gogcli-mcp-slides 2.7.1 → 2.18.0

package/tests/tools/slides-extra.test.ts

@@ -1,7 +1,8 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { registerExtraSlidesTools } from '../../src/tools/slides-extra.js';
 import * as lib from '../../../gogcli-mcp/src/lib.js';
-import { setupHandlers, toText, type ToolHandler } from '../../../gogcli-mcp/tests/helpers/test-harness.js';
+import { createTestHarness, type TestHarness } from '@chrischall/mcp-utils/test';
+import { rawTextResult } from '@chrischall/mcp-utils';
 
 vi.mock('../../../gogcli-mcp/src/lib.js', async (importOriginal) => {
   const actual = await importOriginal<typeof lib>();
@@ -11,17 +12,17 @@ vi.mock('../../../gogcli-mcp/src/lib.js', async (importOriginal) => {
   };
 });
 
-let handlers: Map<string, ToolHandler>;
+let harness: TestHarness;
 
-beforeEach(() => {
+beforeEach(async () => {
   vi.clearAllMocks();
-  vi.mocked(lib.runOrDiagnose).mockResolvedValue(toText('{}'));
-  handlers = setupHandlers(registerExtraSlidesTools);
+  vi.mocked(lib.runOrDiagnose).mockResolvedValue(rawTextResult('{}'));
+  harness = await createTestHarness(registerExtraSlidesTools);
 });
 
 describe('gog_slides_create_from_markdown', () => {
   it('calls runOrDiagnose with title only', async () => {
-    await handlers.get('gog_slides_create_from_markdown')!({ title: 'Deck' });
+    await harness.callTool('gog_slides_create_from_markdown', { title: 'Deck' });
     expect(lib.runOrDiagnose).toHaveBeenCalledWith(
       ['slides', 'create-from-markdown', 'Deck'],
       { account: undefined },
@@ -29,7 +30,7 @@ describe('gog_slides_create_from_markdown', () => {
   });
 
   it('passes all optional flags', async () => {
-    await handlers.get('gog_slides_create_from_markdown')!({
+    await harness.callTool('gog_slides_create_from_markdown', {
       title: 'Deck',
       content: '# Slide 1',
       contentFile: '/tmp/deck.md',
@@ -49,7 +50,7 @@ describe('gog_slides_create_from_markdown', () => {
   });
 
   it('omits --debug when false', async () => {
-    await handlers.get('gog_slides_create_from_markdown')!({ title: 'Deck', debug: false });
+    await harness.callTool('gog_slides_create_from_markdown', { title: 'Deck', debug: false });
     expect(lib.runOrDiagnose).toHaveBeenCalledWith(
       ['slides', 'create-from-markdown', 'Deck'],
       { account: undefined },
@@ -59,7 +60,7 @@ describe('gog_slides_create_from_markdown', () => {
 
 describe('gog_slides_create_from_template', () => {
   it('calls runOrDiagnose with templateId and title only', async () => {
-    await handlers.get('gog_slides_create_from_template')!({ templateId: 'tpl1', title: 'Deck' });
+    await harness.callTool('gog_slides_create_from_template', { templateId: 'tpl1', title: 'Deck' });
     expect(lib.runOrDiagnose).toHaveBeenCalledWith(
       ['slides', 'create-from-template', 'tpl1', 'Deck'],
       { account: undefined },
@@ -67,7 +68,7 @@ describe('gog_slides_create_from_template', () => {
   });
 
   it('passes --replace for a single replacement entry', async () => {
-    await handlers.get('gog_slides_create_from_template')!({
+    await harness.callTool('gog_slides_create_from_template', {
       templateId: 'tpl1',
       title: 'Deck',
       replacements: { name: 'Alice' },
@@ -79,7 +80,7 @@ describe('gog_slides_create_from_template', () => {
   });
 
   it('passes --replace for each entry in replacements', async () => {
-    await handlers.get('gog_slides_create_from_template')!({
+    await harness.callTool('gog_slides_create_from_template', {
       templateId: 'tpl1',
       title: 'Deck',
       replacements: { name: 'Alice', company: 'Acme' },
@@ -90,7 +91,7 @@ describe('gog_slides_create_from_template', () => {
   });
 
   it('passes --replacements, --parent, and --exact', async () => {
-    await handlers.get('gog_slides_create_from_template')!({
+    await harness.callTool('gog_slides_create_from_template', {
       templateId: 'tpl1',
       title: 'Deck',
       replacementsFile: '/tmp/r.json',
@@ -109,7 +110,7 @@ describe('gog_slides_create_from_template', () => {
   });
 
   it('omits --exact when false', async () => {
-    await handlers.get('gog_slides_create_from_template')!({
+    await harness.callTool('gog_slides_create_from_template', {
       templateId: 'tpl1',
       title: 'Deck',
       exact: false,
@@ -121,9 +122,77 @@ describe('gog_slides_create_from_template', () => {
   });
 });
 
+// Slides is the asymmetric case: gog accepts both the inline and the *-file
+// flag and lets the FILE win, so these tools keep passing both through rather
+// than rejecting like gog_docs_cell_update / the gmail body pairs do.
+describe('slides payload routing', () => {
+  const big = 'x'.repeat(lib.PAYLOAD_INLINE_MAX + 1);
+
+  it('routes a large create-from-markdown content to --content-file', async () => {
+    await harness.callTool('gog_slides_create_from_markdown', { title: 'Deck', content: big });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['slides', 'create-from-markdown', 'Deck',
+        { kind: 'file', flag: 'content-file', contents: big, ext: 'md' }],
+      { account: undefined },
+    );
+  });
+
+  it('routes large add-slide notes to --notes-file', async () => {
+    await harness.callTool('gog_slides_add_slide', { presentationId: 'p1', image: '/tmp/i.png', notes: big });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['slides', 'add-slide', 'p1', '/tmp/i.png',
+        { kind: 'file', flag: 'notes-file', contents: big, ext: undefined }],
+      { account: undefined },
+    );
+  });
+
+  it('routes large update-notes notes to --notes-file', async () => {
+    await harness.callTool('gog_slides_update_notes', { presentationId: 'p1', slideId: 's1', notes: big });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['slides', 'update-notes', 'p1', 's1',
+        { kind: 'file', flag: 'notes-file', contents: big, ext: undefined }],
+      { account: undefined },
+    );
+  });
+
+  it('routes large replace-slide notes to --notes-file', async () => {
+    await harness.callTool('gog_slides_replace_slide', {
+      presentationId: 'p1', slideId: 's1', image: '/tmp/i.png', notes: big,
+    });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['slides', 'replace-slide', 'p1', 's1', '/tmp/i.png',
+        { kind: 'file', flag: 'notes-file', contents: big, ext: undefined }],
+      { account: undefined },
+    );
+  });
+
+  // A caller-supplied notesFile is pushed last, so it still wins over a
+  // payloadArg-generated file — matching gog's own "last flag wins" behavior.
+  it('keeps a caller-supplied notesFile last so it still wins over a spilled payload', async () => {
+    await harness.callTool('gog_slides_update_notes', {
+      presentationId: 'p1', slideId: 's1', notes: big, notesFile: '/tmp/mine.txt',
+    });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['slides', 'update-notes', 'p1', 's1',
+        { kind: 'file', flag: 'notes-file', contents: big, ext: undefined },
+        '--notes-file=/tmp/mine.txt'],
+      { account: undefined },
+    );
+  });
+
+  // Trailing newlines survive the file round-trip for slides notes (gog 0.34.1),
+  // unlike gmail bodies where they are stripped. Documented as a property.
+  it('preserves trailing newlines in a spilled notes payload', async () => {
+    const padded = `${big}\n\n`;
+    await harness.callTool('gog_slides_update_notes', { presentationId: 'p1', slideId: 's1', notes: padded });
+    const [args] = vi.mocked(lib.runOrDiagnose).mock.calls[0];
+    expect(args[4]).toEqual({ kind: 'file', flag: 'notes-file', contents: padded, ext: undefined });
+  });
+});
+
 describe('gog_slides_add_slide', () => {
   it('calls runOrDiagnose with presentationId and image', async () => {
-    await handlers.get('gog_slides_add_slide')!({ presentationId: 'p1', image: '/tmp/img.png' });
+    await harness.callTool('gog_slides_add_slide', { presentationId: 'p1', image: '/tmp/img.png' });
     expect(lib.runOrDiagnose).toHaveBeenCalledWith(
       ['slides', 'add-slide', 'p1', '/tmp/img.png'],
       { account: undefined },
@@ -131,7 +200,7 @@ describe('gog_slides_add_slide', () => {
   });
 
   it('passes --notes, --notes-file, and --before', async () => {
-    await handlers.get('gog_slides_add_slide')!({
+    await harness.callTool('gog_slides_add_slide', {
       presentationId: 'p1',
       image: '/tmp/img.png',
       notes: 'Speaker note',
@@ -152,9 +221,9 @@ describe('gog_slides_add_slide', () => {
 
 describe('gog_slides_delete_slide', () => {
   it('calls runOrDiagnose with presentationId and slideId', async () => {
-    await handlers.get('gog_slides_delete_slide')!({ presentationId: 'p1', slideId: 's1' });
+    await harness.callTool('gog_slides_delete_slide', { presentationId: 'p1', slideId: 's1' });
     expect(lib.runOrDiagnose).toHaveBeenCalledWith(
-      ['slides', 'delete-slide', 'p1', 's1'],
+      ['slides', 'delete-slide', 'p1', 's1', '--force'],
       { account: undefined },
     );
   });
@@ -162,7 +231,7 @@ describe('gog_slides_delete_slide', () => {
 
 describe('gog_slides_update_notes', () => {
   it('calls runOrDiagnose with presentationId and slideId', async () => {
-    await handlers.get('gog_slides_update_notes')!({ presentationId: 'p1', slideId: 's1' });
+    await harness.callTool('gog_slides_update_notes', { presentationId: 'p1', slideId: 's1' });
     expect(lib.runOrDiagnose).toHaveBeenCalledWith(
       ['slides', 'update-notes', 'p1', 's1'],
       { account: undefined },
@@ -170,7 +239,7 @@ describe('gog_slides_update_notes', () => {
   });
 
   it('passes --notes and --notes-file when provided', async () => {
-    await handlers.get('gog_slides_update_notes')!({
+    await harness.callTool('gog_slides_update_notes', {
       presentationId: 'p1',
       slideId: 's1',
       notes: 'speak clearly',
@@ -189,7 +258,7 @@ describe('gog_slides_update_notes', () => {
 
 describe('gog_slides_replace_slide', () => {
   it('calls runOrDiagnose with presentationId, slideId, and image', async () => {
-    await handlers.get('gog_slides_replace_slide')!({
+    await harness.callTool('gog_slides_replace_slide', {
       presentationId: 'p1',
       slideId: 's1',
       image: '/tmp/img.png',
@@ -201,7 +270,7 @@ describe('gog_slides_replace_slide', () => {
   });
 
   it('passes --notes and --notes-file when provided', async () => {
-    await handlers.get('gog_slides_replace_slide')!({
+    await harness.callTool('gog_slides_replace_slide', {
       presentationId: 'p1',
       slideId: 's1',
       image: '/tmp/img.png',
@@ -222,7 +291,7 @@ describe('gog_slides_replace_slide', () => {
 // gog 0.23.0
 describe('gog_slides_insert_image', () => {
   it('inserts an image with the required width', async () => {
-    await handlers.get('gog_slides_insert_image')!({
+    await harness.callTool('gog_slides_insert_image', {
       presentationId: 'p1', slideId: 's1', image: '/tmp/i.png', width: 200,
     });
     expect(lib.runOrDiagnose).toHaveBeenCalledWith(
@@ -232,7 +301,7 @@ describe('gog_slides_insert_image', () => {
   });
 
   it('passes height, position and unit', async () => {
-    await handlers.get('gog_slides_insert_image')!({
+    await harness.callTool('gog_slides_insert_image', {
       presentationId: 'p1', slideId: 's1', image: '/tmp/i.png', width: 200, height: 100, x: 50, y: 60, unit: 'PT', account: 'a@b.com',
     });
     expect(lib.runOrDiagnose).toHaveBeenCalledWith(
@@ -241,3 +310,452 @@ describe('gog_slides_insert_image', () => {
     );
   });
 });
+
+// ===========================================================================
+// gog 0.29 native authoring (PR3a): reads, slide mgmt, text, shapes/lines
+// ===========================================================================
+
+describe('gog_slides_insert_image url mode', () => {
+  it('inserts from a public URL with width and height', async () => {
+    await harness.callTool('gog_slides_insert_image', {
+      presentationId: 'p1', slideId: 's1', url: 'https://x.test/i.png', width: 200, height: 100,
+    });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['slides', 'insert-image', 'p1', 's1', '--width=200', '--url=https://x.test/i.png', '--height=100'],
+      { account: undefined },
+    );
+  });
+});
+
+describe('gog_slides_replace_slide url mode', () => {
+  it('replaces from a public URL', async () => {
+    await harness.callTool('gog_slides_replace_slide', {
+      presentationId: 'p1', slideId: 's1', url: 'https://x.test/i.png', notes: 'n',
+    });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['slides', 'replace-slide', 'p1', 's1', '--url=https://x.test/i.png', '--notes=n'],
+      { account: undefined },
+    );
+  });
+});
+
+describe('gog_slides_raw', () => {
+  it('passes --pretty', async () => {
+    await harness.callTool('gog_slides_raw', { presentationId: 'p1', pretty: true });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['slides', 'raw', 'p1', '--pretty'], { account: undefined });
+  });
+  it('bare', async () => {
+    await harness.callTool('gog_slides_raw', { presentationId: 'p1' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['slides', 'raw', 'p1'], { account: undefined });
+  });
+});
+
+describe('gog_slides_locate', () => {
+  it('passes all filters', async () => {
+    await harness.callTool('gog_slides_locate', {
+      presentationId: 'p1', text: 'hi', page: 'sl1', occurrence: 2, all: true, matchCase: true, failEmpty: true,
+    });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['slides', 'locate', 'p1', 'hi', '--page=sl1', '--occurrence=2', '--all', '--match-case', '--fail-empty'],
+      { account: undefined },
+    );
+  });
+  it('bare', async () => {
+    await harness.callTool('gog_slides_locate', { presentationId: 'p1', text: 'hi' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['slides', 'locate', 'p1', 'hi'], { account: undefined });
+  });
+});
+
+describe('gog_slides_thumbnail', () => {
+  it('passes format, size, out and overwrite', async () => {
+    await harness.callTool('gog_slides_thumbnail', {
+      presentationId: 'p1', slideId: 's1', format: 'png', size: 'large', out: '/tmp/t.png', overwrite: true,
+    });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['slides', 'thumbnail', 'p1', 's1', '--format=png', '--size=large', '--out=/tmp/t.png', '--overwrite'],
+      { account: undefined },
+    );
+  });
+  it('bare', async () => {
+    await harness.callTool('gog_slides_thumbnail', { presentationId: 'p1', slideId: 's1' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['slides', 'thumbnail', 'p1', 's1'], { account: undefined });
+  });
+});
+
+describe('gog_slides_new_slide', () => {
+  it('passes layout and index', async () => {
+    await harness.callTool('gog_slides_new_slide', { presentationId: 'p1', layout: 'TITLE_AND_BODY', index: 2 });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['slides', 'new-slide', 'p1', '--layout=TITLE_AND_BODY', '--index=2'],
+      { account: undefined },
+    );
+  });
+  it('passes layoutId', async () => {
+    await harness.callTool('gog_slides_new_slide', { presentationId: 'p1', layoutId: 'LAY1' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['slides', 'new-slide', 'p1', '--layout-id=LAY1'], { account: undefined });
+  });
+  it('bare', async () => {
+    await harness.callTool('gog_slides_new_slide', { presentationId: 'p1' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['slides', 'new-slide', 'p1'], { account: undefined });
+  });
+});
+
+describe('gog_slides_duplicate_slide', () => {
+  it('passes --to-index', async () => {
+    await harness.callTool('gog_slides_duplicate_slide', { presentationId: 'p1', slideId: 's1', toIndex: 3 });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['slides', 'duplicate-slide', 'p1', 's1', '--to-index=3'], { account: undefined });
+  });
+  it('bare', async () => {
+    await harness.callTool('gog_slides_duplicate_slide', { presentationId: 'p1', slideId: 's1' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['slides', 'duplicate-slide', 'p1', 's1'], { account: undefined });
+  });
+});
+
+describe('gog_slides_move_slide', () => {
+  it('passes required --to-index', async () => {
+    await harness.callTool('gog_slides_move_slide', { presentationId: 'p1', slideId: 's1', toIndex: 0 });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['slides', 'move-slide', 'p1', 's1', '--to-index=0'], { account: undefined });
+  });
+});
+
+describe('gog_slides_insert_text', () => {
+  it('passes cell targeting, insertion index and replace', async () => {
+    await harness.callTool('gog_slides_insert_text', {
+      presentationId: 'p1', objectId: 'o1', text: 'hi', row: 0, col: 1, insertionIndex: 2, replace: true,
+    });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['slides', 'insert-text', 'p1', 'o1', 'hi', '--row=0', '--col=1', '--insertion-index=2', '--replace'],
+      { account: undefined },
+    );
+  });
+  it('bare', async () => {
+    await harness.callTool('gog_slides_insert_text', { presentationId: 'p1', objectId: 'o1', text: 'hi' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['slides', 'insert-text', 'p1', 'o1', 'hi'], { account: undefined });
+  });
+});
+
+describe('gog_slides_style_text', () => {
+  it('passes every styling flag', async () => {
+    await harness.callTool('gog_slides_style_text', {
+      presentationId: 'p1', objectId: 'o1', range: '0:5', font: 'Arial', size: 18, textColor: '#ff0000',
+      bold: true, noBold: true, italic: true, noItalic: true, underline: true, noUnderline: true,
+    });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['slides', 'style-text', 'p1', 'o1', '--range=0:5', '--font=Arial', '--size=18', '--text-color=#ff0000',
+        '--bold', '--no-bold', '--italic', '--no-italic', '--underline', '--no-underline'],
+      { account: undefined },
+    );
+  });
+  it('minimal (range only)', async () => {
+    await harness.callTool('gog_slides_style_text', { presentationId: 'p1', objectId: 'o1', range: '0:5' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['slides', 'style-text', 'p1', 'o1', '--range=0:5'], { account: undefined });
+  });
+});
+
+describe('gog_slides_link', () => {
+  it('applies a url', async () => {
+    await harness.callTool('gog_slides_link', { presentationId: 'p1', objectId: 'o1', range: '0:5', url: 'https://x.test' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['slides', 'link', 'p1', 'o1', '--range=0:5', '--url=https://x.test'], { account: undefined });
+  });
+  it('clears the link', async () => {
+    await harness.callTool('gog_slides_link', { presentationId: 'p1', objectId: 'o1', range: '0:5', clear: true });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['slides', 'link', 'p1', 'o1', '--range=0:5', '--clear'], { account: undefined });
+  });
+});
+
+describe('gog_slides_bullets', () => {
+  it('turns bullets on with a preset', async () => {
+    await harness.callTool('gog_slides_bullets', { presentationId: 'p1', objectId: 'o1', range: '0:5', on: true, preset: 'BULLET_DISC_CIRCLE_SQUARE' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['slides', 'bullets', 'p1', 'o1', '--range=0:5', '--on', '--preset=BULLET_DISC_CIRCLE_SQUARE'], { account: undefined });
+  });
+  it('turns bullets off', async () => {
+    await harness.callTool('gog_slides_bullets', { presentationId: 'p1', objectId: 'o1', range: '0:5', off: true });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['slides', 'bullets', 'p1', 'o1', '--range=0:5', '--off'], { account: undefined });
+  });
+});
+
+describe('gog_slides_replace_text', () => {
+  it('scopes to a single object', async () => {
+    await harness.callTool('gog_slides_replace_text', { presentationId: 'p1', find: 'a', replacement: 'b', object: 'o1', matchCase: true });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['slides', 'replace-text', 'p1', 'a', 'b', '--object=o1', '--match-case'], { account: undefined });
+  });
+  it('scopes to specific pages (repeatable)', async () => {
+    await harness.callTool('gog_slides_replace_text', { presentationId: 'p1', find: 'a', replacement: 'b', pages: ['s1', 's2'] });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['slides', 'replace-text', 'p1', 'a', 'b', '--page=s1', '--page=s2'], { account: undefined });
+  });
+  it('scopes to the whole presentation', async () => {
+    await harness.callTool('gog_slides_replace_text', { presentationId: 'p1', find: 'a', replacement: 'b', all: true });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['slides', 'replace-text', 'p1', 'a', 'b', '--all'], { account: undefined });
+  });
+});
+
+describe('gog_slides_element_create_shape', () => {
+  it('passes type, geometry and object id', async () => {
+    await harness.callTool('gog_slides_element_create_shape', {
+      presentationId: 'p1', slideId: 's1', type: 'RECTANGLE', x: 10, y: 20, width: 100, height: 50, unit: 'PT', objectId: 'shape1',
+    });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['slides', 'element', 'create-shape', 'p1', 's1', '--type=RECTANGLE', '--x=10', '--y=20', '--width=100', '--height=50', '--unit=PT', '--object-id=shape1'],
+      { account: undefined },
+    );
+  });
+  it('bare', async () => {
+    await harness.callTool('gog_slides_element_create_shape', { presentationId: 'p1', slideId: 's1' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['slides', 'element', 'create-shape', 'p1', 's1'], { account: undefined });
+  });
+});
+
+describe('gog_slides_element_create_line', () => {
+  it('passes category, geometry and object id', async () => {
+    await harness.callTool('gog_slides_element_create_line', {
+      presentationId: 'p1', slideId: 's1', category: 'BENT', x: 10, y: 20, width: 100, height: 50, unit: 'EMU', objectId: 'line1',
+    });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['slides', 'element', 'create-line', 'p1', 's1', '--category=BENT', '--x=10', '--y=20', '--width=100', '--height=50', '--unit=EMU', '--object-id=line1'],
+      { account: undefined },
+    );
+  });
+  it('bare', async () => {
+    await harness.callTool('gog_slides_element_create_line', { presentationId: 'p1', slideId: 's1' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['slides', 'element', 'create-line', 'p1', 's1'], { account: undefined });
+  });
+});
+
+describe('gog_slides_element_style', () => {
+  it('passes fill, outline and dash flags', async () => {
+    await harness.callTool('gog_slides_element_style', {
+      presentationId: 'p1', objectId: 'o1', kind: 'shape', fillColor: '#fff', fillTransparent: true,
+      outlineColor: '#000', outlineWeight: 2, outlineDash: 'DASH', outlineTransparent: true,
+    });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['slides', 'element', 'style', 'p1', 'o1', '--kind=shape', '--fill-color=#fff', '--fill-transparent',
+        '--outline-color=#000', '--outline-weight=2', '--outline-dash=DASH', '--outline-transparent'],
+      { account: undefined },
+    );
+  });
+  it('bare', async () => {
+    await harness.callTool('gog_slides_element_style', { presentationId: 'p1', objectId: 'o1' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['slides', 'element', 'style', 'p1', 'o1'], { account: undefined });
+  });
+});
+
+describe('gog_slides_element_transform', () => {
+  it('passes translate, scale, shear, rotate, apply-mode and unit', async () => {
+    await harness.callTool('gog_slides_element_transform', {
+      presentationId: 'p1', objectId: 'o1', translateX: 10, translateY: 20, scaleX: 1.5, scaleY: 2,
+      shearX: 0.1, shearY: 0.2, rotate: 45, applyMode: 'ABSOLUTE', unit: 'PT',
+    });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['slides', 'element', 'transform', 'p1', 'o1', '--translate-x=10', '--translate-y=20', '--scale-x=1.5', '--scale-y=2',
+        '--shear-x=0.1', '--shear-y=0.2', '--rotate=45', '--apply-mode=ABSOLUTE', '--unit=PT'],
+      { account: undefined },
+    );
+  });
+  it('bare', async () => {
+    await harness.callTool('gog_slides_element_transform', { presentationId: 'p1', objectId: 'o1' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['slides', 'element', 'transform', 'p1', 'o1'], { account: undefined });
+  });
+});
+
+describe('gog_slides_element_z_order', () => {
+  it('passes the operation', async () => {
+    await harness.callTool('gog_slides_element_z_order', { presentationId: 'p1', objectId: 'o1', operation: 'BRING_TO_FRONT' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['slides', 'element', 'z-order', 'p1', 'o1', '--operation=BRING_TO_FRONT'], { account: undefined });
+  });
+});
+
+describe('gog_slides_element_group', () => {
+  it('groups elements with a group id', async () => {
+    await harness.callTool('gog_slides_element_group', { presentationId: 'p1', objectIds: ['o1', 'o2', 'o3'], groupId: 'g1' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['slides', 'element', 'group', 'p1', 'o1', 'o2', 'o3', '--group-id=g1'], { account: undefined });
+  });
+  it('groups elements without a group id', async () => {
+    await harness.callTool('gog_slides_element_group', { presentationId: 'p1', objectIds: ['o1', 'o2'] });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['slides', 'element', 'group', 'p1', 'o1', 'o2'], { account: undefined });
+  });
+});
+
+describe('gog_slides_element_ungroup', () => {
+  it('ungroups groups', async () => {
+    await harness.callTool('gog_slides_element_ungroup', { presentationId: 'p1', groupIds: ['g1', 'g2'] });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['slides', 'element', 'ungroup', 'p1', 'g1', 'g2'], { account: undefined });
+  });
+});
+
+describe('gog_slides_element_alt_text', () => {
+  it('sets title and description', async () => {
+    await harness.callTool('gog_slides_element_alt_text', { presentationId: 'p1', objectId: 'o1', title: 'T', description: 'D' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['slides', 'element', 'alt-text', 'p1', 'o1', '--title=T', '--description=D'], { account: undefined });
+  });
+  it('clears both fields with empty strings', async () => {
+    await harness.callTool('gog_slides_element_alt_text', { presentationId: 'p1', objectId: 'o1', title: '', description: '' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['slides', 'element', 'alt-text', 'p1', 'o1', '--title=', '--description='], { account: undefined });
+  });
+  it('bare leaves both untouched', async () => {
+    await harness.callTool('gog_slides_element_alt_text', { presentationId: 'p1', objectId: 'o1' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['slides', 'element', 'alt-text', 'p1', 'o1'], { account: undefined });
+  });
+});
+
+describe('gog_slides_element_delete', () => {
+  it('deletes an element', async () => {
+    await harness.callTool('gog_slides_element_delete', { presentationId: 'p1', objectId: 'o1' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(['slides', 'element', 'delete', 'p1', 'o1', '--force'], { account: undefined });
+  });
+});
+
+// ===========================================================================
+// gog 0.29 native tables (PR3b)
+// ===========================================================================
+
+describe('gog_slides_table_create', () => {
+  it('passes rows, cols and object id', async () => {
+    await harness.callTool('gog_slides_table_create', { presentationId: 'p1', slideId: 's1', rows: 3, cols: 4, objectId: 'tbl1' });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['slides', 'table', 'create', 'p1', 's1', '--rows=3', '--cols=4', '--object-id=tbl1'], { account: undefined });
+  });
+  it('bare', async () => {
+    await harness.callTool('gog_slides_table_create', { presentationId: 'p1', slideId: 's1', rows: 2, cols: 2 });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['slides', 'table', 'create', 'p1', 's1', '--rows=2', '--cols=2'], { account: undefined });
+  });
+});
+
+describe('gog_slides_table_cell_style', () => {
+  it('passes fill, alignment, range and text styling', async () => {
+    await harness.callTool('gog_slides_table_cell_style', {
+      presentationId: 'p1', tableObjectId: 't1', row: 0, col: 1, range: '0:3', fillColor: '#eee', fillTransparent: true,
+      contentAlign: 'MIDDLE', font: 'Arial', size: 12, textColor: '#111',
+      bold: true, noBold: true, italic: true, noItalic: true, underline: true, noUnderline: true,
+    });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['slides', 'table', 'cell', 'style', 'p1', 't1', '--row=0', '--col=1', '--range=0:3', '--fill-color=#eee', '--fill-transparent',
+        '--content-align=MIDDLE', '--font=Arial', '--size=12', '--text-color=#111',
+        '--bold', '--no-bold', '--italic', '--no-italic', '--underline', '--no-underline'],
+      { account: undefined },
+    );
+  });
+  it('minimal (row/col only)', async () => {
+    await harness.callTool('gog_slides_table_cell_style', { presentationId: 'p1', tableObjectId: 't1', row: 0, col: 0 });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['slides', 'table', 'cell', 'style', 'p1', 't1', '--row=0', '--col=0'], { account: undefined });
+  });
+});
+
+describe('gog_slides_table_border_style', () => {
+  it('passes span, position, color, weight, dash and transparent', async () => {
+    await harness.callTool('gog_slides_table_border_style', {
+      presentationId: 'p1', tableObjectId: 't1', row: 0, col: 0, rowSpan: 2, colSpan: 2,
+      position: 'OUTER', borderColor: '#000', weight: 2, dash: 'DASH', transparent: true,
+    });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['slides', 'table', 'border', 'style', 'p1', 't1', '--row=0', '--col=0', '--row-span=2', '--col-span=2',
+        '--position=OUTER', '--border-color=#000', '--weight=2', '--dash=DASH', '--transparent'],
+      { account: undefined },
+    );
+  });
+  it('minimal (row/col only)', async () => {
+    await harness.callTool('gog_slides_table_border_style', { presentationId: 'p1', tableObjectId: 't1', row: 1, col: 1 });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['slides', 'table', 'border', 'style', 'p1', 't1', '--row=1', '--col=1'], { account: undefined });
+  });
+});
+
+describe('gog_slides_table_column_insert', () => {
+  it('passes count and --right', async () => {
+    await harness.callTool('gog_slides_table_column_insert', { presentationId: 'p1', tableObjectId: 't1', col: 1, count: 2, right: true });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['slides', 'table', 'column', 'insert', 'p1', 't1', '--col=1', '--count=2', '--right'], { account: undefined });
+  });
+  it('bare', async () => {
+    await harness.callTool('gog_slides_table_column_insert', { presentationId: 'p1', tableObjectId: 't1', col: 0 });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['slides', 'table', 'column', 'insert', 'p1', 't1', '--col=0'], { account: undefined });
+  });
+});
+
+describe('gog_slides_table_column_delete', () => {
+  it('deletes by column index', async () => {
+    await harness.callTool('gog_slides_table_column_delete', { presentationId: 'p1', tableObjectId: 't1', col: 2 });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['slides', 'table', 'column', 'delete', 'p1', 't1', '--col=2', '--force'], { account: undefined });
+  });
+});
+
+describe('gog_slides_table_column_size', () => {
+  it('sets column width', async () => {
+    await harness.callTool('gog_slides_table_column_size', { presentationId: 'p1', tableObjectId: 't1', col: 1, width: 120 });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['slides', 'table', 'column', 'size', 'p1', 't1', '--col=1', '--width=120'], { account: undefined });
+  });
+});
+
+describe('gog_slides_table_row_insert', () => {
+  it('passes count and --below', async () => {
+    await harness.callTool('gog_slides_table_row_insert', { presentationId: 'p1', tableObjectId: 't1', row: 0, count: 1, below: true });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['slides', 'table', 'row', 'insert', 'p1', 't1', '--row=0', '--count=1', '--below'], { account: undefined });
+  });
+  it('bare', async () => {
+    await harness.callTool('gog_slides_table_row_insert', { presentationId: 'p1', tableObjectId: 't1', row: 1 });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['slides', 'table', 'row', 'insert', 'p1', 't1', '--row=1'], { account: undefined });
+  });
+});
+
+describe('gog_slides_table_row_delete', () => {
+  it('deletes by row index', async () => {
+    await harness.callTool('gog_slides_table_row_delete', { presentationId: 'p1', tableObjectId: 't1', row: 2 });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['slides', 'table', 'row', 'delete', 'p1', 't1', '--row=2', '--force'], { account: undefined });
+  });
+});
+
+describe('gog_slides_table_row_size', () => {
+  it('sets row min height', async () => {
+    await harness.callTool('gog_slides_table_row_size', { presentationId: 'p1', tableObjectId: 't1', row: 0, height: 40 });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['slides', 'table', 'row', 'size', 'p1', 't1', '--row=0', '--height=40'], { account: undefined });
+  });
+});
+
+describe('gog_slides_table_merge', () => {
+  it('passes span', async () => {
+    await harness.callTool('gog_slides_table_merge', { presentationId: 'p1', tableObjectId: 't1', row: 0, col: 0, rowSpan: 2, colSpan: 3 });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['slides', 'table', 'merge', 'p1', 't1', '--row=0', '--col=0', '--row-span=2', '--col-span=3'], { account: undefined });
+  });
+  it('minimal', async () => {
+    await harness.callTool('gog_slides_table_merge', { presentationId: 'p1', tableObjectId: 't1', row: 0, col: 0 });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['slides', 'table', 'merge', 'p1', 't1', '--row=0', '--col=0'], { account: undefined });
+  });
+});
+
+describe('gog_slides_table_unmerge', () => {
+  it('passes span', async () => {
+    await harness.callTool('gog_slides_table_unmerge', { presentationId: 'p1', tableObjectId: 't1', row: 0, col: 0, rowSpan: 2, colSpan: 2 });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['slides', 'table', 'unmerge', 'p1', 't1', '--row=0', '--col=0', '--row-span=2', '--col-span=2'], { account: undefined });
+  });
+  it('minimal', async () => {
+    await harness.callTool('gog_slides_table_unmerge', { presentationId: 'p1', tableObjectId: 't1', row: 1, col: 1 });
+    expect(lib.runOrDiagnose).toHaveBeenCalledWith(
+      ['slides', 'table', 'unmerge', 'p1', 't1', '--row=1', '--col=1'], { account: undefined });
+  });
+});