@bendyline/squisq-editor-react 2.0.0 → 2.0.1

package/src/Toolbar.tsx

@@ -52,6 +52,13 @@ import type { PickerEntry } from './emojiData';
 import { createPortal } from 'react-dom';
 import { PreviewModeMenu, displayModeLabel, usePreviewSettingsOptional } from './PreviewControls';
 import { filterVisibleMediaEntries } from './mediaEntries';
+import {
+  selectionToTable,
+  selectionToTableMarkdown,
+  selectionToTaskItems,
+  selectionToTaskListMarkdown,
+  type SelectionTaskItem,
+} from './selectionConversions';
 
 const VIEWS: { id: EditorView; label: string; shortLabel?: string; shortcut: string }[] = [
   { id: 'wysiwyg', label: 'Write', shortcut: '⌘1' },
@@ -273,6 +280,7 @@ const BUTTONS: ToolbarButton[] = [
 
 const FIRST_MEDIA_INDEX = BUTTONS.findIndex((b) => b.group === 'media');
 const MEDIA_BUTTONS = BUTTONS.filter((b) => b.group === 'media');
+const CONVERT_BUTTONS = MEDIA_BUTTONS.filter((b) => b.id === 'table' || b.id === 'tasklist');
 const INSERT_MENU_WIDTH = 200;
 const TASK_LIST_ITEMS = ['Task 1', 'Task 2', 'Task 3'] as const;
 const TASK_LIST_MARKDOWN = TASK_LIST_ITEMS.map((item) => `- [ ] ${item}`).join('\n');
@@ -297,18 +305,35 @@ function fileCountBadge(count: number): string {
   return count > 99 ? '99+' : String(count);
 }
 
-function taskListContent(): JSONContent {
+function paragraphContent(text: string): JSONContent {
+  return text ? { type: 'paragraph', content: [{ type: 'text', text }] } : { type: 'paragraph' };
+}
+
+function tableContent(rows: string[][]): JSONContent {
+  return {
+    type: 'table',
+    content: rows.map((row, rowIndex) => ({
+      type: 'tableRow',
+      content: row.map((cell) => ({
+        type: rowIndex === 0 ? 'tableHeader' : 'tableCell',
+        content: [paragraphContent(cell)],
+      })),
+    })),
+  };
+}
+
+function taskListContent(
+  items: readonly SelectionTaskItem[] = TASK_LIST_ITEMS.map((text) => ({
+    checked: false,
+    text,
+  })),
+): JSONContent {
   return {
     type: 'taskList',
-    content: TASK_LIST_ITEMS.map((item) => ({
+    content: items.map((item) => ({
       type: 'taskItem',
-      attrs: { checked: false },
-      content: [
-        {
-          type: 'paragraph',
-          content: [{ type: 'text', text: item }],
-        },
-      ],
+      attrs: { checked: item.checked },
+      content: [paragraphContent(item.text)],
     })),
   };
 }
@@ -319,6 +344,26 @@ function insertTaskList(editor: TiptapEditor): void {
   editor.chain().focus().insertContent(content).run();
 }
 
+/**
+ * Expand a full-line Tiptap text selection to the surrounding top-level node
+ * boundaries. Inserting a list/table at an in-paragraph range makes
+ * ProseMirror preserve the emptied paragraph before or after the new block.
+ * Partial-line selections deliberately retain their exact range.
+ */
+function blockConversionRange(editor: TiptapEditor): { from: number; to: number } {
+  const { from, to, $from, $to } = editor.state.selection;
+  return {
+    from:
+      $from.depth === 1 && $from.parent.isTextblock && $from.parentOffset === 0
+        ? $from.before(1)
+        : from,
+    to:
+      $to.depth === 1 && $to.parent.isTextblock && $to.parentOffset === $to.parent.content.size
+        ? $to.after(1)
+        : to,
+  };
+}
+
 // ─── Tiptap active-state map ────────────────────────────
 
 /** Returns true if the given button id is currently active in Tiptap */
@@ -377,17 +422,23 @@ const LAYOUT_STARTER_MARKDOWN = `\n## Layout {[layout]}\n\n### {#text-1} {[text
  * fences (the fence is the source of truth; `AsciiDiagramExtension` mounts
  * the interactive canvas over it). This exact art is the codec's own
  * canonical rendering of a two-node flow, so it re-parses and re-renders
- * byte-stably.
+ * byte-stably. The leading rows/columns are deliberate: ASCII has no
+ * separate canvas-origin metadata, so this persisted gutter gives the first
+ * node real grid space to move north/west. Without it, content-fit makes the
+ * node look centered while its authored coordinate is still (0, 0), and a
+ * drag into the apparent margin clamps straight back to that corner.
  */
 const DIAGRAM_STARTER_ART = [
-  '┌─────────┐',
-  '│  Start  │',
-  '└────┬────┘',
-  '     │',
-  '     ▼',
-  '┌────┴────┐',
-  '│  Next   │',
-  '└─────────┘',
+  '',
+  '',
+  '        ┌─────────┐',
+  '        │  Start  │',
+  '        └────┬────┘',
+  '             │',
+  '             ▼',
+  '        ┌────┴────┐',
+  '        │  Next   │',
+  '        └─────────┘',
 ].join('\n');
 /**
  * Fenced form for raw / code views — tagged with the explicit `diagram`
@@ -1235,6 +1286,68 @@ export function Toolbar({
     [monacoEditor, markdownSource, setMarkdownSource],
   );
 
+  // ── Selected-text conversion handlers ─────────────────
+  const readSelectedText = useCallback((): string => {
+    // Canvas text overlays intentionally have a smaller schema without tables
+    // or task lists. Ignore their selection instead of surfacing actions that
+    // cannot be represented by those layers.
+    if (activeSceneText) return '';
+
+    if (activeView === 'wysiwyg' && tiptapEditor) {
+      const { from, to, empty } = tiptapEditor.state.selection;
+      return empty ? '' : tiptapEditor.state.doc.textBetween(from, to, '\n');
+    }
+
+    if (activeView === 'raw' && monacoEditor) {
+      const selection = monacoEditor.getSelection();
+      const model = monacoEditor.getModel();
+      return selection && model ? model.getValueInRange(selection) : '';
+    }
+
+    return '';
+  }, [activeSceneText, activeView, monacoEditor, tiptapEditor]);
+
+  const handleConvertSelection = useCallback(
+    (target: 'table' | 'tasklist') => {
+      const selectedText = readSelectedText();
+      if (!selectedText.trim()) return;
+
+      if (activeView === 'wysiwyg' && tiptapEditor) {
+        const content =
+          target === 'table'
+            ? tableContent(selectionToTable(selectedText).rows)
+            : taskListContent(selectionToTaskItems(selectedText));
+        tiptapEditor
+          .chain()
+          .focus()
+          .insertContentAt(blockConversionRange(tiptapEditor), content)
+          .run();
+        return;
+      }
+
+      if (activeView === 'raw' && monacoEditor) {
+        const selection = monacoEditor.getSelection();
+        if (!selection) return;
+        const converted =
+          target === 'table'
+            ? selectionToTableMarkdown(selectedText)
+            : selectionToTaskListMarkdown(selectedText);
+        if (!converted) return;
+
+        // Monaco line selections commonly include the newline after the last
+        // selected line. Retain selected edge newlines so the replacement
+        // block never runs into the surrounding Markdown.
+        const leadingNewline = /^(?:\r?\n)/.test(selectedText) ? '\n' : '';
+        const trailingNewline = /(?:\r?\n)$/.test(selectedText) ? '\n' : '';
+        monacoEditor.executeEdits('toolbar-convert-selection', [
+          { range: selection, text: leadingNewline + converted + trailingNewline },
+        ]);
+        monacoEditor.focus();
+      }
+    },
+    [activeView, monacoEditor, readSelectedText, tiptapEditor],
+  );
+
   // ── Image upload handler ───────────────────────────────
   const handleImageFile = useCallback(
     async (file: File) => {
@@ -1471,6 +1584,10 @@ export function Toolbar({
     if (sceneTextLevel === 'block') return BLOCK_SCENE_BUTTONS.has(id);
     return INLINE_SCENE_BUTTONS.has(id);
   };
+  const showConvertActions =
+    insertMenuAnchor !== null &&
+    readSelectedText().trim().length > 0 &&
+    CONVERT_BUTTONS.some((button) => buttonAllowed(button.id));
 
   // ── Progressive heading disclosure ───────────────────
   // H1\u2013H3 are always visible. H4 appears once the document already
@@ -2392,7 +2509,35 @@ export function Toolbar({
             style={{ position: 'fixed', top: insertMenuAnchor.top, left: insertMenuAnchor.left }}
             role="menu"
           >
-            <div className="squisq-insert-menu-header">Insert</div>
+            {showConvertActions && (
+              <>
+                <div className="squisq-insert-menu-header">Convert</div>
+                {CONVERT_BUTTONS.map((btn) => {
+                  const label = btn.id === 'table' ? 'Table' : 'Task List';
+                  return (
+                    <button
+                      key={`convert-${btn.id}`}
+                      className="squisq-toolbar-overflow-item"
+                      disabled={!buttonAllowed(btn.id)}
+                      onClick={() => {
+                        handleConvertSelection(btn.id as 'table' | 'tasklist');
+                        closeInsertMenu();
+                      }}
+                      role="menuitem"
+                      aria-label={`Convert selection to ${label}`}
+                    >
+                      <span className="squisq-toolbar-overflow-icon">{buttonIcon(btn)}</span>
+                      <span>{label}</span>
+                    </button>
+                  );
+                })}
+              </>
+            )}
+            <div
+              className={`squisq-insert-menu-header${showConvertActions ? ' squisq-insert-menu-header--separated' : ''}`}
+            >
+              Insert
+            </div>
             {MEDIA_BUTTONS.filter((b) => isButtonVisible(b.id)).map((btn) => {
               const disabled = (btn.id === 'image' && !mediaProvider) || !buttonAllowed(btn.id);
               const stripped = btn.title.replace(/^Insert\s+/i, '');

package/src/__tests__/codeContextSectionView.test.tsx

@@ -10,7 +10,7 @@ const noop = () => {};
 const baseSection = {
   id: 'foo@10',
   summaryMarkdown: '**foo** — does things · ↓2 imported-by',
-  markdown: 'Body text with [`a.ts`](gezel-nav:src%2Fa.ts) and [line 4](#L4).',
+  markdown: 'Body text with [`a.ts`](workspace-nav:src%2Fa.ts) and [line 4](#L4).',
 };
 
 function renderView(over: Partial<Parameters<typeof CodeContextSectionView>[0]> = {}) {
@@ -18,7 +18,7 @@ function renderView(over: Partial<Parameters<typeof CodeContextSectionView>[0]>
     section: baseSection,
     expanded: false,
     onToggle: vi.fn(),
-    linkSchemes: ['gezel-nav'] as const,
+    linkSchemes: ['workspace-nav'] as const,
     onLinkClick: vi.fn(),
     onRevealLine: vi.fn(),
     onMeasure: noop,
@@ -47,7 +47,7 @@ describe('<CodeContextSectionView>', () => {
     const body = container.querySelector('.squisq-ccx-body')!;
     expect(body.textContent).toContain('Body text');
     const anchors = [...body.querySelectorAll('a')].map((a) => a.getAttribute('href'));
-    expect(anchors).toContain('gezel-nav:src%2Fa.ts');
+    expect(anchors).toContain('workspace-nav:src%2Fa.ts');
     expect(anchors).toContain('#L4');
   });
 
@@ -63,10 +63,12 @@ describe('<CodeContextSectionView>', () => {
     const onLinkClick = vi.fn(() => undefined);
     const { container } = renderView({ expanded: true, onLinkClick });
     const nav = [...container.querySelectorAll('a')].find(
-      (a) => a.getAttribute('href') === 'gezel-nav:src%2Fa.ts',
+      (a) => a.getAttribute('href') === 'workspace-nav:src%2Fa.ts',
     )!;
     const first = fireEvent.click(nav);
-    expect(onLinkClick).toHaveBeenCalledWith('gezel-nav:src%2Fa.ts', { sectionId: 'foo@10' });
+    expect(onLinkClick).toHaveBeenCalledWith('workspace-nav:src%2Fa.ts', {
+      sectionId: 'foo@10',
+    });
     expect(first).toBe(false); // preventDefault was called
 
     onLinkClick.mockReturnValue(false as unknown as undefined);
@@ -89,7 +91,7 @@ describe('<CodeContextSectionView>', () => {
   it('without linkSchemes, custom-scheme links render blocked (no anchor)', () => {
     const { container } = renderView({ expanded: true, linkSchemes: undefined });
     const anchors = [...container.querySelectorAll('a')].map((a) => a.getAttribute('href'));
-    expect(anchors).not.toContain('gezel-nav:src%2Fa.ts');
+    expect(anchors).not.toContain('workspace-nav:src%2Fa.ts');
     expect(container.querySelector('.squisq-md-link--blocked')).toBeTruthy();
   });
 });

package/src/__tests__/documentSettingsDialog.test.tsx

@@ -123,6 +123,28 @@ describe('DocumentSettingsDialog', () => {
     expect(next).not.toContain('squisq-theme');
   });
 
+  it('removes explicit managed defaults and their legacy aliases on save', () => {
+    const onSave = vi.fn();
+    const src = `---
+squisq-theme: standard
+themeId: standard
+theme: standard
+squisq-captions: standard
+caption-style: standard
+author: Keep
+---
+
+# Doc
+`;
+    open(src, onSave);
+    clickSave();
+
+    const next = onSave.mock.calls[0][0] as string;
+    expect(next).not.toMatch(/^(?:squisq-theme|themeId|theme):/m);
+    expect(next).not.toMatch(/^(?:squisq-captions|caption-style):/m);
+    expect(next).toContain('author: Keep');
+  });
+
   it('writes squisq-transform when a transform is picked', () => {
     const onSave = vi.fn();
     open('# Doc\n', onSave);

package/src/__tests__/mediaAttachmentFlow.test.ts

@@ -7,7 +7,7 @@ import { markdownToTiptap, tiptapToMarkdown } from '../tiptapBridge';
  * uploaded files into the bin without inserting a markdown ref into
  * the editor body. A user would upload an image, hit Send in the
  * downstream chat composer, and the outgoing markdown would have no
- * image reference — the gezel would reply "nothing came through."
+ * image reference — the downstream consumer would reply "nothing came through."
  *
  * The fix: after `mediaProvider.addMedia(...)` succeeds, MediaBin
  * fires `onMediaUploaded(relativePath, name, mimeType)`. The
@@ -18,7 +18,7 @@ import { markdownToTiptap, tiptapToMarkdown } from '../tiptapBridge';
  * These tests exercise the contract directly: the markdown snippet
  * produced by the upload callback, once round-tripped through the
  * editor's markdown↔HTML bridge, must round-trip back to a form
- * the gezel service's image-extraction regex can see.
+ * the downstream service's image-extraction regex can see.
  */
 
 function fakeMediaProvider(records: string[]): MediaProvider {

package/src/__tests__/previewControls.test.tsx

@@ -88,6 +88,75 @@ function LibraryThemeHarness() {
   );
 }
 
+function CoverSlideProbe() {
+  const { activeCoverSlide, setCoverSlideEnabled } = usePreviewSettings();
+  const { markdownSource } = useEditorContext();
+  return (
+    <>
+      <button type="button" onClick={() => setCoverSlideEnabled(false)}>
+        Hide cover slide
+      </button>
+      <button type="button" onClick={() => setCoverSlideEnabled(true)}>
+        Use default cover slide
+      </button>
+      <div data-testid="active-cover-slide">{String(activeCoverSlide)}</div>
+      <pre data-testid="markdown-source">{markdownSource}</pre>
+    </>
+  );
+}
+
+function CoverSlideHarness() {
+  const { doc } = useEditorContext();
+  return (
+    <PreviewSettingsProvider doc={doc}>
+      <CoverSlideProbe />
+    </PreviewSettingsProvider>
+  );
+}
+
+function ManagedDefaultsProbe() {
+  const {
+    activeThemeId,
+    activeTransformStyle,
+    activeCaptionStyle,
+    activeCaptionsEnabled,
+    setSelectedThemeId,
+    setSelectedTransformStyle,
+    setCaptionMode,
+  } = usePreviewSettings();
+  const { markdownSource } = useEditorContext();
+  return (
+    <>
+      <button type="button" onClick={() => setSelectedThemeId('standard')}>
+        Use default theme
+      </button>
+      <button type="button" onClick={() => setSelectedTransformStyle('')}>
+        Use default transform
+      </button>
+      <button type="button" onClick={() => setCaptionMode('standard')}>
+        Use default captions
+      </button>
+      <div
+        data-testid="managed-defaults"
+        data-theme={activeThemeId}
+        data-transform={activeTransformStyle}
+        data-caption-style={activeCaptionStyle}
+        data-captions-enabled={String(activeCaptionsEnabled)}
+      />
+      <pre data-testid="markdown-source">{markdownSource}</pre>
+    </>
+  );
+}
+
+function ManagedDefaultsHarness() {
+  const { doc } = useEditorContext();
+  return (
+    <PreviewSettingsProvider doc={doc}>
+      <ManagedDefaultsProbe />
+    </PreviewSettingsProvider>
+  );
+}
+
 function renderPreviewControls(markdown: string) {
   render(
     <EditorProvider initialMarkdown={markdown}>
@@ -191,6 +260,101 @@ describe('PreviewModeSwitch', () => {
   });
 });
 
+describe('cover-slide frontmatter', () => {
+  it('writes the non-default as a boolean and removes the default value', async () => {
+    render(
+      <EditorProvider initialMarkdown="# Hello">
+        <CoverSlideHarness />
+      </EditorProvider>,
+    );
+
+    expect(screen.getByTestId('active-cover-slide').textContent).toBe('true');
+    fireEvent.click(screen.getByRole('button', { name: 'Hide cover slide' }));
+
+    await waitFor(() => {
+      const source = screen.getByTestId('markdown-source').textContent ?? '';
+      expect(source).toContain('squisq-cover-slide: false');
+      expect(source).not.toContain('squisq-cover-slide: "false"');
+    });
+    expect(screen.getByTestId('active-cover-slide').textContent).toBe('false');
+
+    fireEvent.click(screen.getByRole('button', { name: 'Use default cover slide' }));
+
+    await waitFor(() => {
+      const source = screen.getByTestId('markdown-source').textContent ?? '';
+      expect(source).not.toContain('squisq-cover-slide');
+      expect(source).not.toContain('---');
+    });
+    expect(screen.getByTestId('active-cover-slide').textContent).toBe('true');
+  });
+
+  it('removes a legacy cover-slide override when restoring the default', async () => {
+    render(
+      <EditorProvider initialMarkdown={'---\ncover-slide: false\ntitle: Hello\n---\n\n# Hello'}>
+        <CoverSlideHarness />
+      </EditorProvider>,
+    );
+
+    await waitFor(() => {
+      expect(screen.getByTestId('active-cover-slide').textContent).toBe('false');
+    });
+    fireEvent.click(screen.getByRole('button', { name: 'Use default cover slide' }));
+
+    await waitFor(() => {
+      const source = screen.getByTestId('markdown-source').textContent ?? '';
+      expect(source).not.toContain('cover-slide');
+      expect(source).toContain('title: Hello');
+    });
+    expect(screen.getByTestId('active-cover-slide').textContent).toBe('true');
+  });
+});
+
+describe('managed preview-setting defaults', () => {
+  it('removes default theme, transform, and caption values plus their legacy aliases', async () => {
+    const markdown = `---
+squisq-theme: documentary
+themeId: bold
+theme: cinematic
+squisq-transform: documentary
+transform-style: magazine
+squisq-captions: social
+caption-style: off
+title: Hello
+---
+
+# Hello`;
+    render(
+      <EditorProvider initialMarkdown={markdown}>
+        <ManagedDefaultsHarness />
+      </EditorProvider>,
+    );
+
+    fireEvent.click(screen.getByRole('button', { name: 'Use default theme' }));
+    await waitFor(() => {
+      const source = screen.getByTestId('markdown-source').textContent ?? '';
+      expect(source).not.toMatch(/^(?:squisq-theme|themeId|theme):/m);
+    });
+    expect(screen.getByTestId('managed-defaults').getAttribute('data-theme')).toBe('standard');
+
+    fireEvent.click(screen.getByRole('button', { name: 'Use default transform' }));
+    await waitFor(() => {
+      const source = screen.getByTestId('markdown-source').textContent ?? '';
+      expect(source).not.toMatch(/^(?:squisq-transform|transform-style):/m);
+    });
+    expect(screen.getByTestId('managed-defaults').getAttribute('data-transform')).toBe('');
+
+    fireEvent.click(screen.getByRole('button', { name: 'Use default captions' }));
+    await waitFor(() => {
+      const source = screen.getByTestId('markdown-source').textContent ?? '';
+      expect(source).not.toMatch(/^(?:squisq-captions|caption-style):/m);
+      expect(source).toContain('title: Hello');
+    });
+    const defaults = screen.getByTestId('managed-defaults');
+    expect(defaults.getAttribute('data-caption-style')).toBe('standard');
+    expect(defaults.getAttribute('data-captions-enabled')).toBe('true');
+  });
+});
+
 describe('PreviewToolbarControls', () => {
   it('presents transforms as summarization without implying the source is changed', () => {
     const originalResizeObserver = globalThis.ResizeObserver;

package/src/__tests__/recorderTheme.test.tsx

@@ -0,0 +1,42 @@
+/**
+ * @vitest-environment jsdom
+ */
+import { fireEvent, render, screen } from '@testing-library/react';
+import { describe, expect, it, vi } from 'vitest';
+import type { MediaProvider } from '@bendyline/squisq/schemas';
+import { RecorderModal } from '../recorder/RecorderModal';
+import { RecorderPanel } from '../recorder/RecorderPanel';
+
+const mediaProvider: MediaProvider = {
+  resolveUrl: vi.fn(async (path: string) => path),
+  listMedia: vi.fn(async () => []),
+  addMedia: vi.fn(async (name: string) => name),
+  removeMedia: vi.fn(async () => undefined),
+  dispose: vi.fn(),
+};
+
+describe('recorder theme propagation', () => {
+  it('creates a dark theme scope for the recorder dialog', () => {
+    render(<RecorderModal mediaProvider={mediaProvider} colorScheme="dark" onClose={vi.fn()} />);
+
+    const dialog = screen.getByRole('dialog', { name: 'Record media' });
+    expect(dialog.getAttribute('data-theme')).toBe('dark');
+    expect(dialog.classList.contains('squisq-editor-shell')).toBe(true);
+    expect(dialog.style.colorScheme).toBe('dark');
+    expect(dialog.style.getPropertyValue('--squisq-recorder-surface')).toBe(
+      'var(--squisq-bg, #1f2937)',
+    );
+    expect(dialog.style.getPropertyValue('--squisq-recorder-text')).toBe(
+      'var(--squisq-text, #e5e7eb)',
+    );
+  });
+
+  it('passes the requested scheme through the portaled panel wrapper', () => {
+    render(<RecorderPanel mediaProvider={mediaProvider} colorScheme="dark" />);
+    fireEvent.click(screen.getByRole('button', { name: 'Record media' }));
+
+    expect(screen.getByRole('dialog', { name: 'Record media' }).getAttribute('data-theme')).toBe(
+      'dark',
+    );
+  });
+});

package/src/__tests__/selectionConversions.test.ts

@@ -0,0 +1,80 @@
+import { describe, expect, it } from 'vitest';
+import {
+  selectionToTable,
+  selectionToTableMarkdown,
+  selectionToTaskItems,
+  selectionToTaskListMarkdown,
+} from '../selectionConversions';
+
+describe('selectionToTable', () => {
+  it('detects consistently pipe-delimited rows, including outer pipes', () => {
+    expect(selectionToTable('| Name | Role |\n| Ada | Engineer |')).toEqual({
+      delimiter: 'pipe',
+      rows: [
+        ['Name', 'Role'],
+        ['Ada', 'Engineer'],
+      ],
+    });
+  });
+
+  it('detects CSV rows without splitting quoted commas', () => {
+    expect(selectionToTable('Name,Notes\nAda,"Math, logic"')).toEqual({
+      delimiter: 'comma',
+      rows: [
+        ['Name', 'Notes'],
+        ['Ada', 'Math, logic'],
+      ],
+    });
+  });
+
+  it('retains literal quotes in comma-delimited cells', () => {
+    expect(selectionToTable('Item,Size\nDisplay,5" screen').rows[1]).toEqual([
+      'Display',
+      '5" screen',
+    ]);
+  });
+
+  it.each([
+    ['tab', 'Name\tRole\nAda\tEngineer'],
+    ['multispace', 'Name    Role\nAda     Engineer'],
+  ] as const)('detects %s-delimited rows', (delimiter, text) => {
+    expect(selectionToTable(text)).toEqual({
+      delimiter,
+      rows: [
+        ['Name', 'Role'],
+        ['Ada', 'Engineer'],
+      ],
+    });
+  });
+
+  it('falls back to one column when delimiter counts are inconsistent', () => {
+    expect(selectionToTable('One,Two\nThree\nFour,Five,Six')).toEqual({
+      delimiter: null,
+      rows: [['One,Two'], ['Three'], ['Four,Five,Six']],
+    });
+  });
+
+  it('uses the first row as the Markdown header and escapes cell pipes', () => {
+    expect(selectionToTableMarkdown('Name,Notes\nAda,A | B')).toBe(
+      '| Name | Notes |\n| --- | --- |\n| Ada | A \\| B |',
+    );
+  });
+});
+
+describe('selectionToTaskListMarkdown', () => {
+  it('turns non-empty selected lines into unchecked tasks', () => {
+    expect(selectionToTaskListMarkdown('Buy milk\n\nCall Sam')).toBe(
+      '- [ ] Buy milk\n- [ ] Call Sam',
+    );
+  });
+
+  it('normalizes list markers and retains existing checked state', () => {
+    const text = '- first\n2. second\n- [x] already done';
+    expect(selectionToTaskItems(text)).toEqual([
+      { checked: false, text: 'first' },
+      { checked: false, text: 'second' },
+      { checked: true, text: 'already done' },
+    ]);
+    expect(selectionToTaskListMarkdown(text)).toBe('- [ ] first\n- [ ] second\n- [x] already done');
+  });
+});