@bendyline/squisq-editor-react 2.0.1 → 2.2.0

package/src/__tests__/fileKind.test.ts

@@ -1,112 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { detectLanguageFromFileName, resolveFileKind } from '../fileKind';
-
-describe('detectLanguageFromFileName', () => {
-  it('detects common extensions', () => {
-    expect(detectLanguageFromFileName('foo.ts')).toBe('typescript');
-    expect(detectLanguageFromFileName('app.py')).toBe('python');
-    expect(detectLanguageFromFileName('data.json')).toBe('json');
-    expect(detectLanguageFromFileName('index.html')).toBe('html');
-    expect(detectLanguageFromFileName('styles.css')).toBe('css');
-    expect(detectLanguageFromFileName('README.md')).toBe('markdown');
-  });
-
-  it('uses the final extension for multi-dot names', () => {
-    expect(detectLanguageFromFileName('archive.tar.gz')).toBe(null);
-    expect(detectLanguageFromFileName('component.test.ts')).toBe('typescript');
-  });
-
-  it('accepts bare extensions with or without a leading dot', () => {
-    expect(detectLanguageFromFileName('.ts')).toBe('typescript');
-    expect(detectLanguageFromFileName('ts')).toBe('typescript');
-  });
-
-  it('matches extensionless names like Dockerfile', () => {
-    expect(detectLanguageFromFileName('Dockerfile')).toBe('dockerfile');
-    expect(detectLanguageFromFileName('dockerfile')).toBe('dockerfile');
-  });
-
-  it('is case-insensitive for extensions', () => {
-    expect(detectLanguageFromFileName('foo.TS')).toBe('typescript');
-    expect(detectLanguageFromFileName('App.JSX')).toBe('javascript');
-  });
-
-  it('strips leading paths', () => {
-    expect(detectLanguageFromFileName('src/lib/foo.ts')).toBe('typescript');
-    expect(detectLanguageFromFileName('C:\\Users\\me\\app.py')).toBe('python');
-  });
-
-  it('returns null for unknown extensions', () => {
-    expect(detectLanguageFromFileName('foo.xyz')).toBe(null);
-    expect(detectLanguageFromFileName('mystery.blob')).toBe(null);
-  });
-
-  it('returns null for empty or trailing-dot inputs', () => {
-    expect(detectLanguageFromFileName('')).toBe(null);
-    expect(detectLanguageFromFileName('   ')).toBe(null);
-    expect(detectLanguageFromFileName('foo.')).toBe(null);
-  });
-});
-
-describe('resolveFileKind', () => {
-  it('defaults to markdown mode when nothing is supplied', () => {
-    expect(resolveFileKind()).toEqual({ mode: 'markdown', language: 'markdown' });
-  });
-
-  it('returns code mode for recognized code extensions', () => {
-    expect(resolveFileKind('foo.ts')).toEqual({ mode: 'code', language: 'typescript' });
-    expect(resolveFileKind('app.py')).toEqual({ mode: 'code', language: 'python' });
-    expect(resolveFileKind('data.json')).toEqual({ mode: 'code', language: 'json' });
-  });
-
-  it('keeps markdown extensions in markdown mode', () => {
-    expect(resolveFileKind('README.md')).toEqual({ mode: 'markdown', language: 'markdown' });
-    expect(resolveFileKind('doc.markdown')).toEqual({ mode: 'markdown', language: 'markdown' });
-  });
-
-  it('keeps .txt in markdown mode with plaintext language', () => {
-    expect(resolveFileKind('notes.txt')).toEqual({ mode: 'markdown', language: 'plaintext' });
-  });
-
-  it('falls back to markdown mode for unknown extensions', () => {
-    expect(resolveFileKind('foo.xyz')).toEqual({ mode: 'markdown', language: 'markdown' });
-  });
-
-  it('lets the explicit language override fileName detection', () => {
-    expect(resolveFileKind('foo.md', 'typescript')).toEqual({
-      mode: 'code',
-      language: 'typescript',
-    });
-  });
-
-  it('stays in markdown mode when language override is markdown or plaintext', () => {
-    expect(resolveFileKind('foo.ts', 'markdown')).toEqual({
-      mode: 'markdown',
-      language: 'markdown',
-    });
-    expect(resolveFileKind(undefined, 'plaintext')).toEqual({
-      mode: 'markdown',
-      language: 'plaintext',
-    });
-  });
-
-  it('accepts a language with no fileName', () => {
-    expect(resolveFileKind(undefined, 'rust')).toEqual({ mode: 'code', language: 'rust' });
-  });
-
-  it('returns image mode for raster image extensions', () => {
-    expect(resolveFileKind('foo.png')).toEqual({ mode: 'image', language: 'image' });
-    expect(resolveFileKind('photo.JPEG')).toEqual({ mode: 'image', language: 'image' });
-    expect(resolveFileKind('anim.gif')).toEqual({ mode: 'image', language: 'image' });
-    expect(resolveFileKind('hero.webp')).toEqual({ mode: 'image', language: 'image' });
-    expect(resolveFileKind('icon.avif')).toEqual({ mode: 'image', language: 'image' });
-  });
-
-  it('keeps SVG as code mode (xml) so the source stays editable', () => {
-    expect(resolveFileKind('logo.svg')).toEqual({ mode: 'code', language: 'xml' });
-  });
-
-  it('respects an explicit language=image override', () => {
-    expect(resolveFileKind(undefined, 'image')).toEqual({ mode: 'image', language: 'image' });
-  });
-});

package/src/__tests__/headingTransition.test.ts

@@ -1,176 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import {
-  readHeadingLineTransition,
-  setHeadingLineTransition,
-  readBlockAttrsTransition,
-  setHeadingAttrsTransition,
-  EMPTY_TRANSITION,
-} from '../headingTransition';
-
-describe('readHeadingLineTransition', () => {
-  it('returns empty for a plain heading', () => {
-    expect(readHeadingLineTransition('## Tips')).toEqual(EMPTY_TRANSITION);
-  });
-
-  it('returns empty for a non-heading line', () => {
-    expect(readHeadingLineTransition('Just a paragraph')).toEqual(EMPTY_TRANSITION);
-  });
-
-  it('reads transition from a Pandoc block', () => {
-    expect(readHeadingLineTransition('## Tips {transition=fade}')).toEqual({
-      type: 'fade',
-      direction: '',
-      duration: '',
-    });
-  });
-
-  it('reads type, direction and duration together', () => {
-    expect(
-      readHeadingLineTransition(
-        '## Tips {transition=push transitionDirection=left transitionDuration=0.7}',
-      ),
-    ).toEqual({ type: 'push', direction: 'left', duration: '0.7' });
-  });
-
-  it('reads a hand-typed transition from the {[…]} template params', () => {
-    expect(readHeadingLineTransition('## Tips {[title transition=zoom]}')).toEqual({
-      type: 'zoom',
-      direction: '',
-      duration: '',
-    });
-  });
-
-  it('reads a transition from a param-only {[…]} annotation', () => {
-    expect(readHeadingLineTransition('## Tips {[transition=zoom]}')).toEqual({
-      type: 'zoom',
-      direction: '',
-      duration: '',
-    });
-  });
-
-  it('prefers the Pandoc block over the template params when both set it', () => {
-    expect(
-      readHeadingLineTransition('## Tips {transition=fade} {[title transition=zoom]}'),
-    ).toEqual({ type: 'fade', direction: '', duration: '' });
-  });
-});
-
-describe('setHeadingLineTransition', () => {
-  it('adds a squiggly annotation to a plain heading', () => {
-    expect(setHeadingLineTransition('## Tips', { type: 'fade', direction: '', duration: '' })).toBe(
-      '## Tips {[transition=fade]}',
-    );
-  });
-
-  it('folds into an existing {[…]} template annotation', () => {
-    expect(
-      setHeadingLineTransition('## Tips {[title]}', { type: 'fade', direction: '', duration: '' }),
-    ).toBe('## Tips {[title transition=fade]}');
-  });
-
-  it('includes direction and duration when present', () => {
-    expect(
-      setHeadingLineTransition('## Tips', { type: 'push', direction: 'up', duration: '1.2' }),
-    ).toBe('## Tips {[transition=push transitionDirection=up transitionDuration=1.2]}');
-  });
-
-  it('migrates an existing Pandoc transition, preserving other params and the id', () => {
-    expect(
-      setHeadingLineTransition('## Tips {#intro transition=fade x=10}', {
-        type: 'zoom',
-        direction: '',
-        duration: '',
-      }),
-    ).toBe('## Tips {#intro x=10} {[transition=zoom]}');
-  });
-
-  it('migrates into an existing template annotation without duplicating channels', () => {
-    expect(
-      setHeadingLineTransition('## Tips {#intro transition=fade} {[title color=blue]}', {
-        type: 'zoom',
-        direction: '',
-        duration: '',
-      }),
-    ).toBe('## Tips {#intro} {[title color=blue transition=zoom]}');
-  });
-
-  it('removes the transition (and an empty block) when set to none', () => {
-    expect(setHeadingLineTransition('## Tips {transition=fade}', EMPTY_TRANSITION)).toBe('## Tips');
-  });
-
-  it('keeps a non-empty Pandoc block when only the transition is cleared', () => {
-    expect(setHeadingLineTransition('## Tips {#intro transition=fade}', EMPTY_TRANSITION)).toBe(
-      '## Tips {#intro}',
-    );
-  });
-
-  it('drops direction/duration when the type is cleared', () => {
-    expect(
-      setHeadingLineTransition(
-        '## Tips {transition=push transitionDirection=left}',
-        EMPTY_TRANSITION,
-      ),
-    ).toBe('## Tips');
-  });
-
-  it('round-trips through read', () => {
-    const next = { type: 'wipe', direction: 'right', duration: '0.5' };
-    const line = setHeadingLineTransition('## Tips {[title]}', next);
-    expect(readHeadingLineTransition(line)).toEqual(next);
-  });
-
-  it('leaves non-heading lines untouched', () => {
-    expect(
-      setHeadingLineTransition('paragraph', { type: 'fade', direction: '', duration: '' }),
-    ).toBe('paragraph');
-  });
-});
-
-describe('block-attrs (WYSIWYG) helpers', () => {
-  it('reads from the dataBlockAttrs inner', () => {
-    expect(readBlockAttrsTransition('#intro transition=fade', null)).toEqual({
-      type: 'fade',
-      direction: '',
-      duration: '',
-    });
-  });
-
-  it('reads a hand-typed transition from dataTemplateParams', () => {
-    expect(readBlockAttrsTransition(null, 'transition=zoom x=1')).toEqual({
-      type: 'zoom',
-      direction: '',
-      duration: '',
-    });
-  });
-
-  it('writes transition edits to dataTemplateParams by default', () => {
-    expect(
-      setHeadingAttrsTransition(null, null, { type: 'fade', direction: '', duration: '' }),
-    ).toEqual({
-      blockAttrsInner: null,
-      templateParams: 'transition=fade',
-    });
-  });
-
-  it('migrates legacy dataBlockAttrs transitions to dataTemplateParams', () => {
-    expect(
-      setHeadingAttrsTransition('#intro transition=fade', 'color=blue', {
-        type: 'zoom',
-        direction: '',
-        duration: '',
-      }),
-    ).toEqual({
-      blockAttrsInner: '#intro',
-      templateParams: 'color=blue transition=zoom',
-    });
-  });
-
-  it('clears transitions from both WYSIWYG channels', () => {
-    expect(
-      setHeadingAttrsTransition('#intro transition=fade', 'transition=zoom', EMPTY_TRANSITION),
-    ).toEqual({
-      blockAttrsInner: '#intro',
-      templateParams: null,
-    });
-  });
-});

package/src/__tests__/imageEditAffordance.test.tsx

@@ -1,272 +0,0 @@
-/**
- * @vitest-environment jsdom
- *
- * Tests for the image-edit affordance + modal:
- *   - EditorContext exposes openImageEdit / closeImageEdit / bumpMediaRevision
- *   - <EditorShell> mounts an `<ImageEditModal>` when the target is set,
- *     and routes Export blobs back through `mediaProvider.addMedia`.
- *
- * The Tiptap NodeView itself isn't exercised here (Tiptap + ProseMirror
- * are jsdom-hostile); we verify the surrounding context + shell wiring
- * directly via a small harness.
- */
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { act, fireEvent, render, screen, waitFor } from '@testing-library/react';
-import {
-  MemoryContentContainer,
-  createMediaProviderFromContainer,
-} from '@bendyline/squisq/storage';
-import type { MediaProvider } from '@bendyline/squisq/schemas';
-import { EditorProvider, useEditorContext } from '../EditorContext';
-
-// Stub the heavy editing surfaces so the shell can mount under jsdom
-// without dragging in monaco-editor or Tiptap. We only care about the
-// shell's modal-mounting wiring here.
-vi.mock('../RawEditor', () => ({
-  RawEditor: () => <div data-testid="raw-editor-stub" />,
-}));
-vi.mock('../WysiwygEditor', () => ({
-  WysiwygEditor: () => <div data-testid="wysiwyg-editor-stub" />,
-}));
-vi.mock('../PreviewPanel', () => ({
-  PreviewPanel: () => <div data-testid="preview-stub" />,
-}));
-
-import { EditorShell } from '../EditorShell';
-
-beforeEach(() => {
-  if (typeof URL.createObjectURL !== 'function') {
-    Object.defineProperty(URL, 'createObjectURL', {
-      configurable: true,
-      value: vi.fn(() => 'blob:stub'),
-    });
-  }
-  if (typeof URL.revokeObjectURL !== 'function') {
-    Object.defineProperty(URL, 'revokeObjectURL', {
-      configurable: true,
-      value: vi.fn(),
-    });
-  }
-  if (typeof window !== 'undefined' && typeof window.matchMedia !== 'function') {
-    Object.defineProperty(window, 'matchMedia', {
-      configurable: true,
-      value: (query: string) => ({
-        matches: false,
-        media: query,
-        onchange: null,
-        addListener: vi.fn(),
-        removeListener: vi.fn(),
-        addEventListener: vi.fn(),
-        removeEventListener: vi.fn(),
-        dispatchEvent: vi.fn(() => false),
-      }),
-    });
-  }
-  if (typeof globalThis.ResizeObserver === 'undefined') {
-    class ResizeObserverStub {
-      observe(): void {}
-      unobserve(): void {}
-      disconnect(): void {}
-    }
-    (globalThis as unknown as { ResizeObserver: typeof ResizeObserverStub }).ResizeObserver =
-      ResizeObserverStub;
-  }
-});
-
-// ── Context harness ──────────────────────────────────────
-
-function ContextHarness() {
-  const ctx = useEditorContext();
-  return (
-    <div>
-      <span data-testid="target">{ctx.imageEditTarget ?? 'null'}</span>
-      <span data-testid="revision">{ctx.mediaRevision}</span>
-      <button data-testid="open" type="button" onClick={() => ctx.openImageEdit('hero.png')}>
-        open
-      </button>
-      <button data-testid="close" type="button" onClick={ctx.closeImageEdit}>
-        close
-      </button>
-      <button data-testid="bump" type="button" onClick={ctx.bumpMediaRevision}>
-        bump
-      </button>
-    </div>
-  );
-}
-
-describe('EditorContext image-edit actions', () => {
-  it('starts with imageEditTarget=null and mediaRevision=0', () => {
-    render(
-      <EditorProvider>
-        <ContextHarness />
-      </EditorProvider>,
-    );
-    expect(screen.getByTestId('target').textContent).toBe('null');
-    expect(screen.getByTestId('revision').textContent).toBe('0');
-  });
-
-  it('openImageEdit sets the target, closeImageEdit clears it', () => {
-    render(
-      <EditorProvider>
-        <ContextHarness />
-      </EditorProvider>,
-    );
-    act(() => {
-      fireEvent.click(screen.getByTestId('open'));
-    });
-    expect(screen.getByTestId('target').textContent).toBe('hero.png');
-    act(() => {
-      fireEvent.click(screen.getByTestId('close'));
-    });
-    expect(screen.getByTestId('target').textContent).toBe('null');
-  });
-
-  it('bumpMediaRevision increments monotonically', () => {
-    render(
-      <EditorProvider>
-        <ContextHarness />
-      </EditorProvider>,
-    );
-    expect(screen.getByTestId('revision').textContent).toBe('0');
-    act(() => {
-      fireEvent.click(screen.getByTestId('bump'));
-    });
-    act(() => {
-      fireEvent.click(screen.getByTestId('bump'));
-    });
-    expect(screen.getByTestId('revision').textContent).toBe('2');
-  });
-});
-
-// ── Shell + modal harness ────────────────────────────────
-
-/**
- * A floating button that uses `useEditorContext` to dispatch
- * `openImageEdit(path)` from inside the shell — this lets us trigger
- * the modal without spinning up a full Tiptap NodeView.
- */
-function TriggerButton({ path }: { path: string }) {
-  const { openImageEdit } = useEditorContext();
-  return (
-    <button data-testid="trigger" type="button" onClick={() => openImageEdit(path)}>
-      open
-    </button>
-  );
-}
-
-async function setupShellWithImage(): Promise<{
-  container: MemoryContentContainer;
-  mediaProvider: MediaProvider;
-}> {
-  const container = new MemoryContentContainer();
-  // Seed a 1×1 PNG so resolveUrl returns a fetchable blob URL.
-  const onePixel = new Uint8Array([
-    0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
-  ]);
-  await container.writeFile('hero.png', onePixel.buffer, 'image/png');
-  const mediaProvider = createMediaProviderFromContainer(container);
-  return { container, mediaProvider };
-}
-
-describe('<EditorShell> image-edit modal wiring', () => {
-  it('opens the modal when openImageEdit is dispatched and closes via the close button', async () => {
-    const { container, mediaProvider } = await setupShellWithImage();
-    render(
-      <EditorShell
-        initialMarkdown="# hi"
-        workspaceContainer={container}
-        mediaProvider={mediaProvider}
-        toolbarSlotRight={<TriggerButton path="hero.png" />}
-      />,
-    );
-
-    expect(screen.queryByTestId('image-edit-modal')).toBeNull();
-
-    const trigger = screen.getByTestId('trigger');
-    trigger.focus();
-    await act(async () => {
-      fireEvent.click(trigger);
-    });
-
-    await waitFor(() => {
-      expect(screen.getByTestId('image-edit-modal')).toBeTruthy();
-    });
-    // Shows the relative path in the header.
-    expect(screen.getByText('hero.png')).toBeTruthy();
-    expect(document.activeElement).toBe(screen.getByTestId('image-edit-modal-close'));
-
-    await act(async () => {
-      fireEvent.click(screen.getByTestId('image-edit-modal-close'));
-    });
-    await waitFor(() => {
-      expect(screen.queryByTestId('image-edit-modal')).toBeNull();
-    });
-    expect(document.activeElement).toBe(screen.getByTestId('trigger'));
-  });
-
-  it('opens the modal with a transient sidecar when only a mediaProvider is wired (no host container)', async () => {
-    const { mediaProvider } = await setupShellWithImage();
-    render(
-      <EditorShell
-        initialMarkdown="# hi"
-        mediaProvider={mediaProvider}
-        toolbarSlotRight={<TriggerButton path="hero.png" />}
-      />,
-    );
-    await act(async () => {
-      fireEvent.click(screen.getByTestId('trigger'));
-    });
-    // Modal now mounts even without a host container — the sidecar is
-    // backed by a fresh MemoryContentContainer the modal owns.
-    await waitFor(() => {
-      expect(screen.getByTestId('image-edit-modal')).toBeTruthy();
-    });
-  });
-
-  it('does NOT mount the modal when no mediaProvider is wired', async () => {
-    render(
-      <EditorShell initialMarkdown="# hi" toolbarSlotRight={<TriggerButton path="hero.png" />} />,
-    );
-    await act(async () => {
-      fireEvent.click(screen.getByTestId('trigger'));
-    });
-    // Without a media provider the modal has no way to resolve the source
-    // or write the result back — the guard bails out.
-    expect(screen.queryByTestId('image-edit-modal')).toBeNull();
-  });
-
-  it('writes the exported blob back through mediaProvider.addMedia and closes', async () => {
-    const { container, mediaProvider } = await setupShellWithImage();
-    const addMediaSpy = vi.spyOn(mediaProvider, 'addMedia');
-
-    render(
-      <EditorShell
-        initialMarkdown="# hi"
-        workspaceContainer={container}
-        mediaProvider={mediaProvider}
-        toolbarSlotRight={<TriggerButton path="hero.png" />}
-      />,
-    );
-
-    await act(async () => {
-      fireEvent.click(screen.getByTestId('trigger'));
-    });
-    await waitFor(() => {
-      expect(screen.getByTestId('image-edit-modal')).toBeTruthy();
-    });
-
-    // Drive the export path directly via mediaProvider.addMedia — the
-    // modal's onExport handler does exactly this. We don't try to
-    // pump the inner ImageEditor's Export button (it depends on async
-    // sidecar seeding that's heavy to wait through here).
-    // Pass raw bytes (a Uint8Array) — jsdom's Blob lacks `arrayBuffer()`,
-    // and a fake-Blob stub doesn't satisfy `instanceof Blob`, so the
-    // simplest payload is the Uint8Array branch addMedia already supports.
-    const bytes = new Uint8Array([1, 2, 3]);
-    await act(async () => {
-      await mediaProvider.addMedia('hero.png', bytes, 'image/png');
-    });
-
-    expect(addMediaSpy).toHaveBeenCalledWith('hero.png', bytes, 'image/png');
-  });
-});

package/src/__tests__/imageEditModalContract.test.tsx

@@ -1,119 +0,0 @@
-/** @vitest-environment jsdom */
-import { act, fireEvent, render, screen, waitFor } from '@testing-library/react';
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import type { ContentContainer } from '@bendyline/squisq/storage';
-import { MemoryContentContainer } from '@bendyline/squisq/storage';
-import type { MediaProvider } from '@bendyline/squisq/schemas';
-import { useEditorContext } from '../EditorContext';
-
-const imageEditorProps: Array<{
-  filesContainer: ContentContainer;
-  saveFormat: 'png' | 'jpeg' | 'webp';
-  onExport: (blob: Blob, format: 'png' | 'jpeg' | 'webp') => void;
-}> = [];
-
-vi.mock('../ImageEditor', () => ({
-  ImageEditor: (props: (typeof imageEditorProps)[number]) => {
-    imageEditorProps.push(props);
-    return <div data-testid="image-editor-contract-stub" />;
-  },
-}));
-vi.mock('../RawEditor', () => ({ RawEditor: () => <div /> }));
-vi.mock('../WysiwygEditor', () => ({ WysiwygEditor: () => <div /> }));
-vi.mock('../PreviewPanel', () => ({ PreviewPanel: () => <div /> }));
-
-import { EditorShell } from '../EditorShell';
-
-function Trigger({ path }: { path: string }) {
-  const { openImageEdit } = useEditorContext();
-  return <button onClick={() => openImageEdit(path)}>edit</button>;
-}
-
-function provider(): MediaProvider {
-  return {
-    addMedia: vi.fn(async (name: string) => name),
-    resolveUrl: vi.fn(async (name: string) => `blob:${name}`),
-    listMedia: vi.fn(async () => []),
-    removeMedia: vi.fn(async () => {}),
-    dispose: vi.fn(),
-  };
-}
-
-beforeEach(() => {
-  imageEditorProps.length = 0;
-  if (typeof window.matchMedia !== 'function') {
-    Object.defineProperty(window, 'matchMedia', {
-      configurable: true,
-      value: () => ({ matches: false, addEventListener() {}, removeEventListener() {} }),
-    });
-  }
-});
-
-describe('ImageEditModal storage contract', () => {
-  it('writes JPEG bytes/MIME back to a .jpg path', async () => {
-    const mediaProvider = provider();
-    render(
-      <EditorShell
-        initialMarkdown="# image"
-        mediaProvider={mediaProvider}
-        toolbarSlotRight={<Trigger path="photo.jpg" />}
-      />,
-    );
-    fireEvent.click(screen.getByText('edit'));
-    await waitFor(() => expect(screen.getByTestId('image-editor-contract-stub')).toBeTruthy());
-    const props = imageEditorProps[imageEditorProps.length - 1]!;
-    expect(props.saveFormat).toBe('jpeg');
-    await act(async () => props.onExport(new Blob(['jpeg']), 'jpeg'));
-    expect(mediaProvider.addMedia).toHaveBeenCalledWith(
-      'photo.jpg',
-      expect.any(Blob),
-      'image/jpeg',
-    );
-  });
-
-  it('hashes sidecar paths so sanitized-name collisions remain separate', async () => {
-    const parent = new MemoryContentContainer();
-    const mediaProvider = provider();
-    const first = render(
-      <EditorShell
-        initialMarkdown="# image"
-        workspaceContainer={parent}
-        mediaProvider={mediaProvider}
-        toolbarSlotRight={<Trigger path="a/b.png" />}
-      />,
-    );
-    fireEvent.click(screen.getByText('edit'));
-    await waitFor(() => expect(imageEditorProps).toHaveLength(1));
-    const firstContainer = imageEditorProps[0].filesContainer;
-    first.unmount();
-
-    render(
-      <EditorShell
-        initialMarkdown="# image"
-        workspaceContainer={parent}
-        mediaProvider={mediaProvider}
-        toolbarSlotRight={<Trigger path="a_b.png" />}
-      />,
-    );
-    fireEvent.click(screen.getByText('edit'));
-    await waitFor(() => expect(imageEditorProps).toHaveLength(2));
-    const secondContainer = imageEditorProps[1].filesContainer;
-    await firstContainer.writeFile('sentinel', new Uint8Array([1]).buffer);
-    await secondContainer.writeFile('sentinel', new Uint8Array([2]).buffer);
-    const paths = (await parent.listFiles('.imageEdits')).map((entry) => entry.path);
-    expect(paths.filter((path) => path.endsWith('/sentinel'))).toHaveLength(2);
-  });
-
-  it('refuses unsupported source formats instead of writing mismatched bytes', async () => {
-    render(
-      <EditorShell
-        initialMarkdown="# image"
-        mediaProvider={provider()}
-        toolbarSlotRight={<Trigger path="animated.gif" />}
-      />,
-    );
-    fireEvent.click(screen.getByText('edit'));
-    await waitFor(() => expect(screen.getByText(/supports PNG, JPEG, and WebP/i)).toBeTruthy());
-    expect(screen.queryByTestId('image-editor-contract-stub')).toBeNull();
-  });
-});