@mx-space/cli 0.14.2 → 0.15.1

package/dist/test/cli/project-crud.test.js

@@ -0,0 +1,315 @@
+import { Effect, Exit, Layer, Option } from 'effect';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { create as createProject } from '../../src/cli/project/create';
+import { del as deleteProject } from '../../src/cli/project/delete';
+import { edit as editProject } from '../../src/cli/project/edit';
+import { get as getProject } from '../../src/cli/project/get';
+import { list as listProject } from '../../src/cli/project/list';
+import { update as updateProject } from '../../src/cli/project/update';
+import { viewCmd as viewProject } from '../../src/cli/project/view-cmd';
+import { Api } from '../../src/services/Api';
+import { Editor } from '../../src/services/Editor';
+import { Renderer } from '../../src/services/Renderer';
+import { Resolver } from '../../src/services/Resolver';
+import { makeMemFs, TestFsLive, TestPathLive } from '../helper/test-fs';
+const rendererJson = {
+    json: true,
+    output: 'json',
+    quiet: false,
+    verbose: false,
+};
+const captureStdout = () => {
+    const data = [];
+    const orig = process.stdout.write.bind(process.stdout);
+    process.stdout.write = (s) => {
+        data.push(typeof s === 'string' ? s : s.toString());
+        return true;
+    };
+    return {
+        data,
+        restore: () => {
+            ;
+            process.stdout.write = orig;
+        },
+    };
+};
+const makeResolver = (id = '900000000000000001') => ({
+    resolveCategory: () => Effect.succeed('cat-id'),
+    resolveTopic: () => Effect.succeed('topic-id'),
+    resolveCategoryRefs: (refs) => Effect.succeed(refs),
+    resolvePostId: () => Effect.succeed('123456789012345'),
+    resolvePostReadPath: () => Effect.succeed('/posts/p/x'),
+    resolveNoteId: () => Effect.succeed('123456789012346'),
+    resolveCategoryId: () => Effect.succeed('cat-id'),
+    resolveProjectId: () => Effect.succeed(id),
+    invalidate: () => Effect.void,
+});
+const makeApi = (calls, responses = {}) => ({
+    request: (path, options) => Effect.sync(() => {
+        calls.push({ path, options });
+        return (responses[path] ?? {
+            id: '900000000000000001',
+            name: 'k',
+            description: 'd',
+        });
+    }),
+    raw: (path, options) => Effect.sync(() => {
+        calls.push({ path, options });
+        return responses[path] ?? { ok: true };
+    }),
+});
+const buildLayer = (calls, responses = {}, editor) => Layer.mergeAll(TestFsLive(makeMemFs()), TestPathLive, Layer.succeed(Api, makeApi(calls, responses)), Layer.succeed(Resolver, makeResolver()), Renderer.Default, ...(editor ? [Layer.succeed(Editor, editor)] : []));
+afterEach(() => {
+    vi.restoreAllMocks();
+});
+const none = () => Option.none();
+describe('project command handlers', () => {
+    it('lists projects with pagination flags', async () => {
+        const calls = [];
+        const stdout = captureStdout();
+        try {
+            const exit = await Effect.runPromiseExit(listProject
+                .handler({ page: Option.some(2), size: Option.some(20) })
+                .pipe(Effect.provide(buildLayer(calls)), Renderer.withOptions(rendererJson)));
+            expect(Exit.isSuccess(exit)).toBe(true);
+            expect(calls[0]).toMatchObject({
+                path: '/projects',
+                options: { query: { page: 2, size: 20 } },
+            });
+        }
+        finally {
+            stdout.restore();
+        }
+    });
+    it('gets a project by resolved id', async () => {
+        const calls = [];
+        const stdout = captureStdout();
+        try {
+            const exit = await Effect.runPromiseExit(getProject.handler({ nameOrId: 'kami' }).pipe(Effect.provide(buildLayer(calls)), Renderer.withOptions(rendererJson)));
+            expect(Exit.isSuccess(exit)).toBe(true);
+            expect(calls[0]).toMatchObject({
+                path: '/projects/900000000000000001',
+            });
+        }
+        finally {
+            stdout.restore();
+        }
+    });
+    it('renders a project view', async () => {
+        const calls = [];
+        const stdout = captureStdout();
+        try {
+            const exit = await Effect.runPromiseExit(viewProject.handler({ nameOrId: 'kami' }).pipe(Effect.provide(buildLayer(calls)), Renderer.withOptions(rendererJson)));
+            expect(Exit.isSuccess(exit)).toBe(true);
+        }
+        finally {
+            stdout.restore();
+        }
+    });
+    it('creates a project from flags', async () => {
+        const calls = [];
+        const stdout = captureStdout();
+        try {
+            const exit = await Effect.runPromiseExit(createProject
+                .handler({
+                name: Option.some('kami'),
+                description: Option.some('a stack'),
+                previewUrl: Option.some('https://kami.test'),
+                docUrl: none(),
+                projectUrl: none(),
+                avatar: none(),
+                images: Option.some('https://a, https://b'),
+                text: none(),
+                file: none(),
+                open: false,
+                silent: false,
+            })
+                .pipe(Effect.provide(buildLayer(calls)), Renderer.withOptions(rendererJson)));
+            expect(Exit.isSuccess(exit)).toBe(true);
+            expect(calls[0]).toMatchObject({
+                path: '/projects',
+                options: { method: 'POST' },
+            });
+            const body = calls[0].options.body;
+            expect(body).toMatchObject({
+                name: 'kami',
+                description: 'a stack',
+                previewUrl: 'https://kami.test',
+                images: ['https://a', 'https://b'],
+            });
+            expect(body.docUrl).toBeUndefined();
+        }
+        finally {
+            stdout.restore();
+        }
+    });
+    it('PATCHes via update with only supplied fields', async () => {
+        const calls = [];
+        const exit = await Effect.runPromiseExit(updateProject
+            .handler({
+            nameOrId: 'kami',
+            name: none(),
+            description: Option.some('updated'),
+            previewUrl: none(),
+            docUrl: none(),
+            projectUrl: none(),
+            avatar: none(),
+            images: none(),
+            text: none(),
+            file: none(),
+            open: false,
+            silent: true,
+        })
+            .pipe(Effect.provide(buildLayer(calls)), Renderer.withOptions(rendererJson)));
+        expect(Exit.isSuccess(exit)).toBe(true);
+        expect(calls[0]).toMatchObject({
+            path: '/projects/900000000000000001',
+            options: { method: 'PATCH' },
+        });
+        const body = calls[0].options.body;
+        expect(body).toEqual({ description: 'updated' });
+    });
+    it('deletes a project when --force is supplied', async () => {
+        const calls = [];
+        const stdout = captureStdout();
+        try {
+            const exit = await Effect.runPromiseExit(deleteProject
+                .handler({ nameOrId: 'kami', force: true })
+                .pipe(Effect.provide(buildLayer(calls)), Renderer.withOptions(rendererJson)));
+            expect(Exit.isSuccess(exit)).toBe(true);
+            expect(calls[0]).toMatchObject({
+                path: '/projects/900000000000000001',
+                options: { method: 'DELETE' },
+            });
+        }
+        finally {
+            stdout.restore();
+        }
+    });
+    it('refuses project delete without --force in non-TTY', async () => {
+        const descriptor = Object.getOwnPropertyDescriptor(process.stdin, 'isTTY');
+        Object.defineProperty(process.stdin, 'isTTY', {
+            configurable: true,
+            value: false,
+        });
+        try {
+            const exit = await Effect.runPromiseExit(deleteProject
+                .handler({ nameOrId: 'kami', force: false })
+                .pipe(Effect.provide(buildLayer([]))));
+            expect(Exit.isFailure(exit)).toBe(true);
+        }
+        finally {
+            if (descriptor)
+                Object.defineProperty(process.stdin, 'isTTY', descriptor);
+        }
+    });
+    it('edit: no-change exits without a PATCH', async () => {
+        const calls = [];
+        const responses = {
+            '/projects/900000000000000001': {
+                id: '900000000000000001',
+                name: 'kami',
+                description: 'k',
+                previewUrl: null,
+                docUrl: null,
+                projectUrl: null,
+                avatar: null,
+                images: null,
+                text: null,
+            },
+        };
+        const editor = {
+            openEditor: (opts) => Effect.succeed(opts.initialContent),
+            prompt: () => Effect.succeed(''),
+            confirm: () => Effect.succeed(true),
+            readFileOrStdin: () => Effect.succeed(''),
+        };
+        const stdout = captureStdout();
+        try {
+            const exit = await Effect.runPromiseExit(editProject
+                .handler({ nameOrId: 'kami', open: false, silent: false })
+                .pipe(Effect.provide(buildLayer(calls, responses, editor)), Renderer.withOptions(rendererJson)));
+            expect(Exit.isSuccess(exit)).toBe(true);
+            expect(calls).toHaveLength(1);
+            expect(calls[0].path).toBe('/projects/900000000000000001');
+        }
+        finally {
+            stdout.restore();
+        }
+    });
+    it('edit: round-trip change PATCHes parsed JSON', async () => {
+        const calls = [];
+        const responses = {
+            '/projects/900000000000000001': {
+                id: '900000000000000001',
+                name: 'kami',
+                description: 'k',
+                previewUrl: null,
+                docUrl: null,
+                projectUrl: null,
+                avatar: null,
+                images: null,
+                text: null,
+            },
+        };
+        const editor = {
+            openEditor: () => Effect.succeed(JSON.stringify({
+                name: 'kami',
+                description: 'renamed',
+                previewUrl: 'https://k.test',
+                docUrl: null,
+                projectUrl: null,
+                avatar: null,
+                images: null,
+                text: null,
+            }, null, 2)),
+            prompt: () => Effect.succeed(''),
+            confirm: () => Effect.succeed(true),
+            readFileOrStdin: () => Effect.succeed(''),
+        };
+        const exit = await Effect.runPromiseExit(editProject
+            .handler({ nameOrId: 'kami', open: false, silent: true })
+            .pipe(Effect.provide(buildLayer(calls, responses, editor)), Renderer.withOptions(rendererJson)));
+        expect(Exit.isSuccess(exit)).toBe(true);
+        expect(calls).toHaveLength(2);
+        expect(calls[1]).toMatchObject({
+            path: '/projects/900000000000000001',
+            options: { method: 'PATCH' },
+        });
+        const body = calls[1].options.body;
+        expect(body).toMatchObject({
+            description: 'renamed',
+            previewUrl: 'https://k.test',
+        });
+    });
+    it('edit: malformed JSON fails with ValidationJson', async () => {
+        const calls = [];
+        const responses = {
+            '/projects/900000000000000001': {
+                id: '900000000000000001',
+                name: 'kami',
+                description: 'k',
+                previewUrl: null,
+                docUrl: null,
+                projectUrl: null,
+                avatar: null,
+                images: null,
+                text: null,
+            },
+        };
+        const editor = {
+            openEditor: () => Effect.succeed('not json at all'),
+            prompt: () => Effect.succeed(''),
+            confirm: () => Effect.succeed(true),
+            readFileOrStdin: () => Effect.succeed(''),
+        };
+        const exit = await Effect.runPromiseExit(editProject
+            .handler({ nameOrId: 'kami', open: false, silent: false })
+            .pipe(Effect.provide(buildLayer(calls, responses, editor))));
+        expect(Exit.isFailure(exit)).toBe(true);
+        if (Exit.isFailure(exit)) {
+            const failure = exit.cause.toString();
+            expect(failure).toContain('ValidationJson');
+        }
+    });
+});

package/dist/test/cli/render/lexical.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/cli/render/lexical.test.js

@@ -0,0 +1,216 @@
+import { describe, expect, it } from 'vitest';
+import { renderLexicalAnsi } from '../../../src/cli/render/lexical';
+import { visibleLen } from '../../../src/cli/render/markdown';
+const plain = (xml) => renderLexicalAnsi(xml, { color: false });
+const styled = (xml) => renderLexicalAnsi(xml, { color: true });
+// `SEPARATOR_WIDTH` constant from `src/cli/render/helpers.ts`. Hard-coded
+// here so the test breaks loudly if the visual width changes (the renderer's
+// box-drawing depends on it).
+const RULE = '─'.repeat(64);
+describe('renderLexicalAnsi — blocks', () => {
+    it('renders a paragraph as its inline children', () => {
+        expect(plain('<p>hello world</p>')).toBe('hello world');
+    });
+    it('joins multiple paragraphs with a blank line', () => {
+        expect(plain('<p>a</p><p>b</p>')).toBe('a\n\nb');
+    });
+    it('drops pretty-print whitespace text nodes between blocks', () => {
+        expect(plain('<p>a</p>\n  <p>b</p>')).toBe('a\n\nb');
+    });
+    it('renders h1 with an underline rule sized to the title', () => {
+        expect(plain('<h1>Title</h1>')).toBe('Title\n─────');
+    });
+    it('renders h2 with an underline rule sized to the title', () => {
+        expect(plain('<h2>Sub</h2>')).toBe('Sub\n───');
+    });
+    it('renders h3-h6 as bold-only (no rule)', () => {
+        expect(plain('<h3>Three</h3>')).toBe('Three');
+        expect(plain('<h4>Four</h4>')).toBe('Four');
+        expect(plain('<h5>Five</h5>')).toBe('Five');
+        expect(plain('<h6>Six</h6>')).toBe('Six');
+    });
+    it('prefixes blockquote body lines with `| `', () => {
+        expect(plain('<blockquote><p>quoted</p></blockquote>')).toBe('│ quoted');
+    });
+    it('appends a blockquote attribution line', () => {
+        expect(plain('<blockquote attribution="Alice"><p>q</p></blockquote>')).toBe('│ q\n   — Alice');
+    });
+    it('emits only the attribution line for an empty quote body', () => {
+        expect(plain('<blockquote attribution="Alice"></blockquote>')).toBe('   — Alice');
+    });
+    it('renders <hr/> as a 64-wide dim rule', () => {
+        expect(plain('<hr/>')).toBe(RULE);
+    });
+    it('renders ul items with `- ` bullets', () => {
+        expect(plain('<ul><li>a</li><li>b</li></ul>')).toBe('- a\n- b');
+    });
+    it('renders ol items with right-aligned ordinals', () => {
+        expect(plain('<ol><li>a</li><li>b</li><li>c</li></ol>')).toBe('1. a\n2. b\n3. c');
+    });
+    it('renders checked list items with [x]/[ ] markers', () => {
+        expect(plain('<ul><li checked="true">done</li><li checked="false">todo</li></ul>')).toBe('[x] done\n[ ] todo');
+    });
+    it('indents nested lists by 2 spaces', () => {
+        expect(plain('<ul><li>a<ul><li>b</li></ul></li></ul>')).toBe('- a\n  - b');
+    });
+    it('keeps multi-paragraph li body aligned under the bullet', () => {
+        expect(plain('<ul><li><p>a</p><p>b</p></li></ul>')).toBe('- a\n  b');
+    });
+    it('renders a table header row in bold with a separator', () => {
+        expect(plain('<table><tr><th>A</th><th>B</th></tr><tr><td>1</td><td>2</td></tr></table>')).toBe('A │ B\n──┼──\n1 │ 2');
+    });
+    it('renders a table without a header (no rule)', () => {
+        expect(plain('<table><tr><td>1</td><td>2</td></tr></table>')).toBe('1 │ 2');
+    });
+    it('renders an alert as label + framed body', () => {
+        expect(plain('<alert type="warning"><p>watch out</p></alert>')).toBe(`WARNING\n${RULE}\n│ watch out\n${RULE}`);
+    });
+    it('defaults alert label to INFO when type is missing', () => {
+        expect(plain('<alert><p>hi</p></alert>')).toBe(`INFO\n${RULE}\n│ hi\n${RULE}`);
+    });
+    it('renders a banner with the same shape as alert', () => {
+        expect(plain('<banner type="info"><p>hi</p></banner>')).toBe(`INFO\n${RULE}\n│ hi\n${RULE}`);
+    });
+    it('renders details with a summary head and indented body', () => {
+        expect(plain('<details summary="more"><p>hidden</p></details>')).toBe('▸ more\n  hidden');
+    });
+    it('omits the body when details has no children', () => {
+        expect(plain('<details summary="empty"></details>')).toBe('▸ empty');
+    });
+    it('renders spoiler as dim text', () => {
+        expect(plain('<spoiler>secret</spoiler>')).toBe('secret');
+    });
+});
+describe('renderLexicalAnsi — inlines', () => {
+    it('returns plain text when color is off', () => {
+        expect(plain('<p><b>x</b></p>')).toBe('x');
+    });
+    it('wraps bold with bold open/close (color on)', () => {
+        expect(styled('<p><b>x</b></p>')).toBe('\x1B[1mx\x1B[22m');
+    });
+    it('survives nested format reset (italic inside bold)', () => {
+        expect(styled('<p><b>a <i>b</i> c</b></p>')).toBe('\x1B[1ma \x1B[3mb\x1B[23m c\x1B[22m');
+    });
+    it('uses the strike open/close pair', () => {
+        expect(styled('<p><s>x</s></p>')).toBe('\x1B[9mx\x1B[29m');
+    });
+    it('uses the underline open/close pair', () => {
+        expect(styled('<p><u>x</u></p>')).toBe('\x1B[4mx\x1B[24m');
+    });
+    it('uses dim for inline code', () => {
+        expect(styled('<p><code>x</code></p>')).toBe('\x1B[2mx\x1B[22m');
+    });
+    it('uses reverse-video for mark', () => {
+        expect(styled('<p><mark>x</mark></p>')).toBe('\x1B[7mx\x1B[27m');
+    });
+    it('renders sub and sup as dim (degraded for TTY)', () => {
+        expect(styled('<p><sub>2</sub><sup>3</sup></p>')).toBe('\x1B[2m2\x1B[22m\x1B[2m3\x1B[22m');
+    });
+    it('appends a visible href when link text differs from href', () => {
+        expect(plain('<p><a href="https://x.com">click</a></p>')).toBe('click (https://x.com)');
+    });
+    it('suppresses the href suffix when text already equals href', () => {
+        expect(plain('<p><a href="https://x.com">https://x.com</a></p>')).toBe('https://x.com');
+    });
+    it('renders <a> without href as just its text', () => {
+        expect(plain('<p><a>noref</a></p>')).toBe('noref');
+    });
+    it('renders <br/> as a newline', () => {
+        expect(plain('<p>line1<br/>line2</p>')).toBe('line1\nline2');
+    });
+    it('renders mention with @ prefix and display fallback', () => {
+        expect(plain('<p><mention handle="alice">Alice</mention></p>')).toBe('@Alice');
+        expect(plain('<p><mention handle="bob"></mention></p>')).toBe('@bob');
+    });
+    it('renders tag with # prefix', () => {
+        expect(plain('<p><tag>js</tag></p>')).toBe('#js');
+    });
+    it('renders comment as dim passthrough', () => {
+        expect(plain('<p><comment>aside</comment></p>')).toBe('aside');
+    });
+    it('renders footnote as [^ref]', () => {
+        expect(plain('<p><footnote ref="1"/></p>')).toBe('[^1]');
+    });
+    it('renders ruby with a dim (rt) suffix when present', () => {
+        expect(plain('<p><ruby rt="kanji">漢</ruby></p>')).toBe('漢 (kanji)');
+    });
+    it('renders ruby without rt as just the base', () => {
+        expect(plain('<p><ruby>漢</ruby></p>')).toBe('漢');
+    });
+});
+describe('renderLexicalAnsi — embeds', () => {
+    it('renders img with alt text as the label', () => {
+        expect(plain('<img alt="cat" src="/a/b/cat.png"/>')).toBe('[image: cat]');
+    });
+    it('falls back to the src basename when alt is absent', () => {
+        expect(plain('<img src="/path/img.png"/>')).toBe('[image: img.png]');
+    });
+    it('renders bare img as [image]', () => {
+        expect(plain('<img/>')).toBe('[image]');
+    });
+    it('appends a caption line when present', () => {
+        expect(plain('<img alt="x" src="y" caption="cap"/>')).toBe('[image: x]\ncap');
+    });
+    it('renders video with the src in the label', () => {
+        expect(plain('<video src="https://x/y.mp4"/>')).toBe('[video: https://x/y.mp4]');
+    });
+    it('renders link-card with title, description, and url', () => {
+        expect(plain('<link-card url="https://ex.com" title="T" description="D"/>')).toBe('┌ T\n│ D\n└ https://ex.com');
+    });
+    it('renders link-card without description (no middle line)', () => {
+        expect(plain('<link-card url="https://ex.com" title="T"/>')).toBe('┌ T\n└ https://ex.com');
+    });
+    it('renders link-card without title as a one-line [link: ...]', () => {
+        expect(plain('<link-card url="https://ex.com"/>')).toBe('[link: https://ex.com]');
+    });
+    it('renders embed with source prefix when source is set', () => {
+        expect(plain('<embed url="u" source="yt"/>')).toBe('[embed: yt u]');
+    });
+    it('renders embed without source as just the url', () => {
+        expect(plain('<embed url="u"/>')).toBe('[embed: u]');
+    });
+});
+describe('renderLexicalAnsi — codeblock', () => {
+    it('prepends a dim language label when lang is set', () => {
+        expect(plain('<codeblock lang="ts">const a = 1;</codeblock>')).toBe('ts\nconst a = 1;');
+    });
+    it('strips trailing newlines from the body', () => {
+        expect(plain('<codeblock lang="ts">const a = 1;\n\n</codeblock>')).toBe('ts\nconst a = 1;');
+    });
+    it('emits just the body when lang is absent', () => {
+        expect(plain('<codeblock>plain text</codeblock>')).toBe('plain text');
+    });
+});
+describe('renderLexicalAnsi — robustness', () => {
+    it('returns empty string for empty input', () => {
+        expect(plain('')).toBe('');
+    });
+    it('returns empty string for malformed XML (no throw)', () => {
+        expect(() => plain('<<<bad')).not.toThrow();
+        expect(plain('<<<bad')).toBe('');
+    });
+    it('falls back to rendering children of unknown tags', () => {
+        expect(plain('<unknown>fallback</unknown>')).toBe('fallback');
+        expect(plain('<unknown><p>nested</p></unknown>')).toBe('nested');
+    });
+    it('trims trailing newlines from the final output', () => {
+        // `renderLexicalAnsi` strips trailing newlines from the output as a
+        // post-processing step — exercise it via details which renders as
+        // `head\n  body` with no trailing newline of its own.
+        expect(plain('<details summary="x"><p>y</p></details>')).toBe('▸ x\n  y');
+    });
+});
+describe('renderLexicalAnsi — table alignment', () => {
+    it('keeps every row the same visible width with CJK columns', () => {
+        const xml = '<table>' +
+            '<tr><th>指标</th><th>Next.js</th><th>占优</th></tr>' +
+            '<tr><td>Performance</td><td>64</td><td>Remix</td></tr>' +
+            '<tr><td>FCP</td><td>3037 ms</td><td>Remix +19</td></tr>' +
+            '</table>';
+        const lines = plain(xml)
+            .split('\n')
+            .filter((line) => line.length > 0);
+        const widths = new Set(lines.map((line) => visibleLen(line)));
+        expect(widths.size).toBe(1);
+    });
+});

package/dist/test/cli/render/markdown.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/cli/render/markdown.test.js

@@ -0,0 +1,39 @@
+import { describe, expect, it } from 'vitest';
+import { renderMarkdownToAnsi, visibleLen, } from '../../../src/cli/render/markdown';
+describe('visibleLen', () => {
+    it('counts ASCII as one column each', () => {
+        expect(visibleLen('hello')).toBe(5);
+    });
+    it('counts CJK characters as two columns each', () => {
+        expect(visibleLen('中文')).toBe(4);
+        expect(visibleLen('指标')).toBe(4);
+    });
+    it('counts mixed CJK and ASCII by display width', () => {
+        expect(visibleLen('中a文')).toBe(5);
+    });
+    it('counts fullwidth punctuation as two columns', () => {
+        expect(visibleLen('（）')).toBe(4);
+    });
+    it('ignores ANSI escape sequences', () => {
+        const esc = String.fromCharCode(0x1b);
+        expect(visibleLen(`${esc}[1m中${esc}[0m`)).toBe(2);
+    });
+    it('counts an astral-plane CJK character as a single wide unit', () => {
+        expect(visibleLen('𠀀')).toBe(2);
+    });
+});
+describe('renderMarkdownToAnsi — table alignment', () => {
+    it('keeps every row the same visible width with CJK columns', () => {
+        const md = [
+            '| 指标 | Next.js | 占优 |',
+            '| --- | --- | --- |',
+            '| Performance | 64 | Remix |',
+            '| FCP | 3037 ms | Remix +19 |',
+        ].join('\n');
+        const lines = renderMarkdownToAnsi(md, { color: false })
+            .split('\n')
+            .filter((line) => line.length > 0);
+        const widths = new Set(lines.map((line) => visibleLen(line)));
+        expect(widths.size).toBe(1);
+    });
+});

package/dist/test/cli/snippet-crud.test.d.ts

@@ -0,0 +1 @@
+export {};