@khoralabs/chat 0.1.0

package/dist/persistence/sqlite/index.js

@@ -0,0 +1,1544 @@
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/persistence/sqlite/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/sqlite/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);
+}
+function getPostRow(db, postId) {
+  return db.prepare(`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 = ?`).get(postId);
+}
+function insertStreamEvent(db, event) {
+  db.prepare(`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 (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(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);
+}
+function getStreamIdempotency(db, key) {
+  return db.prepare(`SELECT post_id, revision FROM chat_post_stream_events
+       WHERE idempotency_key = ?`).get(key);
+}
+function sqliteListPostStreamEvents(db, postId) {
+  const rows = db.prepare(`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`).all(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
+  }));
+}
+function sqliteStartStreamedPost(db, input, getVersion) {
+  if (input.idempotencyKey) {
+    const existing = getStreamIdempotency(db, input.idempotencyKey);
+    if (existing) {
+      const row = 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 db.transaction(() => {
+    const thread = db.prepare("SELECT id FROM chat_threads WHERE id = ?").get(input.threadId);
+    if (!thread)
+      throw new ChatNotFoundError("thread", input.threadId);
+    const maxIndexRow = db.prepare("SELECT COALESCE(MAX(post_index), 0) AS max_index FROM chat_posts WHERE thread_id = ?").get(input.threadId);
+    const nextIndex = maxIndexRow.max_index + 1;
+    const postId = input.message.id || createId();
+    const createdAtMs = Date.now();
+    const message = { ...input.message, id: postId };
+    const revision = 1;
+    db.prepare(`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)`).run(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);
+    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 };
+  })();
+}
+function sqliteApplyPostDelta(db, input, getVersion) {
+  if (input.idempotencyKey) {
+    const existing = getStreamIdempotency(db, input.idempotencyKey);
+    if (existing && existing.post_id === input.postId) {
+      const row = 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 db.transaction(() => {
+    const row = 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);
+    db.prepare(`UPDATE chat_posts
+       SET stream_message = ?, stream_mentions = ?, stream_model = ?, stream_usage = ?, stream_revision = ?, updated_at_ms = ?
+       WHERE id = ?`).run(JSON.stringify(message), mentions ? JSON.stringify(mentions) : null, model ? JSON.stringify(model) : null, usage ? JSON.stringify(usage) : null, revision, updatedAtMs, input.postId);
+    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 };
+  })();
+}
+function sqliteCompleteStreamedPost(db, input) {
+  return db.transaction(() => {
+    const row = 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 = db.prepare("SELECT id, default_head_id FROM chat_threads WHERE id = ?").get(row.thread_id);
+    if (!thread)
+      throw new ChatNotFoundError("thread", row.thread_id);
+    const currentHead = thread.default_head_id ? db.prepare("SELECT * FROM chat_thread_heads WHERE id = ?").get(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 ? db.prepare("SELECT * FROM chat_post_versions WHERE id = ?").get(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
+    });
+    db.prepare(`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 (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(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) {
+      db.prepare("UPDATE chat_thread_heads SET head_post_version_id = ? WHERE id = ?").run(prepared.versionId, head.id);
+    } else {
+      db.prepare(`INSERT INTO chat_thread_heads (id, thread_id, name, head_post_version_id, created_at_ms)
+         VALUES (?, ?, ?, ?, ?)`).run(head.id, head.threadId, head.name, head.headPostVersionId, head.createdAtMs);
+      db.prepare("UPDATE chat_threads SET default_head_id = ? WHERE id = ?").run(head.id, row.thread_id);
+    }
+    const completedRevision = row.stream_revision + 1;
+    const completedAtMs = Date.now();
+    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
+    });
+    db.prepare(`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 = ?`).run(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
+    };
+  })();
+}
+function sqliteAbortStreamedPost(db, input, getVersion) {
+  return db.transaction(() => {
+    const row = 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;
+    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
+    });
+    db.prepare(`UPDATE chat_posts SET status = 'aborted', stream_revision = ?, deleted_at_ms = ?, updated_at_ms = ? WHERE id = ?`).run(revision, deletedAtMs, deletedAtMs, input.postId);
+    const updated = 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 };
+  })();
+}
+function sqliteRebuildStreamedPostCache(db, postId, _getVersion) {
+  const row = getPostRow(db, postId);
+  if (!row)
+    throw new ChatNotFoundError("post", postId);
+  if (row.status !== "streaming") {
+    throw new ChatValidationError(`post ${postId} is not streaming`);
+  }
+  const events2 = sqliteListPostStreamEvents(db, postId);
+  const rebuilt = rebuildStreamCacheFromEvents(events2);
+  const updatedAtMs = Date.now();
+  db.prepare(`UPDATE chat_posts SET stream_message = ?, stream_mentions = ?, stream_model = ?, stream_usage = ?, stream_revision = ?, updated_at_ms = ? WHERE id = ?`).run(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/sqlite/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 SqliteChatPersistence extends BaseChatPersistence {
+  db;
+  constructor(db) {
+    super();
+    this.db = db;
+  }
+  getPostVersionSync(id) {
+    const row = this.db.prepare("SELECT * FROM chat_post_versions WHERE id = ?").get(id);
+    return row ? versionFromRow(row) : null;
+  }
+  async createChannel(input) {
+    const channel = {
+      id: input.id ?? createId(),
+      metadata: input.metadata,
+      createdAtMs: Date.now()
+    };
+    this.db.prepare("INSERT INTO chat_channels (id, metadata, created_at_ms) VALUES (?, ?, ?)").run(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);
+    this.db.prepare(`INSERT INTO chat_threads
+         (id, root_type, root_id, root_version_id, default_head_id, metadata, created_at_ms, archived_at_ms)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(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 = this.db.prepare("SELECT id, metadata, created_at_ms FROM chat_channels WHERE id = ?").get(id);
+    if (!row)
+      return null;
+    return {
+      id: row.id,
+      metadata: parseJson2(row.metadata),
+      createdAtMs: row.created_at_ms
+    };
+  }
+  async getThread(id) {
+    const row = this.db.prepare(`SELECT id, root_type, root_id, root_version_id, default_head_id, metadata, created_at_ms, archived_at_ms
+         FROM chat_threads WHERE id = ?`).get(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 = this.db.prepare(`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 = ?`).get(id);
+    if (!postRow)
+      return null;
+    return postFromRow(postRow, (versionId) => this.getPostVersionSync(versionId));
+  }
+  async getPostVersion(id) {
+    const row = this.db.prepare("SELECT * FROM chat_post_versions WHERE id = ?").get(id);
+    return row ? versionFromRow(row) : null;
+  }
+  async getThreadHead(threadId, headId) {
+    const thread = await this.requireThread(threadId);
+    const resolvedHeadId = headId ?? thread.defaultHeadId;
+    if (!resolvedHeadId)
+      return null;
+    const row = this.db.prepare("SELECT * FROM chat_thread_heads WHERE id = ?").get(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 = 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
+    };
+  }
+  listThreadRows(input) {
+    const participant = input.participant;
+    if (participant && input.channelId) {
+      return this.db.prepare(`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`).all(participant.type, participant.id, input.channelId);
+    }
+    if (participant && input.postId) {
+      return this.db.prepare(`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`).all(participant.type, participant.id, input.postId);
+    }
+    if (participant) {
+      return this.db.prepare(`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`).all(participant.type, participant.id);
+    }
+    if (input.channelId) {
+      return this.db.prepare(`SELECT * FROM chat_threads
+           WHERE root_type = 'channel' AND root_id = ?
+           ORDER BY created_at_ms ASC`).all(input.channelId);
+    }
+    if (input.postId) {
+      return this.db.prepare(`SELECT * FROM chat_threads
+           WHERE root_type = 'post' AND root_id = ?
+           ORDER BY created_at_ms ASC`).all(input.postId);
+    }
+    return this.db.prepare("SELECT * FROM chat_threads ORDER BY created_at_ms ASC").all();
+  }
+  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 = this.db.prepare("SELECT * FROM chat_post_versions WHERE thread_id = ?").all(input.threadId);
+    const versionsById = new Map(versionRows.map((row) => [row.id, versionFromRow(row)]));
+    const lineagePosts = head ? walkLineageFromHead(head.headPostVersionId, versionsById).flatMap((version) => {
+      const postRow = this.db.prepare("SELECT post_index, deleted_at_ms FROM chat_posts WHERE id = ?").get(version.postId);
+      if (!postRow)
+        return [];
+      return [
+        {
+          index: postRow.post_index,
+          post: postFromVersion(version, postRow.post_index, postRow.deleted_at_ms)
+        }
+      ];
+    }) : [];
+    const activeRows = this.db.prepare(`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`).all(input.threadId);
+    const activePosts = activeRows.map((row) => postFromRow(row, (versionId) => this.getPostVersionSync(versionId))).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 = this.db.prepare(`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 = ?`).get(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 this.db.transaction(() => {
+      const thread = this.db.prepare("SELECT * FROM chat_threads WHERE id = ?").get(input.threadId);
+      if (!thread)
+        throw new ChatNotFoundError("thread", input.threadId);
+      const currentHead = thread.default_head_id ? this.db.prepare("SELECT * FROM chat_thread_heads WHERE id = ?").get(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 ? versionFromRow(this.db.prepare("SELECT * FROM chat_post_versions WHERE id = ?").get(currentHead.head_post_version_id)) : null;
+      const prepared = prepareAppendPost2({
+        ...input,
+        previousPostVersionId: previousVersion?.id ?? null,
+        previousLineageHash: previousVersion?.lineageHash ?? null
+      });
+      const maxIndexRow = this.db.prepare("SELECT COALESCE(MAX(post_index), 0) AS max_index FROM chat_posts WHERE thread_id = ?").get(input.threadId);
+      const nextIndex = maxIndexRow.max_index + 1;
+      this.db.prepare(`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)`).run(prepared.postId, prepared.threadId, nextIndex, prepared.versionId, prepared.createdAtMs);
+      this.db.prepare(`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 (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(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) {
+        this.db.prepare("UPDATE chat_thread_heads SET head_post_version_id = ? WHERE id = ?").run(prepared.versionId, head.id);
+      } else {
+        this.db.prepare(`INSERT INTO chat_thread_heads
+             (id, thread_id, name, head_post_version_id, created_at_ms)
+             VALUES (?, ?, ?, ?, ?)`).run(head.id, head.threadId, head.name, head.headPostVersionId, head.createdAtMs);
+        this.db.prepare("UPDATE chat_threads SET default_head_id = ? WHERE id = ?").run(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 = this.db.prepare(`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 = ?`).get(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 this.db.transaction(() => {
+      const parentRow = this.db.prepare("SELECT * FROM chat_post_versions WHERE id = ?").get(input.parentVersionId);
+      if (!parentRow) {
+        throw new ChatNotFoundError("post_version", input.parentVersionId);
+      }
+      const parentVersion = versionFromRow(parentRow);
+      const thread = this.db.prepare("SELECT * FROM chat_threads WHERE id = ?").get(parentVersion.threadId);
+      if (!thread)
+        throw new ChatNotFoundError("thread", parentVersion.threadId);
+      const currentHead = thread.default_head_id ? this.db.prepare("SELECT * FROM chat_thread_heads WHERE id = ?").get(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 previousInChain = parentVersion.previousPostVersionId ? versionFromRow(this.db.prepare("SELECT * FROM chat_post_versions WHERE id = ?").get(parentVersion.previousPostVersionId)) : null;
+      const prepared = prepareEditPost({
+        ...input,
+        threadId: parentVersion.threadId,
+        previousPostVersionId: parentVersion.previousPostVersionId ?? null,
+        previousLineageHash: previousInChain?.lineageHash ?? null
+      });
+      const postRow = this.db.prepare("SELECT post_index, deleted_at_ms FROM chat_posts WHERE id = ?").get(input.postId);
+      if (!postRow)
+        throw new ChatNotFoundError("post", input.postId);
+      this.db.prepare(`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 (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(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) {
+        this.db.prepare("UPDATE chat_thread_heads SET head_post_version_id = ? WHERE id = ?").run(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
+        };
+        this.db.prepare(`INSERT INTO chat_thread_heads
+             (id, thread_id, name, head_post_version_id, created_at_ms)
+             VALUES (?, ?, ?, ?, ?)`).run(head.id, head.threadId, head.name, head.headPostVersionId, head.createdAtMs);
+        this.db.prepare("UPDATE chat_threads SET default_head_id = ? WHERE id = ?").run(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();
+    this.db.prepare("UPDATE chat_posts SET deleted_at_ms = ? WHERE id = ?").run(deletedAtMs, input.postId);
+    return { ...post, deletedAtMs };
+  }
+  async addChannelMember(input) {
+    await this.requireChannel(input.channelId);
+    const createdAtMs = Date.now();
+    this.db.prepare(`INSERT OR REPLACE INTO chat_channel_members
+         (channel_id, scope_type, scope_id, role, created_at_ms)
+         VALUES (?, ?, ?, ?, ?)`).run(input.channelId, input.scope.type, input.scope.id, input.role, createdAtMs);
+    const previousAclEventId = 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
+    };
+    this.insertAclEvent(event, input.scope, input.role);
+    return event;
+  }
+  async removeChannelMember(input) {
+    await this.requireChannel(input.channelId);
+    this.db.prepare("DELETE FROM chat_channel_members WHERE channel_id = ? AND scope_type = ? AND scope_id = ?").run(input.channelId, input.scope.type, input.scope.id);
+    const previousAclEventId = 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
+    };
+    this.insertAclEvent(event, input.scope);
+    return event;
+  }
+  async addThreadParticipant(input) {
+    await this.requireThread(input.threadId);
+    const createdAtMs = Date.now();
+    this.db.prepare(`INSERT OR REPLACE INTO chat_thread_participants
+         (thread_id, scope_type, scope_id, role, created_at_ms)
+         VALUES (?, ?, ?, ?, ?)`).run(input.threadId, input.scope.type, input.scope.id, input.role, createdAtMs);
+    const previousAclEventId = 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
+    };
+    this.insertAclEvent(event, input.scope, input.role, input.threadId);
+    return event;
+  }
+  async removeThreadParticipant(input) {
+    await this.requireThread(input.threadId);
+    this.db.prepare("DELETE FROM chat_thread_participants WHERE thread_id = ? AND scope_type = ? AND scope_id = ?").run(input.threadId, input.scope.type, input.scope.id);
+    const previousAclEventId = 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
+    };
+    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()
+    };
+    this.db.prepare(`INSERT INTO chat_thread_heads
+         (id, thread_id, name, head_post_version_id, created_at_ms)
+         VALUES (?, ?, ?, ?, ?)`).run(head.id, head.threadId, head.name, head.headPostVersionId, head.createdAtMs);
+    return head;
+  }
+  async listChannelMembers(channelId) {
+    const rows = this.db.prepare("SELECT scope_type, scope_id FROM chat_channel_members WHERE channel_id = ?").all(channelId);
+    return rows.map(scopeFromRow2);
+  }
+  async listThreadParticipants(threadId) {
+    const rows = this.db.prepare("SELECT scope_type, scope_id FROM chat_thread_participants WHERE thread_id = ?").all(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 = this.db.prepare(query).all(...params);
+    const events2 = rows.map(aclEventFromRow);
+    return events2.slice(0, input.limit ?? events2.length);
+  }
+  latestAclEventId() {
+    const row = this.db.prepare("SELECT id FROM chat_acl_events ORDER BY created_at_ms DESC LIMIT 1").get();
+    return row?.id ?? null;
+  }
+  insertAclEvent(event, subject, role, threadTargetId) {
+    const targetType = event.type.startsWith("channel.") ? "channel" : "thread";
+    const targetId = targetType === "channel" ? event.channelId : threadTargetId ?? event.threadId;
+    this.db.prepare(`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 (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(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 sqliteListPostStreamEvents(this.db, postId);
+  }
+  async startStreamedPost(input) {
+    return sqliteStartStreamedPost(this.db, input, (versionId) => this.getPostVersionSync(versionId));
+  }
+  async applyPostDelta(input) {
+    return sqliteApplyPostDelta(this.db, input, (versionId) => this.getPostVersionSync(versionId));
+  }
+  async completeStreamedPost(input) {
+    return sqliteCompleteStreamedPost(this.db, input);
+  }
+  async abortStreamedPost(input) {
+    return sqliteAbortStreamedPost(this.db, input, (versionId) => this.getPostVersionSync(versionId));
+  }
+  async rebuildStreamedPostCache(postId) {
+    return sqliteRebuildStreamedPostCache(this.db, postId, (versionId) => this.getPostVersionSync(versionId));
+  }
+  async setPostVersionSignature(versionId, signature) {
+    const existing = this.db.prepare("SELECT id FROM chat_post_versions WHERE id = ?").get(versionId);
+    if (!existing) {
+      throw new ChatNotFoundError("post_version", versionId);
+    }
+    this.db.prepare("UPDATE chat_post_versions SET signature = ? WHERE id = ?").run(JSON.stringify(signature), versionId);
+  }
+}
+function createSqliteChatPersistence(db) {
+  return new SqliteChatPersistence(db);
+}
+// src/persistence/sqlite/persistence/schema.ts
+import { Database } from "bun:sqlite";
+var 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);
+`;
+function ensureChatSqliteSchema(db, busyTimeoutMs = 5000) {
+  db.run("PRAGMA journal_mode = WAL;");
+  db.run(`PRAGMA busy_timeout = ${busyTimeoutMs};`);
+  db.run("PRAGMA foreign_keys = ON;");
+  db.exec(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 {
+      db.run(statement);
+    } catch (error) {
+      if (!(error instanceof Error) || !error.message.includes("duplicate column name"))
+        throw error;
+    }
+  }
+}
+function createChatDatabase(path = ":memory:") {
+  const db = new Database(path);
+  ensureChatSqliteSchema(db);
+  return db;
+}
+export {
+  ensureChatSqliteSchema,
+  createSqliteChatPersistence,
+  createChatDatabase,
+  SqliteChatPersistence
+};