@contentful/experience-design-system-cli 2.2.1

package/dist/src/session/db.js

@@ -0,0 +1,1114 @@
+import { DatabaseSync } from 'node:sqlite';
+import { mkdirSync } from 'node:fs';
+import { createHash } from 'node:crypto';
+import { homedir } from 'node:os';
+import { dirname, resolve } from 'node:path';
+import { generateSessionId } from './session-id.js';
+const SCHEMA = `
+PRAGMA journal_mode = WAL;
+PRAGMA foreign_keys = ON;
+
+CREATE TABLE IF NOT EXISTS migrations (
+  name        TEXT NOT NULL PRIMARY KEY,
+  applied_at  TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS sessions (
+  id          TEXT NOT NULL PRIMARY KEY,
+  name        TEXT,
+  created_at  TEXT NOT NULL,
+  updated_at  TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS steps (
+  id            INTEGER PRIMARY KEY AUTOINCREMENT,
+  session_id    TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
+  command       TEXT NOT NULL,
+  status        TEXT NOT NULL DEFAULT 'pending',
+  started_at    TEXT NOT NULL,
+  completed_at  TEXT,
+  inputs        TEXT NOT NULL DEFAULT '{}',
+  outputs       TEXT NOT NULL DEFAULT '{}',
+  error         TEXT,
+  updated_at    TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS raw_components (
+  session_id    TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
+  component_id  TEXT NOT NULL,
+  name          TEXT NOT NULL,
+  source        TEXT NOT NULL,
+  framework     TEXT NOT NULL,
+  extracted_at  TEXT NOT NULL,
+  status        TEXT NOT NULL DEFAULT 'extracted',
+  cdf_schema    TEXT,
+  description   TEXT,
+  PRIMARY KEY (session_id, component_id)
+);
+
+CREATE TABLE IF NOT EXISTS raw_props (
+  session_id      TEXT NOT NULL,
+  component_id    TEXT NOT NULL,
+  name            TEXT NOT NULL,
+  type            TEXT NOT NULL,
+  required        INTEGER NOT NULL CHECK (required IN (0, 1)),
+  category        TEXT CHECK (category IN ('content', 'design', 'state')),
+  default_value   TEXT,
+  description     TEXT,
+  token_reference TEXT,
+  position        INTEGER NOT NULL,
+  cdf_type        TEXT,
+  cdf_category    TEXT CHECK (cdf_category IN ('content', 'design', 'state')),
+  cdf_token_kind  TEXT,
+  PRIMARY KEY (session_id, component_id, name),
+  FOREIGN KEY (session_id, component_id) REFERENCES raw_components(session_id, component_id) ON DELETE CASCADE
+);
+
+CREATE TABLE IF NOT EXISTS raw_prop_allowed_values (
+  session_id   TEXT NOT NULL,
+  component_id TEXT NOT NULL,
+  prop_name    TEXT NOT NULL,
+  position     INTEGER NOT NULL,
+  value        TEXT NOT NULL,
+  PRIMARY KEY (session_id, component_id, prop_name, position),
+  FOREIGN KEY (session_id, component_id, prop_name) REFERENCES raw_props(session_id, component_id, name) ON DELETE CASCADE
+);
+
+CREATE TABLE IF NOT EXISTS raw_slots (
+  session_id   TEXT NOT NULL,
+  component_id TEXT NOT NULL,
+  name         TEXT NOT NULL,
+  is_default   INTEGER NOT NULL CHECK (is_default IN (0, 1)),
+  description  TEXT,
+  position     INTEGER NOT NULL,
+  required     INTEGER NOT NULL DEFAULT 1 CHECK (required IN (0, 1)),
+  PRIMARY KEY (session_id, component_id, name),
+  FOREIGN KEY (session_id, component_id) REFERENCES raw_components(session_id, component_id) ON DELETE CASCADE
+);
+
+CREATE TABLE IF NOT EXISTS raw_slot_allowed_components (
+  session_id        TEXT NOT NULL,
+  component_id      TEXT NOT NULL,
+  slot_name         TEXT NOT NULL,
+  position          INTEGER NOT NULL,
+  allowed_component TEXT NOT NULL,
+  PRIMARY KEY (session_id, component_id, slot_name, position),
+  FOREIGN KEY (session_id, component_id, slot_name) REFERENCES raw_slots(session_id, component_id, name) ON DELETE CASCADE
+);
+
+CREATE TABLE IF NOT EXISTS raw_token_groups (
+  session_id   TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
+  path         TEXT NOT NULL,
+  description  TEXT,
+  PRIMARY KEY (session_id, path)
+);
+
+CREATE TABLE IF NOT EXISTS raw_tokens (
+  session_id   TEXT NOT NULL,
+  path         TEXT NOT NULL,
+  type         TEXT NOT NULL,
+  value        TEXT NOT NULL,
+  description  TEXT,
+  PRIMARY KEY (session_id, path),
+  FOREIGN KEY (session_id) REFERENCES sessions(id) ON DELETE CASCADE
+);
+
+CREATE TABLE IF NOT EXISTS generation_cache (
+  input_hash        TEXT NOT NULL,
+  entity_type       TEXT NOT NULL CHECK (entity_type IN ('component', 'token_set')),
+  entity_id         TEXT NOT NULL,
+  source_session_id TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
+  human_edited      INTEGER NOT NULL DEFAULT 0 CHECK (human_edited IN (0, 1)),
+  created_at        TEXT NOT NULL,
+  updated_at        TEXT NOT NULL,
+  PRIMARY KEY (input_hash, entity_type, entity_id)
+);
+
+CREATE INDEX IF NOT EXISTS idx_steps_session            ON steps(session_id);
+CREATE INDEX IF NOT EXISTS idx_steps_command            ON steps(session_id, command);
+CREATE INDEX IF NOT EXISTS idx_raw_components_session   ON raw_components(session_id);
+CREATE INDEX IF NOT EXISTS idx_raw_props_session        ON raw_props(session_id, component_id);
+CREATE INDEX IF NOT EXISTS idx_raw_slots_session        ON raw_slots(session_id, component_id);
+CREATE INDEX IF NOT EXISTS idx_raw_tokens_session       ON raw_tokens(session_id);
+CREATE INDEX IF NOT EXISTS idx_raw_token_groups_session ON raw_token_groups(session_id);
+CREATE INDEX IF NOT EXISTS idx_generation_cache_entity  ON generation_cache(entity_type, entity_id);
+CREATE INDEX IF NOT EXISTS idx_generation_cache_session ON generation_cache(source_session_id);
+`;
+export function getPipelineDbPath() {
+    if (process.env.EDS_PIPELINE_DB_PATH) {
+        return resolve(process.env.EDS_PIPELINE_DB_PATH);
+    }
+    return resolve(homedir(), '.contentful', 'experience-design-system-cli', 'pipeline.db');
+}
+export function openPipelineDb(dbPath) {
+    const path = dbPath ?? getPipelineDbPath();
+    mkdirSync(dirname(path), { recursive: true });
+    try {
+        const db = new DatabaseSync(path);
+        db.exec(SCHEMA);
+        applyDbMigrations(db);
+        return db;
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        if (msg.includes('database is locked')) {
+            process.stderr.write('Error: another CLI process is already running. Wait for it to finish and retry.\n');
+            process.exit(1);
+        }
+        throw e;
+    }
+}
+function applyDbMigrations(db) {
+    // Add raw_slots.required column if it doesn't exist yet (added in v0.5.14).
+    const cols = db.prepare('PRAGMA table_info(raw_slots)').all();
+    if (!cols.some((c) => c.name === 'required')) {
+        db.exec('ALTER TABLE raw_slots ADD COLUMN required INTEGER NOT NULL DEFAULT 1 CHECK (required IN (0, 1))');
+    }
+    // Add generation_cache table if it doesn't exist yet.
+    const tables = db
+        .prepare(`SELECT name FROM sqlite_master WHERE type='table' AND name='generation_cache'`)
+        .all();
+    if (tables.length === 0) {
+        db.exec(`
+      CREATE TABLE generation_cache (
+        input_hash        TEXT NOT NULL,
+        entity_type       TEXT NOT NULL CHECK (entity_type IN ('component', 'token_set')),
+        entity_id         TEXT NOT NULL,
+        source_session_id TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
+        human_edited      INTEGER NOT NULL DEFAULT 0 CHECK (human_edited IN (0, 1)),
+        created_at        TEXT NOT NULL,
+        updated_at        TEXT NOT NULL,
+        PRIMARY KEY (input_hash, entity_type, entity_id)
+      );
+      CREATE INDEX idx_generation_cache_entity ON generation_cache(entity_type, entity_id);
+      CREATE INDEX idx_generation_cache_session ON generation_cache(source_session_id);
+    `);
+    }
+}
+export function applyToolCalls(db, sessionId, componentId, componentName, calls, incomingWarnings) {
+    const now = new Date().toISOString();
+    const warnings = [...incomingWarnings];
+    let classified = 0;
+    let excluded = 0;
+    let slots = 0;
+    const updateProp = db.prepare(`UPDATE raw_props SET cdf_type = ?, cdf_category = ?, cdf_token_kind = ?, required = ?, description = ?
+     WHERE session_id = ? AND component_id = ? AND name = ?`);
+    const clearProp = db.prepare(`UPDATE raw_props SET cdf_type = 'excluded', cdf_category = NULL, cdf_token_kind = NULL
+     WHERE session_id = ? AND component_id = ? AND name = ?`);
+    const deleteAllowedValues = db.prepare(`DELETE FROM raw_prop_allowed_values WHERE session_id = ? AND component_id = ? AND prop_name = ?`);
+    const insertAllowedValue = db.prepare(`INSERT OR IGNORE INTO raw_prop_allowed_values (session_id, component_id, prop_name, value, position)
+     VALUES (?, ?, ?, ?, ?)`);
+    const deleteAllowedComponents = db.prepare(`DELETE FROM raw_slot_allowed_components WHERE session_id = ? AND component_id = ? AND slot_name = ?`);
+    const insertAllowedComponent = db.prepare(`INSERT OR IGNORE INTO raw_slot_allowed_components (session_id, component_id, slot_name, allowed_component, position)
+     VALUES (?, ?, ?, ?, ?)`);
+    const updateSlot = db.prepare(`UPDATE raw_slots SET required = ?, description = ? WHERE session_id = ? AND component_id = ? AND name = ?`);
+    db.exec('BEGIN');
+    try {
+        for (const call of calls) {
+            if (call.tool === 'classify_component') {
+                if (call.description !== undefined) {
+                    db.prepare('UPDATE raw_components SET description = ? WHERE session_id = ? AND component_id = ?').run(call.description, sessionId, componentId);
+                }
+            }
+            else if (call.tool === 'classify_prop') {
+                const changes = updateProp.run(call.cdf_type, call.cdf_category, call.token_kind ?? null, call.required !== undefined ? (call.required ? 1 : 0) : 0, call.description ?? null, sessionId, componentId, call.prop);
+                if (changes.changes === 0) {
+                    warnings.push(`${componentName}: classify_prop '${call.prop}' — prop not found, skipped`);
+                    continue;
+                }
+                if (call.values && call.values.length > 0) {
+                    deleteAllowedValues.run(sessionId, componentId, call.prop);
+                    call.values.forEach((v, i) => insertAllowedValue.run(sessionId, componentId, call.prop, v, i));
+                }
+                if (call.default !== undefined) {
+                    const storedDefault = typeof call.default === 'boolean' ? String(call.default) : call.default;
+                    db.prepare(`UPDATE raw_props SET default_value = ? WHERE session_id = ? AND component_id = ? AND name = ?`).run(storedDefault, sessionId, componentId, call.prop);
+                }
+                classified++;
+            }
+            else if (call.tool === 'exclude_prop') {
+                clearProp.run(sessionId, componentId, call.prop);
+                excluded++;
+            }
+            else if (call.tool === 'classify_slot') {
+                const slotRequired = call.required !== undefined ? (call.required ? 1 : 0) : 1;
+                const slotChanges = updateSlot.run(slotRequired, call.description ?? null, sessionId, componentId, call.slot);
+                if (slotChanges.changes === 0) {
+                    warnings.push(`${componentName}: classify_slot '${call.slot}' — slot not found, skipped`);
+                    continue;
+                }
+                if (call.allowed_components !== undefined) {
+                    deleteAllowedComponents.run(sessionId, componentId, call.slot);
+                    call.allowed_components.forEach((ac, i) => insertAllowedComponent.run(sessionId, componentId, call.slot, ac, i));
+                }
+                slots++;
+            }
+        }
+        db.prepare(`UPDATE raw_components SET status = 'generated', extracted_at = ? WHERE session_id = ? AND component_id = ?`).run(now, sessionId, componentId);
+        db.prepare('UPDATE sessions SET updated_at = ? WHERE id = ?').run(now, sessionId);
+        db.exec('COMMIT');
+    }
+    catch (e) {
+        db.exec('ROLLBACK');
+        throw e;
+    }
+    return { classified, excluded, slots, warnings };
+}
+export function getOrCreateSession(db, sessionFlag, sessionName, hints) {
+    const now = new Date().toISOString();
+    if (sessionFlag === 'new' || sessionFlag === undefined) {
+        if (sessionFlag !== 'new') {
+            const match = findMatchingSession(db, hints);
+            if (match) {
+                return { sessionId: match, isNew: false, isResumed: true };
+            }
+        }
+        const id = generateSessionId();
+        db.prepare('INSERT INTO sessions (id, name, created_at, updated_at) VALUES (?, ?, ?, ?)').run(id, sessionName ?? null, now, now);
+        return { sessionId: id, isNew: true, isResumed: false };
+    }
+    const existing = db.prepare('SELECT id FROM sessions WHERE id = ?').get(sessionFlag);
+    if (!existing) {
+        throw new Error(`session '${sessionFlag}' not found. Run 'session list' to see active sessions.`);
+    }
+    return { sessionId: sessionFlag, isNew: false, isResumed: false };
+}
+function findMatchingSession(db, hints) {
+    if (!hints.inputPath && !hints.outDir)
+        return null;
+    const rows = db
+        .prepare(`SELECT s.id, st.inputs, st.outputs, st.status
+       FROM sessions s
+       JOIN steps st ON st.session_id = s.id
+       WHERE st.command = ?
+         AND st.status IN ('pending', 'interrupted')
+       ORDER BY st.started_at DESC
+       LIMIT 20`)
+        .all(hints.command);
+    for (const row of rows) {
+        let inputs = {};
+        try {
+            inputs = JSON.parse(row.inputs);
+        }
+        catch {
+            continue;
+        }
+        if (hints.inputPath) {
+            const inputValues = Object.values(inputs);
+            if (inputValues.some((v) => v === hints.inputPath)) {
+                return row.id;
+            }
+        }
+        if (hints.outDir) {
+            let outputs = {};
+            try {
+                outputs = JSON.parse(row.outputs);
+            }
+            catch {
+                // ignore
+            }
+            const allValues = [...Object.values(inputs), ...Object.values(outputs)];
+            if (allValues.some((v) => v === hints.outDir)) {
+                return row.id;
+            }
+        }
+    }
+    return null;
+}
+export function createStep(db, sessionId, command, inputs) {
+    const now = new Date().toISOString();
+    db.exec('BEGIN');
+    try {
+        db.prepare(`UPDATE steps SET status = 'interrupted', completed_at = ?, updated_at = ?
+       WHERE session_id = ? AND command = ? AND status = 'pending'`).run(now, now, sessionId, command);
+        const result = db
+            .prepare(`INSERT INTO steps (session_id, command, status, started_at, inputs, outputs, updated_at)
+         VALUES (?, ?, 'pending', ?, ?, '{}', ?)`)
+            .run(sessionId, command, now, JSON.stringify(inputs), now);
+        db.prepare('UPDATE sessions SET updated_at = ? WHERE id = ?').run(now, sessionId);
+        db.exec('COMMIT');
+        return Number(result.lastInsertRowid);
+    }
+    catch (e) {
+        db.exec('ROLLBACK');
+        throw e;
+    }
+}
+export function updateStep(db, stepId, status, outputs, error) {
+    const now = new Date().toISOString();
+    db.exec('BEGIN');
+    try {
+        const step = db.prepare('SELECT session_id FROM steps WHERE id = ?').get(stepId);
+        db.prepare(`UPDATE steps SET status = ?, completed_at = ?, outputs = ?, error = ?, updated_at = ? WHERE id = ?`).run(status, now, JSON.stringify(outputs), error ?? null, now, stepId);
+        if (step) {
+            db.prepare('UPDATE sessions SET updated_at = ? WHERE id = ?').run(now, step.session_id);
+        }
+        db.exec('COMMIT');
+    }
+    catch (e) {
+        db.exec('ROLLBACK');
+        throw e;
+    }
+}
+export function storeRawComponents(db, sessionId, components, options) {
+    const now = new Date().toISOString();
+    const insertComp = db.prepare(`INSERT INTO raw_components (session_id, component_id, name, source, framework, extracted_at)
+     VALUES (?, ?, ?, ?, ?, ?)`);
+    const insertProp = db.prepare(`INSERT INTO raw_props
+       (session_id, component_id, name, type, required, category, default_value, description, token_reference, position)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
+    const insertAllowedValue = db.prepare(`INSERT INTO raw_prop_allowed_values (session_id, component_id, prop_name, position, value)
+     VALUES (?, ?, ?, ?, ?)`);
+    const insertSlot = db.prepare(`INSERT INTO raw_slots (session_id, component_id, name, is_default, description, position)
+     VALUES (?, ?, ?, ?, ?, ?)`);
+    const insertAllowedComponent = db.prepare(`INSERT INTO raw_slot_allowed_components (session_id, component_id, slot_name, position, allowed_component)
+     VALUES (?, ?, ?, ?, ?)`);
+    db.exec('BEGIN');
+    try {
+        let cdfSnapshot = [];
+        let descSnapshot = [];
+        let avSnapshot = [];
+        if (options?.preserveCDF) {
+            cdfSnapshot = db
+                .prepare(`SELECT component_id, name, position, cdf_type, cdf_category, cdf_token_kind
+           FROM raw_props WHERE session_id = ? AND cdf_type IS NOT NULL`)
+                .all(sessionId);
+            descSnapshot = db
+                .prepare(`SELECT component_id, description
+           FROM raw_components WHERE session_id = ? AND description IS NOT NULL`)
+                .all(sessionId);
+            if (cdfSnapshot.length > 0) {
+                avSnapshot = db
+                    .prepare(`SELECT component_id, prop_name, position, value
+             FROM raw_prop_allowed_values WHERE session_id = ?`)
+                    .all(sessionId);
+            }
+        }
+        db.prepare('DELETE FROM raw_components WHERE session_id = ?').run(sessionId);
+        for (const comp of components) {
+            const componentId = deriveComponentId(comp.name, comp.source);
+            insertComp.run(sessionId, componentId, comp.name, comp.source, comp.framework, now);
+            for (let i = 0; i < comp.props.length; i++) {
+                const prop = comp.props[i];
+                insertProp.run(sessionId, componentId, prop.name, prop.type, prop.required ? 1 : 0, prop.category ?? null, prop.defaultValue ?? null, prop.description ?? null, prop.tokenReference ?? null, i);
+                if (prop.allowedValues) {
+                    prop.allowedValues.forEach((v, j) => insertAllowedValue.run(sessionId, componentId, prop.name, j, v));
+                }
+            }
+            for (let i = 0; i < comp.slots.length; i++) {
+                const slot = comp.slots[i];
+                insertSlot.run(sessionId, componentId, slot.name, slot.isDefault ? 1 : 0, slot.description ?? null, i);
+                if (slot.allowedComponents) {
+                    slot.allowedComponents.forEach((ac, j) => insertAllowedComponent.run(sessionId, componentId, slot.name, j, ac));
+                }
+            }
+        }
+        // Restore CDF classification data for props that still exist
+        if (options?.preserveCDF && cdfSnapshot.length > 0) {
+            const updateCDFByName = db.prepare(`UPDATE raw_props SET cdf_type = ?, cdf_category = ?, cdf_token_kind = ?
+         WHERE session_id = ? AND component_id = ? AND name = ?`);
+            const updateCDFByPosition = db.prepare(`UPDATE raw_props SET cdf_type = ?, cdf_category = ?, cdf_token_kind = ?
+         WHERE session_id = ? AND component_id = ? AND position = ? AND cdf_type IS NULL`);
+            const restoredPropKeys = new Set();
+            const unmatchedSnaps = [];
+            // First pass: match by name
+            for (const snap of cdfSnapshot) {
+                const result = updateCDFByName.run(snap.cdf_type, snap.cdf_category, snap.cdf_token_kind, sessionId, snap.component_id, snap.name);
+                if (Number(result.changes) > 0) {
+                    restoredPropKeys.add(`${snap.component_id}::${snap.name}`);
+                }
+                else {
+                    unmatchedSnaps.push(snap);
+                }
+            }
+            // Second pass: for renamed props, fall back to position-based matching
+            for (const snap of unmatchedSnaps) {
+                const result = updateCDFByPosition.run(snap.cdf_type, snap.cdf_category, snap.cdf_token_kind, sessionId, snap.component_id, snap.position);
+                if (Number(result.changes) > 0) {
+                    const matched = db
+                        .prepare(`SELECT name FROM raw_props WHERE session_id = ? AND component_id = ? AND position = ?`)
+                        .get(sessionId, snap.component_id, snap.position);
+                    if (matched) {
+                        restoredPropKeys.add(`${snap.component_id}::${matched.name}`);
+                    }
+                }
+            }
+            const updateDesc = db.prepare(`UPDATE raw_components SET description = ? WHERE session_id = ? AND component_id = ?`);
+            for (const snap of descSnapshot) {
+                updateDesc.run(snap.description, sessionId, snap.component_id);
+            }
+            // Restore allowed values only for props that still exist (to avoid FK violations)
+            const relevantAV = avSnapshot.filter((av) => restoredPropKeys.has(`${av.component_id}::${av.prop_name}`));
+            if (relevantAV.length > 0) {
+                const deleteAV = db.prepare(`DELETE FROM raw_prop_allowed_values WHERE session_id = ? AND component_id = ? AND prop_name = ?`);
+                const insertAV = db.prepare(`INSERT OR IGNORE INTO raw_prop_allowed_values (session_id, component_id, prop_name, position, value)
+           VALUES (?, ?, ?, ?, ?)`);
+                const deletedKeys = new Set();
+                for (const av of relevantAV) {
+                    const key = `${av.component_id}::${av.prop_name}`;
+                    if (!deletedKeys.has(key)) {
+                        deleteAV.run(sessionId, av.component_id, av.prop_name);
+                        deletedKeys.add(key);
+                    }
+                    insertAV.run(sessionId, av.component_id, av.prop_name, av.position, av.value);
+                }
+            }
+        }
+        if (options?.status) {
+            db.prepare('UPDATE raw_components SET status = ? WHERE session_id = ?').run(options.status, sessionId);
+        }
+        db.prepare('UPDATE sessions SET updated_at = ? WHERE id = ?').run(now, sessionId);
+        db.exec('COMMIT');
+    }
+    catch (e) {
+        db.exec('ROLLBACK');
+        throw e;
+    }
+}
+export function loadRawComponents(db, sessionId, allowedNames) {
+    const all = db
+        .prepare('SELECT component_id, name, source, framework FROM raw_components WHERE session_id = ? ORDER BY rowid')
+        .all(sessionId);
+    const components = allowedNames ? all.filter((c) => allowedNames.has(c.name)) : all;
+    if (components.length === 0)
+        return [];
+    const props = db
+        .prepare(`SELECT component_id, name, type, required, category, default_value, description, token_reference, position
+       FROM raw_props WHERE session_id = ? ORDER BY component_id, position`)
+        .all(sessionId);
+    const allowedValues = db
+        .prepare(`SELECT component_id, prop_name, position, value
+       FROM raw_prop_allowed_values WHERE session_id = ? ORDER BY component_id, prop_name, position`)
+        .all(sessionId);
+    const slots = db
+        .prepare(`SELECT component_id, name, is_default, description, position
+       FROM raw_slots WHERE session_id = ? ORDER BY component_id, position`)
+        .all(sessionId);
+    const allowedComponents = db
+        .prepare(`SELECT component_id, slot_name, position, allowed_component
+       FROM raw_slot_allowed_components WHERE session_id = ? ORDER BY component_id, slot_name, position`)
+        .all(sessionId);
+    // Group children by component_id
+    const propsByComponent = groupBy(props, (p) => p.component_id);
+    const allowedValuesByProp = groupBy(allowedValues, (av) => `${av.component_id}::${av.prop_name}`);
+    const slotsByComponent = groupBy(slots, (s) => s.component_id);
+    const allowedComponentsBySlot = groupBy(allowedComponents, (ac) => `${ac.component_id}::${ac.slot_name}`);
+    return components.map((c) => ({
+        component_id: c.component_id,
+        name: c.name,
+        source: c.source,
+        framework: c.framework,
+        props: (propsByComponent.get(c.component_id) ?? []).map((p) => {
+            const av = allowedValuesByProp.get(`${c.component_id}::${p.name}`);
+            const prop = {
+                name: p.name,
+                type: p.type,
+                required: Boolean(p.required),
+            };
+            if (p.category !== null)
+                prop.category = p.category;
+            if (p.default_value !== null)
+                prop.defaultValue = p.default_value;
+            if (p.description !== null)
+                prop.description = p.description;
+            if (p.token_reference !== null)
+                prop.tokenReference = p.token_reference;
+            if (av && av.length > 0)
+                prop.allowedValues = av.map((v) => v.value);
+            return prop;
+        }),
+        slots: (slotsByComponent.get(c.component_id) ?? []).map((s) => {
+            const ac = allowedComponentsBySlot.get(`${c.component_id}::${s.name}`);
+            const slot = {
+                name: s.name,
+                isDefault: Boolean(s.is_default),
+            };
+            if (s.description !== null)
+                slot.description = s.description;
+            if (ac && ac.length > 0)
+                slot.allowedComponents = ac.map((v) => v.allowed_component);
+            return slot;
+        }),
+    }));
+}
+function groupBy(items, key) {
+    const map = new Map();
+    for (const item of items) {
+        const k = key(item);
+        let arr = map.get(k);
+        if (!arr) {
+            arr = [];
+            map.set(k, arr);
+        }
+        arr.push(item);
+    }
+    return map;
+}
+function deriveComponentId(name, source) {
+    return createHash('sha256').update(`${name}:${source}`).digest('hex').slice(0, 12);
+}
+export function storeCDFComponents(db, sessionId, components) {
+    const now = new Date().toISOString();
+    const updateComp = db.prepare(`UPDATE raw_components SET status = 'generated', description = ? WHERE session_id = ? AND name = ?`);
+    const updateProp = db.prepare(`UPDATE raw_props SET cdf_type = ?, cdf_category = ?, cdf_token_kind = ?, required = ? WHERE session_id = ? AND component_id = ? AND name = ?`);
+    const deleteAllowedValues = db.prepare(`DELETE FROM raw_prop_allowed_values WHERE session_id = ? AND component_id = ? AND prop_name = ?`);
+    const insertAllowedValue = db.prepare(`INSERT INTO raw_prop_allowed_values (session_id, component_id, prop_name, value, position)
+     VALUES (?, ?, ?, ?, ?)`);
+    const insertAllowedComponent = db.prepare(`INSERT INTO raw_slot_allowed_components (session_id, component_id, slot_name, allowed_component, position)
+     VALUES (?, ?, ?, ?, ?)`);
+    db.exec('BEGIN');
+    try {
+        for (const { key, entry } of components) {
+            const row = db
+                .prepare('SELECT component_id FROM raw_components WHERE session_id = ? AND name = ?')
+                .get(sessionId, key);
+            if (row) {
+                const { component_id: componentId } = row;
+                updateComp.run(entry.$description ?? null, sessionId, key);
+                for (const [propName, prop] of Object.entries(entry.$properties)) {
+                    updateProp.run(prop.$type, prop.$category, prop['$token.kind'] ?? null, prop.$required ? 1 : 0, sessionId, componentId, propName);
+                    if (prop.$values && prop.$values.length > 0) {
+                        deleteAllowedValues.run(sessionId, componentId, propName);
+                        prop.$values.forEach((v, i) => insertAllowedValue.run(sessionId, componentId, propName, v, i));
+                    }
+                }
+            }
+            else {
+                // Component not in raw_components (e.g. agent added a new one) — insert a minimal record
+                const componentId = createHash('sha256').update(`${key}:generated`).digest('hex').slice(0, 12);
+                db.prepare(`INSERT INTO raw_components (session_id, component_id, name, source, framework, extracted_at, status, description)
+           VALUES (?, ?, ?, '', 'react', ?, 'generated', ?)`).run(sessionId, componentId, key, now, entry.$description ?? null);
+                let position = 0;
+                for (const [propName, prop] of Object.entries(entry.$properties)) {
+                    db.prepare(`INSERT OR REPLACE INTO raw_props
+               (session_id, component_id, name, type, required, category, default_value, description, token_reference, position, cdf_type, cdf_category, cdf_token_kind)
+             VALUES (?, ?, ?, '', ?, NULL, NULL, NULL, NULL, ?, ?, ?, ?)`).run(sessionId, componentId, propName, prop.$required ? 1 : 0, position++, prop.$type, prop.$category, prop['$token.kind'] ?? null);
+                    if (prop.$values && prop.$values.length > 0) {
+                        prop.$values.forEach((v, i) => insertAllowedValue.run(sessionId, componentId, propName, v, i));
+                    }
+                }
+                let slotPos = 0;
+                for (const [slotName, slot] of Object.entries(entry.$slots ?? {})) {
+                    db.prepare(`INSERT OR REPLACE INTO raw_slots
+               (session_id, component_id, name, is_default, required, description, position)
+             VALUES (?, ?, ?, 0, ?, ?, ?)`).run(sessionId, componentId, slotName, slot.$required ? 1 : 0, slot.$description ?? null, slotPos++);
+                    if (slot.$allowedComponents && slot.$allowedComponents.length > 0) {
+                        slot.$allowedComponents.forEach((ac, i) => insertAllowedComponent.run(sessionId, componentId, slotName, ac, i));
+                    }
+                }
+            }
+        }
+        db.prepare('UPDATE sessions SET updated_at = ? WHERE id = ?').run(now, sessionId);
+        db.exec('COMMIT');
+    }
+    catch (e) {
+        db.exec('ROLLBACK');
+        throw e;
+    }
+}
+export function loadCDFComponents(db, sessionId) {
+    const components = db
+        .prepare(`SELECT component_id, name, description FROM raw_components
+       WHERE session_id = ? AND status = 'generated' ORDER BY rowid`)
+        .all(sessionId);
+    if (components.length === 0)
+        return [];
+    const props = db
+        .prepare(`SELECT component_id, name, required, default_value, description,
+              cdf_type, cdf_category, cdf_token_kind, position
+       FROM raw_props
+       WHERE session_id = ? AND cdf_type IS NOT NULL AND cdf_type != 'excluded'
+       ORDER BY component_id, position`)
+        .all(sessionId);
+    const allowedValues = db
+        .prepare(`SELECT component_id, prop_name, value, position
+       FROM raw_prop_allowed_values WHERE session_id = ? ORDER BY component_id, prop_name, position`)
+        .all(sessionId);
+    const slots = db
+        .prepare(`SELECT component_id, name, description, required FROM raw_slots WHERE session_id = ? ORDER BY component_id, position`)
+        .all(sessionId);
+    const allowedComponents = db
+        .prepare(`SELECT component_id, slot_name, allowed_component
+       FROM raw_slot_allowed_components WHERE session_id = ? ORDER BY component_id, slot_name, position`)
+        .all(sessionId);
+    const propsByComponent = groupBy(props, (p) => p.component_id);
+    const allowedValuesByProp = groupBy(allowedValues, (av) => `${av.component_id}::${av.prop_name}`);
+    const slotsByComponent = groupBy(slots, (s) => s.component_id);
+    const allowedComponentsBySlot = groupBy(allowedComponents, (ac) => `${ac.component_id}::${ac.slot_name}`);
+    return components
+        .map(({ component_id, name, description }) => {
+        const compProps = propsByComponent.get(component_id) ?? [];
+        // Skip components with no CDF-classified props — sending them with empty
+        // $properties causes the server to flag all stored props as "removed" (breaking).
+        if (compProps.length === 0)
+            return null;
+        const $properties = {};
+        for (const p of compProps) {
+            const av = allowedValuesByProp.get(`${component_id}::${p.name}`);
+            const propDef = {
+                $type: p.cdf_type,
+                $category: p.cdf_category,
+            };
+            if (p.required)
+                propDef.$required = true;
+            if (p.default_value !== null) {
+                if (p.cdf_type === 'boolean') {
+                    propDef.$default = p.default_value === 'true';
+                }
+                else {
+                    propDef.$default = p.default_value;
+                }
+            }
+            if (p.description !== null)
+                propDef.$description = p.description;
+            if (av && av.length > 0)
+                propDef.$values = av.map((v) => v.value);
+            if (p.cdf_token_kind !== null)
+                propDef['$token.kind'] = p.cdf_token_kind;
+            $properties[p.name] = propDef;
+        }
+        const compSlots = slotsByComponent.get(component_id) ?? [];
+        const $slots = {};
+        for (const s of compSlots) {
+            const ac = allowedComponentsBySlot.get(`${component_id}::${s.name}`);
+            const slotDef = {};
+            if (s.description !== null)
+                slotDef.$description = s.description;
+            if (s.required)
+                slotDef.$required = true;
+            if (ac && ac.length > 0)
+                slotDef.$allowedComponents = ac.map((v) => v.allowed_component);
+            $slots[s.name] = slotDef;
+        }
+        const entry = { $type: 'component', $properties };
+        if (description !== null)
+            entry.$description = description;
+        if (Object.keys($slots).length > 0)
+            entry.$slots = $slots;
+        return { key: name, entry };
+    })
+        .filter((c) => c !== null);
+}
+export function storeDTCGTokens(db, sessionId, groups, tokens) {
+    const now = new Date().toISOString();
+    db.exec('BEGIN');
+    try {
+        db.prepare('DELETE FROM raw_token_groups WHERE session_id = ?').run(sessionId);
+        db.prepare('DELETE FROM raw_tokens WHERE session_id = ?').run(sessionId);
+        const insertGroup = db.prepare(`INSERT INTO raw_token_groups (session_id, path, description) VALUES (?, ?, ?)`);
+        for (const group of groups) {
+            insertGroup.run(sessionId, group.path, group.$description ?? null);
+        }
+        const insertToken = db.prepare(`INSERT INTO raw_tokens (session_id, path, type, value, description) VALUES (?, ?, ?, ?, ?)`);
+        for (const token of tokens) {
+            insertToken.run(sessionId, token.path, token.$type, JSON.stringify(token.$value), token.$description ?? null);
+        }
+        db.prepare('UPDATE sessions SET updated_at = ? WHERE id = ?').run(now, sessionId);
+        db.exec('COMMIT');
+    }
+    catch (e) {
+        db.exec('ROLLBACK');
+        throw e;
+    }
+}
+export function applyTokenToolCalls(db, sessionId, calls, incomingWarnings) {
+    const now = new Date().toISOString();
+    const warnings = [...incomingWarnings];
+    let tokens = 0;
+    let groups = 0;
+    const upsertToken = db.prepare(`INSERT INTO raw_tokens (session_id, path, type, value, description) VALUES (?, ?, ?, ?, ?)
+     ON CONFLICT(session_id, path) DO UPDATE SET type = excluded.type, value = excluded.value, description = excluded.description`);
+    const upsertGroup = db.prepare(`INSERT INTO raw_token_groups (session_id, path, description) VALUES (?, ?, ?)
+     ON CONFLICT(session_id, path) DO UPDATE SET description = excluded.description`);
+    db.exec('BEGIN');
+    try {
+        for (const call of calls) {
+            if (call.tool === 'set_token') {
+                upsertToken.run(sessionId, call.path, call.type, JSON.stringify(call.value), call.description ?? null);
+                tokens++;
+            }
+            else if (call.tool === 'set_group') {
+                upsertGroup.run(sessionId, call.path, call.description ?? null);
+                groups++;
+            }
+        }
+        db.prepare('UPDATE sessions SET updated_at = ? WHERE id = ?').run(now, sessionId);
+        db.exec('COMMIT');
+    }
+    catch (e) {
+        db.exec('ROLLBACK');
+        throw e;
+    }
+    return { tokens, groups, warnings };
+}
+export function loadDTCGTokens(db, sessionId) {
+    const groupRows = db
+        .prepare('SELECT path, description FROM raw_token_groups WHERE session_id = ? ORDER BY path')
+        .all(sessionId);
+    const tokenRows = db
+        .prepare('SELECT path, type, value, description FROM raw_tokens WHERE session_id = ? ORDER BY path')
+        .all(sessionId);
+    const groups = groupRows.map((r) => {
+        const prefix = `${r.path}.`;
+        const tokenIds = tokenRows
+            .filter((t) => t.path.startsWith(prefix) && !t.path.slice(prefix.length).includes('.'))
+            .map((t) => t.path);
+        const g = { path: r.path, tokenIds };
+        if (r.description !== null)
+            g.$description = r.description;
+        return g;
+    });
+    const tokens = tokenRows.map((r) => {
+        const t = {
+            path: r.path,
+            $type: r.type,
+            $value: JSON.parse(r.value),
+        };
+        if (r.description !== null)
+            t.$description = r.description;
+        return t;
+    });
+    return { groups, tokens };
+}
+export function findLatestSessionForCommand(db, command) {
+    const row = db
+        .prepare(`SELECT s.id FROM sessions s
+       JOIN steps st ON st.session_id = s.id
+       WHERE st.command = ? AND st.status = 'complete'
+       ORDER BY st.started_at DESC, st.id DESC
+       LIMIT 1`)
+        .get(command);
+    return row?.id ?? null;
+}
+export function seedCDFFromPriorSession(db, targetSessionId) {
+    // Find the most recent session (other than target) that has CDF data for any of the
+    // target's component_ids. This works regardless of which command produced the CDF.
+    const targetComponentIds = db
+        .prepare(`SELECT component_id FROM raw_components WHERE session_id = ?`)
+        .all(targetSessionId);
+    if (targetComponentIds.length === 0)
+        return 0;
+    const placeholders = targetComponentIds.map(() => '?').join(',');
+    const priorRow = db
+        .prepare(`SELECT session_id FROM raw_props
+       WHERE cdf_type IS NOT NULL AND session_id != ?
+         AND component_id IN (${placeholders})
+       ORDER BY rowid DESC LIMIT 1`)
+        .get(targetSessionId, ...targetComponentIds.map((r) => r.component_id));
+    if (!priorRow)
+        return 0;
+    const priorSessionId = priorRow.session_id;
+    // Copy CDF columns from prior session's props into matching props in the target session.
+    const result = db
+        .prepare(`UPDATE raw_props SET
+       cdf_type = (SELECT p2.cdf_type FROM raw_props p2
+                   WHERE p2.session_id = ? AND p2.component_id = raw_props.component_id
+                   AND p2.name = raw_props.name AND p2.cdf_type IS NOT NULL),
+       cdf_category = (SELECT p2.cdf_category FROM raw_props p2
+                       WHERE p2.session_id = ? AND p2.component_id = raw_props.component_id
+                       AND p2.name = raw_props.name AND p2.cdf_type IS NOT NULL),
+       cdf_token_kind = (SELECT p2.cdf_token_kind FROM raw_props p2
+                         WHERE p2.session_id = ? AND p2.component_id = raw_props.component_id
+                         AND p2.name = raw_props.name AND p2.cdf_type IS NOT NULL)
+     WHERE session_id = ? AND cdf_type IS NULL
+       AND EXISTS (SELECT 1 FROM raw_props p2
+                   WHERE p2.session_id = ? AND p2.component_id = raw_props.component_id
+                   AND p2.name = raw_props.name AND p2.cdf_type IS NOT NULL)`)
+        .run(priorSessionId, priorSessionId, priorSessionId, targetSessionId, priorSessionId);
+    // Also copy descriptions from prior session's components
+    db.prepare(`UPDATE raw_components SET description = (
+       SELECT c2.description FROM raw_components c2
+       WHERE c2.session_id = ? AND c2.component_id = raw_components.component_id
+       AND c2.description IS NOT NULL
+     )
+     WHERE session_id = ? AND description IS NULL
+       AND EXISTS (SELECT 1 FROM raw_components c2
+                   WHERE c2.session_id = ? AND c2.component_id = raw_components.component_id
+                   AND c2.description IS NOT NULL)`).run(priorSessionId, targetSessionId, priorSessionId);
+    // Copy allowed values for seeded props from prior session
+    if (result.changes > 0) {
+        db.prepare(`INSERT OR IGNORE INTO raw_prop_allowed_values (session_id, component_id, prop_name, position, value)
+       SELECT ?, av.component_id, av.prop_name, av.position, av.value
+       FROM raw_prop_allowed_values av
+       WHERE av.session_id = ?
+         AND EXISTS (SELECT 1 FROM raw_props p
+                     WHERE p.session_id = ? AND p.component_id = av.component_id
+                     AND p.name = av.prop_name AND p.cdf_type IS NOT NULL)`).run(targetSessionId, priorSessionId, targetSessionId);
+    }
+    return Number(result.changes);
+}
+export function seedCDFFromPreviewResponse(db, sessionId, removedItems) {
+    if (removedItems.length === 0)
+        return 0;
+    let totalSeeded = 0;
+    const updateStmt = db.prepare(`UPDATE raw_props
+     SET cdf_type = ?, cdf_category = ?
+     WHERE session_id = ? AND component_id = ? AND name = ? AND cdf_type IS NULL`);
+    for (const item of removedItems) {
+        if (!item.fullProperties)
+            continue;
+        const localComponent = db
+            .prepare(`SELECT component_id FROM raw_components WHERE session_id = ? AND name = ?`)
+            .get(sessionId, item.name);
+        if (!localComponent)
+            continue;
+        const contentProps = new Set(item.contentProperties);
+        const designProps = new Set(item.designProperties);
+        for (const [propName, propSummary] of Object.entries(item.fullProperties)) {
+            const cdfType = mapServerTypeToCDFType(propSummary.type);
+            if (!cdfType)
+                continue;
+            let cdfCategory = propSummary.category || null;
+            if (!cdfCategory || !['content', 'design', 'state'].includes(cdfCategory)) {
+                if (contentProps.has(propName))
+                    cdfCategory = 'content';
+                else if (designProps.has(propName))
+                    cdfCategory = 'design';
+                else
+                    cdfCategory = 'state';
+            }
+            const result = updateStmt.run(cdfType, cdfCategory, sessionId, localComponent.component_id, propName);
+            totalSeeded += Number(result.changes);
+        }
+    }
+    return totalSeeded;
+}
+/**
+ * Seeds server-side metadata for changed components:
+ * 1. Fills in defaults the server has but we don't (prevents accidental removal)
+ * 2. Seeds cdf_type/cdf_category for props that exist on server but lack CDF locally
+ *    (e.g. props with non-standard source types the generation step couldn't classify)
+ */
+export function seedDefaultsFromChangedItems(db, sessionId, changedItems) {
+    if (changedItems.length === 0)
+        return 0;
+    let totalSeeded = 0;
+    const updateDefaultStmt = db.prepare(`UPDATE raw_props SET default_value = ?
+     WHERE session_id = ? AND component_id = ? AND name = ? AND default_value IS NULL`);
+    const updateCDFStmt = db.prepare(`UPDATE raw_props SET cdf_type = ?, cdf_category = ?
+     WHERE session_id = ? AND component_id = ? AND name = ? AND cdf_type IS NULL`);
+    for (const { current } of changedItems) {
+        if (!current.fullProperties)
+            continue;
+        const localComponent = db
+            .prepare(`SELECT component_id FROM raw_components WHERE session_id = ? AND name = ?`)
+            .get(sessionId, current.name);
+        if (!localComponent)
+            continue;
+        const contentProps = new Set(current.contentProperties);
+        const designProps = new Set(current.designProperties);
+        for (const [propName, propSummary] of Object.entries(current.fullProperties)) {
+            // Seed defaults
+            if (propSummary.default !== undefined && propSummary.default !== null) {
+                const defaultStr = typeof propSummary.default === 'string' ? propSummary.default : JSON.stringify(propSummary.default);
+                const result = updateDefaultStmt.run(defaultStr, sessionId, localComponent.component_id, propName);
+                totalSeeded += Number(result.changes);
+            }
+            // Seed CDF type/category for props that lack it
+            const cdfType = mapServerTypeToCDFType(propSummary.type);
+            if (!cdfType)
+                continue;
+            let cdfCategory = propSummary.category || null;
+            if (!cdfCategory || !['content', 'design', 'state'].includes(cdfCategory)) {
+                if (contentProps.has(propName))
+                    cdfCategory = 'content';
+                else if (designProps.has(propName))
+                    cdfCategory = 'design';
+                else
+                    cdfCategory = 'state';
+            }
+            const result = updateCDFStmt.run(cdfType, cdfCategory, sessionId, localComponent.component_id, propName);
+            totalSeeded += Number(result.changes);
+        }
+    }
+    return totalSeeded;
+}
+/**
+ * Ensures all props on generated components have a cdf_type.
+ * Uses the pre-classification `category` column when available.
+ * Falls back to cdf_type: 'string', cdf_category: 'content' for props
+ * with no pre-classification (safe default — content is the most common category).
+ */
+export function backfillUnclassifiedProps(db, sessionId) {
+    // First: backfill props that HAVE a pre-classification category
+    const withCategory = db
+        .prepare(`UPDATE raw_props SET cdf_type = 'string', cdf_category = category
+     WHERE session_id = ? AND cdf_type IS NULL AND category IS NOT NULL
+       AND component_id IN (
+         SELECT component_id FROM raw_components WHERE session_id = ? AND status = 'generated'
+       )`)
+        .run(sessionId, sessionId);
+    // Second: backfill props with NO category (complex types the rules couldn't classify)
+    const withoutCategory = db
+        .prepare(`UPDATE raw_props SET cdf_type = 'string', cdf_category = 'content'
+     WHERE session_id = ? AND cdf_type IS NULL AND category IS NULL
+       AND component_id IN (
+         SELECT component_id FROM raw_components WHERE session_id = ? AND status = 'generated'
+       )`)
+        .run(sessionId, sessionId);
+    return Number(withCategory.changes) + Number(withoutCategory.changes);
+}
+function mapServerTypeToCDFType(serverType) {
+    switch (serverType.toLowerCase()) {
+        case 'string':
+        case 'text':
+            return 'string';
+        case 'richtext':
+            return 'richtext';
+        case 'media':
+            return 'media';
+        case 'link':
+            return 'link';
+        case 'enum':
+        case 'symbol':
+            return 'enum';
+        case 'token':
+            return 'token';
+        case 'boolean':
+            return 'boolean';
+        default:
+            return 'string';
+    }
+}
+export function computeComponentInputHash(component) {
+    const payload = {
+        framework: component.framework,
+        name: component.name,
+        props: component.props.map((p) => ({
+            allowedValues: p.allowedValues ?? [],
+            defaultValue: p.defaultValue ?? null,
+            description: p.description ?? null,
+            name: p.name,
+            required: p.required,
+            tokenReference: p.tokenReference ?? null,
+            type: p.type,
+        })),
+        slots: component.slots.map((s) => ({
+            allowedComponents: s.allowedComponents ?? [],
+            description: s.description ?? null,
+            isDefault: s.isDefault,
+            name: s.name,
+        })),
+        source: component.source,
+    };
+    return createHash('sha256').update(JSON.stringify(payload)).digest('hex');
+}
+export function computeTokenInputHash(rawTokenContent) {
+    return createHash('sha256').update(rawTokenContent.trim()).digest('hex');
+}
+export function lookupCache(db, inputHash, entityType, entityId) {
+    const row = db
+        .prepare(`SELECT input_hash, entity_type, entity_id, source_session_id, human_edited, created_at, updated_at
+       FROM generation_cache
+       WHERE input_hash = ? AND entity_type = ? AND entity_id = ?`)
+        .get(inputHash, entityType, entityId);
+    if (!row)
+        return null;
+    return {
+        inputHash: row.input_hash,
+        entityType: row.entity_type,
+        entityId: row.entity_id,
+        sourceSessionId: row.source_session_id,
+        humanEdited: row.human_edited === 1,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    };
+}
+export function lookupCacheByEntity(db, entityType, entityId) {
+    const row = db
+        .prepare(`SELECT input_hash, entity_type, entity_id, source_session_id, human_edited, created_at, updated_at
+       FROM generation_cache
+       WHERE entity_type = ? AND entity_id = ?
+       ORDER BY updated_at DESC LIMIT 1`)
+        .get(entityType, entityId);
+    if (!row)
+        return null;
+    return {
+        inputHash: row.input_hash,
+        entityType: row.entity_type,
+        entityId: row.entity_id,
+        sourceSessionId: row.source_session_id,
+        humanEdited: row.human_edited === 1,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    };
+}
+export function storeCache(db, inputHash, entityType, entityId, sourceSessionId, humanEdited) {
+    const now = new Date().toISOString();
+    db.prepare(`INSERT INTO generation_cache (input_hash, entity_type, entity_id, source_session_id, human_edited, created_at, updated_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?)
+     ON CONFLICT(input_hash, entity_type, entity_id) DO UPDATE SET
+       source_session_id = excluded.source_session_id,
+       human_edited = CASE WHEN generation_cache.human_edited = 1 THEN 1 ELSE excluded.human_edited END,
+       updated_at = excluded.updated_at`).run(inputHash, entityType, entityId, sourceSessionId, humanEdited ? 1 : 0, now, now);
+}
+export function markCacheHumanEdited(db, entityType, entityId) {
+    const now = new Date().toISOString();
+    db.prepare(`UPDATE generation_cache SET human_edited = 1, updated_at = ? WHERE entity_type = ? AND entity_id = ?`).run(now, entityType, entityId);
+}
+export function copyComponentFromCache(db, sourceSessionId, targetSessionId, componentId) {
+    const now = new Date().toISOString();
+    db.exec('BEGIN');
+    try {
+        const srcComp = db
+            .prepare(`SELECT description, status FROM raw_components WHERE session_id = ? AND component_id = ?`)
+            .get(sourceSessionId, componentId);
+        if (srcComp) {
+            db.prepare(`UPDATE raw_components SET description = ?, status = ?, extracted_at = ? WHERE session_id = ? AND component_id = ?`).run(srcComp.description, srcComp.status, now, targetSessionId, componentId);
+        }
+        const srcProps = db
+            .prepare(`SELECT name, cdf_type, cdf_category, cdf_token_kind, required, description, default_value
+         FROM raw_props WHERE session_id = ? AND component_id = ?`)
+            .all(sourceSessionId, componentId);
+        for (const p of srcProps) {
+            db.prepare(`UPDATE raw_props SET cdf_type = ?, cdf_category = ?, cdf_token_kind = ?, required = ?, description = ?, default_value = ?
+         WHERE session_id = ? AND component_id = ? AND name = ?`).run(p.cdf_type, p.cdf_category, p.cdf_token_kind, p.required, p.description, p.default_value, targetSessionId, componentId, p.name);
+        }
+        db.prepare(`DELETE FROM raw_prop_allowed_values WHERE session_id = ? AND component_id = ?`).run(targetSessionId, componentId);
+        const srcAV = db
+            .prepare(`SELECT prop_name, position, value FROM raw_prop_allowed_values WHERE session_id = ? AND component_id = ?`)
+            .all(sourceSessionId, componentId);
+        const insertAV = db.prepare(`INSERT INTO raw_prop_allowed_values (session_id, component_id, prop_name, position, value) VALUES (?, ?, ?, ?, ?)`);
+        for (const av of srcAV) {
+            insertAV.run(targetSessionId, componentId, av.prop_name, av.position, av.value);
+        }
+        const srcSlots = db
+            .prepare(`SELECT name, required, description FROM raw_slots WHERE session_id = ? AND component_id = ?`)
+            .all(sourceSessionId, componentId);
+        for (const s of srcSlots) {
+            db.prepare(`UPDATE raw_slots SET required = ?, description = ? WHERE session_id = ? AND component_id = ? AND name = ?`).run(s.required, s.description, targetSessionId, componentId, s.name);
+        }
+        db.prepare(`DELETE FROM raw_slot_allowed_components WHERE session_id = ? AND component_id = ?`).run(targetSessionId, componentId);
+        const srcSAC = db
+            .prepare(`SELECT slot_name, position, allowed_component FROM raw_slot_allowed_components WHERE session_id = ? AND component_id = ?`)
+            .all(sourceSessionId, componentId);
+        const insertSAC = db.prepare(`INSERT INTO raw_slot_allowed_components (session_id, component_id, slot_name, allowed_component, position) VALUES (?, ?, ?, ?, ?)`);
+        for (const sac of srcSAC) {
+            insertSAC.run(targetSessionId, componentId, sac.slot_name, sac.allowed_component, sac.position);
+        }
+        db.prepare('UPDATE sessions SET updated_at = ? WHERE id = ?').run(now, targetSessionId);
+        db.exec('COMMIT');
+    }
+    catch (e) {
+        db.exec('ROLLBACK');
+        throw e;
+    }
+}
+export function copyTokensFromCache(db, sourceSessionId, targetSessionId) {
+    const now = new Date().toISOString();
+    db.exec('BEGIN');
+    try {
+        db.prepare('DELETE FROM raw_tokens WHERE session_id = ?').run(targetSessionId);
+        db.prepare('DELETE FROM raw_token_groups WHERE session_id = ?').run(targetSessionId);
+        db.prepare(`INSERT INTO raw_token_groups (session_id, path, description)
+       SELECT ?, path, description FROM raw_token_groups WHERE session_id = ?`).run(targetSessionId, sourceSessionId);
+        db.prepare(`INSERT INTO raw_tokens (session_id, path, type, value, description)
+       SELECT ?, path, type, value, description FROM raw_tokens WHERE session_id = ?`).run(targetSessionId, sourceSessionId);
+        db.prepare('UPDATE sessions SET updated_at = ? WHERE id = ?').run(now, targetSessionId);
+        db.exec('COMMIT');
+    }
+    catch (e) {
+        db.exec('ROLLBACK');
+        throw e;
+    }
+}