mockpit 0.0.0-stage → 1.0.0

package/dist/server/sqlStore.js

@@ -0,0 +1,954 @@
+import { collectAssetIds, DEFAULT_PROJECT, DEFAULT_VARIANT, hashAssetId, HISTORY_LIMIT, htmlSurface, MAX_WORKSPACE_ASSET_BYTES, newId, normalizeSurfaceIds, projectFromCwd, reservedAgent, selectEvictions, slugify, stripNul, summarizeProjects, } from "./types.js";
+function parseJson(raw, fallback) {
+    if (typeof raw !== "string" || !raw)
+        return fallback;
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return fallback;
+    }
+}
+const POST_COLUMNS = `
+  id TEXT PRIMARY KEY, sessionId TEXT NOT NULL, mockId TEXT NOT NULL, state TEXT,
+  variant TEXT NOT NULL, status TEXT NOT NULL DEFAULT 'open', title TEXT NOT NULL,
+  surfaces TEXT NOT NULL, knobs TEXT, slots TEXT NOT NULL DEFAULT '[]',
+  createdAt TEXT NOT NULL, updatedAt TEXT NOT NULL, version INTEGER NOT NULL,
+  curFrom INTEGER, curPrompt TEXT, curAuthor TEXT`;
+// Store implementation on SQLite — a Durable Object's `ctx.storage.sql` in the
+// Worker, or node:sqlite via an adapter on Node (see server/sqliteStorage.ts).
+// One workspace = one database, so plain SQL with no tenant columns.
+export class SqlStore {
+    sql;
+    // Cached set of asset ids referenced by any live surface (current or a
+    // historical version of any post). Built lazily and maintained incrementally
+    // — post writes add to it, removes invalidate it — so isAssetReferenced (hit
+    // on every /a/:id miss) and putAsset's eviction scan don't re-parse every
+    // post's surfaces on each call. Stays correct because history is append-only:
+    // an asset id once referenced stays referenced until its post is deleted.
+    assetRefCache;
+    constructor(sql) {
+        this.sql = sql;
+        this.atomic(() => this.migrate());
+    }
+    // On a Durable Object the synchronous writes of one event already commit as a
+    // unit, so its SqlStorage has no transactionSync; node:sqlite provides one.
+    atomic(fn) {
+        return this.sql.transactionSync ? this.sql.transactionSync(fn) : fn();
+    }
+    tables() {
+        return new Set(this.sql
+            .exec("SELECT name FROM sqlite_master WHERE type = 'table'")
+            .toArray()
+            .map((t) => t.name));
+    }
+    columns(table) {
+        return new Set(this.sql
+            .exec(`SELECT name FROM pragma_table_info('${table}')`)
+            .toArray()
+            .map((c) => c.name));
+    }
+    // SQLite has no ADD COLUMN IF NOT EXISTS, so probe and patch.
+    addMissing(table, columns) {
+        const have = this.columns(table);
+        for (const [name, decl] of Object.entries(columns)) {
+            if (!have.has(name))
+                this.sql.exec(`ALTER TABLE ${table} ADD COLUMN ${name} ${decl}`);
+        }
+    }
+    migrate() {
+        const before = this.tables();
+        // Deployed Durable Objects can never be reset, so a workspace written by a
+        // build from before mocks existed is lifted in place (see migrateLegacy).
+        const legacy = before.has("posts") && !before.has("mocks");
+        this.sql.exec(`
+      CREATE TABLE IF NOT EXISTS sessions (
+        id TEXT PRIMARY KEY, agent TEXT NOT NULL, title TEXT, cwd TEXT,
+        createdAt TEXT NOT NULL, lastActiveAt TEXT NOT NULL,
+        agentSeq INTEGER NOT NULL DEFAULT 0, project TEXT, key TEXT
+      );
+      CREATE TABLE IF NOT EXISTS mocks (
+        id TEXT PRIMARY KEY, project TEXT NOT NULL, slug TEXT NOT NULL, title TEXT NOT NULL,
+        kind TEXT NOT NULL DEFAULT 'component', states TEXT NOT NULL DEFAULT '[]',
+        asks TEXT NOT NULL DEFAULT '[]', knobs TEXT NOT NULL DEFAULT '{}', draft TEXT,
+        sessionId TEXT, createdAt TEXT NOT NULL, updatedAt TEXT NOT NULL
+      );
+      CREATE TABLE IF NOT EXISTS posts (${POST_COLUMNS});
+      CREATE TABLE IF NOT EXISTS post_versions (
+        postId TEXT NOT NULL, version INTEGER NOT NULL, title TEXT NOT NULL,
+        surfaces TEXT NOT NULL, at TEXT NOT NULL,
+        fromVersion INTEGER, prompt TEXT, author TEXT,
+        PRIMARY KEY (postId, version)
+      );
+      CREATE TABLE IF NOT EXISTS comments (
+        seq INTEGER PRIMARY KEY AUTOINCREMENT, id TEXT NOT NULL,
+        sessionId TEXT NOT NULL, mockId TEXT, postId TEXT,
+        author TEXT NOT NULL, text TEXT NOT NULL, createdAt TEXT NOT NULL,
+        kind TEXT NOT NULL DEFAULT 'comment', anchor TEXT, anchors TEXT NOT NULL DEFAULT '[]',
+        postVersion INTEGER, viewport INTEGER, payload TEXT
+      );
+      CREATE TABLE IF NOT EXISTS assets (
+        id TEXT PRIMARY KEY, sessionId TEXT NOT NULL, kind TEXT NOT NULL,
+        contentType TEXT NOT NULL, byteLength INTEGER NOT NULL, filename TEXT,
+        data BLOB NOT NULL, createdAt TEXT NOT NULL, lastAccessedAt TEXT NOT NULL
+      );
+      CREATE TABLE IF NOT EXISTS settings (
+        key TEXT PRIMARY KEY, value TEXT NOT NULL
+      );
+    `);
+        this.addMissing("sessions", {
+            agentSeq: "INTEGER NOT NULL DEFAULT 0",
+            project: "TEXT",
+            key: "TEXT",
+        });
+        if (legacy)
+            this.migrateLegacy();
+        this.createIndexes();
+    }
+    createIndexes() {
+        this.sql.exec(`
+      CREATE UNIQUE INDEX IF NOT EXISTS mockpit_mocks_slug_idx ON mocks (project, slug);
+      CREATE INDEX IF NOT EXISTS mockpit_mocks_updated_at_idx ON mocks (updatedAt DESC);
+      CREATE INDEX IF NOT EXISTS mockpit_posts_mock_idx ON posts (mockId, state, variant);
+      CREATE INDEX IF NOT EXISTS mockpit_posts_session_created_at_idx ON posts (sessionId, createdAt);
+      CREATE INDEX IF NOT EXISTS mockpit_comments_session_seq_idx ON comments (sessionId, seq);
+      CREATE INDEX IF NOT EXISTS mockpit_comments_mock_seq_idx ON comments (mockId, seq);
+      CREATE INDEX IF NOT EXISTS mockpit_comments_post_seq_idx ON comments (postId, seq);
+      CREATE INDEX IF NOT EXISTS mockpit_comments_id_idx ON comments (id);
+      CREATE INDEX IF NOT EXISTS mockpit_assets_session_idx ON assets (sessionId);
+      CREATE INDEX IF NOT EXISTS mockpit_sessions_key_idx ON sessions (key);
+    `);
+    }
+    // --- in-place migration of a pre-mock workspace ---
+    migrateLegacy() {
+        this.addMissing("comments", {
+            anchor: "TEXT",
+            kind: "TEXT NOT NULL DEFAULT 'comment'",
+            anchors: "TEXT NOT NULL DEFAULT '[]'",
+            draft: "INTEGER NOT NULL DEFAULT 0",
+            postVersion: "INTEGER",
+            viewport: "INTEGER",
+            mockId: "TEXT",
+            payload: "TEXT",
+        });
+        this.migrateToSurfaces();
+        this.migrateToPosts();
+        this.migrateSurfaceIds();
+        this.migrateToItems();
+        this.migrateToVersions();
+        this.migrateToMocks();
+        this.sql.exec(`
+      DROP TABLE IF EXISTS trace_steps;
+      DROP INDEX IF EXISTS mockpit_comments_post_draft_idx;
+      DROP INDEX IF EXISTS mockpit_posts_updated_at_idx;
+      DROP INDEX IF EXISTS sideshow_posts_session_created_at_idx;
+      DROP INDEX IF EXISTS sideshow_posts_updated_at_idx;
+      DROP INDEX IF EXISTS sideshow_comments_session_seq_idx;
+      DROP INDEX IF EXISTS sideshow_comments_post_seq_idx;
+      DROP INDEX IF EXISTS sideshow_comments_id_idx;
+      DROP INDEX IF EXISTS sideshow_assets_session_idx;
+      DROP INDEX IF EXISTS sideshow_posts_variant_idx;
+      DROP INDEX IF EXISTS sideshow_comments_post_draft_idx;
+    `);
+    }
+    // Pre-0.5.0 workspaces stored a `snippets` table and `comments.snippetId`.
+    migrateToSurfaces() {
+        const commentCols = this.columns("comments");
+        if (commentCols.has("snippetId") && !commentCols.has("surfaceId")) {
+            this.sql.exec("ALTER TABLE comments RENAME COLUMN snippetId TO surfaceId");
+        }
+        if (commentCols.has("snippetTitle") && !commentCols.has("surfaceTitle")) {
+            this.sql.exec("ALTER TABLE comments RENAME COLUMN snippetTitle TO surfaceTitle");
+        }
+        if (!this.tables().has("snippets"))
+            return;
+        for (const r of this.sql.exec("SELECT * FROM snippets").toArray()) {
+            const legacyHistory = parseJson(r.history, []);
+            const history = legacyHistory.map((h) => ({
+                version: h.version,
+                title: h.title,
+                surfaces: [htmlSurface(h.html)],
+                at: h.at,
+            }));
+            this.sql.exec("INSERT OR IGNORE INTO posts (id, sessionId, title, surfaces, createdAt, updatedAt, version, history) VALUES (?, ?, ?, ?, ?, ?, ?, ?)", r.id, r.sessionId, r.title, JSON.stringify([htmlSurface(r.html)]), r.createdAt, r.updatedAt, r.version, JSON.stringify(history));
+        }
+        this.sql.exec("DROP TABLE snippets");
+    }
+    // 0.5.x workspaces stored a `surfaces` table with a `parts` column and
+    // `comments.surfaceId/surfaceTitle`.
+    migrateToPosts() {
+        const commentCols = this.columns("comments");
+        if (commentCols.has("surfaceId") && !commentCols.has("postId")) {
+            this.sql.exec("ALTER TABLE comments RENAME COLUMN surfaceId TO postId");
+        }
+        if (commentCols.has("surfaceTitle") && !commentCols.has("postTitle")) {
+            this.sql.exec("ALTER TABLE comments RENAME COLUMN surfaceTitle TO postTitle");
+        }
+        if (!this.tables().has("surfaces"))
+            return;
+        for (const r of this.sql.exec("SELECT * FROM surfaces").toArray()) {
+            const history = parseJson(r.history, []).map(({ parts, ...rest }) => ({ ...rest, surfaces: parts ?? [] }));
+            this.sql.exec("INSERT OR IGNORE INTO posts (id, sessionId, title, surfaces, createdAt, updatedAt, version, history) VALUES (?, ?, ?, ?, ?, ?, ?, ?)", r.id, r.sessionId, r.title, r.parts, r.createdAt, r.updatedAt, r.version, JSON.stringify(history));
+        }
+        this.sql.exec("DROP TABLE surfaces");
+    }
+    // Assign stable ids to surfaces written before surface ids existed.
+    migrateSurfaceIds() {
+        if (this.settingSync("surfaceIdsMigrated") === "1")
+            return;
+        for (const r of this.sql.exec("SELECT id, surfaces, history FROM posts").toArray()) {
+            const surfaces = normalizeSurfaceIds(parseJson(r.surfaces, []));
+            const history = parseJson(r.history, []).map((h) => ({
+                ...h,
+                surfaces: normalizeSurfaceIds(h.surfaces ?? []),
+            }));
+            this.sql.exec("UPDATE posts SET surfaces = ?, history = ? WHERE id = ?", JSON.stringify(surfaces), JSON.stringify(history), r.id);
+        }
+    }
+    // Before items, posts had no project/slug/variant; derive them per post.
+    migrateToItems() {
+        this.addMissing("posts", {
+            project: "TEXT NOT NULL DEFAULT 'workspace'",
+            slug: "TEXT NOT NULL DEFAULT ''",
+            kind: "TEXT NOT NULL DEFAULT 'component'",
+            variant: "TEXT NOT NULL DEFAULT 'default'",
+            status: "TEXT NOT NULL DEFAULT 'open'",
+            slots: "TEXT NOT NULL DEFAULT '[]'",
+            curFrom: "INTEGER",
+            curPrompt: "TEXT",
+            curAuthor: "TEXT",
+        });
+        if (this.settingSync("itemsMigrated") === "1")
+            return;
+        const sessions = new Map();
+        for (const r of this.sql.exec("SELECT id, project, cwd FROM sessions").toArray()) {
+            sessions.set(r.id, {
+                project: r.project ?? null,
+                cwd: r.cwd ?? null,
+            });
+        }
+        const taken = new Map();
+        for (const r of this.sql
+            .exec("SELECT id, sessionId, title, slug FROM posts ORDER BY createdAt ASC")
+            .toArray()) {
+            if ((r.slug ?? "") !== "")
+                continue;
+            const session = sessions.get(r.sessionId);
+            const project = session?.project || projectFromCwd(session?.cwd ?? null) || DEFAULT_PROJECT;
+            let used = taken.get(project);
+            if (!used)
+                taken.set(project, (used = new Set()));
+            const base = slugify(r.title);
+            const suffix = r.id
+                .slice(0, 4)
+                .toLowerCase()
+                .replace(/[^a-z0-9]/g, "0");
+            let slug = `${base}-${suffix}`;
+            for (let n = 2; used.has(slug); n++)
+                slug = `${base}-${suffix}-${n}`;
+            used.add(slug);
+            this.sql.exec("UPDATE posts SET project = ?, slug = ? WHERE id = ?", project, slug, r.id);
+        }
+    }
+    // History used to live in a `history` JSON blob on the post row.
+    migrateToVersions() {
+        if (this.settingSync("versionsMigrated") === "1")
+            return;
+        for (const r of this.sql.exec("SELECT id, history FROM posts").toArray()) {
+            for (const h of parseJson(r.history, [])) {
+                this.insertVersion(r.id, {
+                    ...h,
+                    surfaces: normalizeSurfaceIds(h.surfaces ?? []),
+                });
+            }
+        }
+    }
+    // Every (project, item slug) becomes one single-state mock; its posts become
+    // the mock's variants with state null. Unsent operator drafts become the
+    // mock's draft so they are still there to send; decisions become plain
+    // comments (they were already delivered).
+    migrateToMocks() {
+        const rows = this.sql.exec("SELECT * FROM posts ORDER BY createdAt ASC, rowid ASC").toArray();
+        const groups = new Map();
+        for (const r of rows) {
+            const key = `${r.project}\u0000${r.slug}`;
+            const list = groups.get(key);
+            if (list)
+                list.push(r);
+            else
+                groups.set(key, [r]);
+        }
+        const mockOf = new Map();
+        const variantOf = new Map();
+        for (const group of groups.values()) {
+            const first = group[0];
+            const latest = group.reduce((a, b) => b.updatedAt > a.updatedAt ? b : a);
+            const id = newId();
+            this.sql.exec("INSERT INTO mocks (id, project, slug, title, kind, states, asks, knobs, draft, sessionId, createdAt, updatedAt) VALUES (?, ?, ?, ?, ?, '[]', '[]', '{}', NULL, ?, ?, ?)", id, first.project || DEFAULT_PROJECT, first.slug || slugify(first.title), first.title, group.some((r) => r.kind === "page") ? "page" : "component", latest.sessionId, first.createdAt, latest.updatedAt);
+            const used = new Set();
+            for (const r of group) {
+                const base = r.variant || DEFAULT_VARIANT;
+                let variant = base;
+                for (let n = 2; used.has(variant); n++)
+                    variant = `${base}-${n}`;
+                used.add(variant);
+                mockOf.set(r.id, id);
+                variantOf.set(r.id, variant);
+            }
+        }
+        this.sql.exec(`CREATE TABLE posts_next (${POST_COLUMNS})`);
+        for (const r of rows) {
+            const id = r.id;
+            this.sql.exec("INSERT INTO posts_next (id, sessionId, mockId, state, variant, status, title, surfaces, knobs, slots, createdAt, updatedAt, version, curFrom, curPrompt, curAuthor) VALUES (?, ?, ?, NULL, ?, ?, ?, ?, NULL, ?, ?, ?, ?, ?, ?, ?)", id, r.sessionId, mockOf.get(id), variantOf.get(id), r.status || "open", r.title, r.surfaces, r.slots || "[]", r.createdAt, r.updatedAt, r.version, r.curFrom ?? null, r.curPrompt ?? null, r.curAuthor ?? null);
+        }
+        this.sql.exec("DROP TABLE posts");
+        this.sql.exec("ALTER TABLE posts_next RENAME TO posts");
+        this.sql.exec("UPDATE comments SET mockId = (SELECT mockId FROM posts WHERE posts.id = comments.postId) WHERE mockId IS NULL");
+        this.sql.exec("UPDATE comments SET text = (CASE kind WHEN 'accept' THEN 'Accepted' WHEN 'revise' THEN 'Revise' ELSE 'Dropped' END) || (CASE WHEN text = '' THEN '' ELSE ': ' || text END), kind = 'comment' WHERE kind IN ('accept', 'revise', 'drop')");
+        const drafts = new Map();
+        for (const c of this.sql
+            .exec("SELECT * FROM comments WHERE draft = 1 AND mockId IS NOT NULL ORDER BY seq ASC")
+            .toArray()) {
+            const mockId = c.mockId;
+            let draft = drafts.get(mockId);
+            if (!draft) {
+                draft = {
+                    version: 1,
+                    answers: {},
+                    mix: {},
+                    tuned: {},
+                    comments: [],
+                    updatedAt: c.createdAt,
+                };
+                drafts.set(mockId, draft);
+            }
+            draft.version = Math.max(draft.version, c.postVersion ?? 1);
+            draft.comments.push({ part: null, state: null, text: c.text });
+            draft.updatedAt = c.createdAt;
+        }
+        for (const [mockId, draft] of drafts) {
+            this.sql.exec("UPDATE mocks SET draft = ? WHERE id = ?", JSON.stringify(draft), mockId);
+        }
+        this.sql.exec("DELETE FROM comments WHERE draft = 1");
+    }
+    settingSync(key) {
+        const rows = this.sql.exec("SELECT value FROM settings WHERE key = ?", key).toArray();
+        return rows.length ? rows[0].value : null;
+    }
+    // --- rows ---
+    insertVersion(postId, v) {
+        this.sql.exec("INSERT OR REPLACE INTO post_versions (postId, version, title, surfaces, at, fromVersion, prompt, author) VALUES (?, ?, ?, ?, ?, ?, ?, ?)", postId, v.version, v.title, JSON.stringify(v.surfaces ?? []), v.at, v.from ?? null, v.prompt ?? null, v.author ?? null);
+    }
+    rowToVersion(r) {
+        return {
+            version: r.version,
+            title: r.title,
+            surfaces: parseJson(r.surfaces, []),
+            at: r.at,
+            // Absent stays absent: the store contract compares entries whole.
+            ...(r.fromVersion == null ? {} : { from: r.fromVersion }),
+            ...(r.prompt == null ? {} : { prompt: r.prompt }),
+            ...(r.author == null ? {} : { author: r.author }),
+        };
+    }
+    historiesFor(ids) {
+        const out = new Map();
+        if (ids.length === 0)
+            return out;
+        const rows = this.sql
+            .exec(`SELECT * FROM post_versions WHERE postId IN (${ids.map(() => "?").join(",")}) ORDER BY version ASC`, ...ids)
+            .toArray();
+        for (const r of rows) {
+            const id = r.postId;
+            let list = out.get(id);
+            if (!list)
+                out.set(id, (list = []));
+            list.push(this.rowToVersion(r));
+        }
+        return out;
+    }
+    rowsToPosts(rows) {
+        const histories = this.historiesFor(rows.map((r) => r.id));
+        return rows.map((r) => this.rowToPost(r, histories.get(r.id) ?? []));
+    }
+    rowToSession(r) {
+        return {
+            id: r.id,
+            agent: r.agent,
+            title: r.title ?? null,
+            cwd: r.cwd ?? null,
+            createdAt: r.createdAt,
+            lastActiveAt: r.lastActiveAt,
+            agentSeq: r.agentSeq ?? 0,
+            project: r.project ?? null,
+        };
+    }
+    rowToMock(r) {
+        return {
+            id: r.id,
+            project: r.project,
+            slug: r.slug,
+            title: r.title,
+            kind: (r.kind === "page" ? "page" : "component"),
+            states: parseJson(r.states, []),
+            asks: parseJson(r.asks, []),
+            knobs: parseJson(r.knobs, {}),
+            draft: parseJson(r.draft, null),
+            sessionId: r.sessionId ?? null,
+            createdAt: r.createdAt,
+            updatedAt: r.updatedAt,
+        };
+    }
+    rowToPost(r, history) {
+        const knobs = parseJson(r.knobs, null);
+        return {
+            id: r.id,
+            sessionId: r.sessionId,
+            mock: r.mockId,
+            state: r.state ?? null,
+            variant: r.variant,
+            status: (r.status || "open"),
+            title: r.title,
+            surfaces: parseJson(r.surfaces, []),
+            createdAt: r.createdAt,
+            updatedAt: r.updatedAt,
+            version: r.version,
+            history,
+            ...(knobs ? { knobs } : {}),
+            slots: parseJson(r.slots, []),
+            ...(r.curFrom == null ? {} : { from: r.curFrom }),
+            ...(r.curPrompt == null ? {} : { prompt: r.curPrompt }),
+            ...(r.curAuthor == null ? {} : { author: r.curAuthor }),
+        };
+    }
+    // The BLOB comes back as an ArrayBuffer (real DO) or a Uint8Array
+    // (node:sqlite); `new Uint8Array(raw)` copies from either into a fresh array.
+    rowToAsset(r) {
+        const raw = r.data;
+        return {
+            id: r.id,
+            sessionId: r.sessionId,
+            kind: r.kind === "image" ? "image" : "file",
+            contentType: r.contentType,
+            byteLength: r.byteLength,
+            filename: r.filename ?? null,
+            data: new Uint8Array(raw),
+            createdAt: r.createdAt,
+            lastAccessedAt: r.lastAccessedAt,
+        };
+    }
+    rowToComment(r) {
+        const anchor = parseJson(r.anchor, null);
+        const payload = parseJson(r.payload, null);
+        return {
+            id: r.id,
+            seq: r.seq,
+            sessionId: r.sessionId,
+            mockId: r.mockId ?? null,
+            postId: r.postId ?? null,
+            author: r.author,
+            text: r.text,
+            createdAt: r.createdAt,
+            ...(anchor ? { anchor } : {}),
+            kind: (r.kind || "comment"),
+            anchors: parseJson(r.anchors, []),
+            postVersion: r.postVersion == null ? null : r.postVersion,
+            viewport: r.viewport == null ? null : r.viewport,
+            ...(payload ? { payload } : {}),
+        };
+    }
+    // --- sessions ---
+    async listSessions() {
+        return this.sql
+            .exec("SELECT * FROM sessions ORDER BY lastActiveAt DESC")
+            .toArray()
+            .map((r) => this.rowToSession(r));
+    }
+    async getSession(id) {
+        const rows = this.sql.exec("SELECT * FROM sessions WHERE id = ?", id).toArray();
+        return rows.length > 0 ? this.rowToSession(rows[0]) : null;
+    }
+    async getSessionByKey(key) {
+        const rows = this.sql
+            .exec("SELECT * FROM sessions WHERE key = ? ORDER BY lastActiveAt DESC LIMIT 1", key)
+            .toArray();
+        return rows.length > 0 ? this.rowToSession(rows[0]) : null;
+    }
+    async createSession(input) {
+        const now = new Date().toISOString();
+        const session = {
+            id: newId(),
+            agent: reservedAgent(stripNul(input.agent).trim() || "agent"),
+            title: stripNul(input.title)?.trim() || null,
+            cwd: stripNul(input.cwd ?? null),
+            createdAt: now,
+            lastActiveAt: now,
+            agentSeq: 0,
+            project: stripNul(input.project)?.trim() || projectFromCwd(stripNul(input.cwd ?? null)) || null,
+        };
+        this.sql.exec("INSERT INTO sessions (id, agent, title, cwd, createdAt, lastActiveAt, agentSeq, project, key) VALUES (?, ?, ?, ?, ?, ?, 0, ?, ?)", session.id, session.agent, session.title, session.cwd, session.createdAt, session.lastActiveAt, session.project, stripNul(input.key)?.trim() || null);
+        return session;
+    }
+    async renameSession(id, title) {
+        const session = await this.getSession(id);
+        if (!session)
+            return null;
+        session.title = stripNul(title).trim() || null;
+        this.sql.exec("UPDATE sessions SET title = ? WHERE id = ?", session.title, id);
+        return session;
+    }
+    async removeSession(id) {
+        if (!(await this.getSession(id)))
+            return false;
+        this.atomic(() => {
+            this.sql.exec("DELETE FROM comments WHERE sessionId = ?", id);
+            this.sql.exec("DELETE FROM post_versions WHERE postId IN (SELECT id FROM posts WHERE sessionId = ?)", id);
+            this.sql.exec("DELETE FROM posts WHERE sessionId = ?", id);
+            // A mock left with no variants has nothing to show.
+            this.sql.exec("DELETE FROM comments WHERE mockId IN (SELECT id FROM mocks WHERE id NOT IN (SELECT mockId FROM posts))");
+            this.sql.exec("DELETE FROM mocks WHERE id NOT IN (SELECT mockId FROM posts)");
+            this.sql.exec("UPDATE mocks SET sessionId = NULL WHERE sessionId = ?", id);
+            // Posts are gone, so the referenced set reflects survivors only: drop this
+            // session's own assets except any a surviving surface still points at
+            // (assets are content-addressed and may be shared across sessions).
+            this.invalidateAssetRefs();
+            const referenced = this.referencedAssetIds();
+            for (const r of this.sql.exec("SELECT id FROM assets WHERE sessionId = ?", id).toArray()) {
+                const aid = r.id;
+                if (!referenced.has(aid))
+                    this.sql.exec("DELETE FROM assets WHERE id = ?", aid);
+            }
+            this.sql.exec("DELETE FROM sessions WHERE id = ?", id);
+        });
+        return true;
+    }
+    touch(sessionId) {
+        this.sql.exec("UPDATE sessions SET lastActiveAt = ? WHERE id = ?", new Date().toISOString(), sessionId);
+    }
+    async markAgentSeen(sessionId, seq) {
+        this.sql.exec("UPDATE sessions SET agentSeq = ? WHERE id = ? AND agentSeq < ?", seq, sessionId, seq);
+    }
+    // --- settings ---
+    async getSetting(key) {
+        return this.settingSync(key);
+    }
+    async setSetting(key, value) {
+        if (key.startsWith("design:"))
+            this.invalidateAssetRefs();
+        this.sql.exec("INSERT INTO settings (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value", stripNul(key), stripNul(value));
+    }
+    // --- projects / mocks ---
+    async listProjects() {
+        return summarizeProjects(await this.listMocks(), await this.listSessions(), await this.listPosts());
+    }
+    async listMocks(project) {
+        const rows = project === undefined
+            ? this.sql.exec("SELECT * FROM mocks ORDER BY updatedAt DESC, rowid DESC").toArray()
+            : this.sql
+                .exec("SELECT * FROM mocks WHERE project = ? ORDER BY updatedAt DESC, rowid DESC", project)
+                .toArray();
+        return rows.map((r) => this.rowToMock(r));
+    }
+    async getMock(id) {
+        const rows = this.sql.exec("SELECT * FROM mocks WHERE id = ?", id).toArray();
+        return rows.length > 0 ? this.rowToMock(rows[0]) : null;
+    }
+    async findMock(project, slug) {
+        const rows = this.sql
+            .exec("SELECT * FROM mocks WHERE project = ? AND slug = ?", project, slug)
+            .toArray();
+        return rows.length > 0 ? this.rowToMock(rows[0]) : null;
+    }
+    async createMock(input) {
+        const now = new Date().toISOString();
+        const mock = {
+            id: newId(),
+            project: stripNul(input.project).trim() || DEFAULT_PROJECT,
+            slug: slugify(stripNul(input.slug)),
+            title: stripNul(input.title)?.trim() || input.slug,
+            kind: input.kind === "page" ? "page" : "component",
+            states: (input.states ?? []).map((s) => stripNul(s)),
+            asks: [],
+            knobs: input.knobs ?? {},
+            draft: null,
+            sessionId: input.sessionId ?? null,
+            createdAt: now,
+            updatedAt: now,
+        };
+        this.sql.exec("INSERT INTO mocks (id, project, slug, title, kind, states, asks, knobs, draft, sessionId, createdAt, updatedAt) VALUES (?, ?, ?, ?, ?, ?, '[]', ?, NULL, ?, ?, ?)", mock.id, mock.project, mock.slug, mock.title, mock.kind, JSON.stringify(mock.states), JSON.stringify(mock.knobs), mock.sessionId, mock.createdAt, mock.updatedAt);
+        return mock;
+    }
+    async updateMock(id, patch) {
+        const mock = await this.getMock(id);
+        if (!mock)
+            return null;
+        const next = {
+            ...mock,
+            ...(patch.title !== undefined && { title: stripNul(patch.title).trim() || mock.title }),
+            ...(patch.kind !== undefined && { kind: patch.kind }),
+            ...(patch.states !== undefined && { states: patch.states.map((s) => stripNul(s)) }),
+            ...(patch.asks !== undefined && { asks: patch.asks }),
+            ...(patch.knobs !== undefined && { knobs: patch.knobs }),
+            ...(patch.sessionId !== undefined && { sessionId: patch.sessionId }),
+            updatedAt: new Date().toISOString(),
+        };
+        this.sql.exec("UPDATE mocks SET title = ?, kind = ?, states = ?, asks = ?, knobs = ?, sessionId = ?, updatedAt = ? WHERE id = ?", next.title, next.kind, JSON.stringify(next.states), JSON.stringify(next.asks), JSON.stringify(next.knobs), next.sessionId, next.updatedAt, id);
+        return next;
+    }
+    async removeMock(id) {
+        if (!(await this.getMock(id)))
+            return false;
+        this.atomic(() => {
+            this.sql.exec("DELETE FROM comments WHERE mockId = ?", id);
+            this.sql.exec("DELETE FROM post_versions WHERE postId IN (SELECT id FROM posts WHERE mockId = ?)", id);
+            this.sql.exec("DELETE FROM posts WHERE mockId = ?", id);
+            this.sql.exec("DELETE FROM mocks WHERE id = ?", id);
+        });
+        this.invalidateAssetRefs();
+        return true;
+    }
+    async putDraft(mockId, draft) {
+        const mock = await this.getMock(mockId);
+        if (!mock)
+            return null;
+        this.sql.exec("UPDATE mocks SET draft = ? WHERE id = ?", draft ? JSON.stringify(draft) : null, mockId);
+        return { ...mock, draft };
+    }
+    touchMock(mockId, at) {
+        this.sql.exec("UPDATE mocks SET updatedAt = ? WHERE id = ?", at, mockId);
+    }
+    // --- posts ---
+    async listPosts(query = {}) {
+        const clauses = [];
+        const params = [];
+        if (query.mockId !== undefined) {
+            clauses.push("mockId = ?");
+            params.push(query.mockId);
+        }
+        if (query.sessionId !== undefined) {
+            clauses.push("sessionId = ?");
+            params.push(query.sessionId);
+        }
+        const where = clauses.length ? `WHERE ${clauses.join(" AND ")}` : "";
+        const rows = this.sql
+            .exec(`SELECT * FROM posts ${where} ORDER BY createdAt ASC, rowid ASC`, ...params)
+            .toArray();
+        return this.rowsToPosts(rows);
+    }
+    async countPostsBySession() {
+        const counts = new Map();
+        for (const row of this.sql
+            .exec("SELECT sessionId, COUNT(*) AS n FROM posts GROUP BY sessionId")
+            .toArray()) {
+            counts.set(row.sessionId, row.n);
+        }
+        return counts;
+    }
+    async getPost(id) {
+        const rows = this.sql.exec("SELECT * FROM posts WHERE id = ?", id).toArray();
+        return rows.length > 0 ? this.rowsToPosts(rows)[0] : null;
+    }
+    async findPost(mockId, state, variant) {
+        const rows = this.sql
+            .exec("SELECT * FROM posts WHERE mockId = ? AND state IS ? AND variant = ? ORDER BY createdAt ASC LIMIT 1", mockId, state, variant)
+            .toArray();
+        return rows.length > 0 ? this.rowsToPosts(rows)[0] : null;
+    }
+    async createPost(input) {
+        if (!(await this.getSession(input.sessionId)))
+            return null;
+        if (!(await this.getMock(input.mock)))
+            return null;
+        const now = new Date().toISOString();
+        const post = {
+            id: newId(),
+            sessionId: input.sessionId,
+            mock: input.mock,
+            state: input.state === null ? null : stripNul(input.state),
+            variant: stripNul(input.variant)?.trim() || DEFAULT_VARIANT,
+            status: "open",
+            title: stripNul(input.title)?.trim() || "Untitled",
+            surfaces: normalizeSurfaceIds(input.surfaces),
+            createdAt: now,
+            updatedAt: now,
+            version: 1,
+            history: [],
+            ...(input.knobs ? { knobs: input.knobs } : {}),
+            slots: input.slots ?? [],
+            ...(input.from === undefined ? {} : { from: input.from }),
+            ...(input.prompt === undefined ? {} : { prompt: stripNul(input.prompt) }),
+            ...(input.author === undefined ? {} : { author: stripNul(input.author) }),
+        };
+        this.sql.exec("INSERT INTO posts (id, sessionId, mockId, state, variant, status, title, surfaces, knobs, slots, createdAt, updatedAt, version, curFrom, curPrompt, curAuthor) VALUES (?, ?, ?, ?, ?, 'open', ?, ?, ?, ?, ?, ?, 1, ?, ?, ?)", post.id, post.sessionId, post.mock, post.state, post.variant, post.title, JSON.stringify(post.surfaces), post.knobs ? JSON.stringify(post.knobs) : null, JSON.stringify(post.slots), post.createdAt, post.updatedAt, post.from ?? null, post.prompt ?? null, post.author ?? null);
+        this.touch(input.sessionId);
+        this.touchMock(post.mock, now);
+        this.addAssetRefs(post.surfaces);
+        return post;
+    }
+    async updatePost(id, patch) {
+        // Compare-and-set on the version: two concurrent updates serialize without
+        // a read-then-write gap. The loser sees 0 rows changed and retries.
+        for (let attempt = 0; attempt < 4; attempt++) {
+            const post = await this.getPost(id);
+            if (!post)
+                return null;
+            const archived = {
+                version: post.version,
+                title: post.title,
+                surfaces: post.surfaces,
+                at: post.updatedAt,
+                ...(post.from === undefined ? {} : { from: post.from }),
+                ...(post.prompt === undefined ? {} : { prompt: post.prompt }),
+                ...(post.author === undefined ? {} : { author: post.author }),
+            };
+            const history = [...post.history, archived];
+            if (history.length > HISTORY_LIMIT)
+                history.shift();
+            const title = patch.title !== undefined ? stripNul(patch.title).trim() || post.title : post.title;
+            const surfaces = patch.surfaces !== undefined ? normalizeSurfaceIds(patch.surfaces) : post.surfaces;
+            const knobs = patch.knobs === undefined ? post.knobs : (patch.knobs ?? undefined);
+            const slots = patch.slots ?? post.slots;
+            const state = patch.state === undefined ? post.state : patch.state;
+            const version = post.version + 1;
+            const updatedAt = new Date().toISOString();
+            // A revision may branch from any earlier version; default to the one it replaces.
+            const from = patch.from ?? post.version;
+            const prompt = stripNul(patch.prompt ?? "");
+            const author = patch.author === undefined ? null : stripNul(patch.author);
+            this.sql.exec("UPDATE posts SET title = ?, surfaces = ?, knobs = ?, slots = ?, state = ?, updatedAt = ?, version = ?, curFrom = ?, curPrompt = ?, curAuthor = ? WHERE id = ? AND version = ?", title, JSON.stringify(surfaces), knobs ? JSON.stringify(knobs) : null, JSON.stringify(slots), state, updatedAt, version, from, prompt, author, id, post.version);
+            const affected = this.sql.exec("SELECT changes() AS n").one().n;
+            if (affected > 0) {
+                this.insertVersion(id, archived);
+                this.sql.exec("DELETE FROM post_versions WHERE postId = ? AND version <= ?", id, version - 1 - HISTORY_LIMIT);
+                this.touch(post.sessionId);
+                this.touchMock(post.mock, updatedAt);
+                if (patch.surfaces !== undefined)
+                    this.addAssetRefs(surfaces);
+                const { knobs: _knobs, author: _author, ...rest } = post;
+                return {
+                    ...rest,
+                    title,
+                    surfaces,
+                    ...(knobs ? { knobs } : {}),
+                    slots,
+                    state,
+                    version,
+                    updatedAt,
+                    history,
+                    from,
+                    prompt,
+                    ...(author === null ? {} : { author }),
+                };
+            }
+        }
+        return null;
+    }
+    async removePost(id) {
+        if (!(await this.getPost(id)))
+            return false;
+        this.atomic(() => {
+            this.sql.exec("DELETE FROM comments WHERE postId = ?", id);
+            this.sql.exec("DELETE FROM post_versions WHERE postId = ?", id);
+            this.sql.exec("DELETE FROM posts WHERE id = ?", id);
+        });
+        this.invalidateAssetRefs();
+        return true;
+    }
+    async setPostStatus(id, status) {
+        const post = await this.getPost(id);
+        if (!post)
+            return null;
+        this.sql.exec("UPDATE posts SET status = ? WHERE id = ?", status, id);
+        return { ...post, status };
+    }
+    // --- comments ---
+    async listComments(query) {
+        const clauses = [];
+        const params = [];
+        if (query.sessionId !== undefined) {
+            clauses.push("sessionId = ?");
+            params.push(query.sessionId);
+        }
+        if (query.mockId !== undefined) {
+            clauses.push("mockId = ?");
+            params.push(query.mockId);
+        }
+        if (query.postId !== undefined) {
+            clauses.push("postId = ?");
+            params.push(query.postId);
+        }
+        if (query.afterSeq !== undefined) {
+            clauses.push("seq > ?");
+            params.push(query.afterSeq);
+        }
+        const where = clauses.length > 0 ? `WHERE ${clauses.join(" AND ")}` : "";
+        return this.sql
+            .exec(`SELECT * FROM comments ${where} ORDER BY seq ASC`, ...params)
+            .toArray()
+            .map((r) => this.rowToComment(r));
+    }
+    insertComment(input) {
+        const createdAt = new Date().toISOString();
+        const comment = {
+            id: newId(),
+            sessionId: input.sessionId,
+            mockId: input.mockId ?? null,
+            postId: input.postId ?? null,
+            author: stripNul(input.author).trim() || "user",
+            text: stripNul(input.text),
+            createdAt,
+            ...(input.anchor ? { anchor: input.anchor } : {}),
+            kind: input.kind ?? "comment",
+            anchors: input.anchors ?? [],
+            postVersion: input.postVersion ?? null,
+            viewport: input.viewport ?? null,
+            ...(input.payload ? { payload: input.payload } : {}),
+        };
+        this.sql.exec("INSERT INTO comments (id, sessionId, mockId, postId, author, text, createdAt, kind, anchor, anchors, postVersion, viewport, payload) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)", comment.id, comment.sessionId, comment.mockId, comment.postId, comment.author, comment.text, comment.createdAt, comment.kind, comment.anchor ? JSON.stringify(comment.anchor) : null, JSON.stringify(comment.anchors), comment.postVersion, comment.viewport, comment.payload ? JSON.stringify(comment.payload) : null);
+        const seq = this.sql.exec("SELECT last_insert_rowid() AS seq").one().seq;
+        this.touch(input.sessionId);
+        return { ...comment, seq };
+    }
+    async createComment(input) {
+        if (!(await this.getSession(input.sessionId)))
+            return null;
+        const post = input.postId ? await this.getPost(input.postId) : null;
+        return this.insertComment({
+            ...input,
+            postId: post?.id ?? null,
+            mockId: input.mockId ?? post?.mock ?? null,
+            postVersion: input.postVersion ?? post?.version ?? null,
+        });
+    }
+    async removeComment(id) {
+        const rows = this.sql.exec("SELECT * FROM comments WHERE id = ?", id).toArray();
+        if (rows.length === 0)
+            return null;
+        const comment = this.rowToComment(rows[0]);
+        this.sql.exec("DELETE FROM comments WHERE id = ?", id);
+        this.touch(comment.sessionId);
+        return comment;
+    }
+    async commitReply(input) {
+        if (!(await this.getSession(input.sessionId)))
+            return null;
+        if (!(await this.getMock(input.mockId)))
+            return null;
+        return this.atomic(() => {
+            const comment = this.insertComment({
+                sessionId: input.sessionId,
+                mockId: input.mockId,
+                author: "user",
+                text: input.text,
+                kind: "reply",
+                postVersion: input.payload.version,
+                payload: input.payload,
+            });
+            this.sql.exec("UPDATE mocks SET asks = ?, draft = NULL WHERE id = ?", JSON.stringify(input.asks), input.mockId);
+            for (const id of input.accept) {
+                this.sql.exec("UPDATE posts SET status = 'accepted' WHERE id = ? AND mockId = ?", id, input.mockId);
+            }
+            for (const id of input.archive) {
+                this.sql.exec("UPDATE posts SET status = 'archived' WHERE id = ? AND mockId = ?", id, input.mockId);
+            }
+            return comment;
+        });
+    }
+    // --- assets ---
+    referencedAssetIds() {
+        if (this.assetRefCache)
+            return this.assetRefCache;
+        const out = new Set();
+        for (const r of this.sql.exec("SELECT surfaces FROM posts").toArray()) {
+            collectAssetIds(parseJson(r.surfaces, []), out);
+        }
+        for (const r of this.sql.exec("SELECT surfaces FROM post_versions").toArray()) {
+            collectAssetIds(parseJson(r.surfaces, []), out);
+        }
+        // An installed icon set is referenced by its project's design, not by a
+        // surface; evicting it would blank that project's icons.
+        for (const r of this.sql
+            .exec("SELECT value FROM settings WHERE key LIKE 'design:%'")
+            .toArray()) {
+            const sets = parseJson(r.value, null)?.iconSets;
+            for (const ref of Array.isArray(sets) ? sets : []) {
+                if (typeof ref?.assetId === "string")
+                    out.add(ref.assetId);
+            }
+        }
+        this.assetRefCache = out;
+        return out;
+    }
+    addAssetRefs(surfaces) {
+        if (this.assetRefCache)
+            collectAssetIds(surfaces, this.assetRefCache);
+    }
+    invalidateAssetRefs() {
+        this.assetRefCache = undefined;
+    }
+    async putAsset(input) {
+        if (!(await this.getSession(input.sessionId)))
+            return null;
+        // Content-addressed: identical bytes dedupe to the existing blob (idempotent
+        // upload), keeping its original session and createdAt; we just warm it.
+        const id = await hashAssetId(input.data);
+        if (await this.getAsset(id)) {
+            await this.touchAsset(id);
+            this.touch(input.sessionId);
+            return (await this.getAsset(id));
+        }
+        const referenced = this.referencedAssetIds();
+        const candidates = this.sql
+            .exec("SELECT id, byteLength, lastAccessedAt FROM assets")
+            .toArray()
+            .map((r) => ({
+            id: r.id,
+            byteLength: r.byteLength,
+            lastAccessedAt: r.lastAccessedAt,
+            referenced: referenced.has(r.id),
+        }));
+        for (const evict of selectEvictions(candidates, input.data.byteLength, MAX_WORKSPACE_ASSET_BYTES)) {
+            this.sql.exec("DELETE FROM assets WHERE id = ?", evict);
+        }
+        const now = new Date().toISOString();
+        const asset = {
+            id,
+            sessionId: input.sessionId,
+            kind: input.kind,
+            contentType: stripNul(input.contentType),
+            byteLength: input.data.byteLength,
+            filename: stripNul(input.filename ?? null),
+            data: input.data,
+            createdAt: now,
+            lastAccessedAt: now,
+        };
+        // Bind the blob as an ArrayBuffer (the SqlStorageValue type); the node
+        // adapter turns it back into a Uint8Array for node:sqlite.
+        const buf = asset.data.buffer.slice(asset.data.byteOffset, asset.data.byteOffset + asset.data.byteLength);
+        this.sql.exec("INSERT INTO assets (id, sessionId, kind, contentType, byteLength, filename, data, createdAt, lastAccessedAt) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)", asset.id, asset.sessionId, asset.kind, asset.contentType, asset.byteLength, asset.filename, buf, asset.createdAt, asset.lastAccessedAt);
+        this.touch(input.sessionId);
+        return asset;
+    }
+    async getAsset(id) {
+        const rows = this.sql.exec("SELECT * FROM assets WHERE id = ?", id).toArray();
+        return rows.length > 0 ? this.rowToAsset(rows[0]) : null;
+    }
+    async touchAsset(id) {
+        this.sql.exec("UPDATE assets SET lastAccessedAt = ? WHERE id = ?", new Date().toISOString(), id);
+    }
+    async listAssets(sessionId) {
+        return this.sql
+            .exec("SELECT * FROM assets WHERE sessionId = ?", sessionId)
+            .toArray()
+            .map((r) => this.rowToAsset(r));
+    }
+    async removeAsset(id) {
+        if (!(await this.getAsset(id)))
+            return false;
+        this.sql.exec("DELETE FROM assets WHERE id = ?", id);
+        return true;
+    }
+    async isAssetReferenced(id) {
+        return this.referencedAssetIds().has(id);
+    }
+}