nebula-cms 0.1.3 → 0.1.5

package/dist/client/js/drafts/storage.js

@@ -0,0 +1,76 @@
+/*
+ * Draft persistence layer backed by IndexedDB.
+ * CRUD operations for draft content entries, used by the editor and merge logic.
+ */
+import { openDB } from '../storage/db';
+// Object store name for drafts
+const STORE = 'drafts';
+/**
+ * Saves or updates a draft in IndexedDB.
+ * @param {Draft} draft - The draft record to persist
+ * @return {Promise<void>}
+ */
+export async function saveDraft(draft) {
+    const db = await openDB();
+    return new Promise((resolve, reject) => {
+        const tx = db.transaction(STORE, 'readwrite');
+        tx.objectStore(STORE).put(draft);
+        tx.oncomplete = () => resolve();
+        tx.onerror = () => reject(tx.error);
+    });
+}
+/**
+ * Loads all drafts for a given collection.
+ * @param {string} collection - The collection name to filter by
+ * @return {Promise<Draft[]>} All drafts belonging to the collection
+ */
+export async function loadDrafts(collection) {
+    const db = await openDB();
+    return new Promise((resolve, reject) => {
+        const tx = db.transaction(STORE, 'readonly');
+        const request = tx.objectStore(STORE).getAll();
+        request.onsuccess = () => {
+            const all = request.result;
+            resolve(all.filter((d) => d.collection === collection));
+        };
+        request.onerror = () => reject(request.error);
+    });
+}
+/**
+ * Loads a single draft by ID.
+ * @param {string} id - The draft UUID
+ * @return {Promise<Draft | null>} The draft, or null if not found
+ */
+export async function loadDraft(id) {
+    const db = await openDB();
+    return new Promise((resolve, reject) => {
+        const tx = db.transaction(STORE, 'readonly');
+        const request = tx.objectStore(STORE).get(id);
+        request.onsuccess = () => resolve(request.result ?? null);
+        request.onerror = () => reject(request.error);
+    });
+}
+/**
+ * Deletes a draft from IndexedDB by ID.
+ * @param {string} id - The draft UUID to delete
+ * @return {Promise<void>}
+ */
+export async function deleteDraft(id) {
+    const db = await openDB();
+    return new Promise((resolve, reject) => {
+        const tx = db.transaction(STORE, 'readwrite');
+        tx.objectStore(STORE).delete(id);
+        tx.oncomplete = () => resolve();
+        tx.onerror = () => reject(tx.error);
+    });
+}
+/**
+ * Finds a draft linked to a specific live file.
+ * @param {string} collection - The collection name
+ * @param {string} filename - The live file's filename
+ * @return {Promise<Draft | null>} The matching draft, or null if none exists
+ */
+export async function getDraftByFile(collection, filename) {
+    const drafts = await loadDrafts(collection);
+    return drafts.find((d) => !d.isNew && d.filename === filename) ?? null;
+}

package/dist/client/js/drafts/workers/diff.d.ts

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

package/dist/client/js/drafts/workers/diff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diff.d.ts","sourceRoot":"","sources":["../../../../../src/client/js/drafts/workers/diff.ts"],"names":[],"mappings":""}

package/dist/client/js/drafts/workers/diff.js

@@ -0,0 +1,20 @@
+import { stableStringify } from '../../utils/stable-stringify';
+/*
+ * Listens for diff requests, compares each draft's snapshot against current
+ * live content, and returns a map of draftId to isOutdated.
+ */
+self.addEventListener('message', (event) => {
+    const { type, entries } = event.data;
+    if (type !== 'diff')
+        return;
+    const results = {};
+    for (const entry of entries) {
+        // Reconstruct the comparable string using the same format as snapshot creation
+        const liveString = stableStringify({
+            formData: entry.liveFormData,
+            body: entry.liveBody,
+        });
+        results[entry.draftId] = liveString !== entry.snapshot;
+    }
+    self.postMessage({ type: 'diff-result', results });
+});

package/dist/client/js/editor/editor.svelte.d.ts

@@ -0,0 +1,124 @@
+import { type PathSegment } from '../utils/schema-utils';
+export type EditorFile = {
+    body: string;
+    formData: Record<string, unknown>;
+    dirty: boolean;
+    saving: boolean;
+    filename: string;
+    bodyLoaded: boolean;
+    draftId: string | null;
+    isNewDraft: boolean;
+};
+export type EditorStateConfig = {
+    body: string;
+    formData: Record<string, unknown>;
+    filename: string;
+    bodyLoaded: boolean;
+    draftId: string | null;
+    isNewDraft: boolean;
+    snapshot: string | null;
+    collection: string;
+    draftCreatedAt: string | null;
+};
+export declare const editor: {
+    readonly data: Record<string, unknown>;
+    readonly tab: string;
+    readonly originalFilename: string;
+};
+/**
+ * Applies a full set of editor state values, resetting dirty/saving flags and updating save baselines.
+ * @param {EditorStateConfig} c - All editor state fields to apply
+ * @param {boolean} open - Whether to mark the file as open
+ * @return {void}
+ */
+export declare function applyEditorState(c: EditorStateConfig, open: boolean): void;
+/**
+ * Returns a snapshot of draft-related internal state for use by editor-draft-ops. Exposes private module state without leaking $state reactivity.
+ * @return {object} Snapshot of all draft-related editor state
+ */
+export declare function _getDraftState(): {
+    saving: boolean;
+    draftId: string | null;
+    isNewDraft: boolean;
+    snapshot: string | null;
+    currentCollection: string;
+    draftCreatedAt: string | null;
+    lastSavedFormData: string;
+    lastSavedBody: string;
+    formData: Record<string, unknown>;
+    body: string;
+    filename: string;
+    originalFilename: string;
+    dirty: boolean;
+};
+/**
+ * Applies draft-related state mutations from editor-draft-ops back into the reactive module state.
+ * @param {Partial<ReturnType<typeof _getDraftState>>} updates - Fields to update
+ * @return {void}
+ */
+export declare function _setDraftState(updates: Partial<ReturnType<typeof _getDraftState>>): void;
+/**
+ * Returns the current editor file state, or null if no file is open.
+ * @return {EditorFile | null} The current editor file state, or null
+ */
+export declare function getEditorFile(): EditorFile | null;
+/**
+ * Sets the active editor tab.
+ * @param {string} tab - The tab identifier to activate
+ * @return {void}
+ */
+export declare function setActiveTab(tab: string): void;
+/**
+ * Updates a single field within formData by path and recomputes dirty state.
+ * @param {PathSegment[]} path - Ordered path segments addressing the field
+ * @param {unknown} value - The new value to assign at the given path
+ * @return {void}
+ */
+export declare function updateFormField(path: PathSegment[], value: unknown): void;
+/**
+ * Populates the editor with metadata so the UI renders without waiting for the async file read. Checks IndexedDB for an existing draft first — if found, loads draft data instead.
+ * @param {string} collection - The collection this file belongs to
+ * @param {string} itemFilename - The content file's name
+ * @param {Record<string, unknown>} data - Pre-parsed frontmatter data
+ * @return {Promise<void>}
+ */
+export declare function preloadFile(collection: string, itemFilename: string, data: Record<string, unknown>): Promise<void>;
+/**
+ * Sets the filename for the current editor file. Used by the filename dialog.
+ * @param {string} newFilename - The new filename to set
+ * @return {void}
+ */
+export declare function setFilename(newFilename: string): void;
+/**
+ * Changes the file format by swapping the filename extension to the new type's default. Preserves the slug (base filename without extension) and leaves originalFilename untouched so publishFile can detect the rename and delete the old file on disk.
+ * @param {string} newType - The type identifier to switch to (e.g. 'md', 'json')
+ * @return {void}
+ */
+export declare function changeFileFormat(newType: string): void;
+/**
+ * Sets a default file format for a new draft based on the collection's supported file types. Only applies when the editor has no filename yet (new draft). Sets the activeTab to 'body' if the format supports body editing.
+ * @param {string[]} fileTypes - Type identifiers from the schema's files array
+ * @return {void}
+ */
+export declare function setDefaultFormat(fileTypes: string[]): void;
+/**
+ * Loads body content via StorageClient for an already-preloaded file, completing the two-phase load.
+ * @param {string} collection - The collection the file belongs to
+ * @param {string} filename - The filename to read within the collection
+ * @return {Promise<void>}
+ */
+export declare function loadFileBody(collection: string, filename: string): Promise<void>;
+/**
+ * Updates the editor body content and recomputes dirty state.
+ * Only compares body against its saved snapshot — avoids serializing
+ * formData to JSON on every keystroke from CodeMirror's update listener.
+ * @param {string} content - The new body content
+ * @return {void}
+ */
+export declare function updateBody(content: string): void;
+/**
+ * Resets all editor state including draft-specific fields.
+ * @return {void}
+ */
+export declare function clearEditor(): void;
+//# sourceMappingURL=editor.svelte.d.ts.map

package/dist/client/js/editor/editor.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"editor.svelte.d.ts","sourceRoot":"","sources":["../../../../src/client/js/editor/editor.svelte.ts"],"names":[],"mappings":"AAOA,OAAO,EAAa,KAAK,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAWpE,MAAM,MAAM,UAAU,GAAG;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAClC,KAAK,EAAE,OAAO,CAAC;IACf,MAAM,EAAE,OAAO,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,OAAO,CAAC;IACpB,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,UAAU,EAAE,OAAO,CAAC;CACrB,CAAC;AAGF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAClC,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,OAAO,CAAC;IACpB,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,UAAU,EAAE,OAAO,CAAC;IACpB,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,UAAU,EAAE,MAAM,CAAC;IACnB,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;CAC/B,CAAC;AAqBF,eAAO,MAAM,MAAM;mBAEL,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;kBAIxB,MAAM;+BAIO,MAAM;CAG/B,CAAC;AAEF;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,iBAAiB,EAAE,IAAI,EAAE,OAAO,GAAG,IAAI,CAkB1E;AAeD;;;GAGG;AACH,wBAAgB,cAAc;;;;;;;;;;;;;;EAgB7B;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAC5B,OAAO,EAAE,OAAO,CAAC,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC,GAClD,IAAI,CAYN;AACD;;;GAGG;AACH,wBAAgB,aAAa,IAAI,UAAU,GAAG,IAAI,CAYjD;AACD;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAE9C;AACD;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,WAAW,EAAE,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI,CAIzE;AAED;;;;;;GAMG;AACH,wBAAsB,WAAW,CAC/B,UAAU,EAAE,MAAM,EAClB,YAAY,EAAE,MAAM,EACpB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC5B,OAAO,CAAC,IAAI,CAAC,CAwCf;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI,CAErD;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAQtD;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,IAAI,CAS1D;AAED;;;;;GAKG;AACH,wBAAsB,YAAY,CAChC,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,IAAI,CAAC,CAaf;AAED;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAGhD;AAED;;;GAGG;AACH,wBAAgB,WAAW,IAAI,IAAI,CAelC"}

package/dist/client/js/editor/editor.svelte.js

@@ -0,0 +1,294 @@
+/*
+ * Reactive editor state for the file editing view.
+ * Manages loading, saving, and dirty-checking of content files and drafts.
+ */
+import { registerDirtyChecker } from '../state/router.svelte';
+import { splitFrontmatter } from '../utils/frontmatter';
+import { setByPath } from '../utils/schema-utils';
+import { getDraftByFile } from '../drafts/storage';
+import { storageClient } from '../state/state.svelte';
+import { getFileCategory, stripExtension, getDefaultExtension, FILE_TYPES, } from '../utils/file-types';
+let body = $state('');
+let formData = $state({});
+let dirty = $state(false);
+let saving = $state(false);
+let lastSavedBody = '';
+let lastSavedFormData = '{}';
+let filename = $state('');
+let fileOpen = $state(false);
+let activeTab = $state('metadata');
+let bodyLoaded = $state(false);
+let originalFilename = $state(''); // filename at load time — publish uses this to detect renames
+// Draft-specific state
+let draftId = $state(null);
+let isNewDraft = $state(false);
+let snapshot = $state(null);
+let currentCollection = $state('');
+let draftCreatedAt = $state(null);
+registerDirtyChecker(() => dirty);
+export const editor = {
+    // Current structured form data for the open file.
+    get data() {
+        return formData;
+    },
+    // Currently active editor tab identifier.
+    get tab() {
+        return activeTab;
+    },
+    // Filename at load time — publish uses this to detect renames.
+    get originalFilename() {
+        return originalFilename;
+    },
+};
+/**
+ * Applies a full set of editor state values, resetting dirty/saving flags and updating save baselines.
+ * @param {EditorStateConfig} c - All editor state fields to apply
+ * @param {boolean} open - Whether to mark the file as open
+ * @return {void}
+ */
+export function applyEditorState(c, open) {
+    formData = c.formData;
+    lastSavedFormData = JSON.stringify(c.formData);
+    body = c.body;
+    lastSavedBody = c.body;
+    dirty = false;
+    formDataDirty = false;
+    saving = false;
+    filename = c.filename;
+    originalFilename = c.filename;
+    bodyLoaded = c.bodyLoaded;
+    activeTab = 'metadata';
+    fileOpen = open;
+    draftId = c.draftId;
+    isNewDraft = c.isNewDraft;
+    snapshot = c.snapshot;
+    currentCollection = c.collection;
+    draftCreatedAt = c.draftCreatedAt;
+}
+/*
+ * Tracks whether formData has diverged from its saved snapshot.
+ * Updated only by updateFormField to avoid re-serializing on every body keystroke.
+ */
+let formDataDirty = false;
+/**
+ * Recomputes dirty state from body comparison and the cached formData flag.
+ * @return {void}
+ */
+function recomputeDirty() {
+    dirty = body !== lastSavedBody || formDataDirty;
+}
+/**
+ * Returns a snapshot of draft-related internal state for use by editor-draft-ops. Exposes private module state without leaking $state reactivity.
+ * @return {object} Snapshot of all draft-related editor state
+ */
+export function _getDraftState() {
+    return {
+        saving,
+        draftId,
+        isNewDraft,
+        snapshot,
+        currentCollection,
+        draftCreatedAt,
+        lastSavedFormData,
+        lastSavedBody,
+        formData,
+        body,
+        filename,
+        originalFilename,
+        dirty,
+    };
+}
+/**
+ * Applies draft-related state mutations from editor-draft-ops back into the reactive module state.
+ * @param {Partial<ReturnType<typeof _getDraftState>>} updates - Fields to update
+ * @return {void}
+ */
+export function _setDraftState(updates) {
+    if ('saving' in updates)
+        saving = updates.saving;
+    if ('draftId' in updates)
+        draftId = updates.draftId;
+    if ('isNewDraft' in updates)
+        isNewDraft = updates.isNewDraft;
+    if ('snapshot' in updates)
+        snapshot = updates.snapshot;
+    if ('draftCreatedAt' in updates)
+        draftCreatedAt = updates.draftCreatedAt;
+    if ('lastSavedFormData' in updates)
+        lastSavedFormData = updates.lastSavedFormData;
+    if ('lastSavedBody' in updates)
+        lastSavedBody = updates.lastSavedBody;
+    if ('dirty' in updates)
+        dirty = updates.dirty;
+    if ('originalFilename' in updates)
+        originalFilename = updates.originalFilename;
+}
+/**
+ * Returns the current editor file state, or null if no file is open.
+ * @return {EditorFile | null} The current editor file state, or null
+ */
+export function getEditorFile() {
+    if (!fileOpen)
+        return null;
+    return {
+        body,
+        formData,
+        dirty,
+        saving,
+        filename,
+        bodyLoaded,
+        draftId,
+        isNewDraft,
+    };
+}
+/**
+ * Sets the active editor tab.
+ * @param {string} tab - The tab identifier to activate
+ * @return {void}
+ */
+export function setActiveTab(tab) {
+    activeTab = tab;
+}
+/**
+ * Updates a single field within formData by path and recomputes dirty state.
+ * @param {PathSegment[]} path - Ordered path segments addressing the field
+ * @param {unknown} value - The new value to assign at the given path
+ * @return {void}
+ */
+export function updateFormField(path, value) {
+    setByPath(formData, path, value);
+    formDataDirty = JSON.stringify(formData) !== lastSavedFormData;
+    recomputeDirty();
+}
+/**
+ * Populates the editor with metadata so the UI renders without waiting for the async file read. Checks IndexedDB for an existing draft first — if found, loads draft data instead.
+ * @param {string} collection - The collection this file belongs to
+ * @param {string} itemFilename - The content file's name
+ * @param {Record<string, unknown>} data - Pre-parsed frontmatter data
+ * @return {Promise<void>}
+ */
+export async function preloadFile(collection, itemFilename, data) {
+    // Compare slugs so a format change (e.g. .md → .mdx) doesn't trigger a full reload
+    if (stripExtension(filename) === stripExtension(itemFilename) && fileOpen)
+        return;
+    // Check IndexedDB for an existing draft of this live file
+    const d = await getDraftByFile(collection, itemFilename);
+    if (d) {
+        // Draft already contains body content, no disk read needed
+        applyEditorState({
+            body: d.body,
+            formData: d.formData,
+            filename: itemFilename,
+            bodyLoaded: true,
+            draftId: d.id,
+            isNewDraft: d.isNew,
+            snapshot: d.snapshot,
+            collection,
+            draftCreatedAt: d.createdAt,
+        }, true);
+        return;
+    }
+    // No draft — load live data; $state.snapshot strips Svelte reactive proxies
+    applyEditorState({
+        body: '',
+        formData: $state.snapshot(data),
+        filename: itemFilename,
+        bodyLoaded: false,
+        draftId: null,
+        isNewDraft: false,
+        snapshot: null,
+        collection,
+        draftCreatedAt: null,
+    }, true);
+}
+/**
+ * Sets the filename for the current editor file. Used by the filename dialog.
+ * @param {string} newFilename - The new filename to set
+ * @return {void}
+ */
+export function setFilename(newFilename) {
+    filename = newFilename;
+}
+/**
+ * Changes the file format by swapping the filename extension to the new type's default. Preserves the slug (base filename without extension) and leaves originalFilename untouched so publishFile can detect the rename and delete the old file on disk.
+ * @param {string} newType - The type identifier to switch to (e.g. 'md', 'json')
+ * @return {void}
+ */
+export function changeFileFormat(newType) {
+    const ext = getDefaultExtension(newType);
+    if (!ext)
+        return;
+    const slug = filename ? stripExtension(filename) : '';
+    filename = slug ? slug + ext : '';
+    // Switch to metadata tab if the new format has no body editor
+    const config = FILE_TYPES[newType];
+    if (config && !config.hasBody && activeTab === 'body')
+        activeTab = 'metadata';
+}
+/**
+ * Sets a default file format for a new draft based on the collection's supported file types. Only applies when the editor has no filename yet (new draft). Sets the activeTab to 'body' if the format supports body editing.
+ * @param {string[]} fileTypes - Type identifiers from the schema's files array
+ * @return {void}
+ */
+export function setDefaultFormat(fileTypes) {
+    if (filename || fileTypes.length === 0)
+        return;
+    const defaultType = fileTypes[0];
+    const ext = getDefaultExtension(defaultType);
+    if (!ext)
+        return;
+    // Set just the extension so EditorTabs and FormatSelector derive the correct type
+    filename = ext;
+    // Activate body tab for content types that support it
+    if (FILE_TYPES[defaultType]?.hasBody)
+        activeTab = 'body';
+}
+/**
+ * Loads body content via StorageClient for an already-preloaded file, completing the two-phase load.
+ * @param {string} collection - The collection the file belongs to
+ * @param {string} filename - The filename to read within the collection
+ * @return {Promise<void>}
+ */
+export async function loadFileBody(collection, filename) {
+    const category = getFileCategory(filename);
+    if (category === 'data') {
+        // Data files have no body — all content was parsed as formData during preload
+        bodyLoaded = true;
+        return;
+    }
+    if (!storageClient)
+        return;
+    const text = await storageClient.readFile(collection, filename);
+    const split = splitFrontmatter(text);
+    // Strip leading/trailing newlines from body; added back on save when reconstituting the file
+    body = lastSavedBody = split.body.replace(/^\n+/, '').replace(/\n+$/, '');
+    bodyLoaded = true;
+}
+/**
+ * Updates the editor body content and recomputes dirty state.
+ * Only compares body against its saved snapshot — avoids serializing
+ * formData to JSON on every keystroke from CodeMirror's update listener.
+ * @param {string} content - The new body content
+ * @return {void}
+ */
+export function updateBody(content) {
+    body = content;
+    recomputeDirty();
+}
+/**
+ * Resets all editor state including draft-specific fields.
+ * @return {void}
+ */
+export function clearEditor() {
+    applyEditorState({
+        body: '',
+        formData: {},
+        filename: '',
+        bodyLoaded: false,
+        draftId: null,
+        isNewDraft: false,
+        snapshot: null,
+        collection: '',
+        draftCreatedAt: null,
+    }, false);
+}

package/dist/client/js/editor/languages.d.ts

@@ -0,0 +1,11 @@
+import type { Extension } from '@codemirror/state';
+/**
+ * Returns the composed language extension (parser + syntax highlighting)
+ * for a given file type. Results are cached per type so repeated calls
+ * return the same reference. Today all body formats use the same markdown
+ * extension — individual entries can diverge when custom parsers are added.
+ * @param {string} fileType - Type identifier from the file type registry (e.g. 'md', 'mdx', 'markdoc')
+ * @return {Extension} The composed CodeMirror language extension
+ */
+export declare function getLanguageExtension(fileType: string): Extension;
+//# sourceMappingURL=languages.d.ts.map

package/dist/client/js/editor/languages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"languages.d.ts","sourceRoot":"","sources":["../../../../src/client/js/editor/languages.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AA4DnD;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,CAiBhE"}

package/dist/client/js/editor/languages.js

@@ -0,0 +1,93 @@
+/*
+ * Language extension registry for the CodeMirror editor.
+ * Provides lazy-loaded language extensions keyed by file type identifier.
+ * Today all body formats use the same markdown parser — the registry
+ * exists so MDX/Markdoc-specific parsers can drop in later without
+ * changing EditorPane.
+ */
+import { markdown, markdownLanguage } from '@codemirror/lang-markdown';
+import { languages } from '@codemirror/language-data';
+import { syntaxHighlighting, HighlightStyle } from '@codemirror/language';
+import { tags as t } from '@lezer/highlight';
+// Highlight style for the editor — headings are sized, syntax markers are dimmed.
+const editorHighlight = HighlightStyle.define([
+    // Headings — larger, bold
+    {
+        tag: t.heading1,
+        fontSize: '1.5rem',
+        fontWeight: 'bold',
+        color: 'var(--cms-fg)',
+    },
+    {
+        tag: t.heading2,
+        fontSize: '1.25rem',
+        fontWeight: 'bold',
+        color: 'var(--cms-fg)',
+    },
+    {
+        tag: t.heading3,
+        fontSize: '1rem',
+        fontWeight: 'bold',
+        color: 'var(--cms-fg)',
+    },
+    // Emphasis
+    { tag: t.strong, fontWeight: 'bold', color: 'var(--cms-fg)' },
+    { tag: t.emphasis, fontStyle: 'italic', color: 'var(--cms-fg)' },
+    // Inline code
+    { tag: t.monospace, color: 'var(--light-orange)' },
+    // Links
+    { tag: t.link, color: 'var(--light-teal)', textDecoration: 'underline' },
+    { tag: t.url, color: 'var(--light-green)' },
+    // Syntax markers — dimmed
+    { tag: t.processingInstruction, color: 'var(--cms-muted)' },
+    { tag: t.labelName, color: 'var(--light-teal)' },
+    // Code block language tag
+    { tag: t.tagName, color: 'var(--light-purple)' },
+    // Lists
+    { tag: t.list, color: 'var(--light-teal)' },
+    // Blockquotes
+    { tag: t.quote, color: 'var(--cms-muted)', fontStyle: 'italic' },
+    // Code block contents — language-specific highlighting
+    { tag: t.keyword, color: 'var(--light-plum)' },
+    { tag: t.string, color: 'var(--light-orange)' },
+    { tag: t.variableName, color: 'var(--light-teal)' },
+    { tag: t.function(t.variableName), color: 'var(--gold)' },
+    { tag: t.typeName, color: 'var(--light-green)' },
+    { tag: t.number, color: 'var(--light-purple)' },
+    { tag: t.bool, color: 'var(--light-purple)' },
+    { tag: t.comment, color: 'var(--cms-muted)', fontStyle: 'italic' },
+    { tag: t.operator, color: 'var(--light-red)' },
+    { tag: t.punctuation, color: 'var(--cms-muted)' },
+    { tag: t.meta, color: 'var(--cms-muted)' },
+]);
+/*
+ * Cached extensions per file type — avoids re-creating parser instances and
+ * lets CodeMirror short-circuit its extension diff via reference equality.
+ */
+const cache = new Map();
+/**
+ * Returns the composed language extension (parser + syntax highlighting)
+ * for a given file type. Results are cached per type so repeated calls
+ * return the same reference. Today all body formats use the same markdown
+ * extension — individual entries can diverge when custom parsers are added.
+ * @param {string} fileType - Type identifier from the file type registry (e.g. 'md', 'mdx', 'markdoc')
+ * @return {Extension} The composed CodeMirror language extension
+ */
+export function getLanguageExtension(fileType) {
+    let ext = cache.get(fileType);
+    if (ext)
+        return ext;
+    /*
+     * All body formats currently use the same markdown parser.
+     * When MDX/Markdoc-specific parsers are built, add branches here.
+     */
+    ext = [
+        markdown({
+            base: markdownLanguage,
+            codeLanguages: languages,
+        }),
+        syntaxHighlighting(editorHighlight),
+    ];
+    cache.set(fileType, ext);
+    return ext;
+}

package/dist/client/js/editor/link-wrap.d.ts

@@ -0,0 +1,6 @@
+import { ViewPlugin, type DecorationSet } from '@codemirror/view';
+export declare const linkWrapPlugin: ViewPlugin<{
+    decorations: DecorationSet;
+    update(update: import("@codemirror/view").ViewUpdate): void;
+}, undefined>;
+//# sourceMappingURL=link-wrap.d.ts.map

package/dist/client/js/editor/link-wrap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"link-wrap.d.ts","sourceRoot":"","sources":["../../../../src/client/js/editor/link-wrap.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,UAAU,EAAc,KAAK,aAAa,EAAE,MAAM,kBAAkB,CAAC;AA6B9E,eAAO,MAAM,cAAc;;;aAU1B,CAAC"}