@khoralabs/chat 0.1.0

package/dist/persistence/turso-serverless/index.js

@@ -0,0 +1,1812 @@
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/persistence/turso-serverless/persistence/sql.ts
+import { connect } from "@tursodatabase/serverless";
+function createTursoDatabase(config) {
+  return connect({ url: config.url, authToken: config.authToken });
+}
+async function prepare(db, sql) {
+  return await Promise.resolve(db.prepare(sql));
+}
+async function run(db, sql, args = []) {
+  const stmt = await prepare(db, sql);
+  await stmt.run(args);
+}
+async function all(db, sql, args = []) {
+  const stmt = await prepare(db, sql);
+  return await stmt.all(args);
+}
+async function get(db, sql, args = []) {
+  const stmt = await prepare(db, sql);
+  return await stmt.get(args) ?? null;
+}
+async function exec(db, sql) {
+  if (db.exec !== undefined) {
+    await Promise.resolve(db.exec(sql));
+    return;
+  }
+  for (const statement of sql.split(";").map((part) => part.trim()).filter((part) => part.length > 0)) {
+    await run(db, statement);
+  }
+}
+async function transaction(db, fn) {
+  await run(db, "BEGIN IMMEDIATE");
+  try {
+    const result = await fn();
+    await run(db, "COMMIT");
+    return result;
+  } catch (error) {
+    try {
+      await run(db, "ROLLBACK");
+    } catch {}
+    throw error;
+  }
+}
+
+// src/persistence/turso-serverless/persistence/local-sqlite.ts
+import { Database } from "bun:sqlite";
+import { mkdirSync } from "node:fs";
+import path from "node:path";
+
+// src/persistence/turso-serverless/persistence/schema.ts
+var CHAT_SCHEMA = `
+CREATE TABLE IF NOT EXISTS chat_channels (
+  id TEXT PRIMARY KEY,
+  metadata TEXT,
+  created_at_ms INTEGER NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS chat_threads (
+  id TEXT PRIMARY KEY,
+  root_type TEXT NOT NULL,
+  root_id TEXT NOT NULL,
+  root_version_id TEXT,
+  default_head_id TEXT,
+  metadata TEXT,
+  created_at_ms INTEGER NOT NULL,
+  archived_at_ms INTEGER
+);
+
+CREATE TABLE IF NOT EXISTS chat_posts (
+  id TEXT PRIMARY KEY,
+  thread_id TEXT NOT NULL,
+  post_index INTEGER NOT NULL,
+  status TEXT NOT NULL DEFAULT 'complete',
+  stream_message TEXT,
+  stream_mentions TEXT,
+  stream_model TEXT,
+  stream_usage TEXT,
+  stream_author_scope_type TEXT,
+  stream_author_scope_id TEXT,
+  stream_revision INTEGER NOT NULL DEFAULT 0,
+  completed_version_id TEXT,
+  created_at_ms INTEGER NOT NULL,
+  updated_at_ms INTEGER,
+  deleted_at_ms INTEGER,
+  UNIQUE(thread_id, post_index)
+);
+
+CREATE TABLE IF NOT EXISTS chat_post_stream_events (
+  id TEXT PRIMARY KEY,
+  post_id TEXT NOT NULL,
+  thread_id TEXT NOT NULL,
+  event_type TEXT NOT NULL,
+  revision INTEGER NOT NULL,
+  message TEXT,
+  delta TEXT,
+  mentions TEXT,
+  model TEXT,
+  usage TEXT,
+  idempotency_key TEXT UNIQUE,
+  created_at_ms INTEGER NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS chat_post_versions (
+  id TEXT PRIMARY KEY,
+  post_id TEXT NOT NULL,
+  thread_id TEXT NOT NULL,
+  parent_version_id TEXT,
+  previous_post_version_id TEXT,
+  author_scope_type TEXT NOT NULL,
+  author_scope_id TEXT NOT NULL,
+  message TEXT NOT NULL,
+  mentions TEXT,
+  model TEXT,
+  usage TEXT,
+  content_hash TEXT NOT NULL,
+  lineage_hash TEXT NOT NULL,
+  signature TEXT,
+  idempotency_key TEXT UNIQUE,
+  created_at_ms INTEGER NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS chat_thread_heads (
+  id TEXT PRIMARY KEY,
+  thread_id TEXT NOT NULL,
+  name TEXT NOT NULL,
+  head_post_version_id TEXT NOT NULL,
+  created_at_ms INTEGER NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS chat_acl_events (
+  id TEXT PRIMARY KEY,
+  target_type TEXT NOT NULL,
+  target_id TEXT NOT NULL,
+  event_type TEXT NOT NULL,
+  actor_scope_type TEXT NOT NULL,
+  actor_scope_id TEXT NOT NULL,
+  subject_scope_type TEXT,
+  subject_scope_id TEXT,
+  role TEXT,
+  previous_acl_event_id TEXT,
+  content_hash TEXT NOT NULL,
+  signature TEXT,
+  created_at_ms INTEGER NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS chat_channel_members (
+  channel_id TEXT NOT NULL,
+  scope_type TEXT NOT NULL,
+  scope_id TEXT NOT NULL,
+  role TEXT NOT NULL,
+  created_at_ms INTEGER NOT NULL,
+  PRIMARY KEY (channel_id, scope_type, scope_id)
+);
+
+CREATE TABLE IF NOT EXISTS chat_thread_participants (
+  thread_id TEXT NOT NULL,
+  scope_type TEXT NOT NULL,
+  scope_id TEXT NOT NULL,
+  role TEXT NOT NULL,
+  created_at_ms INTEGER NOT NULL,
+  PRIMARY KEY (thread_id, scope_type, scope_id)
+);
+
+CREATE INDEX IF NOT EXISTS idx_chat_threads_root ON chat_threads(root_type, root_id);
+CREATE INDEX IF NOT EXISTS idx_chat_post_versions_thread ON chat_post_versions(thread_id);
+CREATE INDEX IF NOT EXISTS idx_chat_post_versions_post ON chat_post_versions(post_id);
+CREATE INDEX IF NOT EXISTS idx_chat_posts_thread ON chat_posts(thread_id, post_index);
+CREATE INDEX IF NOT EXISTS idx_chat_post_stream_events_post ON chat_post_stream_events(post_id, revision);
+`;
+async function ensureChatSchema(db) {
+  await exec(db, CHAT_SCHEMA);
+  for (const statement of [
+    "ALTER TABLE chat_posts ADD COLUMN stream_model TEXT",
+    "ALTER TABLE chat_posts ADD COLUMN stream_usage TEXT",
+    "ALTER TABLE chat_post_stream_events ADD COLUMN model TEXT",
+    "ALTER TABLE chat_post_stream_events ADD COLUMN usage TEXT",
+    "ALTER TABLE chat_post_versions ADD COLUMN model TEXT",
+    "ALTER TABLE chat_post_versions ADD COLUMN usage TEXT"
+  ]) {
+    try {
+      await run(db, statement);
+    } catch (error) {
+      if (!(error instanceof Error) || !error.message.includes("duplicate column name")) {
+        throw error;
+      }
+    }
+  }
+}
+
+// src/persistence/turso-serverless/persistence/local-sqlite.ts
+class BunSqliteDatabase {
+  db;
+  constructor(db) {
+    this.db = db;
+  }
+  prepare(sql) {
+    const stmt = this.db.prepare(sql);
+    return {
+      run: async (args = []) => {
+        stmt.run(...args);
+      },
+      all: async (args = []) => stmt.all(...args),
+      get: async (args = []) => stmt.get(...args) ?? null
+    };
+  }
+  exec(sql) {
+    this.db.exec(sql);
+  }
+  close() {
+    this.db.close();
+  }
+}
+function applyMigrationsSync(db) {
+  for (const statement of [
+    "ALTER TABLE chat_posts ADD COLUMN stream_model TEXT",
+    "ALTER TABLE chat_posts ADD COLUMN stream_usage TEXT",
+    "ALTER TABLE chat_post_stream_events ADD COLUMN model TEXT",
+    "ALTER TABLE chat_post_stream_events ADD COLUMN usage TEXT",
+    "ALTER TABLE chat_post_versions ADD COLUMN model TEXT",
+    "ALTER TABLE chat_post_versions ADD COLUMN usage TEXT"
+  ]) {
+    try {
+      db.run(statement);
+    } catch (error) {
+      if (!(error instanceof Error) || !error.message.includes("duplicate column name")) {
+        throw error;
+      }
+    }
+  }
+}
+function createLocalSqliteDatabase(dbPath) {
+  const resolved = path.resolve(dbPath);
+  mkdirSync(path.dirname(resolved), { recursive: true });
+  const db = new Database(resolved, { create: true });
+  db.exec(CHAT_SCHEMA);
+  applyMigrationsSync(db);
+  return new BunSqliteDatabase(db);
+}
+function createMemorySqliteDatabase() {
+  const db = new Database(":memory:");
+  db.exec(CHAT_SCHEMA);
+  applyMigrationsSync(db);
+  return new BunSqliteDatabase(db);
+}
+function closeLocalSqliteDatabase(db) {
+  if (db instanceof BunSqliteDatabase) {
+    db.close();
+  }
+}
+// src/persistence/turso-serverless/persistence/persistence.ts
+import {
+  BaseChatPersistence,
+  buildAclEventContentHash,
+  prepareAppendPost as prepareAppendPost2,
+  prepareEditPost
+} from "@khoralabs/chat/persistence";
+
+// src/errors.ts
+class ChatError extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "ChatError";
+    this.code = code;
+  }
+}
+
+class ChatNotFoundError extends ChatError {
+  resource;
+  resourceId;
+  constructor(resource, resourceId) {
+    super("not_found", `${resource} not found: ${resourceId}`);
+    this.name = "ChatNotFoundError";
+    this.resource = resource;
+    this.resourceId = resourceId;
+  }
+}
+
+class ChatConflictError extends ChatError {
+  reason;
+  constructor(reason, message) {
+    super("conflict", message);
+    this.name = "ChatConflictError";
+    this.reason = reason;
+  }
+}
+
+class ChatValidationError extends ChatError {
+  constructor(message) {
+    super("validation", message);
+    this.name = "ChatValidationError";
+  }
+}
+
+class ChatPermissionError extends ChatError {
+  constructor(message) {
+    super("permission_denied", message);
+    this.name = "ChatPermissionError";
+  }
+}
+// src/hash.ts
+function sha256Hex(input) {
+  const hasher = new Bun.CryptoHasher("sha256");
+  hasher.update(input);
+  return hasher.digest("hex");
+}
+function stableStringify(value) {
+  if (value === undefined) {
+    return "null";
+  }
+  if (value === null || typeof value !== "object") {
+    return JSON.stringify(value);
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map((item) => stableStringify(item)).join(",")}]`;
+  }
+  const record = value;
+  const keys = Object.keys(record).sort();
+  return `{${keys.map((key) => `${JSON.stringify(key)}:${stableStringify(record[key])}`).join(",")}}`;
+}
+function canonicalPostVersionPayload(input) {
+  return stableStringify({
+    postId: input.postId,
+    versionId: input.versionId,
+    threadId: input.threadId,
+    author: input.author,
+    role: input.role,
+    parts: input.parts,
+    metadata: input.metadata ?? null,
+    mentions: input.mentions ?? null,
+    model: input.model ?? null,
+    usage: input.usage ?? null,
+    parentVersionId: input.parentVersionId ?? null,
+    previousPostVersionId: input.previousPostVersionId ?? null
+  });
+}
+function computeContentHash(payload) {
+  return sha256Hex(canonicalPostVersionPayload(payload));
+}
+function computeLineageHash(input) {
+  return sha256Hex(stableStringify({
+    previousLineageHash: input.previousLineageHash,
+    contentHash: input.contentHash,
+    postId: input.postId,
+    versionId: input.versionId
+  }));
+}
+function canonicalAclEventPayload(input) {
+  return stableStringify({
+    type: input.type,
+    targetType: input.targetType,
+    targetId: input.targetId,
+    scope: input.scope ?? null,
+    role: input.role ?? null,
+    actor: input.actor,
+    previousAclEventId: input.previousAclEventId ?? null
+  });
+}
+function computeAclEventContentHash(payload) {
+  return sha256Hex(canonicalAclEventPayload(payload));
+}
+function signedPayloadBytes(payload) {
+  return new TextEncoder().encode(payload);
+}
+function canonicalSignedPostVersionPayload(input) {
+  return stableStringify({
+    contentHash: input.contentHash,
+    lineageHash: input.lineageHash,
+    payload: JSON.parse(canonicalPostVersionPayload(input))
+  });
+}
+function canonicalSignedAclEventPayload(input) {
+  return stableStringify({
+    contentHash: input.contentHash,
+    payload: JSON.parse(canonicalAclEventPayload(input.payload))
+  });
+}
+async function maybeSignPayload(payload, signer, sign) {
+  return sign(signedPayloadBytes(payload), signer);
+}
+// src/ids.ts
+function createId() {
+  return crypto.randomUUID();
+}
+function scopeKey(scope) {
+  return `${scope.type}:${scope.id}`;
+}
+function scopeRefFromKey(key) {
+  const separatorIndex = key.indexOf(":");
+  if (separatorIndex === -1) {
+    throw new Error(`Invalid scope key: ${key}`);
+  }
+  return {
+    type: key.slice(0, separatorIndex),
+    id: key.slice(separatorIndex + 1)
+  };
+}
+// src/lineage.ts
+function walkLineageFromHead(headVersionId, versionsById) {
+  const lineage = [];
+  let currentId = headVersionId;
+  const seenPostIds = new Set;
+  while (currentId) {
+    const version = versionsById.get(currentId);
+    if (!version)
+      break;
+    if (!seenPostIds.has(version.postId)) {
+      lineage.push(version);
+      seenPostIds.add(version.postId);
+    }
+    currentId = version.previousPostVersionId;
+  }
+  return lineage.reverse();
+}
+function lineageBetween(headVersionId, ancestorVersionId, versionsById) {
+  const lineage = walkLineageFromHead(headVersionId, versionsById);
+  const startIndex = lineage.findIndex((version) => version.id === ancestorVersionId);
+  if (startIndex === -1)
+    return null;
+  return lineage.slice(startIndex);
+}
+function postFromVersion(version, index, deletedAtMs) {
+  return {
+    ...version,
+    id: version.postId,
+    status: "complete",
+    versionId: version.id,
+    previousVersionId: version.parentVersionId ?? null,
+    index,
+    updatedAtMs: version.parentVersionId ? version.createdAtMs : null,
+    deletedAtMs: deletedAtMs ?? null
+  };
+}
+// src/stream.ts
+function rebuildStreamCacheFromEvents(events) {
+  const sorted = [...events].sort((a, b) => a.revision - b.revision);
+  let message = null;
+  let mentions;
+  let model;
+  let usage;
+  let revision = 0;
+  for (const event of sorted) {
+    if (event.eventType === "stream.started") {
+      if (!event.message) {
+        throw new Error(`stream.started event ${event.id} missing message`);
+      }
+      message = event.message;
+      mentions = event.mentions;
+      model = event.model;
+      usage = event.usage;
+      revision = event.revision;
+      continue;
+    }
+    if (event.eventType === "stream.delta") {
+      if (!event.message) {
+        throw new Error(`stream.delta event ${event.id} missing message`);
+      }
+      message = event.message;
+      if (event.mentions !== undefined)
+        mentions = event.mentions;
+      if (event.model !== undefined)
+        model = event.model;
+      if (event.usage !== undefined)
+        usage = event.usage;
+      revision = event.revision;
+      continue;
+    }
+    if (event.eventType === "stream.completed" || event.eventType === "stream.aborted") {
+      revision = event.revision;
+    }
+  }
+  if (!message) {
+    throw new Error("stream events did not produce a message");
+  }
+  return { message, mentions, model, usage, revision };
+}
+function streamingPostFromCache(input) {
+  return {
+    ...input.message,
+    id: input.postId,
+    status: "streaming",
+    threadId: input.threadId,
+    author: input.author,
+    mentions: input.mentions,
+    model: input.model,
+    usage: input.usage,
+    index: input.index,
+    streamRevision: input.streamRevision,
+    createdAtMs: input.createdAtMs,
+    updatedAtMs: input.updatedAtMs ?? null,
+    deletedAtMs: input.deletedAtMs ?? null
+  };
+}
+function mergeThreadPostsForList(lineagePosts, activePosts) {
+  const byIndex = new Map;
+  for (const item of lineagePosts) {
+    byIndex.set(item.index, item.post);
+  }
+  for (const post of activePosts) {
+    if (post.status === "streaming" || post.status === "aborted") {
+      byIndex.set(post.index, post);
+    }
+  }
+  return [...byIndex.entries()].sort(([a], [b]) => a - b).map(([, post]) => post);
+}
+// src/validation.ts
+function assertThreadRoot(root) {
+  if (root.type === "channel") {
+    if (!root.channelId.trim()) {
+      throw new ChatValidationError("channel root requires channelId");
+    }
+    return;
+  }
+  if (!root.postId.trim()) {
+    throw new ChatValidationError("post root requires postId");
+  }
+}
+function assertNonEmptyString(value, label) {
+  if (!value.trim()) {
+    throw new ChatValidationError(`${label} is required`);
+  }
+}
+// src/persistence/turso-serverless/persistence/streaming.ts
+import { prepareAppendPost } from "@khoralabs/chat/persistence";
+var DEFAULT_HEAD_NAME = "default";
+function parseJson(value) {
+  if (!value)
+    return;
+  return JSON.parse(value);
+}
+function scopeFromRow(type, id) {
+  return { type, id };
+}
+function requireStreamAuthor(row) {
+  if (!row.stream_author_scope_type || !row.stream_author_scope_id) {
+    throw new ChatValidationError(`post ${row.id} is missing stream author`);
+  }
+  return scopeFromRow(row.stream_author_scope_type, row.stream_author_scope_id);
+}
+function postFromRow(row, getVersion) {
+  if (row.status === "streaming") {
+    const message = parseJson(row.stream_message);
+    if (!message || !row.stream_author_scope_type || !row.stream_author_scope_id)
+      return null;
+    return streamingPostFromCache({
+      postId: row.id,
+      threadId: row.thread_id,
+      author: scopeFromRow(row.stream_author_scope_type, row.stream_author_scope_id),
+      message,
+      mentions: parseJson(row.stream_mentions),
+      model: parseJson(row.stream_model),
+      usage: parseJson(row.stream_usage),
+      index: row.post_index,
+      streamRevision: row.stream_revision,
+      createdAtMs: row.created_at_ms,
+      updatedAtMs: row.updated_at_ms,
+      deletedAtMs: row.deleted_at_ms
+    });
+  }
+  if (row.status === "aborted") {
+    const message = parseJson(row.stream_message);
+    if (!message || !row.stream_author_scope_type || !row.stream_author_scope_id)
+      return null;
+    return {
+      ...message,
+      id: row.id,
+      status: "aborted",
+      threadId: row.thread_id,
+      author: scopeFromRow(row.stream_author_scope_type, row.stream_author_scope_id),
+      mentions: parseJson(row.stream_mentions),
+      model: parseJson(row.stream_model),
+      usage: parseJson(row.stream_usage),
+      index: row.post_index,
+      streamRevision: row.stream_revision,
+      createdAtMs: row.created_at_ms,
+      updatedAtMs: row.updated_at_ms,
+      deletedAtMs: row.deleted_at_ms
+    };
+  }
+  const versionId = row.completed_version_id;
+  if (!versionId)
+    return null;
+  const version = getVersion(versionId);
+  if (!version)
+    return null;
+  return postFromVersion(version, row.post_index, row.deleted_at_ms);
+}
+async function getPostRow(db, postId) {
+  return get(db, `SELECT id, thread_id, post_index, status, stream_message, stream_mentions, stream_model, stream_usage,
+            stream_author_scope_type, stream_author_scope_id, stream_revision,
+            completed_version_id, created_at_ms, updated_at_ms, deleted_at_ms
+     FROM chat_posts WHERE id = ?`, [postId]);
+}
+async function insertStreamEvent(db, event) {
+  await run(db, `INSERT INTO chat_post_stream_events
+     (id, post_id, thread_id, event_type, revision, message, delta, mentions, model, usage, idempotency_key, created_at_ms)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+    event.id,
+    event.postId,
+    event.threadId,
+    event.eventType,
+    event.revision,
+    event.message ? JSON.stringify(event.message) : null,
+    event.delta ? JSON.stringify(event.delta) : null,
+    event.mentions ? JSON.stringify(event.mentions) : null,
+    event.model ? JSON.stringify(event.model) : null,
+    event.usage ? JSON.stringify(event.usage) : null,
+    event.idempotencyKey ?? null,
+    event.createdAtMs
+  ]);
+}
+async function getStreamIdempotency(db, key) {
+  return get(db, `SELECT post_id, revision FROM chat_post_stream_events
+     WHERE idempotency_key = ?`, [key]);
+}
+async function listPostStreamEvents(db, postId) {
+  const rows = await all(db, `SELECT id, post_id, thread_id, event_type, revision, message, delta, mentions, model, usage, idempotency_key, created_at_ms
+     FROM chat_post_stream_events WHERE post_id = ? ORDER BY revision ASC`, [postId]);
+  return rows.map((row) => ({
+    id: row.id,
+    postId: row.post_id,
+    threadId: row.thread_id,
+    eventType: row.event_type,
+    revision: row.revision,
+    message: parseJson(row.message),
+    delta: parseJson(row.delta),
+    mentions: parseJson(row.mentions),
+    model: parseJson(row.model),
+    usage: parseJson(row.usage),
+    idempotencyKey: row.idempotency_key ?? undefined,
+    createdAtMs: row.created_at_ms
+  }));
+}
+async function startStreamedPost(db, input, getVersion) {
+  if (input.idempotencyKey) {
+    const existing = await getStreamIdempotency(db, input.idempotencyKey);
+    if (existing) {
+      const row = await getPostRow(db, existing.post_id);
+      if (!row)
+        throw new ChatNotFoundError("post", existing.post_id);
+      const post = postFromRow(row, getVersion);
+      if (post?.status !== "streaming") {
+        throw new ChatConflictError("idempotency_mismatch", "idempotency key reused");
+      }
+      return { post, revision: existing.revision };
+    }
+  }
+  return transaction(db, async () => {
+    const thread = await get(db, "SELECT id FROM chat_threads WHERE id = ?", [
+      input.threadId
+    ]);
+    if (!thread)
+      throw new ChatNotFoundError("thread", input.threadId);
+    const maxIndexRow = await get(db, "SELECT COALESCE(MAX(post_index), 0) AS max_index FROM chat_posts WHERE thread_id = ?", [input.threadId]);
+    const nextIndex = (maxIndexRow?.max_index ?? 0) + 1;
+    const postId = input.message.id || createId();
+    const createdAtMs = Date.now();
+    const message = { ...input.message, id: postId };
+    const revision = 1;
+    await run(db, `INSERT INTO chat_posts
+       (id, thread_id, post_index, status, stream_message, stream_mentions, stream_model, stream_usage,
+        stream_author_scope_type, stream_author_scope_id, stream_revision,
+        completed_version_id, created_at_ms, updated_at_ms, deleted_at_ms)
+       VALUES (?, ?, ?, 'streaming', ?, ?, ?, ?, ?, ?, ?, NULL, ?, NULL, NULL)`, [
+      postId,
+      input.threadId,
+      nextIndex,
+      JSON.stringify(message),
+      input.mentions ? JSON.stringify(input.mentions) : null,
+      input.model ? JSON.stringify(input.model) : null,
+      input.usage ? JSON.stringify(input.usage) : null,
+      input.author.type,
+      input.author.id,
+      revision,
+      createdAtMs
+    ]);
+    await insertStreamEvent(db, {
+      id: createId(),
+      postId,
+      threadId: input.threadId,
+      eventType: "stream.started",
+      revision,
+      message,
+      mentions: input.mentions,
+      model: input.model,
+      usage: input.usage,
+      idempotencyKey: input.idempotencyKey,
+      createdAtMs
+    });
+    const post = streamingPostFromCache({
+      postId,
+      threadId: input.threadId,
+      author: input.author,
+      message,
+      mentions: input.mentions,
+      model: input.model,
+      usage: input.usage,
+      index: nextIndex,
+      streamRevision: revision,
+      createdAtMs
+    });
+    return { post, revision };
+  });
+}
+async function applyPostDelta(db, input, getVersion) {
+  if (input.idempotencyKey) {
+    const existing = await getStreamIdempotency(db, input.idempotencyKey);
+    if (existing && existing.post_id === input.postId) {
+      const row = await getPostRow(db, input.postId);
+      if (!row)
+        throw new ChatNotFoundError("post", input.postId);
+      const post = postFromRow(row, getVersion);
+      if (post?.status !== "streaming") {
+        throw new ChatConflictError("idempotency_mismatch", "idempotency key reused");
+      }
+      return { post, revision: existing.revision };
+    }
+  }
+  return transaction(db, async () => {
+    const row = await getPostRow(db, input.postId);
+    if (!row)
+      throw new ChatNotFoundError("post", input.postId);
+    if (row.status !== "streaming") {
+      throw new ChatValidationError(`post ${input.postId} is not streaming`);
+    }
+    if (input.expectedRevision !== undefined && row.stream_revision !== input.expectedRevision) {
+      throw new ChatConflictError("stream_revision_conflict", `expected revision ${input.expectedRevision}, current ${row.stream_revision}`);
+    }
+    const revision = row.stream_revision + 1;
+    const updatedAtMs = Date.now();
+    const message = { ...input.message, id: input.postId };
+    const mentions = input.mentions ?? parseJson(row.stream_mentions);
+    const model = input.model ?? parseJson(row.stream_model);
+    const usage = input.usage ?? parseJson(row.stream_usage);
+    await run(db, `UPDATE chat_posts
+       SET stream_message = ?, stream_mentions = ?, stream_model = ?, stream_usage = ?, stream_revision = ?, updated_at_ms = ?
+       WHERE id = ?`, [
+      JSON.stringify(message),
+      mentions ? JSON.stringify(mentions) : null,
+      model ? JSON.stringify(model) : null,
+      usage ? JSON.stringify(usage) : null,
+      revision,
+      updatedAtMs,
+      input.postId
+    ]);
+    await insertStreamEvent(db, {
+      id: createId(),
+      postId: input.postId,
+      threadId: row.thread_id,
+      eventType: "stream.delta",
+      revision,
+      message,
+      delta: input.delta,
+      mentions,
+      model,
+      usage,
+      idempotencyKey: input.idempotencyKey,
+      createdAtMs: updatedAtMs
+    });
+    const post = streamingPostFromCache({
+      postId: input.postId,
+      threadId: row.thread_id,
+      author: requireStreamAuthor(row),
+      message,
+      mentions,
+      model,
+      usage,
+      index: row.post_index,
+      streamRevision: revision,
+      createdAtMs: row.created_at_ms,
+      updatedAtMs,
+      deletedAtMs: row.deleted_at_ms
+    });
+    return { post, revision };
+  });
+}
+async function completeStreamedPost(db, input) {
+  return transaction(db, async () => {
+    const row = await getPostRow(db, input.postId);
+    if (!row)
+      throw new ChatNotFoundError("post", input.postId);
+    if (row.status !== "streaming") {
+      throw new ChatValidationError(`post ${input.postId} is not streaming`);
+    }
+    if (input.expectedRevision !== undefined && row.stream_revision !== input.expectedRevision) {
+      throw new ChatConflictError("stream_revision_conflict", `expected revision ${input.expectedRevision}, current ${row.stream_revision}`);
+    }
+    const message = parseJson(row.stream_message);
+    if (!message)
+      throw new ChatValidationError(`post ${input.postId} has no streamed message`);
+    const model = parseJson(row.stream_model);
+    const usage = parseJson(row.stream_usage);
+    const thread = await get(db, "SELECT id, default_head_id FROM chat_threads WHERE id = ?", [row.thread_id]);
+    if (!thread)
+      throw new ChatNotFoundError("thread", row.thread_id);
+    const currentHead = thread.default_head_id ? await get(db, "SELECT * FROM chat_thread_heads WHERE id = ?", [thread.default_head_id]) : null;
+    if (input.expectedHeadPostVersionId !== undefined && (currentHead?.head_post_version_id ?? null) !== (input.expectedHeadPostVersionId ?? null)) {
+      if (!currentHead)
+        throw new ChatConflictError("head_conflict", "expected head but thread is empty");
+      return {
+        ok: false,
+        reason: "head_conflict",
+        currentHead: {
+          id: currentHead.id,
+          threadId: currentHead.thread_id,
+          name: currentHead.name,
+          headPostVersionId: currentHead.head_post_version_id,
+          createdAtMs: currentHead.created_at_ms
+        }
+      };
+    }
+    const previousVersion = currentHead ? await get(db, "SELECT * FROM chat_post_versions WHERE id = ?", [currentHead.head_post_version_id]) : null;
+    const prepared = prepareAppendPost({
+      threadId: row.thread_id,
+      author: requireStreamAuthor(row),
+      message,
+      mentions: parseJson(row.stream_mentions),
+      model,
+      usage,
+      previousPostVersionId: previousVersion?.id ?? null,
+      previousLineageHash: previousVersion?.lineage_hash ?? null
+    });
+    await run(db, `INSERT INTO chat_post_versions
+       (id, post_id, thread_id, parent_version_id, previous_post_version_id,
+        author_scope_type, author_scope_id, message, mentions, model, usage, content_hash, lineage_hash,
+        signature, idempotency_key, created_at_ms)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+      prepared.versionId,
+      prepared.postId,
+      prepared.threadId,
+      null,
+      prepared.previousPostVersionId,
+      prepared.author.type,
+      prepared.author.id,
+      JSON.stringify(prepared.message),
+      prepared.mentions ? JSON.stringify(prepared.mentions) : null,
+      prepared.model ? JSON.stringify(prepared.model) : null,
+      prepared.usage ? JSON.stringify(prepared.usage) : null,
+      prepared.contentHash,
+      prepared.lineageHash,
+      null,
+      input.idempotencyKey ?? null,
+      prepared.createdAtMs
+    ]);
+    const head = currentHead ? {
+      id: currentHead.id,
+      threadId: row.thread_id,
+      name: currentHead.name,
+      headPostVersionId: prepared.versionId,
+      createdAtMs: currentHead.created_at_ms
+    } : {
+      id: createId(),
+      threadId: row.thread_id,
+      name: DEFAULT_HEAD_NAME,
+      headPostVersionId: prepared.versionId,
+      createdAtMs: prepared.createdAtMs
+    };
+    if (currentHead) {
+      await run(db, "UPDATE chat_thread_heads SET head_post_version_id = ? WHERE id = ?", [
+        prepared.versionId,
+        head.id
+      ]);
+    } else {
+      await run(db, `INSERT INTO chat_thread_heads (id, thread_id, name, head_post_version_id, created_at_ms)
+         VALUES (?, ?, ?, ?, ?)`, [head.id, head.threadId, head.name, head.headPostVersionId, head.createdAtMs]);
+      await run(db, "UPDATE chat_threads SET default_head_id = ? WHERE id = ?", [
+        head.id,
+        row.thread_id
+      ]);
+    }
+    const completedRevision = row.stream_revision + 1;
+    const completedAtMs = Date.now();
+    await insertStreamEvent(db, {
+      id: createId(),
+      postId: input.postId,
+      threadId: row.thread_id,
+      eventType: "stream.completed",
+      revision: completedRevision,
+      message,
+      mentions: parseJson(row.stream_mentions),
+      model,
+      usage,
+      createdAtMs: completedAtMs
+    });
+    await run(db, `UPDATE chat_posts
+       SET status = 'complete', stream_message = NULL, stream_mentions = NULL,
+           stream_model = NULL, stream_usage = NULL,
+           stream_author_scope_type = NULL, stream_author_scope_id = NULL,
+           stream_revision = ?, completed_version_id = ?, updated_at_ms = ?
+       WHERE id = ?`, [completedRevision, prepared.versionId, completedAtMs, input.postId]);
+    const version = {
+      ...prepared.message,
+      id: prepared.versionId,
+      postId: prepared.postId,
+      threadId: prepared.threadId,
+      parentVersionId: null,
+      previousPostVersionId: prepared.previousPostVersionId,
+      author: prepared.author,
+      contentHash: prepared.contentHash,
+      lineageHash: prepared.lineageHash,
+      mentions: prepared.mentions,
+      model: prepared.model,
+      usage: prepared.usage,
+      createdAtMs: prepared.createdAtMs
+    };
+    return {
+      ok: true,
+      post: postFromVersion(version, row.post_index, row.deleted_at_ms),
+      head
+    };
+  });
+}
+async function abortStreamedPost(db, input, getVersion) {
+  return transaction(db, async () => {
+    const row = await getPostRow(db, input.postId);
+    if (!row)
+      throw new ChatNotFoundError("post", input.postId);
+    if (row.status !== "streaming") {
+      throw new ChatValidationError(`post ${input.postId} is not streaming`);
+    }
+    const deletedAtMs = input.deletedAtMs ?? Date.now();
+    const revision = row.stream_revision + 1;
+    await insertStreamEvent(db, {
+      id: createId(),
+      postId: input.postId,
+      threadId: row.thread_id,
+      eventType: "stream.aborted",
+      revision,
+      message: parseJson(row.stream_message),
+      mentions: parseJson(row.stream_mentions),
+      model: parseJson(row.stream_model),
+      usage: parseJson(row.stream_usage),
+      createdAtMs: deletedAtMs
+    });
+    await run(db, `UPDATE chat_posts SET status = 'aborted', stream_revision = ?, deleted_at_ms = ?, updated_at_ms = ? WHERE id = ?`, [revision, deletedAtMs, deletedAtMs, input.postId]);
+    const updated = await getPostRow(db, input.postId);
+    if (!updated)
+      throw new ChatNotFoundError("post", input.postId);
+    const post = postFromRow(updated, getVersion);
+    if (post?.status !== "aborted")
+      throw new ChatNotFoundError("post", input.postId);
+    return { post };
+  });
+}
+async function rebuildStreamedPostCache(db, postId, _getVersion) {
+  const row = await getPostRow(db, postId);
+  if (!row)
+    throw new ChatNotFoundError("post", postId);
+  if (row.status !== "streaming") {
+    throw new ChatValidationError(`post ${postId} is not streaming`);
+  }
+  const events2 = await listPostStreamEvents(db, postId);
+  const rebuilt = rebuildStreamCacheFromEvents(events2);
+  const updatedAtMs = Date.now();
+  await run(db, `UPDATE chat_posts SET stream_message = ?, stream_mentions = ?, stream_model = ?, stream_usage = ?, stream_revision = ?, updated_at_ms = ? WHERE id = ?`, [
+    JSON.stringify(rebuilt.message),
+    rebuilt.mentions ? JSON.stringify(rebuilt.mentions) : null,
+    rebuilt.model ? JSON.stringify(rebuilt.model) : null,
+    rebuilt.usage ? JSON.stringify(rebuilt.usage) : null,
+    rebuilt.revision,
+    updatedAtMs,
+    postId
+  ]);
+  return streamingPostFromCache({
+    postId,
+    threadId: row.thread_id,
+    author: requireStreamAuthor(row),
+    message: rebuilt.message,
+    mentions: rebuilt.mentions,
+    model: rebuilt.model,
+    usage: rebuilt.usage,
+    index: row.post_index,
+    streamRevision: rebuilt.revision,
+    createdAtMs: row.created_at_ms,
+    updatedAtMs,
+    deletedAtMs: row.deleted_at_ms
+  });
+}
+
+// src/persistence/turso-serverless/persistence/persistence.ts
+var DEFAULT_HEAD_NAME2 = "default";
+function parseJson2(value) {
+  if (!value)
+    return;
+  return JSON.parse(value);
+}
+function parseSignature(value) {
+  return parseJson2(value);
+}
+function requireAclSubjectScope(scope, eventId) {
+  if (!scope) {
+    throw new ChatValidationError(`ACL event ${eventId} is missing subject scope`);
+  }
+  return scope;
+}
+function requireAclRole(role, eventId) {
+  if (!role) {
+    throw new ChatValidationError(`ACL event ${eventId} is missing role`);
+  }
+  return role;
+}
+function aclEventFromRow(row) {
+  const actor = scopeFromRow2({
+    scope_type: row.actor_scope_type,
+    scope_id: row.actor_scope_id
+  });
+  const scope = row.subject_scope_type && row.subject_scope_id ? scopeFromRow2({
+    scope_type: row.subject_scope_type,
+    scope_id: row.subject_scope_id
+  }) : undefined;
+  const base = {
+    id: row.id,
+    previousAclEventId: row.previous_acl_event_id,
+    contentHash: row.content_hash,
+    signature: parseSignature(row.signature),
+    createdAtMs: row.created_at_ms,
+    actor
+  };
+  if (row.event_type === "channel.member.added") {
+    return {
+      ...base,
+      type: "channel.member.added",
+      channelId: row.target_id,
+      scope: requireAclSubjectScope(scope, row.id),
+      role: requireAclRole(row.role, row.id)
+    };
+  }
+  if (row.event_type === "channel.member.removed") {
+    return {
+      ...base,
+      type: "channel.member.removed",
+      channelId: row.target_id,
+      scope: requireAclSubjectScope(scope, row.id)
+    };
+  }
+  if (row.event_type === "thread.participant.added") {
+    return {
+      ...base,
+      type: "thread.participant.added",
+      threadId: row.target_id,
+      scope: requireAclSubjectScope(scope, row.id),
+      role: requireAclRole(row.role, row.id)
+    };
+  }
+  return {
+    ...base,
+    type: "thread.participant.removed",
+    threadId: row.target_id,
+    scope: requireAclSubjectScope(scope, row.id)
+  };
+}
+function scopeFromRow2(row) {
+  return { type: row.scope_type, id: row.scope_id };
+}
+function encodeThreadRoot(root) {
+  if (root.type === "channel") {
+    return {
+      root_type: "channel",
+      root_id: root.channelId,
+      root_version_id: null
+    };
+  }
+  return {
+    root_type: "post",
+    root_id: root.postId,
+    root_version_id: root.versionId ?? null
+  };
+}
+function decodeThreadRoot(row) {
+  if (row.root_type === "channel") {
+    return { type: "channel", channelId: row.root_id };
+  }
+  return {
+    type: "post",
+    postId: row.root_id,
+    versionId: row.root_version_id ?? undefined
+  };
+}
+function versionFromRow(row) {
+  const message = JSON.parse(row.message);
+  return {
+    ...message,
+    id: row.id,
+    postId: row.post_id,
+    threadId: row.thread_id,
+    parentVersionId: row.parent_version_id,
+    previousPostVersionId: row.previous_post_version_id,
+    author: scopeFromRow2({
+      scope_type: row.author_scope_type,
+      scope_id: row.author_scope_id
+    }),
+    contentHash: row.content_hash,
+    lineageHash: row.lineage_hash,
+    signature: parseSignature(row.signature),
+    mentions: parseJson2(row.mentions),
+    model: parseJson2(row.model),
+    usage: parseJson2(row.usage),
+    createdAtMs: row.created_at_ms
+  };
+}
+
+class TursoChatPersistence extends BaseChatPersistence {
+  db;
+  constructor(db) {
+    super();
+    this.db = db;
+  }
+  async getPostVersionInternal(id) {
+    const row = await get(this.db, "SELECT * FROM chat_post_versions WHERE id = ?", [id]);
+    return row ? versionFromRow(row) : null;
+  }
+  async createChannel(input) {
+    const channel = {
+      id: input.id ?? createId(),
+      metadata: input.metadata,
+      createdAtMs: Date.now()
+    };
+    await run(this.db, "INSERT INTO chat_channels (id, metadata, created_at_ms) VALUES (?, ?, ?)", [
+      channel.id,
+      channel.metadata ? JSON.stringify(channel.metadata) : null,
+      channel.createdAtMs
+    ]);
+    return channel;
+  }
+  async createThread(input) {
+    this.validateCreateThreadInput(input);
+    if (input.root.type === "channel") {
+      await this.requireChannel(input.root.channelId);
+    } else {
+      await this.requirePost(input.root.postId);
+    }
+    const thread = {
+      id: input.id ?? createId(),
+      root: input.root,
+      defaultHeadId: null,
+      metadata: input.metadata,
+      createdAtMs: Date.now()
+    };
+    const encoded = encodeThreadRoot(thread.root);
+    await run(this.db, `INSERT INTO chat_threads
+       (id, root_type, root_id, root_version_id, default_head_id, metadata, created_at_ms, archived_at_ms)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`, [
+      thread.id,
+      encoded.root_type,
+      encoded.root_id,
+      encoded.root_version_id,
+      null,
+      thread.metadata ? JSON.stringify(thread.metadata) : null,
+      thread.createdAtMs,
+      null
+    ]);
+    return thread;
+  }
+  async getChannel(id) {
+    const row = await get(this.db, "SELECT id, metadata, created_at_ms FROM chat_channels WHERE id = ?", [id]);
+    if (!row)
+      return null;
+    return {
+      id: row.id,
+      metadata: parseJson2(row.metadata),
+      createdAtMs: row.created_at_ms
+    };
+  }
+  async getThread(id) {
+    const row = await get(this.db, `SELECT id, root_type, root_id, root_version_id, default_head_id, metadata, created_at_ms, archived_at_ms
+       FROM chat_threads WHERE id = ?`, [id]);
+    if (!row)
+      return null;
+    return {
+      id: row.id,
+      root: decodeThreadRoot(row),
+      defaultHeadId: row.default_head_id,
+      metadata: parseJson2(row.metadata),
+      createdAtMs: row.created_at_ms,
+      archivedAtMs: row.archived_at_ms ?? undefined
+    };
+  }
+  async getPost(id) {
+    const postRow = await get(this.db, `SELECT id, thread_id, post_index, status, stream_message, stream_mentions, stream_model, stream_usage,
+              stream_author_scope_type, stream_author_scope_id, stream_revision,
+              completed_version_id, created_at_ms, updated_at_ms, deleted_at_ms
+       FROM chat_posts WHERE id = ?`, [id]);
+    if (!postRow)
+      return null;
+    const versionMap = new Map;
+    if (postRow.completed_version_id) {
+      const version = await this.getPostVersionInternal(postRow.completed_version_id);
+      if (version) {
+        versionMap.set(postRow.completed_version_id, version);
+      }
+    }
+    return postFromRow(postRow, (versionId) => versionMap.get(versionId) ?? null);
+  }
+  async getPostVersion(id) {
+    return this.getPostVersionInternal(id);
+  }
+  async getThreadHead(threadId, headId) {
+    const thread = await this.requireThread(threadId);
+    const resolvedHeadId = headId ?? thread.defaultHeadId;
+    if (!resolvedHeadId)
+      return null;
+    const row = await get(this.db, "SELECT * FROM chat_thread_heads WHERE id = ?", [resolvedHeadId]);
+    if (!row || row.thread_id !== threadId)
+      return null;
+    return {
+      id: row.id,
+      threadId: row.thread_id,
+      name: row.name,
+      headPostVersionId: row.head_post_version_id,
+      createdAtMs: row.created_at_ms
+    };
+  }
+  async getThreadTip(threadId) {
+    const head = await this.getThreadHead(threadId);
+    if (!head)
+      return null;
+    const version = await this.getPostVersion(head.headPostVersionId);
+    if (!version)
+      return null;
+    return { id: version.id, lineageHash: version.lineageHash };
+  }
+  async listThreads(input) {
+    const limit = input.limit ?? 50;
+    const start = input.cursor ? Number.parseInt(input.cursor, 10) : 0;
+    const rows = await this.listThreadRows(input);
+    const page = rows.slice(start, start + limit);
+    return {
+      items: page.map((row) => ({
+        id: row.id,
+        root: decodeThreadRoot(row),
+        defaultHeadId: row.default_head_id,
+        metadata: parseJson2(row.metadata),
+        createdAtMs: row.created_at_ms,
+        archivedAtMs: row.archived_at_ms ?? undefined
+      })),
+      nextCursor: start + limit < rows.length ? String(start + limit) : null
+    };
+  }
+  async listThreadRows(input) {
+    const participant = input.participant;
+    if (participant && input.channelId) {
+      return all(this.db, `SELECT t.*
+         FROM chat_threads t
+         INNER JOIN chat_thread_participants p ON p.thread_id = t.id
+         WHERE p.scope_type = ? AND p.scope_id = ?
+           AND t.root_type = 'channel' AND t.root_id = ?
+         ORDER BY t.created_at_ms ASC`, [participant.type, participant.id, input.channelId]);
+    }
+    if (participant && input.postId) {
+      return all(this.db, `SELECT t.*
+         FROM chat_threads t
+         INNER JOIN chat_thread_participants p ON p.thread_id = t.id
+         WHERE p.scope_type = ? AND p.scope_id = ?
+           AND t.root_type = 'post' AND t.root_id = ?
+         ORDER BY t.created_at_ms ASC`, [participant.type, participant.id, input.postId]);
+    }
+    if (participant) {
+      return all(this.db, `SELECT t.*
+         FROM chat_threads t
+         INNER JOIN chat_thread_participants p ON p.thread_id = t.id
+         WHERE p.scope_type = ? AND p.scope_id = ?
+         ORDER BY t.created_at_ms ASC`, [participant.type, participant.id]);
+    }
+    if (input.channelId) {
+      return all(this.db, `SELECT * FROM chat_threads
+         WHERE root_type = 'channel' AND root_id = ?
+         ORDER BY created_at_ms ASC`, [input.channelId]);
+    }
+    if (input.postId) {
+      return all(this.db, `SELECT * FROM chat_threads
+         WHERE root_type = 'post' AND root_id = ?
+         ORDER BY created_at_ms ASC`, [input.postId]);
+    }
+    return all(this.db, "SELECT * FROM chat_threads ORDER BY created_at_ms ASC");
+  }
+  async listPosts(input) {
+    const thread = await this.requireThread(input.threadId);
+    const head = input.headPostVersionId ? {
+      id: "inline",
+      threadId: input.threadId,
+      name: "inline",
+      headPostVersionId: input.headPostVersionId,
+      createdAtMs: 0
+    } : await this.getThreadHead(input.threadId, input.headId ?? thread.defaultHeadId ?? undefined);
+    const versionRows = await all(this.db, "SELECT * FROM chat_post_versions WHERE thread_id = ?", [input.threadId]);
+    const versionsById = new Map(versionRows.map((row) => [row.id, versionFromRow(row)]));
+    const postMetaRows = await all(this.db, "SELECT id, post_index, deleted_at_ms FROM chat_posts WHERE thread_id = ?", [
+      input.threadId
+    ]);
+    const postsById = new Map(postMetaRows.map((row) => [row.id, row]));
+    const lineagePosts = head ? walkLineageFromHead(head.headPostVersionId, versionsById).flatMap((version) => {
+      const postRow = postsById.get(version.postId);
+      if (!postRow)
+        return [];
+      return [
+        {
+          index: postRow.post_index,
+          post: postFromVersion(version, postRow.post_index, postRow.deleted_at_ms)
+        }
+      ];
+    }) : [];
+    const activeRows = await all(this.db, `SELECT id, thread_id, post_index, status, stream_message, stream_mentions, stream_model, stream_usage,
+              stream_author_scope_type, stream_author_scope_id, stream_revision,
+              completed_version_id, created_at_ms, updated_at_ms, deleted_at_ms
+       FROM chat_posts
+       WHERE thread_id = ? AND status != 'complete'
+       ORDER BY post_index ASC`, [input.threadId]);
+    const activePosts = activeRows.map((row) => postFromRow(row, (versionId) => versionsById.get(versionId) ?? null)).filter((post) => post !== null && (post.status === "streaming" || post.status === "aborted"));
+    const merged = mergeThreadPostsForList(lineagePosts, activePosts);
+    const limit = input.limit ?? 50;
+    const start = input.cursor ? Number.parseInt(input.cursor, 10) : 0;
+    const items = merged.slice(start, start + limit);
+    return {
+      items,
+      nextCursor: start + limit < merged.length ? String(start + limit) : null
+    };
+  }
+  async appendPost(input) {
+    if (input.idempotencyKey) {
+      const existing = await get(this.db, `SELECT pv.*, cp.post_index, cp.deleted_at_ms
+         FROM chat_post_versions pv
+         JOIN chat_posts cp ON cp.id = pv.post_id
+         WHERE pv.idempotency_key = ?`, [input.idempotencyKey]);
+      if (existing) {
+        const version = versionFromRow(existing);
+        const head = await this.getThreadHead(input.threadId);
+        if (!head) {
+          throw new ChatNotFoundError("thread_head", input.threadId);
+        }
+        return {
+          ok: true,
+          post: postFromVersion(version, existing.post_index, existing.deleted_at_ms),
+          head
+        };
+      }
+    }
+    return transaction(this.db, async () => {
+      const thread = await get(this.db, "SELECT * FROM chat_threads WHERE id = ?", [input.threadId]);
+      if (!thread)
+        throw new ChatNotFoundError("thread", input.threadId);
+      const currentHead = thread.default_head_id ? await get(this.db, "SELECT * FROM chat_thread_heads WHERE id = ?", [thread.default_head_id]) : null;
+      if (input.expectedHeadPostVersionId !== undefined && (currentHead?.head_post_version_id ?? null) !== (input.expectedHeadPostVersionId ?? null)) {
+        if (!currentHead) {
+          throw new ChatConflictError("head_conflict", "expected head but thread is empty");
+        }
+        return {
+          ok: false,
+          reason: "head_conflict",
+          currentHead: {
+            id: currentHead.id,
+            threadId: currentHead.thread_id,
+            name: currentHead.name,
+            headPostVersionId: currentHead.head_post_version_id,
+            createdAtMs: currentHead.created_at_ms
+          }
+        };
+      }
+      const previousVersionRow = currentHead ? await get(this.db, "SELECT * FROM chat_post_versions WHERE id = ?", [currentHead.head_post_version_id]) : null;
+      const previousVersion = previousVersionRow ? versionFromRow(previousVersionRow) : null;
+      const prepared = prepareAppendPost2({
+        ...input,
+        previousPostVersionId: previousVersion?.id ?? null,
+        previousLineageHash: previousVersion?.lineageHash ?? null
+      });
+      const maxIndexRow = await get(this.db, "SELECT COALESCE(MAX(post_index), 0) AS max_index FROM chat_posts WHERE thread_id = ?", [input.threadId]);
+      const nextIndex = (maxIndexRow?.max_index ?? 0) + 1;
+      await run(this.db, `INSERT INTO chat_posts
+         (id, thread_id, post_index, status, stream_revision, completed_version_id,
+          created_at_ms, updated_at_ms, deleted_at_ms)
+         VALUES (?, ?, ?, 'complete', 0, ?, ?, NULL, NULL)`, [prepared.postId, prepared.threadId, nextIndex, prepared.versionId, prepared.createdAtMs]);
+      await run(this.db, `INSERT INTO chat_post_versions
+         (id, post_id, thread_id, parent_version_id, previous_post_version_id,
+          author_scope_type, author_scope_id, message, mentions, model, usage, content_hash, lineage_hash,
+          signature, idempotency_key, created_at_ms)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+        prepared.versionId,
+        prepared.postId,
+        prepared.threadId,
+        null,
+        prepared.previousPostVersionId,
+        prepared.author.type,
+        prepared.author.id,
+        JSON.stringify(prepared.message),
+        prepared.mentions ? JSON.stringify(prepared.mentions) : null,
+        prepared.model ? JSON.stringify(prepared.model) : null,
+        prepared.usage ? JSON.stringify(prepared.usage) : null,
+        prepared.contentHash,
+        prepared.lineageHash,
+        input.signature ? JSON.stringify(input.signature) : null,
+        input.idempotencyKey ?? null,
+        prepared.createdAtMs
+      ]);
+      const head = currentHead ? {
+        id: currentHead.id,
+        threadId: input.threadId,
+        name: currentHead.name,
+        headPostVersionId: prepared.versionId,
+        createdAtMs: currentHead.created_at_ms
+      } : {
+        id: createId(),
+        threadId: input.threadId,
+        name: DEFAULT_HEAD_NAME2,
+        headPostVersionId: prepared.versionId,
+        createdAtMs: prepared.createdAtMs
+      };
+      if (currentHead) {
+        await run(this.db, "UPDATE chat_thread_heads SET head_post_version_id = ? WHERE id = ?", [
+          prepared.versionId,
+          head.id
+        ]);
+      } else {
+        await run(this.db, `INSERT INTO chat_thread_heads
+           (id, thread_id, name, head_post_version_id, created_at_ms)
+           VALUES (?, ?, ?, ?, ?)`, [head.id, head.threadId, head.name, head.headPostVersionId, head.createdAtMs]);
+        await run(this.db, "UPDATE chat_threads SET default_head_id = ? WHERE id = ?", [
+          head.id,
+          input.threadId
+        ]);
+      }
+      const version = {
+        ...prepared.message,
+        id: prepared.versionId,
+        postId: prepared.postId,
+        threadId: prepared.threadId,
+        parentVersionId: null,
+        previousPostVersionId: prepared.previousPostVersionId,
+        author: prepared.author,
+        contentHash: prepared.contentHash,
+        lineageHash: prepared.lineageHash,
+        mentions: prepared.mentions,
+        createdAtMs: prepared.createdAtMs
+      };
+      return {
+        ok: true,
+        post: postFromVersion(version, nextIndex),
+        head
+      };
+    });
+  }
+  async editPost(input) {
+    if (input.idempotencyKey) {
+      const existing = await get(this.db, `SELECT pv.*, cp.post_index, cp.deleted_at_ms
+         FROM chat_post_versions pv
+         JOIN chat_posts cp ON cp.id = pv.post_id
+         WHERE pv.idempotency_key = ?`, [input.idempotencyKey]);
+      if (existing) {
+        const version = versionFromRow(existing);
+        const head = await this.getThreadHead(version.threadId);
+        if (!head) {
+          throw new ChatNotFoundError("thread_head", version.threadId);
+        }
+        return {
+          ok: true,
+          post: postFromVersion(version, existing.post_index, existing.deleted_at_ms),
+          head
+        };
+      }
+    }
+    return transaction(this.db, async () => {
+      const parentRow = await get(this.db, "SELECT * FROM chat_post_versions WHERE id = ?", [input.parentVersionId]);
+      if (!parentRow) {
+        throw new ChatNotFoundError("post_version", input.parentVersionId);
+      }
+      const parentVersion = versionFromRow(parentRow);
+      const thread = await get(this.db, "SELECT * FROM chat_threads WHERE id = ?", [parentVersion.threadId]);
+      if (!thread)
+        throw new ChatNotFoundError("thread", parentVersion.threadId);
+      const currentHead = thread.default_head_id ? await get(this.db, "SELECT * FROM chat_thread_heads WHERE id = ?", [thread.default_head_id]) : null;
+      if (input.expectedHeadPostVersionId !== undefined && (currentHead?.head_post_version_id ?? null) !== (input.expectedHeadPostVersionId ?? null)) {
+        if (!currentHead) {
+          throw new ChatConflictError("head_conflict", "expected head but thread is empty");
+        }
+        return {
+          ok: false,
+          reason: "head_conflict",
+          currentHead: {
+            id: currentHead.id,
+            threadId: currentHead.thread_id,
+            name: currentHead.name,
+            headPostVersionId: currentHead.head_post_version_id,
+            createdAtMs: currentHead.created_at_ms
+          }
+        };
+      }
+      const previousInChainRow = parentVersion.previousPostVersionId ? await get(this.db, "SELECT * FROM chat_post_versions WHERE id = ?", [parentVersion.previousPostVersionId]) : null;
+      const previousInChain = previousInChainRow ? versionFromRow(previousInChainRow) : null;
+      const prepared = prepareEditPost({
+        ...input,
+        threadId: parentVersion.threadId,
+        previousPostVersionId: parentVersion.previousPostVersionId ?? null,
+        previousLineageHash: previousInChain?.lineageHash ?? null
+      });
+      const postRow = await get(this.db, "SELECT post_index, deleted_at_ms FROM chat_posts WHERE id = ?", [input.postId]);
+      if (!postRow)
+        throw new ChatNotFoundError("post", input.postId);
+      await run(this.db, `INSERT INTO chat_post_versions
+         (id, post_id, thread_id, parent_version_id, previous_post_version_id,
+          author_scope_type, author_scope_id, message, mentions, model, usage, content_hash, lineage_hash,
+          signature, idempotency_key, created_at_ms)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+        prepared.versionId,
+        prepared.postId,
+        prepared.threadId,
+        prepared.parentVersionId,
+        prepared.previousPostVersionId,
+        prepared.author.type,
+        prepared.author.id,
+        JSON.stringify(prepared.message),
+        prepared.mentions ? JSON.stringify(prepared.mentions) : null,
+        prepared.model ? JSON.stringify(prepared.model) : null,
+        prepared.usage ? JSON.stringify(prepared.usage) : null,
+        prepared.contentHash,
+        prepared.lineageHash,
+        null,
+        input.idempotencyKey ?? null,
+        prepared.createdAtMs
+      ]);
+      let head;
+      if (currentHead?.head_post_version_id === input.parentVersionId) {
+        await run(this.db, "UPDATE chat_thread_heads SET head_post_version_id = ? WHERE id = ?", [
+          prepared.versionId,
+          currentHead.id
+        ]);
+        head = {
+          id: currentHead.id,
+          threadId: currentHead.thread_id,
+          name: currentHead.name,
+          headPostVersionId: prepared.versionId,
+          createdAtMs: currentHead.created_at_ms
+        };
+      } else if (currentHead) {
+        head = {
+          id: currentHead.id,
+          threadId: currentHead.thread_id,
+          name: currentHead.name,
+          headPostVersionId: currentHead.head_post_version_id,
+          createdAtMs: currentHead.created_at_ms
+        };
+      } else {
+        head = {
+          id: createId(),
+          threadId: parentVersion.threadId,
+          name: DEFAULT_HEAD_NAME2,
+          headPostVersionId: prepared.versionId,
+          createdAtMs: prepared.createdAtMs
+        };
+        await run(this.db, `INSERT INTO chat_thread_heads
+           (id, thread_id, name, head_post_version_id, created_at_ms)
+           VALUES (?, ?, ?, ?, ?)`, [head.id, head.threadId, head.name, head.headPostVersionId, head.createdAtMs]);
+        await run(this.db, "UPDATE chat_threads SET default_head_id = ? WHERE id = ?", [
+          head.id,
+          parentVersion.threadId
+        ]);
+      }
+      const version = {
+        ...prepared.message,
+        id: prepared.versionId,
+        postId: prepared.postId,
+        threadId: prepared.threadId,
+        parentVersionId: prepared.parentVersionId,
+        previousPostVersionId: prepared.previousPostVersionId,
+        author: prepared.author,
+        contentHash: prepared.contentHash,
+        lineageHash: prepared.lineageHash,
+        mentions: prepared.mentions,
+        createdAtMs: prepared.createdAtMs
+      };
+      return {
+        ok: true,
+        post: postFromVersion(version, postRow.post_index, postRow.deleted_at_ms),
+        head
+      };
+    });
+  }
+  async deletePost(input) {
+    const post = await this.requirePost(input.postId);
+    const deletedAtMs = input.deletedAtMs ?? Date.now();
+    await run(this.db, "UPDATE chat_posts SET deleted_at_ms = ? WHERE id = ?", [
+      deletedAtMs,
+      input.postId
+    ]);
+    return { ...post, deletedAtMs };
+  }
+  async addChannelMember(input) {
+    await this.requireChannel(input.channelId);
+    const createdAtMs = Date.now();
+    await run(this.db, `INSERT OR REPLACE INTO chat_channel_members
+       (channel_id, scope_type, scope_id, role, created_at_ms)
+       VALUES (?, ?, ?, ?, ?)`, [input.channelId, input.scope.type, input.scope.id, input.role, createdAtMs]);
+    const previousAclEventId = await this.latestAclEventId();
+    const event = {
+      id: createId(),
+      type: "channel.member.added",
+      channelId: input.channelId,
+      scope: input.scope,
+      role: input.role,
+      actor: input.actor,
+      previousAclEventId,
+      contentHash: buildAclEventContentHash({
+        type: "channel.member.added",
+        targetType: "channel",
+        targetId: input.channelId,
+        scope: input.scope,
+        role: input.role,
+        actor: input.actor,
+        previousAclEventId
+      }),
+      signature: input.signature,
+      createdAtMs
+    };
+    await this.insertAclEvent(event, input.scope, input.role);
+    return event;
+  }
+  async removeChannelMember(input) {
+    await this.requireChannel(input.channelId);
+    await run(this.db, "DELETE FROM chat_channel_members WHERE channel_id = ? AND scope_type = ? AND scope_id = ?", [input.channelId, input.scope.type, input.scope.id]);
+    const previousAclEventId = await this.latestAclEventId();
+    const createdAtMs = Date.now();
+    const event = {
+      id: createId(),
+      type: "channel.member.removed",
+      channelId: input.channelId,
+      scope: input.scope,
+      actor: input.actor,
+      previousAclEventId,
+      contentHash: buildAclEventContentHash({
+        type: "channel.member.removed",
+        targetType: "channel",
+        targetId: input.channelId,
+        scope: input.scope,
+        actor: input.actor,
+        previousAclEventId
+      }),
+      signature: input.signature,
+      createdAtMs
+    };
+    await this.insertAclEvent(event, input.scope);
+    return event;
+  }
+  async addThreadParticipant(input) {
+    await this.requireThread(input.threadId);
+    const createdAtMs = Date.now();
+    await run(this.db, `INSERT OR REPLACE INTO chat_thread_participants
+       (thread_id, scope_type, scope_id, role, created_at_ms)
+       VALUES (?, ?, ?, ?, ?)`, [input.threadId, input.scope.type, input.scope.id, input.role, createdAtMs]);
+    const previousAclEventId = await this.latestAclEventId();
+    const event = {
+      id: createId(),
+      type: "thread.participant.added",
+      threadId: input.threadId,
+      scope: input.scope,
+      role: input.role,
+      actor: input.actor,
+      previousAclEventId,
+      contentHash: buildAclEventContentHash({
+        type: "thread.participant.added",
+        targetType: "thread",
+        targetId: input.threadId,
+        scope: input.scope,
+        role: input.role,
+        actor: input.actor,
+        previousAclEventId
+      }),
+      signature: input.signature,
+      createdAtMs
+    };
+    await this.insertAclEvent(event, input.scope, input.role, input.threadId);
+    return event;
+  }
+  async removeThreadParticipant(input) {
+    await this.requireThread(input.threadId);
+    await run(this.db, "DELETE FROM chat_thread_participants WHERE thread_id = ? AND scope_type = ? AND scope_id = ?", [input.threadId, input.scope.type, input.scope.id]);
+    const previousAclEventId = await this.latestAclEventId();
+    const createdAtMs = Date.now();
+    const event = {
+      id: createId(),
+      type: "thread.participant.removed",
+      threadId: input.threadId,
+      scope: input.scope,
+      actor: input.actor,
+      previousAclEventId,
+      contentHash: buildAclEventContentHash({
+        type: "thread.participant.removed",
+        targetType: "thread",
+        targetId: input.threadId,
+        scope: input.scope,
+        actor: input.actor,
+        previousAclEventId
+      }),
+      signature: input.signature,
+      createdAtMs
+    };
+    await this.insertAclEvent(event, input.scope, undefined, input.threadId);
+    return event;
+  }
+  async createThreadHead(input) {
+    await this.requireThread(input.threadId);
+    const version = await this.getPostVersion(input.headPostVersionId);
+    if (!version) {
+      throw new ChatNotFoundError("post_version", input.headPostVersionId);
+    }
+    const head = {
+      id: createId(),
+      threadId: input.threadId,
+      name: input.name,
+      headPostVersionId: input.headPostVersionId,
+      createdAtMs: Date.now()
+    };
+    await run(this.db, `INSERT INTO chat_thread_heads
+       (id, thread_id, name, head_post_version_id, created_at_ms)
+       VALUES (?, ?, ?, ?, ?)`, [head.id, head.threadId, head.name, head.headPostVersionId, head.createdAtMs]);
+    return head;
+  }
+  async listChannelMembers(channelId) {
+    const rows = await all(this.db, "SELECT scope_type, scope_id FROM chat_channel_members WHERE channel_id = ?", [channelId]);
+    return rows.map(scopeFromRow2);
+  }
+  async listThreadParticipants(threadId) {
+    const rows = await all(this.db, "SELECT scope_type, scope_id FROM chat_thread_participants WHERE thread_id = ?", [threadId]);
+    return rows.map(scopeFromRow2);
+  }
+  async listAclEvents(input) {
+    let query = "SELECT * FROM chat_acl_events";
+    const params = [];
+    if (input.channelId) {
+      query += " WHERE target_type = 'channel' AND target_id = ?";
+      params.push(input.channelId);
+    } else if (input.threadId) {
+      query += " WHERE target_type = 'thread' AND target_id = ?";
+      params.push(input.threadId);
+    }
+    query += " ORDER BY created_at_ms ASC";
+    const rows = await all(this.db, query, params);
+    const events2 = rows.map(aclEventFromRow);
+    return events2.slice(0, input.limit ?? events2.length);
+  }
+  async latestAclEventId() {
+    const row = await get(this.db, "SELECT id FROM chat_acl_events ORDER BY created_at_ms DESC LIMIT 1");
+    return row?.id ?? null;
+  }
+  async insertAclEvent(event, subject, role, threadTargetId) {
+    const targetType = event.type.startsWith("channel.") ? "channel" : "thread";
+    const targetId = targetType === "channel" ? event.channelId : threadTargetId ?? event.threadId;
+    await run(this.db, `INSERT INTO chat_acl_events
+       (id, target_type, target_id, event_type, actor_scope_type, actor_scope_id,
+        subject_scope_type, subject_scope_id, role, previous_acl_event_id, content_hash, signature, created_at_ms)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+      event.id,
+      targetType,
+      targetId,
+      event.type,
+      event.actor.type,
+      event.actor.id,
+      subject?.type ?? null,
+      subject?.id ?? null,
+      role ?? ("role" in event ? event.role : null),
+      event.previousAclEventId ?? null,
+      event.contentHash,
+      event.signature ? JSON.stringify(event.signature) : null,
+      event.createdAtMs
+    ]);
+  }
+  async listPostStreamEvents(postId) {
+    return listPostStreamEvents(this.db, postId);
+  }
+  async startStreamedPost(input) {
+    return startStreamedPost(this.db, input, () => null);
+  }
+  async applyPostDelta(input) {
+    return applyPostDelta(this.db, input, () => null);
+  }
+  async completeStreamedPost(input) {
+    return completeStreamedPost(this.db, input);
+  }
+  async abortStreamedPost(input) {
+    return abortStreamedPost(this.db, input, () => null);
+  }
+  async rebuildStreamedPostCache(postId) {
+    return rebuildStreamedPostCache(this.db, postId, () => null);
+  }
+  async setPostVersionSignature(versionId, signature) {
+    const existing = await get(this.db, "SELECT id FROM chat_post_versions WHERE id = ?", [versionId]);
+    if (!existing) {
+      throw new ChatNotFoundError("post_version", versionId);
+    }
+    await run(this.db, "UPDATE chat_post_versions SET signature = ? WHERE id = ?", [
+      JSON.stringify(signature),
+      versionId
+    ]);
+  }
+}
+function createTursoChatPersistence(db) {
+  return new TursoChatPersistence(db);
+}
+// src/persistence/turso-serverless/index.ts
+async function createTestChatDatabase() {
+  const db = createMemorySqliteDatabase();
+  await ensureChatSchema(db);
+  return { db, persistence: createTursoChatPersistence(db) };
+}
+export {
+  ensureChatSchema,
+  createTursoDatabase,
+  createTursoChatPersistence,
+  createTestChatDatabase,
+  createMemorySqliteDatabase,
+  createLocalSqliteDatabase,
+  closeLocalSqliteDatabase,
+  TursoChatPersistence
+};