diff --git a/ARCHITECTURE.md b/ARCHITECTURE.md
index 2e9fb3d..da5f850 100644
--- a/ARCHITECTURE.md
+++ b/ARCHITECTURE.md
@@ -71,7 +71,7 @@ Block-based editor (Craft/Notion-like) for Compose Multiplatform. Unidirectional
 | Unknown block type | `core/UnknownBlockType.kt` | `UnknownBlockType` (implements `CustomBlockType`) |
 | Document serialization | `serialization/DocumentSchema.kt` | `DocumentSchema` (encode/decode full document) |
 | Rich text serialization | `serialization/RichTextSchema.kt` | `RichTextSchema` |
-| Link URL policy | `richtext/LinkUrlPolicy.kt` | `LinkUrlPolicy`, `LinkValidationResult`, `LinkValidationError` |
+| Link URL policy | `richtext/LinkUrlPolicy.kt` | `LinkUrlPolicy` (`validate` user-entry normalization, `validateStoredTarget` codec/persistence preservation), `LinkValidationResult`, `LinkValidationError` |
 | Link hit tester | `richtext/LinkHitTester.kt` | `LinkHitTester` (internal) |
 | Link state | `richtext/LinkState.kt` | `LinkState`, `LinkTarget` |
 | Link state calculator | `richtext/LinkStateCalculator.kt` | `LinkStateCalculator` (internal) |
@@ -93,11 +93,34 @@ Block-based editor (Craft/Notion-like) for Compose Multiplatform. Unidirectional
 | HTML schema entry point | `htmlserialization/HtmlSchema.kt` | `HtmlSchema` (`decode` and `encode` wired through profile-driven engines) |
 | HTML decode limits | `htmlserialization/HtmlDecodeLimits.kt` | `HtmlDecodeLimits` (input-size bound; `loadFromHtml` / `HtmlSchema.decodeWithReport` `limits` param) |
 | HTML parser internals | `htmlserialization/HtmlParser.kt`, `htmlserialization/HtmlPolicyApplier.kt`, `htmlserialization/HtmlTokenizer.kt`, `htmlserialization/HtmlTreeBuilder.kt`, `htmlserialization/HtmlNode.kt`, `htmlserialization/HtmlToken.kt` | `HtmlParser.parse()` (internal), `HtmlPolicyApplier`, `HtmlNode`, `HtmlToken` |
-| HTML decode engine | `htmlserialization/HtmlDecodeEngine.kt`, `htmlserialization/TagDecodeContextImpl.kt`, `htmlserialization/HtmlNodeViewMapper.kt`, `htmlserialization/DefaultTagDecoders.kt`, `htmlserialization/PreservedHtmlBlockType.kt` | `HtmlDecodeEngine` (internal; normalizes indentation + numbered lists after decode), `TagDecodeContextImpl`, default tag decoders, `PreservedHtmlBlockType`; default list-item decoders honor `class="cascade-indent-N"` as the lossless default-profile list-depth escape hatch, while default `<ul>` / `<ol>` containers delegate to a profile-level custom `<li>` decoder when one is registered |
+| HTML decode engine | `htmlserialization/HtmlDecodeEngine.kt`, `htmlserialization/TagDecodeContextImpl.kt`, `htmlserialization/HtmlNodeViewMapper.kt`, `htmlserialization/DefaultTagDecoders.kt`, `htmlserialization/PreservedHtmlBlockType.kt` | `HtmlDecodeEngine` (internal; normalizes indentation + numbered lists after decode), `HtmlDecodeRunner` (internal shared walker with optional text-leaf reparser hook), `TagDecodeContextImpl`, default tag decoders, `PreservedHtmlBlockType`; default list-item decoders honor `class="cascade-indent-N"` as the lossless default-profile list-depth escape hatch, while default `<ul>` / `<ol>` containers delegate to a profile-level custom `<li>` decoder when one is registered |
+| HTML fragment decoder (Markdown bridge) | `htmlserialization/HtmlFragmentDecoder.kt` | `HtmlFragmentDecoder` (internal `decodeBlockFragment` / `decodeInlineFragment` over an `HtmlProfile`; policy-free parse so root inline content is kept; caller-supplied text-leaf reparser hook), `HtmlBlockFragmentResult`, `HtmlInlineFragmentResult` |
+| Markdown serialization technical context | `docs/MarkdownSerialization.md` | Architecture, decode/encode/analyze data flow, public API, host integration tutorials, constraints, and glossary |
+| Markdown experimental annotation | `markdown/ExperimentalCascadeMarkdownApi.kt` | `ExperimentalCascadeMarkdownApi` (opt-in for all public Markdown codec API) |
+| Markdown source layer | `markdown/MarkdownAstDecoder.kt` (`MarkdownParseInput`), `markdown/MarkdownSourceRange.kt` | One-pass internal projection retains original text, normalizes BOM/CRLF/CR for JetBrains, maps parser boundaries to original UTF-16, slices preserved source, and builds the public `MarkdownSourceLocator`; `MarkdownSourceRange` is the public half-open range |
+| Markdown results/warnings/limits | `markdown/MarkdownResults.kt`, `markdown/MarkdownWarnings.kt`, `markdown/MarkdownCodecLimits.kt` | `MarkdownDecodeResult` / `MarkdownEncodeResult` (explicit `MarkdownCodecStatus`; payload non-null iff `Success`), `MarkdownFidelityImpact`, `MarkdownWarning`, `MarkdownDecodeWarning` / `MarkdownEncodeWarning` (open sealed hierarchies), `MarkdownTextRange`, `MarkdownCodecLimitKind`, `MarkdownCodecLimits` + `Default` |
+| Markdown escaping helpers | `markdown/MarkdownEscaping.kt` | `Markdown.escapeInline(text, context)` / `codeSpanDelimiters` / `escapeLinkDestination` / `escapeLinkText`, `MarkdownEscapeContext`, `MarkdownEscapeTextKind`, `MarkdownCodeSpanDelimiters` (pure, positional, regex-free) |
+| Markdown codec entry point | `markdown/MarkdownSchema.kt` | `MarkdownSchema` (public `encode`/`decode` nullable-payload + `*WithReport` + `analyze`; every path takes `MarkdownCodecLimits`, encode takes `MarkdownLineEnding`; the codec's no-throw boundary — escaped exceptions become an aborted `EngineFailure` result) |
+| Markdown fidelity report | `markdown/MarkdownFidelityReport.kt` | `MarkdownFidelityReport`, `MarkdownEditModeRecommendation` (`Native`/`RawFallback`), `MarkdownFidelityAnalyzer` (internal; source decode + one reused canonical encode + verification decode; impact/model-driven `nativeEditingSafe`, `wouldRewriteSource`) |
+| Markdown editor extensions | `markdown/MarkdownSerializationExt.kt` | `EditorStateHolder.toMarkdown`/`toMarkdownWithReport`/`loadFromMarkdown`/`applyMarkdownDecodeResult` (live-state resolution via `resolveCurrentBlocks`; hard replace only after a non-aborted decode; mode-aware trailing-scaffold trim) |
+| Markdown HTML bridge | `markdown/MarkdownHtmlBridge.kt` | `MarkdownHtmlBridge` (internal; inline paired-tag + block HTML detection, routing through `HtmlFragmentDecoder` with inner text handed back to the Markdown inline parser), `MarkdownHtmlSpanEncoders` (`Underline`→`<u>`, `Highlight`→`<mark data-cascade-highlight>`), `MARKDOWN_PRESERVED_HTML_TYPE_ID` |
+| Markdown profile config | `markdown/MarkdownProfile.kt`, `markdown/MarkdownProfileSupportSet.kt` | `MarkdownProfile` / `.Default` (immutable encoder registrations, policy slots, `withSupportSet`, strict `withoutHtmlBridge()` composite), `MarkdownProfileSupportSet` (public block/span/document narrowing predicates; default and analyze claims are verified by canonical encode→decode model equality, so predicates cannot falsely widen native safety; `.None` placeholder). Decode grammar and emphasis dialect injection are intentionally not public. |
+| Markdown codec contracts | `markdown/MarkdownCodecContracts.kt` | Encoder-only contracts: `MarkdownEmit` (`Raw`/`Verbatim`/`Skip`), `MarkdownMarkPair`, `MarkdownEncodeContext`, `MarkdownBlockEncoder`, `MarkdownSpanEncoder`, and `MarkdownBlockGroupEncoder` |
+| Markdown policies | `markdown/MarkdownPolicies.kt` | `HtmlInMarkdown` (`Bridge(HtmlProfile)` default), `UnsupportedSyntax`, `NewlineSemantics`, `SoftBreak`, `HardBreakEncode`, `EntityDecode` |
+| Markdown parser dependency | `org.jetbrains:markdown:0.7.7` via `gradle/libs.versions.toml`, `markdown/MarkdownAstDecoder.kt` | JetBrains GFM grammar and AST are internal implementation details. `CascadeMarkdownFlavour` removes upstream's broad dollar-math parser; `parseMarkdownTree` is the shared assertion-free entry point. No JetBrains type crosses the public API. |
+| Markdown parse projection + state | `markdown/MarkdownAstDecoder.kt`, `markdown/MarkdownDecodeState.kt` | `MarkdownParseInput` performs the single original-source/projection scan (BOM, CRLF/CR normalization, exact slicing, source locator, original UTF-16 boundary map); `MarkdownParseState` owns bounded warnings, definitions, block/span counts, and fatal abort state |
+| Markdown definition table | `markdown/MarkdownDefinitionTable.kt` | `MarkdownDefinitionTable` (internal; CommonMark label normalization, first-definition-wins) |
+| Markdown AST lowering + decode engine | `markdown/MarkdownAstDecoder.kt`, `markdown/MarkdownDecodeEngine.kt` | Direct JetBrains AST → editor blocks/spans lowering; iterative definition/depth prepass; policy-owned HTML, HardBreak, exact preservation, diagnostics, limits, and narrow tested AST-shape compatibility shims; final `normalizeIndentationOutline` → `renumberNumberedLists`; `MARKDOWN_PRESERVED_TYPE_ID` / `MARKDOWN_PRESERVED_HTML_TYPE_ID` |
+| Markdown encode engine | `markdown/MarkdownEncodeEngine.kt`, `markdown/MarkdownEncodeContextImpl.kt`, `markdown/DefaultMarkdownBlockEncoders.kt`, `markdown/DefaultMarkdownListOutlineEncoder.kt`, `markdown/DefaultMarkdownEncoderFallbacks.kt` | `MarkdownEncodeEngine.encodeWithReport` (internal canonical writer; engine-owned `\n\n` unit separation, `Verbatim` path for preserved source, one final newline, `MarkdownLineEnding` LF/CRLF, output/warning limits), `MarkdownEncodeContextImpl` (physical-line sequences produced by the verified inline renderer), canonical default block encoders + `md.preserved` verbatim encoder, `DefaultMarkdownListOutlineEncoder` (bullets/numbered/todos, marker-relative nesting), warning-emitting block/span fallbacks |
+| Markdown entity adapter | `markdown/MarkdownEntities.kt` | `MarkdownEntities` uses JetBrains' generated replacement code points for the stable named subset while retaining Cascade's supplementary/invalid numeric handling, exact matching, and unknown-name diagnostics; `MarkdownEntityMatch` |
+| Markdown inline AST adapter | `markdown/MarkdownAstDecoder.kt` | `MarkdownAstInlineDecoder` lowers JetBrains inline AST nodes to visible text/spans, handles entities/HTML/policies, performs conservative inline-math recognition, and is reused by encode-side verification |
+| Markdown inline span encoder | `markdown/MarkdownInlineRenderer.kt`, `markdown/DefaultMarkdownSpanEncoders.kt` | `MarkdownInlineRenderer` (internal sweep-line walker over span boundaries with JetBrains-backed reparse verification; InlineCode overlap classification, code-piece close/reopen, italic `_` auto-switch, drop-with-`AmbiguousEmphasis`/`DroppedSpanOverlap` fallback), fixed CommonMark/GFM canonical/alternate marker mappings |
 | HTML encode engine | `htmlserialization/HtmlEncodeEngine.kt`, `htmlserialization/HtmlEncodeContextImpl.kt`, `htmlserialization/DefaultBlockEncoders.kt`, `htmlserialization/DefaultSpanEncoders.kt`, `htmlserialization/DefaultListOutlineEncoder.kt`, `htmlserialization/DefaultEncoderFallbacks.kt` | `HtmlEncodeEngine` (internal), `HtmlEncodeContextImpl`, canonical default block/span encoders, one default `listOutline` encoder for mixed bullet/numbered runs, default block/span encode fallbacks |
 | HTML profile config | `htmlserialization/HtmlProfile.kt` | `HtmlProfile`, `HtmlProfile.Default` (immutable builder-style with default tag decoders, canonical encode mappings, encode fallbacks, and `withSupportSet`) |
 | HTML support set | `htmlserialization/HtmlProfileSupportSet.kt` | `HtmlProfileSupportSet` (public predicate-based support-set constructor; `supportsBlock`/`supportsSpan`/`supportsDocument`; document checks reject stale numbering, invalid indentation outlines, and non-round-trippable content shapes) |
 | Custom reference HTML profile | `sample/src/commonMain/kotlin/io/github/linreal/cascade/profiles/CustomHtmlProfile.kt` | Sample-only `CustomHtmlProfile.Profile` composed from public HTML APIs; flat `ql-indent-N` lists and custom link attributes |
+| Sample Markdown round-trip screen | `sample/src/commonMain/kotlin/io/github/linreal/cascade/screens/markdownfield/MarkdownFieldScreen.kt`, `MarkdownFieldScreenModel.kt` | `MarkdownFieldScreen` is an interactive source → editor → export playground for newline, break, unsupported-syntax, HTML, entity, and line-ending modes with analyze/import/export diagnostics; `MarkdownFieldScreenModel` remains the unit-tested host-contract reference for native/raw gating and revision-safe persistence |
+| Sample Markdown example corpus | `sample/src/commonMain/kotlin/io/github/linreal/cascade/screens/markdownfield/examples/*.md` | Indexed copy/paste fixtures for real-world notes, tasks, bugs, meetings, releases, hard-break logs, support handoffs, PRDs, reference links, HTML, entities, and preservation/raw-fallback cases |
 | HTML codec contracts | `htmlserialization/HtmlCodecContracts.kt` | `HtmlNodeView`, `TagDecoder`, `TagDecodeContext`, `TagDecodeResult`, `InlineFragment`, `BlockEncoder`, `SpanEncoder`, `BlockGroupEncoder`, `HtmlEncodeContext`, `HtmlEmit`, `HtmlTagPair` |
 | HTML parser policies | `htmlserialization/HtmlPolicies.kt` | `BlockSeparator`, `InlineRoot`, `EntityDecode`, `UnknownTagPolicy` |
 | HTML escaping helpers | `htmlserialization/HtmlEscaping.kt` | `Html.escapeText()`, `Html.escapeAttr()` |
@@ -206,9 +229,9 @@ Unless a row uses an explicit module-root path such as `sample/src/...`, paths a
 
 **TextSpan** — `TextSpan(start, end, style)` with half-open `[start, end)` visible coordinates. Validates `start >= 0` and `end >= start`.
 
-**SpanStyle** — sealed interface: `Bold`, `Italic`, `Underline`, `StrikeThrough`, `InlineCode`, `Highlight(colorArgb)`, `Link(url)`, `Custom(typeId, payload?)`. `Link.url` stores only the normalized target URL; the visible link title remains the covered `TextSpan` range. Use `LinkUrlPolicy.validate(...)` before constructing link styles. `SpanStyle.kindKey(Link(url))` keeps URL identity so same-URL links can merge while different URLs remain distinct; URL-agnostic link remove/query behavior is implemented as an operation-matching rule inside `SpanAlgorithms`, not by changing the merge key. `Custom.payload` is opaque `String?` (raw JSON); core layer must not parse it.
+**SpanStyle** — sealed interface: `Bold`, `Italic`, `Underline`, `StrikeThrough`, `InlineCode`, `Highlight(colorArgb)`, `Link(url)`, `Custom(typeId, payload?)`. `Link.url` stores the target exactly as validated; the visible link title remains the covered `TextSpan` range. Use `LinkUrlPolicy.validate(...)` (user-entry normalization) when constructing links from user input and `LinkUrlPolicy.validateStoredTarget(...)` (trim + nonblank, preserve exactly) when decoding persisted/imported targets. `SpanStyle.kindKey(Link(url))` keeps URL identity so same-URL links can merge while different URLs remain distinct; URL-agnostic link remove/query behavior is implemented as an operation-matching rule inside `SpanAlgorithms`, not by changing the merge key. `Custom.payload` is opaque `String?` (raw JSON); core layer must not parse it.
 
-**LinkUrlPolicy** — permissive Slack-style URL normalization for link creation. Anything non-blank is accepted: inputs that already carry a `<scheme>://` prefix are kept verbatim after trimming, everything else is normalized by prepending `https://`. The only `LinkValidationError` is `Blank`. Platform URL opening, link persistence, rendering, mutation actions, and allowlists are separate feature layers.
+**LinkUrlPolicy** — two link URL contracts split by call-site intent. `validate(...)` is user-entry normalization for link creation chrome (toolbar/popup): anything non-blank is accepted, inputs without a `<scheme>://` prefix get `https://` prepended. `validateStoredTarget(...)` is stored-target validation for codec/persistence paths (`RichTextSchema` JSON, HTML `<a href>` decode, Markdown link decode): trim + nonblank only, the target string is otherwise preserved exactly so relative/fragment/`mailto:`/`tel:`/custom-scheme targets round-trip byte-identically. The only `LinkValidationError` in both contracts is `Blank`. Platform URL opening, rendering, mutation actions, and allowlists are separate feature layers.
 
 **Public link API** — custom chrome reads `LocalLinkState` (`State<LinkState>?`) and `LocalLinkActions` (`LinkChromeActions?`) from inside `CascadeEditor`. These locals are provided regardless of `ToolbarSlot.Default`, `ToolbarSlot.Custom`, or `ToolbarSlot.None` so link UI does not require a new custom-toolbar lambda parameter. `LocalLinkState` is backed by lazy derived state over focused editor/text/span inputs. Read-only policy sets `LinkState.canLink` to false while preserving focused-block target and existing-link inspection metadata when available. The link API is split: `LinkActions` is the minimal target-based mutation surface (`applyLink(target, ...)`, `removeLink(target)`) used by popup sessions and any caller that already captured a target; `LinkChromeActions extends LinkActions` adds `currentTarget()` plus `applyLinkAtCurrentTarget(...)` / `removeLinkAtCurrentTarget()` sugar for chrome that reads live `LinkState`. `LocalLinkActions` exposes a gated `LinkChromeActions` facade over `LinkActionDispatcher`: when current `LinkState.canLink` or `EditorInteractionPolicy.canEditLinks` is false, apply still returns URL validation feedback but does not mutate, and remove no-ops. The default toolbar has a special link entry point controlled by `RichTextToolbarConfig.showLink`; editor-owned popup presentation is selected through `CascadeEditor(linkPopup = LinkPopupSlot.Default/Custom/None)`, and `LinkPopupController.open()` also gates on `canEditLinks` before creating a popup session. `LinkPopupSlot.Default` uses the foundation-only default `LinkPopup`, `Custom` receives the editor-managed `LinkPopupState` / `LinkPopupActions`, and `None` suppresses editor-owned popup state/UI. Link opening is configured separately through `CascadeEditor(onOpenLink)`: consumer callbacks receive normalized URLs and may throw, while the default `LocalUriHandler` path swallows platform opening failures.
 
@@ -328,6 +351,7 @@ All state changes go through `EditorAction.reduce(state) → newState`.
 | Serialization — doc foundation types | Done | Enums, options, warnings, codecs, `UnknownBlockType` |
 | Serialization — full document | Done | `DocumentSchema` encode/decode, `EditorStateHolder.toJson()`/`loadFromJson()` extensions |
 | HTML import/export | Done | Profile-driven HTML codec under `htmlserialization/`: hand-written common-only parser, generic decode/encode engines, default HTML5-ish profile (canonical block/span/list-outline encoders, default tag decoders, encode fallbacks), `UnknownTagPolicy` (`Strip`/`WarnAndStrip`/`Preserve`/`Custom`), `HtmlProfileSupportSet` round-trip claim with `SupportSetBlockGenerator`, `EditorStateHolder.toHtml()` / `loadFromHtml()` integration, and sample-only `CustomHtmlProfile.Profile` reference dialect. As-shipped behavior documented in `docs/HtmlImportExportFeatureContext.md`; design history in `docs/HtmlImportExportSpec.md` |
+| Markdown import/export | Done | JetBrains Markdown 0.7.7 owns CommonMark/GFM grammar; Cascade owns BOM/line-ending projection, direct AST→editor lowering, preservation/policies/diagnostics/limits, canonical encoding with JetBrains-backed verification, finalized `MarkdownProfileSupportSet` + 1000-doc CommonMark and 300-doc HardBreak round-trip properties, `analyze` fidelity gate, editor extensions, HTML bridge + strict mode, corpus/differential/fuzz suites, and the interactive sample screen. The unreleased custom decode-syntax/delimiter APIs and their sample-only table/footnote profiles were retired; encoder extension APIs remain. Technical context: `docs/MarkdownSerialization.md` |
 | Undo / Redo | Done | Hybrid linear history is finalized: `BlockTextEntry` handles strict one-block text/span edits, `StructuralEntry` handles semantic or multi-block changes, public `canUndo`/`canRedo`/`undo()`/`redo()` API is live, and Cmd/Ctrl+Z plus Shift+Cmd/Ctrl+Z are implemented |
 | Theming / styling API — data models | Done | `CascadeEditorTheme`, `CascadeEditorColors`, `CascadeEditorTypography`, `LocalCascadeTheme`; light/dark presets |
 | Theming / styling API — color migration | Done | All UI colors read from `LocalCascadeTheme.current.colors` |
@@ -409,7 +433,29 @@ All state changes go through `EditorAction.reduce(state) → newState`.
 | `HtmlSchemaDecodeTest.kt` | Default-profile block decode mappings, inline tag synonyms, nested mixed list flattening, numbered-list post-decode renumbering, and Todo-like HTML non-mapping |
 | `HtmlPerDecoderWhitespaceTest.kt` | Default per-decoder whitespace: paragraph / heading / quote trim+collapse, list-item edge trimming and single trailing newline drop, pre/code whitespace preservation |
 | `HtmlBrAndPreCodeTest.kt` | Default `<br>` handling, root `<br>` warning/drop behavior, `<pre><code>` plain code blocks, inline `<code>` spans |
-| `HtmlLinkAttributesTest.kt` | Default `<a href>` URL normalization, missing/blank href warning/drop behavior, and `<mark>` highlight color decode |
+| `HtmlLinkAttributesTest.kt` | Default `<a href>` stored-target preservation (relative/fragment/mailto/tel/custom-scheme hrefs kept exactly), missing/blank href warning/drop behavior, and `<mark>` highlight color decode |
+| `htmlserialization/HtmlFragmentDecoderTest.kt` | Internal fragment entry points: inline `<u>`/`<em>` span decode, block fragment quote/paragraph decode, root inline runs kept, text-leaf reparser hook plumbing (invocation, span contribution, throw degradation), empty fragments |
+| `markdown/MarkdownSourceTest.kt` | Unified parse projection: BOM + CRLF/CR normalization, original UTF-16 boundary mapping, character-exact slicing, empty/trailing-line and clamped location lookup |
+| `markdown/MarkdownResultsTest.kt` | Results model: Success-with-empty-payload vs Aborted-with-null-payload invariants, Fatal-warning requirement on abort, per-member impact classification, decode range / encode blockId+textRange addressing, decided default limits |
+| `markdown/MarkdownEscapingTest.kt` | Positional escaping: line-start `#`/`>`/`=`/bullets/ordered markers (incl. after embedded newlines), flanking-based `*`/`_`/`~` escaping, intraword underscores, code-span fence widening/padding, link destination angle form, link text, hostile fixture sweep |
+| `markdown/MarkdownProfileTest.kt` | Encoder/policy/support-set defaults and profile immutability |
+| `markdown/MarkdownAstDecoderTest.kt` | JetBrains adapter projection: BOM, CRLF/lone-CR normalization, original UTF-16 warning ranges, and character-exact preserved CRLF slices |
+| `markdown/MarkdownNoThrowGuaranteeTest.kt` | No-throw boundary: hostile inputs plus every decode resource limit aborts without a partial payload |
+| `markdown/MarkdownSchemaTest.kt` | Public `MarkdownSchema`: empty input/document success, canonical decode→encode, input/output-limit abort→null, CRLF output, throwing consumer encoder containment, custom support claims |
+| `markdown/MarkdownSupportSetTest.kt` | Default claim: built-in blocks/spans, empty-text/preserved/stale-numbering/invalid-outline/non-normalized-span/nested-link rejection, Highlight range, §5.12 value exclusions (trailing/leading space, tab), `\r` rejection, HardBreak merge/front-matter/empty-text claim |
+| `markdown/MarkdownRoundTripTest.kt` | 1000 generated in-support documents satisfy `decode(encode(doc)) == doc` modulo BlockIds (seed `0x5CA1AB1E`, self-adapting span palette + hostile-fragment mixing) |
+| `markdown/MarkdownOutOfSupportTest.kt` | Deterministic degraded output + warnings for out-of-set documents (empty paragraph, custom span, preserved pipe table) |
+| `markdown/MarkdownHardBreakTest.kt` | HardBreak mode: literal `\n`, blank-line→empty-paragraph runs, setext/indented-code disabled, trailing-blank round-trip, empty-text claim, 300-doc property round-trip |
+| `markdown/MarkdownAnalyzeTest.kt` | `analyze`: Native/RawFallback, preserved-count, abort→null encode, BOM/CRLF/canonical `wouldRewriteSource`, Strip-policy suppressed DataLoss, custom-support-set branch |
+| `markdown/MarkdownSerializationExtTest.kt` | Editor extensions: live-text export, hard replacement + runtime/ history clearing on success, over-limit untouched, aborted-apply rejection, non-spans span stripping, trailing-scaffold in both modes |
+| `markdown/MarkdownHtmlBridgeTest.kt` | HTML bridge: `<u>`/`<mark>` decode+encode round-trip, inner-warning DataLoss + analyze RawFallback, empty-island preservation, unmatched-flood termination, partial overlap island |
+| `markdown/MarkdownStrictProfileTest.kt` | `withoutHtmlBridge()`: inline HTML stripped with DataLoss, analyze RawFallback, no raw HTML through any emission path (spans/verbatim/preservedHtml/`<script>`), no Underline/Highlight claim |
+| `markdown/MarkdownCorpusTest.kt` + `MarkdownCorpusFixtures.kt` | Data-driven corpus manifest: expected `analyze` recommendation + warning-impact categories per fixture, Native fixtures round-trip |
+| `markdown/MarkdownReferenceCorpusTest.kt` + `MarkdownReferenceProfiles.kt` | StrictGfm/StrictHardBreak reference field profiles, #339 blank-line and #348 numbered-continuation classes, dialect round-trip |
+| `markdown/MarkdownDifferentialTest.kt` | Selected CommonMark 0.30 / GFM examples by number: byte-identical round-trip (Aligned) or documented Deviation, no third state |
+| `markdown/MarkdownFuzzTest.kt` | Random + multi-KB + deep-nesting input across retained reference profiles: terminates, no-throw, bounded warnings/output |
+| `markdown/MarkdownPerformanceBaselineTest.kt` (desktopTest) | 64 KB field regression guard: decode/encode ≤ 250 ms, analyze ≤ 750 ms, adversarial ≤ 1 s (post-simplification local median decode 21 / encode 19 / analyze 47 ms) |
+| `screens/markdownfield/MarkdownFieldScreenModelTest.kt` (sample) | Markdown field host contract: unsupported→raw+0 writes, external-revision→Conflict (edit retained), matching-revision→exact canonical persisted once, no-edit→no write, lossy edit→RejectedLossy+0 writes |
 | `HtmlIndentationEncodingTest.kt` | Decode-side default `cascade-indent-N` class support and post-decode indentation normalization for unsupported block types |
 | `HtmlEncodeContextTest.kt` | Generic encode context helpers: inline escaping, registered span tags, newline policy for non-Code vs Code, text-only/attr/free-fragment helpers |
 | `HtmlBlockGroupEncoderTest.kt` | Generic block group dispatch: profile-order group matching, contiguous run detection, unrelated-block splitting, null-key fallthrough |
diff --git a/THIRD_PARTY_NOTICES/JetBrains-Markdown-Apache-2.0.txt b/THIRD_PARTY_NOTICES/JetBrains-Markdown-Apache-2.0.txt
new file mode 100644
index 0000000..9163bd1
--- /dev/null
+++ b/THIRD_PARTY_NOTICES/JetBrains-Markdown-Apache-2.0.txt
@@ -0,0 +1,206 @@
+JetBrains Markdown
+https://github.com/JetBrains/markdown
+
+Licensed under the Apache License, Version 2.0.
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/docs/MarkdownSerialization.md b/docs/MarkdownSerialization.md
new file mode 100644
index 0000000..f9ca858
--- /dev/null
+++ b/docs/MarkdownSerialization.md
@@ -0,0 +1,328 @@
+# Markdown Serialization
+
+Technical context for the experimental Markdown import/export feature in
+`:editor`. Public APIs live in `io.github.linreal.cascade.editor.markdown` and
+require `ExperimentalCascadeMarkdownApi` opt-in.
+
+## 1. Scope
+
+The Markdown codec converts between a Markdown `String` and CascadeEditor's
+existing block/span model. It also supports direct import/export from
+`EditorStateHolder` and can analyze whether a source is safe for native editing
+or should stay in a raw-text fallback.
+
+The codec targets bounded task, memo, and note fields. It is a canonical
+whole-document codec, not a byte-preserving or minimal-diff file editor.
+
+The default GFM-oriented behavior includes:
+
+- paragraphs, ATX/setext headings, thematic breaks, fenced/indented code;
+- blockquotes, bullet/ordered/task lists;
+- emphasis, strong emphasis, strikethrough, inline code;
+- inline/reference links, autolinks, entities, soft/hard breaks;
+- policy-driven HTML bridging;
+- opaque preservation or warning-based degradation for front matter, math,
+  footnotes, tables, images, metadata, and unrepresentable containers.
+
+## 2. Parser dependency decision
+
+Decode grammar recognition is delegated to `org.jetbrains:markdown:0.7.7`.
+Cascade uses its GFM AST internally; JetBrains types do not cross the public
+API. The dependency is Apache-2.0 licensed and publishes the KMP variants used
+by this project.
+
+This boundary replaces the former hand-written block parser, inline parser,
+delimiter stack, source-backed parser node tree, recognizer registry, and
+public decode-syntax extension contracts.
+
+### Ownership boundary
+
+| Concern | Owner |
+|---|---|
+| CommonMark/GFM tokenization, block structure, inline precedence, emphasis matching | JetBrains Markdown |
+| BOM and CRLF/CR normalization with original UTF-16 range mapping | Cascade |
+| AST-to-`Block`/`TextSpan` mapping | Cascade |
+| HardBreak mode and editor outline normalization | Cascade |
+| Unsupported-syntax preserve/degrade behavior | Cascade |
+| HTML bridge and sanitization boundary | Cascade |
+| Fidelity warnings, source ranges, resource limits, no-partial-result rules | Cascade |
+| Canonical encoding and encoder extensions | Cascade |
+| Executable profile support claims and analyze/native-edit gate | Cascade |
+
+
+## 3. Decode architecture
+
+`MarkdownDecodeEngine` runs this pipeline:
+
+1. Reject an input over `MarkdownCodecLimits.maxInputChars`.
+2. Preflight the bounded emphasis-delimiter-run limit.
+3. `MarkdownParseInput` performs one source scan: it retains the original text,
+   removes a leading BOM from the parser projection, normalizes CRLF/lone CR to
+   LF, builds the original-offset boundary map, and indexes source locations.
+4. `parseMarkdownTree` invokes an assertion-free `MarkdownParser` with
+   `CascadeMarkdownFlavour`.
+5. An iterative definition/depth prepass collects link-reference definitions,
+   applies first-definition-wins, and enforces nesting/definition limits.
+6. `MarkdownAstDecoder` lowers the AST directly to editor blocks. Inline AST
+   children lower to visible text plus normalized `TextSpan`s.
+7. Unsupported syntax either warns and degrades or escalates its owning root
+   block to an exact `md.preserved`/`md.preservedHtml` slice.
+8. `normalizeIndentationOutline` then `renumberNumberedLists` establish editor
+   invariants.
+9. A successful result contains the complete block list. Any fatal limit or
+   engine failure returns an aborted result with no partial payload.
+
+`CascadeMarkdownFlavour` starts from GFM but omits JetBrains' dollar-math
+sequential parser. That parser recognizes currency, spaced delimiters, and
+other sources outside Cascade's documented math subset. Cascade performs a
+small conservative math recognition pass while code spans and images remain
+opaque.
+
+The adapter contains two narrow JetBrains 0.7.7 compatibility shims covered by
+tests:
+
+- angle-form link destinations can arrive as an `AUTOLINK` child rather than
+  `LINK_DESTINATION`;
+- an outer-link AST around `[a [b](u2)](u1)` is corrected to CommonMark's
+  inner-link-wins result.
+
+These are local AST-shape adapters, not a competing Markdown parser.
+
+### Source preservation
+
+`MarkdownParseInput` owns both views required by decode: the unchanged original
+string used for exact slices and locations, and the normalized parser
+projection with its normalized-boundary-to-original-boundary map. CRLF, lone
+CR, Unicode, and original spelling therefore survive opaque preservation
+character-exactly without a second source scan.
+
+Named entity replacement code points come from JetBrains Markdown's generated
+table. Cascade retains the documented v1 name subset, exact unknown-name
+diagnostics, and its own numeric-code-point handling because JetBrains 0.7.7's
+converter narrows numeric values through a single UTF-16 `Char`.
+
+## 4. Encode architecture
+
+Encoding remains Cascade-owned:
+
+1. Resolve live editor text/spans over the stored snapshot.
+2. Dispatch a registered block-group encoder, block encoder, or fallback.
+3. `MarkdownInlineRenderer` normalizes spans, performs a sweep-line render,
+   escapes visible text, and chooses canonical markers.
+4. Reparse the candidate through the same JetBrains-backed inline adapter.
+5. If decoded text/spans differ, drop the weakest unrepresentable residue and
+   emit a data-loss warning instead of claiming a false round trip.
+6. Join units with CommonMark or HardBreak separators, add the canonical final
+   newline, apply LF/CRLF output policy, and enforce output/warning limits.
+
+The supported encoder contracts are:
+
+- `MarkdownBlockEncoder<T>`;
+- `MarkdownSpanEncoder<T>`;
+- `MarkdownBlockGroupEncoder`;
+- `MarkdownEncodeContext`;
+- `MarkdownEmit.Raw`, `Verbatim`, and `Skip`;
+- `MarkdownMarkPair`.
+
+Custom encoders register by built-in class or custom `typeId`. Registration
+never widens `MarkdownProfileSupportSet`; a profile that adds encoders must
+install an explicit executable support claim.
+
+## 5. Profiles and policies
+
+`MarkdownProfile` is immutable and safe to reuse. It configures encoding,
+policies, and support claims—not decode grammar.
+
+The default document claim is executable: it encodes and decodes the candidate
+and compares block type, content, attributes, and spans while ignoring generated
+block IDs. During `analyze`, the existing canonical encode is reused and only
+the verification decode is added. Custom support predicates remain public
+narrowing hooks, but cannot widen native-edit safety past a failed round trip.
+
+Public composition includes:
+
+- `withMarkdownBlockEncoder<T>`;
+- `withMarkdownSpanEncoder<T>`;
+- `withCustomMarkdownBlockEncoder`;
+- `withCustomMarkdownSpanEncoder`;
+- `withMarkdownBlockGroupEncoder` / `withoutMarkdownBlockGroupEncoder`;
+- block/span encoder fallbacks;
+- `withHtmlInMarkdown`, `withoutHtmlBridge`;
+- `withUnsupportedSyntax`;
+- `withNewlineSemantics`, `withSoftBreak`, `withHardBreakEncode`;
+- `withEntityDecode`;
+- `withSupportSet` and `supportSet`.
+
+| Policy | Options |
+|---|---|
+| `HtmlInMarkdown` | `Bridge(HtmlProfile)`, `Preserve`, `WarnAndStrip`, `Strip` |
+| `UnsupportedSyntax` | `Preserve`, `WarnAndDegrade` |
+| `NewlineSemantics` | `CommonMark`, `HardBreak` |
+| `SoftBreak` | `Space`, `LineBreak` |
+| `HardBreakEncode` | `Backslash`, `TwoSpaces` |
+| `EntityDecode` | `Standard`, `None` |
+
+Bold, italic, and strikethrough use the fixed CommonMark/GFM marker dialect:
+canonical `**`, `*`, `~~`, with `__` and `_` available internally when encode
+verification needs a non-conflicting alternate.
+
+### Unsupported syntax
+
+`UnsupportedSyntax.Preserve` creates an `UnknownBlockType`:
+
+- `md.preserved` with `kind` and `rawMarkdown`;
+- `md.preservedHtml` for opaque block HTML.
+
+Preservation is safe for storage and re-emission but not natively editable, so
+its fidelity impact is `OpaquePreservation`.
+
+`WarnAndDegrade` keeps representable visible content and reports `DataLoss` for
+structure or metadata that cannot be represented.
+
+### HTML
+
+The default `HtmlInMarkdown.Bridge(HtmlProfile.Default)` routes HTML fragments
+through the existing HTML codec. Text leaves inside HTML are reparsed as
+Markdown, so `<u>**bold**</u>` retains both styles. Underline and Highlight
+encode through `<u>` and `<mark>` while the bridge is active.
+
+`withoutHtmlBridge()` strips HTML on decode, removes HTML-emitting span
+encoders and HTML preservation paths, and installs a strict support set.
+
+This codec is not an HTML sanitizer. Hosts must sanitize at their render or
+trust boundary.
+
+## 6. Public API
+
+### Entry points
+
+| API | Result |
+|---|---|
+| `MarkdownSchema.decode` | `List<Block>?`; null only on abort |
+| `MarkdownSchema.decodeWithReport` | status, nullable blocks, warnings, source locator |
+| `MarkdownSchema.encode` | `String?`; null only on abort |
+| `MarkdownSchema.encodeWithReport` | status, nullable Markdown, warnings |
+| `MarkdownSchema.analyze` | `MarkdownFidelityReport` with Native/RawFallback recommendation |
+
+Successful empty input/output stays non-null. Callers must use status/null to
+distinguish an abort from an empty document.
+
+### Editor integration
+
+| Extension | Behavior |
+|---|---|
+| `EditorStateHolder.toMarkdown(...)` | resolve live state and encode |
+| `toMarkdownWithReport(...)` | same, retaining diagnostics |
+| `loadFromMarkdown(...)` | decode and hard-replace only on success |
+| `applyMarkdownDecodeResult(...)` | apply a precomputed successful result on the UI thread |
+
+An aborted import leaves the editor untouched. A successful import resets
+focus, selection, transient runtime state, and undo/redo history like other
+whole-document load paths.
+
+### Limits
+
+| Default limit | Value |
+|---|---:|
+| Input UTF-16 code units | 4,000,000 |
+| Output UTF-16 code units | 16,000,000 |
+| Block nesting depth | 32 |
+| Produced blocks | 50,000 |
+| Spans per block | 1,000 |
+| Total spans | 50,000 |
+| Reference definitions | 5,000 |
+| Delimiter runs | 10,000 |
+| Collected warnings | 1,000 |
+
+Limit exhaustion is fatal and returns no partial payload.
+
+### Diagnostics
+
+Every warning has a `MarkdownFidelityImpact`:
+
+- `Informational`;
+- `Canonicalization`;
+- `OpaquePreservation`;
+- `DataLoss`;
+- `Fatal`.
+
+Decode warnings use half-open original-source UTF-16 ranges. Encode warnings
+use a block id and/or visible-text range. Consumers should gate by `impact` and
+include an `else` when matching concrete warning subclasses.
+
+## 7. Host save contract
+
+For externally authored Markdown:
+
+1. Keep the original source and persistence revision.
+2. Analyze without writing.
+3. Use native editing only when the recommendation is `Native`; otherwise show
+   a raw-text editor.
+4. On explicit save, encode with a report.
+5. Persist only a successful payload with no `DataLoss`/`Fatal` impact and an
+   unchanged source revision.
+
+```kotlin
+val report = MarkdownSchema.analyze(source, profile)
+if (report.recommendation == MarkdownEditModeRecommendation.Native) {
+    val decoded = report.decodeResult
+    editor.applyMarkdownDecodeResult(decoded, textStates, spanStates)
+} else {
+    openRawEditor(source)
+}
+```
+
+Use the same profile for analyze, decode, editing, and encode. A profile is part
+of the storage contract; it must not change mid-session.
+
+For app-owned fields that only store this codec's canonical output, direct
+decode is reasonable, though report-based saving remains useful for defensive
+checks and telemetry.
+
+## 8. Testing and performance
+
+The retained test strategy validates Cascade-owned behavior rather than
+retesting the dependency's complete grammar implementation:
+
+- focused projection tests for BOM/CRLF/CR mapping, source locations, and exact preservation;
+- decode/lowering tests for product block/span semantics and warnings;
+- 1,000 generated in-support CommonMark round trips;
+- 300 generated HardBreak round trips;
+- selected CommonMark/GFM differential fixtures;
+- HTML bridge, strict profile, fidelity, editor integration, and preservation;
+- hostile/fuzz inputs and every resource limit;
+- encode escaping and reparse verification;
+- desktop 64 KiB performance guards.
+
+The post-simplification local desktop guard reports 21 ms decode, 19 ms encode,
+and 47 ms analyze for the generated 64 KiB fixture. Values are
+machine-dependent; enforced thresholds remain 250/250/750 ms. Decode is still
+synchronous, so hosts should run large decode/analyze operations off the UI
+thread.
+
+
+## 9. Extending behavior
+
+Encoder customization remains supported. Arbitrary decode-grammar injection is
+not. For a new Markdown construct:
+
+1. Prefer opaque preservation if native editing is not required.
+2. If it is a broadly useful editor feature, add an internal AST adapter with a
+   native block/span model, warnings, limits, source mapping, and tests.
+3. If upstream grammar support is required, evaluate a narrowly scoped internal
+   flavour extension; do not expose upstream AST types publicly.
+4. Update the executable support set only after round-trip behavior is proven.
+
+The removed sample table/footnote profiles existed only to prove the retired
+decode-extension API and were not wired into the application. Default table and
+footnote preservation behavior remains covered.
+
+## 10. Build and licensing
+
+The dependency is declared in `gradle/libs.versions.toml` and consumed from the
+editor `commonMain` source set. Version changes must run desktop, Android/KMP
+compilation, API validation, round-trip, differential, fuzz, and performance
+tests because AST shapes are an internal integration contract.
+
+JetBrains Markdown is Apache License 2.0. Its license and notices must be
+included by downstream packaging as required by the consuming platform.
diff --git a/editor/api/android/editor.api b/editor/api/android/editor.api
index afbb082..0a5da4e 100644
--- a/editor/api/android/editor.api
+++ b/editor/api/android/editor.api
@@ -1567,6 +1567,874 @@ public final class io/github/linreal/cascade/editor/indentation/IndentationState
 	public final fun getEmpty ()Lio/github/linreal/cascade/editor/indentation/IndentationState;
 }
 
+public abstract interface class io/github/linreal/cascade/editor/markdown/EntityDecode {
+}
+
+public final class io/github/linreal/cascade/editor/markdown/EntityDecode$None : io/github/linreal/cascade/editor/markdown/EntityDecode {
+	public static final field $stable I
+	public static final field INSTANCE Lio/github/linreal/cascade/editor/markdown/EntityDecode$None;
+	public fun equals (Ljava/lang/Object;)Z
+	public fun hashCode ()I
+	public fun toString ()Ljava/lang/String;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/EntityDecode$Standard : io/github/linreal/cascade/editor/markdown/EntityDecode {
+	public static final field $stable I
+	public static final field INSTANCE Lio/github/linreal/cascade/editor/markdown/EntityDecode$Standard;
+	public fun equals (Ljava/lang/Object;)Z
+	public fun hashCode ()I
+	public fun toString ()Ljava/lang/String;
+}
+
+public abstract interface annotation class io/github/linreal/cascade/editor/markdown/ExperimentalCascadeMarkdownApi : java/lang/annotation/Annotation {
+}
+
+public abstract interface class io/github/linreal/cascade/editor/markdown/HardBreakEncode {
+}
+
+public final class io/github/linreal/cascade/editor/markdown/HardBreakEncode$Backslash : io/github/linreal/cascade/editor/markdown/HardBreakEncode {
+	public static final field $stable I
+	public static final field INSTANCE Lio/github/linreal/cascade/editor/markdown/HardBreakEncode$Backslash;
+	public fun equals (Ljava/lang/Object;)Z
+	public fun hashCode ()I
+	public fun toString ()Ljava/lang/String;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/HardBreakEncode$TwoSpaces : io/github/linreal/cascade/editor/markdown/HardBreakEncode {
+	public static final field $stable I
+	public static final field INSTANCE Lio/github/linreal/cascade/editor/markdown/HardBreakEncode$TwoSpaces;
+	public fun equals (Ljava/lang/Object;)Z
+	public fun hashCode ()I
+	public fun toString ()Ljava/lang/String;
+}
+
+public abstract interface class io/github/linreal/cascade/editor/markdown/HtmlInMarkdown {
+}
+
+public final class io/github/linreal/cascade/editor/markdown/HtmlInMarkdown$Bridge : io/github/linreal/cascade/editor/markdown/HtmlInMarkdown {
+	public static final field $stable I
+	public fun <init> (Lio/github/linreal/cascade/editor/htmlserialization/HtmlProfile;)V
+	public final fun component1 ()Lio/github/linreal/cascade/editor/htmlserialization/HtmlProfile;
+	public final fun copy (Lio/github/linreal/cascade/editor/htmlserialization/HtmlProfile;)Lio/github/linreal/cascade/editor/markdown/HtmlInMarkdown$Bridge;
+	public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/markdown/HtmlInMarkdown$Bridge;Lio/github/linreal/cascade/editor/htmlserialization/HtmlProfile;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/markdown/HtmlInMarkdown$Bridge;
+	public fun equals (Ljava/lang/Object;)Z
+	public final fun getHtmlProfile ()Lio/github/linreal/cascade/editor/htmlserialization/HtmlProfile;
+	public fun hashCode ()I
+	public fun toString ()Ljava/lang/String;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/HtmlInMarkdown$Preserve : io/github/linreal/cascade/editor/markdown/HtmlInMarkdown {
+	public static final field $stable I
+	public static final field INSTANCE Lio/github/linreal/cascade/editor/markdown/HtmlInMarkdown$Preserve;
+	public fun equals (Ljava/lang/Object;)Z
+	public fun hashCode ()I
+	public fun toString ()Ljava/lang/String;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/HtmlInMarkdown$Strip : io/github/linreal/cascade/editor/markdown/HtmlInMarkdown {
+	public static final field $stable I
+	public static final field INSTANCE Lio/github/linreal/cascade/editor/markdown/HtmlInMarkdown$Strip;
+	public fun equals (Ljava/lang/Object;)Z
+	public fun hashCode ()I
+	public fun toString ()Ljava/lang/String;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/HtmlInMarkdown$WarnAndStrip : io/github/linreal/cascade/editor/markdown/HtmlInMarkdown {
+	public static final field $stable I
+	public static final field INSTANCE Lio/github/linreal/cascade/editor/markdown/HtmlInMarkdown$WarnAndStrip;
+	public fun equals (Ljava/lang/Object;)Z
+	public fun hashCode ()I
+	public fun toString ()Ljava/lang/String;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/Markdown {
+	public static final field $stable I
+	public static final field INSTANCE Lio/github/linreal/cascade/editor/markdown/Markdown;
+	public final fun codeSpanDelimiters (Ljava/lang/String;)Lio/github/linreal/cascade/editor/markdown/MarkdownCodeSpanDelimiters;
+	public final fun escapeInline (Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownEscapeContext;)Ljava/lang/String;
+	public final fun escapeLinkDestination (Ljava/lang/String;)Ljava/lang/String;
+	public final fun escapeLinkText (Ljava/lang/String;)Ljava/lang/String;
+}
+
+public abstract interface class io/github/linreal/cascade/editor/markdown/MarkdownBlockEncoder {
+	public abstract fun encode (Lio/github/linreal/cascade/editor/markdown/MarkdownEncodeContext;Lio/github/linreal/cascade/editor/core/Block;Lio/github/linreal/cascade/editor/core/BlockContent;)Lio/github/linreal/cascade/editor/markdown/MarkdownEmit;
+}
+
+public abstract interface class io/github/linreal/cascade/editor/markdown/MarkdownBlockGroupEncoder {
+	public abstract fun encodeGroup (Lio/github/linreal/cascade/editor/markdown/MarkdownEncodeContext;Ljava/util/List;)Lio/github/linreal/cascade/editor/markdown/MarkdownEmit;
+	public abstract fun groupKey (Lio/github/linreal/cascade/editor/core/Block;)Ljava/lang/Object;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/MarkdownCodeSpanDelimiters {
+	public static final field $stable I
+	public fun <init> (Ljava/lang/String;ZZ)V
+	public synthetic fun <init> (Ljava/lang/String;ZZILkotlin/jvm/internal/DefaultConstructorMarker;)V
+	public final fun component1 ()Ljava/lang/String;
+	public final fun component2 ()Z
+	public final fun component3 ()Z
+	public final fun copy (Ljava/lang/String;ZZ)Lio/github/linreal/cascade/editor/markdown/MarkdownCodeSpanDelimiters;
+	public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/markdown/MarkdownCodeSpanDelimiters;Ljava/lang/String;ZZILjava/lang/Object;)Lio/github/linreal/cascade/editor/markdown/MarkdownCodeSpanDelimiters;
+	public fun equals (Ljava/lang/Object;)Z
+	public final fun getClose ()Ljava/lang/String;
+	public final fun getFence ()Ljava/lang/String;
+	public final fun getOpen ()Ljava/lang/String;
+	public final fun getPadded ()Z
+	public final fun getRequiresFallback ()Z
+	public fun hashCode ()I
+	public fun toString ()Ljava/lang/String;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/MarkdownCodecLimitKind : java/lang/Enum {
+	public static final field BlockNesting Lio/github/linreal/cascade/editor/markdown/MarkdownCodecLimitKind;
+	public static final field Blocks Lio/github/linreal/cascade/editor/markdown/MarkdownCodecLimitKind;
+	public static final field DelimiterRuns Lio/github/linreal/cascade/editor/markdown/MarkdownCodecLimitKind;
+	public static final field ReferenceDefinitions Lio/github/linreal/cascade/editor/markdown/MarkdownCodecLimitKind;
+	public static final field SpansPerBlock Lio/github/linreal/cascade/editor/markdown/MarkdownCodecLimitKind;
+	public static final field TotalSpans Lio/github/linreal/cascade/editor/markdown/MarkdownCodecLimitKind;
+	public static final field Warnings Lio/github/linreal/cascade/editor/markdown/MarkdownCodecLimitKind;
+	public static fun getEntries ()Lkotlin/enums/EnumEntries;
+	public static fun valueOf (Ljava/lang/String;)Lio/github/linreal/cascade/editor/markdown/MarkdownCodecLimitKind;
+	public static fun values ()[Lio/github/linreal/cascade/editor/markdown/MarkdownCodecLimitKind;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/MarkdownCodecLimits {
+	public static final field $stable I
+	public static final field Companion Lio/github/linreal/cascade/editor/markdown/MarkdownCodecLimits$Companion;
+	public static final field DEFAULT_MAX_BLOCKS I
+	public static final field DEFAULT_MAX_BLOCK_NESTING I
+	public static final field DEFAULT_MAX_DELIMITER_RUNS I
+	public static final field DEFAULT_MAX_INPUT_CHARS I
+	public static final field DEFAULT_MAX_OUTPUT_CHARS I
+	public static final field DEFAULT_MAX_REFERENCE_DEFINITIONS I
+	public static final field DEFAULT_MAX_SPANS_PER_BLOCK I
+	public static final field DEFAULT_MAX_TOTAL_SPANS I
+	public static final field DEFAULT_MAX_WARNINGS I
+	public fun <init> ()V
+	public fun <init> (IIIIIIIII)V
+	public synthetic fun <init> (IIIIIIIIIILkotlin/jvm/internal/DefaultConstructorMarker;)V
+	public final fun component1 ()I
+	public final fun component2 ()I
+	public final fun component3 ()I
+	public final fun component4 ()I
+	public final fun component5 ()I
+	public final fun component6 ()I
+	public final fun component7 ()I
+	public final fun component8 ()I
+	public final fun component9 ()I
+	public final fun copy (IIIIIIIII)Lio/github/linreal/cascade/editor/markdown/MarkdownCodecLimits;
+	public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/markdown/MarkdownCodecLimits;IIIIIIIIIILjava/lang/Object;)Lio/github/linreal/cascade/editor/markdown/MarkdownCodecLimits;
+	public fun equals (Ljava/lang/Object;)Z
+	public final fun getMaxBlockNesting ()I
+	public final fun getMaxBlocks ()I
+	public final fun getMaxDelimiterRuns ()I
+	public final fun getMaxInputChars ()I
+	public final fun getMaxOutputChars ()I
+	public final fun getMaxReferenceDefinitions ()I
+	public final fun getMaxSpansPerBlock ()I
+	public final fun getMaxTotalSpans ()I
+	public final fun getMaxWarnings ()I
+	public fun hashCode ()I
+	public fun toString ()Ljava/lang/String;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/MarkdownCodecLimits$Companion {
+	public final fun getDefault ()Lio/github/linreal/cascade/editor/markdown/MarkdownCodecLimits;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/MarkdownCodecStatus : java/lang/Enum {
+	public static final field Aborted Lio/github/linreal/cascade/editor/markdown/MarkdownCodecStatus;
+	public static final field Success Lio/github/linreal/cascade/editor/markdown/MarkdownCodecStatus;
+	public static fun getEntries ()Lkotlin/enums/EnumEntries;
+	public static fun valueOf (Ljava/lang/String;)Lio/github/linreal/cascade/editor/markdown/MarkdownCodecStatus;
+	public static fun values ()[Lio/github/linreal/cascade/editor/markdown/MarkdownCodecStatus;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/MarkdownDecodeResult {
+	public static final field $stable I
+	public static final field Companion Lio/github/linreal/cascade/editor/markdown/MarkdownDecodeResult$Companion;
+	public synthetic fun <init> (Lio/github/linreal/cascade/editor/markdown/MarkdownCodecStatus;Ljava/util/List;Ljava/util/List;Lio/github/linreal/cascade/editor/markdown/MarkdownSourceLocator;Lkotlin/jvm/internal/DefaultConstructorMarker;)V
+	public final fun getBlocks ()Ljava/util/List;
+	public final fun getSourceLocator ()Lio/github/linreal/cascade/editor/markdown/MarkdownSourceLocator;
+	public final fun getStatus ()Lio/github/linreal/cascade/editor/markdown/MarkdownCodecStatus;
+	public final fun getWarnings ()Ljava/util/List;
+	public final fun isAborted ()Z
+	public final fun isSuccess ()Z
+	public fun toString ()Ljava/lang/String;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/MarkdownDecodeResult$Companion {
+	public final fun aborted (Ljava/util/List;Lio/github/linreal/cascade/editor/markdown/MarkdownSourceLocator;)Lio/github/linreal/cascade/editor/markdown/MarkdownDecodeResult;
+	public static synthetic fun aborted$default (Lio/github/linreal/cascade/editor/markdown/MarkdownDecodeResult$Companion;Ljava/util/List;Lio/github/linreal/cascade/editor/markdown/MarkdownSourceLocator;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/markdown/MarkdownDecodeResult;
+	public final fun success (Ljava/util/List;Ljava/util/List;Lio/github/linreal/cascade/editor/markdown/MarkdownSourceLocator;)Lio/github/linreal/cascade/editor/markdown/MarkdownDecodeResult;
+	public static synthetic fun success$default (Lio/github/linreal/cascade/editor/markdown/MarkdownDecodeResult$Companion;Ljava/util/List;Ljava/util/List;Lio/github/linreal/cascade/editor/markdown/MarkdownSourceLocator;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/markdown/MarkdownDecodeResult;
+}
+
+public abstract class io/github/linreal/cascade/editor/markdown/MarkdownDecodeWarning : io/github/linreal/cascade/editor/markdown/MarkdownWarning {
+	public static final field $stable I
+	public abstract fun getRange ()Lio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/MarkdownDecodeWarning$DroppedAttribute : io/github/linreal/cascade/editor/markdown/MarkdownDecodeWarning {
+	public static final field $stable I
+	public fun <init> (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;)V
+	public final fun component1 ()Ljava/lang/String;
+	public final fun component2 ()Ljava/lang/String;
+	public final fun component3 ()Ljava/lang/String;
+	public final fun component4 ()Lio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;
+	public final fun copy (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;)Lio/github/linreal/cascade/editor/markdown/MarkdownDecodeWarning$DroppedAttribute;
+	public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/markdown/MarkdownDecodeWarning$DroppedAttribute;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/markdown/MarkdownDecodeWarning$DroppedAttribute;
+	public fun equals (Ljava/lang/Object;)Z
+	public final fun getAttr ()Ljava/lang/String;
+	public final fun getConstruct ()Ljava/lang/String;
+	public fun getImpact ()Lio/github/linreal/cascade/editor/markdown/MarkdownFidelityImpact;
+	public fun getRange ()Lio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;
+	public final fun getReason ()Ljava/lang/String;
+	public fun hashCode ()I
+	public fun toString ()Ljava/lang/String;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/MarkdownDecodeWarning$DuplicateLinkDefinition : io/github/linreal/cascade/editor/markdown/MarkdownDecodeWarning {
+	public static final field $stable I
+	public fun <init> (Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;)V
+	public final fun component1 ()Ljava/lang/String;
+	public final fun component2 ()Lio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;
+	public final fun copy (Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;)Lio/github/linreal/cascade/editor/markdown/MarkdownDecodeWarning$DuplicateLinkDefinition;
+	public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/markdown/MarkdownDecodeWarning$DuplicateLinkDefinition;Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/markdown/MarkdownDecodeWarning$DuplicateLinkDefinition;
+	public fun equals (Ljava/lang/Object;)Z
+	public fun getImpact ()Lio/github/linreal/cascade/editor/markdown/MarkdownFidelityImpact;
+	public final fun getLabel ()Ljava/lang/String;
+	public fun getRange ()Lio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;
+	public fun hashCode ()I
+	public fun toString ()Ljava/lang/String;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/MarkdownDecodeWarning$EngineFailure : io/github/linreal/cascade/editor/markdown/MarkdownDecodeWarning {
+	public static final field $stable I
+	public fun <init> (Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;)V
+	public synthetic fun <init> (Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;ILkotlin/jvm/internal/DefaultConstructorMarker;)V
+	public final fun component1 ()Ljava/lang/String;
+	public final fun component2 ()Lio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;
+	public final fun copy (Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;)Lio/github/linreal/cascade/editor/markdown/MarkdownDecodeWarning$EngineFailure;
+	public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/markdown/MarkdownDecodeWarning$EngineFailure;Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/markdown/MarkdownDecodeWarning$EngineFailure;
+	public fun equals (Ljava/lang/Object;)Z
+	public fun getImpact ()Lio/github/linreal/cascade/editor/markdown/MarkdownFidelityImpact;
+	public final fun getMessage ()Ljava/lang/String;
+	public fun getRange ()Lio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;
+	public fun hashCode ()I
+	public fun toString ()Ljava/lang/String;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/MarkdownDecodeWarning$HtmlBridged : io/github/linreal/cascade/editor/markdown/MarkdownDecodeWarning {
+	public static final field $stable I
+	public fun <init> (Lio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;)V
+	public final fun component1 ()Lio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;
+	public final fun copy (Lio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;)Lio/github/linreal/cascade/editor/markdown/MarkdownDecodeWarning$HtmlBridged;
+	public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/markdown/MarkdownDecodeWarning$HtmlBridged;Lio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/markdown/MarkdownDecodeWarning$HtmlBridged;
+	public fun equals (Ljava/lang/Object;)Z
+	public fun getImpact ()Lio/github/linreal/cascade/editor/markdown/MarkdownFidelityImpact;
+	public fun getRange ()Lio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;
+	public fun hashCode ()I
+	public fun toString ()Ljava/lang/String;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/MarkdownDecodeWarning$HtmlStripped : io/github/linreal/cascade/editor/markdown/MarkdownDecodeWarning {
+	public static final field $stable I
+	public fun <init> (Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;)V
+	public final fun component1 ()Ljava/lang/String;
+	public final fun component2 ()Lio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;
+	public final fun copy (Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;)Lio/github/linreal/cascade/editor/markdown/MarkdownDecodeWarning$HtmlStripped;
+	public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/markdown/MarkdownDecodeWarning$HtmlStripped;Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/markdown/MarkdownDecodeWarning$HtmlStripped;
+	public fun equals (Ljava/lang/Object;)Z
+	public fun getImpact ()Lio/github/linreal/cascade/editor/markdown/MarkdownFidelityImpact;
+	public fun getRange ()Lio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;
+	public final fun getTag ()Ljava/lang/String;
+	public fun hashCode ()I
+	public fun toString ()Ljava/lang/String;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/MarkdownDecodeWarning$InputLimitExceeded : io/github/linreal/cascade/editor/markdown/MarkdownDecodeWarning {
+	public static final field $stable I
+	public fun <init> (IILio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;)V
+	public synthetic fun <init> (IILio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;ILkotlin/jvm/internal/DefaultConstructorMarker;)V
+	public final fun component1 ()I
+	public final fun component2 ()I
+	public final fun component3 ()Lio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;
+	public final fun copy (IILio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;)Lio/github/linreal/cascade/editor/markdown/MarkdownDecodeWarning$InputLimitExceeded;
+	public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/markdown/MarkdownDecodeWarning$InputLimitExceeded;IILio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/markdown/MarkdownDecodeWarning$InputLimitExceeded;
+	public fun equals (Ljava/lang/Object;)Z
+	public final fun getActual ()I
+	public fun getImpact ()Lio/github/linreal/cascade/editor/markdown/MarkdownFidelityImpact;
+	public final fun getLimit ()I
+	public fun getRange ()Lio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;
+	public fun hashCode ()I
+	public fun toString ()Ljava/lang/String;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/MarkdownDecodeWarning$LimitExceeded : io/github/linreal/cascade/editor/markdown/MarkdownDecodeWarning {
+	public static final field $stable I
+	public fun <init> (Lio/github/linreal/cascade/editor/markdown/MarkdownCodecLimitKind;ILio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;)V
+	public final fun component1 ()Lio/github/linreal/cascade/editor/markdown/MarkdownCodecLimitKind;
+	public final fun component2 ()I
+	public final fun component3 ()Lio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;
+	public final fun copy (Lio/github/linreal/cascade/editor/markdown/MarkdownCodecLimitKind;ILio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;)Lio/github/linreal/cascade/editor/markdown/MarkdownDecodeWarning$LimitExceeded;
+	public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/markdown/MarkdownDecodeWarning$LimitExceeded;Lio/github/linreal/cascade/editor/markdown/MarkdownCodecLimitKind;ILio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/markdown/MarkdownDecodeWarning$LimitExceeded;
+	public fun equals (Ljava/lang/Object;)Z
+	public fun getImpact ()Lio/github/linreal/cascade/editor/markdown/MarkdownFidelityImpact;
+	public final fun getKind ()Lio/github/linreal/cascade/editor/markdown/MarkdownCodecLimitKind;
+	public final fun getLimit ()I
+	public fun getRange ()Lio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;
+	public fun hashCode ()I
+	public fun toString ()Ljava/lang/String;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/MarkdownDecodeWarning$PreservedSyntax : io/github/linreal/cascade/editor/markdown/MarkdownDecodeWarning {
+	public static final field $stable I
+	public fun <init> (Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;)V
+	public final fun component1 ()Ljava/lang/String;
+	public final fun component2 ()Lio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;
+	public final fun copy (Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;)Lio/github/linreal/cascade/editor/markdown/MarkdownDecodeWarning$PreservedSyntax;
+	public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/markdown/MarkdownDecodeWarning$PreservedSyntax;Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/markdown/MarkdownDecodeWarning$PreservedSyntax;
+	public fun equals (Ljava/lang/Object;)Z
+	public fun getImpact ()Lio/github/linreal/cascade/editor/markdown/MarkdownFidelityImpact;
+	public final fun getKind ()Ljava/lang/String;
+	public fun getRange ()Lio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;
+	public fun hashCode ()I
+	public fun toString ()Ljava/lang/String;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/MarkdownDecodeWarning$UnsupportedEntity : io/github/linreal/cascade/editor/markdown/MarkdownDecodeWarning {
+	public static final field $stable I
+	public fun <init> (Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;)V
+	public final fun component1 ()Ljava/lang/String;
+	public final fun component2 ()Lio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;
+	public final fun copy (Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;)Lio/github/linreal/cascade/editor/markdown/MarkdownDecodeWarning$UnsupportedEntity;
+	public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/markdown/MarkdownDecodeWarning$UnsupportedEntity;Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/markdown/MarkdownDecodeWarning$UnsupportedEntity;
+	public fun equals (Ljava/lang/Object;)Z
+	public fun getImpact ()Lio/github/linreal/cascade/editor/markdown/MarkdownFidelityImpact;
+	public final fun getName ()Ljava/lang/String;
+	public fun getRange ()Lio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;
+	public fun hashCode ()I
+	public fun toString ()Ljava/lang/String;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/MarkdownDecodeWarning$UnsupportedSyntax : io/github/linreal/cascade/editor/markdown/MarkdownDecodeWarning {
+	public static final field $stable I
+	public fun <init> (Ljava/lang/String;Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;)V
+	public final fun component1 ()Ljava/lang/String;
+	public final fun component2 ()Ljava/lang/String;
+	public final fun component3 ()Lio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;
+	public final fun copy (Ljava/lang/String;Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;)Lio/github/linreal/cascade/editor/markdown/MarkdownDecodeWarning$UnsupportedSyntax;
+	public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/markdown/MarkdownDecodeWarning$UnsupportedSyntax;Ljava/lang/String;Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/markdown/MarkdownDecodeWarning$UnsupportedSyntax;
+	public fun equals (Ljava/lang/Object;)Z
+	public final fun getConstruct ()Ljava/lang/String;
+	public final fun getDetail ()Ljava/lang/String;
+	public fun getImpact ()Lio/github/linreal/cascade/editor/markdown/MarkdownFidelityImpact;
+	public fun getRange ()Lio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;
+	public fun hashCode ()I
+	public fun toString ()Ljava/lang/String;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/MarkdownEditModeRecommendation : java/lang/Enum {
+	public static final field Native Lio/github/linreal/cascade/editor/markdown/MarkdownEditModeRecommendation;
+	public static final field RawFallback Lio/github/linreal/cascade/editor/markdown/MarkdownEditModeRecommendation;
+	public static fun getEntries ()Lkotlin/enums/EnumEntries;
+	public static fun valueOf (Ljava/lang/String;)Lio/github/linreal/cascade/editor/markdown/MarkdownEditModeRecommendation;
+	public static fun values ()[Lio/github/linreal/cascade/editor/markdown/MarkdownEditModeRecommendation;
+}
+
+public abstract interface class io/github/linreal/cascade/editor/markdown/MarkdownEmit {
+}
+
+public final class io/github/linreal/cascade/editor/markdown/MarkdownEmit$Raw : io/github/linreal/cascade/editor/markdown/MarkdownEmit {
+	public static final field $stable I
+	public fun <init> (Ljava/lang/String;)V
+	public final fun component1 ()Ljava/lang/String;
+	public final fun copy (Ljava/lang/String;)Lio/github/linreal/cascade/editor/markdown/MarkdownEmit$Raw;
+	public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/markdown/MarkdownEmit$Raw;Ljava/lang/String;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/markdown/MarkdownEmit$Raw;
+	public fun equals (Ljava/lang/Object;)Z
+	public final fun getMarkdown ()Ljava/lang/String;
+	public fun hashCode ()I
+	public fun toString ()Ljava/lang/String;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/MarkdownEmit$Skip : io/github/linreal/cascade/editor/markdown/MarkdownEmit {
+	public static final field $stable I
+	public static final field INSTANCE Lio/github/linreal/cascade/editor/markdown/MarkdownEmit$Skip;
+	public fun equals (Ljava/lang/Object;)Z
+	public fun hashCode ()I
+	public fun toString ()Ljava/lang/String;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/MarkdownEmit$Verbatim : io/github/linreal/cascade/editor/markdown/MarkdownEmit {
+	public static final field $stable I
+	public fun <init> (Ljava/lang/String;)V
+	public final fun component1 ()Ljava/lang/String;
+	public final fun copy (Ljava/lang/String;)Lio/github/linreal/cascade/editor/markdown/MarkdownEmit$Verbatim;
+	public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/markdown/MarkdownEmit$Verbatim;Ljava/lang/String;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/markdown/MarkdownEmit$Verbatim;
+	public fun equals (Ljava/lang/Object;)Z
+	public final fun getMarkdown ()Ljava/lang/String;
+	public fun hashCode ()I
+	public fun toString ()Ljava/lang/String;
+}
+
+public abstract class io/github/linreal/cascade/editor/markdown/MarkdownEncodeContext {
+	public static final field $stable I
+	public abstract fun encodeInlineLines (Lio/github/linreal/cascade/editor/core/Block;)Ljava/util/List;
+	public abstract fun encodeTextOnly (Lio/github/linreal/cascade/editor/core/Block;)Ljava/lang/String;
+	public abstract fun prefixLines (Ljava/util/List;Ljava/lang/String;Ljava/lang/String;)Ljava/util/List;
+	public abstract fun warn (Lio/github/linreal/cascade/editor/markdown/MarkdownEncodeWarning;)V
+}
+
+public final class io/github/linreal/cascade/editor/markdown/MarkdownEncodeResult {
+	public static final field $stable I
+	public static final field Companion Lio/github/linreal/cascade/editor/markdown/MarkdownEncodeResult$Companion;
+	public synthetic fun <init> (Lio/github/linreal/cascade/editor/markdown/MarkdownCodecStatus;Ljava/lang/String;Ljava/util/List;Lkotlin/jvm/internal/DefaultConstructorMarker;)V
+	public final fun getMarkdown ()Ljava/lang/String;
+	public final fun getStatus ()Lio/github/linreal/cascade/editor/markdown/MarkdownCodecStatus;
+	public final fun getWarnings ()Ljava/util/List;
+	public final fun isAborted ()Z
+	public final fun isSuccess ()Z
+	public fun toString ()Ljava/lang/String;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/MarkdownEncodeResult$Companion {
+	public final fun aborted (Ljava/util/List;)Lio/github/linreal/cascade/editor/markdown/MarkdownEncodeResult;
+	public final fun success (Ljava/lang/String;Ljava/util/List;)Lio/github/linreal/cascade/editor/markdown/MarkdownEncodeResult;
+	public static synthetic fun success$default (Lio/github/linreal/cascade/editor/markdown/MarkdownEncodeResult$Companion;Ljava/lang/String;Ljava/util/List;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/markdown/MarkdownEncodeResult;
+}
+
+public abstract class io/github/linreal/cascade/editor/markdown/MarkdownEncodeWarning : io/github/linreal/cascade/editor/markdown/MarkdownWarning {
+	public static final field $stable I
+	public abstract fun getBlockId-ticUwL4 ()Ljava/lang/String;
+	public abstract fun getTextRange ()Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/MarkdownEncodeWarning$AmbiguousEmphasis : io/github/linreal/cascade/editor/markdown/MarkdownEncodeWarning {
+	public static final field $stable I
+	public synthetic fun <init> (Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;Lkotlin/jvm/internal/DefaultConstructorMarker;)V
+	public final fun component1-ticUwL4 ()Ljava/lang/String;
+	public final fun component2 ()Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;
+	public final fun copy-421T0j4 (Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;)Lio/github/linreal/cascade/editor/markdown/MarkdownEncodeWarning$AmbiguousEmphasis;
+	public static synthetic fun copy-421T0j4$default (Lio/github/linreal/cascade/editor/markdown/MarkdownEncodeWarning$AmbiguousEmphasis;Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/markdown/MarkdownEncodeWarning$AmbiguousEmphasis;
+	public fun equals (Ljava/lang/Object;)Z
+	public fun getBlockId-ticUwL4 ()Ljava/lang/String;
+	public fun getImpact ()Lio/github/linreal/cascade/editor/markdown/MarkdownFidelityImpact;
+	public fun getTextRange ()Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;
+	public fun hashCode ()I
+	public fun toString ()Ljava/lang/String;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/MarkdownEncodeWarning$DroppedAttribute : io/github/linreal/cascade/editor/markdown/MarkdownEncodeWarning {
+	public static final field $stable I
+	public synthetic fun <init> (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;ILkotlin/jvm/internal/DefaultConstructorMarker;)V
+	public synthetic fun <init> (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;Lkotlin/jvm/internal/DefaultConstructorMarker;)V
+	public final fun component1 ()Ljava/lang/String;
+	public final fun component2 ()Ljava/lang/String;
+	public final fun component3-ticUwL4 ()Ljava/lang/String;
+	public final fun component4 ()Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;
+	public final fun copy-9Un3DiA (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;)Lio/github/linreal/cascade/editor/markdown/MarkdownEncodeWarning$DroppedAttribute;
+	public static synthetic fun copy-9Un3DiA$default (Lio/github/linreal/cascade/editor/markdown/MarkdownEncodeWarning$DroppedAttribute;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/markdown/MarkdownEncodeWarning$DroppedAttribute;
+	public fun equals (Ljava/lang/Object;)Z
+	public final fun getAttr ()Ljava/lang/String;
+	public fun getBlockId-ticUwL4 ()Ljava/lang/String;
+	public fun getImpact ()Lio/github/linreal/cascade/editor/markdown/MarkdownFidelityImpact;
+	public final fun getReason ()Ljava/lang/String;
+	public fun getTextRange ()Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;
+	public fun hashCode ()I
+	public fun toString ()Ljava/lang/String;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/MarkdownEncodeWarning$DroppedSpanOverlap : io/github/linreal/cascade/editor/markdown/MarkdownEncodeWarning {
+	public static final field $stable I
+	public synthetic fun <init> (Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;Ljava/lang/String;Lkotlin/jvm/internal/DefaultConstructorMarker;)V
+	public final fun component1-ticUwL4 ()Ljava/lang/String;
+	public final fun component2 ()Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;
+	public final fun component3 ()Ljava/lang/String;
+	public final fun copy-w7YA71c (Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;Ljava/lang/String;)Lio/github/linreal/cascade/editor/markdown/MarkdownEncodeWarning$DroppedSpanOverlap;
+	public static synthetic fun copy-w7YA71c$default (Lio/github/linreal/cascade/editor/markdown/MarkdownEncodeWarning$DroppedSpanOverlap;Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;Ljava/lang/String;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/markdown/MarkdownEncodeWarning$DroppedSpanOverlap;
+	public fun equals (Ljava/lang/Object;)Z
+	public fun getBlockId-ticUwL4 ()Ljava/lang/String;
+	public fun getImpact ()Lio/github/linreal/cascade/editor/markdown/MarkdownFidelityImpact;
+	public final fun getReason ()Ljava/lang/String;
+	public fun getTextRange ()Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;
+	public fun hashCode ()I
+	public fun toString ()Ljava/lang/String;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/MarkdownEncodeWarning$EncoderException : io/github/linreal/cascade/editor/markdown/MarkdownEncodeWarning {
+	public static final field $stable I
+	public synthetic fun <init> (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;ILkotlin/jvm/internal/DefaultConstructorMarker;)V
+	public synthetic fun <init> (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;Lkotlin/jvm/internal/DefaultConstructorMarker;)V
+	public final fun component1 ()Ljava/lang/String;
+	public final fun component2 ()Ljava/lang/String;
+	public final fun component3-ticUwL4 ()Ljava/lang/String;
+	public final fun component4 ()Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;
+	public final fun copy-9Un3DiA (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;)Lio/github/linreal/cascade/editor/markdown/MarkdownEncodeWarning$EncoderException;
+	public static synthetic fun copy-9Un3DiA$default (Lio/github/linreal/cascade/editor/markdown/MarkdownEncodeWarning$EncoderException;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/markdown/MarkdownEncodeWarning$EncoderException;
+	public fun equals (Ljava/lang/Object;)Z
+	public fun getBlockId-ticUwL4 ()Ljava/lang/String;
+	public fun getImpact ()Lio/github/linreal/cascade/editor/markdown/MarkdownFidelityImpact;
+	public final fun getMessage ()Ljava/lang/String;
+	public fun getTextRange ()Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;
+	public final fun getTypeId ()Ljava/lang/String;
+	public fun hashCode ()I
+	public fun toString ()Ljava/lang/String;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/MarkdownEncodeWarning$EngineFailure : io/github/linreal/cascade/editor/markdown/MarkdownEncodeWarning {
+	public static final field $stable I
+	public synthetic fun <init> (Ljava/lang/String;Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;ILkotlin/jvm/internal/DefaultConstructorMarker;)V
+	public synthetic fun <init> (Ljava/lang/String;Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;Lkotlin/jvm/internal/DefaultConstructorMarker;)V
+	public final fun component1 ()Ljava/lang/String;
+	public final fun component2-ticUwL4 ()Ljava/lang/String;
+	public final fun component3 ()Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;
+	public final fun copy-mf-9-9k (Ljava/lang/String;Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;)Lio/github/linreal/cascade/editor/markdown/MarkdownEncodeWarning$EngineFailure;
+	public static synthetic fun copy-mf-9-9k$default (Lio/github/linreal/cascade/editor/markdown/MarkdownEncodeWarning$EngineFailure;Ljava/lang/String;Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/markdown/MarkdownEncodeWarning$EngineFailure;
+	public fun equals (Ljava/lang/Object;)Z
+	public fun getBlockId-ticUwL4 ()Ljava/lang/String;
+	public fun getImpact ()Lio/github/linreal/cascade/editor/markdown/MarkdownFidelityImpact;
+	public final fun getMessage ()Ljava/lang/String;
+	public fun getTextRange ()Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;
+	public fun hashCode ()I
+	public fun toString ()Ljava/lang/String;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/MarkdownEncodeWarning$LimitExceeded : io/github/linreal/cascade/editor/markdown/MarkdownEncodeWarning {
+	public static final field $stable I
+	public synthetic fun <init> (Lio/github/linreal/cascade/editor/markdown/MarkdownCodecLimitKind;ILjava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;ILkotlin/jvm/internal/DefaultConstructorMarker;)V
+	public synthetic fun <init> (Lio/github/linreal/cascade/editor/markdown/MarkdownCodecLimitKind;ILjava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;Lkotlin/jvm/internal/DefaultConstructorMarker;)V
+	public final fun component1 ()Lio/github/linreal/cascade/editor/markdown/MarkdownCodecLimitKind;
+	public final fun component2 ()I
+	public final fun component3-ticUwL4 ()Ljava/lang/String;
+	public final fun component4 ()Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;
+	public final fun copy-9Un3DiA (Lio/github/linreal/cascade/editor/markdown/MarkdownCodecLimitKind;ILjava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;)Lio/github/linreal/cascade/editor/markdown/MarkdownEncodeWarning$LimitExceeded;
+	public static synthetic fun copy-9Un3DiA$default (Lio/github/linreal/cascade/editor/markdown/MarkdownEncodeWarning$LimitExceeded;Lio/github/linreal/cascade/editor/markdown/MarkdownCodecLimitKind;ILjava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/markdown/MarkdownEncodeWarning$LimitExceeded;
+	public fun equals (Ljava/lang/Object;)Z
+	public fun getBlockId-ticUwL4 ()Ljava/lang/String;
+	public fun getImpact ()Lio/github/linreal/cascade/editor/markdown/MarkdownFidelityImpact;
+	public final fun getKind ()Lio/github/linreal/cascade/editor/markdown/MarkdownCodecLimitKind;
+	public final fun getLimit ()I
+	public fun getTextRange ()Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;
+	public fun hashCode ()I
+	public fun toString ()Ljava/lang/String;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/MarkdownEncodeWarning$OutputLimitExceeded : io/github/linreal/cascade/editor/markdown/MarkdownEncodeWarning {
+	public static final field $stable I
+	public synthetic fun <init> (ILjava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;ILkotlin/jvm/internal/DefaultConstructorMarker;)V
+	public synthetic fun <init> (ILjava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;Lkotlin/jvm/internal/DefaultConstructorMarker;)V
+	public final fun component1 ()I
+	public final fun component2-ticUwL4 ()Ljava/lang/String;
+	public final fun component3 ()Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;
+	public final fun copy-mf-9-9k (ILjava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;)Lio/github/linreal/cascade/editor/markdown/MarkdownEncodeWarning$OutputLimitExceeded;
+	public static synthetic fun copy-mf-9-9k$default (Lio/github/linreal/cascade/editor/markdown/MarkdownEncodeWarning$OutputLimitExceeded;ILjava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/markdown/MarkdownEncodeWarning$OutputLimitExceeded;
+	public fun equals (Ljava/lang/Object;)Z
+	public fun getBlockId-ticUwL4 ()Ljava/lang/String;
+	public fun getImpact ()Lio/github/linreal/cascade/editor/markdown/MarkdownFidelityImpact;
+	public final fun getLimit ()I
+	public fun getTextRange ()Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;
+	public fun hashCode ()I
+	public fun toString ()Ljava/lang/String;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/MarkdownEncodeWarning$UnsupportedBlock : io/github/linreal/cascade/editor/markdown/MarkdownEncodeWarning {
+	public static final field $stable I
+	public synthetic fun <init> (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;ILkotlin/jvm/internal/DefaultConstructorMarker;)V
+	public synthetic fun <init> (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;Lkotlin/jvm/internal/DefaultConstructorMarker;)V
+	public final fun component1 ()Ljava/lang/String;
+	public final fun component2 ()Ljava/lang/String;
+	public final fun component3-ticUwL4 ()Ljava/lang/String;
+	public final fun component4 ()Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;
+	public final fun copy-9Un3DiA (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;)Lio/github/linreal/cascade/editor/markdown/MarkdownEncodeWarning$UnsupportedBlock;
+	public static synthetic fun copy-9Un3DiA$default (Lio/github/linreal/cascade/editor/markdown/MarkdownEncodeWarning$UnsupportedBlock;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/markdown/MarkdownEncodeWarning$UnsupportedBlock;
+	public fun equals (Ljava/lang/Object;)Z
+	public fun getBlockId-ticUwL4 ()Ljava/lang/String;
+	public fun getImpact ()Lio/github/linreal/cascade/editor/markdown/MarkdownFidelityImpact;
+	public final fun getReason ()Ljava/lang/String;
+	public fun getTextRange ()Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;
+	public final fun getTypeId ()Ljava/lang/String;
+	public fun hashCode ()I
+	public fun toString ()Ljava/lang/String;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/MarkdownEncodeWarning$UnsupportedSpan : io/github/linreal/cascade/editor/markdown/MarkdownEncodeWarning {
+	public static final field $stable I
+	public synthetic fun <init> (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;Lkotlin/jvm/internal/DefaultConstructorMarker;)V
+	public final fun component1 ()Ljava/lang/String;
+	public final fun component2 ()Ljava/lang/String;
+	public final fun component3-ticUwL4 ()Ljava/lang/String;
+	public final fun component4 ()Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;
+	public final fun copy-9Un3DiA (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;)Lio/github/linreal/cascade/editor/markdown/MarkdownEncodeWarning$UnsupportedSpan;
+	public static synthetic fun copy-9Un3DiA$default (Lio/github/linreal/cascade/editor/markdown/MarkdownEncodeWarning$UnsupportedSpan;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/markdown/MarkdownEncodeWarning$UnsupportedSpan;
+	public fun equals (Ljava/lang/Object;)Z
+	public fun getBlockId-ticUwL4 ()Ljava/lang/String;
+	public fun getImpact ()Lio/github/linreal/cascade/editor/markdown/MarkdownFidelityImpact;
+	public final fun getReason ()Ljava/lang/String;
+	public fun getTextRange ()Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;
+	public final fun getTypeId ()Ljava/lang/String;
+	public fun hashCode ()I
+	public fun toString ()Ljava/lang/String;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/MarkdownEscapeContext {
+	public static final field $stable I
+	public static final field Companion Lio/github/linreal/cascade/editor/markdown/MarkdownEscapeContext$Companion;
+	public fun <init> (ZLjava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownEscapeTextKind;)V
+	public synthetic fun <init> (ZLjava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownEscapeTextKind;ILkotlin/jvm/internal/DefaultConstructorMarker;)V
+	public final fun component1 ()Z
+	public final fun component2 ()Ljava/lang/String;
+	public final fun component3 ()Lio/github/linreal/cascade/editor/markdown/MarkdownEscapeTextKind;
+	public final fun copy (ZLjava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownEscapeTextKind;)Lio/github/linreal/cascade/editor/markdown/MarkdownEscapeContext;
+	public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/markdown/MarkdownEscapeContext;ZLjava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownEscapeTextKind;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/markdown/MarkdownEscapeContext;
+	public fun equals (Ljava/lang/Object;)Z
+	public final fun getAtLineStart ()Z
+	public final fun getContainerPrefix ()Ljava/lang/String;
+	public final fun getKind ()Lio/github/linreal/cascade/editor/markdown/MarkdownEscapeTextKind;
+	public fun hashCode ()I
+	public fun toString ()Ljava/lang/String;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/MarkdownEscapeContext$Companion {
+	public final fun getLineStart ()Lio/github/linreal/cascade/editor/markdown/MarkdownEscapeContext;
+	public final fun getMidLine ()Lio/github/linreal/cascade/editor/markdown/MarkdownEscapeContext;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/MarkdownEscapeTextKind : java/lang/Enum {
+	public static final field LinkLabel Lio/github/linreal/cascade/editor/markdown/MarkdownEscapeTextKind;
+	public static final field LinkText Lio/github/linreal/cascade/editor/markdown/MarkdownEscapeTextKind;
+	public static final field Plain Lio/github/linreal/cascade/editor/markdown/MarkdownEscapeTextKind;
+	public static fun getEntries ()Lkotlin/enums/EnumEntries;
+	public static fun valueOf (Ljava/lang/String;)Lio/github/linreal/cascade/editor/markdown/MarkdownEscapeTextKind;
+	public static fun values ()[Lio/github/linreal/cascade/editor/markdown/MarkdownEscapeTextKind;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/MarkdownFidelityImpact : java/lang/Enum {
+	public static final field Canonicalization Lio/github/linreal/cascade/editor/markdown/MarkdownFidelityImpact;
+	public static final field DataLoss Lio/github/linreal/cascade/editor/markdown/MarkdownFidelityImpact;
+	public static final field Fatal Lio/github/linreal/cascade/editor/markdown/MarkdownFidelityImpact;
+	public static final field Informational Lio/github/linreal/cascade/editor/markdown/MarkdownFidelityImpact;
+	public static final field OpaquePreservation Lio/github/linreal/cascade/editor/markdown/MarkdownFidelityImpact;
+	public static fun getEntries ()Lkotlin/enums/EnumEntries;
+	public static fun valueOf (Ljava/lang/String;)Lio/github/linreal/cascade/editor/markdown/MarkdownFidelityImpact;
+	public static fun values ()[Lio/github/linreal/cascade/editor/markdown/MarkdownFidelityImpact;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/MarkdownFidelityReport {
+	public static final field $stable I
+	public final fun getDataLossWarnings ()Ljava/util/List;
+	public final fun getDecodeResult ()Lio/github/linreal/cascade/editor/markdown/MarkdownDecodeResult;
+	public final fun getEncodeResult ()Lio/github/linreal/cascade/editor/markdown/MarkdownEncodeResult;
+	public final fun getNativeEditingSafe ()Z
+	public final fun getPreservedBlockCount ()I
+	public final fun getRecommendedMode ()Lio/github/linreal/cascade/editor/markdown/MarkdownEditModeRecommendation;
+	public final fun getWouldRewriteSource ()Ljava/lang/Boolean;
+	public fun toString ()Ljava/lang/String;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/MarkdownLineEnding : java/lang/Enum {
+	public static final field CrLf Lio/github/linreal/cascade/editor/markdown/MarkdownLineEnding;
+	public static final field Lf Lio/github/linreal/cascade/editor/markdown/MarkdownLineEnding;
+	public static fun getEntries ()Lkotlin/enums/EnumEntries;
+	public static fun valueOf (Ljava/lang/String;)Lio/github/linreal/cascade/editor/markdown/MarkdownLineEnding;
+	public static fun values ()[Lio/github/linreal/cascade/editor/markdown/MarkdownLineEnding;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/MarkdownMarkPair {
+	public static final field $stable I
+	public fun <init> (Ljava/lang/String;Ljava/lang/String;)V
+	public final fun component1 ()Ljava/lang/String;
+	public final fun component2 ()Ljava/lang/String;
+	public final fun copy (Ljava/lang/String;Ljava/lang/String;)Lio/github/linreal/cascade/editor/markdown/MarkdownMarkPair;
+	public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/markdown/MarkdownMarkPair;Ljava/lang/String;Ljava/lang/String;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/markdown/MarkdownMarkPair;
+	public fun equals (Ljava/lang/Object;)Z
+	public final fun getClose ()Ljava/lang/String;
+	public final fun getOpen ()Ljava/lang/String;
+	public fun hashCode ()I
+	public fun toString ()Ljava/lang/String;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/MarkdownProfile {
+	public static final field $stable I
+	public static final field Companion Lio/github/linreal/cascade/editor/markdown/MarkdownProfile$Companion;
+	public final fun getSupportSet ()Lio/github/linreal/cascade/editor/markdown/MarkdownProfileSupportSet;
+	public final fun withCustomMarkdownBlockEncoder (Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownBlockEncoder;)Lio/github/linreal/cascade/editor/markdown/MarkdownProfile;
+	public final fun withCustomMarkdownSpanEncoder (Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownSpanEncoder;)Lio/github/linreal/cascade/editor/markdown/MarkdownProfile;
+	public final fun withEncoderBlockFallback (Lio/github/linreal/cascade/editor/markdown/MarkdownBlockEncoder;)Lio/github/linreal/cascade/editor/markdown/MarkdownProfile;
+	public final fun withEncoderSpanFallback (Lio/github/linreal/cascade/editor/markdown/MarkdownSpanEncoder;)Lio/github/linreal/cascade/editor/markdown/MarkdownProfile;
+	public final fun withEntityDecode (Lio/github/linreal/cascade/editor/markdown/EntityDecode;)Lio/github/linreal/cascade/editor/markdown/MarkdownProfile;
+	public final fun withHardBreakEncode (Lio/github/linreal/cascade/editor/markdown/HardBreakEncode;)Lio/github/linreal/cascade/editor/markdown/MarkdownProfile;
+	public final fun withHtmlInMarkdown (Lio/github/linreal/cascade/editor/markdown/HtmlInMarkdown;)Lio/github/linreal/cascade/editor/markdown/MarkdownProfile;
+	public final fun withMarkdownBlockEncoderInternal (Lkotlin/reflect/KClass;Lio/github/linreal/cascade/editor/markdown/MarkdownBlockEncoder;)Lio/github/linreal/cascade/editor/markdown/MarkdownProfile;
+	public final fun withMarkdownBlockGroupEncoder (Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownBlockGroupEncoder;)Lio/github/linreal/cascade/editor/markdown/MarkdownProfile;
+	public final fun withMarkdownSpanEncoderInternal (Lkotlin/reflect/KClass;Lio/github/linreal/cascade/editor/markdown/MarkdownSpanEncoder;)Lio/github/linreal/cascade/editor/markdown/MarkdownProfile;
+	public final fun withNewlineSemantics (Lio/github/linreal/cascade/editor/markdown/NewlineSemantics;)Lio/github/linreal/cascade/editor/markdown/MarkdownProfile;
+	public final fun withSoftBreak (Lio/github/linreal/cascade/editor/markdown/SoftBreak;)Lio/github/linreal/cascade/editor/markdown/MarkdownProfile;
+	public final fun withSupportSet (Lio/github/linreal/cascade/editor/markdown/MarkdownProfileSupportSet;)Lio/github/linreal/cascade/editor/markdown/MarkdownProfile;
+	public final fun withUnsupportedSyntax (Lio/github/linreal/cascade/editor/markdown/UnsupportedSyntax;)Lio/github/linreal/cascade/editor/markdown/MarkdownProfile;
+	public final fun withoutHtmlBridge ()Lio/github/linreal/cascade/editor/markdown/MarkdownProfile;
+	public final fun withoutMarkdownBlockGroupEncoder (Ljava/lang/String;)Lio/github/linreal/cascade/editor/markdown/MarkdownProfile;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/MarkdownProfile$Companion {
+	public final fun getDefault ()Lio/github/linreal/cascade/editor/markdown/MarkdownProfile;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/MarkdownProfileSupportSet {
+	public static final field $stable I
+	public static final field Companion Lio/github/linreal/cascade/editor/markdown/MarkdownProfileSupportSet$Companion;
+	public fun <init> (Lkotlin/jvm/functions/Function1;Lkotlin/jvm/functions/Function1;Lkotlin/jvm/functions/Function1;)V
+	public final fun getSupportsBlockPredicate ()Lkotlin/jvm/functions/Function1;
+	public final fun getSupportsDocumentPredicate ()Lkotlin/jvm/functions/Function1;
+	public final fun getSupportsSpanPredicate ()Lkotlin/jvm/functions/Function1;
+	public final fun supportsBlock (Lio/github/linreal/cascade/editor/core/Block;)Z
+	public final fun supportsDocument (Ljava/util/List;)Z
+	public final fun supportsSpan (Lio/github/linreal/cascade/editor/core/SpanStyle;)Z
+}
+
+public final class io/github/linreal/cascade/editor/markdown/MarkdownProfileSupportSet$Companion {
+	public final fun getNone ()Lio/github/linreal/cascade/editor/markdown/MarkdownProfileSupportSet;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/MarkdownSchema {
+	public static final field $stable I
+	public static final field INSTANCE Lio/github/linreal/cascade/editor/markdown/MarkdownSchema;
+	public final fun analyze (Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownProfile;Lio/github/linreal/cascade/editor/markdown/MarkdownCodecLimits;)Lio/github/linreal/cascade/editor/markdown/MarkdownFidelityReport;
+	public static synthetic fun analyze$default (Lio/github/linreal/cascade/editor/markdown/MarkdownSchema;Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownProfile;Lio/github/linreal/cascade/editor/markdown/MarkdownCodecLimits;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/markdown/MarkdownFidelityReport;
+	public final fun decode (Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownProfile;Lio/github/linreal/cascade/editor/markdown/MarkdownCodecLimits;)Ljava/util/List;
+	public static synthetic fun decode$default (Lio/github/linreal/cascade/editor/markdown/MarkdownSchema;Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownProfile;Lio/github/linreal/cascade/editor/markdown/MarkdownCodecLimits;ILjava/lang/Object;)Ljava/util/List;
+	public final fun decodeWithReport (Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownProfile;Lio/github/linreal/cascade/editor/markdown/MarkdownCodecLimits;)Lio/github/linreal/cascade/editor/markdown/MarkdownDecodeResult;
+	public static synthetic fun decodeWithReport$default (Lio/github/linreal/cascade/editor/markdown/MarkdownSchema;Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownProfile;Lio/github/linreal/cascade/editor/markdown/MarkdownCodecLimits;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/markdown/MarkdownDecodeResult;
+	public final fun encode (Ljava/util/List;Lio/github/linreal/cascade/editor/markdown/MarkdownProfile;Lio/github/linreal/cascade/editor/markdown/MarkdownCodecLimits;Lio/github/linreal/cascade/editor/markdown/MarkdownLineEnding;)Ljava/lang/String;
+	public static synthetic fun encode$default (Lio/github/linreal/cascade/editor/markdown/MarkdownSchema;Ljava/util/List;Lio/github/linreal/cascade/editor/markdown/MarkdownProfile;Lio/github/linreal/cascade/editor/markdown/MarkdownCodecLimits;Lio/github/linreal/cascade/editor/markdown/MarkdownLineEnding;ILjava/lang/Object;)Ljava/lang/String;
+	public final fun encodeWithReport (Ljava/util/List;Lio/github/linreal/cascade/editor/markdown/MarkdownProfile;Lio/github/linreal/cascade/editor/markdown/MarkdownCodecLimits;Lio/github/linreal/cascade/editor/markdown/MarkdownLineEnding;)Lio/github/linreal/cascade/editor/markdown/MarkdownEncodeResult;
+	public static synthetic fun encodeWithReport$default (Lio/github/linreal/cascade/editor/markdown/MarkdownSchema;Ljava/util/List;Lio/github/linreal/cascade/editor/markdown/MarkdownProfile;Lio/github/linreal/cascade/editor/markdown/MarkdownCodecLimits;Lio/github/linreal/cascade/editor/markdown/MarkdownLineEnding;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/markdown/MarkdownEncodeResult;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/MarkdownSerializationExtKt {
+	public static final fun applyMarkdownDecodeResult (Lio/github/linreal/cascade/editor/state/EditorStateHolder;Lio/github/linreal/cascade/editor/markdown/MarkdownDecodeResult;Lio/github/linreal/cascade/editor/state/BlockTextStates;Lio/github/linreal/cascade/editor/state/BlockSpanStates;)V
+	public static final fun loadFromMarkdown (Lio/github/linreal/cascade/editor/state/EditorStateHolder;Ljava/lang/String;Lio/github/linreal/cascade/editor/state/BlockTextStates;Lio/github/linreal/cascade/editor/state/BlockSpanStates;Lio/github/linreal/cascade/editor/markdown/MarkdownProfile;Lio/github/linreal/cascade/editor/markdown/MarkdownCodecLimits;)Lio/github/linreal/cascade/editor/markdown/MarkdownDecodeResult;
+	public static synthetic fun loadFromMarkdown$default (Lio/github/linreal/cascade/editor/state/EditorStateHolder;Ljava/lang/String;Lio/github/linreal/cascade/editor/state/BlockTextStates;Lio/github/linreal/cascade/editor/state/BlockSpanStates;Lio/github/linreal/cascade/editor/markdown/MarkdownProfile;Lio/github/linreal/cascade/editor/markdown/MarkdownCodecLimits;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/markdown/MarkdownDecodeResult;
+	public static final fun toMarkdown (Lio/github/linreal/cascade/editor/state/EditorStateHolder;Lio/github/linreal/cascade/editor/state/BlockTextStates;Lio/github/linreal/cascade/editor/state/BlockSpanStates;Lio/github/linreal/cascade/editor/markdown/MarkdownProfile;Lio/github/linreal/cascade/editor/markdown/MarkdownCodecLimits;Lio/github/linreal/cascade/editor/markdown/MarkdownLineEnding;)Ljava/lang/String;
+	public static synthetic fun toMarkdown$default (Lio/github/linreal/cascade/editor/state/EditorStateHolder;Lio/github/linreal/cascade/editor/state/BlockTextStates;Lio/github/linreal/cascade/editor/state/BlockSpanStates;Lio/github/linreal/cascade/editor/markdown/MarkdownProfile;Lio/github/linreal/cascade/editor/markdown/MarkdownCodecLimits;Lio/github/linreal/cascade/editor/markdown/MarkdownLineEnding;ILjava/lang/Object;)Ljava/lang/String;
+	public static final fun toMarkdownWithReport (Lio/github/linreal/cascade/editor/state/EditorStateHolder;Lio/github/linreal/cascade/editor/state/BlockTextStates;Lio/github/linreal/cascade/editor/state/BlockSpanStates;Lio/github/linreal/cascade/editor/markdown/MarkdownProfile;Lio/github/linreal/cascade/editor/markdown/MarkdownCodecLimits;Lio/github/linreal/cascade/editor/markdown/MarkdownLineEnding;)Lio/github/linreal/cascade/editor/markdown/MarkdownEncodeResult;
+	public static synthetic fun toMarkdownWithReport$default (Lio/github/linreal/cascade/editor/state/EditorStateHolder;Lio/github/linreal/cascade/editor/state/BlockTextStates;Lio/github/linreal/cascade/editor/state/BlockSpanStates;Lio/github/linreal/cascade/editor/markdown/MarkdownProfile;Lio/github/linreal/cascade/editor/markdown/MarkdownCodecLimits;Lio/github/linreal/cascade/editor/markdown/MarkdownLineEnding;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/markdown/MarkdownEncodeResult;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/MarkdownSourceLocation {
+	public static final field $stable I
+	public fun <init> (II)V
+	public final fun component1 ()I
+	public final fun component2 ()I
+	public final fun copy (II)Lio/github/linreal/cascade/editor/markdown/MarkdownSourceLocation;
+	public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/markdown/MarkdownSourceLocation;IIILjava/lang/Object;)Lio/github/linreal/cascade/editor/markdown/MarkdownSourceLocation;
+	public fun equals (Ljava/lang/Object;)Z
+	public final fun getColumn ()I
+	public final fun getLine ()I
+	public fun hashCode ()I
+	public fun toString ()Ljava/lang/String;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/MarkdownSourceLocator {
+	public static final field $stable I
+	public final fun locate (I)Lio/github/linreal/cascade/editor/markdown/MarkdownSourceLocation;
+	public final fun locate (Lio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;)Lio/github/linreal/cascade/editor/markdown/MarkdownSourceLocation;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/MarkdownSourceRange {
+	public static final field $stable I
+	public fun <init> (II)V
+	public final fun component1 ()I
+	public final fun component2 ()I
+	public final fun copy (II)Lio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;
+	public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;IIILjava/lang/Object;)Lio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;
+	public fun equals (Ljava/lang/Object;)Z
+	public final fun getEndExclusive ()I
+	public final fun getLength ()I
+	public final fun getStart ()I
+	public fun hashCode ()I
+	public final fun isEmpty ()Z
+	public fun toString ()Ljava/lang/String;
+}
+
+public abstract interface class io/github/linreal/cascade/editor/markdown/MarkdownSpanEncoder {
+	public abstract fun encode (Lio/github/linreal/cascade/editor/core/SpanStyle;)Lio/github/linreal/cascade/editor/markdown/MarkdownMarkPair;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/MarkdownTextRange {
+	public static final field $stable I
+	public fun <init> (II)V
+	public final fun component1 ()I
+	public final fun component2 ()I
+	public final fun copy (II)Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;
+	public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;IIILjava/lang/Object;)Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;
+	public fun equals (Ljava/lang/Object;)Z
+	public final fun getEndExclusive ()I
+	public final fun getStart ()I
+	public fun hashCode ()I
+	public fun toString ()Ljava/lang/String;
+}
+
+public abstract interface class io/github/linreal/cascade/editor/markdown/MarkdownWarning {
+	public abstract fun getImpact ()Lio/github/linreal/cascade/editor/markdown/MarkdownFidelityImpact;
+}
+
+public abstract interface class io/github/linreal/cascade/editor/markdown/NewlineSemantics {
+}
+
+public final class io/github/linreal/cascade/editor/markdown/NewlineSemantics$CommonMark : io/github/linreal/cascade/editor/markdown/NewlineSemantics {
+	public static final field $stable I
+	public static final field INSTANCE Lio/github/linreal/cascade/editor/markdown/NewlineSemantics$CommonMark;
+	public fun equals (Ljava/lang/Object;)Z
+	public fun hashCode ()I
+	public fun toString ()Ljava/lang/String;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/NewlineSemantics$HardBreak : io/github/linreal/cascade/editor/markdown/NewlineSemantics {
+	public static final field $stable I
+	public static final field INSTANCE Lio/github/linreal/cascade/editor/markdown/NewlineSemantics$HardBreak;
+	public fun equals (Ljava/lang/Object;)Z
+	public fun hashCode ()I
+	public fun toString ()Ljava/lang/String;
+}
+
+public abstract interface class io/github/linreal/cascade/editor/markdown/SoftBreak {
+}
+
+public final class io/github/linreal/cascade/editor/markdown/SoftBreak$LineBreak : io/github/linreal/cascade/editor/markdown/SoftBreak {
+	public static final field $stable I
+	public static final field INSTANCE Lio/github/linreal/cascade/editor/markdown/SoftBreak$LineBreak;
+	public fun equals (Ljava/lang/Object;)Z
+	public fun hashCode ()I
+	public fun toString ()Ljava/lang/String;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/SoftBreak$Space : io/github/linreal/cascade/editor/markdown/SoftBreak {
+	public static final field $stable I
+	public static final field INSTANCE Lio/github/linreal/cascade/editor/markdown/SoftBreak$Space;
+	public fun equals (Ljava/lang/Object;)Z
+	public fun hashCode ()I
+	public fun toString ()Ljava/lang/String;
+}
+
+public abstract interface class io/github/linreal/cascade/editor/markdown/UnsupportedSyntax {
+}
+
+public final class io/github/linreal/cascade/editor/markdown/UnsupportedSyntax$Preserve : io/github/linreal/cascade/editor/markdown/UnsupportedSyntax {
+	public static final field $stable I
+	public static final field INSTANCE Lio/github/linreal/cascade/editor/markdown/UnsupportedSyntax$Preserve;
+	public fun equals (Ljava/lang/Object;)Z
+	public fun hashCode ()I
+	public fun toString ()Ljava/lang/String;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/UnsupportedSyntax$WarnAndDegrade : io/github/linreal/cascade/editor/markdown/UnsupportedSyntax {
+	public static final field $stable I
+	public static final field INSTANCE Lio/github/linreal/cascade/editor/markdown/UnsupportedSyntax$WarnAndDegrade;
+	public fun equals (Ljava/lang/Object;)Z
+	public fun hashCode ()I
+	public fun toString ()Ljava/lang/String;
+}
+
 public abstract interface class io/github/linreal/cascade/editor/registry/BlockCallbacks {
 	public abstract fun dispatch (Lio/github/linreal/cascade/editor/action/EditorAction;)V
 	public abstract fun onBackspaceAtStart-SDe6QqM (Ljava/lang/String;)V
@@ -1820,6 +2688,7 @@ public final class io/github/linreal/cascade/editor/richtext/LinkUrlPolicy {
 	public static final field $stable I
 	public static final field INSTANCE Lio/github/linreal/cascade/editor/richtext/LinkUrlPolicy;
 	public final fun validate (Ljava/lang/String;)Lio/github/linreal/cascade/editor/richtext/LinkValidationResult;
+	public final fun validateStoredTarget (Ljava/lang/String;)Lio/github/linreal/cascade/editor/richtext/LinkValidationResult;
 }
 
 public final class io/github/linreal/cascade/editor/richtext/LinkValidationError : java/lang/Enum {
diff --git a/editor/api/desktop/editor.api b/editor/api/desktop/editor.api
index afbb082..0a5da4e 100644
--- a/editor/api/desktop/editor.api
+++ b/editor/api/desktop/editor.api
@@ -1567,6 +1567,874 @@ public final class io/github/linreal/cascade/editor/indentation/IndentationState
 	public final fun getEmpty ()Lio/github/linreal/cascade/editor/indentation/IndentationState;
 }
 
+public abstract interface class io/github/linreal/cascade/editor/markdown/EntityDecode {
+}
+
+public final class io/github/linreal/cascade/editor/markdown/EntityDecode$None : io/github/linreal/cascade/editor/markdown/EntityDecode {
+	public static final field $stable I
+	public static final field INSTANCE Lio/github/linreal/cascade/editor/markdown/EntityDecode$None;
+	public fun equals (Ljava/lang/Object;)Z
+	public fun hashCode ()I
+	public fun toString ()Ljava/lang/String;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/EntityDecode$Standard : io/github/linreal/cascade/editor/markdown/EntityDecode {
+	public static final field $stable I
+	public static final field INSTANCE Lio/github/linreal/cascade/editor/markdown/EntityDecode$Standard;
+	public fun equals (Ljava/lang/Object;)Z
+	public fun hashCode ()I
+	public fun toString ()Ljava/lang/String;
+}
+
+public abstract interface annotation class io/github/linreal/cascade/editor/markdown/ExperimentalCascadeMarkdownApi : java/lang/annotation/Annotation {
+}
+
+public abstract interface class io/github/linreal/cascade/editor/markdown/HardBreakEncode {
+}
+
+public final class io/github/linreal/cascade/editor/markdown/HardBreakEncode$Backslash : io/github/linreal/cascade/editor/markdown/HardBreakEncode {
+	public static final field $stable I
+	public static final field INSTANCE Lio/github/linreal/cascade/editor/markdown/HardBreakEncode$Backslash;
+	public fun equals (Ljava/lang/Object;)Z
+	public fun hashCode ()I
+	public fun toString ()Ljava/lang/String;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/HardBreakEncode$TwoSpaces : io/github/linreal/cascade/editor/markdown/HardBreakEncode {
+	public static final field $stable I
+	public static final field INSTANCE Lio/github/linreal/cascade/editor/markdown/HardBreakEncode$TwoSpaces;
+	public fun equals (Ljava/lang/Object;)Z
+	public fun hashCode ()I
+	public fun toString ()Ljava/lang/String;
+}
+
+public abstract interface class io/github/linreal/cascade/editor/markdown/HtmlInMarkdown {
+}
+
+public final class io/github/linreal/cascade/editor/markdown/HtmlInMarkdown$Bridge : io/github/linreal/cascade/editor/markdown/HtmlInMarkdown {
+	public static final field $stable I
+	public fun <init> (Lio/github/linreal/cascade/editor/htmlserialization/HtmlProfile;)V
+	public final fun component1 ()Lio/github/linreal/cascade/editor/htmlserialization/HtmlProfile;
+	public final fun copy (Lio/github/linreal/cascade/editor/htmlserialization/HtmlProfile;)Lio/github/linreal/cascade/editor/markdown/HtmlInMarkdown$Bridge;
+	public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/markdown/HtmlInMarkdown$Bridge;Lio/github/linreal/cascade/editor/htmlserialization/HtmlProfile;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/markdown/HtmlInMarkdown$Bridge;
+	public fun equals (Ljava/lang/Object;)Z
+	public final fun getHtmlProfile ()Lio/github/linreal/cascade/editor/htmlserialization/HtmlProfile;
+	public fun hashCode ()I
+	public fun toString ()Ljava/lang/String;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/HtmlInMarkdown$Preserve : io/github/linreal/cascade/editor/markdown/HtmlInMarkdown {
+	public static final field $stable I
+	public static final field INSTANCE Lio/github/linreal/cascade/editor/markdown/HtmlInMarkdown$Preserve;
+	public fun equals (Ljava/lang/Object;)Z
+	public fun hashCode ()I
+	public fun toString ()Ljava/lang/String;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/HtmlInMarkdown$Strip : io/github/linreal/cascade/editor/markdown/HtmlInMarkdown {
+	public static final field $stable I
+	public static final field INSTANCE Lio/github/linreal/cascade/editor/markdown/HtmlInMarkdown$Strip;
+	public fun equals (Ljava/lang/Object;)Z
+	public fun hashCode ()I
+	public fun toString ()Ljava/lang/String;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/HtmlInMarkdown$WarnAndStrip : io/github/linreal/cascade/editor/markdown/HtmlInMarkdown {
+	public static final field $stable I
+	public static final field INSTANCE Lio/github/linreal/cascade/editor/markdown/HtmlInMarkdown$WarnAndStrip;
+	public fun equals (Ljava/lang/Object;)Z
+	public fun hashCode ()I
+	public fun toString ()Ljava/lang/String;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/Markdown {
+	public static final field $stable I
+	public static final field INSTANCE Lio/github/linreal/cascade/editor/markdown/Markdown;
+	public final fun codeSpanDelimiters (Ljava/lang/String;)Lio/github/linreal/cascade/editor/markdown/MarkdownCodeSpanDelimiters;
+	public final fun escapeInline (Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownEscapeContext;)Ljava/lang/String;
+	public final fun escapeLinkDestination (Ljava/lang/String;)Ljava/lang/String;
+	public final fun escapeLinkText (Ljava/lang/String;)Ljava/lang/String;
+}
+
+public abstract interface class io/github/linreal/cascade/editor/markdown/MarkdownBlockEncoder {
+	public abstract fun encode (Lio/github/linreal/cascade/editor/markdown/MarkdownEncodeContext;Lio/github/linreal/cascade/editor/core/Block;Lio/github/linreal/cascade/editor/core/BlockContent;)Lio/github/linreal/cascade/editor/markdown/MarkdownEmit;
+}
+
+public abstract interface class io/github/linreal/cascade/editor/markdown/MarkdownBlockGroupEncoder {
+	public abstract fun encodeGroup (Lio/github/linreal/cascade/editor/markdown/MarkdownEncodeContext;Ljava/util/List;)Lio/github/linreal/cascade/editor/markdown/MarkdownEmit;
+	public abstract fun groupKey (Lio/github/linreal/cascade/editor/core/Block;)Ljava/lang/Object;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/MarkdownCodeSpanDelimiters {
+	public static final field $stable I
+	public fun <init> (Ljava/lang/String;ZZ)V
+	public synthetic fun <init> (Ljava/lang/String;ZZILkotlin/jvm/internal/DefaultConstructorMarker;)V
+	public final fun component1 ()Ljava/lang/String;
+	public final fun component2 ()Z
+	public final fun component3 ()Z
+	public final fun copy (Ljava/lang/String;ZZ)Lio/github/linreal/cascade/editor/markdown/MarkdownCodeSpanDelimiters;
+	public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/markdown/MarkdownCodeSpanDelimiters;Ljava/lang/String;ZZILjava/lang/Object;)Lio/github/linreal/cascade/editor/markdown/MarkdownCodeSpanDelimiters;
+	public fun equals (Ljava/lang/Object;)Z
+	public final fun getClose ()Ljava/lang/String;
+	public final fun getFence ()Ljava/lang/String;
+	public final fun getOpen ()Ljava/lang/String;
+	public final fun getPadded ()Z
+	public final fun getRequiresFallback ()Z
+	public fun hashCode ()I
+	public fun toString ()Ljava/lang/String;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/MarkdownCodecLimitKind : java/lang/Enum {
+	public static final field BlockNesting Lio/github/linreal/cascade/editor/markdown/MarkdownCodecLimitKind;
+	public static final field Blocks Lio/github/linreal/cascade/editor/markdown/MarkdownCodecLimitKind;
+	public static final field DelimiterRuns Lio/github/linreal/cascade/editor/markdown/MarkdownCodecLimitKind;
+	public static final field ReferenceDefinitions Lio/github/linreal/cascade/editor/markdown/MarkdownCodecLimitKind;
+	public static final field SpansPerBlock Lio/github/linreal/cascade/editor/markdown/MarkdownCodecLimitKind;
+	public static final field TotalSpans Lio/github/linreal/cascade/editor/markdown/MarkdownCodecLimitKind;
+	public static final field Warnings Lio/github/linreal/cascade/editor/markdown/MarkdownCodecLimitKind;
+	public static fun getEntries ()Lkotlin/enums/EnumEntries;
+	public static fun valueOf (Ljava/lang/String;)Lio/github/linreal/cascade/editor/markdown/MarkdownCodecLimitKind;
+	public static fun values ()[Lio/github/linreal/cascade/editor/markdown/MarkdownCodecLimitKind;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/MarkdownCodecLimits {
+	public static final field $stable I
+	public static final field Companion Lio/github/linreal/cascade/editor/markdown/MarkdownCodecLimits$Companion;
+	public static final field DEFAULT_MAX_BLOCKS I
+	public static final field DEFAULT_MAX_BLOCK_NESTING I
+	public static final field DEFAULT_MAX_DELIMITER_RUNS I
+	public static final field DEFAULT_MAX_INPUT_CHARS I
+	public static final field DEFAULT_MAX_OUTPUT_CHARS I
+	public static final field DEFAULT_MAX_REFERENCE_DEFINITIONS I
+	public static final field DEFAULT_MAX_SPANS_PER_BLOCK I
+	public static final field DEFAULT_MAX_TOTAL_SPANS I
+	public static final field DEFAULT_MAX_WARNINGS I
+	public fun <init> ()V
+	public fun <init> (IIIIIIIII)V
+	public synthetic fun <init> (IIIIIIIIIILkotlin/jvm/internal/DefaultConstructorMarker;)V
+	public final fun component1 ()I
+	public final fun component2 ()I
+	public final fun component3 ()I
+	public final fun component4 ()I
+	public final fun component5 ()I
+	public final fun component6 ()I
+	public final fun component7 ()I
+	public final fun component8 ()I
+	public final fun component9 ()I
+	public final fun copy (IIIIIIIII)Lio/github/linreal/cascade/editor/markdown/MarkdownCodecLimits;
+	public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/markdown/MarkdownCodecLimits;IIIIIIIIIILjava/lang/Object;)Lio/github/linreal/cascade/editor/markdown/MarkdownCodecLimits;
+	public fun equals (Ljava/lang/Object;)Z
+	public final fun getMaxBlockNesting ()I
+	public final fun getMaxBlocks ()I
+	public final fun getMaxDelimiterRuns ()I
+	public final fun getMaxInputChars ()I
+	public final fun getMaxOutputChars ()I
+	public final fun getMaxReferenceDefinitions ()I
+	public final fun getMaxSpansPerBlock ()I
+	public final fun getMaxTotalSpans ()I
+	public final fun getMaxWarnings ()I
+	public fun hashCode ()I
+	public fun toString ()Ljava/lang/String;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/MarkdownCodecLimits$Companion {
+	public final fun getDefault ()Lio/github/linreal/cascade/editor/markdown/MarkdownCodecLimits;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/MarkdownCodecStatus : java/lang/Enum {
+	public static final field Aborted Lio/github/linreal/cascade/editor/markdown/MarkdownCodecStatus;
+	public static final field Success Lio/github/linreal/cascade/editor/markdown/MarkdownCodecStatus;
+	public static fun getEntries ()Lkotlin/enums/EnumEntries;
+	public static fun valueOf (Ljava/lang/String;)Lio/github/linreal/cascade/editor/markdown/MarkdownCodecStatus;
+	public static fun values ()[Lio/github/linreal/cascade/editor/markdown/MarkdownCodecStatus;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/MarkdownDecodeResult {
+	public static final field $stable I
+	public static final field Companion Lio/github/linreal/cascade/editor/markdown/MarkdownDecodeResult$Companion;
+	public synthetic fun <init> (Lio/github/linreal/cascade/editor/markdown/MarkdownCodecStatus;Ljava/util/List;Ljava/util/List;Lio/github/linreal/cascade/editor/markdown/MarkdownSourceLocator;Lkotlin/jvm/internal/DefaultConstructorMarker;)V
+	public final fun getBlocks ()Ljava/util/List;
+	public final fun getSourceLocator ()Lio/github/linreal/cascade/editor/markdown/MarkdownSourceLocator;
+	public final fun getStatus ()Lio/github/linreal/cascade/editor/markdown/MarkdownCodecStatus;
+	public final fun getWarnings ()Ljava/util/List;
+	public final fun isAborted ()Z
+	public final fun isSuccess ()Z
+	public fun toString ()Ljava/lang/String;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/MarkdownDecodeResult$Companion {
+	public final fun aborted (Ljava/util/List;Lio/github/linreal/cascade/editor/markdown/MarkdownSourceLocator;)Lio/github/linreal/cascade/editor/markdown/MarkdownDecodeResult;
+	public static synthetic fun aborted$default (Lio/github/linreal/cascade/editor/markdown/MarkdownDecodeResult$Companion;Ljava/util/List;Lio/github/linreal/cascade/editor/markdown/MarkdownSourceLocator;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/markdown/MarkdownDecodeResult;
+	public final fun success (Ljava/util/List;Ljava/util/List;Lio/github/linreal/cascade/editor/markdown/MarkdownSourceLocator;)Lio/github/linreal/cascade/editor/markdown/MarkdownDecodeResult;
+	public static synthetic fun success$default (Lio/github/linreal/cascade/editor/markdown/MarkdownDecodeResult$Companion;Ljava/util/List;Ljava/util/List;Lio/github/linreal/cascade/editor/markdown/MarkdownSourceLocator;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/markdown/MarkdownDecodeResult;
+}
+
+public abstract class io/github/linreal/cascade/editor/markdown/MarkdownDecodeWarning : io/github/linreal/cascade/editor/markdown/MarkdownWarning {
+	public static final field $stable I
+	public abstract fun getRange ()Lio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/MarkdownDecodeWarning$DroppedAttribute : io/github/linreal/cascade/editor/markdown/MarkdownDecodeWarning {
+	public static final field $stable I
+	public fun <init> (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;)V
+	public final fun component1 ()Ljava/lang/String;
+	public final fun component2 ()Ljava/lang/String;
+	public final fun component3 ()Ljava/lang/String;
+	public final fun component4 ()Lio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;
+	public final fun copy (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;)Lio/github/linreal/cascade/editor/markdown/MarkdownDecodeWarning$DroppedAttribute;
+	public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/markdown/MarkdownDecodeWarning$DroppedAttribute;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/markdown/MarkdownDecodeWarning$DroppedAttribute;
+	public fun equals (Ljava/lang/Object;)Z
+	public final fun getAttr ()Ljava/lang/String;
+	public final fun getConstruct ()Ljava/lang/String;
+	public fun getImpact ()Lio/github/linreal/cascade/editor/markdown/MarkdownFidelityImpact;
+	public fun getRange ()Lio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;
+	public final fun getReason ()Ljava/lang/String;
+	public fun hashCode ()I
+	public fun toString ()Ljava/lang/String;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/MarkdownDecodeWarning$DuplicateLinkDefinition : io/github/linreal/cascade/editor/markdown/MarkdownDecodeWarning {
+	public static final field $stable I
+	public fun <init> (Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;)V
+	public final fun component1 ()Ljava/lang/String;
+	public final fun component2 ()Lio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;
+	public final fun copy (Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;)Lio/github/linreal/cascade/editor/markdown/MarkdownDecodeWarning$DuplicateLinkDefinition;
+	public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/markdown/MarkdownDecodeWarning$DuplicateLinkDefinition;Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/markdown/MarkdownDecodeWarning$DuplicateLinkDefinition;
+	public fun equals (Ljava/lang/Object;)Z
+	public fun getImpact ()Lio/github/linreal/cascade/editor/markdown/MarkdownFidelityImpact;
+	public final fun getLabel ()Ljava/lang/String;
+	public fun getRange ()Lio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;
+	public fun hashCode ()I
+	public fun toString ()Ljava/lang/String;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/MarkdownDecodeWarning$EngineFailure : io/github/linreal/cascade/editor/markdown/MarkdownDecodeWarning {
+	public static final field $stable I
+	public fun <init> (Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;)V
+	public synthetic fun <init> (Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;ILkotlin/jvm/internal/DefaultConstructorMarker;)V
+	public final fun component1 ()Ljava/lang/String;
+	public final fun component2 ()Lio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;
+	public final fun copy (Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;)Lio/github/linreal/cascade/editor/markdown/MarkdownDecodeWarning$EngineFailure;
+	public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/markdown/MarkdownDecodeWarning$EngineFailure;Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/markdown/MarkdownDecodeWarning$EngineFailure;
+	public fun equals (Ljava/lang/Object;)Z
+	public fun getImpact ()Lio/github/linreal/cascade/editor/markdown/MarkdownFidelityImpact;
+	public final fun getMessage ()Ljava/lang/String;
+	public fun getRange ()Lio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;
+	public fun hashCode ()I
+	public fun toString ()Ljava/lang/String;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/MarkdownDecodeWarning$HtmlBridged : io/github/linreal/cascade/editor/markdown/MarkdownDecodeWarning {
+	public static final field $stable I
+	public fun <init> (Lio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;)V
+	public final fun component1 ()Lio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;
+	public final fun copy (Lio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;)Lio/github/linreal/cascade/editor/markdown/MarkdownDecodeWarning$HtmlBridged;
+	public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/markdown/MarkdownDecodeWarning$HtmlBridged;Lio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/markdown/MarkdownDecodeWarning$HtmlBridged;
+	public fun equals (Ljava/lang/Object;)Z
+	public fun getImpact ()Lio/github/linreal/cascade/editor/markdown/MarkdownFidelityImpact;
+	public fun getRange ()Lio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;
+	public fun hashCode ()I
+	public fun toString ()Ljava/lang/String;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/MarkdownDecodeWarning$HtmlStripped : io/github/linreal/cascade/editor/markdown/MarkdownDecodeWarning {
+	public static final field $stable I
+	public fun <init> (Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;)V
+	public final fun component1 ()Ljava/lang/String;
+	public final fun component2 ()Lio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;
+	public final fun copy (Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;)Lio/github/linreal/cascade/editor/markdown/MarkdownDecodeWarning$HtmlStripped;
+	public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/markdown/MarkdownDecodeWarning$HtmlStripped;Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/markdown/MarkdownDecodeWarning$HtmlStripped;
+	public fun equals (Ljava/lang/Object;)Z
+	public fun getImpact ()Lio/github/linreal/cascade/editor/markdown/MarkdownFidelityImpact;
+	public fun getRange ()Lio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;
+	public final fun getTag ()Ljava/lang/String;
+	public fun hashCode ()I
+	public fun toString ()Ljava/lang/String;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/MarkdownDecodeWarning$InputLimitExceeded : io/github/linreal/cascade/editor/markdown/MarkdownDecodeWarning {
+	public static final field $stable I
+	public fun <init> (IILio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;)V
+	public synthetic fun <init> (IILio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;ILkotlin/jvm/internal/DefaultConstructorMarker;)V
+	public final fun component1 ()I
+	public final fun component2 ()I
+	public final fun component3 ()Lio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;
+	public final fun copy (IILio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;)Lio/github/linreal/cascade/editor/markdown/MarkdownDecodeWarning$InputLimitExceeded;
+	public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/markdown/MarkdownDecodeWarning$InputLimitExceeded;IILio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/markdown/MarkdownDecodeWarning$InputLimitExceeded;
+	public fun equals (Ljava/lang/Object;)Z
+	public final fun getActual ()I
+	public fun getImpact ()Lio/github/linreal/cascade/editor/markdown/MarkdownFidelityImpact;
+	public final fun getLimit ()I
+	public fun getRange ()Lio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;
+	public fun hashCode ()I
+	public fun toString ()Ljava/lang/String;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/MarkdownDecodeWarning$LimitExceeded : io/github/linreal/cascade/editor/markdown/MarkdownDecodeWarning {
+	public static final field $stable I
+	public fun <init> (Lio/github/linreal/cascade/editor/markdown/MarkdownCodecLimitKind;ILio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;)V
+	public final fun component1 ()Lio/github/linreal/cascade/editor/markdown/MarkdownCodecLimitKind;
+	public final fun component2 ()I
+	public final fun component3 ()Lio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;
+	public final fun copy (Lio/github/linreal/cascade/editor/markdown/MarkdownCodecLimitKind;ILio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;)Lio/github/linreal/cascade/editor/markdown/MarkdownDecodeWarning$LimitExceeded;
+	public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/markdown/MarkdownDecodeWarning$LimitExceeded;Lio/github/linreal/cascade/editor/markdown/MarkdownCodecLimitKind;ILio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/markdown/MarkdownDecodeWarning$LimitExceeded;
+	public fun equals (Ljava/lang/Object;)Z
+	public fun getImpact ()Lio/github/linreal/cascade/editor/markdown/MarkdownFidelityImpact;
+	public final fun getKind ()Lio/github/linreal/cascade/editor/markdown/MarkdownCodecLimitKind;
+	public final fun getLimit ()I
+	public fun getRange ()Lio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;
+	public fun hashCode ()I
+	public fun toString ()Ljava/lang/String;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/MarkdownDecodeWarning$PreservedSyntax : io/github/linreal/cascade/editor/markdown/MarkdownDecodeWarning {
+	public static final field $stable I
+	public fun <init> (Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;)V
+	public final fun component1 ()Ljava/lang/String;
+	public final fun component2 ()Lio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;
+	public final fun copy (Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;)Lio/github/linreal/cascade/editor/markdown/MarkdownDecodeWarning$PreservedSyntax;
+	public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/markdown/MarkdownDecodeWarning$PreservedSyntax;Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/markdown/MarkdownDecodeWarning$PreservedSyntax;
+	public fun equals (Ljava/lang/Object;)Z
+	public fun getImpact ()Lio/github/linreal/cascade/editor/markdown/MarkdownFidelityImpact;
+	public final fun getKind ()Ljava/lang/String;
+	public fun getRange ()Lio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;
+	public fun hashCode ()I
+	public fun toString ()Ljava/lang/String;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/MarkdownDecodeWarning$UnsupportedEntity : io/github/linreal/cascade/editor/markdown/MarkdownDecodeWarning {
+	public static final field $stable I
+	public fun <init> (Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;)V
+	public final fun component1 ()Ljava/lang/String;
+	public final fun component2 ()Lio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;
+	public final fun copy (Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;)Lio/github/linreal/cascade/editor/markdown/MarkdownDecodeWarning$UnsupportedEntity;
+	public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/markdown/MarkdownDecodeWarning$UnsupportedEntity;Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/markdown/MarkdownDecodeWarning$UnsupportedEntity;
+	public fun equals (Ljava/lang/Object;)Z
+	public fun getImpact ()Lio/github/linreal/cascade/editor/markdown/MarkdownFidelityImpact;
+	public final fun getName ()Ljava/lang/String;
+	public fun getRange ()Lio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;
+	public fun hashCode ()I
+	public fun toString ()Ljava/lang/String;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/MarkdownDecodeWarning$UnsupportedSyntax : io/github/linreal/cascade/editor/markdown/MarkdownDecodeWarning {
+	public static final field $stable I
+	public fun <init> (Ljava/lang/String;Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;)V
+	public final fun component1 ()Ljava/lang/String;
+	public final fun component2 ()Ljava/lang/String;
+	public final fun component3 ()Lio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;
+	public final fun copy (Ljava/lang/String;Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;)Lio/github/linreal/cascade/editor/markdown/MarkdownDecodeWarning$UnsupportedSyntax;
+	public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/markdown/MarkdownDecodeWarning$UnsupportedSyntax;Ljava/lang/String;Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/markdown/MarkdownDecodeWarning$UnsupportedSyntax;
+	public fun equals (Ljava/lang/Object;)Z
+	public final fun getConstruct ()Ljava/lang/String;
+	public final fun getDetail ()Ljava/lang/String;
+	public fun getImpact ()Lio/github/linreal/cascade/editor/markdown/MarkdownFidelityImpact;
+	public fun getRange ()Lio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;
+	public fun hashCode ()I
+	public fun toString ()Ljava/lang/String;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/MarkdownEditModeRecommendation : java/lang/Enum {
+	public static final field Native Lio/github/linreal/cascade/editor/markdown/MarkdownEditModeRecommendation;
+	public static final field RawFallback Lio/github/linreal/cascade/editor/markdown/MarkdownEditModeRecommendation;
+	public static fun getEntries ()Lkotlin/enums/EnumEntries;
+	public static fun valueOf (Ljava/lang/String;)Lio/github/linreal/cascade/editor/markdown/MarkdownEditModeRecommendation;
+	public static fun values ()[Lio/github/linreal/cascade/editor/markdown/MarkdownEditModeRecommendation;
+}
+
+public abstract interface class io/github/linreal/cascade/editor/markdown/MarkdownEmit {
+}
+
+public final class io/github/linreal/cascade/editor/markdown/MarkdownEmit$Raw : io/github/linreal/cascade/editor/markdown/MarkdownEmit {
+	public static final field $stable I
+	public fun <init> (Ljava/lang/String;)V
+	public final fun component1 ()Ljava/lang/String;
+	public final fun copy (Ljava/lang/String;)Lio/github/linreal/cascade/editor/markdown/MarkdownEmit$Raw;
+	public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/markdown/MarkdownEmit$Raw;Ljava/lang/String;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/markdown/MarkdownEmit$Raw;
+	public fun equals (Ljava/lang/Object;)Z
+	public final fun getMarkdown ()Ljava/lang/String;
+	public fun hashCode ()I
+	public fun toString ()Ljava/lang/String;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/MarkdownEmit$Skip : io/github/linreal/cascade/editor/markdown/MarkdownEmit {
+	public static final field $stable I
+	public static final field INSTANCE Lio/github/linreal/cascade/editor/markdown/MarkdownEmit$Skip;
+	public fun equals (Ljava/lang/Object;)Z
+	public fun hashCode ()I
+	public fun toString ()Ljava/lang/String;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/MarkdownEmit$Verbatim : io/github/linreal/cascade/editor/markdown/MarkdownEmit {
+	public static final field $stable I
+	public fun <init> (Ljava/lang/String;)V
+	public final fun component1 ()Ljava/lang/String;
+	public final fun copy (Ljava/lang/String;)Lio/github/linreal/cascade/editor/markdown/MarkdownEmit$Verbatim;
+	public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/markdown/MarkdownEmit$Verbatim;Ljava/lang/String;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/markdown/MarkdownEmit$Verbatim;
+	public fun equals (Ljava/lang/Object;)Z
+	public final fun getMarkdown ()Ljava/lang/String;
+	public fun hashCode ()I
+	public fun toString ()Ljava/lang/String;
+}
+
+public abstract class io/github/linreal/cascade/editor/markdown/MarkdownEncodeContext {
+	public static final field $stable I
+	public abstract fun encodeInlineLines (Lio/github/linreal/cascade/editor/core/Block;)Ljava/util/List;
+	public abstract fun encodeTextOnly (Lio/github/linreal/cascade/editor/core/Block;)Ljava/lang/String;
+	public abstract fun prefixLines (Ljava/util/List;Ljava/lang/String;Ljava/lang/String;)Ljava/util/List;
+	public abstract fun warn (Lio/github/linreal/cascade/editor/markdown/MarkdownEncodeWarning;)V
+}
+
+public final class io/github/linreal/cascade/editor/markdown/MarkdownEncodeResult {
+	public static final field $stable I
+	public static final field Companion Lio/github/linreal/cascade/editor/markdown/MarkdownEncodeResult$Companion;
+	public synthetic fun <init> (Lio/github/linreal/cascade/editor/markdown/MarkdownCodecStatus;Ljava/lang/String;Ljava/util/List;Lkotlin/jvm/internal/DefaultConstructorMarker;)V
+	public final fun getMarkdown ()Ljava/lang/String;
+	public final fun getStatus ()Lio/github/linreal/cascade/editor/markdown/MarkdownCodecStatus;
+	public final fun getWarnings ()Ljava/util/List;
+	public final fun isAborted ()Z
+	public final fun isSuccess ()Z
+	public fun toString ()Ljava/lang/String;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/MarkdownEncodeResult$Companion {
+	public final fun aborted (Ljava/util/List;)Lio/github/linreal/cascade/editor/markdown/MarkdownEncodeResult;
+	public final fun success (Ljava/lang/String;Ljava/util/List;)Lio/github/linreal/cascade/editor/markdown/MarkdownEncodeResult;
+	public static synthetic fun success$default (Lio/github/linreal/cascade/editor/markdown/MarkdownEncodeResult$Companion;Ljava/lang/String;Ljava/util/List;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/markdown/MarkdownEncodeResult;
+}
+
+public abstract class io/github/linreal/cascade/editor/markdown/MarkdownEncodeWarning : io/github/linreal/cascade/editor/markdown/MarkdownWarning {
+	public static final field $stable I
+	public abstract fun getBlockId-ticUwL4 ()Ljava/lang/String;
+	public abstract fun getTextRange ()Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/MarkdownEncodeWarning$AmbiguousEmphasis : io/github/linreal/cascade/editor/markdown/MarkdownEncodeWarning {
+	public static final field $stable I
+	public synthetic fun <init> (Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;Lkotlin/jvm/internal/DefaultConstructorMarker;)V
+	public final fun component1-ticUwL4 ()Ljava/lang/String;
+	public final fun component2 ()Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;
+	public final fun copy-421T0j4 (Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;)Lio/github/linreal/cascade/editor/markdown/MarkdownEncodeWarning$AmbiguousEmphasis;
+	public static synthetic fun copy-421T0j4$default (Lio/github/linreal/cascade/editor/markdown/MarkdownEncodeWarning$AmbiguousEmphasis;Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/markdown/MarkdownEncodeWarning$AmbiguousEmphasis;
+	public fun equals (Ljava/lang/Object;)Z
+	public fun getBlockId-ticUwL4 ()Ljava/lang/String;
+	public fun getImpact ()Lio/github/linreal/cascade/editor/markdown/MarkdownFidelityImpact;
+	public fun getTextRange ()Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;
+	public fun hashCode ()I
+	public fun toString ()Ljava/lang/String;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/MarkdownEncodeWarning$DroppedAttribute : io/github/linreal/cascade/editor/markdown/MarkdownEncodeWarning {
+	public static final field $stable I
+	public synthetic fun <init> (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;ILkotlin/jvm/internal/DefaultConstructorMarker;)V
+	public synthetic fun <init> (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;Lkotlin/jvm/internal/DefaultConstructorMarker;)V
+	public final fun component1 ()Ljava/lang/String;
+	public final fun component2 ()Ljava/lang/String;
+	public final fun component3-ticUwL4 ()Ljava/lang/String;
+	public final fun component4 ()Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;
+	public final fun copy-9Un3DiA (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;)Lio/github/linreal/cascade/editor/markdown/MarkdownEncodeWarning$DroppedAttribute;
+	public static synthetic fun copy-9Un3DiA$default (Lio/github/linreal/cascade/editor/markdown/MarkdownEncodeWarning$DroppedAttribute;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/markdown/MarkdownEncodeWarning$DroppedAttribute;
+	public fun equals (Ljava/lang/Object;)Z
+	public final fun getAttr ()Ljava/lang/String;
+	public fun getBlockId-ticUwL4 ()Ljava/lang/String;
+	public fun getImpact ()Lio/github/linreal/cascade/editor/markdown/MarkdownFidelityImpact;
+	public final fun getReason ()Ljava/lang/String;
+	public fun getTextRange ()Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;
+	public fun hashCode ()I
+	public fun toString ()Ljava/lang/String;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/MarkdownEncodeWarning$DroppedSpanOverlap : io/github/linreal/cascade/editor/markdown/MarkdownEncodeWarning {
+	public static final field $stable I
+	public synthetic fun <init> (Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;Ljava/lang/String;Lkotlin/jvm/internal/DefaultConstructorMarker;)V
+	public final fun component1-ticUwL4 ()Ljava/lang/String;
+	public final fun component2 ()Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;
+	public final fun component3 ()Ljava/lang/String;
+	public final fun copy-w7YA71c (Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;Ljava/lang/String;)Lio/github/linreal/cascade/editor/markdown/MarkdownEncodeWarning$DroppedSpanOverlap;
+	public static synthetic fun copy-w7YA71c$default (Lio/github/linreal/cascade/editor/markdown/MarkdownEncodeWarning$DroppedSpanOverlap;Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;Ljava/lang/String;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/markdown/MarkdownEncodeWarning$DroppedSpanOverlap;
+	public fun equals (Ljava/lang/Object;)Z
+	public fun getBlockId-ticUwL4 ()Ljava/lang/String;
+	public fun getImpact ()Lio/github/linreal/cascade/editor/markdown/MarkdownFidelityImpact;
+	public final fun getReason ()Ljava/lang/String;
+	public fun getTextRange ()Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;
+	public fun hashCode ()I
+	public fun toString ()Ljava/lang/String;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/MarkdownEncodeWarning$EncoderException : io/github/linreal/cascade/editor/markdown/MarkdownEncodeWarning {
+	public static final field $stable I
+	public synthetic fun <init> (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;ILkotlin/jvm/internal/DefaultConstructorMarker;)V
+	public synthetic fun <init> (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;Lkotlin/jvm/internal/DefaultConstructorMarker;)V
+	public final fun component1 ()Ljava/lang/String;
+	public final fun component2 ()Ljava/lang/String;
+	public final fun component3-ticUwL4 ()Ljava/lang/String;
+	public final fun component4 ()Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;
+	public final fun copy-9Un3DiA (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;)Lio/github/linreal/cascade/editor/markdown/MarkdownEncodeWarning$EncoderException;
+	public static synthetic fun copy-9Un3DiA$default (Lio/github/linreal/cascade/editor/markdown/MarkdownEncodeWarning$EncoderException;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/markdown/MarkdownEncodeWarning$EncoderException;
+	public fun equals (Ljava/lang/Object;)Z
+	public fun getBlockId-ticUwL4 ()Ljava/lang/String;
+	public fun getImpact ()Lio/github/linreal/cascade/editor/markdown/MarkdownFidelityImpact;
+	public final fun getMessage ()Ljava/lang/String;
+	public fun getTextRange ()Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;
+	public final fun getTypeId ()Ljava/lang/String;
+	public fun hashCode ()I
+	public fun toString ()Ljava/lang/String;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/MarkdownEncodeWarning$EngineFailure : io/github/linreal/cascade/editor/markdown/MarkdownEncodeWarning {
+	public static final field $stable I
+	public synthetic fun <init> (Ljava/lang/String;Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;ILkotlin/jvm/internal/DefaultConstructorMarker;)V
+	public synthetic fun <init> (Ljava/lang/String;Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;Lkotlin/jvm/internal/DefaultConstructorMarker;)V
+	public final fun component1 ()Ljava/lang/String;
+	public final fun component2-ticUwL4 ()Ljava/lang/String;
+	public final fun component3 ()Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;
+	public final fun copy-mf-9-9k (Ljava/lang/String;Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;)Lio/github/linreal/cascade/editor/markdown/MarkdownEncodeWarning$EngineFailure;
+	public static synthetic fun copy-mf-9-9k$default (Lio/github/linreal/cascade/editor/markdown/MarkdownEncodeWarning$EngineFailure;Ljava/lang/String;Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/markdown/MarkdownEncodeWarning$EngineFailure;
+	public fun equals (Ljava/lang/Object;)Z
+	public fun getBlockId-ticUwL4 ()Ljava/lang/String;
+	public fun getImpact ()Lio/github/linreal/cascade/editor/markdown/MarkdownFidelityImpact;
+	public final fun getMessage ()Ljava/lang/String;
+	public fun getTextRange ()Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;
+	public fun hashCode ()I
+	public fun toString ()Ljava/lang/String;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/MarkdownEncodeWarning$LimitExceeded : io/github/linreal/cascade/editor/markdown/MarkdownEncodeWarning {
+	public static final field $stable I
+	public synthetic fun <init> (Lio/github/linreal/cascade/editor/markdown/MarkdownCodecLimitKind;ILjava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;ILkotlin/jvm/internal/DefaultConstructorMarker;)V
+	public synthetic fun <init> (Lio/github/linreal/cascade/editor/markdown/MarkdownCodecLimitKind;ILjava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;Lkotlin/jvm/internal/DefaultConstructorMarker;)V
+	public final fun component1 ()Lio/github/linreal/cascade/editor/markdown/MarkdownCodecLimitKind;
+	public final fun component2 ()I
+	public final fun component3-ticUwL4 ()Ljava/lang/String;
+	public final fun component4 ()Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;
+	public final fun copy-9Un3DiA (Lio/github/linreal/cascade/editor/markdown/MarkdownCodecLimitKind;ILjava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;)Lio/github/linreal/cascade/editor/markdown/MarkdownEncodeWarning$LimitExceeded;
+	public static synthetic fun copy-9Un3DiA$default (Lio/github/linreal/cascade/editor/markdown/MarkdownEncodeWarning$LimitExceeded;Lio/github/linreal/cascade/editor/markdown/MarkdownCodecLimitKind;ILjava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/markdown/MarkdownEncodeWarning$LimitExceeded;
+	public fun equals (Ljava/lang/Object;)Z
+	public fun getBlockId-ticUwL4 ()Ljava/lang/String;
+	public fun getImpact ()Lio/github/linreal/cascade/editor/markdown/MarkdownFidelityImpact;
+	public final fun getKind ()Lio/github/linreal/cascade/editor/markdown/MarkdownCodecLimitKind;
+	public final fun getLimit ()I
+	public fun getTextRange ()Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;
+	public fun hashCode ()I
+	public fun toString ()Ljava/lang/String;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/MarkdownEncodeWarning$OutputLimitExceeded : io/github/linreal/cascade/editor/markdown/MarkdownEncodeWarning {
+	public static final field $stable I
+	public synthetic fun <init> (ILjava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;ILkotlin/jvm/internal/DefaultConstructorMarker;)V
+	public synthetic fun <init> (ILjava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;Lkotlin/jvm/internal/DefaultConstructorMarker;)V
+	public final fun component1 ()I
+	public final fun component2-ticUwL4 ()Ljava/lang/String;
+	public final fun component3 ()Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;
+	public final fun copy-mf-9-9k (ILjava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;)Lio/github/linreal/cascade/editor/markdown/MarkdownEncodeWarning$OutputLimitExceeded;
+	public static synthetic fun copy-mf-9-9k$default (Lio/github/linreal/cascade/editor/markdown/MarkdownEncodeWarning$OutputLimitExceeded;ILjava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/markdown/MarkdownEncodeWarning$OutputLimitExceeded;
+	public fun equals (Ljava/lang/Object;)Z
+	public fun getBlockId-ticUwL4 ()Ljava/lang/String;
+	public fun getImpact ()Lio/github/linreal/cascade/editor/markdown/MarkdownFidelityImpact;
+	public final fun getLimit ()I
+	public fun getTextRange ()Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;
+	public fun hashCode ()I
+	public fun toString ()Ljava/lang/String;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/MarkdownEncodeWarning$UnsupportedBlock : io/github/linreal/cascade/editor/markdown/MarkdownEncodeWarning {
+	public static final field $stable I
+	public synthetic fun <init> (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;ILkotlin/jvm/internal/DefaultConstructorMarker;)V
+	public synthetic fun <init> (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;Lkotlin/jvm/internal/DefaultConstructorMarker;)V
+	public final fun component1 ()Ljava/lang/String;
+	public final fun component2 ()Ljava/lang/String;
+	public final fun component3-ticUwL4 ()Ljava/lang/String;
+	public final fun component4 ()Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;
+	public final fun copy-9Un3DiA (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;)Lio/github/linreal/cascade/editor/markdown/MarkdownEncodeWarning$UnsupportedBlock;
+	public static synthetic fun copy-9Un3DiA$default (Lio/github/linreal/cascade/editor/markdown/MarkdownEncodeWarning$UnsupportedBlock;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/markdown/MarkdownEncodeWarning$UnsupportedBlock;
+	public fun equals (Ljava/lang/Object;)Z
+	public fun getBlockId-ticUwL4 ()Ljava/lang/String;
+	public fun getImpact ()Lio/github/linreal/cascade/editor/markdown/MarkdownFidelityImpact;
+	public final fun getReason ()Ljava/lang/String;
+	public fun getTextRange ()Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;
+	public final fun getTypeId ()Ljava/lang/String;
+	public fun hashCode ()I
+	public fun toString ()Ljava/lang/String;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/MarkdownEncodeWarning$UnsupportedSpan : io/github/linreal/cascade/editor/markdown/MarkdownEncodeWarning {
+	public static final field $stable I
+	public synthetic fun <init> (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;Lkotlin/jvm/internal/DefaultConstructorMarker;)V
+	public final fun component1 ()Ljava/lang/String;
+	public final fun component2 ()Ljava/lang/String;
+	public final fun component3-ticUwL4 ()Ljava/lang/String;
+	public final fun component4 ()Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;
+	public final fun copy-9Un3DiA (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;)Lio/github/linreal/cascade/editor/markdown/MarkdownEncodeWarning$UnsupportedSpan;
+	public static synthetic fun copy-9Un3DiA$default (Lio/github/linreal/cascade/editor/markdown/MarkdownEncodeWarning$UnsupportedSpan;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/markdown/MarkdownEncodeWarning$UnsupportedSpan;
+	public fun equals (Ljava/lang/Object;)Z
+	public fun getBlockId-ticUwL4 ()Ljava/lang/String;
+	public fun getImpact ()Lio/github/linreal/cascade/editor/markdown/MarkdownFidelityImpact;
+	public final fun getReason ()Ljava/lang/String;
+	public fun getTextRange ()Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;
+	public final fun getTypeId ()Ljava/lang/String;
+	public fun hashCode ()I
+	public fun toString ()Ljava/lang/String;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/MarkdownEscapeContext {
+	public static final field $stable I
+	public static final field Companion Lio/github/linreal/cascade/editor/markdown/MarkdownEscapeContext$Companion;
+	public fun <init> (ZLjava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownEscapeTextKind;)V
+	public synthetic fun <init> (ZLjava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownEscapeTextKind;ILkotlin/jvm/internal/DefaultConstructorMarker;)V
+	public final fun component1 ()Z
+	public final fun component2 ()Ljava/lang/String;
+	public final fun component3 ()Lio/github/linreal/cascade/editor/markdown/MarkdownEscapeTextKind;
+	public final fun copy (ZLjava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownEscapeTextKind;)Lio/github/linreal/cascade/editor/markdown/MarkdownEscapeContext;
+	public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/markdown/MarkdownEscapeContext;ZLjava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownEscapeTextKind;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/markdown/MarkdownEscapeContext;
+	public fun equals (Ljava/lang/Object;)Z
+	public final fun getAtLineStart ()Z
+	public final fun getContainerPrefix ()Ljava/lang/String;
+	public final fun getKind ()Lio/github/linreal/cascade/editor/markdown/MarkdownEscapeTextKind;
+	public fun hashCode ()I
+	public fun toString ()Ljava/lang/String;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/MarkdownEscapeContext$Companion {
+	public final fun getLineStart ()Lio/github/linreal/cascade/editor/markdown/MarkdownEscapeContext;
+	public final fun getMidLine ()Lio/github/linreal/cascade/editor/markdown/MarkdownEscapeContext;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/MarkdownEscapeTextKind : java/lang/Enum {
+	public static final field LinkLabel Lio/github/linreal/cascade/editor/markdown/MarkdownEscapeTextKind;
+	public static final field LinkText Lio/github/linreal/cascade/editor/markdown/MarkdownEscapeTextKind;
+	public static final field Plain Lio/github/linreal/cascade/editor/markdown/MarkdownEscapeTextKind;
+	public static fun getEntries ()Lkotlin/enums/EnumEntries;
+	public static fun valueOf (Ljava/lang/String;)Lio/github/linreal/cascade/editor/markdown/MarkdownEscapeTextKind;
+	public static fun values ()[Lio/github/linreal/cascade/editor/markdown/MarkdownEscapeTextKind;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/MarkdownFidelityImpact : java/lang/Enum {
+	public static final field Canonicalization Lio/github/linreal/cascade/editor/markdown/MarkdownFidelityImpact;
+	public static final field DataLoss Lio/github/linreal/cascade/editor/markdown/MarkdownFidelityImpact;
+	public static final field Fatal Lio/github/linreal/cascade/editor/markdown/MarkdownFidelityImpact;
+	public static final field Informational Lio/github/linreal/cascade/editor/markdown/MarkdownFidelityImpact;
+	public static final field OpaquePreservation Lio/github/linreal/cascade/editor/markdown/MarkdownFidelityImpact;
+	public static fun getEntries ()Lkotlin/enums/EnumEntries;
+	public static fun valueOf (Ljava/lang/String;)Lio/github/linreal/cascade/editor/markdown/MarkdownFidelityImpact;
+	public static fun values ()[Lio/github/linreal/cascade/editor/markdown/MarkdownFidelityImpact;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/MarkdownFidelityReport {
+	public static final field $stable I
+	public final fun getDataLossWarnings ()Ljava/util/List;
+	public final fun getDecodeResult ()Lio/github/linreal/cascade/editor/markdown/MarkdownDecodeResult;
+	public final fun getEncodeResult ()Lio/github/linreal/cascade/editor/markdown/MarkdownEncodeResult;
+	public final fun getNativeEditingSafe ()Z
+	public final fun getPreservedBlockCount ()I
+	public final fun getRecommendedMode ()Lio/github/linreal/cascade/editor/markdown/MarkdownEditModeRecommendation;
+	public final fun getWouldRewriteSource ()Ljava/lang/Boolean;
+	public fun toString ()Ljava/lang/String;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/MarkdownLineEnding : java/lang/Enum {
+	public static final field CrLf Lio/github/linreal/cascade/editor/markdown/MarkdownLineEnding;
+	public static final field Lf Lio/github/linreal/cascade/editor/markdown/MarkdownLineEnding;
+	public static fun getEntries ()Lkotlin/enums/EnumEntries;
+	public static fun valueOf (Ljava/lang/String;)Lio/github/linreal/cascade/editor/markdown/MarkdownLineEnding;
+	public static fun values ()[Lio/github/linreal/cascade/editor/markdown/MarkdownLineEnding;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/MarkdownMarkPair {
+	public static final field $stable I
+	public fun <init> (Ljava/lang/String;Ljava/lang/String;)V
+	public final fun component1 ()Ljava/lang/String;
+	public final fun component2 ()Ljava/lang/String;
+	public final fun copy (Ljava/lang/String;Ljava/lang/String;)Lio/github/linreal/cascade/editor/markdown/MarkdownMarkPair;
+	public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/markdown/MarkdownMarkPair;Ljava/lang/String;Ljava/lang/String;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/markdown/MarkdownMarkPair;
+	public fun equals (Ljava/lang/Object;)Z
+	public final fun getClose ()Ljava/lang/String;
+	public final fun getOpen ()Ljava/lang/String;
+	public fun hashCode ()I
+	public fun toString ()Ljava/lang/String;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/MarkdownProfile {
+	public static final field $stable I
+	public static final field Companion Lio/github/linreal/cascade/editor/markdown/MarkdownProfile$Companion;
+	public final fun getSupportSet ()Lio/github/linreal/cascade/editor/markdown/MarkdownProfileSupportSet;
+	public final fun withCustomMarkdownBlockEncoder (Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownBlockEncoder;)Lio/github/linreal/cascade/editor/markdown/MarkdownProfile;
+	public final fun withCustomMarkdownSpanEncoder (Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownSpanEncoder;)Lio/github/linreal/cascade/editor/markdown/MarkdownProfile;
+	public final fun withEncoderBlockFallback (Lio/github/linreal/cascade/editor/markdown/MarkdownBlockEncoder;)Lio/github/linreal/cascade/editor/markdown/MarkdownProfile;
+	public final fun withEncoderSpanFallback (Lio/github/linreal/cascade/editor/markdown/MarkdownSpanEncoder;)Lio/github/linreal/cascade/editor/markdown/MarkdownProfile;
+	public final fun withEntityDecode (Lio/github/linreal/cascade/editor/markdown/EntityDecode;)Lio/github/linreal/cascade/editor/markdown/MarkdownProfile;
+	public final fun withHardBreakEncode (Lio/github/linreal/cascade/editor/markdown/HardBreakEncode;)Lio/github/linreal/cascade/editor/markdown/MarkdownProfile;
+	public final fun withHtmlInMarkdown (Lio/github/linreal/cascade/editor/markdown/HtmlInMarkdown;)Lio/github/linreal/cascade/editor/markdown/MarkdownProfile;
+	public final fun withMarkdownBlockEncoderInternal (Lkotlin/reflect/KClass;Lio/github/linreal/cascade/editor/markdown/MarkdownBlockEncoder;)Lio/github/linreal/cascade/editor/markdown/MarkdownProfile;
+	public final fun withMarkdownBlockGroupEncoder (Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownBlockGroupEncoder;)Lio/github/linreal/cascade/editor/markdown/MarkdownProfile;
+	public final fun withMarkdownSpanEncoderInternal (Lkotlin/reflect/KClass;Lio/github/linreal/cascade/editor/markdown/MarkdownSpanEncoder;)Lio/github/linreal/cascade/editor/markdown/MarkdownProfile;
+	public final fun withNewlineSemantics (Lio/github/linreal/cascade/editor/markdown/NewlineSemantics;)Lio/github/linreal/cascade/editor/markdown/MarkdownProfile;
+	public final fun withSoftBreak (Lio/github/linreal/cascade/editor/markdown/SoftBreak;)Lio/github/linreal/cascade/editor/markdown/MarkdownProfile;
+	public final fun withSupportSet (Lio/github/linreal/cascade/editor/markdown/MarkdownProfileSupportSet;)Lio/github/linreal/cascade/editor/markdown/MarkdownProfile;
+	public final fun withUnsupportedSyntax (Lio/github/linreal/cascade/editor/markdown/UnsupportedSyntax;)Lio/github/linreal/cascade/editor/markdown/MarkdownProfile;
+	public final fun withoutHtmlBridge ()Lio/github/linreal/cascade/editor/markdown/MarkdownProfile;
+	public final fun withoutMarkdownBlockGroupEncoder (Ljava/lang/String;)Lio/github/linreal/cascade/editor/markdown/MarkdownProfile;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/MarkdownProfile$Companion {
+	public final fun getDefault ()Lio/github/linreal/cascade/editor/markdown/MarkdownProfile;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/MarkdownProfileSupportSet {
+	public static final field $stable I
+	public static final field Companion Lio/github/linreal/cascade/editor/markdown/MarkdownProfileSupportSet$Companion;
+	public fun <init> (Lkotlin/jvm/functions/Function1;Lkotlin/jvm/functions/Function1;Lkotlin/jvm/functions/Function1;)V
+	public final fun getSupportsBlockPredicate ()Lkotlin/jvm/functions/Function1;
+	public final fun getSupportsDocumentPredicate ()Lkotlin/jvm/functions/Function1;
+	public final fun getSupportsSpanPredicate ()Lkotlin/jvm/functions/Function1;
+	public final fun supportsBlock (Lio/github/linreal/cascade/editor/core/Block;)Z
+	public final fun supportsDocument (Ljava/util/List;)Z
+	public final fun supportsSpan (Lio/github/linreal/cascade/editor/core/SpanStyle;)Z
+}
+
+public final class io/github/linreal/cascade/editor/markdown/MarkdownProfileSupportSet$Companion {
+	public final fun getNone ()Lio/github/linreal/cascade/editor/markdown/MarkdownProfileSupportSet;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/MarkdownSchema {
+	public static final field $stable I
+	public static final field INSTANCE Lio/github/linreal/cascade/editor/markdown/MarkdownSchema;
+	public final fun analyze (Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownProfile;Lio/github/linreal/cascade/editor/markdown/MarkdownCodecLimits;)Lio/github/linreal/cascade/editor/markdown/MarkdownFidelityReport;
+	public static synthetic fun analyze$default (Lio/github/linreal/cascade/editor/markdown/MarkdownSchema;Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownProfile;Lio/github/linreal/cascade/editor/markdown/MarkdownCodecLimits;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/markdown/MarkdownFidelityReport;
+	public final fun decode (Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownProfile;Lio/github/linreal/cascade/editor/markdown/MarkdownCodecLimits;)Ljava/util/List;
+	public static synthetic fun decode$default (Lio/github/linreal/cascade/editor/markdown/MarkdownSchema;Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownProfile;Lio/github/linreal/cascade/editor/markdown/MarkdownCodecLimits;ILjava/lang/Object;)Ljava/util/List;
+	public final fun decodeWithReport (Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownProfile;Lio/github/linreal/cascade/editor/markdown/MarkdownCodecLimits;)Lio/github/linreal/cascade/editor/markdown/MarkdownDecodeResult;
+	public static synthetic fun decodeWithReport$default (Lio/github/linreal/cascade/editor/markdown/MarkdownSchema;Ljava/lang/String;Lio/github/linreal/cascade/editor/markdown/MarkdownProfile;Lio/github/linreal/cascade/editor/markdown/MarkdownCodecLimits;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/markdown/MarkdownDecodeResult;
+	public final fun encode (Ljava/util/List;Lio/github/linreal/cascade/editor/markdown/MarkdownProfile;Lio/github/linreal/cascade/editor/markdown/MarkdownCodecLimits;Lio/github/linreal/cascade/editor/markdown/MarkdownLineEnding;)Ljava/lang/String;
+	public static synthetic fun encode$default (Lio/github/linreal/cascade/editor/markdown/MarkdownSchema;Ljava/util/List;Lio/github/linreal/cascade/editor/markdown/MarkdownProfile;Lio/github/linreal/cascade/editor/markdown/MarkdownCodecLimits;Lio/github/linreal/cascade/editor/markdown/MarkdownLineEnding;ILjava/lang/Object;)Ljava/lang/String;
+	public final fun encodeWithReport (Ljava/util/List;Lio/github/linreal/cascade/editor/markdown/MarkdownProfile;Lio/github/linreal/cascade/editor/markdown/MarkdownCodecLimits;Lio/github/linreal/cascade/editor/markdown/MarkdownLineEnding;)Lio/github/linreal/cascade/editor/markdown/MarkdownEncodeResult;
+	public static synthetic fun encodeWithReport$default (Lio/github/linreal/cascade/editor/markdown/MarkdownSchema;Ljava/util/List;Lio/github/linreal/cascade/editor/markdown/MarkdownProfile;Lio/github/linreal/cascade/editor/markdown/MarkdownCodecLimits;Lio/github/linreal/cascade/editor/markdown/MarkdownLineEnding;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/markdown/MarkdownEncodeResult;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/MarkdownSerializationExtKt {
+	public static final fun applyMarkdownDecodeResult (Lio/github/linreal/cascade/editor/state/EditorStateHolder;Lio/github/linreal/cascade/editor/markdown/MarkdownDecodeResult;Lio/github/linreal/cascade/editor/state/BlockTextStates;Lio/github/linreal/cascade/editor/state/BlockSpanStates;)V
+	public static final fun loadFromMarkdown (Lio/github/linreal/cascade/editor/state/EditorStateHolder;Ljava/lang/String;Lio/github/linreal/cascade/editor/state/BlockTextStates;Lio/github/linreal/cascade/editor/state/BlockSpanStates;Lio/github/linreal/cascade/editor/markdown/MarkdownProfile;Lio/github/linreal/cascade/editor/markdown/MarkdownCodecLimits;)Lio/github/linreal/cascade/editor/markdown/MarkdownDecodeResult;
+	public static synthetic fun loadFromMarkdown$default (Lio/github/linreal/cascade/editor/state/EditorStateHolder;Ljava/lang/String;Lio/github/linreal/cascade/editor/state/BlockTextStates;Lio/github/linreal/cascade/editor/state/BlockSpanStates;Lio/github/linreal/cascade/editor/markdown/MarkdownProfile;Lio/github/linreal/cascade/editor/markdown/MarkdownCodecLimits;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/markdown/MarkdownDecodeResult;
+	public static final fun toMarkdown (Lio/github/linreal/cascade/editor/state/EditorStateHolder;Lio/github/linreal/cascade/editor/state/BlockTextStates;Lio/github/linreal/cascade/editor/state/BlockSpanStates;Lio/github/linreal/cascade/editor/markdown/MarkdownProfile;Lio/github/linreal/cascade/editor/markdown/MarkdownCodecLimits;Lio/github/linreal/cascade/editor/markdown/MarkdownLineEnding;)Ljava/lang/String;
+	public static synthetic fun toMarkdown$default (Lio/github/linreal/cascade/editor/state/EditorStateHolder;Lio/github/linreal/cascade/editor/state/BlockTextStates;Lio/github/linreal/cascade/editor/state/BlockSpanStates;Lio/github/linreal/cascade/editor/markdown/MarkdownProfile;Lio/github/linreal/cascade/editor/markdown/MarkdownCodecLimits;Lio/github/linreal/cascade/editor/markdown/MarkdownLineEnding;ILjava/lang/Object;)Ljava/lang/String;
+	public static final fun toMarkdownWithReport (Lio/github/linreal/cascade/editor/state/EditorStateHolder;Lio/github/linreal/cascade/editor/state/BlockTextStates;Lio/github/linreal/cascade/editor/state/BlockSpanStates;Lio/github/linreal/cascade/editor/markdown/MarkdownProfile;Lio/github/linreal/cascade/editor/markdown/MarkdownCodecLimits;Lio/github/linreal/cascade/editor/markdown/MarkdownLineEnding;)Lio/github/linreal/cascade/editor/markdown/MarkdownEncodeResult;
+	public static synthetic fun toMarkdownWithReport$default (Lio/github/linreal/cascade/editor/state/EditorStateHolder;Lio/github/linreal/cascade/editor/state/BlockTextStates;Lio/github/linreal/cascade/editor/state/BlockSpanStates;Lio/github/linreal/cascade/editor/markdown/MarkdownProfile;Lio/github/linreal/cascade/editor/markdown/MarkdownCodecLimits;Lio/github/linreal/cascade/editor/markdown/MarkdownLineEnding;ILjava/lang/Object;)Lio/github/linreal/cascade/editor/markdown/MarkdownEncodeResult;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/MarkdownSourceLocation {
+	public static final field $stable I
+	public fun <init> (II)V
+	public final fun component1 ()I
+	public final fun component2 ()I
+	public final fun copy (II)Lio/github/linreal/cascade/editor/markdown/MarkdownSourceLocation;
+	public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/markdown/MarkdownSourceLocation;IIILjava/lang/Object;)Lio/github/linreal/cascade/editor/markdown/MarkdownSourceLocation;
+	public fun equals (Ljava/lang/Object;)Z
+	public final fun getColumn ()I
+	public final fun getLine ()I
+	public fun hashCode ()I
+	public fun toString ()Ljava/lang/String;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/MarkdownSourceLocator {
+	public static final field $stable I
+	public final fun locate (I)Lio/github/linreal/cascade/editor/markdown/MarkdownSourceLocation;
+	public final fun locate (Lio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;)Lio/github/linreal/cascade/editor/markdown/MarkdownSourceLocation;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/MarkdownSourceRange {
+	public static final field $stable I
+	public fun <init> (II)V
+	public final fun component1 ()I
+	public final fun component2 ()I
+	public final fun copy (II)Lio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;
+	public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;IIILjava/lang/Object;)Lio/github/linreal/cascade/editor/markdown/MarkdownSourceRange;
+	public fun equals (Ljava/lang/Object;)Z
+	public final fun getEndExclusive ()I
+	public final fun getLength ()I
+	public final fun getStart ()I
+	public fun hashCode ()I
+	public final fun isEmpty ()Z
+	public fun toString ()Ljava/lang/String;
+}
+
+public abstract interface class io/github/linreal/cascade/editor/markdown/MarkdownSpanEncoder {
+	public abstract fun encode (Lio/github/linreal/cascade/editor/core/SpanStyle;)Lio/github/linreal/cascade/editor/markdown/MarkdownMarkPair;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/MarkdownTextRange {
+	public static final field $stable I
+	public fun <init> (II)V
+	public final fun component1 ()I
+	public final fun component2 ()I
+	public final fun copy (II)Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;
+	public static synthetic fun copy$default (Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;IIILjava/lang/Object;)Lio/github/linreal/cascade/editor/markdown/MarkdownTextRange;
+	public fun equals (Ljava/lang/Object;)Z
+	public final fun getEndExclusive ()I
+	public final fun getStart ()I
+	public fun hashCode ()I
+	public fun toString ()Ljava/lang/String;
+}
+
+public abstract interface class io/github/linreal/cascade/editor/markdown/MarkdownWarning {
+	public abstract fun getImpact ()Lio/github/linreal/cascade/editor/markdown/MarkdownFidelityImpact;
+}
+
+public abstract interface class io/github/linreal/cascade/editor/markdown/NewlineSemantics {
+}
+
+public final class io/github/linreal/cascade/editor/markdown/NewlineSemantics$CommonMark : io/github/linreal/cascade/editor/markdown/NewlineSemantics {
+	public static final field $stable I
+	public static final field INSTANCE Lio/github/linreal/cascade/editor/markdown/NewlineSemantics$CommonMark;
+	public fun equals (Ljava/lang/Object;)Z
+	public fun hashCode ()I
+	public fun toString ()Ljava/lang/String;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/NewlineSemantics$HardBreak : io/github/linreal/cascade/editor/markdown/NewlineSemantics {
+	public static final field $stable I
+	public static final field INSTANCE Lio/github/linreal/cascade/editor/markdown/NewlineSemantics$HardBreak;
+	public fun equals (Ljava/lang/Object;)Z
+	public fun hashCode ()I
+	public fun toString ()Ljava/lang/String;
+}
+
+public abstract interface class io/github/linreal/cascade/editor/markdown/SoftBreak {
+}
+
+public final class io/github/linreal/cascade/editor/markdown/SoftBreak$LineBreak : io/github/linreal/cascade/editor/markdown/SoftBreak {
+	public static final field $stable I
+	public static final field INSTANCE Lio/github/linreal/cascade/editor/markdown/SoftBreak$LineBreak;
+	public fun equals (Ljava/lang/Object;)Z
+	public fun hashCode ()I
+	public fun toString ()Ljava/lang/String;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/SoftBreak$Space : io/github/linreal/cascade/editor/markdown/SoftBreak {
+	public static final field $stable I
+	public static final field INSTANCE Lio/github/linreal/cascade/editor/markdown/SoftBreak$Space;
+	public fun equals (Ljava/lang/Object;)Z
+	public fun hashCode ()I
+	public fun toString ()Ljava/lang/String;
+}
+
+public abstract interface class io/github/linreal/cascade/editor/markdown/UnsupportedSyntax {
+}
+
+public final class io/github/linreal/cascade/editor/markdown/UnsupportedSyntax$Preserve : io/github/linreal/cascade/editor/markdown/UnsupportedSyntax {
+	public static final field $stable I
+	public static final field INSTANCE Lio/github/linreal/cascade/editor/markdown/UnsupportedSyntax$Preserve;
+	public fun equals (Ljava/lang/Object;)Z
+	public fun hashCode ()I
+	public fun toString ()Ljava/lang/String;
+}
+
+public final class io/github/linreal/cascade/editor/markdown/UnsupportedSyntax$WarnAndDegrade : io/github/linreal/cascade/editor/markdown/UnsupportedSyntax {
+	public static final field $stable I
+	public static final field INSTANCE Lio/github/linreal/cascade/editor/markdown/UnsupportedSyntax$WarnAndDegrade;
+	public fun equals (Ljava/lang/Object;)Z
+	public fun hashCode ()I
+	public fun toString ()Ljava/lang/String;
+}
+
 public abstract interface class io/github/linreal/cascade/editor/registry/BlockCallbacks {
 	public abstract fun dispatch (Lio/github/linreal/cascade/editor/action/EditorAction;)V
 	public abstract fun onBackspaceAtStart-SDe6QqM (Ljava/lang/String;)V
@@ -1820,6 +2688,7 @@ public final class io/github/linreal/cascade/editor/richtext/LinkUrlPolicy {
 	public static final field $stable I
 	public static final field INSTANCE Lio/github/linreal/cascade/editor/richtext/LinkUrlPolicy;
 	public final fun validate (Ljava/lang/String;)Lio/github/linreal/cascade/editor/richtext/LinkValidationResult;
+	public final fun validateStoredTarget (Ljava/lang/String;)Lio/github/linreal/cascade/editor/richtext/LinkValidationResult;
 }
 
 public final class io/github/linreal/cascade/editor/richtext/LinkValidationError : java/lang/Enum {
diff --git a/editor/api/editor.klib.api b/editor/api/editor.klib.api
index 94c75e8..9bde8d0 100644
--- a/editor/api/editor.klib.api
+++ b/editor/api/editor.klib.api
@@ -10,6 +10,85 @@ open annotation class io.github.linreal.cascade.editor.htmlserialization/Experim
     constructor <init>() // io.github.linreal.cascade.editor.htmlserialization/ExperimentalCascadeHtmlApi.<init>|<init>(){}[0]
 }
 
+open annotation class io.github.linreal.cascade.editor.markdown/ExperimentalCascadeMarkdownApi : kotlin/Annotation { // io.github.linreal.cascade.editor.markdown/ExperimentalCascadeMarkdownApi|null[0]
+    constructor <init>() // io.github.linreal.cascade.editor.markdown/ExperimentalCascadeMarkdownApi.<init>|<init>(){}[0]
+}
+
+final enum class io.github.linreal.cascade.editor.markdown/MarkdownCodecLimitKind : kotlin/Enum<io.github.linreal.cascade.editor.markdown/MarkdownCodecLimitKind> { // io.github.linreal.cascade.editor.markdown/MarkdownCodecLimitKind|null[0]
+    enum entry BlockNesting // io.github.linreal.cascade.editor.markdown/MarkdownCodecLimitKind.BlockNesting|null[0]
+    enum entry Blocks // io.github.linreal.cascade.editor.markdown/MarkdownCodecLimitKind.Blocks|null[0]
+    enum entry DelimiterRuns // io.github.linreal.cascade.editor.markdown/MarkdownCodecLimitKind.DelimiterRuns|null[0]
+    enum entry ReferenceDefinitions // io.github.linreal.cascade.editor.markdown/MarkdownCodecLimitKind.ReferenceDefinitions|null[0]
+    enum entry SpansPerBlock // io.github.linreal.cascade.editor.markdown/MarkdownCodecLimitKind.SpansPerBlock|null[0]
+    enum entry TotalSpans // io.github.linreal.cascade.editor.markdown/MarkdownCodecLimitKind.TotalSpans|null[0]
+    enum entry Warnings // io.github.linreal.cascade.editor.markdown/MarkdownCodecLimitKind.Warnings|null[0]
+
+    final val entries // io.github.linreal.cascade.editor.markdown/MarkdownCodecLimitKind.entries|#static{}entries[0]
+        final fun <get-entries>(): kotlin.enums/EnumEntries<io.github.linreal.cascade.editor.markdown/MarkdownCodecLimitKind> // io.github.linreal.cascade.editor.markdown/MarkdownCodecLimitKind.entries.<get-entries>|<get-entries>#static(){}[0]
+
+    final fun valueOf(kotlin/String): io.github.linreal.cascade.editor.markdown/MarkdownCodecLimitKind // io.github.linreal.cascade.editor.markdown/MarkdownCodecLimitKind.valueOf|valueOf#static(kotlin.String){}[0]
+    final fun values(): kotlin/Array<io.github.linreal.cascade.editor.markdown/MarkdownCodecLimitKind> // io.github.linreal.cascade.editor.markdown/MarkdownCodecLimitKind.values|values#static(){}[0]
+}
+
+final enum class io.github.linreal.cascade.editor.markdown/MarkdownCodecStatus : kotlin/Enum<io.github.linreal.cascade.editor.markdown/MarkdownCodecStatus> { // io.github.linreal.cascade.editor.markdown/MarkdownCodecStatus|null[0]
+    enum entry Aborted // io.github.linreal.cascade.editor.markdown/MarkdownCodecStatus.Aborted|null[0]
+    enum entry Success // io.github.linreal.cascade.editor.markdown/MarkdownCodecStatus.Success|null[0]
+
+    final val entries // io.github.linreal.cascade.editor.markdown/MarkdownCodecStatus.entries|#static{}entries[0]
+        final fun <get-entries>(): kotlin.enums/EnumEntries<io.github.linreal.cascade.editor.markdown/MarkdownCodecStatus> // io.github.linreal.cascade.editor.markdown/MarkdownCodecStatus.entries.<get-entries>|<get-entries>#static(){}[0]
+
+    final fun valueOf(kotlin/String): io.github.linreal.cascade.editor.markdown/MarkdownCodecStatus // io.github.linreal.cascade.editor.markdown/MarkdownCodecStatus.valueOf|valueOf#static(kotlin.String){}[0]
+    final fun values(): kotlin/Array<io.github.linreal.cascade.editor.markdown/MarkdownCodecStatus> // io.github.linreal.cascade.editor.markdown/MarkdownCodecStatus.values|values#static(){}[0]
+}
+
+final enum class io.github.linreal.cascade.editor.markdown/MarkdownEditModeRecommendation : kotlin/Enum<io.github.linreal.cascade.editor.markdown/MarkdownEditModeRecommendation> { // io.github.linreal.cascade.editor.markdown/MarkdownEditModeRecommendation|null[0]
+    enum entry Native // io.github.linreal.cascade.editor.markdown/MarkdownEditModeRecommendation.Native|null[0]
+    enum entry RawFallback // io.github.linreal.cascade.editor.markdown/MarkdownEditModeRecommendation.RawFallback|null[0]
+
+    final val entries // io.github.linreal.cascade.editor.markdown/MarkdownEditModeRecommendation.entries|#static{}entries[0]
+        final fun <get-entries>(): kotlin.enums/EnumEntries<io.github.linreal.cascade.editor.markdown/MarkdownEditModeRecommendation> // io.github.linreal.cascade.editor.markdown/MarkdownEditModeRecommendation.entries.<get-entries>|<get-entries>#static(){}[0]
+
+    final fun valueOf(kotlin/String): io.github.linreal.cascade.editor.markdown/MarkdownEditModeRecommendation // io.github.linreal.cascade.editor.markdown/MarkdownEditModeRecommendation.valueOf|valueOf#static(kotlin.String){}[0]
+    final fun values(): kotlin/Array<io.github.linreal.cascade.editor.markdown/MarkdownEditModeRecommendation> // io.github.linreal.cascade.editor.markdown/MarkdownEditModeRecommendation.values|values#static(){}[0]
+}
+
+final enum class io.github.linreal.cascade.editor.markdown/MarkdownEscapeTextKind : kotlin/Enum<io.github.linreal.cascade.editor.markdown/MarkdownEscapeTextKind> { // io.github.linreal.cascade.editor.markdown/MarkdownEscapeTextKind|null[0]
+    enum entry LinkLabel // io.github.linreal.cascade.editor.markdown/MarkdownEscapeTextKind.LinkLabel|null[0]
+    enum entry LinkText // io.github.linreal.cascade.editor.markdown/MarkdownEscapeTextKind.LinkText|null[0]
+    enum entry Plain // io.github.linreal.cascade.editor.markdown/MarkdownEscapeTextKind.Plain|null[0]
+
+    final val entries // io.github.linreal.cascade.editor.markdown/MarkdownEscapeTextKind.entries|#static{}entries[0]
+        final fun <get-entries>(): kotlin.enums/EnumEntries<io.github.linreal.cascade.editor.markdown/MarkdownEscapeTextKind> // io.github.linreal.cascade.editor.markdown/MarkdownEscapeTextKind.entries.<get-entries>|<get-entries>#static(){}[0]
+
+    final fun valueOf(kotlin/String): io.github.linreal.cascade.editor.markdown/MarkdownEscapeTextKind // io.github.linreal.cascade.editor.markdown/MarkdownEscapeTextKind.valueOf|valueOf#static(kotlin.String){}[0]
+    final fun values(): kotlin/Array<io.github.linreal.cascade.editor.markdown/MarkdownEscapeTextKind> // io.github.linreal.cascade.editor.markdown/MarkdownEscapeTextKind.values|values#static(){}[0]
+}
+
+final enum class io.github.linreal.cascade.editor.markdown/MarkdownFidelityImpact : kotlin/Enum<io.github.linreal.cascade.editor.markdown/MarkdownFidelityImpact> { // io.github.linreal.cascade.editor.markdown/MarkdownFidelityImpact|null[0]
+    enum entry Canonicalization // io.github.linreal.cascade.editor.markdown/MarkdownFidelityImpact.Canonicalization|null[0]
+    enum entry DataLoss // io.github.linreal.cascade.editor.markdown/MarkdownFidelityImpact.DataLoss|null[0]
+    enum entry Fatal // io.github.linreal.cascade.editor.markdown/MarkdownFidelityImpact.Fatal|null[0]
+    enum entry Informational // io.github.linreal.cascade.editor.markdown/MarkdownFidelityImpact.Informational|null[0]
+    enum entry OpaquePreservation // io.github.linreal.cascade.editor.markdown/MarkdownFidelityImpact.OpaquePreservation|null[0]
+
+    final val entries // io.github.linreal.cascade.editor.markdown/MarkdownFidelityImpact.entries|#static{}entries[0]
+        final fun <get-entries>(): kotlin.enums/EnumEntries<io.github.linreal.cascade.editor.markdown/MarkdownFidelityImpact> // io.github.linreal.cascade.editor.markdown/MarkdownFidelityImpact.entries.<get-entries>|<get-entries>#static(){}[0]
+
+    final fun valueOf(kotlin/String): io.github.linreal.cascade.editor.markdown/MarkdownFidelityImpact // io.github.linreal.cascade.editor.markdown/MarkdownFidelityImpact.valueOf|valueOf#static(kotlin.String){}[0]
+    final fun values(): kotlin/Array<io.github.linreal.cascade.editor.markdown/MarkdownFidelityImpact> // io.github.linreal.cascade.editor.markdown/MarkdownFidelityImpact.values|values#static(){}[0]
+}
+
+final enum class io.github.linreal.cascade.editor.markdown/MarkdownLineEnding : kotlin/Enum<io.github.linreal.cascade.editor.markdown/MarkdownLineEnding> { // io.github.linreal.cascade.editor.markdown/MarkdownLineEnding|null[0]
+    enum entry CrLf // io.github.linreal.cascade.editor.markdown/MarkdownLineEnding.CrLf|null[0]
+    enum entry Lf // io.github.linreal.cascade.editor.markdown/MarkdownLineEnding.Lf|null[0]
+
+    final val entries // io.github.linreal.cascade.editor.markdown/MarkdownLineEnding.entries|#static{}entries[0]
+        final fun <get-entries>(): kotlin.enums/EnumEntries<io.github.linreal.cascade.editor.markdown/MarkdownLineEnding> // io.github.linreal.cascade.editor.markdown/MarkdownLineEnding.entries.<get-entries>|<get-entries>#static(){}[0]
+
+    final fun valueOf(kotlin/String): io.github.linreal.cascade.editor.markdown/MarkdownLineEnding // io.github.linreal.cascade.editor.markdown/MarkdownLineEnding.valueOf|valueOf#static(kotlin.String){}[0]
+    final fun values(): kotlin/Array<io.github.linreal.cascade.editor.markdown/MarkdownLineEnding> // io.github.linreal.cascade.editor.markdown/MarkdownLineEnding.values|values#static(){}[0]
+}
+
 final enum class io.github.linreal.cascade.editor.richtext/LinkValidationError : kotlin/Enum<io.github.linreal.cascade.editor.richtext/LinkValidationError> { // io.github.linreal.cascade.editor.richtext/LinkValidationError|null[0]
     enum entry Blank // io.github.linreal.cascade.editor.richtext/LinkValidationError.Blank|null[0]
 
@@ -91,10 +170,18 @@ abstract fun interface <#A: io.github.linreal.cascade.editor.core/BlockType> io.
     abstract fun encode(io.github.linreal.cascade.editor.htmlserialization/HtmlEncodeContext, io.github.linreal.cascade.editor.core/Block, io.github.linreal.cascade.editor.core/BlockContent): io.github.linreal.cascade.editor.htmlserialization/HtmlEmit // io.github.linreal.cascade.editor.htmlserialization/BlockEncoder.encode|encode(io.github.linreal.cascade.editor.htmlserialization.HtmlEncodeContext;io.github.linreal.cascade.editor.core.Block;io.github.linreal.cascade.editor.core.BlockContent){}[0]
 }
 
+abstract fun interface <#A: io.github.linreal.cascade.editor.core/BlockType> io.github.linreal.cascade.editor.markdown/MarkdownBlockEncoder { // io.github.linreal.cascade.editor.markdown/MarkdownBlockEncoder|null[0]
+    abstract fun encode(io.github.linreal.cascade.editor.markdown/MarkdownEncodeContext, io.github.linreal.cascade.editor.core/Block, io.github.linreal.cascade.editor.core/BlockContent): io.github.linreal.cascade.editor.markdown/MarkdownEmit // io.github.linreal.cascade.editor.markdown/MarkdownBlockEncoder.encode|encode(io.github.linreal.cascade.editor.markdown.MarkdownEncodeContext;io.github.linreal.cascade.editor.core.Block;io.github.linreal.cascade.editor.core.BlockContent){}[0]
+}
+
 abstract fun interface <#A: io.github.linreal.cascade.editor.core/SpanStyle> io.github.linreal.cascade.editor.htmlserialization/SpanEncoder { // io.github.linreal.cascade.editor.htmlserialization/SpanEncoder|null[0]
     abstract fun encode(#A): io.github.linreal.cascade.editor.htmlserialization/HtmlTagPair // io.github.linreal.cascade.editor.htmlserialization/SpanEncoder.encode|encode(1:0){}[0]
 }
 
+abstract fun interface <#A: io.github.linreal.cascade.editor.core/SpanStyle> io.github.linreal.cascade.editor.markdown/MarkdownSpanEncoder { // io.github.linreal.cascade.editor.markdown/MarkdownSpanEncoder|null[0]
+    abstract fun encode(#A): io.github.linreal.cascade.editor.markdown/MarkdownMarkPair // io.github.linreal.cascade.editor.markdown/MarkdownSpanEncoder.encode|encode(1:0){}[0]
+}
+
 abstract fun interface io.github.linreal.cascade.editor.htmlserialization/TagDecoder { // io.github.linreal.cascade.editor.htmlserialization/TagDecoder|null[0]
     abstract fun decode(io.github.linreal.cascade.editor.htmlserialization/TagDecodeContext, kotlin.collections/Map<kotlin/String, kotlin/String>, kotlin.collections/List<io.github.linreal.cascade.editor.htmlserialization/HtmlNodeView>): io.github.linreal.cascade.editor.htmlserialization/TagDecodeResult // io.github.linreal.cascade.editor.htmlserialization/TagDecoder.decode|decode(io.github.linreal.cascade.editor.htmlserialization.TagDecodeContext;kotlin.collections.Map<kotlin.String,kotlin.String>;kotlin.collections.List<io.github.linreal.cascade.editor.htmlserialization.HtmlNodeView>){}[0]
 }
@@ -125,6 +212,11 @@ abstract interface io.github.linreal.cascade.editor.indentation/IndentationActio
     abstract fun indentForward() // io.github.linreal.cascade.editor.indentation/IndentationActions.indentForward|indentForward(){}[0]
 }
 
+abstract interface io.github.linreal.cascade.editor.markdown/MarkdownBlockGroupEncoder { // io.github.linreal.cascade.editor.markdown/MarkdownBlockGroupEncoder|null[0]
+    abstract fun encodeGroup(io.github.linreal.cascade.editor.markdown/MarkdownEncodeContext, kotlin.collections/List<io.github.linreal.cascade.editor.core/Block>): io.github.linreal.cascade.editor.markdown/MarkdownEmit // io.github.linreal.cascade.editor.markdown/MarkdownBlockGroupEncoder.encodeGroup|encodeGroup(io.github.linreal.cascade.editor.markdown.MarkdownEncodeContext;kotlin.collections.List<io.github.linreal.cascade.editor.core.Block>){}[0]
+    abstract fun groupKey(io.github.linreal.cascade.editor.core/Block): kotlin/Any? // io.github.linreal.cascade.editor.markdown/MarkdownBlockGroupEncoder.groupKey|groupKey(io.github.linreal.cascade.editor.core.Block){}[0]
+}
+
 abstract interface io.github.linreal.cascade.editor.registry/BlockCallbacks { // io.github.linreal.cascade.editor.registry/BlockCallbacks|null[0]
     abstract fun dispatch(io.github.linreal.cascade.editor.action/EditorAction) // io.github.linreal.cascade.editor.registry/BlockCallbacks.dispatch|dispatch(io.github.linreal.cascade.editor.action.EditorAction){}[0]
     abstract fun onBackspaceAtStart(io.github.linreal.cascade.editor.core/BlockId) // io.github.linreal.cascade.editor.registry/BlockCallbacks.onBackspaceAtStart|onBackspaceAtStart(io.github.linreal.cascade.editor.core.BlockId){}[0]
@@ -695,6 +787,148 @@ sealed interface io.github.linreal.cascade.editor.htmlserialization/UnknownTagPo
     }
 }
 
+sealed interface io.github.linreal.cascade.editor.markdown/EntityDecode { // io.github.linreal.cascade.editor.markdown/EntityDecode|null[0]
+    final object None : io.github.linreal.cascade.editor.markdown/EntityDecode { // io.github.linreal.cascade.editor.markdown/EntityDecode.None|null[0]
+        final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.markdown/EntityDecode.None.equals|equals(kotlin.Any?){}[0]
+        final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.markdown/EntityDecode.None.hashCode|hashCode(){}[0]
+        final fun toString(): kotlin/String // io.github.linreal.cascade.editor.markdown/EntityDecode.None.toString|toString(){}[0]
+    }
+
+    final object Standard : io.github.linreal.cascade.editor.markdown/EntityDecode { // io.github.linreal.cascade.editor.markdown/EntityDecode.Standard|null[0]
+        final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.markdown/EntityDecode.Standard.equals|equals(kotlin.Any?){}[0]
+        final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.markdown/EntityDecode.Standard.hashCode|hashCode(){}[0]
+        final fun toString(): kotlin/String // io.github.linreal.cascade.editor.markdown/EntityDecode.Standard.toString|toString(){}[0]
+    }
+}
+
+sealed interface io.github.linreal.cascade.editor.markdown/HardBreakEncode { // io.github.linreal.cascade.editor.markdown/HardBreakEncode|null[0]
+    final object Backslash : io.github.linreal.cascade.editor.markdown/HardBreakEncode { // io.github.linreal.cascade.editor.markdown/HardBreakEncode.Backslash|null[0]
+        final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.markdown/HardBreakEncode.Backslash.equals|equals(kotlin.Any?){}[0]
+        final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.markdown/HardBreakEncode.Backslash.hashCode|hashCode(){}[0]
+        final fun toString(): kotlin/String // io.github.linreal.cascade.editor.markdown/HardBreakEncode.Backslash.toString|toString(){}[0]
+    }
+
+    final object TwoSpaces : io.github.linreal.cascade.editor.markdown/HardBreakEncode { // io.github.linreal.cascade.editor.markdown/HardBreakEncode.TwoSpaces|null[0]
+        final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.markdown/HardBreakEncode.TwoSpaces.equals|equals(kotlin.Any?){}[0]
+        final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.markdown/HardBreakEncode.TwoSpaces.hashCode|hashCode(){}[0]
+        final fun toString(): kotlin/String // io.github.linreal.cascade.editor.markdown/HardBreakEncode.TwoSpaces.toString|toString(){}[0]
+    }
+}
+
+sealed interface io.github.linreal.cascade.editor.markdown/HtmlInMarkdown { // io.github.linreal.cascade.editor.markdown/HtmlInMarkdown|null[0]
+    final class Bridge : io.github.linreal.cascade.editor.markdown/HtmlInMarkdown { // io.github.linreal.cascade.editor.markdown/HtmlInMarkdown.Bridge|null[0]
+        constructor <init>(io.github.linreal.cascade.editor.htmlserialization/HtmlProfile) // io.github.linreal.cascade.editor.markdown/HtmlInMarkdown.Bridge.<init>|<init>(io.github.linreal.cascade.editor.htmlserialization.HtmlProfile){}[0]
+
+        final val htmlProfile // io.github.linreal.cascade.editor.markdown/HtmlInMarkdown.Bridge.htmlProfile|{}htmlProfile[0]
+            final fun <get-htmlProfile>(): io.github.linreal.cascade.editor.htmlserialization/HtmlProfile // io.github.linreal.cascade.editor.markdown/HtmlInMarkdown.Bridge.htmlProfile.<get-htmlProfile>|<get-htmlProfile>(){}[0]
+
+        final fun component1(): io.github.linreal.cascade.editor.htmlserialization/HtmlProfile // io.github.linreal.cascade.editor.markdown/HtmlInMarkdown.Bridge.component1|component1(){}[0]
+        final fun copy(io.github.linreal.cascade.editor.htmlserialization/HtmlProfile = ...): io.github.linreal.cascade.editor.markdown/HtmlInMarkdown.Bridge // io.github.linreal.cascade.editor.markdown/HtmlInMarkdown.Bridge.copy|copy(io.github.linreal.cascade.editor.htmlserialization.HtmlProfile){}[0]
+        final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.markdown/HtmlInMarkdown.Bridge.equals|equals(kotlin.Any?){}[0]
+        final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.markdown/HtmlInMarkdown.Bridge.hashCode|hashCode(){}[0]
+        final fun toString(): kotlin/String // io.github.linreal.cascade.editor.markdown/HtmlInMarkdown.Bridge.toString|toString(){}[0]
+    }
+
+    final object Preserve : io.github.linreal.cascade.editor.markdown/HtmlInMarkdown { // io.github.linreal.cascade.editor.markdown/HtmlInMarkdown.Preserve|null[0]
+        final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.markdown/HtmlInMarkdown.Preserve.equals|equals(kotlin.Any?){}[0]
+        final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.markdown/HtmlInMarkdown.Preserve.hashCode|hashCode(){}[0]
+        final fun toString(): kotlin/String // io.github.linreal.cascade.editor.markdown/HtmlInMarkdown.Preserve.toString|toString(){}[0]
+    }
+
+    final object Strip : io.github.linreal.cascade.editor.markdown/HtmlInMarkdown { // io.github.linreal.cascade.editor.markdown/HtmlInMarkdown.Strip|null[0]
+        final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.markdown/HtmlInMarkdown.Strip.equals|equals(kotlin.Any?){}[0]
+        final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.markdown/HtmlInMarkdown.Strip.hashCode|hashCode(){}[0]
+        final fun toString(): kotlin/String // io.github.linreal.cascade.editor.markdown/HtmlInMarkdown.Strip.toString|toString(){}[0]
+    }
+
+    final object WarnAndStrip : io.github.linreal.cascade.editor.markdown/HtmlInMarkdown { // io.github.linreal.cascade.editor.markdown/HtmlInMarkdown.WarnAndStrip|null[0]
+        final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.markdown/HtmlInMarkdown.WarnAndStrip.equals|equals(kotlin.Any?){}[0]
+        final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.markdown/HtmlInMarkdown.WarnAndStrip.hashCode|hashCode(){}[0]
+        final fun toString(): kotlin/String // io.github.linreal.cascade.editor.markdown/HtmlInMarkdown.WarnAndStrip.toString|toString(){}[0]
+    }
+}
+
+sealed interface io.github.linreal.cascade.editor.markdown/MarkdownEmit { // io.github.linreal.cascade.editor.markdown/MarkdownEmit|null[0]
+    final class Raw : io.github.linreal.cascade.editor.markdown/MarkdownEmit { // io.github.linreal.cascade.editor.markdown/MarkdownEmit.Raw|null[0]
+        constructor <init>(kotlin/String) // io.github.linreal.cascade.editor.markdown/MarkdownEmit.Raw.<init>|<init>(kotlin.String){}[0]
+
+        final val markdown // io.github.linreal.cascade.editor.markdown/MarkdownEmit.Raw.markdown|{}markdown[0]
+            final fun <get-markdown>(): kotlin/String // io.github.linreal.cascade.editor.markdown/MarkdownEmit.Raw.markdown.<get-markdown>|<get-markdown>(){}[0]
+
+        final fun component1(): kotlin/String // io.github.linreal.cascade.editor.markdown/MarkdownEmit.Raw.component1|component1(){}[0]
+        final fun copy(kotlin/String = ...): io.github.linreal.cascade.editor.markdown/MarkdownEmit.Raw // io.github.linreal.cascade.editor.markdown/MarkdownEmit.Raw.copy|copy(kotlin.String){}[0]
+        final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.markdown/MarkdownEmit.Raw.equals|equals(kotlin.Any?){}[0]
+        final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.markdown/MarkdownEmit.Raw.hashCode|hashCode(){}[0]
+        final fun toString(): kotlin/String // io.github.linreal.cascade.editor.markdown/MarkdownEmit.Raw.toString|toString(){}[0]
+    }
+
+    final class Verbatim : io.github.linreal.cascade.editor.markdown/MarkdownEmit { // io.github.linreal.cascade.editor.markdown/MarkdownEmit.Verbatim|null[0]
+        constructor <init>(kotlin/String) // io.github.linreal.cascade.editor.markdown/MarkdownEmit.Verbatim.<init>|<init>(kotlin.String){}[0]
+
+        final val markdown // io.github.linreal.cascade.editor.markdown/MarkdownEmit.Verbatim.markdown|{}markdown[0]
+            final fun <get-markdown>(): kotlin/String // io.github.linreal.cascade.editor.markdown/MarkdownEmit.Verbatim.markdown.<get-markdown>|<get-markdown>(){}[0]
+
+        final fun component1(): kotlin/String // io.github.linreal.cascade.editor.markdown/MarkdownEmit.Verbatim.component1|component1(){}[0]
+        final fun copy(kotlin/String = ...): io.github.linreal.cascade.editor.markdown/MarkdownEmit.Verbatim // io.github.linreal.cascade.editor.markdown/MarkdownEmit.Verbatim.copy|copy(kotlin.String){}[0]
+        final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.markdown/MarkdownEmit.Verbatim.equals|equals(kotlin.Any?){}[0]
+        final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.markdown/MarkdownEmit.Verbatim.hashCode|hashCode(){}[0]
+        final fun toString(): kotlin/String // io.github.linreal.cascade.editor.markdown/MarkdownEmit.Verbatim.toString|toString(){}[0]
+    }
+
+    final object Skip : io.github.linreal.cascade.editor.markdown/MarkdownEmit { // io.github.linreal.cascade.editor.markdown/MarkdownEmit.Skip|null[0]
+        final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.markdown/MarkdownEmit.Skip.equals|equals(kotlin.Any?){}[0]
+        final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.markdown/MarkdownEmit.Skip.hashCode|hashCode(){}[0]
+        final fun toString(): kotlin/String // io.github.linreal.cascade.editor.markdown/MarkdownEmit.Skip.toString|toString(){}[0]
+    }
+}
+
+sealed interface io.github.linreal.cascade.editor.markdown/MarkdownWarning { // io.github.linreal.cascade.editor.markdown/MarkdownWarning|null[0]
+    abstract val impact // io.github.linreal.cascade.editor.markdown/MarkdownWarning.impact|{}impact[0]
+        abstract fun <get-impact>(): io.github.linreal.cascade.editor.markdown/MarkdownFidelityImpact // io.github.linreal.cascade.editor.markdown/MarkdownWarning.impact.<get-impact>|<get-impact>(){}[0]
+}
+
+sealed interface io.github.linreal.cascade.editor.markdown/NewlineSemantics { // io.github.linreal.cascade.editor.markdown/NewlineSemantics|null[0]
+    final object CommonMark : io.github.linreal.cascade.editor.markdown/NewlineSemantics { // io.github.linreal.cascade.editor.markdown/NewlineSemantics.CommonMark|null[0]
+        final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.markdown/NewlineSemantics.CommonMark.equals|equals(kotlin.Any?){}[0]
+        final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.markdown/NewlineSemantics.CommonMark.hashCode|hashCode(){}[0]
+        final fun toString(): kotlin/String // io.github.linreal.cascade.editor.markdown/NewlineSemantics.CommonMark.toString|toString(){}[0]
+    }
+
+    final object HardBreak : io.github.linreal.cascade.editor.markdown/NewlineSemantics { // io.github.linreal.cascade.editor.markdown/NewlineSemantics.HardBreak|null[0]
+        final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.markdown/NewlineSemantics.HardBreak.equals|equals(kotlin.Any?){}[0]
+        final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.markdown/NewlineSemantics.HardBreak.hashCode|hashCode(){}[0]
+        final fun toString(): kotlin/String // io.github.linreal.cascade.editor.markdown/NewlineSemantics.HardBreak.toString|toString(){}[0]
+    }
+}
+
+sealed interface io.github.linreal.cascade.editor.markdown/SoftBreak { // io.github.linreal.cascade.editor.markdown/SoftBreak|null[0]
+    final object LineBreak : io.github.linreal.cascade.editor.markdown/SoftBreak { // io.github.linreal.cascade.editor.markdown/SoftBreak.LineBreak|null[0]
+        final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.markdown/SoftBreak.LineBreak.equals|equals(kotlin.Any?){}[0]
+        final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.markdown/SoftBreak.LineBreak.hashCode|hashCode(){}[0]
+        final fun toString(): kotlin/String // io.github.linreal.cascade.editor.markdown/SoftBreak.LineBreak.toString|toString(){}[0]
+    }
+
+    final object Space : io.github.linreal.cascade.editor.markdown/SoftBreak { // io.github.linreal.cascade.editor.markdown/SoftBreak.Space|null[0]
+        final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.markdown/SoftBreak.Space.equals|equals(kotlin.Any?){}[0]
+        final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.markdown/SoftBreak.Space.hashCode|hashCode(){}[0]
+        final fun toString(): kotlin/String // io.github.linreal.cascade.editor.markdown/SoftBreak.Space.toString|toString(){}[0]
+    }
+}
+
+sealed interface io.github.linreal.cascade.editor.markdown/UnsupportedSyntax { // io.github.linreal.cascade.editor.markdown/UnsupportedSyntax|null[0]
+    final object Preserve : io.github.linreal.cascade.editor.markdown/UnsupportedSyntax { // io.github.linreal.cascade.editor.markdown/UnsupportedSyntax.Preserve|null[0]
+        final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.markdown/UnsupportedSyntax.Preserve.equals|equals(kotlin.Any?){}[0]
+        final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.markdown/UnsupportedSyntax.Preserve.hashCode|hashCode(){}[0]
+        final fun toString(): kotlin/String // io.github.linreal.cascade.editor.markdown/UnsupportedSyntax.Preserve.toString|toString(){}[0]
+    }
+
+    final object WarnAndDegrade : io.github.linreal.cascade.editor.markdown/UnsupportedSyntax { // io.github.linreal.cascade.editor.markdown/UnsupportedSyntax.WarnAndDegrade|null[0]
+        final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.markdown/UnsupportedSyntax.WarnAndDegrade.equals|equals(kotlin.Any?){}[0]
+        final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.markdown/UnsupportedSyntax.WarnAndDegrade.hashCode|hashCode(){}[0]
+        final fun toString(): kotlin/String // io.github.linreal.cascade.editor.markdown/UnsupportedSyntax.WarnAndDegrade.toString|toString(){}[0]
+    }
+}
+
 sealed interface io.github.linreal.cascade.editor.richtext/LinkValidationResult { // io.github.linreal.cascade.editor.richtext/LinkValidationResult|null[0]
     abstract val error // io.github.linreal.cascade.editor.richtext/LinkValidationResult.error|{}error[0]
         abstract fun <get-error>(): io.github.linreal.cascade.editor.richtext/LinkValidationError? // io.github.linreal.cascade.editor.richtext/LinkValidationResult.error.<get-error>|<get-error>(){}[0]
@@ -885,6 +1119,13 @@ abstract class io.github.linreal.cascade.editor.htmlserialization/TagDecodeConte
     abstract fun warn(io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeWarning) // io.github.linreal.cascade.editor.htmlserialization/TagDecodeContext.warn|warn(io.github.linreal.cascade.editor.htmlserialization.HtmlDecodeWarning){}[0]
 }
 
+abstract class io.github.linreal.cascade.editor.markdown/MarkdownEncodeContext { // io.github.linreal.cascade.editor.markdown/MarkdownEncodeContext|null[0]
+    abstract fun encodeInlineLines(io.github.linreal.cascade.editor.core/Block): kotlin.collections/List<kotlin/String> // io.github.linreal.cascade.editor.markdown/MarkdownEncodeContext.encodeInlineLines|encodeInlineLines(io.github.linreal.cascade.editor.core.Block){}[0]
+    abstract fun encodeTextOnly(io.github.linreal.cascade.editor.core/Block): kotlin/String // io.github.linreal.cascade.editor.markdown/MarkdownEncodeContext.encodeTextOnly|encodeTextOnly(io.github.linreal.cascade.editor.core.Block){}[0]
+    abstract fun prefixLines(kotlin.collections/List<kotlin/String>, kotlin/String, kotlin/String): kotlin.collections/List<kotlin/String> // io.github.linreal.cascade.editor.markdown/MarkdownEncodeContext.prefixLines|prefixLines(kotlin.collections.List<kotlin.String>;kotlin.String;kotlin.String){}[0]
+    abstract fun warn(io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning) // io.github.linreal.cascade.editor.markdown/MarkdownEncodeContext.warn|warn(io.github.linreal.cascade.editor.markdown.MarkdownEncodeWarning){}[0]
+}
+
 final class <#A: io.github.linreal.cascade.editor.core/BlockType> io.github.linreal.cascade.editor.registry/LambdaBlockRenderer : io.github.linreal.cascade.editor.registry/BlockRenderer<#A> { // io.github.linreal.cascade.editor.registry/LambdaBlockRenderer|null[0]
     constructor <init>(kotlin/Function7<io.github.linreal.cascade.editor.core/Block, kotlin/Boolean, kotlin/Boolean, androidx.compose.ui/Modifier, io.github.linreal.cascade.editor.registry/BlockCallbacks, androidx.compose.runtime/Composer, kotlin/Int, kotlin/Unit>) // io.github.linreal.cascade.editor.registry/LambdaBlockRenderer.<init>|<init>(kotlin.Function7<io.github.linreal.cascade.editor.core.Block,kotlin.Boolean,kotlin.Boolean,androidx.compose.ui.Modifier,io.github.linreal.cascade.editor.registry.BlockCallbacks,androidx.compose.runtime.Composer,kotlin.Int,kotlin.Unit>){}[0]
 
@@ -1596,6 +1837,299 @@ final class io.github.linreal.cascade.editor.indentation/IndentationState { // i
     }
 }
 
+final class io.github.linreal.cascade.editor.markdown/MarkdownCodeSpanDelimiters { // io.github.linreal.cascade.editor.markdown/MarkdownCodeSpanDelimiters|null[0]
+    constructor <init>(kotlin/String, kotlin/Boolean, kotlin/Boolean = ...) // io.github.linreal.cascade.editor.markdown/MarkdownCodeSpanDelimiters.<init>|<init>(kotlin.String;kotlin.Boolean;kotlin.Boolean){}[0]
+
+    final val close // io.github.linreal.cascade.editor.markdown/MarkdownCodeSpanDelimiters.close|{}close[0]
+        final fun <get-close>(): kotlin/String // io.github.linreal.cascade.editor.markdown/MarkdownCodeSpanDelimiters.close.<get-close>|<get-close>(){}[0]
+    final val fence // io.github.linreal.cascade.editor.markdown/MarkdownCodeSpanDelimiters.fence|{}fence[0]
+        final fun <get-fence>(): kotlin/String // io.github.linreal.cascade.editor.markdown/MarkdownCodeSpanDelimiters.fence.<get-fence>|<get-fence>(){}[0]
+    final val open // io.github.linreal.cascade.editor.markdown/MarkdownCodeSpanDelimiters.open|{}open[0]
+        final fun <get-open>(): kotlin/String // io.github.linreal.cascade.editor.markdown/MarkdownCodeSpanDelimiters.open.<get-open>|<get-open>(){}[0]
+    final val padded // io.github.linreal.cascade.editor.markdown/MarkdownCodeSpanDelimiters.padded|{}padded[0]
+        final fun <get-padded>(): kotlin/Boolean // io.github.linreal.cascade.editor.markdown/MarkdownCodeSpanDelimiters.padded.<get-padded>|<get-padded>(){}[0]
+    final val requiresFallback // io.github.linreal.cascade.editor.markdown/MarkdownCodeSpanDelimiters.requiresFallback|{}requiresFallback[0]
+        final fun <get-requiresFallback>(): kotlin/Boolean // io.github.linreal.cascade.editor.markdown/MarkdownCodeSpanDelimiters.requiresFallback.<get-requiresFallback>|<get-requiresFallback>(){}[0]
+
+    final fun component1(): kotlin/String // io.github.linreal.cascade.editor.markdown/MarkdownCodeSpanDelimiters.component1|component1(){}[0]
+    final fun component2(): kotlin/Boolean // io.github.linreal.cascade.editor.markdown/MarkdownCodeSpanDelimiters.component2|component2(){}[0]
+    final fun component3(): kotlin/Boolean // io.github.linreal.cascade.editor.markdown/MarkdownCodeSpanDelimiters.component3|component3(){}[0]
+    final fun copy(kotlin/String = ..., kotlin/Boolean = ..., kotlin/Boolean = ...): io.github.linreal.cascade.editor.markdown/MarkdownCodeSpanDelimiters // io.github.linreal.cascade.editor.markdown/MarkdownCodeSpanDelimiters.copy|copy(kotlin.String;kotlin.Boolean;kotlin.Boolean){}[0]
+    final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.markdown/MarkdownCodeSpanDelimiters.equals|equals(kotlin.Any?){}[0]
+    final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.markdown/MarkdownCodeSpanDelimiters.hashCode|hashCode(){}[0]
+    final fun toString(): kotlin/String // io.github.linreal.cascade.editor.markdown/MarkdownCodeSpanDelimiters.toString|toString(){}[0]
+}
+
+final class io.github.linreal.cascade.editor.markdown/MarkdownCodecLimits { // io.github.linreal.cascade.editor.markdown/MarkdownCodecLimits|null[0]
+    constructor <init>(kotlin/Int = ..., kotlin/Int = ..., kotlin/Int = ..., kotlin/Int = ..., kotlin/Int = ..., kotlin/Int = ..., kotlin/Int = ..., kotlin/Int = ..., kotlin/Int = ...) // io.github.linreal.cascade.editor.markdown/MarkdownCodecLimits.<init>|<init>(kotlin.Int;kotlin.Int;kotlin.Int;kotlin.Int;kotlin.Int;kotlin.Int;kotlin.Int;kotlin.Int;kotlin.Int){}[0]
+
+    final val maxBlockNesting // io.github.linreal.cascade.editor.markdown/MarkdownCodecLimits.maxBlockNesting|{}maxBlockNesting[0]
+        final fun <get-maxBlockNesting>(): kotlin/Int // io.github.linreal.cascade.editor.markdown/MarkdownCodecLimits.maxBlockNesting.<get-maxBlockNesting>|<get-maxBlockNesting>(){}[0]
+    final val maxBlocks // io.github.linreal.cascade.editor.markdown/MarkdownCodecLimits.maxBlocks|{}maxBlocks[0]
+        final fun <get-maxBlocks>(): kotlin/Int // io.github.linreal.cascade.editor.markdown/MarkdownCodecLimits.maxBlocks.<get-maxBlocks>|<get-maxBlocks>(){}[0]
+    final val maxDelimiterRuns // io.github.linreal.cascade.editor.markdown/MarkdownCodecLimits.maxDelimiterRuns|{}maxDelimiterRuns[0]
+        final fun <get-maxDelimiterRuns>(): kotlin/Int // io.github.linreal.cascade.editor.markdown/MarkdownCodecLimits.maxDelimiterRuns.<get-maxDelimiterRuns>|<get-maxDelimiterRuns>(){}[0]
+    final val maxInputChars // io.github.linreal.cascade.editor.markdown/MarkdownCodecLimits.maxInputChars|{}maxInputChars[0]
+        final fun <get-maxInputChars>(): kotlin/Int // io.github.linreal.cascade.editor.markdown/MarkdownCodecLimits.maxInputChars.<get-maxInputChars>|<get-maxInputChars>(){}[0]
+    final val maxOutputChars // io.github.linreal.cascade.editor.markdown/MarkdownCodecLimits.maxOutputChars|{}maxOutputChars[0]
+        final fun <get-maxOutputChars>(): kotlin/Int // io.github.linreal.cascade.editor.markdown/MarkdownCodecLimits.maxOutputChars.<get-maxOutputChars>|<get-maxOutputChars>(){}[0]
+    final val maxReferenceDefinitions // io.github.linreal.cascade.editor.markdown/MarkdownCodecLimits.maxReferenceDefinitions|{}maxReferenceDefinitions[0]
+        final fun <get-maxReferenceDefinitions>(): kotlin/Int // io.github.linreal.cascade.editor.markdown/MarkdownCodecLimits.maxReferenceDefinitions.<get-maxReferenceDefinitions>|<get-maxReferenceDefinitions>(){}[0]
+    final val maxSpansPerBlock // io.github.linreal.cascade.editor.markdown/MarkdownCodecLimits.maxSpansPerBlock|{}maxSpansPerBlock[0]
+        final fun <get-maxSpansPerBlock>(): kotlin/Int // io.github.linreal.cascade.editor.markdown/MarkdownCodecLimits.maxSpansPerBlock.<get-maxSpansPerBlock>|<get-maxSpansPerBlock>(){}[0]
+    final val maxTotalSpans // io.github.linreal.cascade.editor.markdown/MarkdownCodecLimits.maxTotalSpans|{}maxTotalSpans[0]
+        final fun <get-maxTotalSpans>(): kotlin/Int // io.github.linreal.cascade.editor.markdown/MarkdownCodecLimits.maxTotalSpans.<get-maxTotalSpans>|<get-maxTotalSpans>(){}[0]
+    final val maxWarnings // io.github.linreal.cascade.editor.markdown/MarkdownCodecLimits.maxWarnings|{}maxWarnings[0]
+        final fun <get-maxWarnings>(): kotlin/Int // io.github.linreal.cascade.editor.markdown/MarkdownCodecLimits.maxWarnings.<get-maxWarnings>|<get-maxWarnings>(){}[0]
+
+    final fun component1(): kotlin/Int // io.github.linreal.cascade.editor.markdown/MarkdownCodecLimits.component1|component1(){}[0]
+    final fun component2(): kotlin/Int // io.github.linreal.cascade.editor.markdown/MarkdownCodecLimits.component2|component2(){}[0]
+    final fun component3(): kotlin/Int // io.github.linreal.cascade.editor.markdown/MarkdownCodecLimits.component3|component3(){}[0]
+    final fun component4(): kotlin/Int // io.github.linreal.cascade.editor.markdown/MarkdownCodecLimits.component4|component4(){}[0]
+    final fun component5(): kotlin/Int // io.github.linreal.cascade.editor.markdown/MarkdownCodecLimits.component5|component5(){}[0]
+    final fun component6(): kotlin/Int // io.github.linreal.cascade.editor.markdown/MarkdownCodecLimits.component6|component6(){}[0]
+    final fun component7(): kotlin/Int // io.github.linreal.cascade.editor.markdown/MarkdownCodecLimits.component7|component7(){}[0]
+    final fun component8(): kotlin/Int // io.github.linreal.cascade.editor.markdown/MarkdownCodecLimits.component8|component8(){}[0]
+    final fun component9(): kotlin/Int // io.github.linreal.cascade.editor.markdown/MarkdownCodecLimits.component9|component9(){}[0]
+    final fun copy(kotlin/Int = ..., kotlin/Int = ..., kotlin/Int = ..., kotlin/Int = ..., kotlin/Int = ..., kotlin/Int = ..., kotlin/Int = ..., kotlin/Int = ..., kotlin/Int = ...): io.github.linreal.cascade.editor.markdown/MarkdownCodecLimits // io.github.linreal.cascade.editor.markdown/MarkdownCodecLimits.copy|copy(kotlin.Int;kotlin.Int;kotlin.Int;kotlin.Int;kotlin.Int;kotlin.Int;kotlin.Int;kotlin.Int;kotlin.Int){}[0]
+    final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.markdown/MarkdownCodecLimits.equals|equals(kotlin.Any?){}[0]
+    final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.markdown/MarkdownCodecLimits.hashCode|hashCode(){}[0]
+    final fun toString(): kotlin/String // io.github.linreal.cascade.editor.markdown/MarkdownCodecLimits.toString|toString(){}[0]
+
+    final object Companion { // io.github.linreal.cascade.editor.markdown/MarkdownCodecLimits.Companion|null[0]
+        final const val DEFAULT_MAX_BLOCKS // io.github.linreal.cascade.editor.markdown/MarkdownCodecLimits.Companion.DEFAULT_MAX_BLOCKS|{}DEFAULT_MAX_BLOCKS[0]
+            final fun <get-DEFAULT_MAX_BLOCKS>(): kotlin/Int // io.github.linreal.cascade.editor.markdown/MarkdownCodecLimits.Companion.DEFAULT_MAX_BLOCKS.<get-DEFAULT_MAX_BLOCKS>|<get-DEFAULT_MAX_BLOCKS>(){}[0]
+        final const val DEFAULT_MAX_BLOCK_NESTING // io.github.linreal.cascade.editor.markdown/MarkdownCodecLimits.Companion.DEFAULT_MAX_BLOCK_NESTING|{}DEFAULT_MAX_BLOCK_NESTING[0]
+            final fun <get-DEFAULT_MAX_BLOCK_NESTING>(): kotlin/Int // io.github.linreal.cascade.editor.markdown/MarkdownCodecLimits.Companion.DEFAULT_MAX_BLOCK_NESTING.<get-DEFAULT_MAX_BLOCK_NESTING>|<get-DEFAULT_MAX_BLOCK_NESTING>(){}[0]
+        final const val DEFAULT_MAX_DELIMITER_RUNS // io.github.linreal.cascade.editor.markdown/MarkdownCodecLimits.Companion.DEFAULT_MAX_DELIMITER_RUNS|{}DEFAULT_MAX_DELIMITER_RUNS[0]
+            final fun <get-DEFAULT_MAX_DELIMITER_RUNS>(): kotlin/Int // io.github.linreal.cascade.editor.markdown/MarkdownCodecLimits.Companion.DEFAULT_MAX_DELIMITER_RUNS.<get-DEFAULT_MAX_DELIMITER_RUNS>|<get-DEFAULT_MAX_DELIMITER_RUNS>(){}[0]
+        final const val DEFAULT_MAX_INPUT_CHARS // io.github.linreal.cascade.editor.markdown/MarkdownCodecLimits.Companion.DEFAULT_MAX_INPUT_CHARS|{}DEFAULT_MAX_INPUT_CHARS[0]
+            final fun <get-DEFAULT_MAX_INPUT_CHARS>(): kotlin/Int // io.github.linreal.cascade.editor.markdown/MarkdownCodecLimits.Companion.DEFAULT_MAX_INPUT_CHARS.<get-DEFAULT_MAX_INPUT_CHARS>|<get-DEFAULT_MAX_INPUT_CHARS>(){}[0]
+        final const val DEFAULT_MAX_OUTPUT_CHARS // io.github.linreal.cascade.editor.markdown/MarkdownCodecLimits.Companion.DEFAULT_MAX_OUTPUT_CHARS|{}DEFAULT_MAX_OUTPUT_CHARS[0]
+            final fun <get-DEFAULT_MAX_OUTPUT_CHARS>(): kotlin/Int // io.github.linreal.cascade.editor.markdown/MarkdownCodecLimits.Companion.DEFAULT_MAX_OUTPUT_CHARS.<get-DEFAULT_MAX_OUTPUT_CHARS>|<get-DEFAULT_MAX_OUTPUT_CHARS>(){}[0]
+        final const val DEFAULT_MAX_REFERENCE_DEFINITIONS // io.github.linreal.cascade.editor.markdown/MarkdownCodecLimits.Companion.DEFAULT_MAX_REFERENCE_DEFINITIONS|{}DEFAULT_MAX_REFERENCE_DEFINITIONS[0]
+            final fun <get-DEFAULT_MAX_REFERENCE_DEFINITIONS>(): kotlin/Int // io.github.linreal.cascade.editor.markdown/MarkdownCodecLimits.Companion.DEFAULT_MAX_REFERENCE_DEFINITIONS.<get-DEFAULT_MAX_REFERENCE_DEFINITIONS>|<get-DEFAULT_MAX_REFERENCE_DEFINITIONS>(){}[0]
+        final const val DEFAULT_MAX_SPANS_PER_BLOCK // io.github.linreal.cascade.editor.markdown/MarkdownCodecLimits.Companion.DEFAULT_MAX_SPANS_PER_BLOCK|{}DEFAULT_MAX_SPANS_PER_BLOCK[0]
+            final fun <get-DEFAULT_MAX_SPANS_PER_BLOCK>(): kotlin/Int // io.github.linreal.cascade.editor.markdown/MarkdownCodecLimits.Companion.DEFAULT_MAX_SPANS_PER_BLOCK.<get-DEFAULT_MAX_SPANS_PER_BLOCK>|<get-DEFAULT_MAX_SPANS_PER_BLOCK>(){}[0]
+        final const val DEFAULT_MAX_TOTAL_SPANS // io.github.linreal.cascade.editor.markdown/MarkdownCodecLimits.Companion.DEFAULT_MAX_TOTAL_SPANS|{}DEFAULT_MAX_TOTAL_SPANS[0]
+            final fun <get-DEFAULT_MAX_TOTAL_SPANS>(): kotlin/Int // io.github.linreal.cascade.editor.markdown/MarkdownCodecLimits.Companion.DEFAULT_MAX_TOTAL_SPANS.<get-DEFAULT_MAX_TOTAL_SPANS>|<get-DEFAULT_MAX_TOTAL_SPANS>(){}[0]
+        final const val DEFAULT_MAX_WARNINGS // io.github.linreal.cascade.editor.markdown/MarkdownCodecLimits.Companion.DEFAULT_MAX_WARNINGS|{}DEFAULT_MAX_WARNINGS[0]
+            final fun <get-DEFAULT_MAX_WARNINGS>(): kotlin/Int // io.github.linreal.cascade.editor.markdown/MarkdownCodecLimits.Companion.DEFAULT_MAX_WARNINGS.<get-DEFAULT_MAX_WARNINGS>|<get-DEFAULT_MAX_WARNINGS>(){}[0]
+
+        final val Default // io.github.linreal.cascade.editor.markdown/MarkdownCodecLimits.Companion.Default|{}Default[0]
+            final fun <get-Default>(): io.github.linreal.cascade.editor.markdown/MarkdownCodecLimits // io.github.linreal.cascade.editor.markdown/MarkdownCodecLimits.Companion.Default.<get-Default>|<get-Default>(){}[0]
+    }
+}
+
+final class io.github.linreal.cascade.editor.markdown/MarkdownDecodeResult { // io.github.linreal.cascade.editor.markdown/MarkdownDecodeResult|null[0]
+    final val blocks // io.github.linreal.cascade.editor.markdown/MarkdownDecodeResult.blocks|{}blocks[0]
+        final fun <get-blocks>(): kotlin.collections/List<io.github.linreal.cascade.editor.core/Block>? // io.github.linreal.cascade.editor.markdown/MarkdownDecodeResult.blocks.<get-blocks>|<get-blocks>(){}[0]
+    final val isAborted // io.github.linreal.cascade.editor.markdown/MarkdownDecodeResult.isAborted|{}isAborted[0]
+        final fun <get-isAborted>(): kotlin/Boolean // io.github.linreal.cascade.editor.markdown/MarkdownDecodeResult.isAborted.<get-isAborted>|<get-isAborted>(){}[0]
+    final val isSuccess // io.github.linreal.cascade.editor.markdown/MarkdownDecodeResult.isSuccess|{}isSuccess[0]
+        final fun <get-isSuccess>(): kotlin/Boolean // io.github.linreal.cascade.editor.markdown/MarkdownDecodeResult.isSuccess.<get-isSuccess>|<get-isSuccess>(){}[0]
+    final val sourceLocator // io.github.linreal.cascade.editor.markdown/MarkdownDecodeResult.sourceLocator|{}sourceLocator[0]
+        final fun <get-sourceLocator>(): io.github.linreal.cascade.editor.markdown/MarkdownSourceLocator // io.github.linreal.cascade.editor.markdown/MarkdownDecodeResult.sourceLocator.<get-sourceLocator>|<get-sourceLocator>(){}[0]
+    final val status // io.github.linreal.cascade.editor.markdown/MarkdownDecodeResult.status|{}status[0]
+        final fun <get-status>(): io.github.linreal.cascade.editor.markdown/MarkdownCodecStatus // io.github.linreal.cascade.editor.markdown/MarkdownDecodeResult.status.<get-status>|<get-status>(){}[0]
+    final val warnings // io.github.linreal.cascade.editor.markdown/MarkdownDecodeResult.warnings|{}warnings[0]
+        final fun <get-warnings>(): kotlin.collections/List<io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning> // io.github.linreal.cascade.editor.markdown/MarkdownDecodeResult.warnings.<get-warnings>|<get-warnings>(){}[0]
+
+    final fun toString(): kotlin/String // io.github.linreal.cascade.editor.markdown/MarkdownDecodeResult.toString|toString(){}[0]
+
+    final object Companion { // io.github.linreal.cascade.editor.markdown/MarkdownDecodeResult.Companion|null[0]
+        final fun aborted(kotlin.collections/List<io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning>, io.github.linreal.cascade.editor.markdown/MarkdownSourceLocator = ...): io.github.linreal.cascade.editor.markdown/MarkdownDecodeResult // io.github.linreal.cascade.editor.markdown/MarkdownDecodeResult.Companion.aborted|aborted(kotlin.collections.List<io.github.linreal.cascade.editor.markdown.MarkdownDecodeWarning>;io.github.linreal.cascade.editor.markdown.MarkdownSourceLocator){}[0]
+        final fun success(kotlin.collections/List<io.github.linreal.cascade.editor.core/Block>, kotlin.collections/List<io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning> = ..., io.github.linreal.cascade.editor.markdown/MarkdownSourceLocator = ...): io.github.linreal.cascade.editor.markdown/MarkdownDecodeResult // io.github.linreal.cascade.editor.markdown/MarkdownDecodeResult.Companion.success|success(kotlin.collections.List<io.github.linreal.cascade.editor.core.Block>;kotlin.collections.List<io.github.linreal.cascade.editor.markdown.MarkdownDecodeWarning>;io.github.linreal.cascade.editor.markdown.MarkdownSourceLocator){}[0]
+    }
+}
+
+final class io.github.linreal.cascade.editor.markdown/MarkdownEncodeResult { // io.github.linreal.cascade.editor.markdown/MarkdownEncodeResult|null[0]
+    final val isAborted // io.github.linreal.cascade.editor.markdown/MarkdownEncodeResult.isAborted|{}isAborted[0]
+        final fun <get-isAborted>(): kotlin/Boolean // io.github.linreal.cascade.editor.markdown/MarkdownEncodeResult.isAborted.<get-isAborted>|<get-isAborted>(){}[0]
+    final val isSuccess // io.github.linreal.cascade.editor.markdown/MarkdownEncodeResult.isSuccess|{}isSuccess[0]
+        final fun <get-isSuccess>(): kotlin/Boolean // io.github.linreal.cascade.editor.markdown/MarkdownEncodeResult.isSuccess.<get-isSuccess>|<get-isSuccess>(){}[0]
+    final val markdown // io.github.linreal.cascade.editor.markdown/MarkdownEncodeResult.markdown|{}markdown[0]
+        final fun <get-markdown>(): kotlin/String? // io.github.linreal.cascade.editor.markdown/MarkdownEncodeResult.markdown.<get-markdown>|<get-markdown>(){}[0]
+    final val status // io.github.linreal.cascade.editor.markdown/MarkdownEncodeResult.status|{}status[0]
+        final fun <get-status>(): io.github.linreal.cascade.editor.markdown/MarkdownCodecStatus // io.github.linreal.cascade.editor.markdown/MarkdownEncodeResult.status.<get-status>|<get-status>(){}[0]
+    final val warnings // io.github.linreal.cascade.editor.markdown/MarkdownEncodeResult.warnings|{}warnings[0]
+        final fun <get-warnings>(): kotlin.collections/List<io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning> // io.github.linreal.cascade.editor.markdown/MarkdownEncodeResult.warnings.<get-warnings>|<get-warnings>(){}[0]
+
+    final fun toString(): kotlin/String // io.github.linreal.cascade.editor.markdown/MarkdownEncodeResult.toString|toString(){}[0]
+
+    final object Companion { // io.github.linreal.cascade.editor.markdown/MarkdownEncodeResult.Companion|null[0]
+        final fun aborted(kotlin.collections/List<io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning>): io.github.linreal.cascade.editor.markdown/MarkdownEncodeResult // io.github.linreal.cascade.editor.markdown/MarkdownEncodeResult.Companion.aborted|aborted(kotlin.collections.List<io.github.linreal.cascade.editor.markdown.MarkdownEncodeWarning>){}[0]
+        final fun success(kotlin/String, kotlin.collections/List<io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning> = ...): io.github.linreal.cascade.editor.markdown/MarkdownEncodeResult // io.github.linreal.cascade.editor.markdown/MarkdownEncodeResult.Companion.success|success(kotlin.String;kotlin.collections.List<io.github.linreal.cascade.editor.markdown.MarkdownEncodeWarning>){}[0]
+    }
+}
+
+final class io.github.linreal.cascade.editor.markdown/MarkdownEscapeContext { // io.github.linreal.cascade.editor.markdown/MarkdownEscapeContext|null[0]
+    constructor <init>(kotlin/Boolean, kotlin/String = ..., io.github.linreal.cascade.editor.markdown/MarkdownEscapeTextKind = ...) // io.github.linreal.cascade.editor.markdown/MarkdownEscapeContext.<init>|<init>(kotlin.Boolean;kotlin.String;io.github.linreal.cascade.editor.markdown.MarkdownEscapeTextKind){}[0]
+
+    final val atLineStart // io.github.linreal.cascade.editor.markdown/MarkdownEscapeContext.atLineStart|{}atLineStart[0]
+        final fun <get-atLineStart>(): kotlin/Boolean // io.github.linreal.cascade.editor.markdown/MarkdownEscapeContext.atLineStart.<get-atLineStart>|<get-atLineStart>(){}[0]
+    final val containerPrefix // io.github.linreal.cascade.editor.markdown/MarkdownEscapeContext.containerPrefix|{}containerPrefix[0]
+        final fun <get-containerPrefix>(): kotlin/String // io.github.linreal.cascade.editor.markdown/MarkdownEscapeContext.containerPrefix.<get-containerPrefix>|<get-containerPrefix>(){}[0]
+    final val kind // io.github.linreal.cascade.editor.markdown/MarkdownEscapeContext.kind|{}kind[0]
+        final fun <get-kind>(): io.github.linreal.cascade.editor.markdown/MarkdownEscapeTextKind // io.github.linreal.cascade.editor.markdown/MarkdownEscapeContext.kind.<get-kind>|<get-kind>(){}[0]
+
+    final fun component1(): kotlin/Boolean // io.github.linreal.cascade.editor.markdown/MarkdownEscapeContext.component1|component1(){}[0]
+    final fun component2(): kotlin/String // io.github.linreal.cascade.editor.markdown/MarkdownEscapeContext.component2|component2(){}[0]
+    final fun component3(): io.github.linreal.cascade.editor.markdown/MarkdownEscapeTextKind // io.github.linreal.cascade.editor.markdown/MarkdownEscapeContext.component3|component3(){}[0]
+    final fun copy(kotlin/Boolean = ..., kotlin/String = ..., io.github.linreal.cascade.editor.markdown/MarkdownEscapeTextKind = ...): io.github.linreal.cascade.editor.markdown/MarkdownEscapeContext // io.github.linreal.cascade.editor.markdown/MarkdownEscapeContext.copy|copy(kotlin.Boolean;kotlin.String;io.github.linreal.cascade.editor.markdown.MarkdownEscapeTextKind){}[0]
+    final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.markdown/MarkdownEscapeContext.equals|equals(kotlin.Any?){}[0]
+    final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.markdown/MarkdownEscapeContext.hashCode|hashCode(){}[0]
+    final fun toString(): kotlin/String // io.github.linreal.cascade.editor.markdown/MarkdownEscapeContext.toString|toString(){}[0]
+
+    final object Companion { // io.github.linreal.cascade.editor.markdown/MarkdownEscapeContext.Companion|null[0]
+        final val LineStart // io.github.linreal.cascade.editor.markdown/MarkdownEscapeContext.Companion.LineStart|{}LineStart[0]
+            final fun <get-LineStart>(): io.github.linreal.cascade.editor.markdown/MarkdownEscapeContext // io.github.linreal.cascade.editor.markdown/MarkdownEscapeContext.Companion.LineStart.<get-LineStart>|<get-LineStart>(){}[0]
+        final val MidLine // io.github.linreal.cascade.editor.markdown/MarkdownEscapeContext.Companion.MidLine|{}MidLine[0]
+            final fun <get-MidLine>(): io.github.linreal.cascade.editor.markdown/MarkdownEscapeContext // io.github.linreal.cascade.editor.markdown/MarkdownEscapeContext.Companion.MidLine.<get-MidLine>|<get-MidLine>(){}[0]
+    }
+}
+
+final class io.github.linreal.cascade.editor.markdown/MarkdownFidelityReport { // io.github.linreal.cascade.editor.markdown/MarkdownFidelityReport|null[0]
+    final val dataLossWarnings // io.github.linreal.cascade.editor.markdown/MarkdownFidelityReport.dataLossWarnings|{}dataLossWarnings[0]
+        final fun <get-dataLossWarnings>(): kotlin.collections/List<io.github.linreal.cascade.editor.markdown/MarkdownWarning> // io.github.linreal.cascade.editor.markdown/MarkdownFidelityReport.dataLossWarnings.<get-dataLossWarnings>|<get-dataLossWarnings>(){}[0]
+    final val decodeResult // io.github.linreal.cascade.editor.markdown/MarkdownFidelityReport.decodeResult|{}decodeResult[0]
+        final fun <get-decodeResult>(): io.github.linreal.cascade.editor.markdown/MarkdownDecodeResult // io.github.linreal.cascade.editor.markdown/MarkdownFidelityReport.decodeResult.<get-decodeResult>|<get-decodeResult>(){}[0]
+    final val encodeResult // io.github.linreal.cascade.editor.markdown/MarkdownFidelityReport.encodeResult|{}encodeResult[0]
+        final fun <get-encodeResult>(): io.github.linreal.cascade.editor.markdown/MarkdownEncodeResult? // io.github.linreal.cascade.editor.markdown/MarkdownFidelityReport.encodeResult.<get-encodeResult>|<get-encodeResult>(){}[0]
+    final val nativeEditingSafe // io.github.linreal.cascade.editor.markdown/MarkdownFidelityReport.nativeEditingSafe|{}nativeEditingSafe[0]
+        final fun <get-nativeEditingSafe>(): kotlin/Boolean // io.github.linreal.cascade.editor.markdown/MarkdownFidelityReport.nativeEditingSafe.<get-nativeEditingSafe>|<get-nativeEditingSafe>(){}[0]
+    final val preservedBlockCount // io.github.linreal.cascade.editor.markdown/MarkdownFidelityReport.preservedBlockCount|{}preservedBlockCount[0]
+        final fun <get-preservedBlockCount>(): kotlin/Int // io.github.linreal.cascade.editor.markdown/MarkdownFidelityReport.preservedBlockCount.<get-preservedBlockCount>|<get-preservedBlockCount>(){}[0]
+    final val recommendedMode // io.github.linreal.cascade.editor.markdown/MarkdownFidelityReport.recommendedMode|{}recommendedMode[0]
+        final fun <get-recommendedMode>(): io.github.linreal.cascade.editor.markdown/MarkdownEditModeRecommendation // io.github.linreal.cascade.editor.markdown/MarkdownFidelityReport.recommendedMode.<get-recommendedMode>|<get-recommendedMode>(){}[0]
+    final val wouldRewriteSource // io.github.linreal.cascade.editor.markdown/MarkdownFidelityReport.wouldRewriteSource|{}wouldRewriteSource[0]
+        final fun <get-wouldRewriteSource>(): kotlin/Boolean? // io.github.linreal.cascade.editor.markdown/MarkdownFidelityReport.wouldRewriteSource.<get-wouldRewriteSource>|<get-wouldRewriteSource>(){}[0]
+
+    final fun toString(): kotlin/String // io.github.linreal.cascade.editor.markdown/MarkdownFidelityReport.toString|toString(){}[0]
+}
+
+final class io.github.linreal.cascade.editor.markdown/MarkdownMarkPair { // io.github.linreal.cascade.editor.markdown/MarkdownMarkPair|null[0]
+    constructor <init>(kotlin/String, kotlin/String) // io.github.linreal.cascade.editor.markdown/MarkdownMarkPair.<init>|<init>(kotlin.String;kotlin.String){}[0]
+
+    final val close // io.github.linreal.cascade.editor.markdown/MarkdownMarkPair.close|{}close[0]
+        final fun <get-close>(): kotlin/String // io.github.linreal.cascade.editor.markdown/MarkdownMarkPair.close.<get-close>|<get-close>(){}[0]
+    final val open // io.github.linreal.cascade.editor.markdown/MarkdownMarkPair.open|{}open[0]
+        final fun <get-open>(): kotlin/String // io.github.linreal.cascade.editor.markdown/MarkdownMarkPair.open.<get-open>|<get-open>(){}[0]
+
+    final fun component1(): kotlin/String // io.github.linreal.cascade.editor.markdown/MarkdownMarkPair.component1|component1(){}[0]
+    final fun component2(): kotlin/String // io.github.linreal.cascade.editor.markdown/MarkdownMarkPair.component2|component2(){}[0]
+    final fun copy(kotlin/String = ..., kotlin/String = ...): io.github.linreal.cascade.editor.markdown/MarkdownMarkPair // io.github.linreal.cascade.editor.markdown/MarkdownMarkPair.copy|copy(kotlin.String;kotlin.String){}[0]
+    final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.markdown/MarkdownMarkPair.equals|equals(kotlin.Any?){}[0]
+    final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.markdown/MarkdownMarkPair.hashCode|hashCode(){}[0]
+    final fun toString(): kotlin/String // io.github.linreal.cascade.editor.markdown/MarkdownMarkPair.toString|toString(){}[0]
+}
+
+final class io.github.linreal.cascade.editor.markdown/MarkdownProfile { // io.github.linreal.cascade.editor.markdown/MarkdownProfile|null[0]
+    final val supportSet // io.github.linreal.cascade.editor.markdown/MarkdownProfile.supportSet|{}supportSet[0]
+        final fun <get-supportSet>(): io.github.linreal.cascade.editor.markdown/MarkdownProfileSupportSet // io.github.linreal.cascade.editor.markdown/MarkdownProfile.supportSet.<get-supportSet>|<get-supportSet>(){}[0]
+
+    final fun withCustomMarkdownBlockEncoder(kotlin/String, io.github.linreal.cascade.editor.markdown/MarkdownBlockEncoder<*>): io.github.linreal.cascade.editor.markdown/MarkdownProfile // io.github.linreal.cascade.editor.markdown/MarkdownProfile.withCustomMarkdownBlockEncoder|withCustomMarkdownBlockEncoder(kotlin.String;io.github.linreal.cascade.editor.markdown.MarkdownBlockEncoder<*>){}[0]
+    final fun withCustomMarkdownSpanEncoder(kotlin/String, io.github.linreal.cascade.editor.markdown/MarkdownSpanEncoder<io.github.linreal.cascade.editor.core/SpanStyle.Custom>): io.github.linreal.cascade.editor.markdown/MarkdownProfile // io.github.linreal.cascade.editor.markdown/MarkdownProfile.withCustomMarkdownSpanEncoder|withCustomMarkdownSpanEncoder(kotlin.String;io.github.linreal.cascade.editor.markdown.MarkdownSpanEncoder<io.github.linreal.cascade.editor.core.SpanStyle.Custom>){}[0]
+    final fun withEncoderBlockFallback(io.github.linreal.cascade.editor.markdown/MarkdownBlockEncoder<io.github.linreal.cascade.editor.core/BlockType>): io.github.linreal.cascade.editor.markdown/MarkdownProfile // io.github.linreal.cascade.editor.markdown/MarkdownProfile.withEncoderBlockFallback|withEncoderBlockFallback(io.github.linreal.cascade.editor.markdown.MarkdownBlockEncoder<io.github.linreal.cascade.editor.core.BlockType>){}[0]
+    final fun withEncoderSpanFallback(io.github.linreal.cascade.editor.markdown/MarkdownSpanEncoder<io.github.linreal.cascade.editor.core/SpanStyle>): io.github.linreal.cascade.editor.markdown/MarkdownProfile // io.github.linreal.cascade.editor.markdown/MarkdownProfile.withEncoderSpanFallback|withEncoderSpanFallback(io.github.linreal.cascade.editor.markdown.MarkdownSpanEncoder<io.github.linreal.cascade.editor.core.SpanStyle>){}[0]
+    final fun withEntityDecode(io.github.linreal.cascade.editor.markdown/EntityDecode): io.github.linreal.cascade.editor.markdown/MarkdownProfile // io.github.linreal.cascade.editor.markdown/MarkdownProfile.withEntityDecode|withEntityDecode(io.github.linreal.cascade.editor.markdown.EntityDecode){}[0]
+    final fun withHardBreakEncode(io.github.linreal.cascade.editor.markdown/HardBreakEncode): io.github.linreal.cascade.editor.markdown/MarkdownProfile // io.github.linreal.cascade.editor.markdown/MarkdownProfile.withHardBreakEncode|withHardBreakEncode(io.github.linreal.cascade.editor.markdown.HardBreakEncode){}[0]
+    final fun withHtmlInMarkdown(io.github.linreal.cascade.editor.markdown/HtmlInMarkdown): io.github.linreal.cascade.editor.markdown/MarkdownProfile // io.github.linreal.cascade.editor.markdown/MarkdownProfile.withHtmlInMarkdown|withHtmlInMarkdown(io.github.linreal.cascade.editor.markdown.HtmlInMarkdown){}[0]
+    final fun withMarkdownBlockEncoderInternal(kotlin.reflect/KClass<out io.github.linreal.cascade.editor.core/BlockType>, io.github.linreal.cascade.editor.markdown/MarkdownBlockEncoder<*>): io.github.linreal.cascade.editor.markdown/MarkdownProfile // io.github.linreal.cascade.editor.markdown/MarkdownProfile.withMarkdownBlockEncoderInternal|withMarkdownBlockEncoderInternal(kotlin.reflect.KClass<out|io.github.linreal.cascade.editor.core.BlockType>;io.github.linreal.cascade.editor.markdown.MarkdownBlockEncoder<*>){}[0]
+    final fun withMarkdownBlockGroupEncoder(kotlin/String, io.github.linreal.cascade.editor.markdown/MarkdownBlockGroupEncoder): io.github.linreal.cascade.editor.markdown/MarkdownProfile // io.github.linreal.cascade.editor.markdown/MarkdownProfile.withMarkdownBlockGroupEncoder|withMarkdownBlockGroupEncoder(kotlin.String;io.github.linreal.cascade.editor.markdown.MarkdownBlockGroupEncoder){}[0]
+    final fun withMarkdownSpanEncoderInternal(kotlin.reflect/KClass<out io.github.linreal.cascade.editor.core/SpanStyle>, io.github.linreal.cascade.editor.markdown/MarkdownSpanEncoder<*>): io.github.linreal.cascade.editor.markdown/MarkdownProfile // io.github.linreal.cascade.editor.markdown/MarkdownProfile.withMarkdownSpanEncoderInternal|withMarkdownSpanEncoderInternal(kotlin.reflect.KClass<out|io.github.linreal.cascade.editor.core.SpanStyle>;io.github.linreal.cascade.editor.markdown.MarkdownSpanEncoder<*>){}[0]
+    final fun withNewlineSemantics(io.github.linreal.cascade.editor.markdown/NewlineSemantics): io.github.linreal.cascade.editor.markdown/MarkdownProfile // io.github.linreal.cascade.editor.markdown/MarkdownProfile.withNewlineSemantics|withNewlineSemantics(io.github.linreal.cascade.editor.markdown.NewlineSemantics){}[0]
+    final fun withSoftBreak(io.github.linreal.cascade.editor.markdown/SoftBreak): io.github.linreal.cascade.editor.markdown/MarkdownProfile // io.github.linreal.cascade.editor.markdown/MarkdownProfile.withSoftBreak|withSoftBreak(io.github.linreal.cascade.editor.markdown.SoftBreak){}[0]
+    final fun withSupportSet(io.github.linreal.cascade.editor.markdown/MarkdownProfileSupportSet): io.github.linreal.cascade.editor.markdown/MarkdownProfile // io.github.linreal.cascade.editor.markdown/MarkdownProfile.withSupportSet|withSupportSet(io.github.linreal.cascade.editor.markdown.MarkdownProfileSupportSet){}[0]
+    final fun withUnsupportedSyntax(io.github.linreal.cascade.editor.markdown/UnsupportedSyntax): io.github.linreal.cascade.editor.markdown/MarkdownProfile // io.github.linreal.cascade.editor.markdown/MarkdownProfile.withUnsupportedSyntax|withUnsupportedSyntax(io.github.linreal.cascade.editor.markdown.UnsupportedSyntax){}[0]
+    final fun withoutHtmlBridge(): io.github.linreal.cascade.editor.markdown/MarkdownProfile // io.github.linreal.cascade.editor.markdown/MarkdownProfile.withoutHtmlBridge|withoutHtmlBridge(){}[0]
+    final fun withoutMarkdownBlockGroupEncoder(kotlin/String): io.github.linreal.cascade.editor.markdown/MarkdownProfile // io.github.linreal.cascade.editor.markdown/MarkdownProfile.withoutMarkdownBlockGroupEncoder|withoutMarkdownBlockGroupEncoder(kotlin.String){}[0]
+    final inline fun <#A1: reified io.github.linreal.cascade.editor.core/BlockType> withMarkdownBlockEncoder(io.github.linreal.cascade.editor.markdown/MarkdownBlockEncoder<#A1>): io.github.linreal.cascade.editor.markdown/MarkdownProfile // io.github.linreal.cascade.editor.markdown/MarkdownProfile.withMarkdownBlockEncoder|withMarkdownBlockEncoder(io.github.linreal.cascade.editor.markdown.MarkdownBlockEncoder<0:0>){0§<io.github.linreal.cascade.editor.core.BlockType>}[0]
+    final inline fun <#A1: reified io.github.linreal.cascade.editor.core/SpanStyle> withMarkdownSpanEncoder(io.github.linreal.cascade.editor.markdown/MarkdownSpanEncoder<#A1>): io.github.linreal.cascade.editor.markdown/MarkdownProfile // io.github.linreal.cascade.editor.markdown/MarkdownProfile.withMarkdownSpanEncoder|withMarkdownSpanEncoder(io.github.linreal.cascade.editor.markdown.MarkdownSpanEncoder<0:0>){0§<io.github.linreal.cascade.editor.core.SpanStyle>}[0]
+
+    final object Companion { // io.github.linreal.cascade.editor.markdown/MarkdownProfile.Companion|null[0]
+        final val Default // io.github.linreal.cascade.editor.markdown/MarkdownProfile.Companion.Default|{}Default[0]
+            final fun <get-Default>(): io.github.linreal.cascade.editor.markdown/MarkdownProfile // io.github.linreal.cascade.editor.markdown/MarkdownProfile.Companion.Default.<get-Default>|<get-Default>(){}[0]
+    }
+}
+
+final class io.github.linreal.cascade.editor.markdown/MarkdownProfileSupportSet { // io.github.linreal.cascade.editor.markdown/MarkdownProfileSupportSet|null[0]
+    constructor <init>(kotlin/Function1<io.github.linreal.cascade.editor.core/Block, kotlin/Boolean>, kotlin/Function1<io.github.linreal.cascade.editor.core/SpanStyle, kotlin/Boolean>, kotlin/Function1<kotlin.collections/List<io.github.linreal.cascade.editor.core/Block>, kotlin/Boolean>) // io.github.linreal.cascade.editor.markdown/MarkdownProfileSupportSet.<init>|<init>(kotlin.Function1<io.github.linreal.cascade.editor.core.Block,kotlin.Boolean>;kotlin.Function1<io.github.linreal.cascade.editor.core.SpanStyle,kotlin.Boolean>;kotlin.Function1<kotlin.collections.List<io.github.linreal.cascade.editor.core.Block>,kotlin.Boolean>){}[0]
+
+    final val supportsBlockPredicate // io.github.linreal.cascade.editor.markdown/MarkdownProfileSupportSet.supportsBlockPredicate|{}supportsBlockPredicate[0]
+        final fun <get-supportsBlockPredicate>(): kotlin/Function1<io.github.linreal.cascade.editor.core/Block, kotlin/Boolean> // io.github.linreal.cascade.editor.markdown/MarkdownProfileSupportSet.supportsBlockPredicate.<get-supportsBlockPredicate>|<get-supportsBlockPredicate>(){}[0]
+    final val supportsDocumentPredicate // io.github.linreal.cascade.editor.markdown/MarkdownProfileSupportSet.supportsDocumentPredicate|{}supportsDocumentPredicate[0]
+        final fun <get-supportsDocumentPredicate>(): kotlin/Function1<kotlin.collections/List<io.github.linreal.cascade.editor.core/Block>, kotlin/Boolean> // io.github.linreal.cascade.editor.markdown/MarkdownProfileSupportSet.supportsDocumentPredicate.<get-supportsDocumentPredicate>|<get-supportsDocumentPredicate>(){}[0]
+    final val supportsSpanPredicate // io.github.linreal.cascade.editor.markdown/MarkdownProfileSupportSet.supportsSpanPredicate|{}supportsSpanPredicate[0]
+        final fun <get-supportsSpanPredicate>(): kotlin/Function1<io.github.linreal.cascade.editor.core/SpanStyle, kotlin/Boolean> // io.github.linreal.cascade.editor.markdown/MarkdownProfileSupportSet.supportsSpanPredicate.<get-supportsSpanPredicate>|<get-supportsSpanPredicate>(){}[0]
+
+    final fun supportsBlock(io.github.linreal.cascade.editor.core/Block): kotlin/Boolean // io.github.linreal.cascade.editor.markdown/MarkdownProfileSupportSet.supportsBlock|supportsBlock(io.github.linreal.cascade.editor.core.Block){}[0]
+    final fun supportsDocument(kotlin.collections/List<io.github.linreal.cascade.editor.core/Block>): kotlin/Boolean // io.github.linreal.cascade.editor.markdown/MarkdownProfileSupportSet.supportsDocument|supportsDocument(kotlin.collections.List<io.github.linreal.cascade.editor.core.Block>){}[0]
+    final fun supportsSpan(io.github.linreal.cascade.editor.core/SpanStyle): kotlin/Boolean // io.github.linreal.cascade.editor.markdown/MarkdownProfileSupportSet.supportsSpan|supportsSpan(io.github.linreal.cascade.editor.core.SpanStyle){}[0]
+
+    final object Companion { // io.github.linreal.cascade.editor.markdown/MarkdownProfileSupportSet.Companion|null[0]
+        final val None // io.github.linreal.cascade.editor.markdown/MarkdownProfileSupportSet.Companion.None|{}None[0]
+            final fun <get-None>(): io.github.linreal.cascade.editor.markdown/MarkdownProfileSupportSet // io.github.linreal.cascade.editor.markdown/MarkdownProfileSupportSet.Companion.None.<get-None>|<get-None>(){}[0]
+    }
+}
+
+final class io.github.linreal.cascade.editor.markdown/MarkdownSourceLocation { // io.github.linreal.cascade.editor.markdown/MarkdownSourceLocation|null[0]
+    constructor <init>(kotlin/Int, kotlin/Int) // io.github.linreal.cascade.editor.markdown/MarkdownSourceLocation.<init>|<init>(kotlin.Int;kotlin.Int){}[0]
+
+    final val column // io.github.linreal.cascade.editor.markdown/MarkdownSourceLocation.column|{}column[0]
+        final fun <get-column>(): kotlin/Int // io.github.linreal.cascade.editor.markdown/MarkdownSourceLocation.column.<get-column>|<get-column>(){}[0]
+    final val line // io.github.linreal.cascade.editor.markdown/MarkdownSourceLocation.line|{}line[0]
+        final fun <get-line>(): kotlin/Int // io.github.linreal.cascade.editor.markdown/MarkdownSourceLocation.line.<get-line>|<get-line>(){}[0]
+
+    final fun component1(): kotlin/Int // io.github.linreal.cascade.editor.markdown/MarkdownSourceLocation.component1|component1(){}[0]
+    final fun component2(): kotlin/Int // io.github.linreal.cascade.editor.markdown/MarkdownSourceLocation.component2|component2(){}[0]
+    final fun copy(kotlin/Int = ..., kotlin/Int = ...): io.github.linreal.cascade.editor.markdown/MarkdownSourceLocation // io.github.linreal.cascade.editor.markdown/MarkdownSourceLocation.copy|copy(kotlin.Int;kotlin.Int){}[0]
+    final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.markdown/MarkdownSourceLocation.equals|equals(kotlin.Any?){}[0]
+    final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.markdown/MarkdownSourceLocation.hashCode|hashCode(){}[0]
+    final fun toString(): kotlin/String // io.github.linreal.cascade.editor.markdown/MarkdownSourceLocation.toString|toString(){}[0]
+}
+
+final class io.github.linreal.cascade.editor.markdown/MarkdownSourceLocator { // io.github.linreal.cascade.editor.markdown/MarkdownSourceLocator|null[0]
+    final fun locate(io.github.linreal.cascade.editor.markdown/MarkdownSourceRange): io.github.linreal.cascade.editor.markdown/MarkdownSourceLocation // io.github.linreal.cascade.editor.markdown/MarkdownSourceLocator.locate|locate(io.github.linreal.cascade.editor.markdown.MarkdownSourceRange){}[0]
+    final fun locate(kotlin/Int): io.github.linreal.cascade.editor.markdown/MarkdownSourceLocation // io.github.linreal.cascade.editor.markdown/MarkdownSourceLocator.locate|locate(kotlin.Int){}[0]
+}
+
+final class io.github.linreal.cascade.editor.markdown/MarkdownSourceRange { // io.github.linreal.cascade.editor.markdown/MarkdownSourceRange|null[0]
+    constructor <init>(kotlin/Int, kotlin/Int) // io.github.linreal.cascade.editor.markdown/MarkdownSourceRange.<init>|<init>(kotlin.Int;kotlin.Int){}[0]
+
+    final val endExclusive // io.github.linreal.cascade.editor.markdown/MarkdownSourceRange.endExclusive|{}endExclusive[0]
+        final fun <get-endExclusive>(): kotlin/Int // io.github.linreal.cascade.editor.markdown/MarkdownSourceRange.endExclusive.<get-endExclusive>|<get-endExclusive>(){}[0]
+    final val isEmpty // io.github.linreal.cascade.editor.markdown/MarkdownSourceRange.isEmpty|{}isEmpty[0]
+        final fun <get-isEmpty>(): kotlin/Boolean // io.github.linreal.cascade.editor.markdown/MarkdownSourceRange.isEmpty.<get-isEmpty>|<get-isEmpty>(){}[0]
+    final val length // io.github.linreal.cascade.editor.markdown/MarkdownSourceRange.length|{}length[0]
+        final fun <get-length>(): kotlin/Int // io.github.linreal.cascade.editor.markdown/MarkdownSourceRange.length.<get-length>|<get-length>(){}[0]
+    final val start // io.github.linreal.cascade.editor.markdown/MarkdownSourceRange.start|{}start[0]
+        final fun <get-start>(): kotlin/Int // io.github.linreal.cascade.editor.markdown/MarkdownSourceRange.start.<get-start>|<get-start>(){}[0]
+
+    final fun component1(): kotlin/Int // io.github.linreal.cascade.editor.markdown/MarkdownSourceRange.component1|component1(){}[0]
+    final fun component2(): kotlin/Int // io.github.linreal.cascade.editor.markdown/MarkdownSourceRange.component2|component2(){}[0]
+    final fun copy(kotlin/Int = ..., kotlin/Int = ...): io.github.linreal.cascade.editor.markdown/MarkdownSourceRange // io.github.linreal.cascade.editor.markdown/MarkdownSourceRange.copy|copy(kotlin.Int;kotlin.Int){}[0]
+    final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.markdown/MarkdownSourceRange.equals|equals(kotlin.Any?){}[0]
+    final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.markdown/MarkdownSourceRange.hashCode|hashCode(){}[0]
+    final fun toString(): kotlin/String // io.github.linreal.cascade.editor.markdown/MarkdownSourceRange.toString|toString(){}[0]
+}
+
+final class io.github.linreal.cascade.editor.markdown/MarkdownTextRange { // io.github.linreal.cascade.editor.markdown/MarkdownTextRange|null[0]
+    constructor <init>(kotlin/Int, kotlin/Int) // io.github.linreal.cascade.editor.markdown/MarkdownTextRange.<init>|<init>(kotlin.Int;kotlin.Int){}[0]
+
+    final val endExclusive // io.github.linreal.cascade.editor.markdown/MarkdownTextRange.endExclusive|{}endExclusive[0]
+        final fun <get-endExclusive>(): kotlin/Int // io.github.linreal.cascade.editor.markdown/MarkdownTextRange.endExclusive.<get-endExclusive>|<get-endExclusive>(){}[0]
+    final val start // io.github.linreal.cascade.editor.markdown/MarkdownTextRange.start|{}start[0]
+        final fun <get-start>(): kotlin/Int // io.github.linreal.cascade.editor.markdown/MarkdownTextRange.start.<get-start>|<get-start>(){}[0]
+
+    final fun component1(): kotlin/Int // io.github.linreal.cascade.editor.markdown/MarkdownTextRange.component1|component1(){}[0]
+    final fun component2(): kotlin/Int // io.github.linreal.cascade.editor.markdown/MarkdownTextRange.component2|component2(){}[0]
+    final fun copy(kotlin/Int = ..., kotlin/Int = ...): io.github.linreal.cascade.editor.markdown/MarkdownTextRange // io.github.linreal.cascade.editor.markdown/MarkdownTextRange.copy|copy(kotlin.Int;kotlin.Int){}[0]
+    final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.markdown/MarkdownTextRange.equals|equals(kotlin.Any?){}[0]
+    final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.markdown/MarkdownTextRange.hashCode|hashCode(){}[0]
+    final fun toString(): kotlin/String // io.github.linreal.cascade.editor.markdown/MarkdownTextRange.toString|toString(){}[0]
+}
+
 final class io.github.linreal.cascade.editor.registry/BlockDescriptor { // io.github.linreal.cascade.editor.registry/BlockDescriptor|null[0]
     constructor <init>(kotlin/String, kotlin/String, kotlin/String, kotlin.collections/List<kotlin/String> = ..., kotlin/String? = ..., io.github.linreal.cascade.editor.slash/BuiltInSlashCommandSpec? = ..., kotlin/Function1<io.github.linreal.cascade.editor.core/BlockId, io.github.linreal.cascade.editor.core/Block>) // io.github.linreal.cascade.editor.registry/BlockDescriptor.<init>|<init>(kotlin.String;kotlin.String;kotlin.String;kotlin.collections.List<kotlin.String>;kotlin.String?;io.github.linreal.cascade.editor.slash.BuiltInSlashCommandSpec?;kotlin.Function1<io.github.linreal.cascade.editor.core.BlockId,io.github.linreal.cascade.editor.core.Block>){}[0]
 
@@ -2838,6 +3372,411 @@ sealed class io.github.linreal.cascade.editor.htmlserialization/HtmlEncodeWarnin
     }
 }
 
+sealed class io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning : io.github.linreal.cascade.editor.markdown/MarkdownWarning { // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning|null[0]
+    abstract val range // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.range|{}range[0]
+        abstract fun <get-range>(): io.github.linreal.cascade.editor.markdown/MarkdownSourceRange // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.range.<get-range>|<get-range>(){}[0]
+
+    final class DroppedAttribute : io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning { // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.DroppedAttribute|null[0]
+        constructor <init>(kotlin/String, kotlin/String, kotlin/String, io.github.linreal.cascade.editor.markdown/MarkdownSourceRange) // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.DroppedAttribute.<init>|<init>(kotlin.String;kotlin.String;kotlin.String;io.github.linreal.cascade.editor.markdown.MarkdownSourceRange){}[0]
+
+        final val attr // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.DroppedAttribute.attr|{}attr[0]
+            final fun <get-attr>(): kotlin/String // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.DroppedAttribute.attr.<get-attr>|<get-attr>(){}[0]
+        final val construct // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.DroppedAttribute.construct|{}construct[0]
+            final fun <get-construct>(): kotlin/String // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.DroppedAttribute.construct.<get-construct>|<get-construct>(){}[0]
+        final val impact // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.DroppedAttribute.impact|{}impact[0]
+            final fun <get-impact>(): io.github.linreal.cascade.editor.markdown/MarkdownFidelityImpact // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.DroppedAttribute.impact.<get-impact>|<get-impact>(){}[0]
+        final val range // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.DroppedAttribute.range|{}range[0]
+            final fun <get-range>(): io.github.linreal.cascade.editor.markdown/MarkdownSourceRange // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.DroppedAttribute.range.<get-range>|<get-range>(){}[0]
+        final val reason // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.DroppedAttribute.reason|{}reason[0]
+            final fun <get-reason>(): kotlin/String // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.DroppedAttribute.reason.<get-reason>|<get-reason>(){}[0]
+
+        final fun component1(): kotlin/String // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.DroppedAttribute.component1|component1(){}[0]
+        final fun component2(): kotlin/String // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.DroppedAttribute.component2|component2(){}[0]
+        final fun component3(): kotlin/String // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.DroppedAttribute.component3|component3(){}[0]
+        final fun component4(): io.github.linreal.cascade.editor.markdown/MarkdownSourceRange // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.DroppedAttribute.component4|component4(){}[0]
+        final fun copy(kotlin/String = ..., kotlin/String = ..., kotlin/String = ..., io.github.linreal.cascade.editor.markdown/MarkdownSourceRange = ...): io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.DroppedAttribute // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.DroppedAttribute.copy|copy(kotlin.String;kotlin.String;kotlin.String;io.github.linreal.cascade.editor.markdown.MarkdownSourceRange){}[0]
+        final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.DroppedAttribute.equals|equals(kotlin.Any?){}[0]
+        final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.DroppedAttribute.hashCode|hashCode(){}[0]
+        final fun toString(): kotlin/String // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.DroppedAttribute.toString|toString(){}[0]
+    }
+
+    final class DuplicateLinkDefinition : io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning { // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.DuplicateLinkDefinition|null[0]
+        constructor <init>(kotlin/String, io.github.linreal.cascade.editor.markdown/MarkdownSourceRange) // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.DuplicateLinkDefinition.<init>|<init>(kotlin.String;io.github.linreal.cascade.editor.markdown.MarkdownSourceRange){}[0]
+
+        final val impact // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.DuplicateLinkDefinition.impact|{}impact[0]
+            final fun <get-impact>(): io.github.linreal.cascade.editor.markdown/MarkdownFidelityImpact // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.DuplicateLinkDefinition.impact.<get-impact>|<get-impact>(){}[0]
+        final val label // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.DuplicateLinkDefinition.label|{}label[0]
+            final fun <get-label>(): kotlin/String // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.DuplicateLinkDefinition.label.<get-label>|<get-label>(){}[0]
+        final val range // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.DuplicateLinkDefinition.range|{}range[0]
+            final fun <get-range>(): io.github.linreal.cascade.editor.markdown/MarkdownSourceRange // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.DuplicateLinkDefinition.range.<get-range>|<get-range>(){}[0]
+
+        final fun component1(): kotlin/String // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.DuplicateLinkDefinition.component1|component1(){}[0]
+        final fun component2(): io.github.linreal.cascade.editor.markdown/MarkdownSourceRange // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.DuplicateLinkDefinition.component2|component2(){}[0]
+        final fun copy(kotlin/String = ..., io.github.linreal.cascade.editor.markdown/MarkdownSourceRange = ...): io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.DuplicateLinkDefinition // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.DuplicateLinkDefinition.copy|copy(kotlin.String;io.github.linreal.cascade.editor.markdown.MarkdownSourceRange){}[0]
+        final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.DuplicateLinkDefinition.equals|equals(kotlin.Any?){}[0]
+        final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.DuplicateLinkDefinition.hashCode|hashCode(){}[0]
+        final fun toString(): kotlin/String // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.DuplicateLinkDefinition.toString|toString(){}[0]
+    }
+
+    final class EngineFailure : io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning { // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.EngineFailure|null[0]
+        constructor <init>(kotlin/String, io.github.linreal.cascade.editor.markdown/MarkdownSourceRange = ...) // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.EngineFailure.<init>|<init>(kotlin.String;io.github.linreal.cascade.editor.markdown.MarkdownSourceRange){}[0]
+
+        final val impact // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.EngineFailure.impact|{}impact[0]
+            final fun <get-impact>(): io.github.linreal.cascade.editor.markdown/MarkdownFidelityImpact // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.EngineFailure.impact.<get-impact>|<get-impact>(){}[0]
+        final val message // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.EngineFailure.message|{}message[0]
+            final fun <get-message>(): kotlin/String // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.EngineFailure.message.<get-message>|<get-message>(){}[0]
+        final val range // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.EngineFailure.range|{}range[0]
+            final fun <get-range>(): io.github.linreal.cascade.editor.markdown/MarkdownSourceRange // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.EngineFailure.range.<get-range>|<get-range>(){}[0]
+
+        final fun component1(): kotlin/String // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.EngineFailure.component1|component1(){}[0]
+        final fun component2(): io.github.linreal.cascade.editor.markdown/MarkdownSourceRange // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.EngineFailure.component2|component2(){}[0]
+        final fun copy(kotlin/String = ..., io.github.linreal.cascade.editor.markdown/MarkdownSourceRange = ...): io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.EngineFailure // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.EngineFailure.copy|copy(kotlin.String;io.github.linreal.cascade.editor.markdown.MarkdownSourceRange){}[0]
+        final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.EngineFailure.equals|equals(kotlin.Any?){}[0]
+        final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.EngineFailure.hashCode|hashCode(){}[0]
+        final fun toString(): kotlin/String // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.EngineFailure.toString|toString(){}[0]
+    }
+
+    final class HtmlBridged : io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning { // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.HtmlBridged|null[0]
+        constructor <init>(io.github.linreal.cascade.editor.markdown/MarkdownSourceRange) // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.HtmlBridged.<init>|<init>(io.github.linreal.cascade.editor.markdown.MarkdownSourceRange){}[0]
+
+        final val impact // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.HtmlBridged.impact|{}impact[0]
+            final fun <get-impact>(): io.github.linreal.cascade.editor.markdown/MarkdownFidelityImpact // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.HtmlBridged.impact.<get-impact>|<get-impact>(){}[0]
+        final val range // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.HtmlBridged.range|{}range[0]
+            final fun <get-range>(): io.github.linreal.cascade.editor.markdown/MarkdownSourceRange // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.HtmlBridged.range.<get-range>|<get-range>(){}[0]
+
+        final fun component1(): io.github.linreal.cascade.editor.markdown/MarkdownSourceRange // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.HtmlBridged.component1|component1(){}[0]
+        final fun copy(io.github.linreal.cascade.editor.markdown/MarkdownSourceRange = ...): io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.HtmlBridged // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.HtmlBridged.copy|copy(io.github.linreal.cascade.editor.markdown.MarkdownSourceRange){}[0]
+        final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.HtmlBridged.equals|equals(kotlin.Any?){}[0]
+        final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.HtmlBridged.hashCode|hashCode(){}[0]
+        final fun toString(): kotlin/String // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.HtmlBridged.toString|toString(){}[0]
+    }
+
+    final class HtmlStripped : io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning { // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.HtmlStripped|null[0]
+        constructor <init>(kotlin/String?, io.github.linreal.cascade.editor.markdown/MarkdownSourceRange) // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.HtmlStripped.<init>|<init>(kotlin.String?;io.github.linreal.cascade.editor.markdown.MarkdownSourceRange){}[0]
+
+        final val impact // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.HtmlStripped.impact|{}impact[0]
+            final fun <get-impact>(): io.github.linreal.cascade.editor.markdown/MarkdownFidelityImpact // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.HtmlStripped.impact.<get-impact>|<get-impact>(){}[0]
+        final val range // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.HtmlStripped.range|{}range[0]
+            final fun <get-range>(): io.github.linreal.cascade.editor.markdown/MarkdownSourceRange // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.HtmlStripped.range.<get-range>|<get-range>(){}[0]
+        final val tag // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.HtmlStripped.tag|{}tag[0]
+            final fun <get-tag>(): kotlin/String? // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.HtmlStripped.tag.<get-tag>|<get-tag>(){}[0]
+
+        final fun component1(): kotlin/String? // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.HtmlStripped.component1|component1(){}[0]
+        final fun component2(): io.github.linreal.cascade.editor.markdown/MarkdownSourceRange // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.HtmlStripped.component2|component2(){}[0]
+        final fun copy(kotlin/String? = ..., io.github.linreal.cascade.editor.markdown/MarkdownSourceRange = ...): io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.HtmlStripped // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.HtmlStripped.copy|copy(kotlin.String?;io.github.linreal.cascade.editor.markdown.MarkdownSourceRange){}[0]
+        final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.HtmlStripped.equals|equals(kotlin.Any?){}[0]
+        final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.HtmlStripped.hashCode|hashCode(){}[0]
+        final fun toString(): kotlin/String // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.HtmlStripped.toString|toString(){}[0]
+    }
+
+    final class InputLimitExceeded : io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning { // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.InputLimitExceeded|null[0]
+        constructor <init>(kotlin/Int, kotlin/Int, io.github.linreal.cascade.editor.markdown/MarkdownSourceRange = ...) // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.InputLimitExceeded.<init>|<init>(kotlin.Int;kotlin.Int;io.github.linreal.cascade.editor.markdown.MarkdownSourceRange){}[0]
+
+        final val actual // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.InputLimitExceeded.actual|{}actual[0]
+            final fun <get-actual>(): kotlin/Int // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.InputLimitExceeded.actual.<get-actual>|<get-actual>(){}[0]
+        final val impact // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.InputLimitExceeded.impact|{}impact[0]
+            final fun <get-impact>(): io.github.linreal.cascade.editor.markdown/MarkdownFidelityImpact // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.InputLimitExceeded.impact.<get-impact>|<get-impact>(){}[0]
+        final val limit // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.InputLimitExceeded.limit|{}limit[0]
+            final fun <get-limit>(): kotlin/Int // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.InputLimitExceeded.limit.<get-limit>|<get-limit>(){}[0]
+        final val range // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.InputLimitExceeded.range|{}range[0]
+            final fun <get-range>(): io.github.linreal.cascade.editor.markdown/MarkdownSourceRange // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.InputLimitExceeded.range.<get-range>|<get-range>(){}[0]
+
+        final fun component1(): kotlin/Int // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.InputLimitExceeded.component1|component1(){}[0]
+        final fun component2(): kotlin/Int // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.InputLimitExceeded.component2|component2(){}[0]
+        final fun component3(): io.github.linreal.cascade.editor.markdown/MarkdownSourceRange // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.InputLimitExceeded.component3|component3(){}[0]
+        final fun copy(kotlin/Int = ..., kotlin/Int = ..., io.github.linreal.cascade.editor.markdown/MarkdownSourceRange = ...): io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.InputLimitExceeded // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.InputLimitExceeded.copy|copy(kotlin.Int;kotlin.Int;io.github.linreal.cascade.editor.markdown.MarkdownSourceRange){}[0]
+        final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.InputLimitExceeded.equals|equals(kotlin.Any?){}[0]
+        final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.InputLimitExceeded.hashCode|hashCode(){}[0]
+        final fun toString(): kotlin/String // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.InputLimitExceeded.toString|toString(){}[0]
+    }
+
+    final class LimitExceeded : io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning { // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.LimitExceeded|null[0]
+        constructor <init>(io.github.linreal.cascade.editor.markdown/MarkdownCodecLimitKind, kotlin/Int, io.github.linreal.cascade.editor.markdown/MarkdownSourceRange) // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.LimitExceeded.<init>|<init>(io.github.linreal.cascade.editor.markdown.MarkdownCodecLimitKind;kotlin.Int;io.github.linreal.cascade.editor.markdown.MarkdownSourceRange){}[0]
+
+        final val impact // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.LimitExceeded.impact|{}impact[0]
+            final fun <get-impact>(): io.github.linreal.cascade.editor.markdown/MarkdownFidelityImpact // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.LimitExceeded.impact.<get-impact>|<get-impact>(){}[0]
+        final val kind // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.LimitExceeded.kind|{}kind[0]
+            final fun <get-kind>(): io.github.linreal.cascade.editor.markdown/MarkdownCodecLimitKind // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.LimitExceeded.kind.<get-kind>|<get-kind>(){}[0]
+        final val limit // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.LimitExceeded.limit|{}limit[0]
+            final fun <get-limit>(): kotlin/Int // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.LimitExceeded.limit.<get-limit>|<get-limit>(){}[0]
+        final val range // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.LimitExceeded.range|{}range[0]
+            final fun <get-range>(): io.github.linreal.cascade.editor.markdown/MarkdownSourceRange // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.LimitExceeded.range.<get-range>|<get-range>(){}[0]
+
+        final fun component1(): io.github.linreal.cascade.editor.markdown/MarkdownCodecLimitKind // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.LimitExceeded.component1|component1(){}[0]
+        final fun component2(): kotlin/Int // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.LimitExceeded.component2|component2(){}[0]
+        final fun component3(): io.github.linreal.cascade.editor.markdown/MarkdownSourceRange // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.LimitExceeded.component3|component3(){}[0]
+        final fun copy(io.github.linreal.cascade.editor.markdown/MarkdownCodecLimitKind = ..., kotlin/Int = ..., io.github.linreal.cascade.editor.markdown/MarkdownSourceRange = ...): io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.LimitExceeded // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.LimitExceeded.copy|copy(io.github.linreal.cascade.editor.markdown.MarkdownCodecLimitKind;kotlin.Int;io.github.linreal.cascade.editor.markdown.MarkdownSourceRange){}[0]
+        final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.LimitExceeded.equals|equals(kotlin.Any?){}[0]
+        final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.LimitExceeded.hashCode|hashCode(){}[0]
+        final fun toString(): kotlin/String // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.LimitExceeded.toString|toString(){}[0]
+    }
+
+    final class PreservedSyntax : io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning { // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.PreservedSyntax|null[0]
+        constructor <init>(kotlin/String, io.github.linreal.cascade.editor.markdown/MarkdownSourceRange) // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.PreservedSyntax.<init>|<init>(kotlin.String;io.github.linreal.cascade.editor.markdown.MarkdownSourceRange){}[0]
+
+        final val impact // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.PreservedSyntax.impact|{}impact[0]
+            final fun <get-impact>(): io.github.linreal.cascade.editor.markdown/MarkdownFidelityImpact // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.PreservedSyntax.impact.<get-impact>|<get-impact>(){}[0]
+        final val kind // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.PreservedSyntax.kind|{}kind[0]
+            final fun <get-kind>(): kotlin/String // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.PreservedSyntax.kind.<get-kind>|<get-kind>(){}[0]
+        final val range // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.PreservedSyntax.range|{}range[0]
+            final fun <get-range>(): io.github.linreal.cascade.editor.markdown/MarkdownSourceRange // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.PreservedSyntax.range.<get-range>|<get-range>(){}[0]
+
+        final fun component1(): kotlin/String // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.PreservedSyntax.component1|component1(){}[0]
+        final fun component2(): io.github.linreal.cascade.editor.markdown/MarkdownSourceRange // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.PreservedSyntax.component2|component2(){}[0]
+        final fun copy(kotlin/String = ..., io.github.linreal.cascade.editor.markdown/MarkdownSourceRange = ...): io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.PreservedSyntax // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.PreservedSyntax.copy|copy(kotlin.String;io.github.linreal.cascade.editor.markdown.MarkdownSourceRange){}[0]
+        final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.PreservedSyntax.equals|equals(kotlin.Any?){}[0]
+        final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.PreservedSyntax.hashCode|hashCode(){}[0]
+        final fun toString(): kotlin/String // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.PreservedSyntax.toString|toString(){}[0]
+    }
+
+    final class UnsupportedEntity : io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning { // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.UnsupportedEntity|null[0]
+        constructor <init>(kotlin/String, io.github.linreal.cascade.editor.markdown/MarkdownSourceRange) // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.UnsupportedEntity.<init>|<init>(kotlin.String;io.github.linreal.cascade.editor.markdown.MarkdownSourceRange){}[0]
+
+        final val impact // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.UnsupportedEntity.impact|{}impact[0]
+            final fun <get-impact>(): io.github.linreal.cascade.editor.markdown/MarkdownFidelityImpact // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.UnsupportedEntity.impact.<get-impact>|<get-impact>(){}[0]
+        final val name // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.UnsupportedEntity.name|{}name[0]
+            final fun <get-name>(): kotlin/String // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.UnsupportedEntity.name.<get-name>|<get-name>(){}[0]
+        final val range // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.UnsupportedEntity.range|{}range[0]
+            final fun <get-range>(): io.github.linreal.cascade.editor.markdown/MarkdownSourceRange // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.UnsupportedEntity.range.<get-range>|<get-range>(){}[0]
+
+        final fun component1(): kotlin/String // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.UnsupportedEntity.component1|component1(){}[0]
+        final fun component2(): io.github.linreal.cascade.editor.markdown/MarkdownSourceRange // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.UnsupportedEntity.component2|component2(){}[0]
+        final fun copy(kotlin/String = ..., io.github.linreal.cascade.editor.markdown/MarkdownSourceRange = ...): io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.UnsupportedEntity // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.UnsupportedEntity.copy|copy(kotlin.String;io.github.linreal.cascade.editor.markdown.MarkdownSourceRange){}[0]
+        final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.UnsupportedEntity.equals|equals(kotlin.Any?){}[0]
+        final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.UnsupportedEntity.hashCode|hashCode(){}[0]
+        final fun toString(): kotlin/String // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.UnsupportedEntity.toString|toString(){}[0]
+    }
+
+    final class UnsupportedSyntax : io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning { // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.UnsupportedSyntax|null[0]
+        constructor <init>(kotlin/String, kotlin/String, io.github.linreal.cascade.editor.markdown/MarkdownSourceRange) // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.UnsupportedSyntax.<init>|<init>(kotlin.String;kotlin.String;io.github.linreal.cascade.editor.markdown.MarkdownSourceRange){}[0]
+
+        final val construct // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.UnsupportedSyntax.construct|{}construct[0]
+            final fun <get-construct>(): kotlin/String // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.UnsupportedSyntax.construct.<get-construct>|<get-construct>(){}[0]
+        final val detail // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.UnsupportedSyntax.detail|{}detail[0]
+            final fun <get-detail>(): kotlin/String // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.UnsupportedSyntax.detail.<get-detail>|<get-detail>(){}[0]
+        final val impact // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.UnsupportedSyntax.impact|{}impact[0]
+            final fun <get-impact>(): io.github.linreal.cascade.editor.markdown/MarkdownFidelityImpact // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.UnsupportedSyntax.impact.<get-impact>|<get-impact>(){}[0]
+        final val range // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.UnsupportedSyntax.range|{}range[0]
+            final fun <get-range>(): io.github.linreal.cascade.editor.markdown/MarkdownSourceRange // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.UnsupportedSyntax.range.<get-range>|<get-range>(){}[0]
+
+        final fun component1(): kotlin/String // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.UnsupportedSyntax.component1|component1(){}[0]
+        final fun component2(): kotlin/String // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.UnsupportedSyntax.component2|component2(){}[0]
+        final fun component3(): io.github.linreal.cascade.editor.markdown/MarkdownSourceRange // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.UnsupportedSyntax.component3|component3(){}[0]
+        final fun copy(kotlin/String = ..., kotlin/String = ..., io.github.linreal.cascade.editor.markdown/MarkdownSourceRange = ...): io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.UnsupportedSyntax // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.UnsupportedSyntax.copy|copy(kotlin.String;kotlin.String;io.github.linreal.cascade.editor.markdown.MarkdownSourceRange){}[0]
+        final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.UnsupportedSyntax.equals|equals(kotlin.Any?){}[0]
+        final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.UnsupportedSyntax.hashCode|hashCode(){}[0]
+        final fun toString(): kotlin/String // io.github.linreal.cascade.editor.markdown/MarkdownDecodeWarning.UnsupportedSyntax.toString|toString(){}[0]
+    }
+}
+
+sealed class io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning : io.github.linreal.cascade.editor.markdown/MarkdownWarning { // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning|null[0]
+    abstract val blockId // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.blockId|{}blockId[0]
+        abstract fun <get-blockId>(): io.github.linreal.cascade.editor.core/BlockId? // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.blockId.<get-blockId>|<get-blockId>(){}[0]
+    abstract val textRange // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.textRange|{}textRange[0]
+        abstract fun <get-textRange>(): io.github.linreal.cascade.editor.markdown/MarkdownTextRange? // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.textRange.<get-textRange>|<get-textRange>(){}[0]
+
+    final class AmbiguousEmphasis : io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning { // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.AmbiguousEmphasis|null[0]
+        constructor <init>(io.github.linreal.cascade.editor.core/BlockId?, io.github.linreal.cascade.editor.markdown/MarkdownTextRange?) // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.AmbiguousEmphasis.<init>|<init>(io.github.linreal.cascade.editor.core.BlockId?;io.github.linreal.cascade.editor.markdown.MarkdownTextRange?){}[0]
+
+        final val blockId // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.AmbiguousEmphasis.blockId|{}blockId[0]
+            final fun <get-blockId>(): io.github.linreal.cascade.editor.core/BlockId? // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.AmbiguousEmphasis.blockId.<get-blockId>|<get-blockId>(){}[0]
+        final val impact // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.AmbiguousEmphasis.impact|{}impact[0]
+            final fun <get-impact>(): io.github.linreal.cascade.editor.markdown/MarkdownFidelityImpact // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.AmbiguousEmphasis.impact.<get-impact>|<get-impact>(){}[0]
+        final val textRange // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.AmbiguousEmphasis.textRange|{}textRange[0]
+            final fun <get-textRange>(): io.github.linreal.cascade.editor.markdown/MarkdownTextRange? // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.AmbiguousEmphasis.textRange.<get-textRange>|<get-textRange>(){}[0]
+
+        final fun component1(): io.github.linreal.cascade.editor.core/BlockId? // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.AmbiguousEmphasis.component1|component1(){}[0]
+        final fun component2(): io.github.linreal.cascade.editor.markdown/MarkdownTextRange? // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.AmbiguousEmphasis.component2|component2(){}[0]
+        final fun copy(io.github.linreal.cascade.editor.core/BlockId? = ..., io.github.linreal.cascade.editor.markdown/MarkdownTextRange? = ...): io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.AmbiguousEmphasis // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.AmbiguousEmphasis.copy|copy(io.github.linreal.cascade.editor.core.BlockId?;io.github.linreal.cascade.editor.markdown.MarkdownTextRange?){}[0]
+        final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.AmbiguousEmphasis.equals|equals(kotlin.Any?){}[0]
+        final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.AmbiguousEmphasis.hashCode|hashCode(){}[0]
+        final fun toString(): kotlin/String // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.AmbiguousEmphasis.toString|toString(){}[0]
+    }
+
+    final class DroppedAttribute : io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning { // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.DroppedAttribute|null[0]
+        constructor <init>(kotlin/String, kotlin/String, io.github.linreal.cascade.editor.core/BlockId?, io.github.linreal.cascade.editor.markdown/MarkdownTextRange? = ...) // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.DroppedAttribute.<init>|<init>(kotlin.String;kotlin.String;io.github.linreal.cascade.editor.core.BlockId?;io.github.linreal.cascade.editor.markdown.MarkdownTextRange?){}[0]
+
+        final val attr // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.DroppedAttribute.attr|{}attr[0]
+            final fun <get-attr>(): kotlin/String // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.DroppedAttribute.attr.<get-attr>|<get-attr>(){}[0]
+        final val blockId // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.DroppedAttribute.blockId|{}blockId[0]
+            final fun <get-blockId>(): io.github.linreal.cascade.editor.core/BlockId? // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.DroppedAttribute.blockId.<get-blockId>|<get-blockId>(){}[0]
+        final val impact // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.DroppedAttribute.impact|{}impact[0]
+            final fun <get-impact>(): io.github.linreal.cascade.editor.markdown/MarkdownFidelityImpact // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.DroppedAttribute.impact.<get-impact>|<get-impact>(){}[0]
+        final val reason // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.DroppedAttribute.reason|{}reason[0]
+            final fun <get-reason>(): kotlin/String // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.DroppedAttribute.reason.<get-reason>|<get-reason>(){}[0]
+        final val textRange // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.DroppedAttribute.textRange|{}textRange[0]
+            final fun <get-textRange>(): io.github.linreal.cascade.editor.markdown/MarkdownTextRange? // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.DroppedAttribute.textRange.<get-textRange>|<get-textRange>(){}[0]
+
+        final fun component1(): kotlin/String // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.DroppedAttribute.component1|component1(){}[0]
+        final fun component2(): kotlin/String // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.DroppedAttribute.component2|component2(){}[0]
+        final fun component3(): io.github.linreal.cascade.editor.core/BlockId? // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.DroppedAttribute.component3|component3(){}[0]
+        final fun component4(): io.github.linreal.cascade.editor.markdown/MarkdownTextRange? // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.DroppedAttribute.component4|component4(){}[0]
+        final fun copy(kotlin/String = ..., kotlin/String = ..., io.github.linreal.cascade.editor.core/BlockId? = ..., io.github.linreal.cascade.editor.markdown/MarkdownTextRange? = ...): io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.DroppedAttribute // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.DroppedAttribute.copy|copy(kotlin.String;kotlin.String;io.github.linreal.cascade.editor.core.BlockId?;io.github.linreal.cascade.editor.markdown.MarkdownTextRange?){}[0]
+        final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.DroppedAttribute.equals|equals(kotlin.Any?){}[0]
+        final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.DroppedAttribute.hashCode|hashCode(){}[0]
+        final fun toString(): kotlin/String // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.DroppedAttribute.toString|toString(){}[0]
+    }
+
+    final class DroppedSpanOverlap : io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning { // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.DroppedSpanOverlap|null[0]
+        constructor <init>(io.github.linreal.cascade.editor.core/BlockId?, io.github.linreal.cascade.editor.markdown/MarkdownTextRange?, kotlin/String) // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.DroppedSpanOverlap.<init>|<init>(io.github.linreal.cascade.editor.core.BlockId?;io.github.linreal.cascade.editor.markdown.MarkdownTextRange?;kotlin.String){}[0]
+
+        final val blockId // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.DroppedSpanOverlap.blockId|{}blockId[0]
+            final fun <get-blockId>(): io.github.linreal.cascade.editor.core/BlockId? // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.DroppedSpanOverlap.blockId.<get-blockId>|<get-blockId>(){}[0]
+        final val impact // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.DroppedSpanOverlap.impact|{}impact[0]
+            final fun <get-impact>(): io.github.linreal.cascade.editor.markdown/MarkdownFidelityImpact // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.DroppedSpanOverlap.impact.<get-impact>|<get-impact>(){}[0]
+        final val reason // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.DroppedSpanOverlap.reason|{}reason[0]
+            final fun <get-reason>(): kotlin/String // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.DroppedSpanOverlap.reason.<get-reason>|<get-reason>(){}[0]
+        final val textRange // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.DroppedSpanOverlap.textRange|{}textRange[0]
+            final fun <get-textRange>(): io.github.linreal.cascade.editor.markdown/MarkdownTextRange? // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.DroppedSpanOverlap.textRange.<get-textRange>|<get-textRange>(){}[0]
+
+        final fun component1(): io.github.linreal.cascade.editor.core/BlockId? // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.DroppedSpanOverlap.component1|component1(){}[0]
+        final fun component2(): io.github.linreal.cascade.editor.markdown/MarkdownTextRange? // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.DroppedSpanOverlap.component2|component2(){}[0]
+        final fun component3(): kotlin/String // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.DroppedSpanOverlap.component3|component3(){}[0]
+        final fun copy(io.github.linreal.cascade.editor.core/BlockId? = ..., io.github.linreal.cascade.editor.markdown/MarkdownTextRange? = ..., kotlin/String = ...): io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.DroppedSpanOverlap // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.DroppedSpanOverlap.copy|copy(io.github.linreal.cascade.editor.core.BlockId?;io.github.linreal.cascade.editor.markdown.MarkdownTextRange?;kotlin.String){}[0]
+        final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.DroppedSpanOverlap.equals|equals(kotlin.Any?){}[0]
+        final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.DroppedSpanOverlap.hashCode|hashCode(){}[0]
+        final fun toString(): kotlin/String // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.DroppedSpanOverlap.toString|toString(){}[0]
+    }
+
+    final class EncoderException : io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning { // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.EncoderException|null[0]
+        constructor <init>(kotlin/String?, kotlin/String, io.github.linreal.cascade.editor.core/BlockId?, io.github.linreal.cascade.editor.markdown/MarkdownTextRange? = ...) // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.EncoderException.<init>|<init>(kotlin.String?;kotlin.String;io.github.linreal.cascade.editor.core.BlockId?;io.github.linreal.cascade.editor.markdown.MarkdownTextRange?){}[0]
+
+        final val blockId // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.EncoderException.blockId|{}blockId[0]
+            final fun <get-blockId>(): io.github.linreal.cascade.editor.core/BlockId? // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.EncoderException.blockId.<get-blockId>|<get-blockId>(){}[0]
+        final val impact // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.EncoderException.impact|{}impact[0]
+            final fun <get-impact>(): io.github.linreal.cascade.editor.markdown/MarkdownFidelityImpact // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.EncoderException.impact.<get-impact>|<get-impact>(){}[0]
+        final val message // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.EncoderException.message|{}message[0]
+            final fun <get-message>(): kotlin/String // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.EncoderException.message.<get-message>|<get-message>(){}[0]
+        final val textRange // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.EncoderException.textRange|{}textRange[0]
+            final fun <get-textRange>(): io.github.linreal.cascade.editor.markdown/MarkdownTextRange? // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.EncoderException.textRange.<get-textRange>|<get-textRange>(){}[0]
+        final val typeId // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.EncoderException.typeId|{}typeId[0]
+            final fun <get-typeId>(): kotlin/String? // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.EncoderException.typeId.<get-typeId>|<get-typeId>(){}[0]
+
+        final fun component1(): kotlin/String? // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.EncoderException.component1|component1(){}[0]
+        final fun component2(): kotlin/String // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.EncoderException.component2|component2(){}[0]
+        final fun component3(): io.github.linreal.cascade.editor.core/BlockId? // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.EncoderException.component3|component3(){}[0]
+        final fun component4(): io.github.linreal.cascade.editor.markdown/MarkdownTextRange? // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.EncoderException.component4|component4(){}[0]
+        final fun copy(kotlin/String? = ..., kotlin/String = ..., io.github.linreal.cascade.editor.core/BlockId? = ..., io.github.linreal.cascade.editor.markdown/MarkdownTextRange? = ...): io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.EncoderException // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.EncoderException.copy|copy(kotlin.String?;kotlin.String;io.github.linreal.cascade.editor.core.BlockId?;io.github.linreal.cascade.editor.markdown.MarkdownTextRange?){}[0]
+        final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.EncoderException.equals|equals(kotlin.Any?){}[0]
+        final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.EncoderException.hashCode|hashCode(){}[0]
+        final fun toString(): kotlin/String // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.EncoderException.toString|toString(){}[0]
+    }
+
+    final class EngineFailure : io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning { // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.EngineFailure|null[0]
+        constructor <init>(kotlin/String, io.github.linreal.cascade.editor.core/BlockId? = ..., io.github.linreal.cascade.editor.markdown/MarkdownTextRange? = ...) // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.EngineFailure.<init>|<init>(kotlin.String;io.github.linreal.cascade.editor.core.BlockId?;io.github.linreal.cascade.editor.markdown.MarkdownTextRange?){}[0]
+
+        final val blockId // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.EngineFailure.blockId|{}blockId[0]
+            final fun <get-blockId>(): io.github.linreal.cascade.editor.core/BlockId? // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.EngineFailure.blockId.<get-blockId>|<get-blockId>(){}[0]
+        final val impact // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.EngineFailure.impact|{}impact[0]
+            final fun <get-impact>(): io.github.linreal.cascade.editor.markdown/MarkdownFidelityImpact // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.EngineFailure.impact.<get-impact>|<get-impact>(){}[0]
+        final val message // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.EngineFailure.message|{}message[0]
+            final fun <get-message>(): kotlin/String // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.EngineFailure.message.<get-message>|<get-message>(){}[0]
+        final val textRange // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.EngineFailure.textRange|{}textRange[0]
+            final fun <get-textRange>(): io.github.linreal.cascade.editor.markdown/MarkdownTextRange? // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.EngineFailure.textRange.<get-textRange>|<get-textRange>(){}[0]
+
+        final fun component1(): kotlin/String // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.EngineFailure.component1|component1(){}[0]
+        final fun component2(): io.github.linreal.cascade.editor.core/BlockId? // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.EngineFailure.component2|component2(){}[0]
+        final fun component3(): io.github.linreal.cascade.editor.markdown/MarkdownTextRange? // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.EngineFailure.component3|component3(){}[0]
+        final fun copy(kotlin/String = ..., io.github.linreal.cascade.editor.core/BlockId? = ..., io.github.linreal.cascade.editor.markdown/MarkdownTextRange? = ...): io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.EngineFailure // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.EngineFailure.copy|copy(kotlin.String;io.github.linreal.cascade.editor.core.BlockId?;io.github.linreal.cascade.editor.markdown.MarkdownTextRange?){}[0]
+        final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.EngineFailure.equals|equals(kotlin.Any?){}[0]
+        final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.EngineFailure.hashCode|hashCode(){}[0]
+        final fun toString(): kotlin/String // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.EngineFailure.toString|toString(){}[0]
+    }
+
+    final class LimitExceeded : io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning { // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.LimitExceeded|null[0]
+        constructor <init>(io.github.linreal.cascade.editor.markdown/MarkdownCodecLimitKind, kotlin/Int, io.github.linreal.cascade.editor.core/BlockId? = ..., io.github.linreal.cascade.editor.markdown/MarkdownTextRange? = ...) // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.LimitExceeded.<init>|<init>(io.github.linreal.cascade.editor.markdown.MarkdownCodecLimitKind;kotlin.Int;io.github.linreal.cascade.editor.core.BlockId?;io.github.linreal.cascade.editor.markdown.MarkdownTextRange?){}[0]
+
+        final val blockId // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.LimitExceeded.blockId|{}blockId[0]
+            final fun <get-blockId>(): io.github.linreal.cascade.editor.core/BlockId? // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.LimitExceeded.blockId.<get-blockId>|<get-blockId>(){}[0]
+        final val impact // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.LimitExceeded.impact|{}impact[0]
+            final fun <get-impact>(): io.github.linreal.cascade.editor.markdown/MarkdownFidelityImpact // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.LimitExceeded.impact.<get-impact>|<get-impact>(){}[0]
+        final val kind // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.LimitExceeded.kind|{}kind[0]
+            final fun <get-kind>(): io.github.linreal.cascade.editor.markdown/MarkdownCodecLimitKind // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.LimitExceeded.kind.<get-kind>|<get-kind>(){}[0]
+        final val limit // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.LimitExceeded.limit|{}limit[0]
+            final fun <get-limit>(): kotlin/Int // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.LimitExceeded.limit.<get-limit>|<get-limit>(){}[0]
+        final val textRange // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.LimitExceeded.textRange|{}textRange[0]
+            final fun <get-textRange>(): io.github.linreal.cascade.editor.markdown/MarkdownTextRange? // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.LimitExceeded.textRange.<get-textRange>|<get-textRange>(){}[0]
+
+        final fun component1(): io.github.linreal.cascade.editor.markdown/MarkdownCodecLimitKind // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.LimitExceeded.component1|component1(){}[0]
+        final fun component2(): kotlin/Int // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.LimitExceeded.component2|component2(){}[0]
+        final fun component3(): io.github.linreal.cascade.editor.core/BlockId? // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.LimitExceeded.component3|component3(){}[0]
+        final fun component4(): io.github.linreal.cascade.editor.markdown/MarkdownTextRange? // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.LimitExceeded.component4|component4(){}[0]
+        final fun copy(io.github.linreal.cascade.editor.markdown/MarkdownCodecLimitKind = ..., kotlin/Int = ..., io.github.linreal.cascade.editor.core/BlockId? = ..., io.github.linreal.cascade.editor.markdown/MarkdownTextRange? = ...): io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.LimitExceeded // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.LimitExceeded.copy|copy(io.github.linreal.cascade.editor.markdown.MarkdownCodecLimitKind;kotlin.Int;io.github.linreal.cascade.editor.core.BlockId?;io.github.linreal.cascade.editor.markdown.MarkdownTextRange?){}[0]
+        final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.LimitExceeded.equals|equals(kotlin.Any?){}[0]
+        final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.LimitExceeded.hashCode|hashCode(){}[0]
+        final fun toString(): kotlin/String // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.LimitExceeded.toString|toString(){}[0]
+    }
+
+    final class OutputLimitExceeded : io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning { // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.OutputLimitExceeded|null[0]
+        constructor <init>(kotlin/Int, io.github.linreal.cascade.editor.core/BlockId? = ..., io.github.linreal.cascade.editor.markdown/MarkdownTextRange? = ...) // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.OutputLimitExceeded.<init>|<init>(kotlin.Int;io.github.linreal.cascade.editor.core.BlockId?;io.github.linreal.cascade.editor.markdown.MarkdownTextRange?){}[0]
+
+        final val blockId // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.OutputLimitExceeded.blockId|{}blockId[0]
+            final fun <get-blockId>(): io.github.linreal.cascade.editor.core/BlockId? // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.OutputLimitExceeded.blockId.<get-blockId>|<get-blockId>(){}[0]
+        final val impact // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.OutputLimitExceeded.impact|{}impact[0]
+            final fun <get-impact>(): io.github.linreal.cascade.editor.markdown/MarkdownFidelityImpact // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.OutputLimitExceeded.impact.<get-impact>|<get-impact>(){}[0]
+        final val limit // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.OutputLimitExceeded.limit|{}limit[0]
+            final fun <get-limit>(): kotlin/Int // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.OutputLimitExceeded.limit.<get-limit>|<get-limit>(){}[0]
+        final val textRange // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.OutputLimitExceeded.textRange|{}textRange[0]
+            final fun <get-textRange>(): io.github.linreal.cascade.editor.markdown/MarkdownTextRange? // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.OutputLimitExceeded.textRange.<get-textRange>|<get-textRange>(){}[0]
+
+        final fun component1(): kotlin/Int // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.OutputLimitExceeded.component1|component1(){}[0]
+        final fun component2(): io.github.linreal.cascade.editor.core/BlockId? // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.OutputLimitExceeded.component2|component2(){}[0]
+        final fun component3(): io.github.linreal.cascade.editor.markdown/MarkdownTextRange? // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.OutputLimitExceeded.component3|component3(){}[0]
+        final fun copy(kotlin/Int = ..., io.github.linreal.cascade.editor.core/BlockId? = ..., io.github.linreal.cascade.editor.markdown/MarkdownTextRange? = ...): io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.OutputLimitExceeded // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.OutputLimitExceeded.copy|copy(kotlin.Int;io.github.linreal.cascade.editor.core.BlockId?;io.github.linreal.cascade.editor.markdown.MarkdownTextRange?){}[0]
+        final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.OutputLimitExceeded.equals|equals(kotlin.Any?){}[0]
+        final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.OutputLimitExceeded.hashCode|hashCode(){}[0]
+        final fun toString(): kotlin/String // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.OutputLimitExceeded.toString|toString(){}[0]
+    }
+
+    final class UnsupportedBlock : io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning { // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.UnsupportedBlock|null[0]
+        constructor <init>(kotlin/String?, kotlin/String, io.github.linreal.cascade.editor.core/BlockId?, io.github.linreal.cascade.editor.markdown/MarkdownTextRange? = ...) // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.UnsupportedBlock.<init>|<init>(kotlin.String?;kotlin.String;io.github.linreal.cascade.editor.core.BlockId?;io.github.linreal.cascade.editor.markdown.MarkdownTextRange?){}[0]
+
+        final val blockId // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.UnsupportedBlock.blockId|{}blockId[0]
+            final fun <get-blockId>(): io.github.linreal.cascade.editor.core/BlockId? // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.UnsupportedBlock.blockId.<get-blockId>|<get-blockId>(){}[0]
+        final val impact // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.UnsupportedBlock.impact|{}impact[0]
+            final fun <get-impact>(): io.github.linreal.cascade.editor.markdown/MarkdownFidelityImpact // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.UnsupportedBlock.impact.<get-impact>|<get-impact>(){}[0]
+        final val reason // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.UnsupportedBlock.reason|{}reason[0]
+            final fun <get-reason>(): kotlin/String // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.UnsupportedBlock.reason.<get-reason>|<get-reason>(){}[0]
+        final val textRange // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.UnsupportedBlock.textRange|{}textRange[0]
+            final fun <get-textRange>(): io.github.linreal.cascade.editor.markdown/MarkdownTextRange? // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.UnsupportedBlock.textRange.<get-textRange>|<get-textRange>(){}[0]
+        final val typeId // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.UnsupportedBlock.typeId|{}typeId[0]
+            final fun <get-typeId>(): kotlin/String? // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.UnsupportedBlock.typeId.<get-typeId>|<get-typeId>(){}[0]
+
+        final fun component1(): kotlin/String? // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.UnsupportedBlock.component1|component1(){}[0]
+        final fun component2(): kotlin/String // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.UnsupportedBlock.component2|component2(){}[0]
+        final fun component3(): io.github.linreal.cascade.editor.core/BlockId? // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.UnsupportedBlock.component3|component3(){}[0]
+        final fun component4(): io.github.linreal.cascade.editor.markdown/MarkdownTextRange? // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.UnsupportedBlock.component4|component4(){}[0]
+        final fun copy(kotlin/String? = ..., kotlin/String = ..., io.github.linreal.cascade.editor.core/BlockId? = ..., io.github.linreal.cascade.editor.markdown/MarkdownTextRange? = ...): io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.UnsupportedBlock // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.UnsupportedBlock.copy|copy(kotlin.String?;kotlin.String;io.github.linreal.cascade.editor.core.BlockId?;io.github.linreal.cascade.editor.markdown.MarkdownTextRange?){}[0]
+        final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.UnsupportedBlock.equals|equals(kotlin.Any?){}[0]
+        final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.UnsupportedBlock.hashCode|hashCode(){}[0]
+        final fun toString(): kotlin/String // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.UnsupportedBlock.toString|toString(){}[0]
+    }
+
+    final class UnsupportedSpan : io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning { // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.UnsupportedSpan|null[0]
+        constructor <init>(kotlin/String?, kotlin/String, io.github.linreal.cascade.editor.core/BlockId?, io.github.linreal.cascade.editor.markdown/MarkdownTextRange?) // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.UnsupportedSpan.<init>|<init>(kotlin.String?;kotlin.String;io.github.linreal.cascade.editor.core.BlockId?;io.github.linreal.cascade.editor.markdown.MarkdownTextRange?){}[0]
+
+        final val blockId // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.UnsupportedSpan.blockId|{}blockId[0]
+            final fun <get-blockId>(): io.github.linreal.cascade.editor.core/BlockId? // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.UnsupportedSpan.blockId.<get-blockId>|<get-blockId>(){}[0]
+        final val impact // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.UnsupportedSpan.impact|{}impact[0]
+            final fun <get-impact>(): io.github.linreal.cascade.editor.markdown/MarkdownFidelityImpact // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.UnsupportedSpan.impact.<get-impact>|<get-impact>(){}[0]
+        final val reason // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.UnsupportedSpan.reason|{}reason[0]
+            final fun <get-reason>(): kotlin/String // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.UnsupportedSpan.reason.<get-reason>|<get-reason>(){}[0]
+        final val textRange // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.UnsupportedSpan.textRange|{}textRange[0]
+            final fun <get-textRange>(): io.github.linreal.cascade.editor.markdown/MarkdownTextRange? // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.UnsupportedSpan.textRange.<get-textRange>|<get-textRange>(){}[0]
+        final val typeId // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.UnsupportedSpan.typeId|{}typeId[0]
+            final fun <get-typeId>(): kotlin/String? // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.UnsupportedSpan.typeId.<get-typeId>|<get-typeId>(){}[0]
+
+        final fun component1(): kotlin/String? // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.UnsupportedSpan.component1|component1(){}[0]
+        final fun component2(): kotlin/String // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.UnsupportedSpan.component2|component2(){}[0]
+        final fun component3(): io.github.linreal.cascade.editor.core/BlockId? // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.UnsupportedSpan.component3|component3(){}[0]
+        final fun component4(): io.github.linreal.cascade.editor.markdown/MarkdownTextRange? // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.UnsupportedSpan.component4|component4(){}[0]
+        final fun copy(kotlin/String? = ..., kotlin/String = ..., io.github.linreal.cascade.editor.core/BlockId? = ..., io.github.linreal.cascade.editor.markdown/MarkdownTextRange? = ...): io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.UnsupportedSpan // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.UnsupportedSpan.copy|copy(kotlin.String?;kotlin.String;io.github.linreal.cascade.editor.core.BlockId?;io.github.linreal.cascade.editor.markdown.MarkdownTextRange?){}[0]
+        final fun equals(kotlin/Any?): kotlin/Boolean // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.UnsupportedSpan.equals|equals(kotlin.Any?){}[0]
+        final fun hashCode(): kotlin/Int // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.UnsupportedSpan.hashCode|hashCode(){}[0]
+        final fun toString(): kotlin/String // io.github.linreal.cascade.editor.markdown/MarkdownEncodeWarning.UnsupportedSpan.toString|toString(){}[0]
+    }
+}
+
 sealed class io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning { // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning|null[0]
     final class DocumentParseFailed : io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning { // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.DocumentParseFailed|null[0]
         constructor <init>(kotlin/String) // io.github.linreal.cascade.editor.serialization/DocumentDecodeWarning.DocumentParseFailed.<init>|<init>(kotlin.String){}[0]
@@ -3089,8 +4028,24 @@ final object io.github.linreal.cascade.editor.htmlserialization/HtmlSchema { //
     final fun encodeWithReport(kotlin.collections/List<io.github.linreal.cascade.editor.core/Block>, io.github.linreal.cascade.editor.htmlserialization/HtmlProfile): io.github.linreal.cascade.editor.htmlserialization/HtmlEncodeResult // io.github.linreal.cascade.editor.htmlserialization/HtmlSchema.encodeWithReport|encodeWithReport(kotlin.collections.List<io.github.linreal.cascade.editor.core.Block>;io.github.linreal.cascade.editor.htmlserialization.HtmlProfile){}[0]
 }
 
+final object io.github.linreal.cascade.editor.markdown/Markdown { // io.github.linreal.cascade.editor.markdown/Markdown|null[0]
+    final fun codeSpanDelimiters(kotlin/String): io.github.linreal.cascade.editor.markdown/MarkdownCodeSpanDelimiters // io.github.linreal.cascade.editor.markdown/Markdown.codeSpanDelimiters|codeSpanDelimiters(kotlin.String){}[0]
+    final fun escapeInline(kotlin/String, io.github.linreal.cascade.editor.markdown/MarkdownEscapeContext): kotlin/String // io.github.linreal.cascade.editor.markdown/Markdown.escapeInline|escapeInline(kotlin.String;io.github.linreal.cascade.editor.markdown.MarkdownEscapeContext){}[0]
+    final fun escapeLinkDestination(kotlin/String): kotlin/String // io.github.linreal.cascade.editor.markdown/Markdown.escapeLinkDestination|escapeLinkDestination(kotlin.String){}[0]
+    final fun escapeLinkText(kotlin/String): kotlin/String // io.github.linreal.cascade.editor.markdown/Markdown.escapeLinkText|escapeLinkText(kotlin.String){}[0]
+}
+
+final object io.github.linreal.cascade.editor.markdown/MarkdownSchema { // io.github.linreal.cascade.editor.markdown/MarkdownSchema|null[0]
+    final fun analyze(kotlin/String, io.github.linreal.cascade.editor.markdown/MarkdownProfile = ..., io.github.linreal.cascade.editor.markdown/MarkdownCodecLimits = ...): io.github.linreal.cascade.editor.markdown/MarkdownFidelityReport // io.github.linreal.cascade.editor.markdown/MarkdownSchema.analyze|analyze(kotlin.String;io.github.linreal.cascade.editor.markdown.MarkdownProfile;io.github.linreal.cascade.editor.markdown.MarkdownCodecLimits){}[0]
+    final fun decode(kotlin/String, io.github.linreal.cascade.editor.markdown/MarkdownProfile = ..., io.github.linreal.cascade.editor.markdown/MarkdownCodecLimits = ...): kotlin.collections/List<io.github.linreal.cascade.editor.core/Block>? // io.github.linreal.cascade.editor.markdown/MarkdownSchema.decode|decode(kotlin.String;io.github.linreal.cascade.editor.markdown.MarkdownProfile;io.github.linreal.cascade.editor.markdown.MarkdownCodecLimits){}[0]
+    final fun decodeWithReport(kotlin/String, io.github.linreal.cascade.editor.markdown/MarkdownProfile = ..., io.github.linreal.cascade.editor.markdown/MarkdownCodecLimits = ...): io.github.linreal.cascade.editor.markdown/MarkdownDecodeResult // io.github.linreal.cascade.editor.markdown/MarkdownSchema.decodeWithReport|decodeWithReport(kotlin.String;io.github.linreal.cascade.editor.markdown.MarkdownProfile;io.github.linreal.cascade.editor.markdown.MarkdownCodecLimits){}[0]
+    final fun encode(kotlin.collections/List<io.github.linreal.cascade.editor.core/Block>, io.github.linreal.cascade.editor.markdown/MarkdownProfile = ..., io.github.linreal.cascade.editor.markdown/MarkdownCodecLimits = ..., io.github.linreal.cascade.editor.markdown/MarkdownLineEnding = ...): kotlin/String? // io.github.linreal.cascade.editor.markdown/MarkdownSchema.encode|encode(kotlin.collections.List<io.github.linreal.cascade.editor.core.Block>;io.github.linreal.cascade.editor.markdown.MarkdownProfile;io.github.linreal.cascade.editor.markdown.MarkdownCodecLimits;io.github.linreal.cascade.editor.markdown.MarkdownLineEnding){}[0]
+    final fun encodeWithReport(kotlin.collections/List<io.github.linreal.cascade.editor.core/Block>, io.github.linreal.cascade.editor.markdown/MarkdownProfile = ..., io.github.linreal.cascade.editor.markdown/MarkdownCodecLimits = ..., io.github.linreal.cascade.editor.markdown/MarkdownLineEnding = ...): io.github.linreal.cascade.editor.markdown/MarkdownEncodeResult // io.github.linreal.cascade.editor.markdown/MarkdownSchema.encodeWithReport|encodeWithReport(kotlin.collections.List<io.github.linreal.cascade.editor.core.Block>;io.github.linreal.cascade.editor.markdown.MarkdownProfile;io.github.linreal.cascade.editor.markdown.MarkdownCodecLimits;io.github.linreal.cascade.editor.markdown.MarkdownLineEnding){}[0]
+}
+
 final object io.github.linreal.cascade.editor.richtext/LinkUrlPolicy { // io.github.linreal.cascade.editor.richtext/LinkUrlPolicy|null[0]
     final fun validate(kotlin/String): io.github.linreal.cascade.editor.richtext/LinkValidationResult // io.github.linreal.cascade.editor.richtext/LinkUrlPolicy.validate|validate(kotlin.String){}[0]
+    final fun validateStoredTarget(kotlin/String): io.github.linreal.cascade.editor.richtext/LinkValidationResult // io.github.linreal.cascade.editor.richtext/LinkUrlPolicy.validateStoredTarget|validateStoredTarget(kotlin.String){}[0]
 }
 
 final object io.github.linreal.cascade.editor.serialization/DocumentSchema { // io.github.linreal.cascade.editor.serialization/DocumentSchema|null[0]
@@ -3251,6 +4206,64 @@ final val io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_c
 final val io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_UnknownTagPolicy_Strip$stableprop // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_UnknownTagPolicy_Strip$stableprop|#static{}io_github_linreal_cascade_editor_htmlserialization_UnknownTagPolicy_Strip$stableprop[0]
 final val io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_UnknownTagPolicy_WarnAndStrip$stableprop // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_UnknownTagPolicy_WarnAndStrip$stableprop|#static{}io_github_linreal_cascade_editor_htmlserialization_UnknownTagPolicy_WarnAndStrip$stableprop[0]
 final val io.github.linreal.cascade.editor.indentation/io_github_linreal_cascade_editor_indentation_IndentationState$stableprop // io.github.linreal.cascade.editor.indentation/io_github_linreal_cascade_editor_indentation_IndentationState$stableprop|#static{}io_github_linreal_cascade_editor_indentation_IndentationState$stableprop[0]
+final val io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_EntityDecode_None$stableprop // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_EntityDecode_None$stableprop|#static{}io_github_linreal_cascade_editor_markdown_EntityDecode_None$stableprop[0]
+final val io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_EntityDecode_Standard$stableprop // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_EntityDecode_Standard$stableprop|#static{}io_github_linreal_cascade_editor_markdown_EntityDecode_Standard$stableprop[0]
+final val io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_HardBreakEncode_Backslash$stableprop // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_HardBreakEncode_Backslash$stableprop|#static{}io_github_linreal_cascade_editor_markdown_HardBreakEncode_Backslash$stableprop[0]
+final val io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_HardBreakEncode_TwoSpaces$stableprop // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_HardBreakEncode_TwoSpaces$stableprop|#static{}io_github_linreal_cascade_editor_markdown_HardBreakEncode_TwoSpaces$stableprop[0]
+final val io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_HtmlInMarkdown_Bridge$stableprop // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_HtmlInMarkdown_Bridge$stableprop|#static{}io_github_linreal_cascade_editor_markdown_HtmlInMarkdown_Bridge$stableprop[0]
+final val io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_HtmlInMarkdown_Preserve$stableprop // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_HtmlInMarkdown_Preserve$stableprop|#static{}io_github_linreal_cascade_editor_markdown_HtmlInMarkdown_Preserve$stableprop[0]
+final val io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_HtmlInMarkdown_Strip$stableprop // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_HtmlInMarkdown_Strip$stableprop|#static{}io_github_linreal_cascade_editor_markdown_HtmlInMarkdown_Strip$stableprop[0]
+final val io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_HtmlInMarkdown_WarnAndStrip$stableprop // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_HtmlInMarkdown_WarnAndStrip$stableprop|#static{}io_github_linreal_cascade_editor_markdown_HtmlInMarkdown_WarnAndStrip$stableprop[0]
+final val io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_Markdown$stableprop // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_Markdown$stableprop|#static{}io_github_linreal_cascade_editor_markdown_Markdown$stableprop[0]
+final val io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownCodeSpanDelimiters$stableprop // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownCodeSpanDelimiters$stableprop|#static{}io_github_linreal_cascade_editor_markdown_MarkdownCodeSpanDelimiters$stableprop[0]
+final val io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownCodecLimits$stableprop // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownCodecLimits$stableprop|#static{}io_github_linreal_cascade_editor_markdown_MarkdownCodecLimits$stableprop[0]
+final val io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownDecodeResult$stableprop // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownDecodeResult$stableprop|#static{}io_github_linreal_cascade_editor_markdown_MarkdownDecodeResult$stableprop[0]
+final val io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownDecodeWarning$stableprop // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownDecodeWarning$stableprop|#static{}io_github_linreal_cascade_editor_markdown_MarkdownDecodeWarning$stableprop[0]
+final val io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownDecodeWarning_DroppedAttribute$stableprop // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownDecodeWarning_DroppedAttribute$stableprop|#static{}io_github_linreal_cascade_editor_markdown_MarkdownDecodeWarning_DroppedAttribute$stableprop[0]
+final val io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownDecodeWarning_DuplicateLinkDefinition$stableprop // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownDecodeWarning_DuplicateLinkDefinition$stableprop|#static{}io_github_linreal_cascade_editor_markdown_MarkdownDecodeWarning_DuplicateLinkDefinition$stableprop[0]
+final val io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownDecodeWarning_EngineFailure$stableprop // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownDecodeWarning_EngineFailure$stableprop|#static{}io_github_linreal_cascade_editor_markdown_MarkdownDecodeWarning_EngineFailure$stableprop[0]
+final val io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownDecodeWarning_HtmlBridged$stableprop // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownDecodeWarning_HtmlBridged$stableprop|#static{}io_github_linreal_cascade_editor_markdown_MarkdownDecodeWarning_HtmlBridged$stableprop[0]
+final val io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownDecodeWarning_HtmlStripped$stableprop // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownDecodeWarning_HtmlStripped$stableprop|#static{}io_github_linreal_cascade_editor_markdown_MarkdownDecodeWarning_HtmlStripped$stableprop[0]
+final val io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownDecodeWarning_InputLimitExceeded$stableprop // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownDecodeWarning_InputLimitExceeded$stableprop|#static{}io_github_linreal_cascade_editor_markdown_MarkdownDecodeWarning_InputLimitExceeded$stableprop[0]
+final val io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownDecodeWarning_LimitExceeded$stableprop // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownDecodeWarning_LimitExceeded$stableprop|#static{}io_github_linreal_cascade_editor_markdown_MarkdownDecodeWarning_LimitExceeded$stableprop[0]
+final val io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownDecodeWarning_PreservedSyntax$stableprop // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownDecodeWarning_PreservedSyntax$stableprop|#static{}io_github_linreal_cascade_editor_markdown_MarkdownDecodeWarning_PreservedSyntax$stableprop[0]
+final val io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownDecodeWarning_UnsupportedEntity$stableprop // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownDecodeWarning_UnsupportedEntity$stableprop|#static{}io_github_linreal_cascade_editor_markdown_MarkdownDecodeWarning_UnsupportedEntity$stableprop[0]
+final val io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownDecodeWarning_UnsupportedSyntax$stableprop // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownDecodeWarning_UnsupportedSyntax$stableprop|#static{}io_github_linreal_cascade_editor_markdown_MarkdownDecodeWarning_UnsupportedSyntax$stableprop[0]
+final val io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownEmit_Raw$stableprop // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownEmit_Raw$stableprop|#static{}io_github_linreal_cascade_editor_markdown_MarkdownEmit_Raw$stableprop[0]
+final val io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownEmit_Skip$stableprop // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownEmit_Skip$stableprop|#static{}io_github_linreal_cascade_editor_markdown_MarkdownEmit_Skip$stableprop[0]
+final val io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownEmit_Verbatim$stableprop // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownEmit_Verbatim$stableprop|#static{}io_github_linreal_cascade_editor_markdown_MarkdownEmit_Verbatim$stableprop[0]
+final val io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownEncodeContext$stableprop // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownEncodeContext$stableprop|#static{}io_github_linreal_cascade_editor_markdown_MarkdownEncodeContext$stableprop[0]
+final val io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownEncodeResult$stableprop // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownEncodeResult$stableprop|#static{}io_github_linreal_cascade_editor_markdown_MarkdownEncodeResult$stableprop[0]
+final val io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownEncodeWarning$stableprop // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownEncodeWarning$stableprop|#static{}io_github_linreal_cascade_editor_markdown_MarkdownEncodeWarning$stableprop[0]
+final val io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownEncodeWarning_AmbiguousEmphasis$stableprop // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownEncodeWarning_AmbiguousEmphasis$stableprop|#static{}io_github_linreal_cascade_editor_markdown_MarkdownEncodeWarning_AmbiguousEmphasis$stableprop[0]
+final val io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownEncodeWarning_DroppedAttribute$stableprop // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownEncodeWarning_DroppedAttribute$stableprop|#static{}io_github_linreal_cascade_editor_markdown_MarkdownEncodeWarning_DroppedAttribute$stableprop[0]
+final val io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownEncodeWarning_DroppedSpanOverlap$stableprop // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownEncodeWarning_DroppedSpanOverlap$stableprop|#static{}io_github_linreal_cascade_editor_markdown_MarkdownEncodeWarning_DroppedSpanOverlap$stableprop[0]
+final val io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownEncodeWarning_EncoderException$stableprop // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownEncodeWarning_EncoderException$stableprop|#static{}io_github_linreal_cascade_editor_markdown_MarkdownEncodeWarning_EncoderException$stableprop[0]
+final val io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownEncodeWarning_EngineFailure$stableprop // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownEncodeWarning_EngineFailure$stableprop|#static{}io_github_linreal_cascade_editor_markdown_MarkdownEncodeWarning_EngineFailure$stableprop[0]
+final val io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownEncodeWarning_LimitExceeded$stableprop // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownEncodeWarning_LimitExceeded$stableprop|#static{}io_github_linreal_cascade_editor_markdown_MarkdownEncodeWarning_LimitExceeded$stableprop[0]
+final val io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownEncodeWarning_OutputLimitExceeded$stableprop // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownEncodeWarning_OutputLimitExceeded$stableprop|#static{}io_github_linreal_cascade_editor_markdown_MarkdownEncodeWarning_OutputLimitExceeded$stableprop[0]
+final val io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownEncodeWarning_UnsupportedBlock$stableprop // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownEncodeWarning_UnsupportedBlock$stableprop|#static{}io_github_linreal_cascade_editor_markdown_MarkdownEncodeWarning_UnsupportedBlock$stableprop[0]
+final val io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownEncodeWarning_UnsupportedSpan$stableprop // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownEncodeWarning_UnsupportedSpan$stableprop|#static{}io_github_linreal_cascade_editor_markdown_MarkdownEncodeWarning_UnsupportedSpan$stableprop[0]
+final val io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownEscapeContext$stableprop // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownEscapeContext$stableprop|#static{}io_github_linreal_cascade_editor_markdown_MarkdownEscapeContext$stableprop[0]
+final val io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownFidelityReport$stableprop // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownFidelityReport$stableprop|#static{}io_github_linreal_cascade_editor_markdown_MarkdownFidelityReport$stableprop[0]
+final val io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownHtmlBridge_InlineIsland$stableprop // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownHtmlBridge_InlineIsland$stableprop|#static{}io_github_linreal_cascade_editor_markdown_MarkdownHtmlBridge_InlineIsland$stableprop[0]
+final val io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownInlineRenderer_Part_Code$stableprop // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownInlineRenderer_Part_Code$stableprop|#static{}io_github_linreal_cascade_editor_markdown_MarkdownInlineRenderer_Part_Code$stableprop[0]
+final val io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownInlineRenderer_Part_Marker$stableprop // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownInlineRenderer_Part_Marker$stableprop|#static{}io_github_linreal_cascade_editor_markdown_MarkdownInlineRenderer_Part_Marker$stableprop[0]
+final val io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownInlineRenderer_Part_Text$stableprop // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownInlineRenderer_Part_Text$stableprop|#static{}io_github_linreal_cascade_editor_markdown_MarkdownInlineRenderer_Part_Text$stableprop[0]
+final val io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownMarkPair$stableprop // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownMarkPair$stableprop|#static{}io_github_linreal_cascade_editor_markdown_MarkdownMarkPair$stableprop[0]
+final val io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownProfile$stableprop // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownProfile$stableprop|#static{}io_github_linreal_cascade_editor_markdown_MarkdownProfile$stableprop[0]
+final val io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownProfileSupportSet$stableprop // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownProfileSupportSet$stableprop|#static{}io_github_linreal_cascade_editor_markdown_MarkdownProfileSupportSet$stableprop[0]
+final val io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownSchema$stableprop // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownSchema$stableprop|#static{}io_github_linreal_cascade_editor_markdown_MarkdownSchema$stableprop[0]
+final val io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownSourceLocation$stableprop // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownSourceLocation$stableprop|#static{}io_github_linreal_cascade_editor_markdown_MarkdownSourceLocation$stableprop[0]
+final val io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownSourceLocator$stableprop // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownSourceLocator$stableprop|#static{}io_github_linreal_cascade_editor_markdown_MarkdownSourceLocator$stableprop[0]
+final val io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownSourceRange$stableprop // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownSourceRange$stableprop|#static{}io_github_linreal_cascade_editor_markdown_MarkdownSourceRange$stableprop[0]
+final val io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownTextRange$stableprop // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownTextRange$stableprop|#static{}io_github_linreal_cascade_editor_markdown_MarkdownTextRange$stableprop[0]
+final val io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_NewlineSemantics_CommonMark$stableprop // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_NewlineSemantics_CommonMark$stableprop|#static{}io_github_linreal_cascade_editor_markdown_NewlineSemantics_CommonMark$stableprop[0]
+final val io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_NewlineSemantics_HardBreak$stableprop // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_NewlineSemantics_HardBreak$stableprop|#static{}io_github_linreal_cascade_editor_markdown_NewlineSemantics_HardBreak$stableprop[0]
+final val io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_SoftBreak_LineBreak$stableprop // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_SoftBreak_LineBreak$stableprop|#static{}io_github_linreal_cascade_editor_markdown_SoftBreak_LineBreak$stableprop[0]
+final val io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_SoftBreak_Space$stableprop // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_SoftBreak_Space$stableprop|#static{}io_github_linreal_cascade_editor_markdown_SoftBreak_Space$stableprop[0]
+final val io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_UnsupportedSyntax_Preserve$stableprop // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_UnsupportedSyntax_Preserve$stableprop|#static{}io_github_linreal_cascade_editor_markdown_UnsupportedSyntax_Preserve$stableprop[0]
+final val io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_UnsupportedSyntax_WarnAndDegrade$stableprop // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_UnsupportedSyntax_WarnAndDegrade$stableprop|#static{}io_github_linreal_cascade_editor_markdown_UnsupportedSyntax_WarnAndDegrade$stableprop[0]
 final val io.github.linreal.cascade.editor.registry/io_github_linreal_cascade_editor_registry_BlockDescriptor$stableprop // io.github.linreal.cascade.editor.registry/io_github_linreal_cascade_editor_registry_BlockDescriptor$stableprop|#static{}io_github_linreal_cascade_editor_registry_BlockDescriptor$stableprop[0]
 final val io.github.linreal.cascade.editor.registry/io_github_linreal_cascade_editor_registry_BlockRegistry$stableprop // io.github.linreal.cascade.editor.registry/io_github_linreal_cascade_editor_registry_BlockRegistry$stableprop|#static{}io_github_linreal_cascade_editor_registry_BlockRegistry$stableprop[0]
 final val io.github.linreal.cascade.editor.registry/io_github_linreal_cascade_editor_registry_DefaultBlockCallbacks$stableprop // io.github.linreal.cascade.editor.registry/io_github_linreal_cascade_editor_registry_DefaultBlockCallbacks$stableprop|#static{}io_github_linreal_cascade_editor_registry_DefaultBlockCallbacks$stableprop[0]
@@ -3351,6 +4364,10 @@ final fun (androidx.compose.ui/Modifier).io.github.linreal.cascade.editor.ui/dra
 final fun (io.github.linreal.cascade.editor.registry/BlockRegistry).io.github.linreal.cascade.editor.ui/registerBuiltInRenderers() // io.github.linreal.cascade.editor.ui/registerBuiltInRenderers|registerBuiltInRenderers@io.github.linreal.cascade.editor.registry.BlockRegistry(){}[0]
 final fun (io.github.linreal.cascade.editor.state/EditorStateHolder).io.github.linreal.cascade.editor.htmlserialization/loadFromHtml(kotlin/String, io.github.linreal.cascade.editor.state/BlockTextStates, io.github.linreal.cascade.editor.state/BlockSpanStates, io.github.linreal.cascade.editor.htmlserialization/HtmlProfile, io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeLimits = ...): io.github.linreal.cascade.editor.htmlserialization/HtmlDecodeResult // io.github.linreal.cascade.editor.htmlserialization/loadFromHtml|loadFromHtml@io.github.linreal.cascade.editor.state.EditorStateHolder(kotlin.String;io.github.linreal.cascade.editor.state.BlockTextStates;io.github.linreal.cascade.editor.state.BlockSpanStates;io.github.linreal.cascade.editor.htmlserialization.HtmlProfile;io.github.linreal.cascade.editor.htmlserialization.HtmlDecodeLimits){}[0]
 final fun (io.github.linreal.cascade.editor.state/EditorStateHolder).io.github.linreal.cascade.editor.htmlserialization/toHtml(io.github.linreal.cascade.editor.state/BlockTextStates, io.github.linreal.cascade.editor.state/BlockSpanStates, io.github.linreal.cascade.editor.htmlserialization/HtmlProfile): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/toHtml|toHtml@io.github.linreal.cascade.editor.state.EditorStateHolder(io.github.linreal.cascade.editor.state.BlockTextStates;io.github.linreal.cascade.editor.state.BlockSpanStates;io.github.linreal.cascade.editor.htmlserialization.HtmlProfile){}[0]
+final fun (io.github.linreal.cascade.editor.state/EditorStateHolder).io.github.linreal.cascade.editor.markdown/applyMarkdownDecodeResult(io.github.linreal.cascade.editor.markdown/MarkdownDecodeResult, io.github.linreal.cascade.editor.state/BlockTextStates, io.github.linreal.cascade.editor.state/BlockSpanStates) // io.github.linreal.cascade.editor.markdown/applyMarkdownDecodeResult|applyMarkdownDecodeResult@io.github.linreal.cascade.editor.state.EditorStateHolder(io.github.linreal.cascade.editor.markdown.MarkdownDecodeResult;io.github.linreal.cascade.editor.state.BlockTextStates;io.github.linreal.cascade.editor.state.BlockSpanStates){}[0]
+final fun (io.github.linreal.cascade.editor.state/EditorStateHolder).io.github.linreal.cascade.editor.markdown/loadFromMarkdown(kotlin/String, io.github.linreal.cascade.editor.state/BlockTextStates, io.github.linreal.cascade.editor.state/BlockSpanStates, io.github.linreal.cascade.editor.markdown/MarkdownProfile = ..., io.github.linreal.cascade.editor.markdown/MarkdownCodecLimits = ...): io.github.linreal.cascade.editor.markdown/MarkdownDecodeResult // io.github.linreal.cascade.editor.markdown/loadFromMarkdown|loadFromMarkdown@io.github.linreal.cascade.editor.state.EditorStateHolder(kotlin.String;io.github.linreal.cascade.editor.state.BlockTextStates;io.github.linreal.cascade.editor.state.BlockSpanStates;io.github.linreal.cascade.editor.markdown.MarkdownProfile;io.github.linreal.cascade.editor.markdown.MarkdownCodecLimits){}[0]
+final fun (io.github.linreal.cascade.editor.state/EditorStateHolder).io.github.linreal.cascade.editor.markdown/toMarkdown(io.github.linreal.cascade.editor.state/BlockTextStates, io.github.linreal.cascade.editor.state/BlockSpanStates, io.github.linreal.cascade.editor.markdown/MarkdownProfile = ..., io.github.linreal.cascade.editor.markdown/MarkdownCodecLimits = ..., io.github.linreal.cascade.editor.markdown/MarkdownLineEnding = ...): kotlin/String? // io.github.linreal.cascade.editor.markdown/toMarkdown|toMarkdown@io.github.linreal.cascade.editor.state.EditorStateHolder(io.github.linreal.cascade.editor.state.BlockTextStates;io.github.linreal.cascade.editor.state.BlockSpanStates;io.github.linreal.cascade.editor.markdown.MarkdownProfile;io.github.linreal.cascade.editor.markdown.MarkdownCodecLimits;io.github.linreal.cascade.editor.markdown.MarkdownLineEnding){}[0]
+final fun (io.github.linreal.cascade.editor.state/EditorStateHolder).io.github.linreal.cascade.editor.markdown/toMarkdownWithReport(io.github.linreal.cascade.editor.state/BlockTextStates, io.github.linreal.cascade.editor.state/BlockSpanStates, io.github.linreal.cascade.editor.markdown/MarkdownProfile = ..., io.github.linreal.cascade.editor.markdown/MarkdownCodecLimits = ..., io.github.linreal.cascade.editor.markdown/MarkdownLineEnding = ...): io.github.linreal.cascade.editor.markdown/MarkdownEncodeResult // io.github.linreal.cascade.editor.markdown/toMarkdownWithReport|toMarkdownWithReport@io.github.linreal.cascade.editor.state.EditorStateHolder(io.github.linreal.cascade.editor.state.BlockTextStates;io.github.linreal.cascade.editor.state.BlockSpanStates;io.github.linreal.cascade.editor.markdown.MarkdownProfile;io.github.linreal.cascade.editor.markdown.MarkdownCodecLimits;io.github.linreal.cascade.editor.markdown.MarkdownLineEnding){}[0]
 final fun (io.github.linreal.cascade.editor.state/EditorStateHolder).io.github.linreal.cascade.editor.serialization/loadFromJson(kotlin/String, io.github.linreal.cascade.editor.state/BlockTextStates, io.github.linreal.cascade.editor.state/BlockSpanStates, io.github.linreal.cascade.editor.serialization/DocumentDecodeOptions = ..., io.github.linreal.cascade.editor.serialization/BlockTypeCodec? = ..., io.github.linreal.cascade.editor.serialization/BlockContentCodec? = ...): io.github.linreal.cascade.editor.serialization/DocumentDecodeResult // io.github.linreal.cascade.editor.serialization/loadFromJson|loadFromJson@io.github.linreal.cascade.editor.state.EditorStateHolder(kotlin.String;io.github.linreal.cascade.editor.state.BlockTextStates;io.github.linreal.cascade.editor.state.BlockSpanStates;io.github.linreal.cascade.editor.serialization.DocumentDecodeOptions;io.github.linreal.cascade.editor.serialization.BlockTypeCodec?;io.github.linreal.cascade.editor.serialization.BlockContentCodec?){}[0]
 final fun (io.github.linreal.cascade.editor.state/EditorStateHolder).io.github.linreal.cascade.editor.serialization/resolveDocumentBlocks(io.github.linreal.cascade.editor.state/BlockTextStates, io.github.linreal.cascade.editor.state/BlockSpanStates): kotlin.collections/List<io.github.linreal.cascade.editor.core/Block> // io.github.linreal.cascade.editor.serialization/resolveDocumentBlocks|resolveDocumentBlocks@io.github.linreal.cascade.editor.state.EditorStateHolder(io.github.linreal.cascade.editor.state.BlockTextStates;io.github.linreal.cascade.editor.state.BlockSpanStates){}[0]
 final fun (io.github.linreal.cascade.editor.state/EditorStateHolder).io.github.linreal.cascade.editor.serialization/toJson(io.github.linreal.cascade.editor.state/BlockTextStates, io.github.linreal.cascade.editor.state/BlockSpanStates, io.github.linreal.cascade.editor.serialization/DocumentEncodeOptions = ..., io.github.linreal.cascade.editor.serialization/BlockTypeCodec? = ..., io.github.linreal.cascade.editor.serialization/BlockContentCodec? = ...): kotlin/String // io.github.linreal.cascade.editor.serialization/toJson|toJson@io.github.linreal.cascade.editor.state.EditorStateHolder(io.github.linreal.cascade.editor.state.BlockTextStates;io.github.linreal.cascade.editor.state.BlockSpanStates;io.github.linreal.cascade.editor.serialization.DocumentEncodeOptions;io.github.linreal.cascade.editor.serialization.BlockTypeCodec?;io.github.linreal.cascade.editor.serialization.BlockContentCodec?){}[0]
@@ -3474,6 +4491,64 @@ final fun io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_c
 final fun io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_UnknownTagPolicy_WarnAndStrip$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.htmlserialization/io_github_linreal_cascade_editor_htmlserialization_UnknownTagPolicy_WarnAndStrip$stableprop_getter|io_github_linreal_cascade_editor_htmlserialization_UnknownTagPolicy_WarnAndStrip$stableprop_getter(){}[0]
 final fun io.github.linreal.cascade.editor.htmlserialization/openTagWithCascadeIndentation(kotlin/String, io.github.linreal.cascade.editor.core/Block): kotlin/String // io.github.linreal.cascade.editor.htmlserialization/openTagWithCascadeIndentation|openTagWithCascadeIndentation(kotlin.String;io.github.linreal.cascade.editor.core.Block){}[0]
 final fun io.github.linreal.cascade.editor.indentation/io_github_linreal_cascade_editor_indentation_IndentationState$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.indentation/io_github_linreal_cascade_editor_indentation_IndentationState$stableprop_getter|io_github_linreal_cascade_editor_indentation_IndentationState$stableprop_getter(){}[0]
+final fun io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_EntityDecode_None$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_EntityDecode_None$stableprop_getter|io_github_linreal_cascade_editor_markdown_EntityDecode_None$stableprop_getter(){}[0]
+final fun io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_EntityDecode_Standard$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_EntityDecode_Standard$stableprop_getter|io_github_linreal_cascade_editor_markdown_EntityDecode_Standard$stableprop_getter(){}[0]
+final fun io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_HardBreakEncode_Backslash$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_HardBreakEncode_Backslash$stableprop_getter|io_github_linreal_cascade_editor_markdown_HardBreakEncode_Backslash$stableprop_getter(){}[0]
+final fun io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_HardBreakEncode_TwoSpaces$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_HardBreakEncode_TwoSpaces$stableprop_getter|io_github_linreal_cascade_editor_markdown_HardBreakEncode_TwoSpaces$stableprop_getter(){}[0]
+final fun io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_HtmlInMarkdown_Bridge$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_HtmlInMarkdown_Bridge$stableprop_getter|io_github_linreal_cascade_editor_markdown_HtmlInMarkdown_Bridge$stableprop_getter(){}[0]
+final fun io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_HtmlInMarkdown_Preserve$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_HtmlInMarkdown_Preserve$stableprop_getter|io_github_linreal_cascade_editor_markdown_HtmlInMarkdown_Preserve$stableprop_getter(){}[0]
+final fun io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_HtmlInMarkdown_Strip$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_HtmlInMarkdown_Strip$stableprop_getter|io_github_linreal_cascade_editor_markdown_HtmlInMarkdown_Strip$stableprop_getter(){}[0]
+final fun io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_HtmlInMarkdown_WarnAndStrip$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_HtmlInMarkdown_WarnAndStrip$stableprop_getter|io_github_linreal_cascade_editor_markdown_HtmlInMarkdown_WarnAndStrip$stableprop_getter(){}[0]
+final fun io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_Markdown$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_Markdown$stableprop_getter|io_github_linreal_cascade_editor_markdown_Markdown$stableprop_getter(){}[0]
+final fun io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownCodeSpanDelimiters$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownCodeSpanDelimiters$stableprop_getter|io_github_linreal_cascade_editor_markdown_MarkdownCodeSpanDelimiters$stableprop_getter(){}[0]
+final fun io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownCodecLimits$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownCodecLimits$stableprop_getter|io_github_linreal_cascade_editor_markdown_MarkdownCodecLimits$stableprop_getter(){}[0]
+final fun io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownDecodeResult$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownDecodeResult$stableprop_getter|io_github_linreal_cascade_editor_markdown_MarkdownDecodeResult$stableprop_getter(){}[0]
+final fun io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownDecodeWarning$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownDecodeWarning$stableprop_getter|io_github_linreal_cascade_editor_markdown_MarkdownDecodeWarning$stableprop_getter(){}[0]
+final fun io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownDecodeWarning_DroppedAttribute$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownDecodeWarning_DroppedAttribute$stableprop_getter|io_github_linreal_cascade_editor_markdown_MarkdownDecodeWarning_DroppedAttribute$stableprop_getter(){}[0]
+final fun io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownDecodeWarning_DuplicateLinkDefinition$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownDecodeWarning_DuplicateLinkDefinition$stableprop_getter|io_github_linreal_cascade_editor_markdown_MarkdownDecodeWarning_DuplicateLinkDefinition$stableprop_getter(){}[0]
+final fun io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownDecodeWarning_EngineFailure$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownDecodeWarning_EngineFailure$stableprop_getter|io_github_linreal_cascade_editor_markdown_MarkdownDecodeWarning_EngineFailure$stableprop_getter(){}[0]
+final fun io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownDecodeWarning_HtmlBridged$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownDecodeWarning_HtmlBridged$stableprop_getter|io_github_linreal_cascade_editor_markdown_MarkdownDecodeWarning_HtmlBridged$stableprop_getter(){}[0]
+final fun io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownDecodeWarning_HtmlStripped$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownDecodeWarning_HtmlStripped$stableprop_getter|io_github_linreal_cascade_editor_markdown_MarkdownDecodeWarning_HtmlStripped$stableprop_getter(){}[0]
+final fun io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownDecodeWarning_InputLimitExceeded$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownDecodeWarning_InputLimitExceeded$stableprop_getter|io_github_linreal_cascade_editor_markdown_MarkdownDecodeWarning_InputLimitExceeded$stableprop_getter(){}[0]
+final fun io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownDecodeWarning_LimitExceeded$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownDecodeWarning_LimitExceeded$stableprop_getter|io_github_linreal_cascade_editor_markdown_MarkdownDecodeWarning_LimitExceeded$stableprop_getter(){}[0]
+final fun io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownDecodeWarning_PreservedSyntax$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownDecodeWarning_PreservedSyntax$stableprop_getter|io_github_linreal_cascade_editor_markdown_MarkdownDecodeWarning_PreservedSyntax$stableprop_getter(){}[0]
+final fun io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownDecodeWarning_UnsupportedEntity$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownDecodeWarning_UnsupportedEntity$stableprop_getter|io_github_linreal_cascade_editor_markdown_MarkdownDecodeWarning_UnsupportedEntity$stableprop_getter(){}[0]
+final fun io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownDecodeWarning_UnsupportedSyntax$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownDecodeWarning_UnsupportedSyntax$stableprop_getter|io_github_linreal_cascade_editor_markdown_MarkdownDecodeWarning_UnsupportedSyntax$stableprop_getter(){}[0]
+final fun io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownEmit_Raw$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownEmit_Raw$stableprop_getter|io_github_linreal_cascade_editor_markdown_MarkdownEmit_Raw$stableprop_getter(){}[0]
+final fun io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownEmit_Skip$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownEmit_Skip$stableprop_getter|io_github_linreal_cascade_editor_markdown_MarkdownEmit_Skip$stableprop_getter(){}[0]
+final fun io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownEmit_Verbatim$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownEmit_Verbatim$stableprop_getter|io_github_linreal_cascade_editor_markdown_MarkdownEmit_Verbatim$stableprop_getter(){}[0]
+final fun io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownEncodeContext$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownEncodeContext$stableprop_getter|io_github_linreal_cascade_editor_markdown_MarkdownEncodeContext$stableprop_getter(){}[0]
+final fun io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownEncodeResult$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownEncodeResult$stableprop_getter|io_github_linreal_cascade_editor_markdown_MarkdownEncodeResult$stableprop_getter(){}[0]
+final fun io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownEncodeWarning$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownEncodeWarning$stableprop_getter|io_github_linreal_cascade_editor_markdown_MarkdownEncodeWarning$stableprop_getter(){}[0]
+final fun io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownEncodeWarning_AmbiguousEmphasis$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownEncodeWarning_AmbiguousEmphasis$stableprop_getter|io_github_linreal_cascade_editor_markdown_MarkdownEncodeWarning_AmbiguousEmphasis$stableprop_getter(){}[0]
+final fun io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownEncodeWarning_DroppedAttribute$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownEncodeWarning_DroppedAttribute$stableprop_getter|io_github_linreal_cascade_editor_markdown_MarkdownEncodeWarning_DroppedAttribute$stableprop_getter(){}[0]
+final fun io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownEncodeWarning_DroppedSpanOverlap$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownEncodeWarning_DroppedSpanOverlap$stableprop_getter|io_github_linreal_cascade_editor_markdown_MarkdownEncodeWarning_DroppedSpanOverlap$stableprop_getter(){}[0]
+final fun io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownEncodeWarning_EncoderException$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownEncodeWarning_EncoderException$stableprop_getter|io_github_linreal_cascade_editor_markdown_MarkdownEncodeWarning_EncoderException$stableprop_getter(){}[0]
+final fun io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownEncodeWarning_EngineFailure$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownEncodeWarning_EngineFailure$stableprop_getter|io_github_linreal_cascade_editor_markdown_MarkdownEncodeWarning_EngineFailure$stableprop_getter(){}[0]
+final fun io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownEncodeWarning_LimitExceeded$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownEncodeWarning_LimitExceeded$stableprop_getter|io_github_linreal_cascade_editor_markdown_MarkdownEncodeWarning_LimitExceeded$stableprop_getter(){}[0]
+final fun io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownEncodeWarning_OutputLimitExceeded$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownEncodeWarning_OutputLimitExceeded$stableprop_getter|io_github_linreal_cascade_editor_markdown_MarkdownEncodeWarning_OutputLimitExceeded$stableprop_getter(){}[0]
+final fun io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownEncodeWarning_UnsupportedBlock$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownEncodeWarning_UnsupportedBlock$stableprop_getter|io_github_linreal_cascade_editor_markdown_MarkdownEncodeWarning_UnsupportedBlock$stableprop_getter(){}[0]
+final fun io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownEncodeWarning_UnsupportedSpan$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownEncodeWarning_UnsupportedSpan$stableprop_getter|io_github_linreal_cascade_editor_markdown_MarkdownEncodeWarning_UnsupportedSpan$stableprop_getter(){}[0]
+final fun io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownEscapeContext$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownEscapeContext$stableprop_getter|io_github_linreal_cascade_editor_markdown_MarkdownEscapeContext$stableprop_getter(){}[0]
+final fun io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownFidelityReport$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownFidelityReport$stableprop_getter|io_github_linreal_cascade_editor_markdown_MarkdownFidelityReport$stableprop_getter(){}[0]
+final fun io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownHtmlBridge_InlineIsland$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownHtmlBridge_InlineIsland$stableprop_getter|io_github_linreal_cascade_editor_markdown_MarkdownHtmlBridge_InlineIsland$stableprop_getter(){}[0]
+final fun io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownInlineRenderer_Part_Code$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownInlineRenderer_Part_Code$stableprop_getter|io_github_linreal_cascade_editor_markdown_MarkdownInlineRenderer_Part_Code$stableprop_getter(){}[0]
+final fun io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownInlineRenderer_Part_Marker$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownInlineRenderer_Part_Marker$stableprop_getter|io_github_linreal_cascade_editor_markdown_MarkdownInlineRenderer_Part_Marker$stableprop_getter(){}[0]
+final fun io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownInlineRenderer_Part_Text$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownInlineRenderer_Part_Text$stableprop_getter|io_github_linreal_cascade_editor_markdown_MarkdownInlineRenderer_Part_Text$stableprop_getter(){}[0]
+final fun io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownMarkPair$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownMarkPair$stableprop_getter|io_github_linreal_cascade_editor_markdown_MarkdownMarkPair$stableprop_getter(){}[0]
+final fun io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownProfile$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownProfile$stableprop_getter|io_github_linreal_cascade_editor_markdown_MarkdownProfile$stableprop_getter(){}[0]
+final fun io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownProfileSupportSet$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownProfileSupportSet$stableprop_getter|io_github_linreal_cascade_editor_markdown_MarkdownProfileSupportSet$stableprop_getter(){}[0]
+final fun io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownSchema$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownSchema$stableprop_getter|io_github_linreal_cascade_editor_markdown_MarkdownSchema$stableprop_getter(){}[0]
+final fun io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownSourceLocation$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownSourceLocation$stableprop_getter|io_github_linreal_cascade_editor_markdown_MarkdownSourceLocation$stableprop_getter(){}[0]
+final fun io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownSourceLocator$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownSourceLocator$stableprop_getter|io_github_linreal_cascade_editor_markdown_MarkdownSourceLocator$stableprop_getter(){}[0]
+final fun io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownSourceRange$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownSourceRange$stableprop_getter|io_github_linreal_cascade_editor_markdown_MarkdownSourceRange$stableprop_getter(){}[0]
+final fun io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownTextRange$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_MarkdownTextRange$stableprop_getter|io_github_linreal_cascade_editor_markdown_MarkdownTextRange$stableprop_getter(){}[0]
+final fun io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_NewlineSemantics_CommonMark$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_NewlineSemantics_CommonMark$stableprop_getter|io_github_linreal_cascade_editor_markdown_NewlineSemantics_CommonMark$stableprop_getter(){}[0]
+final fun io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_NewlineSemantics_HardBreak$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_NewlineSemantics_HardBreak$stableprop_getter|io_github_linreal_cascade_editor_markdown_NewlineSemantics_HardBreak$stableprop_getter(){}[0]
+final fun io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_SoftBreak_LineBreak$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_SoftBreak_LineBreak$stableprop_getter|io_github_linreal_cascade_editor_markdown_SoftBreak_LineBreak$stableprop_getter(){}[0]
+final fun io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_SoftBreak_Space$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_SoftBreak_Space$stableprop_getter|io_github_linreal_cascade_editor_markdown_SoftBreak_Space$stableprop_getter(){}[0]
+final fun io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_UnsupportedSyntax_Preserve$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_UnsupportedSyntax_Preserve$stableprop_getter|io_github_linreal_cascade_editor_markdown_UnsupportedSyntax_Preserve$stableprop_getter(){}[0]
+final fun io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_UnsupportedSyntax_WarnAndDegrade$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.markdown/io_github_linreal_cascade_editor_markdown_UnsupportedSyntax_WarnAndDegrade$stableprop_getter|io_github_linreal_cascade_editor_markdown_UnsupportedSyntax_WarnAndDegrade$stableprop_getter(){}[0]
 final fun io.github.linreal.cascade.editor.registry/io_github_linreal_cascade_editor_registry_BlockDescriptor$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.registry/io_github_linreal_cascade_editor_registry_BlockDescriptor$stableprop_getter|io_github_linreal_cascade_editor_registry_BlockDescriptor$stableprop_getter(){}[0]
 final fun io.github.linreal.cascade.editor.registry/io_github_linreal_cascade_editor_registry_BlockRegistry$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.registry/io_github_linreal_cascade_editor_registry_BlockRegistry$stableprop_getter|io_github_linreal_cascade_editor_registry_BlockRegistry$stableprop_getter(){}[0]
 final fun io.github.linreal.cascade.editor.registry/io_github_linreal_cascade_editor_registry_DefaultBlockCallbacks$stableprop_getter(): kotlin/Int // io.github.linreal.cascade.editor.registry/io_github_linreal_cascade_editor_registry_DefaultBlockCallbacks$stableprop_getter|io_github_linreal_cascade_editor_registry_DefaultBlockCallbacks$stableprop_getter(){}[0]
diff --git a/editor/build.gradle.kts b/editor/build.gradle.kts
index 7579be7..509fb75 100644
--- a/editor/build.gradle.kts
+++ b/editor/build.gradle.kts
@@ -53,12 +53,14 @@ kotlin {
     sourceSets {
         all {
             languageSettings.optIn("io.github.linreal.cascade.editor.htmlserialization.ExperimentalCascadeHtmlApi")
+            languageSettings.optIn("io.github.linreal.cascade.editor.markdown.ExperimentalCascadeMarkdownApi")
         }
 
         commonMain.dependencies {
             implementation(libs.compose.foundation)
             implementation(libs.compose.components.resources)
             implementation(libs.kotlinx.serialization.json)
+            implementation(libs.jetbrains.markdown)
         }
 
         commonTest.dependencies {
diff --git a/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/core/SpanStyle.kt b/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/core/SpanStyle.kt
index 7f79288..c84a4fc 100644
--- a/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/core/SpanStyle.kt
+++ b/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/core/SpanStyle.kt
@@ -29,14 +29,16 @@ public sealed interface SpanStyle {
      * Link to an external web URL.
      *
      * The visible link title remains the text covered by the [TextSpan] range.
-     * Callers should construct this style with a URL normalized by
-     * [io.github.linreal.cascade.editor.richtext.LinkUrlPolicy].
+     * Callers should construct this style with a target validated by
+     * [io.github.linreal.cascade.editor.richtext.LinkUrlPolicy]: `validate` for
+     * user-entered URLs (normalizing), `validateStoredTarget` for decoded/persisted
+     * targets (preserving).
      */
     @Immutable
     public data class Link(val url: String) : SpanStyle {
         init {
             require(url.isNotBlank()) {
-                "url must not be blank; use LinkUrlPolicy.validate before constructing Link"
+                "url must not be blank; use LinkUrlPolicy before constructing Link"
             }
         }
     }
diff --git a/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/htmlserialization/DefaultTagDecoders.kt b/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/htmlserialization/DefaultTagDecoders.kt
index 6918a13..0b91780 100644
--- a/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/htmlserialization/DefaultTagDecoders.kt
+++ b/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/htmlserialization/DefaultTagDecoders.kt
@@ -219,7 +219,9 @@ internal object DefaultTagDecoders {
     ): TagDecodeResult {
         val inline = ctx.decodeInline(children)
         val href = attrs["href"]
-        val validation = href?.let(LinkUrlPolicy::validate)
+        // Stored-target validation: imported hrefs are persisted targets, not user entry.
+        // Relative/fragment/mailto:/tel:/custom-scheme targets must be preserved exactly.
+        val validation = href?.let(LinkUrlPolicy::validateStoredTarget)
         val normalizedUrl = (validation as? LinkValidationResult.Valid)?.normalizedUrl
         if (normalizedUrl == null) {
             ctx.warn(
diff --git a/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/htmlserialization/HtmlDecodeEngine.kt b/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/htmlserialization/HtmlDecodeEngine.kt
index 3ed807b..5242374 100644
--- a/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/htmlserialization/HtmlDecodeEngine.kt
+++ b/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/htmlserialization/HtmlDecodeEngine.kt
@@ -26,7 +26,7 @@ internal object HtmlDecodeEngine {
             val parsed = HtmlParser.parse(html, profile)
             val warnings = parsed.warnings.toMutableList()
             val rootNodes = parsed.nodes.map(HtmlNodeViewMapper::toView)
-            val runner = Runner(
+            val runner = HtmlDecodeRunner(
                 rawSource = html,
                 profile = profile,
                 warnings = warnings,
@@ -41,172 +41,216 @@ internal object HtmlDecodeEngine {
             )
         }
     }
+}
 
-    private class Runner(
-        override val rawSource: String,
-        private val profile: HtmlProfile,
-        private val warnings: MutableList<HtmlDecodeWarning>,
-    ) : DecodeEngineHandle {
-
-        override fun warn(warning: HtmlDecodeWarning) {
-            warnings += warning
-        }
+/**
+ * Shared decode walker used by the full-document [HtmlDecodeEngine] and the
+ * fragment entry points in [HtmlFragmentDecoder].
+ *
+ * [textLeafReparser] is an optional hook that re-parses text leaves before they
+ * join the surrounding inline run (the Markdown HTML bridge routes inner text
+ * back through the Markdown inline parser this way, so `<u>**bold**</u>` keeps
+ * the nested style). When null — the full-document path — text leaves append
+ * verbatim, preserving existing behavior exactly. A throwing reparser degrades
+ * to verbatim text plus a [HtmlDecodeWarning.DecoderException]. The hook does
+ * not apply to `<pre>` text, which is collected verbatim by the code decoder
+ * without entering inline decoding.
+ */
+internal class HtmlDecodeRunner(
+    override val rawSource: String,
+    private val profile: HtmlProfile,
+    private val warnings: MutableList<HtmlDecodeWarning>,
+    private val textLeafReparser: ((String) -> InlineFragment)? = null,
+    /**
+     * When true, an inline run that is whitespace-only and span-free is not
+     * flushed into a paragraph. Fragment decoding uses this so formatting
+     * whitespace between block elements produces no blank paragraph while
+     * significant spaces between inline runs (`<b>a</b> <i>b</i>`) survive.
+     * The document path keeps this false: root whitespace there is governed
+     * by parser policies before the runner sees it.
+     */
+    private val skipBlankInlineFlush: Boolean = false,
+) : DecodeEngineHandle {
+
+    override fun warn(warning: HtmlDecodeWarning) {
+        warnings += warning
+    }
 
-        override fun tagDecoderFor(tag: String): TagDecoder? = profile.tagDecoderFor(tag)
+    override fun tagDecoderFor(tag: String): TagDecoder? = profile.tagDecoderFor(tag)
 
-        override fun decodeBlocks(children: List<HtmlNodeView>, parentTag: String?): List<Block> {
-            val blocks = mutableListOf<Block>()
-            var pendingInline = InlineFragment("", emptyList())
+    override fun decodeBlocks(children: List<HtmlNodeView>, parentTag: String?): List<Block> {
+        val blocks = mutableListOf<Block>()
+        var pendingInline = InlineFragment("", emptyList())
 
-            fun flushInline() {
-                if (pendingInline.text.isEmpty() && pendingInline.spans.isEmpty()) return
-                blocks += Block.paragraph(pendingInline.text, pendingInline.spans)
+        fun flushInline() {
+            if (pendingInline.text.isEmpty() && pendingInline.spans.isEmpty()) return
+            if (skipBlankInlineFlush && pendingInline.text.isBlank() && pendingInline.spans.isEmpty()) {
                 pendingInline = InlineFragment("", emptyList())
+                return
             }
+            blocks += Block.paragraph(pendingInline.text, pendingInline.spans)
+            pendingInline = InlineFragment("", emptyList())
+        }
 
-            for (child in children) {
-                when (child) {
-                    is HtmlNodeView.Text -> {
-                        pendingInline = pendingInline.appendText(child.text)
-                    }
-
-                    is HtmlNodeView.Element -> {
-                        when (val result = decodeElement(child, isBlockContext = true, parentTag = parentTag)) {
-                            is TagDecodeResult.AsBlock -> {
-                                flushInline()
-                                blocks += result.block
-                            }
+        for (child in children) {
+            when (child) {
+                is HtmlNodeView.Text -> {
+                    pendingInline = pendingInline.appendFragment(textLeafFragment(child))
+                }
 
-                            is TagDecodeResult.AsBlocks -> {
-                                flushInline()
-                                blocks += result.blocks
-                            }
+                is HtmlNodeView.Element -> {
+                    when (val result = decodeElement(child, isBlockContext = true, parentTag = parentTag)) {
+                        is TagDecodeResult.AsBlock -> {
+                            flushInline()
+                            blocks += result.block
+                        }
 
-                            is TagDecodeResult.AsText -> {
-                                pendingInline = pendingInline.appendFragment(InlineFragment(result.text, result.spans))
-                            }
+                        is TagDecodeResult.AsBlocks -> {
+                            flushInline()
+                            blocks += result.blocks
+                        }
 
-                            TagDecodeResult.Drop -> Unit
+                        is TagDecodeResult.AsText -> {
+                            pendingInline = pendingInline.appendFragment(InlineFragment(result.text, result.spans))
                         }
+
+                        TagDecodeResult.Drop -> Unit
                     }
                 }
             }
-            flushInline()
-            return blocks
         }
+        flushInline()
+        return blocks
+    }
 
-        override fun decodeInline(children: List<HtmlNodeView>, parentTag: String?): InlineFragment {
-            var inline = InlineFragment("", emptyList())
-            for (child in children) {
-                when (child) {
-                    is HtmlNodeView.Text -> {
-                        inline = inline.appendText(child.text)
-                    }
-
-                    is HtmlNodeView.Element -> {
-                        when (val result = decodeElement(child, isBlockContext = false, parentTag = parentTag)) {
-                            is TagDecodeResult.AsText -> {
-                                inline = inline.appendFragment(InlineFragment(result.text, result.spans))
-                            }
+    override fun decodeInline(children: List<HtmlNodeView>, parentTag: String?): InlineFragment {
+        var inline = InlineFragment("", emptyList())
+        for (child in children) {
+            when (child) {
+                is HtmlNodeView.Text -> {
+                    inline = inline.appendFragment(textLeafFragment(child))
+                }
 
-                            is TagDecodeResult.AsBlock -> {
-                                warn(HtmlDecodeWarning.BlockInInlineContext(child.tag, child.sourceStart))
-                                inline = inline.appendBlocks(listOf(result.block))
-                            }
+                is HtmlNodeView.Element -> {
+                    when (val result = decodeElement(child, isBlockContext = false, parentTag = parentTag)) {
+                        is TagDecodeResult.AsText -> {
+                            inline = inline.appendFragment(InlineFragment(result.text, result.spans))
+                        }
 
-                            is TagDecodeResult.AsBlocks -> {
-                                warn(HtmlDecodeWarning.BlockInInlineContext(child.tag, child.sourceStart))
-                                inline = inline.appendBlocks(result.blocks)
-                            }
+                        is TagDecodeResult.AsBlock -> {
+                            warn(HtmlDecodeWarning.BlockInInlineContext(child.tag, child.sourceStart))
+                            inline = inline.appendBlocks(listOf(result.block))
+                        }
 
-                            TagDecodeResult.Drop -> Unit
+                        is TagDecodeResult.AsBlocks -> {
+                            warn(HtmlDecodeWarning.BlockInInlineContext(child.tag, child.sourceStart))
+                            inline = inline.appendBlocks(result.blocks)
                         }
+
+                        TagDecodeResult.Drop -> Unit
                     }
                 }
             }
-            return inline
         }
+        return inline
+    }
 
-        private fun decodeElement(
-            element: HtmlNodeView.Element,
-            isBlockContext: Boolean,
-            parentTag: String?,
-        ): TagDecodeResult {
-            val context = TagDecodeContextImpl(
-                engine = this,
-                currentNode = element,
-                isBlockContext = isBlockContext,
-                parentTag = parentTag,
-            )
-
-            return try {
-                val decoder = profile.tagDecoderFor(element.tag)
-                if (decoder != null) {
-                    decoder.decode(context, element.attrs, element.children)
-                } else {
-                    decodeUnknown(element, context, isBlockContext)
-                }
-            } catch (throwable: Throwable) {
-                warn(
-                    decoderExceptionWarning(
-                        tag = element.tag,
-                        throwable = throwable,
-                        charOffset = element.sourceStart,
-                    )
+    private fun textLeafFragment(leaf: HtmlNodeView.Text): InlineFragment {
+        val reparser = textLeafReparser
+            ?: return InlineFragment(leaf.text, emptyList())
+        return try {
+            reparser(leaf.text)
+        } catch (throwable: Throwable) {
+            warn(
+                decoderExceptionWarning(
+                    tag = null,
+                    throwable = throwable,
+                    charOffset = leaf.sourceStart,
                 )
-                TagDecodeResult.Drop
-            }
+            )
+            InlineFragment(leaf.text, emptyList())
         }
+    }
 
-        private fun decodeUnknown(
-            element: HtmlNodeView.Element,
-            context: TagDecodeContext,
-            isBlockContext: Boolean,
-        ): TagDecodeResult = when (val policy = profile.unknownTagPolicy) {
-            UnknownTagPolicy.Strip -> stripUnknown(element, isBlockContext)
-            UnknownTagPolicy.WarnAndStrip -> {
-                warn(HtmlDecodeWarning.UnknownTag(element.tag, element.sourceStart))
-                stripUnknown(element, isBlockContext)
-            }
+    private fun decodeElement(
+        element: HtmlNodeView.Element,
+        isBlockContext: Boolean,
+        parentTag: String?,
+    ): TagDecodeResult {
+        val context = TagDecodeContextImpl(
+            engine = this,
+            currentNode = element,
+            isBlockContext = isBlockContext,
+            parentTag = parentTag,
+        )
 
-            UnknownTagPolicy.Preserve -> {
-                if (isBlockContext) {
-                    TagDecodeResult.AsBlock(preserveUnknownBlock(element, context))
-                } else {
-                    warn(HtmlDecodeWarning.UnknownTag(element.tag, element.sourceStart))
-                    stripUnknown(element, isBlockContext = false)
-                }
+        return try {
+            val decoder = profile.tagDecoderFor(element.tag)
+            if (decoder != null) {
+                decoder.decode(context, element.attrs, element.children)
+            } else {
+                decodeUnknown(element, context, isBlockContext)
             }
+        } catch (throwable: Throwable) {
+            warn(
+                decoderExceptionWarning(
+                    tag = element.tag,
+                    throwable = throwable,
+                    charOffset = element.sourceStart,
+                )
+            )
+            TagDecodeResult.Drop
+        }
+    }
 
-            is UnknownTagPolicy.Custom -> policy.handler(element, context)
+    private fun decodeUnknown(
+        element: HtmlNodeView.Element,
+        context: TagDecodeContext,
+        isBlockContext: Boolean,
+    ): TagDecodeResult = when (val policy = profile.unknownTagPolicy) {
+        UnknownTagPolicy.Strip -> stripUnknown(element, isBlockContext)
+        UnknownTagPolicy.WarnAndStrip -> {
+            warn(HtmlDecodeWarning.UnknownTag(element.tag, element.sourceStart))
+            stripUnknown(element, isBlockContext)
         }
 
-        private fun stripUnknown(
-            element: HtmlNodeView.Element,
-            isBlockContext: Boolean,
-        ): TagDecodeResult =
+        UnknownTagPolicy.Preserve -> {
             if (isBlockContext) {
-                TagDecodeResult.AsBlocks(decodeBlocks(element.children, parentTag = element.tag))
+                TagDecodeResult.AsBlock(preserveUnknownBlock(element, context))
             } else {
-                val inline = decodeInline(element.children, parentTag = element.tag)
-                TagDecodeResult.AsText(inline.text, inline.spans)
+                warn(HtmlDecodeWarning.UnknownTag(element.tag, element.sourceStart))
+                stripUnknown(element, isBlockContext = false)
             }
+        }
 
-        private fun preserveUnknownBlock(
-            element: HtmlNodeView.Element,
-            context: TagDecodeContext,
-        ): Block = Block(
-            id = BlockId.generate(),
-            type = PreservedHtmlBlockType,
-            content = BlockContent.Custom(
-                typeId = PreservedHtmlBlockType.typeId,
-                data = mapOf(
-                    "tagName" to element.tag,
-                    "rawHtml" to context.rawSliceOf(element),
-                ),
-            ),
-        )
+        is UnknownTagPolicy.Custom -> policy.handler(element, context)
     }
+
+    private fun stripUnknown(
+        element: HtmlNodeView.Element,
+        isBlockContext: Boolean,
+    ): TagDecodeResult =
+        if (isBlockContext) {
+            TagDecodeResult.AsBlocks(decodeBlocks(element.children, parentTag = element.tag))
+        } else {
+            val inline = decodeInline(element.children, parentTag = element.tag)
+            TagDecodeResult.AsText(inline.text, inline.spans)
+        }
+
+    private fun preserveUnknownBlock(
+        element: HtmlNodeView.Element,
+        context: TagDecodeContext,
+    ): Block = Block(
+        id = BlockId.generate(),
+        type = PreservedHtmlBlockType,
+        content = BlockContent.Custom(
+            typeId = PreservedHtmlBlockType.typeId,
+            data = mapOf(
+                "tagName" to element.tag,
+                "rawHtml" to context.rawSliceOf(element),
+            ),
+        ),
+    )
 }
 
 internal interface DecodeEngineHandle {
@@ -221,7 +265,7 @@ internal interface DecodeEngineHandle {
     fun decodeInline(children: List<HtmlNodeView>, parentTag: String?): InlineFragment
 }
 
-private fun decoderExceptionWarning(
+internal fun decoderExceptionWarning(
     tag: String?,
     throwable: Throwable,
     charOffset: Int,
@@ -232,9 +276,6 @@ private fun decoderExceptionWarning(
         charOffset = charOffset,
     )
 
-private fun InlineFragment.appendText(textToAppend: String): InlineFragment =
-    if (textToAppend.isEmpty()) this else copy(text = text + textToAppend)
-
 private fun InlineFragment.appendFragment(fragment: InlineFragment): InlineFragment {
     if (fragment.text.isEmpty() && fragment.spans.isEmpty()) return this
     val offset = text.length
diff --git a/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/htmlserialization/HtmlFragmentDecoder.kt b/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/htmlserialization/HtmlFragmentDecoder.kt
new file mode 100644
index 0000000..79eb8e5
--- /dev/null
+++ b/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/htmlserialization/HtmlFragmentDecoder.kt
@@ -0,0 +1,107 @@
+package io.github.linreal.cascade.editor.htmlserialization
+
+import io.github.linreal.cascade.editor.core.Block
+
+/**
+ * Internal fragment-decode entry points over a given [HtmlProfile], extracted
+ * for the Markdown HTML bridge.
+ *
+ * Differences from the full-document [HtmlDecodeEngine] path, by design:
+ *
+ * - Parser policies do not apply: root inline content is decoded, not dropped
+ *   (`InlineRoot.Drop` would make `<u>x</u>` yield an empty inline result),
+ *   and root text is not newline-split. Fragments are already scoped by the
+ *   caller.
+ * - No post-decode outline normalization or list renumbering — fragment blocks
+ *   join a larger document whose decode owns normalization.
+ * - Warning `charOffset`s are relative to the fragment string; callers re-base
+ *   them into their own source coordinates (the bridge maps them into Markdown
+ *   source ranges).
+ *
+ * [textLeafReparser] hands text leaves back to a caller-supplied inline
+ * re-parser so nested non-HTML syntax survives (`<u>**bold**</u>` routes
+ * `**bold**` through the Markdown inline parser). See [HtmlDecodeRunner].
+ *
+ * Everything here is internal to `:editor`; no public API surface changes.
+ */
+internal object HtmlFragmentDecoder {
+
+    /**
+     * Decode [html] as a block-level fragment: block elements produce blocks,
+     * root-level inline runs flush into paragraphs. Whitespace-only inline
+     * runs never flush into blank paragraphs (formatting whitespace between
+     * block elements is noise), but whitespace between inline elements stays
+     * part of the surrounding run — `<b>a</b> <i>b</i>` keeps its space.
+     */
+    internal fun decodeBlockFragment(
+        html: String,
+        profile: HtmlProfile,
+        textLeafReparser: ((String) -> InlineFragment)? = null,
+    ): HtmlBlockFragmentResult {
+        return try {
+            val parsed = HtmlParser.parse(html, profile.entityDecode)
+            val warnings = parsed.warnings.toMutableList()
+            val rootViews = parsed.nodes.map(HtmlNodeViewMapper::toView)
+            val runner = HtmlDecodeRunner(
+                rawSource = html,
+                profile = profile,
+                warnings = warnings,
+                textLeafReparser = textLeafReparser,
+                skipBlankInlineFlush = true,
+            )
+            HtmlBlockFragmentResult(
+                blocks = runner.decodeBlocks(rootViews, parentTag = null),
+                warnings = warnings,
+            )
+        } catch (throwable: Throwable) {
+            HtmlBlockFragmentResult(
+                blocks = emptyList(),
+                warnings = listOf(decoderExceptionWarning(tag = null, throwable = throwable, charOffset = 0)),
+            )
+        }
+    }
+
+    /**
+     * Decode [html] as an inline fragment: paired inline tags produce spans
+     * over the collected text. Block-producing decoders degrade through the
+     * usual [HtmlDecodeWarning.BlockInInlineContext] flattening.
+     */
+    internal fun decodeInlineFragment(
+        html: String,
+        profile: HtmlProfile,
+        textLeafReparser: ((String) -> InlineFragment)? = null,
+    ): HtmlInlineFragmentResult {
+        return try {
+            val parsed = HtmlParser.parse(html, profile.entityDecode)
+            val warnings = parsed.warnings.toMutableList()
+            val rootViews = parsed.nodes.map(HtmlNodeViewMapper::toView)
+            val runner = HtmlDecodeRunner(
+                rawSource = html,
+                profile = profile,
+                warnings = warnings,
+                textLeafReparser = textLeafReparser,
+            )
+            HtmlInlineFragmentResult(
+                fragment = runner.decodeInline(rootViews, parentTag = null),
+                warnings = warnings,
+            )
+        } catch (throwable: Throwable) {
+            HtmlInlineFragmentResult(
+                fragment = InlineFragment("", emptyList()),
+                warnings = listOf(decoderExceptionWarning(tag = null, throwable = throwable, charOffset = 0)),
+            )
+        }
+    }
+}
+
+/** Result of [HtmlFragmentDecoder.decodeBlockFragment]. */
+internal data class HtmlBlockFragmentResult(
+    val blocks: List<Block>,
+    val warnings: List<HtmlDecodeWarning>,
+)
+
+/** Result of [HtmlFragmentDecoder.decodeInlineFragment]. */
+internal data class HtmlInlineFragmentResult(
+    val fragment: InlineFragment,
+    val warnings: List<HtmlDecodeWarning>,
+)
diff --git a/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/htmlserialization/HtmlTokenizer.kt b/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/htmlserialization/HtmlTokenizer.kt
index 523fb0f..49a0c83 100644
--- a/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/htmlserialization/HtmlTokenizer.kt
+++ b/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/htmlserialization/HtmlTokenizer.kt
@@ -286,7 +286,9 @@ internal object HtmlTokenizer {
 }
 
 internal object HtmlEntityDecoder {
-    private val namedEntities: Map<String, String> = mapOf(
+    // Shared with the Markdown codec's entity table (markdown/MarkdownEntities.kt),
+    // which extends this base set with additional documented names.
+    internal val namedEntities: Map<String, String> = mapOf(
         "amp" to "&",
         "lt" to "<",
         "gt" to ">",
diff --git a/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/markdown/DefaultMarkdownBlockEncoders.kt b/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/markdown/DefaultMarkdownBlockEncoders.kt
new file mode 100644
index 0000000..8a69893
--- /dev/null
+++ b/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/markdown/DefaultMarkdownBlockEncoders.kt
@@ -0,0 +1,168 @@
+package io.github.linreal.cascade.editor.markdown
+
+import io.github.linreal.cascade.editor.core.BlockAttributes
+import io.github.linreal.cascade.editor.core.BlockContent
+import io.github.linreal.cascade.editor.core.BlockType
+
+/**
+ * Canonical default block encoders: ATX headings, `> ` per
+ * physical line, backtick fences with no info string widened past internal
+ * runs, `---` dividers. The list outline (`BulletList` / `NumberedList` /
+ * `Todo`) is claimed by [DefaultMarkdownListOutlineEncoder]; block separation
+ * belongs to [MarkdownEncodeEngine], so every emit here is content-only.
+ */
+internal object DefaultMarkdownBlockEncoders {
+
+    internal val Paragraph: MarkdownBlockEncoder<BlockType.Paragraph> =
+        MarkdownBlockEncoder { ctx, block, content ->
+            val text = (content as? BlockContent.Text)?.text.orEmpty()
+            if (text.isEmpty() && ctx.newlineSemantics == NewlineSemantics.CommonMark) {
+                // Empty paragraphs are not encodable in CommonMark mode; defer
+                // to the warning fallback.
+                MarkdownEmit.Skip
+            } else {
+                if (block.attributes.indentationLevel > BlockAttributes.MIN_INDENTATION_LEVEL) {
+                    ctx.warn(
+                        MarkdownEncodeWarning.DroppedAttribute(
+                            attr = "indentationLevel",
+                            reason = "Markdown has no indented-paragraph syntax; " +
+                                "encoded at depth 0",
+                            blockId = block.id,
+                        ),
+                    )
+                }
+                MarkdownEmit.Raw(ctx.encodeInlineLines(block).joinToString("\n"))
+            }
+        }
+
+    internal val Heading: MarkdownBlockEncoder<BlockType.Heading> =
+        MarkdownBlockEncoder { ctx, block, _ ->
+            val level = (block.type as BlockType.Heading).level
+            val lines = ctx.encodeInlineLines(block)
+            // A heading is one physical line; embedded newlines encode as a
+            // single space with a DataLoss warning.
+            val text = if (lines.size > 1) {
+                ctx.warn(
+                    MarkdownEncodeWarning.DroppedAttribute(
+                        attr = "lineBreak",
+                        reason = "an ATX heading cannot contain line breaks; " +
+                            "each embedded newline was encoded as a space",
+                        blockId = block.id,
+                    ),
+                )
+                // Strip exactly the marker the context appended to non-final
+                // lines; final lines (and HardBreak mode) carry none.
+                val marker = ctx.hardBreakMarker
+                lines.mapIndexed { index, line ->
+                    if (marker != null && index < lines.lastIndex && line.endsWith(marker)) {
+                        line.dropLast(marker.length)
+                    } else {
+                        line
+                    }
+                }.joinToString(" ")
+            } else {
+                lines.first()
+            }
+            val marker = "#".repeat(level)
+            MarkdownEmit.Raw(if (text.isEmpty()) marker else "$marker $text")
+        }
+
+    internal val Quote: MarkdownBlockEncoder<BlockType.Quote> =
+        MarkdownBlockEncoder { ctx, block, content ->
+            val text = (content as? BlockContent.Text)?.text.orEmpty()
+            if (text.isEmpty() && ctx.newlineSemantics == NewlineSemantics.CommonMark) {
+                // "> " re-decodes to zero blocks; empty quotes are not
+                // encodable in CommonMark mode — defer to the warning fallback
+                // like empty paragraphs, with no silent fallback.
+                MarkdownEmit.Skip
+            } else {
+                val prefixed = ctx.prefixLines(
+                    lines = ctx.encodeInlineLines(block),
+                    firstLinePrefix = "> ",
+                    continuationPrefix = "> ",
+                )
+                MarkdownEmit.Raw(prefixed.joinToString("\n"))
+            }
+        }
+
+    internal val Code: MarkdownBlockEncoder<BlockType.Code> =
+        MarkdownBlockEncoder { ctx, block, content ->
+            // Code content is byte-exact — never escaped. The fence owns one
+            // structural newline after the opener and before the closer, and
+            // is widened past every backtick run in the
+            // content so no content line can close it early.
+            val text = (content as? BlockContent.Text)?.text.orEmpty()
+            // A `\r` in code does not round-trip: the source layer treats it as
+            // a line terminator, so re-decode normalizes it away.
+            if (text.indexOf('\r') >= 0) {
+                ctx.warn(
+                    MarkdownEncodeWarning.DroppedAttribute(
+                        attr = "carriageReturn",
+                        reason = "code content contains a carriage return, which does not " +
+                            "round-trip as Markdown code",
+                        blockId = block.id,
+                    ),
+                )
+            }
+            val fence = "`".repeat(maxOf(3, longestBacktickRun(text) + 1))
+            val body = if (text.isEmpty()) "" else text + "\n"
+            MarkdownEmit.Raw("$fence\n$body$fence")
+        }
+
+    internal val Divider: MarkdownBlockEncoder<BlockType.Divider> =
+        MarkdownBlockEncoder { _, _, _ -> MarkdownEmit.Raw("---") }
+
+    /**
+     * Pre-registered verbatim encoder for `md.preserved` blocks: the
+     * character-exact `rawMarkdown` slice is emitted through the
+     * distinct [MarkdownEmit.Verbatim] path. A payload without the slice
+     * defers to the warning fallback.
+     */
+    internal val Preserved: MarkdownBlockEncoder<BlockType> =
+        MarkdownBlockEncoder { _, _, content ->
+            val raw = ((content as? BlockContent.Custom)?.data?.get("rawMarkdown") as? String)
+            if (raw == null) MarkdownEmit.Skip else MarkdownEmit.Verbatim(raw)
+        }
+
+    /**
+     * Strict-mode `md.preserved` encoder for [MarkdownProfile.withoutHtmlBridge]:
+     * emits the verbatim slice **except** when the preserved kind is HTML **or**
+     * the slice contains a `<` — a strict profile can never emit raw HTML
+     * through the preserved-block path, including a `<script>` smuggled inside a
+     * preserved table cell or front-matter block. Such a slice is dropped
+     * through the fallback (with an `UnsupportedBlock` warning).
+     */
+    internal val StrictPreserved: MarkdownBlockEncoder<BlockType> =
+        MarkdownBlockEncoder { _, _, content ->
+            val custom = content as? BlockContent.Custom
+            val raw = custom?.data?.get("rawMarkdown") as? String
+            val kind = custom?.data?.get("kind") as? String
+            when {
+                raw == null -> MarkdownEmit.Skip
+                kind != null && kind.startsWith("html") -> MarkdownEmit.Skip
+                raw.indexOf('<') >= 0 -> MarkdownEmit.Skip
+                else -> MarkdownEmit.Verbatim(raw)
+            }
+        }
+
+    /**
+     * Strict-mode `md.preservedHtml` encoder: always defers to the fallback
+     * (dropped with a warning) so raw HTML is never emitted.
+     */
+    internal val StrictDropHtml: MarkdownBlockEncoder<BlockType> =
+        MarkdownBlockEncoder { _, _, _ -> MarkdownEmit.Skip }
+}
+
+private fun longestBacktickRun(text: String): Int {
+    var longest = 0
+    var current = 0
+    for (ch in text) {
+        if (ch == '`') {
+            current++
+            if (current > longest) longest = current
+        } else {
+            current = 0
+        }
+    }
+    return longest
+}
diff --git a/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/markdown/DefaultMarkdownEncoderFallbacks.kt b/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/markdown/DefaultMarkdownEncoderFallbacks.kt
new file mode 100644
index 0000000..71db635
--- /dev/null
+++ b/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/markdown/DefaultMarkdownEncoderFallbacks.kt
@@ -0,0 +1,49 @@
+package io.github.linreal.cascade.editor.markdown
+
+import io.github.linreal.cascade.editor.core.BlockContent
+import io.github.linreal.cascade.editor.core.BlockType
+import io.github.linreal.cascade.editor.core.CustomBlockType
+import io.github.linreal.cascade.editor.core.SpanStyle
+
+/**
+ * Default encode fallbacks. Unlike the HTML codec's silent
+ * fallbacks, both emit a `DataLoss` warning — a silent fallback would make
+ * `encodeWithReport` and `analyze` unreliable for out-of-support documents.
+ */
+internal object DefaultMarkdownEncoderFallbacks {
+
+    /**
+     * Block fallback: a plain paragraph carrying the block's visible text
+     * where possible (custom/empty content may have none), plus an
+     * [MarkdownEncodeWarning.UnsupportedBlock] warning. An empty emission is
+     * dropped by the engine, never turned into a blank unit.
+     */
+    internal val Block: MarkdownBlockEncoder<BlockType> =
+        MarkdownBlockEncoder { ctx, block, content ->
+            ctx.warn(
+                MarkdownEncodeWarning.UnsupportedBlock(
+                    typeId = block.fallbackTypeId(),
+                    reason = "no Markdown encoding produced output for this block; " +
+                        "visible text was emitted as a plain paragraph",
+                    blockId = block.id,
+                ),
+            )
+            if (content is BlockContent.Text && content.text.isNotEmpty()) {
+                MarkdownEmit.Raw(ctx.encodeInlineLines(block).joinToString("\n"))
+            } else {
+                MarkdownEmit.Raw("")
+            }
+        }
+
+    /** Span fallback: text kept, marks dropped. */
+    internal val Span: MarkdownSpanEncoder<SpanStyle> =
+        MarkdownSpanEncoder { MarkdownMarkPair(open = "", close = "") }
+}
+
+private fun io.github.linreal.cascade.editor.core.Block.fallbackTypeId(): String {
+    val type = this.type
+    if (type is CustomBlockType) return type.typeId
+    val content = this.content
+    if (content is BlockContent.Custom) return content.typeId
+    return type.typeId
+}
diff --git a/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/markdown/DefaultMarkdownListOutlineEncoder.kt b/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/markdown/DefaultMarkdownListOutlineEncoder.kt
new file mode 100644
index 0000000..db34875
--- /dev/null
+++ b/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/markdown/DefaultMarkdownListOutlineEncoder.kt
@@ -0,0 +1,127 @@
+package io.github.linreal.cascade.editor.markdown
+
+import io.github.linreal.cascade.editor.core.Block
+import io.github.linreal.cascade.editor.core.BlockAttributes
+import io.github.linreal.cascade.editor.core.BlockType
+
+/**
+ * Default `listOutline` group encoder: claims contiguous runs of `BulletList`,
+ * `NumberedList`, **and** `Todo` blocks (task items are list items, so `Todo`
+ * must join the outline group to nest correctly).
+ *
+ * Canonical forms: `- ` bullets, normalized `n.` markers
+ * from the block's stored number, `- [ ]` / `- [x]` task items, tight lists
+ * (no blank lines between items). Indentation is **marker-relative**: a child
+ * is indented by its parent's marker width (2 columns for `- ` and task
+ * items — the `[x] ` checkbox is item *content* — and `digits + 2` for
+ * ordered markers), so the output re-parses to the same nesting.
+ *
+ * Skipped editor depths have no `cascade-indent-N` analog in Markdown: they
+ * encode best-effort at the deepest reachable nesting and re-decode shallower,
+ * with a [MarkdownEncodeWarning.DroppedAttribute] warning.
+ */
+internal object DefaultMarkdownListOutlineEncoder : MarkdownBlockGroupEncoder {
+
+    override fun groupKey(block: Block): Any? =
+        if (block.type.isListOutlineType) LIST_OUTLINE_GROUP_KEY else null
+
+    override fun encodeGroup(ctx: MarkdownEncodeContext, blocks: List<Block>): MarkdownEmit {
+        if (blocks.isEmpty()) return MarkdownEmit.Skip
+        val lines = ArrayList<String>(blocks.size)
+        appendNodes(
+            ctx = ctx,
+            nodes = blocks.toListOutlineForest(),
+            indent = "",
+            expectedDepth = BlockAttributes.MIN_INDENTATION_LEVEL,
+            lines = lines,
+        )
+        return MarkdownEmit.Raw(lines.joinToString("\n"))
+    }
+
+    /**
+     * Builds a parent/child forest from the flat editor outline using the
+     * nearest preceding shallower item as the parent (same construction as the
+     * HTML codec's list outline encoder).
+     */
+    private fun List<Block>.toListOutlineForest(): List<ListNode> {
+        val roots = mutableListOf<ListNode>()
+        val stack = mutableListOf<ListNode>()
+        for (block in this) {
+            val depth = block.attributes.indentationLevel
+            while (stack.isNotEmpty() && stack.last().depth >= depth) {
+                stack.removeAt(stack.lastIndex)
+            }
+            val node = ListNode(block = block, depth = depth)
+            val parent = stack.lastOrNull()
+            if (parent == null) roots += node else parent.children += node
+            stack += node
+        }
+        return roots
+    }
+
+    private fun appendNodes(
+        ctx: MarkdownEncodeContext,
+        nodes: List<ListNode>,
+        indent: String,
+        expectedDepth: Int,
+        lines: MutableList<String>,
+    ) {
+        for (node in nodes) {
+            if (node.depth > expectedDepth) {
+                ctx.warn(
+                    MarkdownEncodeWarning.DroppedAttribute(
+                        attr = "indentationLevel",
+                        reason = "skipped outline depth ${node.depth} has no Markdown " +
+                            "encoding; the item re-decodes at depth $expectedDepth",
+                        blockId = node.block.id,
+                    ),
+                )
+            }
+            val marker = markerFor(node.block.type)
+            val continuationIndent = indent + " ".repeat(marker.continuationWidth)
+            val inline = ctx.encodeInlineLines(node.block)
+            val firstLine = indent + marker.text + inline.first()
+            lines += if (inline.first().isEmpty()) firstLine.trimEnd(' ') else firstLine
+            for (index in 1 until inline.size) {
+                lines += continuationIndent + inline[index]
+            }
+            appendNodes(
+                ctx = ctx,
+                nodes = node.children,
+                indent = continuationIndent,
+                // A skipped-depth node emits at expectedDepth, so descendants
+                // must be measured against the emitted depth, not the stored
+                // one — otherwise they shift silently without a warning.
+                expectedDepth = minOf(node.depth, expectedDepth) + 1,
+                lines = lines,
+            )
+        }
+    }
+
+    private fun markerFor(type: BlockType): Marker = when (type) {
+        is BlockType.Todo ->
+            // The "[x] " checkbox is item content, not marker: continuation
+            // and child indentation is relative to the "- " marker alone.
+            Marker(text = if (type.checked) "- [x] " else "- [ ] ", continuationWidth = 2)
+
+        is BlockType.NumberedList -> {
+            val text = "${type.number}. "
+            Marker(text = text, continuationWidth = text.length)
+        }
+
+        else -> Marker(text = "- ", continuationWidth = 2)
+    }
+
+    private class Marker(val text: String, val continuationWidth: Int)
+
+    private class ListNode(
+        val block: Block,
+        val depth: Int,
+        val children: MutableList<ListNode> = mutableListOf(),
+    )
+
+    private const val LIST_OUTLINE_GROUP_KEY: String = "listOutline"
+}
+
+internal val BlockType.isListOutlineType: Boolean
+    get() = this == BlockType.BulletList || this is BlockType.NumberedList || this is BlockType.Todo
diff --git a/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/markdown/DefaultMarkdownSpanEncoders.kt b/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/markdown/DefaultMarkdownSpanEncoders.kt
new file mode 100644
index 0000000..ff3b9fe
--- /dev/null
+++ b/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/markdown/DefaultMarkdownSpanEncoders.kt
@@ -0,0 +1,65 @@
+package io.github.linreal.cascade.editor.markdown
+
+import io.github.linreal.cascade.editor.core.SpanStyle
+
+/**
+ * Default span-emission resolution used by [MarkdownInlineRenderer]. Per span
+ * style, in precedence order:
+ *
+ * 1. `SpanStyle.Link` → native `[text](target)` inline form (angle destination
+ *    when needed), always — reference style is canonicalized away;
+ * 2. an explicit [MarkdownSpanEncoder] registration
+ *    ([MarkdownProfile.withMarkdownSpanEncoder] /
+ *    `withCustomMarkdownSpanEncoder`) → its [MarkdownMarkPair], emitted
+ *    without encode-side verification (consumer responsibility; the HTML
+ *    bridge encoders land here);
+ * 3. a built-in Bold/Italic/Strike mapping → canonical marker emission;
+ * 4. `SpanStyle.InlineCode` → backtick fences via
+ *    [Markdown.codeSpanDelimiters];
+ * 5. otherwise → the registered span fallback (text kept, marks dropped) plus
+ *    a [MarkdownEncodeWarning.UnsupportedSpan] warning.
+ *
+ * Decode grammar is fixed to CommonMark/GFM; custom span encoders remain
+ * available through explicit [MarkdownMarkPair] registrations.
+ */
+internal object DefaultMarkdownSpanEncoders {
+
+    /**
+     * Canonical CommonMark/GFM marker for a built-in style.
+     */
+    fun canonicalMarkerFor(@Suppress("UNUSED_PARAMETER") profile: MarkdownProfile, style: SpanStyle): String? =
+        when (style) {
+            SpanStyle.Bold -> "**"
+            SpanStyle.Italic -> "*"
+            SpanStyle.StrikeThrough -> "~~"
+            else -> null
+        }
+
+    /**
+     * An alternate marker for [style] using a different delimiter character
+     * (the `*` → `_` italic auto-switch), or null.
+     */
+    fun alternateMarkerFor(
+        @Suppress("UNUSED_PARAMETER") profile: MarkdownProfile,
+        style: SpanStyle,
+        excludeChar: Char,
+    ): String? = when (style) {
+        SpanStyle.Bold -> "__".takeIf { excludeChar != '_' }
+        SpanStyle.Italic -> "_".takeIf { excludeChar != '_' }
+        else -> null
+    }
+
+    /** The style a matched pair of [marker] decodes to, per the profile table. */
+    fun decodedStyleFor(@Suppress("UNUSED_PARAMETER") profile: MarkdownProfile, marker: String): SpanStyle? =
+        when (marker) {
+            "**", "__" -> SpanStyle.Bold
+            "*", "_" -> SpanStyle.Italic
+            "~~" -> SpanStyle.StrikeThrough
+            else -> null
+        }
+
+    /** Native inline-link mark pair: `[` … `](target)`. */
+    fun linkMarkPair(url: String): MarkdownMarkPair =
+        MarkdownMarkPair(open = "[", close = "](" + Markdown.escapeLinkDestination(url) + ")")
+
+}
diff --git a/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/markdown/ExperimentalCascadeMarkdownApi.kt b/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/markdown/ExperimentalCascadeMarkdownApi.kt
new file mode 100644
index 0000000..f6f9ed2
--- /dev/null
+++ b/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/markdown/ExperimentalCascadeMarkdownApi.kt
@@ -0,0 +1,21 @@
+package io.github.linreal.cascade.editor.markdown
+
+/**
+ * Marks CascadeEditor Markdown import/export APIs that are still stabilizing.
+ *
+ * The feature is usable, but public contracts in `markdown` may change before the
+ * Markdown codec is declared stable.
+ */
+@Retention(AnnotationRetention.BINARY)
+@Target(
+    AnnotationTarget.CLASS,
+    AnnotationTarget.FUNCTION,
+    AnnotationTarget.PROPERTY,
+    AnnotationTarget.TYPEALIAS,
+)
+@RequiresOptIn(
+    level = RequiresOptIn.Level.WARNING,
+    message = "CascadeEditor Markdown import/export API is experimental and may change before stabilization.",
+)
+@MustBeDocumented
+public annotation class ExperimentalCascadeMarkdownApi
diff --git a/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownAstDecoder.kt b/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownAstDecoder.kt
new file mode 100644
index 0000000..2d9c568
--- /dev/null
+++ b/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownAstDecoder.kt
@@ -0,0 +1,1474 @@
+package io.github.linreal.cascade.editor.markdown
+
+import io.github.linreal.cascade.editor.core.Block
+import io.github.linreal.cascade.editor.core.BlockAttributes
+import io.github.linreal.cascade.editor.core.BlockContent
+import io.github.linreal.cascade.editor.core.BlockId
+import io.github.linreal.cascade.editor.core.BlockType
+import io.github.linreal.cascade.editor.core.SpanStyle
+import io.github.linreal.cascade.editor.core.TextSpan
+import io.github.linreal.cascade.editor.core.UnknownBlockType
+import io.github.linreal.cascade.editor.htmlserialization.HtmlProfile
+import io.github.linreal.cascade.editor.htmlserialization.InlineFragment
+import io.github.linreal.cascade.editor.richtext.SpanAlgorithms
+import org.intellij.markdown.IElementType
+import org.intellij.markdown.MarkdownElementTypes
+import org.intellij.markdown.MarkdownTokenTypes
+import org.intellij.markdown.ast.ASTNode
+import org.intellij.markdown.flavours.gfm.GFMElementTypes
+import org.intellij.markdown.flavours.gfm.GFMFlavourDescriptor
+import org.intellij.markdown.flavours.gfm.GFMTokenTypes
+import org.intellij.markdown.flavours.gfm.StrikeThroughDelimiterParser
+import org.intellij.markdown.parser.CancellationToken
+import org.intellij.markdown.parser.MarkdownParser
+import org.intellij.markdown.parser.sequentialparsers.EmphasisLikeParser
+import org.intellij.markdown.parser.sequentialparsers.SequentialParser
+import org.intellij.markdown.parser.sequentialparsers.SequentialParserManager
+import org.intellij.markdown.parser.sequentialparsers.impl.AutolinkParser
+import org.intellij.markdown.parser.sequentialparsers.impl.BacktickParser
+import org.intellij.markdown.parser.sequentialparsers.impl.EmphStrongDelimiterParser
+import org.intellij.markdown.parser.sequentialparsers.impl.ImageParser
+import org.intellij.markdown.parser.sequentialparsers.impl.InlineLinkParser
+import org.intellij.markdown.parser.sequentialparsers.impl.ReferenceLinkParser
+
+/** Custom typeId carried by opaque preserved-Markdown blocks. */
+internal const val MARKDOWN_PRESERVED_TYPE_ID: String = "md.preserved"
+
+/** Custom typeId carried by opaque preserved block-level HTML. */
+internal const val MARKDOWN_PRESERVED_HTML_TYPE_ID: String = "md.preservedHtml"
+
+/** GFM block/inline grammar with upstream's overly broad dollar-math parser removed. */
+internal class CascadeMarkdownFlavour : GFMFlavourDescriptor() {
+    override val sequentialParserManager: SequentialParserManager = object : SequentialParserManager() {
+        override fun getParserSequence(): List<SequentialParser> = listOf(
+            AutolinkParser(listOf(MarkdownTokenTypes.AUTOLINK, GFMTokenTypes.GFM_AUTOLINK)),
+            BacktickParser(),
+            ImageParser(),
+            InlineLinkParser(),
+            ReferenceLinkParser(),
+            EmphasisLikeParser(EmphStrongDelimiterParser(), StrikeThroughDelimiterParser()),
+        )
+    }
+}
+
+/** One assertion-free, non-cancellable parser entry point for all decode/verification paths. */
+internal fun parseMarkdownTree(text: CharSequence): ASTNode =
+    MarkdownParser(
+        CascadeMarkdownFlavour(),
+        assertionsEnabled = false,
+        cancellationToken = CancellationToken.NonCancellable,
+    ).buildMarkdownTreeFromString(text)
+
+/**
+ * A parser-facing projection of the source.
+ *
+ * JetBrains Markdown splits physical lines only on `\n` and treats a BOM as
+ * ordinary text. Cascade accepts BOM, CRLF, and lone CR, so the parser sees a
+ * normalized projection while every AST boundary maps back to the original
+ * UTF-16 source. Preserved payloads always slice [originalText].
+ */
+internal class MarkdownParseInput private constructor(
+    private val originalText: String,
+    val text: String,
+    private val originalBoundary: IntArray,
+    val locator: MarkdownSourceLocator,
+) {
+    fun originalOffset(parseOffset: Int): Int =
+        originalBoundary[parseOffset.coerceIn(0, originalBoundary.lastIndex)]
+
+    fun sourceRange(start: Int, endExclusive: Int): MarkdownSourceRange {
+        val from = originalOffset(start)
+        val to = originalOffset(endExclusive).coerceAtLeast(from)
+        return MarkdownSourceRange(from, to)
+    }
+
+    fun sourceRange(node: ASTNode, trimTrailingNewline: Boolean = false): MarkdownSourceRange {
+        var end = node.endOffset
+        if (trimTrailingNewline) {
+            while (end > node.startOffset && text[end - 1] == '\n') end--
+        }
+        return sourceRange(node.startOffset, end)
+    }
+
+    fun slice(range: MarkdownSourceRange): String {
+        val start = range.start.coerceIn(0, originalText.length)
+        val end = range.endExclusive.coerceIn(start, originalText.length)
+        return originalText.substring(start, end)
+    }
+
+    companion object {
+        fun of(source: String): MarkdownParseInput {
+            val normalized = StringBuilder(source.length)
+            val boundaries = ArrayList<Int>(source.length + 1)
+            var index = if (source.startsWith('\uFEFF')) 1 else 0
+            val lineStarts = ArrayList<Int>(16)
+            var lineStart = index
+            var lastContentEnd = 0
+            boundaries += index
+            while (index < source.length) {
+                when (source[index]) {
+                    '\r' -> {
+                        lineStarts += lineStart
+                        lastContentEnd = index
+                        normalized.append('\n')
+                        index += if (index + 1 < source.length && source[index + 1] == '\n') 2 else 1
+                        lineStart = index
+                    }
+                    '\n' -> {
+                        lineStarts += lineStart
+                        lastContentEnd = index
+                        normalized.append('\n')
+                        index++
+                        lineStart = index
+                    }
+                    else -> {
+                        normalized.append(source[index])
+                        index++
+                    }
+                }
+                boundaries += index
+            }
+            if (lineStart < source.length) {
+                lineStarts += lineStart
+                lastContentEnd = source.length
+            }
+            return MarkdownParseInput(
+                originalText = source,
+                text = normalized.toString(),
+                originalBoundary = boundaries.toIntArray(),
+                locator = MarkdownSourceLocator(lineStarts.toIntArray(), lastContentEnd),
+            )
+        }
+    }
+}
+
+/** JetBrains AST -> Cascade editor model. JetBrains types never cross the public API. */
+internal class MarkdownAstDecoder(
+    private val input: MarkdownParseInput,
+    private val root: ASTNode,
+    private val profile: MarkdownProfile,
+    private val limits: MarkdownCodecLimits,
+    private val state: MarkdownParseState,
+) {
+    private val preserve: Boolean get() = profile.unsupportedSyntax == UnsupportedSyntax.Preserve
+    private val titledDefinitions = HashSet<String>()
+    private var escalationKind: String? = null
+    private var rootOwnerRange: MarkdownSourceRange = MarkdownSourceRange(0, 0)
+
+    fun decode(): List<Block> {
+        collectDefinitions(root)
+        if (state.isAborted) return emptyList()
+
+        val frontMatter = recognizeFrontMatter(input.text)
+        val out = ArrayList<Block>()
+        var previousEnd = 0
+        var frontMatterHandled = false
+        for (node in root.children) {
+            if (state.isAborted) break
+            if (isTrivia(node.type)) continue
+
+            if (frontMatter != null && node.startOffset < frontMatter.endExclusive) {
+                if (!frontMatterHandled) {
+                    frontMatterHandled = true
+                    if (preserve) {
+                        addPreserved(out, "frontMatter", input.sourceRange(0, frontMatter.endExclusive))
+                    } else {
+                        state.warn(
+                            MarkdownDecodeWarning.UnsupportedSyntax(
+                                construct = "frontMatter",
+                                detail = "recognized construct decodes through ordinary syntaxes with degraded content",
+                                range = input.sourceRange(0, frontMatter.endExclusive),
+                            ),
+                        )
+                    }
+                }
+                if (preserve) {
+                    previousEnd = maxOf(previousEnd, node.endOffset)
+                    continue
+                }
+            }
+
+            if (profile.newlineSemantics == NewlineSemantics.HardBreak) {
+                addHardBreakGap(out, previousEnd, node.startOffset, leading = previousEnd == 0)
+            }
+            val range = input.sourceRange(node, trimTrailingNewline = true)
+            rootOwnerRange = range
+            escalationKind = null
+            val buffer = ArrayList<Block>()
+            lowerNode(node, buffer, depth = 0, quote = false)
+            val escalation = escalationKind
+            if (!state.isAborted) {
+                if (escalation != null) addPreserved(out, escalation, range) else out += buffer
+            }
+            previousEnd = maxOf(previousEnd, node.endOffset)
+        }
+        if (!state.isAborted && profile.newlineSemantics == NewlineSemantics.HardBreak) {
+            addHardBreakGap(
+                out,
+                previousEnd,
+                input.text.length,
+                leading = previousEnd == 0 && out.isEmpty(),
+            )
+        }
+        return out
+    }
+
+    private fun lowerNode(node: ASTNode, out: MutableList<Block>, depth: Int, quote: Boolean) {
+        if (state.isAborted || escalationKind != null) return
+        if (depth > limits.maxBlockNesting) {
+            state.abort(
+                MarkdownDecodeWarning.LimitExceeded(
+                    MarkdownCodecLimitKind.BlockNesting,
+                    limits.maxBlockNesting,
+                    input.sourceRange(node, trimTrailingNewline = true),
+                ),
+            )
+            return
+        }
+        when (node.type) {
+            MarkdownElementTypes.PARAGRAPH -> lowerParagraph(node, out, quote)
+            MarkdownElementTypes.ATX_1 -> lowerHeading(node, 1, out, quote)
+            MarkdownElementTypes.ATX_2 -> lowerHeading(node, 2, out, quote)
+            MarkdownElementTypes.ATX_3 -> lowerHeading(node, 3, out, quote)
+            MarkdownElementTypes.ATX_4 -> lowerHeading(node, 4, out, quote)
+            MarkdownElementTypes.ATX_5 -> lowerHeading(node, 5, out, quote)
+            MarkdownElementTypes.ATX_6 -> lowerHeading(node, 6, out, quote)
+            MarkdownElementTypes.SETEXT_1 -> lowerSetext(node, 1, out, quote)
+            MarkdownElementTypes.SETEXT_2 -> lowerSetext(node, 2, out, quote)
+            MarkdownTokenTypes.HORIZONTAL_RULE -> addBlock(
+                out,
+                Block(BlockId.generate(), BlockType.Divider, BlockContent.Empty),
+                input.sourceRange(node),
+            )
+            MarkdownElementTypes.CODE_FENCE -> lowerFence(node, out, quote)
+            MarkdownElementTypes.CODE_BLOCK -> lowerIndentedCode(node, out, quote)
+            MarkdownElementTypes.BLOCK_QUOTE -> lowerQuote(node, out, depth)
+            MarkdownElementTypes.UNORDERED_LIST -> lowerList(node, out, depth, ordered = false)
+            MarkdownElementTypes.ORDERED_LIST -> lowerList(node, out, depth, ordered = true)
+            MarkdownElementTypes.HTML_BLOCK -> lowerHtmlBlock(node, out)
+            MarkdownElementTypes.LINK_DEFINITION -> lowerDefinition(node, out)
+            GFMElementTypes.TABLE -> lowerTable(node, out, quote)
+            else -> {
+                if (node.children.isNotEmpty()) {
+                    for (child in node.children) lowerNode(child, out, depth + 1, quote)
+                } else if (node.endOffset > node.startOffset) {
+                    lowerLiteralBlock(node, out, quote)
+                }
+            }
+        }
+    }
+
+    private fun lowerParagraph(node: ASTNode, out: MutableList<Block>, quote: Boolean) {
+        val raw = input.text.substring(node.startOffset, node.endOffset).trimEnd('\n')
+        val range = input.sourceRange(node, trimTrailingNewline = true)
+        recognizeFootnoteDefinition(raw)?.let {
+            unsupportedBlock(out, "footnoteDefinition", range)
+            return
+        }
+        if (recognizeMathBlock(raw)) {
+            unsupportedBlock(out, "mathBlock", range)
+            return
+        }
+        if (isStandaloneImage(node, raw)) {
+            unsupportedBlock(out, "blockImage", range)
+            return
+        }
+        val inline = MarkdownAstInlineDecoder(input, profile, limits, state, state.definitions, titledDefinitions)
+            .decode(node)
+        if (inline.escalationKind != null) {
+            requestEscalation(inline.escalationKind)
+            return
+        }
+        val hardBreakAtxLevel = if (profile.newlineSemantics == NewlineSemantics.HardBreak) {
+            hardBreakAtxLevel(raw)
+        } else null
+        if (hardBreakAtxLevel != null) {
+            val prefixLength = raw.indexOfFirst { it != ' ' && it != '\t' } + hardBreakAtxLevel + 1
+            addTextBlock(
+                out,
+                BlockType.Heading(hardBreakAtxLevel),
+                dropInlinePrefix(inline, prefixLength.coerceAtMost(inline.text.length)),
+                range,
+            )
+            return
+        }
+        val structuralLeadingWhitespace = node.children.firstOrNull()?.type == MarkdownTokenTypes.WHITE_SPACE
+        addTextBlock(
+            out,
+            if (quote) BlockType.Quote else BlockType.Paragraph,
+            if (structuralLeadingWhitespace) trimLeadingInline(inline) else inline,
+            range,
+        )
+    }
+
+    private fun lowerHeading(
+        node: ASTNode,
+        level: Int,
+        out: MutableList<Block>,
+        quote: Boolean,
+    ) {
+        if (quote) {
+            unsupportedQuoteChild(node, out, level)
+            return
+        }
+        val content = node.children.firstOrNull {
+            it.type == MarkdownTokenTypes.ATX_CONTENT || it.type == MarkdownTokenTypes.SETEXT_CONTENT
+        } ?: node
+        val inline = MarkdownAstInlineDecoder(input, profile, limits, state, state.definitions, titledDefinitions)
+            .decode(content)
+        if (inline.escalationKind != null) {
+            requestEscalation(inline.escalationKind)
+            return
+        }
+        addTextBlock(out, BlockType.Heading(level), trimLeadingInline(inline), input.sourceRange(node, true))
+    }
+
+    private fun lowerSetext(node: ASTNode, level: Int, out: MutableList<Block>, quote: Boolean) {
+        if (profile.newlineSemantics != NewlineSemantics.HardBreak) {
+            lowerHeading(node, level, out, quote)
+            return
+        }
+        val content = node.children.firstOrNull { it.type == MarkdownTokenTypes.SETEXT_CONTENT } ?: node
+        val inline = MarkdownAstInlineDecoder(input, profile, limits, state, state.definitions, titledDefinitions)
+            .decode(content)
+        if (inline.escalationKind != null) {
+            requestEscalation(inline.escalationKind)
+            return
+        }
+        val rawContent = input.text.substring(content.startOffset, content.endOffset).trimEnd('\n')
+        val atxLevel = hardBreakAtxLevel(rawContent)
+        if (atxLevel != null) {
+            val prefixLength = rawContent.indexOfFirst { it != ' ' && it != '\t' } + atxLevel + 1
+            addTextBlock(
+                out,
+                BlockType.Heading(atxLevel),
+                dropInlinePrefix(inline, prefixLength.coerceAtMost(inline.text.length)),
+                input.sourceRange(content, true),
+            )
+            if (level == 2) {
+                addBlock(
+                    out,
+                    Block(BlockId.generate(), BlockType.Divider, BlockContent.Empty),
+                    input.sourceRange(node, true),
+                )
+            }
+            return
+        }
+        if (level == 1) {
+            val underline = input.text.substring(content.endOffset, node.endOffset).trimEnd('\n')
+            val visible = trimLeadingInline(inline)
+            addTextBlock(
+                out,
+                if (quote) BlockType.Quote else BlockType.Paragraph,
+                MarkdownInlineParseResult(visible.text + underline, visible.spans, null),
+                input.sourceRange(node, true),
+            )
+        } else {
+            addTextBlock(
+                out,
+                if (quote) BlockType.Quote else BlockType.Paragraph,
+                trimLeadingInline(inline),
+                input.sourceRange(content),
+            )
+            addBlock(
+                out,
+                Block(BlockId.generate(), BlockType.Divider, BlockContent.Empty),
+                input.sourceRange(node, true),
+            )
+        }
+    }
+
+    private fun lowerFence(node: ASTNode, out: MutableList<Block>, quote: Boolean) {
+        if (quote) {
+            unsupportedQuoteChild(node, out, null)
+            return
+        }
+        val range = input.sourceRange(node, true)
+        val info = node.children.firstOrNull { it.type == MarkdownTokenTypes.FENCE_LANG }
+        if (info != null && info.endOffset > info.startOffset) {
+            if (preserve) {
+                requestEscalation("fencedCode")
+                return
+            }
+            state.warn(
+                MarkdownDecodeWarning.DroppedAttribute(
+                    "fencedCode",
+                    "infoString",
+                    "BlockType.Code has no language/info-string field",
+                    range,
+                ),
+            )
+        }
+        val contents = node.children.filter { it.type == MarkdownTokenTypes.CODE_FENCE_CONTENT }
+        var text = contents.joinToString("") { input.text.substring(it.startOffset, it.endOffset) }
+        // Content tokens exclude EOL leaves; use the structural range between
+        // the opener's EOL and closer to retain leading/trailing blank lines.
+        val opener = node.children.firstOrNull { it.type == MarkdownTokenTypes.CODE_FENCE_START }
+        val closer = node.children.lastOrNull { it.type == MarkdownTokenTypes.CODE_FENCE_END }
+        if (opener != null) {
+            val contentStart = input.text.indexOf('\n', opener.endOffset).let { if (it < 0) opener.endOffset else it + 1 }
+            val contentEnd = closer?.startOffset ?: node.endOffset
+            val lineStart = input.text.lastIndexOf('\n', opener.startOffset - 1).let { if (it < 0) 0 else it + 1 }
+            val openerIndent = (opener.startOffset - lineStart).coerceAtLeast(0)
+            text = input.text.substring(contentStart.coerceAtMost(contentEnd), contentEnd)
+                .split('\n')
+                .joinToString("\n") { line -> stripIndentColumns(line, openerIndent) }
+                .removeSuffix("\n")
+        }
+        addBlock(out, Block(BlockId.generate(), BlockType.Code, BlockContent.Text(text)), range)
+    }
+
+    private fun lowerIndentedCode(node: ASTNode, out: MutableList<Block>, quote: Boolean) {
+        if (quote) {
+            unsupportedQuoteChild(node, out, null)
+            return
+        }
+        val lines = input.text.substring(node.startOffset, node.endOffset).trimEnd('\n').split('\n')
+        val text = lines.joinToString("\n") { stripIndentColumns(it, 4) }
+        val type = if (profile.newlineSemantics == NewlineSemantics.HardBreak) BlockType.Paragraph else BlockType.Code
+        addBlock(out, Block(BlockId.generate(), type, BlockContent.Text(text)), input.sourceRange(node, true))
+    }
+
+    private fun lowerQuote(node: ASTNode, out: MutableList<Block>, depth: Int) {
+        val structural = node.children.filterNot { isTrivia(it.type) || it.type == MarkdownTokenTypes.BLOCK_QUOTE }
+        for (child in structural) {
+            when (child.type) {
+                MarkdownElementTypes.PARAGRAPH -> lowerParagraph(child, out, quote = true)
+                MarkdownElementTypes.BLOCK_QUOTE -> {
+                    if (preserve) requestEscalation("blockquote") else {
+                        state.warn(
+                            MarkdownDecodeWarning.DroppedAttribute(
+                                "blockquote",
+                                "nestingDepth",
+                                "nested blockquotes flatten to one level",
+                                input.sourceRange(child, true),
+                            ),
+                        )
+                        lowerQuote(child, out, depth + 1)
+                    }
+                }
+                else -> unsupportedQuoteChild(child, out, null)
+            }
+            if (state.isAborted || escalationKind != null) return
+        }
+    }
+
+    private fun unsupportedQuoteChild(node: ASTNode, out: MutableList<Block>, level: Int?) {
+        if (preserve) {
+            requestEscalation("blockquote")
+            return
+        }
+        state.warn(
+            MarkdownDecodeWarning.UnsupportedSyntax(
+                "blockquote",
+                "a flat Quote cannot contain this construct; it was lowered outside the quote",
+                input.sourceRange(node, true),
+            ),
+        )
+        if (level != null) lowerHeading(node, level, out, quote = false)
+        else lowerNode(node, out, depth = 1, quote = false)
+    }
+
+    private fun lowerList(node: ASTNode, out: MutableList<Block>, depth: Int, ordered: Boolean) {
+        val listDepth = depth.coerceAtMost(BlockAttributes.MAX_INDENTATION_LEVEL)
+        if (depth > BlockAttributes.MAX_INDENTATION_LEVEL) {
+            if (preserve) {
+                requestEscalation("list")
+                return
+            }
+            state.warn(
+                MarkdownDecodeWarning.DroppedAttribute(
+                    "list",
+                    "indentationLevel",
+                    "nesting depth $depth exceeds the module range and was clamped to $listDepth",
+                    input.sourceRange(node, true),
+                ),
+            )
+        }
+        val items = node.children.filter { it.type == MarkdownElementTypes.LIST_ITEM }
+        val firstMarker = items.firstOrNull()?.children?.firstOrNull {
+            it.type == MarkdownTokenTypes.LIST_NUMBER || it.type == MarkdownTokenTypes.LIST_BULLET
+        }
+        val startNumber = firstMarker?.let { markerNumber(it) }
+        if (ordered && startNumber != null && startNumber != 1) {
+            if (preserve) {
+                requestEscalation("orderedList")
+                return
+            }
+            state.warn(
+                MarkdownDecodeWarning.UnsupportedSyntax(
+                    "orderedList",
+                    "start value $startNumber is not representable; the list was renumbered from 1",
+                    input.sourceRange(node, true),
+                ),
+            )
+        }
+
+        var number = 1
+        for (item in items) {
+            val children = item.children.filterNot {
+                isTrivia(it.type) || it.type == MarkdownTokenTypes.LIST_BULLET ||
+                    it.type == MarkdownTokenTypes.LIST_NUMBER || it.type == GFMTokenTypes.CHECK_BOX
+            }
+            val firstParagraph = children.firstOrNull { it.type == MarkdownElementTypes.PARAGRAPH }
+            val checkbox = item.children.firstOrNull { it.type == GFMTokenTypes.CHECK_BOX }
+            val type = when {
+                checkbox != null -> {
+                    val raw = input.text.substring(checkbox.startOffset, checkbox.endOffset)
+                    BlockType.Todo(raw.length > 1 && raw[1] != ' ')
+                }
+                ordered -> BlockType.NumberedList(number)
+                else -> BlockType.BulletList
+            }
+            number++
+            val inline = if (firstParagraph != null) {
+                MarkdownAstInlineDecoder(input, profile, limits, state, state.definitions, titledDefinitions)
+                    .decode(firstParagraph)
+            } else MarkdownInlineParseResult("", emptyList(), null)
+            if (inline.escalationKind != null) {
+                requestEscalation(inline.escalationKind)
+                return
+            }
+            addBlock(
+                out,
+                Block(
+                    BlockId.generate(),
+                    type,
+                    BlockContent.Text(inline.text, inline.spans),
+                    BlockAttributes(indentationLevel = listDepth),
+                ),
+                input.sourceRange(item, true),
+                spansAlreadyCounted = true,
+            )
+
+            for (child in children) {
+                if (child === firstParagraph) continue
+                if (child.type == MarkdownElementTypes.UNORDERED_LIST || child.type == MarkdownElementTypes.ORDERED_LIST) {
+                    lowerList(child, out, depth + 1, child.type == MarkdownElementTypes.ORDERED_LIST)
+                } else {
+                    if (preserve) {
+                        requestEscalation("listItem")
+                        return
+                    }
+                    state.warn(
+                        MarkdownDecodeWarning.UnsupportedSyntax(
+                            "listItem",
+                            "multi-block list-item content cannot be expressed in the outline; it was lowered as a separate block",
+                            input.sourceRange(child, true),
+                        ),
+                    )
+                    lowerNode(child, out, depth + 1, quote = false)
+                }
+                if (state.isAborted || escalationKind != null) return
+            }
+        }
+    }
+
+    private fun lowerTable(node: ASTNode, out: MutableList<Block>, quote: Boolean) {
+        val range = input.sourceRange(node, true)
+        if (preserve) {
+            requestEscalation("pipeTable")
+            return
+        }
+        state.warn(
+            MarkdownDecodeWarning.UnsupportedSyntax(
+                "pipeTable",
+                "recognized construct decodes through ordinary syntaxes with degraded content",
+                range,
+            ),
+        )
+        val rows = node.children.filter { it.type == GFMElementTypes.HEADER || it.type == GFMElementTypes.ROW }
+        for (row in rows) {
+            val cells = row.children.filter { it.type == GFMTokenTypes.CELL }
+            val rendered = cells.map {
+                MarkdownAstInlineDecoder(input, profile, limits, state, state.definitions, titledDefinitions)
+                    .decode(it)
+            }
+            val text = rendered.joinToString(" | ") { it.text.trim() }
+            addBlock(
+                out,
+                Block(BlockId.generate(), if (quote) BlockType.Quote else BlockType.Paragraph, BlockContent.Text(text)),
+                input.sourceRange(row, true),
+            )
+        }
+    }
+
+    private fun lowerDefinition(node: ASTNode, out: MutableList<Block>) {
+        val title = node.children.firstOrNull { it.type == MarkdownElementTypes.LINK_TITLE }
+        if (title != null && preserve) {
+            addPreserved(out, "linkReferenceDefinition", input.sourceRange(node, true))
+        }
+    }
+
+    private fun lowerHtmlBlock(node: ASTNode, out: MutableList<Block>) {
+        val range = input.sourceRange(node, true)
+        val raw = input.slice(range)
+        val firstLine = raw.substringBefore('\n').substringBefore('\r')
+        if (!MarkdownHtmlBridge.looksLikeHtmlBlockStart(firstLine)) {
+            addBlock(out, Block.paragraph(raw), range)
+            return
+        }
+        when (val policy = profile.htmlInMarkdown) {
+            is HtmlInMarkdown.Bridge -> {
+                val result = MarkdownHtmlBridge.bridgeBlock(raw, policy.htmlProfile, ::reparseHtmlLeaf)
+                if (result.blocks.isEmpty()) {
+                    if (preserve) addPreservedHtml(out, range, raw)
+                    else state.warn(MarkdownDecodeWarning.UnsupportedSyntax("html", "the HTML produced no editable content and was dropped", range))
+                    return
+                }
+                val destructive = result.warnings.filter { MarkdownHtmlBridge.isDestructiveHtmlWarning(it) }
+                if (destructive.isEmpty()) state.warn(MarkdownDecodeWarning.HtmlBridged(range))
+                else destructive.forEach { warning ->
+                    state.warn(
+                        MarkdownDecodeWarning.HtmlStripped(
+                            MarkdownHtmlBridge.htmlWarningTag(warning),
+                            rebase(range, warning.charOffset),
+                        ),
+                    )
+                }
+                result.blocks.forEach { addBlock(out, it.copy(id = BlockId.generate()), range) }
+            }
+            HtmlInMarkdown.Preserve -> addPreservedHtml(out, range, raw)
+            HtmlInMarkdown.WarnAndStrip, HtmlInMarkdown.Strip -> {
+                val result = MarkdownHtmlBridge.bridgeBlock(raw, HtmlProfile.Default, ::reparseHtmlLeaf)
+                state.warn(MarkdownDecodeWarning.HtmlStripped(null, range))
+                result.blocks.forEach { block ->
+                    val content = block.content
+                    val stripped = if (content is BlockContent.Text) block.copy(
+                        id = BlockId.generate(),
+                        content = BlockContent.Text(content.text),
+                    ) else block.copy(id = BlockId.generate())
+                    addBlock(out, stripped, range)
+                }
+            }
+        }
+    }
+
+    private fun lowerLiteralBlock(node: ASTNode, out: MutableList<Block>, quote: Boolean) {
+        val raw = input.text.substring(node.startOffset, node.endOffset).trimEnd('\n')
+        addBlock(
+            out,
+            Block(BlockId.generate(), if (quote) BlockType.Quote else BlockType.Paragraph, BlockContent.Text(raw)),
+            input.sourceRange(node, true),
+        )
+    }
+
+    private fun addTextBlock(
+        out: MutableList<Block>,
+        type: BlockType,
+        inline: MarkdownInlineParseResult,
+        range: MarkdownSourceRange,
+    ) {
+        addBlock(
+            out,
+            Block(BlockId.generate(), type, BlockContent.Text(inline.text, if (type.supportsSpans) inline.spans else emptyList())),
+            range,
+            spansAlreadyCounted = true,
+        )
+    }
+
+    private fun addBlock(
+        out: MutableList<Block>,
+        block: Block,
+        range: MarkdownSourceRange,
+        spansAlreadyCounted: Boolean = false,
+    ) {
+        if (!state.noteBlock(range)) return
+        if (!spansAlreadyCounted) {
+            val count = (block.content as? BlockContent.Text)?.spans?.size ?: 0
+            if (!state.noteSpans(count, range)) return
+        }
+        out += block
+    }
+
+    private fun unsupportedBlock(out: MutableList<Block>, kind: String, range: MarkdownSourceRange) {
+        if (preserve) addPreserved(out, kind, range)
+        else state.warn(
+            MarkdownDecodeWarning.UnsupportedSyntax(
+                kind,
+                "recognized construct decodes through ordinary syntaxes with degraded content",
+                range,
+            ),
+        )
+    }
+
+    private fun addPreserved(out: MutableList<Block>, kind: String, range: MarkdownSourceRange) {
+        state.warn(MarkdownDecodeWarning.PreservedSyntax(kind, range))
+        addBlock(
+            out,
+            Block(
+                BlockId.generate(),
+                UnknownBlockType(MARKDOWN_PRESERVED_TYPE_ID, rawTypeJsonForAst(MARKDOWN_PRESERVED_TYPE_ID)),
+                BlockContent.Custom(
+                    MARKDOWN_PRESERVED_TYPE_ID,
+                    mapOf("kind" to kind, "rawMarkdown" to input.slice(range)),
+                ),
+            ),
+            range,
+        )
+    }
+
+    private fun addPreservedHtml(out: MutableList<Block>, range: MarkdownSourceRange, raw: String) {
+        state.warn(MarkdownDecodeWarning.PreservedSyntax("html", range))
+        addBlock(
+            out,
+            Block(
+                BlockId.generate(),
+                UnknownBlockType(MARKDOWN_PRESERVED_HTML_TYPE_ID, rawTypeJsonForAst(MARKDOWN_PRESERVED_HTML_TYPE_ID)),
+                BlockContent.Custom(
+                    MARKDOWN_PRESERVED_HTML_TYPE_ID,
+                    mapOf("kind" to "html", "rawMarkdown" to raw),
+                ),
+            ),
+            range,
+        )
+    }
+
+    private fun requestEscalation(kind: String) {
+        if (escalationKind == null) escalationKind = kind
+    }
+
+    private fun collectDefinitions(root: ASTNode) {
+        data class Pending(val node: ASTNode, val depth: Int)
+
+        val pending = ArrayList<Pending>()
+        pending += Pending(root, 0)
+        while (pending.isNotEmpty() && !state.isAborted) {
+            val (node, depth) = pending.removeAt(pending.lastIndex)
+            if (depth > limits.maxBlockNesting) {
+                state.abort(
+                    MarkdownDecodeWarning.LimitExceeded(
+                        MarkdownCodecLimitKind.BlockNesting,
+                        limits.maxBlockNesting,
+                        input.sourceRange(node, trimTrailingNewline = true),
+                    ),
+                )
+                return
+            }
+            if (node.type == MarkdownElementTypes.LINK_DEFINITION) {
+                collectDefinition(node)
+            } else {
+                for (index in node.children.lastIndex downTo 0) {
+                    val child = node.children[index]
+                    pending += Pending(child, depth + blockNestingIncrement(child.type))
+                }
+            }
+        }
+    }
+
+    private fun collectDefinition(node: ASTNode) {
+        val labelNode = node.children.firstOrNull { it.type == MarkdownElementTypes.LINK_LABEL } ?: return
+        val destinationNode = node.children.firstOrNull { it.type == MarkdownElementTypes.LINK_DESTINATION } ?: return
+        val titleNode = node.children.firstOrNull { it.type == MarkdownElementTypes.LINK_TITLE }
+        val label = stripBrackets(input.text.substring(labelNode.startOffset, labelNode.endOffset))
+        val destination = decodeDestination(input.text.substring(destinationNode.startOffset, destinationNode.endOffset))
+        val title = titleNode?.let { stripTitle(input.text.substring(it.startOffset, it.endOffset)) }
+        state.registerDefinition(label, MarkdownLinkReferenceDefinition(destination, title), input.sourceRange(node, true))
+        if (title != null) {
+            titledDefinitions += MarkdownDefinitionTable.normalizeLabel(label)
+            if (!preserve) {
+                state.warn(
+                    MarkdownDecodeWarning.DroppedAttribute(
+                        "linkReferenceDefinition",
+                        "title",
+                        "link titles have no editor representation",
+                        input.sourceRange(node, true),
+                    ),
+                )
+            }
+        }
+    }
+
+    private fun reparseHtmlLeaf(text: String): InlineFragment {
+        val nestedInput = MarkdownParseInput.of(text)
+        val nestedRoot = parseMarkdownTree(nestedInput.text)
+        val container = nestedRoot.children.firstOrNull { it.type == MarkdownElementTypes.PARAGRAPH } ?: nestedRoot
+        val nestedState = MarkdownParseState(limits)
+        val parsed = MarkdownAstInlineDecoder(
+            nestedInput,
+            profile,
+            limits,
+            nestedState,
+            MarkdownDefinitionTable(),
+            emptySet(),
+        ).decode(container)
+        return InlineFragment(parsed.text, parsed.spans)
+    }
+
+    private fun addHardBreakGap(out: MutableList<Block>, start: Int, end: Int, leading: Boolean) {
+        if (end <= start) return
+        val newlines = input.text.substring(start, end).count { it == '\n' }
+        val blankLines = if (leading) newlines else (newlines - 1).coerceAtLeast(0)
+        repeat(blankLines) {
+            addBlock(
+                out,
+                Block.paragraph(),
+                input.sourceRange(start, end),
+            )
+        }
+    }
+
+    private fun rebase(range: MarkdownSourceRange, relative: Int): MarkdownSourceRange {
+        val start = (range.start + relative).coerceIn(range.start, range.endExclusive)
+        return MarkdownSourceRange(start, (start + 1).coerceAtMost(range.endExclusive))
+    }
+
+    private fun markerNumber(marker: ASTNode): Int? =
+        input.text.substring(marker.startOffset, marker.endOffset)
+            .trimStart(' ', '\t')
+            .takeWhile { it.isDigit() }
+            .toIntOrNull()
+
+    private fun trimLeadingInline(inline: MarkdownInlineParseResult): MarkdownInlineParseResult {
+        var count = 0
+        while (count < inline.text.length && (inline.text[count] == ' ' || inline.text[count] == '\t')) count++
+        if (count == 0) return inline
+        val shifted = inline.spans.mapNotNull { span ->
+            val start = (span.start - count).coerceAtLeast(0)
+            val end = span.end - count
+            if (end > start) TextSpan(start, end, span.style) else null
+        }
+        return MarkdownInlineParseResult(inline.text.substring(count), shifted, inline.escalationKind)
+    }
+
+    private fun dropInlinePrefix(inline: MarkdownInlineParseResult, count: Int): MarkdownInlineParseResult {
+        if (count <= 0) return inline
+        val shifted = inline.spans.mapNotNull { span ->
+            val start = (span.start - count).coerceAtLeast(0)
+            val end = span.end - count
+            if (end > start) TextSpan(start, end, span.style) else null
+        }
+        return MarkdownInlineParseResult(inline.text.drop(count), shifted, inline.escalationKind)
+    }
+}
+
+/** Inline AST lowering shared by decode and encode-side ambiguity verification. */
+internal class MarkdownAstInlineDecoder(
+    private val input: MarkdownParseInput,
+    private val profile: MarkdownProfile,
+    private val limits: MarkdownCodecLimits,
+    private val state: MarkdownParseState,
+    private val definitions: MarkdownDefinitionTable,
+    private val titledDefinitions: Set<String>,
+) {
+    private val text = StringBuilder()
+    private val spans = ArrayList<TextSpan>()
+    private var escalation: String? = null
+    private var hardBreakPendingEol = false
+    private var lastEmissionWasCodeSpan = false
+
+    fun decode(node: ASTNode): MarkdownInlineParseResult {
+        preflightInlineMath(node)
+        if (escalation != null) return MarkdownInlineParseResult("", emptyList(), escalation)
+        renderChildren(node.children.ifEmpty { listOf(node) })
+        if (!lastEmissionWasCodeSpan) trimTrailingBlanks()
+        if (escalation != null) return MarkdownInlineParseResult("", emptyList(), escalation)
+        val normalized = SpanAlgorithms.normalize(spans, text.length)
+        val range = input.sourceRange(node.startOffset, node.endOffset)
+        if (normalized.size > limits.maxSpansPerBlock) {
+            state.abort(MarkdownDecodeWarning.LimitExceeded(MarkdownCodecLimitKind.SpansPerBlock, limits.maxSpansPerBlock, range))
+            return MarkdownInlineParseResult("", emptyList(), null)
+        }
+        if (!state.noteSpans(normalized.size, range)) return MarkdownInlineParseResult("", emptyList(), null)
+        return MarkdownInlineParseResult(text.toString(), normalized, null)
+    }
+
+    private fun preflightInlineMath(node: ASTNode) {
+        val excluded = ArrayList<IntRange>()
+        val pending = ArrayList<ASTNode>()
+        pending += node
+        while (pending.isNotEmpty()) {
+            val current = pending.removeAt(pending.lastIndex)
+            if (current.type == MarkdownElementTypes.CODE_SPAN || current.type == MarkdownElementTypes.IMAGE) {
+                excluded += current.startOffset until current.endOffset
+            } else {
+                pending.addAll(current.children)
+            }
+        }
+        excluded.sortBy { it.first }
+        var excludedIndex = 0
+        var offset = node.startOffset
+        while (offset < node.endOffset) {
+            while (excludedIndex < excluded.size && excluded[excludedIndex].last < offset) excludedIndex++
+            val excludedRange = excluded.getOrNull(excludedIndex)
+            if (excludedRange != null && offset in excludedRange) {
+                offset = excludedRange.last + 1
+                continue
+            }
+            if (input.text[offset] != '$') {
+                offset++
+                continue
+            }
+            val end = recognizeInlineMathEnd(input.text, offset)
+            if (end <= offset || end > node.endOffset) {
+                offset++
+                continue
+            }
+            val range = input.sourceRange(offset, end)
+            if (profile.unsupportedSyntax == UnsupportedSyntax.Preserve) {
+                escalation = "inlineMath"
+                return
+            }
+            state.warn(
+                MarkdownDecodeWarning.UnsupportedSyntax(
+                    "inlineMath",
+                    "inline math has no editor representation; the expression was kept as literal text",
+                    range,
+                ),
+            )
+            offset = end
+        }
+    }
+
+    private fun renderChildren(children: List<ASTNode>) {
+        var index = 0
+        while (index < children.size && escalation == null && !state.isAborted) {
+            val child = children[index]
+            if (
+                child.type == MarkdownTokenTypes.LT &&
+                children.getOrNull(index + 1)?.type == MarkdownTokenTypes.EMAIL_AUTOLINK &&
+                children.getOrNull(index + 2)?.type == MarkdownTokenTypes.GT
+            ) {
+                renderEmailToken(children[index + 1])
+                index += 3
+                continue
+            }
+            if (child.type == MarkdownTokenTypes.HTML_TAG && input.text.startsWith("<", child.startOffset)) {
+                val island = MarkdownHtmlBridge.matchInlinePairedTag(input.text, child.startOffset)
+                if (island != null) {
+                    renderHtmlIsland(child.startOffset, island)
+                    index++
+                    while (index < children.size && children[index].startOffset < island.endExclusive) index++
+                    continue
+                }
+            }
+            render(child)
+            index++
+        }
+    }
+
+    private fun render(node: ASTNode) {
+        when (node.type) {
+            MarkdownElementTypes.EMPH -> styled(node, SpanStyle.Italic, MarkdownTokenTypes.EMPH)
+            MarkdownElementTypes.STRONG -> styled(node, SpanStyle.Bold, MarkdownTokenTypes.EMPH)
+            GFMElementTypes.STRIKETHROUGH -> styled(node, SpanStyle.StrikeThrough, GFMTokenTypes.TILDE)
+            MarkdownElementTypes.CODE_SPAN -> renderCodeSpan(node)
+            MarkdownElementTypes.INLINE_LINK -> renderInlineLink(node)
+            MarkdownElementTypes.FULL_REFERENCE_LINK,
+            MarkdownElementTypes.SHORT_REFERENCE_LINK,
+            -> renderReferenceLink(node)
+            MarkdownElementTypes.IMAGE -> renderImage(node)
+            MarkdownElementTypes.AUTOLINK -> renderAutolink(node)
+            GFMElementTypes.INLINE_MATH,
+            GFMElementTypes.BLOCK_MATH,
+            -> unsupportedInline("inlineMath", node)
+            MarkdownTokenTypes.HARD_LINE_BREAK -> {
+                trimTrailingBlanks()
+                text.append('\n')
+                lastEmissionWasCodeSpan = false
+                hardBreakPendingEol = true
+            }
+            MarkdownTokenTypes.EOL -> {
+                if (hardBreakPendingEol) hardBreakPendingEol = false
+                else {
+                    trimTrailingBlanks()
+                    text.append(
+                        if (profile.newlineSemantics == NewlineSemantics.HardBreak || profile.softBreak == SoftBreak.LineBreak) '\n' else ' ',
+                    )
+                    lastEmissionWasCodeSpan = false
+                }
+            }
+            MarkdownTokenTypes.TEXT,
+            MarkdownTokenTypes.WHITE_SPACE,
+            MarkdownTokenTypes.ATX_CONTENT,
+            MarkdownTokenTypes.SETEXT_CONTENT,
+            GFMTokenTypes.CELL,
+            -> if (node.children.isEmpty()) appendPlain(node) else renderChildren(node.children)
+            MarkdownTokenTypes.EMAIL_AUTOLINK -> renderEmailToken(node)
+            GFMTokenTypes.GFM_AUTOLINK -> appendRaw(node)
+            MarkdownTokenTypes.HTML_TAG -> appendRaw(node)
+            else -> if (node.children.isEmpty()) appendRaw(node) else renderChildren(node.children)
+        }
+    }
+
+    private fun styled(node: ASTNode, style: SpanStyle, markerType: IElementType) {
+        val start = text.length
+        renderChildren(node.children.filterNot { it.type == markerType })
+        if (text.length > start) spans += TextSpan(start, text.length, style)
+    }
+
+    private fun renderCodeSpan(node: ASTNode) {
+        val ticks = node.children.filter { it.type == MarkdownTokenTypes.BACKTICK }
+        if (ticks.size < 2) {
+            appendRaw(node)
+            return
+        }
+        var content = input.text.substring(ticks.first().endOffset, ticks.last().startOffset).replace('\n', ' ')
+        if (content.length >= 2 && content.first() == ' ' && content.last() == ' ' && content.any { it != ' ' }) {
+            content = content.substring(1, content.length - 1)
+        }
+        val start = text.length
+        text.append(content)
+        lastEmissionWasCodeSpan = true
+        if (text.length > start) spans += TextSpan(start, text.length, SpanStyle.InlineCode)
+    }
+
+    private fun renderInlineLink(node: ASTNode) {
+        val label = node.children.firstOrNull { it.type == MarkdownElementTypes.LINK_TEXT }
+        if (label != null && renderNestedInlineLinkCompatibility(node, label)) return
+        // JetBrains Markdown 0.7.7 represents an angle-form destination as an
+        // AUTOLINK child, while a bare destination is LINK_DESTINATION.
+        val destinationNode = node.children.firstOrNull {
+            it.type == MarkdownElementTypes.LINK_DESTINATION || it.type == MarkdownElementTypes.AUTOLINK
+        }
+        if (label == null || destinationNode == null) {
+            appendRaw(node)
+            return
+        }
+        val title = node.children.firstOrNull { it.type == MarkdownElementTypes.LINK_TITLE }
+        if (title != null) {
+            if (profile.unsupportedSyntax == UnsupportedSyntax.Preserve) {
+                escalation = "linkTitle"
+                return
+            }
+            state.warn(
+                MarkdownDecodeWarning.DroppedAttribute(
+                    "link",
+                    "title",
+                    "link titles have no editor representation",
+                    input.sourceRange(title.startOffset, title.endOffset),
+                ),
+            )
+        }
+        val destination = decodeDestination(input.text.substring(destinationNode.startOffset, destinationNode.endOffset))
+        if (destination.isBlank()) {
+            appendRaw(node)
+            return
+        }
+        val start = text.length
+        renderLinkLabel(label)
+        if (text.length > start) spans += TextSpan(start, text.length, SpanStyle.Link(destination))
+    }
+
+    /**
+     * CommonMark forbids links inside links. JetBrains 0.7.7 instead wraps
+     * `[a [b](u2)](u1)` in the outer link and tokenizes the inner link as a
+     * short reference plus literal destination. Recover the CommonMark result
+     * from that distinctive AST shape without maintaining a general parser.
+     */
+    private fun renderNestedInlineLinkCompatibility(node: ASTNode, label: ASTNode): Boolean {
+        val children = label.children
+        val nestedIndex = children.indexOfFirst { it.type == MarkdownElementTypes.SHORT_REFERENCE_LINK }
+        if (nestedIndex < 0 || children.getOrNull(nestedIndex + 1)?.type != MarkdownTokenTypes.LPAREN) return false
+        val closeIndex = (nestedIndex + 2 until children.size).firstOrNull {
+            children[it].type == MarkdownTokenTypes.RPAREN
+        } ?: return false
+        val nested = children[nestedIndex]
+        val destinationStart = children[nestedIndex + 1].endOffset
+        val destinationEnd = children[closeIndex].startOffset
+        if (destinationEnd <= destinationStart) return false
+        val destination = decodeDestination(input.text.substring(destinationStart, destinationEnd).trim())
+        if (destination.isBlank()) return false
+
+        text.append('[')
+        renderChildren(children.subList(1, nestedIndex))
+        val start = text.length
+        val nestedLabel = nested.children.firstOrNull { it.type == MarkdownElementTypes.LINK_LABEL } ?: nested
+        renderLinkLabel(nestedLabel)
+        if (text.length > start) spans += TextSpan(start, text.length, SpanStyle.Link(destination))
+        renderChildren(children.subList(closeIndex + 1, (children.size - 1).coerceAtLeast(closeIndex + 1)))
+        val outerClose = children.lastOrNull { it.type == MarkdownTokenTypes.RBRACKET }?.startOffset ?: label.endOffset
+        text.append(input.text, outerClose, node.endOffset)
+        lastEmissionWasCodeSpan = false
+        return true
+    }
+
+    private fun renderReferenceLink(node: ASTNode) {
+        val raw = input.text.substring(node.startOffset, node.endOffset)
+        if (isFootnoteReference(raw)) {
+            unsupportedInline("footnoteRef", node)
+            return
+        }
+        val labelNode = node.children.lastOrNull { it.type == MarkdownElementTypes.LINK_LABEL }
+            ?: node.children.firstOrNull { it.type == MarkdownElementTypes.LINK_TEXT }
+        val rawLabel = labelNode?.let { stripBrackets(input.text.substring(it.startOffset, it.endOffset)) }
+            ?: raw.substringAfter('[').substringBefore(']')
+        val definition = definitions.lookup(rawLabel)
+        if (definition == null) {
+            appendRaw(node)
+            return
+        }
+        if (MarkdownDefinitionTable.normalizeLabel(rawLabel) in titledDefinitions) {
+            if (profile.unsupportedSyntax == UnsupportedSyntax.Preserve) {
+                escalation = "linkReferenceTitle"
+                return
+            }
+        }
+        val linkText = node.children.firstOrNull { it.type == MarkdownElementTypes.LINK_TEXT }
+            ?: node.children.firstOrNull { it.type == MarkdownElementTypes.LINK_LABEL }
+        val start = text.length
+        if (linkText != null) renderLinkLabel(linkText) else text.append(rawLabel)
+        if (definition.destination.isNotBlank() && text.length > start) {
+            spans += TextSpan(start, text.length, SpanStyle.Link(definition.destination))
+        }
+    }
+
+    private fun renderLinkLabel(node: ASTNode) {
+        val filtered = node.children.filterNot {
+            it.type == MarkdownTokenTypes.LBRACKET || it.type == MarkdownTokenTypes.RBRACKET
+        }
+        if (filtered.isEmpty()) {
+            text.append(stripBrackets(input.text.substring(node.startOffset, node.endOffset)))
+        } else renderChildren(filtered)
+    }
+
+    private fun renderImage(node: ASTNode) {
+        if (profile.unsupportedSyntax == UnsupportedSyntax.Preserve) {
+            escalation = "inlineImage"
+            return
+        }
+        state.warn(
+            MarkdownDecodeWarning.UnsupportedSyntax(
+                "inlineImage",
+                "images have no editor representation; the alt text was retained",
+                input.sourceRange(node.startOffset, node.endOffset),
+            ),
+        )
+        val link = node.children.firstOrNull {
+            it.type == MarkdownElementTypes.INLINE_LINK || it.type == MarkdownElementTypes.FULL_REFERENCE_LINK ||
+                it.type == MarkdownElementTypes.SHORT_REFERENCE_LINK
+        }
+        val label = link?.children?.firstOrNull {
+            it.type == MarkdownElementTypes.LINK_TEXT || it.type == MarkdownElementTypes.LINK_LABEL
+        }
+        if (label != null) renderLinkLabel(label)
+    }
+
+    private fun renderAutolink(node: ASTNode) {
+        val token = node.children.firstOrNull {
+            it.type == MarkdownTokenTypes.AUTOLINK || it.type == MarkdownTokenTypes.EMAIL_AUTOLINK
+        }
+        if (token == null) {
+            appendRaw(node)
+            return
+        }
+        if (token.type == MarkdownTokenTypes.EMAIL_AUTOLINK) renderEmailToken(token)
+        else {
+            val value = input.text.substring(token.startOffset, token.endOffset)
+            appendLinkText(value, value)
+        }
+    }
+
+    private fun renderEmailToken(node: ASTNode) {
+        val value = input.text.substring(node.startOffset, node.endOffset)
+        appendLinkText(value, "mailto:$value")
+    }
+
+    private fun appendLinkText(value: String, target: String) {
+        val start = text.length
+        text.append(value)
+        lastEmissionWasCodeSpan = false
+        if (value.isNotEmpty()) spans += TextSpan(start, text.length, SpanStyle.Link(target))
+    }
+
+    private fun unsupportedInline(kind: String, node: ASTNode) {
+        if (profile.unsupportedSyntax == UnsupportedSyntax.Preserve) {
+            escalation = kind
+            return
+        }
+        state.warn(
+            MarkdownDecodeWarning.UnsupportedSyntax(
+                kind,
+                "$kind has no editor representation; source text was retained",
+                input.sourceRange(node.startOffset, node.endOffset),
+            ),
+        )
+        appendRaw(node)
+    }
+
+    private fun renderHtmlIsland(startOffset: Int, island: MarkdownHtmlBridge.InlineIsland) {
+        val range = input.sourceRange(startOffset, island.endExclusive)
+        val raw = input.text.substring(startOffset, island.endExclusive)
+        val inner = input.text.substring(island.innerStart, island.innerEnd)
+        when (val policy = profile.htmlInMarkdown) {
+            is HtmlInMarkdown.Bridge -> {
+                val result = MarkdownHtmlBridge.bridgeInline(raw, policy.htmlProfile) { leaf ->
+                    val nestedInput = MarkdownParseInput.of(leaf)
+                    val nestedRoot = parseMarkdownTree(nestedInput.text)
+                    val container = nestedRoot.children.firstOrNull { it.type == MarkdownElementTypes.PARAGRAPH } ?: nestedRoot
+                    val parsed = MarkdownAstInlineDecoder(
+                        nestedInput,
+                        profile,
+                        limits,
+                        MarkdownParseState(limits),
+                        MarkdownDefinitionTable(),
+                        emptySet(),
+                    ).decode(container)
+                    InlineFragment(parsed.text, parsed.spans)
+                }
+                val fragment = result.fragment
+                if (fragment.text.isEmpty() && fragment.spans.isEmpty()) {
+                    if (profile.unsupportedSyntax == UnsupportedSyntax.Preserve) escalation = "htmlInline"
+                    else state.warn(MarkdownDecodeWarning.HtmlStripped(island.tagName, range))
+                    return
+                }
+                val destructive = result.warnings.filter { MarkdownHtmlBridge.isDestructiveHtmlWarning(it) }
+                if (destructive.isEmpty()) state.warn(MarkdownDecodeWarning.HtmlBridged(range))
+                else destructive.forEach { warning ->
+                    val at = input.originalOffset((startOffset + warning.charOffset).coerceAtMost(island.endExclusive))
+                    state.warn(
+                        MarkdownDecodeWarning.HtmlStripped(
+                            MarkdownHtmlBridge.htmlWarningTag(warning),
+                            MarkdownSourceRange(at, (at + 1).coerceAtMost(range.endExclusive)),
+                        ),
+                    )
+                }
+                val base = text.length
+                text.append(fragment.text)
+                lastEmissionWasCodeSpan = false
+                fragment.spans.forEach { spans += TextSpan(it.start + base, it.end + base, it.style) }
+            }
+            HtmlInMarkdown.Preserve -> escalation = "htmlInline"
+            HtmlInMarkdown.WarnAndStrip, HtmlInMarkdown.Strip -> {
+                state.warn(MarkdownDecodeWarning.HtmlStripped(island.tagName, range))
+                val nestedInput = MarkdownParseInput.of(inner)
+                val nestedRoot = parseMarkdownTree(nestedInput.text)
+                val container = nestedRoot.children.firstOrNull { it.type == MarkdownElementTypes.PARAGRAPH } ?: nestedRoot
+                val parsed = MarkdownAstInlineDecoder(
+                    nestedInput,
+                    profile,
+                    limits,
+                    MarkdownParseState(limits),
+                    MarkdownDefinitionTable(),
+                    emptySet(),
+                ).decode(container)
+                val base = text.length
+                text.append(parsed.text)
+                lastEmissionWasCodeSpan = false
+                parsed.spans.forEach { spans += TextSpan(it.start + base, it.end + base, it.style) }
+            }
+        }
+    }
+
+    private fun appendPlain(node: ASTNode) {
+        val raw = input.text.substring(node.startOffset, node.endOffset)
+        var index = 0
+        while (index < raw.length) {
+            val char = raw[index]
+            if (char == '\\' && index + 1 < raw.length && raw[index + 1].isMarkdownPunctuationAst()) {
+                text.append(raw[index + 1])
+                lastEmissionWasCodeSpan = false
+                index += 2
+                continue
+            }
+            if (char == '&' && profile.entityDecode != EntityDecode.None) {
+                val entity = MarkdownEntities.matchAt(raw, index)
+                if (entity != null) {
+                    if (entity.replacement != null) text.append(entity.replacement)
+                    else {
+                        text.append(raw, index, index + entity.length)
+                        entity.name?.let {
+                            state.warn(
+                                MarkdownDecodeWarning.UnsupportedEntity(
+                                    it,
+                                    input.sourceRange(node.startOffset + index, node.startOffset + index + entity.length),
+                                ),
+                            )
+                        }
+                    }
+                    index += entity.length
+                    lastEmissionWasCodeSpan = false
+                    continue
+                }
+            }
+            text.append(char)
+            lastEmissionWasCodeSpan = false
+            index++
+        }
+    }
+
+    private fun appendRaw(node: ASTNode) {
+        text.append(input.text, node.startOffset, node.endOffset)
+        lastEmissionWasCodeSpan = false
+    }
+
+    private fun trimTrailingBlanks() {
+        while (text.isNotEmpty() && (text.last() == ' ' || text.last() == '\t')) text.setLength(text.length - 1)
+    }
+}
+
+private data class RecognizedRange(val endExclusive: Int)
+
+private fun recognizeFrontMatter(text: String): RecognizedRange? {
+    val firstEnd = text.indexOf('\n').let { if (it < 0) text.length else it }
+    if (text.substring(0, firstEnd).trimEnd(' ', '\t') != "---") return null
+    var start = if (firstEnd < text.length) firstEnd + 1 else text.length
+    while (start < text.length) {
+        val end = text.indexOf('\n', start).let { if (it < 0) text.length else it }
+        val line = text.substring(start, end).trimEnd(' ', '\t')
+        if (line.isEmpty()) return null
+        if (line == "---" || line == "...") return RecognizedRange(end)
+        start = if (end < text.length) end + 1 else text.length
+    }
+    return null
+}
+
+private fun recognizeMathBlock(raw: String): Boolean {
+    val lines = raw.split('\n')
+    val first = lines.firstOrNull()?.trim(' ', '\t') ?: return false
+    if (!first.startsWith("$$")) return false
+    if (first.length >= 4 && first.endsWith("$$")) return true
+    if (first != "$$") return false
+    for (line in lines.drop(1)) {
+        val trimmed = line.trimEnd(' ', '\t')
+        if (trimmed.isEmpty()) return false
+        if (trimmed.endsWith("$$")) return true
+    }
+    return false
+}
+
+/** Cascade's conservative single-dollar inline-math recognizer. */
+private fun recognizeInlineMathEnd(text: String, start: Int): Int {
+    if (start + 1 >= text.length || text[start] != '$') return -1
+    val first = text[start + 1]
+    if (first == '$' || first == ' ' || first == '\t' || first == '\n') return -1
+    // An escaped opener is literal.
+    var backslashes = 0
+    var before = start - 1
+    while (before >= 0 && text[before] == '\\') {
+        backslashes++
+        before--
+    }
+    if (backslashes % 2 == 1) return -1
+    var index = start + 2
+    while (index < text.length) {
+        when (text[index]) {
+            '\n' -> return -1
+            '\\' -> index += 2
+            '$' -> {
+                val previous = text[index - 1]
+                if (previous == ' ' || previous == '\t') return -1
+                if (index + 1 < text.length && text[index + 1].isDigit()) return -1
+                return index + 1
+            }
+            else -> index++
+        }
+    }
+    return -1
+}
+
+private fun recognizeFootnoteDefinition(raw: String): String? {
+    val first = raw.lineSequence().firstOrNull()?.trimStart(' ', '\t') ?: return null
+    if (!first.startsWith("[^")) return null
+    val close = first.indexOf("]:", 2)
+    if (close < 3) return null
+    val label = first.substring(2, close)
+    return label.takeIf { it.isNotEmpty() && it.none { ch -> ch == '[' || ch == '^' || ch.isWhitespace() } }
+}
+
+private fun hardBreakAtxLevel(raw: String): Int? {
+    if ('\n' in raw) return null
+    var index = 0
+    while (index < raw.length && index < 3 && raw[index] == ' ') index++
+    val markerStart = index
+    while (index < raw.length && raw[index] == '#' && index - markerStart < 6) index++
+    val level = index - markerStart
+    if (level !in 1..6) return null
+    if (index >= raw.length || (raw[index] != ' ' && raw[index] != '\t')) return null
+    return level
+}
+
+private fun isFootnoteReference(raw: String): Boolean {
+    if (!raw.startsWith("[^") || !raw.endsWith(']')) return false
+    val label = raw.substring(2, raw.length - 1)
+    return label.isNotEmpty() && label.none { it == '[' || it == '^' || it.isWhitespace() }
+}
+
+private fun isStandaloneImage(node: ASTNode, raw: String): Boolean {
+    if (!raw.trim().startsWith("![") || !raw.trim().endsWith(')')) return false
+    val structural = node.children.filterNot { isTrivia(it.type) }
+    return structural.size == 1 && structural.single().type == MarkdownElementTypes.IMAGE
+}
+
+private fun isTrivia(type: IElementType): Boolean =
+    type == MarkdownTokenTypes.EOL || type == MarkdownTokenTypes.WHITE_SPACE
+
+private fun blockNestingIncrement(type: IElementType): Int = when (type) {
+    MarkdownElementTypes.BLOCK_QUOTE,
+    MarkdownElementTypes.ORDERED_LIST,
+    MarkdownElementTypes.UNORDERED_LIST,
+    MarkdownElementTypes.LIST_ITEM,
+    -> 1
+    else -> 0
+}
+
+private fun stripBrackets(raw: String): String =
+    if (raw.length >= 2 && raw.first() == '[' && raw.last() == ']') raw.substring(1, raw.length - 1) else raw
+
+private fun stripTitle(raw: String): String {
+    if (raw.length < 2) return raw
+    val first = raw.first()
+    val last = raw.last()
+    return if ((first == '"' && last == '"') || (first == '\'' && last == '\'') || (first == '(' && last == ')')) {
+        raw.substring(1, raw.length - 1)
+    } else raw
+}
+
+private fun decodeDestination(raw: String): String {
+    var value = raw
+    if (value.length >= 2 && value.first() == '<' && value.last() == '>') value = value.substring(1, value.length - 1)
+    val out = StringBuilder(value.length)
+    var index = 0
+    while (index < value.length) {
+        if (value[index] == '\\' && index + 1 < value.length && value[index + 1].isMarkdownPunctuationAst()) {
+            out.append(value[index + 1])
+            index += 2
+        } else {
+            out.append(value[index])
+            index++
+        }
+    }
+    return MarkdownEntities.decode(out.toString(), EntityDecode.Standard)
+}
+
+private fun stripIndentColumns(line: String, columns: Int): String {
+    var index = 0
+    var consumed = 0
+    while (index < line.length && consumed < columns) {
+        when (line[index]) {
+            ' ' -> {
+                consumed++
+                index++
+            }
+            '\t' -> {
+                consumed += 4 - (consumed % 4)
+                index++
+            }
+            else -> break
+        }
+    }
+    return line.substring(index)
+}
+
+/** Minimal JSON escaping for unknown custom-block type metadata. */
+private fun rawTypeJsonForAst(typeId: String): String {
+    val escaped = StringBuilder(typeId.length + 2)
+    for (char in typeId) {
+        when (char) {
+            '\\' -> escaped.append("\\\\")
+            '"' -> escaped.append("\\\"")
+            '\n' -> escaped.append("\\n")
+            '\r' -> escaped.append("\\r")
+            '\t' -> escaped.append("\\t")
+            else -> if (char.code < 0x20) escaped.append("\\u").append(char.code.toString(16).padStart(4, '0')) else escaped.append(char)
+        }
+    }
+    return "{\"typeId\":\"$escaped\"}"
+}
+
+private fun Char.isMarkdownPunctuationAst(): Boolean = when (this) {
+    '!', '"', '#', '$', '%', '&', '\'', '(', ')', '*', '+', ',', '-', '.', '/',
+    ':', ';', '<', '=', '>', '?', '@', '[', '\\', ']', '^', '_', '`', '{', '|', '}', '~',
+    -> true
+    else -> false
+}
diff --git a/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownCodecContracts.kt b/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownCodecContracts.kt
new file mode 100644
index 0000000..99d924b
--- /dev/null
+++ b/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownCodecContracts.kt
@@ -0,0 +1,65 @@
+package io.github.linreal.cascade.editor.markdown
+
+import io.github.linreal.cascade.editor.core.Block
+import io.github.linreal.cascade.editor.core.BlockContent
+import io.github.linreal.cascade.editor.core.BlockType
+import io.github.linreal.cascade.editor.core.SpanStyle
+
+/** Result of a Markdown encoder invocation. */
+@ExperimentalCascadeMarkdownApi
+public sealed interface MarkdownEmit {
+    /** Content-only emission of one canonical unit. */
+    public data class Raw(val markdown: String) : MarkdownEmit
+
+    /** Character-exact emission of a preserved source unit. */
+    public data class Verbatim(val markdown: String) : MarkdownEmit
+
+    /** Skip this encoder; defer to the registered fallback. */
+    public data object Skip : MarkdownEmit
+}
+
+/** Open/close marker pair produced by a span encoder. */
+@ExperimentalCascadeMarkdownApi
+public data class MarkdownMarkPair(val open: String, val close: String)
+
+/** Context passed to Markdown block encoders. */
+@ExperimentalCascadeMarkdownApi
+public abstract class MarkdownEncodeContext internal constructor() {
+    /** Render a block's content as escaped inline Markdown, split by physical line. */
+    public abstract fun encodeInlineLines(block: Block): List<String>
+
+    /** Render escaped visible text with spans ignored. */
+    public abstract fun encodeTextOnly(block: Block): String
+
+    /** Apply first/continuation prefixes to every physical line. */
+    public abstract fun prefixLines(
+        lines: List<String>,
+        firstLinePrefix: String,
+        continuationPrefix: String,
+    ): List<String>
+
+    /** Record an encode-side warning. */
+    public abstract fun warn(warning: MarkdownEncodeWarning)
+
+    internal abstract val newlineSemantics: NewlineSemantics
+    internal abstract val hardBreakMarker: String?
+}
+
+/** Encoder for an individual block. */
+@ExperimentalCascadeMarkdownApi
+public fun interface MarkdownBlockEncoder<T : BlockType> {
+    public fun encode(ctx: MarkdownEncodeContext, block: Block, content: BlockContent): MarkdownEmit
+}
+
+/** Encoder for one inline span style. */
+@ExperimentalCascadeMarkdownApi
+public fun interface MarkdownSpanEncoder<T : SpanStyle> {
+    public fun encode(style: T): MarkdownMarkPair
+}
+
+/** Encoder for a contiguous run of blocks sharing a group key. */
+@ExperimentalCascadeMarkdownApi
+public interface MarkdownBlockGroupEncoder {
+    public fun groupKey(block: Block): Any?
+    public fun encodeGroup(ctx: MarkdownEncodeContext, blocks: List<Block>): MarkdownEmit
+}
diff --git a/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownCodecLimits.kt b/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownCodecLimits.kt
new file mode 100644
index 0000000..aa3d4d6
--- /dev/null
+++ b/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownCodecLimits.kt
@@ -0,0 +1,67 @@
+package io.github.linreal.cascade.editor.markdown
+
+/**
+ * Defensive resource bounds for the Markdown codec.
+ *
+ * Markdown can amplify both parsed state (delimiter runs, nesting) and emitted
+ * text (escaping, prefixing), so limits apply to decode, encode, and analyze.
+ * Exceeding any limit aborts the operation: the result carries
+ * `status = Aborted`, a `null` payload, and a [MarkdownFidelityImpact.Fatal]
+ * warning — an aborted operation is never reported as successful empty content.
+ *
+ * The defaults are generous for the bounded-field v1 target (task/note fields up
+ * to tens of KB) while hard-stopping adversarial input.
+ */
+@ExperimentalCascadeMarkdownApi
+public data class MarkdownCodecLimits(
+    /** Maximum decode/analyze input length in UTF-16 code units. */
+    val maxInputChars: Int = DEFAULT_MAX_INPUT_CHARS,
+    /** Maximum container nesting depth accepted from the Markdown AST. */
+    val maxBlockNesting: Int = DEFAULT_MAX_BLOCK_NESTING,
+    /** Maximum number of blocks produced by one decode. */
+    val maxBlocks: Int = DEFAULT_MAX_BLOCKS,
+    /** Maximum number of spans lowered onto a single block. */
+    val maxSpansPerBlock: Int = DEFAULT_MAX_SPANS_PER_BLOCK,
+    /** Maximum total number of spans across the whole document. */
+    val maxTotalSpans: Int = DEFAULT_MAX_TOTAL_SPANS,
+    /** Maximum number of link-reference definitions collected in the AST prepass. */
+    val maxReferenceDefinitions: Int = DEFAULT_MAX_REFERENCE_DEFINITIONS,
+    /** Maximum number of emphasis-capable delimiter runs accepted before parsing. */
+    val maxDelimiterRuns: Int = DEFAULT_MAX_DELIMITER_RUNS,
+    /**
+     * Maximum number of warnings collected before the operation aborts. The
+     * exhaustion itself is reported as one final [MarkdownFidelityImpact.Fatal]
+     * warning, so the warning list never grows unboundedly.
+     */
+    val maxWarnings: Int = DEFAULT_MAX_WARNINGS,
+    /** Maximum encode/analyze output length in UTF-16 code units. */
+    val maxOutputChars: Int = DEFAULT_MAX_OUTPUT_CHARS,
+) {
+    init {
+        require(maxInputChars > 0) { "maxInputChars must be positive" }
+        require(maxBlockNesting > 0) { "maxBlockNesting must be positive" }
+        require(maxBlocks > 0) { "maxBlocks must be positive" }
+        require(maxSpansPerBlock > 0) { "maxSpansPerBlock must be positive" }
+        require(maxTotalSpans > 0) { "maxTotalSpans must be positive" }
+        require(maxReferenceDefinitions > 0) { "maxReferenceDefinitions must be positive" }
+        require(maxDelimiterRuns > 0) { "maxDelimiterRuns must be positive" }
+        require(maxWarnings > 0) { "maxWarnings must be positive" }
+        require(maxOutputChars > 0) { "maxOutputChars must be positive" }
+    }
+
+    public companion object {
+        // Mirrors HtmlDecodeLimits.DEFAULT_MAX_INPUT_CHARS.
+        public const val DEFAULT_MAX_INPUT_CHARS: Int = 4_000_000
+        public const val DEFAULT_MAX_BLOCK_NESTING: Int = 32
+        public const val DEFAULT_MAX_BLOCKS: Int = 50_000
+        public const val DEFAULT_MAX_SPANS_PER_BLOCK: Int = 1_000
+        public const val DEFAULT_MAX_TOTAL_SPANS: Int = 50_000
+        public const val DEFAULT_MAX_REFERENCE_DEFINITIONS: Int = 5_000
+        public const val DEFAULT_MAX_DELIMITER_RUNS: Int = 10_000
+        public const val DEFAULT_MAX_WARNINGS: Int = 1_000
+        // 4x the input bound: Markdown escaping/prefixing amplifies output.
+        public const val DEFAULT_MAX_OUTPUT_CHARS: Int = 16_000_000
+
+        public val Default: MarkdownCodecLimits = MarkdownCodecLimits()
+    }
+}
diff --git a/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownDecodeEngine.kt b/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownDecodeEngine.kt
new file mode 100644
index 0000000..d1fd0ac
--- /dev/null
+++ b/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownDecodeEngine.kt
@@ -0,0 +1,77 @@
+package io.github.linreal.cascade.editor.markdown
+
+import io.github.linreal.cascade.editor.core.normalizeIndentationOutline
+import io.github.linreal.cascade.editor.core.renumberNumberedLists
+
+/**
+ * Internal decode orchestration. JetBrains Markdown owns CommonMark/GFM
+ * recognition; Cascade owns source normalization, AST-to-editor lowering,
+ * preservation, policy behavior, diagnostics, and resource limits. After
+ * lowering, the core normalization pipeline runs in the mandated order:
+ *    `normalizeIndentationOutline` then `renumberNumberedLists`.
+ *
+ * Warnings from every stage share one bounded collection
+ * ([MarkdownParseState]); an abort in any stage yields an aborted result with
+ * no partial payload. The public no-throw boundary around consumer code lives
+ * in the parser/encoders; the public `MarkdownSchema` entry points
+ * add the final top-level guard.
+ */
+internal object MarkdownDecodeEngine {
+
+    fun decode(
+        input: String,
+        profile: MarkdownProfile,
+        limits: MarkdownCodecLimits = MarkdownCodecLimits.Default,
+    ): MarkdownDecodeResult {
+        if (input.length > limits.maxInputChars) {
+            return MarkdownDecodeResult.aborted(
+                listOf(MarkdownDecodeWarning.InputLimitExceeded(limits.maxInputChars, input.length)),
+                MarkdownSourceLocator(IntArray(0), 0),
+            )
+        }
+        val parseInput = MarkdownParseInput.of(input)
+        val locator = parseInput.locator
+        val state = MarkdownParseState(limits)
+        enforceDelimiterLimit(input, limits, state)
+        if (state.isAborted) return MarkdownDecodeResult.aborted(state.warnings.toList(), locator)
+
+        val tree = parseMarkdownTree(parseInput.text)
+        val blocks = MarkdownAstDecoder(parseInput, tree, profile, limits, state).decode()
+        if (state.isAborted) return MarkdownDecodeResult.aborted(state.warnings.toList(), locator)
+
+        val normalized = renumberNumberedLists(normalizeIndentationOutline(blocks))
+        return MarkdownDecodeResult.success(
+            blocks = normalized,
+            warnings = state.warnings.toList(),
+            sourceLocator = locator,
+        )
+    }
+
+    private fun enforceDelimiterLimit(
+        input: String,
+        limits: MarkdownCodecLimits,
+        state: MarkdownParseState,
+    ) {
+        var runs = 0
+        var index = 0
+        while (index < input.length) {
+            val char = input[index]
+            if (char != '*' && char != '_' && char != '~') {
+                index++
+                continue
+            }
+            runs++
+            if (runs > limits.maxDelimiterRuns) {
+                state.abort(
+                    MarkdownDecodeWarning.LimitExceeded(
+                        MarkdownCodecLimitKind.DelimiterRuns,
+                        limits.maxDelimiterRuns,
+                        MarkdownSourceRange(index, index + 1),
+                    ),
+                )
+                return
+            }
+            while (index < input.length && input[index] == char) index++
+        }
+    }
+}
diff --git a/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownDecodeState.kt b/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownDecodeState.kt
new file mode 100644
index 0000000..8d4050d
--- /dev/null
+++ b/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownDecodeState.kt
@@ -0,0 +1,87 @@
+package io.github.linreal.cascade.editor.markdown
+
+import io.github.linreal.cascade.editor.core.TextSpan
+
+/** Shared, bounded mutable state for one AST decode. */
+internal class MarkdownParseState(private val limits: MarkdownCodecLimits) {
+    private val warningList = ArrayList<MarkdownDecodeWarning>()
+    val warnings: List<MarkdownDecodeWarning> get() = warningList
+    val definitions: MarkdownDefinitionTable = MarkdownDefinitionTable()
+
+    private var fatal: MarkdownDecodeWarning? = null
+    private var blockCount = 0
+    private var spanCount = 0
+
+    val isAborted: Boolean get() = fatal != null
+
+    fun warn(warning: MarkdownDecodeWarning) {
+        if (isAborted) return
+        if (warningList.size >= limits.maxWarnings) {
+            abort(
+                MarkdownDecodeWarning.LimitExceeded(
+                    MarkdownCodecLimitKind.Warnings,
+                    limits.maxWarnings,
+                    warning.range,
+                ),
+            )
+        } else {
+            warningList += warning
+        }
+    }
+
+    fun abort(warning: MarkdownDecodeWarning) {
+        if (fatal != null) return
+        fatal = warning
+        warningList += warning
+    }
+
+    fun noteBlock(range: MarkdownSourceRange): Boolean {
+        if (isAborted) return false
+        blockCount++
+        if (blockCount <= limits.maxBlocks) return true
+        abort(MarkdownDecodeWarning.LimitExceeded(MarkdownCodecLimitKind.Blocks, limits.maxBlocks, range))
+        return false
+    }
+
+    fun noteSpans(count: Int, range: MarkdownSourceRange): Boolean {
+        if (isAborted) return false
+        spanCount += count
+        if (spanCount <= limits.maxTotalSpans) return true
+        abort(
+            MarkdownDecodeWarning.LimitExceeded(
+                MarkdownCodecLimitKind.TotalSpans,
+                limits.maxTotalSpans,
+                range,
+            ),
+        )
+        return false
+    }
+
+    fun registerDefinition(
+        label: String,
+        definition: MarkdownLinkReferenceDefinition,
+        range: MarkdownSourceRange,
+    ) {
+        if (isAborted) return
+        if (!definitions.register(label, definition)) {
+            warn(MarkdownDecodeWarning.DuplicateLinkDefinition(label, range))
+            return
+        }
+        if (definitions.size > limits.maxReferenceDefinitions) {
+            abort(
+                MarkdownDecodeWarning.LimitExceeded(
+                    MarkdownCodecLimitKind.ReferenceDefinitions,
+                    limits.maxReferenceDefinitions,
+                    range,
+                ),
+            )
+        }
+    }
+}
+
+/** Visible text and spans produced by one inline AST container. */
+internal class MarkdownInlineParseResult(
+    val text: String,
+    val spans: List<TextSpan>,
+    val escalationKind: String?,
+)
diff --git a/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownDefinitionTable.kt b/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownDefinitionTable.kt
new file mode 100644
index 0000000..3b79392
--- /dev/null
+++ b/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownDefinitionTable.kt
@@ -0,0 +1,68 @@
+package io.github.linreal.cascade.editor.markdown
+
+/** Internal resolved reference definition collected from the JetBrains AST. */
+internal data class MarkdownLinkReferenceDefinition(
+    val destination: String,
+    val title: String?,
+)
+
+/**
+ * Document-wide table of link-reference definitions collected during the
+ * block phase, so the inline phase can resolve
+ * forward references.
+ *
+ * Lookup keys are CommonMark-normalized labels ([normalizeLabel]): whitespace
+ * trimmed and collapsed, then case-folded. On duplicate labels the **first**
+ * definition wins (CommonMark); [register] reports the collision so the rule
+ * can warn about the shadowed duplicate.
+ */
+internal class MarkdownDefinitionTable {
+
+    private val entries = LinkedHashMap<String, MarkdownLinkReferenceDefinition>()
+
+    /** Number of registered definitions (duplicates excluded). */
+    val size: Int get() = entries.size
+
+    /**
+     * Register [definition] under the raw [label]. Returns `true` when the
+     * definition was stored, `false` when an earlier definition already owns
+     * the normalized label (first definition wins).
+     */
+    fun register(label: String, definition: MarkdownLinkReferenceDefinition): Boolean {
+        val key = normalizeLabel(label)
+        if (entries.containsKey(key)) return false
+        entries[key] = definition
+        return true
+    }
+
+    /** Look up the definition for the raw [label], or `null`. */
+    fun lookup(label: String): MarkdownLinkReferenceDefinition? =
+        entries[normalizeLabel(label)]
+
+    companion object {
+
+        /**
+         * CommonMark label normalization: strip leading/trailing whitespace,
+         * collapse internal whitespace runs (spaces, tabs, line terminators)
+         * to one space, then case-fold. The uppercase-then-lowercase pass
+         * approximates Unicode case folding in common code (it maps
+         * `ß` → `ss` and similar one-to-many folds correctly).
+         */
+        fun normalizeLabel(label: String): String {
+            val sb = StringBuilder(label.length)
+            var pendingSpace = false
+            for (ch in label) {
+                if (ch == ' ' || ch == '\t' || ch == '\n' || ch == '\r') {
+                    if (sb.isNotEmpty()) pendingSpace = true
+                    continue
+                }
+                if (pendingSpace) {
+                    sb.append(' ')
+                    pendingSpace = false
+                }
+                sb.append(ch)
+            }
+            return sb.toString().uppercase().lowercase()
+        }
+    }
+}
diff --git a/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownEncodeContextImpl.kt b/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownEncodeContextImpl.kt
new file mode 100644
index 0000000..78281a2
--- /dev/null
+++ b/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownEncodeContextImpl.kt
@@ -0,0 +1,68 @@
+package io.github.linreal.cascade.editor.markdown
+
+import io.github.linreal.cascade.editor.core.Block
+import io.github.linreal.cascade.editor.core.BlockContent
+
+/**
+ * Concrete [MarkdownEncodeContext] created once per encode by
+ * [MarkdownEncodeEngine]. Warnings flow into the engine's bounded collector.
+ *
+ * Inline emission routes through [MarkdownInlineRenderer]: the
+ * sweep-line walker over span boundaries with encode-side reparse
+ * verification. The structured line-sequence contract holds — one entry per
+ * physical output line, hard-break markers already attached to non-final
+ * lines — so prefix-style encoders transform complete lines.
+ */
+internal class MarkdownEncodeContextImpl(
+    private val profile: MarkdownProfile,
+    private val limits: MarkdownCodecLimits,
+    private val warningSink: (MarkdownEncodeWarning) -> Unit,
+) : MarkdownEncodeContext() {
+
+    private val inlineRenderer = MarkdownInlineRenderer(
+        profile = profile,
+        limits = limits,
+        warningSink = warningSink,
+    )
+
+    override val newlineSemantics: NewlineSemantics get() = profile.newlineSemantics
+
+    override val hardBreakMarker: String?
+        get() = when (profile.newlineSemantics) {
+            NewlineSemantics.CommonMark -> when (profile.hardBreakEncode) {
+                HardBreakEncode.Backslash -> "\\"
+                HardBreakEncode.TwoSpaces -> "  "
+            }
+
+            // HardBreak mode emits plain newlines.
+            NewlineSemantics.HardBreak -> null
+        }
+
+    override fun encodeInlineLines(block: Block): List<String> {
+        val content = block.content as? BlockContent.Text ?: return listOf("")
+        val spans = if (block.type.supportsSpans) content.spans else emptyList()
+        return inlineRenderer.renderLines(
+            blockId = block.id,
+            text = content.text,
+            spans = spans,
+            hardBreakMarker = hardBreakMarker,
+        )
+    }
+
+    override fun encodeTextOnly(block: Block): String {
+        val text = (block.content as? BlockContent.Text)?.text ?: return ""
+        return Markdown.escapeInline(text, MarkdownEscapeContext.LineStart)
+    }
+
+    override fun prefixLines(
+        lines: List<String>,
+        firstLinePrefix: String,
+        continuationPrefix: String,
+    ): List<String> = lines.mapIndexed { index, line ->
+        if (index == 0) firstLinePrefix + line else continuationPrefix + line
+    }
+
+    override fun warn(warning: MarkdownEncodeWarning) {
+        warningSink(warning)
+    }
+}
diff --git a/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownEncodeEngine.kt b/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownEncodeEngine.kt
new file mode 100644
index 0000000..a019978
--- /dev/null
+++ b/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownEncodeEngine.kt
@@ -0,0 +1,282 @@
+package io.github.linreal.cascade.editor.markdown
+
+import io.github.linreal.cascade.editor.core.Block
+import io.github.linreal.cascade.editor.core.BlockContent
+import io.github.linreal.cascade.editor.core.BlockType
+import io.github.linreal.cascade.editor.core.CustomBlockType
+import kotlin.coroutines.cancellation.CancellationException
+
+/** Encode-side line-ending option. */
+@ExperimentalCascadeMarkdownApi
+public enum class MarkdownLineEnding {
+    /** Unix `\n` line endings. Default. */
+    Lf,
+
+    /** Windows `\r\n` line endings. */
+    CrLf,
+}
+
+/**
+ * Canonical whole-document Markdown writer.
+ *
+ * The engine — never the encoders — owns block separation: every encoder emit
+ * is one canonical unit, units are joined with a blank line in CommonMark mode
+ * (a single newline under [NewlineSemantics.HardBreak]), and non-empty output
+ * ends with exactly one final newline. [MarkdownEmit.Raw] declares content
+ * only; [MarkdownEmit.Verbatim] is the distinct path for preserved source
+ * whose slice is never escaped or transformed — with one documented boundary
+ * canonicalization: trailing newlines of a document-final verbatim unit fold
+ * into the single final newline (built-in preserved slices are terminator-free,
+ * so only consumer emissions ending in `\n` can observe this).
+ *
+ * Group encoders run first (the `listOutline` run claim mirrors the HTML
+ * engine); a throwing or [MarkdownEmit.Skip]-returning encoder degrades
+ * through the registered fallback with a warning — consumer exceptions never
+ * cross the codec boundary.
+ *
+ * Inline span emission for text blocks routes through
+ * [MarkdownEncodeContextImpl.encodeInlineLines], which is the
+ * seam where the verified inline renderer (sweep-line walker over span
+ * boundaries, not per-boundary span filtering) plugs in.
+ */
+internal object MarkdownEncodeEngine {
+
+    fun encodeWithReport(
+        blocks: List<Block>,
+        profile: MarkdownProfile,
+        limits: MarkdownCodecLimits = MarkdownCodecLimits.Default,
+        lineEnding: MarkdownLineEnding = MarkdownLineEnding.Lf,
+    ): MarkdownEncodeResult {
+        val state = EncodeState(limits)
+        val context = MarkdownEncodeContextImpl(
+            profile = profile,
+            limits = limits,
+            warningSink = state::warn,
+        )
+        val hardBreak = profile.newlineSemantics == NewlineSemantics.HardBreak
+        val separator = if (hardBreak) "\n" else "\n\n"
+        val runner = Runner(profile, context, state, unitSeparator = separator)
+
+        val units = ArrayList<String>()
+        var runningLength = 0
+        var index = 0
+        while (index < blocks.size && !state.isAborted) {
+            val block = blocks[index]
+            val groupMatch = runner.findGroupMatch(block)
+            // `null` means "nothing to emit" (an encoder Skip that reached an
+            // empty fallback); `""` means an intentional empty unit (a HardBreak
+            // empty paragraph). Only the latter becomes a blank line.
+            val unit: String?
+            if (groupMatch == null) {
+                unit = runner.encodeSingleBlock(block)
+                index++
+            } else {
+                val run = runner.collectRun(blocks, startIndex = index, groupMatch = groupMatch)
+                unit = runner.encodeGroupOrFallback(groupMatch.encoder, run)
+                index += run.size
+            }
+            if (unit == null) continue
+            // In HardBreak mode empty units are real: an empty paragraph owns
+            // one blank line, so N empties between two non-empty units yield
+            // exactly N+1 newlines and trailing empties preserve trailing
+            // blanks. In CommonMark mode a bare empty unit is
+            // still dropped.
+            if (unit.isEmpty() && !hardBreak) continue
+            units += unit
+            runningLength += unit.length + separator.length
+            if (runningLength > limits.maxOutputChars) {
+                state.abort(MarkdownEncodeWarning.OutputLimitExceeded(limit = limits.maxOutputChars))
+            }
+        }
+        if (state.isAborted) return MarkdownEncodeResult.aborted(state.warnings.toList())
+
+        val body = units.joinToString(separator)
+        var output = when {
+            units.isEmpty() -> ""
+            // HardBreak: the join already carries the blank-line structure;
+            // append exactly one final newline (the last line's terminator)
+            // without trimming, so trailing empty paragraphs survive.
+            hardBreak -> body + "\n"
+            else -> body.trimEnd('\n') + "\n"
+        }
+        if (lineEnding == MarkdownLineEnding.CrLf) output = output.toCrLf()
+        if (output.length > limits.maxOutputChars) {
+            state.abort(MarkdownEncodeWarning.OutputLimitExceeded(limit = limits.maxOutputChars))
+            return MarkdownEncodeResult.aborted(state.warnings.toList())
+        }
+        return MarkdownEncodeResult.success(
+            markdown = output,
+            warnings = state.warnings.toList(),
+        )
+    }
+
+    /** Bounded warning collection + abort latch, mirroring [MarkdownParseState]. */
+    private class EncodeState(private val limits: MarkdownCodecLimits) {
+
+        private val warningList = ArrayList<MarkdownEncodeWarning>()
+        val warnings: List<MarkdownEncodeWarning> get() = warningList
+
+        private var fatal: MarkdownEncodeWarning? = null
+        val isAborted: Boolean get() = fatal != null
+
+        fun warn(warning: MarkdownEncodeWarning) {
+            if (isAborted) return
+            if (warningList.size >= limits.maxWarnings) {
+                abort(
+                    MarkdownEncodeWarning.LimitExceeded(
+                        kind = MarkdownCodecLimitKind.Warnings,
+                        limit = limits.maxWarnings,
+                    ),
+                )
+                return
+            }
+            warningList.add(warning)
+        }
+
+        fun abort(warning: MarkdownEncodeWarning) {
+            if (fatal != null) return
+            fatal = warning
+            warningList.add(warning)
+        }
+    }
+
+    private class Runner(
+        private val profile: MarkdownProfile,
+        private val context: MarkdownEncodeContextImpl,
+        private val state: EncodeState,
+        private val unitSeparator: String,
+    ) {
+
+        fun findGroupMatch(block: Block): GroupMatch? {
+            for (named in profile.blockGroupEncoders) {
+                val key = groupKeyOrNull(named.encoder, block)
+                if (key != null) return GroupMatch(encoder = named.encoder, key = key)
+            }
+            return null
+        }
+
+        fun collectRun(blocks: List<Block>, startIndex: Int, groupMatch: GroupMatch): List<Block> {
+            val run = mutableListOf(blocks[startIndex])
+            var index = startIndex + 1
+            while (index < blocks.size) {
+                val nextKey = groupKeyOrNull(groupMatch.encoder, blocks[index])
+                if (nextKey != groupMatch.key) break
+                run += blocks[index]
+                index++
+            }
+            return run
+        }
+
+        // Returns null when there is nothing to emit (Skip that reached an empty
+        // fallback); "" is a distinct intentional empty unit.
+        fun encodeGroupOrFallback(encoder: MarkdownBlockGroupEncoder, blocks: List<Block>): String? {
+            val emit = try {
+                encoder.encodeGroup(context, blocks)
+            } catch (e: CancellationException) {
+                throw e
+            } catch (e: Exception) {
+                state.warn(encoderExceptionWarning(blocks.firstOrNull(), e))
+                MarkdownEmit.Skip
+            }
+            return when (emit) {
+                is MarkdownEmit.Raw -> emit.markdown.trim('\n')
+                is MarkdownEmit.Verbatim -> emit.markdown
+                MarkdownEmit.Skip -> {
+                    val parts = blocks.mapNotNull { encodeBlockFallback(it) }
+                    if (parts.isEmpty()) null else parts.joinToString(unitSeparator)
+                }
+            }
+        }
+
+        fun encodeSingleBlock(block: Block): String? {
+            val primary = profile.blockEncoderFor(block)
+            if (primary != null) {
+                val emit = try {
+                    primary.encodeUnchecked(context, block, block.content)
+                } catch (e: CancellationException) {
+                    throw e
+                } catch (e: Exception) {
+                    state.warn(encoderExceptionWarning(block, e))
+                    MarkdownEmit.Skip
+                }
+                when (emit) {
+                    // Content-only contract: defensively drop boundary blank
+                    // lines an encoder should not have included.
+                    is MarkdownEmit.Raw -> return emit.markdown.trim('\n')
+                    is MarkdownEmit.Verbatim -> return emit.markdown
+                    MarkdownEmit.Skip -> Unit
+                }
+            }
+            return encodeBlockFallback(block)
+        }
+
+        private fun encodeBlockFallback(block: Block): String? {
+            val fallback = profile.encoderBlockFallback ?: return null
+            val emit = try {
+                fallback.encode(context, block, block.content)
+            } catch (e: CancellationException) {
+                throw e
+            } catch (e: Exception) {
+                state.warn(encoderExceptionWarning(block, e))
+                MarkdownEmit.Skip
+            }
+            return when (emit) {
+                is MarkdownEmit.Raw -> emit.markdown.trim('\n')
+                is MarkdownEmit.Verbatim -> emit.markdown
+                MarkdownEmit.Skip -> null
+            }
+        }
+
+        private fun groupKeyOrNull(encoder: MarkdownBlockGroupEncoder, block: Block): Any? =
+            try {
+                encoder.groupKey(block)
+            } catch (e: CancellationException) {
+                throw e
+            } catch (e: Exception) {
+                state.warn(encoderExceptionWarning(block, e))
+                null
+            }
+
+        private fun encoderExceptionWarning(
+            block: Block?,
+            exception: Exception,
+        ): MarkdownEncodeWarning = MarkdownEncodeWarning.EncoderException(
+            typeId = block?.warningTypeId(),
+            message = exception.message ?: (exception::class.simpleName ?: "exception"),
+            blockId = block?.id,
+        )
+    }
+
+    private data class GroupMatch(
+        val encoder: MarkdownBlockGroupEncoder,
+        val key: Any,
+    )
+}
+
+@Suppress("UNCHECKED_CAST")
+private fun MarkdownBlockEncoder<*>.encodeUnchecked(
+    ctx: MarkdownEncodeContext,
+    block: Block,
+    content: BlockContent,
+): MarkdownEmit = (this as MarkdownBlockEncoder<BlockType>).encode(ctx, block, content)
+
+private fun Block.warningTypeId(): String {
+    val type = this.type
+    if (type is CustomBlockType) return type.typeId
+    val content = this.content
+    if (content is BlockContent.Custom) return content.typeId
+    return type.typeId
+}
+
+private fun String.toCrLf(): String {
+    if (indexOf('\n') < 0) return this
+    val out = StringBuilder(length + 16)
+    var previous = ' '
+    for (ch in this) {
+        // A verbatim slice may already contain CRLF pairs; never double the CR.
+        if (ch == '\n' && previous != '\r') out.append('\r')
+        out.append(ch)
+        previous = ch
+    }
+    return out.toString()
+}
diff --git a/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownEntities.kt b/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownEntities.kt
new file mode 100644
index 0000000..220c7c4
--- /dev/null
+++ b/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownEntities.kt
@@ -0,0 +1,197 @@
+package io.github.linreal.cascade.editor.markdown
+
+import org.intellij.markdown.html.entities.Entities
+
+/**
+ * One matched entity reference, produced by [MarkdownEntities.matchAt].
+ *
+ * [replacement] is non-null for numeric references and for named references in
+ * the documented supported subset. A named reference that is entity-shaped but
+ * outside the subset yields a match with a null [replacement]: the reference
+ * stays literal text and the call site reports it through
+ * [MarkdownDecodeWarning.UnsupportedEntity].
+ */
+internal class MarkdownEntityMatch(
+    /** Total matched length including the leading `&` and trailing `;`. */
+    val length: Int,
+    /** Decoded text, or null when the named reference is unsupported. */
+    val replacement: String?,
+    /** Reference name for named references (known or unknown); null for numeric. */
+    val name: String?,
+)
+
+/**
+ * Entity-reference decoding for the Markdown codec.
+ *
+ * Numeric references retain Cascade's strict CommonMark-compatible handling.
+ * Named reference values come from JetBrains Markdown's generated entity table,
+ * constrained to Cascade's documented v1 subset so existing decode behavior and
+ * diagnostics stay stable.
+ *
+ * - **Numeric references decode fully**: `&#35;` (1–7 decimal digits) and
+ *   `&#x1F600;` (1–6 hex digits), with the CommonMark invalid-codepoint rule —
+ *   U+0000, values above U+10FFFF, and surrogate code points decode to U+FFFD.
+ * - **Named references decode from the documented subset** in
+ *   [supportedNames]: common
+ *   punctuation/symbol/arrow/fraction/currency names. Unknown names stay
+ *   literal text and are reported through the [decode] callback (the call site
+ *   wraps that into an Informational [MarkdownDecodeWarning.UnsupportedEntity]
+ *   with the exact source range).
+ * - Anything not entity-shaped (`&` without a terminated body, over-long
+ *   bodies, malformed numerics) stays literal text with no warning, matching
+ *   CommonMark's treatment of such text as ordinary characters.
+ *
+ * All functions are pure, single-pass, position-agnostic, and regex-free.
+ * The no-decoding-inside-code-spans rule is enforced at the call site (the
+ * inline parser), not here. [EntityDecode.None] disables decoding
+ * entirely (handled in [decode]).
+ *
+ * The table is internal: consumers cannot extend it in v1.
+ */
+internal object MarkdownEntities {
+
+    /** Reviewable v1 subset; replacement code points are owned by JetBrains. */
+    private val supportedNames: Set<String> = setOf(
+        "amp", "lt", "gt", "quot", "apos", "nbsp", "copy", "reg", "trade",
+        "ndash", "mdash", "hellip", "lsquo", "rsquo", "ldquo", "rdquo", "bull",
+        "rarr", "larr", "uarr", "darr", "harr", "times", "divide", "minus",
+        "plusmn", "infin", "ne", "le", "ge", "asymp", "deg", "micro", "middot",
+        "sect", "para", "laquo", "raquo", "sbquo", "bdquo", "prime", "Prime",
+        "dagger", "Dagger", "permil", "euro", "pound", "yen", "cent", "frac12",
+        "frac14", "frac34", "sup1", "sup2", "sup3", "shy", "ensp", "emsp", "thinsp",
+    )
+
+    /**
+     * Match an entity reference starting at [index] in [text].
+     *
+     * [index] must point at a `&`. Returns null when the text at [index] is
+     * not entity-shaped (no such construct — the `&` is literal, no warning).
+     * Returns a match with a null replacement when the body is a well-formed
+     * named reference outside [supportedNames].
+     */
+    fun matchAt(text: String, index: Int): MarkdownEntityMatch? {
+        if (index >= text.length || text[index] != '&') return null
+        var cursor = index + 1
+        if (cursor >= text.length) return null
+
+        if (text[cursor] == '#') {
+            cursor++
+            val hex = cursor < text.length && (text[cursor] == 'x' || text[cursor] == 'X')
+            if (hex) cursor++
+            val digitsStart = cursor
+            val radix = if (hex) 16 else 10
+            val maxDigits = if (hex) MAX_HEX_DIGITS else MAX_DECIMAL_DIGITS
+            var value = 0
+            while (cursor < text.length) {
+                val digit = text[cursor].digitToIntOrNull(radix) ?: break
+                // Clamp instead of overflowing; anything past the max code
+                // point is invalid and becomes U+FFFD anyway.
+                value = if (value > MAX_CODE_POINT) MAX_CODE_POINT + 1 else value * radix + digit
+                cursor++
+            }
+            val digits = cursor - digitsStart
+            if (digits < 1 || digits > maxDigits) return null
+            if (cursor >= text.length || text[cursor] != ';') return null
+            return MarkdownEntityMatch(
+                length = cursor + 1 - index,
+                replacement = codePointToStringOrReplacement(value),
+                name = null,
+            )
+        }
+
+        val nameStart = cursor
+        while (cursor < text.length && cursor - nameStart <= MAX_NAME_LENGTH) {
+            val ch = text[cursor]
+            if (ch == ';') {
+                if (cursor == nameStart) return null
+                val name = text.substring(nameStart, cursor)
+                return MarkdownEntityMatch(
+                    length = cursor + 1 - index,
+                    replacement = if (name in supportedNames) {
+                        Entities.map["&$name;"]?.let(::codePointToStringOrReplacement)
+                    } else null,
+                    name = name,
+                )
+            }
+            if (!ch.isAsciiAlphanumeric()) return null
+            cursor++
+        }
+        return null
+    }
+
+    /**
+     * Decode every entity reference in [text].
+     *
+     * Under [EntityDecode.None] the input is returned unchanged and
+     * [onUnknownName] is never invoked. Unknown named references stay literal
+     * and are reported through [onUnknownName] with their exact half-open
+     * offsets **within [text]** — the call site re-bases them into source
+     * coordinates (the helper stays position-agnostic).
+     */
+    fun decode(
+        text: String,
+        policy: EntityDecode,
+        onUnknownName: ((name: String, start: Int, endExclusive: Int) -> Unit)? = null,
+    ): String {
+        if (policy == EntityDecode.None) return text
+        val firstAmpersand = text.indexOf('&')
+        if (firstAmpersand < 0) return text
+
+        val out = StringBuilder(text.length)
+        out.append(text, 0, firstAmpersand)
+        var index = firstAmpersand
+        while (index < text.length) {
+            val ch = text[index]
+            if (ch != '&') {
+                out.append(ch)
+                index++
+                continue
+            }
+            val match = matchAt(text, index)
+            if (match == null) {
+                out.append(ch)
+                index++
+                continue
+            }
+            if (match.replacement != null) {
+                out.append(match.replacement)
+            } else {
+                out.append(text, index, index + match.length)
+                if (match.name != null) {
+                    onUnknownName?.invoke(match.name, index, index + match.length)
+                }
+            }
+            index += match.length
+        }
+        return out.toString()
+    }
+
+    /**
+     * CommonMark invalid-codepoint rule: U+0000, out-of-range values, and
+     * surrogate code points decode to U+FFFD REPLACEMENT CHARACTER.
+     */
+    private fun codePointToStringOrReplacement(codePoint: Int): String {
+        if (codePoint <= 0 || codePoint > MAX_CODE_POINT) return REPLACEMENT
+        if (codePoint in HIGH_SURROGATE_START..LOW_SURROGATE_END) return REPLACEMENT
+        if (codePoint <= BMP_MAX) return codePoint.toChar().toString()
+        val shifted = codePoint - SUPPLEMENTARY_PLANE_START
+        val high = HIGH_SURROGATE_START + (shifted shr 10)
+        val low = LOW_SURROGATE_START + (shifted and LOW_SURROGATE_MASK)
+        return high.toChar().toString() + low.toChar().toString()
+    }
+
+    private fun Char.isAsciiAlphanumeric(): Boolean =
+        this in '0'..'9' || this in 'a'..'z' || this in 'A'..'Z'
+
+    private const val REPLACEMENT: String = "�"
+    private const val MAX_DECIMAL_DIGITS: Int = 7
+    private const val MAX_HEX_DIGITS: Int = 6
+    private const val MAX_NAME_LENGTH: Int = 32
+    private const val BMP_MAX: Int = 0xFFFF
+    private const val MAX_CODE_POINT: Int = 0x10FFFF
+    private const val SUPPLEMENTARY_PLANE_START: Int = 0x10000
+    private const val HIGH_SURROGATE_START: Int = 0xD800
+    private const val LOW_SURROGATE_START: Int = 0xDC00
+    private const val LOW_SURROGATE_END: Int = 0xDFFF
+    private const val LOW_SURROGATE_MASK: Int = 0x3FF
+}
diff --git a/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownEscaping.kt b/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownEscaping.kt
new file mode 100644
index 0000000..b744f20
--- /dev/null
+++ b/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownEscaping.kt
@@ -0,0 +1,366 @@
+package io.github.linreal.cascade.editor.markdown
+
+/**
+ * Surrounding-syntax context for [Markdown.escapeInline].
+ *
+ * Markdown escaping is position-dependent, so a lone `atLineStart` Boolean is
+ * insufficient for multi-line text or text nested in list/quote prefixes:
+ *
+ * - [atLineStart] describes only the *first* character of the text being
+ *   escaped. After every `\n` inside the text a new physical output line
+ *   begins, and line-start rules apply again to its first character — block
+ *   constructs can start after container prefixes (`> `, list continuation
+ *   indentation), so a container prefix does not neutralize line-start syntax.
+ * - [containerPrefix] is the prefix the encoder prepends to every subsequent
+ *   physical output line (e.g. `"> "` inside a quote, `"  "` for list-item
+ *   continuations). [Markdown.escapeInline] does not insert it — prefixing is
+ *   the emission engine's job — but it is carried so escaping decisions stay
+ *   reviewable alongside the emission context and future prefix-sensitive
+ *   rules have the data they need.
+ * - [kind] selects the destination/label/plain-text context.
+ *
+ * [containerPrefix] and [kind] are currently informational: no escaping rule
+ * consults them (brackets are escaped unconditionally, so [kind] adds nothing
+ * yet). They are part of the contract so prefix- or kind-sensitive rules can
+ * be added without a signature change; do not rely on kind-specific behavior.
+ */
+@ExperimentalCascadeMarkdownApi
+public data class MarkdownEscapeContext(
+    /** Whether the first character of the text lands at a physical line start. */
+    val atLineStart: Boolean,
+    /** Prefix the encoder applies to every following physical output line. */
+    val containerPrefix: String = "",
+    /** Text position kind: plain inline text, link text, or link label. */
+    val kind: MarkdownEscapeTextKind = MarkdownEscapeTextKind.Plain,
+) {
+    public companion object {
+        /** Plain text starting at a physical line start with no container prefix. */
+        public val LineStart: MarkdownEscapeContext = MarkdownEscapeContext(atLineStart = true)
+
+        /** Plain text continuing mid-line (e.g. after an emphasis opener). */
+        public val MidLine: MarkdownEscapeContext = MarkdownEscapeContext(atLineStart = false)
+    }
+}
+
+/** Position kind carried by [MarkdownEscapeContext]. */
+@ExperimentalCascadeMarkdownApi
+public enum class MarkdownEscapeTextKind {
+    /** Ordinary inline text. */
+    Plain,
+
+    /** Text between `[` and `]` of a link. */
+    LinkText,
+
+    /** A reference-link label. */
+    LinkLabel,
+}
+
+/**
+ * Delimiter decision for encoding one inline code span, computed by
+ * [Markdown.codeSpanDelimiters].
+ *
+ * The [fence] is a backtick run strictly longer than every backtick run inside
+ * the content. When [padded] is true the content must be emitted with one
+ * space of padding inside each fence (`open` and `close` include it), so that
+ * edge backticks cannot merge with the fence and CommonMark's
+ * strip-one-space rule reproduces the original content on decode.
+ */
+@ExperimentalCascadeMarkdownApi
+public data class MarkdownCodeSpanDelimiters(
+    val fence: String,
+    val padded: Boolean,
+    /**
+     * True when the content cannot round-trip as an inline code span at all:
+     * empty content (an empty code span is unrepresentable in CommonMark) or
+     * content containing line terminators (CommonMark normalizes internal line
+     * endings to a space on decode). Callers must route such content through
+     * the HTML bridge or a drop-with-warning path instead of emitting these
+     * delimiters blindly.
+     */
+    val requiresFallback: Boolean = false,
+) {
+    /** Opening delimiter including padding. */
+    public val open: String get() = if (padded) "$fence " else fence
+
+    /** Closing delimiter including padding. */
+    public val close: String get() = if (padded) " $fence" else fence
+}
+
+/**
+ * Positional Markdown escaping helpers — the analog of `Html.escapeText` /
+ * `Html.escapeAttr`, except Markdown escaping depends on *position*: `#` is
+ * only special at line start, `-`/`1.` only where they would form list or
+ * break syntax, `*`/`_` only where they would form delimiter runs, `` ` ``
+ * always, `[`/`]` around link syntax.
+ *
+ * Default encoders and consumer-authored encoders must go through these
+ * helpers rather than hand-rolling `replace(...)` chains. The helpers may
+ * over-escape (every escaped character re-decodes to itself); they never
+ * under-escape — the round-trip property suite is the honesty check.
+ *
+ * All functions are pure, single-pass, and regex-free.
+ */
+@ExperimentalCascadeMarkdownApi
+public object Markdown {
+
+    /**
+     * Escape [text] for emission as inline Markdown content in [context].
+     *
+     * Line-start rules apply to the first character when
+     * [MarkdownEscapeContext.atLineStart] is true and to the first character
+     * after every line terminator in [text] (`\n`, `\r\n`, and lone `\r` all
+     * begin a new physical output line, matching the decoder's line map;
+     * container prefixes do not neutralize line-start syntax). CommonMark
+     * allows up to 3 leading spaces before block syntax, so line-start rules
+     * see through 1–3 spaces of indentation; 4+ spaces is indented-code
+     * territory and outside the escaper's job (a value-based support-set
+     * exclusion).
+     */
+    public fun escapeInline(text: String, context: MarkdownEscapeContext): String {
+        if (text.isEmpty()) return text
+
+        val out = StringBuilder(text.length + 8)
+        // Index in text where the current physical line begins.
+        var lineStart = 0
+        // Whether the current physical line's head is a true line start. The
+        // first line inherits context.atLineStart; every line after a
+        // terminator is.
+        var lineHeadIsLineStart = context.atLineStart
+        // First non-space index of the current line, looking through at most
+        // 3 leading spaces — where line-start block syntax can begin.
+        var lineContentStart = contentStartOf(text, 0)
+        var index = 0
+        while (index < text.length) {
+            val ch = text[index]
+            if (ch == '\n' || ch == '\r') {
+                out.append(ch)
+                index++
+                if (ch == '\r' && index < text.length && text[index] == '\n') {
+                    out.append('\n')
+                    index++
+                }
+                lineStart = index
+                lineHeadIsLineStart = true
+                lineContentStart = contentStartOf(text, index)
+                continue
+            }
+
+            val atLineStart = lineHeadIsLineStart && index == lineContentStart
+            val escape = when (ch) {
+                // Backslash could escape the next character; backtick opens
+                // code spans (and line-start runs open fences); & could start
+                // an entity; < opens autolinks and inline HTML anywhere.
+                '\\', '`', '&', '<' -> true
+
+                // Link syntax binds anywhere in inline text.
+                '[', ']' -> true
+
+                // Pipe tables and math blocks/spans are claimed by the default
+                // profile's recognizers; unescaped '|'
+                // or '$' in ordinary text could re-decode as an opaque
+                // preserved block. Over-escaping is permitted and cheap.
+                '|', '$' -> true
+
+                // Emphasis-style delimiters: escape unless the run can neither
+                // open nor close per flanking rules. Line-start '*' can also be
+                // a bullet or thematic break; line-start '~' runs can open a
+                // tilde fence.
+                '*' -> canFormDelimiterRun(text, index) ||
+                    (atLineStart && isListOrBreakMarker(text, index))
+
+                '~' -> canFormDelimiterRun(text, index) || atLineStart
+                '_' -> canFormDelimiterRun(text, index) && !isIntraword(text, index)
+
+                // Line-start block syntax: ATX headings, blockquotes, setext
+                // underlines, bullets, and thematic breaks.
+                '#', '>', '=' -> atLineStart
+                '-', '+' -> atLineStart && isListOrBreakMarker(text, index)
+
+                // Ordered-list marker: escape the '.'/')' that closes a
+                // digit run at the line's content start so "1. x" (with up to
+                // 3 leading spaces) cannot re-parse as a list.
+                '.', ')' -> lineHeadIsLineStart &&
+                    isOrderedListMarkerClose(text, lineContentStart, index)
+
+                else -> false
+            }
+
+            if (escape) out.append('\\')
+            out.append(ch)
+            index++
+        }
+        return out.toString()
+    }
+
+    /**
+     * Compute the backtick fence and padding needed to emit [text] as an
+     * inline code span.
+     *
+     * The fence is widened past the longest backtick run in [text]. Padding is
+     * chosen conservatively (over-padding is safe): it is applied whenever the
+     * content contains a backtick or starts/ends with a space, except when the
+     * content is empty or all spaces — CommonMark's strip-one-space rule only
+     * fires when content begins *and* ends with a space and is not all spaces,
+     * so padding all-space content would corrupt it.
+     */
+    public fun codeSpanDelimiters(text: String): MarkdownCodeSpanDelimiters {
+        var longestRun = 0
+        var currentRun = 0
+        var hasBacktick = false
+        var allSpaces = true
+        var hasLineBreak = false
+        for (ch in text) {
+            if (ch == '`') {
+                hasBacktick = true
+                currentRun++
+                if (currentRun > longestRun) longestRun = currentRun
+            } else {
+                currentRun = 0
+            }
+            if (ch != ' ') allSpaces = false
+            if (ch == '\n' || ch == '\r') hasLineBreak = true
+        }
+
+        val fence = "`".repeat(longestRun + 1)
+        val padded = text.isNotEmpty() &&
+            !allSpaces &&
+            (hasBacktick || text.first() == ' ' || text.last() == ' ')
+        return MarkdownCodeSpanDelimiters(
+            fence = fence,
+            padded = padded,
+            requiresFallback = text.isEmpty() || hasLineBreak,
+        )
+    }
+
+    /**
+     * Escape [target] for emission as a link destination.
+     *
+     * Chooses the `<angle>` form whenever the bare form would be invalid or
+     * ambiguous: empty targets, whitespace or control characters, parentheses,
+     * angle brackets, or backslashes. Inside the angle form, `<`, `>`, and
+     * `\` are backslash-escaped; line terminators (invalid even in the angle
+     * form) are percent-encoded.
+     */
+    public fun escapeLinkDestination(target: String): String {
+        var needsAngle = target.isEmpty()
+        if (!needsAngle) {
+            for (ch in target) {
+                if (ch == '(' || ch == ')' || ch == '<' || ch == '>' || ch == '\\' ||
+                    ch == ' ' || ch.code < 0x20 || ch.code == 0x7F
+                ) {
+                    needsAngle = true
+                    break
+                }
+            }
+        }
+        if (!needsAngle) return target
+
+        val out = StringBuilder(target.length + 8)
+        out.append('<')
+        for (ch in target) {
+            when (ch) {
+                '<', '>', '\\' -> out.append('\\').append(ch)
+                '\n' -> out.append("%0A")
+                '\r' -> out.append("%0D")
+                else -> out.append(ch)
+            }
+        }
+        out.append('>')
+        return out.toString()
+    }
+
+    /**
+     * Escape [text] for emission between `[` and `]` of a link.
+     *
+     * Equivalent to [escapeInline] mid-line with the link-text kind: brackets
+     * are always escaped so nested bracket runs cannot terminate or restart
+     * the link syntax.
+     */
+    public fun escapeLinkText(text: String): String =
+        escapeInline(
+            text,
+            MarkdownEscapeContext(
+                atLineStart = false,
+                kind = MarkdownEscapeTextKind.LinkText,
+            ),
+        )
+
+    /**
+     * True when the delimiter-capable character at [index] could open or close
+     * a delimiter run: escaped unless it is surrounded by whitespace on both
+     * sides (such a run is neither left- nor right-flanking and can never
+     * bind). Text boundaries count as unknown neighbors and force escaping —
+     * the emitted text may sit adjacent to other emitted markers. Over-escaping
+     * is deliberate; deciding true pairing requires the full emphasis
+     * algorithm.
+     */
+    private fun canFormDelimiterRun(text: String, index: Int): Boolean {
+        val marker = text[index]
+        var runStart = index
+        while (runStart > 0 && text[runStart - 1] == marker) runStart--
+        var runEnd = index
+        while (runEnd + 1 < text.length && text[runEnd + 1] == marker) runEnd++
+
+        val beforeIsWhitespace = runStart > 0 && text[runStart - 1].isMarkdownWhitespace()
+        val afterIsWhitespace = runEnd < text.length - 1 && text[runEnd + 1].isMarkdownWhitespace()
+        return !(beforeIsWhitespace && afterIsWhitespace)
+    }
+
+    /** True when `_` at [index] sits between two alphanumerics (intraword). */
+    private fun isIntraword(text: String, index: Int): Boolean {
+        var runStart = index
+        while (runStart > 0 && text[runStart - 1] == '_') runStart--
+        var runEnd = index
+        while (runEnd + 1 < text.length && text[runEnd + 1] == '_') runEnd++
+
+        val before = if (runStart == 0) null else text[runStart - 1]
+        val after = if (runEnd == text.length - 1) null else text[runEnd + 1]
+        return before != null && after != null &&
+            before.isLetterOrDigit() && after.isLetterOrDigit()
+    }
+
+    /**
+     * True when `-`/`+`/`*` at a line start would form a bullet marker or a
+     * thematic-break/setext line: followed by space/tab, end of line, or more
+     * of the same character.
+     */
+    private fun isListOrBreakMarker(text: String, index: Int): Boolean {
+        val marker = text[index]
+        val next = if (index + 1 < text.length) text[index + 1] else null
+        return next == null || next == ' ' || next == '\t' ||
+            next == '\n' || next == '\r' || next == marker
+    }
+
+    /**
+     * True when `.`/`)` at [index] closes an ordered-list marker: the current
+     * physical line's content (after at most 3 leading spaces) up to [index] is
+     * exactly a 1–9 digit run and the marker is followed by space, tab, or end
+     * of line.
+     */
+    private fun isOrderedListMarkerClose(text: String, contentStart: Int, index: Int): Boolean {
+        val digits = index - contentStart
+        if (digits < 1 || digits > 9) return false
+        for (cursor in contentStart until index) {
+            if (!text[cursor].isAsciiDigit()) return false
+        }
+        val next = if (index + 1 < text.length) text[index + 1] else null
+        return next == null || next == ' ' || next == '\t' || next == '\n' || next == '\r'
+    }
+
+    /**
+     * First index at or after [lineStart] that is not one of up to 3 leading
+     * spaces — the position where line-start block syntax can begin. A line
+     * indented 4+ spaces has its content start pinned at the fourth space, so
+     * no later character can qualify as line-start.
+     */
+    private fun contentStartOf(text: String, lineStart: Int): Int {
+        var cursor = lineStart
+        while (cursor < text.length && cursor - lineStart < 3 && text[cursor] == ' ') cursor++
+        return cursor
+    }
+
+    private fun Char.isMarkdownWhitespace(): Boolean =
+        this == ' ' || this == '\t' || this == '\n' || this == '\r'
+
+    private fun Char.isAsciiDigit(): Boolean = this in '0'..'9'
+}
diff --git a/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownFidelityReport.kt b/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownFidelityReport.kt
new file mode 100644
index 0000000..2a68d15
--- /dev/null
+++ b/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownFidelityReport.kt
@@ -0,0 +1,159 @@
+package io.github.linreal.cascade.editor.markdown
+
+import io.github.linreal.cascade.editor.core.Block
+import io.github.linreal.cascade.editor.core.BlockContent
+
+/**
+ * Host edit-mode recommendation from [MarkdownSchema.analyze].
+ */
+@ExperimentalCascadeMarkdownApi
+public enum class MarkdownEditModeRecommendation {
+    /** The document round-trips losslessly; open it in the native editor. */
+    Native,
+
+    /**
+     * The document cannot be edited without losing fidelity; open a raw text
+     * fallback so the original source is preserved byte-for-byte.
+     */
+    RawFallback,
+}
+
+/**
+ * Fidelity assessment of a Markdown document under a profile.
+ *
+ * Produced by [MarkdownSchema.analyze]: a source decode followed — on success —
+ * by one canonical encode and one verification decode. The encode result is
+ * reused for [wouldRewriteSource] and [nativeEditingSafe]; no second encode runs.
+ *
+ * The report classifies by fidelity **impact**, never by concrete warning
+ * subclass, so new warning members never require an analyze change.
+ *
+ * @property decodeResult the decode outcome.
+ * @property encodeResult the encode outcome, or `null` when the decode aborted
+ *   (no blocks to encode).
+ * @property preservedBlockCount number of opaque preserved blocks
+ *   (`md.preserved` / `md.preservedHtml`) in the decoded document.
+ * @property dataLossWarnings every [MarkdownFidelityImpact.DataLoss] warning
+ *   from either direction — the actionable "what would be lost" list.
+ * @property wouldRewriteSource whether re-encoding differs from the source
+ *   (line endings, BOM, final newline, and canonical spelling all count);
+ *   `null` when no encode comparison was possible. A `true` value driven only
+ *   by [MarkdownFidelityImpact.Canonicalization] never forces raw fallback on
+ *   its own.
+ * @property nativeEditingSafe successful decode ∧ completed encode ∧ no
+ *   [MarkdownFidelityImpact.OpaquePreservation] / [MarkdownFidelityImpact.DataLoss]
+ *   / [MarkdownFidelityImpact.Fatal] from either direction ∧ the profile's
+ *   support predicate accepts the blocks ∧ canonical output decodes to the same
+ *   editor model (generated block IDs ignored).
+ * @property recommendedMode [MarkdownEditModeRecommendation.Native] iff
+ *   [nativeEditingSafe].
+ */
+@ExperimentalCascadeMarkdownApi
+public class MarkdownFidelityReport internal constructor(
+    public val decodeResult: MarkdownDecodeResult,
+    public val encodeResult: MarkdownEncodeResult?,
+    public val preservedBlockCount: Int,
+    public val dataLossWarnings: List<MarkdownWarning>,
+    public val wouldRewriteSource: Boolean?,
+    public val nativeEditingSafe: Boolean,
+    public val recommendedMode: MarkdownEditModeRecommendation,
+) {
+    override fun toString(): String =
+        "MarkdownFidelityReport(recommendedMode=$recommendedMode, " +
+            "nativeEditingSafe=$nativeEditingSafe, preservedBlockCount=$preservedBlockCount, " +
+            "dataLossWarnings=${dataLossWarnings.size}, wouldRewriteSource=$wouldRewriteSource)"
+}
+
+/**
+ * Internal analyzer backing [MarkdownSchema.analyze]. Runs one source decode
+ * and, on success, one encode plus one verification decode. The single encode
+ * result serves both source-rewrite comparison and round-trip verification.
+ */
+internal object MarkdownFidelityAnalyzer {
+
+    private val PRESERVED_TYPE_IDS = setOf(MARKDOWN_PRESERVED_TYPE_ID, MARKDOWN_PRESERVED_HTML_TYPE_ID)
+
+    fun analyze(
+        markdown: String,
+        profile: MarkdownProfile,
+        limits: MarkdownCodecLimits,
+    ): MarkdownFidelityReport {
+        val decodeResult = MarkdownSchema.decodeWithReport(markdown, profile, limits)
+        val blocks = decodeResult.blocks
+            ?: return MarkdownFidelityReport(
+                decodeResult = decodeResult,
+                encodeResult = null,
+                preservedBlockCount = 0,
+                dataLossWarnings = decodeResult.warnings.filter {
+                    it.impact == MarkdownFidelityImpact.DataLoss
+                },
+                wouldRewriteSource = null,
+                nativeEditingSafe = false,
+                recommendedMode = MarkdownEditModeRecommendation.RawFallback,
+            )
+
+        val encodeResult = MarkdownSchema.encodeWithReport(blocks, profile, limits)
+        val preservedBlockCount = blocks.count { block ->
+            val content = block.content
+            content is BlockContent.Custom && content.typeId in PRESERVED_TYPE_IDS
+        }
+
+        val combinedWarnings: List<MarkdownWarning> = decodeResult.warnings + encodeResult.warnings
+        val dataLossWarnings = combinedWarnings.filter { it.impact == MarkdownFidelityImpact.DataLoss }
+        val wouldRewriteSource = encodeResult.markdown?.let { it != markdown }
+
+        val impactClean = combinedWarnings.none {
+            it.impact == MarkdownFidelityImpact.OpaquePreservation ||
+                it.impact == MarkdownFidelityImpact.DataLoss ||
+                it.impact == MarkdownFidelityImpact.Fatal
+        }
+        val supportOk = documentSupported(profile, blocks, encodeResult, limits)
+        val nativeEditingSafe =
+            decodeResult.isSuccess && encodeResult.isSuccess && impactClean && supportOk
+        val mode = if (nativeEditingSafe) {
+            MarkdownEditModeRecommendation.Native
+        } else {
+            MarkdownEditModeRecommendation.RawFallback
+        }
+
+        return MarkdownFidelityReport(
+            decodeResult = decodeResult,
+            encodeResult = encodeResult,
+            preservedBlockCount = preservedBlockCount,
+            dataLossWarnings = dataLossWarnings,
+            wouldRewriteSource = wouldRewriteSource,
+            nativeEditingSafe = nativeEditingSafe,
+            recommendedMode = mode,
+        )
+    }
+
+    /**
+     * Support component of [MarkdownFidelityReport.nativeEditingSafe]. The
+     * public support predicate remains a narrowing hook; the canonical output
+     * is then decoded and compared with the editor model so no predicate can
+     * falsely widen the round-trip claim. A default-built support set exposes
+     * its cheap value/shape claim so the already-computed encode is reused.
+     */
+    private fun documentSupported(
+        profile: MarkdownProfile,
+        blocks: List<Block>,
+        encodeResult: MarkdownEncodeResult,
+        limits: MarkdownCodecLimits,
+    ): Boolean {
+        // A custom support-set predicate may throw; `analyze` must stay no-throw,
+        // so a throwing predicate is treated as "not supported" → RawFallback.
+        return try {
+            val analyzerClaim = profile.supportSet.analyzerDocumentClaim
+            val claimed = if (analyzerClaim != null) {
+                analyzerClaim(blocks)
+            } else {
+                profile.supportSet.supportsDocument(blocks)
+            }
+            claimed && markdownRoundTripMatches(blocks, encodeResult, profile, limits)
+        } catch (e: kotlin.coroutines.cancellation.CancellationException) {
+            throw e
+        } catch (e: Exception) {
+            false
+        }
+    }
+}
diff --git a/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownHtmlBridge.kt b/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownHtmlBridge.kt
new file mode 100644
index 0000000..aa24541
--- /dev/null
+++ b/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownHtmlBridge.kt
@@ -0,0 +1,258 @@
+package io.github.linreal.cascade.editor.markdown
+
+import io.github.linreal.cascade.editor.core.SpanStyle
+import io.github.linreal.cascade.editor.htmlserialization.HtmlBlockFragmentResult
+import io.github.linreal.cascade.editor.htmlserialization.HtmlDecodeWarning
+import io.github.linreal.cascade.editor.htmlserialization.HtmlFragmentDecoder
+import io.github.linreal.cascade.editor.htmlserialization.HtmlInlineFragmentResult
+import io.github.linreal.cascade.editor.htmlserialization.HtmlProfile
+import io.github.linreal.cascade.editor.htmlserialization.InlineFragment
+
+/**
+ * Internal HTML ⇄ Markdown bridge.
+ *
+ * Detection of HTML in Markdown source is **always active** regardless of the
+ * [HtmlInMarkdown] policy — something must consume `<tag …>` / `</tag>` /
+ * `<!-- … -->`; the policy decides what the detected range *becomes*:
+ *
+ * - [HtmlInMarkdown.Bridge] routes the island through the internal
+ *   [HtmlFragmentDecoder], handing inner text back to the Markdown inline
+ *   parser (so `<u>**bold**</u>` keeps Bold), and emits
+ *   [MarkdownDecodeWarning.HtmlBridged] (Informational). Islands that lower to
+ *   no content are **not** a successful bridge and follow the
+ *   [UnsupportedSyntax] policy (Preserve → `md.preservedHtml`; WarnAndDegrade →
+ *   DataLoss).
+ * - [HtmlInMarkdown.Preserve] always preserves block HTML as an opaque
+ *   `md.preservedHtml` block.
+ * - [HtmlInMarkdown.WarnAndStrip] drops the tags, keeps inner text, and emits
+ *   [MarkdownDecodeWarning.HtmlStripped] (DataLoss).
+ * - [HtmlInMarkdown.Strip] does the same but the strip warning is recorded for
+ *   fidelity analysis rather than surfaced as a user-facing loss.
+ *
+ * ### Security
+ *
+ * The codec is **not a sanitizer**. Under [HtmlInMarkdown.Bridge] /
+ * [HtmlInMarkdown.Preserve] raw HTML can survive a decode/encode round-trip
+ * verbatim. WebView or server hosts must sanitize at render time, or adopt a
+ * strict profile via [MarkdownProfile.withoutHtmlBridge], which guarantees no
+ * raw HTML is ever emitted through any path.
+ */
+internal object MarkdownHtmlBridge {
+
+    /** typeId of the internal block-phase node carrying a raw HTML block slice. */
+    const val HTML_BLOCK_NODE_TYPE_ID: String = "md.htmlBlockSource"
+
+    /** Data key holding the raw HTML slice on an [HTML_BLOCK_NODE_TYPE_ID] node. */
+    const val RAW_HTML_KEY: String = "rawHtml"
+
+    // Inline detection
+
+    /**
+     * An inline HTML island `<tag …>inner</tag>` recognized at a `<` trigger,
+     * or null. Only paired tags are recognized inline; comments, void tags, and
+     * unmatched opens stay literal (the block path handles line-level HTML).
+     */
+    class InlineIsland(
+        val endExclusive: Int,
+        val innerStart: Int,
+        val innerEnd: Int,
+        val tagName: String,
+    )
+
+    /**
+     * True when [line] begins an HTML *block* (pragmatic subset of the
+     * CommonMark start conditions): an HTML comment, or a well-formed
+     * open/close tag whose name is a **block-level** element (the CommonMark
+     * type-6 list plus script/pre/style/textarea). Inline tags (`<u>`, `<mark>`,
+     * `<span>`, `<b>`, …) deliberately do **not** start a block — they are
+     * handled inline by `rawHtmlInline`, so a paragraph beginning with an inline
+     * tag stays a paragraph. Up to three leading spaces are tolerated.
+     */
+    fun looksLikeHtmlBlockStart(line: String): Boolean {
+        var start = 0
+        var indent = 0
+        while (start < line.length && line[start] == ' ' && indent < 4) {
+            start++
+            indent++
+        }
+        if (indent >= 4 || start >= line.length || line[start] != '<') return false
+        if (line.startsWith("<!--", start)) return true
+        val tag = scanTag(line, start) ?: return false
+        return tag.name.lowercase() in BLOCK_TAG_NAMES
+    }
+
+    private val BLOCK_TAG_NAMES: Set<String> = setOf(
+        "address", "article", "aside", "base", "basefont", "blockquote", "body",
+        "caption", "center", "col", "colgroup", "dd", "details", "dialog", "dir",
+        "div", "dl", "dt", "fieldset", "figcaption", "figure", "footer", "form",
+        "frame", "frameset", "h1", "h2", "h3", "h4", "h5", "h6", "head", "header",
+        "hr", "html", "iframe", "legend", "li", "link", "main", "menu", "menuitem",
+        "nav", "noframes", "ol", "optgroup", "option", "p", "param", "section",
+        "summary", "table", "tbody", "td", "tfoot", "th", "thead", "title", "tr",
+        "track", "ul", "script", "pre", "style", "textarea",
+    )
+
+    fun matchInlinePairedTag(text: String, pos: Int): InlineIsland? {
+        val open = scanTag(text, pos) ?: return null
+        if (open.isClose || open.selfClosing || open.name.isEmpty()) return null
+        val name = open.name
+        var index = open.endExclusive
+        var depth = 1
+        while (index < text.length) {
+            // Bound the forward scan so a flood of unmatched `<tag …>` opens
+            // stays linear overall instead of O(n^2) (each trigger re-scanning
+            // to end-of-text). A legitimate inline island is far shorter.
+            if (index - pos > MAX_INLINE_ISLAND_SCAN) return null
+            if (text[index] == '<') {
+                val tag = scanTag(text, index)
+                if (tag != null && tag.name.equals(name, ignoreCase = true)) {
+                    if (tag.isClose) {
+                        depth--
+                        if (depth == 0) {
+                            return InlineIsland(
+                                endExclusive = tag.endExclusive,
+                                innerStart = open.endExclusive,
+                                innerEnd = index,
+                                tagName = name,
+                            )
+                        }
+                    } else if (!tag.selfClosing) {
+                        depth++
+                    }
+                    index = tag.endExclusive
+                    continue
+                }
+            }
+            index++
+        }
+        return null
+    }
+
+    private class TagToken(
+        val name: String,
+        val endExclusive: Int,
+        val isClose: Boolean,
+        val selfClosing: Boolean,
+    )
+
+    /** Scan one HTML tag at [pos] (which must be `<`), or null when not a tag. */
+    private fun scanTag(text: String, pos: Int): TagToken? {
+        if (pos >= text.length || text[pos] != '<') return null
+        var index = pos + 1
+        if (index >= text.length) return null
+        val isClose = text[index] == '/'
+        if (isClose) index++
+        val nameStart = index
+        if (index >= text.length || !text[index].isHtmlNameStart()) return null
+        while (index < text.length && text[index].isHtmlNameChar()) index++
+        val name = text.substring(nameStart, index)
+        // The character right after the name must end the name legally —
+        // whitespace, `>`, or `/`. This rejects autolink-shaped input like
+        // `<http://x>` (`:` after the name is not a valid tag continuation).
+        if (index < text.length) {
+            val after = text[index]
+            if (after != '>' && after != '/' && !after.isWhitespace()) return null
+        }
+        // Attributes / whitespace until '>' (quotes respected, no nested '>').
+        var selfClosing = false
+        while (index < text.length) {
+            val ch = text[index]
+            when (ch) {
+                '>' -> return TagToken(name, index + 1, isClose, selfClosing)
+                '/' -> {
+                    selfClosing = true
+                    index++
+                }
+                '"', '\'' -> {
+                    val quote = ch
+                    index++
+                    while (index < text.length && text[index] != quote) index++
+                    if (index >= text.length) return null
+                    index++
+                }
+                '<' -> return null
+                else -> {
+                    if (ch != '/') selfClosing = false
+                    index++
+                }
+            }
+        }
+        return null
+    }
+
+    private const val MAX_INLINE_ISLAND_SCAN: Int = 8192
+
+    // Bridge routing
+
+    /**
+     * Decode an inline island's HTML through the fragment decoder, routing its
+     * text leaves back through [reparseInner] (the Markdown inline parser) so
+     * nested Markdown survives. Returns the full fragment result **including
+     * inner warnings** — the caller re-bases and classifies them (a dropped
+     * inner tag is data loss, not a clean bridge).
+     */
+    fun bridgeInline(
+        islandHtml: String,
+        htmlProfile: HtmlProfile,
+        reparseInner: (String) -> InlineFragment,
+    ): HtmlInlineFragmentResult =
+        HtmlFragmentDecoder.decodeInlineFragment(islandHtml, htmlProfile, reparseInner)
+
+    /** Decode a block-level HTML slice through the fragment decoder (with warnings). */
+    fun bridgeBlock(
+        html: String,
+        htmlProfile: HtmlProfile,
+        reparseInner: (String) -> InlineFragment,
+    ): HtmlBlockFragmentResult =
+        HtmlFragmentDecoder.decodeBlockFragment(html, htmlProfile, reparseInner)
+
+    /**
+     * True when an inner HTML decode warning represents **content or metadata
+     * loss** (so the bridge was not clean). Straightened/auto-closed nesting is
+     * canonicalization and preserves content, so it is treated as benign.
+     */
+    fun isDestructiveHtmlWarning(warning: HtmlDecodeWarning): Boolean = when (warning) {
+        is HtmlDecodeWarning.MismatchedNesting,
+        is HtmlDecodeWarning.UnclosedTag -> false
+        else -> true
+    }
+
+    /** Best-effort tag name carried by a destructive inner warning, for the re-wrapped warning. */
+    fun htmlWarningTag(warning: HtmlDecodeWarning): String? = when (warning) {
+        is HtmlDecodeWarning.UnknownTag -> warning.tag
+        is HtmlDecodeWarning.StrayClosingTag -> warning.tag
+        is HtmlDecodeWarning.UnknownAttribute -> warning.tag
+        is HtmlDecodeWarning.InvalidAttribute -> warning.tag
+        is HtmlDecodeWarning.BlockInInlineContext -> warning.tag
+        is HtmlDecodeWarning.DroppedAttribute -> warning.tag
+        is HtmlDecodeWarning.DecoderException -> warning.tag
+        else -> null
+    }
+}
+
+/** Native inline-code / HTML span mark pairs used by the default profile encoders. */
+internal object MarkdownHtmlSpanEncoders {
+
+    /** `Underline` → `<u>…</u>` (mirrors the HTML codec spelling). */
+    val Underline: MarkdownSpanEncoder<SpanStyle.Underline> =
+        MarkdownSpanEncoder { MarkdownMarkPair(open = "<u>", close = "</u>") }
+
+    /** `Highlight` → `<mark data-cascade-highlight="AARRGGBB">…</mark>`. */
+    val Highlight: MarkdownSpanEncoder<SpanStyle.Highlight> =
+        MarkdownSpanEncoder { style ->
+            MarkdownMarkPair(
+                open = "<mark data-cascade-highlight=\"${style.colorArgb.toEightDigitUpperHex()}\">",
+                close = "</mark>",
+            )
+        }
+
+    private fun Long.toEightDigitUpperHex(): String {
+        val hex = (this and 0xFFFF_FFFFL).toString(16).uppercase()
+        return hex.padStart(8, '0')
+    }
+}
+
+private fun Char.isHtmlNameStart(): Boolean = this in 'a'..'z' || this in 'A'..'Z'
+
+private fun Char.isHtmlNameChar(): Boolean =
+    this in 'a'..'z' || this in 'A'..'Z' || this in '0'..'9' || this == '-'
diff --git a/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownInlineRenderer.kt b/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownInlineRenderer.kt
new file mode 100644
index 0000000..ee94570
--- /dev/null
+++ b/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownInlineRenderer.kt
@@ -0,0 +1,532 @@
+package io.github.linreal.cascade.editor.markdown
+
+import io.github.linreal.cascade.editor.core.BlockId
+import io.github.linreal.cascade.editor.core.SpanStyle
+import io.github.linreal.cascade.editor.core.TextSpan
+import io.github.linreal.cascade.editor.richtext.SpanAlgorithms
+import kotlin.coroutines.cancellation.CancellationException
+
+/**
+ * Verified inline span encoder.
+ *
+ * A sweep-line walker over span boundaries — never per-boundary full-span
+ * filtering — emits canonical markers with close/reopen for
+ * partial overlaps, then **re-parses its own output with the decode-side
+ * the JetBrains-backed inline AST adapter**. Output is returned only when it decodes back to
+ * exactly the spans that were encoded; on mismatch the weakest span is dropped
+ * with [MarkdownEncodeWarning.AmbiguousEmphasis] (or
+ * [MarkdownEncodeWarning.DroppedSpanOverlap] for code/link residue) and the
+ * segment re-emits — never silently different spans.
+ *
+ * `InlineCode` overlap classification:
+ * - an outer style fully containing a code range nests normally;
+ * - disjoint styles are trivial;
+ * - a style wholly inside code content is unrepresentable → dropped with
+ *   `DroppedSpanOverlap`;
+ * - a partial crossing splits the code range at the crossing boundary
+ *   (close/reopen); the adjacent code pieces re-merge under decode-side span
+ *   normalization, and the verification pass proves it.
+ * - code content containing a line ending cannot round-trip (CommonMark
+ *   normalizes it to a space) → the code span drops with `DroppedSpanOverlap`.
+ */
+internal class MarkdownInlineRenderer(
+    private val profile: MarkdownProfile,
+    private val limits: MarkdownCodecLimits,
+    private val warningSink: (MarkdownEncodeWarning) -> Unit,
+) {
+
+    /**
+     * Render one text block's content as physical output lines. Hard-break
+     * markers (when [hardBreakMarker] is non-null) are appended to every
+     * non-final line so prefix encoders transform complete lines.
+     */
+    fun renderLines(
+        blockId: BlockId?,
+        text: String,
+        spans: List<TextSpan>,
+        hardBreakMarker: String?,
+    ): List<String> {
+        // Span-free text enters the same emit/verify loop: plain text has
+        // value-based failure modes the escaper cannot fix (trailing spaces,
+        // trailing spaces before a hard break, >0 leading spaces) and those
+        // must warn instead of silently re-decoding differently — otherwise a
+        // clean encodeWithReport would falsify the default support claim.
+        val normalized = SpanAlgorithms.normalize(spans, text.length)
+        val working = classify(normalized, text, blockId)
+        // Whether the bare text (no spans, no markers) survives a decode.
+        // Computed lazily on the first mismatch: it separates value-based text
+        // exclusions (unfixable — warn once) from marker-induced text damage
+        // (fixable by dropping the ambiguous span).
+        var plainProbe: Boolean? = null
+        fun plainTextRoundTrips(): Boolean = plainProbe ?: run {
+            val plainLines = attachBreakMarkers(
+                escapeText(text, atLineStart = true),
+                hardBreakMarker,
+            )
+            val ok = verify(plainLines, text, emptyList()) == VerifyOutcome.Match
+            plainProbe = ok
+            ok
+        }
+
+        while (true) {
+            val parts = emitParts(text, working)
+            switchJuxtaposedItalics(parts, text)
+            val emitted = assemble(parts)
+            val lines = attachBreakMarkers(emitted, hardBreakMarker)
+
+            if (!needsVerification(working)) return lines
+            val outcome = verify(lines, text, working)
+            if (outcome == VerifyOutcome.Match) return lines
+            if (outcome == VerifyOutcome.TextMismatch && !plainTextRoundTrips()) {
+                // The visible text itself does not round-trip (a value-based
+                // exclusion); dropping spans cannot fix it,
+                // so warn once and return instead of spending
+                // AmbiguousEmphasis warnings on innocent spans.
+                warningSink(
+                    MarkdownEncodeWarning.DroppedSpanOverlap(
+                        blockId = blockId,
+                        textRange = null,
+                        reason = "emitted inline text failed encode-side verification",
+                    ),
+                )
+                return lines
+            }
+            // Span mismatch, or a text mismatch induced by the emitted
+            // markers themselves (e.g. an unpairable leftover delimiter):
+            // both are resolved by dropping the weakest span and re-emitting.
+
+            val victim = chooseVictim(working)
+            if (victim == null) {
+                // Defensive: a span mismatch with nothing left to drop.
+                for (span in working) {
+                    warningSink(
+                        MarkdownEncodeWarning.DroppedSpanOverlap(
+                            blockId = blockId,
+                            textRange = MarkdownTextRange(span.start, span.end),
+                            reason = "span failed encode-side verification",
+                        ),
+                    )
+                }
+                if (working.isEmpty()) return lines
+                working.clear()
+                continue
+            }
+            working.remove(victim)
+            if (victim.strategy == Strategy.Delimiter) {
+                warningSink(
+                    MarkdownEncodeWarning.AmbiguousEmphasis(
+                        blockId = blockId,
+                        textRange = MarkdownTextRange(victim.start, victim.end),
+                    ),
+                )
+            } else {
+                warningSink(
+                    MarkdownEncodeWarning.DroppedSpanOverlap(
+                        blockId = blockId,
+                        textRange = MarkdownTextRange(victim.start, victim.end),
+                        reason = "span failed encode-side verification",
+                    ),
+                )
+            }
+        }
+    }
+
+    // Classification
+
+    private enum class Strategy { Delimiter, Code, LinkNative, MarkPair }
+
+    private class RenderSpan(
+        val start: Int,
+        val end: Int,
+        val style: SpanStyle,
+        val strategy: Strategy,
+        var marker: String? = null,
+        var pair: MarkdownMarkPair? = null,
+    ) {
+        val openPriority: Int
+            get() = when (strategy) {
+                Strategy.LinkNative -> 0
+                Strategy.MarkPair -> 1
+                Strategy.Delimiter -> 2
+                Strategy.Code -> 3
+            }
+    }
+
+    private fun classify(
+        spans: List<TextSpan>,
+        text: String,
+        blockId: BlockId?,
+    ): MutableList<RenderSpan> {
+        val codeRanges = ArrayList<TextSpan>()
+        val out = ArrayList<RenderSpan>(spans.size)
+
+        for (span in spans) {
+            if (span.style == SpanStyle.InlineCode) {
+                val covered = text.substring(span.start, span.end)
+                if (covered.indexOf('\n') >= 0) {
+                    // CommonMark normalizes line endings inside code spans to a
+                    // space, so the code marks drop while the text is kept.
+                    warningSink(
+                        MarkdownEncodeWarning.DroppedSpanOverlap(
+                            blockId = blockId,
+                            textRange = MarkdownTextRange(span.start, span.end),
+                            reason = "inline-code content contains a line ending, " +
+                                "which cannot round-trip as a Markdown code span",
+                        ),
+                    )
+                    continue
+                }
+                codeRanges.add(span)
+                out.add(RenderSpan(span.start, span.end, span.style, Strategy.Code))
+            }
+        }
+
+        for (span in spans) {
+            val style = span.style
+            if (style == SpanStyle.InlineCode) continue
+
+            // A style wholly inside code content is unrepresentable; containing
+            // and disjoint layouts are fine; partial crossings split the code
+            // range at emission time.
+            val insideCode = codeRanges.any { code ->
+                span.start >= code.start && span.end <= code.end &&
+                    !(span.start <= code.start && span.end >= code.end)
+            }
+            if (insideCode) {
+                warningSink(
+                    MarkdownEncodeWarning.DroppedSpanOverlap(
+                        blockId = blockId,
+                        textRange = MarkdownTextRange(span.start, span.end),
+                        reason = "span lies inside inline-code content, where no " +
+                            "Markdown markup can apply",
+                    ),
+                )
+                continue
+            }
+
+            if (style is SpanStyle.Link) {
+                out.add(
+                    RenderSpan(span.start, span.end, style, Strategy.LinkNative).also {
+                        it.pair = DefaultMarkdownSpanEncoders.linkMarkPair(style.url)
+                    },
+                )
+                continue
+            }
+
+            val explicit = profile.spanEncoderFor(style)
+            if (explicit != null) {
+                val pair = encodePairSafely(explicit, style, blockId)
+                if (pair != null) {
+                    out.add(
+                        RenderSpan(span.start, span.end, style, Strategy.MarkPair)
+                            .also { it.pair = pair },
+                    )
+                    continue
+                }
+            }
+
+            val marker = DefaultMarkdownSpanEncoders.canonicalMarkerFor(profile, style)
+            if (marker != null) {
+                out.add(
+                    RenderSpan(span.start, span.end, style, Strategy.Delimiter)
+                        .also { it.marker = marker },
+                )
+                continue
+            }
+
+            // No encoding: text kept, marks dropped through the span fallback.
+            warningSink(
+                MarkdownEncodeWarning.UnsupportedSpan(
+                    typeId = (style as? SpanStyle.Custom)?.typeId,
+                    reason = "no Markdown encoding is registered for this span style",
+                    blockId = blockId,
+                    textRange = MarkdownTextRange(span.start, span.end),
+                ),
+            )
+            val fallback = profile.encoderSpanFallback ?: continue
+            val pair = encodePairSafely(fallback, style, blockId) ?: continue
+            if (pair.open.isNotEmpty() || pair.close.isNotEmpty()) {
+                out.add(
+                    RenderSpan(span.start, span.end, style, Strategy.MarkPair)
+                        .also { it.pair = pair },
+                )
+            }
+        }
+        return out
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    private fun encodePairSafely(
+        encoder: MarkdownSpanEncoder<*>,
+        style: SpanStyle,
+        blockId: BlockId?,
+    ): MarkdownMarkPair? = try {
+        (encoder as MarkdownSpanEncoder<SpanStyle>).encode(style)
+    } catch (e: CancellationException) {
+        throw e
+    } catch (e: Exception) {
+        warningSink(
+            MarkdownEncodeWarning.EncoderException(
+                typeId = (style as? SpanStyle.Custom)?.typeId,
+                message = e.message ?: (e::class.simpleName ?: "exception"),
+                blockId = blockId,
+            ),
+        )
+        null
+    }
+
+    // Emission (sweep line over span boundaries)
+
+    private sealed interface Part {
+        class Text(val raw: String) : Part
+        class Marker(val span: RenderSpan, val open: Boolean) : Part
+        class Code(val content: String) : Part
+    }
+
+    private fun emitParts(text: String, working: List<RenderSpan>): MutableList<Part> {
+        val parts = ArrayList<Part>()
+        if (working.isEmpty()) {
+            if (text.isNotEmpty()) parts.add(Part.Text(text))
+            return parts
+        }
+
+        val stackSpans = working.filter { it.strategy != Strategy.Code }
+        val codeSpans = working.filter { it.strategy == Strategy.Code }.sortedBy { it.start }
+
+        val boundaryList = ArrayList<Int>(working.size * 2 + 2)
+        boundaryList.add(0)
+        boundaryList.add(text.length)
+        for (span in working) {
+            boundaryList.add(span.start)
+            boundaryList.add(span.end)
+        }
+        val boundaries = boundaryList.distinct().sorted().toIntArray()
+
+        val opensAt = HashMap<Int, MutableList<RenderSpan>>()
+        val hasCloseAt = HashMap<Int, Boolean>()
+        for (span in stackSpans) {
+            opensAt.getOrPut(span.start) { mutableListOf() }.add(span)
+            hasCloseAt[span.end] = true
+        }
+        for (list in opensAt.values) {
+            // Longest span first; at equal extents links open outermost so the
+            // canonical form is `[**text**](target)`.
+            list.sortWith(compareByDescending<RenderSpan> { it.end }.thenBy { it.openPriority })
+        }
+
+        val stack = ArrayList<RenderSpan>()
+        var codeIndex = 0
+
+        for (index in boundaries.indices) {
+            val at = boundaries[index]
+
+            if (hasCloseAt[at] == true) {
+                var lowest = -1
+                for (stackIndex in stack.indices) {
+                    if (stack[stackIndex].end == at) {
+                        lowest = stackIndex
+                        break
+                    }
+                }
+                if (lowest >= 0) {
+                    val reopen = ArrayList<RenderSpan>()
+                    for (stackIndex in stack.indices.reversed()) {
+                        if (stackIndex < lowest) break
+                        val span = stack.removeAt(stackIndex)
+                        parts.add(Part.Marker(span, open = false))
+                        if (span.end != at) reopen.add(span)
+                    }
+                    reopen.sortWith(compareByDescending { it.end })
+                    for (span in reopen) {
+                        stack.add(span)
+                        parts.add(Part.Marker(span, open = true))
+                    }
+                }
+            }
+
+            opensAt[at]?.forEach { span ->
+                stack.add(span)
+                parts.add(Part.Marker(span, open = true))
+            }
+
+            if (index + 1 >= boundaries.size) break
+            val next = boundaries[index + 1]
+            if (next <= at) continue
+
+            while (codeIndex < codeSpans.size && codeSpans[codeIndex].end <= at) codeIndex++
+            val code = codeSpans.getOrNull(codeIndex)
+            if (code != null && at >= code.start && next <= code.end) {
+                parts.add(Part.Code(text.substring(at, next)))
+            } else {
+                parts.add(Part.Text(text.substring(at, next)))
+            }
+        }
+        return parts
+    }
+
+    /**
+     * The `*` → `_` auto-switch: when two markers of
+     * the same character from different spans end up juxtaposed, the span with
+     * an alternate-character marker (canonically the italic `_`) switches —
+     * unless one of its boundaries is intraword, where `_` cannot flank and the
+     * ambiguity risk is accepted (verification decides).
+     */
+    private fun switchJuxtaposedItalics(parts: List<Part>, text: String) {
+        for (index in 0 until parts.size - 1) {
+            val a = parts[index] as? Part.Marker ?: continue
+            val b = parts[index + 1] as? Part.Marker ?: continue
+            val markerA = a.span.marker ?: continue
+            val markerB = b.span.marker ?: continue
+            if (markerA[0] != markerB[0] || a.span === b.span) continue
+
+            val candidates = listOf(a.span, b.span)
+                .filter { it.strategy == Strategy.Delimiter }
+                .sortedBy { it.marker?.length ?: Int.MAX_VALUE }
+            for (candidate in candidates) {
+                val current = candidate.marker ?: continue
+                if (hasIntrawordBoundary(candidate, text)) continue
+                val alternate = DefaultMarkdownSpanEncoders.alternateMarkerFor(
+                    profile = profile,
+                    style = candidate.style,
+                    excludeChar = current[0],
+                ) ?: continue
+                candidate.marker = alternate
+                break
+            }
+        }
+    }
+
+    private fun hasIntrawordBoundary(span: RenderSpan, text: String): Boolean {
+        fun alnum(index: Int): Boolean =
+            index in text.indices && text[index].isLetterOrDigit()
+        val openIntraword = alnum(span.start - 1) && alnum(span.start)
+        val closeIntraword = alnum(span.end - 1) && alnum(span.end)
+        return openIntraword || closeIntraword
+    }
+
+    private fun assemble(parts: List<Part>): String {
+        val sb = StringBuilder()
+        var atLineStart = true
+        for (part in parts) {
+            when (part) {
+                is Part.Text -> {
+                    val escaped = escapeText(part.raw, atLineStart)
+                    sb.append(escaped)
+                    if (part.raw.isNotEmpty()) atLineStart = part.raw.last() == '\n'
+                }
+
+                is Part.Marker -> {
+                    sb.append(markerText(part))
+                    atLineStart = false
+                }
+
+                is Part.Code -> {
+                    val delimiters = Markdown.codeSpanDelimiters(part.content)
+                    sb.append(delimiters.open).append(part.content).append(delimiters.close)
+                    atLineStart = false
+                }
+            }
+        }
+        return sb.toString()
+    }
+
+    private fun markerText(part: Part.Marker): String {
+        val span = part.span
+        span.marker?.let { return it }
+        val pair = span.pair ?: return ""
+        return if (part.open) pair.open else pair.close
+    }
+
+    private fun escapeText(text: String, atLineStart: Boolean): String {
+        val escaped = Markdown.escapeInline(
+            text,
+            if (atLineStart) MarkdownEscapeContext.LineStart else MarkdownEscapeContext.MidLine,
+        )
+        return escaped
+    }
+
+    private fun attachBreakMarkers(emitted: String, hardBreakMarker: String?): List<String> {
+        val lines = emitted.split('\n')
+        if (hardBreakMarker == null || lines.size == 1) return lines
+        return lines.mapIndexed { index, line ->
+            if (index < lines.lastIndex) line + hardBreakMarker else line
+        }
+    }
+
+    // Encode-side verification
+
+    private enum class VerifyOutcome { Match, TextMismatch, SpanMismatch }
+
+    // A MarkPair span whose emission decodes back through the Markdown parser
+    // (the built-in HTML `<u>` / `<mark>` islands, when the bridge is active) is
+    // verified like any other span — the reparse rebuilds Underline/Highlight,
+    // so mixed HTML/Markdown islands are proven by reparse.
+    // Verification is disabled only when an *opaque* consumer MarkPair span is
+    // present (its emission may not decode back; the consumer owns correctness).
+    private fun needsVerification(working: List<RenderSpan>): Boolean =
+        working.none { it.strategy == Strategy.MarkPair && !isBridgeVerifiableMarkPair(it) }
+
+    private fun isBridgeVerifiableMarkPair(span: RenderSpan): Boolean =
+        profile.htmlInMarkdown is HtmlInMarkdown.Bridge &&
+            (span.style is SpanStyle.Underline || span.style is SpanStyle.Highlight)
+
+    private fun verify(lines: List<String>, text: String, working: List<RenderSpan>): VerifyOutcome {
+        // Mimic the decode path: the block phase trims leading whitespace from
+        // paragraph continuation lines before the inline phase sees the leaf.
+        val input = lines.joinToString("\n") { line -> line.trimStart(' ', '\t') }
+        val parseInput = MarkdownParseInput.of(input)
+        val root = parseMarkdownTree(parseInput.text)
+        val container = root.children.firstOrNull {
+            it.type == org.intellij.markdown.MarkdownElementTypes.PARAGRAPH
+        } ?: root
+        val state = MarkdownParseState(limits)
+        val parsed = MarkdownAstInlineDecoder(
+            parseInput,
+            profile,
+            limits,
+            state,
+            MarkdownDefinitionTable(),
+            emptySet(),
+        ).decode(container)
+        if (state.isAborted || parsed.escalationKind != null) {
+            return VerifyOutcome.TextMismatch
+        }
+        if (parsed.text != text) return VerifyOutcome.TextMismatch
+
+        val expected = working.map { span ->
+            val style = if (span.strategy == Strategy.Delimiter) {
+                val marker = span.marker
+                (marker?.let { DefaultMarkdownSpanEncoders.decodedStyleFor(profile, it) })
+                    ?: span.style
+            } else {
+                span.style
+            }
+            TextSpan(span.start, span.end, style)
+        }
+        return if (parsed.spans == SpanAlgorithms.normalize(expected, text.length)) {
+            VerifyOutcome.Match
+        } else {
+            VerifyOutcome.SpanMismatch
+        }
+    }
+
+    /**
+     * The weakest span to drop after a verification mismatch: the shortest
+     * delimiter-emitted span (later start breaks ties), then code spans, then
+     * links, then a bridge/consumer MarkPair span **last** — so one bad
+     * MarkPair (e.g. an out-of-range Highlight) is dropped itself rather than
+     * destroying every other span with misleading `AmbiguousEmphasis`
+     * warnings. Every drop emits a warning at the call site.
+     */
+    private fun chooseVictim(working: List<RenderSpan>): RenderSpan? {
+        val delimiter = working
+            .filter { it.strategy == Strategy.Delimiter }
+            .minWithOrNull(compareBy<RenderSpan> { it.end - it.start }.thenByDescending { it.start })
+        if (delimiter != null) return delimiter
+        val code = working.lastOrNull { it.strategy == Strategy.Code }
+        if (code != null) return code
+        val link = working.lastOrNull { it.strategy == Strategy.LinkNative }
+        if (link != null) return link
+        return working.lastOrNull { it.strategy == Strategy.MarkPair }
+    }
+}
diff --git a/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownPolicies.kt b/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownPolicies.kt
new file mode 100644
index 0000000..77de5cf
--- /dev/null
+++ b/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownPolicies.kt
@@ -0,0 +1,151 @@
+package io.github.linreal.cascade.editor.markdown
+
+import io.github.linreal.cascade.editor.htmlserialization.HtmlProfile
+
+/**
+ * Policy that controls what happens to raw HTML embedded in Markdown source.
+ *
+ * Detection of HTML blocks and inline tags is always active regardless of the
+ * chosen policy — something must consume those constructs — the policy decides
+ * what the detected range becomes.
+ */
+@ExperimentalCascadeMarkdownApi
+public sealed interface HtmlInMarkdown {
+
+    /** Drop HTML tags, keep inner text, emit [MarkdownDecodeWarning.HtmlStripped]. */
+    public data object WarnAndStrip : HtmlInMarkdown
+
+    /**
+     * Drop HTML tags and keep inner text without a user-facing warning. The
+     * destructive impact is still recorded for fidelity analysis — policy choice
+     * never makes fidelity appear better than the actual transform.
+     */
+    public data object Strip : HtmlInMarkdown
+
+    /**
+     * Decode embedded HTML through the internal HTML fragment bridge using
+     * [htmlProfile]. Every bridged range emits
+     * [MarkdownDecodeWarning.HtmlBridged]. Default (with [HtmlProfile.Default]).
+     */
+    public data class Bridge(val htmlProfile: HtmlProfile) : HtmlInMarkdown
+
+    /**
+     * Preserve block-level HTML as a renderable opaque block with custom
+     * content `typeId = "md.preservedHtml"`.
+     */
+    public data object Preserve : HtmlInMarkdown
+}
+
+/**
+ * Policy that controls what happens to well-known Markdown constructs the
+ * editor cannot model (pipe tables, front matter, math blocks, footnotes,
+ * block images, and unrepresentable metadata).
+ */
+@ExperimentalCascadeMarkdownApi
+public sealed interface UnsupportedSyntax {
+
+    /**
+     * Preservation recognizers are active: a recognized construct becomes an
+     * opaque `md.preserved` block carrying its character-exact source slice,
+     * with a [MarkdownDecodeWarning.PreservedSyntax] warning. Default —
+     * every surveyed Markdown-native host treats silent data loss as a
+     * pilot blocker.
+     */
+    public data object Preserve : UnsupportedSyntax
+
+    /**
+     * Recognizers stand down: constructs decode through ordinary syntaxes with
+     * degraded content (a table becomes paragraph text, an image its alt text)
+     * plus a [MarkdownDecodeWarning.UnsupportedSyntax] warning.
+     */
+    public data object WarnAndDegrade : UnsupportedSyntax
+}
+
+/**
+ * Umbrella policy for the newline dialect of a profile.
+ *
+ * The two modes decode with different active block-syntax orders:
+ *
+ * | Slot | CommonMark | HardBreak |
+ * |---|---|---|
+ * | headings | `atxHeading`, `setextHeading` | `atxHeading` only |
+ * | code | `fence`, `indentedCode` | `fence` only |
+ * | breaks | single `\n` = soft break, blank line = separator | single `\n` = literal line break, blank line = empty paragraph |
+ * | everything else | same order | same order (lists, quotes, fences, thematic breaks, recognizers) |
+ *
+ * `setextHeading` and `indentedCode` are dropped in HardBreak so `text\n---`
+ * stays a paragraph run plus a thematic break and a 4-space indent is content,
+ * not code.
+ */
+@ExperimentalCascadeMarkdownApi
+public sealed interface NewlineSemantics {
+
+    /**
+     * CommonMark behavior: a single `\n` is a soft break (see [SoftBreak]),
+     * blank lines separate blocks and collapse, hard breaks encode per
+     * [HardBreakEncode]. Empty paragraph blocks are not encodable in this
+     * mode. Active block syntaxes include `setextHeading` and `indentedCode`.
+     * Default.
+     */
+    public data object CommonMark : NewlineSemantics
+
+    /**
+     * Chat-style dialect: every source newline inside a text leaf lowers to a
+     * literal `\n` in one paragraph-shaped leaf, embedded `\n` encodes as a
+     * plain newline (no `\`/two-space marker), and blank-line runs are
+     * represented explicitly — each blank line becomes one empty `Paragraph`
+     * block, so `N` empty paragraphs between two non-empty blocks encode to
+     * exactly `N + 1` newlines and trailing empties preserve trailing blank
+     * lines. `setextHeading` and `indentedCode` are removed from the active
+     * order. This is the mode that fixes the Moe Memos blank-line loss (#339)
+     * and numbered-continuation (#348) bug classes.
+     */
+    public data object HardBreak : NewlineSemantics
+}
+
+/**
+ * Decode-side policy for what a single `\n` inside a paragraph becomes under
+ * [NewlineSemantics.CommonMark].
+ */
+@ExperimentalCascadeMarkdownApi
+public sealed interface SoftBreak {
+
+    /** A soft break lowers to a single space. Default. */
+    public data object Space : SoftBreak
+
+    /** A soft break lowers to a literal `\n`. */
+    public data object LineBreak : SoftBreak
+}
+
+/**
+ * Encode-side policy for embedded `\n` in non-Code text blocks under
+ * [NewlineSemantics.CommonMark]. Decode accepts both forms
+ * regardless of this policy.
+ */
+@ExperimentalCascadeMarkdownApi
+public sealed interface HardBreakEncode {
+
+    /** Encode hard breaks as a trailing backslash. Survives whitespace trimming. Default. */
+    public data object Backslash : HardBreakEncode
+
+    /** Encode hard breaks as two trailing spaces. */
+    public data object TwoSpaces : HardBreakEncode
+}
+
+/**
+ * Policy that controls entity-reference decoding outside code spans and fenced
+ * code.
+ *
+ * The supported named-entity set is a documented subset, not the full HTML5
+ * table; numeric references decode fully. Unknown names stay literal text with
+ * an informational warning.
+ */
+@ExperimentalCascadeMarkdownApi
+public sealed interface EntityDecode {
+
+    /** Decode numeric references and the documented named subset. Default. */
+    public data object Standard : EntityDecode
+
+    /** Pass all entity references through as literal text. */
+    public data object None : EntityDecode
+}
diff --git a/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownProfile.kt b/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownProfile.kt
new file mode 100644
index 0000000..7b8f19e
--- /dev/null
+++ b/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownProfile.kt
@@ -0,0 +1,342 @@
+package io.github.linreal.cascade.editor.markdown
+
+import io.github.linreal.cascade.editor.core.Block
+import io.github.linreal.cascade.editor.core.BlockContent
+import io.github.linreal.cascade.editor.core.BlockType
+import io.github.linreal.cascade.editor.core.CustomBlockType
+import io.github.linreal.cascade.editor.core.SpanStyle
+import io.github.linreal.cascade.editor.htmlserialization.HtmlProfile
+import kotlin.reflect.KClass
+
+/**
+ * Configuration bundle that drives both encode and decode for the Markdown
+ * codec.
+ *
+ * `MarkdownProfile` is **immutable**: every `with*` / `without*` method returns
+ * a new profile instance and never mutates the receiver.
+ *
+ * Decode grammar is supplied by the internal JetBrains Markdown dependency;
+ * profiles configure Cascade-owned policies and the canonical writer. Encoder
+ * registration (class-keyed plus custom-typeId-keyed) matches the HTML codec's
+ * semantics. No registration call mutates [supportSet].
+ */
+@ExperimentalCascadeMarkdownApi
+public class MarkdownProfile internal constructor(
+    internal val blockEncoders: Map<KClass<out BlockType>, MarkdownBlockEncoder<*>>,
+    internal val customBlockEncoders: Map<String, MarkdownBlockEncoder<*>>,
+    internal val spanEncoders: Map<KClass<out SpanStyle>, MarkdownSpanEncoder<*>>,
+    internal val customSpanEncoders: Map<String, MarkdownSpanEncoder<SpanStyle.Custom>>,
+    internal val blockGroupEncoders: List<NamedMarkdownBlockGroupEncoder>,
+    internal val encoderBlockFallback: MarkdownBlockEncoder<BlockType>?,
+    internal val encoderSpanFallback: MarkdownSpanEncoder<SpanStyle>?,
+    internal val htmlInMarkdown: HtmlInMarkdown,
+    internal val unsupportedSyntax: UnsupportedSyntax,
+    internal val newlineSemantics: NewlineSemantics,
+    internal val softBreak: SoftBreak,
+    internal val hardBreakEncode: HardBreakEncode,
+    internal val entityDecode: EntityDecode,
+    public val supportSet: MarkdownProfileSupportSet,
+) {
+
+    // Built-in encoders (class-keyed)
+
+    /**
+     * Register [encoder] for the [BlockType] class `T`. Replaces any
+     * previously-registered encoder for the same class.
+     */
+    public inline fun <reified T : BlockType> withMarkdownBlockEncoder(
+        encoder: MarkdownBlockEncoder<T>,
+    ): MarkdownProfile = withMarkdownBlockEncoderInternal(T::class, encoder)
+
+    /**
+     * Register [encoder] for the [SpanStyle] class `T`. Replaces any
+     * previously-registered encoder for the same class.
+     */
+    public inline fun <reified T : SpanStyle> withMarkdownSpanEncoder(
+        encoder: MarkdownSpanEncoder<T>,
+    ): MarkdownProfile = withMarkdownSpanEncoderInternal(T::class, encoder)
+
+    @PublishedApi
+    internal fun withMarkdownBlockEncoderInternal(
+        typeClass: KClass<out BlockType>,
+        encoder: MarkdownBlockEncoder<*>,
+    ): MarkdownProfile = copyWith(blockEncoders = blockEncoders + (typeClass to encoder))
+
+    @PublishedApi
+    internal fun withMarkdownSpanEncoderInternal(
+        styleClass: KClass<out SpanStyle>,
+        encoder: MarkdownSpanEncoder<*>,
+    ): MarkdownProfile = copyWith(spanEncoders = spanEncoders + (styleClass to encoder))
+
+    // Custom-typed encoders (typeId-keyed)
+
+    /**
+     * Register a block encoder for a custom block type carried by either
+     * `block.type.typeId` (when the type implements [CustomBlockType]) or by
+     * `BlockContent.Custom.typeId`.
+     */
+    public fun withCustomMarkdownBlockEncoder(
+        typeId: String,
+        encoder: MarkdownBlockEncoder<*>,
+    ): MarkdownProfile =
+        copyWith(customBlockEncoders = customBlockEncoders + (typeId to encoder))
+
+    /** Register a span encoder for a [SpanStyle.Custom] keyed by `typeId`. */
+    public fun withCustomMarkdownSpanEncoder(
+        typeId: String,
+        encoder: MarkdownSpanEncoder<SpanStyle.Custom>,
+    ): MarkdownProfile =
+        copyWith(customSpanEncoders = customSpanEncoders + (typeId to encoder))
+
+    // Block group encoders
+
+    /**
+     * Register a group [encoder] under [name]. Group encoders keep
+     * registration order; re-registering a name removes the old registration
+     * and appends the new one at the tail.
+     */
+    public fun withMarkdownBlockGroupEncoder(
+        name: String,
+        encoder: MarkdownBlockGroupEncoder,
+    ): MarkdownProfile {
+        val withoutName = blockGroupEncoders.filterNot { it.name == name }
+        return copyWith(
+            blockGroupEncoders = withoutName + NamedMarkdownBlockGroupEncoder(name, encoder),
+        )
+    }
+
+    /** Remove the group encoder registered under [name], if any. */
+    public fun withoutMarkdownBlockGroupEncoder(name: String): MarkdownProfile =
+        copyWith(blockGroupEncoders = blockGroupEncoders.filterNot { it.name == name })
+
+    // Encode fallbacks
+
+    /** Set the block-level encode fallback invoked when no encoder matches. */
+    public fun withEncoderBlockFallback(fallback: MarkdownBlockEncoder<BlockType>): MarkdownProfile =
+        copyWith(encoderBlockFallback = fallback)
+
+    /** Set the span-level encode fallback invoked when no encoder matches. */
+    public fun withEncoderSpanFallback(fallback: MarkdownSpanEncoder<SpanStyle>): MarkdownProfile =
+        copyWith(encoderSpanFallback = fallback)
+
+    // Policies
+
+    /** Override the [HtmlInMarkdown] policy. */
+    public fun withHtmlInMarkdown(policy: HtmlInMarkdown): MarkdownProfile =
+        copyWith(htmlInMarkdown = policy).rebindDefaultDocumentClaim()
+
+    /**
+     * When a default-built support set is installed (its analyzer claim is
+     * present), rebind it to *this* profile so a policy change
+     * (newline/HTML) produces an honest claim resolved from the new policies,
+     * rather than a stale claim frozen against the profile that first built it.
+     * A custom [withSupportSet] set has no analyzer claim and is left as-is.
+     */
+    private fun rebindDefaultDocumentClaim(): MarkdownProfile {
+        if (supportSet.analyzerDocumentClaim == null) return this
+        return copyWith(supportSet = markdownDefaultSupportSet { this })
+    }
+
+    /** Override the [UnsupportedSyntax] policy. */
+    public fun withUnsupportedSyntax(policy: UnsupportedSyntax): MarkdownProfile =
+        copyWith(unsupportedSyntax = policy)
+
+    /** Override the [NewlineSemantics] policy. */
+    public fun withNewlineSemantics(policy: NewlineSemantics): MarkdownProfile =
+        copyWith(newlineSemantics = policy).rebindDefaultDocumentClaim()
+
+    /** Override the [SoftBreak] policy. */
+    public fun withSoftBreak(policy: SoftBreak): MarkdownProfile =
+        copyWith(softBreak = policy)
+
+    /** Override the [HardBreakEncode] policy. */
+    public fun withHardBreakEncode(policy: HardBreakEncode): MarkdownProfile =
+        copyWith(hardBreakEncode = policy)
+
+    /** Override the [EntityDecode] policy. */
+    public fun withEntityDecode(policy: EntityDecode): MarkdownProfile =
+        copyWith(entityDecode = policy)
+
+    /**
+     * Compose the strict, no-HTML opt-out. A strict profile can **never** emit
+     * raw HTML through any path. This method:
+     *
+     * - flips [HtmlInMarkdown] to [HtmlInMarkdown.WarnAndStrip] (embedded HTML
+     *   is stripped to inner text on decode, with a `DataLoss` warning);
+     * - unregisters the HTML-emitting span encoders (`Underline` → `<u>`,
+     *   `Highlight` → `<mark>`), so those styles degrade through the span
+     *   fallback instead;
+     * - replaces the `md.preservedHtml` and HTML-kind `md.preserved` verbatim
+     *   encoders so preserved raw HTML is dropped rather than re-emitted;
+     * - installs a no-HTML default support set (Underline/Highlight are not
+     *   claimed).
+     *
+     * ### Security
+     *
+     * The codec is not a sanitizer. A default profile can round-trip raw
+     * `<script>` verbatim; a strict `withoutHtmlBridge()` profile guarantees no
+     * raw HTML is emitted through span encoders, verbatim preserved blocks, the
+     * `md.preservedHtml` path, or the generic fallback. Hosts that render
+     * untrusted Markdown into a WebView should either sanitize at render time or
+     * adopt this profile.
+     *
+     * ### Call order
+     *
+     * Call this **before** a consumer's final [withSupportSet]: it installs its
+     * own strict support set, so a later `withSupportSet` (yours) wins, while a
+     * `withSupportSet` placed before this call would be overwritten.
+     */
+    public fun withoutHtmlBridge(): MarkdownProfile {
+        val strict = copyWith(
+            htmlInMarkdown = HtmlInMarkdown.WarnAndStrip,
+            spanEncoders = spanEncoders -
+                SpanStyle.Underline::class -
+                SpanStyle.Highlight::class,
+            customBlockEncoders = customBlockEncoders +
+                (MARKDOWN_PRESERVED_HTML_TYPE_ID to DefaultMarkdownBlockEncoders.StrictDropHtml) +
+                (MARKDOWN_PRESERVED_TYPE_ID to DefaultMarkdownBlockEncoders.StrictPreserved),
+        )
+        // The default claim resolves empty-text / HTML-span support from
+        // `strict` at call time (WarnAndStrip ⇒ no HTML spans claimed).
+        return strict.copyWith(supportSet = markdownDefaultSupportSet { strict })
+    }
+
+    // Support set
+
+    /**
+     * Replace the executable round-trip support claim exposed by [supportSet].
+     * Registrations never widen the claim implicitly — custom encoder profiles call
+     * this explicitly as their final composition step.
+     */
+    public fun withSupportSet(supportSet: MarkdownProfileSupportSet): MarkdownProfile =
+        copyWith(supportSet = supportSet)
+
+    // Internal lookup helpers used by the engines + contract tests.
+
+    /**
+     * Resolve the encoder for [block]. Custom block types and custom block
+     * contents are looked up by `typeId`; built-in types by class.
+     */
+    internal fun blockEncoderFor(block: Block): MarkdownBlockEncoder<*>? {
+        val type = block.type
+        if (type is CustomBlockType) {
+            customBlockEncoders[type.typeId]?.let { return it }
+        }
+        val content = block.content
+        if (content is BlockContent.Custom) {
+            customBlockEncoders[content.typeId]?.let { return it }
+        }
+        return blockEncoders[type::class]
+    }
+
+    /**
+     * Resolve the encoder for [style]. Custom span styles are looked up by
+     * `typeId`; built-in styles by class.
+     */
+    internal fun spanEncoderFor(style: SpanStyle): MarkdownSpanEncoder<*>? {
+        if (style is SpanStyle.Custom) return customSpanEncoders[style.typeId]
+        return spanEncoders[style::class]
+    }
+
+    private fun copyWith(
+        blockEncoders: Map<KClass<out BlockType>, MarkdownBlockEncoder<*>> = this.blockEncoders,
+        customBlockEncoders: Map<String, MarkdownBlockEncoder<*>> = this.customBlockEncoders,
+        spanEncoders: Map<KClass<out SpanStyle>, MarkdownSpanEncoder<*>> = this.spanEncoders,
+        customSpanEncoders: Map<String, MarkdownSpanEncoder<SpanStyle.Custom>> = this.customSpanEncoders,
+        blockGroupEncoders: List<NamedMarkdownBlockGroupEncoder> = this.blockGroupEncoders,
+        encoderBlockFallback: MarkdownBlockEncoder<BlockType>? = this.encoderBlockFallback,
+        encoderSpanFallback: MarkdownSpanEncoder<SpanStyle>? = this.encoderSpanFallback,
+        htmlInMarkdown: HtmlInMarkdown = this.htmlInMarkdown,
+        unsupportedSyntax: UnsupportedSyntax = this.unsupportedSyntax,
+        newlineSemantics: NewlineSemantics = this.newlineSemantics,
+        softBreak: SoftBreak = this.softBreak,
+        hardBreakEncode: HardBreakEncode = this.hardBreakEncode,
+        entityDecode: EntityDecode = this.entityDecode,
+        supportSet: MarkdownProfileSupportSet = this.supportSet,
+    ): MarkdownProfile = MarkdownProfile(
+        blockEncoders = blockEncoders,
+        customBlockEncoders = customBlockEncoders,
+        spanEncoders = spanEncoders,
+        customSpanEncoders = customSpanEncoders,
+        blockGroupEncoders = blockGroupEncoders,
+        encoderBlockFallback = encoderBlockFallback,
+        encoderSpanFallback = encoderSpanFallback,
+        htmlInMarkdown = htmlInMarkdown,
+        unsupportedSyntax = unsupportedSyntax,
+        newlineSemantics = newlineSemantics,
+        softBreak = softBreak,
+        hardBreakEncode = hardBreakEncode,
+        entityDecode = entityDecode,
+        supportSet = supportSet,
+    )
+
+    public companion object {
+
+        /**
+         * Default GFM-oriented profile.
+         *
+         * CommonMark/GFM recognition is provided by JetBrains Markdown. The
+         * adapter adds Cascade's conservative preservation recognizers and
+         * maps supported AST nodes into editor blocks and spans.
+         *
+         * Canonical encode defaults: class-keyed encoders
+         * for Paragraph/Heading/Quote/Code/Divider, the `listOutline` group
+         * encoder claiming `BulletList` + `NumberedList` + `Todo`, a verbatim
+         * `md.preserved` custom encoder, and warning-emitting block/span
+         * fallbacks.
+         *
+         * Policy defaults:
+         * [HtmlInMarkdown.Bridge] with [HtmlProfile.Default],
+         * [UnsupportedSyntax.Preserve], [NewlineSemantics.CommonMark],
+         * [SoftBreak.Space], [HardBreakEncode.Backslash],
+         * [EntityDecode.Standard].
+         */
+        public val Default: MarkdownProfile = MarkdownProfile(
+            blockEncoders = mapOf(
+                BlockType.Paragraph::class to DefaultMarkdownBlockEncoders.Paragraph,
+                BlockType.Heading::class to DefaultMarkdownBlockEncoders.Heading,
+                BlockType.Quote::class to DefaultMarkdownBlockEncoders.Quote,
+                BlockType.Code::class to DefaultMarkdownBlockEncoders.Code,
+                BlockType.Divider::class to DefaultMarkdownBlockEncoders.Divider,
+            ),
+            customBlockEncoders = mapOf(
+                MARKDOWN_PRESERVED_TYPE_ID to DefaultMarkdownBlockEncoders.Preserved,
+                // Block-level preserved HTML shares the verbatim encoder; a
+                // strict `withoutHtmlBridge()` profile replaces both so raw HTML
+                // can never be emitted.
+                MARKDOWN_PRESERVED_HTML_TYPE_ID to DefaultMarkdownBlockEncoders.Preserved,
+            ),
+            // HTML span encoders: Underline → <u>, Highlight →
+            // <mark data-cascade-highlight="…">. These make Underline/Highlight
+            // round-trip against the inline HTML bridge on the default profile.
+            spanEncoders = mapOf(
+                SpanStyle.Underline::class to MarkdownHtmlSpanEncoders.Underline,
+                SpanStyle.Highlight::class to MarkdownHtmlSpanEncoders.Highlight,
+            ),
+            customSpanEncoders = emptyMap(),
+            blockGroupEncoders = listOf(
+                NamedMarkdownBlockGroupEncoder("listOutline", DefaultMarkdownListOutlineEncoder),
+            ),
+            encoderBlockFallback = DefaultMarkdownEncoderFallbacks.Block,
+            encoderSpanFallback = DefaultMarkdownEncoderFallbacks.Span,
+            htmlInMarkdown = HtmlInMarkdown.Bridge(HtmlProfile.Default),
+            unsupportedSyntax = UnsupportedSyntax.Preserve,
+            newlineSemantics = NewlineSemantics.CommonMark,
+            softBreak = SoftBreak.Space,
+            hardBreakEncode = HardBreakEncode.Backslash,
+            entityDecode = EntityDecode.Standard,
+            // The default claim resolves empty-text-block / HTML-span support
+            // from the owning profile at call time and verifies candidates by
+            // encoding through it. The provider is lazy, so
+            // referencing `Default` here is safe: it is only dereferenced when
+            // `supportsDocument` is later called.
+            supportSet = markdownDefaultSupportSet { Default },
+        )
+    }
+}
+
+/** Internal carrier pairing a registered [MarkdownBlockGroupEncoder] with its name. */
+internal data class NamedMarkdownBlockGroupEncoder(
+    val name: String,
+    val encoder: MarkdownBlockGroupEncoder,
+)
diff --git a/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownProfileSupportSet.kt b/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownProfileSupportSet.kt
new file mode 100644
index 0000000..4003c4d
--- /dev/null
+++ b/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownProfileSupportSet.kt
@@ -0,0 +1,154 @@
+package io.github.linreal.cascade.editor.markdown
+
+import io.github.linreal.cascade.editor.core.Block
+import io.github.linreal.cascade.editor.core.BlockAttributes
+import io.github.linreal.cascade.editor.core.BlockContent
+import io.github.linreal.cascade.editor.core.BlockType
+import io.github.linreal.cascade.editor.core.SpanStyle
+
+/**
+ * Executable claim of which blocks, spans, and whole documents a
+ * [MarkdownProfile] commits to round-tripping through encode/decode.
+ *
+ * Public predicates remain replaceable so a custom profile can narrow the
+ * advertised surface. Fidelity analysis additionally verifies every claim by
+ * encoding and decoding the canonical output; a predicate can therefore narrow
+ * native-edit support, but cannot falsely widen it.
+ * [supportsBlockPredicate] receives the whole block, so custom support sets can
+ * still claim custom types or content explicitly.
+ */
+@ExperimentalCascadeMarkdownApi
+public class MarkdownProfileSupportSet(
+    public val supportsBlockPredicate: (Block) -> Boolean,
+    public val supportsSpanPredicate: (SpanStyle) -> Boolean,
+    public val supportsDocumentPredicate: (List<Block>) -> Boolean,
+) {
+
+    /** True when [block]'s type, attributes, and content are in the support set. */
+    public fun supportsBlock(block: Block): Boolean = supportsBlockPredicate(block)
+
+    /** True when [style] is in the profile's support set. */
+    public fun supportsSpan(style: SpanStyle): Boolean = supportsSpanPredicate(style)
+
+    /** True when the whole document is inside the profile's round-trip claim. */
+    public fun supportsDocument(blocks: List<Block>): Boolean = supportsDocumentPredicate(blocks)
+
+    /**
+     * Cheap claim used by `analyze` for the default set. The analyzer combines
+     * it with the canonical encode result and one verification decode, avoiding
+     * a duplicate encode. Custom support sets leave this null and retain their
+     * public document predicate as the narrowing hook.
+     */
+    internal var analyzerDocumentClaim: ((List<Block>) -> Boolean)? = null
+        private set
+
+    internal fun withAnalyzerClaim(claim: (List<Block>) -> Boolean): MarkdownProfileSupportSet {
+        analyzerDocumentClaim = claim
+        return this
+    }
+
+    public companion object {
+        /** Placeholder support set claiming nothing. */
+        public val None: MarkdownProfileSupportSet = MarkdownProfileSupportSet(
+            supportsBlockPredicate = { false },
+            supportsSpanPredicate = { false },
+            supportsDocumentPredicate = { false },
+        )
+    }
+}
+
+/** Build the default profile's value claims and executable document claim. */
+internal fun markdownDefaultSupportSet(
+    profileProvider: () -> MarkdownProfile,
+): MarkdownProfileSupportSet {
+    val blockClaim: (Block) -> Boolean = ::isDefaultSupportedBlock
+    val spanClaim: (SpanStyle) -> Boolean = { style ->
+        isDefaultSupportedSpan(style, profileProvider().htmlInMarkdown is HtmlInMarkdown.Bridge)
+    }
+    val shapeClaim: (List<Block>) -> Boolean = { blocks ->
+        blocks.all { block -> defaultContentShapeIsSupported(block, blockClaim, spanClaim) }
+    }
+    return MarkdownProfileSupportSet(
+        supportsBlockPredicate = blockClaim,
+        supportsSpanPredicate = spanClaim,
+        supportsDocumentPredicate = { blocks ->
+            if (!shapeClaim(blocks)) false
+            else {
+                val profile = profileProvider()
+                val encoded = MarkdownSchema.encodeWithReport(blocks, profile)
+                markdownRoundTripMatches(blocks, encoded, profile, MarkdownCodecLimits.Default)
+            }
+        },
+    ).withAnalyzerClaim(shapeClaim)
+}
+
+private fun isDefaultSupportedBlock(block: Block): Boolean {
+    val depth = block.attributes.indentationLevel
+    if (depth !in BlockAttributes.MIN_INDENTATION_LEVEL..BlockAttributes.MAX_INDENTATION_LEVEL) return false
+    return when (val type = block.type) {
+        BlockType.Paragraph -> true
+        is BlockType.Heading -> depth == BlockAttributes.MIN_INDENTATION_LEVEL && type.level in 1..6
+        BlockType.BulletList -> true
+        is BlockType.NumberedList -> type.number >= 1
+        is BlockType.Todo -> true
+        BlockType.Quote, BlockType.Code -> depth == BlockAttributes.MIN_INDENTATION_LEVEL
+        BlockType.Divider ->
+            depth == BlockAttributes.MIN_INDENTATION_LEVEL && block.content is BlockContent.Empty
+        else -> false
+    }
+}
+
+private fun isDefaultSupportedSpan(style: SpanStyle, claimHtmlSpans: Boolean): Boolean = when (style) {
+    SpanStyle.Bold,
+    SpanStyle.Italic,
+    SpanStyle.StrikeThrough,
+    SpanStyle.InlineCode -> true
+    SpanStyle.Underline -> claimHtmlSpans
+    is SpanStyle.Highlight -> claimHtmlSpans && style.colorArgb in 0L..0xFFFF_FFFFL
+    is SpanStyle.Link -> style.url.isNotBlank()
+    is SpanStyle.Custom -> false
+}
+
+private fun defaultContentShapeIsSupported(
+    block: Block,
+    blockClaim: (Block) -> Boolean,
+    spanClaim: (SpanStyle) -> Boolean,
+): Boolean {
+    if (!blockClaim(block)) return false
+    return when (val content = block.content) {
+        is BlockContent.Text -> {
+            block.type.supportsText &&
+                if (block.type.supportsSpans) content.spans.all { spanClaim(it.style) }
+                else content.spans.isEmpty()
+        }
+        BlockContent.Empty -> !block.type.supportsText
+        is BlockContent.Custom -> false
+    }
+}
+
+/** True only when canonical output decodes to the same editor model, ignoring generated ids. */
+internal fun markdownRoundTripMatches(
+    blocks: List<Block>,
+    encoded: MarkdownEncodeResult,
+    profile: MarkdownProfile,
+    limits: MarkdownCodecLimits,
+): Boolean {
+    val markdown = encoded.markdown ?: return false
+    if (encoded.warnings.any(MarkdownWarning::blocksNativeEditing)) return false
+    val decoded = MarkdownSchema.decodeWithReport(markdown, profile, limits)
+    val decodedBlocks = decoded.blocks ?: return false
+    if (decoded.warnings.any(MarkdownWarning::blocksNativeEditing)) return false
+    return markdownModelsEqual(blocks, decodedBlocks)
+}
+
+private fun MarkdownWarning.blocksNativeEditing(): Boolean =
+    impact == MarkdownFidelityImpact.OpaquePreservation ||
+        impact == MarkdownFidelityImpact.DataLoss ||
+        impact == MarkdownFidelityImpact.Fatal
+
+internal fun markdownModelsEqual(expected: List<Block>, actual: List<Block>): Boolean =
+    expected.size == actual.size && expected.indices.all { index ->
+        val left = expected[index]
+        val right = actual[index]
+        left.type == right.type && left.content == right.content && left.attributes == right.attributes
+    }
diff --git a/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownResults.kt b/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownResults.kt
new file mode 100644
index 0000000..a35713d
--- /dev/null
+++ b/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownResults.kt
@@ -0,0 +1,152 @@
+package io.github.linreal.cascade.editor.markdown
+
+import io.github.linreal.cascade.editor.core.Block
+
+/**
+ * Outcome status of a Markdown codec operation.
+ *
+ * Status is always explicit: an empty block list and an empty output string are
+ * both valid [Success] payloads, so abort must never be inferred from payload
+ * emptiness — only from [Aborted].
+ */
+@ExperimentalCascadeMarkdownApi
+public enum class MarkdownCodecStatus {
+    Success,
+    Aborted,
+}
+
+/**
+ * Result of a Markdown decode.
+ *
+ * [blocks] is non-null exactly when [status] is [MarkdownCodecStatus.Success];
+ * a partial payload is never representable. An aborted result always carries at
+ * least one [MarkdownFidelityImpact.Fatal] warning explaining the abort.
+ *
+ * Warning [MarkdownDecodeWarning.range]s resolve to line/column positions in
+ * the original input through [sourceLocator].
+ */
+@ExperimentalCascadeMarkdownApi
+public class MarkdownDecodeResult private constructor(
+    public val status: MarkdownCodecStatus,
+    public val blocks: List<Block>?,
+    public val warnings: List<MarkdownDecodeWarning>,
+    public val sourceLocator: MarkdownSourceLocator,
+) {
+
+    public val isSuccess: Boolean get() = status == MarkdownCodecStatus.Success
+
+    public val isAborted: Boolean get() = status == MarkdownCodecStatus.Aborted
+
+    override fun toString(): String =
+        "MarkdownDecodeResult(status=$status, blocks=${blocks?.size}, warnings=${warnings.size})"
+
+    public companion object {
+
+        /**
+         * A completed decode. [blocks] may be empty — empty input decodes to an
+         * empty, successful payload, never to an abort. Rejects
+         * [MarkdownFidelityImpact.Fatal] warnings: a Fatal impact means the
+         * operation aborted, which is only representable through [aborted].
+         */
+        public fun success(
+            blocks: List<Block>,
+            warnings: List<MarkdownDecodeWarning> = emptyList(),
+            sourceLocator: MarkdownSourceLocator = emptyLocator(),
+        ): MarkdownDecodeResult {
+            require(warnings.none { it.impact == MarkdownFidelityImpact.Fatal }) {
+                "A successful decode result cannot carry Fatal-impact warnings"
+            }
+            return MarkdownDecodeResult(
+                status = MarkdownCodecStatus.Success,
+                blocks = blocks,
+                warnings = warnings,
+                sourceLocator = sourceLocator,
+            )
+        }
+
+        /**
+         * An aborted decode. Requires at least one
+         * [MarkdownFidelityImpact.Fatal] warning; the payload is always null.
+         */
+        public fun aborted(
+            warnings: List<MarkdownDecodeWarning>,
+            sourceLocator: MarkdownSourceLocator = emptyLocator(),
+        ): MarkdownDecodeResult {
+            require(warnings.any { it.impact == MarkdownFidelityImpact.Fatal }) {
+                "An aborted decode result must carry at least one Fatal-impact warning"
+            }
+            return MarkdownDecodeResult(
+                status = MarkdownCodecStatus.Aborted,
+                blocks = null,
+                warnings = warnings,
+                sourceLocator = sourceLocator,
+            )
+        }
+
+        private fun emptyLocator(): MarkdownSourceLocator =
+            MarkdownSourceLocator(lineContentStarts = IntArray(0), lastContentEnd = 0)
+    }
+}
+
+/**
+ * Result of a Markdown encode.
+ *
+ * [markdown] is non-null exactly when [status] is
+ * [MarkdownCodecStatus.Success]; a partial payload is never representable. An
+ * aborted result always carries at least one [MarkdownFidelityImpact.Fatal]
+ * warning explaining the abort.
+ */
+@ExperimentalCascadeMarkdownApi
+public class MarkdownEncodeResult private constructor(
+    public val status: MarkdownCodecStatus,
+    public val markdown: String?,
+    public val warnings: List<MarkdownEncodeWarning>,
+) {
+
+    public val isSuccess: Boolean get() = status == MarkdownCodecStatus.Success
+
+    public val isAborted: Boolean get() = status == MarkdownCodecStatus.Aborted
+
+    override fun toString(): String =
+        "MarkdownEncodeResult(status=$status, markdown=${markdown?.length}, warnings=${warnings.size})"
+
+    public companion object {
+
+        /**
+         * A completed encode. [markdown] may be empty — an empty document
+         * encodes to an empty, successful payload, never to an abort. Rejects
+         * [MarkdownFidelityImpact.Fatal] warnings: a Fatal impact means the
+         * operation aborted, which is only representable through [aborted].
+         */
+        public fun success(
+            markdown: String,
+            warnings: List<MarkdownEncodeWarning> = emptyList(),
+        ): MarkdownEncodeResult {
+            require(warnings.none { it.impact == MarkdownFidelityImpact.Fatal }) {
+                "A successful encode result cannot carry Fatal-impact warnings"
+            }
+            return MarkdownEncodeResult(
+                status = MarkdownCodecStatus.Success,
+                markdown = markdown,
+                warnings = warnings,
+            )
+        }
+
+        /**
+         * An aborted encode. Requires at least one
+         * [MarkdownFidelityImpact.Fatal] warning; the payload is always null.
+         */
+        public fun aborted(
+            warnings: List<MarkdownEncodeWarning>,
+        ): MarkdownEncodeResult {
+            require(warnings.any { it.impact == MarkdownFidelityImpact.Fatal }) {
+                "An aborted encode result must carry at least one Fatal-impact warning"
+            }
+            return MarkdownEncodeResult(
+                status = MarkdownCodecStatus.Aborted,
+                markdown = null,
+                warnings = warnings,
+            )
+        }
+    }
+}
diff --git a/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownSchema.kt b/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownSchema.kt
new file mode 100644
index 0000000..6e91887
--- /dev/null
+++ b/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownSchema.kt
@@ -0,0 +1,109 @@
+package io.github.linreal.cascade.editor.markdown
+
+import io.github.linreal.cascade.editor.core.Block
+import kotlin.coroutines.cancellation.CancellationException
+
+/**
+ * Public entry point for Markdown import/export.
+ *
+ * Mirrors [io.github.linreal.cascade.editor.htmlserialization.HtmlSchema] and
+ * `DocumentSchema`: a stateless, synchronous, thread-agnostic object with
+ * `encode` / `decode` conveniences (nullable payload — `null` only when the
+ * operation aborted) and `*WithReport` variants that surface warnings through
+ * [MarkdownEncodeResult] / [MarkdownDecodeResult]. Every path takes an explicit
+ * [MarkdownCodecLimits]; [analyze] assembles a [MarkdownFidelityReport] for the
+ * host edit-mode gate.
+ *
+ * ### No-throw boundary
+ *
+ * This object is the codec's public no-throw boundary. Consumer encoders that
+ * throw are already contained inside the encode engine and surface as warnings;
+ * any *unexpected* exception that still escapes the internal pipeline
+ * is caught here and converted into an aborted result with a
+ * [MarkdownDecodeWarning.EngineFailure] / [MarkdownEncodeWarning.EngineFailure]
+ * (both [MarkdownFidelityImpact.Fatal]) — the codec never lets an exception
+ * cross into caller code.
+ *
+ * ### Threading
+ *
+ * All entry points are pure and stateless. Decode, encode, and especially
+ * [analyze] (decode + encode) can be non-trivial for large inputs; hosts should
+ * run them off the main thread and apply the result on the UI thread (see
+ * `MarkdownSerializationExt`).
+ */
+@ExperimentalCascadeMarkdownApi
+public object MarkdownSchema {
+
+    /**
+     * Encode [blocks] to a Markdown string using [profile]. Returns `null` only
+     * when the encode aborted (output/warning limit); an empty document encodes
+     * to an empty, non-null string.
+     */
+    public fun encode(
+        blocks: List<Block>,
+        profile: MarkdownProfile = MarkdownProfile.Default,
+        limits: MarkdownCodecLimits = MarkdownCodecLimits.Default,
+        lineEnding: MarkdownLineEnding = MarkdownLineEnding.Lf,
+    ): String? = encodeWithReport(blocks, profile, limits, lineEnding).markdown
+
+    /** Encode [blocks] to Markdown using [profile], returning warnings. */
+    public fun encodeWithReport(
+        blocks: List<Block>,
+        profile: MarkdownProfile = MarkdownProfile.Default,
+        limits: MarkdownCodecLimits = MarkdownCodecLimits.Default,
+        lineEnding: MarkdownLineEnding = MarkdownLineEnding.Lf,
+    ): MarkdownEncodeResult = try {
+        MarkdownEncodeEngine.encodeWithReport(blocks, profile, limits, lineEnding)
+    } catch (e: CancellationException) {
+        throw e
+    } catch (e: Exception) {
+        MarkdownEncodeResult.aborted(
+            listOf(MarkdownEncodeWarning.EngineFailure(engineFailureMessage(e))),
+        )
+    }
+
+    /**
+     * Decode [markdown] to blocks using [profile]. Returns `null` only when the
+     * decode aborted (input/nesting/limit exhaustion); empty input decodes to a
+     * non-null empty block list.
+     */
+    public fun decode(
+        markdown: String,
+        profile: MarkdownProfile = MarkdownProfile.Default,
+        limits: MarkdownCodecLimits = MarkdownCodecLimits.Default,
+    ): List<Block>? = decodeWithReport(markdown, profile, limits).blocks
+
+    /** Decode [markdown] to blocks using [profile], returning warnings. */
+    public fun decodeWithReport(
+        markdown: String,
+        profile: MarkdownProfile = MarkdownProfile.Default,
+        limits: MarkdownCodecLimits = MarkdownCodecLimits.Default,
+    ): MarkdownDecodeResult = try {
+        MarkdownDecodeEngine.decode(markdown, profile, limits)
+    } catch (e: CancellationException) {
+        throw e
+    } catch (e: Exception) {
+        MarkdownDecodeResult.aborted(
+            listOf(MarkdownDecodeWarning.EngineFailure(engineFailureMessage(e))),
+        )
+    }
+
+    /**
+     * Assess whether [markdown] can be edited natively under [profile]. Runs
+     * decode, then — on success — encode, and assembles a
+     * [MarkdownFidelityReport]. This is the most expensive call (decode +
+     * encode); run it off the main thread.
+     *
+     * Hosts keep the original [markdown] string. Opening, analyzing, or
+     * read-only rendering must never persist canonical output: only a
+     * user-initiated save writes back, gated on this report.
+     */
+    public fun analyze(
+        markdown: String,
+        profile: MarkdownProfile = MarkdownProfile.Default,
+        limits: MarkdownCodecLimits = MarkdownCodecLimits.Default,
+    ): MarkdownFidelityReport = MarkdownFidelityAnalyzer.analyze(markdown, profile, limits)
+
+    private fun engineFailureMessage(e: Exception): String =
+        e.message ?: (e::class.simpleName ?: "unexpected engine failure")
+}
diff --git a/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownSerializationExt.kt b/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownSerializationExt.kt
new file mode 100644
index 0000000..92832ed
--- /dev/null
+++ b/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownSerializationExt.kt
@@ -0,0 +1,124 @@
+package io.github.linreal.cascade.editor.markdown
+
+import io.github.linreal.cascade.editor.core.Block
+import io.github.linreal.cascade.editor.core.BlockContent
+import io.github.linreal.cascade.editor.core.BlockType
+import io.github.linreal.cascade.editor.serialization.resolveCurrentBlocks
+import io.github.linreal.cascade.editor.state.BlockSpanStates
+import io.github.linreal.cascade.editor.state.BlockTextStates
+import io.github.linreal.cascade.editor.state.EditorState
+import io.github.linreal.cascade.editor.state.EditorStateHolder
+
+/**
+ * Serialize the current editor state to Markdown using [profile]. Returns
+ * `null` only when the encode aborted; discards warnings.
+ *
+ * Runtime text/span state takes priority over snapshot content, matching the
+ * JSON/HTML export paths.
+ */
+@ExperimentalCascadeMarkdownApi
+public fun EditorStateHolder.toMarkdown(
+    textStates: BlockTextStates,
+    spanStates: BlockSpanStates,
+    profile: MarkdownProfile = MarkdownProfile.Default,
+    limits: MarkdownCodecLimits = MarkdownCodecLimits.Default,
+    lineEnding: MarkdownLineEnding = MarkdownLineEnding.Lf,
+): String? = toMarkdownWithReport(textStates, spanStates, profile, limits, lineEnding).markdown
+
+/**
+ * Serialize the current editor state to Markdown using [profile], returning the
+ * full [MarkdownEncodeResult].
+ *
+ * The synthetic trailing editor scaffold is handled per mode:
+ * in CommonMark mode a single depth-0, span-free empty trailing paragraph is
+ * dropped when it is the sole block or follows a non-text block (divider,
+ * custom); in HardBreak mode every trailing empty paragraph is retained because
+ * it carries a meaningful blank line.
+ */
+@ExperimentalCascadeMarkdownApi
+public fun EditorStateHolder.toMarkdownWithReport(
+    textStates: BlockTextStates,
+    spanStates: BlockSpanStates,
+    profile: MarkdownProfile = MarkdownProfile.Default,
+    limits: MarkdownCodecLimits = MarkdownCodecLimits.Default,
+    lineEnding: MarkdownLineEnding = MarkdownLineEnding.Lf,
+): MarkdownEncodeResult {
+    val resolved = resolveCurrentBlocks(this, textStates, spanStates)
+    val trimmed = stripTrailingEditorScaffold(resolved, profile)
+    return MarkdownSchema.encodeWithReport(trimmed, profile, limits, lineEnding)
+}
+
+/**
+ * Decode [markdown] with [profile] and replace the editor document with the
+ * result — but only after a non-aborted decode.
+ *
+ * On success the runtime holders are cleared, `setState` replaces the document
+ * (resetting focus, selection, transient UI state, and undo/redo history like
+ * every hard load), and the successful result is returned. On abort
+ * ([MarkdownDecodeWarning.InputLimitExceeded], output/warning limit exhaustion,
+ * or an engine-fatal result) the current document and history are left
+ * untouched and the aborted report is returned.
+ *
+ * App-owned import is not gated by read-only mode (consistent with the
+ * documented read-only boundary).
+ */
+@ExperimentalCascadeMarkdownApi
+public fun EditorStateHolder.loadFromMarkdown(
+    markdown: String,
+    textStates: BlockTextStates,
+    spanStates: BlockSpanStates,
+    profile: MarkdownProfile = MarkdownProfile.Default,
+    limits: MarkdownCodecLimits = MarkdownCodecLimits.Default,
+): MarkdownDecodeResult {
+    val result = MarkdownSchema.decodeWithReport(markdown, profile, limits)
+    if (result.isSuccess) {
+        applyMarkdownDecodeResult(result, textStates, spanStates)
+    }
+    return result
+}
+
+/**
+ * Apply an already-decoded, successful [result] as a hard document replacement.
+ *
+ * Hosts decode/analyze off the UI thread and call this on the UI thread to
+ * perform only the final state swap. An aborted result is rejected with an
+ * [IllegalArgumentException] — the payload would be `null`, and aborting must
+ * never mutate the current document.
+ */
+@ExperimentalCascadeMarkdownApi
+public fun EditorStateHolder.applyMarkdownDecodeResult(
+    result: MarkdownDecodeResult,
+    textStates: BlockTextStates,
+    spanStates: BlockSpanStates,
+) {
+    val blocks = result.blocks
+    require(blocks != null) {
+        "applyMarkdownDecodeResult requires a successful (non-aborted) decode result"
+    }
+    textStates.clear()
+    spanStates.clear()
+    setState(EditorState.withBlocks(blocks))
+}
+
+private fun stripTrailingEditorScaffold(
+    blocks: List<Block>,
+    profile: MarkdownProfile,
+): List<Block> {
+    if (profile.newlineSemantics == NewlineSemantics.HardBreak) return blocks
+    if (blocks.isEmpty()) return blocks
+
+    val last = blocks.last()
+    val content = last.content
+    val isEmptyTrailingParagraph = last.type == BlockType.Paragraph &&
+        last.attributes.indentationLevel == 0 &&
+        content is BlockContent.Text &&
+        content.text.isEmpty() &&
+        content.spans.isEmpty()
+    if (!isEmptyTrailingParagraph) return blocks
+
+    // Sole block, or the preceding block is non-text (divider/custom): the
+    // trailing empty paragraph is the editor's cursor scaffold, not content.
+    if (blocks.size == 1) return emptyList()
+    val previous = blocks[blocks.size - 2]
+    return if (!previous.type.supportsText) blocks.dropLast(1) else blocks
+}
diff --git a/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownSourceRange.kt b/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownSourceRange.kt
new file mode 100644
index 0000000..b352e61
--- /dev/null
+++ b/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownSourceRange.kt
@@ -0,0 +1,99 @@
+package io.github.linreal.cascade.editor.markdown
+
+/**
+ * Half-open range of UTF-16 code units in the original Markdown source `String`.
+ *
+ * `start` is inclusive, [endExclusive] is exclusive. Ranges always address the
+ * original string handed to decode — never a normalized copy — so
+ * `source.substring(range.start, range.endExclusive)` reproduces the covered
+ * source characters exactly (including line terminators and a leading BOM when
+ * the range spans them).
+ *
+ * Byte offsets, file encodings, and filesystem metadata are outside the codec:
+ * "verbatim" always means UTF-16 source-slice equality.
+ */
+@ExperimentalCascadeMarkdownApi
+public data class MarkdownSourceRange(
+    val start: Int,
+    val endExclusive: Int,
+) {
+    init {
+        require(start >= 0) { "start must be >= 0, was $start" }
+        require(endExclusive >= start) {
+            "endExclusive ($endExclusive) must be >= start ($start)"
+        }
+    }
+
+    /** Number of UTF-16 code units covered by this range. */
+    public val length: Int get() = endExclusive - start
+
+    /** True when the range covers no characters. */
+    public val isEmpty: Boolean get() = start == endExclusive
+}
+
+/**
+ * 1-based line/column position in the original Markdown source.
+ *
+ * Columns count UTF-16 code units from the first content character of the
+ * logical line. A leading U+FEFF BOM is not part of line 1's content: line 1
+ * column 1 addresses the first character after the BOM.
+ */
+@ExperimentalCascadeMarkdownApi
+public data class MarkdownSourceLocation(
+    val line: Int,
+    val column: Int,
+) {
+    init {
+        require(line >= 1) { "line must be >= 1, was $line" }
+        require(column >= 1) { "column must be >= 1, was $column" }
+    }
+}
+
+/**
+ * Resolves UTF-16 offsets and [MarkdownSourceRange]s in the original source to
+ * 1-based [MarkdownSourceLocation]s.
+ *
+ * Instances are produced by the codec (attached to decode results) — consumers
+ * never construct one directly. Offsets are clamped defensively: negative
+ * offsets resolve to line 1 column 1, offsets at or past end of input resolve
+ * to the position just past the last line's content.
+ */
+@ExperimentalCascadeMarkdownApi
+public class MarkdownSourceLocator internal constructor(
+    /** Offset where each logical line's content starts (terminators excluded). */
+    private val lineContentStarts: IntArray,
+    /** Offset where the last logical line's content ends (terminator excluded). */
+    private val lastContentEnd: Int,
+) {
+
+    /** Resolve a single UTF-16 offset in the original source. */
+    public fun locate(offset: Int): MarkdownSourceLocation {
+        if (lineContentStarts.isEmpty()) return MarkdownSourceLocation(line = 1, column = 1)
+
+        val clamped = offset.coerceIn(0, lastContentEnd)
+        val lineIndex = lineIndexFor(clamped)
+        val column = (clamped - lineContentStarts[lineIndex] + 1).coerceAtLeast(1)
+        return MarkdownSourceLocation(line = lineIndex + 1, column = column)
+    }
+
+    /** Resolve the start position of [range] in the original source. */
+    public fun locate(range: MarkdownSourceRange): MarkdownSourceLocation = locate(range.start)
+
+    private fun lineIndexFor(offset: Int): Int {
+        // Largest index whose content start is <= offset. Offsets before the first
+        // content start (a leading BOM) belong to line 1.
+        var low = 0
+        var high = lineContentStarts.size - 1
+        var result = 0
+        while (low <= high) {
+            val mid = (low + high) ushr 1
+            if (lineContentStarts[mid] <= offset) {
+                result = mid
+                low = mid + 1
+            } else {
+                high = mid - 1
+            }
+        }
+        return result
+    }
+}
diff --git a/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownWarnings.kt b/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownWarnings.kt
new file mode 100644
index 0000000..1d12302
--- /dev/null
+++ b/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownWarnings.kt
@@ -0,0 +1,329 @@
+package io.github.linreal.cascade.editor.markdown
+
+import io.github.linreal.cascade.editor.core.BlockId
+
+/**
+ * Fidelity impact classification carried by every Markdown codec warning.
+ *
+ * `analyze` and host save guards classify results by impact alone — never by
+ * hard-coded warning-subclass lists — so the classification below is the
+ * contract each warning member commits to:
+ *
+ * | Impact | Meaning | Examples |
+ * |---|---|---|
+ * | [Informational] | Nothing was lost or hidden; purely advisory. | successful `HtmlBridged`, an unsupported entity name kept as literal text |
+ * | [Canonicalization] | Semantics identical, spelling/trivia would change on re-encode (line endings, marker spelling, final newline). Never forces raw fallback on its own. | canonical bullet/heading spelling notes |
+ * | [OpaquePreservation] | Content survives character-exactly but as an opaque, non-natively-editable block. | `PreservedSyntax` for tables, front matter, math, footnotes, images |
+ * | [DataLoss] | Content or metadata was altered or dropped; a re-decode would not reproduce the input. | `UnsupportedSyntax` degradation, `HtmlStripped`, `DroppedSpanOverlap`, `AmbiguousEmphasis`, dropped attributes, encoder fallbacks |
+ * | [Fatal] | The operation aborted; the result carries no payload. | input/output/nesting/block/span/definition/delimiter/warning limit exhaustion, engine failure |
+ */
+@ExperimentalCascadeMarkdownApi
+public enum class MarkdownFidelityImpact {
+    Informational,
+    Canonicalization,
+    OpaquePreservation,
+    DataLoss,
+    Fatal,
+}
+
+/**
+ * Common supertype of [MarkdownDecodeWarning] and [MarkdownEncodeWarning] so
+ * impact-driven consumers (e.g. `analyze`) can classify warnings from both
+ * directions uniformly.
+ */
+@ExperimentalCascadeMarkdownApi
+public sealed interface MarkdownWarning {
+    /** Fidelity impact this warning commits to. See [MarkdownFidelityImpact]. */
+    public val impact: MarkdownFidelityImpact
+}
+
+/**
+ * Half-open UTF-16 range into a block's visible text, used by encode warnings
+ * to point at the responsible text/span region. Unlike [MarkdownSourceRange]
+ * this addresses editor block text, not a Markdown source string.
+ */
+@ExperimentalCascadeMarkdownApi
+public data class MarkdownTextRange(
+    val start: Int,
+    val endExclusive: Int,
+) {
+    init {
+        require(start >= 0) { "start must be >= 0, was $start" }
+        require(endExclusive >= start) {
+            "endExclusive ($endExclusive) must be >= start ($start)"
+        }
+    }
+}
+
+/**
+ * The codec limit a [MarkdownDecodeWarning.LimitExceeded] /
+ * [MarkdownEncodeWarning.LimitExceeded] warning refers to.
+ */
+@ExperimentalCascadeMarkdownApi
+public enum class MarkdownCodecLimitKind {
+    BlockNesting,
+    Blocks,
+    SpansPerBlock,
+    TotalSpans,
+    ReferenceDefinitions,
+    DelimiterRuns,
+    Warnings,
+}
+
+/**
+ * Warnings emitted while decoding Markdown.
+ *
+ * Every decode warning carries a [range]: a half-open UTF-16
+ * [MarkdownSourceRange] into the original input string, resolvable to
+ * line/column through the result's [MarkdownSourceLocator].
+ *
+ * This hierarchy is open by design — later codec phases add members. Consumers
+ * should include an `else` branch in `when` expressions and prefer classifying
+ * by [impact] rather than by concrete subclass.
+ */
+@ExperimentalCascadeMarkdownApi
+public sealed class MarkdownDecodeWarning : MarkdownWarning {
+
+    /** Source range of the construct responsible for the warning. */
+    public abstract val range: MarkdownSourceRange
+
+    /**
+     * A construct the editor cannot model decoded through ordinary syntaxes
+     * with degraded content (the `UnsupportedSyntax.WarnAndDegrade` path).
+     */
+    public data class UnsupportedSyntax(
+        val construct: String,
+        val detail: String,
+        override val range: MarkdownSourceRange,
+    ) : MarkdownDecodeWarning() {
+        override val impact: MarkdownFidelityImpact get() = MarkdownFidelityImpact.DataLoss
+    }
+
+    /**
+     * A construct was preserved character-exactly as an opaque `md.preserved`
+     * block (the `UnsupportedSyntax.Preserve` path).
+     */
+    public data class PreservedSyntax(
+        val kind: String,
+        override val range: MarkdownSourceRange,
+    ) : MarkdownDecodeWarning() {
+        override val impact: MarkdownFidelityImpact get() = MarkdownFidelityImpact.OpaquePreservation
+    }
+
+    /** Embedded HTML decoded successfully through the HTML bridge. */
+    public data class HtmlBridged(
+        override val range: MarkdownSourceRange,
+    ) : MarkdownDecodeWarning() {
+        override val impact: MarkdownFidelityImpact get() = MarkdownFidelityImpact.Informational
+    }
+
+    /** Embedded HTML tags were dropped (inner text kept) under a strip policy. */
+    public data class HtmlStripped(
+        val tag: String?,
+        override val range: MarkdownSourceRange,
+    ) : MarkdownDecodeWarning() {
+        override val impact: MarkdownFidelityImpact get() = MarkdownFidelityImpact.DataLoss
+    }
+
+    /**
+     * Source metadata that has no editor representation was dropped
+     * (e.g. clamped indentation depth, dropped link title under degrade).
+     */
+    public data class DroppedAttribute(
+        val construct: String,
+        val attr: String,
+        val reason: String,
+        override val range: MarkdownSourceRange,
+    ) : MarkdownDecodeWarning() {
+        override val impact: MarkdownFidelityImpact get() = MarkdownFidelityImpact.DataLoss
+    }
+
+    /**
+     * A link-reference definition whose label was already defined; the first
+     * definition wins (CommonMark) and the shadowed duplicate is dropped.
+     * Semantics are unchanged — CommonMark lookup is defined as
+     * first-definition-wins — but a re-encode would not reproduce the
+     * shadowed line, hence [MarkdownFidelityImpact.Canonicalization].
+     */
+    public data class DuplicateLinkDefinition(
+        val label: String,
+        override val range: MarkdownSourceRange,
+    ) : MarkdownDecodeWarning() {
+        override val impact: MarkdownFidelityImpact get() = MarkdownFidelityImpact.Canonicalization
+    }
+
+    /**
+     * A named entity reference outside the documented supported subset was
+     * kept as literal text. Nothing is lost — the character data is retained
+     * exactly — so this never trips the raw-fallback gate on its own.
+     */
+    public data class UnsupportedEntity(
+        val name: String,
+        override val range: MarkdownSourceRange,
+    ) : MarkdownDecodeWarning() {
+        override val impact: MarkdownFidelityImpact get() = MarkdownFidelityImpact.Informational
+    }
+
+    /** Input exceeded [MarkdownCodecLimits.maxInputChars]; the decode aborted. */
+    public data class InputLimitExceeded(
+        val limit: Int,
+        val actual: Int,
+        override val range: MarkdownSourceRange = MarkdownSourceRange(0, 0),
+    ) : MarkdownDecodeWarning() {
+        override val impact: MarkdownFidelityImpact get() = MarkdownFidelityImpact.Fatal
+    }
+
+    /**
+     * A decode resource limit ([kind]) was exhausted; the decode aborted.
+     * [MarkdownCodecLimitKind.Warnings] exhaustion is reported through exactly
+     * one such warning appended after the retained warnings, so the list stays
+     * bounded.
+     */
+    public data class LimitExceeded(
+        val kind: MarkdownCodecLimitKind,
+        val limit: Int,
+        override val range: MarkdownSourceRange,
+    ) : MarkdownDecodeWarning() {
+        override val impact: MarkdownFidelityImpact get() = MarkdownFidelityImpact.Fatal
+    }
+
+    /**
+     * An unexpected engine failure crossed the internal pipeline and was caught
+     * at the public `MarkdownSchema` boundary. The decode aborted with no
+     * payload; this is the last-resort net that keeps the codec no-throw.
+     */
+    public data class EngineFailure(
+        val message: String,
+        override val range: MarkdownSourceRange = MarkdownSourceRange(0, 0),
+    ) : MarkdownDecodeWarning() {
+        override val impact: MarkdownFidelityImpact get() = MarkdownFidelityImpact.Fatal
+    }
+}
+
+/**
+ * Warnings emitted while encoding blocks to Markdown.
+ *
+ * Encode warnings carry the responsible [blockId] when a specific block is
+ * responsible, plus an optional [textRange] into that block's visible text for
+ * inline losses. A lone `typeId` is deliberately not the addressing scheme — it
+ * is not actionable when a document contains many blocks of the same type.
+ *
+ * This hierarchy is open by design — later codec phases add members. Consumers
+ * should include an `else` branch in `when` expressions and prefer classifying
+ * by [impact] rather than by concrete subclass.
+ */
+@ExperimentalCascadeMarkdownApi
+public sealed class MarkdownEncodeWarning : MarkdownWarning {
+
+    /** Id of the block responsible for the warning, when one is. */
+    public abstract val blockId: BlockId?
+
+    /** Optional range into the responsible block's visible text. */
+    public abstract val textRange: MarkdownTextRange?
+
+    /**
+     * Emitted delimiter runs re-parsed to different spans than were encoded;
+     * the weaker span was dropped to keep the output honest.
+     */
+    public data class AmbiguousEmphasis(
+        override val blockId: BlockId?,
+        override val textRange: MarkdownTextRange?,
+    ) : MarkdownEncodeWarning() {
+        override val impact: MarkdownFidelityImpact get() = MarkdownFidelityImpact.DataLoss
+    }
+
+    /**
+     * A span overlapping an inline-code range (or otherwise unrepresentable
+     * overlap residue) was dropped.
+     */
+    public data class DroppedSpanOverlap(
+        override val blockId: BlockId?,
+        override val textRange: MarkdownTextRange?,
+        val reason: String,
+    ) : MarkdownEncodeWarning() {
+        override val impact: MarkdownFidelityImpact get() = MarkdownFidelityImpact.DataLoss
+    }
+
+    /**
+     * A block attribute (e.g. paragraph `indentationLevel`) was dropped because
+     * canonical Markdown has no encoding for it.
+     */
+    public data class DroppedAttribute(
+        val attr: String,
+        val reason: String,
+        override val blockId: BlockId?,
+        override val textRange: MarkdownTextRange? = null,
+    ) : MarkdownEncodeWarning() {
+        override val impact: MarkdownFidelityImpact get() = MarkdownFidelityImpact.DataLoss
+    }
+
+    /** A block with no registered encoder fell back to a plain paragraph. */
+    public data class UnsupportedBlock(
+        val typeId: String?,
+        val reason: String,
+        override val blockId: BlockId?,
+        override val textRange: MarkdownTextRange? = null,
+    ) : MarkdownEncodeWarning() {
+        override val impact: MarkdownFidelityImpact get() = MarkdownFidelityImpact.DataLoss
+    }
+
+    /** A span with no registered encoder kept its text but dropped its marks. */
+    public data class UnsupportedSpan(
+        val typeId: String?,
+        val reason: String,
+        override val blockId: BlockId?,
+        override val textRange: MarkdownTextRange?,
+    ) : MarkdownEncodeWarning() {
+        override val impact: MarkdownFidelityImpact get() = MarkdownFidelityImpact.DataLoss
+    }
+
+    /**
+     * A consumer-supplied encoder threw; its block/span degraded through the
+     * fallback path.
+     */
+    public data class EncoderException(
+        val typeId: String?,
+        val message: String,
+        override val blockId: BlockId?,
+        override val textRange: MarkdownTextRange? = null,
+    ) : MarkdownEncodeWarning() {
+        override val impact: MarkdownFidelityImpact get() = MarkdownFidelityImpact.DataLoss
+    }
+
+    /** Output exceeded [MarkdownCodecLimits.maxOutputChars]; the encode aborted. */
+    public data class OutputLimitExceeded(
+        val limit: Int,
+        override val blockId: BlockId? = null,
+        override val textRange: MarkdownTextRange? = null,
+    ) : MarkdownEncodeWarning() {
+        override val impact: MarkdownFidelityImpact get() = MarkdownFidelityImpact.Fatal
+    }
+
+    /**
+     * An encode resource limit ([kind]) was exhausted; the encode aborted.
+     * [MarkdownCodecLimitKind.Warnings] exhaustion is reported through exactly
+     * one such warning appended after the retained warnings, so the list stays
+     * bounded.
+     */
+    public data class LimitExceeded(
+        val kind: MarkdownCodecLimitKind,
+        val limit: Int,
+        override val blockId: BlockId? = null,
+        override val textRange: MarkdownTextRange? = null,
+    ) : MarkdownEncodeWarning() {
+        override val impact: MarkdownFidelityImpact get() = MarkdownFidelityImpact.Fatal
+    }
+
+    /**
+     * An unexpected engine failure crossed the internal pipeline and was caught
+     * at the public `MarkdownSchema` boundary. The encode aborted with no
+     * payload; this is the last-resort net that keeps the codec no-throw.
+     */
+    public data class EngineFailure(
+        val message: String,
+        override val blockId: BlockId? = null,
+        override val textRange: MarkdownTextRange? = null,
+    ) : MarkdownEncodeWarning() {
+        override val impact: MarkdownFidelityImpact get() = MarkdownFidelityImpact.Fatal
+    }
+}
diff --git a/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/richtext/LinkUrlPolicy.kt b/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/richtext/LinkUrlPolicy.kt
index 711deee..49c0f2d 100644
--- a/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/richtext/LinkUrlPolicy.kt
+++ b/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/richtext/LinkUrlPolicy.kt
@@ -28,15 +28,31 @@ public sealed interface LinkValidationResult {
 }
 
 /**
- * Permissive URL normalization for link spans, modeled on Slack's link entry.
+ * Link URL contracts split by call site intent.
  *
- * Anything non-blank is accepted. Inputs that already carry a `<scheme>://`
- * prefix are preserved verbatim after trimming; everything else is normalized
- * by prepending `https://`, so bare hosts like `example.com/path` become
- * `https://example.com/path`.
+ * [validate] is user-entry normalization for link creation chrome (toolbar, link
+ * popup), modeled on Slack's link entry: anything non-blank is accepted, and inputs
+ * without a `<scheme>://` prefix are rewritten by prepending `https://`, so bare
+ * hosts like `example.com/path` become `https://example.com/path`.
+ *
+ * [validateStoredTarget] is stored-target validation for codec and persistence
+ * paths (JSON [io.github.linreal.cascade.editor.serialization.RichTextSchema],
+ * HTML/Markdown import). It only trims and rejects blank input; the target string
+ * is otherwise preserved exactly, so relative (`../guide.md`), absolute-path
+ * (`/docs`), fragment (`#heading`), `mailto:`, `tel:`, and custom-scheme targets
+ * survive save/load cycles byte-identically.
+ *
+ * Choosing the wrong contract is a correctness bug: entry normalization applied to
+ * a stored target rewrites `../guide.md` into `https://../guide.md` on the next
+ * save; stored-target validation applied to toolbar input stops normalizing bare
+ * hosts. The only [LinkValidationError] in both contracts is [LinkValidationError.Blank].
  */
 public object LinkUrlPolicy {
 
+    /**
+     * User-entry normalization for link creation. May rewrite the input
+     * (prepends `https://` to values without a `<scheme>://` prefix).
+     */
     public fun validate(input: String): LinkValidationResult {
         val trimmed = input.trim()
         if (trimmed.isEmpty()) {
@@ -46,4 +62,16 @@ public object LinkUrlPolicy {
         val normalized = if (trimmed.contains("://")) trimmed else "https://$trimmed"
         return LinkValidationResult.Valid(normalized)
     }
+
+    /**
+     * Stored-target validation for codec/persistence paths. Trims surrounding
+     * whitespace and rejects blank values; never rewrites the target otherwise.
+     */
+    public fun validateStoredTarget(input: String): LinkValidationResult {
+        val trimmed = input.trim()
+        if (trimmed.isEmpty()) {
+            return LinkValidationResult.Invalid(LinkValidationError.Blank)
+        }
+        return LinkValidationResult.Valid(trimmed)
+    }
 }
diff --git a/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/serialization/RichTextSchema.kt b/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/serialization/RichTextSchema.kt
index bff24d1..3752220 100644
--- a/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/serialization/RichTextSchema.kt
+++ b/editor/src/commonMain/kotlin/io/github/linreal/cascade/editor/serialization/RichTextSchema.kt
@@ -35,7 +35,10 @@ import kotlinx.serialization.json.longOrNull
  * - Empty spans (after clamping) are dropped.
  * - Unknown style types are dropped gracefully.
  * - Missing required fields cause the individual span to be dropped, not the whole decode.
- * - Invalid link URLs cause the individual span to be dropped, not the whole decode.
+ * - Blank link URLs cause the individual span to be dropped, not the whole decode.
+ *   Link targets go through [LinkUrlPolicy.validateStoredTarget]: they are trimmed but
+ *   otherwise preserved exactly, so relative/fragment/`mailto:`/`tel:`/custom-scheme
+ *   targets round-trip byte-identically through persistence.
  *
  * Custom payload canonicalization:
  * - On encode, `SpanStyle.Custom.payload` (`String?`) is parsed and embedded as structured JSON.
@@ -130,7 +133,7 @@ public object RichTextSchema {
         }
 
     private fun encodeLinkStyle(style: SpanStyle.Link): JsonObject? {
-        val normalizedUrl = LinkUrlPolicy.validate(style.url).normalizedUrl ?: return null
+        val normalizedUrl = LinkUrlPolicy.validateStoredTarget(style.url).normalizedUrl ?: return null
         return buildJsonObject {
             put("type", JsonPrimitive("link"))
             put("url", JsonPrimitive(normalizedUrl))
@@ -182,7 +185,7 @@ public object RichTextSchema {
                 val urlPrimitive = json["url"] as? JsonPrimitive ?: return null
                 if (!urlPrimitive.isString) return null
                 val rawUrl = urlPrimitive.contentOrNull ?: return null
-                val normalizedUrl = LinkUrlPolicy.validate(rawUrl).normalizedUrl ?: return null
+                val normalizedUrl = LinkUrlPolicy.validateStoredTarget(rawUrl).normalizedUrl ?: return null
                 SpanStyle.Link(normalizedUrl)
             }
             "custom" -> {
diff --git a/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/CascadeEditorBlockStringsTest.kt b/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/CascadeEditorBlockStringsTest.kt
index 81f2ea6..23e0f0d 100644
--- a/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/CascadeEditorBlockStringsTest.kt
+++ b/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/CascadeEditorBlockStringsTest.kt
@@ -94,7 +94,7 @@ class CascadeEditorBlockStringsTest {
         assertEquals("Heading 1", entry.displayName)
     }
 
-    // -- Code entry (Task 6) --
+    // -- Code entry --
 
     @Test
     fun `code entry has expected v1 metadata`() {
diff --git a/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/HtmlLinkAttributesTest.kt b/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/HtmlLinkAttributesTest.kt
index 157f8a2..8e8e2d2 100644
--- a/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/HtmlLinkAttributesTest.kt
+++ b/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/HtmlLinkAttributesTest.kt
@@ -14,17 +14,43 @@ import kotlin.test.assertTrue
 class HtmlLinkAttributesTest {
 
     @Test
-    fun `a href normalizes bare domain through link policy`() {
+    fun `a href preserves bare domain target exactly`() {
+        // Stored-target validation: imported hrefs are never rewritten. Previously,
+        // bare domains gained an https:// prefix.
         val block = HtmlSchema.decode("""<p><a href="example.com/path">Example</a></p>""", HtmlProfile.Default).single()
         val content = assertTextContent(block)
 
         assertEquals("Example", content.text)
         assertEquals(
-            listOf(TextSpan(0, 7, SpanStyle.Link("https://example.com/path"))),
+            listOf(TextSpan(0, 7, SpanStyle.Link("example.com/path"))),
             content.spans,
         )
     }
 
+    @Test
+    fun `a href preserves fragment target without scheme prefix`() {
+        val block = HtmlSchema.decode("""<p><a href="#section">x</a></p>""", HtmlProfile.Default).single()
+        val content = assertTextContent(block)
+
+        assertEquals("x", content.text)
+        assertEquals(listOf(TextSpan(0, 1, SpanStyle.Link("#section"))), content.spans)
+    }
+
+    @Test
+    fun `a href preserves relative mailto tel and custom-scheme targets exactly`() {
+        val targets = listOf("../guide.md", "/docs", "mailto:user@example.com", "tel:+123", "note://custom")
+        for (target in targets) {
+            val block = HtmlSchema.decode("""<p><a href="$target">x</a></p>""", HtmlProfile.Default).single()
+            val content = assertTextContent(block)
+
+            assertEquals(
+                listOf(TextSpan(0, 1, SpanStyle.Link(target))),
+                content.spans,
+                "href $target must be preserved exactly",
+            )
+        }
+    }
+
     @Test
     fun `a with blank href keeps text drops link span and reports dropped attribute`() {
         val result = HtmlSchema.decodeWithReport("""<p><a href=" ">Example</a></p>""", HtmlProfile.Default)
diff --git a/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/LinkUrlPolicyTest.kt b/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/LinkUrlPolicyTest.kt
index 5606041..7e2ada5 100644
--- a/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/LinkUrlPolicyTest.kt
+++ b/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/LinkUrlPolicyTest.kt
@@ -87,6 +87,43 @@ class LinkUrlPolicyTest {
         assertInvalid("   ", LinkValidationError.Blank)
     }
 
+    @Test
+    fun `stored-target validation preserves relative and fragment targets exactly`() {
+        val targets = listOf(
+            "../guide.md",
+            "/docs",
+            "#heading",
+            "mailto:user@example.com",
+            "tel:+123",
+            "note://custom",
+            "example.com/path",
+        )
+        for (target in targets) {
+            val result = LinkUrlPolicy.validateStoredTarget(target)
+            assertEquals(LinkValidationResult.Valid(target), result, "target $target must be preserved")
+        }
+    }
+
+    @Test
+    fun `stored-target validation trims surrounding whitespace only`() {
+        assertEquals(
+            LinkValidationResult.Valid("../guide.md"),
+            LinkUrlPolicy.validateStoredTarget("  ../guide.md  "),
+        )
+    }
+
+    @Test
+    fun `stored-target validation rejects blank input`() {
+        assertEquals(
+            LinkValidationResult.Invalid(LinkValidationError.Blank),
+            LinkUrlPolicy.validateStoredTarget(""),
+        )
+        assertEquals(
+            LinkValidationResult.Invalid(LinkValidationError.Blank),
+            LinkUrlPolicy.validateStoredTarget("   "),
+        )
+    }
+
     private fun assertValid(input: String, expected: String) {
         val result = LinkUrlPolicy.validate(input)
         assertEquals(expected, result.normalizedUrl)
diff --git a/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/RichTextSchemaTest.kt b/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/RichTextSchemaTest.kt
index 42b0e2d..072e116 100644
--- a/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/RichTextSchemaTest.kt
+++ b/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/RichTextSchemaTest.kt
@@ -136,12 +136,46 @@ class RichTextSchemaTest {
     }
 
     @Test
-    fun `decode valid link span normalizes bare domain url`() {
+    fun `decode link span preserves bare domain target exactly`() {
         val json = """{"version":1,"text":"Open example","spans":[{"start":5,"end":12,"style":{"type":"link","url":"example.com/path"}}]}"""
 
         val decoded = RichTextSchema.decodeFromString(json)
 
-        assertEquals(listOf(TextSpan(5, 12, SpanStyle.Link("https://example.com/path"))), decoded.spans)
+        assertEquals(listOf(TextSpan(5, 12, SpanStyle.Link("example.com/path"))), decoded.spans)
+    }
+
+    @Test
+    fun `relative link target survives a save load cycle byte-identically`() {
+        val original = BlockContent.Text(
+            text = "Read the guide",
+            spans = listOf(TextSpan(9, 14, SpanStyle.Link("../guide.md")))
+        )
+
+        val decoded = RichTextSchema.decodeFromString(RichTextSchema.encodeToString(original))
+
+        assertEquals("../guide.md", (decoded.spans.single().style as SpanStyle.Link).url)
+        assertEquals(original, decoded)
+    }
+
+    @Test
+    fun `mailto tel and custom-scheme link targets round-trip unchanged`() {
+        val targets = listOf(
+            "mailto:user@example.com",
+            "tel:+123",
+            "note://custom",
+            "/docs",
+            "#heading",
+        )
+        for (target in targets) {
+            val original = BlockContent.Text(
+                text = "Open target",
+                spans = listOf(TextSpan(0, 4, SpanStyle.Link(target)))
+            )
+
+            val decoded = RichTextSchema.decodeFromString(RichTextSchema.encodeToString(original))
+
+            assertEquals(original, decoded, "target $target must survive persistence unchanged")
+        }
     }
 
     @Test
diff --git a/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/htmlserialization/HtmlFragmentDecoderTest.kt b/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/htmlserialization/HtmlFragmentDecoderTest.kt
new file mode 100644
index 0000000..25f1767
--- /dev/null
+++ b/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/htmlserialization/HtmlFragmentDecoderTest.kt
@@ -0,0 +1,169 @@
+package io.github.linreal.cascade.editor.htmlserialization
+
+import io.github.linreal.cascade.editor.core.BlockContent
+import io.github.linreal.cascade.editor.core.BlockType
+import io.github.linreal.cascade.editor.core.SpanStyle
+import io.github.linreal.cascade.editor.core.TextSpan
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertIs
+import kotlin.test.assertTrue
+
+class HtmlFragmentDecoderTest {
+
+    @Test
+    fun `inline entry point decodes paired inline tags to spans`() {
+        val result = HtmlFragmentDecoder.decodeInlineFragment("<u>x</u>", HtmlProfile.Default)
+
+        assertEquals("x", result.fragment.text)
+        assertEquals(listOf(TextSpan(0, 1, SpanStyle.Underline)), result.fragment.spans)
+    }
+
+    @Test
+    fun `inline entry point keeps surrounding root text`() {
+        val result = HtmlFragmentDecoder.decodeInlineFragment("a <em>b</em> c", HtmlProfile.Default)
+
+        assertEquals("a b c", result.fragment.text)
+        assertEquals(listOf(TextSpan(2, 3, SpanStyle.Italic)), result.fragment.spans)
+    }
+
+    @Test
+    fun `block entry point decodes a blockquote fragment to a quote block`() {
+        val result = HtmlFragmentDecoder.decodeBlockFragment(
+            "<blockquote><p>a</p></blockquote>",
+            HtmlProfile.Default,
+        )
+
+        val block = result.blocks.single()
+        assertEquals(BlockType.Quote, block.type)
+        val content = assertIs<BlockContent.Text>(block.content)
+        assertEquals("a", content.text)
+    }
+
+    @Test
+    fun `block entry point flushes root inline runs into paragraphs`() {
+        val result = HtmlFragmentDecoder.decodeBlockFragment(
+            "loose <b>text</b><p>para</p>",
+            HtmlProfile.Default,
+        )
+
+        assertEquals(2, result.blocks.size)
+        val first = assertIs<BlockContent.Text>(result.blocks[0].content)
+        assertEquals("loose text", first.text)
+        assertEquals(listOf(TextSpan(6, 10, SpanStyle.Bold)), first.spans)
+        val second = assertIs<BlockContent.Text>(result.blocks[1].content)
+        assertEquals("para", second.text)
+    }
+
+    @Test
+    fun `block entry point ignores whitespace-only root text between blocks`() {
+        val result = HtmlFragmentDecoder.decodeBlockFragment(
+            "<p>a</p>\n  <p>b</p>\n",
+            HtmlProfile.Default,
+        )
+
+        assertEquals(2, result.blocks.size)
+        assertEquals("a", assertIs<BlockContent.Text>(result.blocks[0].content).text)
+        assertEquals("b", assertIs<BlockContent.Text>(result.blocks[1].content).text)
+    }
+
+    @Test
+    fun `block entry point keeps significant whitespace between root inline elements`() {
+        val result = HtmlFragmentDecoder.decodeBlockFragment(
+            "<b>a</b> <i>b</i>",
+            HtmlProfile.Default,
+        )
+
+        val paragraph = assertIs<BlockContent.Text>(result.blocks.single().content)
+        assertEquals("a b", paragraph.text)
+        assertEquals(
+            listOf(TextSpan(0, 1, SpanStyle.Bold), TextSpan(2, 3, SpanStyle.Italic)),
+            paragraph.spans,
+        )
+    }
+
+    @Test
+    fun `text leaf reparser hook is invoked for inline text leaves`() {
+        val seen = mutableListOf<String>()
+        val result = HtmlFragmentDecoder.decodeInlineFragment(
+            "<u>ab</u>",
+            HtmlProfile.Default,
+            textLeafReparser = { text ->
+                seen += text
+                InlineFragment(text.uppercase(), emptyList())
+            },
+        )
+
+        assertEquals(listOf("ab"), seen)
+        assertEquals("AB", result.fragment.text)
+        assertEquals(listOf(TextSpan(0, 2, SpanStyle.Underline)), result.fragment.spans)
+    }
+
+    @Test
+    fun `text leaf reparser can contribute spans under outer tags`() {
+        // Simulates the bridge handing "**bold**" back to a Markdown inline
+        // parser: the hook returns a shorter text plus its own span, and the
+        // outer <u> decoder wraps the combined fragment.
+        val result = HtmlFragmentDecoder.decodeInlineFragment(
+            "<u>**bold**</u>",
+            HtmlProfile.Default,
+            textLeafReparser = { text ->
+                if (text == "**bold**") {
+                    InlineFragment("bold", listOf(TextSpan(0, 4, SpanStyle.Bold)))
+                } else {
+                    InlineFragment(text, emptyList())
+                }
+            },
+        )
+
+        assertEquals("bold", result.fragment.text)
+        assertEquals(
+            setOf(
+                TextSpan(0, 4, SpanStyle.Bold),
+                TextSpan(0, 4, SpanStyle.Underline),
+            ),
+            result.fragment.spans.toSet(),
+        )
+    }
+
+    @Test
+    fun `throwing reparser degrades to verbatim text with a decoder exception warning`() {
+        val result = HtmlFragmentDecoder.decodeInlineFragment(
+            "<u>ab</u>",
+            HtmlProfile.Default,
+            textLeafReparser = { error("hook boom") },
+        )
+
+        assertEquals("ab", result.fragment.text)
+        assertEquals(listOf(TextSpan(0, 2, SpanStyle.Underline)), result.fragment.spans)
+        val warning = assertIs<HtmlDecodeWarning.DecoderException>(result.warnings.single())
+        assertTrue(warning.message.contains("hook boom"))
+    }
+
+    @Test
+    fun `block entry point applies the reparser to paragraph text leaves`() {
+        val seen = mutableListOf<String>()
+        HtmlFragmentDecoder.decodeBlockFragment(
+            "<p>inner</p>",
+            HtmlProfile.Default,
+            textLeafReparser = { text ->
+                seen += text
+                InlineFragment(text, emptyList())
+            },
+        )
+
+        assertEquals(listOf("inner"), seen)
+    }
+
+    @Test
+    fun `empty fragment decodes to empty results without warnings`() {
+        val blockResult = HtmlFragmentDecoder.decodeBlockFragment("", HtmlProfile.Default)
+        val inlineResult = HtmlFragmentDecoder.decodeInlineFragment("", HtmlProfile.Default)
+
+        assertTrue(blockResult.blocks.isEmpty())
+        assertTrue(blockResult.warnings.isEmpty())
+        assertEquals("", inlineResult.fragment.text)
+        assertTrue(inlineResult.fragment.spans.isEmpty())
+        assertTrue(inlineResult.warnings.isEmpty())
+    }
+}
diff --git a/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownAnalyzeTest.kt b/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownAnalyzeTest.kt
new file mode 100644
index 0000000..96c5314
--- /dev/null
+++ b/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownAnalyzeTest.kt
@@ -0,0 +1,109 @@
+package io.github.linreal.cascade.editor.markdown
+
+import io.github.linreal.cascade.editor.core.BlockType
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertFalse
+import kotlin.test.assertNull
+import kotlin.test.assertTrue
+
+class MarkdownAnalyzeTest {
+
+    @Test
+    fun `fully supported gfm is native with no data loss`() {
+        val report = MarkdownSchema.analyze("# Title\n\nBody **bold** text\n", MarkdownProfile.Default)
+        assertEquals(MarkdownEditModeRecommendation.Native, report.recommendedMode)
+        assertTrue(report.nativeEditingSafe)
+        assertTrue(report.dataLossWarnings.isEmpty())
+        assertEquals(0, report.preservedBlockCount)
+    }
+
+    @Test
+    fun `pipe table under preserve is raw fallback`() {
+        val report = MarkdownSchema.analyze("| a | b |\n| - | - |\n", MarkdownProfile.Default)
+        assertEquals(1, report.preservedBlockCount)
+        assertFalse(report.nativeEditingSafe)
+        assertEquals(MarkdownEditModeRecommendation.RawFallback, report.recommendedMode)
+    }
+
+    @Test
+    fun `decode abort yields null encode result and raw fallback`() {
+        val limits = MarkdownCodecLimits(maxInputChars = 3)
+        val report = MarkdownSchema.analyze("way too long", MarkdownProfile.Default, limits)
+        assertTrue(report.decodeResult.isAborted)
+        assertNull(report.encodeResult)
+        assertNull(report.wouldRewriteSource)
+        assertEquals(MarkdownEditModeRecommendation.RawFallback, report.recommendedMode)
+    }
+
+    @Test
+    fun `missing final newline is native but would rewrite source`() {
+        val report = MarkdownSchema.analyze("# a", MarkdownProfile.Default)
+        assertEquals(MarkdownEditModeRecommendation.Native, report.recommendedMode)
+        assertEquals(true, report.wouldRewriteSource)
+    }
+
+    @Test
+    fun `byte-identical canonical input does not rewrite source`() {
+        val report = MarkdownSchema.analyze("# a\n", MarkdownProfile.Default)
+        assertEquals(MarkdownEditModeRecommendation.Native, report.recommendedMode)
+        assertEquals(false, report.wouldRewriteSource)
+    }
+
+    @Test
+    fun `bom and crlf drive wouldRewriteSource but stay native`() {
+        val bom = MarkdownSchema.analyze("\uFEFF# a\n", MarkdownProfile.Default)
+        assertEquals(MarkdownEditModeRecommendation.Native, bom.recommendedMode)
+        assertEquals(true, bom.wouldRewriteSource)
+
+        val crlf = MarkdownSchema.analyze("# a\r\n", MarkdownProfile.Default)
+        assertEquals(MarkdownEditModeRecommendation.Native, crlf.recommendedMode)
+        assertEquals(true, crlf.wouldRewriteSource)
+    }
+
+    @Test
+    fun `strip policy still records data loss for analyze even when suppressed`() {
+        val profile = MarkdownProfile.Default.withHtmlInMarkdown(HtmlInMarkdown.Strip)
+        val report = MarkdownSchema.analyze("a <span>x</span> b", profile)
+        assertEquals(MarkdownEditModeRecommendation.RawFallback, report.recommendedMode)
+        assertTrue(report.dataLossWarnings.isNotEmpty())
+    }
+
+    @Test
+    fun `custom support set branch is honored by analyze`() {
+        val claimAll = MarkdownProfileSupportSet(
+            supportsBlockPredicate = { true },
+            supportsSpanPredicate = { true },
+            supportsDocumentPredicate = { true },
+        )
+        val profile = MarkdownProfile.Default.withSupportSet(claimAll)
+        val report = MarkdownSchema.analyze("# a\n", profile)
+        assertEquals(MarkdownEditModeRecommendation.Native, report.recommendedMode)
+    }
+
+    @Test
+    fun `custom support set cannot widen a failed canonical round trip`() {
+        val claimAll = MarkdownProfileSupportSet(
+            supportsBlockPredicate = { true },
+            supportsSpanPredicate = { true },
+            supportsDocumentPredicate = { true },
+        )
+        val profile = MarkdownProfile.Default
+            .withMarkdownBlockEncoder<BlockType.Paragraph> { _, _, _ ->
+                MarkdownEmit.Raw("different")
+            }
+            .withSupportSet(claimAll)
+
+        val report = MarkdownSchema.analyze("original\n", profile)
+
+        assertEquals(MarkdownEditModeRecommendation.RawFallback, report.recommendedMode)
+    }
+
+    @Test
+    fun `canonicalization alone does not force raw fallback`() {
+        // Non-canonical bullet spelling `*` canonicalizes to `-`; still Native.
+        val report = MarkdownSchema.analyze("* item\n", MarkdownProfile.Default)
+        assertEquals(MarkdownEditModeRecommendation.Native, report.recommendedMode)
+        assertEquals(true, report.wouldRewriteSource)
+    }
+}
diff --git a/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownAstDecoderTest.kt b/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownAstDecoderTest.kt
new file mode 100644
index 0000000..9ea54ee
--- /dev/null
+++ b/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownAstDecoderTest.kt
@@ -0,0 +1,42 @@
+package io.github.linreal.cascade.editor.markdown
+
+import io.github.linreal.cascade.editor.core.BlockContent
+import io.github.linreal.cascade.editor.core.BlockType
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertIs
+
+class MarkdownAstDecoderTest {
+    @Test
+    fun `parser projection handles bom crlf and lone cr`() {
+        val blocks = MarkdownSchema.decode("\uFEFF# first\r\n\rsecond")!!
+
+        assertEquals(listOf(BlockType.Heading(1), BlockType.Paragraph), blocks.map { it.type })
+        assertEquals("first", (blocks[0].content as BlockContent.Text).text)
+        assertEquals("second", (blocks[1].content as BlockContent.Text).text)
+    }
+
+    @Test
+    fun `preserved slices retain original crlf bytes and omit bom`() {
+        val markdown = "\uFEFF---\r\nname: cascade\r\n---\r\n"
+        val result = MarkdownSchema.decodeWithReport(markdown)
+        val content = assertIs<BlockContent.Custom>(result.blocks!!.single().content)
+
+        assertEquals("---\r\nname: cascade\r\n---", content.data["rawMarkdown"])
+        val warning = assertIs<MarkdownDecodeWarning.PreservedSyntax>(result.warnings.single())
+        assertEquals(1, warning.range.start)
+        assertEquals(markdown.length - 2, warning.range.endExclusive)
+    }
+
+    @Test
+    fun `unsupported range maps through crlf to original utf16 offsets`() {
+        val markdown = "line\r\n\$x\$"
+        val profile = MarkdownProfile.Default.withUnsupportedSyntax(UnsupportedSyntax.WarnAndDegrade)
+        val warning = MarkdownSchema.decodeWithReport(markdown, profile).warnings
+            .filterIsInstance<MarkdownDecodeWarning.UnsupportedSyntax>()
+            .single()
+
+        assertEquals(markdown.indexOf('$'), warning.range.start)
+        assertEquals(markdown.lastIndexOf('$') + 1, warning.range.endExclusive)
+    }
+}
diff --git a/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownCorpusFixtures.kt b/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownCorpusFixtures.kt
new file mode 100644
index 0000000..98760e8
--- /dev/null
+++ b/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownCorpusFixtures.kt
@@ -0,0 +1,108 @@
+package io.github.linreal.cascade.editor.markdown
+
+/**
+ * Reviewable corpus fixtures, kept as **data** separate from the
+ * assertion logic in `MarkdownCorpusTest`. (KMP `commonTest` has no portable
+ * filesystem, so a single Kotlin manifest is the cross-platform equivalent of
+ * one expectations file per fixture — every corpus document, its profile, and
+ * its expected `analyze` recommendation + warning-impact categories are visible
+ * here and reviewed as data.)
+ *
+ * Corpora are synthetic but plausible (pasted GitHub/Notion/ChatGPT-style docs,
+ * Tasks.org/MyBrain task notes, and hard-break notes). No source-identity
+ * claim is made — only no-throw, the expected recommendation, and the
+ * expected warning categories.
+ */
+internal enum class MarkdownCorpusProfileKey { StrictGfm, StrictHardBreak }
+
+internal data class MarkdownCorpusEntry(
+    val name: String,
+    val profile: MarkdownCorpusProfileKey,
+    val source: String,
+    val expectedRecommendation: MarkdownEditModeRecommendation,
+    /** Warning-impact categories that MUST be present in the analyze report. */
+    val expectedImpacts: Set<MarkdownFidelityImpact>,
+)
+
+internal object MarkdownCorpusFixtures {
+
+    val Entries: List<MarkdownCorpusEntry> = listOf(
+        MarkdownCorpusEntry(
+            name = "github-standup",
+            profile = MarkdownCorpusProfileKey.StrictGfm,
+            source = "# Standup\n\nShipped **auth**, reviewed the [PR](../pr/42.md).\n\n" +
+                "- done\n- next\n\n> ship notes tomorrow\n",
+            expectedRecommendation = MarkdownEditModeRecommendation.Native,
+            expectedImpacts = emptySet(),
+        ),
+        MarkdownCorpusEntry(
+            name = "notion-pasted-table",
+            profile = MarkdownCorpusProfileKey.StrictGfm,
+            source = "Budget:\n\n| item | usd |\n| - | - |\n| infra | 42 |\n| tools | 7 |\n",
+            expectedRecommendation = MarkdownEditModeRecommendation.RawFallback,
+            expectedImpacts = setOf(MarkdownFidelityImpact.OpaquePreservation),
+        ),
+        MarkdownCorpusEntry(
+            name = "chatgpt-inline-html",
+            profile = MarkdownCorpusProfileKey.StrictGfm,
+            source = "A note with <span class=\"x\">inline html</span> pasted in.\n",
+            expectedRecommendation = MarkdownEditModeRecommendation.RawFallback,
+            expectedImpacts = setOf(MarkdownFidelityImpact.DataLoss),
+        ),
+        MarkdownCorpusEntry(
+            name = "tasks-org-note",
+            profile = MarkdownCorpusProfileKey.StrictGfm,
+            source = "## Groceries\n\n- [ ] milk\n- [x] eggs\n- [ ] bread\n",
+            expectedRecommendation = MarkdownEditModeRecommendation.Native,
+            expectedImpacts = emptySet(),
+        ),
+        MarkdownCorpusEntry(
+            name = "strict-hardbreak-memo",
+            profile = MarkdownCorpusProfileKey.StrictHardBreak,
+            source = "monday: plan sprint\n\ntuesday: review PRs\n\nwednesday: ship release\n",
+            expectedRecommendation = MarkdownEditModeRecommendation.Native,
+            expectedImpacts = emptySet(),
+        ),
+        MarkdownCorpusEntry(
+            name = "hardbreak-raw-html",
+            profile = MarkdownCorpusProfileKey.StrictHardBreak,
+            source = "a memo with <b>inline html</b> pasted in\n",
+            expectedRecommendation = MarkdownEditModeRecommendation.RawFallback,
+            expectedImpacts = setOf(MarkdownFidelityImpact.DataLoss),
+        ),
+        MarkdownCorpusEntry(
+            name = "gfm-document-scale",
+            profile = MarkdownCorpusProfileKey.StrictGfm,
+            source = buildString {
+                append("# Release checklist\n\n")
+                append("Track progress with **bold**, _italic_, `code`, and ~~struck~~ notes.\n\n")
+                append("## Tasks\n\n")
+                append("- [ ] cut the branch\n")
+                append("- [x] update the changelog\n")
+                append("- [ ] tag the build\n")
+                append("  - [ ] macOS\n")
+                append("  - [ ] linux\n\n")
+                append("## Steps\n\n")
+                append("1. build\n")
+                append("2. sign\n")
+                append("3. publish\n\n")
+                append("See the [runbook](../docs/runbook.md) and <https://example.com/status>.\n\n")
+                append("> Remember to announce in the channel.\n\n")
+                append("```\n./gradlew publish --no-daemon\n```\n\n")
+                append("Nested notes:\n\n")
+                append("- outer\n")
+                append("  - inner one\n")
+                append("  - inner two\n\n")
+                append("---\n\n")
+                append("Final paragraph with a relative link [here](./notes.md).\n")
+            },
+            expectedRecommendation = MarkdownEditModeRecommendation.Native,
+            expectedImpacts = emptySet(),
+        ),
+    )
+
+    fun profileFor(key: MarkdownCorpusProfileKey): MarkdownProfile = when (key) {
+        MarkdownCorpusProfileKey.StrictGfm -> MarkdownReferenceProfiles.StrictGfmFieldProfile
+        MarkdownCorpusProfileKey.StrictHardBreak -> MarkdownReferenceProfiles.StrictHardBreakFieldProfile
+    }
+}
diff --git a/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownCorpusTest.kt b/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownCorpusTest.kt
new file mode 100644
index 0000000..6ffe165
--- /dev/null
+++ b/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownCorpusTest.kt
@@ -0,0 +1,55 @@
+package io.github.linreal.cascade.editor.markdown
+
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+
+/**
+ * Data-driven corpus suite: iterates the reviewable
+ * [MarkdownCorpusFixtures] manifest, asserting no-throw, the expected `analyze`
+ * recommendation, and the expected warning-impact categories per fixture.
+ */
+class MarkdownCorpusTest {
+
+    @Test
+    fun `every corpus fixture matches its expected recommendation and warning categories`() {
+        for (entry in MarkdownCorpusFixtures.Entries) {
+            val profile = MarkdownCorpusFixtures.profileFor(entry.profile)
+            val report = MarkdownSchema.analyze(entry.source, profile)
+
+            assertEquals(
+                entry.expectedRecommendation,
+                report.recommendedMode,
+                "recommendation for '${entry.name}'",
+            )
+
+            val presentImpacts = buildSet {
+                report.decodeResult.warnings.forEach { add(it.impact) }
+                report.encodeResult?.warnings?.forEach { add(it.impact) }
+            }
+            for (expected in entry.expectedImpacts) {
+                assertTrue(
+                    expected in presentImpacts,
+                    "corpus '${entry.name}' expected impact $expected; present=$presentImpacts",
+                )
+            }
+            if (entry.expectedRecommendation == MarkdownEditModeRecommendation.Native) {
+                assertTrue(
+                    presentImpacts.none {
+                        it == MarkdownFidelityImpact.OpaquePreservation ||
+                            it == MarkdownFidelityImpact.DataLoss ||
+                            it == MarkdownFidelityImpact.Fatal
+                    },
+                    "native corpus '${entry.name}' must have no lossy impacts; present=$presentImpacts",
+                )
+                // A Native fixture must round-trip: decode → encode → re-decode
+                // is structurally stable.
+                val profile = MarkdownCorpusFixtures.profileFor(entry.profile)
+                val decoded = MarkdownSchema.decode(entry.source, profile)!!
+                val reencoded = MarkdownSchema.encode(decoded, profile)!!
+                val redecoded = MarkdownSchema.decode(reencoded, profile)!!
+                assertMarkdownSemanticallyEquals(decoded, redecoded)
+            }
+        }
+    }
+}
diff --git a/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownDifferentialTest.kt b/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownDifferentialTest.kt
new file mode 100644
index 0000000..2d11d27
--- /dev/null
+++ b/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownDifferentialTest.kt
@@ -0,0 +1,105 @@
+package io.github.linreal.cascade.editor.markdown
+
+import kotlin.test.Test
+import kotlin.test.assertTrue
+import kotlin.test.fail
+
+/**
+ * Differential suite against **CommonMark 0.30**
+ * (https://spec.commonmark.org/0.30/) plus one GFM 0.29-gfm strikethrough
+ * example. Inputs are verbatim from the spec; the example numbers are the
+ * official ones.
+ *
+ * Classification is a single consistent rule — `encode(decode(input))` is
+ * compared to the verbatim input:
+ * - **Aligned**: byte-identical round-trip (the input already matches our
+ *   canonical form).
+ * - **Deviation**: differs, and the difference matches a documented rationale
+ *   (documented in `docs/MarkdownSerialization.md`). There is no third state.
+ */
+class MarkdownDifferentialTest {
+
+    private sealed interface Expectation {
+        data object Aligned : Expectation
+        data class Deviation(val rationale: String, val check: (String) -> Boolean) : Expectation
+    }
+
+    private data class Case(val id: String, val input: String, val expectation: Expectation)
+
+    private val cases: List<Case> = listOf(
+        // Aligned: inputs already in our canonical form.
+        Case("CM0.30 #219 paragraphs", "aaa\n\nbbb\n", Expectation.Aligned),
+        Case("CM0.30 #377 strong emphasis", "**foo bar**\n", Expectation.Aligned),
+        Case("GFM0.29 strikethrough", "~~Hi~~ Hello\n", Expectation.Aligned),
+
+        // Documented deviations (see the feature matrix).
+        Case(
+            "CM0.30 #62 ATX headings",
+            "# foo\n## foo\n### foo\n#### foo\n##### foo\n###### foo\n",
+            Expectation.Deviation("engine-owned canonical block separation inserts a blank line between blocks") {
+                it.contains("# foo") && it.contains("###### foo") && it.contains("\n\n")
+            },
+        ),
+        Case(
+            "CM0.30 #43 thematic breaks",
+            "***\n---\n___\n",
+            Expectation.Deviation("thematic breaks canonicalize to `---` with blank-line separation") {
+                it == "---\n\n---\n\n---\n"
+            },
+        ),
+        Case(
+            "CM0.30 #350 emphasis",
+            "*foo bar*",
+            Expectation.Deviation("output always ends with exactly one final newline") {
+                it == "*foo bar*\n"
+            },
+        ),
+        Case(
+            "CM0.30 #301 bullet list markers",
+            "- foo\n- bar\n+ baz\n",
+            Expectation.Deviation("bullet markers canonicalize to `-`") {
+                it == "- foo\n- bar\n- baz\n"
+            },
+        ),
+        Case(
+            "CM0.30 #80 setext headings",
+            "Foo *bar*\n=========\n\nFoo *bar*\n---------\n",
+            Expectation.Deviation("setext headings are decode-only and re-emit as ATX (`#`/`##`)") {
+                it.startsWith("# Foo ") && it.contains("\n## Foo ")
+            },
+        ),
+        Case(
+            "CM0.30 #107 indented code",
+            "    a simple\n      indented code block\n",
+            Expectation.Deviation("indented code is decode-only and re-emits as a fenced block") {
+                it.startsWith("```") && it.contains("a simple")
+            },
+        ),
+    )
+
+    @Test
+    fun `official examples are byte-identical or match a documented deviation`() {
+        for (case in cases) {
+            val decoded = MarkdownSchema.decode(case.input, MarkdownProfile.Default)
+                ?: fail("${case.id}: decode aborted")
+            val encoded = MarkdownSchema.encode(decoded, MarkdownProfile.Default)
+                ?: fail("${case.id}: encode aborted")
+            when (val expectation = case.expectation) {
+                Expectation.Aligned -> assertTrue(
+                    encoded == case.input,
+                    "${case.id}: expected byte-identical round-trip; got:\n<<<$encoded>>>",
+                )
+                is Expectation.Deviation -> {
+                    assertTrue(
+                        encoded != case.input,
+                        "${case.id}: marked deviation but round-trip was byte-identical",
+                    )
+                    assertTrue(
+                        expectation.check(encoded),
+                        "${case.id}: deviation (${expectation.rationale}); got:\n<<<$encoded>>>",
+                    )
+                }
+            }
+        }
+    }
+}
diff --git a/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownEncodeTest.kt b/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownEncodeTest.kt
new file mode 100644
index 0000000..1fb9285
--- /dev/null
+++ b/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownEncodeTest.kt
@@ -0,0 +1,231 @@
+package io.github.linreal.cascade.editor.markdown
+
+import io.github.linreal.cascade.editor.core.Block
+import io.github.linreal.cascade.editor.core.BlockAttributes
+import io.github.linreal.cascade.editor.core.BlockContent
+import io.github.linreal.cascade.editor.core.BlockId
+import io.github.linreal.cascade.editor.core.BlockType
+import io.github.linreal.cascade.editor.core.CustomBlockType
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertIs
+import kotlin.test.assertNull
+import kotlin.test.assertTrue
+import kotlin.test.fail
+
+/** Canonical block encoder and emission engine. */
+class MarkdownEncodeTest {
+
+    private fun encode(
+        blocks: List<Block>,
+        profile: MarkdownProfile = MarkdownProfile.Default,
+        limits: MarkdownCodecLimits = MarkdownCodecLimits.Default,
+        lineEnding: MarkdownLineEnding = MarkdownLineEnding.Lf,
+    ): MarkdownEncodeResult = MarkdownEncodeEngine.encodeWithReport(blocks, profile, limits, lineEnding)
+
+    private fun MarkdownEncodeResult.requireMarkdown(): String =
+        markdown ?: fail("expected a successful encode, got aborted with warnings=$warnings")
+
+    private fun textBlock(type: BlockType, text: String): Block =
+        Block(id = BlockId.generate(), type = type, content = BlockContent.Text(text))
+
+    // Engine-owned separation and canonical forms
+
+    @Test
+    fun headingAndParagraphJoinWithBlankLineAndEndWithOneNewline() {
+        val markdown = encode(
+            listOf(
+                textBlock(BlockType.Heading(2), "a"),
+                textBlock(BlockType.Paragraph, "b"),
+            ),
+        ).requireMarkdown()
+        assertEquals("## a\n\nb\n", markdown)
+    }
+
+    @Test
+    fun emptyDocumentEncodesToEmptySuccessfulPayload() {
+        val result = encode(emptyList())
+        assertTrue(result.isSuccess)
+        assertEquals("", result.markdown)
+    }
+
+    @Test
+    fun dividerEncodesCanonically() {
+        assertEquals("---\n", encode(listOf(Block.divider())).requireMarkdown())
+    }
+
+    @Test
+    fun crLfOptionConvertsEveryLineEnding() {
+        val markdown = encode(
+            listOf(
+                textBlock(BlockType.Heading(1), "a"),
+                textBlock(BlockType.Paragraph, "b"),
+            ),
+            lineEnding = MarkdownLineEnding.CrLf,
+        ).requireMarkdown()
+        assertEquals("# a\r\n\r\nb\r\n", markdown)
+    }
+
+    // Quote prefixes every physical line
+
+    @Test
+    fun quoteWithHardBreakPrefixesBothPhysicalLines() {
+        val markdown = encode(listOf(textBlock(BlockType.Quote, "a\nb"))).requireMarkdown()
+        assertEquals("> a\\\n> b\n", markdown)
+    }
+
+    @Test
+    fun quoteHardBreakUsesTwoSpacesUnderThatPolicy() {
+        val profile = MarkdownProfile.Default.withHardBreakEncode(HardBreakEncode.TwoSpaces)
+        val markdown = encode(listOf(textBlock(BlockType.Quote, "a\nb")), profile).requireMarkdown()
+        assertEquals("> a  \n> b\n", markdown)
+    }
+
+    // Fences
+
+    @Test
+    fun codeFenceWidensPastInternalBacktickRuns() {
+        val markdown = encode(listOf(textBlock(BlockType.Code, "a\n```\nb"))).requireMarkdown()
+        assertEquals("````\na\n```\nb\n````\n", markdown)
+    }
+
+    @Test
+    fun codeFenceWidensPastContentEndingInAFenceLikeLine() {
+        val markdown = encode(listOf(textBlock(BlockType.Code, "a\n```"))).requireMarkdown()
+        assertEquals("````\na\n```\n````\n", markdown)
+    }
+
+    @Test
+    fun emptyCodeBlockEncodesAsEmptyFence() {
+        val markdown = encode(listOf(textBlock(BlockType.Code, ""))).requireMarkdown()
+        assertEquals("```\n```\n", markdown)
+    }
+
+    @Test
+    fun codeContentIsNeverEscaped() {
+        val markdown = encode(listOf(textBlock(BlockType.Code, "# not a heading *x*"))).requireMarkdown()
+        assertEquals("```\n# not a heading *x*\n```\n", markdown)
+    }
+
+    // Warnings and fallbacks
+
+    @Test
+    fun paragraphDepthDropsToZeroWithWarning() {
+        val block = Block.paragraph("b").withAttributes(BlockAttributes(indentationLevel = 2))
+        val result = encode(listOf(block))
+        assertEquals("b\n", result.requireMarkdown())
+        val warning = result.warnings
+            .filterIsInstance<MarkdownEncodeWarning.DroppedAttribute>()
+            .single()
+        assertEquals("indentationLevel", warning.attr)
+        assertEquals(block.id, warning.blockId)
+    }
+
+    @Test
+    fun headingWithEmbeddedNewlineEncodesSpacesWithDataLossWarning() {
+        val result = encode(listOf(textBlock(BlockType.Heading(1), "a\nb")))
+        assertEquals("# a b\n", result.requireMarkdown())
+        val warning = result.warnings
+            .filterIsInstance<MarkdownEncodeWarning.DroppedAttribute>()
+            .single()
+        assertEquals(MarkdownFidelityImpact.DataLoss, warning.impact)
+    }
+
+    @Test
+    fun unregisteredCustomBlockFallsBackToPlainParagraphWithWarning() {
+        val customType = object : CustomBlockType {
+            override val typeId: String = "sample.widget"
+            override val displayName: String = "Widget"
+            override val supportsText: Boolean = true
+        }
+        val block = Block(BlockId.generate(), customType, BlockContent.Text("visible"))
+        val result = encode(listOf(block))
+        assertEquals("visible\n", result.requireMarkdown())
+        val warning = result.warnings
+            .filterIsInstance<MarkdownEncodeWarning.UnsupportedBlock>()
+            .single()
+        assertEquals("sample.widget", warning.typeId)
+        assertEquals(MarkdownFidelityImpact.DataLoss, warning.impact)
+    }
+
+    @Test
+    fun emptyParagraphIsNotEncodableInCommonMarkMode() {
+        val result = encode(listOf(Block.paragraph("")))
+        assertEquals("", result.requireMarkdown())
+        assertTrue(result.warnings.filterIsInstance<MarkdownEncodeWarning.UnsupportedBlock>().isNotEmpty())
+    }
+
+    @Test
+    fun emptyQuoteIsNotEncodableInCommonMarkMode() {
+        // "> " would re-decode to zero blocks; the empty quote must go through
+        // the warning fallback, never vanish silently.
+        val result = encode(listOf(textBlock(BlockType.Quote, "")))
+        assertEquals("", result.requireMarkdown())
+        assertTrue(result.warnings.filterIsInstance<MarkdownEncodeWarning.UnsupportedBlock>().isNotEmpty())
+    }
+
+    @Test
+    fun throwingConsumerEncoderDegradesThroughFallbackWithoutThrowing() {
+        val profile = MarkdownProfile.Default.withMarkdownBlockEncoder<BlockType.Paragraph> { _, _, _ ->
+            error("boom")
+        }
+        val result = encode(listOf(Block.paragraph("still here")), profile)
+        assertEquals("still here\n", result.requireMarkdown())
+        assertIs<MarkdownEncodeWarning.EncoderException>(
+            result.warnings.first { it is MarkdownEncodeWarning.EncoderException },
+        )
+    }
+
+    // Limits
+
+    @Test
+    fun outputLimitAbortsWithNullPayload() {
+        val result = encode(
+            listOf(Block.paragraph("a".repeat(64))),
+            limits = MarkdownCodecLimits(maxOutputChars = 16),
+        )
+        assertTrue(result.isAborted)
+        assertNull(result.markdown)
+        val fatal = result.warnings.single { it.impact == MarkdownFidelityImpact.Fatal }
+        assertIs<MarkdownEncodeWarning.OutputLimitExceeded>(fatal)
+    }
+
+    // Preserved verbatim emission
+
+    @Test
+    fun preservedBlockEmitsExactRawMarkdownViaVerbatim() {
+        val table = "| a | b |\n| --- | --- |"
+        val decoded = MarkdownDecodeEngine.decode(table, MarkdownProfile.Default).blocks
+            ?: fail("decode failed")
+        val markdown = encode(decoded).requireMarkdown()
+        assertEquals("$table\n", markdown)
+    }
+
+    // decode(encode(...)) smoke test for block shapes
+
+    @Test
+    fun blockShapesSurviveEncodeDecodeRoundTrip() {
+        val original = listOf(
+            textBlock(BlockType.Heading(1), "Title"),
+            textBlock(BlockType.Paragraph, "Some plain text."),
+            textBlock(BlockType.BulletList, "one"),
+            textBlock(BlockType.Todo(checked = true), "task"),
+            textBlock(BlockType.NumberedList(1), "first"),
+            textBlock(BlockType.Quote, "quoted"),
+            textBlock(BlockType.Code, "code()\n  indented"),
+            Block.divider(),
+        )
+        val markdown = encode(original).requireMarkdown()
+        val decoded = MarkdownDecodeEngine.decode(markdown, MarkdownProfile.Default).blocks
+            ?: fail("re-decode failed")
+        assertEquals(original.map { it.type }, decoded.map { it.type })
+        assertEquals(
+            original.map { (it.content as? BlockContent.Text)?.text },
+            decoded.map { (it.content as? BlockContent.Text)?.text },
+        )
+        assertEquals(
+            original.map { it.attributes.indentationLevel },
+            decoded.map { it.attributes.indentationLevel },
+        )
+    }
+}
diff --git a/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownEntityTest.kt b/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownEntityTest.kt
new file mode 100644
index 0000000..ab0f1ef
--- /dev/null
+++ b/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownEntityTest.kt
@@ -0,0 +1,139 @@
+package io.github.linreal.cascade.editor.markdown
+
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertNotNull
+import kotlin.test.assertNull
+import kotlin.test.assertTrue
+
+/** Entity decoding infrastructure. */
+class MarkdownEntityTest {
+
+    private fun decode(
+        text: String,
+        policy: EntityDecode = EntityDecode.Standard,
+    ): Pair<String, List<Triple<String, Int, Int>>> {
+        val unknown = mutableListOf<Triple<String, Int, Int>>()
+        val decoded = MarkdownEntities.decode(text, policy) { name, start, endExclusive ->
+            unknown += Triple(name, start, endExclusive)
+        }
+        return decoded to unknown
+    }
+
+    // Named references
+
+    @Test
+    fun knownNamedReferencesDecode() {
+        assertEquals("&", decode("&amp;").first)
+        assertEquals("a < b", decode("a &lt; b").first)
+        assertEquals("\u00A0", decode("&nbsp;").first)
+        assertEquals("—", decode("&mdash;").first)
+        assertEquals("–", decode("&ndash;").first)
+        assertEquals("…", decode("&hellip;").first)
+        assertEquals("©", decode("&copy;").first)
+        assertEquals("™", decode("&trade;").first)
+        assertEquals("→", decode("&rarr;").first)
+        assertEquals("←", decode("&larr;").first)
+        assertEquals("×", decode("&times;").first)
+        assertEquals("°", decode("&deg;").first)
+    }
+
+    @Test
+    fun unknownNameStaysLiteralAndReportsExactRange() {
+        val (text, unknown) = decode("a &nosuch; b")
+        assertEquals("a &nosuch; b", text)
+        assertEquals(listOf(Triple("nosuch", 2, 10)), unknown)
+    }
+
+    @Test
+    fun namedReferencesAreCaseSensitive() {
+        // "Prime" and "prime" are distinct names; "AMP" is not in the subset.
+        assertEquals("′", decode("&prime;").first)
+        assertEquals("″", decode("&Prime;").first)
+        val (text, unknown) = decode("&AMP;")
+        assertEquals("&AMP;", text)
+        assertEquals("AMP", unknown.single().first)
+    }
+
+    // Numeric references
+
+    @Test
+    fun decimalAndHexReferencesDecodeFully() {
+        assertEquals("#", decode("&#35;").first)
+        assertEquals("A", decode("&#x41;").first)
+        assertEquals("A", decode("&#X41;").first)
+        assertEquals("😀", decode("&#x1F600;").first)
+    }
+
+    @Test
+    fun invalidCodePointsBecomeReplacementCharacter() {
+        assertEquals("�", decode("&#0;").first)
+        assertEquals("�", decode("&#xD800;").first)
+        assertEquals("�", decode("&#1114112;").first)
+    }
+
+    @Test
+    fun malformedNumericsStayLiteralWithoutWarnings() {
+        for (input in listOf("&#;", "&#x;", "&#xGG;", "&#12345678;", "&#x1234567;", "&#12")) {
+            val (text, unknown) = decode(input)
+            assertEquals(input, text)
+            assertTrue(unknown.isEmpty(), "no unknown-name report expected for $input")
+        }
+    }
+
+    @Test
+    fun nonEntityAmpersandsStayLiteralWithoutWarnings() {
+        for (input in listOf("&", "a & b", "&;", "& amp;", "&am p;", "&<tag>")) {
+            val (text, unknown) = decode(input)
+            assertEquals(input, text)
+            assertTrue(unknown.isEmpty(), "no unknown-name report expected for $input")
+        }
+    }
+
+    // Policy
+
+    @Test
+    fun entityDecodeNoneDisablesDecodingAndWarnings() {
+        val (text, unknown) = decode("&amp; &nosuch;", EntityDecode.None)
+        assertEquals("&amp; &nosuch;", text)
+        assertTrue(unknown.isEmpty())
+    }
+
+    // Low-level matcher
+
+    @Test
+    fun matchAtReportsConsumedLengthAndName() {
+        val match = assertNotNull(MarkdownEntities.matchAt("x&amp;y", 1))
+        assertEquals(5, match.length)
+        assertEquals("&", match.replacement)
+        assertEquals("amp", match.name)
+
+        val unknown = assertNotNull(MarkdownEntities.matchAt("&nosuch;", 0))
+        assertEquals(8, unknown.length)
+        assertNull(unknown.replacement)
+        assertEquals("nosuch", unknown.name)
+
+        assertNull(MarkdownEntities.matchAt("&amp;", 1))
+        assertNull(MarkdownEntities.matchAt("& amp;", 0))
+    }
+
+    @Test
+    fun mixedTextDecodesInOnePass() {
+        val (text, unknown) = decode("&copy; 2026 &mdash; a&b &nosuch; &#x41;")
+        assertEquals("© 2026 — a&b &nosuch; A", text)
+        assertEquals(1, unknown.size)
+        assertEquals("nosuch", unknown.single().first)
+    }
+
+    // Warning member contract
+
+    @Test
+    fun unsupportedEntityWarningIsInformational() {
+        val warning = MarkdownDecodeWarning.UnsupportedEntity(
+            name = "nosuch",
+            range = MarkdownSourceRange(2, 10),
+        )
+        assertEquals(MarkdownFidelityImpact.Informational, warning.impact)
+        assertEquals(MarkdownSourceRange(2, 10), warning.range)
+    }
+}
diff --git a/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownEscalationTest.kt b/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownEscalationTest.kt
new file mode 100644
index 0000000..eec5f9d
--- /dev/null
+++ b/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownEscalationTest.kt
@@ -0,0 +1,242 @@
+package io.github.linreal.cascade.editor.markdown
+
+import io.github.linreal.cascade.editor.core.Block
+import io.github.linreal.cascade.editor.core.BlockContent
+import io.github.linreal.cascade.editor.core.BlockType
+import io.github.linreal.cascade.editor.core.UnknownBlockType
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertIs
+import kotlin.test.assertTrue
+import kotlin.test.fail
+
+/**
+ * Inline and metadata preservation escalation.
+ * Under `Preserve` there is no DataLoss decode path: every unrepresentable
+ * construct escalates to opaque `md.preserved` blocks; under `WarnAndDegrade`
+ * editable content lowers with DataLoss warnings.
+ */
+class MarkdownEscalationTest {
+
+    private val degradeProfile =
+        MarkdownProfile.Default.withUnsupportedSyntax(UnsupportedSyntax.WarnAndDegrade)
+
+    private fun decode(
+        input: String,
+        profile: MarkdownProfile = MarkdownProfile.Default,
+    ): MarkdownDecodeResult = MarkdownDecodeEngine.decode(input, profile)
+
+    private fun MarkdownDecodeResult.requireBlocks(): List<Block> =
+        blocks ?: fail("expected a successful decode, warnings=$warnings")
+
+    private fun Block.preservedPayload(expectedKind: String): String {
+        val type = assertIs<UnknownBlockType>(this.type)
+        assertEquals("md.preserved", type.typeId)
+        val content = assertIs<BlockContent.Custom>(this.content)
+        assertEquals(expectedKind, content.data["kind"])
+        return content.data["rawMarkdown"] as? String
+            ?: fail("expected a rawMarkdown slice, got ${content.data}")
+    }
+
+    private fun MarkdownDecodeResult.assertNoDataLoss() {
+        assertTrue(
+            warnings.none { it.impact == MarkdownFidelityImpact.DataLoss },
+            "Preserve must have no DataLoss path, got $warnings",
+        )
+    }
+
+    // Inline math
+
+    @Test
+    fun inlineMathEscalatesWholeLeafUnderPreserve() {
+        val result = decode("a \$x^2\$ b")
+        val block = result.requireBlocks().single()
+        assertEquals("a \$x^2\$ b", block.preservedPayload("inlineMath"))
+        val warning = result.warnings
+            .filterIsInstance<MarkdownDecodeWarning.PreservedSyntax>()
+            .single()
+        assertEquals("inlineMath", warning.kind)
+        result.assertNoDataLoss()
+    }
+
+    @Test
+    fun inlineMathStaysLiteralTextUnderWarnAndDegrade() {
+        val result = decode("a \$x^2\$ b", degradeProfile)
+        val block = result.requireBlocks().single()
+        assertEquals(BlockType.Paragraph, block.type)
+        assertEquals("a \$x^2\$ b", (block.content as BlockContent.Text).text)
+        val warning = result.warnings
+            .filterIsInstance<MarkdownDecodeWarning.UnsupportedSyntax>()
+            .single { it.construct == "inlineMath" }
+        assertEquals(MarkdownFidelityImpact.DataLoss, warning.impact)
+    }
+
+    // Inline images
+
+    @Test
+    fun inlineImageEscalatesUnderPreserveAndKeepsAltUnderDegrade() {
+        val preserved = decode("see ![alt](u) here")
+        assertEquals(
+            "see ![alt](u) here",
+            preserved.requireBlocks().single().preservedPayload("inlineImage"),
+        )
+        preserved.assertNoDataLoss()
+
+        val degraded = decode("see ![alt](u) here", degradeProfile)
+        val block = degraded.requireBlocks().single()
+        assertEquals("see alt here", (block.content as BlockContent.Text).text)
+        assertTrue(
+            degraded.warnings.filterIsInstance<MarkdownDecodeWarning.UnsupportedSyntax>()
+                .any { it.construct == "inlineImage" },
+        )
+    }
+
+    // Footnote references
+
+    @Test
+    fun footnoteRefEscalatesUnderPreserveAndStaysLiteralUnderDegrade() {
+        val preserved = decode("a [^1] b")
+        assertEquals("a [^1] b", preserved.requireBlocks().single().preservedPayload("footnoteRef"))
+        preserved.assertNoDataLoss()
+
+        val degraded = decode("a [^1] b", degradeProfile)
+        val block = degraded.requireBlocks().single()
+        assertEquals("a [^1] b", (block.content as BlockContent.Text).text)
+        assertTrue(
+            degraded.warnings.filterIsInstance<MarkdownDecodeWarning.UnsupportedSyntax>()
+                .any { it.construct == "footnoteRef" },
+        )
+    }
+
+    // Link titles
+
+    @Test
+    fun inlineLinkTitleEscalatesTheLeafUnderPreserve() {
+        val result = decode("x [a](u \"title\") y")
+        val block = result.requireBlocks().single()
+        assertEquals("x [a](u \"title\") y", block.preservedPayload("linkTitle"))
+        result.assertNoDataLoss()
+    }
+
+    @Test
+    fun titledDefinitionPreservesDefinitionAndEveryReferringLeaf() {
+        val input = "[a][r]\n\nplain\n\n[r]: /u \"title\""
+        val result = decode(input)
+        val blocks = result.requireBlocks()
+        assertEquals(3, blocks.size)
+        assertEquals("[a][r]", blocks[0].preservedPayload("linkReferenceTitle"))
+        assertEquals(BlockType.Paragraph, blocks[1].type)
+        assertEquals("[r]: /u \"title\"", blocks[2].preservedPayload("linkReferenceDefinition"))
+        result.assertNoDataLoss()
+    }
+
+    @Test
+    fun untitledDefinitionStillLowersReferencesNatively() {
+        val result = decode("[a][r]\n\n[r]: /u")
+        val block = result.requireBlocks().single()
+        assertEquals(BlockType.Paragraph, block.type)
+        result.assertNoDataLoss()
+    }
+
+    // Ordered-list start values
+
+    @Test
+    fun nonOneOrderedStartPreservesTheWholeListOpaquely() {
+        val result = decode("3. a\n4. b")
+        val block = result.requireBlocks().single()
+        assertEquals("3. a\n4. b", block.preservedPayload("orderedList"))
+        result.assertNoDataLoss()
+    }
+
+    // Complex containers
+
+    @Test
+    fun multiParagraphListItemPreservesTheSmallestSafeContainer() {
+        val input = "- a\n\n  b"
+        val result = decode(input)
+        val block = result.requireBlocks().single()
+        assertEquals(input, block.preservedPayload("listItem"))
+        result.assertNoDataLoss()
+    }
+
+    @Test
+    fun nestedQuotePreservesTheWholeQuote() {
+        val result = decode(">> deep")
+        val block = result.requireBlocks().single()
+        assertEquals(">> deep", block.preservedPayload("blockquote"))
+        result.assertNoDataLoss()
+    }
+
+    @Test
+    fun headingInsideQuotePreservesTheWholeQuote() {
+        val input = "> # h\n> text"
+        val result = decode(input)
+        val block = result.requireBlocks().single()
+        assertEquals(input, block.preservedPayload("blockquote"))
+        result.assertNoDataLoss()
+    }
+
+    @Test
+    fun listNestingBeyondModuleDepthPreservesTheList() {
+        val input = "- a\n" +
+            "  - b\n" +
+            "    - c\n" +
+            "      - d\n" +
+            "        - e\n" +
+            "          - f\n" +
+            "            - g"
+        val result = decode(input)
+        val block = result.requireBlocks().single()
+        assertEquals(input, block.preservedPayload("list"))
+        result.assertNoDataLoss()
+    }
+
+    @Test
+    fun fenceInsideListPreservesTheWholeList() {
+        // A fence inside an item is multi-block item content; the item's slice
+        // inside a container is not independently re-emittable (interior lines
+        // carry the container indent), so the owner is the enclosing
+        // root-level list.
+        val input = "- a\n  ```kotlin\n  x\n  ```"
+        val result = decode(input)
+        val block = result.requireBlocks().single()
+        assertEquals(input, block.preservedPayload("listItem"))
+        result.assertNoDataLoss()
+    }
+
+    // Escalation happens before span commit
+
+    @Test
+    fun escalatedLeafLeaksNoPartialSpans() {
+        val result = decode("**bold** \$m\$")
+        val blocks = result.requireBlocks()
+        val block = blocks.single()
+        assertEquals("**bold** \$m\$", block.preservedPayload("inlineMath"))
+        // No text block with committed spans exists anywhere in the result.
+        assertTrue(blocks.none { it.content is BlockContent.Text })
+        result.assertNoDataLoss()
+    }
+
+    @Test
+    fun onlyTheEscalatingRootNodeIsPreserved() {
+        val result = decode("plain **b**\n\na \$m\$ b\n\ntail")
+        val blocks = result.requireBlocks()
+        assertEquals(3, blocks.size)
+        assertEquals(BlockType.Paragraph, blocks[0].type)
+        assertEquals("plain b", (blocks[0].content as BlockContent.Text).text)
+        blocks[1].preservedPayload("inlineMath")
+        assertEquals(BlockType.Paragraph, blocks[2].type)
+        result.assertNoDataLoss()
+    }
+
+    // The quote leaf owner is the root-level quote, not the bare leaf
+
+    @Test
+    fun inlineEscalationInsideQuotePreservesTheWholeQuote() {
+        val input = "> a \$m\$ b"
+        val result = decode(input)
+        val block = result.requireBlocks().single()
+        assertEquals(input, block.preservedPayload("inlineMath"))
+        result.assertNoDataLoss()
+    }
+}
diff --git a/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownEscapingTest.kt b/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownEscapingTest.kt
new file mode 100644
index 0000000..ffa2b68
--- /dev/null
+++ b/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownEscapingTest.kt
@@ -0,0 +1,262 @@
+package io.github.linreal.cascade.editor.markdown
+
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertFalse
+import kotlin.test.assertTrue
+
+@OptIn(ExperimentalCascadeMarkdownApi::class)
+class MarkdownEscapingTest {
+
+    private val lineStart = MarkdownEscapeContext.LineStart
+    private val midLine = MarkdownEscapeContext.MidLine
+
+    @Test
+    fun `hash is escaped at line start and not mid-line`() {
+        assertEquals("""\# heading""", Markdown.escapeInline("# heading", lineStart))
+        assertEquals("a # b", Markdown.escapeInline("a # b", midLine))
+        assertEquals("a # b", Markdown.escapeInline("a # b", lineStart))
+    }
+
+    @Test
+    fun `blockquote marker is escaped at line start only`() {
+        assertEquals("""\> quote""", Markdown.escapeInline("> quote", lineStart))
+        assertEquals("a > b", Markdown.escapeInline("a > b", lineStart))
+    }
+
+    @Test
+    fun `setext underline chars are escaped at line start`() {
+        assertEquals("""\==""", Markdown.escapeInline("==", lineStart))
+        assertEquals("""\=x""", Markdown.escapeInline("=x", lineStart))
+        assertEquals("a = b", Markdown.escapeInline("a = b", lineStart))
+    }
+
+    @Test
+    fun `bullet markers are escaped at line start when they would form list syntax`() {
+        assertEquals("""\- item""", Markdown.escapeInline("- item", lineStart))
+        assertEquals("""\+ item""", Markdown.escapeInline("+ item", lineStart))
+        assertEquals("""\---""", Markdown.escapeInline("---", lineStart))
+        // A dash inside a word at line start is not list/break syntax.
+        assertEquals("-x", Markdown.escapeInline("-x", lineStart))
+        assertEquals("well-known", Markdown.escapeInline("well-known", lineStart))
+    }
+
+    @Test
+    fun `ordered list marker cannot re-parse as a list item`() {
+        val escaped = Markdown.escapeInline("1. x", lineStart)
+        assertEquals("""1\. x""", escaped)
+
+        assertEquals("""12\) y""", Markdown.escapeInline("12) y", lineStart))
+        // Mid-line numbers stay untouched.
+        assertEquals("see 1. below", Markdown.escapeInline("see 1. below", midLine))
+        assertEquals("see 1. below", Markdown.escapeInline("see 1. below", lineStart))
+        // Not at a true line start: no escape.
+        assertEquals("1. x", Markdown.escapeInline("1. x", midLine))
+        // Ten or more digits cannot be a list marker.
+        assertEquals("1234567890. x", Markdown.escapeInline("1234567890. x", lineStart))
+    }
+
+    @Test
+    fun `multi-line text treats each physical line start as line start`() {
+        val context = MarkdownEscapeContext(
+            atLineStart = true,
+            containerPrefix = "> ",
+        )
+        val escaped = Markdown.escapeInline("first\n# second\n- third\n1. fourth", context)
+
+        assertEquals("first\n\\# second\n\\- third\n1\\. fourth", escaped)
+    }
+
+    @Test
+    fun `mid-line context still arms line-start rules after an embedded newline`() {
+        val escaped = Markdown.escapeInline("tail\n# heading", midLine)
+
+        assertEquals("tail\n\\# heading", escaped)
+    }
+
+    @Test
+    fun `backtick backslash ampersand and angle bracket are always escaped`() {
+        assertEquals("""a\`b""", Markdown.escapeInline("a`b", midLine))
+        assertEquals("""a\\b""", Markdown.escapeInline("a\\b", midLine))
+        assertEquals("""a\&b""", Markdown.escapeInline("a&b", midLine))
+        assertEquals("""a\<b""", Markdown.escapeInline("a<b", midLine))
+    }
+
+    @Test
+    fun `brackets are always escaped`() {
+        assertEquals("""\[text\](url)""", Markdown.escapeInline("[text](url)", midLine))
+    }
+
+    @Test
+    fun `emphasis delimiters escape when they could form delimiter runs`() {
+        assertEquals("""a\*b""", Markdown.escapeInline("a*b", midLine))
+        assertEquals("""\*emphasis\*""", Markdown.escapeInline("*emphasis*", midLine))
+        assertEquals("""\*\*strong\*\*""", Markdown.escapeInline("**strong**", midLine))
+        assertEquals("""\~\~struck\~\~""", Markdown.escapeInline("~~struck~~", midLine))
+        // Whitespace on both sides: the run can neither open nor close.
+        assertEquals("5 * 3", Markdown.escapeInline("5 * 3", midLine))
+        assertEquals("a ~ b", Markdown.escapeInline("a ~ b", midLine))
+    }
+
+    @Test
+    fun `intraword underscores are not escaped`() {
+        assertEquals("foo_bar_baz", Markdown.escapeInline("foo_bar_baz", midLine))
+        assertEquals("""\_lead""", Markdown.escapeInline("_lead", midLine))
+        assertEquals("""trail\_""", Markdown.escapeInline("trail_", midLine))
+        assertEquals("""\_emph\_""", Markdown.escapeInline("_emph_", midLine))
+    }
+
+    @Test
+    fun `line-start star bullet is escaped even when flanking rules would skip it`() {
+        assertEquals("""\* item""", Markdown.escapeInline("* item", lineStart))
+    }
+
+    @Test
+    fun `line-start tilde run is escaped so it cannot open a fence`() {
+        val escaped = Markdown.escapeInline("~~~", lineStart)
+        assertTrue(escaped.startsWith("""\~"""), "expected leading tilde escaped, got $escaped")
+    }
+
+    @Test
+    fun `code span delimiters widen past internal backtick runs and pad`() {
+        val delimiters = Markdown.codeSpanDelimiters("a`b")
+
+        assertEquals("``", delimiters.fence)
+        assertTrue(delimiters.padded)
+        assertEquals("`` ", delimiters.open)
+        assertEquals(" ``", delimiters.close)
+    }
+
+    @Test
+    fun `code span delimiters for plain content are a single unpadded backtick`() {
+        val delimiters = Markdown.codeSpanDelimiters("plain code")
+
+        assertEquals("`", delimiters.fence)
+        assertFalse(delimiters.padded)
+        assertEquals("`", delimiters.open)
+        assertEquals("`", delimiters.close)
+    }
+
+    @Test
+    fun `code span content with edge spaces is padded but all-space content is not`() {
+        assertTrue(Markdown.codeSpanDelimiters(" x ").padded)
+        assertTrue(Markdown.codeSpanDelimiters(" x").padded)
+        assertFalse(Markdown.codeSpanDelimiters("   ").padded)
+        assertFalse(Markdown.codeSpanDelimiters("").padded)
+    }
+
+    @Test
+    fun `code span fence is longer than the longest internal run`() {
+        assertEquals("````", Markdown.codeSpanDelimiters("a ``` b").fence)
+        assertEquals("``", Markdown.codeSpanDelimiters("`").fence)
+    }
+
+    @Test
+    fun `link destination with parens or spaces uses the angle form`() {
+        assertEquals("<http://x/(1)>", Markdown.escapeLinkDestination("http://x/(1)"))
+        assertEquals("<a b>", Markdown.escapeLinkDestination("a b"))
+        assertEquals("<>", Markdown.escapeLinkDestination(""))
+    }
+
+    @Test
+    fun `plain link destination stays bare`() {
+        assertEquals("../guide.md", Markdown.escapeLinkDestination("../guide.md"))
+        assertEquals("https://example.com/path?q=1#frag", Markdown.escapeLinkDestination("https://example.com/path?q=1#frag"))
+        assertEquals("mailto:user@example.com", Markdown.escapeLinkDestination("mailto:user@example.com"))
+    }
+
+    @Test
+    fun `angle form escapes angle brackets and backslashes`() {
+        assertEquals("""<a\<b\>c d>""", Markdown.escapeLinkDestination("a<b>c d"))
+        assertEquals("""<a\\b c>""", Markdown.escapeLinkDestination("""a\b c"""))
+    }
+
+    @Test
+    fun `link text escapes brackets and inline syntax`() {
+        assertEquals("""\[x\]""", Markdown.escapeLinkText("[x]"))
+        assertEquals("""a \`code\` b""", Markdown.escapeLinkText("a `code` b"))
+        assertEquals("""\*em\*""", Markdown.escapeLinkText("*em*"))
+    }
+
+    @Test
+    fun `escaped hostile fixtures contain no unescaped structural triggers at line starts`() {
+        for (hostile in MarkdownHostileTextFixtures.strings) {
+            val escaped = Markdown.escapeInline(hostile, lineStart)
+            for (line in escaped.split('\n', '\r')) {
+                // Line-start syntax sees through up to 3 leading spaces.
+                val content = line.trimStart(' ')
+                if (content.isEmpty() || line.length - content.length >= 4) continue
+                val first = content.first()
+                assertFalse(
+                    first == '#' || first == '>' || first == '`' || first == '~' || first == '=',
+                    "line-start trigger '$first' left unescaped in: $line (from: $hostile)",
+                )
+                assertFalse(
+                    (first == '-' || first == '+' || first == '*') &&
+                        (content.length == 1 || content[1] == ' ' || content[1] == '\t' || content[1] == first),
+                    "unescaped list/break marker at line start in: $line (from: $hostile)",
+                )
+                val digits = content.takeWhile { it in '0'..'9' }
+                assertFalse(
+                    digits.length in 1..9 && content.length > digits.length &&
+                        (content[digits.length] == '.' || content[digits.length] == ')') &&
+                        (content.length == digits.length + 1 || content[digits.length + 1] == ' '),
+                    "unescaped ordered-list marker at line start in: $line (from: $hostile)",
+                )
+                for ((i, c) in content.withIndex()) {
+                    if (c != '|') continue
+                    assertTrue(
+                        i > 0 && content[i - 1] == '\\',
+                        "unescaped pipe in: $line (from: $hostile)",
+                    )
+                }
+            }
+        }
+    }
+
+    @Test
+    fun `escaping is idempotent-safe on empty input`() {
+        assertEquals("", Markdown.escapeInline("", lineStart))
+    }
+
+    @Test
+    fun `block markers behind one to three leading spaces are still escaped`() {
+        assertEquals(" \\# b", Markdown.escapeInline(" # b", lineStart))
+        assertEquals("   \\- x", Markdown.escapeInline("   - x", lineStart))
+        assertEquals("  1\\. x", Markdown.escapeInline("  1. x", lineStart))
+        assertEquals(" \\> q", Markdown.escapeInline(" > q", lineStart))
+        assertEquals("a\n \\# b", Markdown.escapeInline("a\n # b", midLine))
+    }
+
+    @Test
+    fun `markers behind four or more leading spaces are indented-code territory and stay untouched`() {
+        assertEquals("    # b", Markdown.escapeInline("    # b", lineStart))
+        assertEquals("    - x", Markdown.escapeInline("    - x", lineStart))
+    }
+
+    @Test
+    fun `carriage-return line endings re-arm line-start rules`() {
+        assertEquals("a\r\\# b", Markdown.escapeInline("a\r# b", midLine))
+        assertEquals("a\r\n\\- x", Markdown.escapeInline("a\r\n- x", midLine))
+        // '\r' also terminates a bullet/ordered marker.
+        assertEquals("\\-\rx", Markdown.escapeInline("-\rx", lineStart))
+        assertEquals("1\\.\rx", Markdown.escapeInline("1.\rx", lineStart))
+    }
+
+    @Test
+    fun `pipe and dollar are always escaped to guard recognizer syntax`() {
+        assertEquals("a\\|b", Markdown.escapeInline("a|b", midLine))
+        assertEquals("\\| a \\| b \\|", Markdown.escapeInline("| a | b |", lineStart))
+        assertEquals("\\$5 and \\$6", Markdown.escapeInline("$5 and $6", midLine))
+        assertEquals("\\$\\$", Markdown.escapeInline("$$", lineStart))
+    }
+
+    @Test
+    fun `code span delimiters flag unrepresentable content for fallback`() {
+        assertTrue(Markdown.codeSpanDelimiters("").requiresFallback)
+        assertTrue(Markdown.codeSpanDelimiters("a\nb").requiresFallback)
+        assertTrue(Markdown.codeSpanDelimiters("a\rb").requiresFallback)
+        assertFalse(Markdown.codeSpanDelimiters("a`b").requiresFallback)
+        assertFalse(Markdown.codeSpanDelimiters("plain").requiresFallback)
+    }
+}
diff --git a/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownFuzzTest.kt b/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownFuzzTest.kt
new file mode 100644
index 0000000..4aaec36
--- /dev/null
+++ b/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownFuzzTest.kt
@@ -0,0 +1,63 @@
+package io.github.linreal.cascade.editor.markdown
+
+import kotlin.random.Random
+import kotlin.test.Test
+import kotlin.test.assertTrue
+
+/**
+ * Fuzz suite: random hostile input across every reference profile must
+ * terminate and stay within the codec's warning/output limits.
+ */
+class MarkdownFuzzTest {
+
+    private val limits = MarkdownCodecLimits.Default
+
+    private val profiles: List<MarkdownProfile> = listOf(
+        MarkdownProfile.Default,
+        MarkdownReferenceProfiles.StrictGfmFieldProfile,
+        MarkdownReferenceProfiles.StrictHardBreakFieldProfile,
+    )
+
+    private fun assertBounded(input: String, profile: MarkdownProfile) {
+        val decode = MarkdownSchema.decodeWithReport(input, profile, limits)
+        assertTrue(decode.warnings.size <= limits.maxWarnings + 1, "warnings bounded")
+        if (decode.isSuccess) {
+            val encode = MarkdownSchema.encodeWithReport(decode.blocks!!, profile, limits)
+            if (encode.isSuccess) {
+                assertTrue(encode.markdown!!.length <= limits.maxOutputChars, "output bounded")
+            }
+        }
+    }
+
+    @Test
+    fun `random hostile input terminates bounded across every profile`() {
+        val alphabet = "#*_~`[]()<>|$\\!-. \n\t\rabcXYZ=+".toCharArray()
+        val random = Random(0xF0FA)
+        repeat(500) {
+            val length = random.nextInt(0, 600)
+            val input = buildString {
+                repeat(length) { append(alphabet[random.nextInt(alphabet.size)]) }
+            }
+            for (profile in profiles) assertBounded(input, profile)
+        }
+    }
+
+    @Test
+    fun `multi-kilobyte and deeply nested inputs terminate bounded`() {
+        val inputs = listOf(
+            "text ".repeat(4000),
+            "> ".repeat(2000) + "deep quote",
+            "          ".repeat(500) + "deep indent",
+            "- ".repeat(3000) + "x",
+            "*".repeat(20_000),
+            "`".repeat(20_000),
+            "[".repeat(20_000),
+            "<u>".repeat(4000),
+            ("a\n\n").repeat(3000),
+        )
+        for (input in inputs) {
+            for (profile in profiles) assertBounded(input, profile)
+        }
+    }
+
+}
diff --git a/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownHardBreakTest.kt b/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownHardBreakTest.kt
new file mode 100644
index 0000000..6364d5f
--- /dev/null
+++ b/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownHardBreakTest.kt
@@ -0,0 +1,100 @@
+package io.github.linreal.cascade.editor.markdown
+
+import io.github.linreal.cascade.editor.core.BlockContent
+import io.github.linreal.cascade.editor.core.BlockType
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+
+/**
+ * NewlineSemantics.HardBreak mode. Every source newline in a text
+ * leaf is a literal line break, blank-line runs become explicit empty
+ * paragraphs, and `setextHeading` / `indentedCode` are dropped.
+ *
+ * The canonical encode terminates with one final newline (like CommonMark), so
+ * the string assertions below carry that trailing `\n`; the load-bearing
+ * contract is `decode(encode(x)) == x`, asserted throughout.
+ */
+class MarkdownHardBreakTest {
+
+    // withNewlineSemantics rebinds the default support-set claim to the new
+    // profile, so this profile's own support set already allows empty text
+    // blocks and verifies encodes under HardBreak.
+    private val profile = MarkdownProfile.Default.withNewlineSemantics(NewlineSemantics.HardBreak)
+
+    private fun texts(markdown: String): List<Pair<BlockType, String>> =
+        MarkdownSchema.decode(markdown, profile)!!.map {
+            it.type to ((it.content as? BlockContent.Text)?.text ?: "")
+        }
+
+    @Test
+    fun `single newline is one paragraph with literal newline`() {
+        val blocks = MarkdownSchema.decode("a\nb", profile)!!
+        assertEquals(1, blocks.size)
+        assertEquals("a\nb", (blocks.single().content as BlockContent.Text).text)
+        assertEquals("a\nb\n", MarkdownSchema.encode(blocks, profile))
+    }
+
+    @Test
+    fun `two blank lines become two empty paragraphs`() {
+        val blocks = MarkdownSchema.decode("a\n\n\nb", profile)!!
+        assertEquals(
+            listOf("a", "", "", "b"),
+            blocks.map { (it.content as BlockContent.Text).text },
+        )
+        // N=2 empties → N+1 = 3 intervening newlines; one final newline appended.
+        assertEquals("a\n\n\nb\n", MarkdownSchema.encode(blocks, profile))
+    }
+
+    @Test
+    fun `setext underline is not recognized in hard-break mode`() {
+        val decoded = texts("text\n---")
+        assertEquals(BlockType.Paragraph, decoded[0].first)
+        assertEquals("text", decoded[0].second)
+        assertEquals(BlockType.Divider, decoded[1].first)
+    }
+
+    @Test
+    fun `four-space indent is paragraph content not code`() {
+        val decoded = texts("    code")
+        assertEquals(1, decoded.size)
+        assertEquals(BlockType.Paragraph, decoded.single().first)
+    }
+
+    @Test
+    fun `trailing blank line survives round-trip`() {
+        val blocks = MarkdownSchema.decode("a\n\n", profile)!!
+        assertEquals(listOf("a", ""), blocks.map { (it.content as BlockContent.Text).text })
+        val reencoded = MarkdownSchema.encode(blocks, profile)!!
+        val redecoded = MarkdownSchema.decode(reencoded, profile)!!
+        assertEquals(
+            blocks.map { (it.content as BlockContent.Text).text },
+            redecoded.map { (it.content as BlockContent.Text).text },
+        )
+    }
+
+    @Test
+    fun `support set claims empty text blocks in hard-break mode`() {
+        assertTrue(profile.supportSet.supportsDocument(MarkdownSchema.decode("a\n\nb", profile)!!))
+    }
+
+    @Test
+    fun `property round-trip of generated hard-break documents`() {
+        val generator = MarkdownSupportSetBlockGenerator(
+            profile = profile,
+            supportSet = profile.supportSet,
+            seed = 0x11A2DBEEF,
+            hardBreak = true,
+        )
+        repeat(300) {
+            val blocks = generator.nextDocument()
+            val encoded = MarkdownSchema.encode(blocks, profile) ?: error("encode aborted: $blocks")
+            val decoded = MarkdownSchema.decode(encoded, profile) ?: error("decode aborted:\n$encoded")
+            try {
+                assertMarkdownSemanticallyEquals(blocks, decoded)
+            } catch (failure: AssertionError) {
+                throw AssertionError("hard-break counterexample:\n$encoded", failure)
+            }
+        }
+    }
+}
diff --git a/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownHostileTextFixtures.kt b/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownHostileTextFixtures.kt
new file mode 100644
index 0000000..7877337
--- /dev/null
+++ b/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownHostileTextFixtures.kt
@@ -0,0 +1,64 @@
+package io.github.linreal.cascade.editor.markdown
+
+/**
+ * Hostile plain-text fixtures: strings that read as ordinary content but are
+ * built entirely of Markdown syntax triggers and reused by the round-trip
+ * property tests — any text drawn from
+ * this list must survive `decode(encode(paragraph(text)))` unchanged once the
+ * codec pipeline exists.
+ */
+internal object MarkdownHostileTextFixtures {
+
+    val strings: List<String> = listOf(
+        // Line-start block syntax.
+        "# not a heading",
+        "## also not a heading",
+        "> not a quote",
+        "- not a bullet",
+        "+ not a bullet either",
+        "* not a bullet",
+        "1. not an ordered item",
+        "12) also not an ordered item",
+        "--- not a break, but this line is:",
+        "---",
+        "***",
+        "___",
+        "===",
+        "~~~ not a fence",
+        "``` not a fence",
+        // Emphasis and code delimiters.
+        "*emphasis* and **strong** and _under_ and __dunder__",
+        "a*b*c and foo_bar_baz",
+        "***triple*** ~~struck~~ ~single~",
+        "`code span` and ``wide `span``",
+        "5 * 3 = 15 and 4 _ 2",
+        // Links, images, autolinks, HTML, entities.
+        "[text](url) and [ref][label] and ![img](u)",
+        "<https://autolink.example> and <u>tag</u>",
+        "&amp; &nbsp; &#35; &unknown;",
+        // Escapes.
+        """backslash \ and \* literal""",
+        // Multi-line combinations: every continuation line re-arms line-start
+        // syntax.
+        "first\n# second line heading",
+        "quote line\n> continuation",
+        "para\n- list continuation\n1. ordered continuation",
+        "setext bait\n===\nand\n---",
+        // Recognizer-shaped content: pipe tables, math blocks/spans, front
+        // matter. Must re-decode as paragraph text, never as md.preserved.
+        "| a | b |\n| - | - |\n| 1 | 2 |",
+        "col a | col b",
+        "$$\nE = mc^2\n$$",
+        "inline \$x^2\$ math and \$5 prices",
+        "---\ntitle: not front matter\n---",
+        // Block markers hiding behind 1-3 leading spaces (still block syntax
+        // per CommonMark) and carriage-return line endings.
+        " # spaced heading bait",
+        "   - spaced bullet bait",
+        "  1. spaced ordered bait",
+        "cr line\r# heading after cr\r\n- bullet after crlf",
+        // Mixed pathological soup.
+        "#*`_~[]()<>&\\!|=+-.",
+        "  leading spaces and trailing spaces  ",
+    )
+}
diff --git a/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownHtmlBridgeTest.kt b/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownHtmlBridgeTest.kt
new file mode 100644
index 0000000..fbd4dfb
--- /dev/null
+++ b/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownHtmlBridgeTest.kt
@@ -0,0 +1,116 @@
+package io.github.linreal.cascade.editor.markdown
+
+import io.github.linreal.cascade.editor.core.Block
+import io.github.linreal.cascade.editor.core.BlockContent
+import io.github.linreal.cascade.editor.core.SpanStyle
+import io.github.linreal.cascade.editor.core.TextSpan
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+
+class MarkdownHtmlBridgeTest {
+
+    private fun spansOf(markdown: String): Pair<String, List<TextSpan>> {
+        val block = MarkdownSchema.decode(markdown, MarkdownProfile.Default)!!.single()
+        val content = block.content as BlockContent.Text
+        return content.text to content.spans
+    }
+
+    @Test
+    fun `inline paired tag bridges and keeps nested markdown`() {
+        val result = MarkdownSchema.decodeWithReport("<u>**bold** x</u>", MarkdownProfile.Default)
+        val content = result.blocks!!.single().content as BlockContent.Text
+        assertEquals("bold x", content.text)
+        assertTrue(content.spans.any { it.style == SpanStyle.Underline && it.start == 0 && it.end == 6 })
+        assertTrue(content.spans.any { it.style == SpanStyle.Bold && it.start == 0 && it.end == 4 })
+        assertTrue(result.warnings.any { it is MarkdownDecodeWarning.HtmlBridged })
+    }
+
+    @Test
+    fun `underline and highlight encode as html and round-trip`() {
+        val block = Block.paragraph(
+            "abcdef",
+            spans = listOf(
+                TextSpan(0, 3, SpanStyle.Underline),
+                TextSpan(3, 6, SpanStyle.Highlight(0x80FF0000L)),
+            ),
+        )
+        val encoded = MarkdownSchema.encode(listOf(block), MarkdownProfile.Default)!!
+        assertTrue(encoded.contains("<u>abc</u>"), "expected <u> in: $encoded")
+        assertTrue(
+            encoded.contains("<mark data-cascade-highlight=\"80FF0000\">def</mark>"),
+            "expected <mark> in: $encoded",
+        )
+        val (text, spans) = spansOf(encoded.trimEnd('\n'))
+        assertEquals("abcdef", text)
+        assertTrue(spans.any { it.style == SpanStyle.Underline && it.start == 0 && it.end == 3 })
+        assertTrue(spans.any { it.style is SpanStyle.Highlight && it.start == 3 && it.end == 6 })
+    }
+
+    @Test
+    fun `html comment under bridge plus preserve becomes preserved html block`() {
+        val result = MarkdownSchema.decodeWithReport("<!-- separator -->", MarkdownProfile.Default)
+        val block = result.blocks!!.single()
+        val content = block.content
+        assertTrue(
+            content is BlockContent.Custom && content.typeId == MARKDOWN_PRESERVED_HTML_TYPE_ID,
+            "expected md.preservedHtml, got $content",
+        )
+        assertTrue(result.warnings.any { it is MarkdownDecodeWarning.PreservedSyntax })
+    }
+
+    @Test
+    fun `bridged island with an unknown inner tag records data loss and analyzes raw fallback`() {
+        val input = "<u><blink>x</blink></u>"
+        val result = MarkdownSchema.decodeWithReport(input, MarkdownProfile.Default)
+        val content = result.blocks!!.single().content as BlockContent.Text
+        // The inner text survives with Underline, but the dropped <blink> is data loss.
+        assertEquals("x", content.text)
+        assertTrue(content.spans.any { it.style == SpanStyle.Underline })
+        val stripped = result.warnings.filterIsInstance<MarkdownDecodeWarning.HtmlStripped>()
+        assertTrue(stripped.isNotEmpty(), "expected an HtmlStripped DataLoss warning")
+        assertTrue(result.warnings.any { it.impact == MarkdownFidelityImpact.DataLoss })
+        assertTrue(result.warnings.none { it is MarkdownDecodeWarning.HtmlBridged })
+        // Re-based range points inside the Markdown source.
+        assertTrue(stripped.all { it.range.start in 0..input.length })
+
+        val report = MarkdownSchema.analyze(input, MarkdownProfile.Default)
+        assertEquals(MarkdownEditModeRecommendation.RawFallback, report.recommendedMode)
+    }
+
+    @Test
+    fun `empty inline island is not a successful bridge`() {
+        // <u></u> has no content: under Default (Bridge + Preserve) the leaf
+        // escalates to a preserved block rather than a clean bridge.
+        val result = MarkdownSchema.decodeWithReport("<u></u>", MarkdownProfile.Default)
+        val content = result.blocks!!.single().content
+        assertTrue(content is BlockContent.Custom && content.typeId == MARKDOWN_PRESERVED_TYPE_ID)
+        assertTrue(result.warnings.none { it is MarkdownDecodeWarning.HtmlBridged })
+    }
+
+    @Test
+    fun `flood of unmatched inline html opens terminates`() {
+        val flood = "<a foo>text ".repeat(5000)
+        val result = MarkdownSchema.decodeWithReport(flood, MarkdownProfile.Default)
+        // Bounded scan: completes (aborted or success) without hanging.
+        assertTrue(result.isSuccess || result.isAborted)
+    }
+
+    @Test
+    fun `bold partially overlapping underline round-trips`() {
+        val block = Block.paragraph(
+            "abcdef",
+            spans = listOf(
+                TextSpan(0, 4, SpanStyle.Bold),
+                TextSpan(2, 6, SpanStyle.Underline),
+            ),
+        )
+        val encoded = MarkdownSchema.encodeWithReport(listOf(block), MarkdownProfile.Default)
+        assertTrue(encoded.isSuccess)
+        assertTrue(encoded.warnings.none { it.impact == MarkdownFidelityImpact.DataLoss })
+        val (text, spans) = spansOf(encoded.markdown!!.trimEnd('\n'))
+        assertEquals("abcdef", text)
+        assertTrue(spans.any { it.style == SpanStyle.Bold && it.start == 0 && it.end == 4 })
+        assertTrue(spans.any { it.style == SpanStyle.Underline && it.start == 2 && it.end == 6 })
+    }
+}
diff --git a/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownInlineBasicsTest.kt b/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownInlineBasicsTest.kt
new file mode 100644
index 0000000..204b7c6
--- /dev/null
+++ b/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownInlineBasicsTest.kt
@@ -0,0 +1,263 @@
+package io.github.linreal.cascade.editor.markdown
+
+import io.github.linreal.cascade.editor.core.BlockContent
+import io.github.linreal.cascade.editor.core.SpanStyle
+import io.github.linreal.cascade.editor.core.TextSpan
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertIs
+import kotlin.test.assertTrue
+import kotlin.test.fail
+
+/**
+ * Inline phase basics — code spans, escapes, hard/soft breaks,
+ * entities, and inline resource limits. Emphasis has its own directed fixture
+ * file ([MarkdownEmphasisTest]).
+ */
+class MarkdownInlineBasicsTest {
+
+    private fun decode(
+        input: String,
+        profile: MarkdownProfile = MarkdownProfile.Default,
+        limits: MarkdownCodecLimits = MarkdownCodecLimits.Default,
+    ): MarkdownDecodeResult = MarkdownDecodeEngine.decode(input, profile, limits)
+
+    private fun MarkdownDecodeResult.singleText(): BlockContent.Text {
+        val block = blocks?.singleOrNull()
+            ?: fail("expected one block, got blocks=$blocks warnings=$warnings")
+        return assertIs<BlockContent.Text>(block.content)
+    }
+
+    // Code spans
+
+    @Test
+    fun codeSpanBindsBeforeEmphasis() {
+        val content = decode("`a**b`").singleText()
+        assertEquals("a**b", content.text)
+        assertEquals(listOf(TextSpan(0, 4, SpanStyle.InlineCode)), content.spans)
+    }
+
+    @Test
+    fun codeSpanCloserMustMatchOpenerRunLength() {
+        val content = decode("``a`b``").singleText()
+        assertEquals("a`b", content.text)
+        assertEquals(listOf(TextSpan(0, 3, SpanStyle.InlineCode)), content.spans)
+    }
+
+    @Test
+    fun unmatchedBacktickRunStaysLiteralAndRestParses() {
+        val content = decode("`a *b*").singleText()
+        assertEquals("`a b", content.text)
+        assertEquals(listOf(TextSpan(3, 4, SpanStyle.Italic)), content.spans)
+    }
+
+    @Test
+    fun codeSpanStripsOneSpacePerCommonMark() {
+        val content = decode("` `` `").singleText()
+        assertEquals("``", content.text)
+        assertEquals(listOf(TextSpan(0, 2, SpanStyle.InlineCode)), content.spans)
+    }
+
+    @Test
+    fun allSpaceCodeSpanContentIsNotStripped() {
+        val content = decode("` `").singleText()
+        assertEquals(" ", content.text)
+    }
+
+    @Test
+    fun codeSpanNormalizesInternalLineEndingToSpace() {
+        val content = decode("`a\nb`").singleText()
+        assertEquals("a b", content.text)
+        assertEquals(listOf(TextSpan(0, 3, SpanStyle.InlineCode)), content.spans)
+    }
+
+    // Escapes
+
+    @Test
+    fun backslashEscapesAsciiPunctuation() {
+        val content = decode("""\*not em\*""").singleText()
+        assertEquals("*not em*", content.text)
+        assertTrue(content.spans.isEmpty())
+    }
+
+    @Test
+    fun backslashBeforeNonPunctuationStaysLiteral() {
+        val content = decode("""a\b""").singleText()
+        assertEquals("""a\b""", content.text)
+    }
+
+    // Hard and soft breaks
+
+    @Test
+    fun trailingBackslashIsAHardBreak() {
+        val content = decode("a\\\nb").singleText()
+        assertEquals("a\nb", content.text)
+    }
+
+    @Test
+    fun twoTrailingSpacesAreAHardBreak() {
+        val content = decode("a  \nb").singleText()
+        assertEquals("a\nb", content.text)
+    }
+
+    @Test
+    fun oneTrailingSpaceIsASoftBreak() {
+        val content = decode("a \nb").singleText()
+        assertEquals("a b", content.text)
+    }
+
+    @Test
+    fun softBreakLowersPerPolicy() {
+        assertEquals("a b", decode("a\nb").singleText().text)
+        val lineBreak = MarkdownProfile.Default.withSoftBreak(SoftBreak.LineBreak)
+        assertEquals("a\nb", decode("a\nb", lineBreak).singleText().text)
+    }
+
+    @Test
+    fun trailingBackslashAtEndOfParagraphStaysLiteral() {
+        val content = decode("foo\\").singleText()
+        assertEquals("foo\\", content.text)
+    }
+
+    @Test
+    fun hardBreakModeKeepsEveryNewlineLiteral() {
+        val profile = MarkdownProfile.Default.withNewlineSemantics(NewlineSemantics.HardBreak)
+        assertEquals("a\nb", decode("a\nb", profile).singleText().text)
+    }
+
+    // Entities
+
+    @Test
+    fun entitiesDecodeOutsideCodeSpans() {
+        val content = decode("&amp; &#x41; &nbsp;").singleText()
+        assertEquals("& A \u00A0", content.text)
+    }
+
+    @Test
+    fun entitiesDoNotDecodeInsideCodeSpans() {
+        val content = decode("`&amp;`").singleText()
+        assertEquals("&amp;", content.text)
+    }
+
+    @Test
+    fun unknownEntityNameStaysLiteralWithInformationalWarningAndExactRange() {
+        val input = "ab &nosuch; cd"
+        val result = decode(input)
+        assertEquals("ab &nosuch; cd", result.singleText().text)
+        val warning = result.warnings
+            .filterIsInstance<MarkdownDecodeWarning.UnsupportedEntity>()
+            .single()
+        assertEquals("nosuch", warning.name)
+        assertEquals(MarkdownFidelityImpact.Informational, warning.impact)
+        assertEquals(MarkdownSourceRange(3, 11), warning.range)
+    }
+
+    @Test
+    fun entityDecodeNonePassesReferencesThrough() {
+        val profile = MarkdownProfile.Default.withEntityDecode(EntityDecode.None)
+        val result = decode("&amp;", profile)
+        assertEquals("&amp;", result.singleText().text)
+        assertTrue(result.warnings.none { it is MarkdownDecodeWarning.UnsupportedEntity })
+    }
+
+    // Limits
+
+    @Test
+    fun spansPerBlockLimitAborts() {
+        val result = decode(
+            "*a* *b* *c*",
+            limits = MarkdownCodecLimits.Default.copy(maxSpansPerBlock = 2),
+        )
+        assertTrue(result.isAborted)
+        val fatal = result.warnings.filterIsInstance<MarkdownDecodeWarning.LimitExceeded>().single()
+        assertEquals(MarkdownCodecLimitKind.SpansPerBlock, fatal.kind)
+    }
+
+    @Test
+    fun totalSpansLimitAbortsAcrossBlocks() {
+        val result = decode(
+            "*a* *b*\n\n*c* *d*",
+            limits = MarkdownCodecLimits.Default.copy(maxTotalSpans = 3),
+        )
+        assertTrue(result.isAborted)
+        val fatal = result.warnings.filterIsInstance<MarkdownDecodeWarning.LimitExceeded>().single()
+        assertEquals(MarkdownCodecLimitKind.TotalSpans, fatal.kind)
+    }
+
+    @Test
+    fun delimiterRunLimitAbortsInsteadOfSlowResolution() {
+        val input = "*a".repeat(300)
+        val result = decode(
+            input,
+            limits = MarkdownCodecLimits.Default.copy(maxDelimiterRuns = 100),
+        )
+        assertTrue(result.isAborted)
+        val fatal = result.warnings.filterIsInstance<MarkdownDecodeWarning.LimitExceeded>().single()
+        assertEquals(MarkdownCodecLimitKind.DelimiterRuns, fatal.kind)
+    }
+
+    @Test
+    fun adversarialDelimiterInputIsBoundedByDefaultLimits() {
+        // A single 10k-character run plus thousands of small runs: both must
+        // complete or abort within the limits — never hang.
+        val singleRun = "*".repeat(10_000)
+        val manyRuns = "*a".repeat(4_000)
+        for (input in listOf(singleRun, manyRuns)) {
+            val result = decode(input)
+            assertTrue(result.isSuccess || result.isAborted)
+        }
+    }
+
+    @Test
+    fun adversarialBacktickAndBracketFloodsAreBounded() {
+        // Neither construct is covered by maxDelimiterRuns; the per-text
+        // backtick index and bracket-match table keep these linear (an
+        // unmatched opener must never rescan to end-of-text per character).
+        val floods = listOf(
+            // "x " keeps the backtick floods inside a paragraph leaf — a line
+            // starting with three-plus backticks is a code fence at block level.
+            "x " + "`".repeat(10_000),
+            "`".repeat(10_000),
+            "[".repeat(10_000),
+            "![".repeat(5_000),
+            // Strictly increasing run lengths: every opener is unmatched.
+            buildString {
+                append("x ")
+                for (n in 1..120) {
+                    append("`".repeat(n)).append('x')
+                }
+            },
+        )
+        for (input in floods) {
+            val result = decode(input)
+            assertTrue(result.isSuccess || result.isAborted, "flood must complete bounded")
+        }
+        // An unmatched backtick flood is one maximal run — literal, no code span.
+        val literal = decode("x " + "`".repeat(64)).singleText()
+        assertEquals("x " + "`".repeat(64), literal.text)
+        assertTrue(literal.spans.isEmpty())
+    }
+
+    // Spans land on the block
+
+    @Test
+    fun leafSpansAreNormalizedVisibleCoordinates() {
+        val result = decode("x **bold** y")
+        val content = result.singleText()
+        assertEquals("x bold y", content.text)
+        assertEquals(listOf(TextSpan(2, 6, SpanStyle.Bold)), content.spans)
+    }
+
+    @Test
+    fun headingAndQuoteLeavesCarrySpans() {
+        val result = decode("# a *i*\n\n> q **b**")
+        val blocks = result.blocks ?: fail("aborted: ${result.warnings}")
+        val heading = assertIs<BlockContent.Text>(blocks[0].content)
+        assertEquals("a i", heading.text)
+        assertEquals(listOf(TextSpan(2, 3, SpanStyle.Italic)), heading.spans)
+        val quote = assertIs<BlockContent.Text>(blocks[1].content)
+        assertEquals("q b", quote.text)
+        assertEquals(listOf(TextSpan(2, 3, SpanStyle.Bold)), quote.spans)
+    }
+
+}
diff --git a/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownInlineEncodeTest.kt b/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownInlineEncodeTest.kt
new file mode 100644
index 0000000..4448c5d
--- /dev/null
+++ b/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownInlineEncodeTest.kt
@@ -0,0 +1,288 @@
+package io.github.linreal.cascade.editor.markdown
+
+import io.github.linreal.cascade.editor.core.Block
+import io.github.linreal.cascade.editor.core.BlockContent
+import io.github.linreal.cascade.editor.core.BlockId
+import io.github.linreal.cascade.editor.core.BlockType
+import io.github.linreal.cascade.editor.core.SpanStyle
+import io.github.linreal.cascade.editor.core.TextSpan
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertIs
+import kotlin.test.assertTrue
+import kotlin.test.fail
+
+/** Canonical marker emission with encode-side verification. */
+class MarkdownInlineEncodeTest {
+
+    private fun paragraph(text: String, vararg spans: TextSpan): Block = Block(
+        id = BlockId.generate(),
+        type = BlockType.Paragraph,
+        content = BlockContent.Text(text, spans.toList()),
+    )
+
+    private fun encode(
+        vararg blocks: Block,
+        profile: MarkdownProfile = MarkdownProfile.Default,
+    ): MarkdownEncodeResult = MarkdownEncodeEngine.encodeWithReport(blocks.toList(), profile)
+
+    private fun MarkdownEncodeResult.text(): String =
+        markdown ?: fail("encode aborted: $warnings")
+
+    private fun decodeSpans(
+        markdown: String,
+        profile: MarkdownProfile = MarkdownProfile.Default,
+    ): BlockContent.Text {
+        val result = MarkdownDecodeEngine.decode(markdown, profile)
+        val block = result.blocks?.singleOrNull()
+            ?: fail("expected one decoded block, warnings=${result.warnings}")
+        return assertIs<BlockContent.Text>(block.content)
+    }
+
+    // Canonical markers
+
+    @Test
+    fun boldAndItalicUseCanonicalMarkers() {
+        assertEquals(
+            "**bold**\n",
+            encode(paragraph("bold", TextSpan(0, 4, SpanStyle.Bold))).text(),
+        )
+        assertEquals(
+            "*italic*\n",
+            encode(paragraph("italic", TextSpan(0, 6, SpanStyle.Italic))).text(),
+        )
+        assertEquals(
+            "~~struck~~\n",
+            encode(paragraph("struck", TextSpan(0, 6, SpanStyle.StrikeThrough))).text(),
+        )
+    }
+
+    @Test
+    fun juxtaposedStarRunsSwitchItalicToUnderscore() {
+        val result = encode(
+            paragraph(
+                "(a)(b)",
+                TextSpan(0, 3, SpanStyle.Bold),
+                TextSpan(3, 6, SpanStyle.Italic),
+            ),
+        )
+        assertEquals("**(a)**_(b)_\n", result.text())
+        assertTrue(result.warnings.isEmpty())
+    }
+
+    @Test
+    fun intrawordJuxtapositionKeepsStarAndVerifies() {
+        // The italic boundary is intraword, so `_` cannot flank; the emitted
+        // `***` juxtaposition must still re-decode to exactly these spans.
+        val spans = listOf(
+            TextSpan(0, 1, SpanStyle.Bold),
+            TextSpan(1, 2, SpanStyle.Italic),
+        )
+        val result = encode(paragraph("ab", *spans.toTypedArray()))
+        val decoded = decodeSpans(result.text())
+        assertEquals("ab", decoded.text)
+        assertEquals(spans.toSet(), decoded.spans.toSet())
+    }
+
+    @Test
+    fun intrawordItalicKeepsStarMarker() {
+        val result = encode(paragraph("abc", TextSpan(1, 2, SpanStyle.Italic)))
+        assertEquals("a*b*c\n", result.text())
+        val decoded = decodeSpans(result.text())
+        assertEquals(listOf(TextSpan(1, 2, SpanStyle.Italic)), decoded.spans)
+    }
+
+    @Test
+    fun plainDelimiterCharactersAreEscaped() {
+        val result = encode(paragraph("a*b"))
+        val markdown = result.text()
+        val decoded = decodeSpans(markdown)
+        assertEquals("a*b", decoded.text)
+        assertTrue(decoded.spans.isEmpty())
+    }
+
+    // Inline code
+
+    @Test
+    fun boldFullyContainingCodeRoundTrips() {
+        val spans = listOf(
+            TextSpan(0, 3, SpanStyle.Bold),
+            TextSpan(1, 2, SpanStyle.InlineCode),
+        )
+        val result = encode(paragraph("abc", *spans.toTypedArray()))
+        assertEquals("**a`b`c**\n", result.text())
+        val decoded = decodeSpans(result.text())
+        assertEquals(spans.toSet(), decoded.spans.toSet())
+    }
+
+    @Test
+    fun codeSpanDelimitersWidenPastContentBackticks() {
+        val result = encode(paragraph("a`b", TextSpan(0, 3, SpanStyle.InlineCode)))
+        // The helper widens past the internal run and pads conservatively;
+        // CommonMark's strip-one-space rule undoes the padding on decode.
+        assertEquals("`` a`b ``\n", result.text())
+        val decoded = decodeSpans(result.text())
+        assertEquals("a`b", decoded.text)
+        assertEquals(listOf(TextSpan(0, 3, SpanStyle.InlineCode)), decoded.spans)
+    }
+
+    @Test
+    fun italicStrictlyInsideCodeIsDroppedWithoutBridge() {
+        val result = encode(
+            paragraph(
+                "abcd",
+                TextSpan(0, 4, SpanStyle.InlineCode),
+                TextSpan(1, 3, SpanStyle.Italic),
+            ),
+        )
+        assertEquals("`abcd`\n", result.text())
+        val warning = result.warnings
+            .filterIsInstance<MarkdownEncodeWarning.DroppedSpanOverlap>()
+            .single()
+        assertEquals(MarkdownTextRange(1, 3), warning.textRange)
+        val decoded = decodeSpans(result.text())
+        assertEquals(listOf(TextSpan(0, 4, SpanStyle.InlineCode)), decoded.spans)
+    }
+
+    @Test
+    fun newlineInCodeSpanDropsTheCodeMarks() {
+        val result = encode(paragraph("a\nb", TextSpan(0, 3, SpanStyle.InlineCode)))
+        assertEquals("a\\\nb\n", result.text())
+        assertTrue(result.warnings.filterIsInstance<MarkdownEncodeWarning.DroppedSpanOverlap>().isNotEmpty())
+        assertEquals("a\nb", decodeSpans(result.text()).text)
+    }
+
+    // Links
+
+    @Test
+    fun linkEncodesInlineFormWithStyledText() {
+        val spans = listOf(
+            TextSpan(0, 1, SpanStyle.Bold),
+            TextSpan(0, 1, SpanStyle.Link("../g.md")),
+        )
+        val result = encode(paragraph("x", *spans.toTypedArray()))
+        assertEquals("[**x**](../g.md)\n", result.text())
+        val decoded = decodeSpans(result.text())
+        assertEquals(spans.toSet(), decoded.spans.toSet())
+    }
+
+    @Test
+    fun destinationNeedingAngleFormGetsIt() {
+        val result = encode(paragraph("x", TextSpan(0, 1, SpanStyle.Link("http://x/(1)"))))
+        assertEquals("[x](<http://x/(1)>)\n", result.text())
+        val decoded = decodeSpans(result.text())
+        assertEquals(listOf(TextSpan(0, 1, SpanStyle.Link("http://x/(1)"))), decoded.spans)
+    }
+
+    // Hard breaks
+
+    @Test
+    fun hardBreaksEncodePerPolicyAndDecodeBothForms() {
+        val block = paragraph("a\nb")
+        assertEquals("a\\\nb\n", encode(block).text())
+        val twoSpaces = MarkdownProfile.Default.withHardBreakEncode(HardBreakEncode.TwoSpaces)
+        assertEquals("a  \nb\n", encode(block, profile = twoSpaces).text())
+        assertEquals("a\nb", decodeSpans("a\\\nb").text)
+        assertEquals("a\nb", decodeSpans("a  \nb").text)
+    }
+
+    @Test
+    fun spanAcrossHardBreakRoundTrips() {
+        val spans = listOf(TextSpan(0, 3, SpanStyle.Bold))
+        val result = encode(paragraph("a\nb", *spans.toTypedArray()))
+        assertEquals("**a\\\nb**\n", result.text())
+        val decoded = decodeSpans(result.text())
+        assertEquals("a\nb", decoded.text)
+        assertEquals(spans, decoded.spans)
+    }
+
+    // Prefixed blocks keep complete physical lines
+
+    @Test
+    fun quoteWithSpansPrefixesEveryPhysicalLine() {
+        val block = Block(
+            id = BlockId.generate(),
+            type = BlockType.Quote,
+            content = BlockContent.Text("a\nb", listOf(TextSpan(0, 3, SpanStyle.Bold))),
+        )
+        assertEquals("> **a\\\n> b**\n", encode(block).text())
+    }
+
+    @Test
+    fun listItemsCarrySpans() {
+        val block = Block(
+            id = BlockId.generate(),
+            type = BlockType.BulletList,
+            content = BlockContent.Text("hi", listOf(TextSpan(0, 2, SpanStyle.Bold))),
+        )
+        assertEquals("- **hi**\n", encode(block).text())
+    }
+
+    // Heading embedded newline decision
+
+    @Test
+    fun headingEmbeddedNewlineBecomesSpaceWithDataLoss() {
+        val block = Block(
+            id = BlockId.generate(),
+            type = BlockType.Heading(2),
+            content = BlockContent.Text("a\nb", listOf(TextSpan(0, 3, SpanStyle.Bold))),
+        )
+        val result = encode(block)
+        assertEquals("## **a b**\n", result.text())
+        assertTrue(
+            result.warnings.filterIsInstance<MarkdownEncodeWarning.DroppedAttribute>()
+                .any { it.attr == "lineBreak" },
+        )
+    }
+
+    // Span-free value exclusions must warn, never silently change (review fix)
+
+    @Test
+    fun plainTextValueExclusionsWarnInsteadOfSilentlyChanging() {
+        val cases = listOf("a  \nb", "a ", "  a", "    a", "a\t")
+        for (text in cases) {
+            val result = encode(paragraph(text))
+            val markdown = result.text()
+            val warned = result.warnings.any { it.impact == MarkdownFidelityImpact.DataLoss }
+            val decoded = MarkdownDecodeEngine.decode(markdown, MarkdownProfile.Default)
+            val roundTrips = (decoded.blocks?.singleOrNull()?.content as? BlockContent.Text)
+                ?.text == text
+            assertTrue(
+                warned || roundTrips,
+                "\"$text\" must round-trip exactly or carry a DataLoss warning; " +
+                    "got \"$markdown\" with ${result.warnings}",
+            )
+        }
+    }
+
+    @Test
+    fun ordinaryPlainTextStillEncodesWithoutWarnings() {
+        val result = encode(paragraph("plain text, nothing special"))
+        assertEquals("plain text, nothing special\n", result.text())
+        assertTrue(result.warnings.isEmpty())
+    }
+
+    @Test
+    fun textMismatchEmitsOneGenericWarningNotAmbiguousEmphasisPerSpan() {
+        // Trailing spaces before the hard break cannot round-trip; the bold
+        // span is innocent and must not be blamed (review fix, finding 6).
+        val result = encode(paragraph("a  \nb", TextSpan(0, 1, SpanStyle.Bold)))
+        assertTrue(result.warnings.none { it is MarkdownEncodeWarning.AmbiguousEmphasis })
+        assertTrue(
+            result.warnings.filterIsInstance<MarkdownEncodeWarning.DroppedSpanOverlap>()
+                .isNotEmpty(),
+        )
+    }
+
+    // Code blocks bypass the inline renderer entirely
+
+    @Test
+    fun codeBlockContentIsNeverEscaped() {
+        val block = Block(
+            id = BlockId.generate(),
+            type = BlockType.Code,
+            content = BlockContent.Text("*not em* [x](u)"),
+        )
+        assertEquals("```\n*not em* [x](u)\n```\n", encode(block).text())
+    }
+}
diff --git a/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownLinkDecodeTest.kt b/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownLinkDecodeTest.kt
new file mode 100644
index 0000000..e6abe1c
--- /dev/null
+++ b/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownLinkDecodeTest.kt
@@ -0,0 +1,222 @@
+package io.github.linreal.cascade.editor.markdown
+
+import io.github.linreal.cascade.editor.core.BlockContent
+import io.github.linreal.cascade.editor.core.SpanStyle
+import io.github.linreal.cascade.editor.core.TextSpan
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertIs
+import kotlin.test.assertTrue
+import kotlin.test.fail
+
+/** Inline links, autolinks, and reference resolution. */
+class MarkdownLinkDecodeTest {
+
+    private val degradeProfile =
+        MarkdownProfile.Default.withUnsupportedSyntax(UnsupportedSyntax.WarnAndDegrade)
+
+    private fun decode(
+        input: String,
+        profile: MarkdownProfile = MarkdownProfile.Default,
+    ): MarkdownDecodeResult = MarkdownDecodeEngine.decode(input, profile)
+
+    private fun MarkdownDecodeResult.firstText(): BlockContent.Text {
+        val block = blocks?.firstOrNull()
+            ?: fail("expected at least one block, warnings=$warnings")
+        return assertIs<BlockContent.Text>(block.content)
+    }
+
+    // Inline links
+
+    @Test
+    fun relativeTargetSurvivesExactly() {
+        val content = decode("[a](../guide.md)").firstText()
+        assertEquals("a", content.text)
+        assertEquals(listOf(TextSpan(0, 1, SpanStyle.Link("../guide.md"))), content.spans)
+    }
+
+    @Test
+    fun angleDestinationAllowsSpaces() {
+        val content = decode("[a](</url with space>)").firstText()
+        assertEquals(listOf(TextSpan(0, 1, SpanStyle.Link("/url with space"))), content.spans)
+    }
+
+    @Test
+    fun destinationBackslashEscapesAreUnescaped() {
+        val content = decode("""[a](/url\(1\))""").firstText()
+        assertEquals(listOf(TextSpan(0, 1, SpanStyle.Link("/url(1)"))), content.spans)
+    }
+
+    @Test
+    fun nestedStylesInsideLinkText() {
+        val content = decode("[**bold** text](u)").firstText()
+        assertEquals("bold text", content.text)
+        assertEquals(
+            setOf(
+                TextSpan(0, 4, SpanStyle.Bold),
+                TextSpan(0, 9, SpanStyle.Link("u")),
+            ),
+            content.spans.toSet(),
+        )
+    }
+
+    @Test
+    fun specialSchemeTargetsSurviveExactly() {
+        val targets = listOf("mailto:user@example.com", "tel:+123", "note://custom", "#heading")
+        for (target in targets) {
+            val content = decode("[x]($target)").firstText()
+            assertEquals(
+                listOf(TextSpan(0, 1, SpanStyle.Link(target))),
+                content.spans,
+                "target $target",
+            )
+        }
+    }
+
+    @Test
+    fun emphasisCannotSpanALinkBoundary() {
+        val content = decode("*a [b*](u)").firstText()
+        // The * inside the link text belongs to the nested parse; the outer
+        // opener finds no closer, so both stay literal.
+        assertEquals("*a b*", content.text)
+        assertEquals(listOf(TextSpan(3, 5, SpanStyle.Link("u"))), content.spans)
+    }
+
+    // Autolinks
+
+    @Test
+    fun uriAutolinkTextEqualsTarget() {
+        val content = decode("<https://x.example>").firstText()
+        assertEquals("https://x.example", content.text)
+        assertEquals(
+            listOf(TextSpan(0, 17, SpanStyle.Link("https://x.example"))),
+            content.spans,
+        )
+    }
+
+    @Test
+    fun emailAutolinkGetsMailtoTarget() {
+        val content = decode("<user@example.com>").firstText()
+        assertEquals("user@example.com", content.text)
+        assertEquals(
+            listOf(TextSpan(0, 16, SpanStyle.Link("mailto:user@example.com"))),
+            content.spans,
+        )
+    }
+
+    @Test
+    fun angleTextWithoutSchemeStaysLiteral() {
+        val content = decode("<not a link>").firstText()
+        assertEquals("<not a link>", content.text)
+        assertTrue(content.spans.isEmpty())
+    }
+
+    // Reference links
+
+    @Test
+    fun forwardReferenceResolves() {
+        val content = decode("[text][ref]\n\n[ref]: /url").firstText()
+        assertEquals("text", content.text)
+        assertEquals(listOf(TextSpan(0, 4, SpanStyle.Link("/url"))), content.spans)
+    }
+
+    @Test
+    fun allThreeReferenceFormsPlusAutolinkResolveInOneFixture() {
+        val input = "[full][ref] [ref][] [ref] <https://e.example>\n\n[ref]: /url"
+        val content = decode(input).firstText()
+        assertEquals("full ref ref https://e.example", content.text)
+        assertEquals(
+            setOf(
+                TextSpan(0, 4, SpanStyle.Link("/url")),
+                TextSpan(5, 8, SpanStyle.Link("/url")),
+                TextSpan(9, 12, SpanStyle.Link("/url")),
+                TextSpan(13, 30, SpanStyle.Link("https://e.example")),
+            ),
+            content.spans.toSet(),
+        )
+    }
+
+    @Test
+    fun unresolvedReferenceStaysLiteralWithoutWarnings() {
+        val result = decode("[text][missing]")
+        val content = result.firstText()
+        assertEquals("[text][missing]", content.text)
+        assertTrue(content.spans.isEmpty())
+        assertTrue(result.warnings.isEmpty())
+    }
+
+    @Test
+    fun labelNormalizationAppliesOnLookup() {
+        val content = decode("[x][  ThE   LaBeL ]\n\n[the label]: /url").firstText()
+        assertEquals(listOf(TextSpan(0, 1, SpanStyle.Link("/url"))), content.spans)
+    }
+
+    @Test
+    fun closingBracketInsideCodeSpanDoesNotTerminateLinkText() {
+        // The bracket-match table treats code spans as opaque (CommonMark
+        // precedence): the `]` inside `` `…` `` is code content.
+        val content = decode("[`]`](u)").firstText()
+        assertEquals("]", content.text)
+        assertEquals(
+            setOf(
+                TextSpan(0, 1, SpanStyle.InlineCode),
+                TextSpan(0, 1, SpanStyle.Link("u")),
+            ),
+            content.spans.toSet(),
+        )
+    }
+
+    // Nested links
+
+    @Test
+    fun innerLinkWinsAndOuterBracketsStayLiteral() {
+        val content = decode("[a [b](u2)](u1)").firstText()
+        assertEquals("[a b](u1)", content.text)
+        assertEquals(listOf(TextSpan(3, 4, SpanStyle.Link("u2"))), content.spans)
+    }
+
+    // Titles (WarnAndDegrade semantics here; Preserve escalates)
+
+    @Test
+    fun inlineTitleDegradesToLinkWithoutTitle() {
+        val result = decode("[a](u \"title\")", degradeProfile)
+        val content = result.firstText()
+        assertEquals(listOf(TextSpan(0, 1, SpanStyle.Link("u"))), content.spans)
+        val warning = result.warnings
+            .filterIsInstance<MarkdownDecodeWarning.DroppedAttribute>()
+            .single { it.construct == "link" }
+        assertEquals("title", warning.attr)
+        assertEquals(MarkdownFidelityImpact.DataLoss, warning.impact)
+    }
+
+    // Merge identity
+
+    @Test
+    fun adjacentSameUrlLinksMayMerge() {
+        val content = decode("[a](u)[b](u)").firstText()
+        assertEquals("ab", content.text)
+        // URL-exact merge identity: adjacent same-URL links normalize to one.
+        assertEquals(listOf(TextSpan(0, 2, SpanStyle.Link("u"))), content.spans)
+    }
+
+    @Test
+    fun adjacentDifferentUrlLinksStayDistinct() {
+        val content = decode("[a](u1)[b](u2)").firstText()
+        assertEquals(
+            listOf(
+                TextSpan(0, 1, SpanStyle.Link("u1")),
+                TextSpan(1, 2, SpanStyle.Link("u2")),
+            ),
+            content.spans,
+        )
+    }
+
+    @Test
+    fun emptyDestinationStaysLiteral() {
+        // SpanStyle.Link requires a nonblank target; `[a]()` cannot lower to a
+        // link and stays literal text (documented deviation).
+        val content = decode("[a]()").firstText()
+        assertEquals("[a]()", content.text)
+        assertTrue(content.spans.isEmpty())
+    }
+}
diff --git a/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownListOutlineEncodeTest.kt b/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownListOutlineEncodeTest.kt
new file mode 100644
index 0000000..959722c
--- /dev/null
+++ b/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownListOutlineEncodeTest.kt
@@ -0,0 +1,159 @@
+package io.github.linreal.cascade.editor.markdown
+
+import io.github.linreal.cascade.editor.core.Block
+import io.github.linreal.cascade.editor.core.BlockAttributes
+import io.github.linreal.cascade.editor.core.BlockContent
+import io.github.linreal.cascade.editor.core.BlockId
+import io.github.linreal.cascade.editor.core.BlockType
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+import kotlin.test.fail
+
+/** The `listOutline` group encoder (bullets, numbered, todos). */
+class MarkdownListOutlineEncodeTest {
+
+    private fun listBlock(type: BlockType, text: String, depth: Int = 0): Block = Block(
+        id = BlockId.generate(),
+        type = type,
+        content = BlockContent.Text(text),
+        attributes = BlockAttributes(indentationLevel = depth),
+    )
+
+    private fun encode(blocks: List<Block>): MarkdownEncodeResult =
+        MarkdownEncodeEngine.encodeWithReport(blocks, MarkdownProfile.Default)
+
+    private fun MarkdownEncodeResult.requireMarkdown(): String =
+        markdown ?: fail("expected a successful encode, got aborted with warnings=$warnings")
+
+    @Test
+    fun mixedOutlineNestsMarkerRelatively() {
+        val markdown = encode(
+            listOf(
+                listBlock(BlockType.BulletList, "a", depth = 0),
+                listBlock(BlockType.Todo(checked = true), "b", depth = 1),
+                listBlock(BlockType.NumberedList(1), "c", depth = 1),
+            ),
+        ).requireMarkdown()
+        assertEquals("- a\n  - [x] b\n  1. c\n", markdown)
+    }
+
+    @Test
+    fun orderedParentIndentsChildrenByMarkerWidth() {
+        val markdown = encode(
+            listOf(
+                listBlock(BlockType.NumberedList(1), "a", depth = 0),
+                listBlock(BlockType.BulletList, "b", depth = 1),
+            ),
+        ).requireMarkdown()
+        assertEquals("1. a\n   - b\n", markdown)
+    }
+
+    @Test
+    fun numberedMarkersUseStoredNumbers() {
+        val markdown = encode(
+            listOf(
+                listBlock(BlockType.NumberedList(1), "a"),
+                listBlock(BlockType.NumberedList(2), "b"),
+                listBlock(BlockType.NumberedList(3), "c"),
+            ),
+        ).requireMarkdown()
+        assertEquals("1. a\n2. b\n3. c\n", markdown)
+    }
+
+    @Test
+    fun todoFormsEncodeCanonically() {
+        val markdown = encode(
+            listOf(
+                listBlock(BlockType.Todo(checked = false), "open"),
+                listBlock(BlockType.Todo(checked = true), "done"),
+            ),
+        ).requireMarkdown()
+        assertEquals("- [ ] open\n- [x] done\n", markdown)
+    }
+
+    @Test
+    fun listRunIsOneTightUnitBetweenOtherBlocks() {
+        val markdown = encode(
+            listOf(
+                Block.paragraph("x"),
+                listBlock(BlockType.BulletList, "a"),
+                listBlock(BlockType.BulletList, "b"),
+                Block.paragraph("y"),
+            ),
+        ).requireMarkdown()
+        assertEquals("x\n\n- a\n- b\n\ny\n", markdown)
+    }
+
+    @Test
+    fun skippedDepthEncodesBestEffortWithWarning() {
+        val result = encode(
+            listOf(
+                listBlock(BlockType.BulletList, "a", depth = 0),
+                listBlock(BlockType.BulletList, "b", depth = 2),
+            ),
+        )
+        assertEquals("- a\n  - b\n", result.requireMarkdown())
+        val warning = result.warnings
+            .filterIsInstance<MarkdownEncodeWarning.DroppedAttribute>()
+            .single()
+        assertEquals("indentationLevel", warning.attr)
+    }
+
+    @Test
+    fun descendantsOfASkippedDepthNodeWarnAgainstTheEmittedDepth() {
+        // b(2) emits at nesting 1, so c(3) re-decodes at depth 2 and must warn
+        // too — silence would hide the shift for every descendant.
+        val result = encode(
+            listOf(
+                listBlock(BlockType.BulletList, "a", depth = 0),
+                listBlock(BlockType.BulletList, "b", depth = 2),
+                listBlock(BlockType.BulletList, "c", depth = 3),
+            ),
+        )
+        assertEquals("- a\n  - b\n    - c\n", result.requireMarkdown())
+        val warnings = result.warnings
+            .filterIsInstance<MarkdownEncodeWarning.DroppedAttribute>()
+            .filter { it.attr == "indentationLevel" }
+        assertEquals(2, warnings.size)
+    }
+
+    @Test
+    fun hardBreakInsideListItemKeepsContinuationIndent() {
+        val markdown = encode(
+            listOf(listBlock(BlockType.BulletList, "a\nb")),
+        ).requireMarkdown()
+        assertEquals("- a\\\n  b\n", markdown)
+    }
+
+    @Test
+    fun outlineRoundTripsThroughDecode() {
+        val original = listOf(
+            listBlock(BlockType.BulletList, "a", depth = 0),
+            listBlock(BlockType.Todo(checked = true), "b", depth = 1),
+            listBlock(BlockType.Todo(checked = false), "c", depth = 1),
+            listBlock(BlockType.BulletList, "d", depth = 2),
+            listBlock(BlockType.NumberedList(1), "e", depth = 0),
+            listBlock(BlockType.NumberedList(2), "f", depth = 0),
+        )
+        val markdown = encode(original).requireMarkdown()
+        val decoded = MarkdownDecodeEngine.decode(markdown, MarkdownProfile.Default).blocks
+            ?: fail("re-decode failed")
+        assertEquals(original.map { it.type }, decoded.map { it.type })
+        assertEquals(
+            original.map { it.attributes.indentationLevel },
+            decoded.map { it.attributes.indentationLevel },
+        )
+        assertEquals(
+            original.map { (it.content as BlockContent.Text).text },
+            decoded.map { (it.content as BlockContent.Text).text },
+        )
+    }
+
+    @Test
+    fun emptyItemTextEmitsBareMarker() {
+        val markdown = encode(listOf(listBlock(BlockType.BulletList, ""))).requireMarkdown()
+        assertEquals("-\n", markdown)
+        assertTrue(MarkdownDecodeEngine.decode(markdown, MarkdownProfile.Default).isSuccess)
+    }
+}
diff --git a/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownLoweringTest.kt b/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownLoweringTest.kt
new file mode 100644
index 0000000..2fa3195
--- /dev/null
+++ b/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownLoweringTest.kt
@@ -0,0 +1,234 @@
+package io.github.linreal.cascade.editor.markdown
+
+import io.github.linreal.cascade.editor.core.Block
+import io.github.linreal.cascade.editor.core.BlockContent
+import io.github.linreal.cascade.editor.core.BlockType
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertIs
+import kotlin.test.assertTrue
+import kotlin.test.fail
+
+/** Source tree → editor blocks through the internal decode engine. */
+class MarkdownLoweringTest {
+
+    // The degrade paths asserted below are WarnAndDegrade behavior; under the
+    // default Preserve policy the same shapes escalate to md.preserved blocks
+    // Covered by MarkdownEscalationTest.
+    private val degradeProfile =
+        MarkdownProfile.Default.withUnsupportedSyntax(UnsupportedSyntax.WarnAndDegrade)
+
+    private fun decode(
+        input: String,
+        profile: MarkdownProfile = MarkdownProfile.Default,
+        limits: MarkdownCodecLimits = MarkdownCodecLimits.Default,
+    ): MarkdownDecodeResult = MarkdownDecodeEngine.decode(input, profile, limits)
+
+    private fun MarkdownDecodeResult.requireBlocks(): List<Block> =
+        blocks ?: fail("expected a successful decode, got aborted with warnings=$warnings")
+
+    private val Block.text: String
+        get() = (content as? BlockContent.Text)?.text ?: fail("expected text content, got $content")
+
+    // Headings, paragraphs, dividers
+
+    @Test
+    fun headingsParagraphsAndDividersLower() {
+        val blocks = decode("## title\n\nbody\n\n---").requireBlocks()
+        assertEquals(3, blocks.size)
+        assertEquals(BlockType.Heading(2), blocks[0].type)
+        assertEquals("title", blocks[0].text)
+        assertEquals(BlockType.Paragraph, blocks[1].type)
+        assertEquals("body", blocks[1].text)
+        assertEquals(BlockType.Divider, blocks[2].type)
+        assertEquals(BlockContent.Empty, blocks[2].content)
+    }
+
+    @Test
+    fun softBreakLowersPerPolicy() {
+        val spaceJoined = decode("a\nb").requireBlocks()
+        assertEquals("a b", spaceJoined.single().text)
+
+        val lineBreakProfile = MarkdownProfile.Default.withSoftBreak(SoftBreak.LineBreak)
+        val newlineJoined = decode("a\nb", lineBreakProfile).requireBlocks()
+        assertEquals("a\nb", newlineJoined.single().text)
+    }
+
+    @Test
+    fun emptyInputLowersToSuccessfulEmptyPayload() {
+        val result = decode("")
+        assertTrue(result.isSuccess)
+        assertEquals(emptyList(), result.blocks)
+    }
+
+    // Quotes
+
+    @Test
+    fun multiParagraphQuoteLowersToOneQuoteBlockPerParagraph() {
+        val blocks = decode("> a\n>\n> b").requireBlocks()
+        assertEquals(2, blocks.size)
+        assertTrue(blocks.all { it.type == BlockType.Quote })
+        assertEquals(listOf("a", "b"), blocks.map { it.text })
+    }
+
+    @Test
+    fun nestedQuoteFlattensToOneLevelWithWarning() {
+        val result = decode(">> deep", degradeProfile)
+        val blocks = result.requireBlocks()
+        assertEquals(1, blocks.size)
+        assertEquals(BlockType.Quote, blocks[0].type)
+        assertEquals("deep", blocks[0].text)
+        val warning = result.warnings
+            .filterIsInstance<MarkdownDecodeWarning.DroppedAttribute>()
+            .single { it.construct == "blockquote" }
+        assertEquals(MarkdownFidelityImpact.DataLoss, warning.impact)
+    }
+
+    @Test
+    fun headingInsideQuoteDegradesWithDataLossWarning() {
+        val result = decode("> # h", degradeProfile)
+        val blocks = result.requireBlocks()
+        assertEquals(1, blocks.size)
+        assertEquals(BlockType.Heading(1), blocks[0].type)
+        assertEquals("h", blocks[0].text)
+        val warning = result.warnings
+            .filterIsInstance<MarkdownDecodeWarning.UnsupportedSyntax>()
+            .single { it.construct == "blockquote" }
+        assertEquals(MarkdownFidelityImpact.DataLoss, warning.impact)
+    }
+
+    // Lists
+
+    @Test
+    fun threeLevelBulletListLowersToNestedDepths() {
+        val blocks = decode("- a\n  - b\n    - c").requireBlocks()
+        assertEquals(3, blocks.size)
+        assertTrue(blocks.all { it.type == BlockType.BulletList })
+        assertEquals(listOf("a", "b", "c"), blocks.map { it.text })
+        assertEquals(listOf(0, 1, 2), blocks.map { it.attributes.indentationLevel })
+    }
+
+    @Test
+    fun nonOneOrderedStartRenumbersWithDataLossWarning() {
+        val result = decode("3. a", degradeProfile)
+        val blocks = result.requireBlocks()
+        assertEquals(BlockType.NumberedList(1), blocks.single().type)
+        assertEquals("a", blocks.single().text)
+        val warning = result.warnings
+            .filterIsInstance<MarkdownDecodeWarning.UnsupportedSyntax>()
+            .single { it.construct == "orderedList" }
+        assertEquals(MarkdownFidelityImpact.DataLoss, warning.impact)
+        assertEquals(0, warning.range.start)
+        assertTrue(warning.range.endExclusive > 0)
+    }
+
+    @Test
+    fun orderedRunKeepsSequentialNumbering() {
+        val blocks = decode("1. a\n2. b\n3. c").requireBlocks()
+        assertEquals(
+            listOf(BlockType.NumberedList(1), BlockType.NumberedList(2), BlockType.NumberedList(3)),
+            blocks.map { it.type },
+        )
+    }
+
+    @Test
+    fun taskItemsLowerToTodosWithCheckedFlags() {
+        val blocks = decode("- [x] done\n- [ ] open").requireBlocks()
+        assertEquals(2, blocks.size)
+        assertEquals(BlockType.Todo(checked = true), blocks[0].type)
+        assertEquals("done", blocks[0].text)
+        assertEquals(BlockType.Todo(checked = false), blocks[1].type)
+        assertEquals("open", blocks[1].text)
+    }
+
+    @Test
+    fun nestedTaskItemsKeepListDepths() {
+        val blocks = decode("- a\n  - [x] b").requireBlocks()
+        assertEquals(BlockType.BulletList, blocks[0].type)
+        assertEquals(BlockType.Todo(checked = true), blocks[1].type)
+        assertEquals(1, blocks[1].attributes.indentationLevel)
+    }
+
+    @Test
+    fun depthBeyondModuleRangeClampsWithWarning() {
+        val input = "- a\n" +
+            "  - b\n" +
+            "    - c\n" +
+            "      - d\n" +
+            "        - e\n" +
+            "          - f\n" +
+            "            - g"
+        val result = decode(input, degradeProfile)
+        val blocks = result.requireBlocks()
+        assertEquals(7, blocks.size)
+        assertEquals(listOf(0, 1, 2, 3, 4, 5, 5), blocks.map { it.attributes.indentationLevel })
+        val warning = result.warnings
+            .filterIsInstance<MarkdownDecodeWarning.DroppedAttribute>()
+            .single { it.construct == "list" }
+        assertEquals("indentationLevel", warning.attr)
+    }
+
+    @Test
+    fun multiParagraphListItemDegradesWithWarning() {
+        val result = decode("- a\n\n  b", degradeProfile)
+        val blocks = result.requireBlocks()
+        assertEquals(2, blocks.size)
+        assertEquals(BlockType.BulletList, blocks[0].type)
+        assertEquals("a", blocks[0].text)
+        assertEquals(BlockType.Paragraph, blocks[1].type)
+        assertEquals("b", blocks[1].text)
+        val warning = result.warnings
+            .filterIsInstance<MarkdownDecodeWarning.UnsupportedSyntax>()
+            .single { it.construct == "listItem" }
+        assertEquals(MarkdownFidelityImpact.DataLoss, warning.impact)
+    }
+
+    @Test
+    fun fenceInsideListItemDegradesWithWarning() {
+        val result = decode("- a\n  ```\n  x\n  ```", degradeProfile)
+        val blocks = result.requireBlocks()
+        assertEquals(2, blocks.size)
+        assertEquals(BlockType.BulletList, blocks[0].type)
+        assertEquals(BlockType.Code, blocks[1].type)
+        assertEquals("x", blocks[1].text)
+        assertTrue(
+            result.warnings.filterIsInstance<MarkdownDecodeWarning.UnsupportedSyntax>()
+                .any { it.construct == "listItem" },
+        )
+    }
+
+    // Code
+
+    @Test
+    fun fenceContentPreservesExactStructuralNewlines() {
+        val blocks = decode("```\n\ncode\n\n\n```").requireBlocks()
+        val code = blocks.single()
+        assertEquals(BlockType.Code, code.type)
+        assertEquals("\ncode\n\n", code.text)
+    }
+
+    @Test
+    fun indentedCodeLowersToCodeBlock() {
+        val blocks = decode("    code").requireBlocks()
+        assertEquals(BlockType.Code, blocks.single().type)
+        assertEquals("code", blocks.single().text)
+    }
+
+    // Identity and pipeline invariants
+
+    @Test
+    fun loweredBlocksGetFreshIdsOnEveryDecode() {
+        val first = decode("a\n\nb").requireBlocks()
+        val second = decode("a\n\nb").requireBlocks()
+        val ids = (first + second).map { it.id }
+        assertEquals(ids.size, ids.toSet().size)
+    }
+
+    @Test
+    fun abortedParsePropagatesAsAbortedDecode() {
+        val result = decode("text", limits = MarkdownCodecLimits(maxInputChars = 1))
+        assertTrue(result.isAborted)
+        assertEquals(null, result.blocks)
+        assertIs<MarkdownDecodeWarning.InputLimitExceeded>(result.warnings.single())
+    }
+}
diff --git a/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownNoThrowGuaranteeTest.kt b/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownNoThrowGuaranteeTest.kt
new file mode 100644
index 0000000..0af9711
--- /dev/null
+++ b/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownNoThrowGuaranteeTest.kt
@@ -0,0 +1,58 @@
+package io.github.linreal.cascade.editor.markdown
+
+import kotlin.test.Test
+import kotlin.test.assertNull
+import kotlin.test.assertTrue
+
+class MarkdownNoThrowGuaranteeTest {
+    private fun assertCompletes(
+        input: String,
+        profile: MarkdownProfile = MarkdownProfile.Default,
+        limits: MarkdownCodecLimits = MarkdownCodecLimits.Default,
+    ): MarkdownDecodeResult {
+        val result = MarkdownSchema.decodeWithReport(input, profile, limits)
+        assertTrue(result.isSuccess || result.isAborted)
+        if (result.isAborted) {
+            assertNull(result.blocks)
+            assertTrue(result.warnings.any { it.impact == MarkdownFidelityImpact.Fatal })
+        }
+        return result
+    }
+
+    @Test
+    fun everyDecodeLimitAbortsWithoutPartialPayload() {
+        val cases = listOf(
+            "x".repeat(64) to MarkdownCodecLimits.Default.copy(maxInputChars = 16),
+            ">".repeat(500) + " deep" to MarkdownCodecLimits.Default.copy(maxBlockNesting = 8),
+            (1..50).joinToString("\n\n") { "p$it" } to MarkdownCodecLimits.Default.copy(maxBlocks = 5),
+            (1..20).joinToString("\n") { "[ref$it]: /url$it" } to
+                MarkdownCodecLimits.Default.copy(maxReferenceDefinitions = 4),
+            "*a*".repeat(200) to MarkdownCodecLimits.Default.copy(maxDelimiterRuns = 10),
+            "*a*".repeat(200) to MarkdownCodecLimits.Default.copy(maxSpansPerBlock = 4),
+            "*a*".repeat(200) to MarkdownCodecLimits.Default.copy(maxTotalSpans = 4),
+        )
+        for ((input, limits) in cases) {
+            val result = assertCompletes(input, limits = limits)
+            assertTrue(result.isAborted, "expected abort for limits=$limits")
+        }
+    }
+
+    @Test
+    fun warningLimitAbortsWithoutThrowing() {
+        val input = (1..20).joinToString("\n\n") { "paragraph \$m$it\$" }
+        val profile = MarkdownProfile.Default.withUnsupportedSyntax(UnsupportedSyntax.WarnAndDegrade)
+        val result = assertCompletes(input, profile, MarkdownCodecLimits.Default.copy(maxWarnings = 3))
+        assertTrue(result.isAborted)
+    }
+
+    @Test
+    fun hostileInputsNeverEscapeThePublicBoundary() {
+        val hostile = listOf(
+            "", "\uFEFF", "\uFEFF# bom heading", "\n\n\n", "\r\r\r", "a\r\nb\rc\nd",
+            "```", "```\nunclosed", "*".repeat(20_000), "`".repeat(20_000),
+            "[".repeat(20_000), ">".repeat(5000), "- ".repeat(3000) + "x",
+            "<u>".repeat(4000), ("a\n\n").repeat(3000),
+        )
+        hostile.forEach { assertCompletes(it) }
+    }
+}
diff --git a/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownOutOfSupportTest.kt b/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownOutOfSupportTest.kt
new file mode 100644
index 0000000..98a7fff
--- /dev/null
+++ b/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownOutOfSupportTest.kt
@@ -0,0 +1,61 @@
+package io.github.linreal.cascade.editor.markdown
+
+import io.github.linreal.cascade.editor.core.Block
+import io.github.linreal.cascade.editor.core.BlockContent
+import io.github.linreal.cascade.editor.core.SpanStyle
+import io.github.linreal.cascade.editor.core.TextSpan
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertFalse
+import kotlin.test.assertNotNull
+import kotlin.test.assertTrue
+
+/**
+ * Directed out-of-support behavior: documents outside the support
+ * set never throw, emit honest warnings, and degrade deterministically.
+ */
+class MarkdownOutOfSupportTest {
+
+    @Test
+    fun `empty paragraph encodes deterministically with a warning`() {
+        val doc = listOf(Block.paragraph("keep"), Block.paragraph(""))
+        val a = MarkdownSchema.encodeWithReport(doc, MarkdownProfile.Default)
+        val b = MarkdownSchema.encodeWithReport(doc, MarkdownProfile.Default)
+        assertTrue(a.isSuccess)
+        assertEquals(a.markdown, b.markdown)
+        assertFalse(MarkdownProfile.Default.supportSet.supportsDocument(doc))
+    }
+
+    @Test
+    fun `unsupported custom span keeps text and warns`() {
+        val doc = listOf(
+            Block.paragraph("spoiler here", spans = listOf(TextSpan(0, 7, SpanStyle.Custom("spoiler")))),
+        )
+        val result = MarkdownSchema.encodeWithReport(doc, MarkdownProfile.Default)
+        assertTrue(result.isSuccess)
+        assertNotNull(result.markdown)
+        assertTrue(result.markdown!!.contains("spoiler"))
+        assertTrue(result.warnings.any { it is MarkdownEncodeWarning.UnsupportedSpan })
+    }
+
+    @Test
+    fun `pipe table preserved opaquely under default Preserve policy`() {
+        val table = "| a | b |\n| - | - |\n| 1 | 2 |"
+        val result = MarkdownSchema.decodeWithReport(table, MarkdownProfile.Default)
+        assertTrue(result.isSuccess)
+        val block = result.blocks!!.single()
+        val content = block.content
+        assertTrue(content is BlockContent.Custom && content.typeId == MARKDOWN_PRESERVED_TYPE_ID)
+        assertTrue(result.warnings.any { it is MarkdownDecodeWarning.PreservedSyntax })
+    }
+
+    @Test
+    fun `out-of-support document is not claimed but still round-trips its preserved slice`() {
+        val table = "| a | b |\n| - | - |"
+        val decoded = MarkdownSchema.decode(table, MarkdownProfile.Default)!!
+        assertFalse(MarkdownProfile.Default.supportSet.supportsDocument(decoded))
+        val reencoded = MarkdownSchema.encode(decoded, MarkdownProfile.Default)
+        assertNotNull(reencoded)
+        assertTrue(reencoded!!.contains("| a | b |"))
+    }
+}
diff --git a/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownPreservationTest.kt b/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownPreservationTest.kt
new file mode 100644
index 0000000..a1afa58
--- /dev/null
+++ b/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownPreservationTest.kt
@@ -0,0 +1,228 @@
+package io.github.linreal.cascade.editor.markdown
+
+import io.github.linreal.cascade.editor.core.Block
+import io.github.linreal.cascade.editor.core.BlockContent
+import io.github.linreal.cascade.editor.core.BlockType
+import io.github.linreal.cascade.editor.core.UnknownBlockType
+import io.github.linreal.cascade.editor.serialization.DocumentSchema
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertIs
+import kotlin.test.assertTrue
+import kotlin.test.fail
+
+/** Preservation recognizers and the `UnsupportedSyntax.Preserve` path. */
+class MarkdownPreservationTest {
+
+    private val degradeProfile =
+        MarkdownProfile.Default.withUnsupportedSyntax(UnsupportedSyntax.WarnAndDegrade)
+
+    private fun decode(
+        input: String,
+        profile: MarkdownProfile = MarkdownProfile.Default,
+    ): MarkdownDecodeResult = MarkdownDecodeEngine.decode(input, profile)
+
+    private fun MarkdownDecodeResult.requireBlocks(): List<Block> =
+        blocks ?: fail("expected a successful decode, got aborted with warnings=$warnings")
+
+    private fun Block.preservedPayload(expectedKind: String): String {
+        val type = assertIs<UnknownBlockType>(this.type)
+        assertEquals("md.preserved", type.typeId)
+        assertEquals("""{"typeId":"md.preserved"}""", type.rawTypeJson)
+        val content = assertIs<BlockContent.Custom>(this.content)
+        assertEquals("md.preserved", content.typeId)
+        assertEquals(expectedKind, content.data["kind"])
+        return content.data["rawMarkdown"] as? String
+            ?: fail("expected a rawMarkdown slice, got ${content.data}")
+    }
+
+    @Test
+    fun mathBlockNeverInterruptsAParagraph() {
+        // CommonMark keeps "$$" after paragraph text as paragraph content; the
+        // recognizer must not claim it (conservative guard + linear lookahead).
+        val result = decode("text\n$$\nx\n$$")
+        val blocks = result.requireBlocks()
+        assertEquals(1, blocks.size)
+        val content = assertIs<BlockContent.Text>(blocks.single().content)
+        // Soft breaks lower to spaces under the SoftBreak.Space default.
+        assertEquals("text $$ x $$", content.text)
+        assertTrue(result.warnings.filterIsInstance<MarkdownDecodeWarning.PreservedSyntax>().isEmpty())
+    }
+
+    @Test
+    fun dollarPrefixedProseIsNotAMathOpener() {
+        // A multi-line opener must be exactly "$$" — "$$100 spent" is prose.
+        val result = decode("$$100 spent\nmore text $$")
+        val blocks = result.requireBlocks()
+        assertEquals(1, blocks.size)
+        assertIs<BlockContent.Text>(blocks.single().content)
+        assertTrue(result.warnings.filterIsInstance<MarkdownDecodeWarning.PreservedSyntax>().isEmpty())
+    }
+
+    // Pipe tables
+
+    @Test
+    fun pipeTablePreservesCharacterExactSliceUnderPreserve() {
+        val input = "| a | b |\n| --- | --- |\n| 1 | 2 |"
+        val result = decode(input)
+        val block = result.requireBlocks().single()
+        assertEquals(input, block.preservedPayload("pipeTable"))
+        val warning = result.warnings
+            .filterIsInstance<MarkdownDecodeWarning.PreservedSyntax>()
+            .single()
+        assertEquals("pipeTable", warning.kind)
+        assertEquals(MarkdownFidelityImpact.OpaquePreservation, warning.impact)
+    }
+
+    @Test
+    fun pipeRowWithoutDelimiterRowStaysAPlainParagraph() {
+        val result = decode("| a | b |")
+        val block = result.requireBlocks().single()
+        assertEquals(BlockType.Paragraph, block.type)
+        assertEquals("| a | b |", (block.content as BlockContent.Text).text)
+        assertTrue(result.warnings.none { it is MarkdownDecodeWarning.PreservedSyntax })
+    }
+
+    @Test
+    fun delimiterRowColumnMismatchIsNotATable() {
+        val result = decode("| a | b |\n| --- |")
+        assertTrue(result.requireBlocks().all { it.type == BlockType.Paragraph })
+    }
+
+    @Test
+    fun pipeTableDegradesToParagraphTextUnderWarnAndDegrade() {
+        val input = "| a | b |\n| --- | --- |\n| 1 | 2 |"
+        val result = decode(input, degradeProfile)
+        val blocks = result.requireBlocks()
+        assertTrue(blocks.isNotEmpty())
+        assertTrue(blocks.all { it.type == BlockType.Paragraph })
+        val warning = result.warnings
+            .filterIsInstance<MarkdownDecodeWarning.UnsupportedSyntax>()
+            .single { it.construct == "pipeTable" }
+        assertEquals(MarkdownFidelityImpact.DataLoss, warning.impact)
+    }
+
+    // Front matter
+
+    @Test
+    fun frontMatterAtDocumentStartPreservesUnderPreserve() {
+        val input = "---\ntitle: x\n---"
+        val block = decode(input).requireBlocks().single()
+        assertEquals(input, block.preservedPayload("frontMatter"))
+    }
+
+    @Test
+    fun frontMatterShapedLinesMidDocumentAreNotRecognized() {
+        val result = decode("intro\n\n---\ntitle: x\n---")
+        val blocks = result.requireBlocks()
+        assertTrue(blocks.none { it.type is UnknownBlockType })
+        assertTrue(result.warnings.none { it is MarkdownDecodeWarning.PreservedSyntax })
+    }
+
+    @Test
+    fun documentStartingWithThematicBreakIsNotFrontMatter() {
+        val result = decode("---\n\ntext")
+        val blocks = result.requireBlocks()
+        assertEquals(BlockType.Divider, blocks.first().type)
+        assertTrue(result.warnings.none { it is MarkdownDecodeWarning.PreservedSyntax })
+    }
+
+    // Math blocks
+
+    @Test
+    fun multiLineMathBlockPreserves() {
+        val input = "$$\nx^2\n$$"
+        val block = decode(input).requireBlocks().single()
+        assertEquals(input, block.preservedPayload("mathBlock"))
+    }
+
+    @Test
+    fun singleLineMathBlockPreserves() {
+        val input = "\$\$x^2\$\$"
+        val block = decode(input).requireBlocks().single()
+        assertEquals(input, block.preservedPayload("mathBlock"))
+    }
+
+    @Test
+    fun unclosedMathIsNotRecognized() {
+        val result = decode("$$\nx")
+        assertTrue(result.requireBlocks().all { it.type == BlockType.Paragraph })
+    }
+
+    // Footnote definitions and block images
+
+    @Test
+    fun footnoteDefinitionPreserves() {
+        val input = "[^1]: a note"
+        val block = decode(input).requireBlocks().single()
+        assertEquals(input, block.preservedPayload("footnoteDefinition"))
+    }
+
+    @Test
+    fun blockImagePreserves() {
+        val input = "![alt](img.png)"
+        val block = decode(input).requireBlocks().single()
+        assertEquals(input, block.preservedPayload("blockImage"))
+    }
+
+    @Test
+    fun imageWithTrailingTextIsNotABlockImage() {
+        // The block recognizer stands down (trailing text), so the line decodes
+        // as a paragraph — whose inline image then escalates the whole leaf
+        // under Preserve. The proof the *block* recognizer refused
+        // is the "inlineImage" kind.
+        val result = decode("![alt](img.png) tail")
+        val block = result.requireBlocks().single()
+        assertEquals("![alt](img.png) tail", block.preservedPayload("inlineImage"))
+
+        // Under WarnAndDegrade the same line stays an editable paragraph.
+        val degraded = decode("![alt](img.png) tail", degradeProfile)
+        val paragraph = degraded.requireBlocks().single()
+        assertEquals(BlockType.Paragraph, paragraph.type)
+        assertEquals("alt tail", (paragraph.content as BlockContent.Text).text)
+    }
+
+    // Fenced code with info string
+
+    @Test
+    fun fenceWithInfoStringPreservesWholeFenceUnderPreserve() {
+        val input = "```kotlin\ncode\n```"
+        val result = decode(input)
+        val block = result.requireBlocks().single()
+        assertEquals(input, block.preservedPayload("fencedCode"))
+        assertEquals(
+            "fencedCode",
+            result.warnings.filterIsInstance<MarkdownDecodeWarning.PreservedSyntax>().single().kind,
+        )
+    }
+
+    @Test
+    fun fenceWithInfoStringDegradesToCodeUnderWarnAndDegrade() {
+        val result = decode("```kotlin\ncode\n```", degradeProfile)
+        val block = result.requireBlocks().single()
+        assertEquals(BlockType.Code, block.type)
+        assertEquals("code", (block.content as BlockContent.Text).text)
+        val warning = result.warnings
+            .filterIsInstance<MarkdownDecodeWarning.DroppedAttribute>()
+            .single { it.construct == "fencedCode" }
+        assertEquals("infoString", warning.attr)
+    }
+
+    @Test
+    fun fenceWithoutInfoStringLowersNativelyUnderPreserve() {
+        val block = decode("```\ncode\n```").requireBlocks().single()
+        assertEquals(BlockType.Code, block.type)
+    }
+
+    // Persistence round trip
+
+    @Test
+    fun preservedBlockRePersistsThroughDocumentSchema() {
+        val input = "| a | b |\n| --- | --- |"
+        val decoded = decode(input).requireBlocks()
+        val json = DocumentSchema.encodeToString(decoded)
+        val reloaded = DocumentSchema.decodeFromString(json)
+        val block = reloaded.single()
+        assertEquals(input, block.preservedPayload("pipeTable"))
+    }
+}
diff --git a/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownProfileTest.kt b/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownProfileTest.kt
new file mode 100644
index 0000000..2bb4444
--- /dev/null
+++ b/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownProfileTest.kt
@@ -0,0 +1,46 @@
+package io.github.linreal.cascade.editor.markdown
+
+import io.github.linreal.cascade.editor.core.BlockType
+import io.github.linreal.cascade.editor.htmlserialization.HtmlProfile
+import kotlin.test.Test
+import kotlin.test.assertSame
+
+class MarkdownProfileTest {
+    @Test
+    fun defaultPoliciesMatchContract() {
+        val profile = MarkdownProfile.Default
+        assertSame(UnsupportedSyntax.Preserve, profile.unsupportedSyntax)
+        assertSame(NewlineSemantics.CommonMark, profile.newlineSemantics)
+        assertSame(SoftBreak.Space, profile.softBreak)
+        assertSame(HardBreakEncode.Backslash, profile.hardBreakEncode)
+        assertSame(EntityDecode.Standard, profile.entityDecode)
+        assertSame(HtmlProfile.Default, (profile.htmlInMarkdown as HtmlInMarkdown.Bridge).htmlProfile)
+    }
+
+    @Test
+    fun policyBuildersAreImmutable() {
+        val base = MarkdownProfile.Default
+        val changed = base
+            .withUnsupportedSyntax(UnsupportedSyntax.WarnAndDegrade)
+            .withNewlineSemantics(NewlineSemantics.HardBreak)
+            .withSoftBreak(SoftBreak.LineBreak)
+            .withHardBreakEncode(HardBreakEncode.TwoSpaces)
+            .withEntityDecode(EntityDecode.None)
+            .withHtmlInMarkdown(HtmlInMarkdown.WarnAndStrip)
+
+        assertSame(UnsupportedSyntax.Preserve, base.unsupportedSyntax)
+        assertSame(UnsupportedSyntax.WarnAndDegrade, changed.unsupportedSyntax)
+        assertSame(NewlineSemantics.HardBreak, changed.newlineSemantics)
+        assertSame(SoftBreak.LineBreak, changed.softBreak)
+        assertSame(HardBreakEncode.TwoSpaces, changed.hardBreakEncode)
+        assertSame(EntityDecode.None, changed.entityDecode)
+        assertSame(HtmlInMarkdown.WarnAndStrip, changed.htmlInMarkdown)
+    }
+
+    @Test
+    fun encoderRegistrationDoesNotMutateSupportSet() {
+        val base = MarkdownProfile.Default
+        val changed = base.withMarkdownBlockEncoder<BlockType.Paragraph> { _, _, _ -> MarkdownEmit.Skip }
+        assertSame(base.supportSet, changed.supportSet)
+    }
+}
diff --git a/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownReferenceCorpusTest.kt b/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownReferenceCorpusTest.kt
new file mode 100644
index 0000000..7002f6e
--- /dev/null
+++ b/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownReferenceCorpusTest.kt
@@ -0,0 +1,70 @@
+package io.github.linreal.cascade.editor.markdown
+
+import io.github.linreal.cascade.editor.core.BlockContent
+import io.github.linreal.cascade.editor.core.BlockType
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+
+/**
+ * Corpus suite for the reference field profiles. Corpus
+ * documents are synthetic but plausible (no copied private content); each
+ * assertion pins no-throw, an expected analyze recommendation, and — for the
+ * hard-break family — the #339 blank-line and #348 numbered-continuation bug
+ * classes.
+ */
+class MarkdownReferenceCorpusTest {
+
+    @Test
+    fun `strict gfm plain note is native`() {
+        val doc = "# Standup\n\nShipped **auth** and reviewed the [PR](../pr/42.md).\n\n- done\n- next\n"
+        val report = MarkdownSchema.analyze(doc, MarkdownReferenceProfiles.StrictGfmFieldProfile)
+        assertEquals(MarkdownEditModeRecommendation.Native, report.recommendedMode)
+    }
+
+    @Test
+    fun `strict gfm table is raw fallback not native`() {
+        val doc = "Costs:\n\n| item | usd |\n| - | - |\n| a | 1 |\n"
+        val report = MarkdownSchema.analyze(doc, MarkdownReferenceProfiles.StrictGfmFieldProfile)
+        assertEquals(MarkdownEditModeRecommendation.RawFallback, report.recommendedMode)
+        assertTrue(report.preservedBlockCount >= 1)
+    }
+
+    @Test
+    fun `strict profile with raw html analyzes as raw fallback not silent strip`() {
+        val doc = "Note with <span style=\"x\">inline html</span> inside.\n"
+        val report = MarkdownSchema.analyze(doc, MarkdownReferenceProfiles.StrictGfmFieldProfile)
+        assertEquals(MarkdownEditModeRecommendation.RawFallback, report.recommendedMode)
+        assertTrue(report.dataLossWarnings.isNotEmpty())
+    }
+
+    @Test
+    fun `hardbreak memo preserves blank line runs issue 339`() {
+        val profile = MarkdownReferenceProfiles.StrictHardBreakFieldProfile
+        val doc = "first thought\n\n\nthird thought after two blanks\n"
+        val blocks = MarkdownSchema.decode(doc, profile)!!
+        val texts = blocks.map { (it.content as BlockContent.Text).text }
+        assertEquals(listOf("first thought", "", "", "third thought after two blanks"), texts)
+        // Simulated edit round-trip: the blank-line run survives re-encode.
+        val reencoded = MarkdownSchema.encode(blocks, profile)!!
+        val redecoded = MarkdownSchema.decode(reencoded, profile)!!
+        assertEquals(texts, redecoded.map { (it.content as BlockContent.Text).text })
+    }
+
+    @Test
+    fun `hardbreak numbered continuation is renumbered issue 348`() {
+        val profile = MarkdownReferenceProfiles.StrictHardBreakFieldProfile
+        // Chat-style input where every item is typed as "1." — the bug class is
+        // that the continuation must be renumbered, not left as 1/1/1.
+        val doc = "1. first\n1. second\n1. third\n"
+        val blocks = MarkdownSchema.decode(doc, profile)!!
+        val numbered = blocks.filter { it.type is BlockType.NumberedList }
+        assertEquals(3, numbered.size)
+        assertEquals(listOf(1, 2, 3), numbered.map { (it.type as BlockType.NumberedList).number })
+        val reencoded = MarkdownSchema.encode(blocks, profile)!!
+        assertTrue(reencoded.contains("1. first"), reencoded)
+        assertTrue(reencoded.contains("2. second"), reencoded)
+        assertTrue(reencoded.contains("3. third"), reencoded)
+    }
+
+}
diff --git a/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownReferenceProfiles.kt b/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownReferenceProfiles.kt
new file mode 100644
index 0000000..bc3b004
--- /dev/null
+++ b/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownReferenceProfiles.kt
@@ -0,0 +1,10 @@
+package io.github.linreal.cascade.editor.markdown
+
+/** Release-test field profiles built from the supported public policy surface. */
+internal object MarkdownReferenceProfiles {
+    val StrictGfmFieldProfile: MarkdownProfile = MarkdownProfile.Default.withoutHtmlBridge()
+
+    val StrictHardBreakFieldProfile: MarkdownProfile = MarkdownProfile.Default
+        .withNewlineSemantics(NewlineSemantics.HardBreak)
+        .withoutHtmlBridge()
+}
diff --git a/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownResultsTest.kt b/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownResultsTest.kt
new file mode 100644
index 0000000..4b22c8e
--- /dev/null
+++ b/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownResultsTest.kt
@@ -0,0 +1,212 @@
+package io.github.linreal.cascade.editor.markdown
+
+import io.github.linreal.cascade.editor.core.Block
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertFailsWith
+import kotlin.test.assertNotNull
+import kotlin.test.assertNull
+import kotlin.test.assertTrue
+
+@OptIn(ExperimentalCascadeMarkdownApi::class)
+class MarkdownResultsTest {
+
+    private val anyRange = MarkdownSourceRange(0, 1)
+
+    @Test
+    fun `success with zero blocks has non-null empty payload`() {
+        val result = MarkdownDecodeResult.success(blocks = emptyList())
+
+        assertEquals(MarkdownCodecStatus.Success, result.status)
+        assertTrue(result.isSuccess)
+        val blocks = assertNotNull(result.blocks)
+        assertTrue(blocks.isEmpty())
+    }
+
+    @Test
+    fun `success with content carries payload and warnings`() {
+        val result = MarkdownDecodeResult.success(
+            blocks = listOf(Block.paragraph("hello")),
+            warnings = listOf(
+                MarkdownDecodeWarning.PreservedSyntax(kind = "pipeTable", range = anyRange),
+            ),
+        )
+
+        assertEquals(1, assertNotNull(result.blocks).size)
+        assertEquals(1, result.warnings.size)
+    }
+
+    @Test
+    fun `aborted decode has null payload and requires a fatal warning`() {
+        val result = MarkdownDecodeResult.aborted(
+            warnings = listOf(
+                MarkdownDecodeWarning.InputLimitExceeded(limit = 10, actual = 20),
+            ),
+        )
+
+        assertEquals(MarkdownCodecStatus.Aborted, result.status)
+        assertTrue(result.isAborted)
+        assertNull(result.blocks)
+    }
+
+    @Test
+    fun `aborted decode without a fatal warning is rejected`() {
+        assertFailsWith<IllegalArgumentException> {
+            MarkdownDecodeResult.aborted(
+                warnings = listOf(
+                    MarkdownDecodeWarning.PreservedSyntax(kind = "mathBlock", range = anyRange),
+                ),
+            )
+        }
+    }
+
+    @Test
+    fun `aborted encode has null payload and requires a fatal warning`() {
+        val result = MarkdownEncodeResult.aborted(
+            warnings = listOf(MarkdownEncodeWarning.OutputLimitExceeded(limit = 100)),
+        )
+
+        assertEquals(MarkdownCodecStatus.Aborted, result.status)
+        assertNull(result.markdown)
+
+        assertFailsWith<IllegalArgumentException> {
+            MarkdownEncodeResult.aborted(
+                warnings = listOf(
+                    MarkdownEncodeWarning.DroppedAttribute(
+                        attr = "indentationLevel",
+                        reason = "not representable",
+                        blockId = null,
+                    ),
+                ),
+            )
+        }
+    }
+
+    @Test
+    fun `success with a fatal warning is rejected`() {
+        assertFailsWith<IllegalArgumentException> {
+            MarkdownDecodeResult.success(
+                blocks = emptyList(),
+                warnings = listOf(MarkdownDecodeWarning.InputLimitExceeded(limit = 1, actual = 2)),
+            )
+        }
+        assertFailsWith<IllegalArgumentException> {
+            MarkdownEncodeResult.success(
+                markdown = "x",
+                warnings = listOf(MarkdownEncodeWarning.OutputLimitExceeded(limit = 1)),
+            )
+        }
+    }
+
+    @Test
+    fun `empty string is a valid successful encode payload`() {
+        val result = MarkdownEncodeResult.success(markdown = "")
+
+        assertEquals(MarkdownCodecStatus.Success, result.status)
+        assertEquals("", result.markdown)
+    }
+
+    @Test
+    fun `decode warning members expose their documented impact`() {
+        assertEquals(
+            MarkdownFidelityImpact.DataLoss,
+            MarkdownDecodeWarning.UnsupportedSyntax("table", "degraded", anyRange).impact,
+        )
+        assertEquals(
+            MarkdownFidelityImpact.OpaquePreservation,
+            MarkdownDecodeWarning.PreservedSyntax("frontMatter", anyRange).impact,
+        )
+        assertEquals(
+            MarkdownFidelityImpact.Informational,
+            MarkdownDecodeWarning.HtmlBridged(anyRange).impact,
+        )
+        assertEquals(
+            MarkdownFidelityImpact.DataLoss,
+            MarkdownDecodeWarning.HtmlStripped("span", anyRange).impact,
+        )
+        assertEquals(
+            MarkdownFidelityImpact.DataLoss,
+            MarkdownDecodeWarning.DroppedAttribute("list", "start", "non-1 start", anyRange).impact,
+        )
+        assertEquals(
+            MarkdownFidelityImpact.Fatal,
+            MarkdownDecodeWarning.InputLimitExceeded(limit = 1, actual = 2).impact,
+        )
+        assertEquals(
+            MarkdownFidelityImpact.Fatal,
+            MarkdownDecodeWarning.LimitExceeded(MarkdownCodecLimitKind.Blocks, 1, anyRange).impact,
+        )
+    }
+
+    @Test
+    fun `encode warning members expose their documented impact`() {
+        assertEquals(
+            MarkdownFidelityImpact.DataLoss,
+            MarkdownEncodeWarning.AmbiguousEmphasis(blockId = null, textRange = null).impact,
+        )
+        assertEquals(
+            MarkdownFidelityImpact.DataLoss,
+            MarkdownEncodeWarning.DroppedSpanOverlap(null, null, "inside code span").impact,
+        )
+        assertEquals(
+            MarkdownFidelityImpact.DataLoss,
+            MarkdownEncodeWarning.DroppedAttribute("indentationLevel", "no encoding", null).impact,
+        )
+        assertEquals(
+            MarkdownFidelityImpact.DataLoss,
+            MarkdownEncodeWarning.UnsupportedBlock("custom", "no encoder", null).impact,
+        )
+        assertEquals(
+            MarkdownFidelityImpact.DataLoss,
+            MarkdownEncodeWarning.UnsupportedSpan("spoiler", "no encoder", null, null).impact,
+        )
+        assertEquals(
+            MarkdownFidelityImpact.DataLoss,
+            MarkdownEncodeWarning.EncoderException("table", "boom", null).impact,
+        )
+        assertEquals(
+            MarkdownFidelityImpact.Fatal,
+            MarkdownEncodeWarning.OutputLimitExceeded(limit = 1).impact,
+        )
+        assertEquals(
+            MarkdownFidelityImpact.Fatal,
+            MarkdownEncodeWarning.LimitExceeded(MarkdownCodecLimitKind.Warnings, 1).impact,
+        )
+    }
+
+    @Test
+    fun `decode warnings carry source ranges and encode warnings carry block ids`() {
+        val decodeWarning = MarkdownDecodeWarning.PreservedSyntax("pipeTable", MarkdownSourceRange(4, 20))
+        assertEquals(MarkdownSourceRange(4, 20), decodeWarning.range)
+
+        val block = Block.paragraph("x")
+        val encodeWarning = MarkdownEncodeWarning.DroppedSpanOverlap(
+            blockId = block.id,
+            textRange = MarkdownTextRange(2, 5),
+            reason = "span wholly inside code content",
+        )
+        assertEquals(block.id, encodeWarning.blockId)
+        assertEquals(MarkdownTextRange(2, 5), encodeWarning.textRange)
+    }
+
+    @Test
+    fun `default limits match the decided values`() {
+        val limits = MarkdownCodecLimits.Default
+
+        assertEquals(4_000_000, limits.maxInputChars)
+        assertEquals(32, limits.maxBlockNesting)
+        assertEquals(50_000, limits.maxBlocks)
+        assertEquals(1_000, limits.maxSpansPerBlock)
+        assertEquals(50_000, limits.maxTotalSpans)
+        assertEquals(5_000, limits.maxReferenceDefinitions)
+        assertEquals(10_000, limits.maxDelimiterRuns)
+        assertEquals(1_000, limits.maxWarnings)
+        assertEquals(16_000_000, limits.maxOutputChars)
+    }
+
+    @Test
+    fun `non-positive limits are rejected`() {
+        assertFailsWith<IllegalArgumentException> { MarkdownCodecLimits(maxInputChars = 0) }
+        assertFailsWith<IllegalArgumentException> { MarkdownCodecLimits(maxWarnings = -1) }
+    }
+}
diff --git a/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownRoundTripTest.kt b/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownRoundTripTest.kt
new file mode 100644
index 0000000..718bf23
--- /dev/null
+++ b/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownRoundTripTest.kt
@@ -0,0 +1,41 @@
+package io.github.linreal.cascade.editor.markdown
+
+import kotlin.test.Test
+
+/**
+ * Generated round-trip property test: every document drawn inside
+ * the default profile's support set satisfies `decode(encode(doc)) == doc`
+ * modulo `BlockId`s.
+ *
+ * Reproducibility: the base seed is fixed; each document derives its own seed
+ * from it, so a failure prints the offending document and is replayable by
+ * re-running the same seed.
+ */
+class MarkdownRoundTripTest {
+
+    @Test
+    fun `default profile round trips 1000 generated support-set documents`() {
+        val profile = MarkdownProfile.Default
+        val generator = MarkdownSupportSetBlockGenerator(
+            profile = profile,
+            supportSet = profile.supportSet,
+            seed = BASE_SEED,
+        )
+
+        repeat(1000) {
+            val blocks = generator.nextDocument()
+            assertMarkdownSupportSetDocument(profile.supportSet, blocks)
+
+            val encoded = MarkdownSchema.encode(blocks, profile)
+                ?: error("encode aborted for in-support document: $blocks")
+            val decoded = MarkdownSchema.decode(encoded, profile)
+                ?: error("decode aborted for canonical output:\n$encoded")
+
+            assertMarkdownSemanticallyEquals(blocks, decoded)
+        }
+    }
+
+    private companion object {
+        const val BASE_SEED: Long = 0x5CA1AB1E
+    }
+}
diff --git a/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownSchemaTest.kt b/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownSchemaTest.kt
new file mode 100644
index 0000000..c7999f2
--- /dev/null
+++ b/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownSchemaTest.kt
@@ -0,0 +1,92 @@
+package io.github.linreal.cascade.editor.markdown
+
+import io.github.linreal.cascade.editor.core.Block
+import io.github.linreal.cascade.editor.core.BlockContent
+import io.github.linreal.cascade.editor.core.BlockType
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertNotNull
+import kotlin.test.assertNull
+import kotlin.test.assertTrue
+
+class MarkdownSchemaTest {
+
+    @Test
+    fun `decode empty input yields non-null empty success`() {
+        val result = MarkdownSchema.decodeWithReport("", MarkdownProfile.Default)
+        assertTrue(result.isSuccess)
+        assertEquals(emptyList(), result.blocks)
+        assertEquals(emptyList<Block>(), MarkdownSchema.decode("", MarkdownProfile.Default))
+    }
+
+    @Test
+    fun `encode empty document yields non-null empty success`() {
+        val result = MarkdownSchema.encodeWithReport(emptyList(), MarkdownProfile.Default)
+        assertTrue(result.isSuccess)
+        assertEquals("", result.markdown)
+    }
+
+    @Test
+    fun `decode then encode of a heading is canonical`() {
+        val blocks = MarkdownSchema.decode("## Title", MarkdownProfile.Default)
+        assertNotNull(blocks)
+        assertEquals(1, blocks.size)
+        assertEquals(BlockType.Heading(2), blocks.single().type)
+        assertEquals("## Title\n", MarkdownSchema.encode(blocks, MarkdownProfile.Default))
+    }
+
+    @Test
+    fun `over-limit input aborts convenience null and report aborted`() {
+        val limits = MarkdownCodecLimits(maxInputChars = 4)
+        assertNull(MarkdownSchema.decode("longer than four", MarkdownProfile.Default, limits))
+        val report = MarkdownSchema.decodeWithReport("longer than four", MarkdownProfile.Default, limits)
+        assertTrue(report.isAborted)
+        assertNull(report.blocks)
+        assertTrue(report.warnings.any { it.impact == MarkdownFidelityImpact.Fatal })
+    }
+
+    @Test
+    fun `over-limit output aborts encode`() {
+        val blocks = listOf(Block.paragraph("a fairly long paragraph of text"))
+        val limits = MarkdownCodecLimits(maxOutputChars = 4)
+        assertNull(MarkdownSchema.encode(blocks, MarkdownProfile.Default, limits))
+        val report = MarkdownSchema.encodeWithReport(blocks, MarkdownProfile.Default, limits)
+        assertTrue(report.isAborted)
+        assertNull(report.markdown)
+    }
+
+    @Test
+    fun `crlf line ending option applies`() {
+        val blocks = listOf(Block.paragraph("a"), Block.paragraph("b"))
+        val out = MarkdownSchema.encode(blocks, MarkdownProfile.Default, lineEnding = MarkdownLineEnding.CrLf)
+        assertEquals("a\r\n\r\nb\r\n", out)
+    }
+
+    @Test
+    fun `throwing consumer encoder never crosses the public boundary`() {
+        val profile = MarkdownProfile.Default.withMarkdownBlockEncoder<BlockType.Paragraph>(
+            { _, _, _ -> throw IllegalStateException("intentional") },
+        )
+        val result = MarkdownSchema.encodeWithReport(listOf(Block.paragraph("x")), profile)
+        // The encoder threw and degraded through the fallback; no crash.
+        assertTrue(result.isSuccess)
+        assertTrue(result.warnings.any { it is MarkdownEncodeWarning.EncoderException })
+    }
+
+    @Test
+    fun `custom content is not unconditionally rejected by supportsBlock`() {
+        // A custom support set may claim a custom block type.
+        val block = Block(
+            id = io.github.linreal.cascade.editor.core.BlockId.generate(),
+            type = BlockType.Paragraph,
+            content = BlockContent.Custom("widget"),
+        )
+        val claiming = MarkdownProfileSupportSet(
+            supportsBlockPredicate = { it.content is BlockContent.Custom },
+            supportsSpanPredicate = { false },
+            supportsDocumentPredicate = { blocks -> blocks.all { it.content is BlockContent.Custom } },
+        )
+        assertTrue(claiming.supportsBlock(block))
+        assertTrue(claiming.supportsDocument(listOf(block)))
+    }
+}
diff --git a/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownSerializationExtTest.kt b/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownSerializationExtTest.kt
new file mode 100644
index 0000000..1192a20
--- /dev/null
+++ b/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownSerializationExtTest.kt
@@ -0,0 +1,143 @@
+package io.github.linreal.cascade.editor.markdown
+
+import io.github.linreal.cascade.editor.core.Block
+import io.github.linreal.cascade.editor.core.BlockContent
+import io.github.linreal.cascade.editor.core.BlockId
+import io.github.linreal.cascade.editor.core.BlockType
+import io.github.linreal.cascade.editor.core.SpanStyle
+import io.github.linreal.cascade.editor.core.TextSpan
+import io.github.linreal.cascade.editor.state.BlockSpanStates
+import io.github.linreal.cascade.editor.state.BlockTextStates
+import io.github.linreal.cascade.editor.state.EditorState
+import io.github.linreal.cascade.editor.state.EditorStateHolder
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertFailsWith
+import kotlin.test.assertFalse
+import kotlin.test.assertNull
+import kotlin.test.assertTrue
+
+class MarkdownSerializationExtTest {
+
+    private fun holderWith(vararg blocks: Block): EditorStateHolder =
+        EditorStateHolder(EditorState.withBlocks(blocks.toList()))
+
+    @Test
+    fun `toMarkdown exports live runtime text`() {
+        val id = BlockId("b1")
+        val holder = holderWith(Block(id, BlockType.Paragraph, BlockContent.Text("snapshot")))
+        val textStates = BlockTextStates()
+        val spanStates = BlockSpanStates()
+        textStates.getOrCreate(id, "snapshot")
+        textStates.setText(id, "runtime")
+
+        assertEquals("runtime\n", holder.toMarkdown(textStates, spanStates))
+    }
+
+    @Test
+    fun `loadFromMarkdown replaces state and clears runtime holders`() {
+        val oldId = BlockId("old")
+        val holder = holderWith(Block(oldId, BlockType.Paragraph, BlockContent.Text("old")))
+        val textStates = BlockTextStates()
+        val spanStates = BlockSpanStates()
+        textStates.getOrCreate(oldId, "old")
+        spanStates.getOrCreate(oldId, listOf(TextSpan(0, 3, SpanStyle.Bold)), textLength = 3)
+
+        val result = holder.loadFromMarkdown("# Imported\n\nBody", textStates, spanStates)
+
+        assertTrue(result.isSuccess)
+        assertNull(textStates.get(oldId))
+        assertNull(spanStates.get(oldId))
+        assertEquals(2, holder.state.blocks.size)
+        assertEquals(BlockType.Heading(1), holder.state.blocks.first().type)
+    }
+
+    @Test
+    fun `loadFromMarkdown over-limit leaves document untouched`() {
+        val holder = holderWith(Block.paragraph("keep me"))
+        val textStates = BlockTextStates()
+        val spanStates = BlockSpanStates()
+        val before = holder.state.blocks
+
+        val result = holder.loadFromMarkdown(
+            "way too long input",
+            textStates,
+            spanStates,
+            limits = MarkdownCodecLimits(maxInputChars = 3),
+        )
+
+        assertTrue(result.isAborted)
+        assertEquals(before, holder.state.blocks)
+    }
+
+    @Test
+    fun `applyMarkdownDecodeResult rejects aborted result`() {
+        val holder = holderWith(Block.paragraph("keep"))
+        val aborted = MarkdownSchema.decodeWithReport(
+            "too long",
+            MarkdownProfile.Default,
+            MarkdownCodecLimits(maxInputChars = 2),
+        )
+        assertFailsWith<IllegalArgumentException> {
+            holder.applyMarkdownDecodeResult(aborted, BlockTextStates(), BlockSpanStates())
+        }
+        assertEquals(1, holder.state.blocks.size)
+    }
+
+    @Test
+    fun `commonmark export drops trailing empty paragraph after a divider`() {
+        val holder = holderWith(Block.divider(), Block.paragraph(""))
+        val md = holder.toMarkdown(BlockTextStates(), BlockSpanStates())
+        assertEquals("---\n", md)
+    }
+
+    @Test
+    fun `loadFromMarkdown clears history on success and leaves it on abort`() {
+        val holder = holderWith(Block.paragraph("keep"))
+        val textStates = BlockTextStates()
+        val spanStates = BlockSpanStates()
+
+        // Abort leaves history state (canUndo) untouched.
+        val before = holder.canUndo
+        val aborted = holder.loadFromMarkdown(
+            "too long",
+            textStates,
+            spanStates,
+            limits = MarkdownCodecLimits(maxInputChars = 2),
+        )
+        assertTrue(aborted.isAborted)
+        assertEquals(before, holder.canUndo)
+
+        // Success is a hard replacement: history is cleared.
+        holder.loadFromMarkdown("# Fresh\n", textStates, spanStates)
+        assertFalse(holder.canUndo)
+    }
+
+    @Test
+    fun `toMarkdown strips runtime spans from a non-spans code block`() {
+        val id = BlockId("code")
+        val holder = holderWith(Block(id, BlockType.Code, BlockContent.Text("code")))
+        val textStates = BlockTextStates()
+        val spanStates = BlockSpanStates()
+        textStates.getOrCreate(id, "code")
+        spanStates.getOrCreate(id, listOf(TextSpan(0, 4, SpanStyle.Bold)), textLength = 4)
+
+        val md = holder.toMarkdown(textStates, spanStates)!!
+        assertFalse(md.contains("**"), "code must not carry span markers: $md")
+        assertTrue(md.contains("code"))
+    }
+
+    @Test
+    fun `commonmark export drops a sole empty trailing paragraph`() {
+        val holder = holderWith(Block.paragraph(""))
+        assertEquals("", holder.toMarkdown(BlockTextStates(), BlockSpanStates()))
+    }
+
+    @Test
+    fun `hardbreak export keeps trailing empty paragraph`() {
+        val hardBreakBase = MarkdownProfile.Default.withNewlineSemantics(NewlineSemantics.HardBreak)
+        val holder = holderWith(Block.paragraph("a"), Block.paragraph(""))
+        val md = holder.toMarkdown(BlockTextStates(), BlockSpanStates(), profile = hardBreakBase)
+        assertEquals("a\n\n", md)
+    }
+}
diff --git a/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownSourceTest.kt b/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownSourceTest.kt
new file mode 100644
index 0000000..4ff431f
--- /dev/null
+++ b/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownSourceTest.kt
@@ -0,0 +1,59 @@
+package io.github.linreal.cascade.editor.markdown
+
+import kotlin.test.Test
+import kotlin.test.assertEquals
+
+@OptIn(ExperimentalCascadeMarkdownApi::class)
+class MarkdownSourceTest {
+
+    @Test
+    fun `projection normalizes bom crlf and lone cr with original boundaries`() {
+        val source = "\uFEFFa\r\nb\rc"
+        val input = MarkdownParseInput.of(source)
+
+        assertEquals("a\nb\nc", input.text)
+        assertEquals(1, input.originalOffset(0))
+        assertEquals(source.indexOf('b'), input.originalOffset(2))
+        assertEquals(source.length, input.originalOffset(input.text.length))
+    }
+
+    @Test
+    fun `slice remains character exact across normalized line endings`() {
+        val source = "one\r\ntwo\nthree"
+        val input = MarkdownParseInput.of(source)
+        val range = MarkdownSourceRange(2, 9)
+
+        assertEquals(source.substring(2, 9), input.slice(range))
+        assertEquals("e\r\ntwo\n", input.slice(range))
+    }
+
+    @Test
+    fun `locator covers bom empty lines and past end`() {
+        val input = MarkdownParseInput.of("\uFEFFab\r\n\r\ncd")
+
+        assertEquals(MarkdownSourceLocation(1, 1), input.locator.locate(0))
+        assertEquals(MarkdownSourceLocation(1, 1), input.locator.locate(1))
+        assertEquals(MarkdownSourceLocation(1, 3), input.locator.locate(3))
+        assertEquals(MarkdownSourceLocation(2, 1), input.locator.locate(5))
+        assertEquals(MarkdownSourceLocation(3, 3), input.locator.locate(100))
+    }
+
+    @Test
+    fun `locator preserves trailing empty line semantics`() {
+        val lf = MarkdownParseInput.of("a\n")
+        val crLf = MarkdownParseInput.of("a\r\n")
+        val trailingEmpty = MarkdownParseInput.of("a\n\n")
+
+        assertEquals(MarkdownSourceLocation(1, 2), lf.locator.locate(100))
+        assertEquals(MarkdownSourceLocation(1, 2), crLf.locator.locate(100))
+        assertEquals(MarkdownSourceLocation(2, 1), trailingEmpty.locator.locate(100))
+    }
+
+    @Test
+    fun `empty projection has a usable locator`() {
+        val input = MarkdownParseInput.of("")
+
+        assertEquals("", input.text)
+        assertEquals(MarkdownSourceLocation(1, 1), input.locator.locate(0))
+    }
+}
diff --git a/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownSpanOverlapTest.kt b/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownSpanOverlapTest.kt
new file mode 100644
index 0000000..c5c0e9c
--- /dev/null
+++ b/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownSpanOverlapTest.kt
@@ -0,0 +1,232 @@
+package io.github.linreal.cascade.editor.markdown
+
+import io.github.linreal.cascade.editor.core.Block
+import io.github.linreal.cascade.editor.core.BlockContent
+import io.github.linreal.cascade.editor.core.BlockId
+import io.github.linreal.cascade.editor.core.BlockType
+import io.github.linreal.cascade.editor.core.SpanStyle
+import io.github.linreal.cascade.editor.core.TextSpan
+import io.github.linreal.cascade.editor.richtext.SpanAlgorithms
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+import kotlin.test.fail
+
+/**
+ * Overlap classification and the honesty contract — the encoder
+ * never produces output that silently decodes to different spans. Every
+ * generated layout must either round-trip exactly or carry a DataLoss-impact
+ * warning explaining what was dropped.
+ */
+class MarkdownSpanOverlapTest {
+
+    private fun paragraph(text: String, spans: List<TextSpan>): Block = Block(
+        id = BlockId.generate(),
+        type = BlockType.Paragraph,
+        content = BlockContent.Text(text, spans),
+    )
+
+    private fun roundTrip(block: Block): Pair<MarkdownEncodeResult, MarkdownDecodeResult?> {
+        val encoded = MarkdownEncodeEngine.encodeWithReport(listOf(block), MarkdownProfile.Default)
+        val markdown = encoded.markdown ?: return encoded to null
+        return encoded to MarkdownDecodeEngine.decode(markdown, MarkdownProfile.Default)
+    }
+
+    // Directed cases
+
+    @Test
+    fun partialOverlapCloseReopenRoundTripsExactly() {
+        val spans = listOf(
+            TextSpan(0, 5, SpanStyle.Bold),
+            TextSpan(3, 8, SpanStyle.Italic),
+        )
+        val (encoded, decoded) = roundTrip(paragraph("abcdefgh", spans))
+        val content = decoded!!.blocks!!.single().content as BlockContent.Text
+        if (encoded.warnings.none { it.impact == MarkdownFidelityImpact.DataLoss }) {
+            assertEquals("abcdefgh", content.text)
+            assertEquals(spans.toSet(), content.spans.toSet())
+        } else {
+            // Drop path is allowed only with an AmbiguousEmphasis warning.
+            assertTrue(encoded.warnings.any { it is MarkdownEncodeWarning.AmbiguousEmphasis })
+        }
+    }
+
+    @Test
+    fun codeCrossingSplitsAndRemergesThroughNormalization() {
+        val spans = listOf(
+            TextSpan(0, 5, SpanStyle.Bold),
+            TextSpan(3, 8, SpanStyle.InlineCode),
+        )
+        val (encoded, decoded) = roundTrip(paragraph("abcdefgh", spans))
+        val content = decoded!!.blocks!!.single().content as BlockContent.Text
+        if (encoded.warnings.none { it.impact == MarkdownFidelityImpact.DataLoss }) {
+            assertEquals(spans.toSet(), content.spans.toSet())
+        } else {
+            assertTrue(
+                encoded.warnings.any {
+                    it is MarkdownEncodeWarning.DroppedSpanOverlap ||
+                        it is MarkdownEncodeWarning.AmbiguousEmphasis
+                },
+            )
+        }
+    }
+
+    // Generated overlap/code-content matrix
+
+    @Test
+    fun generatedOverlapMatrixIsNeverSilentlyDifferent() {
+        val text = "abcdefgh"
+        val styles = listOf(
+            SpanStyle.Bold,
+            SpanStyle.Italic,
+            SpanStyle.StrikeThrough,
+            SpanStyle.InlineCode,
+            SpanStyle.Link("/u"),
+        )
+        val ranges = listOf(
+            0 to 3, 0 to 5, 0 to 8, 2 to 6, 3 to 5, 3 to 8, 5 to 8, 1 to 7,
+        )
+        val failures = StringBuilder()
+        var checked = 0
+        for (styleA in styles) {
+            for (styleB in styles) {
+                for ((startA, endA) in ranges) {
+                    for ((startB, endB) in ranges) {
+                        val spans = listOf(
+                            TextSpan(startA, endA, styleA),
+                            TextSpan(startB, endB, styleB),
+                        )
+                        checked++
+                        val block = paragraph(text, spans)
+                        val encoded = MarkdownEncodeEngine.encodeWithReport(
+                            listOf(block),
+                            MarkdownProfile.Default,
+                        )
+                        val markdown = encoded.markdown
+                        if (markdown == null) {
+                            failures.appendLine("$spans: encode aborted ${encoded.warnings}")
+                            continue
+                        }
+                        val decoded = MarkdownDecodeEngine.decode(markdown, MarkdownProfile.Default)
+                        val decodedBlocks = decoded.blocks
+                        if (decodedBlocks == null) {
+                            failures.appendLine("$spans: decode aborted ${decoded.warnings}")
+                            continue
+                        }
+                        val hasLoss = encoded.warnings.any {
+                            it.impact == MarkdownFidelityImpact.DataLoss
+                        }
+                        if (hasLoss) continue // honest loss, explicitly warned
+                        val content = decodedBlocks.singleOrNull()?.content as? BlockContent.Text
+                        if (content == null) {
+                            failures.appendLine("$spans → $markdown: shape changed on decode")
+                            continue
+                        }
+                        val expected = normalizeForComparison(spans, text.length)
+                        if (content.text != text || content.spans.toSet() != expected.toSet()) {
+                            failures.appendLine(
+                                "$spans → ${markdown.trimEnd()}: decoded " +
+                                    "${content.spans} / ${content.text}",
+                            )
+                        }
+                    }
+                }
+            }
+        }
+        assertTrue(checked > 300, "matrix too small: $checked")
+        if (failures.isNotEmpty()) fail("silent differences:\n$failures")
+    }
+
+    /**
+     * Decode returns normalized spans, so expectations run through the same
+     * normalization contract (same-style merge, link overlap resolution).
+     */
+    private fun normalizeForComparison(spans: List<TextSpan>, length: Int): List<TextSpan> =
+        SpanAlgorithms.normalize(spans, length)
+
+    // decode(encode(x)) == x smoke suite for span-bearing documents
+
+    @Test
+    fun spanBearingDocumentSmokeRoundTrip() {
+        val docs = listOf(
+            listOf(
+                paragraph(
+                    "intro with bold and italic",
+                    listOf(
+                        TextSpan(11, 15, SpanStyle.Bold),
+                        TextSpan(20, 26, SpanStyle.Italic),
+                    ),
+                ),
+                Block(
+                    id = BlockId.generate(),
+                    type = BlockType.Heading(2),
+                    content = BlockContent.Text(
+                        "heading code",
+                        listOf(TextSpan(8, 12, SpanStyle.InlineCode)),
+                    ),
+                ),
+                Block(
+                    id = BlockId.generate(),
+                    type = BlockType.Quote,
+                    content = BlockContent.Text(
+                        "quoted link",
+                        listOf(TextSpan(7, 11, SpanStyle.Link("../rel.md"))),
+                    ),
+                ),
+                Block(
+                    id = BlockId.generate(),
+                    type = BlockType.Todo(checked = true),
+                    content = BlockContent.Text(
+                        "task struck",
+                        listOf(TextSpan(5, 11, SpanStyle.StrikeThrough)),
+                    ),
+                ),
+                Block(
+                    id = BlockId.generate(),
+                    type = BlockType.BulletList,
+                    content = BlockContent.Text(
+                        "item bold",
+                        listOf(TextSpan(5, 9, SpanStyle.Bold)),
+                    ),
+                ),
+            ),
+            listOf(
+                paragraph(
+                    "nested bold italic",
+                    listOf(
+                        TextSpan(0, 18, SpanStyle.Bold),
+                        TextSpan(7, 11, SpanStyle.Italic),
+                    ),
+                ),
+                paragraph(
+                    "hard\nbreak bold",
+                    listOf(TextSpan(0, 10, SpanStyle.Bold)),
+                ),
+            ),
+        )
+        for (doc in docs) {
+            val encoded = MarkdownEncodeEngine.encodeWithReport(doc, MarkdownProfile.Default)
+            val markdown = encoded.markdown ?: fail("encode aborted: ${encoded.warnings}")
+            assertTrue(
+                encoded.warnings.none { it.impact == MarkdownFidelityImpact.DataLoss },
+                "unexpected loss: ${encoded.warnings}",
+            )
+            val decoded = MarkdownDecodeEngine.decode(markdown, MarkdownProfile.Default)
+            val blocks = decoded.blocks ?: fail("decode aborted: ${decoded.warnings}")
+            assertEquals(doc.size, blocks.size, "block count for:\n$markdown")
+            for (index in doc.indices) {
+                val original = doc[index]
+                val reloaded = blocks[index]
+                assertEquals(original.type, reloaded.type, "type at $index:\n$markdown")
+                val originalContent = original.content as BlockContent.Text
+                val reloadedContent = reloaded.content as BlockContent.Text
+                assertEquals(originalContent.text, reloadedContent.text, "text at $index:\n$markdown")
+                assertEquals(
+                    normalizeForComparison(originalContent.spans, originalContent.text.length).toSet(),
+                    reloadedContent.spans.toSet(),
+                    "spans at $index:\n$markdown",
+                )
+            }
+        }
+    }
+}
diff --git a/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownStrictProfileTest.kt b/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownStrictProfileTest.kt
new file mode 100644
index 0000000..a9f8254
--- /dev/null
+++ b/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownStrictProfileTest.kt
@@ -0,0 +1,83 @@
+package io.github.linreal.cascade.editor.markdown
+
+import io.github.linreal.cascade.editor.core.Block
+import io.github.linreal.cascade.editor.core.BlockContent
+import io.github.linreal.cascade.editor.core.SpanStyle
+import io.github.linreal.cascade.editor.core.TextSpan
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertFalse
+import kotlin.test.assertTrue
+
+class MarkdownStrictProfileTest {
+
+    private val strict = MarkdownProfile.Default.withoutHtmlBridge()
+
+    @Test
+    fun `strict profile strips inline html to text with data loss`() {
+        val result = MarkdownSchema.decodeWithReport("<span foo>x</span>", strict)
+        val content = result.blocks!!.single().content as BlockContent.Text
+        assertEquals("x", content.text)
+        assertTrue(result.warnings.any { it is MarkdownDecodeWarning.HtmlStripped })
+        assertTrue(result.warnings.any { it.impact == MarkdownFidelityImpact.DataLoss })
+    }
+
+    @Test
+    fun `strict profile analyze recommends raw fallback for html`() {
+        val report = MarkdownSchema.analyze("<span foo>x</span>", strict)
+        assertEquals(MarkdownEditModeRecommendation.RawFallback, report.recommendedMode)
+        assertTrue(report.dataLossWarnings.isNotEmpty())
+    }
+
+    private val preserveHtml = MarkdownProfile.Default.withHtmlInMarkdown(
+        io.github.linreal.cascade.editor.markdown.HtmlInMarkdown.Preserve,
+    )
+
+    @Test
+    fun `strict profile never emits raw html through any emission path`() {
+        // A document assembled from every raw-HTML-bearing shape: HTML span
+        // encoders, md.preservedHtml verbatim, HTML-kind md.preserved verbatim.
+        val preservedHtml = MarkdownSchema.decode("<div><b>hi</b></div>", preserveHtml)!!
+        val doc = listOf(
+            Block.paragraph(
+                "abc",
+                spans = listOf(
+                    TextSpan(0, 3, SpanStyle.Underline),
+                ),
+            ),
+            Block.paragraph(
+                "def",
+                spans = listOf(TextSpan(0, 3, SpanStyle.Highlight(0xFF00FF00L))),
+            ),
+        ) + preservedHtml
+
+        val encoded = MarkdownSchema.encode(doc, strict) ?: error("encode aborted")
+        assertFalse(encoded.contains("<u>"), "leaked <u>: $encoded")
+        assertFalse(encoded.contains("<mark"), "leaked <mark>: $encoded")
+        assertFalse(encoded.contains("<div"), "leaked <div>: $encoded")
+        assertFalse(encoded.contains("<b>"), "leaked <b>: $encoded")
+        assertFalse(encoded.contains("<script"), "leaked <script>: $encoded")
+    }
+
+    @Test
+    fun `strict support set does not claim underline or highlight`() {
+        assertFalse(strict.supportSet.supportsSpan(SpanStyle.Underline))
+        assertFalse(strict.supportSet.supportsSpan(SpanStyle.Highlight(0xFF00FF00L)))
+        assertTrue(strict.supportSet.supportsSpan(SpanStyle.Bold))
+    }
+
+    @Test
+    fun `strict profile emits no raw script through the preserved-html path`() {
+        // Raw <script> preserved under a Preserve profile becomes an opaque
+        // md.preservedHtml block; strict encode drops it entirely.
+        val withScript = MarkdownSchema.decode("<script>alert(1)</script>", preserveHtml)!!
+        val content = withScript.single().content
+        assertTrue(
+            content is BlockContent.Custom && content.typeId == MARKDOWN_PRESERVED_HTML_TYPE_ID,
+            "expected preserved html, got $content",
+        )
+        val encoded = MarkdownSchema.encode(withScript, strict) ?: ""
+        assertFalse(encoded.contains("<script"), "leaked <script>: $encoded")
+        assertFalse(encoded.contains("alert(1)"), "leaked script body: $encoded")
+    }
+}
diff --git a/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownSupportSetBlockGenerator.kt b/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownSupportSetBlockGenerator.kt
new file mode 100644
index 0000000..3f6a386
--- /dev/null
+++ b/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownSupportSetBlockGenerator.kt
@@ -0,0 +1,219 @@
+package io.github.linreal.cascade.editor.markdown
+
+import io.github.linreal.cascade.editor.core.Block
+import io.github.linreal.cascade.editor.core.BlockAttributes
+import io.github.linreal.cascade.editor.core.BlockContent
+import io.github.linreal.cascade.editor.core.BlockId
+import io.github.linreal.cascade.editor.core.BlockType
+import io.github.linreal.cascade.editor.core.SpanStyle
+import io.github.linreal.cascade.editor.core.TextSpan
+import io.github.linreal.cascade.editor.core.normalizeIndentationOutline
+import io.github.linreal.cascade.editor.core.renumberNumberedLists
+import io.github.linreal.cascade.editor.richtext.SpanAlgorithms
+import kotlin.random.Random
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+
+/**
+ * Deterministic generator for documents that must satisfy a
+ * [MarkdownProfileSupportSet].
+ *
+ * The generator is **self-adapting**: it probes each candidate span style
+ * through the profile's document claim once, so it only emits styles that
+ * currently round-trip (e.g. `Underline` / `Highlight` become available once
+ * the HTML span encoders are registered on the default profile). Every
+ * generated document is verified against [supportSet] before it is returned, so
+ * a generation escape fails loudly rather than producing a false round-trip
+ * assertion.
+ *
+ * ### Reproducibility
+ *
+ * Seeded [Random]; the seed used by the property test is printed on failure so
+ * any counter-example is replayable by re-running with the same seed.
+ */
+internal class MarkdownSupportSetBlockGenerator(
+    private val profile: MarkdownProfile,
+    private val supportSet: MarkdownProfileSupportSet,
+    seed: Long,
+    private val hardBreak: Boolean = false,
+) {
+    private val random: Random = Random(seed)
+
+    /** Span styles that currently pass the document claim, probed once. */
+    private val encodableStyles: List<SpanStyle> by lazy {
+        CANDIDATE_SPAN_STYLES.filter { style ->
+            val probe = listOf(
+                Block(
+                    id = BlockId.generate(),
+                    type = BlockType.Paragraph,
+                    content = BlockContent.Text("alpha beta", listOf(TextSpan(0, 5, style))),
+                ),
+            )
+            supportSet.supportsDocument(probe)
+        }
+    }
+
+    fun nextDocument(maxBlocks: Int = 8): List<Block> {
+        repeat(MAX_GENERATION_ATTEMPTS) {
+            val blocks = normalizeIndentationOutline(buildCandidateDocument(maxBlocks))
+                .let(::renumberNumberedLists)
+            if (supportSet.supportsDocument(blocks)) return blocks
+        }
+        error("Unable to generate a support-set document after $MAX_GENERATION_ATTEMPTS attempts")
+    }
+
+    private fun buildCandidateDocument(maxBlocks: Int): List<Block> {
+        // No claim-specific shaping: candidate documents are drawn freely and
+        // the support set is the round-trip boundary — merge-prone or
+        // front-matter-ambiguous HardBreak shapes are rejected by the claim and
+        // regenerated, so the property test exercises that boundary.
+        val count = random.nextInt(from = 1, until = maxBlocks + 1)
+        return List(count) { index -> candidateBlock(index) }
+    }
+
+    private fun paragraphText(index: Int): String {
+        // Occasionally draw an in-claim hostile fragment so the generator can
+        // catch escaping bugs, not only "wordN alpha beta" text.
+        if (usableHostileTexts.isNotEmpty() && random.nextInt(3) == 0) {
+            return usableHostileTexts[random.nextInt(usableHostileTexts.size)]
+        }
+        return "word$index alpha beta"
+    }
+
+    private fun candidateBlock(index: Int): Block {
+        val text = "word$index alpha beta"
+        if (hardBreak) {
+            // HardBreak's round-trippable block types are leaf blocks plus
+            // explicit empty paragraphs; containers are excluded by the claim.
+            return when (random.nextInt(5)) {
+                0 -> {
+                    val t = paragraphText(index)
+                    textBlock(BlockType.Paragraph, t, spans = candidateSpans(t.length))
+                }
+                1 -> textBlock(BlockType.Heading(random.nextInt(1, 7)), text, spans = candidateSpans(text.length))
+                2 -> textBlock(BlockType.Code, "code$index\nline")
+                3 -> Block.divider()
+                else -> emptyParagraph()
+            }
+        }
+        return when (random.nextInt(7)) {
+            0 -> {
+                val t = paragraphText(index)
+                textBlock(BlockType.Paragraph, t, spans = candidateSpans(t.length))
+            }
+            1 -> textBlock(BlockType.Heading(random.nextInt(1, 7)), text, spans = candidateSpans(text.length))
+            2 -> textBlock(BlockType.Quote, text, spans = candidateSpans(text.length))
+            3 -> textBlock(BlockType.Code, "code$index\nline")
+            4 -> Block.divider()
+            5 -> textBlock(
+                BlockType.BulletList,
+                text,
+                indentation = randomIndentation(),
+                spans = candidateSpans(text.length),
+            )
+            6 -> textBlock(
+                BlockType.NumberedList(1),
+                text,
+                indentation = randomIndentation(),
+                spans = candidateSpans(text.length),
+            )
+            else -> textBlock(
+                BlockType.Todo(random.nextBoolean()),
+                text,
+                indentation = randomIndentation(),
+                spans = candidateSpans(text.length),
+            )
+        }
+    }
+
+    /** Hostile fixture strings that survive the support set as a lone paragraph. */
+    private val usableHostileTexts: List<String> by lazy {
+        MarkdownHostileTextFixtures.strings.filter { fragment ->
+            fragment.isNotEmpty() && supportSet.supportsDocument(
+                listOf(Block(BlockId.generate(), BlockType.Paragraph, BlockContent.Text(fragment))),
+            )
+        }
+    }
+
+    private fun textBlock(
+        type: BlockType,
+        text: String,
+        indentation: Int = 0,
+        spans: List<TextSpan> = emptyList(),
+    ): Block = Block(
+        id = BlockId.generate(),
+        type = type,
+        content = BlockContent.Text(text, spans),
+        attributes = BlockAttributes(indentationLevel = indentation),
+    )
+
+    private fun emptyParagraph(): Block =
+        Block(BlockId.generate(), BlockType.Paragraph, BlockContent.Text(""))
+
+    /** Non-overlapping, word-aligned spans so they always round-trip. */
+    private fun candidateSpans(textLength: Int): List<TextSpan> {
+        if (textLength < 3 || encodableStyles.isEmpty()) return emptyList()
+        val spanCount = random.nextInt(0, 3)
+        if (spanCount == 0) return emptyList()
+
+        val spans = ArrayList<TextSpan>()
+        var cursor = 0
+        repeat(spanCount) {
+            if (cursor >= textLength - 1) return@repeat
+            val gap = random.nextInt(0, 2)
+            val start = (cursor + gap).coerceAtMost(textLength - 1)
+            val end = random.nextInt(start + 1, textLength + 1)
+            spans += TextSpan(start, end, encodableStyles[random.nextInt(encodableStyles.size)])
+            cursor = end + 1
+        }
+        return SpanAlgorithms.normalize(spans, textLength)
+    }
+
+    private fun randomIndentation(): Int =
+        random.nextInt(BlockAttributes.MIN_INDENTATION_LEVEL, BlockAttributes.MAX_INDENTATION_LEVEL + 1)
+
+    companion object {
+        const val MAX_GENERATION_ATTEMPTS: Int = 500
+
+        private val CANDIDATE_SPAN_STYLES: List<SpanStyle> = listOf(
+            SpanStyle.Bold,
+            SpanStyle.Italic,
+            SpanStyle.StrikeThrough,
+            SpanStyle.InlineCode,
+            SpanStyle.Underline,
+            SpanStyle.Highlight(0xFFFFFF00L),
+            SpanStyle.Link("https://example.com/path"),
+            SpanStyle.Link("../relative/guide.md"),
+            SpanStyle.Link("#section"),
+            SpanStyle.Link("mailto:user@example.com"),
+        )
+    }
+}
+
+/** Compare Markdown round-trip output ignoring regenerated [BlockId]s. */
+internal fun assertMarkdownSemanticallyEquals(expected: List<Block>, actual: List<Block>) {
+    assertEquals(expected.size, actual.size, "block count")
+    for (index in expected.indices) {
+        val e = expected[index]
+        val a = actual[index]
+        assertEquals(e.type, a.type, "block $index type")
+        assertEquals(e.attributes, a.attributes, "block $index attributes")
+        assertEquals(
+            e.content.normalizedForComparison(),
+            a.content.normalizedForComparison(),
+            "block $index content",
+        )
+    }
+}
+
+internal fun assertMarkdownSupportSetDocument(supportSet: MarkdownProfileSupportSet, blocks: List<Block>) {
+    assertTrue(
+        supportSet.supportsDocument(blocks),
+        "generated document escaped the support set: $blocks",
+    )
+}
+
+private fun BlockContent.normalizedForComparison(): BlockContent = when (this) {
+    is BlockContent.Text -> BlockContent.Text(text, SpanAlgorithms.normalize(spans, text.length))
+    BlockContent.Empty, is BlockContent.Custom -> this
+}
diff --git a/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownSupportSetTest.kt b/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownSupportSetTest.kt
new file mode 100644
index 0000000..ef338bd
--- /dev/null
+++ b/editor/src/commonTest/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownSupportSetTest.kt
@@ -0,0 +1,147 @@
+package io.github.linreal.cascade.editor.markdown
+
+import io.github.linreal.cascade.editor.core.Block
+import io.github.linreal.cascade.editor.core.BlockAttributes
+import io.github.linreal.cascade.editor.core.BlockContent
+import io.github.linreal.cascade.editor.core.BlockId
+import io.github.linreal.cascade.editor.core.BlockType
+import io.github.linreal.cascade.editor.core.SpanStyle
+import io.github.linreal.cascade.editor.core.TextSpan
+import io.github.linreal.cascade.editor.core.UnknownBlockType
+import kotlin.test.Test
+import kotlin.test.assertFalse
+import kotlin.test.assertTrue
+
+class MarkdownSupportSetTest {
+
+    private val support = MarkdownProfile.Default.supportSet
+
+    @Test
+    fun `supports plain built-in blocks and spans`() {
+        assertTrue(support.supportsBlock(Block.paragraph("a")))
+        assertTrue(support.supportsBlock(Block.heading(2, "a")))
+        assertTrue(support.supportsBlock(Block.todo("a")))
+        assertTrue(support.supportsSpan(SpanStyle.Bold))
+        assertTrue(support.supportsSpan(SpanStyle.InlineCode))
+    }
+
+    @Test
+    fun `rejects empty text block in CommonMark mode`() {
+        assertFalse(support.supportsDocument(listOf(Block.paragraph(""))))
+    }
+
+    @Test
+    fun `rejects preserved block`() {
+        val preserved = Block(
+            id = BlockId.generate(),
+            type = UnknownBlockType(MARKDOWN_PRESERVED_TYPE_ID, "{\"typeId\":\"md.preserved\"}"),
+            content = BlockContent.Custom(MARKDOWN_PRESERVED_TYPE_ID, mapOf("rawMarkdown" to "| a |")),
+        )
+        assertFalse(support.supportsBlock(preserved))
+        assertFalse(support.supportsDocument(listOf(preserved)))
+    }
+
+    @Test
+    fun `highlight claimed only within color range`() {
+        assertTrue(support.supportsSpan(SpanStyle.Highlight(0x00000000L)))
+        assertTrue(support.supportsSpan(SpanStyle.Highlight(0xFFFFFFFFL)))
+        assertFalse(support.supportsSpan(SpanStyle.Highlight(-1L)))
+        assertFalse(support.supportsSpan(SpanStyle.Highlight(0x1_0000_0000L)))
+    }
+
+    @Test
+    fun `custom span excluded`() {
+        assertFalse(support.supportsSpan(SpanStyle.Custom("spoiler")))
+    }
+
+    @Test
+    fun `rejects stale numbering`() {
+        val stale = listOf(
+            Block.numberedList("a", number = 5),
+            Block.numberedList("b", number = 6),
+        )
+        assertFalse(support.supportsDocument(stale))
+    }
+
+    @Test
+    fun `rejects invalid indentation outline`() {
+        val invalid = listOf(
+            Block.paragraph("root"),
+            Block.bulletList("too deep").withAttributes(BlockAttributes(indentationLevel = 3)),
+        )
+        assertFalse(support.supportsDocument(invalid))
+    }
+
+    @Test
+    fun `rejects non-normalized spans`() {
+        val block = Block.paragraph(
+            "abcdef",
+            spans = listOf(
+                TextSpan(0, 3, SpanStyle.Bold),
+                TextSpan(2, 5, SpanStyle.Bold), // overlapping same-style: not normalized
+            ),
+        )
+        assertFalse(support.supportsDocument(listOf(block)))
+    }
+
+    @Test
+    fun `rejects nested links`() {
+        val block = Block.paragraph(
+            "linked text",
+            spans = listOf(
+                TextSpan(0, 11, SpanStyle.Link("https://a.example")),
+                TextSpan(2, 6, SpanStyle.Link("https://b.example")),
+            ),
+        )
+        assertFalse(support.supportsDocument(listOf(block)))
+    }
+
+    @Test
+    fun `rejects value-based exclusions per section 5_12`() {
+        // Trailing-space run: the inline phase trims it, so it never round-trips.
+        assertFalse(support.supportsDocument(listOf(Block.paragraph("trailing   "))))
+        // Leading spaces are stripped by the block phase.
+        assertFalse(support.supportsDocument(listOf(Block.paragraph("   leading"))))
+        // A tab at a syntax-sensitive (line-start) position expands to code indent.
+        assertFalse(support.supportsDocument(listOf(Block.paragraph("\ttabbed"))))
+    }
+
+    @Test
+    fun `rejects carriage returns in text`() {
+        assertFalse(support.supportsDocument(listOf(Block.paragraph("a\rb"))))
+        assertFalse(
+            support.supportsDocument(
+                listOf(Block(BlockId.generate(), BlockType.Code, BlockContent.Text("a\r\nb"))),
+            ),
+        )
+    }
+
+    @Test
+    fun `hardbreak claim follows executable round trip`() {
+        val hb = MarkdownProfile.Default.withNewlineSemantics(NewlineSemantics.HardBreak).supportSet
+        // Adjacent non-empty paragraphs merge on decode.
+        assertFalse(hb.supportsDocument(listOf(Block.paragraph("a"), Block.paragraph("b"))))
+        // ...but an empty paragraph between them is claimable.
+        assertTrue(hb.supportsDocument(listOf(Block.paragraph("a"), Block.paragraph(""), Block.paragraph("b"))))
+        // Leading divider + a later divider is captured by front matter.
+        assertFalse(hb.supportsDocument(listOf(Block.divider(), Block.paragraph("x"), Block.divider())))
+        // A concrete container that survives the canonical round trip is claimed.
+        assertTrue(hb.supportsDocument(listOf(Block.bulletList("item"))))
+    }
+
+    @Test
+    fun `hardbreak claim allows empty text blocks`() {
+        val hb = MarkdownProfile.Default.withNewlineSemantics(NewlineSemantics.HardBreak).supportSet
+        assertTrue(hb.supportsDocument(listOf(Block.paragraph("a"), Block.paragraph(""), Block.paragraph("b"))))
+    }
+
+    @Test
+    fun `accepts a plain supported document`() {
+        val doc = listOf(
+            Block.heading(1, "Title"),
+            Block.paragraph("Body text"),
+            Block.bulletList("Item"),
+        )
+        assertTrue(support.supportsDocument(doc))
+    }
+}
diff --git a/editor/src/desktopTest/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownPerformanceBaselineTest.kt b/editor/src/desktopTest/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownPerformanceBaselineTest.kt
new file mode 100644
index 0000000..c4f532a
--- /dev/null
+++ b/editor/src/desktopTest/kotlin/io/github/linreal/cascade/editor/markdown/MarkdownPerformanceBaselineTest.kt
@@ -0,0 +1,68 @@
+package io.github.linreal.cascade.editor.markdown
+
+import kotlin.test.Test
+import kotlin.test.assertTrue
+
+/**
+ * Performance regression guard. Bounds are deliberately generous
+ * (they guard against complexity regressions, not micro-performance) on a
+ * generated 64 KB mixed-construct field: decode ≤ 250 ms, encode ≤ 250 ms,
+ * `analyze` ≤ 750 ms, and one adversarial (10k-delimiter) input ≤ 1 s.
+ *
+ * Timings are medians over repeated runs after a warm-up and are printed for
+ * review.
+ */
+class MarkdownPerformanceBaselineTest {
+
+    private val profile = MarkdownProfile.Default
+
+    private val document: String = buildString {
+        val unit = buildString {
+            append("# Section heading with **bold** and _italic_ and `code`\n\n")
+            append("A paragraph with a [link](../docs/guide.md) and ~~strike~~ text ")
+            append("that runs on for a while to bulk up the field content nicely.\n\n")
+            append("- bullet one\n- bullet two\n  - nested item\n- bullet three\n\n")
+            append("1. first\n2. second\n3. third\n\n")
+            append("- [ ] open task\n- [x] done task\n\n")
+            append("> a quoted line of text\n\n")
+            append("```\nsome code\nmore code\n```\n\n")
+            append("Another paragraph with <u>underline</u> and a trailing sentence.\n\n")
+        }
+        while (length < 64 * 1024) append(unit)
+    }
+
+    private fun medianMillis(runs: Int, action: () -> Unit): Long {
+        repeat(3) { action() } // warm up
+        val samples = LongArray(runs) {
+            val start = System.nanoTime()
+            action()
+            (System.nanoTime() - start) / 1_000_000
+        }
+        samples.sort()
+        return samples[runs / 2]
+    }
+
+    @Test
+    fun `decode encode and analyze stay within generous bounds on a 64kb field`() {
+        val decodeMs = medianMillis(7) { MarkdownSchema.decode(document, profile) }
+        val decoded = MarkdownSchema.decode(document, profile)!!
+        val encodeMs = medianMillis(7) { MarkdownSchema.encode(decoded, profile) }
+        val analyzeMs = medianMillis(5) { MarkdownSchema.analyze(document, profile) }
+
+        println("[MarkdownPerf] size=${document.length} decode=${decodeMs}ms encode=${encodeMs}ms analyze=${analyzeMs}ms")
+
+        assertTrue(decodeMs <= 250, "decode median ${decodeMs}ms exceeded 250ms")
+        assertTrue(encodeMs <= 250, "encode median ${encodeMs}ms exceeded 250ms")
+        assertTrue(analyzeMs <= 750, "analyze median ${analyzeMs}ms exceeded 750ms")
+    }
+
+    @Test
+    fun `adversarial delimiter run completes or aborts within one second`() {
+        val adversarial = "*".repeat(10_000)
+        val start = System.nanoTime()
+        val result = MarkdownSchema.decodeWithReport(adversarial, profile)
+        val elapsedMs = (System.nanoTime() - start) / 1_000_000
+        println("[MarkdownPerf] adversarial 10k '*' -> ${if (result.isAborted) "aborted" else "completed"} in ${elapsedMs}ms")
+        assertTrue(elapsedMs <= 1_000, "adversarial input took ${elapsedMs}ms (> 1s)")
+    }
+}
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index 3dba253..f6925b6 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -11,6 +11,7 @@ kotlin = "2.3.21"
 kotlinxCoroutinesTest = "1.11.0"
 kotlinxDatetime = "0.8.0"
 kotlinxSerializationJson = "1.11.0"
+jetbrainsMarkdown = "0.7.7"
 material3 = "1.10.0-alpha05"
 vanniktechPublish = "0.35.0"
 
@@ -31,6 +32,7 @@ compose-uiToolingPreview = { module = "org.jetbrains.compose.ui:ui-tooling-previ
 kotlinx-coroutines-test = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-test", version.ref = "kotlinxCoroutinesTest" }
 kotlinx-datetime = { module = "org.jetbrains.kotlinx:kotlinx-datetime", version.ref = "kotlinxDatetime" }
 kotlinx-serialization-json = { module = "org.jetbrains.kotlinx:kotlinx-serialization-json", version.ref = "kotlinxSerializationJson" }
+jetbrains-markdown = { module = "org.jetbrains:markdown", version.ref = "jetbrainsMarkdown" }
 
 [plugins]
 androidApplication = { id = "com.android.application", version.ref = "agp" }
diff --git a/sample/src/commonMain/kotlin/io/github/linreal/cascade/App.kt b/sample/src/commonMain/kotlin/io/github/linreal/cascade/App.kt
index 6ee696e..498cf92 100644
--- a/sample/src/commonMain/kotlin/io/github/linreal/cascade/App.kt
+++ b/sample/src/commonMain/kotlin/io/github/linreal/cascade/App.kt
@@ -34,6 +34,7 @@ import io.github.linreal.cascade.screens.EditorDemoScreen
 import io.github.linreal.cascade.screens.comments.CommentsScreen
 import io.github.linreal.cascade.screens.external_toolbar.ExternalToolbarScreen
 import io.github.linreal.cascade.screens.LandingScreen
+import io.github.linreal.cascade.screens.markdownfield.MarkdownFieldScreen
 import io.github.linreal.cascade.theme.CascadeSampleColors
 import io.github.linreal.cascade.theme.LocalCascadeSampleColors
 import io.github.linreal.cascade.theme.sampleTypography
@@ -121,6 +122,11 @@ fun App() {
                         onToggleTheme = { themeOverride = !isDark },
                         onBack = { currentScreen = AppScreen.Landing },
                     )
+                    AppScreen.MarkdownField -> MarkdownFieldScreen(
+                        isDark = isDark,
+                        onToggleTheme = { themeOverride = !isDark },
+                        onBack = { currentScreen = AppScreen.Landing },
+                    )
                 }
             }
         }
diff --git a/sample/src/commonMain/kotlin/io/github/linreal/cascade/navigation/AppScreen.kt b/sample/src/commonMain/kotlin/io/github/linreal/cascade/navigation/AppScreen.kt
index 1d1629b..2d0fc54 100644
--- a/sample/src/commonMain/kotlin/io/github/linreal/cascade/navigation/AppScreen.kt
+++ b/sample/src/commonMain/kotlin/io/github/linreal/cascade/navigation/AppScreen.kt
@@ -8,6 +8,7 @@ sealed class AppScreen {
     data object ExternalToolbar : AppScreen()
     data object CustomHtmlProfile : AppScreen()
     data object Comments : AppScreen()
+    data object MarkdownField : AppScreen()
 
     internal val saveKey: String
         get() = when (this) {
@@ -18,6 +19,7 @@ sealed class AppScreen {
             ExternalToolbar -> "external_toolbar"
             CustomHtmlProfile -> "custom_html_profile"
             Comments -> "comments"
+            MarkdownField -> "markdown_field"
         }
 
     companion object {
@@ -29,6 +31,7 @@ sealed class AppScreen {
             ExternalToolbar.saveKey -> ExternalToolbar
             CustomHtmlProfile.saveKey -> CustomHtmlProfile
             Comments.saveKey -> Comments
+            MarkdownField.saveKey -> MarkdownField
             else -> Landing
         }
     }
diff --git a/sample/src/commonMain/kotlin/io/github/linreal/cascade/screens/LandingScreen.kt b/sample/src/commonMain/kotlin/io/github/linreal/cascade/screens/LandingScreen.kt
index 782eaf7..6858cad 100644
--- a/sample/src/commonMain/kotlin/io/github/linreal/cascade/screens/LandingScreen.kt
+++ b/sample/src/commonMain/kotlin/io/github/linreal/cascade/screens/LandingScreen.kt
@@ -164,6 +164,14 @@ fun LandingScreen(
                     description = "Embed the editor as a chat composer",
                     onClick = { onNavigate(AppScreen.Comments) },
                 )
+                ModuleCard(
+                    colors = colors,
+                    icon = Res.drawable.ic_brackets_angle,
+                    tile = colors.tileHtml,
+                    title = "Markdown Round Trip",
+                    description = "Test source → editor → export across Markdown codec modes",
+                    onClick = { onNavigate(AppScreen.MarkdownField) },
+                )
             }
 
             Spacer(modifier = Modifier.height(40.dp))
diff --git a/sample/src/commonMain/kotlin/io/github/linreal/cascade/screens/markdownfield/MarkdownFieldScreen.kt b/sample/src/commonMain/kotlin/io/github/linreal/cascade/screens/markdownfield/MarkdownFieldScreen.kt
new file mode 100644
index 0000000..1c03e5a
--- /dev/null
+++ b/sample/src/commonMain/kotlin/io/github/linreal/cascade/screens/markdownfield/MarkdownFieldScreen.kt
@@ -0,0 +1,901 @@
+@file:OptIn(io.github.linreal.cascade.editor.markdown.ExperimentalCascadeMarkdownApi::class)
+
+package io.github.linreal.cascade.screens.markdownfield
+
+import androidx.compose.foundation.border
+import androidx.compose.foundation.horizontalScroll
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.imePadding
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material3.Button
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.OutlinedButton
+import androidx.compose.material3.OutlinedTextField
+import androidx.compose.material3.Surface
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.text.TextStyle
+import androidx.compose.ui.text.font.FontFamily
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import io.github.linreal.cascade.editor.markdown.EntityDecode
+import io.github.linreal.cascade.editor.markdown.HardBreakEncode
+import io.github.linreal.cascade.editor.markdown.HtmlInMarkdown
+import io.github.linreal.cascade.editor.markdown.MarkdownDecodeResult
+import io.github.linreal.cascade.editor.markdown.MarkdownDecodeWarning
+import io.github.linreal.cascade.editor.markdown.MarkdownEditModeRecommendation
+import io.github.linreal.cascade.editor.markdown.MarkdownEncodeResult
+import io.github.linreal.cascade.editor.markdown.MarkdownEncodeWarning
+import io.github.linreal.cascade.editor.markdown.MarkdownFidelityImpact
+import io.github.linreal.cascade.editor.markdown.MarkdownFidelityReport
+import io.github.linreal.cascade.editor.markdown.MarkdownLineEnding
+import io.github.linreal.cascade.editor.markdown.MarkdownProfile
+import io.github.linreal.cascade.editor.markdown.MarkdownSchema
+import io.github.linreal.cascade.editor.markdown.MarkdownSourceLocator
+import io.github.linreal.cascade.editor.markdown.NewlineSemantics
+import io.github.linreal.cascade.editor.markdown.SoftBreak
+import io.github.linreal.cascade.editor.markdown.UnsupportedSyntax
+import io.github.linreal.cascade.editor.markdown.applyMarkdownDecodeResult
+import io.github.linreal.cascade.editor.markdown.loadFromMarkdown
+import io.github.linreal.cascade.editor.markdown.toMarkdownWithReport
+import io.github.linreal.cascade.editor.state.BlockSpanStates
+import io.github.linreal.cascade.editor.state.BlockTextStates
+import io.github.linreal.cascade.editor.state.rememberEditorState
+import io.github.linreal.cascade.editor.ui.CascadeEditor
+import io.github.linreal.cascade.screens.TitledEditorTopBar
+import io.github.linreal.cascade.theme.SampleEditorTheme
+import io.github.linreal.cascade.ui.PageScaffold
+
+private const val COMMONMARK_SAMPLE = "# Markdown round trip\n\n" +
+    "Edit **bold**, *italic*, ~~strike~~, `code`, and a [relative link](../guide.md).\n\n" +
+    "- First item\n- Second item\n\n> Quotes and <u>HTML-backed underline</u> are supported.\n"
+
+private const val HARD_BREAK_SAMPLE = "Daily update\n" +
+    "First visible line\n" +
+    "Second visible line\n\n" +
+    "Blank lines become explicit empty paragraphs.\n"
+
+const val PRESERVED_SAMPLE = "# Unsupported syntax\n\n" +
+    "The table below is preserved by the default profile.\n\n" +
+    "| item | usd |\n| --- | ---: |\n| infra | 42 |\n"
+
+private const val HTML_SAMPLE = "# HTML policies\n\n" +
+    "<u>Underline with **nested bold**</u> and " +
+    "<mark data-cascade-highlight=\"FFFFD54F\">highlight</mark>.\n\n" +
+    "<section><p>Block HTML passes through the fragment bridge.</p></section>\n"
+
+private enum class MarkdownSample(val label: String) {
+    CommonMark("CommonMark sample"),
+    HardBreak("Hard-break sample"),
+    Unsupported("Unsupported sample"),
+    Html("HTML sample"),
+}
+
+private enum class NewlineMode(val label: String) {
+    CommonMark("CommonMark"),
+    HardBreak("Hard break"),
+}
+
+private enum class SoftBreakMode(val label: String) {
+    Space("Space"),
+    LineBreak("Literal newline"),
+}
+
+private enum class HardBreakStyle(val label: String) {
+    Backslash("Backslash"),
+    TwoSpaces("Two spaces"),
+}
+
+private enum class UnsupportedMode(val label: String) {
+    Preserve("Preserve"),
+    Degrade("Warn + degrade"),
+}
+
+private enum class MarkdownHtmlMode(val label: String) {
+    Bridge("Bridge"),
+    Preserve("Preserve"),
+    WarnAndStrip("Warn + strip"),
+    Strip("Strip"),
+    Strict("Strict no-HTML"),
+}
+
+private enum class EntityMode(val label: String) {
+    Decode("Decode"),
+    Literal("Keep literal"),
+}
+
+/**
+ * Interactive Markdown codec playground, mirroring [io.github.linreal.cascade.screens.CustomHtmlProfileScreen].
+ *
+ * The source field, editor document, and exported field are deliberately
+ * separate. Analyze inspects source without mutation; Import replaces the
+ * editor; Export serializes the editor; Round Trip performs Import then Export.
+ * Every public Markdown policy can be selected so behavior and fidelity
+ * warnings are visible instead of hidden behind the host-contract sample.
+ */
+@Composable
+fun MarkdownFieldScreen(
+    isDark: Boolean,
+    onToggleTheme: () -> Unit,
+    onBack: () -> Unit,
+    initialSource: String = COMMONMARK_SAMPLE,
+) {
+    val editorTheme = if (isDark) SampleEditorTheme.dark() else SampleEditorTheme.light()
+    val textStates = remember { BlockTextStates() }
+    val spanStates = remember { BlockSpanStates() }
+
+    val initialReport = remember(initialSource) {
+        MarkdownSchema.analyze(initialSource, MarkdownProfile.Default)
+    }
+    val editorState = rememberEditorState(initialReport.decodeResult.blocks.orEmpty())
+
+    var sourceMarkdown by remember(initialSource) { mutableStateOf(initialSource) }
+    var exportedMarkdown by remember(initialSource) {
+        mutableStateOf(initialReport.encodeResult?.markdown.orEmpty())
+    }
+    var newlineMode by remember { mutableStateOf(NewlineMode.CommonMark) }
+    var softBreakMode by remember { mutableStateOf(SoftBreakMode.Space) }
+    var hardBreakStyle by remember { mutableStateOf(HardBreakStyle.Backslash) }
+    var unsupportedMode by remember { mutableStateOf(UnsupportedMode.Preserve) }
+    var htmlMode by remember { mutableStateOf(MarkdownHtmlMode.Bridge) }
+    var entityMode by remember { mutableStateOf(EntityMode.Decode) }
+    var lineEnding by remember { mutableStateOf(MarkdownLineEnding.Lf) }
+
+    var lastAnalysis by remember { mutableStateOf<MarkdownFidelityReport?>(initialReport) }
+    var lastDecode by remember { mutableStateOf<MarkdownDecodeResult?>(initialReport.decodeResult) }
+    var lastEncode by remember { mutableStateOf<MarkdownEncodeResult?>(initialReport.encodeResult) }
+    var status by remember {
+        mutableStateOf(
+            compareMarkdown(
+                source = initialSource,
+                exported = initialReport.encodeResult?.markdown.orEmpty(),
+                profile = MarkdownProfile.Default,
+                lineEnding = MarkdownLineEnding.Lf,
+            ),
+        )
+    }
+
+    val profile = remember(
+        newlineMode,
+        softBreakMode,
+        hardBreakStyle,
+        unsupportedMode,
+        htmlMode,
+        entityMode,
+    ) {
+        buildMarkdownProfile(
+            newlineMode = newlineMode,
+            softBreakMode = softBreakMode,
+            hardBreakStyle = hardBreakStyle,
+            unsupportedMode = unsupportedMode,
+            htmlMode = htmlMode,
+            entityMode = entityMode,
+        )
+    }
+
+    fun invalidateResults(message: String) {
+        lastAnalysis = null
+        lastDecode = null
+        lastEncode = null
+        status = message
+    }
+
+    fun selectSample(sample: MarkdownSample) {
+        sourceMarkdown = when (sample) {
+            MarkdownSample.CommonMark -> COMMONMARK_SAMPLE
+            MarkdownSample.HardBreak -> HARD_BREAK_SAMPLE
+            MarkdownSample.Unsupported -> PRESERVED_SAMPLE
+            MarkdownSample.Html -> HTML_SAMPLE
+        }
+        when (sample) {
+            MarkdownSample.CommonMark -> {
+                newlineMode = NewlineMode.CommonMark
+                unsupportedMode = UnsupportedMode.Preserve
+                htmlMode = MarkdownHtmlMode.Bridge
+            }
+            MarkdownSample.HardBreak -> newlineMode = NewlineMode.HardBreak
+            MarkdownSample.Unsupported -> unsupportedMode = UnsupportedMode.Preserve
+            MarkdownSample.Html -> htmlMode = MarkdownHtmlMode.Bridge
+        }
+        invalidateResults("Sample loaded — run Analyze or Round Trip")
+    }
+
+    fun analyzeSource() {
+        val report = MarkdownSchema.analyze(sourceMarkdown, profile)
+        lastAnalysis = report
+        lastDecode = report.decodeResult
+        lastEncode = report.encodeResult
+        status = buildString {
+            append("Analysis: ")
+            append(report.recommendedMode.displayName)
+            if (report.preservedBlockCount > 0) {
+                append(" · ${report.preservedBlockCount} preserved")
+            }
+        }
+    }
+
+    fun importSource() {
+        val result = editorState.loadFromMarkdown(
+            markdown = sourceMarkdown,
+            textStates = textStates,
+            spanStates = spanStates,
+            profile = profile,
+        )
+        lastAnalysis = null
+        lastDecode = result
+        lastEncode = null
+        status = if (result.isSuccess) {
+            "Imported ${result.blocks.orEmpty().size} block(s)"
+        } else {
+            "Import aborted — editor left unchanged"
+        }
+    }
+
+    fun exportEditor() {
+        val result = editorState.toMarkdownWithReport(
+            textStates = textStates,
+            spanStates = spanStates,
+            profile = profile,
+            lineEnding = lineEnding,
+        )
+        lastEncode = result
+        result.markdown?.let { exportedMarkdown = it }
+        status = if (result.isSuccess) {
+            compareMarkdown(sourceMarkdown, exportedMarkdown, profile, lineEnding)
+        } else {
+            "Export aborted — previous output retained"
+        }
+    }
+
+    fun roundTrip() {
+        val report = MarkdownSchema.analyze(sourceMarkdown, profile)
+        lastAnalysis = report
+        lastDecode = report.decodeResult
+        if (!report.decodeResult.isSuccess) {
+            lastEncode = report.encodeResult
+            status = "Round trip aborted during decode — editor left unchanged"
+            return
+        }
+
+        editorState.applyMarkdownDecodeResult(report.decodeResult, textStates, spanStates)
+        val encode = editorState.toMarkdownWithReport(
+            textStates = textStates,
+            spanStates = spanStates,
+            profile = profile,
+            lineEnding = lineEnding,
+        )
+        lastEncode = encode
+        encode.markdown?.let { exportedMarkdown = it }
+        status = if (encode.isSuccess) {
+            compareMarkdown(sourceMarkdown, exportedMarkdown, profile, lineEnding)
+        } else {
+            "Round trip aborted during encode"
+        }
+    }
+
+    val profileSummary = profileSummary(
+        newlineMode = newlineMode,
+        softBreakMode = softBreakMode,
+        hardBreakStyle = hardBreakStyle,
+        unsupportedMode = unsupportedMode,
+        htmlMode = htmlMode,
+        entityMode = entityMode,
+        lineEnding = lineEnding,
+    )
+
+    PageScaffold(maxContentWidth = 1040.dp) {
+        TitledEditorTopBar(
+            title = "Markdown round trip",
+            isDark = isDark,
+            onBack = onBack,
+            onToggleTheme = onToggleTheme,
+        )
+
+        Column(
+            modifier = Modifier
+                .fillMaxSize()
+                .verticalScroll(rememberScrollState())
+                .imePadding()
+                .padding(horizontal = 4.dp),
+            verticalArrangement = Arrangement.spacedBy(12.dp),
+        ) {
+            Text(
+                text = "Analyze inspects source. Import loads the editor. Export reads the editor. " +
+                    "Round Trip imports and immediately exports with the selected policies.",
+                style = MaterialTheme.typography.bodyMedium,
+                color = MaterialTheme.colorScheme.onSurfaceVariant,
+            )
+
+            SampleSelector(onSelect = ::selectSample)
+
+            MarkdownModePanel(
+                newlineMode = newlineMode,
+                onNewlineMode = {
+                    newlineMode = it
+                    invalidateResults("Newline mode changed — run Analyze or Round Trip")
+                },
+                softBreakMode = softBreakMode,
+                onSoftBreakMode = {
+                    softBreakMode = it
+                    invalidateResults("Soft-break policy changed — run Analyze or Round Trip")
+                },
+                hardBreakStyle = hardBreakStyle,
+                onHardBreakStyle = {
+                    hardBreakStyle = it
+                    invalidateResults("Hard-break encoding changed — run Analyze or Round Trip")
+                },
+                unsupportedMode = unsupportedMode,
+                onUnsupportedMode = {
+                    unsupportedMode = it
+                    invalidateResults("Unsupported-syntax policy changed — run Analyze or Round Trip")
+                },
+                htmlMode = htmlMode,
+                onHtmlMode = {
+                    htmlMode = it
+                    invalidateResults("HTML policy changed — run Analyze or Round Trip")
+                },
+                entityMode = entityMode,
+                onEntityMode = {
+                    entityMode = it
+                    invalidateResults("Entity policy changed — run Analyze or Round Trip")
+                },
+                lineEnding = lineEnding,
+                onLineEnding = {
+                    lineEnding = it
+                    invalidateResults("Output line ending changed — run Export or Round Trip")
+                },
+            )
+
+            ActionRow(
+                onAnalyze = ::analyzeSource,
+                onImport = ::importSource,
+                onRoundTrip = ::roundTrip,
+                onExport = ::exportEditor,
+            )
+
+            RoundTripSummaryPanel(
+                status = status,
+                profileSummary = profileSummary,
+                report = lastAnalysis,
+            )
+
+            DiagnosticsPanel(
+                title = "Decode diagnostics",
+                emptyMessage = "Analyze, Import, or Round Trip to inspect source diagnostics.",
+                lines = lastDecode?.warningLines().orEmpty(),
+                hasLoss = lastDecode?.warnings?.hasLossOrFatal() == true,
+            )
+
+            DiagnosticsPanel(
+                title = "Encode diagnostics",
+                emptyMessage = "Analyze, Export, or Round Trip to inspect output diagnostics.",
+                lines = lastEncode?.warningLines().orEmpty(),
+                hasLoss = lastEncode?.warnings?.hasLossOrFatal() == true,
+            )
+
+            MarkdownTextArea(
+                label = "Source Markdown",
+                value = sourceMarkdown,
+                onValueChange = {
+                    sourceMarkdown = it
+                    invalidateResults("Source changed — run Analyze or Round Trip")
+                },
+            )
+
+            Text(
+                text = "CascadeEditor document",
+                style = MaterialTheme.typography.titleSmall,
+                color = MaterialTheme.colorScheme.onSurface,
+            )
+            Box(
+                modifier = Modifier
+                    .fillMaxWidth()
+                    .height(360.dp)
+                    .clip(RoundedCornerShape(8.dp))
+                    .border(
+                        width = 1.dp,
+                        color = MaterialTheme.colorScheme.outlineVariant,
+                        shape = RoundedCornerShape(8.dp),
+                    )
+                    .padding(8.dp),
+            ) {
+                CascadeEditor(
+                    stateHolder = editorState,
+                    textStates = textStates,
+                    spanStates = spanStates,
+                    theme = editorTheme,
+                    modifier = Modifier.fillMaxSize(),
+                )
+            }
+
+            MarkdownTextArea(
+                label = "Exported Markdown",
+                value = exportedMarkdown,
+                onValueChange = {},
+                readOnly = true,
+            )
+
+            Text(
+                text = "Byte match compares the fields exactly. Canonical match means both fields " +
+                    "decode and re-encode to the same canonical document under the selected profile.",
+                style = MaterialTheme.typography.labelSmall,
+                color = MaterialTheme.colorScheme.onSurfaceVariant,
+            )
+            Spacer(modifier = Modifier.height(16.dp))
+        }
+    }
+}
+
+@Composable
+private fun SampleSelector(onSelect: (MarkdownSample) -> Unit) {
+    Column(verticalArrangement = Arrangement.spacedBy(6.dp)) {
+        Text(
+            text = "Source presets",
+            style = MaterialTheme.typography.titleSmall,
+            color = MaterialTheme.colorScheme.onSurface,
+        )
+        Row(
+            modifier = Modifier
+                .fillMaxWidth()
+                .horizontalScroll(rememberScrollState()),
+            horizontalArrangement = Arrangement.spacedBy(8.dp),
+        ) {
+            MarkdownSample.entries.forEach { sample ->
+                OutlinedButton(onClick = { onSelect(sample) }) {
+                    Text(sample.label)
+                }
+            }
+        }
+    }
+}
+
+@Composable
+private fun MarkdownModePanel(
+    newlineMode: NewlineMode,
+    onNewlineMode: (NewlineMode) -> Unit,
+    softBreakMode: SoftBreakMode,
+    onSoftBreakMode: (SoftBreakMode) -> Unit,
+    hardBreakStyle: HardBreakStyle,
+    onHardBreakStyle: (HardBreakStyle) -> Unit,
+    unsupportedMode: UnsupportedMode,
+    onUnsupportedMode: (UnsupportedMode) -> Unit,
+    htmlMode: MarkdownHtmlMode,
+    onHtmlMode: (MarkdownHtmlMode) -> Unit,
+    entityMode: EntityMode,
+    onEntityMode: (EntityMode) -> Unit,
+    lineEnding: MarkdownLineEnding,
+    onLineEnding: (MarkdownLineEnding) -> Unit,
+) {
+    Surface(
+        color = MaterialTheme.colorScheme.surface,
+        shape = RoundedCornerShape(8.dp),
+        modifier = Modifier
+            .fillMaxWidth()
+            .border(1.dp, MaterialTheme.colorScheme.outlineVariant, RoundedCornerShape(8.dp)),
+    ) {
+        Column(
+            modifier = Modifier.padding(12.dp),
+            verticalArrangement = Arrangement.spacedBy(10.dp),
+        ) {
+            Text(
+                text = "Codec modes",
+                style = MaterialTheme.typography.titleSmall,
+                color = MaterialTheme.colorScheme.onSurface,
+            )
+            ModeSelector(
+                label = "Newlines",
+                selected = newlineMode,
+                options = NewlineMode.entries,
+                optionLabel = NewlineMode::label,
+                onSelected = onNewlineMode,
+            )
+            ModeSelector(
+                label = "Soft break (CommonMark only)",
+                selected = softBreakMode,
+                options = SoftBreakMode.entries,
+                optionLabel = SoftBreakMode::label,
+                onSelected = onSoftBreakMode,
+            )
+            ModeSelector(
+                label = "Hard-break marker (CommonMark only)",
+                selected = hardBreakStyle,
+                options = HardBreakStyle.entries,
+                optionLabel = HardBreakStyle::label,
+                onSelected = onHardBreakStyle,
+            )
+            ModeSelector(
+                label = "Unsupported syntax",
+                selected = unsupportedMode,
+                options = UnsupportedMode.entries,
+                optionLabel = UnsupportedMode::label,
+                onSelected = onUnsupportedMode,
+            )
+            ModeSelector(
+                label = "HTML in Markdown",
+                selected = htmlMode,
+                options = MarkdownHtmlMode.entries,
+                optionLabel = MarkdownHtmlMode::label,
+                onSelected = onHtmlMode,
+            )
+            ModeSelector(
+                label = "Entities",
+                selected = entityMode,
+                options = EntityMode.entries,
+                optionLabel = EntityMode::label,
+                onSelected = onEntityMode,
+            )
+            ModeSelector(
+                label = "Output line ending",
+                selected = lineEnding,
+                options = MarkdownLineEnding.entries,
+                optionLabel = { if (it == MarkdownLineEnding.Lf) "LF" else "CRLF" },
+                onSelected = onLineEnding,
+            )
+        }
+    }
+}
+
+@Composable
+private fun <T> ModeSelector(
+    label: String,
+    selected: T,
+    options: List<T>,
+    optionLabel: (T) -> String,
+    onSelected: (T) -> Unit,
+) {
+    Column(verticalArrangement = Arrangement.spacedBy(4.dp)) {
+        Text(
+            text = label,
+            style = MaterialTheme.typography.labelMedium,
+            color = MaterialTheme.colorScheme.onSurfaceVariant,
+        )
+        Row(
+            modifier = Modifier
+                .fillMaxWidth()
+                .horizontalScroll(rememberScrollState()),
+            horizontalArrangement = Arrangement.spacedBy(8.dp),
+            verticalAlignment = Alignment.CenterVertically,
+        ) {
+            options.forEach { option ->
+                if (option == selected) {
+                    Button(onClick = { onSelected(option) }) {
+                        Text(optionLabel(option))
+                    }
+                } else {
+                    OutlinedButton(onClick = { onSelected(option) }) {
+                        Text(optionLabel(option))
+                    }
+                }
+            }
+        }
+    }
+}
+
+@Composable
+private fun ActionRow(
+    onAnalyze: () -> Unit,
+    onImport: () -> Unit,
+    onRoundTrip: () -> Unit,
+    onExport: () -> Unit,
+) {
+    Row(
+        modifier = Modifier
+            .fillMaxWidth()
+            .horizontalScroll(rememberScrollState()),
+        horizontalArrangement = Arrangement.spacedBy(8.dp),
+        verticalAlignment = Alignment.CenterVertically,
+    ) {
+        OutlinedButton(onClick = onAnalyze) { Text("Analyze") }
+        Button(onClick = onImport) { Text("Import") }
+        Button(onClick = onRoundTrip) { Text("Round Trip") }
+        Button(onClick = onExport) { Text("Export") }
+    }
+}
+
+@Composable
+private fun RoundTripSummaryPanel(
+    status: String,
+    profileSummary: String,
+    report: MarkdownFidelityReport?,
+) {
+    Surface(
+        color = MaterialTheme.colorScheme.surface,
+        shape = RoundedCornerShape(8.dp),
+        modifier = Modifier
+            .fillMaxWidth()
+            .border(1.dp, MaterialTheme.colorScheme.outlineVariant, RoundedCornerShape(8.dp)),
+    ) {
+        Column(
+            modifier = Modifier.padding(12.dp),
+            verticalArrangement = Arrangement.spacedBy(6.dp),
+        ) {
+            Text(
+                text = status,
+                style = MaterialTheme.typography.titleSmall,
+                color = MaterialTheme.colorScheme.onSurface,
+            )
+            Text(
+                text = profileSummary,
+                style = MaterialTheme.typography.bodySmall,
+                color = MaterialTheme.colorScheme.onSurfaceVariant,
+            )
+            if (report == null) {
+                Text(
+                    text = "Run Analyze or Round Trip to refresh the fidelity recommendation.",
+                    style = MaterialTheme.typography.labelSmall,
+                    color = MaterialTheme.colorScheme.onSurfaceVariant,
+                )
+            } else {
+                Text(
+                    text = "Recommended editor: ${report.recommendedMode.displayName} · " +
+                        "native safe: ${report.nativeEditingSafe.yesNo()} · " +
+                        "rewrites source: ${report.wouldRewriteSource.yesNoOrUnknown()} · " +
+                        "preserved blocks: ${report.preservedBlockCount}",
+                    style = MaterialTheme.typography.labelSmall,
+                    color = if (report.nativeEditingSafe) {
+                        MaterialTheme.colorScheme.primary
+                    } else {
+                        MaterialTheme.colorScheme.error
+                    },
+                )
+            }
+        }
+    }
+}
+
+@Composable
+private fun DiagnosticsPanel(
+    title: String,
+    emptyMessage: String,
+    lines: List<String>,
+    hasLoss: Boolean,
+) {
+    val borderColor = if (hasLoss) {
+        MaterialTheme.colorScheme.error.copy(alpha = 0.55f)
+    } else {
+        MaterialTheme.colorScheme.outlineVariant
+    }
+    Surface(
+        color = MaterialTheme.colorScheme.surface,
+        shape = RoundedCornerShape(8.dp),
+        modifier = Modifier
+            .fillMaxWidth()
+            .border(1.dp, borderColor, RoundedCornerShape(8.dp)),
+    ) {
+        Column(
+            modifier = Modifier.padding(12.dp),
+            verticalArrangement = Arrangement.spacedBy(6.dp),
+        ) {
+            Row(
+                modifier = Modifier.fillMaxWidth(),
+                horizontalArrangement = Arrangement.SpaceBetween,
+                verticalAlignment = Alignment.CenterVertically,
+            ) {
+                Text(
+                    text = title,
+                    style = MaterialTheme.typography.titleSmall,
+                    color = if (hasLoss) MaterialTheme.colorScheme.error else MaterialTheme.colorScheme.onSurface,
+                )
+                Text(
+                    text = if (lines.isEmpty()) "None" else "${lines.size} warning(s)",
+                    style = MaterialTheme.typography.labelSmall,
+                    color = MaterialTheme.colorScheme.onSurfaceVariant,
+                )
+            }
+            if (lines.isEmpty()) {
+                Text(
+                    text = emptyMessage,
+                    style = MaterialTheme.typography.bodySmall,
+                    color = MaterialTheme.colorScheme.onSurfaceVariant,
+                )
+            } else {
+                lines.take(8).forEachIndexed { index, line ->
+                    Text(
+                        text = "${index + 1}. $line",
+                        style = MaterialTheme.typography.bodySmall,
+                        color = MaterialTheme.colorScheme.onSurface,
+                    )
+                }
+                if (lines.size > 8) {
+                    Text(
+                        text = "+${lines.size - 8} more",
+                        style = MaterialTheme.typography.labelSmall,
+                        color = MaterialTheme.colorScheme.onSurfaceVariant,
+                    )
+                }
+            }
+        }
+    }
+}
+
+@Composable
+private fun MarkdownTextArea(
+    label: String,
+    value: String,
+    onValueChange: (String) -> Unit,
+    readOnly: Boolean = false,
+) {
+    OutlinedTextField(
+        value = value,
+        onValueChange = onValueChange,
+        readOnly = readOnly,
+        label = { Text(label) },
+        textStyle = TextStyle(
+            fontFamily = FontFamily.Monospace,
+            fontSize = 12.sp,
+            lineHeight = 16.sp,
+        ),
+        minLines = 8,
+        maxLines = 14,
+        modifier = Modifier.fillMaxWidth(),
+    )
+}
+
+private fun buildMarkdownProfile(
+    newlineMode: NewlineMode,
+    softBreakMode: SoftBreakMode,
+    hardBreakStyle: HardBreakStyle,
+    unsupportedMode: UnsupportedMode,
+    htmlMode: MarkdownHtmlMode,
+    entityMode: EntityMode,
+): MarkdownProfile {
+    var profile = MarkdownProfile.Default
+        .withNewlineSemantics(
+            when (newlineMode) {
+                NewlineMode.CommonMark -> NewlineSemantics.CommonMark
+                NewlineMode.HardBreak -> NewlineSemantics.HardBreak
+            },
+        )
+        .withSoftBreak(
+            when (softBreakMode) {
+                SoftBreakMode.Space -> SoftBreak.Space
+                SoftBreakMode.LineBreak -> SoftBreak.LineBreak
+            },
+        )
+        .withHardBreakEncode(
+            when (hardBreakStyle) {
+                HardBreakStyle.Backslash -> HardBreakEncode.Backslash
+                HardBreakStyle.TwoSpaces -> HardBreakEncode.TwoSpaces
+            },
+        )
+        .withUnsupportedSyntax(
+            when (unsupportedMode) {
+                UnsupportedMode.Preserve -> UnsupportedSyntax.Preserve
+                UnsupportedMode.Degrade -> UnsupportedSyntax.WarnAndDegrade
+            },
+        )
+        .withEntityDecode(
+            when (entityMode) {
+                EntityMode.Decode -> EntityDecode.Standard
+                EntityMode.Literal -> EntityDecode.None
+            },
+        )
+
+    profile = when (htmlMode) {
+        MarkdownHtmlMode.Bridge -> profile
+        MarkdownHtmlMode.Preserve -> profile.withHtmlInMarkdown(HtmlInMarkdown.Preserve)
+        MarkdownHtmlMode.WarnAndStrip -> profile.withHtmlInMarkdown(HtmlInMarkdown.WarnAndStrip)
+        MarkdownHtmlMode.Strip -> profile.withHtmlInMarkdown(HtmlInMarkdown.Strip)
+        MarkdownHtmlMode.Strict -> profile.withoutHtmlBridge()
+    }
+    return profile
+}
+
+private fun compareMarkdown(
+    source: String,
+    exported: String,
+    profile: MarkdownProfile,
+    lineEnding: MarkdownLineEnding,
+): String {
+    if (source == exported) return "Byte match"
+    val normalizedSource = normalizeMarkdown(source, profile, lineEnding)
+    val normalizedExport = normalizeMarkdown(exported, profile, lineEnding)
+    return when {
+        normalizedSource == null || normalizedExport == null -> "Cannot compare — decode aborted"
+        normalizedSource == normalizedExport -> "Canonical match"
+        else -> "Different"
+    }
+}
+
+private fun normalizeMarkdown(
+    source: String,
+    profile: MarkdownProfile,
+    lineEnding: MarkdownLineEnding,
+): String? {
+    val blocks = MarkdownSchema.decode(source, profile) ?: return null
+    return MarkdownSchema.encode(blocks, profile, lineEnding = lineEnding)
+}
+
+private fun profileSummary(
+    newlineMode: NewlineMode,
+    softBreakMode: SoftBreakMode,
+    hardBreakStyle: HardBreakStyle,
+    unsupportedMode: UnsupportedMode,
+    htmlMode: MarkdownHtmlMode,
+    entityMode: EntityMode,
+    lineEnding: MarkdownLineEnding,
+): String = buildString {
+    append(newlineMode.label)
+    if (newlineMode == NewlineMode.CommonMark) {
+        append(" · soft→${softBreakMode.label.lowercase()}")
+        append(" · hard→${hardBreakStyle.label.lowercase()}")
+    }
+    append(" · unsupported→${unsupportedMode.label.lowercase()}")
+    append(" · HTML→${htmlMode.label.lowercase()}")
+    append(" · entities→${entityMode.label.lowercase()}")
+    append(" · ${if (lineEnding == MarkdownLineEnding.Lf) "LF" else "CRLF"}")
+}
+
+private fun MarkdownDecodeResult.warningLines(): List<String> =
+    warnings.map { it.describe(sourceLocator) }
+
+private fun MarkdownEncodeResult.warningLines(): List<String> = warnings.map { it.describe() }
+
+private fun List<io.github.linreal.cascade.editor.markdown.MarkdownWarning>.hasLossOrFatal(): Boolean =
+    any { it.impact == MarkdownFidelityImpact.DataLoss || it.impact == MarkdownFidelityImpact.Fatal }
+
+private fun MarkdownDecodeWarning.describe(locator: MarkdownSourceLocator): String {
+    val location = locator.locate(range)
+    val detail = when (this) {
+        is MarkdownDecodeWarning.UnsupportedSyntax -> "$construct: $detail"
+        is MarkdownDecodeWarning.PreservedSyntax -> "Preserved $kind as an opaque block"
+        is MarkdownDecodeWarning.HtmlBridged -> "HTML bridged into editor content"
+        is MarkdownDecodeWarning.HtmlStripped -> "HTML${tag?.let { " <$it>" }.orEmpty()} stripped"
+        is MarkdownDecodeWarning.DroppedAttribute -> "$construct.$attr dropped: $reason"
+        is MarkdownDecodeWarning.DuplicateLinkDefinition -> "Duplicate link definition [$label] ignored"
+        is MarkdownDecodeWarning.UnsupportedEntity -> "Entity &$name; kept literal"
+        is MarkdownDecodeWarning.InputLimitExceeded -> "Input length $actual exceeds $limit"
+        is MarkdownDecodeWarning.LimitExceeded -> "$kind limit $limit exceeded"
+        is MarkdownDecodeWarning.EngineFailure -> "Engine failure: $message"
+    }
+    return "$detail · ${impact.name} · ${location.line}:${location.column}"
+}
+
+private fun MarkdownEncodeWarning.describe(): String {
+    val detail = when (this) {
+        is MarkdownEncodeWarning.AmbiguousEmphasis -> "Ambiguous emphasis; weaker formatting dropped"
+        is MarkdownEncodeWarning.DroppedSpanOverlap -> "Span overlap dropped: $reason"
+        is MarkdownEncodeWarning.DroppedAttribute -> "$attr dropped: $reason"
+        is MarkdownEncodeWarning.UnsupportedBlock -> "Unsupported block ${typeId.orEmpty()}: $reason"
+        is MarkdownEncodeWarning.UnsupportedSpan -> "Unsupported span ${typeId.orEmpty()}: $reason"
+        is MarkdownEncodeWarning.EncoderException ->
+            "Encoder${typeId?.let { " $it" }.orEmpty()} failed: $message"
+        is MarkdownEncodeWarning.OutputLimitExceeded -> "Output exceeds $limit characters"
+        is MarkdownEncodeWarning.LimitExceeded -> "$kind limit $limit exceeded"
+        is MarkdownEncodeWarning.EngineFailure -> "Engine failure: $message"
+    }
+    val block = blockId?.let { " · block $it" }.orEmpty()
+    val range = textRange?.let { " · text ${it.start}..${it.endExclusive}" }.orEmpty()
+    return "$detail · ${impact.name}$block$range"
+}
+
+private val MarkdownEditModeRecommendation.displayName: String
+    get() = when (this) {
+        MarkdownEditModeRecommendation.Native -> "Native editor"
+        MarkdownEditModeRecommendation.RawFallback -> "Raw fallback"
+    }
+
+private fun Boolean.yesNo(): String = if (this) "yes" else "no"
+
+private fun Boolean?.yesNoOrUnknown(): String = when (this) {
+    true -> "yes"
+    false -> "no"
+    null -> "unknown"
+}
diff --git a/sample/src/commonMain/kotlin/io/github/linreal/cascade/screens/markdownfield/MarkdownFieldScreenModel.kt b/sample/src/commonMain/kotlin/io/github/linreal/cascade/screens/markdownfield/MarkdownFieldScreenModel.kt
new file mode 100644
index 0000000..2af5be4
--- /dev/null
+++ b/sample/src/commonMain/kotlin/io/github/linreal/cascade/screens/markdownfield/MarkdownFieldScreenModel.kt
@@ -0,0 +1,168 @@
+package io.github.linreal.cascade.screens.markdownfield
+
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.setValue
+import io.github.linreal.cascade.editor.markdown.ExperimentalCascadeMarkdownApi
+import io.github.linreal.cascade.editor.markdown.MarkdownEditModeRecommendation
+import io.github.linreal.cascade.editor.markdown.MarkdownFidelityImpact
+import io.github.linreal.cascade.editor.markdown.MarkdownProfile
+import io.github.linreal.cascade.editor.markdown.MarkdownSchema
+import io.github.linreal.cascade.editor.markdown.loadFromMarkdown
+import io.github.linreal.cascade.editor.markdown.toMarkdown
+import io.github.linreal.cascade.editor.markdown.toMarkdownWithReport
+import io.github.linreal.cascade.editor.state.BlockSpanStates
+import io.github.linreal.cascade.editor.state.BlockTextStates
+import io.github.linreal.cascade.editor.state.EditorStateHolder
+
+/** Which surface a Markdown field opens in. */
+internal enum class MarkdownFieldMode { Native, RawFallback }
+
+/** Outcome of a save attempt. */
+internal enum class MarkdownSaveOutcome { Saved, RejectedLossy, Conflict, NoChange }
+
+/**
+ * A fake persistence store with a revision counter — enough to demonstrate the
+ * conflict guard without real persistence. External edits bump the revision so
+ * a stale save is detected.
+ */
+internal class FakeMarkdownStore(initial: String) {
+    var content: String = initial
+        private set
+    var revision: Int = 0
+        private set
+    var writeCount: Int = 0
+        private set
+
+    fun read(): String = content
+
+    fun write(markdown: String) {
+        content = markdown
+        revision++
+        writeCount++
+    }
+
+    /** Simulate an external editor changing the field out from under us. */
+    fun bumpExternally(newContent: String) {
+        content = newContent
+        revision++
+    }
+}
+
+/**
+ * Unit-testable reference for integrating a persisted Markdown String field.
+ * [MarkdownFieldScreen] is now an interactive codec playground; this model
+ * remains the focused example of the analyze gate, raw fallback, revision
+ * conflict handling, and fidelity-safe persistence contract.
+ *
+ * Contract: hold the original String; `analyze` before opening; open the native
+ * editor on `Native` or a raw text field on `RawFallback`; never write on
+ * open/analyze/mode switch; on save, persist only a non-null `Success` encode
+ * with no `DataLoss`/`Fatal` impact **and** an unchanged source revision — on
+ * violation keep both states and surface a save error.
+ */
+@OptIn(ExperimentalCascadeMarkdownApi::class)
+internal class MarkdownFieldScreenModel(
+    val store: FakeMarkdownStore,
+    private val profile: MarkdownProfile = MarkdownProfile.Default,
+) {
+    val textStates = BlockTextStates()
+    val spanStates = BlockSpanStates()
+    val editorState = EditorStateHolder()
+
+    var mode: MarkdownFieldMode by mutableStateOf(MarkdownFieldMode.RawFallback)
+        private set
+
+    var rawText: String by mutableStateOf("")
+        private set
+
+    var saveError: String? by mutableStateOf(null)
+        private set
+
+    var preservedBlockCount: Int by mutableStateOf(0)
+        private set
+
+    private var openedRevision: Int = -1
+
+    /**
+     * What a save would have produced right after opening — the baseline used
+     * to detect a user-visible edit (save is gated on an actual
+     * change, so opening and saving without editing writes nothing).
+     */
+    private var openedBaseline: String = ""
+
+    /**
+     * Open the field: analyze the stored String, choose the edit mode, and load
+     * the decoded document into the editor (used as the editable surface in
+     * `Native` mode and a read-only preview — including any `md.preserved`
+     * blocks, which render through the editor's unknown-block fallback — in
+     * `RawFallback` mode). No persistence write occurs here.
+     */
+    fun open() {
+        val source = store.read()
+        openedRevision = store.revision
+        saveError = null
+
+        val report = MarkdownSchema.analyze(source, profile)
+        preservedBlockCount = report.preservedBlockCount
+        mode = when (report.recommendedMode) {
+            MarkdownEditModeRecommendation.Native -> MarkdownFieldMode.Native
+            MarkdownEditModeRecommendation.RawFallback -> MarkdownFieldMode.RawFallback
+        }
+        rawText = source
+        // loadFromMarkdown only replaces on a non-aborted decode; a preserved
+        // document still decodes successfully, so the editor holds the blocks.
+        editorState.loadFromMarkdown(source, textStates, spanStates, profile)
+        openedBaseline = when (mode) {
+            MarkdownFieldMode.Native -> editorState.toMarkdown(textStates, spanStates, profile) ?: source
+            MarkdownFieldMode.RawFallback -> source
+        }
+    }
+
+    /** Update the raw-fallback buffer (no write). */
+    fun updateRawText(text: String) {
+        rawText = text
+    }
+
+    /**
+     * Attempt to save the current edit back to the store, enforcing the fidelity
+     * + revision guard. Returns the outcome; on rejection both states are kept
+     * and [saveError] is set.
+     */
+    fun save(): MarkdownSaveOutcome {
+        val markdown: String = when (mode) {
+            MarkdownFieldMode.Native -> {
+                val result = editorState.toMarkdownWithReport(textStates, spanStates, profile)
+                val payload = result.markdown
+                val lossy = result.warnings.any {
+                    it.impact == MarkdownFidelityImpact.DataLoss || it.impact == MarkdownFidelityImpact.Fatal
+                }
+                if (payload == null || lossy) {
+                    saveError = "Save blocked: editing this field would lose Markdown fidelity."
+                    return MarkdownSaveOutcome.RejectedLossy
+                }
+                payload
+            }
+
+            MarkdownFieldMode.RawFallback -> rawText
+        }
+
+        // Gate on a user-visible edit: opening and saving without editing (or
+        // switching modes) must never write.
+        if (markdown == openedBaseline) {
+            saveError = null
+            return MarkdownSaveOutcome.NoChange
+        }
+
+        if (store.revision != openedRevision) {
+            saveError = "Save blocked: the field changed elsewhere. Both versions were kept."
+            return MarkdownSaveOutcome.Conflict
+        }
+
+        store.write(markdown)
+        openedRevision = store.revision
+        openedBaseline = markdown
+        saveError = null
+        return MarkdownSaveOutcome.Saved
+    }
+}
diff --git a/sample/src/commonMain/kotlin/io/github/linreal/cascade/screens/markdownfield/examples/01-personal-weekly-note.md b/sample/src/commonMain/kotlin/io/github/linreal/cascade/screens/markdownfield/examples/01-personal-weekly-note.md
new file mode 100644
index 0000000..e8d5aaf
--- /dev/null
+++ b/sample/src/commonMain/kotlin/io/github/linreal/cascade/screens/markdownfield/examples/01-personal-weekly-note.md
@@ -0,0 +1,22 @@
+# Week 31 review
+
+The main goal was to make onboarding **predictable** without slowing down
+experienced users. The new flow feels *much clearer*, although the empty-state
+copy still needs work.
+
+## Shipped
+
+- Added account recovery from the sign-in screen
+- Reduced the first sync from 12 seconds to 4 seconds
+- Replaced the ~~temporary tooltip~~ with inline guidance
+- Documented the [support escalation path](../support/escalation.md)
+
+## Next week
+
+1. Watch activation and recovery metrics
+2. Interview three new users
+3. Remove the legacy `skipWelcome` flag
+
+> Keep the old onboarding available for one release so support can recover
+> accounts created by older clients.
+
diff --git a/sample/src/commonMain/kotlin/io/github/linreal/cascade/screens/markdownfield/examples/02-engineering-task-description.md b/sample/src/commonMain/kotlin/io/github/linreal/cascade/screens/markdownfield/examples/02-engineering-task-description.md
new file mode 100644
index 0000000..4b94029
--- /dev/null
+++ b/sample/src/commonMain/kotlin/io/github/linreal/cascade/screens/markdownfield/examples/02-engineering-task-description.md
@@ -0,0 +1,30 @@
+# Add offline retry for comment uploads
+
+Comment uploads currently fail permanently when the device loses connectivity
+after the user presses Send. Queue the request locally and retry it when the
+network becomes available.
+
+## Acceptance criteria
+
+- [ ] A pending comment appears immediately with a `Sending` state
+- [ ] Retrying preserves the client-generated comment ID
+- [ ] A successful retry changes the state to `Sent`
+- [ ] A permanent 4xx response changes the state to `Failed`
+- [ ] Tapping Retry does not create a duplicate comment
+
+## Implementation notes
+
+- Store pending work by workspace
+  - Encrypt the comment body at rest
+  - Delete the queue entry after server acknowledgement
+- Use exponential backoff capped at five minutes
+- Keep retry scheduling outside the Compose layer
+
+The worker should make this decision:
+
+```
+if (response.isSuccessful) markSent(commentId)
+else if (response.isRetryable) scheduleRetry(commentId)
+else markFailed(commentId)
+```
+
diff --git a/sample/src/commonMain/kotlin/io/github/linreal/cascade/screens/markdownfield/examples/03-bug-report.md b/sample/src/commonMain/kotlin/io/github/linreal/cascade/screens/markdownfield/examples/03-bug-report.md
new file mode 100644
index 0000000..afecbcb
--- /dev/null
+++ b/sample/src/commonMain/kotlin/io/github/linreal/cascade/screens/markdownfield/examples/03-bug-report.md
@@ -0,0 +1,35 @@
+# Android: editor jumps after deleting a nested list item
+
+## Environment
+
+- App version: 2.8.0
+- Device: Pixel 8
+- Android: 16
+- Input method: Gboard
+
+## Steps to reproduce
+
+1. Open a document containing a nested bullet list.
+2. Place the cursor at the beginning of the second nested item.
+3. Press Backspace twice.
+4. Type any character.
+
+## Expected
+
+The nested item is removed and focus remains on the previous list item.
+
+## Actual
+
+Focus moves to the first block and the viewport jumps to the top.
+
+> Reproduces only when the document has more than one screen of content.
+
+Relevant log excerpt:
+
+```
+focus target missing for block 8f2a
+fallback focus selected block 0001
+```
+
+See the [screen recording](../attachments/editor-jump.mp4).
+
diff --git a/sample/src/commonMain/kotlin/io/github/linreal/cascade/screens/markdownfield/examples/04-meeting-notes.md b/sample/src/commonMain/kotlin/io/github/linreal/cascade/screens/markdownfield/examples/04-meeting-notes.md
new file mode 100644
index 0000000..0e55a65
--- /dev/null
+++ b/sample/src/commonMain/kotlin/io/github/linreal/cascade/screens/markdownfield/examples/04-meeting-notes.md
@@ -0,0 +1,30 @@
+# Mobile weekly sync — 5 August
+
+## Attendees
+
+- Ana
+- Daria
+- Minh
+- Sam
+
+## Decisions
+
+1. Ship the new editor to internal users on Wednesday.
+2. Keep analytics names platform-neutral.
+3. Treat an interrupted migration as recoverable.
+
+## Discussion
+
+The iOS host is ready for the new serializer. Android still needs the database
+migration benchmark. Desktop can remain behind the `editor_v2` flag for one
+additional week.
+
+> A release is blocked if migration recovery requires clearing user data.
+
+## Actions
+
+- [ ] Ana: publish the rollout dashboard
+- [x] Daria: verify the iOS archive
+- [ ] Minh: run the 100k-document migration benchmark
+- [ ] Sam: update the [support playbook](../support/editor-v2.md)
+
diff --git a/sample/src/commonMain/kotlin/io/github/linreal/cascade/screens/markdownfield/examples/05-release-checklist.md b/sample/src/commonMain/kotlin/io/github/linreal/cascade/screens/markdownfield/examples/05-release-checklist.md
new file mode 100644
index 0000000..5eb49c0
--- /dev/null
+++ b/sample/src/commonMain/kotlin/io/github/linreal/cascade/screens/markdownfield/examples/05-release-checklist.md
@@ -0,0 +1,27 @@
+# Android 3.4.0 release checklist
+
+## Before the build
+
+- [x] Version name and code updated
+- [x] Release notes reviewed
+- [ ] Translation freeze confirmed
+- [ ] Database migration tested from the last two production versions
+- [ ] Crash-free sessions above 99.8%
+
+---
+
+## Staged rollout
+
+1. Publish to internal testing.
+2. Promote to 5% after smoke tests pass.
+3. Hold for 24 hours and review crashes, ANRs, and login failures.
+4. Promote to 25%, then 50%, then 100%.
+
+## Rollback signals
+
+- Login failure rate increases by more than **0.5 percentage points**
+- Crash-free sessions fall below **99.5%**
+- Sync queue age exceeds *ten minutes* at p95
+
+> Do not pause solely for an increase in handled network errors during rollout.
+
diff --git a/sample/src/commonMain/kotlin/io/github/linreal/cascade/screens/markdownfield/examples/06-hard-break-daily-log.md b/sample/src/commonMain/kotlin/io/github/linreal/cascade/screens/markdownfield/examples/06-hard-break-daily-log.md
new file mode 100644
index 0000000..49721de
--- /dev/null
+++ b/sample/src/commonMain/kotlin/io/github/linreal/cascade/screens/markdownfield/examples/06-hard-break-daily-log.md
@@ -0,0 +1,14 @@
+# Daily operations log
+
+08:15 Opened the office and checked the overnight queue.
+08:42 Two invoice imports were still processing.
+09:10 Retried import 4182; it completed successfully.
+
+11:30 Customer Northwind reported delayed notifications.
+11:46 Confirmed a provider incident in eu-west.
+12:05 Posted the first customer update.
+
+15:20 Provider recovery confirmed.
+15:45 Notification backlog returned to normal.
+16:00 Closed the incident and linked the timeline.
+
diff --git a/sample/src/commonMain/kotlin/io/github/linreal/cascade/screens/markdownfield/examples/07-customer-support-handoff.md b/sample/src/commonMain/kotlin/io/github/linreal/cascade/screens/markdownfield/examples/07-customer-support-handoff.md
new file mode 100644
index 0000000..e59d8e6
--- /dev/null
+++ b/sample/src/commonMain/kotlin/io/github/linreal/cascade/screens/markdownfield/examples/07-customer-support-handoff.md
@@ -0,0 +1,24 @@
+# Escalation: workspace members cannot accept invitations
+
+## Customer impact
+
+Acme Field Services has 14 pending invitations. New members see **Invitation
+expired** immediately, although the links were created today.
+
+## What support checked
+
+- Workspace is active and below its seat limit
+- Invitation records exist and have future expiry timestamps
+- Reproduces on Android, iOS, and web
+- Creating a second invitation does not help
+
+## Engineering handoff
+
+The API response contains `expiresAt` in local server time without an offset.
+Clients parse it as UTC, which makes the invitation appear expired in UTC+10.
+
+> Please preserve the existing invitation tokens while repairing timestamps;
+> the customer has already distributed the links.
+
+Contact: [support@acme.example](mailto:support@acme.example)
+
diff --git a/sample/src/commonMain/kotlin/io/github/linreal/cascade/screens/markdownfield/examples/08-product-requirements.md b/sample/src/commonMain/kotlin/io/github/linreal/cascade/screens/markdownfield/examples/08-product-requirements.md
new file mode 100644
index 0000000..04f14ef
--- /dev/null
+++ b/sample/src/commonMain/kotlin/io/github/linreal/cascade/screens/markdownfield/examples/08-product-requirements.md
@@ -0,0 +1,36 @@
+# Scheduled report delivery
+
+## Problem
+
+Operations teams export the same dashboard every Monday and email it manually.
+They need a reliable scheduled delivery without giving every recipient access
+to the workspace.
+
+## Goals
+
+- Schedule weekly or monthly delivery
+- Deliver CSV and PDF attachments
+- Show the next delivery time in the workspace timezone
+- Keep an audit record for 90 days
+
+## User flow
+
+1. Open a saved report.
+2. Choose **Schedule delivery**.
+3. Configure recipients and cadence.
+   - Validate every recipient before saving.
+   - Warn when the report contains restricted fields.
+4. Review the next three delivery dates.
+5. Save and send a confirmation email.
+
+## Non-goals
+
+- Arbitrary cron expressions
+- Delivery to chat integrations
+- Editing the report query from the scheduling dialog
+
+## Success measure
+
+At least 60% of teams that repeatedly export a report adopt a schedule within
+four weeks of availability.
+
diff --git a/sample/src/commonMain/kotlin/io/github/linreal/cascade/screens/markdownfield/examples/09-reference-links-research.md b/sample/src/commonMain/kotlin/io/github/linreal/cascade/screens/markdownfield/examples/09-reference-links-research.md
new file mode 100644
index 0000000..227c4f9
--- /dev/null
+++ b/sample/src/commonMain/kotlin/io/github/linreal/cascade/screens/markdownfield/examples/09-reference-links-research.md
@@ -0,0 +1,21 @@
+# Research notes: background sync
+
+Android recommends deferrable persistent work through [WorkManager][wm]. Apple
+provides [background task scheduling][bg] with different execution guarantees.
+The shared domain layer should describe intent without promising an exact start
+time.
+
+## Working assumptions
+
+- A sync request is idempotent.
+- The platform may coalesce multiple requests.
+- User-initiated refresh has a separate foreground path.
+- Battery and connectivity constraints are platform-owned.
+
+The [architecture decision][adr] should document which guarantees are common
+and which remain platform-specific.
+
+[wm]: https://developer.android.com/topic/libraries/architecture/workmanager
+[bg]: https://developer.apple.com/documentation/backgroundtasks
+[adr]: ../decisions/004-background-sync.md
+
diff --git a/sample/src/commonMain/kotlin/io/github/linreal/cascade/screens/markdownfield/examples/10-html-formatting-note.md b/sample/src/commonMain/kotlin/io/github/linreal/cascade/screens/markdownfield/examples/10-html-formatting-note.md
new file mode 100644
index 0000000..273f17a
--- /dev/null
+++ b/sample/src/commonMain/kotlin/io/github/linreal/cascade/screens/markdownfield/examples/10-html-formatting-note.md
@@ -0,0 +1,13 @@
+# Formatting imported from another editor
+
+The customer used <u>underline with **nested bold**</u> to call out the account
+name. The deadline is
+<mark data-cascade-highlight="FFFFD54F">Friday at 17:00 UTC</mark>.
+
+## Follow-up
+
+- Keep the underline when editing with the default HTML bridge
+- Keep the highlight color during export
+- Compare with **Strict no-HTML**, which must drop HTML-backed formatting and
+  report the loss
+
diff --git a/sample/src/commonMain/kotlin/io/github/linreal/cascade/screens/markdownfield/examples/11-pipe-table-dashboard.md b/sample/src/commonMain/kotlin/io/github/linreal/cascade/screens/markdownfield/examples/11-pipe-table-dashboard.md
new file mode 100644
index 0000000..82ae64a
--- /dev/null
+++ b/sample/src/commonMain/kotlin/io/github/linreal/cascade/screens/markdownfield/examples/11-pipe-table-dashboard.md
@@ -0,0 +1,14 @@
+# Weekly service dashboard
+
+| Service | Availability | p95 latency | Owner |
+|:---|---:|---:|:---|
+| Authentication | 99.99% | 180 ms | Identity |
+| Document sync | 99.95% | 420 ms | Collaboration |
+| Notifications | 99.91% | 760 ms | Messaging |
+
+## Notes
+
+- Notification latency includes the provider incident on Tuesday.
+- Document sync improved after the database index rollout.
+- Authentication remained within its error budget.
+
diff --git a/sample/src/commonMain/kotlin/io/github/linreal/cascade/screens/markdownfield/examples/12-code-language-design-note.md b/sample/src/commonMain/kotlin/io/github/linreal/cascade/screens/markdownfield/examples/12-code-language-design-note.md
new file mode 100644
index 0000000..055cee5
--- /dev/null
+++ b/sample/src/commonMain/kotlin/io/github/linreal/cascade/screens/markdownfield/examples/12-code-language-design-note.md
@@ -0,0 +1,16 @@
+# Token refresh design
+
+The client refreshes an access token once, then shares the result with every
+request waiting on the same expired token.
+
+```kotlin
+private val refreshMutex = Mutex()
+
+suspend fun validToken(): Token = refreshMutex.withLock {
+    token.takeUnless(Token::isExpired) ?: api.refresh(refreshToken)
+}
+```
+
+The `kotlin` info string is meaningful to renderers but has no field in
+`BlockType.Code`, so the default profile must preserve this fence opaquely.
+
diff --git a/sample/src/commonMain/kotlin/io/github/linreal/cascade/screens/markdownfield/examples/13-front-matter-and-image.md b/sample/src/commonMain/kotlin/io/github/linreal/cascade/screens/markdownfield/examples/13-front-matter-and-image.md
new file mode 100644
index 0000000..3b40eee
--- /dev/null
+++ b/sample/src/commonMain/kotlin/io/github/linreal/cascade/screens/markdownfield/examples/13-front-matter-and-image.md
@@ -0,0 +1,19 @@
+---
+title: Offline-first architecture
+tags: [android, sync, architecture]
+status: published
+---
+
+# Offline-first architecture
+
+The local database is the source of truth for rendering. Network responses are
+transactions that update local state; screens never render directly from an
+HTTP response.
+
+![Offline-first data flow](../assets/offline-first-flow.png)
+
+## Key rule
+
+> Reads come from local storage. Writes update local storage before scheduling
+> synchronization.
+
diff --git a/sample/src/commonMain/kotlin/io/github/linreal/cascade/screens/markdownfield/examples/14-footnotes-and-math.md b/sample/src/commonMain/kotlin/io/github/linreal/cascade/screens/markdownfield/examples/14-footnotes-and-math.md
new file mode 100644
index 0000000..b963258
--- /dev/null
+++ b/sample/src/commonMain/kotlin/io/github/linreal/cascade/screens/markdownfield/examples/14-footnotes-and-math.md
@@ -0,0 +1,16 @@
+# Retry budget notes
+
+The retry budget limits amplification during a partial outage.[^budget] For a
+request with attempt number $n$, the delay grows exponentially until it reaches
+the configured ceiling.
+
+$$
+delay(n) = min(base * 2^n, maximum)
+$$
+
+Jitter should be applied after calculating the ceiling so clients do not retry
+in lockstep.[^jitter]
+
+[^budget]: A bounded number of retries shared across one logical operation.
+[^jitter]: A random adjustment applied to spread retry traffic over time.
+
diff --git a/sample/src/commonMain/kotlin/io/github/linreal/cascade/screens/markdownfield/examples/15-block-html-embed.md b/sample/src/commonMain/kotlin/io/github/linreal/cascade/screens/markdownfield/examples/15-block-html-embed.md
new file mode 100644
index 0000000..fc8c691
--- /dev/null
+++ b/sample/src/commonMain/kotlin/io/github/linreal/cascade/screens/markdownfield/examples/15-block-html-embed.md
@@ -0,0 +1,13 @@
+# Imported status widget
+
+The source system embeds a status fragment below. Test it under each HTML mode
+before deciding whether the host should bridge, preserve, strip, or reject it.
+
+<section class="service-status">
+  <h2>Document sync</h2>
+  <p><strong>Operational</strong> in all regions.</p>
+  <p>Last incident: 18 days ago.</p>
+</section>
+
+The paragraph after the fragment must remain a separate editable block.
+
diff --git a/sample/src/commonMain/kotlin/io/github/linreal/cascade/screens/markdownfield/examples/16-entities-and-escaping.md b/sample/src/commonMain/kotlin/io/github/linreal/cascade/screens/markdownfield/examples/16-entities-and-escaping.md
new file mode 100644
index 0000000..c7444fc
--- /dev/null
+++ b/sample/src/commonMain/kotlin/io/github/linreal/cascade/screens/markdownfield/examples/16-entities-and-escaping.md
@@ -0,0 +1,13 @@
+# Imported entity and escaping checks
+
+Research &amp; Development owns build &#35;42. The imported source also contains
+the numeric character reference &#x2713; and an unknown named entity &nosuch; that
+must remain literal text.
+
+## Literal syntax in prose
+
+- The heading marker is written as \# when it is not a heading.
+- The checklist token is written as \[x\] when it is only an example.
+- A Windows path such as `C:\Users\demo` stays inside inline code.
+- Comparison text like `a < b` remains code rather than starting HTML.
+
diff --git a/sample/src/commonMain/kotlin/io/github/linreal/cascade/screens/markdownfield/examples/README.md b/sample/src/commonMain/kotlin/io/github/linreal/cascade/screens/markdownfield/examples/README.md
new file mode 100644
index 0000000..b01f7a8
--- /dev/null
+++ b/sample/src/commonMain/kotlin/io/github/linreal/cascade/screens/markdownfield/examples/README.md
@@ -0,0 +1,56 @@
+# Markdown Round-Trip Example Corpus
+
+These files are manual fixtures for `MarkdownFieldScreen`. Copy a file into the
+**Source Markdown** field, select the profile settings shown below, and run
+**Analyze** or **Round Trip**.
+
+The corpus deliberately mixes documents that are safe for native editing with
+documents that should enter raw fallback. A canonical match is acceptable when
+the codec normalizes equivalent syntax; byte equality is not required unless a
+case explicitly tests preservation.
+
+## Default CommonMark profile
+
+| File | Scenario | Expected recommendation | Primary coverage |
+|---|---|---|---|
+| `01-personal-weekly-note.md` | Personal/project note | Native editor | Headings, emphasis, strike, links, bullets, quote |
+| `02-engineering-task-description.md` | Implementation task | Native editor | Task lists, nested bullets, inline/fenced code |
+| `03-bug-report.md` | Reproducible defect | Native editor | Ordered steps, quote, code block, relative link |
+| `04-meeting-notes.md` | Team meeting record | Native editor | Sections, decisions, tasks, attendees, links |
+| `05-release-checklist.md` | Mobile release runbook | Native editor | Task lists, numbered rollout, thematic break |
+| `07-customer-support-handoff.md` | Support escalation | Native editor | Structured prose, quote, bullets, mail link |
+| `08-product-requirements.md` | Lightweight PRD | Native editor | Heading hierarchy and nested list outline |
+| `09-reference-links-research.md` | Research note | Native editor; source rewritten | Reference links canonicalized to inline links |
+| `10-html-formatting-note.md` | Note with inline HTML styles | Native editor with Bridge | `<u>`, `<mark>`, and nested Markdown emphasis |
+| `16-entities-and-escaping.md` | Imported technical prose | Native editor; informational warning | Numeric, supported, and unknown entities |
+
+## HardBreak profile
+
+Select **Newlines → Hard break** before testing:
+
+| File | Scenario | Expected recommendation | Primary coverage |
+|---|---|---|---|
+| `06-hard-break-daily-log.md` | Chat/memo-style daily log | Native editor | Literal line breaks and explicit blank paragraphs |
+
+## Preservation and raw-fallback cases
+
+Use **Unsupported syntax → Preserve** unless testing degradation deliberately.
+
+| File | Scenario | Expected recommendation | Primary coverage |
+|---|---|---|---|
+| `11-pipe-table-dashboard.md` | Metrics dashboard | Raw fallback | GFM pipe table preservation |
+| `12-code-language-design-note.md` | Technical design note | Raw fallback | Fenced-code info string preservation |
+| `13-front-matter-and-image.md` | File-oriented knowledge note | Raw fallback | YAML front matter and block image |
+| `14-footnotes-and-math.md` | Research/academic note | Raw fallback | Footnote reference/definition and math blocks |
+| `15-block-html-embed.md` | Imported CMS fragment | Policy-dependent; normally Raw fallback | Block HTML under Bridge/Preserve/Strip/Strict |
+
+## Suggested test passes
+
+1. Run every native case with the default controls and confirm `Native editor`.
+2. Run the hard-break log in CommonMark, then HardBreak, and compare block shape.
+3. Run each unsupported case with Preserve, then `Warn + degrade`, and compare
+   diagnostics and output.
+4. Run the HTML cases through Bridge, Preserve, Warn + strip, Strip, and Strict.
+5. Switch output from LF to CRLF and confirm semantic/canonical equality even
+   when byte equality changes.
+
diff --git a/sample/src/commonTest/kotlin/io/github/linreal/cascade/navigation/AppScreenTest.kt b/sample/src/commonTest/kotlin/io/github/linreal/cascade/navigation/AppScreenTest.kt
index b2dd1e0..adbda1d 100644
--- a/sample/src/commonTest/kotlin/io/github/linreal/cascade/navigation/AppScreenTest.kt
+++ b/sample/src/commonTest/kotlin/io/github/linreal/cascade/navigation/AppScreenTest.kt
@@ -14,6 +14,8 @@ class AppScreenTest {
             AppScreen.CustomToolbar,
             AppScreen.ExternalToolbar,
             AppScreen.CustomHtmlProfile,
+            AppScreen.Comments,
+            AppScreen.MarkdownField,
         )
 
         for (screen in screens) {
diff --git a/sample/src/commonTest/kotlin/io/github/linreal/cascade/screens/markdownfield/MarkdownFieldScreenModelTest.kt b/sample/src/commonTest/kotlin/io/github/linreal/cascade/screens/markdownfield/MarkdownFieldScreenModelTest.kt
new file mode 100644
index 0000000..10983ac
--- /dev/null
+++ b/sample/src/commonTest/kotlin/io/github/linreal/cascade/screens/markdownfield/MarkdownFieldScreenModelTest.kt
@@ -0,0 +1,105 @@
+package io.github.linreal.cascade.screens.markdownfield
+
+import io.github.linreal.cascade.editor.core.BlockContent
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+
+class MarkdownFieldScreenModelTest {
+
+    @Test
+    fun `unsupported document opens raw and leaves the stored string untouched`() {
+        val source = "Costs:\n\n| item | usd |\n| - | - |\n| a | 1 |\n"
+        val store = FakeMarkdownStore(source)
+        val model = MarkdownFieldScreenModel(store)
+
+        model.open()
+
+        assertEquals(MarkdownFieldMode.RawFallback, model.mode)
+        assertTrue(model.preservedBlockCount >= 1)
+        assertEquals(0, store.writeCount, "opening must never write")
+        assertEquals(source, store.content)
+    }
+
+    @Test
+    fun `native edit with an external revision bump is rejected into the conflict path`() {
+        val store = FakeMarkdownStore("# Title\n\nBody\n")
+        val model = MarkdownFieldScreenModel(store)
+        model.open()
+        assertEquals(MarkdownFieldMode.Native, model.mode)
+
+        // Edit a text block live.
+        val paragraph = model.editorState.state.blocks.first {
+            (it.content as? BlockContent.Text)?.text == "Body"
+        }
+        model.textStates.getOrCreate(paragraph.id, "Body")
+        model.textStates.setText(paragraph.id, "Body edited")
+
+        // Someone else changes the field.
+        store.bumpExternally("# Title\n\nExternally changed\n")
+        val externalContent = store.content
+
+        val outcome = model.save()
+
+        assertEquals(MarkdownSaveOutcome.Conflict, outcome)
+        assertEquals(externalContent, store.content, "our save must not overwrite the external change")
+        assertTrue(model.saveError != null)
+        // The user's live edit is retained (both states kept).
+        assertEquals("Body edited", model.textStates.getVisibleText(paragraph.id))
+    }
+
+    @Test
+    fun `native edit with matching revision persists canonical markdown exactly once`() {
+        val store = FakeMarkdownStore("# Title\n\nBody\n")
+        val model = MarkdownFieldScreenModel(store)
+        model.open()
+
+        val paragraph = model.editorState.state.blocks.first {
+            (it.content as? BlockContent.Text)?.text == "Body"
+        }
+        model.textStates.getOrCreate(paragraph.id, "Body")
+        model.textStates.setText(paragraph.id, "Body edited")
+
+        val outcome = model.save()
+
+        assertEquals(MarkdownSaveOutcome.Saved, outcome)
+        assertEquals(1, store.writeCount, "must persist exactly once")
+        // Exact canonical payload, not just a substring.
+        assertEquals("# Title\n\nBody edited\n", store.content)
+        assertEquals(null, model.saveError)
+    }
+
+    @Test
+    fun `opening then saving without editing writes nothing`() {
+        val store = FakeMarkdownStore("# Title\n\nBody\n")
+        val model = MarkdownFieldScreenModel(store)
+        model.open()
+
+        val outcome = model.save()
+
+        assertEquals(MarkdownSaveOutcome.NoChange, outcome)
+        assertEquals(0, store.writeCount)
+    }
+
+    @Test
+    fun `a lossy native edit is rejected and nothing is written`() {
+        val store = FakeMarkdownStore("# Title\n\nBody\n")
+        val model = MarkdownFieldScreenModel(store)
+        model.open()
+
+        val paragraph = model.editorState.state.blocks.first {
+            (it.content as? BlockContent.Text)?.text == "Body"
+        }
+        model.textStates.getOrCreate(paragraph.id, "Body")
+        // Trailing spaces do not round-trip (the inline phase trims them) → DataLoss.
+        model.textStates.setText(paragraph.id, "Body trailing   ")
+
+        val outcome = model.save()
+
+        assertEquals(MarkdownSaveOutcome.RejectedLossy, outcome)
+        assertEquals(0, store.writeCount)
+        assertTrue(model.saveError != null)
+        // Live state retained (both states kept).
+        assertEquals("Body trailing   ", model.textStates.getVisibleText(paragraph.id))
+    }
+}