nebula-notebook 0.1.1 → 0.2.0

package/node-server/dist/fs/notebook-formats/percent.d.ts

@@ -0,0 +1,25 @@
+/**
+ * jupytext percent-format adapter for #-comment languages (.py, .R, .jl).
+ *
+ * The format is defined entirely in terms of `#` line comments (markers,
+ * header, commented markdown bodies), so the same parser/serializer works
+ * verbatim for any language that uses `#` comments — Python, R, Julia.
+ * The file extension only decides the default kernel (see registry).
+ *
+ * Format essentials:
+ *   - optional jupytext-style header: `# ---` / `# `-prefixed YAML / `# ---`
+ *   - `# %%` markers start cells; `[markdown]` / `[raw]` tag cell type;
+ *     `id=<token>` carries the Nebula cell id (jupytext-legal key=value)
+ *   - markdown/raw bodies are `# `-commented
+ *   - outputs and execution counts are never serialized
+ *
+ * Anything on a marker line that we don't understand is preserved verbatim
+ * (cell._metadata.percent_header_rest) and re-emitted — never interpreted.
+ */
+import { NotebookFormatAdapter } from './types';
+/** Content-based discrimination (the VS Code/jupytext convention): a .py
+ *  file IS a percent notebook iff it has a `# %%` cell marker or a jupytext
+ *  header. Marker-less files are plain scripts — Nebula must never write
+ *  metadata into them as a side effect of merely opening them. */
+export declare function isPercentNotebookText(text: string): boolean;
+export declare const percentAdapter: NotebookFormatAdapter;

package/node-server/dist/fs/notebook-formats/percent.js

@@ -0,0 +1,286 @@
+"use strict";
+/**
+ * jupytext percent-format adapter for #-comment languages (.py, .R, .jl).
+ *
+ * The format is defined entirely in terms of `#` line comments (markers,
+ * header, commented markdown bodies), so the same parser/serializer works
+ * verbatim for any language that uses `#` comments — Python, R, Julia.
+ * The file extension only decides the default kernel (see registry).
+ *
+ * Format essentials:
+ *   - optional jupytext-style header: `# ---` / `# `-prefixed YAML / `# ---`
+ *   - `# %%` markers start cells; `[markdown]` / `[raw]` tag cell type;
+ *     `id=<token>` carries the Nebula cell id (jupytext-legal key=value)
+ *   - markdown/raw bodies are `# `-commented
+ *   - outputs and execution counts are never serialized
+ *
+ * Anything on a marker line that we don't understand is preserved verbatim
+ * (cell._metadata.percent_header_rest) and re-emitted — never interpreted.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.percentAdapter = void 0;
+exports.isPercentNotebookText = isPercentNotebookText;
+const YAML = __importStar(require("yaml"));
+const MARKER_RE = /^#\s*%%(.*)$/;
+// Accept quoted (proper jupytext key="value" metadata) and bare id tokens
+const ID_TOKEN_RE = /(^|\s)id="?([A-Za-z0-9_-]+)"?/;
+function normalizeEol(text) {
+    return text.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+}
+function parseMarkerRemainder(remainder) {
+    let rest = remainder;
+    let cellType = 'code';
+    if (/(^|\s)\[markdown\](\s|$)/.test(rest)) {
+        cellType = 'markdown';
+        rest = rest.replace(/(^|\s)\[markdown\](?=\s|$)/, '$1');
+    }
+    else if (/(^|\s)\[raw\](\s|$)/.test(rest)) {
+        cellType = 'raw';
+        rest = rest.replace(/(^|\s)\[raw\](?=\s|$)/, '$1');
+    }
+    let id = null;
+    const idMatch = rest.match(ID_TOKEN_RE);
+    if (idMatch) {
+        id = idMatch[2];
+        rest = rest.replace(ID_TOKEN_RE, '$1');
+    }
+    return { cellType, id, rest: rest.replace(/\s+/g, ' ').trim() };
+}
+/** Markdown/raw bodies are `# `-commented. A body line that would itself
+ *  render as a cell marker is backslash-escaped (`\%%` ↔ `%%`) so the
+ *  file-level scanner can never mistake it for a marker. Classical escape:
+ *  serializer prepends one backslash to any leading `\*%%` run, parser
+ *  removes one. Lossless for all inputs. */
+function encodeCommentLine(line) {
+    const escaped = /^(\s*)(\\*)%%/.test(line)
+        ? line.replace(/^(\s*)(\\*)%%/, '$1\\$2%%')
+        : line;
+    return escaped === '' ? '#' : `# ${escaped}`;
+}
+function decodeCommentLine(line) {
+    let body;
+    if (line === '#')
+        body = '';
+    else if (line.startsWith('# '))
+        body = line.slice(2);
+    else if (line.startsWith('#'))
+        body = line.slice(1);
+    else
+        body = line; // lenient: uncommented line inside a markdown body
+    return /^(\s*)\\(\\*)%%/.test(body) ? body.replace(/^(\s*)\\(\\*)%%/, '$1$2%%') : body;
+}
+function parseHeader(lines) {
+    if (lines[0] !== '# ---')
+        return { metadata: {}, kernelspecName: null, bodyStart: 0 };
+    let end = -1;
+    for (let i = 1; i < lines.length; i++) {
+        if (lines[i] === '# ---') {
+            end = i;
+            break;
+        }
+        if (!lines[i].startsWith('#'))
+            return { metadata: {}, kernelspecName: null, bodyStart: 0 };
+    }
+    if (end === -1)
+        return { metadata: {}, kernelspecName: null, bodyStart: 0 };
+    const yamlText = lines
+        .slice(1, end)
+        .map((l) => (l === '#' ? '' : l.startsWith('# ') ? l.slice(2) : l.slice(1)))
+        .join('\n');
+    let headerObj;
+    try {
+        const parsed = YAML.parse(yamlText);
+        headerObj = parsed && typeof parsed === 'object' ? parsed : {};
+    }
+    catch {
+        // Unparseable header: treat the whole block as content rather than lose it
+        return { metadata: {}, kernelspecName: null, bodyStart: 0 };
+    }
+    const jupyter = (headerObj.jupyter && typeof headerObj.jupyter === 'object'
+        ? headerObj.jupyter
+        : {});
+    const metadata = { ...jupyter };
+    const extra = {};
+    for (const [k, v] of Object.entries(headerObj)) {
+        if (k !== 'jupyter')
+            extra[k] = v;
+    }
+    if (Object.keys(extra).length > 0)
+        metadata.__percent_header_extra = extra;
+    const kernelspec = metadata.kernelspec;
+    const kernelspecName = typeof kernelspec?.name === 'string' ? kernelspec.name : null;
+    // Skip one blank separator line after the header if present
+    let bodyStart = end + 1;
+    if (lines[bodyStart] === '')
+        bodyStart++;
+    return { metadata, kernelspecName, bodyStart };
+}
+function makeCell(index, info, bodyLines, trimSeparator) {
+    const cellType = info?.cellType ?? 'code';
+    // The serializer emits exactly one blank separator line between a cell body
+    // and the NEXT marker. Trim it only when a following marker caused this
+    // flush — at EOF there is no separator, so trailing blanks belong to the
+    // cell content itself.
+    const body = [...bodyLines];
+    if (trimSeparator && body[body.length - 1] === '')
+        body.pop();
+    const content = cellType === 'code'
+        ? body.join('\n')
+        : body.map(decodeCommentLine).join('\n');
+    const cell = {
+        id: info?.id ?? `cell-${index}`,
+        type: cellType === 'code' ? 'code' : 'markdown',
+        content,
+        outputs: [],
+        executionCount: null,
+        isExecuting: false,
+    };
+    const meta = {};
+    if (cellType === 'raw')
+        meta.percent_cell_type = 'raw';
+    if (info && info.rest)
+        meta.percent_header_rest = info.rest;
+    if (Object.keys(meta).length > 0)
+        cell._metadata = meta;
+    return cell;
+}
+function parse(text) {
+    const lines = normalizeEol(text).split('\n');
+    // Drop the implicit final empty string from a trailing newline
+    if (lines.length > 0 && lines[lines.length - 1] === '')
+        lines.pop();
+    const { metadata, kernelspecName, bodyStart } = parseHeader(lines);
+    const cells = [];
+    let currentInfo = null;
+    let currentBody = [];
+    let sawMarker = false;
+    let started = false; // whether any non-blank content seen before first marker
+    const flush = (trimSeparator) => {
+        if (currentInfo === null && !started)
+            return; // nothing accumulated
+        cells.push(makeCell(cells.length, currentInfo, currentBody, trimSeparator));
+    };
+    for (let i = bodyStart; i < lines.length; i++) {
+        const line = lines[i];
+        const m = line.match(MARKER_RE);
+        if (m) {
+            if (sawMarker || started)
+                flush(true);
+            currentInfo = parseMarkerRemainder(m[1]);
+            currentBody = [];
+            sawMarker = true;
+            started = true;
+        }
+        else {
+            if (!started && line.trim() !== '')
+                started = true;
+            currentBody.push(line);
+        }
+    }
+    if (sawMarker || started)
+        flush(false);
+    return { cells, metadata, kernelspecName };
+}
+function serializeHeader(metadata, kernelName) {
+    const jupyter = {};
+    for (const [k, v] of Object.entries(metadata)) {
+        if (k !== '__percent_header_extra')
+            jupyter[k] = v;
+    }
+    if (kernelName) {
+        const existing = (jupyter.kernelspec && typeof jupyter.kernelspec === 'object'
+            ? jupyter.kernelspec
+            : {});
+        jupyter.kernelspec = { ...existing, name: kernelName };
+    }
+    const extra = (metadata.__percent_header_extra ?? {});
+    const headerObj = { ...extra };
+    if (Object.keys(jupyter).length > 0)
+        headerObj.jupyter = jupyter;
+    if (Object.keys(headerObj).length === 0)
+        return [];
+    const yamlText = YAML.stringify(headerObj, { lineWidth: 0 }).trimEnd();
+    return [
+        '# ---',
+        ...yamlText.split('\n').map((l) => (l === '' ? '#' : `# ${l}`)),
+        '# ---',
+    ];
+}
+function serializeMarker(cell) {
+    const meta = cell._metadata ?? {};
+    const parts = [];
+    const rest = typeof meta.percent_header_rest === 'string' ? meta.percent_header_rest : '';
+    if (rest)
+        parts.push(rest);
+    if (meta.percent_cell_type === 'raw')
+        parts.push('[raw]');
+    else if (cell.type === 'markdown')
+        parts.push('[markdown]');
+    parts.push(`id="${cell.id}"`);
+    return `# %% ${parts.join(' ')}`;
+}
+function serialize(cells, metadata, kernelName) {
+    const out = serializeHeader(metadata, kernelName);
+    cells.forEach((cell, i) => {
+        // Exactly one blank separator before every marker except a file-leading one
+        if (out.length > 0)
+            out.push('');
+        out.push(serializeMarker(cell));
+        const contentLines = cell.content === '' ? [] : cell.content.split('\n');
+        if (cell.type === 'code')
+            out.push(...contentLines);
+        else
+            out.push(...contentLines.map(encodeCommentLine));
+        void i;
+    });
+    return out.join('\n') + '\n';
+}
+/** Content-based discrimination (the VS Code/jupytext convention): a .py
+ *  file IS a percent notebook iff it has a `# %%` cell marker or a jupytext
+ *  header. Marker-less files are plain scripts — Nebula must never write
+ *  metadata into them as a side effect of merely opening them. */
+function isPercentNotebookText(text) {
+    if (/^#\s*%%/m.test(text))
+        return true;
+    return text.startsWith('# ---\n');
+}
+exports.percentAdapter = {
+    name: 'percent',
+    extensions: ['.py', '.r', '.jl'],
+    capabilities: { storesOutputs: false, storesCellIds: true },
+    parse,
+    serialize,
+};

package/node-server/dist/fs/notebook-formats/qmd.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Quarto adapter (.qmd) — notebook-first.
+ *
+ * A .qmd is treated as a notebook that doesn't serialize outputs:
+ *   - optional YAML front matter (kept opaque; jupyter/nebula keys normalized)
+ *   - ```{lang ...} fences are code cells; `#| id: x` carries the cell id;
+ *     all other `#|` chunk options stay in cell content verbatim (they are
+ *     valid comments) and are never interpreted
+ *   - prose between fences becomes markdown cells
+ *
+ * No Quarto rendering, no chunk-option semantics, one kernel per document.
+ *
+ * Markdown cells are delimited by an HTML-comment marker mirroring the
+ * chunk-option syntax: `<!-- #| id: abc -->`. HTML comments are invisible in
+ * rendered Quarto output, so this is notebook-first without rendering cost:
+ * adjacent markdown cells stay distinct, empty markdown cells survive, and
+ * markdown ids persist (no positional fallback for Nebula-written files).
+ * Foreign .qmd files without markers still parse (one implicit markdown cell
+ * per prose block, positional ids); markers appear on first Nebula save.
+ *
+ * Known unrepresentables (inherent):
+ *   - markdown content containing a bare ```{lang} fence-open line outside a
+ *     wrapping plain fence is indistinguishable from a real code chunk (in
+ *     Quarto itself too) and will re-parse as one
+ *   - a markdown content line that is itself a `<!-- #| id: ... -->` marker
+ *     will re-parse as a cell boundary
+ */
+import { NotebookFormatAdapter } from './types';
+export declare const qmdAdapter: NotebookFormatAdapter;

package/node-server/dist/fs/notebook-formats/qmd.js

@@ -0,0 +1,307 @@
+"use strict";
+/**
+ * Quarto adapter (.qmd) — notebook-first.
+ *
+ * A .qmd is treated as a notebook that doesn't serialize outputs:
+ *   - optional YAML front matter (kept opaque; jupyter/nebula keys normalized)
+ *   - ```{lang ...} fences are code cells; `#| id: x` carries the cell id;
+ *     all other `#|` chunk options stay in cell content verbatim (they are
+ *     valid comments) and are never interpreted
+ *   - prose between fences becomes markdown cells
+ *
+ * No Quarto rendering, no chunk-option semantics, one kernel per document.
+ *
+ * Markdown cells are delimited by an HTML-comment marker mirroring the
+ * chunk-option syntax: `<!-- #| id: abc -->`. HTML comments are invisible in
+ * rendered Quarto output, so this is notebook-first without rendering cost:
+ * adjacent markdown cells stay distinct, empty markdown cells survive, and
+ * markdown ids persist (no positional fallback for Nebula-written files).
+ * Foreign .qmd files without markers still parse (one implicit markdown cell
+ * per prose block, positional ids); markers appear on first Nebula save.
+ *
+ * Known unrepresentables (inherent):
+ *   - markdown content containing a bare ```{lang} fence-open line outside a
+ *     wrapping plain fence is indistinguishable from a real code chunk (in
+ *     Quarto itself too) and will re-parse as one
+ *   - a markdown content line that is itself a `<!-- #| id: ... -->` marker
+ *     will re-parse as a cell boundary
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.qmdAdapter = void 0;
+const YAML = __importStar(require("yaml"));
+const CODE_FENCE_OPEN_RE = /^(`{3,})\{(\w+)([^}]*)\}\s*$/;
+const PLAIN_FENCE_RE = /^(`{3,})(?!\{)/;
+const ID_OPTION_RE = /^#\|\s*id:\s*(\S+)\s*$/;
+const MD_MARKER_RE = /^<!--\s*#\|\s*id:\s*(\S+)\s*-->\s*$/;
+const LANG_TO_KERNEL = {
+    python: 'python3',
+    r: 'ir',
+};
+function normalizeEol(text) {
+    return text.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+}
+function parseFrontMatter(lines) {
+    if (lines[0] !== '---')
+        return { metadata: {}, kernelspecName: null, bodyStart: 0 };
+    let end = -1;
+    for (let i = 1; i < lines.length; i++) {
+        if (lines[i] === '---' || lines[i] === '...') {
+            end = i;
+            break;
+        }
+    }
+    if (end === -1)
+        return { metadata: {}, kernelspecName: null, bodyStart: 0 };
+    let fm;
+    try {
+        const parsed = YAML.parse(lines.slice(1, end).join('\n'));
+        fm = parsed && typeof parsed === 'object' ? parsed : {};
+    }
+    catch {
+        return { metadata: {}, kernelspecName: null, bodyStart: 0 };
+    }
+    const metadata = { __qmd_front_matter: fm };
+    let kernelspecName = null;
+    const jupyter = fm.jupyter;
+    if (typeof jupyter === 'string') {
+        kernelspecName = jupyter;
+        metadata.kernelspec = { name: jupyter };
+    }
+    else if (jupyter && typeof jupyter === 'object') {
+        const kernelspec = jupyter.kernelspec;
+        if (kernelspec && typeof kernelspec === 'object') {
+            metadata.kernelspec = kernelspec;
+            const name = kernelspec.name;
+            if (typeof name === 'string')
+                kernelspecName = name;
+        }
+    }
+    if (fm.nebula && typeof fm.nebula === 'object') {
+        metadata.nebula = fm.nebula;
+    }
+    let bodyStart = end + 1;
+    if (lines[bodyStart] === '')
+        bodyStart++;
+    return { metadata, kernelspecName, bodyStart };
+}
+function makeMarkdownCell(index, bodyLines, explicitId) {
+    // Trim one leading and one trailing blank line (block separators)
+    const body = [...bodyLines];
+    if (body[0] === '')
+        body.shift();
+    if (body[body.length - 1] === '')
+        body.pop();
+    // Implicit (marker-less, foreign-file) prose blocks that are empty are
+    // just whitespace between chunks; marker-delimited cells survive empty.
+    if (body.length === 0 && explicitId === null)
+        return null;
+    return {
+        id: explicitId ?? `cell-${index}`,
+        type: 'markdown',
+        content: body.join('\n'),
+        outputs: [],
+        executionCount: null,
+        isExecuting: false,
+    };
+}
+function parse(text) {
+    const lines = normalizeEol(text).split('\n');
+    if (lines.length > 0 && lines[lines.length - 1] === '')
+        lines.pop();
+    const { metadata, kernelspecName, bodyStart } = parseFrontMatter(lines);
+    const cells = [];
+    let prose = [];
+    let proseId = null;
+    let firstLanguage = null;
+    const flushProse = () => {
+        const cell = makeMarkdownCell(cells.length, prose, proseId);
+        if (cell)
+            cells.push(cell);
+        prose = [];
+        proseId = null;
+    };
+    let i = bodyStart;
+    while (i < lines.length) {
+        const line = lines[i];
+        const codeOpen = line.match(CODE_FENCE_OPEN_RE);
+        if (codeOpen) {
+            flushProse();
+            const ticks = codeOpen[1].length;
+            const language = codeOpen[2];
+            const fenceInner = `${codeOpen[2]}${codeOpen[3]}`;
+            if (!firstLanguage)
+                firstLanguage = language;
+            const body = [];
+            i++;
+            let closed = false;
+            while (i < lines.length) {
+                if (new RegExp(`^\`{${ticks},}\\s*$`).test(lines[i])) {
+                    closed = true;
+                    i++;
+                    break;
+                }
+                body.push(lines[i]);
+                i++;
+            }
+            void closed; // unterminated fence: treat rest of file as the cell body
+            // Consume a leading `#| id:` option as the cell id
+            let id = null;
+            if (body.length > 0) {
+                const idMatch = body[0].match(ID_OPTION_RE);
+                if (idMatch) {
+                    id = idMatch[1];
+                    body.shift();
+                }
+            }
+            const cell = {
+                id: id ?? `cell-${cells.length}`,
+                type: 'code',
+                content: body.join('\n'),
+                outputs: [],
+                executionCount: null,
+                isExecuting: false,
+            };
+            cell._metadata = {
+                qmd_fence_attrs: fenceInner,
+            };
+            cells.push(cell);
+            // Skip one blank separator after the closing fence
+            if (lines[i] === '')
+                i++;
+            continue;
+        }
+        const mdMarker = line.match(MD_MARKER_RE);
+        if (mdMarker) {
+            flushProse();
+            proseId = mdMarker[1];
+            i++;
+            continue;
+        }
+        const plainFence = line.match(PLAIN_FENCE_RE);
+        if (plainFence) {
+            // A plain fence inside prose: copy verbatim until its closer so that
+            // ```{lang} examples inside it are never mistaken for cell starts.
+            const ticks = plainFence[1].length;
+            prose.push(line);
+            i++;
+            while (i < lines.length) {
+                prose.push(lines[i]);
+                if (new RegExp(`^\`{${ticks},}\\s*$`).test(lines[i])) {
+                    i++;
+                    break;
+                }
+                i++;
+            }
+            continue;
+        }
+        prose.push(line);
+        i++;
+    }
+    flushProse();
+    if (firstLanguage)
+        metadata.__qmd_language = firstLanguage;
+    let resolvedKernel = kernelspecName;
+    if (!resolvedKernel && firstLanguage) {
+        resolvedKernel = LANG_TO_KERNEL[firstLanguage.toLowerCase()] ?? null;
+    }
+    return { cells, metadata, kernelspecName: resolvedKernel };
+}
+function serializeFrontMatter(metadata, kernelName) {
+    const base = (metadata.__qmd_front_matter && typeof metadata.__qmd_front_matter === 'object'
+        ? { ...metadata.__qmd_front_matter }
+        : {});
+    const kernelspec = (metadata.kernelspec && typeof metadata.kernelspec === 'object'
+        ? { ...metadata.kernelspec }
+        : {});
+    if (kernelName)
+        kernelspec.name = kernelName;
+    if (Object.keys(kernelspec).length > 0) {
+        const jupyter = (base.jupyter && typeof base.jupyter === 'object'
+            ? { ...base.jupyter }
+            : {});
+        jupyter.kernelspec = kernelspec;
+        base.jupyter = jupyter;
+    }
+    if (metadata.nebula && typeof metadata.nebula === 'object') {
+        base.nebula = metadata.nebula;
+    }
+    else {
+        delete base.nebula;
+    }
+    if (Object.keys(base).length === 0)
+        return [];
+    const yamlText = YAML.stringify(base, { lineWidth: 0 }).trimEnd();
+    return ['---', ...yamlText.split('\n'), '---'];
+}
+function serialize(cells, metadata, kernelName) {
+    const language = typeof metadata.__qmd_language === 'string' ? metadata.__qmd_language : 'python';
+    const out = serializeFrontMatter(metadata, kernelName);
+    for (const cell of cells) {
+        if (out.length > 0)
+            out.push('');
+        if (cell.type === 'markdown') {
+            out.push(`<!-- #| id: ${cell.id} -->`);
+            if (cell.content !== '')
+                out.push(...cell.content.split('\n'));
+        }
+        else {
+            const meta = cell._metadata ?? {};
+            const fenceInner = typeof meta.qmd_fence_attrs === 'string' ? meta.qmd_fence_attrs : language;
+            // Fence must be longer than any backtick run starting a content line,
+            // or the content would close it early.
+            let maxRun = 0;
+            for (const l of cell.content.split('\n')) {
+                const run = l.match(/^(`+)/);
+                if (run)
+                    maxRun = Math.max(maxRun, run[1].length);
+            }
+            const fence = '`'.repeat(Math.max(3, maxRun + 1));
+            out.push(fence + '{' + fenceInner + '}');
+            out.push(`#| id: ${cell.id}`);
+            if (cell.content !== '')
+                out.push(...cell.content.split('\n'));
+            out.push(fence);
+        }
+    }
+    return out.join('\n') + '\n';
+}
+exports.qmdAdapter = {
+    name: 'qmd',
+    extensions: ['.qmd'],
+    capabilities: { storesOutputs: false, storesCellIds: true },
+    parse,
+    serialize,
+};

package/node-server/dist/fs/notebook-formats/registry.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Registry for plain-text notebook format adapters.
+ *
+ * .ipynb is intentionally NOT registered here: dispatch sites check .ipynb
+ * first and fall through to the existing Jupyter JSON code path untouched.
+ */
+import { NotebookFormatAdapter } from './types';
+export declare function getFormatAdapter(filePath: string): NotebookFormatAdapter | null;
+export declare function defaultKernelForPath(filePath: string): string;
+export declare function isTextNotebookPath(filePath: string): boolean;
+/** True for any path Nebula can treat as a notebook (.ipynb or text format). */
+export declare function isNotebookPath(filePath: string): boolean;