@barocss/math-editor 0.1.0 → 0.2.0

package/API-SVELTE.md

@@ -0,0 +1,83 @@
+# Svelte API guide
+
+`mathEditor` is a Svelte action around the native DOM editor. Svelte 5 is covered by the integration harness; the package peer range also permits Svelte 4, which is not separately certified.
+
+## Install
+
+```sh
+npm install @barocss/math-editor@0.2.0 svelte
+```
+
+## Complete component
+
+This legacy-syntax component works with Svelte 4 and Svelte 5:
+
+```svelte
+<script lang="ts">
+  import { mathEditor } from '@barocss/math-editor/svelte';
+  import type { DOMMathEditorOptions } from '@barocss/math-editor/dom';
+  import '@barocss/math-editor/style.css';
+
+  let locale = 'en';
+  let latex = '';
+  $: options = {
+    locale,
+    mode: 'inline',
+    toolbar: false,
+    onChange(document, output) {
+      latex = output;
+      // Persist document through your application here.
+    },
+  } satisfies DOMMathEditorOptions;
+</script>
+
+<button on:click={() => locale = locale === 'en' ? 'ko' : 'en'}>Language</button>
+<div use:mathEditor={options}></div>
+<pre>{latex}</pre>
+```
+
+In a Svelte 5 runes component, use `$state` for locale/output and `$derived` for the options object. The action itself is unchanged.
+
+## Action contract
+
+`mathEditor(host, options)` returns `update(next)` and `destroy()`. Svelte invokes these as the action parameter changes and the element is removed. Mutable options merge into the renderer; explicitly use `toolbar: false` to hide tools.
+
+For an external toolbar or loading another document, create one `createMathSession()` per component instance and pass it as `session`. Call `session.load(validatedDocument)` to reset document/history. Use `onDestroy` to release host subscriptions and the external session. Do not expect a changed `defaultValue` or `session` action parameter to remount the editor; use a keyed block for a deliberate remount.
+
+## Popup and SSR
+
+Actions mount in the browser. Avoid `document`, `window` and localStorage at module initialization in SSR applications. A popup should create a fresh draft session and commit only on Apply. `onCancel` is a host notification; it does not close your dialog or revert your data automatically. Keep the action host empty; do not render Svelte children into its editor subtree.
+
+## Svelte 5 runes: session, Undo and saved snapshot
+
+This is a complete runes component, not legacy `$:` syntax. Save retains a structured snapshot in memory; Restore deliberately resets undo history. Replace the in-memory persistence with the storage adapter in the shared API when needed.
+
+```svelte
+<script lang="ts">
+  import { onDestroy } from 'svelte';
+  import { mathEditor } from '@barocss/math-editor/svelte';
+  import { createMathSession, createMathDocument } from '@barocss/math-editor/core';
+  import '@barocss/math-editor/style.css';
+
+  let saved = createMathDocument('x');
+  const session = createMathSession({ document: saved, locale: 'en' });
+  let snapshot = $state(session.getSnapshot());
+  const unsubscribe = session.subscribe(next => { snapshot = next; });
+  onDestroy(() => { unsubscribe(); session.destroy(); });
+</script>
+
+<button disabled={!snapshot.canUndo} onclick={() => session.execute({ type: 'undo' })}>Undo</button>
+<button disabled={!snapshot.canRedo} onclick={() => session.execute({ type: 'redo' })}>Redo</button>
+<button onclick={() => { saved = session.getSnapshot().state.document; }}>Save</button>
+<button onclick={() => session.load(saved)}>Restore saved</button>
+<div use:mathEditor={{ session, locale: 'en' }}></div>
+<pre>{snapshot.latex}</pre>
+```
+
+## Persistence and ownership
+
+Persist the `MathDocument` passed to `onChange`; LaTeX is derived output and is not an editable round-trip format. The package does not parse arbitrary LaTeX. Validate externally supplied JSON before loading it: loading assumes a trusted, structurally valid document with unique IDs. There is no server save or collaboration transport built in.
+
+Keep the mount host empty. The editor owns its descendants; framework rendering into the same host can destroy caret and composition state. Use one editing surface per session. Destroy the renderer on teardown; a session supplied by the host remains the host's responsibility.
+
+See [session and DOM API](API-SESSION.md) for exact options, commands, events and cleanup, and [renderer differences](ADAPTERS.md#current-renderer-parity) before choosing a native wrapper over the rich React editor.

package/API-VUE.md

@@ -0,0 +1,104 @@
+# Vue 3 API guide
+
+The `vMathEditor` directive mounts the native DOM editor. It is not a Vue component and does not implement `v-model`.
+
+## Install
+
+```sh
+npm install @barocss/math-editor@0.2.0 vue
+```
+
+## Complete component
+
+```vue
+<script setup lang="ts">
+import { computed, ref } from 'vue';
+import { vMathEditor } from '@barocss/math-editor/vue';
+import type { MathDocument } from '@barocss/math-editor/core';
+import type { DOMMathEditorOptions } from '@barocss/math-editor/dom';
+import '@barocss/math-editor/style.css';
+
+const locale = ref('en');
+const latex = ref('');
+const saved = ref<MathDocument>();
+const options = computed<DOMMathEditorOptions>(() => ({
+  locale: locale.value,
+  mode: 'inline',
+  toolbar: false,
+  onChange(document, output) {
+    saved.value = document;
+    latex.value = output;
+  },
+}));
+</script>
+
+<template>
+  <button @click="locale = locale === 'en' ? 'ko' : 'en'">Language</button>
+  <div v-math-editor="options"></div>
+  <pre>{{ latex }}</pre>
+</template>
+```
+
+With `<script setup>`, the imported `vMathEditor` is available as `v-math-editor`. Outside script setup, register it under `directives: { mathEditor: vMathEditor }`.
+
+## Lifecycle and document replacement
+
+| Vue hook | Adapter behavior |
+|---|---|
+| `mounted` | `mountMathEditor(host, options)` |
+| `updated` | `editor.update(options)` |
+| `unmounted` | `editor.destroy()` |
+
+Reactive options change locale, mode, toolbar and callbacks without replacing history. `defaultValue` and `session` are mount-only; updating the options object is not a document load.
+
+For commands or opening another document, create one `createMathSession()` instance in setup, pass it as `session` in options, and call `session.load(validatedDocument)`. Register host subscription cleanup and `session.destroy()` with `onUnmounted`. Avoid deeply proxying the session or recreating it inside a computed getter.
+
+## Inline, popup and SSR
+
+Use `mode: 'inline'` and `onCommit`/`onExit` for host caret handoff. In a modal, pass the modal element as mount-only `menuHost` when required by its focus trap. A new modal draft session keeps Cancel from modifying the original. Vue's `mounted` hook runs client-side; browser storage still belongs in your own client lifecycle. Keep the directive host empty and do not combine it with `v-html` or rendered children.
+
+## Document switching, history buttons and explicit save
+
+This complete component uses two trusted in-memory documents. Save stores a snapshot; switching tabs discards unsaved changes and resets history. Add a dirty-state confirmation in a product that must protect unsaved edits. The session is a plain variable, not a deeply reactive object.
+
+```vue
+<script setup lang="ts">
+import { ref, shallowRef, onUnmounted } from 'vue';
+import { vMathEditor } from '@barocss/math-editor/vue';
+import { createMathSession, createMathDocument } from '@barocss/math-editor/core';
+import '@barocss/math-editor/style.css';
+
+const documents = [createMathDocument('x'), createMathDocument('y')];
+const active = ref(0);
+const session = createMathSession({ document: documents[0], locale: 'en' });
+const snapshot = shallowRef(session.getSnapshot());
+const unsubscribe = session.subscribe(next => { snapshot.value = next; });
+const options = { session, locale: 'en' };
+function open(index: number) {
+  active.value = index;
+  session.load(documents[index]);
+}
+function save() {
+  documents[active.value] = session.getSnapshot().state.document;
+}
+onUnmounted(() => { unsubscribe(); session.destroy(); });
+</script>
+
+<template>
+  <button @click="open(0)">Formula A</button>
+  <button @click="open(1)">Formula B</button>
+  <button :disabled="!snapshot.canUndo" @click="session.execute({ type: 'undo' })">Undo</button>
+  <button :disabled="!snapshot.canRedo" @click="session.execute({ type: 'redo' })">Redo</button>
+  <button @click="save">Save formula {{ active + 1 }}</button>
+  <div v-math-editor="options"></div>
+  <pre>{{ snapshot.latex }}</pre>
+</template>
+```
+
+## Persistence and ownership
+
+Persist the `MathDocument` passed to `onChange`; LaTeX is derived output and is not an editable round-trip format. The package does not parse arbitrary LaTeX. Validate externally supplied JSON before loading it: loading assumes a trusted, structurally valid document with unique IDs. There is no server save or collaboration transport built in.
+
+Keep the mount host empty. The editor owns its descendants; framework rendering into the same host can destroy caret and composition state. Use one editing surface per session. Destroy the renderer on teardown; a session supplied by the host remains the host's responsibility.
+
+See [session and DOM API](API-SESSION.md) for exact options, commands, events and cleanup, and [renderer differences](ADAPTERS.md#current-renderer-parity) before choosing a native wrapper over the rich React editor.

package/API-WEB-COMPONENT.md

@@ -0,0 +1,128 @@
+# Web Component API guide
+
+Use the custom element with plain HTML or a framework that can pass DOM properties and listen to native events. It uses the native renderer and light DOM, with no React dependency.
+
+## Install and register
+
+```sh
+npm install @barocss/math-editor@0.2.0
+```
+
+```js
+import { defineMathEditor } from '@barocss/math-editor/web-component';
+import '@barocss/math-editor/style.css';
+defineMathEditor();
+```
+
+```html
+<barocss-math-editor locale="en" mode="inline" toolbar="false"></barocss-math-editor>
+```
+
+Call registration on the client. The default tag is `barocss-math-editor`; `defineMathEditor('my-formula')` registers a custom name. Repeated registration returns the existing constructor. Do not choose a tag another library owns.
+
+## Properties and commands
+
+```ts
+import type { MathEditorElement } from '@barocss/math-editor/web-component';
+import { createMathDocument } from '@barocss/math-editor/core';
+
+const editor = document.querySelector<MathEditorElement>('barocss-math-editor');
+if (!editor) throw new Error('Missing math element');
+editor.value = createMathDocument('x'); // trusted MathDocument, resets undo
+editor.session.execute({ type: 'structure', kind: 'superscript' });
+editor.focusEditor();
+const documentToSave = editor.value; // snapshot copy
+```
+
+Use the `value` **property**, not a JSON HTML attribute. Assigning it opens a new document and resets undo. The `session` property is readonly but its methods are available for commands, subscription and loading.
+
+## Attributes
+
+| Attribute | Values / default |
+|---|---|
+| `locale` | Registered locale code, default `ko` |
+| `mode` | `inline` or `block`; default block |
+| `toolbar` | `false` hides it; otherwise present means visible; absent follows mode |
+| `line-numbers` | `false` hides UI line numbers; otherwise visible |
+| `enter-behavior` | `commit` overrides block newline behavior; otherwise follows mode |
+
+Set inline mode before loading a document. Inline mode rejects multiple top-level rows. Presence-only `toolbar` is true, whereas `toolbar="false"` is false.
+
+## Events
+
+```js
+const save = event => {
+  const { document, latex } = event.detail;
+  console.log(document, latex);
+};
+editor.addEventListener('math-change', save);
+editor.addEventListener('math-commit', event => console.log(event.detail.state.document));
+editor.addEventListener('math-exit', event => console.log(event.detail.direction));
+editor.addEventListener('math-cancel', () => console.log('Host decides whether to close'));
+// On host teardown, remove your own listeners:
+// editor.removeEventListener('math-change', save);
+```
+
+| Event | `detail` |
+|---|---|
+| `math-change` | `{ document, latex }` |
+| `math-commit` | Full `MathSessionSnapshot` |
+| `math-exit` | `{ direction: -1 | 1 }` |
+| `math-cancel` | No detail payload |
+
+Events bubble and are composed. Disconnect destroys the renderer; reconnect restores the same session/document/history. Permanent removal should also release host-owned subscriptions. Shared styles must be loaded in the page because this is light DOM, not a shadow-root widget.
+
+## Complete form integration with JSON and LaTeX outputs
+
+Custom elements do not automatically submit their document as form data. This function builds the form, synchronizes hidden fields, and calls a host callback with `FormData`. It does not assume a backend URL. Pass a trusted initial document and call the returned cleanup on route removal.
+
+```js
+import { defineMathEditor } from '@barocss/math-editor/web-component';
+import '@barocss/math-editor/style.css';
+
+export function mountFormulaForm(host, initialDocument, onSubmit) {
+  defineMathEditor();
+  const form = document.createElement('form');
+  const editor = document.createElement('barocss-math-editor');
+  editor.setAttribute('locale', 'en');
+  editor.value = initialDocument;
+  const json = document.createElement('input');
+  const latex = document.createElement('input');
+  json.type = latex.type = 'hidden';
+  json.name = 'formulaDocument';
+  latex.name = 'formulaLatex';
+  const button = document.createElement('button');
+  button.type = 'submit';
+  button.textContent = 'Save formula';
+  const sync = () => {
+    const snapshot = editor.session.getSnapshot();
+    json.value = JSON.stringify(snapshot.state.document);
+    latex.value = snapshot.latex;
+  };
+  const submit = event => {
+    event.preventDefault();
+    sync(); // Include the initial value even when no edit occurred.
+    onSubmit(new FormData(form));
+  };
+  editor.addEventListener('math-change', sync);
+  form.addEventListener('submit', submit);
+  form.append(editor, json, latex, button);
+  host.append(form);
+  sync();
+  return () => {
+    editor.removeEventListener('math-change', sync);
+    form.removeEventListener('submit', submit);
+    form.remove(); // disconnectedCallback releases the native renderer.
+  };
+}
+```
+
+The JSON field is the editable source; LaTeX is an export. Validate and authorize submitted JSON on your server. Browser form fields are not a trust boundary. The host callback can implement pending/error UI around its own request.
+
+## Persistence and ownership
+
+Persist the `MathDocument` passed to `onChange`; LaTeX is derived output and is not an editable round-trip format. The package does not parse arbitrary LaTeX. Validate externally supplied JSON before loading it: loading assumes a trusted, structurally valid document with unique IDs. There is no server save or collaboration transport built in.
+
+Keep the mount host empty. The editor owns its descendants; framework rendering into the same host can destroy caret and composition state. Use one editing surface per session. Destroy the renderer on teardown; a session supplied by the host remains the host's responsibility.
+
+See [session and DOM API](API-SESSION.md) for exact options, commands, events and cleanup, and [renderer differences](ADAPTERS.md#current-renderer-parity) before choosing a native wrapper over the rich React editor.

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # @barocss/math-editor
 
+## 0.2.0
+
+### Minor Changes
+
+- Add bounded LaTeX import and validated JSON loading with atomic diagnostics and undoable editor imports. Expand editable notation with combined scripts, matrices and cases, integral and limit variants, scalable fences and radicals, accents and brace annotations, explicit sizes, mathematical alphabets, spacing and labeled arrows. Import unnumbered equation wrappers without numbering semantics.
+
+  Improve model-based selection, copying, pasting and wrapping; compact configurable toolbars; and editing typography and focus presentation. Complete English/Korean labels for the new catalog and validate locale pack structure and coverage. Update API, model, syntax, localization and embedding guides. Framework subpaths share this release; unsupported TeX macros, numbering and additional environments remain explicitly excluded.
+
+### Editing and compatibility details
+
+- Preserve combined scripts, delimiter sizing, integral bounds and limit placement. Add norms, multiple/contour integrals, annotations, accents, explicit fraction/binomial sizes, scoped alphabets, fine spacing and labeled arrows.
+- Improve arrow discovery, Korean keyword search, matrix presets, toolbar expansion and focus/spacing geometry using KaTeX comparisons.
+- Import `equation*` as formula content; reject numbering, macros and unsupported environments without modifying the existing document.
+- Keep en/ko message keys inside validated JSON packs. Custom locale dictionaries retain English fallback.
+
 ## 0.1.0
 
 Initial public release.
@@ -11,3 +26,4 @@ Initial public release.
 - English/Korean JSON locale packs and host-registered translations and suggestion aliases.
 
 The native surface has documented feature differences from the rich React editor. See ADAPTERS.md and VALIDATION.md for the supported scope. This release does not parse arbitrary LaTeX or evaluate expressions.
+

package/EMBEDDING.md

@@ -93,3 +93,10 @@ The layout lab demonstrates the interaction contracts; it is not installation in
 Open `/layouts.html` in the math demo. Toggle each optional surface, edit the independent inline example, press Enter to create another host block, and open/cancel/apply the popup. Existing React UI and all framework adapters remain on `/` and `/adapters.html`.
 
 The browser tests cover panel synchronization without extra change events, single-row completion, separate next-block creation, modal mouse suggestions, popup cancellation and one-step undo after applying a draft. OS IME testing remains deferred; this is not a full product integration certification.
+
+
+## Note trial (0.2.0)
+
+Note opts into the shared `LatexEditor` visual mode with `MathEditorSurface`. Existing tex-only atoms load through `parseLatex`; unsupported input stays in the original source editor. Visual draft changes produce `tex` plus JSON-encoded `mathDocument`. `setMathSource` validates the structure, source equality and inline policy, then applies one host transaction. Cancellation writes nothing. Direct source changes clear stale structure, while font/alignment-only edits retain it.
+
+Other products must use the same [import scope](LATEX-SCOPE.md) and core parser. Do not add product-specific regex conversions. Existing Word OMML and Site/Slide ownership boundaries still need their own host adapters; the Note trial does not integrate those products automatically.

package/IMPLEMENTATION.md

@@ -1,5 +1,11 @@
 # Implementation guide
 
+See the [JSON model specification](JSON-MODEL.md) for required fields, exact slot order, invariants and persistence limits.
+
+
+See [LaTeX → JSON model mapping](LATEX-MODEL.md) for node types, slot order and complete conversion examples.
+
+
 ## Ownership and data flow
 
 The host owns document persistence, placement and outer focus. `MathEditor` owns an editing session, its caret, composition draft, model range and up to 100 previous history states. Do not record each internal change into a second host undo stack without a session adapter.
@@ -62,7 +68,7 @@ Pointer hit testing uses token rectangles and mirror text ranges. A drag inside
 
 `wrapRange` accepts one selected row and one of the supported wrapper kinds. It copies that balanced fragment into the new structure and replaces the range through `pasteFragment`. Fraction/power/subscript operations focus their empty second slot. Other wrappers leave the caret after the inserted structure. Power bases receive parentheses unless they are a simple name/number or an already grouped structure. This rule is not a precedence parser and does not infer algebraic equivalence.
 
-The UI disables unsupported structural insertion while a model range is selected. Template insertion explicitly replaces the selection. Contextual wrap tools appear below the surface so their appearance does not move the expression during a drag.
+The UI disables unsupported structural insertion while a model range is selected. Template insertion explicitly replaces the selection. Selection actions use the regular portaled suggestion list beside the selected range. Printable keyboard input replaces a model selection and focuses the resulting input.
 
 ## Clipboard boundary
 
@@ -109,3 +115,128 @@ The existing React renderer still owns its original history and token-level inpu
 The math package and demo source/CSS are consistently formatted. The React toolbar and native toolbar were extracted without moving caret/history ownership. Comments explain composition identity, publication/save notifications and structural clipboard boundaries. Formatting is intentionally separate from changing the selection algorithms: the two renderer implementations are still present.
 
 Output views subscribe to one session and skip caret-only redraws. Host completion is explicit (`onCommit`, `onCancel`, `onExit`) and independent of the single-top-level-line model policy. Popup drafts apply through a transaction, not a history-resetting load. See [Embedding](EMBEDDING.md) for the layouts, product-specific data mismatches and the next integration gates.
+
+### Workspace: binomial and operand suggestions
+
+`binomial` has exactly two slots, upper then lower, and serializes as `\binom{n}{k}`. It shares validation, wrapping, navigation and undo with other structures. Operand suggestions carry `wrapOperand: true`, so acceptance preserves the query as a selected operand instead of deleting it. Both React and native DOM use the same acceptance function. In operand-only menus, bare Enter retains normal behavior until an arrow key selects an action.
+
+### Workspace: limits and function colors
+
+`limit` stores `[condition, body]` and exports `\lim_{condition}{body}`. Parsing accepts an optional lower condition and one body atom; missing slots stay editable. Repeated lower conditions and upper-limit syntax fail atomically. The React and native renderers stack the condition beneath the `lim` glyph, then render the body alongside it. Function names and `lim` use `--me-function` (default `#087b78`); nested slot tokens keep their own semantic colors.
+
+### Workspace: imported notation compatibility
+
+- Implemented `quad`/`qquad` as zero-slot spacing nodes, including suggestion insertion and deletion/Undo.
+- Preserved explicit `limits: true` on sum/product/integral/limit nodes through import/export.
+- Implemented one-slot `roman` groups: scoped `\rm` declarations normalize to `\mathrm{…}`. Parsing restores the enclosing expression boundary after nested groups.
+- Regression fixtures include the reported quotient limit with Chinese text, the three-sum inequality and the chain-rule derivative.
+
+### Workspace: fences, annotations and indexed-root rendering
+
+Added curly/angle fences, open-closed and closed-open interval presets, generic fences with independent ends, and annotation/body nodes for overset/underset. Both renderers share the physical delimiter definitions. Selection wrapping retains the original expression and focuses the annotation when appropriate. Indexed roots now draw a radical that meets the overbar at the same coordinate, with the index overlapping its shoulder.
+
+## Editing typography and focus: 2026-09-08 (workspace)
+
+Active token inputs use a tinted background and caret without an outline or outer halo. Forced-colors mode retains its system focus outline. Toolbar, suggestion and surface keyboard-focus indicators keep their own rules. This changes presentation only; selection, clipboard and JSON/LaTeX output are unchanged.
+
+Single-script slots use inline flex layout to avoid an extra line-box descent below the base. Passive boundary targets within script bases are 1px wide and expand when focused; text and single-script wrappers omit extra side margins. This aligns coefficients with the base and brings subscripts closer without removing editable caret positions.
+
+The stylesheet bundles the MIT-licensed KaTeX Main font as `Barocss Math Glyphs`, scoped to ASCII digits and U+223C. Digits have consistent lining heights, and the similarity sign stays distinct from infinity. Other glyphs retain their existing font fallback. Consumers must ship the stylesheet's relative font asset and license.
+
+### Workspace spacing refinement
+
+Grid fences reuse the scalable parenthesis/brace masks. Grid gaps are 4px vertically and 12px horizontally with 3px/5px padding. Fraction/script/accent slots use flex boxes to avoid extra text-line descent. Nested fraction text is bounded at 16px and then 12px; this is a conservative local rule, not a complete TeX display/text/script style engine. Combined scripts keep 16px text with tighter line height. Active structural boundaries now use a 12px minimum; real empty slots retain their existing larger targets. Accent offsets and large-operator body spacing are reduced. These shared CSS rules apply to rich React and native DOM.
+
+## Required visual check for notation changes
+
+For every new mathematical feature or LaTeX syntax extension, compare the editor with KaTeX rendering of the same exported expression before completion. Check both rich React and native DOM, passive and active inputs, empty and populated slots, and representative nesting. Review delimiter/glyph shapes, baselines, script sizes, accent and limit placement, spacing, clipping and focus-induced movement. Adjust the editor as part of the feature, not as deferred visual polish. Preserve usable caret targets and document deliberate differences from KaTeX. KaTeX is a visual reference, not a parser-support contract or a pixel-equality requirement. Save comparison evidence and verify typing, navigation, deletion and Undo after layout changes.
+
+Workspace norm support: one editable body, shared double-bar fences, `norm`/`노름`/`||` suggestions, range wrapping and LaTeX import/export. The parser accepts short `\lVert…\rVert` and scalable double-bar aliases; export uses `\left\Vert…\right\Vert`. Available in 0.2.0.
+
+## Triple and contour integrals (workspace)
+
+| Input | Model | Slots / behavior |
+| --- | --- | --- |
+| `\iiint_a^b{f}` | `tripleIntegral` | `[lower, upper, body]` |
+| `\oint_C{f}` | `contourIntegral` | `[lower, upper, body]`; absent upper stays empty |
+
+Search `iiint` / `삼중적분` / `∭`, or `oint` / `폐곡선적분` / `∮`. Tab visits lower, upper and body. Backspace after the structure unwraps its contents; Undo restores it. Both accept and preserve `\limits` for stacked bounds; default editing places bounds alongside the slanted glyph. Unbraced input consumes one body atom, as for existing integrals. `\nolimits` is supported in the current workspace. These are editable notation, not integration or path analysis. Contour glyphs use the bundled KaTeX Size2-Regular U+222E directly, with its native ring and slant. No pseudo-element strokes are added.
+
+## Brace annotations (workspace)
+
+| Input | Model | Slots |
+| --- | --- | --- |
+| `\overbrace{a+b}^{n}` | `overbrace` | `[annotation, body]` |
+| `\underbrace{a+b}_{n}` | `underbrace` | `[annotation, body]` |
+
+Type `overbrace` / `위중괄호` or `underbrace` / `아래중괄호`. The annotation is edited first; Tab moves into the body. Wrapping a selection preserves it in the body and focuses the empty annotation. Both slots allow nested math. The brace stretches across the body/annotation container. Backspace immediately after the structure unwraps its contents; Undo restores the structure.
+
+The parser accepts a bare brace body and creates an empty annotation. Export always includes the corresponding `^{…}` or `_{…}`, including an empty annotation. Repeated annotation markers fail. An opposite-side script is handled as an outer ordinary script, not a second brace annotation. Slot order is annotation then body even for underbraces; this matches overset/underset. This workspace addition retains document version 1; older consumers must reject unknown structure kinds during validation.
+
+## Compact and filtered toolbars (workspace)
+
+Toolbars initially show up to eight structure buttons. More tools / Fewer tools toggles the remainder without changing the formula or history. Rich React also places matrix presets, templates and symbol shortcuts in the expanded section; Undo, Redo and `toolbarEnd` stay visible. Native toolbars contain structure buttons and history only and show a toggle when needed. The layout wraps naturally on narrow screens; this is not a guaranteed single-row toolbar.
+
+```tsx
+<MathEditor toolbar={['fraction', 'root', 'superscript', 'matrix']}
+  toolbarMaxItems={3} />
+```
+
+```js
+mountMathEditor(host, session, {
+  toolbar: ['fraction', 'root', 'norm'],
+  toolbarMaxItems: 2,
+});
+mountMathToolbar(toolbarHost, session, {
+  kinds: ['fraction', 'root', 'norm'],
+  maxItems: 2,
+});
+```
+
+`toolbar: false` hides the toolbar. A structure array filters its structure buttons only: it does not disable those structures in suggestions, parsing or the model, and does not filter React's auxiliary template/symbol controls. `toolbarMaxItems` (independent toolbar: `maxItems`) is a nonnegative count; zero initially hides all structure buttons behind More. A sufficiently large count shows all selected structure buttons initially. Expanded state belongs to the mounted toolbar and is not saved in the math document. The rich React `toolbar` array and compact behavior are available in 0.2.0.
+
+## Additional accents (workspace)
+
+| Syntax | Model / appearance | Search |
+| --- | --- | --- |
+| `\tilde{x}` | `tilde`, fixed-width centered wave | `tilde`, `물결악센트` |
+| `\bar{x}` | `bar`, short centered line | `bar`, `짧은윗줄` |
+| `\dot{x}` | `dot`, one centered dot | `dot`, `위점` |
+| `\ddot{x}` | `ddot`, two dots | `ddot`, `두점` |
+| `\widehat{AB}` | `widehat`, body-width hat | `widehat`, `넓은모자` |
+| `\widetilde{AB}` | `widetilde`, body-width wave | `widetilde`, `넓은물결` |
+
+Each is a structure with a unique `id` and exactly one MathRow in `slots: [body]`. Empty and nested bodies are supported, including scripts and fractions. Import preserves the command spelling; export emits the same command with a braced body. Selection wrapping retains the original expression. Tab continues outside; Backspace after the wrapper preserves its body, and Undo restores it. `dot` can also match a multiplication symbol: choose Dot accent explicitly or search `위점`. `bar` remains distinct from the existing body-width `overline`. These additions are in 0.2.0 and do not evaluate derivatives or estimates.
+
+## Limit variants and placement (workspace)
+
+`\limsup_{n}{x}` and `\liminf_{n}{x}` use `limsup` / `liminf` structures with exactly `[condition, body]` rows. Search `limsup` / `상극한` or `liminf` / `하극한`; Tab moves from condition to body. They do not evaluate sequence limits.
+
+All limit-family, sum/product and integral nodes accept a single `\limits` or `\nolimits` immediately after the command, before scripts. The optional `limits` field is now boolean: omitted means default, `true` is stacked placement, `false` is side placement. Both explicit values survive JSON validation, copying and LaTeX export. Repeated/conflicting directives are rejected. Existing `limits: true` remains valid; older package builds do not accept `false` or the new limit kinds.
+
+Placement is currently selected through imported LaTeX/model metadata, not a dedicated toolbar switch. Imported side conditions remain editable; normal limit suggestions use default placement. This is 0.2.0 functionality.
+
+## Fine mathematical spacing (workspace)
+
+| LaTeX | Node type | Width | Suggestion search |
+| --- | --- | --- | --- |
+| `\,` | `thinSpace` | 3mu / 1⁄6em | `thinspace`, `얇은간격` |
+| `\:` | `mediumSpace` | 4mu / 2⁄9em | `mediumspace`, `중간간격` |
+| `\;` | `thickSpace` | 5mu / 5⁄18em | `thickspace`, `두꺼운간격` |
+| `\!` | `negativeThinSpace` | −3mu / −1⁄6em | `negativethinspace`, `간격줄이기` |
+
+All four nodes have a unique ID and `slots: []`, like quad/qquad. Import/export preserve the exact command; ordinary source whitespace is still normalized. Insertion resumes immediately after the spacer. Backspace removes it and Undo restores it. Negative spacing uses a zero-width node with negative inline-end margin, not an overlay that intercepts pointer input. Click the adjoining text to edit; the spacer has no text slot. Plain punctuation remains literal and is not a spacing trigger.
+
+Editor dimensions scale in script/limit slots. These are explicit gaps added to the editor's own token clearance, not a complete TeX math-glue or script-style suppression engine. Arbitrary dimensions (`\hspace`, `\kern`) and rubber-glue stretch/shrink remain unsupported. This is 0.2.0 functionality.
+
+## Explicit fraction/binomial sizes
+
+Reuse the existing two-slot structures with optional `mathStyle: 'display' | 'text'`. Validate metadata only on those two kinds, preserve it during model cloning, and choose the matching command at export. Suggestion presets carry `mathStyle` into insertion without duplicating toolbar structure kinds. React and DOM expose `data-math-style`; scoped size variables allow a nested explicit style to override its parent. Keep active inputs and passive tokens at the same size. General TeX style declarations are outside this implementation.
+
+## Scoped math alphabets
+
+`bold`, `calligraphic` and `blackboard` are one-slot structures validated by the document/clipboard codec. Both renderers use their generic structure path. Scoped CSS font variables keep inner alphabet choices independent of outer ones and leave structural glyphs unchanged. KaTeX font files live under `src/fonts` alongside their license. The parser retains the earlier five single number-set aliases to avoid changing stored symbol semantics.
+
+## Labeled arrows
+
+The `xrightarrow` and `xleftarrow` structures have two slots in upper/lower order. Parse the optional lower bracket before the required upper argument, then store in model order. Render the generic slots in three CSS grid rows, with a pseudo-element shaft and a fixed-size head in the middle row. Labels drive grid width; the decoration cannot intercept pointer events. These commands are inserted through the shared catalog and do not require a separate dialog.