From 73fcf23130303e34dd93e44261b4e745bd59bfc8 Mon Sep 17 00:00:00 2001
From: miguelrk <miguelromerokaram@gmail.com>
Date: Wed, 16 Sep 2026 00:48:47 +0200
Subject: [PATCH] feat(model): add two-way data binding via `::prop` in
 `comark` core #437

Added support for two-way data binding using the `ComarkModel` protocol, allowing native form elements and custom components to synchronize state with the model. Updated documentation to include examples for Vue, React, Svelte, and Angular, demonstrating both uncontrolled and controlled modes. Enhanced the model plugin to facilitate seamless integration with existing components and frameworks.
---
 AGENTS.md                                     |  19 +-
 docs/content/2.syntax/2.components.md         |  34 +
 docs/content/3.rendering/2.html.md            |  51 ++
 docs/content/3.rendering/3.vue.md             |  90 +++
 docs/content/3.rendering/5.react.md           |  90 +++
 docs/content/3.rendering/6.svelte.md          |  51 ++
 docs/content/3.rendering/7.angular.md         |  53 ++
 docs/content/4.plugins/1.built-in/model.md    | 264 +++++++
 .../angular/src/app/pages/syntax.component.ts |  20 +-
 examples/2.vite/ansi/src/main.ts              |   7 +
 examples/2.vite/html/src/main.ts              |  33 +-
 examples/2.vite/html/src/preview.css          |   9 +
 examples/2.vite/react/src/pages/Syntax.tsx    |  22 +-
 .../2.vite/svelte/src/pages/Syntax.svelte     |  24 +-
 examples/2.vite/vue/src/App.vue               |  14 +-
 examples/2.vite/vue/src/pages/syntax.vue      |  21 +-
 .../src/components/form.component.ts          |  40 +
 .../components/markdown-document.component.ts |  33 +
 .../src/components/markdown-node.component.ts |  63 +-
 .../src/components/markdown.component.ts      |   9 +
 packages/comark-angular/src/plugins/form.ts   |   3 +
 .../comark-angular/test/model-binding.test.ts |  64 ++
 packages/comark-ansi/src/render.ts            |  23 +
 .../comark-ansi/test/model-binding.test.ts    |  46 ++
 packages/comark-html/package.json             |   4 +-
 packages/comark-html/src/plugins/binding.ts   |   8 +-
 packages/comark-html/src/runtime.ts           |  84 ++
 .../comark-html/test/plugin-binding.test.ts   |   7 +-
 packages/comark-html/test/runtime.test.ts     | 110 +++
 packages/comark-react/src/components/Form.tsx |  37 +
 .../comark-react/src/components/Markdown.tsx  |  20 +
 .../src/components/MarkdownClient.tsx         |   4 +
 .../src/components/MarkdownDocument.tsx       | 117 ++-
 packages/comark-react/src/plugins/form.ts     |   3 +
 packages/comark-react/test/form.test.tsx      |  43 +
 .../comark-react/test/model-binding.test.tsx  |  76 ++
 .../src/components/ComarkComponent.svelte     |   5 +
 .../comark-svelte/src/components/Form.svelte  |  33 +
 .../src/components/Markdown.svelte            |   9 +
 .../src/components/MarkdownDocument.svelte    |  39 +-
 .../src/components/MarkdownNode.svelte        |  34 +-
 packages/comark-svelte/src/plugins/form.ts    |   3 +
 .../comark-svelte/test/model-binding.test.ts  |  62 ++
 packages/comark-vue/src/components/Form.ts    |  53 ++
 .../comark-vue/src/components/Markdown.ts     |  34 +
 .../src/components/MarkdownDocument.ts        |  86 +-
 packages/comark-vue/src/plugins/form.ts       |   3 +
 packages/comark-vue/test/form.test.ts         |  45 ++
 .../comark-vue/test/model-binding.test.ts     |  73 ++
 .../comark/SPEC/COMARK/data-binding-form.md   |  62 ++
 .../SPEC/COMARK/data-binding-two-way-block.md |  41 +
 .../COMARK/data-binding-two-way-inline.md     |  42 +
 packages/comark/package.json                  |   1 +
 packages/comark/src/context.ts                |   3 +-
 .../comark/src/internal/parse/syntax/props.ts |   7 +-
 .../src/internal/stringify/attributes.ts      | 217 ++++-
 .../comark/src/internal/stringify/state.ts    |   9 +-
 packages/comark/src/model.ts                  | 169 ++++
 packages/comark/src/plugins/form.ts           |  57 ++
 packages/comark/src/types.ts                  |  23 +-
 packages/comark/src/utils/index.ts            |  40 +-
 packages/comark/test/context.test.ts          |  23 +
 packages/comark/test/form.test.ts             |  65 ++
 packages/comark/test/model.test.ts            | 177 +++++
 packages/comark/test/plugins/security.test.ts |  28 +
 .../comark/test/resolve-attributes.test.ts    | 118 ++-
 packages/comark/test/set-guard.test.ts        |  62 ++
 .../test/two-way-binding-parser.test.ts       |  56 ++
 pnpm-lock.yaml                                | 743 ++++++++----------
 test/bundle.test.ts                           |  14 +-
 70 files changed, 3520 insertions(+), 512 deletions(-)
 create mode 100644 docs/content/4.plugins/1.built-in/model.md
 create mode 100644 packages/comark-angular/src/components/form.component.ts
 create mode 100644 packages/comark-angular/src/plugins/form.ts
 create mode 100644 packages/comark-angular/test/model-binding.test.ts
 create mode 100644 packages/comark-ansi/test/model-binding.test.ts
 create mode 100644 packages/comark-html/src/runtime.ts
 create mode 100644 packages/comark-html/test/runtime.test.ts
 create mode 100644 packages/comark-react/src/components/Form.tsx
 create mode 100644 packages/comark-react/src/plugins/form.ts
 create mode 100644 packages/comark-react/test/form.test.tsx
 create mode 100644 packages/comark-react/test/model-binding.test.tsx
 create mode 100644 packages/comark-svelte/src/components/Form.svelte
 create mode 100644 packages/comark-svelte/src/plugins/form.ts
 create mode 100644 packages/comark-svelte/test/model-binding.test.ts
 create mode 100644 packages/comark-vue/src/components/Form.ts
 create mode 100644 packages/comark-vue/src/plugins/form.ts
 create mode 100644 packages/comark-vue/test/form.test.ts
 create mode 100644 packages/comark-vue/test/model-binding.test.ts
 create mode 100644 packages/comark/SPEC/COMARK/data-binding-form.md
 create mode 100644 packages/comark/SPEC/COMARK/data-binding-two-way-block.md
 create mode 100644 packages/comark/SPEC/COMARK/data-binding-two-way-inline.md
 create mode 100644 packages/comark/src/model.ts
 create mode 100644 packages/comark/src/plugins/form.ts
 create mode 100644 packages/comark/test/form.test.ts
 create mode 100644 packages/comark/test/model.test.ts
 create mode 100644 packages/comark/test/set-guard.test.ts
 create mode 100644 packages/comark/test/two-way-binding-parser.test.ts

diff --git a/AGENTS.md b/AGENTS.md
index de7eb372..d9b8bc37 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -55,6 +55,7 @@ packages/comark/
 │   │   ├── index.ts          # Re-exports (comark/ast entry point)
 │   │   ├── types.ts          # MarkdownDocument, Node, ElementNode, TextNode
 │   │   └── utils.ts          # textContent(), visit() document utilities
+│   ├── model.ts              # ComarkModel protocol + createModelStore() (comark/model entry point)
 │   ├── plugins/              # Built-in and optional plugins
 │   │   ├── alert.ts          # Alert/callout blocks
 │   │   ├── frontmatter.ts    # YAML frontmatter extraction (default via registerDefaultPlugins)
@@ -62,6 +63,7 @@ packages/comark/
 │   │   ├── components.ts     # Block/inline components + spans (`::name`, `:name`, `[text]`)
 │   │   ├── attributes.ts     # Inline attributes (`{props}` after tokens)
 │   │   ├── binding.ts        # Inline interpolation + shared conditional rendering rules
+│   │   ├── form.ts           # ::form aggregate helpers (collectFormBindingPaths, buildFormAggregate)
 │   │   ├── emoji.ts          # Emoji shortcodes
 │   │   ├── shiki.ts          # Shiki with bundled default theme + language loaders (peer: shiki)
 │   │   ├── shiki/core.ts     # Shiki without default theme/language imports
@@ -71,12 +73,12 @@ packages/comark/
 │   │   ├── rangi/language-comark.ts # Standalone Comark grammar for rangi
 │   │   ├── math.ts           # LaTeX math via KaTeX (peer: katex)
 │   │   ├── mermaid.ts        # Mermaid diagrams (peer: beautiful-mermaid)
-│   │   ├── security.ts       # XSS/security sanitization
+│   │   ├── security.ts       # XSS/security sanitization (handles ::prop keys correctly)
 │   │   ├── summary.ts        # Summary extraction
 │   │   ├── task-list.ts      # GFM task lists
 │   │   └── toc.ts            # Table of contents
 │   ├── utils/                # Shared utilities (comark/utils entry point)
-│   │   ├── index.ts          # textContent(), visit(), visitAsync(), escapeHtml(), string/object utils
+│   │   ├── index.ts          # textContent(), visit(), visitAsync(), escapeHtml(), get(), set(), string/object utils
 │   │   ├── helpers.ts        # defineComarkPlugin(), dedupePlugins()
 │   │   └── caret.ts          # Caret utilities for streaming
 │   └── internal/             # Internal implementation (not exported)
@@ -406,7 +408,11 @@ import { renderMarkdown } from 'comark/render'
 
 // AST types and utilities
 import type { MarkdownDocument, Node, ElementNode, TextNode } from 'comark'
-import { textContent, visit, escapeHtml } from 'comark/utils'
+import { textContent, visit, escapeHtml, set } from 'comark/utils'
+
+// Two-way data binding model
+import type { ComarkModel } from 'comark/model'
+import { createModelStore } from 'comark/model'
 
 // Core plugins — use when calling parseMarkdown() directly (framework-agnostic)
 import shiki from 'comark/plugins/shiki'
@@ -426,6 +432,7 @@ import attributes from 'comark/plugins/attributes'   // default via registerDefa
 import html from 'comark/plugins/html'               // default via registerDefaultPlugins
 import binding, { Binding, resolveIfWrapper, selectIfBranch, shouldRenderIf } from 'comark/plugins/binding'
 import type { IfComparisonOperator, IfProps, IfWrapperTag } from 'comark/plugins/binding'
+import { collectFormBindingPaths, buildFormAggregate } from 'comark/plugins/form'
 
 // markdown-it / markdown-exit adapters (e.g. VitePress)
 import { markdownItComponents } from 'comark/plugins/components'
@@ -439,12 +446,14 @@ import { markdownItAttributes } from 'comark/plugins/attributes'
 
 // HTML rendering — parse + render to HTML string
 import { createHtmlRenderer, renderHtml, renderHtmlFromDocument } from '@comark/html'
+import { initComarkRuntime } from '@comark/html/runtime' // progressive-enhancement runtime (browser)
 import shiki from '@comark/html/plugins/shiki'
 import math, { Math } from '@comark/html/plugins/math'
 import mermaid, { Mermaid } from '@comark/html/plugins/mermaid'
 import binding, { Binding, If } from '@comark/html/plugins/binding'
 
 // ANSI terminal rendering — parse + render to styled terminal string
+// NOTE: ::prop two-way bindings render read-only in ANSI (a dev warning is emitted once).
 import { createAnsiRenderer, createAnsiPrinter, printAnsi, renderAnsi, renderAnsiFromDocument } from '@comark/ansi'
 import shiki from '@comark/ansi/plugins/shiki'
 import math from '@comark/ansi/plugins/math'
@@ -455,12 +464,14 @@ import { Markdown, MarkdownDocument, defineMarkdownComponent } from '@comark/vue
 import math, { Math } from '@comark/vue/plugins/math'
 import mermaid, { Mermaid } from '@comark/vue/plugins/mermaid'
 import binding, { Binding, If } from '@comark/vue/plugins/binding'
+import { Form } from '@comark/vue/plugins/form'        // ::form aggregate component
 
 // React — renderer + plugin wrappers (plugin fn + React component)
 import { Markdown, MarkdownDocument, defineMarkdownComponent } from '@comark/react'
 import math, { Math } from '@comark/react/plugins/math'
 import mermaid, { Mermaid } from '@comark/react/plugins/mermaid'
 import binding, { Binding, If } from '@comark/react/plugins/binding'
+import { Form } from '@comark/react/plugins/form'      // ::form aggregate component
 
 // Svelte — renderer + plugin wrappers (plugin fn + Svelte component)
 import { Markdown, MarkdownDocument } from '@comark/svelte'
@@ -468,12 +479,14 @@ import { MarkdownAsync } from '@comark/svelte/async' // requires experimental.as
 import math, { Math } from '@comark/svelte/plugins/math'
 import mermaid, { Mermaid } from '@comark/svelte/plugins/mermaid'
 import binding, { Binding, If } from '@comark/svelte/plugins/binding'
+import { Form } from '@comark/svelte/plugins/form'     // ::form aggregate component
 
 // Angular — renderer + plugin wrappers (plugin fn + Angular component)
 import { Markdown, MarkdownDocument, defineMarkdownComponent, defineMarkdownDocumentComponent } from '@comark/angular'
 import math, { Math } from '@comark/angular/plugins/math'
 import mermaid, { Mermaid } from '@comark/angular/plugins/mermaid'
 import binding, { Binding, If } from '@comark/angular/plugins/binding'
+import { Form } from '@comark/angular/plugins/form'    // ::form aggregate component
 ```
 
 ## Coding Principles
diff --git a/docs/content/2.syntax/2.components.md b/docs/content/2.syntax/2.components.md
index d5e9d41a..224a5b2a 100644
--- a/docs/content/2.syntax/2.components.md
+++ b/docs/content/2.syntax/2.components.md
@@ -238,6 +238,40 @@ response:
 
 Props prefixed with `:` are JSON-parsed at render time. When the value isn't valid JSON, the renderer looks it up as a dot-path against an ambient **render context**, letting authors reference runtime data, frontmatter, meta, or the enclosing component's props without hardcoding them.
 
+### Two-way binding {#two-way-binding}
+
+Props prefixed with `::` create a **two-way binding**. The renderer reads the current value from a `ComarkModel` and wires an update handler back — so user interactions (typing, checking a box, picking an option) write the new value into the model automatically.
+
+```mdc
+<!-- Native form elements are wired automatically -->
+:input{::value="data.name" type="text"}
+:input{::checked="data.active" type="checkbox"}
+:select{::value="data.color"}
+
+<!-- Custom components receive the value prop + an onUpdate handler -->
+::card{::title="data.heading"}
+content
+::
+```
+
+The path resolves against the model's writable namespaces (default: `data.*`). Paths outside the writable set or containing unsafe URL schemes are silently ignored.
+
+Pass a `model` to the renderer to activate two-way binding:
+
+```vue [Vue]
+<Markdown :model="model">{{ content }}</Markdown>
+```
+
+```tsx [React]
+<Markdown model={model}>{content}</Markdown>
+```
+
+See [Model plugin](/plugins/built-in/model) for the full API, security notes, and HTML progressive enhancement.
+
+::callout{color="info" icon="i-lucide-info"}
+`::prop` is an inline-only attribute — it cannot appear in a YAML props block. Inline attributes (`{::value="path"}`) are the correct form.
+::
+
 ### Scope
 
 The render context exposes four namespaces:
diff --git a/docs/content/3.rendering/2.html.md b/docs/content/3.rendering/2.html.md
index 54e90ab7..e0ada594 100644
--- a/docs/content/3.rendering/2.html.md
+++ b/docs/content/3.rendering/2.html.md
@@ -277,6 +277,57 @@ const renderHtml = createHtmlRenderer({ components })
 
 ---
 
+## Two-way model binding
+
+`@comark/html` supports the `::prop="path"` syntax for progressive-enhancement two-way binding via the optional `@comark/html/runtime` script. No framework is required.
+
+### How it works
+
+1. **SSR / static output** — `renderHtml()` renders `::prop` bindings as `data-comark-model-{prop}="path"` markers plus the resolved read value. The page is fully functional without JavaScript.
+2. **Client enhancement** — importing `@comark/html/runtime` and calling `initComarkRuntime()` adds event delegation. User input is captured and propagated to the internal `createModelStore`, which patches `[data-comark-bind]` text nodes in real time.
+
+### Example
+
+```markdown [content.md]
+Enter your name: :input{::value="data.name" type="text"}
+
+Hello, {{ data.name }}!
+```
+
+```typescript [render.ts]
+import { renderHtml } from '@comark/html'
+
+const html = await renderHtml(source, { data: { name: 'World' } })
+```
+
+```html [page.html]
+<!DOCTYPE html>
+<html>
+  <body>
+    <div id="content"><!-- rendered HTML --></div>
+    <script type="module">
+      import { initComarkRuntime } from '@comark/html/runtime'
+      initComarkRuntime(document.getElementById('content'))
+    </script>
+  </body>
+</html>
+```
+
+### `initComarkRuntime(root?, model?)`
+
+| Parameter | Type | Default | Description |
+| --- | --- | --- | --- |
+| `root` | `Element \| null` | `document.body` | Root element to scope event delegation to |
+| `model` | `ComarkModel` | internal store | External model for controlled mode |
+
+Returns a teardown function that removes event listeners.
+
+### ANSI renderer
+
+The `@comark/ansi` renderer does not support two-way binding. `::prop` attributes resolve read-only (the current value is used) and a single warning is emitted per process.
+
+---
+
 ## Use cases
 
 ### Static site generation
diff --git a/docs/content/3.rendering/3.vue.md b/docs/content/3.rendering/3.vue.md
index c8426cd9..53925e80 100644
--- a/docs/content/3.rendering/3.vue.md
+++ b/docs/content/3.rendering/3.vue.md
@@ -118,6 +118,8 @@ Passing a document to `<Markdown>` skips parsing at runtime, but the **parser is
 | `summary` | `boolean` | `false` | Only render content before `<!-- more -->` |
 | [`caret`](#streaming-caret) | `boolean \| { class: string }` | `false` | Append caret to last text node |
 | [`data`](#code-markdown-props-code-data) | `Record<string, unknown>` | `{}` | Runtime values referenced from markdown via `:prop="data.path"` |
+| [`model`](#two-way-model-binding) | `ComarkModel` | `undefined` | Two-way binding model for `::prop="path"` attributes. Omit to use an internal uncontrolled store. |
+| `onModelChange` | `(path, value, snapshot) => void` | `undefined` | Observer called after every accepted write. Use for controlled-mode sync. |
 
 #### `options`
 
@@ -452,6 +454,8 @@ const document = await res.json()
 | [`streaming`](#streaming) | `boolean` | `false` | Enable streaming mode |
 | [`caret`](#streaming-caret) | `boolean \| { class: string }` | `false` | Append a blinking caret to the last text node |
 | [`data`](#code-markdown-props-code-data) | `Record<string, unknown>` | `{}` | Runtime values referenced from markdown via `:prop="data.path"` |
+| [`model`](#two-way-model-binding) | `ComarkModel` | `undefined` | Two-way binding model for `::prop="path"` attributes. Omit to use an internal uncontrolled store. |
+| `onModelChange` | `(path, value, snapshot) => void` | `undefined` | Observer called after every accepted write. Use for controlled-mode sync. |
 
 ### `defineMarkdownDocumentComponent`
 
@@ -815,4 +819,90 @@ defineProps<{
 </script>
 ```
 
+## Two-way model binding
+
+Use `::prop="data.path"` in your markdown to wire native form elements or pass live values to custom components. No event handlers needed in the markdown itself.
+
+### Uncontrolled (default)
+
+When no `model` prop is provided, `<Markdown>` and `<MarkdownDocument>` create an internal `createModelStore()` seeded from `data`. Writes stay local to the component.
+
+```vue [App.vue]
+<script setup lang="ts">
+import { Markdown } from '@comark/vue'
+import binding, { Binding, If } from '@comark/vue/plugins/binding'
+
+const content = `
+Name: {{ data.name }}
+
+:input{::value="data.name" type="text"}
+`
+</script>
+
+<template>
+  <Suspense>
+    <Markdown
+      :value="content"
+      :data="{ name: 'Ada' }"
+      :plugins="[binding()]"
+      :components="{ Binding, If }"
+    />
+  </Suspense>
+</template>
+```
+
+### Controlled
+
+Pass your own `ComarkModel` to share state between components or observe changes externally.
+
+```vue [App.vue]
+<script setup lang="ts">
+import { ref } from 'vue'
+import { Markdown } from '@comark/vue'
+import binding, { Binding, If } from '@comark/vue/plugins/binding'
+import { createModelStore } from 'comark/model'
+
+const model = createModelStore({ data: { data: { name: 'Ada' } } })
+const name = ref(model.get('data.name'))
+model.subscribe('data.name', (v) => { name.value = v as string })
+</script>
+
+<template>
+  <p>Current name: {{ name }}</p>
+  <Suspense>
+    <Markdown
+      value=":input{::value=\"data.name\" type=\"text\"}"
+      :model="model"
+      :plugins="[binding()]"
+      :components="{ Binding, If }"
+    />
+  </Suspense>
+</template>
+```
+
+### Native form elements
+
+`::value`, `::checked`, and `::files` on native `<input>`, `<select>`, and `<textarea>` are wired automatically. Vue events (`onInput`, `onChange`) and controlled-element props are set for you.
+
+| Markdown | Element | Wired prop | Event |
+|----------|---------|------------|-------|
+| `:input{::value="…" type="text"}` | `<input>` | `value` | `onInput` |
+| `:input{::checked="…" type="checkbox"}` | `<input>` | `checked` | `onChange` |
+| `:input{::value="…" type="number"}` | `<input>` | `value` (as number) | `onInput` |
+| `:select{::value="…"}` | `<select>` | `value` | `onChange` |
+| `:textarea{::value="…"}` | `<textarea>` | `value` | `onInput` |
+
+For custom components, `onUpdate:prop` (the native Vue v-model handler shape) is passed directly, so `v-model`-compatible components work out of the box.
+
+### `onModelChange`
+
+Observe every write without subscribing to the model manually:
+
+```vue
+<Markdown
+  :value="content"
+  :on-model-change="(path, value, snapshot) => console.log(path, value)"
+/>
+```
+
 ---
diff --git a/docs/content/3.rendering/5.react.md b/docs/content/3.rendering/5.react.md
index 9ec2deb1..669527c4 100644
--- a/docs/content/3.rendering/5.react.md
+++ b/docs/content/3.rendering/5.react.md
@@ -104,6 +104,8 @@ Passing a document to `<Markdown>` skips parsing at runtime, but the **parser is
 | [`streaming`](#streaming) | `boolean` | `false` | Enable streaming mode |
 | [`caret`](#streaming-caret) | `boolean \| { class: string }` | `false` | Append caret to last text node |
 | [`data`](#code-markdown-props-code-data) | `Record<string, unknown>` | `undefined` | Runtime values referenced from markdown via `:prop="data.path"` |
+| [`model`](#two-way-model-binding) | `ComarkModel` | `undefined` | Two-way binding model for `::prop="path"` attributes. Omit to use an internal uncontrolled store. |
+| `onModelChange` | `(path, value, snapshot) => void` | `undefined` | Observer called after every accepted write. Use for controlled-mode sync. |
 | `className` | `string` | `undefined` | CSS class for wrapper element |
 
 #### `options`
@@ -417,6 +419,8 @@ export default async function DocsPage({ params }: { params: { slug: string } })
 | [`streaming`](#streaming) | `boolean` | `false` | Enable streaming mode |
 | [`caret`](#streaming-caret) | `boolean \| { class: string }` | `false` | Append a blinking caret to the last text node |
 | [`data`](#code-markdown-props-code-data) | `Record<string, unknown>` | `undefined` | Runtime values referenced from markdown via `:prop="data.path"` |
+| [`model`](#two-way-model-binding) | `ComarkModel` | `undefined` | Two-way binding model for `::prop="path"` attributes. Omit to use an internal uncontrolled store. |
+| `onModelChange` | `(path, value, snapshot) => void` | `undefined` | Observer called after every accepted write. Use for controlled-mode sync. |
 | `className` | `string` | `undefined` | CSS class for the wrapper `<div>` |
 
 ### `defineMarkdownDocumentComponent`
@@ -744,4 +748,90 @@ export default function Heading({ __node, id, children }: HeadingProps) {
 }
 ```
 
+## Two-way model binding
+
+Use `::prop="data.path"` in your markdown to wire native form elements or pass live values to custom components. No event handlers needed in the markdown itself.
+
+### Uncontrolled (default)
+
+When no `model` prop is provided, `<Markdown>` and `<MarkdownDocument>` create an internal `createModelStore()` seeded from `data`. Writes stay local to the component.
+
+```tsx [App.tsx]
+import { Markdown } from '@comark/react'
+import binding, { Binding, If } from '@comark/react/plugins/binding'
+
+const content = `
+Name: {{ data.name }}
+
+:input{::value="data.name" type="text"}
+`
+
+export default function App() {
+  return (
+    <Markdown
+      value={content}
+      data={{ name: 'Ada' }}
+      plugins={[binding()]}
+      components={{ Binding, If }}
+    />
+  )
+}
+```
+
+### Controlled
+
+Pass your own `ComarkModel` to share state between components or observe changes externally.
+
+```tsx [App.tsx]
+import { useSyncExternalStore } from 'react'
+import { Markdown } from '@comark/react'
+import binding, { Binding, If } from '@comark/react/plugins/binding'
+import { createModelStore } from 'comark/model'
+
+const model = createModelStore({ data: { data: { name: 'Ada' } } })
+
+export default function App() {
+  const name = useSyncExternalStore(
+    (cb) => model.subscribe('data.name', cb),
+    () => model.get('data.name') as string
+  )
+  return (
+    <>
+      <p>Current name: {name}</p>
+      <Markdown
+        value={":input{::value=\"data.name\" type=\"text\"}"}
+        model={model}
+        plugins={[binding()]}
+        components={{ Binding, If }}
+      />
+    </>
+  )
+}
+```
+
+### Native form elements
+
+`::value`, `::checked`, and `::files` on native `<input>`, `<select>`, and `<textarea>` are wired automatically. React events (`onChange`, `onInput`) and controlled-element props are set for you.
+
+| Markdown | Element | Wired prop | Event |
+|----------|---------|------------|-------|
+| `:input{::value="…" type="text"}` | `<input>` | `value` | `onInput` |
+| `:input{::checked="…" type="checkbox"}` | `<input>` | `checked` | `onChange` |
+| `:input{::value="…" type="number"}` | `<input>` | `value` (as number) | `onInput` |
+| `:select{::value="…"}` | `<select>` | `value` | `onChange` |
+| `:textarea{::value="…"}` | `<textarea>` | `value` | `onInput` |
+
+### `onModelChange`
+
+Observe every write without subscribing to the model manually:
+
+```tsx
+<Markdown
+  value={content}
+  onModelChange={(path, value, snapshot) => {
+    console.log(path, value, snapshot)
+  }}
+/>
+```
+
 ---
diff --git a/docs/content/3.rendering/6.svelte.md b/docs/content/3.rendering/6.svelte.md
index a09a9102..e0b60002 100644
--- a/docs/content/3.rendering/6.svelte.md
+++ b/docs/content/3.rendering/6.svelte.md
@@ -96,6 +96,8 @@ Passing a document to `<Markdown>` skips parsing at runtime, but the **parser is
 | [`streaming`](#streaming) | `boolean` | `false` | Enable streaming mode |
 | [`caret`](#streaming-caret) | `boolean \| { class: string }` | `false` | Append caret to last text node |
 | [`data`](#code-markdown-props-code-data) | `Record<string, unknown>` | `undefined` | Runtime values referenced from markdown via `:prop="data.path"` |
+| [`model`](#two-way-model-binding) | `ComarkModel` | `undefined` | Two-way binding model for `::prop="path"` attributes. Omit to use an internal uncontrolled store. |
+| `onModelChange` | `(path, value, snapshot) => void` | `undefined` | Observer called after every accepted write. Use for controlled-mode sync. |
 | `class` | `string` | `''` | CSS class for wrapper element |
 
 #### `options`
@@ -385,6 +387,8 @@ export const load: PageLoad = async ({ params, fetch }) => {
 | [`streaming`](#streaming) | `boolean` | `false` | Enable streaming mode |
 | [`caret`](#streaming-caret) | `boolean \| { class: string }` | `false` | Append a blinking caret to the last text node |
 | [`data`](#code-markdown-props-code-data) | `Record<string, unknown>` | `undefined` | Runtime values referenced from markdown via `:prop="data.path"` |
+| [`model`](#two-way-model-binding) | `ComarkModel` | `undefined` | Two-way binding model for `::prop="path"` attributes. Omit to use an internal uncontrolled store. |
+| `onModelChange` | `(path, value, snapshot) => void` | `undefined` | Observer called after every accepted write. Use for controlled-mode sync. |
 | `class` | `string` | `''` | CSS class for wrapper element |
 
 ### `componentsManifest`
@@ -640,4 +644,51 @@ The `caret` prop appends a blinking cursor to the last text node while `streamin
 </script>
 ```
 
+## Two-way model binding
+
+Use `::prop="data.path"` in your markdown to wire native form elements or pass live values to custom components.
+
+### Uncontrolled (default)
+
+When no `model` prop is provided, `<Markdown>` and `<MarkdownDocument>` create an internal `createModelStore()` seeded from `data`. Writes stay local to the component.
+
+```svelte [App.svelte]
+<script>
+  import { Markdown } from '@comark/svelte'
+  import binding, { Binding, If } from '@comark/svelte/plugins/binding'
+  const content = `Name: {{ data.name }}\n\n:input{::value="data.name" type="text"}`
+</script>
+
+<Markdown value={content} data={{ name: 'Ada' }} plugins={[binding()]} components={{ Binding, If }} />
+```
+
+### Controlled
+
+Pass your own `ComarkModel` to share state between components or observe changes externally.
+
+```svelte [App.svelte]
+<script>
+  import { Markdown } from '@comark/svelte'
+  import binding, { Binding, If } from '@comark/svelte/plugins/binding'
+  import { createModelStore } from 'comark/model'
+
+  const model = createModelStore({ data: { data: { name: 'Ada' } } })
+  let name = $state(model.get('data.name'))
+  model.subscribe('data.name', (v) => { name = v })
+</script>
+
+<p>Current name: {name}</p>
+<Markdown value=":input{::value=\"data.name\" type=\"text\"}" {model} plugins={[binding()]} components={{ Binding, If }} />
+```
+
+### Native form elements
+
+| Markdown | Element | Wired prop | Event |
+|----------|---------|------------|-------|
+| `:input{::value="…" type="text"}` | `<input>` | `value` | `oninput` |
+| `:input{::checked="…" type="checkbox"}` | `<input>` | `checked` | `onchange` |
+| `:input{::value="…" type="number"}` | `<input>` | `value` (as number) | `oninput` |
+| `:select{::value="…"}` | `<select>` | `value` | `onchange` |
+| `:textarea{::value="…"}` | `<textarea>` | `value` | `oninput` |
+
 ---
diff --git a/docs/content/3.rendering/7.angular.md b/docs/content/3.rendering/7.angular.md
index 5ffa3d4e..2eced3b2 100644
--- a/docs/content/3.rendering/7.angular.md
+++ b/docs/content/3.rendering/7.angular.md
@@ -91,6 +91,8 @@ Passing a document to `<comark-markdown>` skips parsing at runtime, but the **pa
 | `summary` | `boolean` | `false` | Only render content before `<!-- more -->` |
 | [`caret`](#caret) | `boolean \| { class: string }` | `false` | Append caret to last text node |
 | [`data`](#data) | `Record<string, unknown>` | `{}` | Runtime values referenced from markdown via `:prop="data.path"` |
+| [`model`](#two-way-model-binding) | `ComarkModel` | `undefined` | Two-way binding model for `::prop="path"` attributes. Omit to use an internal uncontrolled store. |
+| `onModelChange` | `(path, value, snapshot) => void` | `undefined` | Observer called after every accepted write. Use for controlled-mode sync. |
 
 #### `options`
 
@@ -281,6 +283,8 @@ export class DocsComponent implements OnInit {
 | [`streaming`](#streaming) | `boolean` | `false` | Enable streaming mode |
 | [`caret`](#caret) | `boolean \| { class: string }` | `false` | Append a blinking caret to the last text node |
 | [`data`](#data) | `Record<string, unknown>` | `{}` | Runtime values referenced from markdown via `:prop="data.path"` |
+| [`model`](#two-way-model-binding) | `ComarkModel` | `undefined` | Two-way binding model for `::prop="path"` attributes. Omit to use an internal uncontrolled store. |
+| `onModelChange` | `(path, value, snapshot) => void` | `undefined` | Observer called after every accepted write. Use for controlled-mode sync. |
 
 ---
 
@@ -560,4 +564,53 @@ export const DocsMarkdownDocument = defineMarkdownDocumentComponent({
 })
 ```
 
+## Two-way model binding
+
+Use `::prop="data.path"` in your markdown to wire native form elements or pass live values to custom components.
+
+### Uncontrolled (default)
+
+When no `model` input is provided, `<comark-markdown>` and `<comark-markdown-document>` create an internal `createModelStore()` seeded from `data`. Writes stay local to the component.
+
+```html
+<comark-markdown
+  [value]="content"
+  [data]="{ name: 'Ada' }"
+  [plugins]="plugins"
+  [components]="{ Binding, If }"
+/>
+```
+
+### Controlled
+
+Pass your own `ComarkModel` to share state between components or observe changes externally.
+
+```typescript
+import { createModelStore } from 'comark/model'
+
+model = createModelStore({ data: { data: { name: 'Ada' } } })
+```
+
+```html
+<p>Current name: {{ name }}</p>
+<comark-markdown
+  [value]="content"
+  [model]="model"
+  [plugins]="plugins"
+  [components]="{ Binding, If }"
+/>
+```
+
+### Native form elements
+
+Native form events are wired via `Renderer2.listen` so no Zone.js issues arise.
+
+| Markdown | Element | Wired prop | Event |
+|----------|---------|------------|-------|
+| `:input{::value="…" type="text"}` | `<input>` | `value` | `input` |
+| `:input{::checked="…" type="checkbox"}` | `<input>` | `checked` | `change` |
+| `:input{::value="…" type="number"}` | `<input>` | `value` (as number) | `input` |
+| `:select{::value="…"}` | `<select>` | `value` | `change` |
+| `:textarea{::value="…"}` | `<textarea>` | `value` | `input` |
+
 ---
diff --git a/docs/content/4.plugins/1.built-in/model.md b/docs/content/4.plugins/1.built-in/model.md
new file mode 100644
index 00000000..52ddba97
--- /dev/null
+++ b/docs/content/4.plugins/1.built-in/model.md
@@ -0,0 +1,264 @@
+---
+title: Model
+description: "Two-way data binding with `::prop=\"path\"` attributes and the `ComarkModel` protocol."
+navigation:
+  icon: i-lucide-refresh-cw
+seo:
+  title: Model — Two-way binding
+links:
+  - label: Two-way syntax
+    icon: i-lucide-link-2
+    to: /syntax/components#two-way-binding
+    color: neutral
+    variant: soft
+  - label: Parse API
+    icon: i-lucide-code
+    to: /reference/parse
+    color: neutral
+    variant: soft
+---
+
+The `comark/model` entry point provides the `ComarkModel` protocol and the `createModelStore` factory for two-way data binding. When a `::prop="path"` attribute is present on a component or native form element, the renderer reads the current value from the model and wires an update handler that writes back when the user interacts with the element.
+
+Two-way binding is opt-in. Consumers who never import `comark/model` pay no bundle cost.
+
+## Basic usage
+
+### Creating a model store
+
+```typescript
+import { createModelStore } from 'comark/model'
+
+const model = createModelStore({
+  data: { data: { name: 'Alice', active: false } },
+})
+```
+
+### Using the model with a framework renderer
+
+Pass the `model` prop to `<Markdown>` or `<MarkdownDocument>`. The renderer wires native form elements automatically.
+
+```vue [Vue]
+<script setup>
+import { Markdown } from '@comark/vue'
+import { createModelStore } from 'comark/model'
+
+const model = createModelStore({ data: { data: { name: '' } } })
+</script>
+
+<template>
+  <Markdown :model="model">
+    :input{::value="data.name" type="text"}
+  </Markdown>
+</template>
+```
+
+```tsx [React]
+import { Markdown } from '@comark/react'
+import { createModelStore } from 'comark/model'
+
+const model = createModelStore({ data: { data: { name: '' } } })
+
+export default function App() {
+  return (
+    <Markdown model={model}>
+      {':input{::value="data.name" type="text"}'}
+    </Markdown>
+  )
+}
+```
+
+## `::prop` syntax
+
+A `::prop="path"` attribute performs two-way binding on any Comark component or native HTML element.
+
+```md
+<!-- Custom component — receives prop + onUpdate:prop -->
+::card{::title="data.heading"}
+content
+::
+
+<!-- Native input — value is controlled; oninput/onchange updates the model -->
+:input{::value="data.name" type="text"}
+:input{::checked="data.active" type="checkbox"}
+:select{::value="data.color"}
+```
+
+The dot-path resolves against the model's data namespaces. By default, only `data.*` paths are writable.
+
+### Supported native element bindings
+
+| Element | Type | Model prop | Event |
+|---------|------|-----------|-------|
+| `<input>` | `text`, `email`, … | `value` | `input` |
+| `<input>` | `number`, `range` | `value` (Number) | `input` |
+| `<input>` | `date`, `time`, … | `value` | `change` |
+| `<input>` | `checkbox` | `checked` (Boolean) | `change` |
+| `<input>` | `radio` | `checked` (String value) | `change` |
+| `<input>` | `file` | `files` (FileList) | `change` |
+| `<select>` | — | `value` | `change` |
+| `<textarea>` | — | `value` | `input` |
+
+## `ComarkModel` protocol
+
+A custom reactive store can be used in place of `createModelStore` by implementing three methods:
+
+```typescript
+import type { ComarkModel } from 'comark/model'
+
+const model: ComarkModel = {
+  get(path: string): unknown { /* ... */ },
+  set(path: string, value: unknown): boolean { /* return false to reject */ },
+  subscribe(path: string, fn: (value: unknown) => void): () => void { /* return teardown */ },
+  // optional:
+  batch<T>(fn: () => T): T { /* ... */ },
+}
+```
+
+`subscribe` receives the path and every ancestor. A write to `data.a.b` notifies `data.a.b`, `data.a`, and `data`.
+
+## `createModelStore` options
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `data` | `Record<string, unknown>` | `{}` | Initial store contents. |
+| `writable` | `readonly string[]` | `['data']` | Top-level namespace keys that accept writes. |
+| `onChange` | `(path, value, snapshot) => void` | — | Called after each accepted write. Use for persistence or controlled-mode observation. |
+| `documentKey` | `string` | — | When set, writes are also published as `{ op: 'data' }` patches into `globalThis.comarkContext` for `MarkdownLive` subscribers. |
+
+## Controlled vs. uncontrolled mode
+
+**Uncontrolled** (default) — the renderer creates a private model store from the initial `data` prop and manages state internally.
+
+**Controlled** — pass your own `model` instance (and optionally `onModelChange` to observe writes). The renderer reads from and writes to your store.
+
+```vue [Controlled mode — Vue]
+<script setup>
+import { Markdown } from '@comark/vue'
+import { createModelStore } from 'comark/model'
+import { ref, watchEffect } from 'vue'
+
+const model = createModelStore({ data: { data: { name: 'Alice' } } })
+
+// Observe writes externally.
+model.subscribe('data.name', (v) => console.log('name changed to', v))
+</script>
+<template>
+  <Markdown :model="model">
+    :input{::value="data.name"}
+  </Markdown>
+</template>
+```
+
+## Security
+
+Two-way bindings share the same URL-safety guard as one-way (`:prop`) bindings. A `::href` or `::src` that resolves to a `javascript:` or `data:text/html` URL is silently dropped.
+
+Writes are checked against the `writable` namespace list before the path is applied. The `set()` utility rejects `__proto__`, `constructor`, and `prototype` path segments to prevent prototype pollution.
+
+Filtered expressions (`::prop="path | filter"`) are not assignable — they degrade to one-way read-only in production and throw in development.
+
+## `::form` aggregate
+
+The `::form` component wraps a `<form>` element and aggregates all native field values into one object when the form is submitted, writing the result to a single model path.
+
+```md
+::form{::value="data.contact"}
+  :input{::value="data.name" name="name" type="text"}
+  :input{::value="data.email" name="email" type="email"}
+  :button{type="submit"} Submit ::
+::
+```
+
+On submit, the component collects `FormData` from the underlying `<form>` and calls the model write handler with `{ name: …, email: … }`.
+
+### Setup per framework
+
+```vue [Vue]
+<script setup>
+import { Markdown } from '@comark/vue'
+import { Form } from '@comark/vue/plugins/form'
+import { createModelStore } from 'comark/model'
+
+const model = createModelStore({ data: { data: { contact: {} } } })
+</script>
+
+<template>
+  <Markdown :model="model" :components="{ form: Form }">
+    ::form{::value="data.contact"}
+      :input{::value="data.name" name="name" type="text"}
+    ::
+  </Markdown>
+</template>
+```
+
+```tsx [React]
+import { Markdown } from '@comark/react'
+import { Form } from '@comark/react/plugins/form'
+import { createModelStore } from 'comark/model'
+
+const model = createModelStore({ data: { data: { contact: {} } } })
+
+export default function App() {
+  return (
+    <Markdown model={model} components={{ form: Form }}>
+      {'::form{::value="data.contact"}\n  :input{name="name" type="text"}\n::'}
+    </Markdown>
+  )
+}
+```
+
+```svelte [Svelte]
+<script>
+  import { Markdown } from '@comark/svelte'
+  import { Form } from '@comark/svelte/plugins/form'
+  import { createModelStore } from 'comark/model'
+
+  const model = createModelStore({ data: { data: { contact: {} } } })
+</script>
+
+<Markdown {model} components={{ form: Form }}>
+  ::form{::value="data.contact"}
+    :input{name="name" type="text"}
+  ::
+</Markdown>
+```
+
+## Inputs recipe
+
+The table below maps every common HTML input type to its Comark two-way binding form.
+
+| Input | Comark syntax | Model value type |
+|-------|--------------|-----------------|
+| Text field | `:input{::value="data.name" type="text"}` | `string` |
+| Email | `:input{::value="data.email" type="email"}` | `string` |
+| Number | `:input{::value="data.count" type="number"}` | `number` |
+| Range slider | `:input{::value="data.volume" type="range"}` | `number` |
+| Checkbox | `:input{::checked="data.active" type="checkbox"}` | `boolean` |
+| Radio | `:input{::checked="data.color" value="red" type="radio"}` | `string` (the `value` attr) |
+| Date | `:input{::value="data.date" type="date"}` | `string` (ISO format) |
+| Password | `:input{::value="data.pass" type="password"}` | `string` |
+| Textarea | `:textarea{::value="data.bio"}` | `string` |
+| Select | `:select{::value="data.country"}` | `string` |
+| File | `:input{::value="data.file" type="file"}` | `FileList` |
+
+All read-back coercions (string → number, string → boolean, …) happen automatically via the `resolveModelElement` helper shared across all framework renderers.
+
+## HTML progressive enhancement
+
+When using `@comark/html`, the rendered output includes `data-comark-model-{prop}` attributes on two-way-bound elements. Import `@comark/html/runtime` in the browser to activate client-side updates without a framework.
+
+```html
+<!-- Server-rendered output (inert by default) -->
+<input value="Alice" data-comark-model-value="data.name" type="text">
+
+<!-- Add the runtime in the browser -->
+<script type="module">
+  import { initModelRuntime } from '@comark/html/runtime'
+  initModelRuntime(document.getElementById('root'))
+</script>
+```
+
+## ANSI renderer
+
+The ANSI renderer (`@comark/ansi`) renders `::prop` bindings as read-only. The current value is shown; writes are silently ignored. A single per-process warning is emitted in development.
diff --git a/examples/2.vite/angular/src/app/pages/syntax.component.ts b/examples/2.vite/angular/src/app/pages/syntax.component.ts
index f94f93a0..13892be8 100644
--- a/examples/2.vite/angular/src/app/pages/syntax.component.ts
+++ b/examples/2.vite/angular/src/app/pages/syntax.component.ts
@@ -2,6 +2,7 @@ import { Component } from '@angular/core'
 import { Markdown } from '@comark/angular'
 import shiki from 'comark/plugins/shiki'
 import alert from 'comark/plugins/alert'
+import binding, { Binding } from '@comark/angular/plugins/binding'
 import { AlertComponent } from '../components/alert.component'
 import { FeatureCardComponent } from '../components/feature-card.component'
 import python from '@shikijs/langs/python'
@@ -15,17 +16,20 @@ import python from '@shikijs/langs/python'
       [value]="markdown"
       [plugins]="plugins"
       [components]="components"
+      [data]="modelData"
     />
   `,
 })
 export class SyntaxComponent {
-  components = { alert: AlertComponent, 'feature-card': FeatureCardComponent }
+  components = { alert: AlertComponent, 'feature-card': FeatureCardComponent, Binding }
   plugins = [
     shiki({
       languages: [python],
     }),
     alert(),
+    binding(),
   ]
+  modelData = { name: 'Ada', active: true }
 
   markdown = `
 # Comark Syntax Showcase
@@ -242,6 +246,20 @@ With props: :span[hello]{style="color: tomato;"}
 
 ---
 
+## Two-way model binding
+
+Native form elements with \`::prop="path"\` write back to the document model. Change a field and watch the bound text update.
+
+**Name:** {{ data.name }}
+
+:input{::value="data.name" type="text"}
+
+**Active:** {{ data.active }}
+
+:input{::checked="data.active" type="checkbox"}
+
+---
+
 ## Frontmatter
 
 Documents can declare YAML frontmatter at the top (before any content):
diff --git a/examples/2.vite/ansi/src/main.ts b/examples/2.vite/ansi/src/main.ts
index bdf0e3e9..af0b37ac 100644
--- a/examples/2.vite/ansi/src/main.ts
+++ b/examples/2.vite/ansi/src/main.ts
@@ -104,6 +104,12 @@ $$
 | Tables      | ✅      |
 | Lists       | ✅      |
 
+## Two-way model binding
+
+The ANSI renderer resolves \`::prop\` as read-only.
+
+Name: :span{::value="data.name"}
+
 ---
 
 _Edit the markdown on the left to see live updates._
@@ -158,6 +164,7 @@ async function render(markdown: string) {
   const ansi = await renderAnsiFromDocument(tree, {
     components: { Math },
     width: term.cols,
+    data: { name: 'Ada' },
   })
 
   term.reset()
diff --git a/examples/2.vite/html/src/main.ts b/examples/2.vite/html/src/main.ts
index 02fa75dd..b9e63fab 100644
--- a/examples/2.vite/html/src/main.ts
+++ b/examples/2.vite/html/src/main.ts
@@ -2,12 +2,15 @@ import { createHtmlRenderer } from '@comark/html'
 import shiki from '@comark/html/plugins/shiki'
 import math, { Math } from '@comark/html/plugins/math'
 import mermaid, { Mermaid } from '@comark/html/plugins/mermaid'
+import binding, { Binding } from '@comark/html/plugins/binding'
+import { initComarkRuntime } from '@comark/html/runtime'
 import katexCss from 'katex/dist/katex.min.css?raw'
 import previewCss from './preview.css?raw'
 
 const renderHtml = createHtmlRenderer({
-  plugins: [shiki(), math(), mermaid()],
-  components: { Math, Mermaid },
+  plugins: [shiki(), math(), mermaid(), binding()],
+  components: { Math, Mermaid, Binding },
+  data: { name: 'Ada', active: true },
 })
 
 const SAMPLE = `---
@@ -103,14 +106,40 @@ graph TD
 | Tables      | ✅      |
 | Lists       | ✅      |
 
+## Two-way model binding
+
+Native form elements with \`::prop="path"\` write back to the document model. Change a field and watch the bound text update.
+
+**Name:** {{ data.name }}
+
+:input{::value="data.name" type="text"}
+
+**Active:** {{ data.active }}
+
+:input{::checked="data.active" type="checkbox"}
+
 ---
 
 _Edit the markdown on the left to see live updates._
 `
 
+let runtimeTeardown: (() => void) | undefined
+let previewGeneration = 0
+
 async function updatePreview(markdown: string) {
+  const generation = ++previewGeneration
+  runtimeTeardown?.()
+  runtimeTeardown = undefined
   const html = await renderHtml(markdown)
+  if (generation !== previewGeneration) return
   const frame = document.getElementById('preview') as HTMLIFrameElement
+  const onLoad = () => {
+    frame.removeEventListener('load', onLoad)
+    if (generation !== previewGeneration) return
+    const doc = frame.contentDocument
+    if (doc) runtimeTeardown = initComarkRuntime(doc.body)
+  }
+  frame.addEventListener('load', onLoad)
   frame.srcdoc = `<!doctype html><html><head><meta charset="utf-8"><style>${katexCss}${previewCss}</style></head><body>${html}</body></html>`
 }
 
diff --git a/examples/2.vite/html/src/preview.css b/examples/2.vite/html/src/preview.css
index a0cff019..b69740de 100644
--- a/examples/2.vite/html/src/preview.css
+++ b/examples/2.vite/html/src/preview.css
@@ -112,6 +112,15 @@ img {
   max-width: 100%;
   border-radius: 6px;
 }
+input[type='text'] {
+  font: inherit;
+  padding: 4px 8px;
+  border: 1px solid #d0d7de;
+  border-radius: 6px;
+}
+input[type='checkbox'] {
+  margin-right: 0.4em;
+}
 table {
   width: 100%;
   border-collapse: collapse;
diff --git a/examples/2.vite/react/src/pages/Syntax.tsx b/examples/2.vite/react/src/pages/Syntax.tsx
index 3a966c09..f237cf35 100644
--- a/examples/2.vite/react/src/pages/Syntax.tsx
+++ b/examples/2.vite/react/src/pages/Syntax.tsx
@@ -1,10 +1,13 @@
 import { useEffect, useState } from 'react'
 import { parseMarkdown } from 'comark'
 import shiki from '@comark/react/plugins/shiki'
+import binding, { Binding } from '@comark/react/plugins/binding'
 import { MarkdownDocument } from '@comark/react'
 import type { MarkdownDocument as Document } from '@comark/react'
 import Alert from '../components/Alert'
 
+const modelData = { name: 'Ada', active: true }
+
 const markdown = `
 # Comark Syntax Showcase
 
@@ -147,6 +150,20 @@ Documents can declare YAML frontmatter at the top (before any content). Access i
 
 ---
 
+## Two-way model binding
+
+Native form elements with \`::prop="path"\` write back to the document model. Change a field and watch the bound text update.
+
+**Name:** {{ data.name }}
+
+:input{::value="data.name" type="text"}
+
+**Active:** {{ data.active }}
+
+:input{::checked="data.active" type="checkbox"}
+
+---
+
 ## Comments
 
 HTML comments are parsed and ignored by the renderer:
@@ -160,7 +177,7 @@ export default function Syntax() {
   const [tree, setTree] = useState<Document | null>(null)
 
   useEffect(() => {
-    parseMarkdown(markdown, { plugins: [shiki()] }).then(setTree)
+    parseMarkdown(markdown, { plugins: [shiki(), binding()] }).then(setTree)
   }, [])
 
   if (!tree) return null
@@ -168,7 +185,8 @@ export default function Syntax() {
   return (
     <MarkdownDocument
       value={tree}
-      components={{ Alert }}
+      components={{ Alert, Binding }}
+      data={modelData}
     />
   )
 }
diff --git a/examples/2.vite/svelte/src/pages/Syntax.svelte b/examples/2.vite/svelte/src/pages/Syntax.svelte
index 8bf72abb..cb4f7012 100644
--- a/examples/2.vite/svelte/src/pages/Syntax.svelte
+++ b/examples/2.vite/svelte/src/pages/Syntax.svelte
@@ -1,9 +1,12 @@
 <script lang="ts">
   import { Markdown } from '@comark/svelte'
   import shiki from '@comark/svelte/plugins/shiki'
+  import binding, { Binding } from '@comark/svelte/plugins/binding'
   import Alert from '../components/Alert.svelte'
   import python from '@shikijs/langs/python'
 
+  const modelData = { name: 'Ada', active: true }
+
   const componentsManifest = (name: string) => {
     if (name === 'lazy-card') {
       return import('../components/LazyCard.svelte')
@@ -162,6 +165,20 @@ Documents can declare YAML frontmatter at the top (before any content). Access i
 
 ---
 
+## Two-way model binding
+
+Native form elements with \`::prop="path"\` write back to the document model. Change a field and watch the bound text update.
+
+**Name:** {{ data.name }}
+
+:input{::value="data.name" type="text"}
+
+**Active:** {{ data.active }}
+
+:input{::checked="data.active" type="checkbox"}
+
+---
+
 ## Comments
 
 HTML comments are parsed and ignored by the renderer:
@@ -173,8 +190,9 @@ Text before the comment and text after the comment both render normally.
 </script>
 
 <Markdown
-  {markdown}
-  plugins={[shiki({ languages: [python] })]}
-  components={{ Alert }}
+  value={markdown}
+  plugins={[shiki({ languages: [python] }), binding()]}
+  components={{ Alert, Binding }}
   {componentsManifest}
+  data={modelData}
 />
diff --git a/examples/2.vite/vue/src/App.vue b/examples/2.vite/vue/src/App.vue
index 917c632d..e18edf1d 100644
--- a/examples/2.vite/vue/src/App.vue
+++ b/examples/2.vite/vue/src/App.vue
@@ -2,13 +2,25 @@
   <Suspense>
     <div class="min-h-screen flex flex-col">
       <header class="border-b border-gray-200 dark:border-gray-800">
-        <nav class="max-w-2xl mx-auto px-6 py-4">
+        <nav class="max-w-2xl mx-auto px-6 py-4 flex items-center gap-6">
           <RouterLink
             to="/"
             class="text-lg font-semibold text-gray-900 dark:text-white no-underline"
           >
             Comark Blog
           </RouterLink>
+          <RouterLink
+            to="/syntax"
+            class="text-sm text-gray-500 dark:text-gray-400 hover:text-gray-700 dark:hover:text-gray-300 no-underline"
+          >
+            Syntax
+          </RouterLink>
+          <RouterLink
+            to="/live"
+            class="text-sm text-gray-500 dark:text-gray-400 hover:text-gray-700 dark:hover:text-gray-300 no-underline"
+          >
+            Live
+          </RouterLink>
         </nav>
       </header>
       <main class="max-w-2xl mx-auto px-6 py-8 flex-1 w-full">
diff --git a/examples/2.vite/vue/src/pages/syntax.vue b/examples/2.vite/vue/src/pages/syntax.vue
index 89d31ae6..6538f8f5 100644
--- a/examples/2.vite/vue/src/pages/syntax.vue
+++ b/examples/2.vite/vue/src/pages/syntax.vue
@@ -1,10 +1,13 @@
 <script setup lang="ts">
 import { Markdown } from '@comark/vue'
 import shiki from '@comark/vue/plugins/shiki'
+import binding, { Binding } from '@comark/vue/plugins/binding'
 import Alert from '@/components/Alert.vue'
 import ProseUnwrapDiv from '@/components/prose/ProseUnwrapDiv.vue'
 import python from '@shikijs/langs/python'
 
+const modelData = { name: 'Ada', active: true }
+
 const markdown = `
 # Comark Syntax Showcase
 
@@ -240,6 +243,20 @@ This content is inside a \`div\` with inline styles — but the \`div\` itself i
 
 ---
 
+## Two-way model binding
+
+Native form elements with \`::prop="path"\` write back to the document model. Change a field and watch the bound text update.
+
+**Name:** {{ data.name }}
+
+:input{::value="data.name" type="text"}
+
+**Active:** {{ data.active }}
+
+:input{::checked="data.active" type="checkbox"}
+
+---
+
 ## Frontmatter
 
 Documents can declare YAML frontmatter at the top (before any content):
@@ -275,8 +292,10 @@ Text before the comment and text after the comment both render normally.
       shiki({
         languages: [python],
       }),
+      binding(),
     ]"
     :value="markdown"
-    :components="{ Alert, ProseUnwrapDiv }"
+    :components="{ Alert, ProseUnwrapDiv, Binding }"
+    :data="modelData"
   />
 </template>
diff --git a/packages/comark-angular/src/components/form.component.ts b/packages/comark-angular/src/components/form.component.ts
new file mode 100644
index 00000000..110cacee
--- /dev/null
+++ b/packages/comark-angular/src/components/form.component.ts
@@ -0,0 +1,40 @@
+import { Component, Input, Output, EventEmitter, ChangeDetectionStrategy, ElementRef, inject } from '@angular/core'
+
+/**
+ * `::form` aggregate component.
+ *
+ * Wraps its children in a `<form>` element.  On submit, collects native
+ * `FormData` from the form and emits the aggregated field values via
+ * `updateValue`, which the Comark renderer wires to write back to the model
+ * path bound to `::value`.
+ *
+ * @example
+ * ```html
+ * <!-- Markdown: ::form{::value="data.contact"} -->
+ * <comark-form [value]="formData" (updateValue)="onFormSubmit($event)" />
+ * ```
+ */
+@Component({
+  selector: 'comark-form',
+  standalone: true,
+  changeDetection: ChangeDetectionStrategy.OnPush,
+  template: '<form (submit)="handleSubmit($event)"><ng-content /></form>',
+})
+export class Form {
+  /** Current aggregated form value — supplied by the renderer from the model. */
+  @Input() value?: Record<string, unknown>
+
+  /** Emitted with the collected `FormData` aggregate on form submit. */
+  @Output() updateValue = new EventEmitter<Record<string, unknown>>()
+
+  private elementRef = inject(ElementRef)
+
+  handleSubmit(e: Event): void {
+    e.preventDefault()
+    const formEl = (this.elementRef.nativeElement as HTMLElement).querySelector('form') as HTMLFormElement | null
+    if (!formEl) return
+    const fd = new FormData(formEl)
+    const aggregate = Object.fromEntries(fd.entries()) as Record<string, unknown>
+    this.updateValue.emit(aggregate)
+  }
+}
diff --git a/packages/comark-angular/src/components/markdown-document.component.ts b/packages/comark-angular/src/components/markdown-document.component.ts
index a1a5300d..a41f8dcf 100644
--- a/packages/comark-angular/src/components/markdown-document.component.ts
+++ b/packages/comark-angular/src/components/markdown-document.component.ts
@@ -9,6 +9,8 @@ import {
   type OnDestroy,
 } from '@angular/core'
 import type { ElementNode, Node, MarkdownDocument as MarkdownDocumentType, NodeRenderData } from 'comark'
+import type { ComarkModel } from 'comark/model'
+import { createModelStore } from 'comark/model'
 import { MarkdownNode } from './markdown-node.component.ts'
 import { findLastTextNodeAndAppendNode, getCaret } from '../utils/caret.ts'
 
@@ -38,6 +40,7 @@ const EMPTY_DOCUMENT: MarkdownDocumentType = { nodes: [], frontmatter: {}, meta:
           [node]="node"
           [components]="components"
           [renderData]="renderData"
+          [model]="activeModel"
         />
       }
     </div>
@@ -59,6 +62,16 @@ export class MarkdownDocument implements OnInit, OnDestroy {
   /** Additional data to pass to the renderer for :binding resolution */
   @Input() data: Record<string, unknown> = {}
 
+  /**
+   * Two-way data binding model. When provided, `::prop="path"` attributes are
+   * resolved against the model and update handlers are wired automatically.
+   * When omitted an internal uncontrolled store is created from `data`.
+   */
+  @Input() model?: ComarkModel
+
+  /** Called after every write accepted by the model. */
+  @Input() onModelChange?: (path: string, value: unknown, snapshot: Record<string, unknown>) => void
+
   /**
    * Document key used to subscribe to live updates via `globalThis.comarkContext`.
    * Falls back to the document's own `meta.key` when set by a plugin.
@@ -68,6 +81,8 @@ export class MarkdownDocument implements OnInit, OnDestroy {
   private cdr = inject(ChangeDetectorRef)
   private liveDocument: MarkdownDocumentType | null = null
   private cleanup?: (clear?: boolean) => void
+  private modelCleanup?: () => void
+  private internalModel?: ComarkModel
 
   private get inputDocument(): MarkdownDocumentType {
     return this.value ?? EMPTY_DOCUMENT
@@ -83,10 +98,27 @@ export class MarkdownDocument implements OnInit, OnDestroy {
         this.cdr.markForCheck()
       })
     }
+
+    // Model boundary: create an uncontrolled store if no model is provided.
+    // Subscribe to 'data' so every write triggers change detection.
+    this.internalModel =
+      this.model ??
+      createModelStore({
+        data: { data: this.data ?? {} },
+        onChange: this.onModelChange,
+      })
+    this.modelCleanup = this.internalModel.subscribe('data', () => {
+      this.cdr.markForCheck()
+    })
   }
 
   ngOnDestroy(): void {
     this.cleanup?.(true)
+    this.modelCleanup?.()
+  }
+
+  get activeModel(): ComarkModel | undefined {
+    return this.internalModel
   }
 
   private get activeDocument(): MarkdownDocumentType {
@@ -113,6 +145,7 @@ export class MarkdownDocument implements OnInit, OnDestroy {
       meta: this.activeDocument.meta,
       data: this.data || {},
       props: {},
+      model: this.internalModel,
     }
   }
 }
diff --git a/packages/comark-angular/src/components/markdown-node.component.ts b/packages/comark-angular/src/components/markdown-node.component.ts
index 9869759f..544041e4 100644
--- a/packages/comark-angular/src/components/markdown-node.component.ts
+++ b/packages/comark-angular/src/components/markdown-node.component.ts
@@ -16,8 +16,9 @@ import {
   inject,
 } from '@angular/core'
 import type { ElementNode, Node as MarkdownAstNode, NodeRenderData } from 'comark'
+import type { ComarkModel } from 'comark/model'
 import { resolveIfWrapper, selectIfBranch, shouldRenderIf, type IfProps } from 'comark/plugins/binding'
-import { pascalCase, resolveAttributes } from 'comark/utils'
+import { pascalCase, resolveAttributes, resolveModelElement, modelElementDisplayValue } from 'comark/utils'
 
 interface StructuralComponent extends Type<any> {
   ɵcomarkIf?: boolean
@@ -103,6 +104,9 @@ export class MarkdownNode implements OnChanges {
   /** Render data for :binding resolution */
   @Input() renderData: NodeRenderData = { frontmatter: {}, meta: {}, data: {}, props: {} }
 
+  /** Two-way data binding model */
+  @Input() model?: ComarkModel
+
   /** Parent node (for context like `pre` tag detection) */
   @Input() parent?: MarkdownAstNode
 
@@ -153,8 +157,8 @@ export class MarkdownNode implements OnChanges {
         }
       }
 
-      // Resolve attributes (:binding support)
-      const resolved = resolveAttributes(nodeProps, this.renderData, { parseJson: true })
+      // Resolve attributes (:binding support + ::binding two-way support)
+      const resolved = resolveAttributes(nodeProps, this.renderData, { parseJson: true, model: this.model })
 
       // Build childrenRenderData - only shadow parent scope when element has own attrs
       const hasOwnAttrs = Object.keys(resolved).length > 0
@@ -165,7 +169,7 @@ export class MarkdownNode implements OnChanges {
       } else if (customComponent) {
         this.renderCustomComponent(customComponent, resolved, children, childrenRenderData)
       } else {
-        this.renderNativeElement(tag, resolved, children, childrenRenderData)
+        this.renderNativeElement(tag, resolved, children, childrenRenderData, nodeProps)
       }
     }
   }
@@ -176,6 +180,8 @@ export class MarkdownNode implements OnChanges {
       const value = attrs[key]
       if (key === 'as' || key === 'innerHTML' || key === 'dangerouslySetInnerHTML') {
         continue
+      } else if (key.startsWith('onUpdate:') || typeof value === 'function') {
+        continue
       } else if (key === 'className' || key === 'class') {
         this.renderer.setAttribute(el, 'class', String(value))
       } else if (key === 'style' && typeof value === 'string') {
@@ -196,11 +202,28 @@ export class MarkdownNode implements OnChanges {
     tag: string,
     attrs: Record<string, any>,
     children: MarkdownAstNode[],
-    childrenRenderData: NodeRenderData
+    childrenRenderData: NodeRenderData,
+    nodeProps?: Record<string, any>
   ): void {
     const el = this.renderer.createElement(tag)
     this.applyAttributes(el, attrs)
 
+    // Wire model event listeners for ::prop bindings on native form elements.
+    if (this.model && nodeProps) {
+      for (const rawKey in nodeProps) {
+        if (!rawKey.startsWith('::')) continue
+        const modelProp = rawKey.slice(2)
+        const binding = resolveModelElement(tag, modelProp, nodeProps)
+        if (!binding) continue
+        const path = nodeProps[rawKey] as string
+        const model = this.model
+        this.renderer.listen(el, binding.event, (e: Event) => {
+          model.set(path, binding.coerce(e.target as any))
+        })
+        this.renderer.setProperty(el, binding.prop, modelElementDisplayValue(binding, model.get(path), nodeProps))
+      }
+    }
+
     // `innerHTML` from document attributes is never applied — resolveAttributes
     // drops DOM sink props, and raw HTML has its own explicit parse path.
     if (!VOID_ELEMENTS.has(tag)) {
@@ -214,9 +237,17 @@ export class MarkdownNode implements OnChanges {
     tag: string,
     attrs: Record<string, any>,
     children: MarkdownAstNode[],
-    childrenRenderData: NodeRenderData
+    childrenRenderData: NodeRenderData,
+    nodeProps?: Record<string, any>
   ): void {
-    this.renderNativeEl(this.elementRef.nativeElement as HTMLElement, tag, attrs, children, childrenRenderData)
+    this.renderNativeEl(
+      this.elementRef.nativeElement as HTMLElement,
+      tag,
+      attrs,
+      children,
+      childrenRenderData,
+      nodeProps
+    )
   }
 
   /** Evaluate an `::if` before rendering any of its descendants. */
@@ -309,6 +340,19 @@ export class MarkdownNode implements OnChanges {
       }
     }
 
+    for (const output of mirror?.outputs || []) {
+      const rest = output.propName.replace(/^update/, '')
+      if (!rest || rest === output.propName) continue
+      const bindProp = rest.charAt(0).toLowerCase() + rest.slice(1)
+      const handler = attrs[`onUpdate:${bindProp}`]
+      const emitter = (componentRef.instance as Record<string, { subscribe?: (fn: (v: unknown) => void) => void }>)[
+        output.propName
+      ]
+      if (typeof handler === 'function' && emitter && typeof emitter.subscribe === 'function') {
+        emitter.subscribe(handler)
+      }
+    }
+
     // Pass __node if the component accepts it
     if (inputNames.has('__node')) {
       componentRef.setInput('__node', this.node)
@@ -371,6 +415,7 @@ export class MarkdownNode implements OnChanges {
             componentRef.setInput('components', this.components)
             componentRef.setInput('renderData', renderData)
             componentRef.setInput('parent', this.node)
+            componentRef.setInput('model', this.model)
             componentRef.changeDetectorRef.detectChanges()
 
             // Move the component's host element into the parent
@@ -382,10 +427,10 @@ export class MarkdownNode implements OnChanges {
             console.error(`Failed to render custom component "${childTag}"`, error)
           }
         } else {
-          const resolved = resolveAttributes(childProps, renderData, { parseJson: true })
+          const resolved = resolveAttributes(childProps, renderData, { parseJson: true, model: this.model })
           const hasOwnAttrs = Object.keys(resolved).length > 0
           const childRenderData: NodeRenderData = hasOwnAttrs ? { ...renderData, props: resolved } : renderData
-          this.renderNativeEl(parentEl, childTag, resolved, grandChildren, childRenderData)
+          this.renderNativeEl(parentEl, childTag, resolved, grandChildren, childRenderData, childProps)
         }
       }
     }
diff --git a/packages/comark-angular/src/components/markdown.component.ts b/packages/comark-angular/src/components/markdown.component.ts
index c15571b2..bba27b4f 100644
--- a/packages/comark-angular/src/components/markdown.component.ts
+++ b/packages/comark-angular/src/components/markdown.component.ts
@@ -10,6 +10,7 @@ import {
 } from '@angular/core'
 import { createSerializedMarkdownParser } from 'comark'
 import type { ParserOptions, MarkdownDocument as MarkdownDocumentType } from 'comark'
+import type { ComarkModel } from 'comark/model'
 import { isMarkdownDocument } from 'comark/utils'
 import { MarkdownDocument } from './markdown-document.component.ts'
 
@@ -35,6 +36,8 @@ import { MarkdownDocument } from './markdown-document.component.ts'
         [streaming]="streaming"
         [caret]="caret"
         [data]="data"
+        [model]="model"
+        [onModelChange]="onModelChange"
       />
     }
   `,
@@ -71,6 +74,12 @@ export class Markdown implements OnChanges {
   /** Additional data to pass to the renderer for :binding resolution */
   @Input() data: Record<string, unknown> = {}
 
+  /** Two-way data binding model */
+  @Input() model?: ComarkModel
+
+  /** Called after every write accepted by the model */
+  @Input() onModelChange?: (path: string, value: unknown, snapshot: Record<string, unknown>) => void
+
   document: MarkdownDocumentType | null = null
 
   private serializedParse = createSerializedMarkdownParser({})
diff --git a/packages/comark-angular/src/plugins/form.ts b/packages/comark-angular/src/plugins/form.ts
new file mode 100644
index 00000000..8c3fd69f
--- /dev/null
+++ b/packages/comark-angular/src/plugins/form.ts
@@ -0,0 +1,3 @@
+export * from 'comark/plugins/form'
+
+export { Form } from '../components/form.component.ts'
diff --git a/packages/comark-angular/test/model-binding.test.ts b/packages/comark-angular/test/model-binding.test.ts
new file mode 100644
index 00000000..f3f3c49a
--- /dev/null
+++ b/packages/comark-angular/test/model-binding.test.ts
@@ -0,0 +1,64 @@
+import { describe, expect, it, vi } from 'vitest'
+import { parseMarkdown } from 'comark'
+import { createModelStore } from 'comark/model'
+import { resolveAttributes } from 'comark/utils'
+
+describe('Angular model binding — attribute resolution', () => {
+  it('resolves ::value="data.name" from the model', async () => {
+    const model = createModelStore({ data: { data: { name: 'Alice' } } })
+    const doc = await parseMarkdown(':input{::value="data.name" type="text"}')
+    const node = doc.nodes[0] as any
+    // Walk to the input element (inside the paragraph)
+    const inputNode = Array.isArray(node[2]) ? node[2] : node
+    const nodeProps = inputNode[1] ?? {}
+    const renderData = { frontmatter: {}, meta: {}, data: {}, props: {} }
+    const resolved = resolveAttributes(nodeProps, renderData, { parseJson: true, model })
+    expect(resolved.value).toBe('Alice')
+  })
+
+  it('controlled mode: onModelChange fires on write', () => {
+    const onChange = vi.fn()
+    const model = createModelStore({ data: { data: { x: 0 } }, onChange })
+    model.set('data.x', 7)
+    expect(onChange).toHaveBeenCalledWith('data.x', 7, expect.anything())
+  })
+
+  it('custom component gets ::title="data.title" resolved', async () => {
+    const model = createModelStore({ data: { data: { title: 'My Title' } } })
+    const doc = await parseMarkdown('::card{::title="data.title"}\ncontent\n::')
+    const cardNode = doc.nodes[0] as any
+    const nodeProps = cardNode[1] ?? {}
+    const renderData = { frontmatter: {}, meta: {}, data: {}, props: {} }
+    const resolved = resolveAttributes(nodeProps, renderData, { parseJson: true, model })
+    expect(resolved.title).toBe('My Title')
+  })
+
+  it('unsafe URL is blocked for ::href binding', () => {
+    const model = createModelStore({ data: { data: { url: 'javascript:alert(1)' } } })
+    // Directly test resolveAttributes with the ::href node prop
+    const nodeProps = { '::href': 'data.url' }
+    const renderData = { frontmatter: {}, meta: {}, data: {}, props: {} }
+    const resolved = resolveAttributes(nodeProps, renderData, { parseJson: true, model })
+    expect(String(resolved.href ?? '')).not.toContain('javascript:')
+  })
+
+  it('number input resolves value from model', async () => {
+    const model = createModelStore({ data: { data: { count: 5 } } })
+    const doc = await parseMarkdown(':input{::value="data.count" type="number"}')
+    const node = doc.nodes[0] as any
+    const inputNode = Array.isArray(node[2]) ? node[2] : node
+    const nodeProps = inputNode[1] ?? {}
+    const renderData = { frontmatter: {}, meta: {}, data: {}, props: {} }
+    const resolved = resolveAttributes(nodeProps, renderData, { parseJson: true, model })
+    expect(resolved.value).toBe(5)
+  })
+
+  it('per-instance isolation: two stores do not share state', () => {
+    const m1 = createModelStore({ data: { data: { x: 1 } } })
+    const m2 = createModelStore({ data: { data: { x: 99 } } })
+    expect(m1.get('data.x')).toBe(1)
+    expect(m2.get('data.x')).toBe(99)
+    m1.set('data.x', 42)
+    expect(m2.get('data.x')).toBe(99)
+  })
+})
diff --git a/packages/comark-ansi/src/render.ts b/packages/comark-ansi/src/render.ts
index 1a62372a..f4589e05 100644
--- a/packages/comark-ansi/src/render.ts
+++ b/packages/comark-ansi/src/render.ts
@@ -5,6 +5,21 @@ import { stripControlChars } from './utils/escape.ts'
 
 export * from 'comark/render'
 
+/** Emitted at most once per process to avoid log spam. */
+let twoWayWarnEmitted = false
+
+function hasDoubleBindingAttrs(nodes: Node[]): boolean {
+  for (const node of nodes) {
+    if (typeof node === 'string' || node[0] === null) continue
+    const [, attrs, ...children] = node as ElementNode
+    for (const key in attrs) {
+      if (key.charCodeAt(0) === 58 && key.charCodeAt(1) === 58) return true
+    }
+    if (hasDoubleBindingAttrs(children as Node[])) return true
+  }
+  return false
+}
+
 export interface AnsiRendererOptions extends RendererOptions {
   /**
    * Whether to emit ANSI escape codes.
@@ -63,6 +78,14 @@ export async function renderAnsiFromDocument(
   const colors = options?.colors ?? (typeof process !== 'undefined' ? !process.env.NO_COLOR : true)
   const width = options?.width ?? 80
 
+  if (!twoWayWarnEmitted && hasDoubleBindingAttrs(document.nodes)) {
+    twoWayWarnEmitted = true
+    console.warn(
+      '[comark/ansi] Two-way binding (::prop) is not supported in the ANSI renderer. ' +
+        'Attributes are resolved read-only. Use a framework renderer for live two-way binding.'
+    )
+  }
+
   const sanitized = { ...document, nodes: sanitizeForTerminal(document.nodes) }
   return render(sanitized, {
     ...options,
diff --git a/packages/comark-ansi/test/model-binding.test.ts b/packages/comark-ansi/test/model-binding.test.ts
new file mode 100644
index 00000000..cf495d13
--- /dev/null
+++ b/packages/comark-ansi/test/model-binding.test.ts
@@ -0,0 +1,46 @@
+import { beforeEach, afterEach, describe, it, expect, vi } from 'vitest'
+import { parseMarkdown } from 'comark'
+import { renderAnsiFromDocument } from '../src/index'
+
+describe('ANSI two-way binding degrade', () => {
+  let warnSpy: ReturnType<typeof vi.spyOn>
+
+  beforeEach(() => {
+    warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
+  })
+
+  afterEach(() => {
+    vi.restoreAllMocks()
+  })
+
+  it('renders ::value as read-only (resolves from data, no error)', async () => {
+    const doc = await parseMarkdown(':span{::value="data.name"}', {
+      data: { name: 'Alice' },
+    })
+    const output = await renderAnsiFromDocument(doc, { colors: false, data: { name: 'Alice' } })
+    expect(typeof output).toBe('string')
+  })
+
+  it('emits at most one dev warning per process for ::prop usage', async () => {
+    const doc = await parseMarkdown(':input{::value="data.x"}')
+    await renderAnsiFromDocument(doc, { colors: false })
+    await renderAnsiFromDocument(doc, { colors: false })
+    await renderAnsiFromDocument(doc, { colors: false })
+
+    const twoWayCalls = warnSpy.mock.calls.filter((args) => String(args[0]).includes('Two-way binding'))
+    // At most 1 warning (singleton guard ensures no repeated noise)
+    expect(twoWayCalls.length).toBeLessThanOrEqual(1)
+  })
+
+  it('does not warn for documents without ::prop', async () => {
+    // This test uses only single-colon one-way binding
+    const doc = await parseMarkdown(':span{:data-id="data.id"}', {
+      data: { id: '123' },
+    })
+    const output = await renderAnsiFromDocument(doc, { colors: false, data: { id: '123' } })
+    expect(typeof output).toBe('string')
+    const twoWayCalls = warnSpy.mock.calls.filter((args) => String(args[0]).includes('Two-way binding'))
+    // No two-way warning for one-way-only documents (guard fires only on :: keys)
+    expect(twoWayCalls.length).toBe(0)
+  })
+})
diff --git a/packages/comark-html/package.json b/packages/comark-html/package.json
index c3221f4a..865790f3 100644
--- a/packages/comark-html/package.json
+++ b/packages/comark-html/package.json
@@ -33,7 +33,8 @@
     "./plugins/*": "./dist/plugins/*.js",
     "./utils": "./dist/utils/index.js",
     "./parse": "./dist/parse.js",
-    "./render": "./dist/render.js"
+    "./render": "./dist/render.js",
+    "./runtime": "./dist/runtime.js"
   },
   "publishConfig": {
     "access": "public"
@@ -51,6 +52,7 @@
   },
   "devDependencies": {
     "beautiful-mermaid": "catalog:",
+    "jsdom": "^30.0.1",
     "katex": "^0.17.0",
     "vitest": "catalog:"
   },
diff --git a/packages/comark-html/src/plugins/binding.ts b/packages/comark-html/src/plugins/binding.ts
index da3aa4be..3216c745 100644
--- a/packages/comark-html/src/plugins/binding.ts
+++ b/packages/comark-html/src/plugins/binding.ts
@@ -29,8 +29,12 @@ export const Binding: NodeHandler = (node, state) => {
   const resolved = state.renderData.props as Record<string, unknown>
   const raw = (node[1] || {}) as Record<string, unknown>
   const out = resolved.value ?? raw.defaultValue
-  if (out === undefined || out === null) return ''
-  return escapeHtml(String(out))
+  const path = typeof raw[':value'] === 'string' ? raw[':value'].trim() : ''
+  const text = out === undefined || out === null ? '' : escapeHtml(String(out))
+  if (path.startsWith('data.')) {
+    return `<span data-comark-bind="${escapeHtml(path)}">${text}</span>`
+  }
+  return text
 }
 
 /** Render the default or else branch of an `::if` component. */
diff --git a/packages/comark-html/src/runtime.ts b/packages/comark-html/src/runtime.ts
new file mode 100644
index 00000000..42fba59a
--- /dev/null
+++ b/packages/comark-html/src/runtime.ts
@@ -0,0 +1,84 @@
+/**
+ * @comark/html progressive-enhancement runtime (~1KB, zero deps).
+ *
+ * Call `initComarkRuntime(root?)` once the DOM is ready. The runtime:
+ * 1. Event-delegates `input` and `change` on the root element.
+ * 2. Reads `data-comark-model-{prop}` attributes from the event target to
+ *    discover the model path that controls that element's property.
+ * 3. Writes the coerced value into the internal `createModelStore`.
+ * 4. Patches all `[data-comark-bind]` text nodes that reference the same path.
+ *
+ * @example
+ * ```html
+ * <script type="module">
+ *   import { initComarkRuntime } from '@comark/html/runtime'
+ *   initComarkRuntime()
+ * </script>
+ * ```
+ */
+
+import { createModelStore } from 'comark/model'
+import type { ComarkModel } from 'comark/model'
+import { resolveModelElement } from 'comark/utils'
+
+const MODEL_ATTR_PREFIX = 'data-comark-model-'
+const BIND_ATTR = 'data-comark-bind'
+
+function getCoercedValue(el: HTMLElement, prop: string): unknown {
+  const tag = el.tagName.toLowerCase()
+  const inputEl = el as HTMLInputElement
+  const binding = resolveModelElement(tag, prop, { type: inputEl.type || 'text' })
+  if (binding) return binding.coerce(inputEl)
+  return inputEl.value
+}
+
+/**
+ * Initialise the Comark progressive-enhancement runtime.
+ *
+ * @param root - Root element to scope event delegation to. Defaults to
+ *   `document.body`.
+ * @param model - Optional external `ComarkModel`. When omitted the runtime
+ *   creates an internal uncontrolled store.
+ * @returns Teardown function that removes the event listeners.
+ */
+export function initComarkRuntime(root?: Element | null, model?: ComarkModel): () => void {
+  const target = root ?? (typeof document !== 'undefined' ? document.body : null)
+  if (!target) return () => {}
+
+  const el = target
+  const store: ComarkModel = model ?? createModelStore()
+
+  function updateBindNodes(path: string, value: unknown): void {
+    const escaped = path.replace(/\\/g, '\\\\').replace(/"/g, '\\"')
+    const nodes = el.querySelectorAll(`[${BIND_ATTR}="${escaped}"]`)
+    const text = value == null ? '' : String(value)
+    nodes.forEach((node) => {
+      node.textContent = text
+    })
+  }
+
+  function handleEvent(e: Event): void {
+    const targetEl = e.target as HTMLElement | null
+    if (!targetEl) return
+
+    for (const attr of Array.from(targetEl.attributes)) {
+      if (!attr.name.startsWith(MODEL_ATTR_PREFIX)) continue
+      const prop = attr.name.slice(MODEL_ATTR_PREFIX.length)
+      const path = attr.value
+      if (!path) continue
+
+      const value = getCoercedValue(targetEl, prop)
+      if (store.set(path, value)) {
+        updateBindNodes(path, value)
+      }
+    }
+  }
+
+  el.addEventListener('input', handleEvent)
+  el.addEventListener('change', handleEvent)
+
+  return () => {
+    el.removeEventListener('input', handleEvent)
+    el.removeEventListener('change', handleEvent)
+  }
+}
diff --git a/packages/comark-html/test/plugin-binding.test.ts b/packages/comark-html/test/plugin-binding.test.ts
index 9278cc8a..3e03c587 100644
--- a/packages/comark-html/test/plugin-binding.test.ts
+++ b/packages/comark-html/test/plugin-binding.test.ts
@@ -26,13 +26,16 @@ Hello {{ frontmatter.user.name }}!
       components: { binding: Binding },
       data: { score: 42 },
     })
-    expect(html).toContain('Score: 42')
+    expect(html).toContain('Score:')
+    expect(html).toContain('42')
+    expect(html).toContain('data-comark-bind="data.score"')
   })
 
   it('falls back to `|| default` when the path does not resolve', async () => {
     const doc = await parseWithBinding('Hello {{ data.missing || guest }}!')
     const html = await renderHtmlFromDocument(doc, { components: { binding: Binding } })
-    expect(html).toContain('Hello guest!')
+    expect(html).toContain('guest')
+    expect(html).toContain('data-comark-bind="data.missing"')
   })
 
   it('renders empty output when path is unresolved and no default is provided', async () => {
diff --git a/packages/comark-html/test/runtime.test.ts b/packages/comark-html/test/runtime.test.ts
new file mode 100644
index 00000000..a0945f51
--- /dev/null
+++ b/packages/comark-html/test/runtime.test.ts
@@ -0,0 +1,110 @@
+// @vitest-environment jsdom
+import { describe, it, expect, beforeEach, afterEach } from 'vitest'
+import { renderHtml } from '../src/index'
+import { initComarkRuntime } from '../src/runtime'
+
+describe('initComarkRuntime', () => {
+  let root: HTMLElement
+  let teardown: (() => void) | undefined
+
+  beforeEach(() => {
+    root = document.createElement('div')
+    document.body.appendChild(root)
+  })
+
+  afterEach(() => {
+    teardown?.()
+    root.remove()
+  })
+
+  it('updates [data-comark-bind] text nodes on input event', async () => {
+    // SSR markers are emitted by resolveAttributes in non-parseJson mode
+    root.innerHTML = [
+      '<input data-comark-model-value="data.name" value="Alice" />',
+      '<span data-comark-bind="data.name">Alice</span>',
+    ].join('')
+
+    teardown = initComarkRuntime(root)
+
+    const input = root.querySelector('input') as HTMLInputElement
+    input.value = 'Bob'
+    input.dispatchEvent(new Event('input', { bubbles: true }))
+
+    expect(root.querySelector('span')?.textContent).toBe('Bob')
+  })
+
+  it('updates on change event', async () => {
+    root.innerHTML = [
+      '<input type="checkbox" data-comark-model-checked="data.done" />',
+      '<span data-comark-bind="data.done"></span>',
+    ].join('')
+
+    teardown = initComarkRuntime(root)
+
+    const input = root.querySelector('input') as HTMLInputElement
+    input.checked = true
+    input.dispatchEvent(new Event('change', { bubbles: true }))
+
+    expect(root.querySelector('span')?.textContent).toBe('true')
+  })
+
+  it('updates [data-comark-bind] for number input', async () => {
+    root.innerHTML = [
+      '<input type="number" data-comark-model-value="data.count" value="0" />',
+      '<span data-comark-bind="data.count">0</span>',
+    ].join('')
+
+    teardown = initComarkRuntime(root)
+
+    const input = root.querySelector('input') as HTMLInputElement
+    input.value = '42'
+    input.dispatchEvent(new Event('input', { bubbles: true }))
+
+    expect(root.querySelector('span')?.textContent).toBe('42')
+  })
+
+  it('cleans up listeners on teardown', async () => {
+    root.innerHTML = [
+      '<input data-comark-model-value="data.x" value="initial" />',
+      '<span data-comark-bind="data.x">initial</span>',
+    ].join('')
+
+    teardown = initComarkRuntime(root)
+    teardown()
+    teardown = undefined
+
+    const input = root.querySelector('input') as HTMLInputElement
+    input.value = 'changed'
+    input.dispatchEvent(new Event('input', { bubbles: true }))
+
+    // Should NOT have updated since teardown was called
+    expect(root.querySelector('span')?.textContent).toBe('initial')
+  })
+
+  it('handles no root gracefully', () => {
+    const result = initComarkRuntime(null)
+    expect(typeof result).toBe('function')
+    result()
+  })
+})
+
+describe('HTML SSR markers', () => {
+  it('emits data-comark-model-value marker for ::value bindings', async () => {
+    const html = await renderHtml(':input{::value="data.name" type="text"}', {
+      data: { name: 'initial' },
+    })
+    expect(html).toContain('data-comark-model-value="data.name"')
+    expect(html).toContain('value="initial"')
+  })
+
+  it('markers are inert without the runtime (no JS side effects)', async () => {
+    const html = await renderHtml(':input{::value="data.count" type="number"}', {
+      data: { count: 5 },
+    })
+    // Markers present
+    expect(html).toContain('data-comark-model-value="data.count"')
+    // No runtime-only attributes
+    expect(html).not.toContain('oninput')
+    expect(html).not.toContain('onchange')
+  })
+})
diff --git a/packages/comark-react/src/components/Form.tsx b/packages/comark-react/src/components/Form.tsx
new file mode 100644
index 00000000..463277bf
--- /dev/null
+++ b/packages/comark-react/src/components/Form.tsx
@@ -0,0 +1,37 @@
+import type React from 'react'
+
+interface FormProps {
+  /** Current aggregated form value — supplied by the renderer from the model. */
+  value?: Record<string, unknown>
+  /** @internal Comark renderer writes back via this when the form submits. */
+  onUpdateValue?: (aggregate: Record<string, unknown>) => void
+  children?: React.ReactNode
+}
+
+/**
+ * `::form` aggregate component.
+ *
+ * Wraps its children in a `<form>` element.  On submit, collects native
+ * `FormData` from the form and writes the aggregated field values to the
+ * model path bound to `::value` via the auto-generated `onUpdateValue`
+ * handler that the Comark renderer emits.
+ *
+ * @example
+ * ```md
+ * ::form{::value="data.contact"}
+ *   :input{::value="data.name" name="name" type="text"}
+ *   :input{::value="data.email" name="email" type="email"}
+ *   :button{type="submit"} Submit ::
+ * ::
+ * ```
+ */
+export function Form({ onUpdateValue, children }: FormProps): React.ReactNode {
+  function handleSubmit(e: React.FormEvent<HTMLFormElement>): void {
+    e.preventDefault()
+    const fd = new FormData(e.currentTarget)
+    const aggregate = Object.fromEntries(fd.entries()) as Record<string, unknown>
+    onUpdateValue?.(aggregate)
+  }
+
+  return <form onSubmit={handleSubmit}>{children}</form>
+}
diff --git a/packages/comark-react/src/components/Markdown.tsx b/packages/comark-react/src/components/Markdown.tsx
index aecbd5fd..55721981 100644
--- a/packages/comark-react/src/components/Markdown.tsx
+++ b/packages/comark-react/src/components/Markdown.tsx
@@ -2,6 +2,7 @@ import React from 'react'
 import { parseMarkdown } from 'comark'
 import type { MarkdownDocument as MarkdownDocumentType, ParserOptions } from 'comark'
 import { isMarkdownDocument } from 'comark/utils'
+import type { ComarkModel } from 'comark/model'
 import { MarkdownDocument } from './MarkdownDocument.tsx'
 import { MarkdownClient } from './MarkdownClient.tsx'
 
@@ -65,6 +66,17 @@ export interface MarkdownProps {
    */
   data?: Record<string, unknown>
 
+  /**
+   * Two-way data binding model. When provided, `::prop="path"` attributes are
+   * resolved against the model and update handlers are wired automatically.
+   */
+  model?: ComarkModel
+
+  /**
+   * Called after every write accepted by the model.
+   */
+  onModelChange?: (path: string, value: unknown, snapshot: Record<string, unknown>) => void
+
   /**
    * Additional className for the wrapper div
    */
@@ -113,6 +125,8 @@ export async function Markdown({
   streaming = false,
   caret = false,
   data,
+  model,
+  onModelChange,
   className,
 }: MarkdownProps) {
   // Pre-parsed document — skip parsing and render directly
@@ -126,6 +140,8 @@ export async function Markdown({
         className={className}
         caret={caret}
         data={data}
+        model={model}
+        onModelChange={onModelChange}
       />
     )
   }
@@ -146,6 +162,8 @@ export async function Markdown({
         streaming={streaming}
         caret={caret}
         data={data}
+        model={model}
+        onModelChange={onModelChange}
         className={className}
       />
     )
@@ -162,6 +180,8 @@ export async function Markdown({
       className={className}
       caret={caret}
       data={data}
+      model={model}
+      onModelChange={onModelChange}
     />
   )
 }
diff --git a/packages/comark-react/src/components/MarkdownClient.tsx b/packages/comark-react/src/components/MarkdownClient.tsx
index f3d4a9ad..d8374439 100644
--- a/packages/comark-react/src/components/MarkdownClient.tsx
+++ b/packages/comark-react/src/components/MarkdownClient.tsx
@@ -18,6 +18,8 @@ function MarkdownContent({
   streaming = false,
   caret = false,
   data,
+  model,
+  onModelChange,
   className,
 }: MarkdownContentProps) {
   const parsed = use(parsePromise)
@@ -31,6 +33,8 @@ function MarkdownContent({
       className={className}
       caret={caret}
       data={data}
+      model={model}
+      onModelChange={onModelChange}
     />
   )
 }
diff --git a/packages/comark-react/src/components/MarkdownDocument.tsx b/packages/comark-react/src/components/MarkdownDocument.tsx
index eced24f3..d908d12b 100644
--- a/packages/comark-react/src/components/MarkdownDocument.tsx
+++ b/packages/comark-react/src/components/MarkdownDocument.tsx
@@ -5,8 +5,10 @@ import type {
   ComponentManifest,
   NodeRenderData,
 } from 'comark'
-import React, { lazy, Suspense, useMemo } from 'react'
-import { pascalCase, camelCase, resolveAttributes } from 'comark/utils'
+import React, { lazy, Suspense, useMemo, useSyncExternalStore, useRef } from 'react'
+import { pascalCase, camelCase, resolveAttributes, resolveModelElement, modelElementDisplayValue } from 'comark/utils'
+import type { ComarkModel } from 'comark/model'
+import { createModelStore } from 'comark/model'
 import { findLastTextNodeAndAppendNode, getCaret } from '../utils/caret.ts'
 
 /**
@@ -108,7 +110,8 @@ function renderNode(
   key?: string | number,
   componentsManifest?: ComponentManifest,
   parent?: Node,
-  renderData: NodeRenderData = { frontmatter: {}, meta: {}, data: {}, props: {} }
+  renderData: NodeRenderData = { frontmatter: {}, meta: {}, data: {}, props: {} },
+  model?: ComarkModel
 ): React.ReactNode {
   // Handle text nodes (strings)
   if (typeof node === 'string') {
@@ -137,10 +140,10 @@ function renderNode(
 
     const Component = customComponent || tag
 
-    // Resolve `:prefix` bindings, then apply React-specific attribute
-    // remapping (`class` → `className`, string `style` → object, `tabindex`
-    // → `tabIndex`).
-    const resolved = resolveAttributes(nodeProps, renderData, { parseJson: true })
+    // Resolve `:prefix` bindings and `::prefix` two-way bindings, then apply
+    // React-specific attribute remapping (`class` → `className`, string
+    // `style` → object, `tabindex` → `tabIndex`, `onUpdate:X` → `onUpdateX`).
+    const resolved = resolveAttributes(nodeProps, renderData, { parseJson: true, model })
     const props: Record<string, any> = {}
     for (const k in resolved) {
       const v = resolved[k]
@@ -150,11 +153,35 @@ function renderNode(
         props.style = cssStringToObject(v)
       } else if (k === 'tabindex') {
         props.tabIndex = v
+      } else if (k.startsWith('onUpdate:') && model) {
+        // `onUpdate:prop` → `onUpdateProp` for React props.
+        // For native form elements we wire via resolveModelElement below;
+        // custom components receive the camelCased handler directly.
+        const propName = k.slice('onUpdate:'.length)
+        const camelHandler = `onUpdate${propName.charAt(0).toUpperCase()}${propName.slice(1)}`
+        props[camelHandler] = v
       } else {
         props[k] = v
       }
     }
 
+    // For native form elements with model bindings, replace the generic
+    // update handler with the element-specific event listener and coercion.
+    if (model && !customComponent && typeof tag === 'string') {
+      for (const rawKey in nodeProps) {
+        if (!rawKey.startsWith('::')) continue
+        const modelProp = rawKey.slice(2)
+        const binding = resolveModelElement(tag, modelProp, nodeProps)
+        if (!binding) continue
+        const path = nodeProps[rawKey] as string
+        const genericHandler = `onUpdate${modelProp.charAt(0).toUpperCase()}${modelProp.slice(1)}`
+        delete props[genericHandler]
+        const eventProp = `on${binding.event.charAt(0).toUpperCase()}${binding.event.slice(1)}`
+        props[eventProp] = (e: React.SyntheticEvent) => model.set(path, binding.coerce(e.target as any))
+        props[binding.prop] = modelElementDisplayValue(binding, model.get(path), nodeProps)
+      }
+    }
+
     if (typeof Component !== 'string' && (Component as any)?.propTypes?.__node !== undefined) {
       props.__node = node
     }
@@ -207,14 +234,14 @@ function renderNode(
           const slotChildren = getChildren(child)
           slots[slotName] = slotChildren
             .map((slotChild: Node, idx: number) =>
-              renderNode(slotChild, components, idx, componentsManifest, node, childrenRenderData)
+              renderNode(slotChild, components, idx, componentsManifest, node, childrenRenderData, model)
             )
             .filter((slotChild): slotChild is React.ReactNode => slotChild !== null)
           continue
         }
       }
 
-      const rendered = renderNode(child, components, i, componentsManifest, node, childrenRenderData)
+      const rendered = renderNode(child, components, i, componentsManifest, node, childrenRenderData, model)
       if (rendered !== null) {
         regularChildren.push(rendered)
       }
@@ -301,6 +328,20 @@ export interface MarkdownDocumentProps {
    */
   data?: Record<string, unknown>
 
+  /**
+   * Two-way data binding model. When provided, `::prop="path"` attributes are
+   * resolved against the model and update handlers are wired automatically.
+   * When omitted the renderer creates an internal uncontrolled store from
+   * `data` (controlled mode requires passing your own model).
+   */
+  model?: ComarkModel
+
+  /**
+   * Called after every write accepted by the model. Use this to observe
+   * changes in controlled mode without subscribing to the model manually.
+   */
+  onModelChange?: (path: string, value: unknown, snapshot: Record<string, unknown>) => void
+
   /**
    * Additional className for the wrapper div
    */
@@ -328,6 +369,30 @@ export interface MarkdownDocumentProps {
  * }
  * ```
  */
+/**
+ * A React component that subscribes to a model path and re-renders when the
+ * value changes. Uses `useSyncExternalStore` for concurrent-mode safety.
+ */
+function ModelBoundary({
+  model,
+  children,
+}: {
+  model: ComarkModel
+  children: (version: number) => React.ReactNode
+}): React.ReactNode {
+  const versionRef = useRef(0)
+  const version = useSyncExternalStore(
+    (onStoreChange) =>
+      model.subscribe('data', () => {
+        versionRef.current += 1
+        onStoreChange()
+      }),
+    () => versionRef.current,
+    () => 0
+  )
+  return children(version)
+}
+
 export const MarkdownDocument: React.FC<MarkdownDocumentProps> = ({
   value,
   components: customComponents = {},
@@ -335,14 +400,28 @@ export const MarkdownDocument: React.FC<MarkdownDocumentProps> = ({
   streaming = false,
   caret: caretProp = false,
   data,
+  model: modelProp,
+  onModelChange,
   className,
 }) => {
   const document = value ?? { nodes: [] }
 
+  // Uncontrolled mode: create a private model store from `data`.
+  const internalModelRef = useRef<ComarkModel | null>(null)
+  if (!modelProp && !internalModelRef.current) {
+    internalModelRef.current = createModelStore({
+      data: { data: data ?? {} },
+      onChange: onModelChange,
+    })
+  }
+  const model = modelProp ?? internalModelRef.current ?? undefined
+
   const caret = useMemo(() => getCaret(caretProp), [caretProp])
 
-  const renderedNodes = useMemo(() => {
-    // Render all nodes from the document value
+  const renderContent = (modelVersion?: number) => {
+    // modelVersion used only to trigger re-render when the model updates.
+    void modelVersion
+
     const nodes = [...(document.nodes || [])]
 
     if (streaming && caret && nodes.length > 0) {
@@ -360,13 +439,19 @@ export const MarkdownDocument: React.FC<MarkdownDocumentProps> = ({
       meta: (document as MarkdownDocumentType).meta || {},
       data: data || {},
       props: {},
+      model,
     }
 
-    return nodes
-      .map((node, index) => renderNode(node, customComponents, index, componentsManifest, undefined, renderData))
+    const renderedNodes = nodes
+      .map((node, index) => renderNode(node, customComponents, index, componentsManifest, undefined, renderData, model))
       .filter((child): child is React.ReactNode => child !== null)
-  }, [document, customComponents, componentsManifest, streaming, caret, data])
 
-  // Wrap in a fragment
-  return <div className={`comark-content ${className || ''}`}>{renderedNodes}</div>
+    return <div className={`comark-content ${className || ''}`}>{renderedNodes}</div>
+  }
+
+  if (model) {
+    return <ModelBoundary model={model}>{(version) => renderContent(version)}</ModelBoundary>
+  }
+
+  return renderContent()
 }
diff --git a/packages/comark-react/src/plugins/form.ts b/packages/comark-react/src/plugins/form.ts
new file mode 100644
index 00000000..243aa97d
--- /dev/null
+++ b/packages/comark-react/src/plugins/form.ts
@@ -0,0 +1,3 @@
+export * from 'comark/plugins/form'
+
+export { Form } from '../components/Form.tsx'
diff --git a/packages/comark-react/test/form.test.tsx b/packages/comark-react/test/form.test.tsx
new file mode 100644
index 00000000..93483a7e
--- /dev/null
+++ b/packages/comark-react/test/form.test.tsx
@@ -0,0 +1,43 @@
+import { describe, expect, it } from 'vitest'
+import React from 'react'
+import { renderToString } from 'react-dom/server'
+import { parseMarkdown } from 'comark'
+import { createModelStore } from 'comark/model'
+import { MarkdownDocument } from '../src/components/MarkdownDocument'
+import { Form } from '../src/components/Form'
+
+async function render(markdown: string, props: Record<string, any> = {}) {
+  const doc = await parseMarkdown(markdown)
+  return renderToString(
+    <MarkdownDocument
+      value={doc}
+      components={{ form: Form }}
+      {...props}
+    />
+  )
+}
+
+describe('React Form component — SSR', () => {
+  it('renders a <form> element wrapping its children', async () => {
+    const html = await render('::form{::value="data.contact"}\n  Hello\n::')
+    expect(html).toContain('<form')
+    expect(html).toContain('Hello')
+  })
+
+  it('resolves the ::value binding from the model', async () => {
+    const model = createModelStore({ data: { data: { contact: { name: 'Alice' } } } })
+    const html = await render('::form{::value="data.contact"}\n  content\n::', { model })
+    expect(html).toContain('<form')
+    expect(html).toContain('content')
+  })
+
+  it('passes through child input bindings', async () => {
+    const model = createModelStore({ data: { data: { name: 'Bob' } } })
+    const html = await render(
+      '::form{::value="data.contact"}\n  :input{::value="data.name" name="name" type="text"}\n::',
+      { model }
+    )
+    expect(html).toContain('<form')
+    expect(html).toContain('Bob')
+  })
+})
diff --git a/packages/comark-react/test/model-binding.test.tsx b/packages/comark-react/test/model-binding.test.tsx
new file mode 100644
index 00000000..bb0a218d
--- /dev/null
+++ b/packages/comark-react/test/model-binding.test.tsx
@@ -0,0 +1,76 @@
+import { describe, expect, it, vi } from 'vitest'
+import React from 'react'
+import { renderToString } from 'react-dom/server'
+import { parseMarkdown } from 'comark'
+import { createModelStore } from 'comark/model'
+import { MarkdownDocument } from '../src/components/MarkdownDocument'
+
+async function render(markdown: string, props: Record<string, any> = {}) {
+  const doc = await parseMarkdown(markdown)
+  return renderToString(
+    <MarkdownDocument
+      value={doc}
+      {...props}
+    />
+  )
+}
+
+describe('React model binding — SSR snapshot', () => {
+  it('resolves ::value="data.name" from the model in preserve/SSR mode', async () => {
+    const model = createModelStore({ data: { data: { name: 'Alice' } } })
+    const html = await render(':input{::value="data.name" type="text"}', { model })
+    expect(html).toContain('Alice')
+  })
+
+  it('emits data-comark-model-value when no model is provided (HTML markers)', async () => {
+    // When no model is passed an uncontrolled store is created internally.
+    // In SSR, the marker attributes appear in the output.
+    const doc = await parseMarkdown(':input{::value="data.name" type="text"}')
+    const html = renderToString(
+      <MarkdownDocument
+        value={doc}
+        data={{ name: 'Bob' }}
+      />
+    )
+    // The resolved value should be present.
+    expect(html).toContain('Bob')
+  })
+
+  it('controlled mode: onModelChange is called after a write', async () => {
+    const onChange = vi.fn()
+    const model = createModelStore({
+      data: { data: { count: 0 } },
+      onChange,
+    })
+    model.set('data.count', 42)
+    expect(onChange).toHaveBeenCalledWith('data.count', 42, expect.objectContaining({ data: { count: 42 } }))
+  })
+
+  it('emits custom onUpdateX handler for non-native components', async () => {
+    const model = createModelStore({ data: { data: { title: 'Hello' } } })
+    const html = await render('::card{::title="data.title"}\ncontent\n::', { model })
+    // The card component receives title='Hello' in SSR.
+    expect(html).toContain('Hello')
+  })
+
+  it('unsafe URL is blocked for ::href', async () => {
+    const model = createModelStore({ data: { data: { url: 'javascript:alert(1)' } } })
+    const html = await render(':a{::href="data.url" text="click"}', { model })
+    expect(html).not.toContain('javascript:')
+  })
+})
+
+describe('React model binding — coercion matrix', () => {
+  it('number input resolves value as-is from model', async () => {
+    const model = createModelStore({ data: { data: { count: 5 } } })
+    const html = await render(':input{::value="data.count" type="number"}', { model })
+    expect(html).toContain('5')
+  })
+
+  it('checkbox resolves checked from model', async () => {
+    const model = createModelStore({ data: { data: { active: true } } })
+    const html = await render(':input{::checked="data.active" type="checkbox"}', { model })
+    // Boolean checked attribute renders as checked="" in HTML
+    expect(html).toContain('checked')
+  })
+})
diff --git a/packages/comark-svelte/src/components/ComarkComponent.svelte b/packages/comark-svelte/src/components/ComarkComponent.svelte
index 07fb170d..d84ea3b9 100644
--- a/packages/comark-svelte/src/components/ComarkComponent.svelte
+++ b/packages/comark-svelte/src/components/ComarkComponent.svelte
@@ -1,5 +1,6 @@
 <script lang="ts">
   import type { Node as NodeType, ComponentManifest, NodeRenderData } from 'comark'
+  import type { ComarkModel } from 'comark/model'
   import type { Snippet } from 'svelte'
   import type { ComponentResolver } from '../types.js'
   import MarkdownNode from './MarkdownNode.svelte'
@@ -24,6 +25,7 @@
     componentsManifest,
     resolver: Resolver = Resolve,
     renderData = EMPTY_RENDER_DATA,
+    model,
     children,
   }: {
     Component?: any
@@ -35,6 +37,7 @@
     componentsManifest?: ComponentManifest
     resolver?: ComponentResolver
     renderData?: NodeRenderData
+    model?: ComarkModel
     children?: Snippet
   } = $props()
 </script>
@@ -50,6 +53,7 @@
         resolver={Resolver}
         caretClass={i === slot.children.length - 1 ? slot.caretClass : null}
         {renderData}
+        {model}
       />
     {/each}
   {/snippet}
@@ -64,6 +68,7 @@
     {componentsManifest}
     resolver={Resolver}
     {renderData}
+    {model}
   >
     {@render children?.()}
   </ComarkComponent>
diff --git a/packages/comark-svelte/src/components/Form.svelte b/packages/comark-svelte/src/components/Form.svelte
new file mode 100644
index 00000000..ce184067
--- /dev/null
+++ b/packages/comark-svelte/src/components/Form.svelte
@@ -0,0 +1,33 @@
+<!--
+@component
+`::form` aggregate component.
+
+Wraps its children in a `<form>` element.  On submit, collects native
+`FormData` from the form and writes the aggregated field values to the
+model path bound to `::value` via the auto-generated `onUpdateValue`
+handler that the Comark renderer emits.
+-->
+<script lang="ts">
+  import type { Snippet } from 'svelte'
+
+  let {
+    value,
+    onUpdateValue,
+    children,
+  }: {
+    value?: Record<string, unknown>
+    onUpdateValue?: (aggregate: Record<string, unknown>) => void
+    children?: Snippet
+  } = $props()
+
+  function handleSubmit(e: SubmitEvent): void {
+    e.preventDefault()
+    const fd = new FormData(e.currentTarget as HTMLFormElement)
+    const aggregate = Object.fromEntries(fd.entries()) as Record<string, unknown>
+    onUpdateValue?.(aggregate)
+  }
+</script>
+
+<form onsubmit={handleSubmit}>
+  {@render children?.()}
+</form>
diff --git a/packages/comark-svelte/src/components/Markdown.svelte b/packages/comark-svelte/src/components/Markdown.svelte
index fdcffadf..27fb398c 100644
--- a/packages/comark-svelte/src/components/Markdown.svelte
+++ b/packages/comark-svelte/src/components/Markdown.svelte
@@ -25,6 +25,7 @@ This is an alert component
 -->
 <script lang="ts">
   import type { MarkdownDocument as MarkdownDocumentType, ComarkPlugin, ComponentManifest } from 'comark'
+  import type { ComarkModel } from 'comark/model'
   import { parseMarkdown } from 'comark'
   import { isMarkdownDocument } from 'comark/utils'
   import MarkdownDocument from './MarkdownDocument.svelte'
@@ -39,6 +40,8 @@ This is an alert component
     streaming = false,
     caret = false,
     data,
+    model,
+    onModelChange,
     class: className = '',
   }: {
     value?: string | MarkdownDocumentType
@@ -50,6 +53,8 @@ This is an alert component
     streaming?: boolean
     caret?: boolean | { class: string }
     data?: Record<string, unknown>
+    model?: ComarkModel
+    onModelChange?: (path: string, value: unknown, snapshot: Record<string, unknown>) => void
     class?: string
   } = $props()
 
@@ -82,6 +87,8 @@ This is an alert component
     {streaming}
     {caret}
     {data}
+    {model}
+    {onModelChange}
     class={className}
   />
 {:else if parsed}
@@ -92,6 +99,8 @@ This is an alert component
     {streaming}
     {caret}
     {data}
+    {model}
+    {onModelChange}
     class={className}
   />
 {/if}
diff --git a/packages/comark-svelte/src/components/MarkdownDocument.svelte b/packages/comark-svelte/src/components/MarkdownDocument.svelte
index 8f235486..48b40bf5 100644
--- a/packages/comark-svelte/src/components/MarkdownDocument.svelte
+++ b/packages/comark-svelte/src/components/MarkdownDocument.svelte
@@ -21,6 +21,8 @@ Supports custom component mappings and a streaming caret indicator.
 <script lang="ts">
   import { untrack } from 'svelte'
   import type { MarkdownDocument as MarkdownDocumentType, ComponentManifest } from 'comark'
+  import type { ComarkModel } from 'comark/model'
+  import { createModelStore } from 'comark/model'
   import type { ComponentResolver } from '../types.js'
   import MarkdownNode from './MarkdownNode.svelte'
 
@@ -32,6 +34,8 @@ Supports custom component mappings and a streaming caret indicator.
     streaming = false,
     caret: caretProp = false,
     data,
+    model: modelProp,
+    onModelChange,
     class: className = '',
     documentKey,
   }: {
@@ -42,6 +46,8 @@ Supports custom component mappings and a streaming caret indicator.
     streaming?: boolean
     caret?: boolean | { class: string }
     data?: Record<string, unknown>
+    model?: ComarkModel
+    onModelChange?: (path: string, value: unknown, snapshot: Record<string, unknown>) => void
     class?: string
     documentKey?: string
   } = $props()
@@ -68,14 +74,30 @@ Supports custom component mappings and a streaming caret indicator.
       : null,
   )
 
-  let renderData = $derived({
-    frontmatter:
-      (activeDocument as MarkdownDocumentType).frontmatter ||
-      (activeDocument as unknown as { data: Record<string, unknown> }).data ||
-      {},
-    meta: (activeDocument as MarkdownDocumentType).meta || {},
-    data: data || {},
-    props: {},
+  // Model boundary: create an uncontrolled store if no model is provided.
+  // A $state cell is bumped on every write to trigger Svelte reactivity.
+  const fallbackStore = createModelStore({
+    data: { data: { ...(untrack(() => data) ?? {}) } },
+    onChange: (path, value, snapshot) => onModelChange?.(path, value, snapshot),
+  })
+  let internalModel = $derived(modelProp ?? fallbackStore)
+  let modelVersion = $state(0)
+  $effect(() => {
+    return internalModel.subscribe('data', () => { modelVersion++ })
+  })
+
+  let renderData = $derived.by(() => {
+    void modelVersion
+    return {
+      frontmatter:
+        (activeDocument as MarkdownDocumentType).frontmatter ||
+        (activeDocument as unknown as { data: Record<string, unknown> }).data ||
+        {},
+      meta: (activeDocument as MarkdownDocumentType).meta || {},
+      data: data || {},
+      props: {},
+      model: internalModel,
+    }
   })
 </script>
 
@@ -88,6 +110,7 @@ Supports custom component mappings and a streaming caret indicator.
       {resolver}
       caretClass={i === activeDocument.nodes.length - 1 ? caretClass : null}
       {renderData}
+      model={internalModel}
     />
   {/each}
 </div>
diff --git a/packages/comark-svelte/src/components/MarkdownNode.svelte b/packages/comark-svelte/src/components/MarkdownNode.svelte
index dc9db091..6e5c26e6 100644
--- a/packages/comark-svelte/src/components/MarkdownNode.svelte
+++ b/packages/comark-svelte/src/components/MarkdownNode.svelte
@@ -68,11 +68,12 @@ naturally appears inline after the deepest trailing text node.
 
 <script lang="ts">
   import type { Node as NodeType, ComponentManifest, NodeRenderData } from 'comark'
+  import type { ComarkModel } from 'comark/model'
   import type { ComponentResolver } from '../types.js'
   import MarkdownNode from './MarkdownNode.svelte'
   import ComarkComponent from './ComarkComponent.svelte'
   import Resolve from './Resolve.svelte'
-  import { resolveAttributes } from 'comark/utils'
+  import { resolveAttributes, resolveModelElement, modelElementDisplayValue } from 'comark/utils'
 
   const EMPTY_RENDER_DATA: NodeRenderData = { frontmatter: {}, meta: {}, data: {}, props: {} }
 
@@ -83,6 +84,7 @@ naturally appears inline after the deepest trailing text node.
     resolver: Resolver = Resolve,
     caretClass = null,
     renderData = EMPTY_RENDER_DATA,
+    model,
   }: {
     node: NodeType
     components?: Record<string, any>
@@ -90,6 +92,7 @@ naturally appears inline after the deepest trailing text node.
     resolver?: ComponentResolver
     caretClass?: string | null
     renderData?: NodeRenderData
+    model?: ComarkModel
   } = $props()
 
   const CARET_TEXT = '\u2009'
@@ -179,18 +182,38 @@ naturally appears inline after the deepest trailing text node.
       Component = resolvedComponent
     }
 
-    // Resolve `:prefix` bindings, then apply Svelte attribute remapping
-    // (`className` → `class`).
-    const resolved = resolveAttributes(nodeProps, renderData, { parseJson: true })
+    // Resolve `:prefix` bindings and `::prefix` two-way bindings.
+    const resolved = resolveAttributes(nodeProps, renderData, { parseJson: true, model })
     for (const k in resolved) {
       if (k === 'className') {
         mappedProps.class = resolved[k]
       }
+      else if (k.startsWith('onUpdate:')) {
+        const propName = k.slice('onUpdate:'.length)
+        mappedProps[`onUpdate${propName.charAt(0).toUpperCase()}${propName.slice(1)}`] = resolved[k]
+      }
       else {
         mappedProps[k] = resolved[k]
       }
     }
 
+    // For native form elements with model bindings, replace generic onUpdate:*
+    // handlers with element-specific oninput/onchange + coercion.
+    if (model && tag && !Component && !componentPromise) {
+      for (const rawKey in nodeProps) {
+        if (!rawKey.startsWith('::')) continue
+        const modelProp = rawKey.slice(2)
+        const binding = resolveModelElement(tag, modelProp, nodeProps)
+        if (!binding) continue
+        const path = nodeProps[rawKey] as string
+        delete mappedProps[`onUpdate:${modelProp}`]
+        delete mappedProps[`onUpdate${modelProp.charAt(0).toUpperCase()}${modelProp.slice(1)}`]
+        mappedProps[`on${binding.event}`] = (e: Event) =>
+          model!.set(path, binding.coerce(e.target as any))
+        mappedProps[binding.prop] = modelElementDisplayValue(binding, model.get(path), nodeProps)
+      }
+    }
+
     return { isText, tag, isVoid, children, Component, componentPromise, mappedProps }
   })
 
@@ -241,6 +264,7 @@ naturally appears inline after the deepest trailing text node.
       resolver={Resolver}
       caretClass={child.caretClass}
       renderData={childrenRenderData}
+      {model}
     />
   {/each}
 {/snippet}
@@ -259,6 +283,7 @@ naturally appears inline after the deepest trailing text node.
     {componentsManifest}
     resolver={Resolver}
     renderData={childrenRenderData}
+    {model}
   >
     {@render renderChildren()}
   </ComarkComponent>
@@ -275,6 +300,7 @@ naturally appears inline after the deepest trailing text node.
     {componentsManifest}
     resolver={Resolver}
     renderData={childrenRenderData}
+    {model}
   >
     {@render renderChildren()}
   </ComarkComponent>
diff --git a/packages/comark-svelte/src/plugins/form.ts b/packages/comark-svelte/src/plugins/form.ts
new file mode 100644
index 00000000..8ae23d09
--- /dev/null
+++ b/packages/comark-svelte/src/plugins/form.ts
@@ -0,0 +1,3 @@
+export * from 'comark/plugins/form'
+
+export { default as Form } from '../components/Form.svelte'
diff --git a/packages/comark-svelte/test/model-binding.test.ts b/packages/comark-svelte/test/model-binding.test.ts
new file mode 100644
index 00000000..a7cf03c4
--- /dev/null
+++ b/packages/comark-svelte/test/model-binding.test.ts
@@ -0,0 +1,62 @@
+import { describe, expect, it, vi } from 'vitest'
+import { render } from 'svelte/server'
+import { parseMarkdown } from 'comark'
+import { createModelStore } from 'comark/model'
+import MarkdownDocument from '../src/components/MarkdownDocument.svelte'
+
+/** Strip Svelte SSR hydration comments from rendered HTML */
+function html(body: string): string {
+  return body.replace(/<!--[[\]\-\d!]*-->/g, '').replace(/<!---->/g, '')
+}
+
+async function renderDoc(markdown: string, props: Record<string, any> = {}) {
+  const doc = await parseMarkdown(markdown)
+  return html(render(MarkdownDocument, { props: { value: doc, ...props } }).body)
+}
+
+describe('Svelte model binding — SSR snapshot', () => {
+  it('resolves ::value="data.name" from the model', async () => {
+    const model = createModelStore({ data: { data: { name: 'Alice' } } })
+    const out = await renderDoc(':input{::value="data.name" type="text"}', { model })
+    expect(out).toContain('Alice')
+  })
+
+  it('emits controlled value when no model provided (uses data prop)', async () => {
+    const out = await renderDoc(':input{::value="data.name" type="text"}', { data: { name: 'Bob' } })
+    expect(out).toContain('Bob')
+  })
+
+  it('controlled mode: onModelChange fires on write', async () => {
+    const onChange = vi.fn()
+    const model = createModelStore({ data: { data: { x: 0 } }, onChange })
+    model.set('data.x', 7)
+    expect(onChange).toHaveBeenCalledWith('data.x', 7, expect.anything())
+  })
+
+  it('custom component receives title via ::title binding', async () => {
+    const model = createModelStore({ data: { data: { title: 'My Title' } } })
+    const out = await renderDoc('::card{::title="data.title"}\ncontent\n::', { model })
+    expect(out).toContain('My Title')
+  })
+
+  it('unsafe URL is blocked for ::href binding', async () => {
+    const model = createModelStore({ data: { data: { url: 'javascript:alert(1)' } } })
+    const out = await renderDoc(':a{::href="data.url"}', { model })
+    expect(out).not.toContain('javascript:')
+  })
+})
+
+describe('Svelte model binding — coercion matrix', () => {
+  it('number input resolves value from model', async () => {
+    const model = createModelStore({ data: { data: { count: 5 } } })
+    const out = await renderDoc(':input{::value="data.count" type="number"}', { model })
+    expect(out).toContain('5')
+  })
+
+  it('checkbox resolves checked from model', async () => {
+    const model = createModelStore({ data: { data: { active: true } } })
+    const out = await renderDoc(':input{::checked="data.active" type="checkbox"}', { model })
+    // Boolean checked attribute renders as checked="" in HTML
+    expect(out).toContain('checked')
+  })
+})
diff --git a/packages/comark-vue/src/components/Form.ts b/packages/comark-vue/src/components/Form.ts
new file mode 100644
index 00000000..0d3606af
--- /dev/null
+++ b/packages/comark-vue/src/components/Form.ts
@@ -0,0 +1,53 @@
+import { defineComponent, h, ref } from 'vue'
+
+/**
+ * `::form` aggregate component.
+ *
+ * Wraps its children in a `<form>` element.  On submit, collects native
+ * `FormData` from the form and writes the aggregated field values to the
+ * model path bound to `::value` via the auto-generated `onUpdate:value`
+ * handler that the Comark renderer emits.
+ *
+ * @example
+ * ```md
+ * ::form{::value="data.contact"}
+ *   :input{::value="data.name" name="name" type="text"}
+ *   :input{::value="data.email" name="email" type="email"}
+ *   :button{type="submit"} Submit ::
+ * ::
+ * ```
+ */
+export const Form = defineComponent({
+  name: 'Form',
+  props: {
+    /** Current aggregated form value — supplied by the renderer from the model. */
+    value: {
+      type: Object,
+      default: undefined,
+    },
+    /** @internal Comark renderer writes back via this when the form submits. */
+    'onUpdate:value': {
+      type: Function,
+      default: undefined,
+    },
+  },
+  setup(props, { slots }) {
+    const formRef = ref<HTMLFormElement | null>(null)
+
+    return () =>
+      h(
+        'form',
+        {
+          ref: formRef,
+          onSubmit: (e: Event) => {
+            e.preventDefault()
+            const formEl = formRef.value ?? (e.currentTarget as HTMLFormElement)
+            const fd = new FormData(formEl)
+            const aggregate = Object.fromEntries(fd.entries()) as Record<string, unknown>
+            props['onUpdate:value']?.(aggregate)
+          },
+        },
+        slots.default?.()
+      )
+  },
+})
diff --git a/packages/comark-vue/src/components/Markdown.ts b/packages/comark-vue/src/components/Markdown.ts
index 202c19e8..a632e27c 100644
--- a/packages/comark-vue/src/components/Markdown.ts
+++ b/packages/comark-vue/src/components/Markdown.ts
@@ -2,6 +2,7 @@ import type { PropType } from 'vue'
 import { computed, defineComponent, h, shallowRef, watch } from 'vue'
 import { createSerializedMarkdownParser } from 'comark'
 import type { ParserOptions, ComponentManifest, MarkdownDocument as MarkdownDocumentType } from 'comark'
+import type { ComarkModel } from 'comark/model'
 import { isMarkdownDocument } from 'comark/utils'
 import { MarkdownDocument } from './MarkdownDocument.ts'
 
@@ -62,6 +63,16 @@ export interface MarkdownProps {
    */
   data?: Record<string, unknown>
 
+  /**
+   * Two-way data binding model.
+   */
+  model?: ComarkModel
+
+  /**
+   * Called after every write accepted by the model.
+   */
+  onModelChange?: (path: string, value: unknown, snapshot: Record<string, unknown>) => void
+
   /**
    * Document key used to subscribe to live updates via `globalThis.comarkContext`
    */
@@ -163,6 +174,22 @@ export const markdownProps = {
     default: () => ({}),
   },
 
+  /**
+   * Two-way data binding model.
+   */
+  model: {
+    type: Object as PropType<import('comark/model').ComarkModel>,
+    default: undefined,
+  },
+
+  /**
+   * Called after every write accepted by the model.
+   */
+  onModelChange: {
+    type: Function as PropType<(path: string, value: unknown, snapshot: Record<string, unknown>) => void>,
+    default: undefined,
+  },
+
   /**
    * Document key used to subscribe to live updates via `globalThis.comarkContext`
    */
@@ -246,6 +273,11 @@ export const Markdown: MarkdownComponent = defineComponent({
     }
 
     return () => {
+      const modelProps = {
+        model: props.model,
+        onModelChange: props.onModelChange,
+      }
+
       // Pre-parsed document — skip parsing and render directly
       if (isMarkdownDocument(props.value)) {
         return h(MarkdownDocument, {
@@ -257,6 +289,7 @@ export const Markdown: MarkdownComponent = defineComponent({
           caret: props.caret,
           data: props.data,
           documentKey: props.documentKey,
+          ...modelProps,
         })
       }
 
@@ -270,6 +303,7 @@ export const Markdown: MarkdownComponent = defineComponent({
         caret: props.caret,
         data: props.data,
         documentKey: props.documentKey,
+        ...modelProps,
       })
     }
   },
diff --git a/packages/comark-vue/src/components/MarkdownDocument.ts b/packages/comark-vue/src/components/MarkdownDocument.ts
index 530870c3..ddb1942b 100644
--- a/packages/comark-vue/src/components/MarkdownDocument.ts
+++ b/packages/comark-vue/src/components/MarkdownDocument.ts
@@ -15,13 +15,16 @@ import {
   h,
   inject,
   onErrorCaptured,
+  onScopeDispose,
   onUnmounted,
   ref,
   shallowRef,
   toRaw,
 } from 'vue'
 import { findLastTextNodeAndAppendNode, getCaret } from '../utils/caret.ts'
-import { pascalCase, resolveAttributes } from 'comark/utils'
+import { pascalCase, resolveAttributes, resolveModelElement, modelElementDisplayValue } from 'comark/utils'
+import type { ComarkModel } from 'comark/model'
+import { createModelStore } from 'comark/model'
 
 // Cache for dynamically resolved components
 const asyncComponentCache = new Map<string, any>()
@@ -110,7 +113,8 @@ function renderNode(
   key?: string | number,
   componentsManifest?: ComponentManifest,
   parent?: Node,
-  renderData: NodeRenderData = { frontmatter: {}, meta: {}, data: {}, props: {} }
+  renderData: NodeRenderData = { frontmatter: {}, meta: {}, data: {}, props: {} },
+  model?: ComarkModel
 ): VNode | string | null {
   // Handle text nodes (strings)
   if (typeof node === 'string') {
@@ -139,9 +143,10 @@ function renderNode(
 
     const component = customComponent || tag
 
-    // Resolve `:prefix` bindings and let Vue-specific attribute mapping run
-    // on top (e.g. `className` → `class`).
-    const resolved = resolveAttributes(nodeProps, renderData, { parseJson: true })
+    // Resolve `:prefix` bindings and `::prefix` two-way bindings, then apply
+    // Vue-specific attribute mapping (`className` → `class`, `onUpdate:X` as-is
+    // for native v-model support on custom components).
+    const resolved = resolveAttributes(nodeProps, renderData, { parseJson: true, model })
     const props: Record<string, any> = {}
     for (const k in resolved) {
       if (k === 'className') {
@@ -151,6 +156,22 @@ function renderNode(
       }
     }
 
+    // For native form elements with model bindings, replace the generic
+    // update handler with the element-specific event listener and coercion.
+    if (model && !customComponent && typeof tag === 'string') {
+      for (const rawKey in nodeProps) {
+        if (!rawKey.startsWith('::')) continue
+        const modelProp = rawKey.slice(2)
+        const binding = resolveModelElement(tag, modelProp, nodeProps)
+        if (!binding) continue
+        const path = nodeProps[rawKey] as string
+        delete props[`onUpdate:${modelProp}`]
+        const eventHandler = `on${binding.event.charAt(0).toUpperCase()}${binding.event.slice(1)}`
+        props[eventHandler] = (e: Event) => model.set(path, binding.coerce(e.target as any))
+        props[binding.prop] = modelElementDisplayValue(binding, model.get(path), nodeProps)
+      }
+    }
+
     // @ts-expect-error - component might be a Vue component
     if (component?.props?.__node || component?.__asyncResolved?.props?.__node) {
       props.__node = node
@@ -204,14 +225,14 @@ function renderNode(
           slots[slotName] = () =>
             slotChildren
               .map((slotChild: Node, idx: number) =>
-                renderNode(slotChild, components, idx, componentsManifest, node, childrenRenderData)
+                renderNode(slotChild, components, idx, componentsManifest, node, childrenRenderData, model)
               )
               .filter((slotChild): slotChild is VNode | string => slotChild !== null)
           continue
         }
       }
 
-      const rendered = renderNode(child, components, i, componentsManifest, node, childrenRenderData)
+      const rendered = renderNode(child, components, i, componentsManifest, node, childrenRenderData, model)
       if (rendered !== null) {
         regularChildren.push(rendered)
       }
@@ -270,6 +291,17 @@ export interface MarkdownDocumentProps {
    */
   data?: Record<string, unknown>
 
+  /**
+   * Two-way data binding model. When provided, `::prop="path"` attributes are
+   * resolved against the model and update handlers are wired automatically.
+   */
+  model?: ComarkModel
+
+  /**
+   * Called after every write accepted by the model.
+   */
+  onModelChange?: (path: string, value: unknown, snapshot: Record<string, unknown>) => void
+
   /**
    * Document key. When set and `globalThis.comarkContext` exists, the renderer
    * subscribes to live updates for this key (HMR, devtools, collab, agents) and
@@ -340,6 +372,22 @@ export const markdownDocumentProps = {
     default: () => ({}),
   },
 
+  /**
+   * Two-way data binding model.
+   */
+  model: {
+    type: Object as PropType<ComarkModel>,
+    default: undefined,
+  },
+
+  /**
+   * Called after every write accepted by the model.
+   */
+  onModelChange: {
+    type: Function as PropType<(path: string, value: unknown, snapshot: Record<string, unknown>) => void>,
+    default: undefined,
+  },
+
   /**
    * Document key used to subscribe to live updates via `globalThis.comarkContext`
    */
@@ -398,6 +446,22 @@ export const MarkdownDocument: MarkdownDocumentComponent = defineComponent({
       onUnmounted(() => cleanup(true))
     }
 
+    // Two-way model boundary: create an uncontrolled store if no model is
+    // passed, and subscribe to `data` to trigger re-renders on writes.
+    const internalModel: ComarkModel =
+      props.model ??
+      createModelStore({
+        data: { data: props.data ?? {} },
+        onChange: props.onModelChange,
+      })
+    // A shallowRef bumped on every model write causes the render function to
+    // re-run without replacing the entire VNode tree.
+    const modelVersion = shallowRef(0)
+    const unsub = internalModel.subscribe('data', () => {
+      modelVersion.value++
+    })
+    onScopeDispose(unsub)
+
     // Capture errors from child components (e.g., during streaming when props are incomplete)
     onErrorCaptured((_err, instance, _info) => {
       // Get component name from instance
@@ -428,6 +492,9 @@ export const MarkdownDocument: MarkdownDocumentComponent = defineComponent({
     const caret = computed<ElementNode | null>(() => getCaret(props.caret || false))
 
     return () => {
+      // Access modelVersion so Vue tracks it as a dependency of this render.
+      void modelVersion.value
+
       // Render all nodes from the live document when present, else the value prop
       const rawDocument = toRaw(liveDocument.value ?? inputDocument.value)
       const nodes = [...(rawDocument.nodes || [])]
@@ -447,10 +514,13 @@ export const MarkdownDocument: MarkdownDocumentComponent = defineComponent({
         meta: (rawDocument as MarkdownDocumentType).meta || {},
         data: props.data || {},
         props: {},
+        model: internalModel,
       }
 
       const children = nodes
-        .map((node, index) => renderNode(node, components.value, index, componentManifest, undefined, renderData))
+        .map((node, index) =>
+          renderNode(node, components.value, index, componentManifest, undefined, renderData, internalModel)
+        )
         .filter((child): child is VNode | string => child !== null)
 
       // Wrap in a fragment
diff --git a/packages/comark-vue/src/plugins/form.ts b/packages/comark-vue/src/plugins/form.ts
new file mode 100644
index 00000000..4993bd02
--- /dev/null
+++ b/packages/comark-vue/src/plugins/form.ts
@@ -0,0 +1,3 @@
+export * from 'comark/plugins/form'
+
+export { Form } from '../components/Form.ts'
diff --git a/packages/comark-vue/test/form.test.ts b/packages/comark-vue/test/form.test.ts
new file mode 100644
index 00000000..24013cfe
--- /dev/null
+++ b/packages/comark-vue/test/form.test.ts
@@ -0,0 +1,45 @@
+import { describe, expect, it } from 'vitest'
+import { renderToString } from '@vue/server-renderer'
+import { createSSRApp, defineComponent, h } from 'vue'
+import { parseMarkdown } from 'comark'
+import { createModelStore } from 'comark/model'
+import { MarkdownDocument } from '../src/components/MarkdownDocument'
+import { Form } from '../src/components/Form'
+
+async function render(markdown: string, props: Record<string, any> = {}) {
+  const doc = await parseMarkdown(markdown)
+  const app = createSSRApp(
+    defineComponent({
+      render() {
+        return h(MarkdownDocument, { value: doc, components: { form: Form }, ...props })
+      },
+    })
+  )
+  return renderToString(app)
+}
+
+describe('Vue Form component — SSR', () => {
+  it('renders a <form> element wrapping its children', async () => {
+    const html = await render('::form{::value="data.contact"}\n  Hello\n::')
+    expect(html).toContain('<form')
+    expect(html).toContain('Hello')
+  })
+
+  it('resolves the ::value binding from the model', async () => {
+    const model = createModelStore({ data: { data: { contact: { name: 'Alice' } } } })
+    const html = await render('::form{::value="data.contact"}\n  content\n::', { model })
+    // Form renders its slot — the value prop is resolved but not rendered as text
+    expect(html).toContain('<form')
+    expect(html).toContain('content')
+  })
+
+  it('passes through child input bindings', async () => {
+    const model = createModelStore({ data: { data: { name: 'Bob' } } })
+    const html = await render(
+      '::form{::value="data.contact"}\n  :input{::value="data.name" name="name" type="text"}\n::',
+      { model }
+    )
+    expect(html).toContain('<form')
+    expect(html).toContain('Bob')
+  })
+})
diff --git a/packages/comark-vue/test/model-binding.test.ts b/packages/comark-vue/test/model-binding.test.ts
new file mode 100644
index 00000000..90672605
--- /dev/null
+++ b/packages/comark-vue/test/model-binding.test.ts
@@ -0,0 +1,73 @@
+import { describe, expect, it, vi } from 'vitest'
+import { renderToString } from '@vue/server-renderer'
+import { createSSRApp, defineComponent, h } from 'vue'
+import { parseMarkdown } from 'comark'
+import { createModelStore } from 'comark/model'
+import { MarkdownDocument } from '../src/components/MarkdownDocument'
+
+async function render(markdown: string, props: Record<string, any> = {}) {
+  const doc = await parseMarkdown(markdown)
+  const app = createSSRApp(
+    defineComponent({
+      render() {
+        return h(MarkdownDocument, { value: doc, ...props })
+      },
+    })
+  )
+  return renderToString(app)
+}
+
+describe('Vue model binding — SSR snapshot', () => {
+  it('resolves ::value="data.name" from the model', async () => {
+    const model = createModelStore({ data: { data: { name: 'Alice' } } })
+    const html = await render(':input{::value="data.name" type="text"}', { model })
+    expect(html).toContain('Alice')
+  })
+
+  it('emits data-comark-model-value HTML marker when no model provided', async () => {
+    const doc = await parseMarkdown(':input{::value="data.name" type="text"}')
+    const app = createSSRApp(
+      defineComponent({
+        render() {
+          return h(MarkdownDocument, { value: doc, data: { name: 'Bob' } })
+        },
+      })
+    )
+    const html = await renderToString(app)
+    expect(html).toContain('Bob')
+  })
+
+  it('controlled mode: onModelChange fires on write', async () => {
+    const onChange = vi.fn()
+    const model = createModelStore({ data: { data: { x: 0 } }, onChange })
+    model.set('data.x', 7)
+    expect(onChange).toHaveBeenCalledWith('data.x', 7, expect.anything())
+  })
+
+  it('custom component receives title via ::title binding', async () => {
+    const model = createModelStore({ data: { data: { title: 'My Title' } } })
+    const html = await render('::card{::title="data.title"}\ncontent\n::', { model })
+    expect(html).toContain('My Title')
+  })
+
+  it('unsafe URL is blocked for ::href binding', async () => {
+    const model = createModelStore({ data: { data: { url: 'javascript:alert(1)' } } })
+    const html = await render(':a{::href="data.url"}', { model })
+    expect(html).not.toContain('javascript:')
+  })
+})
+
+describe('Vue model binding — coercion matrix', () => {
+  it('number input resolves from model value', async () => {
+    const model = createModelStore({ data: { data: { count: 5 } } })
+    const html = await render(':input{::value="data.count" type="number"}', { model })
+    expect(html).toContain('5')
+  })
+
+  it('checkbox resolves checked from model', async () => {
+    const model = createModelStore({ data: { data: { active: true } } })
+    const html = await render(':input{::checked="data.active" type="checkbox"}', { model })
+    // Boolean checked attribute renders as checked="" in HTML
+    expect(html).toContain('checked')
+  })
+})
diff --git a/packages/comark/SPEC/COMARK/data-binding-form.md b/packages/comark/SPEC/COMARK/data-binding-form.md
new file mode 100644
index 00000000..4040e803
--- /dev/null
+++ b/packages/comark/SPEC/COMARK/data-binding-form.md
@@ -0,0 +1,62 @@
+## Input
+
+```md
+::form{::value="data.contact"}
+  :input{::value="data.name" name="name" type="text"}
+  :input{::value="data.email" name="email" type="email"}
+::
+```
+
+## AST
+
+```json
+{
+  "frontmatter": {},
+  "meta": {},
+  "nodes": [
+    [
+      "form",
+      {
+        "::value": "data.contact"
+      },
+      [
+        "input",
+        {
+          "::value": "data.name",
+          "name": "name",
+          "type": "text"
+        }
+      ],
+      [
+        "input",
+        {
+          "::value": "data.email",
+          "name": "email",
+          "type": "email"
+        }
+      ]
+    ]
+  ]
+}
+```
+
+## HTML
+
+```html
+<form data-comark-model-value="data.contact">
+  <input data-comark-model-value="data.name" name="name" type="text">
+  <input data-comark-model-value="data.email" name="email" type="email">
+</form>
+```
+
+## Markdown
+
+```md
+::form{::value="data.contact"}
+  :::input{::value="data.name" name="name" type="text"}
+  :::
+
+  :::input{::value="data.email" name="email" type="email"}
+  :::
+::
+```
diff --git a/packages/comark/SPEC/COMARK/data-binding-two-way-block.md b/packages/comark/SPEC/COMARK/data-binding-two-way-block.md
new file mode 100644
index 00000000..ee0cc0c7
--- /dev/null
+++ b/packages/comark/SPEC/COMARK/data-binding-two-way-block.md
@@ -0,0 +1,41 @@
+## Input
+
+```md
+::card{::title="data.heading"}
+content
+::
+```
+
+## AST
+
+```json
+{
+  "frontmatter": {},
+  "meta": {},
+  "nodes": [
+    [
+      "card",
+      {
+        "::title": "data.heading"
+      },
+      "content"
+    ]
+  ]
+}
+```
+
+## HTML
+
+```html
+<card data-comark-model-title="data.heading">
+  content
+</card>
+```
+
+## Markdown
+
+```md
+::card{::title="data.heading"}
+content
+::
+```
diff --git a/packages/comark/SPEC/COMARK/data-binding-two-way-inline.md b/packages/comark/SPEC/COMARK/data-binding-two-way-inline.md
new file mode 100644
index 00000000..0ccacf3d
--- /dev/null
+++ b/packages/comark/SPEC/COMARK/data-binding-two-way-inline.md
@@ -0,0 +1,42 @@
+## Input
+
+```md
+Enter name: :input{::value="data.name" type="text"}
+```
+
+## AST
+
+```json
+{
+  "frontmatter": {},
+  "meta": {},
+  "nodes": [
+    [
+      "p",
+      {},
+      "Enter name: ",
+      [
+        "input",
+        {
+          "::value": "data.name",
+          "type": "text"
+        }
+      ]
+    ]
+  ]
+}
+```
+
+## HTML
+
+```html
+<p>
+  Enter name: <input data-comark-model-value="data.name" type="text">
+</p>
+```
+
+## Markdown
+
+```md
+Enter name: :input{::value="data.name" type="text"}
+```
diff --git a/packages/comark/package.json b/packages/comark/package.json
index dcc150d5..e6c8db6f 100644
--- a/packages/comark/package.json
+++ b/packages/comark/package.json
@@ -40,6 +40,7 @@
   "types": "./dist/index.d.ts",
   "exports": {
     ".": "./dist/index.js",
+    "./model": "./dist/model.js",
     "./plugins/*": "./dist/plugins/*.js",
     "./utils": "./dist/utils/index.js",
     "./utils/trace": "./dist/utils/trace.js",
diff --git a/packages/comark/src/context.ts b/packages/comark/src/context.ts
index 5af7e990..ed52322c 100644
--- a/packages/comark/src/context.ts
+++ b/packages/comark/src/context.ts
@@ -70,8 +70,7 @@ function applyPatch(current: MarkdownDocument, patch: ComarkPatch): MarkdownDocu
     case 'frontmatter':
       return { ...current, frontmatter: { ...current.frontmatter, ...patch.frontmatter } }
     case 'data':
-      // @ts-expect-error - patch.data is a plain object
-      return { ...current, data: { ...current.data, ...patch.data } }
+      return { ...current, data: { ...(current.data ?? {}), ...patch.data } }
     default: {
       if (!patch.path.length) {
         throw new Error(`Comark patch "${patch.op}" requires a non-empty path`)
diff --git a/packages/comark/src/internal/parse/syntax/props.ts b/packages/comark/src/internal/parse/syntax/props.ts
index 418a64cd..e574158b 100644
--- a/packages/comark/src/internal/parse/syntax/props.ts
+++ b/packages/comark/src/internal/parse/syntax/props.ts
@@ -57,10 +57,15 @@ export function searchProps(content: string, index = 0) {
           index += 1
           value = searchValue()
         } else {
+          // ::prop boolean shorthand is meaningless — a model binding with no
+          // path has no target to write to, so reject it silently.
+          if (key.startsWith('::')) {
+            continue
+          }
           key = key[0] === ':' ? key : `:${key}`
           value = 'true'
         }
-        if (key.match(/^:?[a-z_][a-z0-9_-]*$/gi)) {
+        if (key.match(/^:{0,2}[a-z_][a-z0-9_-]*$/gi)) {
           props.push([key, value])
         }
       }
diff --git a/packages/comark/src/internal/stringify/attributes.ts b/packages/comark/src/internal/stringify/attributes.ts
index 557cf70f..e203836c 100644
--- a/packages/comark/src/internal/stringify/attributes.ts
+++ b/packages/comark/src/internal/stringify/attributes.ts
@@ -3,6 +3,7 @@ import { escapeHtml, get } from '../../utils/index.ts'
 import { isUnsafeUrlValue } from '../props-validation.ts'
 import { pickFence } from './fence.ts'
 import type { NodeRenderData } from '../../types.ts'
+import type { ComarkModel } from '../../model.ts'
 
 export interface ResolveAttributesOptions {
   /**
@@ -18,6 +19,15 @@ export interface ResolveAttributesOptions {
    * (like HTML attribute emitters) can apply their own `:prefix` handling.
    */
   parseJson?: boolean
+  /**
+   * When provided, `::prop="path"` attributes are resolved as two-way
+   * bindings: the current value is read from `model.get(path)` and an
+   * `onUpdate:prop` handler is emitted that writes back via `model.set`.
+   *
+   * Without a model, `::prop` degrades silently to a one-way read from
+   * `renderData` (same as `:prop`).
+   */
+  model?: ComarkModel
 }
 
 // DOM sinks that turn a string/object prop into raw markup (`innerHTML`,
@@ -27,9 +37,19 @@ export interface ResolveAttributesOptions {
 // from document attributes — raw HTML has its own explicit path.
 const HTML_SINK_PROPS = new Set(['innerhtml', 'dangerouslysetinnerhtml', 'textcontent'])
 
+/** Prefer `model.get(path)` when a model is present, then fall back to `renderData`. */
+const lookupPath = (path: string, renderData: NodeRenderData, model?: ComarkModel): unknown => {
+  if (model) {
+    const fromModel = model.get(path)
+    if (fromModel !== undefined) return fromModel
+  }
+  return get(renderData, path)
+}
+
 /**
- * Resolve `:prefixed` attributes against the render context.
+ * Resolve `:prefixed` and `::prefixed` attributes against the render context.
  *
+ * **One-way (`:`)**
  * Default behavior: a `:prefixed` string value that matches a dot-path in
  * `{ frontmatter, meta, data, props }` is replaced with the resolved value
  * (and the `:` prefix is stripped). Anything that doesn't resolve — literals
@@ -39,6 +59,17 @@ const HTML_SINK_PROPS = new Set(['innerhtml', 'dangerouslysetinnerhtml', 'textco
  * With `parseJson: true`, every `:prefixed` string is JSON-parsed first and
  * the `:` prefix is always stripped, falling back to the dot-path lookup.
  * The `$` metadata key is never forwarded.
+ *
+ * **Two-way (`::`, `options.model`)**
+ * When a `::prop="path"` key is present:
+ * - In framework mode (`parseJson: true`) with a `model`: emits `prop` (read
+ *   via `model.get`) and `onUpdate:prop` (write handler). Degrades to one-way
+ *   when no model is supplied.
+ * - In preserve/HTML mode: emits `prop` (resolved from `renderData`) plus
+ *   `data-comark-model-{prop}="path"` for the HTML progressive-enhancement
+ *   runtime.
+ * - A filtered expression (`::prop="path | filter"`) is not assignable: in
+ *   dev it throws; in production it degrades to one-way silently.
  */
 export function resolveAttributes(
   attrs: Record<string, unknown>,
@@ -46,15 +77,78 @@ export function resolveAttributes(
   options: ResolveAttributesOptions = {}
 ): Record<string, unknown> {
   const result: Record<string, unknown> = {}
+  const { model } = options
+
   for (const key in attrs) {
     if (key === '$') continue
 
     const value = attrs[key]
-    const isBinding = key.charCodeAt(0) === 58 /* ':' */
-    const outKey = isBinding ? key.slice(1) : key
+    const isDoubleBinding = key.charCodeAt(0) === 58 /* ':' */ && key.charCodeAt(1) === 58 /* ':' */
+    const isBinding = !isDoubleBinding && key.charCodeAt(0) === 58 /* ':' */
+    const outKey = isDoubleBinding ? key.slice(2) : isBinding ? key.slice(1) : key
 
     if (HTML_SINK_PROPS.has(outKey.toLowerCase())) continue
 
+    // --- Two-way binding (::prop="path") ---
+    if (isDoubleBinding) {
+      const path = typeof value === 'string' ? value.trim() : ''
+      if (!path) continue
+
+      const lowerOutKey = outKey.toLowerCase()
+
+      // Filtered expressions are projections and are not assignable.
+      if (path.includes('|')) {
+        if ((import.meta as unknown as { env?: { DEV?: boolean } }).env?.DEV) {
+          throw new Error(
+            `[comark] ::${outKey}="${path}" contains a pipe filter. Filtered expressions are not writable. Use a plain path for two-way binding.`
+          )
+        }
+        // Production: degrade to one-way
+        const plainPath = path.split('|')[0].trim()
+        const readValue = lookupPath(plainPath, renderData, model)
+        if (readValue !== undefined) {
+          if (
+            (lowerOutKey === 'href' || lowerOutKey === 'src' || lowerOutKey === 'xlink:href') &&
+            typeof readValue === 'string' &&
+            isUnsafeUrlValue(readValue)
+          )
+            continue
+          result[outKey] = readValue
+        }
+        continue
+      }
+
+      if (options.parseJson) {
+        // Framework mode: emit value + update handler.
+        const readValue = lookupPath(path, renderData, model)
+        if (
+          (lowerOutKey === 'href' || lowerOutKey === 'src' || lowerOutKey === 'xlink:href') &&
+          typeof readValue === 'string' &&
+          isUnsafeUrlValue(readValue)
+        )
+          continue
+        result[outKey] = readValue
+        if (model) {
+          result[`onUpdate:${outKey}`] = (next: unknown) => model.set(path, next)
+        }
+      } else {
+        // Preserve / HTML-string mode: emit the read value + model-path marker.
+        const readValue = lookupPath(path, renderData, model)
+        if (
+          (lowerOutKey === 'href' || lowerOutKey === 'src' || lowerOutKey === 'xlink:href') &&
+          typeof readValue === 'string' &&
+          isUnsafeUrlValue(readValue)
+        )
+          continue
+        if (readValue !== undefined) result[outKey] = readValue
+        // The HTML runtime reads this attribute to discover which model path
+        // controls this element's property.
+        result[`data-comark-model-${outKey}`] = path
+      }
+      continue
+    }
+
+    // --- One-way binding (:prop="...") and plain attributes ---
     let outValue: unknown
     let resultKey = key
 
@@ -65,7 +159,7 @@ export function resolveAttributes(
           outValue = JSON.parse(value)
         } catch {
           // not JSON — fall through to dot-path lookup
-          outValue = get(renderData, value)
+          outValue = lookupPath(value, renderData, model)
         }
       } else {
         // Non-string binding value (e.g. an object literal the parser already
@@ -74,7 +168,7 @@ export function resolveAttributes(
       }
       resultKey = outKey
     } else if (isBinding && typeof value === 'string') {
-      const resolved = get(renderData, value)
+      const resolved = lookupPath(value, renderData, model)
       if (resolved !== undefined) {
         outValue = resolved
         resultKey = outKey
@@ -189,7 +283,9 @@ export function userBlockAttrs(tag: string, attributes: Record<string, unknown>)
 export function comarkAttributes(attributes: Record<string, unknown>) {
   const attrs = Object.entries(attributes)
     .map(([key, value]) => {
-      if (key.startsWith(':') && value === 'true') {
+      // Single-colon boolean shorthand: `:disabled` → `disabled`.
+      // Guard against double-colon so `::value="true"` stays as `::value="true"`.
+      if (key.startsWith(':') && !key.startsWith('::') && value === 'true') {
         return key.slice(1)
       }
       if (key === 'id') {
@@ -241,6 +337,18 @@ const SAFE_ATTR_NAME = /^[a-zA-Z_:][a-zA-Z0-9_:.-]*$/
 export function htmlAttributes(attributes: Record<string, unknown>) {
   const parts: string[] = []
   for (const [rawKey, value] of Object.entries(attributes)) {
+    // Two-way binding keys (::X) that reach htmlAttributes come from raw AST
+    // nodes (non-framework stringify). Emit model-path data-attributes so the
+    // HTML runtime can discover them; omit the native attr since the value
+    // should come from the resolved attrs that resolveAttributes already added.
+    if (rawKey.startsWith('::')) {
+      const propName = rawKey.slice(2)
+      if (propName && typeof value === 'string') {
+        parts.push(`data-comark-model-${propName}="${escapeHtml(value)}"`)
+      }
+      continue
+    }
+
     const key = rawKey.startsWith(':') ? rawKey.slice(1) : rawKey
     if (!SAFE_ATTR_NAME.test(key)) continue
 
@@ -299,6 +407,11 @@ export function comarkYamlAttributes(
   //  - Bare string literals `'true'`/`'false'` from inline attrs coerce to bools.
   const normalized = Object.fromEntries(
     Object.entries(attributes).map(([key, value]) => {
+      // Two-way binding keys keep their `::` prefix — they are path bindings
+      // and must round-trip exactly as `::prop="path"`.
+      if (key.startsWith('::')) {
+        return [key, value]
+      }
       if (key.startsWith(':')) {
         if (typeof value === 'string') {
           try {
@@ -325,3 +438,95 @@ export function comarkYamlAttributes(
   const fence = pickFence(yamlContent)
   return `${fence}yaml [props]\n${yamlContent}\n${fence}`
 }
+
+// #region resolveModelElement
+
+/**
+ * Describes how a renderer should wire a two-way model binding for a native
+ * form element. The table mirrors RFC §5.4.
+ */
+export interface ModelElementBinding {
+  /** The element property that holds the model value (e.g. 'value', 'checked'). */
+  prop: string
+  /** The DOM event that signals a user write (e.g. 'input', 'change'). */
+  event: string
+  /** Coerce the event-target value to the correct JavaScript type. */
+  coerce: (target: { value: string; checked: boolean; files: FileList | null }) => unknown
+  /**
+   * Map the stored model value to the DOM property. Used when the stored value
+   * is not the same as the element property (radio: model holds the group's
+   * selected `value` string, but `checked` must be a boolean).
+   */
+  read?: (modelValue: unknown, attrs: Record<string, unknown>) => unknown
+}
+
+const TEXT_INPUT_TYPES = new Set(['text', 'search', 'email', 'password', 'url', 'tel', 'color'])
+const NUMBER_INPUT_TYPES = new Set(['number', 'range'])
+const DATE_INPUT_TYPES = new Set(['date', 'time', 'datetime-local', 'month', 'week'])
+
+/**
+ * Return the model-element binding descriptor for a native HTML element that
+ * participates in two-way binding, or `null` for non-form elements.
+ *
+ * Renderers use this to wire the correct DOM event listener and value coercion
+ * without duplicating the mapping table in every framework adapter.
+ */
+export const resolveModelElement = (
+  tag: string,
+  modelProp: string,
+  attrs: Record<string, unknown>
+): ModelElementBinding | null => {
+  if (tag === 'input') {
+    const type = String(attrs.type ?? 'text').toLowerCase()
+    if (modelProp === 'value' && TEXT_INPUT_TYPES.has(type)) {
+      return { prop: 'value', event: 'input', coerce: (t) => t.value }
+    }
+    if (modelProp === 'value' && NUMBER_INPUT_TYPES.has(type)) {
+      return { prop: 'value', event: 'input', coerce: (t) => Number(t.value) }
+    }
+    if (modelProp === 'value' && DATE_INPUT_TYPES.has(type)) {
+      return { prop: 'value', event: 'change', coerce: (t) => t.value }
+    }
+    if (modelProp === 'checked' && type === 'checkbox') {
+      return { prop: 'checked', event: 'change', coerce: (t) => t.checked }
+    }
+    if (modelProp === 'checked' && type === 'radio') {
+      return {
+        prop: 'checked',
+        event: 'change',
+        coerce: (t) => t.value,
+        read: (modelValue, attrs) => modelValue === attrs.value,
+      }
+    }
+    if (modelProp === 'files' && type === 'file') {
+      return { prop: 'files', event: 'change', coerce: (t) => t.files }
+    }
+    return null
+  }
+  if ((tag === 'select' || tag === 'textarea') && modelProp === 'value') {
+    return {
+      prop: 'value',
+      event: tag === 'select' ? 'change' : 'input',
+      coerce: (t) => t.value,
+    }
+  }
+  return null
+}
+
+/**
+ * DOM property value for a native model binding. Radio compares against the
+ * element's `value` attribute; other controls use the stored value (with an
+ * empty-string fallback so React/Vue keep the input controlled).
+ */
+export const modelElementDisplayValue = (
+  binding: ModelElementBinding,
+  modelValue: unknown,
+  attrs: Record<string, unknown>
+): unknown => {
+  if (binding.read) return binding.read(modelValue, attrs)
+  if (binding.prop === 'checked') return Boolean(modelValue)
+  if (binding.prop === 'files') return modelValue ?? null
+  return modelValue ?? ''
+}
+
+// #endregion
diff --git a/packages/comark/src/internal/stringify/state.ts b/packages/comark/src/internal/stringify/state.ts
index 5f56cc2c..cfe21bca 100644
--- a/packages/comark/src/internal/stringify/state.ts
+++ b/packages/comark/src/internal/stringify/state.ts
@@ -61,7 +61,9 @@ export async function one(node: Node, state: State, parent?: ElementNode, atLine
   // resolve to nothing.
   const prevRenderData = state.renderData
   if (state.renderData && node[1]) {
-    const resolved = resolveAttributes(node[1] as Record<string, unknown>, prevRenderData)
+    const resolved = resolveAttributes(node[1] as Record<string, unknown>, prevRenderData, {
+      model: prevRenderData.model,
+    })
     if (Object.keys(resolved).length > 0) {
       state.renderData = { ...prevRenderData, props: resolved }
     }
@@ -128,7 +130,10 @@ export function createState(ctx: Partial<CreateContext> = {}): State {
   const renderData: NodeRenderData = {
     frontmatter: (tree?.frontmatter || {}) as Record<string, unknown>,
     meta: (tree?.meta || {}) as Record<string, unknown>,
-    data: (ctx.data || {}) as Record<string, unknown>,
+    // Merge context-patched `document.data` (from `{ op: 'data' }` patches)
+    // with the caller-supplied `ctx.data` so model writes via ComarkContext
+    // are visible to `:binding` and `{{ }}` interpolations.
+    data: { ...(tree?.data ?? {}), ...(ctx.data ?? {}) } as Record<string, unknown>,
     props: {} as Record<string, unknown>,
   }
   const state = {
diff --git a/packages/comark/src/model.ts b/packages/comark/src/model.ts
new file mode 100644
index 00000000..787d2e7e
--- /dev/null
+++ b/packages/comark/src/model.ts
@@ -0,0 +1,169 @@
+import { get, set } from './utils/index.ts'
+
+// #region ComarkModel protocol
+
+/**
+ * Framework-agnostic two-way data binding protocol.
+ *
+ * Core defines this interface; renderers bridge it to native reactivity
+ * (`shallowRef`, `useSyncExternalStore`, `signal`, `$state`). A host that
+ * already has a reactive store can pass its own implementation — ~10 lines —
+ * instead of using {@link createModelStore}.
+ */
+export interface ComarkModel {
+  /** Read a dot-path. Same resolution rules as the existing `get()`. */
+  get(path: string): unknown
+  /**
+   * Write a dot-path. Returns `false` when the path is outside the writable
+   * namespaces or would cause prototype pollution.
+   */
+  set(path: string, value: unknown): boolean
+  /**
+   * Subscribe to a path. A write to `data.a.b` notifies subscribers of
+   * `data.a.b`, `data.a`, and `data`. A subscriber of `data.a.b` is not
+   * notified when an ancestor (`data.a`) is written. Returns the teardown
+   * function.
+   */
+  subscribe(path: string, fn: (value: unknown) => void): () => void
+  /** Optional: coalesce several writes into one notification batch. */
+  batch?<T>(fn: () => T): T
+}
+
+// #endregion
+
+// #region createModelStore
+
+export interface ModelStoreOptions {
+  /** Initial value for the writable namespace(s). */
+  data?: Record<string, unknown>
+  /**
+   * Top-level namespace keys that accept writes.
+   * @default ['data']
+   */
+  writable?: readonly string[]
+  /**
+   * Called after every accepted write with the path, the new scalar value,
+   * and the entire current data snapshot. Use this for persistence or
+   * controlled-mode observation.
+   */
+  onChange?: (path: string, value: unknown, next: Record<string, unknown>) => void
+  /**
+   * When set, every accepted write is also pushed as a `{ op: 'data' }` patch
+   * into `globalThis.comarkContext` under this document key. Allows
+   * `MarkdownLive` subscribers to see model writes via the existing context
+   * transport without a separate data channel.
+   */
+  documentKey?: string
+}
+
+/**
+ * Create a per-instance, dependency-free {@link ComarkModel}.
+ *
+ * Subscribers are keyed by path. A write to `data.a.b` notifies subscribers
+ * of `data.a.b`, `data.a`, and `data` — nothing else (N4). The store holds
+ * no module-scoped state (N3): every call returns an independent instance.
+ */
+export function createModelStore(options: ModelStoreOptions = {}): ComarkModel {
+  const writable = new Set(options.writable ?? ['data'])
+  const incoming = options.data ?? {}
+  const data: Record<string, unknown> = {}
+  for (const key of Object.keys(incoming)) {
+    const value = incoming[key]
+    data[key] =
+      value !== null && typeof value === 'object' && !Array.isArray(value)
+        ? { ...(value as Record<string, unknown>) }
+        : value
+  }
+
+  // path → set of listener functions
+  const listeners = new Map<string, Set<(value: unknown) => void>>()
+
+  let batching = false
+  const pendingNotifications = new Map<string, unknown>()
+
+  const notify = (path: string, value: unknown) => {
+    if (batching) {
+      // Collect at every ancestor; last write wins within the batch.
+      const segments = path.split('.')
+      for (let i = segments.length; i >= 1; i--) {
+        const ancestor = segments.slice(0, i).join('.')
+        pendingNotifications.set(ancestor, i === segments.length ? value : get(data, ancestor))
+      }
+      return
+    }
+    // Notify the path and every ancestor prefix.
+    const segments = path.split('.')
+    for (let i = segments.length; i >= 1; i--) {
+      const ancestor = segments.slice(0, i).join('.')
+      const fns = listeners.get(ancestor)
+      if (fns) {
+        const ancestorValue = i === segments.length ? value : get(data, ancestor)
+        for (const fn of fns) fn(ancestorValue)
+      }
+    }
+  }
+
+  const flushBatch = () => {
+    for (const [p, v] of pendingNotifications) {
+      const fns = listeners.get(p)
+      if (fns) for (const fn of fns) fn(v)
+    }
+    pendingNotifications.clear()
+  }
+
+  const model: ComarkModel = {
+    get(path) {
+      return get(data, path)
+    },
+
+    set(path, value) {
+      const namespace = path.split('.')[0]
+      if (!writable.has(namespace)) return false
+      const ok = set(data, path, value)
+      if (!ok) return false
+
+      // Bridge into globalThis.comarkContext when a documentKey was provided.
+      // Patch the `data` namespace object (`{ name: 'Bob' }`), not the store
+      // envelope (`{ data: { name: 'Bob' } }`), so document.data matches
+      // renderData.data.
+      if (options.documentKey && globalThis.comarkContext) {
+        const payload =
+          typeof data.data === 'object' && data.data !== null && !Array.isArray(data.data)
+            ? { ...(data.data as Record<string, unknown>) }
+            : { ...data }
+        globalThis.comarkContext.get(options.documentKey).patch({ op: 'data', data: payload })
+      }
+
+      notify(path, value)
+      options.onChange?.(path, value, data)
+      return true
+    },
+
+    subscribe(path, fn) {
+      let fns = listeners.get(path)
+      if (!fns) {
+        fns = new Set()
+        listeners.set(path, fns)
+      }
+      fns.add(fn)
+      return () => {
+        fns!.delete(fn)
+        if (fns!.size === 0) listeners.delete(path)
+      }
+    },
+
+    batch(fn) {
+      batching = true
+      try {
+        return fn()
+      } finally {
+        batching = false
+        flushBatch()
+      }
+    },
+  }
+
+  return model
+}
+
+// #endregion
diff --git a/packages/comark/src/plugins/form.ts b/packages/comark/src/plugins/form.ts
new file mode 100644
index 00000000..aed0709c
--- /dev/null
+++ b/packages/comark/src/plugins/form.ts
@@ -0,0 +1,57 @@
+/**
+ * `::form` aggregate — core utilities used by all framework adapters.
+ *
+ * A `::form{::value="data.formData"}` component:
+ * 1. Renders its children normally (each child's `::value` binding writes
+ *    directly to the model via the standard two-way binding mechanism).
+ * 2. Collects all `::X` model paths from its children AST at render time.
+ * 3. On every child write (or on form submit), aggregates the current model
+ *    values for those paths and writes them as one object to the form's
+ *    own `::value` path.
+ *
+ * Framework adapters each import `collectFormBindingPaths` and wire the
+ * form-submit / model-subscribe loop using their own reactivity primitives.
+ */
+
+import type { Node } from '../types.ts'
+
+/**
+ * Recursively collect every model path referenced by a `::X` binding in the
+ * given node list.  Duplicate paths are de-duplicated.
+ */
+export function collectFormBindingPaths(nodes: Node[]): string[] {
+  const paths: string[] = []
+  for (const node of nodes) {
+    if (typeof node === 'string' || node[0] === null) continue
+    const [, attrs, ...children] = node as [string, Record<string, unknown>, ...Node[]]
+    for (const key in attrs) {
+      if (key.charCodeAt(0) === 58 && key.charCodeAt(1) === 58) {
+        const value = attrs[key]
+        if (typeof value === 'string' && value.trim()) {
+          paths.push(value.trim())
+        }
+      }
+    }
+    if (children.length) paths.push(...collectFormBindingPaths(children as Node[]))
+  }
+  // De-duplicate while preserving order
+  return [...new Set(paths)]
+}
+
+/**
+ * Build an aggregate object from a list of model paths.
+ * Each path's final segment becomes the key; the value comes from the model.
+ *
+ * e.g. paths = ['data.user.name', 'data.user.email']
+ * → { name: model.get('data.user.name'), email: model.get('data.user.email') }
+ *
+ * When two paths share the same final segment, the last one wins.
+ */
+export function buildFormAggregate(paths: string[], getValue: (path: string) => unknown): Record<string, unknown> {
+  const result: Record<string, unknown> = {}
+  for (const path of paths) {
+    const key = path.includes('.') ? path.slice(path.lastIndexOf('.') + 1) : path
+    result[key] = getValue(path)
+  }
+  return result
+}
diff --git a/packages/comark/src/types.ts b/packages/comark/src/types.ts
index 50ceeae9..1bbcc071 100644
--- a/packages/comark/src/types.ts
+++ b/packages/comark/src/types.ts
@@ -1,6 +1,7 @@
 import type { DumpOptions } from 'js-yaml'
 import type MarkdownExit from 'markdown-exit'
 import type MarkdownIt from 'markdown-it'
+import type { ComarkModel } from './model.ts'
 
 // #region Utility Types
 /**
@@ -56,6 +57,8 @@ export type Node = ElementNode | TextNode | CommentNode
  * @param nodes - The nodes of the document
  * @param frontmatter - The frontmatter data which is the data at the top of the file
  * @param meta - The meta data of the document, it can be used to store additional data
+ * @param data - Optional runtime data. Populated when a `{ op: 'data' }` patch is
+ *   applied via {@link ComarkContext} so model writes are visible to subscribers.
  *
  * The `TMeta` and `TFrontmatter` type parameters allow `parse` / `createMarkdownParser`
  * to surface plugin-contributed keys with narrow types (see `MergePluginMeta`).
@@ -64,6 +67,8 @@ export interface MarkdownDocument<TMeta = Record<string, any>, TFrontmatter = Re
   nodes: Node[]
   frontmatter: TFrontmatter
   meta: TMeta
+  /** Runtime data populated via `{ op: 'data' }` context patches. */
+  data?: Record<string, unknown>
 }
 
 // #endregion
@@ -259,22 +264,30 @@ export interface RenderMarkdownOptions extends RendererOptions {
 }
 
 export interface NodeRenderData {
-  /*
-   * Frontmatter data from the markdown file
+  /**
+   * Frontmatter data from the markdown file.
    */
   frontmatter: Record<string, unknown>
   /**
-   * Meta information from Comark Tree
+   * Meta information from Comark tree.
    */
   meta: Record<string, unknown>
   /**
-   * Additional data paased to rendere
+   * Additional data passed to renderer nodes. Paths like `data.name` resolve
+   * here; the writable namespace for two-way bindings (`::prop="data.name"`).
    */
   data: Record<string, unknown>
   /**
-   * Props from parent node
+   * Props from the nearest parent element that has its own attributes. Used
+   * by nested bindings such as `:label="props.title"`.
    */
   props: Record<string, unknown>
+  /**
+   * Optional two-way model. When present, `::prop="path"` attributes emit an
+   * update handler alongside the read value, and `Binding`/`If` subscribe to
+   * path changes for fine-grained reactivity.
+   */
+  model?: ComarkModel
 }
 // #endregion
 
diff --git a/packages/comark/src/utils/index.ts b/packages/comark/src/utils/index.ts
index 76790343..2570b666 100644
--- a/packages/comark/src/utils/index.ts
+++ b/packages/comark/src/utils/index.ts
@@ -272,9 +272,45 @@ export function get(data: unknown, key: string): unknown {
   }
   return value
 }
+
+const BLOCKED_SEGMENTS = new Set(['__proto__', 'constructor', 'prototype'])
+
+/**
+ * Set a value on a nested object using a dot-separated key path.
+ * Returns `true` when the write succeeds, `false` when a path segment would
+ * cause prototype pollution (blocked), the path contains an empty segment, or
+ * the intermediate value is not an object.
+ */
+export function set(data: unknown, key: string, value: unknown): boolean {
+  const keys = key.split('.')
+  for (const k of keys) {
+    if (!k || BLOCKED_SEGMENTS.has(k)) return false
+  }
+  let current: unknown = data
+  for (let i = 0; i < keys.length - 1; i++) {
+    const k = keys[i]
+    if (!current || typeof current !== 'object') return false
+    const rec = current as Record<string, unknown>
+    if (!(k in rec) || rec[k] === null) {
+      rec[k] = {}
+    } else if (typeof rec[k] !== 'object') {
+      // Intermediate node is a primitive — cannot traverse further
+      return false
+    }
+    current = rec[k]
+  }
+  if (!current || typeof current !== 'object') return false
+  ;(current as Record<string, unknown>)[keys[keys.length - 1]] = value
+  return true
+}
 // #endregion
 
 // Re-export the shared attribute resolvers so framework renderers can apply the
 // same `:prefix` semantics as the HTML/ANSI handlers without duplicating logic.
-export { resolveAttributes, resolveAttribute } from '../internal/stringify/attributes.ts'
-export type { ResolveAttributesOptions } from '../internal/stringify/attributes.ts'
+export {
+  resolveAttributes,
+  resolveAttribute,
+  resolveModelElement,
+  modelElementDisplayValue,
+} from '../internal/stringify/attributes.ts'
+export type { ResolveAttributesOptions, ModelElementBinding } from '../internal/stringify/attributes.ts'
diff --git a/packages/comark/test/context.test.ts b/packages/comark/test/context.test.ts
index 57d0643a..f304412d 100644
--- a/packages/comark/test/context.test.ts
+++ b/packages/comark/test/context.test.ts
@@ -125,6 +125,29 @@ describe('createComarkContext', () => {
     })
   })
 
+  describe('{ op: data } patch', () => {
+    it('merges data into the document and notifies listeners', () => {
+      const doc = createComarkContext(false).get('x')
+      doc.set(tree([['p', {}, 'hi']]))
+      const fn = vi.fn()
+      doc.listen(fn)
+      doc.patch({ op: 'data', data: { name: 'Alice' } })
+      const [latest] = fn.mock.calls[fn.mock.calls.length - 1]
+      expect(latest.data).toEqual({ name: 'Alice' })
+    })
+
+    it('accumulates multiple data patches', () => {
+      const doc = createComarkContext(false).get('x')
+      doc.set(tree([['p', {}, 'hi']]))
+      const fn = vi.fn()
+      doc.listen(fn)
+      doc.patch({ op: 'data', data: { a: 1 } })
+      doc.patch({ op: 'data', data: { b: 2 } })
+      const [latest] = fn.mock.calls[fn.mock.calls.length - 1]
+      expect(latest.data).toEqual({ a: 1, b: 2 })
+    })
+  })
+
   describe('lifecycle', () => {
     it('emits create on first access and remove on prune', () => {
       const ctx = createComarkContext(false)
diff --git a/packages/comark/test/form.test.ts b/packages/comark/test/form.test.ts
new file mode 100644
index 00000000..0fa65c93
--- /dev/null
+++ b/packages/comark/test/form.test.ts
@@ -0,0 +1,65 @@
+import { describe, expect, it } from 'vitest'
+import { collectFormBindingPaths, buildFormAggregate } from '../src/plugins/form'
+import type { Node } from '../src/types'
+
+const input = (path: string): Node => ['input', { '::value': path }]
+const textarea = (path: string): Node => ['textarea', { '::value': path }]
+const nested = (children: Node[]): Node => ['fieldset', {}, ...children]
+
+describe('collectFormBindingPaths', () => {
+  it('collects a single ::value path', () => {
+    const paths = collectFormBindingPaths([input('data.name')])
+    expect(paths).toEqual(['data.name'])
+  })
+
+  it('collects multiple sibling paths', () => {
+    const paths = collectFormBindingPaths([input('data.name'), input('data.email'), textarea('data.bio')])
+    expect(paths).toEqual(['data.name', 'data.email', 'data.bio'])
+  })
+
+  it('collects paths from nested children', () => {
+    const paths = collectFormBindingPaths([nested([input('data.name'), input('data.email')])])
+    expect(paths).toEqual(['data.name', 'data.email'])
+  })
+
+  it('de-duplicates repeated paths', () => {
+    const paths = collectFormBindingPaths([input('data.name'), input('data.name')])
+    expect(paths).toEqual(['data.name'])
+  })
+
+  it('ignores text nodes and comment nodes', () => {
+    const nodes: Node[] = ['hello', [null, {}, 'comment'], input('data.name')]
+    const paths = collectFormBindingPaths(nodes)
+    expect(paths).toEqual(['data.name'])
+  })
+
+  it('ignores nodes without :: bindings', () => {
+    const paths = collectFormBindingPaths([['input', { value: 'literal', type: 'text' }]])
+    expect(paths).toEqual([])
+  })
+
+  it('collects ::title and ::href in addition to ::value', () => {
+    const paths = collectFormBindingPaths([['a', { '::href': 'data.url', '::title': 'data.label' }]])
+    expect(paths.sort()).toEqual(['data.label', 'data.url'])
+  })
+})
+
+describe('buildFormAggregate', () => {
+  it('builds an object keyed by the last path segment', () => {
+    const agg = buildFormAggregate(
+      ['data.name', 'data.email'],
+      (p) => ({ 'data.name': 'Alice', 'data.email': 'a@b.com' })[p]
+    )
+    expect(agg).toEqual({ name: 'Alice', email: 'a@b.com' })
+  })
+
+  it('handles paths with no dot separator', () => {
+    const agg = buildFormAggregate(['name'], (p) => (p === 'name' ? 'Bob' : undefined))
+    expect(agg).toEqual({ name: 'Bob' })
+  })
+
+  it('last writer wins for duplicate final segments', () => {
+    const agg = buildFormAggregate(['user.name', 'contact.name'], (p) => p)
+    expect(agg).toEqual({ name: 'contact.name' })
+  })
+})
diff --git a/packages/comark/test/model.test.ts b/packages/comark/test/model.test.ts
new file mode 100644
index 00000000..d8f1d37d
--- /dev/null
+++ b/packages/comark/test/model.test.ts
@@ -0,0 +1,177 @@
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import { createModelStore } from '../src/model.ts'
+import type { ComarkModel } from '../src/model.ts'
+
+// Ensure globalThis.comarkContext is clean between tests.
+afterEach(() => {
+  globalThis.comarkContext = undefined
+})
+
+describe('createModelStore', () => {
+  it('returns undefined for unknown paths', () => {
+    const model = createModelStore()
+    expect(model.get('data.x')).toBeUndefined()
+  })
+
+  it('reads initial data', () => {
+    const model = createModelStore({ data: { data: { name: 'Alice' } } })
+    expect(model.get('data.name')).toBe('Alice')
+  })
+
+  it('writes and reads back', () => {
+    const model = createModelStore({ data: { data: {} } })
+    const ok = model.set('data.count', 42)
+    expect(ok).toBe(true)
+    expect(model.get('data.count')).toBe(42)
+  })
+
+  it('rejects writes outside writable namespaces', () => {
+    const model = createModelStore({ data: { frontmatter: { title: 'hi' } } })
+    const ok = model.set('frontmatter.title', 'changed')
+    expect(ok).toBe(false)
+    expect(model.get('frontmatter.title')).toBe('hi')
+  })
+
+  it('accepts writes to custom writable namespaces', () => {
+    const model = createModelStore({
+      data: { state: { open: false } },
+      writable: ['state'],
+    })
+    expect(model.set('state.open', true)).toBe(true)
+    expect(model.get('state.open')).toBe(true)
+  })
+
+  it('rejects prototype-pollution paths', () => {
+    const model = createModelStore()
+    expect(model.set('__proto__.evil', 1)).toBe(false)
+    expect(model.set('constructor.prototype.evil', 1)).toBe(false)
+    expect(model.set('data..bad', 1)).toBe(false)
+    const plain: Record<string, unknown> = {}
+    expect((plain as any).evil).toBeUndefined()
+  })
+
+  describe('subscribe fan-out', () => {
+    it('notifies exact path subscriber', () => {
+      const model = createModelStore({ data: { data: { a: { b: 1 } } } })
+      const fn = vi.fn()
+      model.subscribe('data.a.b', fn)
+      model.set('data.a.b', 2)
+      expect(fn).toHaveBeenCalledOnce()
+      expect(fn).toHaveBeenCalledWith(2)
+    })
+
+    it('notifies ancestor path subscribers', () => {
+      const model = createModelStore({ data: { data: { a: { b: 1 } } } })
+      const fnParent = vi.fn()
+      const fnRoot = vi.fn()
+      model.subscribe('data.a', fnParent)
+      model.subscribe('data', fnRoot)
+      model.set('data.a.b', 2)
+      expect(fnParent).toHaveBeenCalledOnce()
+      expect(fnRoot).toHaveBeenCalledOnce()
+    })
+
+    it('does NOT notify unrelated path subscribers', () => {
+      const model = createModelStore({ data: { data: { x: 1, y: 1 } } })
+      const fn = vi.fn()
+      model.subscribe('data.y', fn)
+      model.set('data.x', 99)
+      expect(fn).not.toHaveBeenCalled()
+    })
+
+    it('teardown removes the listener', () => {
+      const model = createModelStore({ data: { data: {} } })
+      const fn = vi.fn()
+      const unsub = model.subscribe('data.k', fn)
+      unsub()
+      model.set('data.k', 1)
+      expect(fn).not.toHaveBeenCalled()
+    })
+  })
+
+  describe('batch', () => {
+    it('coalesces multiple writes into one notification pass', () => {
+      const model = createModelStore({ data: { data: {} } })
+      const fn = vi.fn()
+      model.subscribe('data', fn)
+      model.batch!(() => {
+        model.set('data.a', 1)
+        model.set('data.b', 2)
+      })
+      // One notification per subscribed path, flushed after batch.
+      expect(fn).toHaveBeenCalledOnce()
+    })
+  })
+
+  describe('onChange callback', () => {
+    it('fires after an accepted write', () => {
+      const onChange = vi.fn()
+      const model = createModelStore({ data: { data: {} }, onChange })
+      model.set('data.x', 7)
+      expect(onChange).toHaveBeenCalledWith('data.x', 7, expect.objectContaining({ data: { x: 7 } }))
+    })
+
+    it('does not fire when write is rejected', () => {
+      const onChange = vi.fn()
+      const model = createModelStore({ onChange })
+      model.set('frontmatter.x', 1)
+      expect(onChange).not.toHaveBeenCalled()
+    })
+  })
+
+  describe('per-instance isolation', () => {
+    it('does not mutate the caller-supplied data object', () => {
+      const initial = { data: { name: 'Alice' } }
+      const model = createModelStore({ data: initial })
+      model.set('data.name', 'Bob')
+      expect(initial.data.name).toBe('Alice')
+      expect(model.get('data.name')).toBe('Bob')
+    })
+
+    it('two stores share no state', () => {
+      const a = createModelStore({ data: { data: {} } })
+      const b = createModelStore({ data: { data: {} } })
+      a.set('data.x', 1)
+      expect(b.get('data.x')).toBeUndefined()
+    })
+
+    it('subscriber on store A is not called when store B writes', () => {
+      const a = createModelStore({ data: { data: {} } })
+      const b = createModelStore({ data: { data: {} } })
+      const fn = vi.fn()
+      a.subscribe('data.x', fn)
+      b.set('data.x', 99)
+      expect(fn).not.toHaveBeenCalled()
+    })
+  })
+
+  describe('documentKey bridge', () => {
+    it('emits { op: data } into globalThis.comarkContext when documentKey is set', () => {
+      const patchSpy = vi.fn()
+      globalThis.comarkContext = { get: () => ({ patch: patchSpy }) } as any
+
+      const model = createModelStore({ data: { data: {} }, documentKey: 'doc1' })
+      model.set('data.name', 'Bob')
+
+      expect(patchSpy).toHaveBeenCalledWith({ op: 'data', data: { name: 'Bob' } })
+    })
+
+    it('does not emit when documentKey is absent', () => {
+      const patchSpy = vi.fn()
+      globalThis.comarkContext = { get: () => ({ patch: patchSpy }) } as any
+
+      const model = createModelStore({ data: { data: {} } })
+      model.set('data.name', 'Bob')
+
+      expect(patchSpy).not.toHaveBeenCalled()
+    })
+  })
+
+  it('satisfies the ComarkModel interface', () => {
+    const model: ComarkModel = createModelStore()
+    expect(typeof model.get).toBe('function')
+    expect(typeof model.set).toBe('function')
+    expect(typeof model.subscribe).toBe('function')
+    expect(typeof model.batch).toBe('function')
+  })
+})
diff --git a/packages/comark/test/plugins/security.test.ts b/packages/comark/test/plugins/security.test.ts
index e28ed0f5..cc5fd774 100644
--- a/packages/comark/test/plugins/security.test.ts
+++ b/packages/comark/test/plugins/security.test.ts
@@ -646,3 +646,31 @@ describe('security plugin — allowDataImages', () => {
     expect((tree.nodes[0] as [string, any])[1]).not.toHaveProperty('href')
   })
 })
+
+describe('security plugin — :: two-way binding keys', () => {
+  it('preserves safe ::value binding path (non-URL attribute)', async () => {
+    const tree = makeTree([['input', { '::value': 'data.name', type: 'text' }]])
+    await runPlugin(tree)
+    expect((tree.nodes[0] as [string, any])[1]).toHaveProperty('::value', 'data.name')
+  })
+
+  it('strips ::onclick (event handler via :: prefix)', async () => {
+    const tree = makeTree([['button', { '::onclick': 'data.handler' }]])
+    await runPlugin(tree)
+    expect((tree.nodes[0] as [string, any])[1]).not.toHaveProperty('::onclick')
+  })
+
+  it('preserves ::href with a safe dot-path value (runtime URL check)', async () => {
+    // The path string itself is not a URL — the security plugin keeps it;
+    // the unsafe URL guard fires at render time inside resolveAttributes.
+    const tree = makeTree([['a', { '::href': 'data.url' }]])
+    await runPlugin(tree)
+    expect((tree.nodes[0] as [string, any])[1]).toHaveProperty('::href', 'data.url')
+  })
+
+  it('strips ::innerHTML (HTML sink attribute via :: prefix)', async () => {
+    const tree = makeTree([['div', { '::innerHTML': 'data.content' }]])
+    await runPlugin(tree)
+    expect((tree.nodes[0] as [string, any])[1]).not.toHaveProperty('::innerHTML')
+  })
+})
diff --git a/packages/comark/test/resolve-attributes.test.ts b/packages/comark/test/resolve-attributes.test.ts
index bab8b0b2..60c37576 100644
--- a/packages/comark/test/resolve-attributes.test.ts
+++ b/packages/comark/test/resolve-attributes.test.ts
@@ -1,7 +1,13 @@
 import { describe, expect, it } from 'vitest'
 import type { Node } from 'comark'
 import type { NodeRenderData } from '../src/types.ts'
-import { resolveAttribute, resolveAttributes } from '../src/internal/stringify/attributes.ts'
+import {
+  resolveAttribute,
+  resolveAttributes,
+  resolveModelElement,
+  modelElementDisplayValue,
+} from '../src/internal/stringify/attributes.ts'
+import { createModelStore } from '../src/model.ts'
 import { parseMarkdown } from '../src/index'
 
 const makeRenderData = (overrides: Partial<NodeRenderData> = {}): NodeRenderData => ({
@@ -262,3 +268,113 @@ describe('resolveAttribute (single-attr lookup)', () => {
     expect(value).toBe(config)
   })
 })
+
+// #region Two-way binding (::prop)
+
+describe('resolveAttributes — two-way bindings (::prop)', () => {
+  const rd: NodeRenderData = {
+    frontmatter: {},
+    meta: {},
+    data: { name: 'Alice', count: 5 },
+    props: {},
+  }
+
+  describe('preserve / HTML mode (no parseJson, no model)', () => {
+    it('emits the prop value and a data-comark-model-{prop} marker', () => {
+      const result = resolveAttributes({ '::value': 'data.name' }, rd)
+      expect(result.value).toBe('Alice')
+      expect(result['data-comark-model-value']).toBe('data.name')
+    })
+
+    it('emits only the marker when the path is unresolved', () => {
+      const result = resolveAttributes({ '::value': 'data.missing' }, rd)
+      expect(result.value).toBeUndefined()
+      expect(result['data-comark-model-value']).toBe('data.missing')
+    })
+
+    it('blocks unsafe URL even in preserve mode', () => {
+      const rdWithUrl: NodeRenderData = { ...rd, data: { url: 'javascript:alert(1)' } }
+      const result = resolveAttributes({ '::href': 'data.url' }, rdWithUrl)
+      expect(result.href).toBeUndefined()
+      expect(result['data-comark-model-href']).toBeUndefined()
+    })
+
+    it('throws on filtered expression in dev mode (vitest runs dev)', () => {
+      const rdWithName: NodeRenderData = { ...rd, data: { name: 'Alice' } }
+      // Vitest runs with import.meta.env.DEV = true so the filtered expression
+      // throws immediately rather than degrading to one-way.
+      expect(() => resolveAttributes({ '::value': 'data.name | upper' }, rdWithName)).toThrow('pipe filter')
+    })
+  })
+
+  describe('framework mode (parseJson: true)', () => {
+    it('emits value from renderData when no model is supplied', () => {
+      const result = resolveAttributes({ '::value': 'data.name' }, rd, { parseJson: true })
+      expect(result.value).toBe('Alice')
+      expect(result['onUpdate:value']).toBeUndefined()
+    })
+
+    it('emits value from model.get when model is supplied', () => {
+      const model = createModelStore({ data: { data: { name: 'Bob' } } })
+      const result = resolveAttributes({ '::value': 'data.name' }, rd, { parseJson: true, model })
+      expect(result.value).toBe('Bob')
+    })
+
+    it('one-way :prop prefers model.get over renderData when a model is supplied', () => {
+      const model = createModelStore({ data: { data: { name: 'FromModel' } } })
+      const result = resolveAttributes({ ':title': 'data.name' }, rd, { parseJson: true, model })
+      expect(result.title).toBe('FromModel')
+    })
+
+    it('emits onUpdate:prop handler when model is supplied', () => {
+      const model = createModelStore({ data: { data: { name: 'Alice' } } })
+      const result = resolveAttributes({ '::value': 'data.name' }, rd, { parseJson: true, model })
+      expect(typeof result['onUpdate:value']).toBe('function')
+    })
+
+    it('onUpdate:prop writes back into the model', () => {
+      const model = createModelStore({ data: { data: { name: 'Alice' } } })
+      const result = resolveAttributes({ '::value': 'data.name' }, rd, { parseJson: true, model })
+      ;(result['onUpdate:value'] as (v: unknown) => void)('Carol')
+      expect(model.get('data.name')).toBe('Carol')
+    })
+
+    it('blocks unsafe URL for ::href', () => {
+      const model = createModelStore({ data: { data: { url: 'javascript:alert(1)' } } })
+      const rdUnsafe: NodeRenderData = { ...rd, data: { url: 'javascript:alert(1)' } }
+      const result = resolveAttributes({ '::href': 'data.url' }, rdUnsafe, { parseJson: true, model })
+      expect(result.href).toBeUndefined()
+      expect(result['onUpdate:href']).toBeUndefined()
+    })
+
+    it('does not emit model-path HTML markers in framework mode', () => {
+      const model = createModelStore({ data: { data: { x: 1 } } })
+      const result = resolveAttributes({ '::value': 'data.x' }, rd, { parseJson: true, model })
+      expect(Object.keys(result).some((k) => k.startsWith('data-comark-model'))).toBe(false)
+    })
+  })
+})
+
+// #endregion
+
+describe('resolveModelElement', () => {
+  it('maps a text input to value/input', () => {
+    const binding = resolveModelElement('input', 'value', { type: 'text' })
+    expect(binding).toMatchObject({ prop: 'value', event: 'input' })
+    expect(binding?.coerce({ value: 'hi', checked: false, files: null })).toBe('hi')
+  })
+
+  it('maps radio checked to a boolean comparison against attrs.value', () => {
+    const binding = resolveModelElement('input', 'checked', { type: 'radio', value: 'admin' })
+    expect(binding?.event).toBe('change')
+    expect(binding?.coerce({ value: 'admin', checked: true, files: null })).toBe('admin')
+    expect(modelElementDisplayValue(binding!, 'admin', { value: 'admin' })).toBe(true)
+    expect(modelElementDisplayValue(binding!, 'member', { value: 'admin' })).toBe(false)
+  })
+
+  it('maps checkbox checked to a boolean', () => {
+    const binding = resolveModelElement('input', 'checked', { type: 'checkbox' })
+    expect(modelElementDisplayValue(binding!, true, {})).toBe(true)
+    expect(modelElementDisplayValue(binding!, undefined, {})).toBe(false)
+  })
+})
diff --git a/packages/comark/test/set-guard.test.ts b/packages/comark/test/set-guard.test.ts
new file mode 100644
index 00000000..1b9fc6f8
--- /dev/null
+++ b/packages/comark/test/set-guard.test.ts
@@ -0,0 +1,62 @@
+import { describe, expect, it } from 'vitest'
+import { set } from '../src/utils/index.ts'
+
+describe('set()', () => {
+  it('sets a top-level key', () => {
+    const obj: Record<string, unknown> = {}
+    expect(set(obj, 'x', 1)).toBe(true)
+    expect(obj.x).toBe(1)
+  })
+
+  it('sets a nested key, creating intermediate objects', () => {
+    const obj: Record<string, unknown> = {}
+    expect(set(obj, 'a.b.c', 42)).toBe(true)
+    expect((obj as any).a.b.c).toBe(42)
+  })
+
+  it('overwrites an existing nested value', () => {
+    const obj = { data: { name: 'Alice' } }
+    set(obj, 'data.name', 'Bob')
+    expect(obj.data.name).toBe('Bob')
+  })
+
+  it('returns false for __proto__', () => {
+    const obj: Record<string, unknown> = {}
+    expect(set(obj, '__proto__.evil', 1)).toBe(false)
+    expect(({} as any).evil).toBeUndefined()
+  })
+
+  it('returns false for constructor', () => {
+    const obj: Record<string, unknown> = {}
+    expect(set(obj, 'constructor.prototype.evil', 1)).toBe(false)
+  })
+
+  it('returns false for prototype', () => {
+    const obj: Record<string, unknown> = {}
+    expect(set(obj, 'prototype.evil', 1)).toBe(false)
+  })
+
+  it('returns false for an empty path segment', () => {
+    const obj: Record<string, unknown> = {}
+    expect(set(obj, 'a..b', 1)).toBe(false)
+    expect(set(obj, '.x', 1)).toBe(false)
+    expect(set(obj, 'x.', 1)).toBe(false)
+  })
+
+  it('returns false when an intermediate node is not an object', () => {
+    const obj = { data: { count: 5 } }
+    expect(set(obj, 'data.count.nested', 1)).toBe(false)
+  })
+
+  it('returns false when the root is not an object', () => {
+    expect(set(null, 'x', 1)).toBe(false)
+    expect(set('string', 'x', 1)).toBe(false)
+    expect(set(42, 'x', 1)).toBe(false)
+  })
+
+  it('does not affect Object.prototype after prototype-pollution attempt', () => {
+    set({}, '__proto__.polluted', true)
+    set({}, 'constructor.prototype.polluted', true)
+    expect(({} as any).polluted).toBeUndefined()
+  })
+})
diff --git a/packages/comark/test/two-way-binding-parser.test.ts b/packages/comark/test/two-way-binding-parser.test.ts
new file mode 100644
index 00000000..a06cc083
--- /dev/null
+++ b/packages/comark/test/two-way-binding-parser.test.ts
@@ -0,0 +1,56 @@
+import { describe, expect, it } from 'vitest'
+import { parseMarkdown } from '../src/index'
+import { renderMarkdown } from '../src/render'
+import type { ElementNode, Node } from 'comark'
+
+function getAttrs(node: Node): Record<string, unknown> {
+  return Array.isArray(node) ? ((node[1] as Record<string, unknown>) ?? {}) : {}
+}
+
+describe('parser — ::prop two-way binding attributes', () => {
+  it('parses ::value="data.name" on an inline component', async () => {
+    const result = await parseMarkdown(':input{::value="data.name"}')
+    // Inline-only component unwraps from the paragraph wrapper
+    const input = result.nodes[0] as ElementNode
+    expect(getAttrs(input)['::value']).toBe('data.name')
+  })
+
+  it('parses ::value="data.name" on a block component', async () => {
+    const result = await parseMarkdown('::card{::title="data.heading"}\ncontent\n::')
+    const card = result.nodes[0] as ElementNode
+    expect(getAttrs(card)['::title']).toBe('data.heading')
+  })
+
+  it('rejects ::value with no value (boolean shorthand is meaningless for two-way binding)', async () => {
+    const result = await parseMarkdown(':input{::value type="text"}')
+    const input = result.nodes[0] as ElementNode
+    const attrs = getAttrs(input)
+    // ::value without = should be silently dropped, not cause a parse error.
+    expect(attrs['::value']).toBeUndefined()
+    // The other attribute is still parsed.
+    expect(attrs.type).toBe('text')
+  })
+
+  it('parses ::value="data.name" and ::checked="data.active" together', async () => {
+    const result = await parseMarkdown(':input{::value="data.name" ::checked="data.active"}')
+    const input = result.nodes[0] as ElementNode
+    const attrs = getAttrs(input)
+    expect(attrs['::value']).toBe('data.name')
+    expect(attrs['::checked']).toBe('data.active')
+  })
+
+  it('round-trips ::value="data.name" through renderMarkdown verbatim', async () => {
+    const src = '::card{::value="data.count"}\ncontent\n::'
+    const doc = await parseMarkdown(src)
+    const out = await renderMarkdown(doc)
+    expect(out).toContain('::value="data.count"')
+  })
+
+  it('single-colon boolean shorthand still works alongside ::value', async () => {
+    const result = await parseMarkdown(':input{::value="data.x" disabled}')
+    const input = result.nodes[0] as ElementNode
+    const attrs = getAttrs(input)
+    expect(attrs['::value']).toBe('data.x')
+    expect(attrs[':disabled']).toBe('true')
+  })
+})
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 4101fbee..4ff22ec4 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -334,7 +334,7 @@ importers:
         version: 1.0.34
       nuxt:
         specifier: 'catalog:'
-        version: 4.4.8(@babel/plugin-syntax-jsx@7.29.7(@babel/core@7.29.7(supports-color@10.2.2)))(@babel/plugin-syntax-typescript@7.29.7(@babel/core@7.29.7(supports-color@10.2.2)))(@oxc-project/types@0.143.0)(@parcel/watcher@2.5.6)(@types/node@26.1.1)(@vercel/functions@3.9.5(ws@8.21.0))(@vue/compiler-sfc@3.5.41)(better-sqlite3@12.10.0)(cac@6.7.14)(db0@0.3.4(better-sqlite3@12.10.0))(esbuild@0.28.1)(eslint@10.4.1(jiti@2.7.0)(supports-color@10.2.2))(ioredis@5.11.1(supports-color@10.2.2))(lightningcss@1.33.0)(magicast@0.5.4)(meow@13.2.0)(optionator@0.9.4)(oxlint@1.73.0)(rolldown@1.1.5)(rollup-plugin-visualizer@7.0.1(rolldown@1.1.5)(rollup@4.62.2))(rollup@4.62.2)(sass@1.99.0)(supports-color@10.2.2)(terser@5.49.0)(tsx@4.23.0)(typescript@6.0.3)(vite@8.1.4(@types/node@26.1.1)(esbuild@0.28.1)(jiti@2.7.0)(sass@1.99.0)(terser@5.49.0)(tsx@4.23.0)(yaml@2.9.0))(vue-tsc@3.3.7(typescript@6.0.3))(yaml@2.9.0)
+        version: 4.4.8(@babel/plugin-syntax-jsx@7.29.7(@babel/core@7.29.7(supports-color@10.2.2)))(@babel/plugin-syntax-typescript@7.29.7(@babel/core@7.29.7(supports-color@10.2.2)))(@oxc-project/types@0.143.0)(@parcel/watcher@2.5.6)(@types/node@26.1.1)(@vercel/functions@3.9.5(ws@8.21.0))(@vue/compiler-sfc@3.5.41)(better-sqlite3@12.10.0)(cac@6.7.14)(db0@0.3.4(better-sqlite3@12.10.0))(esbuild@0.28.1)(eslint@10.4.1(jiti@2.7.0)(supports-color@10.2.2))(ioredis@5.11.1(supports-color@10.2.2))(lightningcss@1.33.0)(magicast@0.5.4)(meow@13.2.0)(optionator@0.9.4)(oxlint@1.73.0)(rolldown@1.1.5)(rollup-plugin-visualizer@7.0.1(rolldown@1.1.5)(rollup@4.62.2))(rollup@4.62.2)(sass@1.99.0)(srvx@0.11.22)(supports-color@10.2.2)(terser@5.49.0)(tsx@4.23.0)(typescript@6.0.3)(vite@8.1.4(@types/node@26.1.1)(esbuild@0.28.1)(jiti@2.7.0)(sass@1.99.0)(terser@5.49.0)(tsx@4.23.0)(yaml@2.9.0))(vue-tsc@3.3.7(typescript@6.0.3))(yaml@2.9.0)
       oxfmt:
         specifier: 'catalog:'
         version: 0.58.0(svelte@5.56.4(@typescript-eslint/types@8.63.0))
@@ -373,7 +373,7 @@ importers:
         version: 11.0.5
       vitest:
         specifier: 'catalog:'
-        version: 4.1.10(@opentelemetry/api@1.9.1)(@types/node@26.1.1)(@vitest/browser-playwright@4.1.10)(vite@8.1.4(@types/node@26.1.1)(esbuild@0.28.1)(jiti@2.7.0)(sass@1.99.0)(terser@5.49.0)(tsx@4.23.0)(yaml@2.9.0))
+        version: 4.1.10(@opentelemetry/api@1.9.1)(@types/node@26.1.1)(@vitest/browser-playwright@4.1.10)(jsdom@30.0.1)(vite@8.1.4(@types/node@26.1.1)(esbuild@0.28.1)(jiti@2.7.0)(sass@1.99.0)(terser@5.49.0)(tsx@4.23.0)(yaml@2.9.0))
 
   docs:
     dependencies:
@@ -538,7 +538,7 @@ importers:
         version: 4.10.0(5c6780d2fb91e0471d34a5c9b4e8eaae)
       nuxt:
         specifier: 'catalog:'
-        version: 4.4.8(@babel/plugin-syntax-jsx@7.29.7(@babel/core@7.29.7(supports-color@10.2.2)))(@babel/plugin-syntax-typescript@7.29.7(@babel/core@7.29.7(supports-color@10.2.2)))(@oxc-project/types@0.143.0)(@parcel/watcher@2.5.6)(@types/node@26.2.0)(@vercel/functions@3.9.5(ws@8.21.0))(@vue/compiler-sfc@3.5.41)(better-sqlite3@12.10.0)(cac@6.7.14)(db0@0.3.4(better-sqlite3@12.10.0))(esbuild@0.28.1)(eslint@10.4.1(jiti@2.7.0)(supports-color@10.2.2))(ioredis@5.11.1(supports-color@10.2.2))(lightningcss@1.33.0)(magicast@0.5.4)(meow@13.2.0)(optionator@0.9.4)(oxlint@1.73.0)(rolldown@1.1.5)(rollup-plugin-visualizer@7.0.1(rolldown@1.1.5)(rollup@4.62.2))(rollup@4.62.2)(sass@1.99.0)(supports-color@10.2.2)(terser@5.49.0)(tsx@4.23.0)(typescript@6.0.3)(vite@8.1.4(@types/node@26.2.0)(esbuild@0.28.1)(jiti@2.7.0)(sass@1.99.0)(terser@5.49.0)(tsx@4.23.0)(yaml@2.9.0))(vue-tsc@3.3.7(typescript@6.0.3))(yaml@2.9.0)
+        version: 4.4.8(@babel/plugin-syntax-jsx@7.29.7(@babel/core@7.29.7(supports-color@10.2.2)))(@babel/plugin-syntax-typescript@7.29.7(@babel/core@7.29.7(supports-color@10.2.2)))(@oxc-project/types@0.143.0)(@parcel/watcher@2.5.6)(@types/node@26.2.0)(@vercel/functions@3.9.5(ws@8.21.0))(@vue/compiler-sfc@3.5.41)(better-sqlite3@12.10.0)(cac@6.7.14)(db0@0.3.4(better-sqlite3@12.10.0))(esbuild@0.28.1)(eslint@10.4.1(jiti@2.7.0)(supports-color@10.2.2))(ioredis@5.11.1(supports-color@10.2.2))(lightningcss@1.33.0)(magicast@0.5.4)(meow@13.2.0)(optionator@0.9.4)(oxlint@1.73.0)(rolldown@1.1.5)(rollup-plugin-visualizer@7.0.1(rolldown@1.1.5)(rollup@4.62.2))(rollup@4.62.2)(sass@1.99.0)(srvx@0.11.22)(supports-color@10.2.2)(terser@5.49.0)(tsx@4.23.0)(typescript@6.0.3)(vite@8.1.4(@types/node@26.2.0)(esbuild@0.28.1)(jiti@2.7.0)(sass@1.99.0)(terser@5.49.0)(tsx@4.23.0)(yaml@2.9.0))(vue-tsc@3.3.7(typescript@6.0.3))(yaml@2.9.0)
       shiki:
         specifier: 'catalog:'
         version: 4.3.1
@@ -1220,7 +1220,7 @@ importers:
         version: 7.0.22(zod@4.4.3)
       nuxt:
         specifier: 'catalog:'
-        version: 4.4.8(@babel/plugin-syntax-jsx@7.29.7(@babel/core@7.29.7(supports-color@10.2.2)))(@babel/plugin-syntax-typescript@7.29.7(@babel/core@7.29.7(supports-color@10.2.2)))(@oxc-project/types@0.143.0)(@parcel/watcher@2.5.6)(@types/node@26.2.0)(@vercel/functions@3.9.5(ws@8.21.0))(@vue/compiler-sfc@3.5.41)(better-sqlite3@12.10.0)(cac@6.7.14)(db0@0.3.4(better-sqlite3@12.10.0))(esbuild@0.28.1)(eslint@10.4.1(jiti@2.7.0)(supports-color@10.2.2))(ioredis@5.11.1(supports-color@10.2.2))(lightningcss@1.33.0)(magicast@0.5.4)(meow@13.2.0)(optionator@0.9.4)(oxlint@1.73.0)(rolldown@1.1.5)(rollup-plugin-visualizer@7.0.1(rolldown@1.1.5)(rollup@4.62.2))(rollup@4.62.2)(sass@1.99.0)(supports-color@10.2.2)(terser@5.49.0)(tsx@4.23.0)(typescript@6.0.3)(vite@8.1.4(@types/node@26.2.0)(esbuild@0.28.1)(jiti@2.7.0)(sass@1.99.0)(terser@5.49.0)(tsx@4.23.0)(yaml@2.9.0))(vue-tsc@3.3.7(typescript@6.0.3))(yaml@2.9.0)
+        version: 4.4.8(@babel/plugin-syntax-jsx@7.29.7(@babel/core@7.29.7(supports-color@10.2.2)))(@babel/plugin-syntax-typescript@7.29.7(@babel/core@7.29.7(supports-color@10.2.2)))(@oxc-project/types@0.143.0)(@parcel/watcher@2.5.6)(@types/node@26.2.0)(@vercel/functions@3.9.5(ws@8.21.0))(@vue/compiler-sfc@3.5.41)(better-sqlite3@12.10.0)(cac@6.7.14)(db0@0.3.4(better-sqlite3@12.10.0))(esbuild@0.28.1)(eslint@10.4.1(jiti@2.7.0)(supports-color@10.2.2))(ioredis@5.11.1(supports-color@10.2.2))(lightningcss@1.33.0)(magicast@0.5.4)(meow@13.2.0)(optionator@0.9.4)(oxlint@1.73.0)(rolldown@1.1.5)(rollup-plugin-visualizer@7.0.1(rolldown@1.1.5)(rollup@4.62.2))(rollup@4.62.2)(sass@1.99.0)(srvx@0.11.22)(supports-color@10.2.2)(terser@5.49.0)(tsx@4.23.0)(typescript@6.0.3)(vite@8.1.4(@types/node@26.2.0)(esbuild@0.28.1)(jiti@2.7.0)(sass@1.99.0)(terser@5.49.0)(tsx@4.23.0)(yaml@2.9.0))(vue-tsc@3.3.7(typescript@6.0.3))(yaml@2.9.0)
 
   packages/comark:
     dependencies:
@@ -1278,7 +1278,7 @@ importers:
         version: 8.1.4(@types/node@26.2.0)(esbuild@0.28.1)(jiti@2.7.0)(sass@1.99.0)(terser@5.49.0)(tsx@4.23.0)(yaml@2.9.0)
       vitest:
         specifier: 'catalog:'
-        version: 4.1.10(@opentelemetry/api@1.9.1)(@types/node@26.2.0)(@vitest/browser-playwright@4.1.10)(vite@8.1.4(@types/node@26.2.0)(esbuild@0.28.1)(jiti@2.7.0)(sass@1.99.0)(terser@5.49.0)(tsx@4.23.0)(yaml@2.9.0))
+        version: 4.1.10(@opentelemetry/api@1.9.1)(@types/node@26.2.0)(@vitest/browser-playwright@4.1.10)(jsdom@30.0.1)(vite@8.1.4(@types/node@26.2.0)(esbuild@0.28.1)(jiti@2.7.0)(sass@1.99.0)(terser@5.49.0)(tsx@4.23.0)(yaml@2.9.0))
 
   packages/comark-angular:
     dependencies:
@@ -1318,7 +1318,7 @@ importers:
         version: 6.0.3
       vitest:
         specifier: 'catalog:'
-        version: 4.1.10(@opentelemetry/api@1.9.1)(@types/node@26.2.0)(@vitest/browser-playwright@4.1.10)(vite@8.1.4(@types/node@26.2.0)(esbuild@0.28.1)(jiti@2.7.0)(sass@1.99.0)(terser@5.49.0)(tsx@4.23.0)(yaml@2.9.0))
+        version: 4.1.10(@opentelemetry/api@1.9.1)(@types/node@26.2.0)(@vitest/browser-playwright@4.1.10)(jsdom@30.0.1)(vite@8.1.4(@types/node@26.2.0)(esbuild@0.28.1)(jiti@2.7.0)(sass@1.99.0)(terser@5.49.0)(tsx@4.23.0)(yaml@2.9.0))
 
   packages/comark-ansi:
     dependencies:
@@ -1337,7 +1337,7 @@ importers:
     devDependencies:
       vitest:
         specifier: 'catalog:'
-        version: 4.1.10(@opentelemetry/api@1.9.1)(@types/node@26.2.0)(@vitest/browser-playwright@4.1.10)(vite@8.1.4(@types/node@26.2.0)(esbuild@0.28.1)(jiti@2.7.0)(sass@1.99.0)(terser@5.49.0)(tsx@4.23.0)(yaml@2.9.0))
+        version: 4.1.10(@opentelemetry/api@1.9.1)(@types/node@26.2.0)(@vitest/browser-playwright@4.1.10)(jsdom@30.0.1)(vite@8.1.4(@types/node@26.2.0)(esbuild@0.28.1)(jiti@2.7.0)(sass@1.99.0)(terser@5.49.0)(tsx@4.23.0)(yaml@2.9.0))
 
   packages/comark-html:
     dependencies:
@@ -1351,12 +1351,15 @@ importers:
       beautiful-mermaid:
         specifier: 'catalog:'
         version: 1.1.3
+      jsdom:
+        specifier: ^30.0.1
+        version: 30.0.1
       katex:
         specifier: ^0.17.0
         version: 0.17.0
       vitest:
         specifier: 'catalog:'
-        version: 4.1.10(@opentelemetry/api@1.9.1)(@types/node@26.2.0)(@vitest/browser-playwright@4.1.10)(vite@8.1.4(@types/node@26.2.0)(esbuild@0.28.1)(jiti@2.7.0)(sass@1.99.0)(terser@5.49.0)(tsx@4.23.0)(yaml@2.9.0))
+        version: 4.1.10(@opentelemetry/api@1.9.1)(@types/node@26.2.0)(@vitest/browser-playwright@4.1.10)(jsdom@30.0.1)(vite@8.1.4(@types/node@26.2.0)(esbuild@0.28.1)(jiti@2.7.0)(sass@1.99.0)(terser@5.49.0)(tsx@4.23.0)(yaml@2.9.0))
 
   packages/comark-nuxt:
     dependencies:
@@ -1378,7 +1381,7 @@ importers:
         version: 3.5.41
       vitest:
         specifier: 'catalog:'
-        version: 4.1.10(@opentelemetry/api@1.9.1)(@types/node@26.2.0)(@vitest/browser-playwright@4.1.10)(vite@8.1.4(@types/node@26.2.0)(esbuild@0.28.1)(jiti@2.7.0)(sass@1.99.0)(terser@5.49.0)(tsx@4.23.0)(yaml@2.9.0))
+        version: 4.1.10(@opentelemetry/api@1.9.1)(@types/node@26.2.0)(@vitest/browser-playwright@4.1.10)(jsdom@30.0.1)(vite@8.1.4(@types/node@26.2.0)(esbuild@0.28.1)(jiti@2.7.0)(sass@1.99.0)(terser@5.49.0)(tsx@4.23.0)(yaml@2.9.0))
       vue:
         specifier: 'catalog:'
         version: 3.5.41(typescript@6.0.3)
@@ -1412,7 +1415,7 @@ importers:
         version: 19.2.7(react@19.2.7)
       vitest:
         specifier: 'catalog:'
-        version: 4.1.10(@opentelemetry/api@1.9.1)(@types/node@26.2.0)(@vitest/browser-playwright@4.1.10)(vite@8.1.4(@types/node@26.2.0)(esbuild@0.28.1)(jiti@2.7.0)(sass@1.99.0)(terser@5.49.0)(tsx@4.23.0)(yaml@2.9.0))
+        version: 4.1.10(@opentelemetry/api@1.9.1)(@types/node@26.2.0)(@vitest/browser-playwright@4.1.10)(jsdom@30.0.1)(vite@8.1.4(@types/node@26.2.0)(esbuild@0.28.1)(jiti@2.7.0)(sass@1.99.0)(terser@5.49.0)(tsx@4.23.0)(yaml@2.9.0))
 
   packages/comark-svelte:
     dependencies:
@@ -1452,7 +1455,7 @@ importers:
         version: 4.7.2(picomatch@4.0.5)(svelte@5.56.4(@typescript-eslint/types@8.63.0))(typescript@6.0.3)
       vitest:
         specifier: 'catalog:'
-        version: 4.1.10(@opentelemetry/api@1.9.1)(@types/node@26.2.0)(@vitest/browser-playwright@4.1.10)(vite@8.1.4(@types/node@26.2.0)(esbuild@0.28.1)(jiti@2.7.0)(sass@1.99.0)(terser@5.49.0)(tsx@4.23.0)(yaml@2.9.0))
+        version: 4.1.10(@opentelemetry/api@1.9.1)(@types/node@26.2.0)(@vitest/browser-playwright@4.1.10)(jsdom@30.0.1)(vite@8.1.4(@types/node@26.2.0)(esbuild@0.28.1)(jiti@2.7.0)(sass@1.99.0)(terser@5.49.0)(tsx@4.23.0)(yaml@2.9.0))
       vitest-browser-svelte:
         specifier: 'catalog:'
         version: 3.0.0(svelte@5.56.4(@typescript-eslint/types@8.63.0))(vitest@4.1.10)
@@ -1483,7 +1486,7 @@ importers:
         version: 8.1.4(@types/node@26.2.0)(esbuild@0.28.1)(jiti@2.7.0)(sass@1.99.0)(terser@5.49.0)(tsx@4.23.0)(yaml@2.9.0)
       vitest:
         specifier: 'catalog:'
-        version: 4.1.10(@opentelemetry/api@1.9.1)(@types/node@26.2.0)(@vitest/browser-playwright@4.1.10)(vite@8.1.4(@types/node@26.2.0)(esbuild@0.28.1)(jiti@2.7.0)(sass@1.99.0)(terser@5.49.0)(tsx@4.23.0)(yaml@2.9.0))
+        version: 4.1.10(@opentelemetry/api@1.9.1)(@types/node@26.2.0)(@vitest/browser-playwright@4.1.10)(jsdom@30.0.1)(vite@8.1.4(@types/node@26.2.0)(esbuild@0.28.1)(jiti@2.7.0)(sass@1.99.0)(terser@5.49.0)(tsx@4.23.0)(yaml@2.9.0))
       vue:
         specifier: 'catalog:'
         version: 3.5.41(typescript@6.0.3)
@@ -1779,6 +1782,14 @@ packages:
     peerDependencies:
       '@types/json-schema': ^7.0.15
 
+  '@asamuzakjp/css-color@6.0.7':
+    resolution: {integrity: sha512-vC/bk1Lz7Tn/EfU9/apOTBk80/8dyGyWMowPoV1tJ52muDGsDqt2HPT2klrFUiY60MQmQv9q8yIht15JnBgDGw==}
+    engines: {node: ^22.13.0 || >=24.0.0}
+
+  '@asamuzakjp/dom-selector@8.3.2':
+    resolution: {integrity: sha512-93Z1N+BQNXysodoicpOIyNh2drHfz/CTf9nnT0FEx72GJcIiwgydD7tGAr78j41LsYn3hlRn+LdGPuBLn1Bl8Q==}
+    engines: {node: ^22.13.0 || >=24.0.0}
+
   '@astrojs/compiler-binding-darwin-arm64@0.3.1':
     resolution: {integrity: sha512-IEmEF2fUIlTHtpeE/isyEGVOB14cEyh/LZOFYt6wn3jNyVpdC8aR5OZ+RzFUR/f+8ZDM1LaMwZKvoA7eMyJeFw==}
     engines: {node: ^20.19.0 || >=22.12.0}
@@ -2047,6 +2058,10 @@ packages:
       commander:
         optional: true
 
+  '@bramus/specificity@2.4.2':
+    resolution: {integrity: sha512-ctxtJ/eA+t+6q2++vj5j7FYX3nRu311q1wfYH3xjlLOsczhlhxAg2FWNUXhpGvAw3BWo1xBcvOV6/YLc2r5FJw==}
+    hasBin: true
+
   '@bruits/satteri-darwin-arm64@0.9.5':
     resolution: {integrity: sha512-iw4nZgx9v30lWo/MTngQqi1pI78KI0DnkSm+lVJGYdmPLgAyDNJigVhpG42/Iq55A6c1Ll8q66ljyyRiQUxwow==}
     cpu: [arm64]
@@ -2162,6 +2177,42 @@ packages:
       conventional-commits-parser:
         optional: true
 
+  '@csstools/color-helpers@6.1.1':
+    resolution: {integrity: sha512-gLNsunvwf3mCi5u5o46/Z/JcJMnhbHSaZ69rkgPzNM3J4s8hWwpPUQB6/tt0EDFyCiWzxANlx+2LJwpYj4zS1w==}
+    engines: {node: '>=20.19.0'}
+
+  '@csstools/css-calc@3.4.0':
+    resolution: {integrity: sha512-XQKj5B7QiZcHiegCOCAzcAOJdhGgWOHbbu62h5e5mkHnn8lWcfiJhllkqWmxu5zWR9jucPHuo1iTB56P033hcg==}
+    engines: {node: '>=20.19.0'}
+    peerDependencies:
+      '@csstools/css-parser-algorithms': ^4.0.0
+      '@csstools/css-tokenizer': ^4.0.0
+
+  '@csstools/css-color-parser@4.2.3':
+    resolution: {integrity: sha512-y4LpL+lmpuyKDiEFq2PnZUVFdAjsoB/qQJod79yLNokXyW7jewi+/WJ69EfItj8A2unWtxXnGjw6LYXgXu5ZjA==}
+    engines: {node: '>=20.19.0'}
+    peerDependencies:
+      '@csstools/css-parser-algorithms': ^4.0.0
+      '@csstools/css-tokenizer': ^4.0.0
+
+  '@csstools/css-parser-algorithms@4.0.0':
+    resolution: {integrity: sha512-+B87qS7fIG3L5h3qwJ/IFbjoVoOe/bpOdh9hAjXbvx0o8ImEmUsGXN0inFOnk2ChCFgqkkGFQ+TpM5rbhkKe4w==}
+    engines: {node: '>=20.19.0'}
+    peerDependencies:
+      '@csstools/css-tokenizer': ^4.0.0
+
+  '@csstools/css-syntax-patches-for-csstree@1.1.13':
+    resolution: {integrity: sha512-i9ZylF5QNhmNfPA9l0vHAWK4kPrbIp6g9lKgaiIFsIBz2F/WNB7OLrzlNNcCOm+h42bkaSD2v1PG+IBPHhc3ZA==}
+    peerDependencies:
+      css-tree: ^3.2.1
+    peerDependenciesMeta:
+      css-tree:
+        optional: true
+
+  '@csstools/css-tokenizer@4.0.0':
+    resolution: {integrity: sha512-QxULHAm7cNu72w97JUNCBFODFaXpbDg+dP8b/oWFAZ2MTRppA3U00Y2L1HqaS4J6yBqxwa/Y3nMBaxVKbB/NsA==}
+    engines: {node: '>=20.19.0'}
+
   '@docsearch/css@3.8.2':
     resolution: {integrity: sha512-y05ayQFyUmCXze79+56v/4HpycYF3uFqB78pLPrSV5ZKAlDuIAAJNhaRi8tTdRNXh05yxX/TyNnzD6LwSM89vQ==}
 
@@ -2700,6 +2751,15 @@ packages:
     resolution: {integrity: sha512-+CNAzxglkrpNf/kKywqQfk74QjtceuOE7Qm+AF8miRvPF/wmmK5+OJOgVh3AVTT3RP2mH3+FOaxlE5v72owk0A==}
     engines: {node: ^20.19.0 || ^22.13.0 || >=24}
 
+  '@exodus/bytes@1.15.1':
+    resolution: {integrity: sha512-S6mL0yNB/Abt9Ei4tq8gDhcczc4S3+vQ4ra7vxnAf+YHC02srtqxKKZghx2Dq6p0e66THKwR6r8N6P95wEty7Q==}
+    engines: {node: ^20.19.0 || ^22.12.0 || >=24.0.0}
+    peerDependencies:
+      '@noble/hashes': ^1.8.0 || ^2.0.0
+    peerDependenciesMeta:
+      '@noble/hashes':
+        optional: true
+
   '@fingerprintjs/botd@2.0.0':
     resolution: {integrity: sha512-yhuz23NKEcBDTHmGz/ULrXlGnbHenO+xZmVwuBkuqHUkqvaZ5TAA0kAgcRy4Wyo5dIBdkIf57UXX8/c9UlMLJg==}
 
@@ -7238,6 +7298,9 @@ packages:
     resolution: {integrity: sha512-CyzaZRQKyHkB2ZInfTTl2nvT33EbDpjkLEbE8/Zck3Ll6O0qqvuGdrJ45HgtH+HykRg88ITY3AdreBGN70aBSQ==}
     engines: {node: 20.x || 22.x || 23.x || 24.x || 25.x || 26.x}
 
+  bidi-js@1.1.0:
+    resolution: {integrity: sha512-fX1Onk0tdVPC7obPWB5EbJ1z7NVhLq4m2xZLq2YXBkxzMXIGRpNMU88n0EPgWseKl12J7zXs7qrDxPK4sRs2fg==}
+
   bindings@1.5.0:
     resolution: {integrity: sha512-p2q/t/mhvuOj/UeLlV6566GD/guowlr0hHxClI0W9m7MWYkL1F0hLo+0Aexs9HSPCtR1SXQ0TD3MMKrXZajbiQ==}
 
@@ -7726,6 +7789,10 @@ packages:
     resolution: {integrity: sha512-CuRUx0TXGSbbWdEci3VK/XOZGP3n0P4pIKpsqpVtBqaIIuj3GKK8H45oAqA4Rg8FHipc+CzRdUzmD4YQXxv66Q==}
     engines: {node: '>= 14'}
 
+  data-urls@7.0.0:
+    resolution: {integrity: sha512-23XHcCF+coGYevirZceTVD7NdJOqVn+49IHyxgszm+JIiHLoB2TkmPtsYkNWT1pvRSGkc35L6NHs0yHkN2SumA==}
+    engines: {node: ^20.19.0 || ^22.12.0 || >=24.0.0}
+
   db0@0.3.4:
     resolution: {integrity: sha512-RiXXi4WaNzPTHEOu8UPQKMooIbqOEyqA1t7Z6MsdxSCeb8iUC9ko3LcmsLmeUt2SM5bctfArZKkRQggKZz7JNw==}
     peerDependencies:
@@ -7758,6 +7825,9 @@ packages:
       supports-color:
         optional: true
 
+  decimal.js@10.6.0:
+    resolution: {integrity: sha512-YpgQiITW3JXGntzdUmyUR1V812Hn8T1YVXhCu+wO3OpS4eU9l4YdD3qjyiKdV6mvV29zapkMeD390UVEf2lkUg==}
+
   decode-named-character-reference@1.3.0:
     resolution: {integrity: sha512-GtpQYB283KrPp6nRw50q3U9/VfOutZOe103qlN7BPP6Ad27xYnOIWv4lPzo8HCAL+mMZofJ9KEy30fq6MfaK6Q==}
 
@@ -8563,6 +8633,10 @@ packages:
     resolution: {integrity: sha512-Rw/B2DNQaPBICNXEm8balFz9a6WpZrkCGpcWFpy7nCj+NyhSdqXipmfvtmWt9xGfp0wZnBxB+iVpLmQMYt47Tw==}
     engines: {node: ^18.17.0 || >=20.5.0}
 
+  html-encoding-sniffer@6.0.0:
+    resolution: {integrity: sha512-CV9TW3Y3f8/wT0BRFc1/KAVQ3TUHiXmaAb6VW9vtiMFf7SLoMd1PdAc4W3KFOFETBJUb90KatHqlsZMWV+R9Gg==}
+    engines: {node: ^20.19.0 || ^22.12.0 || >=24.0.0}
+
   html-escaper@3.0.3:
     resolution: {integrity: sha512-RuMffC89BOWQoY0WKGpIhn5gX3iI54O6nRA0yC124NYVtzjmFWBIiFd8M0x+ZdX0P9R4lADg1mgP8C7PxGOWuQ==}
 
@@ -8768,6 +8842,9 @@ packages:
     resolution: {integrity: sha512-+Pgi+vMuUNkJyExiMBt5IlFoMyKnr5zhJ4Uspz58WOhBF5QoIZkFyNHIbBAtHwzVAgk5RtndVNsDRN61/mmDqg==}
     engines: {node: '>=12'}
 
+  is-potential-custom-element-name@1.0.1:
+    resolution: {integrity: sha512-bCYeRA2rVibKZd+s2625gGnGF/t7DSqDs4dP7CrLA1m7jKWz6pps0LpYLJN8Q64HtmPKJ1hrN3nzPNKFEKOUiQ==}
+
   is-promise@4.0.0:
     resolution: {integrity: sha512-hvpoI6korhJMnej285dSg6nu1+e6uxs7zG3BYAm5byqDsgJNWwxzM6z6iZiAgQR4TJ30JmBTOwqZUw3WlyH3AQ==}
 
@@ -8878,6 +8955,15 @@ packages:
     resolution: {integrity: sha512-muutsYr+e2+d3rTgUGslq5rxbBlUy3cJ61IsHag2QNDQV+7zXWjkUpmALIajhrlLlrgRUiymj6U3zUr/TMK84Q==}
     hasBin: true
 
+  jsdom@30.0.1:
+    resolution: {integrity: sha512-52v7mUVUfNQVYYqE1lcdaymWL0njO7lTLUog6ZvW2U5KsbiLk/GnZlVJ+qx0xfNJZ6Gn+KSpPNE52vurbxZwrA==}
+    engines: {node: ^22.22.2 || ^24.15.0 || >=26.0.0}
+    peerDependencies:
+      canvas: ^3.2.3
+    peerDependenciesMeta:
+      canvas:
+        optional: true
+
   jsesc@3.1.0:
     resolution: {integrity: sha512-/sM3dO2FOzXjKQhJuo0Q173wf2KOo8t4I8vHy6lF9poUp7bKT0/NHE8fPX23PwfhnykfqnC2xRxOnVw5XuGIaA==}
     engines: {node: '>=6'}
@@ -9171,8 +9257,8 @@ packages:
   lru-cache@10.4.3:
     resolution: {integrity: sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ==}
 
-  lru-cache@11.5.1:
-    resolution: {integrity: sha512-RPimw/7aMdv2oqRrxKwvZXcPfwBrn/JZ2xYcY9Hus/6LaS3VOAKVWKWgNLCFSiOm1ESXinjsDlidVU7JlnCN2A==}
+  lru-cache@11.5.2:
+    resolution: {integrity: sha512-4pfM1Ff0x50o0tQwb5ucw/RzNyD0/YJME6IVcStalZuMWxdt3sR3huStTtxz4PUmvZfRguvDejasvQ2kifR11g==}
     engines: {node: 20 || >=22}
 
   lru-cache@5.1.1:
@@ -10649,6 +10735,10 @@ packages:
     resolution: {integrity: sha512-6R3J5M4AcbtLUdZmRv2SygeVaM7IhrLXu9BmnOGmmACak8fiUtOsYNWUS4uK7upbmHIBbLBeFeI//477BKLBzA==}
     engines: {node: '>=11.0.0'}
 
+  saxes@6.0.0:
+    resolution: {integrity: sha512-xAg7SOnEhrm5zI3puOOKyy1OMcMlIJZYNJY7xLBwSze0UjhPLnWfj2GF2EpT0jmzaJKIWKHLsaSSajf35bcYnA==}
+    engines: {node: '>=v12.22.7'}
+
   scheduler@0.27.0:
     resolution: {integrity: sha512-eNv+WrVbKu1f3vbYJT/xtiF5syA5HPIMtf9IgY/nKg0sWqzAUEvqY/xm7OcZc/qafLx/iO9FgOmeSAp4v5ti/Q==}
 
@@ -11023,6 +11113,9 @@ packages:
     peerDependencies:
       vue: '>=3.2.26 < 4'
 
+  symbol-tree@3.2.4:
+    resolution: {integrity: sha512-9QNk5KwDF+Bvz+PyObkmSYjI5ksVUYtjW7AU22r2NKcfLJcXp96hkDWU3+XndOsUb+AQ9QhfzfCT2O+CNWT5Tw==}
+
   tabbable@6.4.0:
     resolution: {integrity: sha512-05PUHKSNE8ou2dwIxTngl4EzcnsCDZGJ/iCLtDflR/SHB/ny14rXc+qU5P4mG9JkusiV7EivzY9Mhm55AzAvCg==}
 
@@ -11115,6 +11208,13 @@ packages:
     resolution: {integrity: sha512-Bf+ILmBgretUrdJxzXM0SgXLZ3XfiaUuOj/IKQHuTXip+05Xn+uyEYdVg0kYDipTBcLrCVyUzAPz7QmArb0mmw==}
     engines: {node: '>=14.0.0'}
 
+  tldts-core@7.4.13:
+    resolution: {integrity: sha512-mbYsrih5FRtGxs3Usvl/PqwJsNpp+jsmrdFviiK02teHDG0/HebBG/pqCylje3kzgXYzuLoHJF/0mz9W53t8Xg==}
+
+  tldts@7.4.13:
+    resolution: {integrity: sha512-iHtaIWWIbMDkCeJdTBzZFGgbluE5J+oHlb2g7+oAz1S1gpuVpabRZdQyd471Vl8UUkcz2vXSL8xZH2kyCe8tfA==}
+    hasBin: true
+
   to-buffer@1.2.2:
     resolution: {integrity: sha512-db0E3UJjcFhpDhAF4tLo03oli3pwl3dbnzXOUIlRKrp+ldk/VUxzpWYZENsw2SZiuBjHAk7DfB0VU7NKdpb6sw==}
     engines: {node: '>= 0.4'}
@@ -11131,9 +11231,17 @@ packages:
     resolution: {integrity: sha512-sf4i37nQ2LBx4m3wB74y+ubopq6W/dIzXg0FDGjsYnZHVa1Da8FH853wlL2gtUhg+xJXjfk3kUZS3BRoQeoQBQ==}
     engines: {node: '>=6'}
 
+  tough-cookie@6.0.2:
+    resolution: {integrity: sha512-exgYmnmL/sJpR3upZfXG5PoatXQii55xAiXGXzY+sROLZ/Y+SLcp9PgJNI9Vz37HpQ74WvDcLT8eqm+kV3FzrA==}
+    engines: {node: '>=16'}
+
   tr46@0.0.3:
     resolution: {integrity: sha512-N3WMsuqV66lT30CrXNbEjx4GEwlow3v6rr4mCcv6prnfwhS01rkgyFdjPNBYd9br7LpXV1+Emh01fHnq2Gdgrw==}
 
+  tr46@6.0.0:
+    resolution: {integrity: sha512-bLVMLPtstlZ4iMQHpFHTR7GAGj2jxi8Dg0s2h2MafAE4uSWF98FC/3MomU51iQAMf8/qDUbKWf5GxuvvVcXEhw==}
+    engines: {node: '>=20'}
+
   trim-lines@3.0.1:
     resolution: {integrity: sha512-kRj8B+YHZCc9kQYdWfJB2/oUl9rA99qbowYYBtr4ui4mZyAQ2JpvVBd/6U2YloATfqBhBTSMhTpgBHtU0Mf3Rg==}
 
@@ -11253,6 +11361,10 @@ packages:
     resolution: {integrity: sha512-cRZYrTDwWznlnRiPjggAGxZXanty6M8RV1ff8Wm4LWXBp7/IG8v5DnOm74DtUBp9OONpK75YlPnIjQqX0dBDtA==}
     engines: {node: '>=20.18.1'}
 
+  undici@8.10.2:
+    resolution: {integrity: sha512-/y4/bH9YNU5hi9NIrpOuvGXFcxrj3CMrV+/AYpowAYTpHn8gX/XPFjNy766FPoYY0miQhdW977JFWKGNhBdwyQ==}
+    engines: {node: '>=22.19.0'}
+
   unenv@2.0.0-rc.24:
     resolution: {integrity: sha512-i7qRCmY42zmCwnYlh9H2SvLEypEFGye5iRmEMKjcGi7zk9UquigRjFtTLz0TYqr0ZGLZhaMHl/foy1bZR+Cwlw==}
 
@@ -11912,6 +12024,10 @@ packages:
   w3c-keyname@2.2.8:
     resolution: {integrity: sha512-dpojBhNsCNN7T82Tm7k26A6G9ML3NkhDsnw9n/eoxSRlVBB4CEtIQ/KTCLI2Fwf3ataSXRhYFkQi3SlnFwPvPQ==}
 
+  w3c-xmlserializer@5.0.0:
+    resolution: {integrity: sha512-o8qghlI8NZHU1lLPrpi2+Uq7abh4GGPpYANlalzWxyWteJOCsr/P+oPBA49TOLu5FTZO4d3F9MnWJfiMo4BkmA==}
+    engines: {node: '>=18'}
+
   walk-up-path@4.0.0:
     resolution: {integrity: sha512-3hu+tD8YzSLGuFYtPRb48vdhKMi0KQV5sn+uWr8+7dMEq/2G/dtLrdDinkLjqq5TIbIBjYJ4Ax/n3YiaW7QM8A==}
     engines: {node: 20 || >=22}
@@ -11929,9 +12045,25 @@ packages:
   webidl-conversions@3.0.1:
     resolution: {integrity: sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ==}
 
+  webidl-conversions@8.0.1:
+    resolution: {integrity: sha512-BMhLD/Sw+GbJC21C/UgyaZX41nPt8bUTg+jWyDeg7e7YN4xOM05YPSIXceACnXVtqyEw/LMClUQMtMZ+PGGpqQ==}
+    engines: {node: '>=20'}
+
   webpack-virtual-modules@0.6.2:
     resolution: {integrity: sha512-66/V2i5hQanC51vBQKPH4aI8NMAcBW59FVBs+rC7eGHupMyfn34q7rZIE+ETlJ+XTevqfUhVVBgSUNSW2flEUQ==}
 
+  whatwg-mimetype@5.0.0:
+    resolution: {integrity: sha512-sXcNcHOC51uPGF0P/D4NVtrkjSU2fNsm9iog4ZvZJsL3rjoDAzXZhkm2MWt1y+PUdggKAYVoMAIYcs78wJ51Cw==}
+    engines: {node: '>=20'}
+
+  whatwg-url@16.0.1:
+    resolution: {integrity: sha512-1to4zXBxmXHV3IiSSEInrreIlu02vUOvrhxJJH5vcxYTBDAx51cqZiKdyTxlecdKNSjj8EcxGBxNf6Vg+945gw==}
+    engines: {node: ^20.19.0 || ^22.12.0 || >=24.0.0}
+
+  whatwg-url@17.1.1:
+    resolution: {integrity: sha512-ohjk1mdUebJVadRt3bAhQhx8lSnISq+GDttK79LFl8EHQkAPvzwctoasC4hs8tBt6kLAncBWWyq1N52qEfKvDw==}
+    engines: {node: ^22.14.0 || >=24.0.0}
+
   whatwg-url@5.0.0:
     resolution: {integrity: sha512-saE57nupxk6v3HY35+jzBwYa0rKSy0XR8JSxZPwgLr7ys0IBzhGviA1/TUGJLmSVqs8pb9AnvICXEuOHLprYTw==}
 
@@ -12019,10 +12151,17 @@ packages:
     resolution: {integrity: sha512-sID0rrVCqkVNUn8t6xuv9+6FViXjUVXq8H5rWOH2rz9fDNQEd4g0EA2XlcEdJXRz5BMEn4O1pJFdT+z4YHhoWw==}
     engines: {node: '>= 6'}
 
+  xml-name-validator@5.0.0:
+    resolution: {integrity: sha512-EvGK8EJ3DhaHfbRlETOWAS5pO9MZITeauHKJyb8wyajUfQUenkIg2MvLDTZ4T/TgIcm3HU0TFBgWWboAZ30UHg==}
+    engines: {node: '>=18'}
+
   xml-naming@0.3.0:
     resolution: {integrity: sha512-ghig2TBE/H11aOVgmahA3MhimvkBr6JIYknH/Dhdk10nXwdbIqBJsbfMxpvFPG8bAw77gN29aQWvKpmVoPlvPQ==}
     engines: {node: '>=16.0.0'}
 
+  xmlchars@2.2.0:
+    resolution: {integrity: sha512-JZnDKK8B0RCDw84FNdDAIpZK+JuJw+s7Lz8nksI7SIuU3UXJJslUthsi+uWBUYOwPFwW7W7PRLRfUKpxjtjFCw==}
+
   xmlhttprequest-ssl@2.1.2:
     resolution: {integrity: sha512-TEU+nJVUUnA4CYJFLvK5X9AOeH4KvDvhIfm0vV1GaQRtchnG0hgK5p8hw/xjv8cunWYCsiPCSDzObPyhEwq3KQ==}
     engines: {node: '>=0.4.0'}
@@ -12363,7 +12502,7 @@ snapshots:
       lmdb: 3.5.4
       postcss: 8.5.25
       tailwindcss: 4.3.3
-      vitest: 4.1.10(@opentelemetry/api@1.9.1)(@types/node@26.2.0)(@vitest/browser-playwright@4.1.10)(vite@8.1.4(@types/node@26.2.0)(esbuild@0.28.1)(jiti@2.7.0)(sass@1.99.0)(terser@5.49.0)(tsx@4.23.0)(yaml@2.9.0))
+      vitest: 4.1.10(@opentelemetry/api@1.9.1)(@types/node@26.2.0)(@vitest/browser-playwright@4.1.10)(jsdom@30.0.1)(vite@8.1.4(@types/node@26.2.0)(esbuild@0.28.1)(jiti@2.7.0)(sass@1.99.0)(terser@5.49.0)(tsx@4.23.0)(yaml@2.9.0))
     transitivePeerDependencies:
       - '@types/node'
       - chokidar
@@ -12454,6 +12593,21 @@ snapshots:
       js-yaml: 4.3.0
     optional: true
 
+  '@asamuzakjp/css-color@6.0.7':
+    dependencies:
+      '@csstools/css-calc': 3.4.0(@csstools/css-parser-algorithms@4.0.0(@csstools/css-tokenizer@4.0.0))(@csstools/css-tokenizer@4.0.0)
+      '@csstools/css-color-parser': 4.2.3(@csstools/css-parser-algorithms@4.0.0(@csstools/css-tokenizer@4.0.0))(@csstools/css-tokenizer@4.0.0)
+      '@csstools/css-parser-algorithms': 4.0.0(@csstools/css-tokenizer@4.0.0)
+      '@csstools/css-tokenizer': 4.0.0
+      lru-cache: 11.5.2
+
+  '@asamuzakjp/dom-selector@8.3.2':
+    dependencies:
+      bidi-js: 1.1.0
+      css-tree: 3.2.1
+      is-potential-custom-element-name: 1.0.1
+      lru-cache: 11.5.2
+
   '@astrojs/compiler-binding-darwin-arm64@0.3.1':
     optional: true
 
@@ -12806,6 +12960,10 @@ snapshots:
       cac: 6.7.14
       citty: 0.2.2
 
+  '@bramus/specificity@2.4.2':
+    dependencies:
+      css-tree: 3.2.1
+
   '@bruits/satteri-darwin-arm64@0.9.5':
     optional: true
 
@@ -12906,6 +13064,30 @@ snapshots:
       conventional-commits-filter: 5.0.0
       conventional-commits-parser: 6.4.0
 
+  '@csstools/color-helpers@6.1.1': {}
+
+  '@csstools/css-calc@3.4.0(@csstools/css-parser-algorithms@4.0.0(@csstools/css-tokenizer@4.0.0))(@csstools/css-tokenizer@4.0.0)':
+    dependencies:
+      '@csstools/css-parser-algorithms': 4.0.0(@csstools/css-tokenizer@4.0.0)
+      '@csstools/css-tokenizer': 4.0.0
+
+  '@csstools/css-color-parser@4.2.3(@csstools/css-parser-algorithms@4.0.0(@csstools/css-tokenizer@4.0.0))(@csstools/css-tokenizer@4.0.0)':
+    dependencies:
+      '@csstools/color-helpers': 6.1.1
+      '@csstools/css-calc': 3.4.0(@csstools/css-parser-algorithms@4.0.0(@csstools/css-tokenizer@4.0.0))(@csstools/css-tokenizer@4.0.0)
+      '@csstools/css-parser-algorithms': 4.0.0(@csstools/css-tokenizer@4.0.0)
+      '@csstools/css-tokenizer': 4.0.0
+
+  '@csstools/css-parser-algorithms@4.0.0(@csstools/css-tokenizer@4.0.0)':
+    dependencies:
+      '@csstools/css-tokenizer': 4.0.0
+
+  '@csstools/css-syntax-patches-for-csstree@1.1.13(css-tree@3.2.1)':
+    optionalDependencies:
+      css-tree: 3.2.1
+
+  '@csstools/css-tokenizer@4.0.0': {}
+
   '@docsearch/css@3.8.2': {}
 
   '@docsearch/js@3.8.2(@algolia/client-search@5.53.0)(search-insights@2.17.3)':
@@ -13269,6 +13451,8 @@ snapshots:
       levn: 0.4.1
     optional: true
 
+  '@exodus/bytes@1.15.1': {}
+
   '@fingerprintjs/botd@2.0.0': {}
 
   '@floating-ui/core@1.8.0':
@@ -14647,7 +14831,7 @@ snapshots:
       - rolldown
       - unplugin
 
-  '@nuxt/nitro-server@4.4.8(99e75d27f8827d00078f30ade7064a9d)':
+  '@nuxt/nitro-server@4.4.8(6c886773a873212c591ea262ba7f6dc4)':
     dependencies:
       '@nuxt/devalue': 2.0.2
       '@nuxt/kit': 4.4.8(magicast@0.5.4)
@@ -14661,11 +14845,11 @@ snapshots:
       escape-string-regexp: 5.0.0
       exsolve: 1.1.1
       h3: 1.15.11
-      impound: 1.1.5(esbuild@0.28.1)(rolldown@1.1.5)(rollup@4.62.2)(vite@8.1.4(@types/node@26.2.0)(esbuild@0.28.1)(jiti@2.7.0)(sass@1.99.0)(terser@5.49.0)(tsx@4.23.0)(yaml@2.9.0))
+      impound: 1.1.5(esbuild@0.28.1)(rolldown@1.1.5)(rollup@4.62.2)(vite@8.1.4(@types/node@26.1.1)(esbuild@0.28.1)(jiti@2.7.0)(sass@1.99.0)(terser@5.49.0)(tsx@4.23.0)(yaml@2.9.0))
       klona: 2.0.6
       mocked-exports: 0.1.1
-      nitropack: 2.13.4(@vercel/functions@3.9.5(ws@8.21.0))(better-sqlite3@12.10.0)(oxc-parser@0.133.0)(rolldown@1.1.5)(supports-color@10.2.2)(vite@8.1.4(@types/node@26.2.0)(esbuild@0.28.1)(jiti@2.7.0)(sass@1.99.0)(terser@5.49.0)(tsx@4.23.0)(yaml@2.9.0))
-      nuxt: 4.4.8(@babel/plugin-syntax-jsx@7.29.7(@babel/core@7.29.7(supports-color@10.2.2)))(@babel/plugin-syntax-typescript@7.29.7(@babel/core@7.29.7(supports-color@10.2.2)))(@oxc-project/types@0.143.0)(@parcel/watcher@2.5.6)(@types/node@26.2.0)(@vercel/functions@3.9.5(ws@8.21.0))(@vue/compiler-sfc@3.5.41)(better-sqlite3@12.10.0)(cac@6.7.14)(db0@0.3.4(better-sqlite3@12.10.0))(esbuild@0.28.1)(eslint@10.4.1(jiti@2.7.0)(supports-color@10.2.2))(ioredis@5.11.1(supports-color@10.2.2))(lightningcss@1.33.0)(magicast@0.5.4)(meow@13.2.0)(optionator@0.9.4)(oxlint@1.73.0)(rolldown@1.1.5)(rollup-plugin-visualizer@7.0.1(rolldown@1.1.5)(rollup@4.62.2))(rollup@4.62.2)(sass@1.99.0)(supports-color@10.2.2)(terser@5.49.0)(tsx@4.23.0)(typescript@6.0.3)(vite@8.1.4(@types/node@26.2.0)(esbuild@0.28.1)(jiti@2.7.0)(sass@1.99.0)(terser@5.49.0)(tsx@4.23.0)(yaml@2.9.0))(vue-tsc@3.3.7(typescript@6.0.3))(yaml@2.9.0)
+      nitropack: 2.13.4(@vercel/functions@3.9.5(ws@8.21.0))(better-sqlite3@12.10.0)(oxc-parser@0.133.0)(rolldown@1.1.5)(srvx@0.11.22)(supports-color@10.2.2)(vite@8.1.4(@types/node@26.1.1)(esbuild@0.28.1)(jiti@2.7.0)(sass@1.99.0)(terser@5.49.0)(tsx@4.23.0)(yaml@2.9.0))
+      nuxt: 4.4.8(@babel/plugin-syntax-jsx@7.29.7(@babel/core@7.29.7(supports-color@10.2.2)))(@babel/plugin-syntax-typescript@7.29.7(@babel/core@7.29.7(supports-color@10.2.2)))(@oxc-project/types@0.143.0)(@parcel/watcher@2.5.6)(@types/node@26.1.1)(@vercel/functions@3.9.5(ws@8.21.0))(@vue/compiler-sfc@3.5.41)(better-sqlite3@12.10.0)(cac@6.7.14)(db0@0.3.4(better-sqlite3@12.10.0))(esbuild@0.28.1)(eslint@10.4.1(jiti@2.7.0)(supports-color@10.2.2))(ioredis@5.11.1(supports-color@10.2.2))(lightningcss@1.33.0)(magicast@0.5.4)(meow@13.2.0)(optionator@0.9.4)(oxlint@1.73.0)(rolldown@1.1.5)(rollup-plugin-visualizer@7.0.1(rolldown@1.1.5)(rollup@4.62.2))(rollup@4.62.2)(sass@1.99.0)(srvx@0.11.22)(supports-color@10.2.2)(terser@5.49.0)(tsx@4.23.0)(typescript@6.0.3)(vite@8.1.4(@types/node@26.1.1)(esbuild@0.28.1)(jiti@2.7.0)(sass@1.99.0)(terser@5.49.0)(tsx@4.23.0)(yaml@2.9.0))(vue-tsc@3.3.7(typescript@6.0.3))(yaml@2.9.0)
       nypm: 0.6.9
       ohash: 2.0.12
       pathe: 2.0.3
@@ -14803,84 +14987,6 @@ snapshots:
       - webpack
       - xml2js
 
-  '@nuxt/nitro-server@4.4.8(f703643dae20cb0f567d0525f9f5d11d)':
-    dependencies:
-      '@nuxt/devalue': 2.0.2
-      '@nuxt/kit': 4.4.8(magicast@0.5.4)
-      '@unhead/vue': 2.1.15(vue@3.5.41(typescript@6.0.3))
-      '@vue/shared': 3.5.41
-      consola: 3.4.2
-      defu: 6.1.7
-      destr: 2.0.5
-      devalue: 5.9.0
-      errx: 0.1.2
-      escape-string-regexp: 5.0.0
-      exsolve: 1.1.1
-      h3: 1.15.11
-      impound: 1.1.5(esbuild@0.28.1)(rolldown@1.1.5)(rollup@4.62.2)(vite@8.1.4(@types/node@26.1.1)(esbuild@0.28.1)(jiti@2.7.0)(sass@1.99.0)(terser@5.49.0)(tsx@4.23.0)(yaml@2.9.0))
-      klona: 2.0.6
-      mocked-exports: 0.1.1
-      nitropack: 2.13.4(@vercel/functions@3.9.5(ws@8.21.0))(better-sqlite3@12.10.0)(oxc-parser@0.133.0)(rolldown@1.1.5)(supports-color@10.2.2)(vite@8.1.4(@types/node@26.1.1)(esbuild@0.28.1)(jiti@2.7.0)(sass@1.99.0)(terser@5.49.0)(tsx@4.23.0)(yaml@2.9.0))
-      nuxt: 4.4.8(@babel/plugin-syntax-jsx@7.29.7(@babel/core@7.29.7(supports-color@10.2.2)))(@babel/plugin-syntax-typescript@7.29.7(@babel/core@7.29.7(supports-color@10.2.2)))(@oxc-project/types@0.143.0)(@parcel/watcher@2.5.6)(@types/node@26.1.1)(@vercel/functions@3.9.5(ws@8.21.0))(@vue/compiler-sfc@3.5.41)(better-sqlite3@12.10.0)(cac@6.7.14)(db0@0.3.4(better-sqlite3@12.10.0))(esbuild@0.28.1)(eslint@10.4.1(jiti@2.7.0)(supports-color@10.2.2))(ioredis@5.11.1(supports-color@10.2.2))(lightningcss@1.33.0)(magicast@0.5.4)(meow@13.2.0)(optionator@0.9.4)(oxlint@1.73.0)(rolldown@1.1.5)(rollup-plugin-visualizer@7.0.1(rolldown@1.1.5)(rollup@4.62.2))(rollup@4.62.2)(sass@1.99.0)(supports-color@10.2.2)(terser@5.49.0)(tsx@4.23.0)(typescript@6.0.3)(vite@8.1.4(@types/node@26.1.1)(esbuild@0.28.1)(jiti@2.7.0)(sass@1.99.0)(terser@5.49.0)(tsx@4.23.0)(yaml@2.9.0))(vue-tsc@3.3.7(typescript@6.0.3))(yaml@2.9.0)
-      nypm: 0.6.9
-      ohash: 2.0.12
-      pathe: 2.0.3
-      rou3: 0.8.1
-      std-env: 4.2.0
-      ufo: 1.6.4
-      unctx: 2.5.0
-      unstorage: 1.17.5(@vercel/functions@3.9.5(ws@8.21.0))(db0@0.3.4(better-sqlite3@12.10.0))(ioredis@5.11.1(supports-color@10.2.2))
-      vue: 3.5.41(typescript@6.0.3)
-      vue-bundle-renderer: 2.3.1
-      vue-devtools-stub: 0.1.0
-    optionalDependencies:
-      '@babel/plugin-syntax-typescript': 7.29.7(@babel/core@7.29.7(supports-color@10.2.2))
-    transitivePeerDependencies:
-      - '@azure/app-configuration'
-      - '@azure/cosmos'
-      - '@azure/data-tables'
-      - '@azure/identity'
-      - '@azure/keyvault-secrets'
-      - '@azure/storage-blob'
-      - '@capacitor/preferences'
-      - '@deno/kv'
-      - '@electric-sql/pglite'
-      - '@farmfe/core'
-      - '@libsql/client'
-      - '@netlify/blobs'
-      - '@planetscale/database'
-      - '@rspack/core'
-      - '@upstash/redis'
-      - '@vercel/blob'
-      - '@vercel/functions'
-      - '@vercel/kv'
-      - aws4fetch
-      - bare-abort-controller
-      - bare-buffer
-      - better-sqlite3
-      - bun-types-no-globals
-      - db0
-      - drizzle-orm
-      - encoding
-      - esbuild
-      - idb-keyval
-      - ioredis
-      - magicast
-      - mysql2
-      - oxc-parser
-      - react-native-b4a
-      - rolldown
-      - rollup
-      - sqlite3
-      - srvx
-      - supports-color
-      - typescript
-      - unloader
-      - uploadthing
-      - vite
-      - webpack
-      - xml2js
-
   '@nuxt/schema@4.4.8':
     dependencies:
       '@vue/shared': 3.5.41
@@ -15270,7 +15376,7 @@ snapshots:
       - vue
       - webpack
 
-  '@nuxt/vite-builder@4.4.8(05f217bab9492dae9cee6b9ce20db355)':
+  '@nuxt/vite-builder@4.4.8(514787a70023067bf2f0622c04b5ace5)':
     dependencies:
       '@nuxt/kit': 4.4.8(magicast@0.5.4)
       '@rollup/plugin-replace': 6.0.3(rollup@4.62.2)
@@ -15288,7 +15394,7 @@ snapshots:
       magic-string: 0.30.21
       mlly: 1.8.2
       mocked-exports: 0.1.1
-      nuxt: 4.4.8(@babel/plugin-syntax-jsx@7.29.7(@babel/core@7.29.7(supports-color@10.2.2)))(@babel/plugin-syntax-typescript@7.29.7(@babel/core@7.29.7(supports-color@10.2.2)))(@oxc-project/types@0.143.0)(@parcel/watcher@2.5.6)(@types/node@26.1.1)(@vercel/functions@3.9.5(ws@8.21.0))(@vue/compiler-sfc@3.5.41)(better-sqlite3@12.10.0)(cac@6.7.14)(db0@0.3.4(better-sqlite3@12.10.0))(esbuild@0.28.1)(eslint@10.4.1(jiti@2.7.0)(supports-color@10.2.2))(ioredis@5.11.1(supports-color@10.2.2))(lightningcss@1.33.0)(magicast@0.5.4)(meow@13.2.0)(optionator@0.9.4)(oxlint@1.73.0)(rolldown@1.1.5)(rollup-plugin-visualizer@7.0.1(rolldown@1.1.5)(rollup@4.62.2))(rollup@4.62.2)(sass@1.99.0)(supports-color@10.2.2)(terser@5.49.0)(tsx@4.23.0)(typescript@6.0.3)(vite@8.1.4(@types/node@26.1.1)(esbuild@0.28.1)(jiti@2.7.0)(sass@1.99.0)(terser@5.49.0)(tsx@4.23.0)(yaml@2.9.0))(vue-tsc@3.3.7(typescript@6.0.3))(yaml@2.9.0)
+      nuxt: 4.4.8(@babel/plugin-syntax-jsx@7.29.7(@babel/core@7.29.7(supports-color@10.2.2)))(@babel/plugin-syntax-typescript@7.29.7(@babel/core@7.29.7(supports-color@10.2.2)))(@oxc-project/types@0.143.0)(@parcel/watcher@2.5.6)(@types/node@26.1.1)(@vercel/functions@3.9.5(ws@8.21.0))(@vue/compiler-sfc@3.5.41)(better-sqlite3@12.10.0)(cac@6.7.14)(db0@0.3.4(better-sqlite3@12.10.0))(esbuild@0.28.1)(eslint@10.4.1(jiti@2.7.0)(supports-color@10.2.2))(ioredis@5.11.1(supports-color@10.2.2))(lightningcss@1.33.0)(magicast@0.5.4)(meow@13.2.0)(optionator@0.9.4)(oxlint@1.73.0)(rolldown@1.1.5)(rollup-plugin-visualizer@7.0.1(rolldown@1.1.5)(rollup@4.62.2))(rollup@4.62.2)(sass@1.99.0)(srvx@0.11.22)(supports-color@10.2.2)(terser@5.49.0)(tsx@4.23.0)(typescript@6.0.3)(vite@8.1.4(@types/node@26.1.1)(esbuild@0.28.1)(jiti@2.7.0)(sass@1.99.0)(terser@5.49.0)(tsx@4.23.0)(yaml@2.9.0))(vue-tsc@3.3.7(typescript@6.0.3))(yaml@2.9.0)
       nypm: 0.6.9
       pathe: 2.0.3
       pkg-types: 2.3.1
@@ -15390,66 +15496,6 @@ snapshots:
       - vue-tsc
       - yaml
 
-  '@nuxt/vite-builder@4.4.8(918c3c402a48f5ef9691fc6ec5f84f06)':
-    dependencies:
-      '@nuxt/kit': 4.4.8(magicast@0.5.4)
-      '@rollup/plugin-replace': 6.0.3(rollup@4.62.2)
-      '@vitejs/plugin-vue': 6.0.8(vite@7.3.6(@types/node@26.2.0)(jiti@2.7.0)(lightningcss@1.33.0)(sass@1.99.0)(terser@5.49.0)(tsx@4.23.0)(yaml@2.9.0))(vue@3.5.41(typescript@6.0.3))
-      '@vitejs/plugin-vue-jsx': 5.1.6(supports-color@10.2.2)(vite@7.3.6(@types/node@26.2.0)(jiti@2.7.0)(lightningcss@1.33.0)(sass@1.99.0)(terser@5.49.0)(tsx@4.23.0)(yaml@2.9.0))(vue@3.5.41(typescript@6.0.3))
-      autoprefixer: 10.5.2(postcss@8.5.25)
-      consola: 3.4.2
-      cssnano: 8.0.2(postcss@8.5.25)
-      defu: 6.1.7
-      escape-string-regexp: 5.0.0
-      exsolve: 1.1.1
-      get-port-please: 3.2.0
-      jiti: 2.7.0
-      knitwork: 1.3.0
-      magic-string: 0.30.21
-      mlly: 1.8.2
-      mocked-exports: 0.1.1
-      nuxt: 4.4.8(@babel/plugin-syntax-jsx@7.29.7(@babel/core@7.29.7(supports-color@10.2.2)))(@babel/plugin-syntax-typescript@7.29.7(@babel/core@7.29.7(supports-color@10.2.2)))(@oxc-project/types@0.143.0)(@parcel/watcher@2.5.6)(@types/node@26.2.0)(@vercel/functions@3.9.5(ws@8.21.0))(@vue/compiler-sfc@3.5.41)(better-sqlite3@12.10.0)(cac@6.7.14)(db0@0.3.4(better-sqlite3@12.10.0))(esbuild@0.28.1)(eslint@10.4.1(jiti@2.7.0)(supports-color@10.2.2))(ioredis@5.11.1(supports-color@10.2.2))(lightningcss@1.33.0)(magicast@0.5.4)(meow@13.2.0)(optionator@0.9.4)(oxlint@1.73.0)(rolldown@1.1.5)(rollup-plugin-visualizer@7.0.1(rolldown@1.1.5)(rollup@4.62.2))(rollup@4.62.2)(sass@1.99.0)(supports-color@10.2.2)(terser@5.49.0)(tsx@4.23.0)(typescript@6.0.3)(vite@8.1.4(@types/node@26.2.0)(esbuild@0.28.1)(jiti@2.7.0)(sass@1.99.0)(terser@5.49.0)(tsx@4.23.0)(yaml@2.9.0))(vue-tsc@3.3.7(typescript@6.0.3))(yaml@2.9.0)
-      nypm: 0.6.9
-      pathe: 2.0.3
-      pkg-types: 2.3.1
-      postcss: 8.5.25
-      seroval: 1.5.5
-      std-env: 4.2.0
-      ufo: 1.6.4
-      unenv: 2.0.0-rc.24
-      unplugin: 2.3.11
-      vite: 7.3.6(@types/node@26.2.0)(jiti@2.7.0)(lightningcss@1.33.0)(sass@1.99.0)(terser@5.49.0)(tsx@4.23.0)(yaml@2.9.0)
-      vite-node: 5.3.0(@types/node@26.2.0)(jiti@2.7.0)(lightningcss@1.33.0)(sass@1.99.0)(terser@5.49.0)(tsx@4.23.0)(yaml@2.9.0)
-      vite-plugin-checker: 0.14.4(eslint@10.4.1(jiti@2.7.0)(supports-color@10.2.2))(meow@13.2.0)(optionator@0.9.4)(oxlint@1.73.0)(typescript@6.0.3)(vite@7.3.6(@types/node@26.2.0)(jiti@2.7.0)(lightningcss@1.33.0)(sass@1.99.0)(terser@5.49.0)(tsx@4.23.0)(yaml@2.9.0))(vue-tsc@3.3.7(typescript@6.0.3))
-      vue: 3.5.41(typescript@6.0.3)
-      vue-bundle-renderer: 2.3.1
-    optionalDependencies:
-      '@babel/plugin-syntax-jsx': 7.29.7(@babel/core@7.29.7(supports-color@10.2.2))
-      rolldown: 1.1.5
-      rollup-plugin-visualizer: 7.0.1(rolldown@1.1.5)(rollup@4.62.2)
-    transitivePeerDependencies:
-      - '@biomejs/biome'
-      - '@types/node'
-      - eslint
-      - less
-      - lightningcss
-      - magicast
-      - meow
-      - optionator
-      - oxlint
-      - rollup
-      - sass
-      - sass-embedded
-      - stylelint
-      - stylus
-      - sugarss
-      - supports-color
-      - terser
-      - tsx
-      - typescript
-      - vue-tsc
-      - yaml
-
   '@nuxtjs/color-mode@4.0.1(magic-string@0.30.21)(magicast@0.5.4)(oxc-parser@0.143.0)(rolldown@1.1.5)(unplugin@3.3.0(esbuild@0.28.1)(rolldown@1.1.5)(rollup@4.62.2)(vite@8.1.4(@types/node@26.2.0)(esbuild@0.28.1)(jiti@2.7.0)(sass@1.99.0)(terser@5.49.0)(tsx@4.23.0)(yaml@2.9.0)))':
     dependencies:
       '@nuxt/kit': 4.5.2(magic-string@0.30.21)(magicast@0.5.4)(oxc-parser@0.143.0)(rolldown@1.1.5)(unplugin@3.3.0(esbuild@0.28.1)(rolldown@1.1.5)(rollup@4.62.2)(vite@8.1.4(@types/node@26.2.0)(esbuild@0.28.1)(jiti@2.7.0)(sass@1.99.0)(terser@5.49.0)(tsx@4.23.0)(yaml@2.9.0)))
@@ -17674,7 +17720,7 @@ snapshots:
       '@vitest/mocker': 4.1.10(vite@8.1.4(@types/node@26.1.1)(esbuild@0.28.1)(jiti@2.7.0)(sass@1.99.0)(terser@5.49.0)(tsx@4.23.0)(yaml@2.9.0))
       playwright: 1.61.1
       tinyrainbow: 3.1.0
-      vitest: 4.1.10(@opentelemetry/api@1.9.1)(@types/node@26.1.1)(@vitest/browser-playwright@4.1.10)(vite@8.1.4(@types/node@26.1.1)(esbuild@0.28.1)(jiti@2.7.0)(sass@1.99.0)(terser@5.49.0)(tsx@4.23.0)(yaml@2.9.0))
+      vitest: 4.1.10(@opentelemetry/api@1.9.1)(@types/node@26.1.1)(@vitest/browser-playwright@4.1.10)(jsdom@30.0.1)(vite@8.1.4(@types/node@26.1.1)(esbuild@0.28.1)(jiti@2.7.0)(sass@1.99.0)(terser@5.49.0)(tsx@4.23.0)(yaml@2.9.0))
     transitivePeerDependencies:
       - bufferutil
       - msw
@@ -17688,7 +17734,7 @@ snapshots:
       '@vitest/mocker': 4.1.10(vite@8.1.4(@types/node@26.2.0)(esbuild@0.28.1)(jiti@2.7.0)(sass@1.99.0)(terser@5.49.0)(tsx@4.23.0)(yaml@2.9.0))
       playwright: 1.61.1
       tinyrainbow: 3.1.0
-      vitest: 4.1.10(@opentelemetry/api@1.9.1)(@types/node@26.2.0)(@vitest/browser-playwright@4.1.10)(vite@8.1.4(@types/node@26.2.0)(esbuild@0.28.1)(jiti@2.7.0)(sass@1.99.0)(terser@5.49.0)(tsx@4.23.0)(yaml@2.9.0))
+      vitest: 4.1.10(@opentelemetry/api@1.9.1)(@types/node@26.2.0)(@vitest/browser-playwright@4.1.10)(jsdom@30.0.1)(vite@8.1.4(@types/node@26.2.0)(esbuild@0.28.1)(jiti@2.7.0)(sass@1.99.0)(terser@5.49.0)(tsx@4.23.0)(yaml@2.9.0))
     transitivePeerDependencies:
       - bufferutil
       - msw
@@ -17704,7 +17750,7 @@ snapshots:
       pngjs: 7.0.0
       sirv: 3.0.2
       tinyrainbow: 3.1.0
-      vitest: 4.1.10(@opentelemetry/api@1.9.1)(@types/node@26.1.1)(@vitest/browser-playwright@4.1.10)(vite@8.1.4(@types/node@26.1.1)(esbuild@0.28.1)(jiti@2.7.0)(sass@1.99.0)(terser@5.49.0)(tsx@4.23.0)(yaml@2.9.0))
+      vitest: 4.1.10(@opentelemetry/api@1.9.1)(@types/node@26.1.1)(@vitest/browser-playwright@4.1.10)(jsdom@30.0.1)(vite@8.1.4(@types/node@26.1.1)(esbuild@0.28.1)(jiti@2.7.0)(sass@1.99.0)(terser@5.49.0)(tsx@4.23.0)(yaml@2.9.0))
       ws: 8.21.0
     transitivePeerDependencies:
       - bufferutil
@@ -17722,7 +17768,7 @@ snapshots:
       pngjs: 7.0.0
       sirv: 3.0.2
       tinyrainbow: 3.1.0
-      vitest: 4.1.10(@opentelemetry/api@1.9.1)(@types/node@26.2.0)(@vitest/browser-playwright@4.1.10)(vite@8.1.4(@types/node@26.2.0)(esbuild@0.28.1)(jiti@2.7.0)(sass@1.99.0)(terser@5.49.0)(tsx@4.23.0)(yaml@2.9.0))
+      vitest: 4.1.10(@opentelemetry/api@1.9.1)(@types/node@26.2.0)(@vitest/browser-playwright@4.1.10)(jsdom@30.0.1)(vite@8.1.4(@types/node@26.2.0)(esbuild@0.28.1)(jiti@2.7.0)(sass@1.99.0)(terser@5.49.0)(tsx@4.23.0)(yaml@2.9.0))
       ws: 8.21.0
     transitivePeerDependencies:
       - bufferutil
@@ -18404,6 +18450,10 @@ snapshots:
       prebuild-install: 7.1.3
     optional: true
 
+  bidi-js@1.1.0:
+    dependencies:
+      require-from-string: 2.0.2
+
   bindings@1.5.0:
     dependencies:
       file-uri-to-path: 1.0.0
@@ -19087,6 +19137,13 @@ snapshots:
 
   data-uri-to-buffer@7.0.0: {}
 
+  data-urls@7.0.0:
+    dependencies:
+      whatwg-mimetype: 5.0.0
+      whatwg-url: 16.0.1
+    transitivePeerDependencies:
+      - '@noble/hashes'
+
   db0@0.3.4(better-sqlite3@12.10.0):
     optionalDependencies:
       better-sqlite3: 12.10.0
@@ -19097,6 +19154,8 @@ snapshots:
     optionalDependencies:
       supports-color: 10.2.2
 
+  decimal.js@10.6.0: {}
+
   decode-named-character-reference@1.3.0:
     dependencies:
       character-entities: 2.0.2
@@ -20152,6 +20211,12 @@ snapshots:
     dependencies:
       lru-cache: 10.4.3
 
+  html-encoding-sniffer@6.0.0:
+    dependencies:
+      '@exodus/bytes': 1.15.1
+    transitivePeerDependencies:
+      - '@noble/hashes'
+
   html-escaper@3.0.3: {}
 
   html-void-elements@3.0.0: {}
@@ -20368,6 +20433,8 @@ snapshots:
 
   is-plain-obj@4.1.0: {}
 
+  is-potential-custom-element-name@1.0.1: {}
+
   is-promise@4.0.0: {}
 
   is-reference@1.2.1:
@@ -20483,6 +20550,32 @@ snapshots:
     dependencies:
       argparse: 2.0.1
 
+  jsdom@30.0.1:
+    dependencies:
+      '@asamuzakjp/css-color': 6.0.7
+      '@asamuzakjp/dom-selector': 8.3.2
+      '@bramus/specificity': 2.4.2
+      '@csstools/css-syntax-patches-for-csstree': 1.1.13(css-tree@3.2.1)
+      '@exodus/bytes': 1.15.1
+      css-tree: 3.2.1
+      data-urls: 7.0.0
+      decimal.js: 10.6.0
+      html-encoding-sniffer: 6.0.0
+      is-potential-custom-element-name: 1.0.1
+      lru-cache: 11.5.2
+      parse5: 8.0.1
+      saxes: 6.0.0
+      symbol-tree: 3.2.4
+      tough-cookie: 6.0.2
+      undici: 8.10.2
+      w3c-xmlserializer: 5.0.0
+      webidl-conversions: 8.0.1
+      whatwg-mimetype: 5.0.0
+      whatwg-url: 17.1.1
+      xml-name-validator: 5.0.0
+    transitivePeerDependencies:
+      - '@noble/hashes'
+
   jsesc@3.1.0: {}
 
   json-buffer@3.0.1:
@@ -20757,7 +20850,7 @@ snapshots:
 
   lru-cache@10.4.3: {}
 
-  lru-cache@11.5.1: {}
+  lru-cache@11.5.2: {}
 
   lru-cache@5.1.1:
     dependencies:
@@ -21307,118 +21400,7 @@ snapshots:
       - '@babel/core'
       - babel-plugin-macros
 
-  nitropack@2.13.4(@vercel/functions@3.9.5(ws@8.21.0))(better-sqlite3@12.10.0)(oxc-parser@0.133.0)(rolldown@1.1.5)(srvx@0.11.22)(supports-color@10.2.2)(vite@8.1.4(@types/node@26.2.0)(esbuild@0.28.1)(jiti@2.7.0)(sass@1.99.0)(terser@5.49.0)(tsx@4.23.0)(yaml@2.9.0)):
-    dependencies:
-      '@cloudflare/kv-asset-handler': 0.4.2
-      '@rollup/plugin-alias': 6.0.0(rollup@4.62.2)
-      '@rollup/plugin-commonjs': 29.0.3(rollup@4.62.2)
-      '@rollup/plugin-inject': 5.0.5(rollup@4.62.2)
-      '@rollup/plugin-json': 6.1.0(rollup@4.62.2)
-      '@rollup/plugin-node-resolve': 16.0.3(rollup@4.62.2)
-      '@rollup/plugin-replace': 6.0.3(rollup@4.62.2)
-      '@rollup/plugin-terser': 1.0.0(rollup@4.62.2)
-      '@vercel/nft': 1.10.2(rollup@4.62.2)(supports-color@10.2.2)
-      archiver: 7.0.1
-      c12: 3.3.4(magicast@0.5.4)
-      chokidar: 5.0.0
-      citty: 0.2.2
-      compatx: 0.2.0
-      confbox: 0.2.4
-      consola: 3.4.2
-      cookie-es: 2.0.1
-      croner: 10.0.1
-      crossws: 0.3.5
-      db0: 0.3.4(better-sqlite3@12.10.0)
-      defu: 6.1.7
-      destr: 2.0.5
-      dot-prop: 10.1.0
-      esbuild: 0.28.1
-      escape-string-regexp: 5.0.0
-      etag: 1.8.1
-      exsolve: 1.1.1
-      globby: 16.2.0
-      gzip-size: 7.0.0
-      h3: 1.15.11
-      hookable: 5.5.3
-      httpxy: 0.5.3
-      ioredis: 5.11.1(supports-color@10.2.2)
-      jiti: 2.7.0
-      klona: 2.0.6
-      knitwork: 1.3.0
-      listhen: 1.10.0(srvx@0.11.22)
-      magic-string: 0.30.21
-      magicast: 0.5.4
-      mime: 4.1.0
-      mlly: 1.8.2
-      node-fetch-native: 1.6.7
-      node-mock-http: 1.0.4
-      ofetch: 1.5.1
-      ohash: 2.0.12
-      pathe: 2.0.3
-      perfect-debounce: 2.1.0
-      pkg-types: 2.3.1
-      pretty-bytes: 7.1.0
-      radix3: 1.1.2
-      rollup: 4.62.2
-      rollup-plugin-visualizer: 7.0.1(rolldown@1.1.5)(rollup@4.62.2)
-      scule: 1.3.0
-      semver: 7.8.5
-      serve-placeholder: 2.0.2
-      serve-static: 2.2.1(supports-color@10.2.2)
-      source-map: 0.7.6
-      std-env: 4.2.0
-      ufo: 1.6.4
-      ultrahtml: 1.7.0
-      uncrypto: 0.1.3
-      unctx: 2.5.0
-      unenv: 2.0.0-rc.24
-      unimport: 6.4.0(esbuild@0.28.1)(oxc-parser@0.133.0)(rolldown@1.1.5)(rollup@4.62.2)(vite@8.1.4(@types/node@26.2.0)(esbuild@0.28.1)(jiti@2.7.0)(sass@1.99.0)(terser@5.49.0)(tsx@4.23.0)(yaml@2.9.0))
-      unplugin-utils: 0.3.2
-      unstorage: 1.17.5(@vercel/functions@3.9.5(ws@8.21.0))(db0@0.3.4(better-sqlite3@12.10.0))(ioredis@5.11.1(supports-color@10.2.2))
-      untyped: 2.0.0
-      unwasm: 0.5.3
-      youch: 4.1.1
-      youch-core: 0.3.3
-    transitivePeerDependencies:
-      - '@azure/app-configuration'
-      - '@azure/cosmos'
-      - '@azure/data-tables'
-      - '@azure/identity'
-      - '@azure/keyvault-secrets'
-      - '@azure/storage-blob'
-      - '@capacitor/preferences'
-      - '@deno/kv'
-      - '@electric-sql/pglite'
-      - '@farmfe/core'
-      - '@libsql/client'
-      - '@netlify/blobs'
-      - '@planetscale/database'
-      - '@rspack/core'
-      - '@upstash/redis'
-      - '@vercel/blob'
-      - '@vercel/functions'
-      - '@vercel/kv'
-      - aws4fetch
-      - bare-abort-controller
-      - bare-buffer
-      - better-sqlite3
-      - bun-types-no-globals
-      - drizzle-orm
-      - encoding
-      - idb-keyval
-      - mysql2
-      - oxc-parser
-      - react-native-b4a
-      - rolldown
-      - sqlite3
-      - srvx
-      - supports-color
-      - unloader
-      - uploadthing
-      - vite
-      - webpack
-
-  nitropack@2.13.4(@vercel/functions@3.9.5(ws@8.21.0))(better-sqlite3@12.10.0)(oxc-parser@0.133.0)(rolldown@1.1.5)(supports-color@10.2.2)(vite@8.1.4(@types/node@26.1.1)(esbuild@0.28.1)(jiti@2.7.0)(sass@1.99.0)(terser@5.49.0)(tsx@4.23.0)(yaml@2.9.0)):
+  nitropack@2.13.4(@vercel/functions@3.9.5(ws@8.21.0))(better-sqlite3@12.10.0)(oxc-parser@0.133.0)(rolldown@1.1.5)(srvx@0.11.22)(supports-color@10.2.2)(vite@8.1.4(@types/node@26.1.1)(esbuild@0.28.1)(jiti@2.7.0)(sass@1.99.0)(terser@5.49.0)(tsx@4.23.0)(yaml@2.9.0)):
     dependencies:
       '@cloudflare/kv-asset-handler': 0.4.2
       '@rollup/plugin-alias': 6.0.0(rollup@4.62.2)
@@ -21529,7 +21511,7 @@ snapshots:
       - vite
       - webpack
 
-  nitropack@2.13.4(@vercel/functions@3.9.5(ws@8.21.0))(better-sqlite3@12.10.0)(oxc-parser@0.133.0)(rolldown@1.1.5)(supports-color@10.2.2)(vite@8.1.4(@types/node@26.2.0)(esbuild@0.28.1)(jiti@2.7.0)(sass@1.99.0)(terser@5.49.0)(tsx@4.23.0)(yaml@2.9.0)):
+  nitropack@2.13.4(@vercel/functions@3.9.5(ws@8.21.0))(better-sqlite3@12.10.0)(oxc-parser@0.133.0)(rolldown@1.1.5)(srvx@0.11.22)(supports-color@10.2.2)(vite@8.1.4(@types/node@26.2.0)(esbuild@0.28.1)(jiti@2.7.0)(sass@1.99.0)(terser@5.49.0)(tsx@4.23.0)(yaml@2.9.0)):
     dependencies:
       '@cloudflare/kv-asset-handler': 0.4.2
       '@rollup/plugin-alias': 6.0.0(rollup@4.62.2)
@@ -21988,16 +21970,16 @@ snapshots:
       - vite
       - zod
 
-  nuxt@4.4.8(@babel/plugin-syntax-jsx@7.29.7(@babel/core@7.29.7(supports-color@10.2.2)))(@babel/plugin-syntax-typescript@7.29.7(@babel/core@7.29.7(supports-color@10.2.2)))(@oxc-project/types@0.143.0)(@parcel/watcher@2.5.6)(@types/node@26.1.1)(@vercel/functions@3.9.5(ws@8.21.0))(@vue/compiler-sfc@3.5.41)(better-sqlite3@12.10.0)(cac@6.7.14)(db0@0.3.4(better-sqlite3@12.10.0))(esbuild@0.28.1)(eslint@10.4.1(jiti@2.7.0)(supports-color@10.2.2))(ioredis@5.11.1(supports-color@10.2.2))(lightningcss@1.33.0)(magicast@0.5.4)(meow@13.2.0)(optionator@0.9.4)(oxlint@1.73.0)(rolldown@1.1.5)(rollup-plugin-visualizer@7.0.1(rolldown@1.1.5)(rollup@4.62.2))(rollup@4.62.2)(sass@1.99.0)(supports-color@10.2.2)(terser@5.49.0)(tsx@4.23.0)(typescript@6.0.3)(vite@8.1.4(@types/node@26.1.1)(esbuild@0.28.1)(jiti@2.7.0)(sass@1.99.0)(terser@5.49.0)(tsx@4.23.0)(yaml@2.9.0))(vue-tsc@3.3.7(typescript@6.0.3))(yaml@2.9.0):
+  nuxt@4.4.8(@babel/plugin-syntax-jsx@7.29.7(@babel/core@7.29.7(supports-color@10.2.2)))(@babel/plugin-syntax-typescript@7.29.7(@babel/core@7.29.7(supports-color@10.2.2)))(@oxc-project/types@0.143.0)(@parcel/watcher@2.5.6)(@types/node@26.1.1)(@vercel/functions@3.9.5(ws@8.21.0))(@vue/compiler-sfc@3.5.41)(better-sqlite3@12.10.0)(cac@6.7.14)(db0@0.3.4(better-sqlite3@12.10.0))(esbuild@0.28.1)(eslint@10.4.1(jiti@2.7.0)(supports-color@10.2.2))(ioredis@5.11.1(supports-color@10.2.2))(lightningcss@1.33.0)(magicast@0.5.4)(meow@13.2.0)(optionator@0.9.4)(oxlint@1.73.0)(rolldown@1.1.5)(rollup-plugin-visualizer@7.0.1(rolldown@1.1.5)(rollup@4.62.2))(rollup@4.62.2)(sass@1.99.0)(srvx@0.11.22)(supports-color@10.2.2)(terser@5.49.0)(tsx@4.23.0)(typescript@6.0.3)(vite@8.1.4(@types/node@26.1.1)(esbuild@0.28.1)(jiti@2.7.0)(sass@1.99.0)(terser@5.49.0)(tsx@4.23.0)(yaml@2.9.0))(vue-tsc@3.3.7(typescript@6.0.3))(yaml@2.9.0):
     dependencies:
       '@dxup/nuxt': 0.4.1(magic-string@0.30.21)(magicast@0.5.4)(oxc-parser@0.133.0)(rolldown@1.1.5)(typescript@6.0.3)(unplugin@3.3.0(esbuild@0.28.1)(rolldown@1.1.5)(rollup@4.62.2)(vite@8.1.4(@types/node@26.1.1)(esbuild@0.28.1)(jiti@2.7.0)(sass@1.99.0)(terser@5.49.0)(tsx@4.23.0)(yaml@2.9.0)))
       '@nuxt/cli': 3.36.1(@nuxt/schema@4.4.8)(cac@6.7.14)(magicast@0.5.4)(supports-color@10.2.2)
       '@nuxt/devtools': 3.2.4(magic-string@0.30.21)(oxc-parser@0.133.0)(rolldown@1.1.5)(supports-color@10.2.2)(unplugin@3.3.0(esbuild@0.28.1)(rolldown@1.1.5)(rollup@4.62.2)(vite@8.1.4(@types/node@26.1.1)(esbuild@0.28.1)(jiti@2.7.0)(sass@1.99.0)(terser@5.49.0)(tsx@4.23.0)(yaml@2.9.0)))(vite@8.1.4(@types/node@26.1.1)(esbuild@0.28.1)(jiti@2.7.0)(sass@1.99.0)(terser@5.49.0)(tsx@4.23.0)(yaml@2.9.0))(vue@3.5.41(typescript@6.0.3))
       '@nuxt/kit': 4.4.8(magicast@0.5.4)
-      '@nuxt/nitro-server': 4.4.8(f703643dae20cb0f567d0525f9f5d11d)
+      '@nuxt/nitro-server': 4.4.8(6c886773a873212c591ea262ba7f6dc4)
       '@nuxt/schema': 4.4.8
       '@nuxt/telemetry': 2.8.0(@nuxt/kit@4.4.8(magicast@0.5.4))
-      '@nuxt/vite-builder': 4.4.8(05f217bab9492dae9cee6b9ce20db355)
+      '@nuxt/vite-builder': 4.4.8(514787a70023067bf2f0622c04b5ace5)
       '@unhead/vue': 2.1.15(vue@3.5.41(typescript@6.0.3))
       '@vue/shared': 3.5.41
       chokidar: 5.0.0
@@ -22260,142 +22242,6 @@ snapshots:
       - xml2js
       - yaml
 
-  nuxt@4.4.8(@babel/plugin-syntax-jsx@7.29.7(@babel/core@7.29.7(supports-color@10.2.2)))(@babel/plugin-syntax-typescript@7.29.7(@babel/core@7.29.7(supports-color@10.2.2)))(@oxc-project/types@0.143.0)(@parcel/watcher@2.5.6)(@types/node@26.2.0)(@vercel/functions@3.9.5(ws@8.21.0))(@vue/compiler-sfc@3.5.41)(better-sqlite3@12.10.0)(cac@6.7.14)(db0@0.3.4(better-sqlite3@12.10.0))(esbuild@0.28.1)(eslint@10.4.1(jiti@2.7.0)(supports-color@10.2.2))(ioredis@5.11.1(supports-color@10.2.2))(lightningcss@1.33.0)(magicast@0.5.4)(meow@13.2.0)(optionator@0.9.4)(oxlint@1.73.0)(rolldown@1.1.5)(rollup-plugin-visualizer@7.0.1(rolldown@1.1.5)(rollup@4.62.2))(rollup@4.62.2)(sass@1.99.0)(supports-color@10.2.2)(terser@5.49.0)(tsx@4.23.0)(typescript@6.0.3)(vite@8.1.4(@types/node@26.2.0)(esbuild@0.28.1)(jiti@2.7.0)(sass@1.99.0)(terser@5.49.0)(tsx@4.23.0)(yaml@2.9.0))(vue-tsc@3.3.7(typescript@6.0.3))(yaml@2.9.0):
-    dependencies:
-      '@dxup/nuxt': 0.4.1(magic-string@0.30.21)(magicast@0.5.4)(oxc-parser@0.133.0)(rolldown@1.1.5)(typescript@6.0.3)(unplugin@3.3.0(esbuild@0.28.1)(rolldown@1.1.5)(rollup@4.62.2)(vite@8.1.4(@types/node@26.2.0)(esbuild@0.28.1)(jiti@2.7.0)(sass@1.99.0)(terser@5.49.0)(tsx@4.23.0)(yaml@2.9.0)))
-      '@nuxt/cli': 3.36.1(@nuxt/schema@4.4.8)(cac@6.7.14)(magicast@0.5.4)(supports-color@10.2.2)
-      '@nuxt/devtools': 3.2.4(magic-string@0.30.21)(oxc-parser@0.133.0)(rolldown@1.1.5)(supports-color@10.2.2)(unplugin@3.3.0(esbuild@0.28.1)(rolldown@1.1.5)(rollup@4.62.2)(vite@8.1.4(@types/node@26.2.0)(esbuild@0.28.1)(jiti@2.7.0)(sass@1.99.0)(terser@5.49.0)(tsx@4.23.0)(yaml@2.9.0)))(vite@8.1.4(@types/node@26.2.0)(esbuild@0.28.1)(jiti@2.7.0)(sass@1.99.0)(terser@5.49.0)(tsx@4.23.0)(yaml@2.9.0))(vue@3.5.41(typescript@6.0.3))
-      '@nuxt/kit': 4.4.8(magicast@0.5.4)
-      '@nuxt/nitro-server': 4.4.8(99e75d27f8827d00078f30ade7064a9d)
-      '@nuxt/schema': 4.4.8
-      '@nuxt/telemetry': 2.8.0(@nuxt/kit@4.4.8(magicast@0.5.4))
-      '@nuxt/vite-builder': 4.4.8(918c3c402a48f5ef9691fc6ec5f84f06)
-      '@unhead/vue': 2.1.15(vue@3.5.41(typescript@6.0.3))
-      '@vue/shared': 3.5.41
-      chokidar: 5.0.0
-      compatx: 0.2.0
-      consola: 3.4.2
-      cookie-es: 3.1.1
-      defu: 6.1.7
-      devalue: 5.9.0
-      errx: 0.1.2
-      escape-string-regexp: 5.0.0
-      exsolve: 1.1.1
-      hookable: 6.1.1
-      ignore: 7.0.6
-      impound: 1.1.5(esbuild@0.28.1)(rolldown@1.1.5)(rollup@4.62.2)(vite@8.1.4(@types/node@26.2.0)(esbuild@0.28.1)(jiti@2.7.0)(sass@1.99.0)(terser@5.49.0)(tsx@4.23.0)(yaml@2.9.0))
-      jiti: 2.7.0
-      klona: 2.0.6
-      knitwork: 1.3.0
-      magic-string: 0.30.21
-      mlly: 1.8.2
-      nanotar: 0.3.0
-      nypm: 0.6.9
-      ofetch: 1.5.1
-      ohash: 2.0.12
-      on-change: 6.0.2
-      oxc-minify: 0.133.0
-      oxc-parser: 0.133.0
-      oxc-transform: 0.133.0
-      oxc-walker: 1.1.1(@oxc-project/types@0.143.0)(oxc-parser@0.133.0)(rolldown@1.1.5)
-      pathe: 2.0.3
-      perfect-debounce: 2.1.0
-      picomatch: 4.0.5
-      pkg-types: 2.3.1
-      rou3: 0.8.1
-      scule: 1.3.0
-      semver: 7.8.5
-      std-env: 4.2.0
-      tinyglobby: 0.2.17
-      ufo: 1.6.4
-      ultrahtml: 1.7.0
-      uncrypto: 0.1.3
-      unctx: 2.5.0
-      unhead: 2.1.15
-      unimport: 6.3.0(esbuild@0.28.1)(oxc-parser@0.133.0)(rolldown@1.1.5)(rollup@4.62.2)(vite@8.1.4(@types/node@26.2.0)(esbuild@0.28.1)(jiti@2.7.0)(sass@1.99.0)(terser@5.49.0)(tsx@4.23.0)(yaml@2.9.0))
-      unplugin: 3.3.0(esbuild@0.28.1)(rolldown@1.1.5)(rollup@4.62.2)(vite@8.1.4(@types/node@26.2.0)(esbuild@0.28.1)(jiti@2.7.0)(sass@1.99.0)(terser@5.49.0)(tsx@4.23.0)(yaml@2.9.0))
-      unrouting: 0.1.7
-      untyped: 2.0.0
-      vue: 3.5.41(typescript@6.0.3)
-      vue-router: 5.1.0(@vue/compiler-sfc@3.5.41)(esbuild@0.28.1)(rolldown@1.1.5)(rollup@4.62.2)(vite@8.1.4(@types/node@26.2.0)(esbuild@0.28.1)(jiti@2.7.0)(sass@1.99.0)(terser@5.49.0)(tsx@4.23.0)(yaml@2.9.0))(vue@3.5.41(typescript@6.0.3))
-    optionalDependencies:
-      '@parcel/watcher': 2.5.6
-      '@types/node': 26.2.0
-    transitivePeerDependencies:
-      - '@azure/app-configuration'
-      - '@azure/cosmos'
-      - '@azure/data-tables'
-      - '@azure/identity'
-      - '@azure/keyvault-secrets'
-      - '@azure/storage-blob'
-      - '@babel/plugin-proposal-decorators'
-      - '@babel/plugin-syntax-jsx'
-      - '@babel/plugin-syntax-typescript'
-      - '@biomejs/biome'
-      - '@capacitor/preferences'
-      - '@deno/kv'
-      - '@electric-sql/pglite'
-      - '@farmfe/core'
-      - '@libsql/client'
-      - '@netlify/blobs'
-      - '@oxc-project/types'
-      - '@pinia/colada'
-      - '@planetscale/database'
-      - '@rollup/plugin-babel'
-      - '@rspack/core'
-      - '@upstash/redis'
-      - '@vercel/blob'
-      - '@vercel/functions'
-      - '@vercel/kv'
-      - '@vitejs/devtools'
-      - '@vue/compiler-sfc'
-      - aws4fetch
-      - bare-abort-controller
-      - bare-buffer
-      - better-sqlite3
-      - bufferutil
-      - bun-types-no-globals
-      - cac
-      - commander
-      - db0
-      - drizzle-orm
-      - encoding
-      - esbuild
-      - eslint
-      - idb-keyval
-      - ioredis
-      - less
-      - lightningcss
-      - magicast
-      - meow
-      - mysql2
-      - optionator
-      - oxlint
-      - pinia
-      - react-native-b4a
-      - rolldown
-      - rollup
-      - rollup-plugin-visualizer
-      - sass
-      - sass-embedded
-      - sqlite3
-      - srvx
-      - stylelint
-      - stylus
-      - sugarss
-      - supports-color
-      - terser
-      - tsx
-      - typescript
-      - unloader
-      - uploadthing
-      - utf-8-validate
-      - vite
-      - vue-tsc
-      - webpack
-      - xml2js
-      - yaml
-
   nuxtseo-shared@5.3.14(7d3df3ec54be8d688f0d0e985f2cfe71):
     dependencies:
       '@clack/prompts': 1.7.0
@@ -22846,7 +22692,7 @@ snapshots:
 
   path-scurry@2.0.2:
     dependencies:
-      lru-cache: 11.5.1
+      lru-cache: 11.5.2
       minipass: 7.1.3
 
   path-to-regexp@8.4.2: {}
@@ -23229,8 +23075,7 @@ snapshots:
 
   punycode.js@2.3.1: {}
 
-  punycode@2.3.1:
-    optional: true
+  punycode@2.3.1: {}
 
   qs@6.15.3:
     dependencies:
@@ -23757,6 +23602,10 @@ snapshots:
 
   sax@1.6.0: {}
 
+  saxes@6.0.0:
+    dependencies:
+      xmlchars: 2.2.0
+
   scheduler@0.27.0: {}
 
   scule@1.3.0: {}
@@ -24247,6 +24096,8 @@ snapshots:
     dependencies:
       vue: 3.5.41(typescript@6.0.3)
 
+  symbol-tree@3.2.4: {}
+
   tabbable@6.4.0: {}
 
   tagged-tag@1.0.0: {}
@@ -24350,6 +24201,12 @@ snapshots:
 
   tinyrainbow@3.1.0: {}
 
+  tldts-core@7.4.13: {}
+
+  tldts@7.4.13:
+    dependencies:
+      tldts-core: 7.4.13
+
   to-buffer@1.2.2:
     dependencies:
       isarray: 2.0.5
@@ -24365,8 +24222,16 @@ snapshots:
 
   totalist@3.0.1: {}
 
+  tough-cookie@6.0.2:
+    dependencies:
+      tldts: 7.4.13
+
   tr46@0.0.3: {}
 
+  tr46@6.0.0:
+    dependencies:
+      punycode: 2.3.1
+
   trim-lines@3.0.1: {}
 
   trim-trailing-lines@2.1.0:
@@ -24502,6 +24367,8 @@ snapshots:
 
   undici@7.28.0: {}
 
+  undici@8.10.2: {}
+
   unenv@2.0.0-rc.24:
     dependencies:
       pathe: 2.0.3
@@ -24884,7 +24751,7 @@ snapshots:
       chokidar: 5.0.0
       destr: 2.0.5
       h3: 1.15.11
-      lru-cache: 11.5.1
+      lru-cache: 11.5.2
       node-fetch-native: 1.6.7
       ofetch: 1.5.1
       ufo: 1.6.4
@@ -25284,9 +25151,9 @@ snapshots:
     dependencies:
       '@testing-library/svelte-core': 1.1.3(svelte@5.56.4(@typescript-eslint/types@8.63.0))
       svelte: 5.56.4(@typescript-eslint/types@8.63.0)
-      vitest: 4.1.10(@opentelemetry/api@1.9.1)(@types/node@26.2.0)(@vitest/browser-playwright@4.1.10)(vite@8.1.4(@types/node@26.2.0)(esbuild@0.28.1)(jiti@2.7.0)(sass@1.99.0)(terser@5.49.0)(tsx@4.23.0)(yaml@2.9.0))
+      vitest: 4.1.10(@opentelemetry/api@1.9.1)(@types/node@26.2.0)(@vitest/browser-playwright@4.1.10)(jsdom@30.0.1)(vite@8.1.4(@types/node@26.2.0)(esbuild@0.28.1)(jiti@2.7.0)(sass@1.99.0)(terser@5.49.0)(tsx@4.23.0)(yaml@2.9.0))
 
-  vitest@4.1.10(@opentelemetry/api@1.9.1)(@types/node@26.1.1)(@vitest/browser-playwright@4.1.10)(vite@8.1.4(@types/node@26.1.1)(esbuild@0.28.1)(jiti@2.7.0)(sass@1.99.0)(terser@5.49.0)(tsx@4.23.0)(yaml@2.9.0)):
+  vitest@4.1.10(@opentelemetry/api@1.9.1)(@types/node@26.1.1)(@vitest/browser-playwright@4.1.10)(jsdom@30.0.1)(vite@8.1.4(@types/node@26.1.1)(esbuild@0.28.1)(jiti@2.7.0)(sass@1.99.0)(terser@5.49.0)(tsx@4.23.0)(yaml@2.9.0)):
     dependencies:
       '@vitest/expect': 4.1.10
       '@vitest/mocker': 4.1.10(vite@8.1.4(@types/node@26.1.1)(esbuild@0.28.1)(jiti@2.7.0)(sass@1.99.0)(terser@5.49.0)(tsx@4.23.0)(yaml@2.9.0))
@@ -25312,10 +25179,11 @@ snapshots:
       '@opentelemetry/api': 1.9.1
       '@types/node': 26.1.1
       '@vitest/browser-playwright': 4.1.10(playwright@1.61.1)(vite@8.1.4(@types/node@26.1.1)(esbuild@0.28.1)(jiti@2.7.0)(sass@1.99.0)(terser@5.49.0)(tsx@4.23.0)(yaml@2.9.0))(vitest@4.1.10)
+      jsdom: 30.0.1
     transitivePeerDependencies:
       - msw
 
-  vitest@4.1.10(@opentelemetry/api@1.9.1)(@types/node@26.2.0)(@vitest/browser-playwright@4.1.10)(vite@8.1.4(@types/node@26.2.0)(esbuild@0.28.1)(jiti@2.7.0)(sass@1.99.0)(terser@5.49.0)(tsx@4.23.0)(yaml@2.9.0)):
+  vitest@4.1.10(@opentelemetry/api@1.9.1)(@types/node@26.2.0)(@vitest/browser-playwright@4.1.10)(jsdom@30.0.1)(vite@8.1.4(@types/node@26.2.0)(esbuild@0.28.1)(jiti@2.7.0)(sass@1.99.0)(terser@5.49.0)(tsx@4.23.0)(yaml@2.9.0)):
     dependencies:
       '@vitest/expect': 4.1.10
       '@vitest/mocker': 4.1.10(vite@8.1.4(@types/node@26.2.0)(esbuild@0.28.1)(jiti@2.7.0)(sass@1.99.0)(terser@5.49.0)(tsx@4.23.0)(yaml@2.9.0))
@@ -25341,6 +25209,7 @@ snapshots:
       '@opentelemetry/api': 1.9.1
       '@types/node': 26.2.0
       '@vitest/browser-playwright': 4.1.10(playwright@1.61.1)(vite@8.1.4(@types/node@26.2.0)(esbuild@0.28.1)(jiti@2.7.0)(sass@1.99.0)(terser@5.49.0)(tsx@4.23.0)(yaml@2.9.0))(vitest@4.1.10)
+      jsdom: 30.0.1
     transitivePeerDependencies:
       - msw
 
@@ -25462,6 +25331,10 @@ snapshots:
 
   w3c-keyname@2.2.8: {}
 
+  w3c-xmlserializer@5.0.0:
+    dependencies:
+      xml-name-validator: 5.0.0
+
   walk-up-path@4.0.0: {}
 
   watchpack@2.5.1:
@@ -25477,8 +25350,28 @@ snapshots:
 
   webidl-conversions@3.0.1: {}
 
+  webidl-conversions@8.0.1: {}
+
   webpack-virtual-modules@0.6.2: {}
 
+  whatwg-mimetype@5.0.0: {}
+
+  whatwg-url@16.0.1:
+    dependencies:
+      '@exodus/bytes': 1.15.1
+      tr46: 6.0.0
+      webidl-conversions: 8.0.1
+    transitivePeerDependencies:
+      - '@noble/hashes'
+
+  whatwg-url@17.1.1:
+    dependencies:
+      '@exodus/bytes': 1.15.1
+      tr46: 6.0.0
+      webidl-conversions: 8.0.1
+    transitivePeerDependencies:
+      - '@noble/hashes'
+
   whatwg-url@5.0.0:
     dependencies:
       tr46: 0.0.3
@@ -25565,8 +25458,12 @@ snapshots:
 
   xhr2@0.2.1: {}
 
+  xml-name-validator@5.0.0: {}
+
   xml-naming@0.3.0: {}
 
+  xmlchars@2.2.0: {}
+
   xmlhttprequest-ssl@2.1.2:
     optional: true
 
diff --git a/test/bundle.test.ts b/test/bundle.test.ts
index a6534737..976a1a86 100644
--- a/test/bundle.test.ts
+++ b/test/bundle.test.ts
@@ -60,14 +60,14 @@ describe('package bundle size', { timeout: 60_000 }, () => {
 
     expect(report).toMatchInlineSnapshot(`
       {
-        "@comark/angular": "56.2k (72 files)",
-        "@comark/ansi": "37.3k (98 files)",
-        "@comark/html": "16.5k (58 files)",
+        "@comark/angular": "59.6k (72 files)",
+        "@comark/ansi": "38.1k (98 files)",
+        "@comark/html": "19.4k (60 files)",
         "@comark/nuxt": "11.8k (58 files)",
-        "@comark/react": "37.7k (76 files)",
-        "@comark/svelte": "44.9k (84 files)",
-        "@comark/vue": "56.0k (80 files)",
-        "comark": "368k (158 files)",
+        "@comark/react": "40.5k (76 files)",
+        "@comark/svelte": "47.4k (84 files)",
+        "@comark/vue": "59.3k (80 files)",
+        "comark": "381k (160 files)",
       }
     `)
   })