@codeyam/codeyam-cli 0.1.0-staging.ad88eeb → 0.1.0-staging.b147f46

package/codeyam-cli/src/utils/__tests__/scenariosManifest.test.js

@@ -1,246 +1,672 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import * as os from 'os';
-import { readManifest, writeManifest, addScenarioToManifest, removeScenarioFromManifest, buildManifestFromRows, syncManifestToDatabase, } from "../scenariosManifest.js";
+import { scanScenarioFiles, writeScenarioMetadata, writeScenarioDataFile, deleteScenarioFiles, syncScenarioFilesToDatabase, backfillScenarioMetadata, migrateScenarioFormats, } from "../scenariosManifest.js";
 function makeTmpDir() {
     return fs.mkdtempSync(path.join(os.tmpdir(), 'manifest-test-'));
 }
-function makeEntry(overrides = {}) {
+function makeMetadata(overrides = {}) {
     return {
-        id: 'test-id-1',
         name: 'Test Scenario',
         description: null,
         componentName: null,
         componentPath: null,
         url: '/',
-        mockDataFile: 'editor-scenarios/test-id-1.json',
-        screenshotFile: null,
+        type: 'application',
+        screenshotPath: null,
+        viewportWidth: null,
+        viewportHeight: null,
         createdAt: '2024-01-01T00:00:00.000Z',
         updatedAt: '2024-01-01T00:00:00.000Z',
         ...overrides,
     };
 }
-describe('scenariosManifest', () => {
-    describe('readManifest / writeManifest round-trip', () => {
-        it('should write and read back a manifest', () => {
-            const tmp = makeTmpDir();
-            const manifest = {
-                version: 1,
-                updatedAt: '2024-01-01T00:00:00.000Z',
-                scenarios: [makeEntry()],
-            };
-            writeManifest(tmp, manifest);
-            const result = readManifest(tmp);
-            expect(result).toEqual(manifest);
-        });
-        it('should return null for missing file', () => {
-            const tmp = makeTmpDir();
-            expect(readManifest(tmp)).toBeNull();
-        });
-    });
-    describe('addScenarioToManifest', () => {
-        it('should create manifest if none exists', () => {
-            const tmp = makeTmpDir();
-            const entry = makeEntry();
-            addScenarioToManifest(tmp, entry);
-            const manifest = readManifest(tmp);
-            expect(manifest).not.toBeNull();
-            expect(manifest.scenarios).toHaveLength(1);
-            expect(manifest.scenarios[0].id).toBe('test-id-1');
-        });
-        it('should append to existing manifest', () => {
-            const tmp = makeTmpDir();
-            addScenarioToManifest(tmp, makeEntry({ id: 'a', name: 'A' }));
-            addScenarioToManifest(tmp, makeEntry({ id: 'b', name: 'B' }));
-            const manifest = readManifest(tmp);
-            expect(manifest.scenarios).toHaveLength(2);
-        });
-        it('should deduplicate by id (update existing)', () => {
-            const tmp = makeTmpDir();
-            addScenarioToManifest(tmp, makeEntry({ id: 'a', name: 'Original' }));
-            addScenarioToManifest(tmp, makeEntry({ id: 'a', name: 'Updated' }));
-            const manifest = readManifest(tmp);
-            expect(manifest.scenarios).toHaveLength(1);
-            expect(manifest.scenarios[0].name).toBe('Updated');
-        });
-    });
-    describe('removeScenarioFromManifest', () => {
-        it('should remove a scenario by id', () => {
-            const tmp = makeTmpDir();
-            addScenarioToManifest(tmp, makeEntry({ id: 'a', name: 'A' }));
-            addScenarioToManifest(tmp, makeEntry({ id: 'b', name: 'B' }));
-            removeScenarioFromManifest(tmp, 'a');
-            const manifest = readManifest(tmp);
-            expect(manifest.scenarios).toHaveLength(1);
-            expect(manifest.scenarios[0].id).toBe('b');
-        });
-        it('should handle removing from nonexistent manifest', () => {
-            const tmp = makeTmpDir();
-            // Should not throw
-            removeScenarioFromManifest(tmp, 'nonexistent');
-        });
-        it('should handle removing nonexistent id', () => {
-            const tmp = makeTmpDir();
-            addScenarioToManifest(tmp, makeEntry({ id: 'a', name: 'A' }));
-            removeScenarioFromManifest(tmp, 'nonexistent');
-            const manifest = readManifest(tmp);
-            expect(manifest.scenarios).toHaveLength(1);
-        });
-    });
-    describe('buildManifestFromRows', () => {
-        it('should build manifest from database-like rows', () => {
-            const rows = [
-                {
-                    id: 'row-1',
-                    name: 'Scenario 1',
-                    description: 'A scenario',
-                    component_name: 'Button',
-                    component_path: 'app/components/Button.tsx',
-                    url: '/isolated-components/Button?s=Default',
-                    screenshot_path: 'screenshots/row-1.png',
-                    created_at: '2024-01-01 00:00:00',
-                    updated_at: '2024-01-02 00:00:00',
-                },
-                {
-                    id: 'row-2',
-                    name: 'Scenario 2',
-                    description: null,
-                    component_name: null,
-                    component_path: null,
-                    url: '/',
-                    screenshot_path: null,
-                    created_at: '2024-01-03 00:00:00',
-                    updated_at: '2024-01-03 00:00:00',
-                },
-            ];
-            const manifest = buildManifestFromRows(rows);
-            expect(manifest.version).toBe(1);
-            expect(manifest.scenarios).toHaveLength(2);
-            expect(manifest.scenarios[0]).toEqual({
-                id: 'row-1',
-                name: 'Scenario 1',
-                description: 'A scenario',
-                componentName: 'Button',
-                componentPath: 'app/components/Button.tsx',
-                url: '/isolated-components/Button?s=Default',
-                mockDataFile: 'editor-scenarios/row-1.json',
-                screenshotFile: 'editor-scenarios/screenshots/row-1.png',
-                createdAt: '2024-01-01 00:00:00',
-                updatedAt: '2024-01-02 00:00:00',
-            });
-            expect(manifest.scenarios[1].screenshotFile).toBeNull();
-        });
-        it('should handle empty rows', () => {
-            const manifest = buildManifestFromRows([]);
-            expect(manifest.scenarios).toEqual([]);
-        });
-    });
-    describe('syncManifestToDatabase', () => {
-        it('should insert missing scenarios', async () => {
-            const tmp = makeTmpDir();
-            const entry = makeEntry({ id: 'new-1', name: 'New Scenario' });
-            addScenarioToManifest(tmp, entry);
-            const existingRows = [];
-            const insertedRows = [];
-            const updatedRows = [];
-            const result = await syncManifestToDatabase(tmp, 'project-1', existingRows, (row) => {
-                insertedRows.push(row);
-            }, (id, row) => {
-                updatedRows.push({ id, ...row });
-            });
-            expect(result.inserted).toBe(1);
-            expect(result.updated).toBe(0);
-            expect(result.skipped).toBe(0);
-            expect(insertedRows).toHaveLength(1);
-            expect(insertedRows[0].id).toBe('new-1');
-            expect(insertedRows[0].project_id).toBe('project-1');
-        });
-        it('should skip scenarios already in DB with same updatedAt', async () => {
-            const tmp = makeTmpDir();
-            const entry = makeEntry({
-                id: 'existing-1',
-                name: 'Existing',
-                updatedAt: '2024-01-01T00:00:00.000Z',
-            });
-            addScenarioToManifest(tmp, entry);
-            const existingRows = [
-                { id: 'existing-1', updated_at: '2024-01-01T00:00:00.000Z' },
-            ];
-            const insertedRows = [];
-            const updatedRows = [];
-            const result = await syncManifestToDatabase(tmp, 'project-1', existingRows, (row) => {
-                insertedRows.push(row);
-            }, (id, row) => {
-                updatedRows.push({ id, ...row });
-            });
-            expect(result.inserted).toBe(0);
-            expect(result.updated).toBe(0);
-            expect(result.skipped).toBe(1);
-        });
-        it('should update scenarios newer than DB row', async () => {
-            const tmp = makeTmpDir();
-            const entry = makeEntry({
-                id: 'existing-1',
-                name: 'Updated Name',
-                updatedAt: '2024-02-01T00:00:00.000Z',
-            });
-            addScenarioToManifest(tmp, entry);
-            const existingRows = [
-                { id: 'existing-1', updated_at: '2024-01-01T00:00:00.000Z' },
-            ];
-            const insertedRows = [];
-            const updatedRows = [];
-            const result = await syncManifestToDatabase(tmp, 'project-1', existingRows, (row) => {
-                insertedRows.push(row);
-            }, (id, row) => {
-                updatedRows.push({ id, ...row });
-            });
-            expect(result.inserted).toBe(0);
-            expect(result.updated).toBe(1);
-            expect(result.skipped).toBe(0);
-            expect(updatedRows[0].name).toBe('Updated Name');
-        });
-        it('should handle empty manifest', async () => {
-            const tmp = makeTmpDir();
-            writeManifest(tmp, { version: 1, updatedAt: '', scenarios: [] });
-            const result = await syncManifestToDatabase(tmp, 'project-1', [], () => { }, () => { });
-            expect(result.inserted).toBe(0);
-            expect(result.updated).toBe(0);
-            expect(result.skipped).toBe(0);
-        });
-        it('should handle no manifest file', async () => {
-            const tmp = makeTmpDir();
-            const result = await syncManifestToDatabase(tmp, 'project-1', [], () => { }, () => { });
-            expect(result.inserted).toBe(0);
-            expect(result.updated).toBe(0);
-            expect(result.skipped).toBe(0);
-        });
-        it('should handle mixed insert/update/skip', async () => {
-            const tmp = makeTmpDir();
-            addScenarioToManifest(tmp, makeEntry({
-                id: 'new-1',
-                name: 'New',
-                updatedAt: '2024-01-01T00:00:00.000Z',
-            }));
-            addScenarioToManifest(tmp, makeEntry({
-                id: 'updated-1',
+function writeScenarioFile(tmp, id, data, metadata) {
+    const dir = path.join(tmp, '.codeyam', 'editor-scenarios');
+    fs.mkdirSync(dir, { recursive: true });
+    const content = metadata ? { _metadata: metadata, ...data } : data;
+    fs.writeFileSync(path.join(dir, `${id}.json`), JSON.stringify(content, null, 2));
+}
+// ─── scanScenarioFiles ────────────────────────────────────────────
+describe('scanScenarioFiles', () => {
+    it('should find scenario files with _metadata', () => {
+        const tmp = makeTmpDir();
+        writeScenarioFile(tmp, 'abc-123', { seed: {} }, makeMetadata({ name: 'Home Page' }));
+        writeScenarioFile(tmp, 'def-456', { seed: {} }, makeMetadata({ name: 'About Page' }));
+        const results = scanScenarioFiles(tmp);
+        expect(results).toHaveLength(2);
+        const names = results.map((r) => r.metadata.name).sort();
+        expect(names).toEqual(['About Page', 'Home Page']);
+    });
+    it('should skip files without _metadata', () => {
+        const tmp = makeTmpDir();
+        writeScenarioFile(tmp, 'with-meta', { seed: {} }, makeMetadata());
+        writeScenarioFile(tmp, 'no-meta', { seed: {} }); // no metadata
+        const results = scanScenarioFiles(tmp);
+        expect(results).toHaveLength(1);
+        expect(results[0].id).toBe('with-meta');
+    });
+    it('should skip .seed.json files', () => {
+        const tmp = makeTmpDir();
+        const dir = path.join(tmp, '.codeyam', 'editor-scenarios');
+        fs.mkdirSync(dir, { recursive: true });
+        writeScenarioFile(tmp, 'abc', { seed: {} }, makeMetadata());
+        // Write a .seed.json file that has _metadata (shouldn't happen but be safe)
+        fs.writeFileSync(path.join(dir, 'abc.seed.json'), JSON.stringify({ _metadata: makeMetadata() }));
+        const results = scanScenarioFiles(tmp);
+        expect(results).toHaveLength(1);
+        expect(results[0].id).toBe('abc');
+    });
+    it('should skip client-errors.json', () => {
+        const tmp = makeTmpDir();
+        const dir = path.join(tmp, '.codeyam', 'editor-scenarios');
+        fs.mkdirSync(dir, { recursive: true });
+        writeScenarioFile(tmp, 'abc', { seed: {} }, makeMetadata());
+        fs.writeFileSync(path.join(dir, 'client-errors.json'), JSON.stringify({ _metadata: makeMetadata() }));
+        const results = scanScenarioFiles(tmp);
+        expect(results).toHaveLength(1);
+    });
+    it('should return empty array for missing directory', () => {
+        const tmp = makeTmpDir();
+        expect(scanScenarioFiles(tmp)).toEqual([]);
+    });
+    it('should extract id from filename', () => {
+        const tmp = makeTmpDir();
+        writeScenarioFile(tmp, 'my-uuid-here', { seed: {} }, makeMetadata());
+        const results = scanScenarioFiles(tmp);
+        expect(results[0].id).toBe('my-uuid-here');
+    });
+});
+// ─── writeScenarioMetadata ────────────────────────────────────────
+describe('writeScenarioMetadata', () => {
+    it('should add _metadata to existing scenario file', () => {
+        const tmp = makeTmpDir();
+        writeScenarioFile(tmp, 'abc', { type: 'application', seed: { users: [] } });
+        writeScenarioMetadata(tmp, 'abc', makeMetadata({ name: 'Updated' }));
+        const filePath = path.join(tmp, '.codeyam', 'editor-scenarios', 'abc.json');
+        const content = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+        expect(content._metadata.name).toBe('Updated');
+        expect(content.type).toBe('application'); // original data preserved
+        expect(content.seed).toEqual({ users: [] }); // original data preserved
+    });
+    it('should update existing _metadata', () => {
+        const tmp = makeTmpDir();
+        writeScenarioFile(tmp, 'abc', { seed: {} }, makeMetadata({ name: 'Old' }));
+        writeScenarioMetadata(tmp, 'abc', makeMetadata({ name: 'New' }));
+        const filePath = path.join(tmp, '.codeyam', 'editor-scenarios', 'abc.json');
+        const content = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+        expect(content._metadata.name).toBe('New');
+    });
+    it('should not create file if it does not exist', () => {
+        const tmp = makeTmpDir();
+        writeScenarioMetadata(tmp, 'nonexistent', makeMetadata());
+        const filePath = path.join(tmp, '.codeyam', 'editor-scenarios', 'nonexistent.json');
+        expect(fs.existsSync(filePath)).toBe(false);
+    });
+});
+// ─── deleteScenarioFiles ──────────────────────────────────────────
+describe('deleteScenarioFiles', () => {
+    it('should delete both .json and .seed.json', () => {
+        const tmp = makeTmpDir();
+        const dir = path.join(tmp, '.codeyam', 'editor-scenarios');
+        fs.mkdirSync(dir, { recursive: true });
+        fs.writeFileSync(path.join(dir, 'abc.json'), '{}');
+        fs.writeFileSync(path.join(dir, 'abc.seed.json'), '{}');
+        deleteScenarioFiles(tmp, 'abc');
+        expect(fs.existsSync(path.join(dir, 'abc.json'))).toBe(false);
+        expect(fs.existsSync(path.join(dir, 'abc.seed.json'))).toBe(false);
+    });
+    it('should not throw for missing files', () => {
+        const tmp = makeTmpDir();
+        expect(() => deleteScenarioFiles(tmp, 'nonexistent')).not.toThrow();
+    });
+});
+// ─── backfillScenarioMetadata ─────────────────────────────────────
+describe('backfillScenarioMetadata', () => {
+    it('should add _metadata to files that lack it', () => {
+        const tmp = makeTmpDir();
+        // Write a file WITHOUT _metadata (legacy)
+        writeScenarioFile(tmp, 'abc-123', {
+            type: 'application',
+            seed: { users: [] },
+        });
+        const updated = backfillScenarioMetadata(tmp, [
+            {
+                id: 'abc-123',
+                name: 'Home Page',
+                description: 'Default view',
+                component_name: null,
+                component_path: null,
+                url: '/',
+                type: 'application',
+                created_at: '2024-01-01T00:00:00.000Z',
+                updated_at: '2024-01-02T00:00:00.000Z',
+            },
+        ]);
+        expect(updated).toBe(1);
+        // Verify _metadata was written
+        const filePath = path.join(tmp, '.codeyam', 'editor-scenarios', 'abc-123.json');
+        const content = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+        expect(content._metadata.name).toBe('Home Page');
+        expect(content._metadata.url).toBe('/');
+        // Original data preserved
+        expect(content.type).toBe('application');
+        expect(content.seed).toEqual({ users: [] });
+    });
+    it('should skip files that already have _metadata', () => {
+        const tmp = makeTmpDir();
+        writeScenarioFile(tmp, 'abc-123', { seed: {} }, makeMetadata({ name: 'Existing' }));
+        const updated = backfillScenarioMetadata(tmp, [
+            {
+                id: 'abc-123',
+                name: 'From DB',
+                description: null,
+                component_name: null,
+                component_path: null,
+                url: '/',
+                type: 'application',
+                created_at: '2024-01-01T00:00:00.000Z',
+                updated_at: '2024-01-01T00:00:00.000Z',
+            },
+        ]);
+        expect(updated).toBe(0);
+        // Verify original _metadata preserved
+        const filePath = path.join(tmp, '.codeyam', 'editor-scenarios', 'abc-123.json');
+        const content = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+        expect(content._metadata.name).toBe('Existing');
+    });
+    it('should skip DB rows with no matching file', () => {
+        const tmp = makeTmpDir();
+        const dir = path.join(tmp, '.codeyam', 'editor-scenarios');
+        fs.mkdirSync(dir, { recursive: true });
+        const updated = backfillScenarioMetadata(tmp, [
+            {
+                id: 'nonexistent',
+                name: 'Ghost',
+                description: null,
+                component_name: null,
+                component_path: null,
+                url: '/',
+                type: null,
+                created_at: '2024-01-01T00:00:00.000Z',
+                updated_at: '2024-01-01T00:00:00.000Z',
+            },
+        ]);
+        expect(updated).toBe(0);
+    });
+    it('should preserve dimensions, screenshotPaths, and pageFilePath from DB rows', () => {
+        const tmp = makeTmpDir();
+        writeScenarioFile(tmp, 'dim-1', {
+            type: 'application',
+            seed: { items: [] },
+        });
+        const updated = backfillScenarioMetadata(tmp, [
+            {
+                id: 'dim-1',
+                name: 'Multi-Dimension',
+                description: null,
+                component_name: 'Dashboard',
+                component_path: 'app/components/Dashboard.tsx',
+                url: '/',
+                type: 'application',
+                screenshot_path: 'screenshots/dim-1.png',
+                viewport_width: 1440,
+                viewport_height: 900,
+                dimensions: JSON.stringify(['Desktop', 'Mobile']),
+                screenshot_paths: JSON.stringify({
+                    Desktop: 'screenshots/dim-1.png',
+                    Mobile: 'screenshots/dim-1-mobile.png',
+                }),
+                page_file_path: 'app/page.tsx',
+                created_at: '2024-01-01T00:00:00.000Z',
+                updated_at: '2024-01-02T00:00:00.000Z',
+            },
+        ]);
+        expect(updated).toBe(1);
+        const filePath = path.join(tmp, '.codeyam', 'editor-scenarios', 'dim-1.json');
+        const content = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+        expect(content._metadata.dimensions).toEqual(['Desktop', 'Mobile']);
+        expect(content._metadata.screenshotPaths).toEqual({
+            Desktop: 'screenshots/dim-1.png',
+            Mobile: 'screenshots/dim-1-mobile.png',
+        });
+        expect(content._metadata.pageFilePath).toBe('app/page.tsx');
+    });
+    it('should handle mix of files with and without _metadata', () => {
+        const tmp = makeTmpDir();
+        writeScenarioFile(tmp, 'has-meta', { seed: {} }, makeMetadata());
+        writeScenarioFile(tmp, 'no-meta', { type: 'application', seed: {} });
+        const updated = backfillScenarioMetadata(tmp, [
+            {
+                id: 'has-meta',
+                name: 'A',
+                description: null,
+                component_name: null,
+                component_path: null,
+                url: '/',
+                type: null,
+                created_at: '2024-01-01T00:00:00.000Z',
+                updated_at: '2024-01-01T00:00:00.000Z',
+            },
+            {
+                id: 'no-meta',
+                name: 'B',
+                description: null,
+                component_name: null,
+                component_path: null,
+                url: '/about',
+                type: 'application',
+                created_at: '2024-01-01T00:00:00.000Z',
+                updated_at: '2024-01-01T00:00:00.000Z',
+            },
+        ]);
+        expect(updated).toBe(1); // Only no-meta was updated
+    });
+});
+// ─── syncScenarioFilesToDatabase ──────────────────────────────────
+describe('syncScenarioFilesToDatabase', () => {
+    it('should insert scenarios from _metadata files', async () => {
+        const tmp = makeTmpDir();
+        writeScenarioFile(tmp, 'new-1', { seed: {} }, makeMetadata({ name: 'New Scenario' }));
+        const insertedRows = [];
+        const result = await syncScenarioFilesToDatabase(tmp, 'project-1', [], (row) => {
+            insertedRows.push(row);
+        }, () => { });
+        expect(result.inserted).toBe(1);
+        expect(insertedRows[0].id).toBe('new-1');
+        expect(insertedRows[0].name).toBe('New Scenario');
+        expect(insertedRows[0].project_id).toBe('project-1');
+        expect(insertedRows[0].type).toBe('application');
+    });
+    it('should sync type, screenshot_path, and viewport from _metadata', async () => {
+        const tmp = makeTmpDir();
+        writeScenarioFile(tmp, 'full-1', { seed: {} }, makeMetadata({
+            name: 'Full Scenario',
+            type: 'user',
+            screenshotPath: 'screenshots/full-1.png',
+            viewportWidth: 1280,
+            viewportHeight: 720,
+        }));
+        const insertedRows = [];
+        await syncScenarioFilesToDatabase(tmp, 'project-1', [], (row) => {
+            insertedRows.push(row);
+        }, () => { });
+        expect(insertedRows[0].type).toBe('user');
+        expect(insertedRows[0].screenshot_path).toBe('screenshots/full-1.png');
+        expect(insertedRows[0].viewport_width).toBe(1280);
+        expect(insertedRows[0].viewport_height).toBe(720);
+    });
+    it('should skip scenarios already in DB with same updatedAt', async () => {
+        const tmp = makeTmpDir();
+        writeScenarioFile(tmp, 'existing-1', { seed: {} }, makeMetadata({ updatedAt: '2024-01-01T00:00:00.000Z' }));
+        const result = await syncScenarioFilesToDatabase(tmp, 'project-1', [{ id: 'existing-1', updated_at: '2024-01-01T00:00:00.000Z' }], () => { }, () => { });
+        expect(result.skipped).toBe(1);
+        expect(result.inserted).toBe(0);
+        expect(result.updated).toBe(0);
+    });
+    it('should update scenarios newer than DB row', async () => {
+        const tmp = makeTmpDir();
+        writeScenarioFile(tmp, 'existing-1', { seed: {} }, makeMetadata({ name: 'Updated', updatedAt: '2024-02-01T00:00:00.000Z' }));
+        const updatedRows = [];
+        const result = await syncScenarioFilesToDatabase(tmp, 'project-1', [{ id: 'existing-1', updated_at: '2024-01-01T00:00:00.000Z' }], () => { }, (id, row) => {
+            updatedRows.push({ id, ...row });
+        });
+        expect(result.updated).toBe(1);
+        expect(updatedRows[0].name).toBe('Updated');
+    });
+    it('should handle empty directory', async () => {
+        const tmp = makeTmpDir();
+        const dir = path.join(tmp, '.codeyam', 'editor-scenarios');
+        fs.mkdirSync(dir, { recursive: true });
+        const result = await syncScenarioFilesToDatabase(tmp, 'project-1', [], () => { }, () => { });
+        expect(result.inserted).toBe(0);
+    });
+    it('should handle mixed insert/update/skip', async () => {
+        const tmp = makeTmpDir();
+        writeScenarioFile(tmp, 'new-1', { seed: {} }, makeMetadata({ name: 'New', updatedAt: '2024-01-01T00:00:00.000Z' }));
+        writeScenarioFile(tmp, 'updated-1', { seed: {} }, makeMetadata({ name: 'Updated', updatedAt: '2024-02-01T00:00:00.000Z' }));
+        writeScenarioFile(tmp, 'current-1', { seed: {} }, makeMetadata({ name: 'Current', updatedAt: '2024-01-01T00:00:00.000Z' }));
+        const result = await syncScenarioFilesToDatabase(tmp, 'project-1', [
+            { id: 'updated-1', updated_at: '2024-01-01T00:00:00.000Z' },
+            { id: 'current-1', updated_at: '2024-01-01T00:00:00.000Z' },
+        ], () => { }, () => { });
+        expect(result.inserted).toBe(1);
+        expect(result.updated).toBe(1);
+        expect(result.skipped).toBe(1);
+    });
+    it('should pass entitySha and displayName from JSON _metadata on insert', async () => {
+        const tmp = makeTmpDir();
+        writeScenarioFile(tmp, 'with-entity', { seed: {} }, {
+            ...makeMetadata({ name: 'With Entity', componentName: 'MyComponent' }),
+            entitySha: 'abc123sha',
+            displayName: 'MyComponent',
+        });
+        const insertedRows = [];
+        await syncScenarioFilesToDatabase(tmp, 'project-1', [], (row) => {
+            insertedRows.push(row);
+        }, () => { });
+        expect(insertedRows[0].entity_sha).toBe('abc123sha');
+        expect(insertedRows[0].display_name).toBe('MyComponent');
+    });
+    it('should pass entitySha and displayName from JSON _metadata on update', async () => {
+        const tmp = makeTmpDir();
+        writeScenarioFile(tmp, 'existing-1', { seed: {} }, {
+            ...makeMetadata({
                 name: 'Updated',
                 updatedAt: '2024-02-01T00:00:00.000Z',
-            }));
-            addScenarioToManifest(tmp, makeEntry({
-                id: 'current-1',
-                name: 'Current',
-                updatedAt: '2024-01-01T00:00:00.000Z',
-            }));
-            const existingRows = [
-                { id: 'updated-1', updated_at: '2024-01-01T00:00:00.000Z' },
-                { id: 'current-1', updated_at: '2024-01-01T00:00:00.000Z' },
-            ];
-            const result = await syncManifestToDatabase(tmp, 'project-1', existingRows, () => { }, () => { });
-            expect(result.inserted).toBe(1);
-            expect(result.updated).toBe(1);
-            expect(result.skipped).toBe(1);
+            }),
+            entitySha: 'def456sha',
+            displayName: 'UpdatedComponent',
+        });
+        const updatedRows = [];
+        await syncScenarioFilesToDatabase(tmp, 'project-1', [{ id: 'existing-1', updated_at: '2024-01-01T00:00:00.000Z' }], () => { }, (id, row) => {
+            updatedRows.push({ id, ...row });
+        });
+        expect(updatedRows[0].entity_sha).toBe('def456sha');
+        expect(updatedRows[0].display_name).toBe('UpdatedComponent');
+    });
+    it('should pass null entitySha and displayName when missing from JSON', async () => {
+        const tmp = makeTmpDir();
+        writeScenarioFile(tmp, 'no-entity', { seed: {} }, makeMetadata({ name: 'No Entity' }));
+        const insertedRows = [];
+        await syncScenarioFilesToDatabase(tmp, 'project-1', [], (row) => {
+            insertedRows.push(row);
+        }, () => { });
+        expect(insertedRows[0].entity_sha).toBeNull();
+        expect(insertedRows[0].display_name).toBeNull();
+    });
+});
+// ─── migrateScenarioFormats ──────────────────────────────────────
+describe('migrateScenarioFormats', () => {
+    function writeConfigWithSizes(tmp, screenSizes, defaultScreenSize) {
+        const dir = path.join(tmp, '.codeyam');
+        fs.mkdirSync(dir, { recursive: true });
+        fs.writeFileSync(path.join(dir, 'config.json'), JSON.stringify({
+            ...(defaultScreenSize ? { defaultScreenSize } : {}),
+            ...(Object.keys(screenSizes).length > 0 ? { screenSizes } : {}),
+        }));
+    }
+    it('should resolve null viewport using project defaultScreenSize', () => {
+        const tmp = makeTmpDir();
+        writeConfigWithSizes(tmp, { Desktop: { width: 1440, height: 900 } }, { name: 'Desktop', width: 1440, height: 900 });
+        writeScenarioFile(tmp, 'null-vp', { seed: {} }, makeMetadata({
+            name: 'Home Page',
+            viewportWidth: null,
+            viewportHeight: null,
+        }));
+        const result = migrateScenarioFormats(tmp);
+        expect(result.fixed).toBe(1);
+        const filePath = path.join(tmp, '.codeyam', 'editor-scenarios', 'null-vp.json');
+        const content = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+        expect(content._metadata.viewportWidth).toBe(1440);
+        expect(content._metadata.viewportHeight).toBe(900);
+    });
+    it('should wrap single dimension into dimensions array', () => {
+        const tmp = makeTmpDir();
+        writeConfigWithSizes(tmp, { Mobile: { width: 375, height: 667 } });
+        writeScenarioFile(tmp, 'single-dim', { seed: {} }, makeMetadata({
+            name: 'Mobile View',
+            dimension: 'Mobile',
+            viewportWidth: 375,
+            viewportHeight: 667,
+        }));
+        const result = migrateScenarioFormats(tmp);
+        expect(result.fixed).toBe(1);
+        const filePath = path.join(tmp, '.codeyam', 'editor-scenarios', 'single-dim.json');
+        const content = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+        expect(content._metadata.dimensions).toEqual(['Mobile']);
+        // Legacy dimension property should be stripped
+        expect(content._metadata.dimension).toBeUndefined();
+    });
+    it('should build screenshotPaths from single screenshotPath + dimension', () => {
+        const tmp = makeTmpDir();
+        writeConfigWithSizes(tmp, { Desktop: { width: 1440, height: 900 } });
+        writeScenarioFile(tmp, 'single-ss', { seed: {} }, makeMetadata({
+            name: 'Dashboard',
+            dimension: 'Desktop',
+            screenshotPath: 'screenshots/single-ss.png',
+            viewportWidth: 1440,
+            viewportHeight: 900,
+        }));
+        const result = migrateScenarioFormats(tmp);
+        expect(result.fixed).toBe(1);
+        const filePath = path.join(tmp, '.codeyam', 'editor-scenarios', 'single-ss.json');
+        const content = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+        expect(content._metadata.screenshotPaths).toEqual({
+            Desktop: 'screenshots/single-ss.png',
+        });
+    });
+    it('should skip files that are already in the correct format', () => {
+        const tmp = makeTmpDir();
+        writeConfigWithSizes(tmp, { Desktop: { width: 1440, height: 900 } });
+        writeScenarioFile(tmp, 'good-fmt', { seed: {} }, makeMetadata({
+            name: 'Good Scenario',
+            viewportWidth: 1440,
+            viewportHeight: 900,
+            dimensions: ['Desktop'],
+            screenshotPaths: { Desktop: 'screenshots/good-fmt.png' },
+            screenshotPath: 'screenshots/good-fmt.png',
+        }));
+        const result = migrateScenarioFormats(tmp);
+        expect(result.fixed).toBe(0);
+        expect(result.scanned).toBe(1);
+    });
+    it('should fix multiple issues in a single file', () => {
+        const tmp = makeTmpDir();
+        writeConfigWithSizes(tmp, { Tablet: { width: 768, height: 1024 } }, { name: 'Tablet', width: 768, height: 1024 });
+        // File has null viewport, dimension set but no dimensions array, screenshotPath but no map
+        writeScenarioFile(tmp, 'multi-fix', { seed: {} }, makeMetadata({
+            name: 'Tablet View',
+            dimension: 'Tablet',
+            viewportWidth: null,
+            viewportHeight: null,
+            screenshotPath: 'screenshots/multi-fix.png',
+        }));
+        const result = migrateScenarioFormats(tmp);
+        expect(result.fixed).toBe(1);
+        const filePath = path.join(tmp, '.codeyam', 'editor-scenarios', 'multi-fix.json');
+        const content = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+        // Null viewport resolved via dimension name lookup
+        expect(content._metadata.viewportWidth).toBe(768);
+        expect(content._metadata.viewportHeight).toBe(1024);
+        // dimensions array created from single dimension
+        expect(content._metadata.dimensions).toEqual(['Tablet']);
+        // screenshotPaths map created from single screenshotPath
+        expect(content._metadata.screenshotPaths).toEqual({
+            Tablet: 'screenshots/multi-fix.png',
+        });
+    });
+    it('should use hardcoded fallback (1280x720) when no project config exists', () => {
+        const tmp = makeTmpDir();
+        // No config.json at all
+        writeScenarioFile(tmp, 'no-config', { seed: {} }, makeMetadata({
+            name: 'Bare Scenario',
+            viewportWidth: null,
+            viewportHeight: null,
+        }));
+        const result = migrateScenarioFormats(tmp);
+        expect(result.fixed).toBe(1);
+        const filePath = path.join(tmp, '.codeyam', 'editor-scenarios', 'no-config.json');
+        const content = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+        expect(content._metadata.viewportWidth).toBe(1280);
+        expect(content._metadata.viewportHeight).toBe(720);
+    });
+    it('should handle empty scenarios directory', () => {
+        const tmp = makeTmpDir();
+        const dir = path.join(tmp, '.codeyam', 'editor-scenarios');
+        fs.mkdirSync(dir, { recursive: true });
+        const result = migrateScenarioFormats(tmp);
+        expect(result.scanned).toBe(0);
+        expect(result.fixed).toBe(0);
+    });
+    it('should handle missing scenarios directory', () => {
+        const tmp = makeTmpDir();
+        const result = migrateScenarioFormats(tmp);
+        expect(result.scanned).toBe(0);
+        expect(result.fixed).toBe(0);
+    });
+    it('should preserve all non-metadata data in the file', () => {
+        const tmp = makeTmpDir();
+        writeConfigWithSizes(tmp, {}, { name: 'Desktop', width: 1440, height: 900 });
+        // Write file with extra data alongside _metadata
+        const dir = path.join(tmp, '.codeyam', 'editor-scenarios');
+        fs.mkdirSync(dir, { recursive: true });
+        const fileContent = {
+            _metadata: makeMetadata({
+                name: 'With Data',
+                viewportWidth: null,
+                viewportHeight: null,
+            }),
+            type: 'application',
+            seed: { users: [{ id: 1, name: 'Alice' }] },
+            session: { cookieValue: 'abc123' },
+        };
+        fs.writeFileSync(path.join(dir, 'with-data.json'), JSON.stringify(fileContent, null, 2));
+        migrateScenarioFormats(tmp);
+        const content = JSON.parse(fs.readFileSync(path.join(dir, 'with-data.json'), 'utf8'));
+        expect(content.type).toBe('application');
+        expect(content.seed).toEqual({ users: [{ id: 1, name: 'Alice' }] });
+        expect(content.session).toEqual({ cookieValue: 'abc123' });
+        // And metadata was fixed
+        expect(content._metadata.viewportWidth).toBe(1440);
+    });
+});
+// ─── writeScenarioDataFile ───────────────────────────────────────
+function readScenarioJson(tmp, id) {
+    return JSON.parse(fs.readFileSync(path.join(tmp, '.codeyam', 'editor-scenarios', `${id}.json`), 'utf8'));
+}
+describe('writeScenarioDataFile', () => {
+    it('should create new file with metadata and data when no existing file', () => {
+        const tmp = makeTmpDir();
+        const dir = path.join(tmp, '.codeyam', 'editor-scenarios');
+        fs.mkdirSync(dir, { recursive: true });
+        const metadata = makeMetadata({ name: 'Library - Rich Data' });
+        writeScenarioDataFile(tmp, 'new-scenario', metadata, {
+            type: 'application',
+            seed: { user: [{ id: 1, name: 'Alice' }] },
+        });
+        const content = readScenarioJson(tmp, 'new-scenario');
+        expect(content._metadata.name).toBe('Library - Rich Data');
+        expect(content.type).toBe('application');
+        expect(content.seed).toEqual({ user: [{ id: 1, name: 'Alice' }] });
+    });
+    it('should preserve existing seed data when re-registering without seed', () => {
+        const tmp = makeTmpDir();
+        // Create scenario with seed data (as if previously registered with seed)
+        writeScenarioFile(tmp, 'app-scenario', {
+            type: 'application',
+            seed: { article: [{ id: 1, title: 'Climate Report' }] },
+            externalApis: { 'GET /api/weather': { body: { temp: 72 } } },
+        }, makeMetadata({ name: 'Library - Rich Data' }));
+        // Re-register without seed (simulating Claude re-registering after code change)
+        const newMetadata = makeMetadata({
+            name: 'Library - Rich Data',
+            updatedAt: '2024-02-01T00:00:00.000Z',
+        });
+        writeScenarioDataFile(tmp, 'app-scenario', newMetadata, {});
+        const content = readScenarioJson(tmp, 'app-scenario');
+        // Metadata should be updated
+        expect(content._metadata.updatedAt).toBe('2024-02-01T00:00:00.000Z');
+        // Existing data fields should be preserved
+        expect(content.type).toBe('application');
+        expect(content.seed).toEqual({
+            article: [{ id: 1, title: 'Climate Report' }],
+        });
+        expect(content.externalApis).toEqual({
+            'GET /api/weather': { body: { temp: 72 } },
+        });
+    });
+    it('should preserve sessionCookies when updating seed', () => {
+        const tmp = makeTmpDir();
+        // Scenario with seed + sessionCookies (set by seed adapter after auth)
+        writeScenarioFile(tmp, 'auth-scenario', {
+            type: 'application',
+            seed: { user: [{ id: 1, email: 'alice@example.com' }] },
+            sessionCookies: [{ name: 'session', value: 'abc123' }],
+        }, makeMetadata({ name: 'Logged In User' }));
+        // Re-register with updated seed but no sessionCookies in the override
+        writeScenarioDataFile(tmp, 'auth-scenario', makeMetadata({ name: 'Logged In User' }), {
+            type: 'application',
+            seed: { user: [{ id: 1, email: 'bob@example.com' }] },
+        });
+        const content = readScenarioJson(tmp, 'auth-scenario');
+        // Seed should be updated
+        expect(content.seed).toEqual({
+            user: [{ id: 1, email: 'bob@example.com' }],
+        });
+        // Session cookies should be preserved (not overwritten)
+        expect(content.sessionCookies).toEqual([
+            { name: 'session', value: 'abc123' },
+        ]);
+    });
+    it('should overwrite fields that are explicitly provided', () => {
+        const tmp = makeTmpDir();
+        writeScenarioFile(tmp, 'update-scenario', {
+            type: 'application',
+            seed: { user: [{ id: 1 }] },
+            localStorage: { theme: 'dark' },
+        }, makeMetadata({ name: 'Old Name' }));
+        writeScenarioDataFile(tmp, 'update-scenario', makeMetadata({ name: 'New Name' }), {
+            seed: { user: [{ id: 1 }, { id: 2 }] },
+            localStorage: { theme: 'light', lang: 'en' },
         });
+        const content = readScenarioJson(tmp, 'update-scenario');
+        expect(content._metadata.name).toBe('New Name');
+        expect(content.seed).toEqual({ user: [{ id: 1 }, { id: 2 }] });
+        expect(content.localStorage).toEqual({ theme: 'light', lang: 'en' });
+        // type was not in overrides, should be preserved
+        expect(content.type).toBe('application');
+    });
+    it('should handle component scenarios with mockData spread at top level', () => {
+        const tmp = makeTmpDir();
+        const dir = path.join(tmp, '.codeyam', 'editor-scenarios');
+        fs.mkdirSync(dir, { recursive: true });
+        writeScenarioDataFile(tmp, 'comp-scenario', makeMetadata({
+            name: 'TaskCard - Default',
+            type: 'component',
+            componentName: 'TaskCard',
+        }), {
+            props: { title: 'My Task', done: false },
+            localStorage: { settings: '{}' },
+        });
+        const content = readScenarioJson(tmp, 'comp-scenario');
+        expect(content.props).toEqual({ title: 'My Task', done: false });
+        expect(content.localStorage).toEqual({ settings: '{}' });
+    });
+    it('should create directories if they do not exist', () => {
+        const tmp = makeTmpDir();
+        // No .codeyam/editor-scenarios/ yet
+        writeScenarioDataFile(tmp, 'first-scenario', makeMetadata({ name: 'First' }), { type: 'application' });
+        const filePath = path.join(tmp, '.codeyam', 'editor-scenarios', 'first-scenario.json');
+        expect(fs.existsSync(filePath)).toBe(true);
+        const content = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+        expect(content.type).toBe('application');
+    });
+    it('should preserve existing fields from all scenario data categories', () => {
+        const tmp = makeTmpDir();
+        // Scenario with every possible field populated
+        writeScenarioFile(tmp, 'full-scenario', {
+            type: 'application',
+            seed: { items: [{ id: 1 }] },
+            externalApis: { 'GET /weather': { body: {} } },
+            session: { cookieValue: 'sess123' },
+            auth: { email: 'a@b.com', password: 'pass' },
+            localStorage: { key: 'val' },
+            sessionCookies: [{ name: 'tok', value: 'xyz' }],
+        }, makeMetadata({ name: 'Full Scenario' }));
+        // Re-register with ONLY metadata update (no data overrides at all)
+        writeScenarioDataFile(tmp, 'full-scenario', makeMetadata({
+            name: 'Full Scenario',
+            updatedAt: '2024-06-01T00:00:00.000Z',
+        }));
+        const content = readScenarioJson(tmp, 'full-scenario');
+        expect(content.type).toBe('application');
+        expect(content.seed).toEqual({ items: [{ id: 1 }] });
+        expect(content.externalApis).toEqual({ 'GET /weather': { body: {} } });
+        expect(content.session).toEqual({ cookieValue: 'sess123' });
+        expect(content.auth).toEqual({ email: 'a@b.com', password: 'pass' });
+        expect(content.localStorage).toEqual({ key: 'val' });
+        expect(content.sessionCookies).toEqual([{ name: 'tok', value: 'xyz' }]);
     });
 });
 //# sourceMappingURL=scenariosManifest.test.js.map