@hatk/hatk 0.0.1-alpha.8 → 0.0.1-alpha.80

package/dist/{db.js → database/db.js}

@@ -1,136 +1,59 @@
-import { DuckDBInstance } from '@duckdb/node-api';
-import { toSnakeCase } from "./schema.js";
-import { getSearchColumns, stripStopWords } from "./fts.js";
-import { emit, timer } from "./logger.js";
-import { OAUTH_DDL } from "./oauth/db.js";
-let instance;
-let con;
-let readCon;
+import { toSnakeCase, q } from "./schema.js";
+import { getSearchColumns, stripStopWords, getSearchPort, updateFtsRecord, deleteFtsRecord } from "./fts.js";
+import { emit, timer } from "../logger.js";
+import { OAUTH_DDL } from "../oauth/db.js";
+import { getDialect } from "./dialect.js";
+let port;
+let dialect;
 const schemas = new Map();
-export function closeDatabase() {
-    try {
-        readCon?.closeSync();
-    }
-    catch { }
-    try {
-        con?.closeSync();
-    }
-    catch { }
-    try {
-        instance?.closeSync();
-    }
-    catch { }
-}
-let writeQueue = Promise.resolve();
-let readQueue = Promise.resolve();
-function enqueue(queue, fn) {
-    if (queue === 'write') {
-        const p = writeQueue.then(fn);
-        writeQueue = p.then(() => { }, () => { });
-        return p;
-    }
-    else {
-        const p = readQueue.then(fn);
-        readQueue = p.then(() => { }, () => { });
-        return p;
-    }
+export function getDatabasePort() {
+    return port;
 }
-function bindParams(prepared, params) {
-    for (let i = 0; i < params.length; i++) {
-        const idx = i + 1;
-        const value = params[i];
-        if (value === null || value === undefined) {
-            prepared.bindNull(idx);
-        }
-        else if (typeof value === 'string') {
-            prepared.bindVarchar(idx, value);
-        }
-        else if (typeof value === 'number') {
-            if (Number.isInteger(value)) {
-                prepared.bindInteger(idx, value);
-            }
-            else {
-                prepared.bindDouble(idx, value);
-            }
-        }
-        else if (typeof value === 'boolean') {
-            prepared.bindBoolean(idx, value);
-        }
-        else if (typeof value === 'bigint') {
-            prepared.bindBigInt(idx, value);
-        }
-        else if (value instanceof Uint8Array) {
-            prepared.bindBlob(idx, value);
-        }
-        else {
-            prepared.bindVarchar(idx, String(value));
-        }
-    }
+export function getSqlDialect() {
+    return dialect;
 }
-async function runDirect(sql, ...params) {
-    if (params.length === 0) {
-        await con.run(sql);
-        return;
-    }
-    const prepared = await con.prepare(sql);
-    bindParams(prepared, params);
-    await prepared.run();
+export function closeDatabase() {
+    port?.close();
 }
-async function run(sql, ...params) {
-    return enqueue('write', () => runDirect(sql, ...params));
+async function run(sql, params = []) {
+    return port.execute(sql, params);
 }
 export async function runBatch(operations) {
-    return enqueue('write', async () => {
-        await con.run('BEGIN TRANSACTION');
+    await port.beginTransaction();
+    try {
         for (const op of operations) {
             try {
-                if (op.params.length === 0) {
-                    await con.run(op.sql);
-                }
-                else {
-                    const prepared = await con.prepare(op.sql);
-                    bindParams(prepared, op.params);
-                    await prepared.run();
-                }
+                await port.execute(op.sql, op.params);
             }
             catch {
                 // Skip bad records, continue with rest of batch
             }
         }
-        await con.run('COMMIT');
-    });
-}
-async function allDirect(sql, ...params) {
-    if (params.length === 0) {
-        const reader = await readCon.runAndReadAll(sql);
-        return reader.getRowObjects();
+        await port.commit();
+    }
+    catch {
+        await port.rollback();
     }
-    const prepared = await readCon.prepare(sql);
-    bindParams(prepared, params);
-    const reader = await prepared.runAndReadAll();
-    return reader.getRowObjects();
 }
-async function all(sql, ...params) {
-    return enqueue('read', () => allDirect(sql, ...params));
+async function all(sql, params = []) {
+    return port.query(sql, params);
 }
-export async function initDatabase(dbPath, tableSchemas, ddlStatements) {
-    instance = await DuckDBInstance.create(dbPath === ':memory:' ? undefined : dbPath);
-    con = await instance.connect();
-    readCon = await instance.connect();
+export async function initDatabase(adapter, dbPath, tableSchemas, ddlStatements) {
+    port = adapter;
+    dialect = getDialect(adapter.dialect);
+    await port.open(dbPath);
     for (const schema of tableSchemas) {
         schemas.set(schema.collection, schema);
     }
     for (const ddl of ddlStatements) {
-        for (const statement of ddl.split(';').filter((s) => s.trim())) {
-            await run(statement);
-        }
+        await port.executeMultiple(ddl);
     }
     // Internal tables for backfill state
     await run(`CREATE TABLE IF NOT EXISTS _repos (
     did TEXT PRIMARY KEY,
     status TEXT NOT NULL DEFAULT 'pending',
     handle TEXT,
-    backfilled_at TIMESTAMP,
+    backfilled_at ${dialect.timestampType},
     rev TEXT,
     retry_count INTEGER NOT NULL DEFAULT 0,
     retry_after INTEGER NOT NULL DEFAULT 0
@@ -142,79 +65,350 @@ export async function initDatabase(dbPath, tableSchemas, ddlStatements) {
     catch { }
     // Re-queue repos with missing handles so backfill populates them
     await run(`UPDATE _repos SET status = 'pending' WHERE handle IS NULL`);
+    // Covering index for the status rollups the admin overview and backfill queue
+    // read. Skipped on DuckDB, which scans the column just as fast and would only
+    // pay the ART index's insert cost.
+    if (port.dialect !== 'duckdb') {
+        await run(`CREATE INDEX IF NOT EXISTS idx_repos_status ON _repos(status)`);
+    }
+    // resolveHandleToDid runs on every feed request that takes an `actor` handle,
+    // and without this it scans all of _repos. Not UNIQUE: during a handle change
+    // two rows can briefly claim the same handle, and a constraint violation there
+    // would fail the indexer write.
+    await run(`CREATE INDEX IF NOT EXISTS idx_repos_handle ON _repos(handle)`);
     await run(`CREATE TABLE IF NOT EXISTS _cursor (
     key TEXT PRIMARY KEY,
     value TEXT NOT NULL
   )`);
     // Labels table (atproto-compatible)
-    await run(`CREATE SEQUENCE IF NOT EXISTS _labels_seq START 1`);
-    await run(`CREATE TABLE IF NOT EXISTS _labels (
-    id INTEGER PRIMARY KEY DEFAULT nextval('_labels_seq'),
-    src TEXT NOT NULL,
-    uri TEXT NOT NULL,
-    val TEXT NOT NULL,
-    neg BOOLEAN DEFAULT FALSE,
-    cts TIMESTAMP NOT NULL,
-    exp TIMESTAMP
-  )`);
+    if (dialect.supportsSequences) {
+        await run(`CREATE SEQUENCE IF NOT EXISTS _labels_seq START 1`);
+        await run(`CREATE TABLE IF NOT EXISTS _labels (
+      id INTEGER PRIMARY KEY DEFAULT nextval('_labels_seq'),
+      src TEXT NOT NULL,
+      uri TEXT NOT NULL,
+      val TEXT NOT NULL,
+      neg ${dialect.typeMap.boolean} DEFAULT FALSE,
+      cts ${dialect.timestampType} NOT NULL,
+      exp ${dialect.timestampType}
+    )`);
+    }
+    else {
+        await run(`CREATE TABLE IF NOT EXISTS _labels (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      src TEXT NOT NULL,
+      uri TEXT NOT NULL,
+      val TEXT NOT NULL,
+      neg INTEGER DEFAULT 0,
+      cts TEXT NOT NULL,
+      exp TEXT
+    )`);
+    }
     await run(`CREATE INDEX IF NOT EXISTS idx_labels_uri ON _labels(uri)`);
     await run(`CREATE INDEX IF NOT EXISTS idx_labels_src ON _labels(src)`);
     // Preferences table (generic key-value per user)
     await run(`CREATE TABLE IF NOT EXISTS _preferences (
     did TEXT NOT NULL,
     key TEXT NOT NULL,
-    value JSON NOT NULL,
-    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    value ${dialect.jsonType} NOT NULL,
+    updated_at ${dialect.timestampType} DEFAULT ${dialect.currentTimestamp},
     PRIMARY KEY (did, key)
+  )`);
+    // Reports table (user-submitted moderation reports)
+    if (dialect.supportsSequences) {
+        await run(`CREATE SEQUENCE IF NOT EXISTS _reports_seq START 1`);
+        await run(`CREATE TABLE IF NOT EXISTS _reports (
+      id INTEGER PRIMARY KEY DEFAULT nextval('_reports_seq'),
+      subject_uri TEXT NOT NULL,
+      subject_did TEXT NOT NULL,
+      label TEXT NOT NULL,
+      reason TEXT,
+      reported_by TEXT NOT NULL,
+      status TEXT NOT NULL DEFAULT 'open',
+      resolved_by TEXT,
+      resolved_at ${dialect.timestampType},
+      created_at ${dialect.timestampType} NOT NULL
+    )`);
+    }
+    else {
+        await run(`CREATE TABLE IF NOT EXISTS _reports (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      subject_uri TEXT NOT NULL,
+      subject_did TEXT NOT NULL,
+      label TEXT NOT NULL,
+      reason TEXT,
+      reported_by TEXT NOT NULL,
+      status TEXT NOT NULL DEFAULT 'open',
+      resolved_by TEXT,
+      resolved_at TEXT,
+      created_at TEXT NOT NULL
+    )`);
+    }
+    await run(`CREATE INDEX IF NOT EXISTS idx_reports_status ON _reports(status)`);
+    await run(`CREATE INDEX IF NOT EXISTS idx_reports_subject_uri ON _reports(subject_uri)`);
+    // Push notification tokens
+    await run(`CREATE TABLE IF NOT EXISTS _push_tokens (
+    did TEXT NOT NULL,
+    token TEXT NOT NULL,
+    platform TEXT NOT NULL,
+    created_at TEXT NOT NULL,
+    PRIMARY KEY (did, token)
   )`);
     // OAuth tables
-    for (const statement of OAUTH_DDL.split(';').filter((s) => s.trim())) {
-        await run(statement);
+    await port.executeMultiple(OAUTH_DDL);
+    // Migrations: add pds_auth_server to existing sessions tables
+    try {
+        await run(`ALTER TABLE _oauth_sessions ADD COLUMN pds_auth_server TEXT`);
+    }
+    catch { }
+}
+/** Normalize SQL type names to handle dialect differences (e.g. VARCHAR → TEXT) */
+function normalizeType(type) {
+    const upper = type.toUpperCase();
+    if (upper === 'VARCHAR' || upper === 'CHARACTER VARYING')
+        return 'TEXT';
+    if (upper === 'TIMESTAMP WITH TIME ZONE')
+        return 'TIMESTAMPTZ';
+    if (upper === 'BOOLEAN' || upper === 'BOOL')
+        return 'BOOLEAN';
+    if (upper === 'INT' || upper === 'INT4' || upper === 'INT8' || upper === 'BIGINT' || upper === 'SMALLINT')
+        return 'INTEGER';
+    return upper;
+}
+async function getExistingColumns(tableName) {
+    if (!/^[a-zA-Z0-9._]+$/.test(tableName)) {
+        throw new Error(`Invalid table name for introspection: ${tableName}`);
+    }
+    const cols = new Map();
+    try {
+        const query = dialect.introspectColumnsQuery(tableName);
+        const rows = await all(query);
+        for (const row of rows) {
+            // SQLite PRAGMA returns { name, type }, DuckDB returns { column_name, data_type }
+            const name = (row.column_name || row.name);
+            const type = normalizeType((row.data_type || row.type || 'TEXT'));
+            cols.set(name, type);
+        }
+    }
+    catch {
+        // Table doesn't exist yet
+    }
+    return cols;
+}
+function diffColumns(tableName, existingCols, expectedCols, changes) {
+    for (const [colName, colType] of expectedCols) {
+        if (!existingCols.has(colName)) {
+            changes.push({ table: tableName, action: 'add', column: colName, type: colType });
+        }
+    }
+    for (const [colName] of existingCols) {
+        if (!expectedCols.has(colName)) {
+            changes.push({ table: tableName, action: 'drop', column: colName });
+        }
+    }
+    for (const [colName, colType] of expectedCols) {
+        const existingType = existingCols.get(colName);
+        if (existingType && normalizeType(existingType) !== normalizeType(colType)) {
+            changes.push({ table: tableName, action: 'retype', column: colName, type: colType });
+        }
+    }
+}
+/** Build expected columns map for a child/union table */
+function buildChildExpectedCols(columns) {
+    const expected = new Map();
+    expected.set('parent_uri', 'TEXT');
+    expected.set('parent_did', 'TEXT');
+    for (const col of columns) {
+        expected.set(col.name, normalizeType(col.sqlType));
+    }
+    return expected;
+}
+export async function migrateSchema(tableSchemas) {
+    const changes = [];
+    const newCollections = new Set();
+    for (const schema of tableSchemas) {
+        if (schema.columns.length === 0)
+            continue; // generic JSON storage, skip
+        const tableName = schema.collection;
+        const existingCols = await getExistingColumns(tableName);
+        if (existingCols.size === 0) {
+            newCollections.add(schema.collection);
+            continue; // table just created, nothing to migrate
+        }
+        // Expected columns: base columns (uri, cid, did, indexed_at) + schema columns
+        const expectedCols = new Map();
+        expectedCols.set('uri', 'TEXT');
+        expectedCols.set('cid', 'TEXT');
+        expectedCols.set('did', 'TEXT');
+        expectedCols.set('indexed_at', normalizeType(dialect.timestampType));
+        for (const col of schema.columns) {
+            expectedCols.set(col.name, normalizeType(col.sqlType));
+        }
+        diffColumns(tableName, existingCols, expectedCols, changes);
+        // Diff child tables
+        for (const child of schema.children) {
+            const childTable = child.tableName.replace(/"/g, '');
+            const existingChildCols = await getExistingColumns(childTable);
+            if (existingChildCols.size === 0)
+                continue;
+            diffColumns(childTable, existingChildCols, buildChildExpectedCols(child.columns), changes);
+        }
+        // Diff union branch tables
+        for (const union of schema.unions) {
+            for (const branch of union.branches) {
+                const branchTable = branch.tableName.replace(/"/g, '');
+                const existingBranchCols = await getExistingColumns(branchTable);
+                if (existingBranchCols.size === 0)
+                    continue;
+                diffColumns(branchTable, existingBranchCols, buildChildExpectedCols(branch.columns), changes);
+            }
+        }
+    }
+    // Detect and drop orphaned child/union tables (query table list once)
+    let allTableNames = null;
+    try {
+        const rows = await all(dialect.listTablesQuery);
+        allTableNames = rows.map((r) => r.table_name);
+    }
+    catch { }
+    if (allTableNames) {
+        for (const schema of tableSchemas) {
+            if (schema.columns.length === 0)
+                continue;
+            const expectedTables = new Set();
+            for (const child of schema.children) {
+                expectedTables.add(child.tableName.replace(/"/g, ''));
+            }
+            for (const union of schema.unions) {
+                for (const branch of union.branches) {
+                    expectedTables.add(branch.tableName.replace(/"/g, ''));
+                }
+            }
+            for (const name of allTableNames) {
+                if (name.startsWith(schema.collection + '__') && !expectedTables.has(name)) {
+                    await run(`DROP TABLE IF EXISTS "${name}"`);
+                    emit('migration', 'drop_table', { table: name });
+                }
+            }
+        }
+    }
+    if (changes.length > 0) {
+        await applyMigrationChanges(changes);
+    }
+    // Trigger backfill only for genuinely new collections (tables created this startup)
+    // Previously this checked ALL empty tables, which caused infinite resync loops
+    // for collections that are legitimately empty (e.g. blocks when nobody has blocked)
+    if (newCollections.size > 0) {
+        const [hasRepos] = await all(`SELECT 1 FROM _repos LIMIT 1`);
+        if (hasRepos) {
+            await run(`UPDATE _repos SET status = 'pending' WHERE status = 'active'`);
+            for (const collection of newCollections) {
+                emit('migration', 'new_collection', { collection });
+            }
+        }
+    }
+    return changes;
+}
+async function applyMigrationChanges(changes) {
+    for (const change of changes) {
+        const quotedTable = `"${change.table}"`;
+        const quotedColumn = `"${change.column}"`;
+        try {
+            switch (change.action) {
+                case 'add': {
+                    await run(`ALTER TABLE ${quotedTable} ADD COLUMN ${quotedColumn} ${change.type}`);
+                    emit('migration', 'add_column', { table: change.table, column: change.column, type: change.type });
+                    const schema = schemas.get(change.table);
+                    if (schema?.refColumns.includes(change.column)) {
+                        const prefix = change.table.replace(/\./g, '_');
+                        await run(`CREATE INDEX IF NOT EXISTS idx_${prefix}_${change.column} ON ${quotedTable}(${quotedColumn})`);
+                    }
+                    break;
+                }
+                case 'drop':
+                    await run(`ALTER TABLE ${quotedTable} DROP COLUMN ${quotedColumn}`);
+                    emit('migration', 'drop_column', { table: change.table, column: change.column });
+                    break;
+                case 'retype':
+                    await run(`ALTER TABLE ${quotedTable} DROP COLUMN ${quotedColumn}`);
+                    await run(`ALTER TABLE ${quotedTable} ADD COLUMN ${quotedColumn} ${change.type}`);
+                    emit('migration', 'retype_column', { table: change.table, column: change.column, type: change.type });
+                    break;
+            }
+        }
+        catch (err) {
+            console.warn(`[migration] failed to ${change.action} column "${change.column}" on "${change.table}": ${err.message}`);
+            emit('migration', 'error', {
+                action: change.action,
+                table: change.table,
+                column: change.column,
+                error: err.message,
+            });
+        }
     }
 }
 export async function getCursor(key) {
-    const rows = await all(`SELECT value FROM _cursor WHERE key = $1`, key);
+    const rows = await all(`SELECT value FROM _cursor WHERE key = $1`, [key]);
     return rows[0]?.value || null;
 }
 export async function setCursor(key, value) {
-    await run(`INSERT OR REPLACE INTO _cursor (key, value) VALUES ($1, $2)`, key, value);
+    await run(`INSERT OR REPLACE INTO _cursor (key, value) VALUES ($1, $2)`, [key, value]);
 }
 export async function getRepoStatus(did) {
-    const rows = await all(`SELECT status FROM _repos WHERE did = $1`, did);
+    const rows = await all(`SELECT status FROM _repos WHERE did = $1`, [did]);
     return rows[0]?.status || null;
 }
 export async function setRepoStatus(did, status, rev, opts) {
     if (status === 'active') {
         // Update existing row preserving handle if not provided
-        await run(`UPDATE _repos SET status = $1, handle = COALESCE($2, handle), backfilled_at = $3, rev = COALESCE($4, rev), retry_count = 0, retry_after = 0 WHERE did = $5`, status, opts?.handle || null, new Date().toISOString(), rev || null, did);
+        await run(`UPDATE _repos SET status = $1, handle = COALESCE($2, handle), backfilled_at = $3, rev = COALESCE($4, rev), retry_count = 0, retry_after = 0 WHERE did = $5`, [status, opts?.handle || null, new Date().toISOString(), rev || null, did]);
         // Insert if row didn't exist yet
-        await run(`INSERT OR IGNORE INTO _repos (did, status, handle, backfilled_at, rev, retry_count, retry_after) VALUES ($1, $2, $3, $4, $5, 0, 0)`, did, status, opts?.handle || null, new Date().toISOString(), rev || null);
+        await run(`INSERT OR IGNORE INTO _repos (did, status, handle, backfilled_at, rev, retry_count, retry_after) VALUES ($1, $2, $3, $4, $5, 0, 0)`, [did, status, opts?.handle || null, new Date().toISOString(), rev || null]);
     }
     else if (status === 'failed' && opts) {
-        await run(`UPDATE _repos SET status = $1, retry_count = $2, retry_after = $3, handle = COALESCE($4, handle) WHERE did = $5`, status, opts.retryCount ?? 0, opts.retryAfter ?? 0, opts.handle || null, did);
+        await run(`UPDATE _repos SET status = $1, retry_count = $2, retry_after = $3, handle = COALESCE($4, handle) WHERE did = $5`, [status, opts.retryCount ?? 0, opts.retryAfter ?? 0, opts.handle || null, did]);
         // If row didn't exist yet, insert it
-        await run(`INSERT OR IGNORE INTO _repos (did, status, handle, retry_count, retry_after) VALUES ($1, $2, $3, $4, $5)`, did, status, opts.handle || null, opts.retryCount ?? 0, opts.retryAfter ?? 0);
+        await run(`INSERT OR IGNORE INTO _repos (did, status, handle, retry_count, retry_after) VALUES ($1, $2, $3, $4, $5)`, [did, status, opts.handle || null, opts.retryCount ?? 0, opts.retryAfter ?? 0]);
     }
     else {
-        await run(`UPDATE _repos SET status = $1 WHERE did = $2`, status, did);
-        await run(`INSERT OR IGNORE INTO _repos (did, status) VALUES ($1, $2)`, did, status);
+        await run(`UPDATE _repos SET status = $1 WHERE did = $2`, [status, did]);
+        await run(`INSERT OR IGNORE INTO _repos (did, status) VALUES ($1, $2)`, [did, status]);
     }
 }
+/** Update the handle for a DID if it exists in _repos. */
+export async function updateRepoHandle(did, handle) {
+    await run(`UPDATE _repos SET handle = $1 WHERE did = $2`, [handle, did]);
+}
+export async function getRepoRev(did) {
+    const rows = await all(`SELECT rev FROM _repos WHERE did = $1`, [did]);
+    return rows[0]?.rev ?? null;
+}
 export async function getRepoRetryInfo(did) {
-    const rows = await all(`SELECT retry_count, retry_after FROM _repos WHERE did = $1`, did);
+    const rows = await all(`SELECT retry_count, retry_after FROM _repos WHERE did = $1`, [did]);
     if (rows.length === 0)
         return null;
     return { retryCount: Number(rows[0].retry_count), retryAfter: Number(rows[0].retry_after) };
 }
 export async function listRetryEligibleRepos(maxRetries) {
     const now = Math.floor(Date.now() / 1000);
-    const rows = await all(`SELECT did FROM _repos WHERE status = 'failed' AND retry_after <= $1 AND retry_count < $2`, now, maxRetries);
+    const rows = await all(`SELECT did FROM _repos WHERE status = 'failed' AND retry_after <= $1 AND retry_count < $2`, [now, maxRetries]);
     return rows.map((r) => r.did);
 }
 export async function listPendingRepos() {
     const rows = await all(`SELECT did FROM _repos WHERE status = 'pending'`);
     return rows.map((r) => r.did);
 }
+export async function listActiveRepoDids() {
+    const rows = await all(`SELECT did FROM _repos WHERE status = 'active'`);
+    return rows.map((r) => r.did);
+}
+export async function removeRepo(did) {
+    await run(`DELETE FROM _repos WHERE did = $1`, [did]);
+}
+export async function getRepoHandle(did) {
+    const rows = await all(`SELECT handle FROM _repos WHERE did = $1`, [did]);
+    return rows[0]?.handle ?? null;
+}
 export async function listAllRepoStatuses() {
     return (await all(`SELECT did, status FROM _repos`));
 }
@@ -228,27 +422,108 @@ export async function listReposPaginated(opts = {}) {
         params.push(status);
     }
     if (q) {
-        conditions.push(`(did ILIKE $${paramIdx} OR handle ILIKE $${paramIdx})`);
+        conditions.push(`(did ${dialect.ilike} $${paramIdx} OR handle ${dialect.ilike} $${paramIdx})`);
         params.push(`%${q}%`);
         paramIdx++;
     }
     const where = conditions.length ? ' WHERE ' + conditions.join(' AND ') : '';
-    const countRows = await all(`SELECT COUNT(*)::INTEGER as total FROM _repos${where}`, ...params);
+    const countRows = await all(`SELECT ${dialect.countAsInteger} as total FROM _repos${where}`, params);
     const total = Number(countRows[0]?.total || 0);
-    const rows = await all(`SELECT did, handle, status, backfilled_at, rev FROM _repos${where} ORDER BY backfilled_at DESC NULLS LAST, did LIMIT $${paramIdx++} OFFSET $${paramIdx++}`, ...params, limit, offset);
+    const rows = await all(`SELECT did, handle, status, backfilled_at, rev FROM _repos${where} ORDER BY CASE WHEN backfilled_at IS NULL THEN 1 ELSE 0 END, backfilled_at DESC, did LIMIT $${paramIdx++} OFFSET $${paramIdx++}`, [...params, limit, offset]);
     return { repos: rows, total };
 }
 export async function getCollectionCounts() {
+    const entries = [...schemas];
     const counts = {};
-    for (const [collection, schema] of schemas) {
-        const rows = await all(`SELECT COUNT(*)::INTEGER as count FROM ${schema.tableName}`);
-        counts[collection] = Number(rows[0]?.count || 0);
-    }
+    for (const [collection] of entries)
+        counts[collection] = 0;
+    if (entries.length === 0)
+        return counts;
+    // One round trip instead of one per collection — reads are serialized on a
+    // single connection, so N queries means N waits behind whatever else is
+    // reading.
+    const sql = entries
+        .map(([collection, schema]) => `SELECT '${collection.replace(/'/g, "''")}' as collection, ${dialect.countAsInteger} as count FROM ${schema.tableName}`)
+        .join(' UNION ALL ');
+    const rows = await all(sql);
+    for (const row of rows)
+        counts[row.collection] = Number(row.count || 0);
+    return counts;
+}
+export async function getRepoStatusCounts() {
+    const rows = await all(`SELECT status, ${dialect.countAsInteger} as count FROM _repos GROUP BY status`);
+    const counts = {};
+    for (const row of rows)
+        counts[row.status] = Number(row.count);
     return counts;
 }
+export async function getDatabaseSize() {
+    if (dialect.supportsSequences) {
+        // DuckDB: pragma_database_size returns pre-formatted strings
+        const rows = await all('SELECT database_size, memory_usage, memory_limit FROM pragma_database_size()');
+        return rows[0] ?? {};
+    }
+    // SQLite: compute from page_count * page_size
+    const pages = await all('SELECT page_count FROM pragma_page_count()');
+    const sizes = await all('SELECT page_size FROM pragma_page_size()');
+    const pageCount = Number(pages[0]?.page_count ?? 0);
+    const pageSize = Number(sizes[0]?.page_size ?? 0);
+    const bytes = pageCount * pageSize;
+    const mib = (bytes / 1024 / 1024).toFixed(1);
+    return { database_size: `${mib} MiB`, memory_usage: 'N/A', memory_limit: 'N/A' };
+}
+export async function getLabelCount(val) {
+    const rows = await all(`SELECT ${dialect.countAsInteger} as count FROM _labels WHERE val = $1`, [
+        val,
+    ]);
+    return Number(rows[0]?.count || 0);
+}
+export async function deleteLabels(val) {
+    const count = await getLabelCount(val);
+    await run(`DELETE FROM _labels WHERE val = $1`, [val]);
+    return count;
+}
+export async function getRecentRecords(collection, limit) {
+    const schema = schemas.get(collection);
+    if (!schema)
+        return [];
+    const rows = await all(`SELECT t.* FROM ${schema.tableName} t JOIN _repos r ON t.did = r.did WHERE t.indexed_at > r.backfilled_at ORDER BY t.indexed_at DESC LIMIT $1`, [limit]);
+    return rows;
+}
 export async function getSchemaDump() {
-    const rows = await all(`SELECT sql FROM duckdb_tables() ORDER BY table_name`);
-    return rows.map((r) => r.sql + ';').join('\n\n');
+    let rows;
+    if (dialect.supportsSequences) {
+        // DuckDB: use duckdb_tables() for full DDL
+        rows = await all(`SELECT sql FROM duckdb_tables() ORDER BY table_name`);
+    }
+    else {
+        // SQLite: use sqlite_master, skip FTS shadow/internal tables
+        rows = await all(`SELECT sql FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%' AND name NOT LIKE '_fts_%' AND sql IS NOT NULL ORDER BY name`);
+    }
+    // Normalize indentation and formatting
+    return rows
+        .map((r) => {
+        let sql = r.sql.trim();
+        // Remove quotes around column names (SQLite adds them for some columns)
+        sql = sql.replace(/\n\s*"(\w+)"/g, '\n$1');
+        // Ensure closing paren is on its own line
+        sql = sql.replace(/([^(\s])\)$/, '$1\n)');
+        // Normalize leading-comma columns added by ALTER TABLE into trailing commas
+        sql = sql.replace(/\n\s*,\s*/g, ',\n');
+        // Split into lines and re-indent consistently
+        const lines = sql.split('\n').map((l) => l.trim());
+        sql = lines
+            .map((line, i) => {
+            if (i === 0)
+                return line; // CREATE TABLE line
+            if (line.startsWith(')'))
+                return ')'; // closing paren at top level
+            return '  ' + line; // indent columns
+        })
+            .join('\n');
+        return sql + ';';
+    })
+        .join('\n\n');
 }
 export function buildInsertOp(collection, uri, cid, authorDid, record) {
     const schema = schemas.get(collection);
@@ -267,12 +542,12 @@ export function buildInsertOp(collection, uri, cid, authorDid, record) {
         else if (col.originalName.endsWith('__cid') && record[col.originalName.replace('__cid', '')]) {
             rawValue = record[col.originalName.replace('__cid', '')].cid;
         }
-        colNames.push(col.name);
+        colNames.push(q(col.name));
         placeholders.push(`$${paramIdx++}`);
         if (rawValue === undefined || rawValue === null) {
             values.push(null);
         }
-        else if (col.duckdbType === 'JSON') {
+        else if (col.isJson) {
             values.push(JSON.stringify(rawValue));
         }
         else {
@@ -287,34 +562,34 @@ export async function insertRecord(collection, uri, cid, authorDid, record) {
     if (!schema)
         throw new Error(`Unknown collection: ${collection}`);
     const { sql, params } = buildInsertOp(collection, uri, cid, authorDid, record);
-    await run(sql, ...params);
+    await run(sql, params);
     // Insert child table rows
     for (const child of schema.children) {
         const items = record[child.fieldName];
         if (!Array.isArray(items))
             continue;
         // Delete existing child rows (handles INSERT OR REPLACE on main table)
-        await run(`DELETE FROM ${child.tableName} WHERE parent_uri = $1`, uri);
+        await run(`DELETE FROM ${child.tableName} WHERE parent_uri = $1`, [uri]);
         for (const item of items) {
             const colNames = ['parent_uri', 'parent_did'];
             const placeholders = ['$1', '$2'];
             const values = [uri, authorDid];
             let idx = 3;
             for (const col of child.columns) {
-                colNames.push(col.name);
+                colNames.push(q(col.name));
                 placeholders.push(`$${idx++}`);
                 const raw = item[col.originalName];
                 if (raw === undefined || raw === null) {
                     values.push(null);
                 }
-                else if (col.duckdbType === 'JSON') {
+                else if (col.isJson) {
                     values.push(JSON.stringify(raw));
                 }
                 else {
                     values.push(raw);
                 }
             }
-            await run(`INSERT INTO ${child.tableName} (${colNames.join(', ')}) VALUES (${placeholders.join(', ')})`, ...values);
+            await run(`INSERT INTO ${child.tableName} (${colNames.join(', ')}) VALUES (${placeholders.join(', ')})`, values);
         }
     }
     // Insert union branch rows
@@ -327,7 +602,7 @@ export async function insertRecord(collection, uri, cid, authorDid, record) {
             continue;
         // Delete existing branch rows (handles INSERT OR REPLACE)
         for (const b of union.branches) {
-            await run(`DELETE FROM ${b.tableName} WHERE parent_uri = $1`, uri);
+            await run(`DELETE FROM ${b.tableName} WHERE parent_uri = $1`, [uri]);
         }
         if (branch.isArray && branch.arrayField) {
             // Array branch (e.g., embed.images) — insert one row per array item
@@ -340,20 +615,20 @@ export async function insertRecord(collection, uri, cid, authorDid, record) {
                 const values = [uri, authorDid];
                 let idx = 3;
                 for (const col of branch.columns) {
-                    colNames.push(col.name);
+                    colNames.push(q(col.name));
                     placeholders.push(`$${idx++}`);
                     const raw = item[col.originalName];
                     if (raw === undefined || raw === null) {
                         values.push(null);
                     }
-                    else if (col.duckdbType === 'JSON') {
+                    else if (col.isJson) {
                         values.push(JSON.stringify(raw));
                     }
                     else {
                         values.push(raw);
                     }
                 }
-                await run(`INSERT INTO ${branch.tableName} (${colNames.join(', ')}) VALUES (${placeholders.join(', ')})`, ...values);
+                await run(`INSERT INTO ${branch.tableName} (${colNames.join(', ')}) VALUES (${placeholders.join(', ')})`, values);
             }
         }
         else {
@@ -364,22 +639,24 @@ export async function insertRecord(collection, uri, cid, authorDid, record) {
             const values = [uri, authorDid];
             let idx = 3;
             for (const col of branch.columns) {
-                colNames.push(col.name);
+                colNames.push(q(col.name));
                 placeholders.push(`$${idx++}`);
                 const raw = branchData[col.originalName];
                 if (raw === undefined || raw === null) {
                     values.push(null);
                 }
-                else if (col.duckdbType === 'JSON') {
+                else if (col.isJson) {
                     values.push(JSON.stringify(raw));
                 }
                 else {
                     values.push(raw);
                 }
             }
-            await run(`INSERT INTO ${branch.tableName} (${colNames.join(', ')}) VALUES (${placeholders.join(', ')})`, ...values);
+            await run(`INSERT INTO ${branch.tableName} (${colNames.join(', ')}) VALUES (${placeholders.join(', ')})`, values);
         }
     }
+    // Incrementally update FTS index for this record
+    await updateFtsRecord(collection, uri);
 }
 /** Extract branch data from a union value, handling wrapper properties */
 function resolveBranchData(unionValue, branch) {
@@ -394,32 +671,41 @@ export async function deleteRecord(collection, uri) {
     const schema = schemas.get(collection);
     if (!schema)
         return;
+    // Remove from FTS index before deleting the record data
+    await deleteFtsRecord(collection, uri);
     for (const child of schema.children) {
-        await run(`DELETE FROM ${child.tableName} WHERE parent_uri = $1`, uri);
+        await run(`DELETE FROM ${child.tableName} WHERE parent_uri = $1`, [uri]);
     }
     for (const union of schema.unions) {
         for (const branch of union.branches) {
-            await run(`DELETE FROM ${branch.tableName} WHERE parent_uri = $1`, uri);
+            await run(`DELETE FROM ${branch.tableName} WHERE parent_uri = $1`, [uri]);
         }
     }
-    await run(`DELETE FROM ${schema.tableName} WHERE uri = $1`, uri);
+    await run(`DELETE FROM ${schema.tableName} WHERE uri = $1`, [uri]);
 }
 export async function insertLabels(labels) {
     if (labels.length === 0)
         return;
     for (const label of labels) {
-        // Skip if an active (non-negated, non-expired, not-superseded-by-negation) label already exists
-        const existing = await all(`SELECT 1 FROM _labels l1 WHERE l1.src = $1 AND l1.uri = $2 AND l1.val = $3 AND l1.neg = false AND (l1.exp IS NULL OR l1.exp > CURRENT_TIMESTAMP) AND NOT EXISTS (SELECT 1 FROM _labels l2 WHERE l2.uri = l1.uri AND l2.val = l1.val AND l2.neg = true AND l2.id > l1.id) LIMIT 1`, label.src, label.uri, label.val);
+        // Skip if an active (non-negated, non-expired, not-superseded-by-negation) label already exists for this src+uri+val
+        const existing = await all(`SELECT 1 FROM _labels l1 WHERE l1.src = $1 AND l1.uri = $2 AND l1.val = $3 AND l1.neg = false AND (l1.exp IS NULL OR l1.exp > CURRENT_TIMESTAMP) AND NOT EXISTS (SELECT 1 FROM _labels l2 WHERE l2.uri = l1.uri AND l2.val = l1.val AND l2.neg = true AND l2.id > l1.id) LIMIT 1`, [label.src, label.uri, label.val]);
         if (!label.neg && existing.length > 0)
             continue;
-        await run(`INSERT INTO _labels (src, uri, val, neg, cts, exp) VALUES ($1, $2, $3, $4, $5, $6)`, label.src, label.uri, label.val, label.neg || false, label.cts || new Date().toISOString(), label.exp || null);
+        await run(`INSERT INTO _labels (src, uri, val, neg, cts, exp) VALUES ($1, $2, $3, $4, $5, $6)`, [
+            label.src,
+            label.uri,
+            label.val,
+            label.neg || false,
+            label.cts || new Date().toISOString(),
+            label.exp || null,
+        ]);
     }
 }
 export async function queryLabelsForUris(uris) {
     if (uris.length === 0)
         return new Map();
     const placeholders = uris.map((_, i) => `$${i + 1}`).join(',');
-    const rows = await all(`SELECT src, uri, val, neg, cts, exp FROM _labels l1 WHERE uri IN (${placeholders}) AND (exp IS NULL OR exp > CURRENT_TIMESTAMP) AND neg = false AND NOT EXISTS (SELECT 1 FROM _labels l2 WHERE l2.uri = l1.uri AND l2.val = l1.val AND l2.neg = true AND l2.id > l1.id)`, ...uris);
+    const rows = await all(`SELECT src, uri, val, neg, cts, exp FROM _labels l1 WHERE uri IN (${placeholders}) AND (exp IS NULL OR exp > CURRENT_TIMESTAMP) AND neg = false AND NOT EXISTS (SELECT 1 FROM _labels l2 WHERE l2.uri = l1.uri AND l2.val = l1.val AND l2.neg = true AND l2.id > l1.id) GROUP BY uri, val`, uris);
     const result = new Map();
     for (const row of rows) {
         const key = row.uri;
@@ -429,9 +715,9 @@ export async function queryLabelsForUris(uris) {
             src: row.src,
             uri: row.uri,
             val: row.val,
-            neg: row.neg,
+            neg: !!row.neg,
             cts: normalizeValue(row.cts),
-            exp: row.exp ? String(row.exp) : null,
+            ...(row.exp ? { exp: String(row.exp) } : {}),
         });
     }
     return result;
@@ -452,246 +738,209 @@ export async function bulkInsertRecords(records) {
         if (!schema)
             continue;
         const stagingTable = `_staging_${collection.replace(/\./g, '_')}`;
-        const allCols = ['uri', 'cid', 'did', 'indexed_at', ...schema.columns.map((c) => c.name)];
+        const allCols = ['uri', 'cid', 'did', 'indexed_at', ...schema.columns.map((c) => q(c.name))];
         const colDefs = [
             'uri TEXT',
             'cid TEXT',
             'did TEXT',
             'indexed_at TEXT',
-            ...schema.columns.map((c) => `${c.name} ${c.duckdbType === 'TIMESTAMP' ? 'TEXT' : c.duckdbType}`),
+            ...schema.columns.map((c) => {
+                const t = c.sqlType;
+                // Use TEXT for timestamp columns in staging (will cast on merge)
+                return `${q(c.name)} ${t === 'TIMESTAMP' || t === 'TIMESTAMPTZ' ? 'TEXT' : t}`;
+            }),
         ];
-        // Create staging table + appender + merge all in one write queue slot
-        await enqueue('write', async () => {
-            await con.run(`DROP TABLE IF EXISTS ${stagingTable}`);
-            await con.run(`CREATE TABLE ${stagingTable} (${colDefs.join(', ')})`);
-            const appender = await con.createAppender(stagingTable);
-            const now = new Date().toISOString();
+        await port.execute(`DROP TABLE IF EXISTS ${stagingTable}`, []);
+        await port.execute(`CREATE TABLE ${stagingTable} (${colDefs.join(', ')})`, []);
+        const inserter = await port.createBulkInserter(stagingTable, allCols);
+        const now = new Date().toISOString();
+        for (const rec of recs) {
+            try {
+                const values = [rec.uri, rec.cid, rec.did, now];
+                for (const col of schema.columns) {
+                    values.push(resolveColumnValue(col, rec.record));
+                }
+                inserter.append(values);
+                inserted++;
+            }
+            catch {
+                // Skip bad records
+            }
+        }
+        await inserter.close();
+        // Merge into target, filtering rows that would violate NOT NULL
+        const selectCols = allCols.map((name) => {
+            const col = schema.columns.find((c) => q(c.name) === name);
+            if (name === 'indexed_at' || (col && (col.sqlType === 'TIMESTAMP' || col.sqlType === 'TIMESTAMPTZ'))) {
+                return `${dialect.tryCastTimestamp(name)} AS ${name}`;
+            }
+            return name;
+        });
+        const notNullChecks = ['uri IS NOT NULL', 'did IS NOT NULL'];
+        for (const col of schema.columns) {
+            if (col.notNull) {
+                if (col.sqlType === 'TIMESTAMP' || col.sqlType === 'TIMESTAMPTZ') {
+                    notNullChecks.push(`${dialect.tryCastTimestamp(q(col.name))} IS NOT NULL`);
+                }
+                else {
+                    notNullChecks.push(`${q(col.name)} IS NOT NULL`);
+                }
+            }
+        }
+        const whereClause = notNullChecks.length ? ` WHERE ${notNullChecks.join(' AND ')}` : '';
+        await port.execute(`INSERT OR REPLACE INTO ${schema.tableName} (${allCols.join(', ')}) SELECT ${selectCols.join(', ')} FROM ${stagingTable}${whereClause}`, []);
+        await port.execute(`DROP TABLE ${stagingTable}`, []);
+        // Populate child tables
+        for (const child of schema.children) {
+            const childStagingTable = `_staging_${collection.replace(/\./g, '_')}__${child.fieldName}`;
+            const childColDefs = [
+                'parent_uri TEXT',
+                'parent_did TEXT',
+                ...child.columns.map((c) => {
+                    const t = c.sqlType;
+                    return `${q(c.name)} ${t === 'TIMESTAMP' || t === 'TIMESTAMPTZ' ? 'TEXT' : t}`;
+                }),
+            ];
+            const childAllCols = ['parent_uri', 'parent_did', ...child.columns.map((c) => q(c.name))];
+            await port.execute(`DROP TABLE IF EXISTS ${childStagingTable}`, []);
+            await port.execute(`CREATE TABLE ${childStagingTable} (${childColDefs.join(', ')})`, []);
+            const childInserter = await port.createBulkInserter(childStagingTable, childAllCols);
             for (const rec of recs) {
-                try {
-                    appender.appendVarchar(rec.uri);
-                    appender.appendVarchar(rec.cid);
-                    appender.appendVarchar(rec.did);
-                    appender.appendVarchar(now);
-                    for (const col of schema.columns) {
-                        let rawValue = rec.record[col.originalName];
-                        if (rawValue && typeof rawValue === 'object' && col.name.endsWith('_uri') && col.isRef) {
-                            rawValue = rawValue.uri;
-                        }
-                        else if (col.originalName.endsWith('__cid') && rec.record[col.originalName.replace('__cid', '')]) {
-                            rawValue = rec.record[col.originalName.replace('__cid', '')].cid;
-                        }
-                        if (rawValue === undefined || rawValue === null) {
-                            appender.appendNull();
-                        }
-                        else if (col.duckdbType === 'JSON') {
-                            appender.appendVarchar(JSON.stringify(rawValue));
-                        }
-                        else if (col.duckdbType === 'INTEGER') {
-                            appender.appendInteger(typeof rawValue === 'number' ? rawValue : parseInt(rawValue));
-                        }
-                        else if (col.duckdbType === 'BOOLEAN') {
-                            appender.appendBoolean(!!rawValue);
-                        }
-                        else {
-                            appender.appendVarchar(String(rawValue));
+                const items = rec.record[child.fieldName];
+                if (!Array.isArray(items))
+                    continue;
+                for (const item of items) {
+                    try {
+                        const values = [rec.uri, rec.did];
+                        for (const col of child.columns) {
+                            values.push(resolveRawColumnValue(col, item));
                         }
+                        childInserter.append(values);
+                    }
+                    catch {
+                        // Skip bad items
                     }
-                    appender.endRow();
-                    inserted++;
-                }
-                catch {
-                    // Skip bad records
                 }
             }
-            appender.flushSync();
-            appender.closeSync();
-            // Merge into target with TRY_CAST for TIMESTAMP columns, filtering rows that would violate NOT NULL
-            const selectCols = allCols.map((name) => {
-                const col = schema.columns.find((c) => c.name === name);
-                if (name === 'indexed_at' || (col && col.duckdbType === 'TIMESTAMP')) {
-                    return `TRY_CAST(${name} AS TIMESTAMP) AS ${name}`;
+            await childInserter.close();
+            // Delete existing child rows for these URIs, then merge staging
+            const uriPlaceholders = recs.map((_, i) => `$${i + 1}`).join(',');
+            await port.execute(`DELETE FROM ${child.tableName} WHERE parent_uri IN (${uriPlaceholders})`, recs.map((r) => r.uri));
+            const childSelectCols = childAllCols.map((name) => {
+                const col = child.columns.find((c) => q(c.name) === name);
+                if (col && (col.sqlType === 'TIMESTAMP' || col.sqlType === 'TIMESTAMPTZ')) {
+                    return `${dialect.tryCastTimestamp(name)} AS ${name}`;
                 }
                 return name;
             });
-            // Build WHERE clause to exclude rows missing NOT NULL fields
-            const notNullChecks = ['uri IS NOT NULL', 'did IS NOT NULL'];
-            for (const col of schema.columns) {
-                if (col.notNull) {
-                    if (col.duckdbType === 'TIMESTAMP') {
-                        notNullChecks.push(`TRY_CAST(${col.name} AS TIMESTAMP) IS NOT NULL`);
-                    }
-                    else {
-                        notNullChecks.push(`${col.name} IS NOT NULL`);
-                    }
-                }
-            }
-            const whereClause = notNullChecks.length ? ` WHERE ${notNullChecks.join(' AND ')}` : '';
-            await con.run(`INSERT OR REPLACE INTO ${schema.tableName} (${allCols.join(', ')}) SELECT ${selectCols.join(', ')} FROM ${stagingTable}${whereClause}`);
-            await con.run(`DROP TABLE ${stagingTable}`);
-            // Populate child tables
-            for (const child of schema.children) {
-                const childStagingTable = `_staging_${collection.replace(/\./g, '_')}__${child.fieldName}`;
-                const childColDefs = [
+            await port.execute(`INSERT INTO ${child.tableName} (${childAllCols.join(', ')}) SELECT ${childSelectCols.join(', ')} FROM ${childStagingTable} WHERE parent_uri IS NOT NULL`, []);
+            await port.execute(`DROP TABLE ${childStagingTable}`, []);
+        }
+        // Populate union branch tables
+        for (const union of schema.unions) {
+            for (const branch of union.branches) {
+                const branchStagingTable = `_staging_${collection.replace(/\./g, '_')}__${toSnakeCase(union.fieldName)}_${branch.branchName}`;
+                const branchColDefs = [
                     'parent_uri TEXT',
                     'parent_did TEXT',
-                    ...child.columns.map((c) => `${c.name} ${c.duckdbType === 'TIMESTAMP' ? 'TEXT' : c.duckdbType}`),
+                    ...branch.columns.map((c) => {
+                        const t = c.sqlType;
+                        return `${q(c.name)} ${t === 'TIMESTAMP' || t === 'TIMESTAMPTZ' ? 'TEXT' : t}`;
+                    }),
                 ];
-                const childAllCols = ['parent_uri', 'parent_did', ...child.columns.map((c) => c.name)];
-                await con.run(`DROP TABLE IF EXISTS ${childStagingTable}`);
-                await con.run(`CREATE TABLE ${childStagingTable} (${childColDefs.join(', ')})`);
-                const childAppender = await con.createAppender(childStagingTable);
+                const branchAllCols = ['parent_uri', 'parent_did', ...branch.columns.map((c) => q(c.name))];
+                await port.execute(`DROP TABLE IF EXISTS ${branchStagingTable}`, []);
+                await port.execute(`CREATE TABLE ${branchStagingTable} (${branchColDefs.join(', ')})`, []);
+                const branchInserter = await port.createBulkInserter(branchStagingTable, branchAllCols);
                 for (const rec of recs) {
-                    const items = rec.record[child.fieldName];
-                    if (!Array.isArray(items))
+                    const unionValue = rec.record[union.fieldName];
+                    if (!unionValue || typeof unionValue !== 'object')
                         continue;
-                    for (const item of items) {
-                        try {
-                            childAppender.appendVarchar(rec.uri);
-                            childAppender.appendVarchar(rec.did);
-                            for (const col of child.columns) {
-                                const rawValue = item[col.originalName];
-                                if (rawValue === undefined || rawValue === null) {
-                                    childAppender.appendNull();
-                                }
-                                else if (col.duckdbType === 'JSON') {
-                                    childAppender.appendVarchar(JSON.stringify(rawValue));
-                                }
-                                else if (col.duckdbType === 'INTEGER') {
-                                    childAppender.appendInteger(typeof rawValue === 'number' ? rawValue : parseInt(rawValue));
-                                }
-                                else if (col.duckdbType === 'BOOLEAN') {
-                                    childAppender.appendBoolean(!!rawValue);
-                                }
-                                else {
-                                    childAppender.appendVarchar(String(rawValue));
-                                }
-                            }
-                            childAppender.endRow();
-                        }
-                        catch {
-                            // Skip bad items
-                        }
-                    }
-                }
-                childAppender.flushSync();
-                childAppender.closeSync();
-                // Delete existing child rows for these URIs, then merge staging
-                const uriPlaceholders = recs.map((_, i) => `$${i + 1}`).join(',');
-                const delStmt = await con.prepare(`DELETE FROM ${child.tableName} WHERE parent_uri IN (${uriPlaceholders})`);
-                bindParams(delStmt, recs.map((r) => r.uri));
-                await delStmt.run();
-                const childSelectCols = childAllCols.map((name) => {
-                    const col = child.columns.find((c) => c.name === name);
-                    if (col && col.duckdbType === 'TIMESTAMP')
-                        return `TRY_CAST(${name} AS TIMESTAMP) AS ${name}`;
-                    return name;
-                });
-                await con.run(`INSERT INTO ${child.tableName} (${childAllCols.join(', ')}) SELECT ${childSelectCols.join(', ')} FROM ${childStagingTable} WHERE parent_uri IS NOT NULL`);
-                await con.run(`DROP TABLE ${childStagingTable}`);
-            }
-            // Populate union branch tables
-            for (const union of schema.unions) {
-                for (const branch of union.branches) {
-                    const branchStagingTable = `_staging_${collection.replace(/\./g, '_')}__${toSnakeCase(union.fieldName)}_${branch.branchName}`;
-                    const branchColDefs = [
-                        'parent_uri TEXT',
-                        'parent_did TEXT',
-                        ...branch.columns.map((c) => `${c.name} ${c.duckdbType === 'TIMESTAMP' ? 'TEXT' : c.duckdbType}`),
-                    ];
-                    const branchAllCols = ['parent_uri', 'parent_did', ...branch.columns.map((c) => c.name)];
-                    await con.run(`DROP TABLE IF EXISTS ${branchStagingTable}`);
-                    await con.run(`CREATE TABLE ${branchStagingTable} (${branchColDefs.join(', ')})`);
-                    const branchAppender = await con.createAppender(branchStagingTable);
-                    for (const rec of recs) {
-                        const unionValue = rec.record[union.fieldName];
-                        if (!unionValue || typeof unionValue !== 'object')
-                            continue;
-                        if (unionValue.$type !== branch.type)
+                    if (unionValue.$type !== branch.type)
+                        continue;
+                    if (branch.isArray && branch.arrayField) {
+                        const items = resolveBranchData(unionValue, branch)[branch.arrayField];
+                        if (!Array.isArray(items))
                             continue;
-                        if (branch.isArray && branch.arrayField) {
-                            const items = resolveBranchData(unionValue, branch)[branch.arrayField];
-                            if (!Array.isArray(items))
-                                continue;
-                            for (const item of items) {
-                                try {
-                                    branchAppender.appendVarchar(rec.uri);
-                                    branchAppender.appendVarchar(rec.did);
-                                    for (const col of branch.columns) {
-                                        const rawValue = item[col.originalName];
-                                        if (rawValue === undefined || rawValue === null) {
-                                            branchAppender.appendNull();
-                                        }
-                                        else if (col.duckdbType === 'JSON') {
-                                            branchAppender.appendVarchar(JSON.stringify(rawValue));
-                                        }
-                                        else if (col.duckdbType === 'INTEGER') {
-                                            branchAppender.appendInteger(typeof rawValue === 'number' ? rawValue : parseInt(rawValue));
-                                        }
-                                        else if (col.duckdbType === 'BOOLEAN') {
-                                            branchAppender.appendBoolean(!!rawValue);
-                                        }
-                                        else {
-                                            branchAppender.appendVarchar(String(rawValue));
-                                        }
-                                    }
-                                    branchAppender.endRow();
-                                }
-                                catch {
-                                    // Skip bad items
-                                }
-                            }
-                        }
-                        else {
+                        for (const item of items) {
                             try {
-                                const branchData = resolveBranchData(unionValue, branch);
-                                branchAppender.appendVarchar(rec.uri);
-                                branchAppender.appendVarchar(rec.did);
+                                const values = [rec.uri, rec.did];
                                 for (const col of branch.columns) {
-                                    const rawValue = branchData[col.originalName];
-                                    if (rawValue === undefined || rawValue === null) {
-                                        branchAppender.appendNull();
-                                    }
-                                    else if (col.duckdbType === 'JSON') {
-                                        branchAppender.appendVarchar(JSON.stringify(rawValue));
-                                    }
-                                    else if (col.duckdbType === 'INTEGER') {
-                                        branchAppender.appendInteger(typeof rawValue === 'number' ? rawValue : parseInt(rawValue));
-                                    }
-                                    else if (col.duckdbType === 'BOOLEAN') {
-                                        branchAppender.appendBoolean(!!rawValue);
-                                    }
-                                    else {
-                                        branchAppender.appendVarchar(String(rawValue));
-                                    }
+                                    values.push(resolveRawColumnValue(col, item));
                                 }
-                                branchAppender.endRow();
+                                branchInserter.append(values);
                             }
                             catch {
-                                // Skip bad records
+                                // Skip bad items
                             }
                         }
                     }
-                    branchAppender.flushSync();
-                    branchAppender.closeSync();
-                    // Delete existing branch rows for these URIs, then merge staging
-                    const uriPlaceholders = recs.map((_, i) => `$${i + 1}`).join(',');
-                    const delStmt = await con.prepare(`DELETE FROM ${branch.tableName} WHERE parent_uri IN (${uriPlaceholders})`);
-                    bindParams(delStmt, recs.map((r) => r.uri));
-                    await delStmt.run();
-                    const branchSelectCols = branchAllCols.map((name) => {
-                        const col = branch.columns.find((c) => c.name === name);
-                        if (col && col.duckdbType === 'TIMESTAMP')
-                            return `TRY_CAST(${name} AS TIMESTAMP) AS ${name}`;
-                        return name;
-                    });
-                    await con.run(`INSERT INTO ${branch.tableName} (${branchAllCols.join(', ')}) SELECT ${branchSelectCols.join(', ')} FROM ${branchStagingTable} WHERE parent_uri IS NOT NULL`);
-                    await con.run(`DROP TABLE ${branchStagingTable}`);
+                    else {
+                        try {
+                            const branchData = resolveBranchData(unionValue, branch);
+                            const values = [rec.uri, rec.did];
+                            for (const col of branch.columns) {
+                                values.push(resolveRawColumnValue(col, branchData));
+                            }
+                            branchInserter.append(values);
+                        }
+                        catch {
+                            // Skip bad records
+                        }
+                    }
                 }
+                await branchInserter.close();
+                // Delete existing branch rows for these URIs, then merge staging
+                const uriPlaceholders = recs.map((_, i) => `$${i + 1}`).join(',');
+                await port.execute(`DELETE FROM ${branch.tableName} WHERE parent_uri IN (${uriPlaceholders})`, recs.map((r) => r.uri));
+                const branchSelectCols = branchAllCols.map((name) => {
+                    const col = branch.columns.find((c) => q(c.name) === name);
+                    if (col && (col.sqlType === 'TIMESTAMP' || col.sqlType === 'TIMESTAMPTZ')) {
+                        return `${dialect.tryCastTimestamp(name)} AS ${name}`;
+                    }
+                    return name;
+                });
+                await port.execute(`INSERT INTO ${branch.tableName} (${branchAllCols.join(', ')}) SELECT ${branchSelectCols.join(', ')} FROM ${branchStagingTable} WHERE parent_uri IS NOT NULL`, []);
+                await port.execute(`DROP TABLE ${branchStagingTable}`, []);
             }
-        });
+        }
     }
     return inserted;
 }
+/** Extract a column value from a record, handling strongRef expansion and type coercion for bulk insert */
+function resolveColumnValue(col, record) {
+    let rawValue = record[col.originalName];
+    if (rawValue && typeof rawValue === 'object' && col.name.endsWith('_uri') && col.isRef) {
+        rawValue = rawValue.uri;
+    }
+    else if (col.originalName.endsWith('__cid') && record[col.originalName.replace('__cid', '')]) {
+        rawValue = record[col.originalName.replace('__cid', '')].cid;
+    }
+    return coerceValue(col.sqlType, rawValue);
+}
+/** Extract a raw column value from a data object and coerce for bulk insert */
+function resolveRawColumnValue(col, data) {
+    return coerceValue(col.sqlType, data[col.originalName]);
+}
+/** Coerce a value to the appropriate type for insertion */
+function coerceValue(sqlType, rawValue) {
+    if (rawValue === undefined || rawValue === null)
+        return null;
+    // Objects and arrays always need JSON stringification regardless of sqlType
+    // (on SQLite, JSON columns map to TEXT but still need stringification)
+    if (typeof rawValue === 'object' && !(rawValue instanceof Uint8Array)) {
+        return JSON.stringify(rawValue);
+    }
+    if (sqlType === 'JSON' || sqlType === 'TEXT') {
+        return String(rawValue);
+    }
+    if (sqlType === 'INTEGER' || sqlType === 'BIGINT') {
+        return typeof rawValue === 'number' ? rawValue : parseInt(rawValue);
+    }
+    if (sqlType === 'BOOLEAN')
+        return !!rawValue;
+    return String(rawValue);
+}
 export async function queryRecords(collection, opts = {}) {
     const schema = schemas.get(collection);
     if (!schema)
@@ -734,7 +983,7 @@ export async function queryRecords(collection, opts = {}) {
         sql += ' AND ' + conditions.join(' AND ');
     sql += ` ORDER BY t.${sortName} ${order.toUpperCase()}, t.cid ${order.toUpperCase()} LIMIT $${paramIdx++}`;
     params.push(limit + 1); // fetch one extra for cursor
-    const rows = await all(sql, ...params);
+    const rows = await all(sql, params);
     const hasMore = rows.length > limit;
     if (hasMore)
         rows.pop();
@@ -774,7 +1023,7 @@ export async function queryRecords(collection, opts = {}) {
 }
 export async function getRecordByUri(uri) {
     for (const [_collection, schema] of schemas) {
-        const rows = await all(`SELECT t.*, r.handle FROM ${schema.tableName} t LEFT JOIN _repos r ON t.did = r.did WHERE t.uri = $1 AND (r.status IS NULL OR r.status != 'takendown')`, uri);
+        const rows = await all(`SELECT t.*, r.handle FROM ${schema.tableName} t LEFT JOIN _repos r ON t.did = r.did WHERE t.uri = $1 AND (r.status IS NULL OR r.status != 'takendown')`, [uri]);
         if (rows.length > 0) {
             const row = rows[0];
             if (schema.children.length > 0) {
@@ -811,7 +1060,7 @@ export async function getRecordsByUris(collection, uris) {
     if (!schema)
         return [];
     const placeholders = uris.map((_, i) => `$${i + 1}`).join(',');
-    const rows = await all(`SELECT t.*, r.handle FROM ${schema.tableName} t LEFT JOIN _repos r ON t.did = r.did WHERE t.uri IN (${placeholders}) AND (r.status IS NULL OR r.status != 'takendown')`, ...uris);
+    const rows = await all(`SELECT t.*, r.handle FROM ${schema.tableName} t LEFT JOIN _repos r ON t.did = r.did WHERE t.uri IN (${placeholders}) AND (r.status IS NULL OR r.status != 'takendown')`, uris);
     // Batch-fetch child rows for all URIs
     const childData = new Map();
     for (const child of schema.children) {
@@ -839,6 +1088,19 @@ export async function getRecordsByUris(collection, uris) {
     const byUri = new Map(rows.map((r) => [r.uri, r]));
     return uris.map((u) => byUri.get(u)).filter(Boolean);
 }
+/** Fetch records by URIs and return as a shaped Map keyed by URI. */
+export async function getRecordsMap(collection, uris) {
+    if (uris.length === 0)
+        return new Map();
+    const records = await getRecordsByUris(collection, uris);
+    const map = new Map();
+    for (const r of records) {
+        const shaped = reshapeRow(r, r?.__childData, r?.__unionData);
+        if (shaped)
+            map.set(shaped.uri, shaped);
+    }
+    return map;
+}
 /**
  * Multi-phase search across any collection's records.
  *
@@ -859,8 +1121,8 @@ export async function searchRecords(collection, query, opts = {}) {
     if (!schema)
         throw new Error(`Unknown collection: ${collection}`);
     const elapsed = timer();
-    const { limit = 20, cursor, fuzzy = true } = opts;
-    const textCols = schema.columns.filter((c) => c.duckdbType === 'TEXT');
+    const { limit = 20, fuzzy = true } = opts;
+    const textCols = schema.columns.filter((c) => c.sqlType === 'TEXT');
     // Also check if FTS has indexed any columns (including derived JSON columns)
     const ftsSearchCols = getSearchColumns(collection);
     if (textCols.length === 0 && ftsSearchCols.length === 0) {
@@ -868,149 +1130,67 @@ export async function searchRecords(collection, query, opts = {}) {
     }
     // FTS shadow table name (dots replaced with underscores)
     const safeName = '_fts_' + collection.replace(/\./g, '_');
-    const ftsSchema = `fts_main_${safeName}`;
     const phaseErrors = [];
     const phasesUsed = [];
-    // Phase 1: BM25 ranked search on FTS shadow table
+    // Phase 1: BM25 ranked search via SearchPort
     let bm25Results = [];
-    try {
-        let paramIdx = 1;
-        const ftsQuery = stripStopWords(query);
-        const isMultiWord = ftsQuery.split(/\s+/).length > 1;
-        const conjunctiveFlag = isMultiWord ? ', conjunctive := 1' : '';
-        let sql = `SELECT m.*, ${ftsSchema}.match_bm25(s.uri, $${paramIdx++}${conjunctiveFlag}) AS score
-      FROM ${safeName} s
-      JOIN ${schema.tableName} m ON m.uri = s.uri
-      LEFT JOIN _repos r ON m.did = r.did
-      WHERE score IS NOT NULL
-      AND (r.status IS NULL OR r.status != 'takendown')`;
-        const params = [ftsQuery];
-        if (cursor) {
-            const parsed = unpackCursor(cursor);
-            if (parsed) {
-                const pScore1 = `$${paramIdx++}`;
-                const pScore2 = `$${paramIdx++}`;
-                const pCid = `$${paramIdx++}`;
-                sql += ` AND (score > ${pScore1} OR (score = ${pScore2} AND m.cid < ${pCid}))`;
-                params.push(parsed.primary, parsed.primary, parsed.cid);
+    const sp = getSearchPort();
+    if (sp)
+        try {
+            const ftsQuery = stripStopWords(query);
+            const ftsSearchColNames = getSearchColumns(collection);
+            // Get ranked URIs from the search port
+            const hits = await sp.search(safeName, ftsQuery, ftsSearchColNames, limit + 1, 0);
+            if (hits.length > 0) {
+                const uriList = hits.map((h) => h.uri);
+                const scoreMap = new Map(hits.map((h) => [h.uri, h.score]));
+                // Fetch full records for matched URIs
+                const placeholders = uriList.map((_, i) => `$${i + 1}`).join(', ');
+                const rows = await all(`SELECT m.* FROM ${schema.tableName} m
+          LEFT JOIN _repos r ON m.did = r.did
+          WHERE m.uri IN (${placeholders})
+          AND (r.status IS NULL OR r.status != 'takendown')`, uriList);
+                // Re-attach scores and sort
+                bm25Results = rows
+                    .map((r) => ({ ...r, score: scoreMap.get(r.uri) ?? 0 }))
+                    .sort((a, b) => b.score - a.score);
             }
+            phasesUsed.push('bm25');
+        }
+        catch (err) {
+            phaseErrors.push(`bm25: ${err.message}`);
         }
-        sql += ` ORDER BY score, m.cid DESC LIMIT $${paramIdx++}`;
-        params.push(limit + 1);
-        bm25Results = await all(sql, ...params);
-        phasesUsed.push('bm25');
-    }
-    catch (err) {
-        phaseErrors.push(`bm25: ${err.message}`);
-    }
     const bm25Count = bm25Results.length;
     const hasMore = bm25Results.length > limit;
     if (hasMore)
         bm25Results.pop();
-    // Phase 2: Exact substring match — boosts phrase matches above BM25 results
-    const exactMatchResults = [];
-    const bm25Uris = new Set(bm25Results.map((r) => r.uri));
-    try {
-        const searchParam = `%${query}%`;
-        let paramIdx = 1;
-        const ilikeConds = [];
-        const params = [];
-        // TEXT columns — direct ILIKE
-        for (const c of textCols) {
-            ilikeConds.push(`t.${c.name} ILIKE $${paramIdx++}`);
-            params.push(searchParam);
-        }
-        // JSON columns — cast to text then ILIKE
-        const jsonCols = schema.columns.filter((c) => c.duckdbType === 'JSON');
-        for (const c of jsonCols) {
-            ilikeConds.push(`CAST(t.${c.name} AS TEXT) ILIKE $${paramIdx++}`);
-            params.push(searchParam);
-        }
-        // Handle from _repos table
-        ilikeConds.push(`r.handle ILIKE $${paramIdx++}`);
-        params.push(searchParam);
-        if (ilikeConds.length > 0) {
-            const exactSQL = `SELECT t.* FROM ${schema.tableName} t LEFT JOIN _repos r ON t.did = r.did
-        WHERE (${ilikeConds.join(' OR ')})
-        ORDER BY t.indexed_at DESC
-        LIMIT $${paramIdx++}`;
-            params.push(limit);
-            const rows = await all(exactSQL, ...params);
-            phasesUsed.push('exact');
-            for (const row of rows) {
-                if (!bm25Uris.has(row.uri)) {
-                    exactMatchResults.push(row);
-                    bm25Uris.add(row.uri);
-                }
-            }
-        }
-    }
-    catch (err) {
-        phaseErrors.push(`exact: ${err.message}`);
-    }
-    // Merge: exact matches first, then BM25 results, capped at limit
-    const mergedResults = [...exactMatchResults, ...bm25Results].slice(0, limit + (hasMore ? 1 : 0));
-    // Replace bm25Results with merged for downstream phases
-    bm25Results = mergedResults;
-    // Phase 3: ILIKE scan of rows written since last FTS rebuild (immediate searchability)
     const existingUris = new Set(bm25Results.map((r) => r.uri));
-    const { getLastRebuiltAt } = await import("./fts.js");
-    const rebuiltAt = getLastRebuiltAt(collection);
-    let recentCount = 0;
-    if (rebuiltAt && bm25Results.length < limit) {
-        const remaining = limit - bm25Results.length;
-        const searchParam = `%${query}%`;
-        let paramIdx = 1;
-        const ilikeParts = textCols.map((c) => `t.${c.name} ILIKE $${paramIdx++}`);
-        ilikeParts.push(`r.handle ILIKE $${paramIdx++}`);
-        const ilikeConds = ilikeParts.join(' OR ');
-        const params = [...textCols.map(() => searchParam), searchParam];
-        const recentSQL = `SELECT t.* FROM ${schema.tableName} t LEFT JOIN _repos r ON t.did = r.did
-      WHERE t.indexed_at >= $${paramIdx++} AND t.uri NOT IN (SELECT uri FROM ${safeName}) AND (${ilikeConds})
-      ORDER BY t.indexed_at DESC
-      LIMIT $${paramIdx++}`;
-        params.push(rebuiltAt, remaining + existingUris.size);
-        try {
-            const recentRows = await all(recentSQL, ...params);
-            phasesUsed.push('recent');
-            for (const row of recentRows) {
-                if (bm25Results.length >= limit)
-                    break;
-                if (!existingUris.has(row.uri)) {
-                    existingUris.add(row.uri);
-                    bm25Results.push(row);
-                    recentCount++;
-                }
-            }
-        }
-        catch (err) {
-            phaseErrors.push(`recent: ${err.message}`);
-        }
-    }
-    // Phase 4: Fuzzy fallback for typo tolerance (if still under limit)
+    // Phase 2: Fuzzy fallback for typo tolerance (if still under limit)
+    // Only available on dialects with jaro_winkler_similarity (DuckDB)
     let fuzzyCount = 0;
-    if (fuzzy && bm25Results.length < limit) {
+    if (fuzzy && dialect.jaroWinklerSimilarity && bm25Results.length < limit) {
         const remaining = limit - bm25Results.length;
+        const jwFn = dialect.jaroWinklerSimilarity;
         const simExprs = [
-            ...textCols.map((c) => `jaro_winkler_similarity(lower(t.${c.name}), lower($1))`),
-            `jaro_winkler_similarity(lower(r.handle), lower($1))`,
+            ...textCols.map((c) => `${jwFn}(lower(t.${q(c.name)}), lower($1))`),
+            `${jwFn}(lower(r.handle), lower($1))`,
         ];
         // Include child table TEXT columns via correlated subquery
         for (const child of schema.children) {
             for (const col of child.columns) {
-                if (col.duckdbType === 'TEXT') {
-                    simExprs.push(`COALESCE((SELECT MAX(jaro_winkler_similarity(lower(c.${col.name}), lower($1))) FROM ${child.tableName} c WHERE c.parent_uri = t.uri), 0)`);
+                if (col.sqlType === 'TEXT') {
+                    simExprs.push(`COALESCE((SELECT MAX(${jwFn}(lower(c.${q(col.name)}), lower($1))) FROM ${child.tableName} c WHERE c.parent_uri = t.uri), 0)`);
                 }
             }
         }
-        const greatestExpr = `GREATEST(${simExprs.join(', ')})`;
+        const greatestExpr = dialect.greatest(simExprs);
         const fuzzySQL = `SELECT t.*, ${greatestExpr} AS fuzzy_score
       FROM ${schema.tableName} t LEFT JOIN _repos r ON t.did = r.did
       WHERE ${greatestExpr} >= 0.8
       ORDER BY fuzzy_score DESC
       LIMIT $2`;
         try {
-            const fuzzyRows = await all(fuzzySQL, query, remaining + existingUris.size);
+            const fuzzyRows = await all(fuzzySQL, [query, remaining + existingUris.size]);
             phasesUsed.push('fuzzy');
             for (const row of fuzzyRows) {
                 if (bm25Results.length >= limit)
@@ -1025,16 +1205,17 @@ export async function searchRecords(collection, query, opts = {}) {
             phaseErrors.push(`fuzzy: ${err.message}`);
         }
     }
-    // Remove score columns from results
-    const records = bm25Results.map(({ score: _score, fuzzy_score: _fuzzy_score, ...rest }) => rest);
+    // Remove score columns and reshape into Row<T> with value
+    const rawRecords = bm25Results.map(({ score: _score, fuzzy_score: _fuzzy_score, ...rest }) => rest);
+    const records = rawRecords
+        .map((r) => reshapeRow(r, r?.__childData, r?.__unionData))
+        .filter((r) => r != null);
     const lastRow = bm25Results[bm25Results.length - 1];
     const nextCursor = hasMore && lastRow?.score != null ? packCursor(lastRow.score, lastRow.cid) : undefined;
     emit('search', 'query', {
         collection,
         query,
         bm25_count: bm25Count > limit ? bm25Count - 1 : bm25Count,
-        exact_count: exactMatchResults.length,
-        recent_count: recentCount,
         fuzzy_count: fuzzyCount,
         total_results: records.length,
         duration_ms: elapsed(),
@@ -1045,10 +1226,13 @@ export async function searchRecords(collection, query, opts = {}) {
 }
 // Raw SQL for script feeds
 export async function querySQL(sql, params = []) {
-    return all(sql, ...params);
+    return all(sql, params);
 }
-export async function runSQL(sql, ...params) {
-    return run(sql, ...params);
+export async function runSQL(sql, params = []) {
+    return run(sql, params);
+}
+export async function createBulkInserterSQL(table, columns, options) {
+    return port.createBulkInserter(table, columns, options);
 }
 export function getSchema(collection) {
     return schemas.get(collection);
@@ -1057,7 +1241,9 @@ export async function countByField(collection, field, value) {
     const schema = schemas.get(collection);
     if (!schema)
         return 0;
-    const rows = await all(`SELECT COUNT(*) as count FROM ${schema.tableName} WHERE ${field} = $1`, value);
+    const rows = await all(`SELECT COUNT(*) as count FROM ${schema.tableName} WHERE ${field} = $1`, [
+        value,
+    ]);
     return Number(rows[0]?.count || 0);
 }
 export async function countByFieldBatch(collection, field, values) {
@@ -1067,7 +1253,7 @@ export async function countByFieldBatch(collection, field, values) {
     if (!schema)
         return new Map();
     const placeholders = values.map((_, i) => `$${i + 1}`).join(',');
-    const rows = await all(`SELECT ${field}, COUNT(*) as count FROM ${schema.tableName} WHERE ${field} IN (${placeholders}) GROUP BY ${field}`, ...values);
+    const rows = await all(`SELECT ${field}, COUNT(*) as count FROM ${schema.tableName} WHERE ${field} IN (${placeholders}) GROUP BY ${field}`, values);
     const result = new Map();
     for (const row of rows) {
         result.set(row[field], Number(row.count));
@@ -1078,7 +1264,7 @@ export async function findByField(collection, field, value) {
     const schema = schemas.get(collection);
     if (!schema)
         return null;
-    const rows = await all(`SELECT * FROM ${schema.tableName} WHERE ${field} = $1 LIMIT 1`, value);
+    const rows = await all(`SELECT * FROM ${schema.tableName} WHERE ${field} = $1 LIMIT 1`, [value]);
     return rows[0] || null;
 }
 export async function findByFieldBatch(collection, field, values) {
@@ -1088,7 +1274,7 @@ export async function findByFieldBatch(collection, field, values) {
     if (!schema)
         return new Map();
     const placeholders = values.map((_, i) => `$${i + 1}`).join(',');
-    const rows = await all(`SELECT t.*, r.handle FROM ${schema.tableName} t LEFT JOIN _repos r ON t.did = r.did WHERE t.${field} IN (${placeholders})`, ...values);
+    const rows = await all(`SELECT t.*, r.handle FROM ${schema.tableName} t LEFT JOIN _repos r ON t.did = r.did WHERE t.${field} IN (${placeholders})`, values);
     // Attach child data if this collection has decomposed arrays
     if (schema.children.length > 0 && rows.length > 0) {
         const uris = rows.map((r) => r.uri);
@@ -1098,7 +1284,6 @@ export async function findByFieldBatch(collection, field, values) {
             childData.set(child.fieldName, childRows);
         }
         for (const row of rows) {
-            ;
             row.__childData = childData;
         }
     }
@@ -1129,7 +1314,7 @@ export async function findUriByFields(collection, conditions) {
         return null;
     const where = conditions.map((c, i) => `${c.field} = $${i + 1}`).join(' AND ');
     const params = conditions.map((c) => c.value);
-    const rows = await all(`SELECT uri FROM ${schema.tableName} WHERE ${where} LIMIT 1`, ...params);
+    const rows = await all(`SELECT uri FROM ${schema.tableName} WHERE ${where} LIMIT 1`, params);
     return rows[0]?.uri || null;
 }
 const ENVELOPE_KEYS = new Set(['uri', 'cid', 'did', 'handle', 'indexed_at']);
@@ -1145,7 +1330,7 @@ export async function getChildRows(childTableName, parentUris) {
     if (parentUris.length === 0)
         return new Map();
     const placeholders = parentUris.map((_, i) => `$${i + 1}`).join(',');
-    const rows = await all(`SELECT * FROM ${childTableName} WHERE parent_uri IN (${placeholders})`, ...parentUris);
+    const rows = await all(`SELECT * FROM ${childTableName} WHERE parent_uri IN (${placeholders})`, parentUris);
     const result = new Map();
     for (const row of rows) {
         const key = row.parent_uri;
@@ -1167,7 +1352,7 @@ export function reshapeRow(row, childData, unionData) {
     if (schema) {
         for (const col of schema.columns) {
             nameMap.set(col.name, col.originalName);
-            if (col.duckdbType === 'JSON')
+            if (col.isJson)
                 jsonCols.add(col.name);
         }
     }
@@ -1273,15 +1458,17 @@ export function unpackCursor(cursor) {
     }
 }
 export async function queryLabelsByDid(did) {
-    return all(`SELECT * FROM _labels WHERE uri LIKE $1 AND neg = false AND (exp IS NULL OR exp > CURRENT_TIMESTAMP)`, `at://${did}/%`);
+    return all(`SELECT * FROM _labels WHERE uri LIKE $1 AND neg = false AND (exp IS NULL OR exp > CURRENT_TIMESTAMP)`, [
+        `at://${did}/%`,
+    ]);
 }
 export async function searchAccounts(query, limit = 20) {
-    return all(`SELECT did, handle, status FROM _repos WHERE did ILIKE $1 OR handle ILIKE $1 ORDER BY handle LIMIT $2`, `%${query}%`, limit);
+    return all(`SELECT did, handle, status FROM _repos WHERE did ${dialect.ilike} $1 OR handle ${dialect.ilike} $1 ORDER BY handle LIMIT $2`, [`%${query}%`, limit]);
 }
 export async function getAccountRecordCount(did) {
     let total = 0;
     for (const [, schema] of schemas) {
-        const rows = await all(`SELECT COUNT(*) as count FROM ${schema.tableName} WHERE did = $1`, did);
+        const rows = await all(`SELECT COUNT(*) as count FROM ${schema.tableName} WHERE did = $1`, [did]);
         total += Number(rows[0]?.count || 0);
     }
     return total;
@@ -1289,17 +1476,17 @@ export async function getAccountRecordCount(did) {
 export async function getAllRecordUrisForDid(did) {
     const uris = [];
     for (const [, schema] of schemas) {
-        const rows = await all(`SELECT uri FROM ${schema.tableName} WHERE did = $1`, did);
+        const rows = await all(`SELECT uri FROM ${schema.tableName} WHERE did = $1`, [did]);
         uris.push(...rows.map((r) => r.uri));
     }
     return uris;
 }
 export async function isTakendownDid(did) {
-    const rows = await all(`SELECT 1 FROM _repos WHERE did = $1 AND status = 'takendown' LIMIT 1`, did);
+    const rows = await all(`SELECT 1 FROM _repos WHERE did = $1 AND status = 'takendown' LIMIT 1`, [did]);
     return rows.length > 0;
 }
 export async function getPreferences(did) {
-    const rows = await all(`SELECT key, value FROM _preferences WHERE did = $1`, did);
+    const rows = await all(`SELECT key, value FROM _preferences WHERE did = $1`, [did]);
     const prefs = {};
     for (const row of rows) {
         try {
@@ -1312,50 +1499,66 @@ export async function getPreferences(did) {
     return prefs;
 }
 export async function putPreference(did, key, value) {
-    await run(`INSERT OR REPLACE INTO _preferences (did, key, value, updated_at) VALUES ($1, $2, $3, $4)`, did, key, JSON.stringify(value), new Date().toISOString());
+    await run(`INSERT OR REPLACE INTO _preferences (did, key, value, updated_at) VALUES ($1, $2, $3, $4)`, [
+        did,
+        key,
+        JSON.stringify(value),
+        new Date().toISOString(),
+    ]);
+}
+export async function resolveHandleToDid(handle) {
+    if (handle.startsWith('did:'))
+        return handle;
+    const rows = await all(`SELECT did FROM _repos WHERE handle = $1 LIMIT 1`, [handle]);
+    return rows[0]?.did ?? null;
 }
 export async function filterTakendownDids(dids) {
     if (dids.length === 0)
         return new Set();
     const placeholders = dids.map((_, i) => `$${i + 1}`).join(',');
-    const rows = await all(`SELECT did FROM _repos WHERE did IN (${placeholders}) AND status = 'takendown'`, ...dids);
+    const rows = await all(`SELECT did FROM _repos WHERE did IN (${placeholders}) AND status = 'takendown'`, dids);
     return new Set(rows.map((r) => r.did));
 }
-export async function backfillChildTables() {
-    for (const [, schema] of schemas) {
-        for (const child of schema.children) {
-            // Check if child table needs backfill (significantly fewer rows than parent)
-            const mainCount = (await all(`SELECT COUNT(*)::INTEGER as n FROM ${schema.tableName}`))[0]?.n || 0;
-            if (mainCount === 0)
-                continue;
-            const childCount = (await all(`SELECT COUNT(DISTINCT parent_uri)::INTEGER as n FROM ${child.tableName}`))[0]?.n || 0;
-            if (childCount >= mainCount * 0.9)
-                continue;
-            console.log(`[db] Backfilling ${child.tableName} from ${schema.tableName}...`);
-            const snakeField = toSnakeCase(child.fieldName);
-            const childColSelects = child.columns
-                .map((c) => `json_extract_string(item.val, '$.${c.originalName}')`)
-                .join(', ');
-            const childColNames = ['parent_uri', 'parent_did', ...child.columns.map((c) => c.name)];
-            const notNullFilters = child.columns
-                .filter((c) => c.notNull)
-                .map((c) => `json_extract_string(item.val, '$.${c.originalName}') IS NOT NULL`);
-            const whereClause = [`p.${snakeField} IS NOT NULL`, ...notNullFilters].join(' AND ');
-            try {
-                await run(`DELETE FROM ${child.tableName}`);
-                await run(`
-          INSERT INTO ${child.tableName} (${childColNames.join(', ')})
-          SELECT p.uri, p.did, ${childColSelects}
-          FROM ${schema.tableName} p,
-               unnest(from_json(p.${snakeField}::JSON, '["json"]')) AS item(val)
-          WHERE ${whereClause}
-        `);
-                const result = await all(`SELECT COUNT(*)::INTEGER as n FROM ${child.tableName}`);
-                console.log(`[db] Backfilled ${child.tableName}: ${result[0]?.n || 0} rows`);
-            }
-            catch (err) {
-                console.warn(`[db] Backfill skipped for ${child.tableName}: ${err.message}`);
-            }
-        }
+export async function insertReport(report) {
+    const createdAt = new Date().toISOString();
+    const rows = await all(`INSERT INTO _reports (subject_uri, subject_did, label, reason, reported_by, created_at) VALUES ($1, $2, $3, $4, $5, $6) RETURNING id`, [report.subjectUri, report.subjectDid, report.label, report.reason || null, report.reportedBy, createdAt]);
+    return { id: rows[0].id };
+}
+export async function queryReports(opts) {
+    const conditions = [];
+    const params = [];
+    let idx = 1;
+    if (opts.status) {
+        conditions.push(`r.status = $${idx++}`);
+        params.push(opts.status);
     }
+    if (opts.label) {
+        conditions.push(`r.label = $${idx++}`);
+        params.push(opts.label);
+    }
+    const where = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
+    const limit = opts.limit || 50;
+    const offset = opts.offset || 0;
+    const countRows = await all(`SELECT ${dialect.countAsInteger} as count FROM _reports r ${where}`, params);
+    const total = Number(countRows[0]?.count || 0);
+    const rows = await all(`SELECT r.*, rp.handle as reported_by_handle FROM _reports r LEFT JOIN _repos rp ON r.reported_by = rp.did ${where} ORDER BY r.created_at DESC LIMIT $${idx++} OFFSET $${idx++}`, [...params, limit, offset]);
+    return { reports: rows, total };
+}
+export async function resolveReport(id, action, resolvedBy) {
+    const rows = await all(`SELECT subject_uri, label, status FROM _reports WHERE id = $1`, [id]);
+    if (!rows.length)
+        return null;
+    if (rows[0].status !== 'open')
+        return null;
+    await run(`UPDATE _reports SET status = $1, resolved_by = $2, resolved_at = $3 WHERE id = $4`, [
+        action,
+        resolvedBy,
+        new Date().toISOString(),
+        id,
+    ]);
+    return { subjectUri: rows[0].subject_uri, label: rows[0].label };
+}
+export async function getOpenReportCount() {
+    const rows = await all(`SELECT ${dialect.countAsInteger} as count FROM _reports WHERE status = 'open'`);
+    return Number(rows[0]?.count || 0);
 }