@codeyam/codeyam-cli 0.1.0-staging.eb21b2f → 0.1.0-staging.f3b710d

package/codeyam-cli/src/utils/editorScenarios.js

@@ -0,0 +1,687 @@
+/**
+ * Shared scenario utilities used across editor routes and components.
+ *
+ * Extracted from inline logic in editor.tsx, api.editor-journal-entry.ts,
+ * and api.editor-register-scenario.ts.
+ */
+import fs from 'fs';
+import path from 'path';
+import { buildRoutePattern, routeDisplayName } from "./routePatternMatching.js";
+import { pageNameFromUrl, isIsolationUrl } from "./entityChangeStatus.js";
+import { sanitizeGlossaryEntries } from "./editorLoaderHelpers.js";
+/**
+ * Generic Map-based deduplication that keeps the last item for each key.
+ * Items are iterated in order, so later entries overwrite earlier ones.
+ * Map preserves insertion order of first appearance.
+ */
+export function deduplicateByName(items, keyFn) {
+    const byKey = new Map();
+    for (const item of items) {
+        byKey.set(keyFn(item), item);
+    }
+    return [...byKey.values()];
+}
+/**
+ * Convert a scenario name to a URL-safe slug.
+ * Replaces any run of non-alphanumeric, non-underscore characters with a single underscore.
+ */
+export function generateScenarioSlug(name) {
+    return name.replace(/[^a-zA-Z0-9_]+/g, '_');
+}
+/**
+ * Convert a dimension name to a filename-safe slug for screenshot paths.
+ * Lowercase, spaces→hyphens, strip non-alphanumeric, collapse multiple hyphens.
+ * "Extension Popup" → "extension-popup"
+ */
+export function slugifyDimension(name) {
+    return name
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '');
+}
+/**
+ * Convert an ISO 8601 timestamp (e.g. "2026-02-28T19:00:00.000Z") to
+ * SQLite-compatible format (e.g. "2026-02-28 19:00:00").
+ *
+ * SQLite's CURRENT_TIMESTAMP uses space-separated "YYYY-MM-DD HH:MM:SS" format,
+ * so we need this conversion for date comparisons.
+ */
+export function convertIsoToSqliteTimestamp(iso) {
+    return iso.replace('T', ' ').replace(/\.\d{3}Z$/, '');
+}
+/**
+ * Check whether a scenario row belongs to the current feature session.
+ * A row belongs if it was created OR updated after the session start —
+ * re-registering a scenario updates `updated_at` but preserves `created_at`.
+ */
+export function isRowInFeatureSession(row, sqliteTimestamp) {
+    if (row.created_at && row.created_at >= sqliteTimestamp)
+        return true;
+    if (row.updated_at && row.updated_at >= sqliteTimestamp)
+        return true;
+    return false;
+}
+/**
+ * Properties in config.json that are user-configured and must survive a re-init.
+ * Auto-detected properties (projectSlug, packageManager, webapps, createdAt, etc.)
+ * are intentionally NOT preserved — init should re-detect them.
+ */
+const PRESERVED_CONFIG_KEYS = [
+    'defaultScreenSize',
+    'screenSizes',
+    'projectTitle',
+    'projectDescription',
+    'appFormats',
+];
+/**
+ * Read user-configured properties from an existing config.json that should be
+ * preserved when `codeyam init --force` overwrites the file.
+ *
+ * Returns only the properties listed in PRESERVED_CONFIG_KEYS.
+ * Returns an empty object if the file doesn't exist or can't be parsed.
+ */
+export function readPreservedConfigProperties(configPath) {
+    try {
+        const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+        const preserved = {};
+        for (const key of PRESERVED_CONFIG_KEYS) {
+            if (config[key] !== undefined) {
+                preserved[key] = config[key];
+            }
+        }
+        return preserved;
+    }
+    catch {
+        return {};
+    }
+}
+/**
+ * Validate that a step transition is allowed.
+ *
+ * Rules:
+ * - Step 1 is always allowed (starts a new feature).
+ * - Steps 2–15 require the current state step to be at least (requestedStep - 1),
+ *   i.e. you can advance one step at a time or re-run the current step, but
+ *   you cannot skip ahead.
+ *
+ * Returns null if valid, or an error message string if invalid.
+ */
+export function validateStepTransition(requestedStep, currentStep, startedAt, projectRoot) {
+    // Step 1 always allowed — it starts or restarts a feature
+    if (requestedStep === 1)
+        return null;
+    // No state at all — must start from step 1
+    if (currentStep === null) {
+        return `Cannot jump to step ${requestedStep} — no feature in progress. Run step 1 first.`;
+    }
+    // Allow re-running the current step or advancing to the next step
+    if (requestedStep > currentStep + 1) {
+        return `Cannot jump from step ${currentStep} to step ${requestedStep}. Complete step ${currentStep + 1} first.`;
+    }
+    // Prevent rapid-fire step advances (e.g. for-loop with `| head -2`).
+    // Each step has a checklist that takes real work — advancing in under
+    // 3 seconds means the instructions weren't read or followed.
+    if (requestedStep === currentStep + 1 && startedAt && currentStep >= 2) {
+        const elapsed = Date.now() - new Date(startedAt).getTime();
+        const MIN_STEP_DURATION_MS = 3000;
+        if (elapsed < MIN_STEP_DURATION_MS) {
+            const remaining = Math.ceil((MIN_STEP_DURATION_MS - elapsed) / 1000);
+            return (`Step ${currentStep} was started only ${Math.round(elapsed / 1000)}s ago. ` +
+                `Each step has a checklist that must be completed before advancing. ` +
+                `Read the FULL output of \`codeyam editor ${currentStep}\` and complete every checklist item. ` +
+                `You cannot advance for another ${remaining}s.`);
+        }
+    }
+    // Task creation gate: when advancing from step 2+, a task must have been
+    // created for the current step. If not, block and require `codeyam editor task-ontrack`.
+    if (requestedStep === currentStep + 1 && currentStep >= 2 && projectRoot) {
+        try {
+            const trackingPath = path.join(projectRoot, '.codeyam', 'editor-task-tracking.json');
+            if (fs.existsSync(trackingPath)) {
+                const tracking = JSON.parse(fs.readFileSync(trackingPath, 'utf8'));
+                if (tracking.step === currentStep && tracking.taskCreated === false) {
+                    return (`BLOCKED: You did not create a task for step ${currentStep}. ` +
+                        `Run \`codeyam editor task-ontrack\` to get back on track.`);
+                }
+            }
+        }
+        catch {
+            // Non-fatal — don't block if tracking file is unreadable
+        }
+    }
+    return null;
+}
+/**
+ * Resolve which URL to use for Playwright screenshot capture.
+ *
+ * Priority:
+ * 1. Path-based URL + proxy → combine (component isolation with API interception)
+ * 2. Full URL → use directly (legacy)
+ * 3. No URL → proxy root or dev server root (page scenarios)
+ */
+/**
+ * Resolve the navigation path for preview refresh.
+ * Priority: explicit path > scenario URL from DB > undefined (plain refresh).
+ */
+export function resolvePreviewNavPath(explicitPath, scenarioUrl) {
+    if (explicitPath)
+        return explicitPath;
+    if (scenarioUrl)
+        return scenarioUrl;
+    return undefined;
+}
+/**
+ * Clear the editor step state file (for starting a new feature).
+ * This should NOT touch the user prompt file — the prompt is captured
+ * by the hook before step 1 runs, so deleting it here would lose it.
+ */
+export function clearEditorState(root) {
+    const statePath = path.join(root, '.codeyam', 'editor-step.json');
+    try {
+        fs.unlinkSync(statePath);
+    }
+    catch {
+        // File doesn't exist, that's fine
+    }
+}
+/**
+ * Clear the user prompt file so the hook can capture the next feature request.
+ * Call this after a feature is committed, not during step 1.
+ */
+export function clearEditorUserPrompt(root) {
+    const promptPath = path.join(root, '.codeyam', 'editor-user-prompt.txt');
+    try {
+        fs.unlinkSync(promptPath);
+    }
+    catch {
+        // File doesn't exist, that's fine
+    }
+}
+export function determineCaptureUrl(url, proxyUrl, devServerUrl) {
+    const isPath = url && url.startsWith('/');
+    if (isPath && proxyUrl) {
+        return `${proxyUrl}${url}`;
+    }
+    else if (url && !isPath) {
+        return url;
+    }
+    else {
+        return proxyUrl || devServerUrl || null;
+    }
+}
+/**
+ * Read the project's default screen size from .codeyam/config.json.
+ * Returns { width, height } or null if not configured.
+ */
+export function readDefaultScreenSize(codeyamRoot) {
+    try {
+        const configPath = path.join(codeyamRoot, '.codeyam', 'config.json');
+        const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+        // New format: screenSizes entry with `default: true`
+        if (config.screenSizes && typeof config.screenSizes === 'object') {
+            for (const entry of Object.values(config.screenSizes)) {
+                const s = entry;
+                if (s.default && s.width && s.height) {
+                    return { width: s.width, height: s.height };
+                }
+            }
+        }
+        // Old format: explicit defaultScreenSize field
+        if (config.defaultScreenSize?.width && config.defaultScreenSize?.height) {
+            return {
+                width: config.defaultScreenSize.width,
+                height: config.defaultScreenSize.height,
+            };
+        }
+    }
+    catch {
+        // Non-fatal
+    }
+    return null;
+}
+/**
+ * Read named screen sizes from .codeyam/config.json.
+ * Returns a map of name → { width, height }, or empty object if not configured.
+ *
+ * Config format:
+ *   "screenSizes": {
+ *     "Desktop": { "width": 1440, "height": 900 },
+ *     "Mobile": { "width": 375, "height": 667 }
+ *   }
+ */
+export function readScreenSizes(codeyamRoot) {
+    try {
+        const configPath = path.join(codeyamRoot, '.codeyam', 'config.json');
+        const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+        if (config.screenSizes &&
+            typeof config.screenSizes === 'object' &&
+            !Array.isArray(config.screenSizes)) {
+            return config.screenSizes;
+        }
+    }
+    catch {
+        // Non-fatal
+    }
+    return {};
+}
+/**
+ * Resolve the viewport dimensions for a scenario capture.
+ * Priority: explicit body values > project default > hardcoded fallback (1280×720).
+ */
+export function resolveScenarioViewport(params) {
+    return {
+        width: params.bodyWidth || params.projectDefault?.width || 1280,
+        height: params.bodyHeight || params.projectDefault?.height || 720,
+    };
+}
+/**
+ * Resolve viewport dimensions by reading the project config.
+ *
+ * Priority chain:
+ * 1. Explicit bodyWidth/bodyHeight (highest)
+ * 2. Named dimension → lookup in config screenSizes map
+ * 3. Project defaultScreenSize from config
+ * 4. 1280×720 hardcoded fallback (lowest)
+ *
+ * Use this in any capture endpoint that needs viewport resolution.
+ */
+export function resolveViewportWithProjectDefault(params) {
+    // Look up named dimension from screenSizes if provided
+    let dimensionSize = null;
+    if (params.dimension) {
+        const screenSizes = readScreenSizes(params.codeyamRoot);
+        const entry = screenSizes[params.dimension];
+        if (entry?.width && entry?.height) {
+            dimensionSize = { width: entry.width, height: entry.height };
+        }
+    }
+    const projectDefault = dimensionSize || readDefaultScreenSize(params.codeyamRoot);
+    return resolveScenarioViewport({
+        bodyWidth: params.bodyWidth,
+        bodyHeight: params.bodyHeight,
+        projectDefault,
+    });
+}
+/**
+ * Insert or update an editor scenario by name + project.
+ *
+ * When a scenario with the same name already exists for the project:
+ * - Reuses the most recent row's ID (so data files at that path get overwritten naturally)
+ * - Updates the row with the new values
+ * - Deletes any additional duplicate rows that accumulated from past always-insert behavior
+ *
+ * When no existing scenario matches: inserts a new row with a fresh UUID.
+ */
+export async function upsertEditorScenario(db, params) {
+    // Serialize multi-dimension fields for storage
+    const dimensionsJson = params.dimensions
+        ? JSON.stringify(params.dimensions)
+        : null;
+    const screenshotPathsJson = params.screenshotPaths
+        ? JSON.stringify(params.screenshotPaths)
+        : null;
+    // Find all existing scenarios with the same name + project
+    const existing = await db
+        .selectFrom('editor_scenarios')
+        .selectAll()
+        .where('name', '=', params.name)
+        .where('project_id', '=', params.projectId)
+        .orderBy('created_at', 'desc')
+        .execute();
+    if (existing.length > 0) {
+        // Reuse the most recent row's ID
+        const latest = existing[0];
+        const scenarioId = latest.id;
+        // Update the existing row with new values
+        const updateSet = {
+            description: params.description,
+            component_name: params.componentName,
+            component_path: params.componentPath,
+            url: params.url,
+            type: params.type,
+            viewport_width: params.viewportWidth,
+            viewport_height: params.viewportHeight,
+            updated_at: new Date()
+                .toISOString()
+                .replace('T', ' ')
+                .replace(/\.\d{3}Z$/, ''),
+        };
+        if (params.dimensions !== undefined) {
+            updateSet.dimensions = dimensionsJson;
+            updateSet.screenshot_paths = screenshotPathsJson;
+        }
+        if (params.pageFilePath !== undefined) {
+            updateSet.page_file_path = params.pageFilePath;
+        }
+        if (params.entitySha !== undefined) {
+            updateSet.entity_sha = params.entitySha;
+        }
+        if (params.displayName !== undefined) {
+            updateSet.display_name = params.displayName;
+        }
+        await db
+            .updateTable('editor_scenarios')
+            .set(updateSet)
+            .where('id', '=', scenarioId)
+            .execute();
+        // Delete duplicate rows (all except the latest)
+        const duplicateIds = existing.slice(1).map((r) => r.id);
+        if (duplicateIds.length > 0) {
+            await db
+                .deleteFrom('editor_scenarios')
+                .where('id', 'in', duplicateIds)
+                .execute();
+        }
+        return { scenarioId, isNew: false, cleanedUpIds: duplicateIds };
+    }
+    // No existing scenario — insert new
+    // Use globalThis.crypto (Web Crypto API) to avoid pulling Node's crypto
+    // module into the Vite client bundle (this file is also imported client-side
+    // for deduplicateByName).
+    const scenarioId = globalThis.crypto.randomUUID();
+    const insertValues = {
+        id: scenarioId,
+        project_id: params.projectId,
+        name: params.name,
+        description: params.description,
+        component_name: params.componentName,
+        component_path: params.componentPath,
+        url: params.url,
+        type: params.type,
+        viewport_width: params.viewportWidth,
+        viewport_height: params.viewportHeight,
+    };
+    if (params.dimensions !== undefined) {
+        insertValues.dimensions = dimensionsJson;
+        insertValues.screenshot_paths = screenshotPathsJson;
+    }
+    if (params.pageFilePath !== undefined) {
+        insertValues.page_file_path = params.pageFilePath;
+    }
+    if (params.entitySha !== undefined) {
+        insertValues.entity_sha = params.entitySha;
+    }
+    if (params.displayName !== undefined) {
+        insertValues.display_name = params.displayName;
+    }
+    await db.insertInto('editor_scenarios').values(insertValues).execute();
+    return { scenarioId, isNew: true, cleanedUpIds: [] };
+}
+/**
+ * Delete data files (.json, .seed.json) and screenshots for a list of scenario IDs.
+ * Used to clean up orphaned files after deduplication.
+ */
+export function cleanupScenarioFiles(codeyamRoot, scenarioIds) {
+    const scenariosDir = path.join(codeyamRoot, '.codeyam', 'editor-scenarios');
+    const screenshotsDir = path.join(scenariosDir, 'screenshots');
+    for (const id of scenarioIds) {
+        for (const file of [
+            `${id}.json`,
+            `${id}.seed.json`,
+            path.join('screenshots', `${id}.png`),
+        ]) {
+            try {
+                fs.unlinkSync(path.join(scenariosDir, file));
+            }
+            catch {
+                // File doesn't exist, that's fine
+            }
+        }
+        // Also clean up multi-dimension screenshots ({id}--{slug}.png)
+        try {
+            const files = fs.readdirSync(screenshotsDir);
+            for (const file of files) {
+                if (file.startsWith(`${id}--`) && file.endsWith('.png')) {
+                    try {
+                        fs.unlinkSync(path.join(screenshotsDir, file));
+                    }
+                    catch {
+                        // File doesn't exist, that's fine
+                    }
+                }
+            }
+        }
+        catch {
+            // Screenshots directory may not exist
+        }
+    }
+}
+/**
+ * Validate that an app/user scenario's file path has a glossary entry.
+ * For component-type scenarios, validation is skipped (they use a different flow).
+ *
+ * Returns:
+ * - { valid: true } if validation passes or is skipped
+ * - { valid: true, needsAnalysis: true } if in glossary but entity not yet created
+ * - { valid: false, error: "..." } if the file is not in the glossary
+ */
+export function validateEntityLinkageForAppScenario(params) {
+    const { lookupFilePath, scenarioType, projectRoot } = params;
+    // Only validate for application/user scenarios
+    if (scenarioType !== 'application' && scenarioType !== 'user') {
+        return { valid: true };
+    }
+    // Nothing to validate if no file path
+    if (!lookupFilePath) {
+        return { valid: true };
+    }
+    // Read and parse the glossary
+    const glossaryPath = path.join(projectRoot, '.codeyam', 'glossary.json');
+    let glossaryEntries = [];
+    try {
+        const raw = JSON.parse(fs.readFileSync(glossaryPath, 'utf8'));
+        glossaryEntries = sanitizeGlossaryEntries(raw);
+    }
+    catch {
+        // Glossary doesn't exist or can't be parsed — file not in glossary
+    }
+    const inGlossary = glossaryEntries.some((entry) => entry.filePath === lookupFilePath);
+    if (!inGlossary) {
+        const hint = glossaryEntries.length === 0
+            ? ` glossary.json is empty or could not be parsed. It must be a JSON array: [{"name": "...", "filePath": "${lookupFilePath}", ...}]`
+            : ` Found ${glossaryEntries.length} entries but none with filePath "${lookupFilePath}".`;
+        return {
+            valid: false,
+            error: `No glossary entry found for '${lookupFilePath}'.${hint} Add this file to .codeyam/glossary.json before registering app scenarios.`,
+        };
+    }
+    // In glossary but entity doesn't exist yet — caller needs to run analyze-imports
+    return { valid: true, needsAnalysis: true };
+}
+/**
+ * Validate that a scenario's componentName and URL are consistent.
+ *
+ * Component scenarios must use isolation URLs (/isolated-components/ or /codeyam-isolate/).
+ * A componentName paired with a regular page URL (e.g., /library) is a miscategorization —
+ * the scenario will be audited as a component but screenshot a full page.
+ *
+ * Returns { valid: true } when OK, or { valid: false, error } with an actionable message.
+ */
+export function validateScenarioCategorization(params) {
+    const { componentName, url } = params;
+    // Only validate when both componentName and url are set
+    if (!componentName || !url) {
+        return { valid: true };
+    }
+    // If the URL is an isolation route, categorization is correct
+    if (isIsolationUrl(url)) {
+        return { valid: true };
+    }
+    return {
+        valid: false,
+        error: `Scenario has componentName "${componentName}" but URL "${url}" is not an isolation route. ` +
+            `Component scenarios must use an isolation URL like /isolated-components/${componentName}?s=ScenarioName ` +
+            `or /codeyam-isolate/${componentName}?s=ScenarioName. ` +
+            `Either change the URL to an isolation route, or remove componentName to register as an application scenario.`,
+    };
+}
+/**
+ * Count scenarios that have null entity_sha but do have a file path
+ * (component_path or page_file_path) — these need entity backfill.
+ */
+export async function countScenariosNeedingEntityBackfill(db) {
+    const result = await db
+        .selectFrom('editor_scenarios')
+        .select(db.fn.countAll().as('count'))
+        .where('entity_sha', 'is', null)
+        .where((eb) => eb.or([
+        eb('component_path', 'is not', null),
+        eb('page_file_path', 'is not', null),
+    ]))
+        .executeTakeFirstOrThrow();
+    return Number(result.count);
+}
+/**
+ * Backfill entity_sha (and display_name) on scenarios that were registered
+ * before analyze-imports created the entity records in the DB.
+ *
+ * Matches scenarios by component_path or page_file_path against the entities
+ * array. Uses the same display_name derivation as the register route.
+ */
+/**
+ * Sync scenario entity_sha values to match the latest entity versions.
+ *
+ * Called proactively when entity versions change (file watcher) and during
+ * registration/audit. Updates scenarios with NULL or stale entity SHAs to
+ * point to the latest entity version. Safe because journals preserve
+ * screenshots and everything is version-controlled in git.
+ *
+ * @deprecated Use syncScenarioEntityShas — backfillEntityShaOnScenarios is the legacy name
+ */
+export const backfillEntityShaOnScenarios = syncScenarioEntityShas;
+export async function syncScenarioEntityShas(db, entities) {
+    // Build lookup maps: name+path for precise component matching,
+    // path-only as fallback for page scenarios (no component_name).
+    // A single file can export multiple entities (e.g., FullPageLibrary.tsx
+    // exports FullPageLibrary, FullPageEmptyState, FullPageArticleCard).
+    // For page scenarios, prefer the default export since app-level scenarios
+    // represent the file's main component.
+    const entityByNameAndPath = new Map();
+    const entityByPath = new Map();
+    for (const entity of entities) {
+        if (entity.filePath) {
+            entityByNameAndPath.set(`${entity.name}::${entity.filePath}`, entity);
+            const existing = entityByPath.get(entity.filePath);
+            // Always prefer the latest entity version (last in array, since callers
+            // pass entities in creation order). Only skip overwrite when the existing
+            // entry is a default export and the new one isn't — default exports
+            // represent the file's main component for page scenario matching.
+            if (!existing || !existing.isDefaultExport || entity.isDefaultExport) {
+                entityByPath.set(entity.filePath, entity);
+            }
+        }
+    }
+    // Query scenarios that need updating: either NULL entity_sha or stale
+    // (pointing to an older entity version). Journals preserve screenshots
+    // and everything is version-controlled, so keeping scenarios on the
+    // latest entity SHA is always correct.
+    const rows = await db
+        .selectFrom('editor_scenarios')
+        .selectAll()
+        .where((eb) => eb.or([
+        eb('component_path', 'is not', null),
+        eb('page_file_path', 'is not', null),
+    ]))
+        .execute();
+    if (rows.length === 0)
+        return { updated: 0 };
+    let updated = 0;
+    for (const row of rows) {
+        const r = row;
+        const lookupPath = r.component_path || r.page_file_path;
+        if (!lookupPath)
+            continue;
+        // Prefer name+path match for component scenarios (handles multi-entity files).
+        // Fall back to path-only for page scenarios or when name doesn't match.
+        const entity = (r.component_name &&
+            entityByNameAndPath.get(`${r.component_name}::${lookupPath}`)) ||
+            entityByPath.get(lookupPath);
+        if (!entity)
+            continue;
+        // Skip if already pointing to the latest SHA
+        if (r.entity_sha === entity.sha)
+            continue;
+        // Derive display_name using same logic as register route
+        let displayName = null;
+        if (r.component_name) {
+            displayName = r.component_name;
+        }
+        else if (r.page_file_path && r.page_file_path.startsWith('app/')) {
+            displayName = routeDisplayName(buildRoutePattern(r.page_file_path));
+        }
+        else if (r.url) {
+            displayName = pageNameFromUrl(r.url);
+        }
+        await db
+            .updateTable('editor_scenarios')
+            .set({
+            entity_sha: entity.sha,
+            ...(displayName ? { display_name: displayName } : {}),
+        })
+            .where('id', '=', r.id)
+            .execute();
+        updated++;
+    }
+    return { updated };
+}
+/**
+ * Resolve seed data from another scenario, referenced by ID or name.
+ *
+ * Lookup order:
+ * 1. Try `ref` as a scenario ID — read `{ref}.seed.json` directly
+ * 2. If no seed file by ID, try `{ref}.json` data file for inline seed
+ * 3. If neither works, look up `ref` as a scenario name in the DB,
+ *    then read the resolved ID's seed files
+ *
+ * Returns the seed data object, or null if not found.
+ */
+export async function resolveSeedFrom(codeyamRoot, db, ref) {
+    const scenariosDir = path.join(codeyamRoot, '.codeyam', 'editor-scenarios');
+    // Helper: try to read seed data for a given scenario ID
+    const readSeedForId = (id) => {
+        // Prefer the dedicated .seed.json file
+        const seedPath = path.join(scenariosDir, `${id}.seed.json`);
+        if (fs.existsSync(seedPath)) {
+            try {
+                return JSON.parse(fs.readFileSync(seedPath, 'utf-8'));
+            }
+            catch {
+                return null;
+            }
+        }
+        // Fall back to the seed field inside the scenario data file
+        const dataPath = path.join(scenariosDir, `${id}.json`);
+        if (fs.existsSync(dataPath)) {
+            try {
+                const data = JSON.parse(fs.readFileSync(dataPath, 'utf-8'));
+                return data.seed || null;
+            }
+            catch {
+                return null;
+            }
+        }
+        return null;
+    };
+    // 1. Try ref as a direct scenario ID
+    const directResult = readSeedForId(ref);
+    if (directResult)
+        return directResult;
+    // 2. Look up ref as a scenario name in the DB
+    try {
+        const row = await db
+            .selectFrom('editor_scenarios')
+            .select('id')
+            .where('name', '=', ref)
+            .orderBy('created_at', 'desc')
+            .limit(1)
+            .executeTakeFirst();
+        if (row) {
+            return readSeedForId(row.id);
+        }
+    }
+    catch {
+        // DB lookup failed — fall through
+    }
+    return null;
+}
+//# sourceMappingURL=editorScenarios.js.map