@lapismd/mira 0.0.1

package/dist/extensions/index.js

@@ -0,0 +1,279 @@
+import { keymap } from "@codemirror/view";
+export { defaultMiraDoodleDividerPalette, defaultMiraDoodleDividerVariants, doodleDividersExtension, materializeDoodleDividerSeeds, } from "./doodle-dividers";
+export { selectionToolbarExtension, defaultMiraSelectionToolbarActions, miraSelectionToolbarActionIds, } from "./selection-toolbar";
+export const miraBlockToolbarItemIds = [
+    "task",
+    "paragraph",
+    "heading1",
+    "heading2",
+    "heading3",
+    "divider",
+    "bulletList",
+    "numberedList",
+    "quote",
+    "image",
+];
+export function createMarkdownTemplate(markdown, marker = "<|>") {
+    if (!marker) {
+        return { markdown };
+    }
+    const selection = markdown.indexOf(marker);
+    if (selection === -1) {
+        return { markdown };
+    }
+    return {
+        markdown: markdown.replace(marker, ""),
+        selection,
+    };
+}
+export function createSlashSnippet(options) {
+    const { markdown, marker, ...command } = options;
+    return {
+        ...command,
+        insert: createMarkdownTemplate(markdown, marker),
+    };
+}
+export function parseMiraFileTarget(href, sourcePath) {
+    const hashIndex = href.indexOf("#");
+    const path = (hashIndex === -1 ? href : href.slice(0, hashIndex)).trim();
+    const subpath = hashIndex === -1
+        ? undefined
+        : href.slice(hashIndex + 1).trim() || undefined;
+    const fragment = subpath
+        ? subpath.startsWith("^")
+            ? {
+                kind: "block",
+                value: subpath.slice(1).trim(),
+            }
+            : {
+                kind: "heading",
+                value: subpath,
+            }
+        : undefined;
+    return {
+        href,
+        path,
+        sourcePath,
+        subpath,
+        fragment: fragment?.value ? fragment : undefined,
+    };
+}
+export const defaultMiraEditorListCallouts = [
+    { color: "255, 214, 0", char: "&" },
+    { color: "255, 145, 0", char: "?" },
+    { color: "255, 23, 68", char: "!" },
+    { color: "124, 77, 255", char: "~" },
+    { color: "0, 184, 212", char: "@", icon: "book-open" },
+    { color: "0, 200, 83", char: "$" },
+    { color: "158, 158, 158", char: "%" },
+];
+export function resolveMiraListCallouts(contributions = []) {
+    const callouts = new Map(defaultMiraEditorListCallouts.map((callout) => [callout.char, { ...callout }]));
+    for (const contribution of contributions) {
+        const char = contribution.char.trim();
+        if (!char) {
+            continue;
+        }
+        if (contribution.enabled === false) {
+            callouts.delete(char);
+            continue;
+        }
+        const current = callouts.get(char);
+        callouts.set(char, {
+            ...current,
+            ...contribution,
+            char,
+            color: contribution.color?.trim() || current?.color || "127, 127, 127",
+        });
+    }
+    return Array.from(callouts.values(), ({ enabled: _enabled, ...callout }) => ({
+        ...callout,
+    }));
+}
+export function defineMiraExtension(extension) {
+    return extension;
+}
+export function emptyResolvedMiraExtensions() {
+    return {
+        codeMirror: [],
+        codeLanguages: [],
+        remarkPlugins: [],
+        rehypePlugins: [],
+        components: {},
+        commands: [],
+        slashCommands: [],
+        blockActions: [],
+        toolbarItems: [],
+        listCallouts: [],
+        postProcessors: [],
+        styles: [],
+        onMount: [],
+    };
+}
+export function resolveMiraExtensions(extensions = [], context) {
+    const resolved = emptyResolvedMiraExtensions();
+    for (const extension of extensions) {
+        const codeMirror = extension.codeMirror?.(context);
+        if (codeMirror) {
+            resolved.codeMirror.push(...[codeMirror].flat());
+        }
+        resolved.codeLanguages.push(...(extension.codeLanguages ?? []));
+        resolved.remarkPlugins.push(...(extension.remarkPlugins ?? []));
+        resolved.rehypePlugins.push(...(extension.rehypePlugins ?? []));
+        Object.assign(resolved.components, extension.components);
+        resolved.commands.push(...(extension.commands ?? []));
+        resolved.slashCommands.push(...(extension.slashCommands ?? []));
+        resolved.blockActions.push(...(extension.blockActions ?? []));
+        resolved.toolbarItems.push(...(extension.toolbarItems ?? []));
+        resolved.listCallouts.push(...(extension.listCallouts ?? []));
+        resolved.postProcessors.push(...(extension.postProcessors ?? []));
+        resolved.styles.push(...(extension.styles ?? []));
+        if (extension.onMount) {
+            resolved.onMount.push(extension.onMount);
+        }
+    }
+    return resolved;
+}
+export function isMiraCommandEnabled(command, context) {
+    if (typeof command.enabled === "function") {
+        return command.enabled(context);
+    }
+    return command.enabled ?? true;
+}
+export function executeMiraCommand(commands, commandId, context) {
+    const command = findMiraCommand(commands, commandId);
+    if (!command || !isMiraCommandEnabled(command, context)) {
+        return false;
+    }
+    void command.run(context);
+    return true;
+}
+export function createMiraCommandKeymap(commands, contextForView) {
+    const bindings = [];
+    for (const command of commands) {
+        for (const binding of command.keybindings ?? []) {
+            const definition = typeof binding === "string" ? { key: binding } : binding;
+            bindings.push({
+                ...definition,
+                run(view) {
+                    return executeMiraCommand(commands, command.id, contextForView(view));
+                },
+            });
+        }
+    }
+    return keymap.of(bindings);
+}
+const mountedStyleTargets = new WeakMap();
+export function mountMiraExtensionStyles(styles, target) {
+    const activeTarget = target ?? (typeof document === "undefined" ? undefined : document.head);
+    if (!activeTarget || styles.length === 0) {
+        return () => undefined;
+    }
+    let mounted = mountedStyleTargets.get(activeTarget);
+    if (!mounted) {
+        mounted = new Map();
+        mountedStyleTargets.set(activeTarget, mounted);
+    }
+    const keys = [];
+    for (const style of styles) {
+        const normalized = normalizeMiraExtensionStyle(style);
+        const key = normalized.key;
+        const existing = mounted.get(key);
+        if (existing) {
+            existing.count += 1;
+            keys.push(key);
+            continue;
+        }
+        const element = normalized.kind === "href"
+            ? createStylesheetLink(activeTarget, normalized)
+            : createInlineStyle(activeTarget, normalized);
+        activeTarget.appendChild(element);
+        mounted.set(key, { count: 1, element });
+        keys.push(key);
+    }
+    return () => {
+        const current = mountedStyleTargets.get(activeTarget);
+        if (!current) {
+            return;
+        }
+        for (const key of keys) {
+            const entry = current.get(key);
+            if (!entry) {
+                continue;
+            }
+            entry.count -= 1;
+            if (entry.count === 0) {
+                entry.element.remove();
+                current.delete(key);
+            }
+        }
+        if (current.size === 0) {
+            mountedStyleTargets.delete(activeTarget);
+        }
+    };
+}
+function findMiraCommand(commands, commandId) {
+    for (let index = commands.length - 1; index >= 0; index -= 1) {
+        const command = commands[index];
+        if (command?.id === commandId) {
+            return command;
+        }
+    }
+    return undefined;
+}
+function normalizeMiraExtensionStyle(style) {
+    if (typeof style === "string") {
+        return {
+            kind: "href",
+            key: `href:${style}`,
+            href: style,
+        };
+    }
+    if ("href" in style) {
+        return {
+            ...style,
+            kind: "href",
+            key: style.id ? `id:${style.id}` : `href:${style.href}`,
+        };
+    }
+    return {
+        ...style,
+        kind: "cssText",
+        key: style.id ? `id:${style.id}` : `cssText:${style.cssText}`,
+    };
+}
+function ownerDocument(target) {
+    if (target instanceof Document) {
+        return target;
+    }
+    if (target.ownerDocument) {
+        return target.ownerDocument;
+    }
+    throw new Error("Mira extension styles require a document-backed target");
+}
+function createStylesheetLink(target, style) {
+    const element = ownerDocument(target).createElement("link");
+    element.rel = "stylesheet";
+    element.href = style.href;
+    element.dataset.miraExtensionStyle = style.key;
+    if (style.media) {
+        element.media = style.media;
+    }
+    if (style.integrity) {
+        element.integrity = style.integrity;
+    }
+    if (style.crossOrigin) {
+        element.crossOrigin = style.crossOrigin;
+    }
+    return element;
+}
+function createInlineStyle(target, style) {
+    const element = ownerDocument(target).createElement("style");
+    element.textContent = style.cssText;
+    element.dataset.miraExtensionStyle = style.key;
+    if (style.media) {
+        element.media = style.media;
+    }
+    return element;
+}
+export { collectMarkdownBlockHandles, collectMarkdownBlockRanges, deleteMarkdownBlockHandle, deleteMarkdownBlockRange, duplicateMarkdownBlockHandle, duplicateMarkdownBlockRange, markdownBlockAt, moveMarkdownBlockHandle, moveMarkdownBlockRange, replaceMarkdownRange, } from "../internal/codemirror/rich/block-ranges";

package/dist/extensions/index.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.test.d.ts.map

package/dist/extensions/index.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.test.d.ts","sourceRoot":"","sources":["../../src/extensions/index.test.ts"],"names":[],"mappings":""}

package/dist/extensions/index.test.js

@@ -0,0 +1,283 @@
+import { describe, expect, it, vi } from "vitest";
+import { EditorState } from "@codemirror/state";
+import { EditorView } from "@codemirror/view";
+import { createMiraCommandKeymap, createMarkdownTemplate, createSlashSnippet, defaultMiraEditorListCallouts, defineMiraExtension, executeMiraCommand, isMiraCommandEnabled, mountMiraExtensionStyles, parseMiraFileTarget, resolveMiraExtensions, resolveMiraListCallouts, selectionToolbarExtension, } from ".";
+describe("resolveMiraExtensions", () => {
+    it("merges contribution arrays in extension order", () => {
+        const first = defineMiraExtension({
+            name: "first",
+            remarkPlugins: [() => undefined],
+            components: { a: "span" },
+        });
+        const second = defineMiraExtension({
+            name: "second",
+            rehypePlugins: [() => undefined],
+            components: { b: "div" },
+        });
+        const resolved = resolveMiraExtensions([first, second], {
+            mode: "source",
+            readonly: false,
+        });
+        expect(resolved.remarkPlugins).toHaveLength(1);
+        expect(resolved.rehypePlugins).toHaveLength(1);
+        expect(resolved.components).toEqual({ a: "span", b: "div" });
+    });
+    it("merges slash commands in extension order", () => {
+        const resolved = resolveMiraExtensions([
+            defineMiraExtension({
+                name: "first",
+                slashCommands: [
+                    {
+                        id: "heading",
+                        label: "Heading",
+                        insert: "# ",
+                    },
+                ],
+            }),
+            defineMiraExtension({
+                name: "second",
+                slashCommands: [
+                    {
+                        id: "callout",
+                        label: "Callout",
+                        insert: "> [!note] ",
+                    },
+                ],
+            }),
+        ], {
+            mode: "source",
+            readonly: false,
+        });
+        expect(resolved.slashCommands.map((command) => command.id)).toEqual([
+            "heading",
+            "callout",
+        ]);
+    });
+    it("merges block actions in extension order", () => {
+        const resolved = resolveMiraExtensions([
+            defineMiraExtension({
+                name: "first",
+                blockActions: [
+                    {
+                        id: "duplicate",
+                        label: "Duplicate",
+                        run: () => undefined,
+                    },
+                ],
+            }),
+            defineMiraExtension({
+                name: "second",
+                blockActions: [
+                    {
+                        id: "ask-ai",
+                        label: "Ask AI",
+                        run: () => undefined,
+                    },
+                ],
+            }),
+        ], {
+            mode: "source",
+            readonly: false,
+        });
+        expect(resolved.blockActions.map((action) => action.id)).toEqual([
+            "duplicate",
+            "ask-ai",
+        ]);
+    });
+    it("merges list callouts and postprocessors in extension order", () => {
+        const firstProcessor = vi.fn();
+        const secondProcessor = vi.fn();
+        const resolved = resolveMiraExtensions([
+            defineMiraExtension({
+                name: "first",
+                listCallouts: [{ char: "^", color: "80, 70, 220" }],
+                postProcessors: [firstProcessor],
+            }),
+            defineMiraExtension({
+                name: "second",
+                listCallouts: [{ char: "@", color: "20, 160, 140" }],
+                postProcessors: [secondProcessor],
+            }),
+        ], {
+            mode: "preview",
+            readonly: true,
+        });
+        expect(resolved.listCallouts.map((callout) => callout.char)).toEqual([
+            "^",
+            "@",
+        ]);
+        expect(resolved.postProcessors).toEqual([firstProcessor, secondProcessor]);
+    });
+});
+describe("selectionToolbarExtension", () => {
+    it("contributes only to editable authoring surfaces", () => {
+        const extension = selectionToolbarExtension({
+            actions: ["bold", "inlineCode"],
+            placement: "above",
+        });
+        expect(extension.name).toBe("selection-toolbar");
+        expect(extension.codeMirror?.({ mode: "source", readonly: false })).not.toBeNull();
+        expect(extension.codeMirror?.({ mode: "live-preview", readonly: false })).not.toBeNull();
+        expect(extension.codeMirror?.({ mode: "split", readonly: false })).not.toBeNull();
+        expect(extension.codeMirror?.({ mode: "preview", readonly: false })).toBeNull();
+        expect(extension.codeMirror?.({ mode: "source", readonly: true })).toBeNull();
+    });
+});
+describe("extension runtime contributions", () => {
+    const context = {
+        focus: () => undefined,
+        getValue: () => "",
+        insertMarkdown: () => undefined,
+        setValue: () => undefined,
+    };
+    it("executes the last enabled command with a matching id", () => {
+        const first = vi.fn();
+        const second = vi.fn();
+        const commands = [
+            { id: "save", label: "Save first", run: first },
+            { id: "save", label: "Save second", run: second },
+        ];
+        expect(executeMiraCommand(commands, "save", context)).toBe(true);
+        expect(first).not.toHaveBeenCalled();
+        expect(second).toHaveBeenCalledWith(context);
+    });
+    it("does not execute disabled or unknown commands", () => {
+        const run = vi.fn();
+        const command = {
+            id: "publish",
+            label: "Publish",
+            enabled: false,
+            run,
+        };
+        expect(isMiraCommandEnabled(command, context)).toBe(false);
+        expect(executeMiraCommand([command], "publish", context)).toBe(false);
+        expect(executeMiraCommand([command], "missing", context)).toBe(false);
+        expect(run).not.toHaveBeenCalled();
+    });
+    it("executes command shortcuts through a CodeMirror keymap", () => {
+        const run = vi.fn();
+        const extension = createMiraCommandKeymap([
+            {
+                id: "save",
+                label: "Save",
+                keybindings: ["Ctrl-s"],
+                run,
+            },
+        ], () => context);
+        const view = new EditorView({
+            state: EditorState.create({
+                extensions: [extension],
+            }),
+        });
+        view.contentDOM.dispatchEvent(new KeyboardEvent("keydown", {
+            bubbles: true,
+            ctrlKey: true,
+            key: "s",
+        }));
+        expect(run).toHaveBeenCalledWith(context);
+        view.destroy();
+    });
+    it("mounts and reference-counts external and inline styles", () => {
+        const cleanupFirst = mountMiraExtensionStyles([
+            "/extension.css",
+            {
+                id: "extension-inline",
+                cssText: ".extension { color: rebeccapurple; }",
+            },
+        ]);
+        const cleanupSecond = mountMiraExtensionStyles([
+            "/extension.css",
+            {
+                id: "extension-inline",
+                cssText: ".extension { color: rebeccapurple; }",
+            },
+        ]);
+        expect(document.head.querySelectorAll("[data-mira-extension-style]")).toHaveLength(2);
+        cleanupFirst();
+        expect(document.head.querySelectorAll("[data-mira-extension-style]")).toHaveLength(2);
+        cleanupSecond();
+        expect(document.head.querySelectorAll("[data-mira-extension-style]")).toHaveLength(0);
+    });
+});
+describe("portable file targets", () => {
+    it("separates paths from heading and block fragments", () => {
+        expect(parseMiraFileTarget("notes/plan.md#Next Steps", "daily.md")).toEqual({
+            href: "notes/plan.md#Next Steps",
+            path: "notes/plan.md",
+            sourcePath: "daily.md",
+            subpath: "Next Steps",
+            fragment: {
+                kind: "heading",
+                value: "Next Steps",
+            },
+        });
+        expect(parseMiraFileTarget("notes/plan.md#^decision-1")).toEqual({
+            href: "notes/plan.md#^decision-1",
+            path: "notes/plan.md",
+            subpath: "^decision-1",
+            fragment: {
+                kind: "block",
+                value: "decision-1",
+            },
+            sourcePath: undefined,
+        });
+    });
+    it("keeps plain and empty-fragment targets portable", () => {
+        expect(parseMiraFileTarget("notes/plan.md")).toEqual({
+            href: "notes/plan.md",
+            path: "notes/plan.md",
+            sourcePath: undefined,
+            subpath: undefined,
+            fragment: undefined,
+        });
+        expect(parseMiraFileTarget("notes/plan.md#").fragment).toBeUndefined();
+    });
+});
+describe("portable list callout catalogs", () => {
+    it("overrides, disables, and appends markers without mutating defaults", () => {
+        const callouts = resolveMiraListCallouts([
+            { char: "@", color: "20, 160, 140", icon: "bookmark" },
+            { char: "%", enabled: false },
+            { char: "^", color: "80, 70, 220" },
+        ]);
+        expect(callouts.find((callout) => callout.char === "@")).toEqual({
+            char: "@",
+            color: "20, 160, 140",
+            icon: "bookmark",
+        });
+        expect(callouts.some((callout) => callout.char === "%")).toBe(false);
+        expect(callouts.at(-1)).toEqual({
+            char: "^",
+            color: "80, 70, 220",
+        });
+        expect(defaultMiraEditorListCallouts).toHaveLength(7);
+    });
+});
+describe("slash snippet helpers", () => {
+    it("creates markdown templates from cursor markers", () => {
+        expect(createMarkdownTemplate("## <|>")).toEqual({
+            markdown: "## ",
+            selection: 3,
+        });
+    });
+    it("creates slash commands from markdown snippets", () => {
+        expect(createSlashSnippet({
+            id: "callout",
+            label: "Callout",
+            description: "Insert a callout",
+            group: "Basic",
+            keywords: ["note"],
+            markdown: "> [!note] <|>\n> ",
+        })).toEqual({
+            id: "callout",
+            label: "Callout",
+            description: "Insert a callout",
+            group: "Basic",
+            keywords: ["note"],
+            insert: {
+                markdown: "> [!note] \n> ",
+                selection: 10,
+            },
+        });
+    });
+});

package/dist/extensions/selection-toolbar.d.ts

@@ -0,0 +1,6 @@
+import { type MiraSelectionToolbarConfig } from "../internal/codemirror/base/selection-toolbar";
+import type { MiraExtension } from ".";
+export { defaultMiraSelectionToolbarActions, miraSelectionToolbarActionIds, type MiraSelectionToolbarActionId, type MiraSelectionToolbarConfig, type MiraSelectionToolbarPlacement, } from "../internal/codemirror/base/selection-toolbar";
+/** Add the contextual formatting toolbar to editable Mira surfaces. */
+export declare function selectionToolbarExtension(config?: MiraSelectionToolbarConfig): MiraExtension;
+//# sourceMappingURL=selection-toolbar.d.ts.map

package/dist/extensions/selection-toolbar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"selection-toolbar.d.ts","sourceRoot":"","sources":["../../src/extensions/selection-toolbar.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,0BAA0B,EAChC,MAAM,+CAA+C,CAAC;AACvD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,GAAG,CAAC;AAEvC,OAAO,EACL,kCAAkC,EAClC,6BAA6B,EAC7B,KAAK,4BAA4B,EACjC,KAAK,0BAA0B,EAC/B,KAAK,6BAA6B,GACnC,MAAM,+CAA+C,CAAC;AAEvD,uEAAuE;AACvE,wBAAgB,yBAAyB,CACvC,MAAM,GAAE,0BAA+B,GACtC,aAAa,CAUf"}

package/dist/extensions/selection-toolbar.js

@@ -0,0 +1,14 @@
+import { createSelectionToolbarExtension, } from "../internal/codemirror/base/selection-toolbar";
+export { defaultMiraSelectionToolbarActions, miraSelectionToolbarActionIds, } from "../internal/codemirror/base/selection-toolbar";
+/** Add the contextual formatting toolbar to editable Mira surfaces. */
+export function selectionToolbarExtension(config = {}) {
+    return {
+        name: "selection-toolbar",
+        codeMirror({ mode, readonly }) {
+            if (readonly || mode === "preview") {
+                return null;
+            }
+            return createSelectionToolbarExtension(config);
+        },
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+import Mira from "./mira.svelte";
+import MiraCodeEditor from "./mira-code-editor.svelte";
+export { Mira, MiraCodeEditor };
+export type { MiraCodeEditorHandle, MiraCodeEditorHeight, MiraCodeEditorProps, MiraCodeEditorSurface, MiraCodeEditorVariant, } from "./mira-code-editor";
+export type { MiraFrontmatterConfig, MiraHandle, MiraProps, MiraOutlineVariant, } from "./types";
+export type { MiraMarkdownActionId } from "./core";
+export { miraBlockToolbarItemIds, type MiraBlockControlsOptions, type MiraBlockToolbarConfig, type MiraBlockToolbarItemId, type MiraToolbarPlacement, } from "./extensions";
+export default Mira;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,IAAI,MAAM,eAAe,CAAC;AACjC,OAAO,cAAc,MAAM,2BAA2B,CAAC;AAEvD,OAAO,EAAE,IAAI,EAAE,cAAc,EAAE,CAAC;AAChC,YAAY,EACV,oBAAoB,EACpB,oBAAoB,EACpB,mBAAmB,EACnB,qBAAqB,EACrB,qBAAqB,GACtB,MAAM,oBAAoB,CAAC;AAC5B,YAAY,EACV,qBAAqB,EACrB,UAAU,EACV,SAAS,EACT,kBAAkB,GACnB,MAAM,SAAS,CAAC;AACjB,YAAY,EAAE,oBAAoB,EAAE,MAAM,QAAQ,CAAC;AACnD,OAAO,EACL,uBAAuB,EACvB,KAAK,wBAAwB,EAC7B,KAAK,sBAAsB,EAC3B,KAAK,sBAAsB,EAC3B,KAAK,oBAAoB,GAC1B,MAAM,cAAc,CAAC;AACtB,eAAe,IAAI,CAAC"}

package/dist/index.js

@@ -0,0 +1,5 @@
+import Mira from "./mira.svelte";
+import MiraCodeEditor from "./mira-code-editor.svelte";
+export { Mira, MiraCodeEditor };
+export { miraBlockToolbarItemIds, } from "./extensions";
+export default Mira;

package/dist/index.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.test.d.ts.map

package/dist/index.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.test.d.ts","sourceRoot":"","sources":["../src/index.test.ts"],"names":[],"mappings":""}

package/dist/index.test.js

@@ -0,0 +1,64 @@
+import { mount, tick, unmount } from "svelte";
+import { describe, expect, it } from "vitest";
+import Mira from "./mira.svelte";
+describe("Mira", () => {
+    it("exports the Svelte component", () => {
+        expect(Mira).toBeTruthy();
+    });
+    it("renders opaque theme tokens and an independent color mode", async () => {
+        const target = document.createElement("div");
+        document.body.append(target);
+        const component = mount(Mira, {
+            target,
+            props: {
+                value: "# Appearance",
+                mode: "preview",
+                theme: "obsidian company-brand",
+                colorMode: "dark",
+            },
+        });
+        await tick();
+        const root = target.querySelector(".mira");
+        expect(root?.dataset.miraTheme).toBe("obsidian company-brand");
+        expect(root?.dataset.miraColorMode).toBe("dark");
+        expect(root?.classList.contains("dark")).toBe(true);
+        await unmount(component);
+        target.remove();
+    });
+    it("inherits appearance when theme and color mode are omitted", async () => {
+        const target = document.createElement("div");
+        document.body.append(target);
+        const component = mount(Mira, {
+            target,
+            props: { value: "# Inherit", mode: "preview", theme: "" },
+        });
+        await tick();
+        const root = target.querySelector(".mira");
+        expect(root?.hasAttribute("data-mira-theme")).toBe(false);
+        expect(root?.hasAttribute("data-mira-color-mode")).toBe(false);
+        await unmount(component);
+        target.remove();
+    });
+    it("uses the shared action engine through its handle and minimal toolbar", async () => {
+        const target = document.createElement("div");
+        document.body.append(target);
+        const component = mount(Mira, {
+            target,
+            props: { value: "word", mode: "source" },
+        });
+        await tick();
+        component.setSelection({
+            anchor: { line: 0, ch: 2 },
+            head: { line: 0, ch: 2 },
+        });
+        target.querySelector('[aria-label="Bold"]')?.click();
+        expect(component.getMarkdown()).toBe("**word**");
+        expect(component.applyMarkdownAction("bold")).toBe(true);
+        expect(component.getMarkdown()).toBe("word");
+        component.setMode("preview");
+        expect(component.applyMarkdownAction("italic")).toBe(false);
+        expect(component.getMarkdown()).toBe("word");
+        await unmount(component);
+        target.remove();
+    });
+});