@wafflebase/cli 0.4.8 → 0.5.0

package/dist/output/formatter.js

@@ -1,41 +0,0 @@
-import { formatJson } from './json.js';
-import { formatTable } from './table.js';
-import { formatCsv } from './csv.js';
-export function format(data, fmt) {
-    switch (fmt) {
-        case 'json':
-            return formatJson(data);
-        case 'table':
-            return formatTable(data);
-        case 'csv':
-            return formatCsv(data);
-    }
-}
-export function output(data, fmt, quiet) {
-    if (quiet)
-        return;
-    console.log(format(data, fmt));
-}
-/**
- * Preserve a structured `code` from any thrown `Error` subclass that
- * carries one (e.g., `InvalidDocxError`'s `code = 'INVALID_DOCX'`).
- * Skill files document those codes, so silently flattening every
- * failure to `'ERROR'` made agents unable to branch on the cause.
- */
-function errorCode(error) {
-    if (error instanceof Error && 'code' in error) {
-        const code = error.code;
-        if (typeof code === 'string' && code.length > 0)
-            return code;
-    }
-    return 'ERROR';
-}
-export function outputError(error, quiet) {
-    if (quiet) {
-        process.exitCode = 1;
-        return;
-    }
-    const message = error instanceof Error ? error.message : String(error);
-    console.error(JSON.stringify({ error: { code: errorCode(error), message } }, null, 2));
-    process.exitCode = 1;
-}

package/dist/output/json.d.ts

@@ -1 +0,0 @@
-export declare function formatJson(data: unknown): string;

package/dist/output/json.js

@@ -1,3 +0,0 @@
-export function formatJson(data) {
-    return JSON.stringify(data, null, 2);
-}

package/dist/output/table.d.ts

@@ -1,4 +0,0 @@
-/**
- * Format an array of objects as an aligned text table.
- */
-export declare function formatTable(data: unknown): string;

package/dist/output/table.js

@@ -1,14 +0,0 @@
-/**
- * Format an array of objects as an aligned text table.
- */
-export function formatTable(data) {
-    if (!Array.isArray(data) || data.length === 0)
-        return '(no results)';
-    const rows = data;
-    const keys = Object.keys(rows[0]);
-    const widths = keys.map((key) => Math.max(key.length, ...rows.map((row) => String(row[key] ?? '').length)));
-    const header = keys.map((k, i) => k.padEnd(widths[i])).join('  ');
-    const separator = widths.map((w) => '-'.repeat(w)).join('  ');
-    const lines = rows.map((row) => keys.map((k, i) => String(row[k] ?? '').padEnd(widths[i])).join('  '));
-    return [header, separator, ...lines].join('\n');
-}

package/dist/schema/registry.d.ts

@@ -1,42 +0,0 @@
-export type SafetyLevel = 'read-only' | 'write' | 'destructive';
-/**
- * Per-command safety variant — used by `docs.import` to spell out that
- * the same command is `write` by default but `destructive` with
- * `--replace`. Skill agents read this to decide when extra confirmation
- * is needed.
- */
-export interface SafetyVariant {
-    when: string;
-    safety: SafetyLevel;
-    creates?: string;
-    modifies?: string;
-    removes?: string;
-}
-export interface CommandSchema {
-    name: string;
-    description: string;
-    safety: SafetyLevel;
-    parameters: Record<string, {
-        type: string;
-        required: boolean;
-        description: string;
-        default?: string;
-    }>;
-    response: Record<string, unknown>;
-    /**
-     * Singular / legacy / namespace-stripped names that should resolve to
-     * this canonical entry. `getCommandSchema('cell.get')` returns the
-     * `sheets.cells.get` schema because `'cell.get'` appears here.
-     */
-    aliases?: string[];
-    /** Optional per-flag safety overrides (currently only `docs.import`). */
-    variants?: SafetyVariant[];
-}
-/**
- * Look up a schema entry by canonical name or any registered alias.
- * Aliases let scripts and skills written against the v0.3.x singular
- * names (`cell.get`, `doc.list`, `import`) keep working after the
- * v0.3.7 namespace shuffle.
- */
-export declare function getCommandSchema(name: string): CommandSchema | undefined;
-export declare function getAllCommandSchemas(): CommandSchema[];

package/dist/schema/registry.js

@@ -1,375 +0,0 @@
-const registry = [
-    {
-        name: 'login',
-        description: 'Authenticate via GitHub OAuth in the browser',
-        safety: 'write',
-        parameters: {
-            '--server': { type: 'string', required: false, description: 'Server URL', default: 'https://api.wafflebase.io' },
-        },
-        response: { user: 'string', workspace: 'string' },
-    },
-    {
-        name: 'logout',
-        description: 'Clear session and log out',
-        safety: 'write',
-        parameters: {},
-        response: {},
-    },
-    {
-        name: 'status',
-        description: 'Show current auth state',
-        safety: 'read-only',
-        parameters: {},
-        response: { user: 'string', server: 'string', workspace: 'string', session: 'string' },
-    },
-    {
-        name: 'ctx.list',
-        description: 'List workspaces',
-        safety: 'read-only',
-        parameters: {},
-        response: { type: 'array', items: { id: 'string', name: 'string', active: 'boolean' } },
-    },
-    {
-        name: 'ctx.switch',
-        description: 'Switch active workspace',
-        safety: 'write',
-        parameters: {
-            'name-or-id': { type: 'string', required: true, description: 'Workspace name or ID' },
-        },
-        response: { workspace: 'string' },
-    },
-    // Docs (word-processor) namespace
-    {
-        name: 'docs.list',
-        description: 'List documents in workspace',
-        safety: 'read-only',
-        parameters: {
-            '--type': { type: 'string', required: false, description: 'Filter by document type (doc|sheet)' },
-        },
-        response: { type: 'array', items: { id: 'string', title: 'string', type: 'string', createdAt: 'string' } },
-        aliases: ['doc.list', 'document.list', 'documents.list'],
-    },
-    {
-        name: 'docs.create',
-        description: 'Create a new document',
-        safety: 'write',
-        parameters: {
-            title: { type: 'string', required: true, description: 'Document title' },
-            '--type': { type: 'string', required: false, description: 'Document type (doc|sheet)', default: 'sheet' },
-        },
-        response: { id: 'string', title: 'string', type: 'string' },
-        aliases: ['doc.create', 'document.create', 'documents.create'],
-    },
-    {
-        name: 'docs.get',
-        description: 'Show document metadata',
-        safety: 'read-only',
-        parameters: {
-            'doc-id': { type: 'string', required: true, description: 'Document ID' },
-        },
-        response: { id: 'string', title: 'string', type: 'string', createdAt: 'string' },
-        aliases: ['doc.get', 'document.get', 'documents.get'],
-    },
-    {
-        name: 'docs.rename',
-        description: 'Rename a document',
-        safety: 'write',
-        parameters: {
-            'doc-id': { type: 'string', required: true, description: 'Document ID' },
-            title: { type: 'string', required: true, description: 'New title' },
-        },
-        response: { id: 'string', title: 'string' },
-        aliases: ['doc.rename', 'document.rename', 'documents.rename'],
-    },
-    {
-        name: 'docs.delete',
-        description: 'Delete a document',
-        safety: 'destructive',
-        parameters: {
-            'doc-id': { type: 'string', required: true, description: 'Document ID' },
-        },
-        response: { id: 'string' },
-        aliases: ['doc.delete', 'document.delete', 'documents.delete'],
-    },
-    {
-        name: 'docs.content',
-        description: 'Read document content as JSON, Markdown, or plain text',
-        safety: 'read-only',
-        parameters: {
-            'doc-id': { type: 'string', required: true, description: 'Document ID' },
-            '--format': { type: 'string', required: false, description: 'Output format (json|md|text)', default: 'json' },
-            '--pages': { type: 'string', required: false, description: 'Page range (e.g. 1-3,5)' },
-            '--include-header-footer': { type: 'boolean', required: false, description: 'Include header/footer (md/text)', default: 'false' },
-            '--inline-images': { type: 'boolean', required: false, description: 'Inline data: image URLs (md only)', default: 'false' },
-            '--out': { type: 'string', required: false, description: 'Output file (- for stdout)' },
-            '--force': { type: 'boolean', required: false, description: 'Overwrite existing output file', default: 'false' },
-        },
-        response: { type: 'object', description: 'Document JSON, Markdown text, or plaintext per --format' },
-        aliases: ['doc.content', 'document.content', 'documents.content'],
-    },
-    {
-        name: 'docs.export',
-        description: 'Export a document to PDF or DOCX',
-        safety: 'read-only',
-        parameters: {
-            'doc-id': { type: 'string', required: true, description: 'Document ID' },
-            file: { type: 'string', required: true, description: 'Output path or - for stdout' },
-            '--format': { type: 'string', required: false, description: 'Output format (pdf|docx); default from extension' },
-            '--pages': { type: 'string', required: false, description: 'Page range (PDF only)' },
-            '--include-header-footer': { type: 'boolean', required: false, description: 'Include header/footer regions', default: 'true' },
-            '--force': { type: 'boolean', required: false, description: 'Overwrite existing output file', default: 'false' },
-        },
-        response: { type: 'binary', description: 'PDF or DOCX bytes' },
-        aliases: ['doc.export', 'document.export', 'documents.export'],
-    },
-    {
-        name: 'docs.import',
-        description: 'Import a .docx file as a new (or replacement) document',
-        // Default safety is `write` (create new doc); `--replace` flips it
-        // to destructive. Variants spell this out for skill agents.
-        safety: 'write',
-        parameters: {
-            file: { type: 'string', required: true, description: 'Source .docx path or - for stdin' },
-            '--title': { type: 'string', required: false, description: 'Document title (default: file basename)' },
-            '--replace': { type: 'string', required: false, description: 'Existing document ID to replace' },
-            '--yes': { type: 'boolean', required: false, description: 'Skip --replace confirmation', default: 'false' },
-        },
-        response: { id: 'string', title: 'string', replaced: 'boolean' },
-        variants: [
-            { when: 'default', safety: 'write', creates: 'new document' },
-            { when: '--replace given', safety: 'destructive', modifies: 'existing document content' },
-        ],
-        aliases: ['doc.import', 'document.import', 'documents.import'],
-    },
-    // Slides (presentation) namespace
-    {
-        name: 'slides.list',
-        description: 'List slide decks in workspace',
-        safety: 'read-only',
-        parameters: {},
-        response: { type: 'array', items: { id: 'string', title: 'string', type: 'string', createdAt: 'string' } },
-        aliases: ['slide.list', 'deck.list', 'decks.list'],
-    },
-    {
-        name: 'slides.create',
-        description: 'Create a new slide deck',
-        safety: 'write',
-        parameters: {
-            title: { type: 'string', required: true, description: 'Deck title' },
-        },
-        response: { id: 'string', title: 'string', type: 'string' },
-        aliases: ['slide.create', 'deck.create', 'decks.create'],
-    },
-    {
-        name: 'slides.get',
-        description: 'Show slide deck metadata',
-        safety: 'read-only',
-        parameters: {
-            'doc-id': { type: 'string', required: true, description: 'Document ID' },
-        },
-        response: { id: 'string', title: 'string', type: 'string', createdAt: 'string' },
-        aliases: ['slide.get', 'deck.get', 'decks.get'],
-    },
-    {
-        name: 'slides.rename',
-        description: 'Rename a slide deck',
-        safety: 'write',
-        parameters: {
-            'doc-id': { type: 'string', required: true, description: 'Document ID' },
-            title: { type: 'string', required: true, description: 'New title' },
-        },
-        response: { id: 'string', title: 'string' },
-        aliases: ['slide.rename', 'deck.rename', 'decks.rename'],
-    },
-    {
-        name: 'slides.delete',
-        description: 'Delete a slide deck',
-        safety: 'destructive',
-        parameters: {
-            'doc-id': { type: 'string', required: true, description: 'Document ID' },
-        },
-        response: { id: 'string' },
-        aliases: ['slide.delete', 'deck.delete', 'decks.delete'],
-    },
-    {
-        name: 'slides.content',
-        description: 'Read deck content as JSON, Markdown, or plain text',
-        safety: 'read-only',
-        parameters: {
-            'doc-id': { type: 'string', required: true, description: 'Document ID' },
-            '--format': { type: 'string', required: false, description: 'Output format (json|md|text)', default: 'json' },
-            '--notes': { type: 'boolean', required: false, description: 'Include speaker notes (md/text)', default: 'false' },
-            '--out': { type: 'string', required: false, description: 'Output file (- for stdout)' },
-            '--force': { type: 'boolean', required: false, description: 'Overwrite existing output file', default: 'false' },
-        },
-        response: { type: 'object', description: 'Deck JSON, Markdown text, or plaintext per --format' },
-        aliases: ['slide.content', 'deck.content', 'decks.content'],
-    },
-    {
-        name: 'slides.import',
-        description: 'Import a .pptx file as a new (or replacement) slide deck',
-        // Default safety is `write` (create new deck); `--replace` flips it
-        // to destructive, mirroring `docs.import`.
-        safety: 'write',
-        parameters: {
-            file: { type: 'string', required: true, description: 'Source .pptx path or - for stdin' },
-            '--title': { type: 'string', required: false, description: 'Deck title (default: file basename)' },
-            '--replace': { type: 'string', required: false, description: 'Existing deck ID to replace' },
-            '--yes': { type: 'boolean', required: false, description: 'Skip --replace confirmation', default: 'false' },
-        },
-        response: { id: 'string', title: 'string', replaced: 'boolean' },
-        variants: [
-            { when: 'default', safety: 'write', creates: 'new slide deck' },
-            { when: '--replace given', safety: 'destructive', modifies: 'existing deck content' },
-        ],
-        aliases: ['slide.import', 'deck.import', 'decks.import'],
-    },
-    {
-        name: 'slides.export',
-        description: 'Export a slide deck to PPTX',
-        safety: 'read-only',
-        parameters: {
-            'doc-id': { type: 'string', required: true, description: 'Document ID' },
-            file: { type: 'string', required: true, description: 'Output path or - for stdout' },
-            '--format': { type: 'string', required: false, description: 'Output format (pptx); default from extension' },
-            '--force': { type: 'boolean', required: false, description: 'Overwrite existing output file', default: 'false' },
-        },
-        response: { type: 'binary', description: 'PPTX bytes' },
-        aliases: ['slide.export', 'deck.export', 'decks.export'],
-    },
-    // Sheets namespace — canonical names live under sheets.*
-    {
-        name: 'sheets.tabs.list',
-        description: 'List tabs in a spreadsheet document',
-        safety: 'read-only',
-        parameters: {
-            'doc-id': { type: 'string', required: true, description: 'Document ID' },
-        },
-        response: { type: 'array', items: { id: 'string', name: 'string', type: 'string' } },
-        aliases: ['tab.list', 'tabs.list', 'sheet.tabs.list', 'sheet.tab.list', 'sheets.tab.list'],
-    },
-    {
-        name: 'sheets.cells.get',
-        description: 'Get cells from a spreadsheet tab',
-        safety: 'read-only',
-        parameters: {
-            'doc-id': { type: 'string', required: true, description: 'Document ID' },
-            range: { type: 'string', required: false, description: 'Cell range (e.g. A1:C10)', default: 'all' },
-            '--tab': { type: 'string', required: false, description: 'Tab ID', default: 'tab-1' },
-        },
-        response: {
-            type: 'array',
-            items: { ref: 'string', value: 'string | null', formula: 'string | null', style: 'object | null' },
-        },
-        aliases: ['cell.get', 'cells.get', 'sheet.cells.get', 'sheet.cell.get', 'sheets.cell.get'],
-    },
-    {
-        name: 'sheets.cells.set',
-        description: 'Set a single cell value',
-        safety: 'write',
-        parameters: {
-            'doc-id': { type: 'string', required: true, description: 'Document ID' },
-            ref: { type: 'string', required: true, description: 'Cell reference (e.g. A1)' },
-            value: { type: 'string', required: true, description: 'Cell value or formula' },
-            '--tab': { type: 'string', required: false, description: 'Tab ID', default: 'tab-1' },
-        },
-        response: { ref: 'string', value: 'string', formula: 'string | null' },
-        aliases: ['cell.set', 'cells.set', 'sheet.cells.set', 'sheet.cell.set', 'sheets.cell.set'],
-    },
-    {
-        name: 'sheets.cells.batch',
-        description: 'Batch update cells',
-        safety: 'write',
-        parameters: {
-            'doc-id': { type: 'string', required: true, description: 'Document ID' },
-            '--tab': { type: 'string', required: false, description: 'Tab ID', default: 'tab-1' },
-            '--data': { type: 'string', required: false, description: 'JSON data (or pipe from stdin)' },
-        },
-        response: { updated: 'number' },
-        aliases: ['cell.batch', 'cells.batch', 'sheet.cells.batch', 'sheet.cell.batch', 'sheets.cell.batch'],
-    },
-    {
-        name: 'sheets.cells.delete',
-        description: 'Delete a single cell',
-        safety: 'destructive',
-        parameters: {
-            'doc-id': { type: 'string', required: true, description: 'Document ID' },
-            ref: { type: 'string', required: true, description: 'Cell reference' },
-            '--tab': { type: 'string', required: false, description: 'Tab ID', default: 'tab-1' },
-        },
-        response: { ref: 'string', deleted: 'boolean' },
-        aliases: ['cell.delete', 'cells.delete', 'sheet.cells.delete', 'sheet.cell.delete', 'sheets.cell.delete'],
-    },
-    {
-        name: 'sheets.import',
-        description: 'Import CSV/JSON into a spreadsheet tab',
-        safety: 'write',
-        parameters: {
-            'doc-id': { type: 'string', required: true, description: 'Document ID' },
-            file: { type: 'string', required: true, description: 'File path or - for stdin' },
-            '--tab': { type: 'string', required: false, description: 'Target tab', default: 'tab-1' },
-            '--file-format': { type: 'string', required: false, description: 'File format (csv, json)' },
-            '--start': { type: 'string', required: false, description: 'Top-left cell', default: 'A1' },
-        },
-        response: { imported: 'number' },
-        aliases: ['import', 'sheet.import'],
-    },
-    {
-        name: 'sheets.export',
-        description: 'Export spreadsheet tab data to CSV/JSON',
-        safety: 'read-only',
-        parameters: {
-            'doc-id': { type: 'string', required: true, description: 'Document ID' },
-            file: { type: 'string', required: true, description: 'File path or - for stdout' },
-            '--tab': { type: 'string', required: false, description: 'Source tab', default: 'tab-1' },
-            '--range': { type: 'string', required: false, description: 'Cell range (e.g. A1:D100)' },
-            '--file-format': { type: 'string', required: false, description: 'File format (csv, json)' },
-        },
-        response: { type: 'string', description: 'Formatted cell data' },
-        aliases: ['export', 'sheet.export'],
-    },
-    // API keys namespace
-    {
-        name: 'api-keys.create',
-        description: 'Create a new API key',
-        safety: 'write',
-        parameters: {
-            name: { type: 'string', required: true, description: 'Key name' },
-        },
-        response: { id: 'string', name: 'string', prefix: 'string', key: 'string' },
-        aliases: ['api-key.create'],
-    },
-    {
-        name: 'api-keys.list',
-        description: 'List API keys in workspace',
-        safety: 'read-only',
-        parameters: {},
-        response: { type: 'array', items: { id: 'string', name: 'string', prefix: 'string' } },
-        aliases: ['api-key.list'],
-    },
-    {
-        name: 'api-keys.revoke',
-        description: 'Revoke an API key',
-        safety: 'destructive',
-        parameters: {
-            'key-id': { type: 'string', required: true, description: 'API key ID' },
-        },
-        response: { id: 'string' },
-        aliases: ['api-key.revoke'],
-    },
-];
-/**
- * Look up a schema entry by canonical name or any registered alias.
- * Aliases let scripts and skills written against the v0.3.x singular
- * names (`cell.get`, `doc.list`, `import`) keep working after the
- * v0.3.7 namespace shuffle.
- */
-export function getCommandSchema(name) {
-    const direct = registry.find((c) => c.name === name);
-    if (direct)
-        return direct;
-    return registry.find((c) => c.aliases?.includes(name));
-}
-export function getAllCommandSchemas() {
-    return registry;
-}

package/dist/slides/content.d.ts

@@ -1,41 +0,0 @@
-import { type SlidesDocument } from '@wafflebase/slides/node';
-export declare const VALID_SLIDES_CONTENT_FORMATS: readonly ["json", "md", "text"];
-export type SlidesContentFormat = (typeof VALID_SLIDES_CONTENT_FORMATS)[number];
-export declare const SLIDES_LOSSY_NOTICE: string;
-export declare function parseSlidesContentFormat(value: string): SlidesContentFormat;
-/**
- * Surface for `runSlidesContent` to talk back to the CLI without taking
- * a direct dependency on `process.stdout` / `process.stderr` / `fs`.
- * Mirrors `ContentIO` in `../docs/content.ts`; the command wires the
- * real implementations, tests inject in-memory collectors.
- */
-export interface SlidesContentIO {
-    stdout: (text: string) => void;
-    stderr: (line: string) => void;
-    /** Write `text` to `path`. Throws if the file exists and `force` is false. */
-    writeFile: (path: string, text: string, force: boolean) => void;
-}
-export declare const defaultSlidesContentIO: SlidesContentIO;
-export interface RunSlidesContentArgs {
-    deck: SlidesDocument;
-    format: SlidesContentFormat;
-    /** Include speaker notes (`Slide.notes`) after each slide's body. */
-    notes?: boolean;
-    out?: string;
-    force?: boolean;
-    quiet?: boolean;
-}
-/**
- * Pure orchestration for `slides content`: takes an already-fetched
- * `SlidesDocument` plus user flags, produces the rendered output, and
- * routes it through the supplied IO surface.
- *
- * - `json`: the raw deck JSON (lossless — themes, layouts, geometry,
- *   styling all preserved).
- * - `md` / `text`: per-slide text extraction only. Slides have no single
- *   linear text stream, so we walk each slide's elements in document
- *   order, pull every `TextBody`'s blocks (text boxes, shape labels,
- *   table cells), and serialize them with the docs serializers. Shapes,
- *   images, connectors, positioning and theming are dropped.
- */
-export declare function runSlidesContent(args: RunSlidesContentArgs, io?: SlidesContentIO): void;

package/dist/slides/content.js

@@ -1,122 +0,0 @@
-import { writeFileSync, existsSync } from 'node:fs';
-import { serializeMarkdown, serializeText, } from '@wafflebase/docs';
-import { flattenElements, } from '@wafflebase/slides/node';
-export const VALID_SLIDES_CONTENT_FORMATS = ['json', 'md', 'text'];
-export const SLIDES_LOSSY_NOTICE = 'Lossy conversion: only text is extracted (shapes, images, connectors, ' +
-    'layout, theming, and positioning are dropped). See cli.md for details.';
-export function parseSlidesContentFormat(value) {
-    if (!VALID_SLIDES_CONTENT_FORMATS.includes(value)) {
-        throw new Error(`Invalid --format "${value}". Use one of: ${VALID_SLIDES_CONTENT_FORMATS.join(', ')}.`);
-    }
-    return value;
-}
-export const defaultSlidesContentIO = {
-    stdout: (text) => {
-        process.stdout.write(text);
-        if (!text.endsWith('\n'))
-            process.stdout.write('\n');
-    },
-    stderr: (line) => {
-        console.error(line);
-    },
-    writeFile: (path, text, force) => {
-        if (existsSync(path) && !force) {
-            throw new Error(`Refusing to overwrite "${path}". Pass --force to allow overwrite.`);
-        }
-        writeFileSync(path, text.endsWith('\n') ? text : text + '\n', 'utf-8');
-    },
-};
-/**
- * Pure orchestration for `slides content`: takes an already-fetched
- * `SlidesDocument` plus user flags, produces the rendered output, and
- * routes it through the supplied IO surface.
- *
- * - `json`: the raw deck JSON (lossless — themes, layouts, geometry,
- *   styling all preserved).
- * - `md` / `text`: per-slide text extraction only. Slides have no single
- *   linear text stream, so we walk each slide's elements in document
- *   order, pull every `TextBody`'s blocks (text boxes, shape labels,
- *   table cells), and serialize them with the docs serializers. Shapes,
- *   images, connectors, positioning and theming are dropped.
- */
-export function runSlidesContent(args, io = defaultSlidesContentIO) {
-    const { deck, format, notes = false, out, force = false, quiet = false } = args;
-    let text;
-    if (format === 'json') {
-        text = JSON.stringify(deck, null, 2);
-    }
-    else {
-        if (!quiet)
-            io.stderr(SLIDES_LOSSY_NOTICE);
-        text = serializeDeck(deck, format, notes);
-    }
-    if (!out || out === '-') {
-        io.stdout(text);
-        return;
-    }
-    io.writeFile(out, text, force);
-    if (!quiet)
-        io.stderr(`Wrote to ${out}`);
-}
-/**
- * Render every slide as a `## Slide N` (md) / `Slide N` (text) section
- * followed by the slide's extracted text. Sections are joined with a
- * blank line so the stream reads as one document.
- */
-function serializeDeck(deck, format, notes) {
-    const sections = deck.slides.map((slide, i) => serializeSlide(slide, i + 1, format, notes));
-    return sections.join('\n\n');
-}
-function serializeSlide(slide, number, format, notes) {
-    const blocks = collectSlideBlocks(slide);
-    const body = serializeBlocks(blocks, format);
-    const parts = [];
-    parts.push(format === 'md' ? `## Slide ${number}` : `Slide ${number}`);
-    if (body.length > 0)
-        parts.push(body);
-    if (notes && slide.notes.length > 0) {
-        const notesBody = serializeBlocks(slide.notes, format);
-        if (notesBody.length > 0) {
-            parts.push(format === 'md' ? '### Notes' : 'Notes:');
-            parts.push(notesBody);
-        }
-    }
-    return parts.join('\n\n');
-}
-/**
- * Collect every text block from a slide's elements, in document order.
- * Groups are flattened so nested text is included.
- */
-function collectSlideBlocks(slide) {
-    const blocks = [];
-    for (const el of flattenElements(slide.elements)) {
-        for (const body of textBodiesOf(el)) {
-            blocks.push(...body.blocks);
-        }
-    }
-    return blocks;
-}
-/** Extract every `TextBody` carried by a single element. */
-function textBodiesOf(el) {
-    switch (el.type) {
-        case 'text':
-            // `TextElement.data` is a `TextBody` (intersection with fill/stroke).
-            return [el.data];
-        case 'shape':
-            return el.data.text ? [el.data.text] : [];
-        case 'table':
-            return el.data.rows.flatMap((row) => row.cells.map((cell) => cell.body));
-        default:
-            // image / connector carry no text; group is handled by flatten.
-            return [];
-    }
-}
-/**
- * Serialize a flat `Block[]` via the docs serializers by wrapping them
- * in a synthetic `Document`. The serializers read only `doc.blocks`
- * (header/footer are opt-in and never set here), so the cast is safe.
- */
-function serializeBlocks(blocks, format) {
-    const doc = { blocks };
-    return format === 'md' ? serializeMarkdown(doc) : serializeText(doc);
-}