@liminis/editor 0.1.0-rc.1

package/dist/markdown/vendor/mdast-util-wiki-link/from-markdown.js

@@ -0,0 +1,127 @@
+/**
+ * Vendored from `mdast-util-wiki-link@0.1.2` (MIT, Mark Hudnall — see LICENSE
+ * in this directory), with the Liminis trailing-backslash fix applied inline.
+ *
+ * Why vendored rather than depended-upon-and-patched: the upstream behaviour we
+ * need was only reachable through a `pnpm` `patchedDependencies` entry, which
+ * does not travel outside the workspace that declares it. An external consumer of the published
+ * package would silently get different — and wrong — wiki-link behaviour inside
+ * markdown tables (#347). Vendoring makes the package self-contained.
+ *
+ * Four deliberate divergences from upstream:
+ *   1. The trailing-backslash strip (see `exitWikiLink`), previously carried as
+ *      `liminis-app/patches/mdast-util-wiki-link@0.1.2.patch` in `verveguy/liminis`.
+ *   2. Real types instead of `any` on the public option and node shapes.
+ *   3. `exitWikiLink` reads the node off `this.stack` rather than off a
+ *      closure variable shared by every handler in one `fromMarkdown()` call.
+ *   4. `top()` asserts the stack frame is actually a wiki-link, so the
+ *      cannot-nest assumption fails loudly rather than corrupting a sibling node.
+ *
+ * Nothing else about the parse behaviour changes: `value`, `data.alias`,
+ * `data.permalink`, `data.exists`, `data.hName`, `data.hProperties` and
+ * `data.hChildren` are computed exactly as upstream computes them.
+ */
+/**
+ * The node currently being built, read off the compile stack.
+ *
+ * The type check is not ceremony. Every handler here assumes the top of the
+ * stack is the wiki-link it entered, which holds because wiki-links cannot
+ * nest — but nothing in this file *enforces* that, and there is no upstream
+ * left to diff against. If a future micromark extension change, or a consumer
+ * combining extensions, ever let a second wiki-link token open while one is
+ * still on the stack, the handlers would quietly write `value`, `alias`,
+ * `permalink` and `hChildren` onto the wrong node and the corruption would
+ * surface as mis-rendered links, not as an error. Failing loudly here converts
+ * that into a stack trace naming this file.
+ */
+function top(stack) {
+    const node = stack[stack.length - 1];
+    if (node?.type !== 'wikiLink') {
+        throw new Error(`wiki-link handler expected a wikiLink on top of the mdast stack, found ${node === undefined ? 'an empty stack' : `a ${String(node.type)}`}. Wiki-links are assumed not to nest; if that changed, these handlers need per-node state.`);
+    }
+    return node;
+}
+export function fromMarkdown(opts = {}) {
+    const permalinks = opts.permalinks || [];
+    const defaultPageResolver = (name) => [name.replace(/ /g, '_').toLowerCase()];
+    const pageResolver = opts.pageResolver || defaultPageResolver;
+    const newClassName = opts.newClassName || 'new';
+    const wikiLinkClassName = opts.wikiLinkClassName || 'internal';
+    const defaultHrefTemplate = (permalink) => `#/page/${permalink}`;
+    const hrefTemplate = opts.hrefTemplate || defaultHrefTemplate;
+    function enterWikiLink(token) {
+        const node = {
+            type: 'wikiLink',
+            value: null,
+            data: {
+                alias: null,
+                permalink: null,
+                exists: null,
+            },
+        };
+        this.enter(node, token);
+    }
+    function exitWikiLinkAlias(token) {
+        top(this.stack).data.alias = this.sliceSerialize(token);
+    }
+    function exitWikiLinkTarget(token) {
+        top(this.stack).value = this.sliceSerialize(token);
+    }
+    function exitWikiLink(token) {
+        // Read the node off the stack *before* exiting — `this.exit()` pops it, so
+        // afterwards `top(this.stack)` is the parent. Upstream reads a closure
+        // variable here instead, which every handler produced by one
+        // `fromMarkdown()` call shares: `exitWikiLink` would then operate on
+        // whichever token last entered, not the one actually exiting. Wiki links
+        // cannot nest today, so the two are equivalent in practice — this just
+        // declines to inherit the assumption.
+        const wikiLink = top(this.stack);
+        this.exit(token);
+        // --- Liminis divergence from upstream (#347) ------------------------------
+        // Strip a trailing backslash from the target only when an alias is present.
+        // `parseMarkdown` escapes the alias divider (`\|`) before parsing so GFM
+        // table parsing does not split a wiki-link at its pipe; that backslash
+        // escapes the pipe for the table parser but is not part of the target. We
+        // strip only when an alias exists, so a target that legitimately ends in a
+        // backslash is left alone.
+        //
+        // The strip happens *before* `pageResolver` runs, so `data.permalink` and
+        // `data.exists` are computed from the stripped value — matching the patched
+        // behaviour this replaces. A post-pass that fixed only `value` would not.
+        if (wikiLink.data.alias && wikiLink.value?.endsWith('\\')) {
+            wikiLink.value = wikiLink.value.slice(0, -1);
+        }
+        // --------------------------------------------------------------------------
+        const pagePermalinks = pageResolver(wikiLink.value);
+        const target = pagePermalinks.find((p) => permalinks.includes(p));
+        const exists = target !== undefined;
+        const permalink = exists ? target : pagePermalinks[0] || '';
+        let displayName = wikiLink.value;
+        if (wikiLink.data.alias) {
+            displayName = wikiLink.data.alias;
+        }
+        let classNames = wikiLinkClassName;
+        if (!exists) {
+            classNames += ' ' + newClassName;
+        }
+        wikiLink.data.alias = displayName;
+        wikiLink.data.permalink = permalink;
+        wikiLink.data.exists = exists;
+        wikiLink.data.hName = 'a';
+        wikiLink.data.hProperties = {
+            className: classNames,
+            href: hrefTemplate(permalink),
+        };
+        wikiLink.data.hChildren = [{ type: 'text', value: displayName }];
+    }
+    return {
+        enter: {
+            wikiLink: enterWikiLink,
+        },
+        exit: {
+            wikiLinkTarget: exitWikiLinkTarget,
+            wikiLinkAlias: exitWikiLinkAlias,
+            wikiLink: exitWikiLink,
+        },
+    };
+}

package/dist/markdown/vendor/mdast-util-wiki-link/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Vendored `mdast-util-wiki-link` (MIT, Mark Hudnall). See LICENSE and
+ * README.md in this directory for provenance and the Liminis divergences.
+ */
+export { fromMarkdown } from './from-markdown.js';
+export type { WikiLinkFromMarkdownOptions } from './from-markdown.js';
+export { toMarkdown } from './to-markdown.js';
+export type { WikiLinkToMarkdownOptions } from './to-markdown.js';

package/dist/markdown/vendor/mdast-util-wiki-link/index.js

@@ -0,0 +1,6 @@
+/**
+ * Vendored `mdast-util-wiki-link` (MIT, Mark Hudnall). See LICENSE and
+ * README.md in this directory for provenance and the Liminis divergences.
+ */
+export { fromMarkdown } from './from-markdown.js';
+export { toMarkdown } from './to-markdown.js';

package/dist/markdown/vendor/mdast-util-wiki-link/to-markdown.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Vendored from `mdast-util-wiki-link@0.1.2` (MIT, Mark Hudnall — see LICENSE
+ * in this directory).
+ *
+ * One deliberate divergence from upstream: upstream imports
+ * `mdast-util-to-markdown/lib/util/safe` from **v0.6.5** of that package, a
+ * deep import into a v0 duplicate of the v2 `mdast-util-to-markdown` this
+ * package already uses. That duplicate (and upstream's `@babel/runtime`
+ * dependency) exists solely to serve this file. Here the same escaping is done
+ * through v2's `state.safe()`, which is the supported API and produces the same
+ * result for the `{ before: '[', after: ']' }` case this handler uses.
+ */
+import type { Options as ToMarkdownExtension } from 'mdast-util-to-markdown';
+export interface WikiLinkToMarkdownOptions {
+    aliasDivider?: string;
+}
+export declare function toMarkdown(opts?: WikiLinkToMarkdownOptions): ToMarkdownExtension;

package/dist/markdown/vendor/mdast-util-wiki-link/to-markdown.js

@@ -0,0 +1,33 @@
+export function toMarkdown(opts = {}) {
+    const aliasDivider = opts.aliasDivider || ':';
+    const handler = (node, _parent, state) => {
+        const wikiLink = node;
+        const exit = state.enter('wikiLink');
+        const nodeValue = state.safe(wikiLink.value, { before: '[', after: ']' });
+        // Second deliberate divergence from upstream. Upstream passes the alias
+        // through `safe()` unconditionally; `safe(undefined)` yields `''`, which is
+        // then unequal to a non-empty target, so a node carrying *no* alias
+        // serialized as `[[Target<divider>]]`. That output is malformed — it does
+        // not round-trip, parsing back as an empty alias rather than none.
+        //
+        // Nothing in this repository could reach it (`fromMarkdown` always populates
+        // `data.alias`, falling back to the target), so this changes no in-repo
+        // behaviour. It only matters to an external host that builds `wikiLink`
+        // nodes by hand — which is precisely who the published package is for.
+        const rawAlias = wikiLink.data?.alias;
+        const hasAlias = typeof rawAlias === 'string' && rawAlias.length > 0;
+        const nodeAlias = hasAlias ? state.safe(rawAlias, { before: '[', after: ']' }) : nodeValue;
+        const value = nodeAlias !== nodeValue ? `[[${nodeValue}${aliasDivider}${nodeAlias}]]` : `[[${nodeValue}]]`;
+        exit();
+        return value;
+    };
+    return {
+        unsafe: [
+            { character: '[', inConstruct: ['phrasing', 'label', 'reference'] },
+            { character: ']', inConstruct: ['label', 'reference'] },
+        ],
+        // `wikiLink` is not a node type mdast knows about — it is contributed by the
+        // micromark wiki-link syntax extension — so `Handlers` cannot name it.
+        handlers: { wikiLink: handler },
+    };
+}

package/dist/markdown.d.ts

@@ -0,0 +1,28 @@
+/**
+ * `@liminis/editor/markdown` — the markdown-parsing surface, with no editor.
+ *
+ * The root barrel (`.`) pulls in Lexical, MathJax, Mermaid and the C4 subsystem,
+ * because it exports `<Editor>`/`<App>`. A consumer that only needs to *read*
+ * markdown — rendering a search-result snippet, building a table of contents —
+ * pays all of that at window startup if it reaches for the barrel. This entry
+ * exists so it doesn't have to.
+ *
+ * Everything here is pure mdast/micromark plus a string helper: no DOM, no
+ * Lexical, no React. It is deliberately **not** part of `./headless`, which
+ * additionally re-exports `mathjax-config` — whose ~90 bare
+ * `import '@mathjax/src/js/input/tex/…Configuration.js'` lines are genuinely
+ * side-effectful and cannot be shaken by anyone, costing a ~1.9 MB chunk.
+ *
+ * Do not add anything to this entry whose import graph reaches Lexical, React,
+ * MathJax, or the C4 subsystem. See ADR-075.
+ *
+ * (The sibling `src/markdown/` directory holds the implementation; `./markdown`
+ * resolves to this file, `./markdown/parse` to the module inside it.)
+ */
+export { parseMarkdown } from './markdown/parse.js';
+export type { ParseOptions, ParseResult } from './markdown/parse.js';
+export { isParagraph, isHeading, isList, isListItem, isBlockquote, isCode, isThematicBreak, isTable, isImage, isLink, isHtml, isText, isStrong, isEmphasis, isInlineCode, isDelete, } from './markdown/parse.js';
+export { getFileType } from './utils/file-types.js';
+export type { FileType } from './utils/file-types.js';
+export { fromMarkdown as wikiLinkFromMarkdown, toMarkdown as wikiLinkToMarkdown, } from './markdown/vendor/mdast-util-wiki-link/index.js';
+export type { WikiLinkFromMarkdownOptions, WikiLinkToMarkdownOptions, } from './markdown/vendor/mdast-util-wiki-link/index.js';

package/dist/markdown.js

@@ -0,0 +1,44 @@
+/**
+ * `@liminis/editor/markdown` — the markdown-parsing surface, with no editor.
+ *
+ * The root barrel (`.`) pulls in Lexical, MathJax, Mermaid and the C4 subsystem,
+ * because it exports `<Editor>`/`<App>`. A consumer that only needs to *read*
+ * markdown — rendering a search-result snippet, building a table of contents —
+ * pays all of that at window startup if it reaches for the barrel. This entry
+ * exists so it doesn't have to.
+ *
+ * Everything here is pure mdast/micromark plus a string helper: no DOM, no
+ * Lexical, no React. It is deliberately **not** part of `./headless`, which
+ * additionally re-exports `mathjax-config` — whose ~90 bare
+ * `import '@mathjax/src/js/input/tex/…Configuration.js'` lines are genuinely
+ * side-effectful and cannot be shaken by anyone, costing a ~1.9 MB chunk.
+ *
+ * Do not add anything to this entry whose import graph reaches Lexical, React,
+ * MathJax, or the C4 subsystem. See ADR-075.
+ *
+ * (The sibling `src/markdown/` directory holds the implementation; `./markdown`
+ * resolves to this file, `./markdown/parse` to the module inside it.)
+ */
+export { parseMarkdown } from './markdown/parse.js';
+export { isParagraph, isHeading, isList, isListItem, isBlockquote, isCode, isThematicBreak, isTable, isImage, isLink, isHtml, isText, isStrong, isEmphasis, isInlineCode, isDelete, } from './markdown/parse.js';
+export { getFileType } from './utils/file-types.js';
+// The vendored wiki-link mdast extension (MIT, landakram/mdast-util-wiki-link),
+// carrying the Liminis trailing-backslash fix for aliased wiki-links inside
+// tables (#347). Exported here so a host building its own mdast pipeline — the
+// Electron main process's canonical chunker is the in-repo one — gets the same
+// *extension* the editor uses, without needing a pnpm patch.
+//
+// These are NOT equivalent to `parseMarkdown`/`stringifyMarkdown`, and the gap
+// is not cosmetic:
+//   - `parseMarkdown` escapes the alias divider before parsing. The strip inside
+//     `fromMarkdown` only helps once that has happened, so with GFM tables
+//     enabled the extension alone lets the table parser reach the `|` first and
+//     the row is corrupted (measured: 5 cells and 0 wiki-links where
+//     `parseMarkdown` gives 4 and 1).
+//   - `parseMarkdown`/`stringifyMarkdown` carry the `_emptyAlias` sentinel that
+//     distinguishes `[[target|]]` from `[[target]]`; the extensions do not.
+//   - the editor serializes wiki-links through `stringify.ts`'s own handler,
+//     not through `toMarkdown` here.
+// See `docs/markdown-pipeline.md` — "What the extensions do not give you".
+// Pure mdast: this entry's isolation contract is preserved.
+export { fromMarkdown as wikiLinkFromMarkdown, toMarkdown as wikiLinkToMarkdown, } from './markdown/vendor/mdast-util-wiki-link/index.js';

package/dist/mathjax-config.d.ts

@@ -0,0 +1,89 @@
+/**
+ * Shared MathJax v4 configuration module.
+ * Provides centralized TeX package imports and factory functions for creating
+ * MathJax documents with either liteAdaptor (server/export) or browserAdaptor (desktop).
+ *
+ * All TeX packages are bundled explicitly for full offline support in Electron and mobile.
+ */
+import '@mathjax/src/js/util/asyncLoad/esm.js';
+import { liteAdaptor } from '@mathjax/src/js/adaptors/liteAdaptor.js';
+import { browserAdaptor } from '@mathjax/src/js/adaptors/browserAdaptor.js';
+import type { LiteElement } from '@mathjax/src/js/adaptors/lite/Element.js';
+import '@mathjax/src/js/input/tex/action/ActionConfiguration.js';
+import '@mathjax/src/js/input/tex/ams/AmsConfiguration.js';
+import '@mathjax/src/js/input/tex/amscd/AmsCdConfiguration.js';
+import '@mathjax/src/js/input/tex/autoload/AutoloadConfiguration.js';
+import '@mathjax/src/js/input/tex/base/BaseConfiguration.js';
+import '@mathjax/src/js/input/tex/bbox/BboxConfiguration.js';
+import '@mathjax/src/js/input/tex/boldsymbol/BoldsymbolConfiguration.js';
+import '@mathjax/src/js/input/tex/braket/BraketConfiguration.js';
+import '@mathjax/src/js/input/tex/bussproofs/BussproofsConfiguration.js';
+import '@mathjax/src/js/input/tex/cancel/CancelConfiguration.js';
+import '@mathjax/src/js/input/tex/centernot/CenternotConfiguration.js';
+import '@mathjax/src/js/input/tex/color/ColorConfiguration.js';
+import '@mathjax/src/js/input/tex/colortbl/ColortblConfiguration.js';
+import '@mathjax/src/js/input/tex/configmacros/ConfigMacrosConfiguration.js';
+import '@mathjax/src/js/input/tex/empheq/EmpheqConfiguration.js';
+import '@mathjax/src/js/input/tex/enclose/EncloseConfiguration.js';
+import '@mathjax/src/js/input/tex/extpfeil/ExtpfeilConfiguration.js';
+import '@mathjax/src/js/input/tex/gensymb/GensymbConfiguration.js';
+import '@mathjax/src/js/input/tex/html/HtmlConfiguration.js';
+import '@mathjax/src/js/input/tex/mathtools/MathtoolsConfiguration.js';
+import '@mathjax/src/js/input/tex/mhchem/MhchemConfiguration.js';
+import '@mathjax/src/js/input/tex/newcommand/NewcommandConfiguration.js';
+import '@mathjax/src/js/input/tex/noerrors/NoErrorsConfiguration.js';
+import '@mathjax/src/js/input/tex/noundefined/NoUndefinedConfiguration.js';
+import '@mathjax/src/js/input/tex/physics/PhysicsConfiguration.js';
+import '@mathjax/src/js/input/tex/require/RequireConfiguration.js';
+import '@mathjax/src/js/input/tex/setoptions/SetOptionsConfiguration.js';
+import '@mathjax/src/js/input/tex/tagformat/TagFormatConfiguration.js';
+import '@mathjax/src/js/input/tex/textcomp/TextcompConfiguration.js';
+import '@mathjax/src/js/input/tex/textmacros/TextMacrosConfiguration.js';
+import '@mathjax/src/js/input/tex/unicode/UnicodeConfiguration.js';
+import '@mathjax/src/js/input/tex/verb/VerbConfiguration.js';
+/**
+ * All TeX packages bundled for offline support.
+ * These correspond to the package configurations imported above.
+ */
+export declare const TEX_PACKAGES: readonly ["base", "ams", "newcommand", "require", "autoload", "configmacros", "action", "amscd", "bbox", "boldsymbol", "braket", "bussproofs", "cancel", "centernot", "color", "colortbl", "empheq", "enclose", "extpfeil", "gensymb", "html", "mathtools", "mhchem", "noerrors", "noundefined", "physics", "setoptions", "tagformat", "textcomp", "textmacros", "unicode", "verb"];
+export type TeXPackage = (typeof TEX_PACKAGES)[number];
+/**
+ * MathJax document type, generic over the node type produced by convert().
+ * TNode depends on the adaptor: LiteElement for liteAdaptor, HTMLElement for browserAdaptor.
+ */
+export interface MathDocument<TNode> {
+    convert(expression: string, options?: {
+        display?: boolean;
+    }): TNode;
+}
+/**
+ * Result of creating a liteAdaptor MathJax instance.
+ * Returning both ensures callers use a single adaptor instance.
+ */
+export interface LiteMathJaxInstance {
+    adaptor: ReturnType<typeof liteAdaptor>;
+    document: MathDocument<LiteElement>;
+}
+/**
+ * Result of creating a browserAdaptor MathJax instance.
+ */
+export interface BrowserMathJaxInstance {
+    adaptor: ReturnType<typeof browserAdaptor>;
+    document: MathDocument<HTMLElement>;
+}
+interface LiteAdaptorDocumentOptions {
+    fontCache?: 'none' | 'local' | 'global';
+}
+/**
+ * Create a MathJax adaptor+document configured for liteAdaptor (server-side/export).
+ * Used by routes.ts (mobile API) and EquationNode.tsx (DOM export).
+ * Returns both adaptor and document to avoid duplicate adaptor creation.
+ */
+export declare function createLiteAdaptorDocument(options?: LiteAdaptorDocumentOptions): LiteMathJaxInstance;
+/**
+ * Create a MathJax adaptor+document configured for browserAdaptor (desktop rendering).
+ * Used by EquationComponent.tsx for live equation rendering.
+ * Returns both adaptor and document to avoid duplicate adaptor creation.
+ */
+export declare function createBrowserAdaptorDocument(targetDocument: Document): BrowserMathJaxInstance;
+export {};

package/dist/mathjax-config.js

@@ -0,0 +1,133 @@
+/**
+ * Shared MathJax v4 configuration module.
+ * Provides centralized TeX package imports and factory functions for creating
+ * MathJax documents with either liteAdaptor (server/export) or browserAdaptor (desktop).
+ *
+ * All TeX packages are bundled explicitly for full offline support in Electron and mobile.
+ */
+// Import ESM async loader for proper ESM support
+import '@mathjax/src/js/util/asyncLoad/esm.js';
+// Core MathJax imports
+import { mathjax } from '@mathjax/src/js/mathjax.js';
+import { TeX } from '@mathjax/src/js/input/tex.js';
+import { SVG } from '@mathjax/src/js/output/svg.js';
+import { RegisterHTMLHandler } from '@mathjax/src/js/handlers/html.js';
+// Adaptor imports (static ESM, not require())
+import { liteAdaptor } from '@mathjax/src/js/adaptors/liteAdaptor.js';
+import { browserAdaptor } from '@mathjax/src/js/adaptors/browserAdaptor.js';
+// Import all TeX package configurations explicitly
+// These side-effect imports register the packages with the TeX parser
+// NOTE: File names must match the exact CamelCase used in @mathjax/src v4
+import '@mathjax/src/js/input/tex/action/ActionConfiguration.js';
+import '@mathjax/src/js/input/tex/ams/AmsConfiguration.js';
+import '@mathjax/src/js/input/tex/amscd/AmsCdConfiguration.js';
+import '@mathjax/src/js/input/tex/autoload/AutoloadConfiguration.js';
+import '@mathjax/src/js/input/tex/base/BaseConfiguration.js';
+import '@mathjax/src/js/input/tex/bbox/BboxConfiguration.js';
+import '@mathjax/src/js/input/tex/boldsymbol/BoldsymbolConfiguration.js';
+import '@mathjax/src/js/input/tex/braket/BraketConfiguration.js';
+import '@mathjax/src/js/input/tex/bussproofs/BussproofsConfiguration.js';
+import '@mathjax/src/js/input/tex/cancel/CancelConfiguration.js';
+import '@mathjax/src/js/input/tex/centernot/CenternotConfiguration.js';
+import '@mathjax/src/js/input/tex/color/ColorConfiguration.js';
+import '@mathjax/src/js/input/tex/colortbl/ColortblConfiguration.js';
+import '@mathjax/src/js/input/tex/configmacros/ConfigMacrosConfiguration.js';
+import '@mathjax/src/js/input/tex/empheq/EmpheqConfiguration.js';
+import '@mathjax/src/js/input/tex/enclose/EncloseConfiguration.js';
+import '@mathjax/src/js/input/tex/extpfeil/ExtpfeilConfiguration.js';
+import '@mathjax/src/js/input/tex/gensymb/GensymbConfiguration.js';
+import '@mathjax/src/js/input/tex/html/HtmlConfiguration.js';
+import '@mathjax/src/js/input/tex/mathtools/MathtoolsConfiguration.js';
+import '@mathjax/src/js/input/tex/mhchem/MhchemConfiguration.js';
+import '@mathjax/src/js/input/tex/newcommand/NewcommandConfiguration.js';
+import '@mathjax/src/js/input/tex/noerrors/NoErrorsConfiguration.js';
+import '@mathjax/src/js/input/tex/noundefined/NoUndefinedConfiguration.js';
+import '@mathjax/src/js/input/tex/physics/PhysicsConfiguration.js';
+import '@mathjax/src/js/input/tex/require/RequireConfiguration.js';
+import '@mathjax/src/js/input/tex/setoptions/SetOptionsConfiguration.js';
+import '@mathjax/src/js/input/tex/tagformat/TagFormatConfiguration.js';
+import '@mathjax/src/js/input/tex/textcomp/TextcompConfiguration.js';
+import '@mathjax/src/js/input/tex/textmacros/TextMacrosConfiguration.js';
+import '@mathjax/src/js/input/tex/unicode/UnicodeConfiguration.js';
+import '@mathjax/src/js/input/tex/verb/VerbConfiguration.js';
+/**
+ * All TeX packages bundled for offline support.
+ * These correspond to the package configurations imported above.
+ */
+export const TEX_PACKAGES = [
+    'base',
+    'ams',
+    'newcommand',
+    'require',
+    'autoload',
+    'configmacros',
+    'action',
+    'amscd',
+    'bbox',
+    'boldsymbol',
+    'braket',
+    'bussproofs',
+    'cancel',
+    'centernot',
+    'color',
+    'colortbl',
+    'empheq',
+    'enclose',
+    'extpfeil',
+    'gensymb',
+    'html',
+    'mathtools',
+    'mhchem',
+    'noerrors',
+    'noundefined',
+    'physics',
+    'setoptions',
+    'tagformat',
+    'textcomp',
+    'textmacros',
+    'unicode',
+    'verb',
+];
+/**
+ * Track if handlers have been registered to avoid duplicate registration.
+ */
+let liteHandlerRegistered = false;
+let browserHandlerRegistered = false;
+/**
+ * Create a MathJax adaptor+document configured for liteAdaptor (server-side/export).
+ * Used by routes.ts (mobile API) and EquationNode.tsx (DOM export).
+ * Returns both adaptor and document to avoid duplicate adaptor creation.
+ */
+export function createLiteAdaptorDocument(options = {}) {
+    const adaptor = liteAdaptor();
+    if (!liteHandlerRegistered) {
+        RegisterHTMLHandler(adaptor);
+        liteHandlerRegistered = true;
+    }
+    return {
+        adaptor,
+        document: mathjax.document('', {
+            InputJax: new TeX({ packages: TEX_PACKAGES.slice() }),
+            OutputJax: new SVG({ fontCache: options.fontCache ?? 'none' }),
+        }),
+    };
+}
+/**
+ * Create a MathJax adaptor+document configured for browserAdaptor (desktop rendering).
+ * Used by EquationComponent.tsx for live equation rendering.
+ * Returns both adaptor and document to avoid duplicate adaptor creation.
+ */
+export function createBrowserAdaptorDocument(targetDocument) {
+    const adaptor = browserAdaptor();
+    if (!browserHandlerRegistered) {
+        RegisterHTMLHandler(adaptor);
+        browserHandlerRegistered = true;
+    }
+    return {
+        adaptor,
+        document: mathjax.document(targetDocument, {
+            InputJax: new TeX({ packages: TEX_PACKAGES.slice() }),
+            OutputJax: new SVG({ fontCache: 'local' }),
+        }),
+    };
+}

package/dist/nodes.d.ts

@@ -0,0 +1,34 @@
+/**
+ * `@liminis/editor/nodes` — the headless mapper surface (#954, ADR-079).
+ *
+ * The seventh declared export subpath, added as a *considered* export under
+ * ADR-075's "closed set of declared subpaths" rule (same pattern ADR-077 used
+ * to add `./annotations`). It exists because no existing subpath's isolation
+ * contract fits: `importMarkdownToLexical`/`exportLexicalToMdast` instantiate
+ * Lexical node classes directly, so any entry point exporting them — or the
+ * node array a consumer needs to construct a matching `createEditor` — must
+ * itself permit Lexical. `./markdown`, `./headless`, `./contract` and
+ * `./annotations` are all documented and tested as Lexical-free, and the root
+ * barrel (`.`) pulls in the full `<App>`/`<Editor>` React surface (Prism,
+ * Mermaid's render path, the C4 subsystem) this subpath exists to avoid.
+ *
+ * `editorNodes` is re-exported from the same module `Editor.tsx` configures
+ * its own `LexicalComposer` with (`./app/editor/editorNodes`) — not a
+ * separately hand-maintained copy — so adding a node type to the production
+ * editor updates this export automatically (FR-002).
+ *
+ * **Known exception, carried over from `./headless`: MathJax-lite.**
+ * `EquationNode` imports `mathjax-config` at module scope, which statically
+ * imports MathJax's lite *and* browser adaptors. Loading this subpath
+ * therefore evaluates ~90 side-effectful MathJax TeX-configuration imports —
+ * no DOM, no rendering, no MathJax document instantiation. This is not new
+ * weight introduced by this subpath; `./headless` already carries the
+ * identical exception for the same reason. Splitting `EquationNode`'s import
+ * into lazy/eager halves is a real fix but a separate refactor, out of scope
+ * for this purely-additive change.
+ *
+ * See docs/markdown-pipeline.md for an example of building a headless editor
+ * from this entry's exports.
+ */
+export { editorNodes } from './app/editor/editorNodes.js';
+export { importMarkdownToLexical, exportLexicalToMdast } from './app/mapper/index.js';

package/dist/nodes.js

@@ -0,0 +1,34 @@
+/**
+ * `@liminis/editor/nodes` — the headless mapper surface (#954, ADR-079).
+ *
+ * The seventh declared export subpath, added as a *considered* export under
+ * ADR-075's "closed set of declared subpaths" rule (same pattern ADR-077 used
+ * to add `./annotations`). It exists because no existing subpath's isolation
+ * contract fits: `importMarkdownToLexical`/`exportLexicalToMdast` instantiate
+ * Lexical node classes directly, so any entry point exporting them — or the
+ * node array a consumer needs to construct a matching `createEditor` — must
+ * itself permit Lexical. `./markdown`, `./headless`, `./contract` and
+ * `./annotations` are all documented and tested as Lexical-free, and the root
+ * barrel (`.`) pulls in the full `<App>`/`<Editor>` React surface (Prism,
+ * Mermaid's render path, the C4 subsystem) this subpath exists to avoid.
+ *
+ * `editorNodes` is re-exported from the same module `Editor.tsx` configures
+ * its own `LexicalComposer` with (`./app/editor/editorNodes`) — not a
+ * separately hand-maintained copy — so adding a node type to the production
+ * editor updates this export automatically (FR-002).
+ *
+ * **Known exception, carried over from `./headless`: MathJax-lite.**
+ * `EquationNode` imports `mathjax-config` at module scope, which statically
+ * imports MathJax's lite *and* browser adaptors. Loading this subpath
+ * therefore evaluates ~90 side-effectful MathJax TeX-configuration imports —
+ * no DOM, no rendering, no MathJax document instantiation. This is not new
+ * weight introduced by this subpath; `./headless` already carries the
+ * identical exception for the same reason. Splitting `EquationNode`'s import
+ * into lazy/eager halves is a real fix but a separate refactor, out of scope
+ * for this purely-additive change.
+ *
+ * See docs/markdown-pipeline.md for an example of building a headless editor
+ * from this entry's exports.
+ */
+export { editorNodes } from './app/editor/editorNodes.js';
+export { importMarkdownToLexical, exportLexicalToMdast } from './app/mapper/index.js';

package/dist/stores/correctionStore.d.ts

@@ -0,0 +1,15 @@
+interface CorrectionState {
+    isOpen: boolean;
+    position: {
+        x: number;
+        y: number;
+    };
+    selectedText: string;
+    open: (position: {
+        x: number;
+        y: number;
+    }, selectedText: string) => void;
+    close: () => void;
+}
+export declare const useCorrectionStore: import("zustand").UseBoundStore<import("zustand").StoreApi<CorrectionState>>;
+export {};

package/dist/stores/correctionStore.js

@@ -0,0 +1,12 @@
+import { create } from 'zustand';
+export const useCorrectionStore = create((set) => ({
+    isOpen: false,
+    position: { x: 0, y: 0 },
+    selectedText: '',
+    open: (position, selectedText) => {
+        set({ isOpen: true, position, selectedText });
+    },
+    close: () => {
+        set({ isOpen: false });
+    },
+}));

package/dist/stores/editorStore.d.ts

@@ -0,0 +1,16 @@
+interface EditorState {
+    /** Whether the current document has frontmatter */
+    hasFrontmatter: boolean;
+    /** Whether the frontmatter tray is open */
+    isFrontmatterOpen: boolean;
+    /** Set frontmatter presence (called by editor plugin) */
+    setHasFrontmatter: (has: boolean) => void;
+    /** Set frontmatter tray state (called by editor plugin) */
+    setFrontmatterOpen: (isOpen: boolean) => void;
+    /** Toggle frontmatter tray (called by UI button) */
+    toggleFrontmatter: () => void;
+    /** Reset editor state (when switching documents) */
+    reset: () => void;
+}
+export declare const useEditorStore: import("zustand").UseBoundStore<import("zustand").StoreApi<EditorState>>;
+export {};

package/dist/stores/editorStore.js

@@ -0,0 +1,27 @@
+import { create } from 'zustand';
+export const useEditorStore = create((set, get) => ({
+    hasFrontmatter: false,
+    isFrontmatterOpen: false,
+    setHasFrontmatter: (has) => {
+        set({ hasFrontmatter: has });
+        // If no frontmatter, close the tray
+        if (!has) {
+            set({ isFrontmatterOpen: false });
+        }
+    },
+    setFrontmatterOpen: (isOpen) => {
+        set({ isFrontmatterOpen: isOpen });
+    },
+    toggleFrontmatter: () => {
+        const state = get();
+        if (state.hasFrontmatter) {
+            set({ isFrontmatterOpen: !state.isFrontmatterOpen });
+        }
+    },
+    reset: () => {
+        set({
+            hasFrontmatter: false,
+            isFrontmatterOpen: false
+        });
+    }
+}));