@khoralabs/chat 0.1.0

package/dist/persistence/core/persistence/index.js

@@ -0,0 +1,1276 @@
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// 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/core/persistence/base-persistence.ts
+class BaseChatPersistence {
+  assertThreadRootExists(root) {
+    if (root.type === "channel" && !root.channelId.trim()) {
+      throw new ChatValidationError("channel root requires channelId");
+    }
+    if (root.type === "post" && !root.postId.trim()) {
+      throw new ChatValidationError("post root requires postId");
+    }
+  }
+  async requireChannel(id) {
+    const channel = await this.getChannel(id);
+    if (!channel)
+      throw new ChatNotFoundError("channel", id);
+    return channel;
+  }
+  async requireThread(id) {
+    const thread = await this.getThread(id);
+    if (!thread)
+      throw new ChatNotFoundError("thread", id);
+    return thread;
+  }
+  async requirePost(id) {
+    const post = await this.getPost(id);
+    if (!post)
+      throw new ChatNotFoundError("post", id);
+    return post;
+  }
+  validateCreateThreadInput(input) {
+    this.assertThreadRootExists(input.root);
+  }
+}
+// src/persistence/core/persistence/helpers.ts
+function prepareAppendPost(input, options = {}) {
+  const generate = options.generateId ?? createId;
+  const now = options.now ?? (() => Date.now());
+  const postId = input.message.id || generate();
+  const versionId = input.versionId ?? generate();
+  const createdAtMs = input.createdAtMs ?? now();
+  const message = { ...input.message, id: postId };
+  const contentHash = computeContentHash({
+    postId,
+    versionId,
+    threadId: input.threadId,
+    author: input.author,
+    role: message.role,
+    parts: message.parts,
+    metadata: message.metadata,
+    mentions: input.mentions,
+    model: input.model,
+    usage: input.usage,
+    parentVersionId: null,
+    previousPostVersionId: input.previousPostVersionId
+  });
+  const lineageHash = computeLineageHash({
+    previousLineageHash: input.previousLineageHash,
+    contentHash,
+    postId,
+    versionId
+  });
+  return {
+    postId,
+    versionId,
+    threadId: input.threadId,
+    author: input.author,
+    message,
+    mentions: input.mentions,
+    model: input.model,
+    usage: input.usage,
+    previousPostVersionId: input.previousPostVersionId,
+    previousLineageHash: input.previousLineageHash,
+    parentVersionId: null,
+    createdAtMs,
+    contentHash,
+    lineageHash
+  };
+}
+function prepareEditPost(input, options = {}) {
+  const generate = options.generateId ?? createId;
+  const now = options.now ?? (() => Date.now());
+  const postId = input.postId;
+  const versionId = generate();
+  const createdAtMs = now();
+  const message = { ...input.message, id: postId };
+  const contentHash = computeContentHash({
+    postId,
+    versionId,
+    threadId: input.threadId,
+    author: input.author,
+    role: message.role,
+    parts: message.parts,
+    metadata: message.metadata,
+    mentions: input.mentions,
+    model: input.model,
+    usage: input.usage,
+    parentVersionId: input.parentVersionId,
+    previousPostVersionId: input.previousPostVersionId
+  });
+  const lineageHash = computeLineageHash({
+    previousLineageHash: input.previousLineageHash,
+    contentHash,
+    postId,
+    versionId
+  });
+  return {
+    postId,
+    versionId,
+    threadId: input.threadId,
+    author: input.author,
+    message,
+    mentions: input.mentions,
+    model: input.model,
+    usage: input.usage,
+    previousPostVersionId: input.previousPostVersionId,
+    previousLineageHash: input.previousLineageHash,
+    parentVersionId: input.parentVersionId,
+    createdAtMs,
+    contentHash,
+    lineageHash
+  };
+}
+function buildAclEventContentHash(input) {
+  return computeAclEventContentHash(input);
+}
+// src/persistence/core/persistence/memory-persistence.ts
+var DEFAULT_HEAD_NAME = "default";
+
+class MemoryChatPersistence extends BaseChatPersistence {
+  channels = new Map;
+  threads = new Map;
+  posts = new Map;
+  versions = new Map;
+  streamEvents = [];
+  streamIdempotency = new Map;
+  heads = new Map;
+  channelMembers = new Map;
+  threadParticipants = new Map;
+  aclEvents = [];
+  idempotency = new Map;
+  threadIndexes = new Map;
+  async createChannel(input) {
+    const channel = {
+      id: input.id ?? createId(),
+      metadata: input.metadata,
+      createdAtMs: Date.now()
+    };
+    this.channels.set(channel.id, channel);
+    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()
+    };
+    this.threads.set(thread.id, thread);
+    this.threadIndexes.set(thread.id, 0);
+    return thread;
+  }
+  async getChannel(id) {
+    return this.channels.get(id) ?? null;
+  }
+  async getThread(id) {
+    return this.threads.get(id) ?? null;
+  }
+  postFromRecord(postId, record) {
+    if (record.status === "streaming") {
+      if (!record.message)
+        return null;
+      return streamingPostFromCache({
+        postId,
+        threadId: record.threadId,
+        author: record.author,
+        message: record.message,
+        mentions: record.mentions,
+        model: record.model,
+        usage: record.usage,
+        index: record.index,
+        streamRevision: record.streamRevision,
+        createdAtMs: record.createdAtMs,
+        updatedAtMs: record.updatedAtMs,
+        deletedAtMs: record.deletedAtMs
+      });
+    }
+    if (record.status === "aborted") {
+      if (!record.message)
+        return null;
+      return {
+        ...record.message,
+        id: postId,
+        status: "aborted",
+        threadId: record.threadId,
+        author: record.author,
+        mentions: record.mentions,
+        model: record.model,
+        usage: record.usage,
+        index: record.index,
+        streamRevision: record.streamRevision,
+        createdAtMs: record.createdAtMs,
+        updatedAtMs: record.updatedAtMs,
+        deletedAtMs: record.deletedAtMs
+      };
+    }
+    const version = record.completedVersionId ? this.versions.get(record.completedVersionId) : [...this.versions.values()].filter((item) => item.postId === postId).sort((a, b) => b.createdAtMs - a.createdAtMs)[0];
+    if (!version)
+      return null;
+    return postFromVersion(version, record.index, record.deletedAtMs);
+  }
+  async getPost(id) {
+    const record = this.posts.get(id);
+    if (!record)
+      return null;
+    return this.postFromRecord(id, record);
+  }
+  async getPostVersion(id) {
+    return this.versions.get(id) ?? null;
+  }
+  async getThreadHead(threadId, headId) {
+    const thread = await this.requireThread(threadId);
+    const resolvedHeadId = headId ?? thread.defaultHeadId;
+    if (!resolvedHeadId)
+      return null;
+    const head = this.heads.get(resolvedHeadId);
+    return head?.threadId === threadId ? head : null;
+  }
+  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;
+    let items = [...this.threads.values()];
+    if (input.channelId) {
+      items = items.filter((thread) => thread.root.type === "channel" && thread.root.channelId === input.channelId);
+    }
+    if (input.postId) {
+      items = items.filter((thread) => thread.root.type === "post" && thread.root.postId === input.postId);
+    }
+    if (input.participant) {
+      const key = scopeKey(input.participant);
+      items = items.filter((thread) => this.threadParticipants.get(thread.id)?.has(key));
+    }
+    items.sort((a, b) => a.createdAtMs - b.createdAtMs);
+    const start = input.cursor ? Number.parseInt(input.cursor, 10) : 0;
+    const page = items.slice(start, start + limit);
+    const nextCursor = start + limit < items.length ? String(start + limit) : null;
+    return { items: page, nextCursor };
+  }
+  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 lineagePosts = head ? walkLineageFromHead(head.headPostVersionId, this.versions).flatMap((version) => {
+      const record = this.posts.get(version.postId);
+      if (!record)
+        return [];
+      const post = postFromVersion(version, record.index, record.deletedAtMs);
+      return [{ index: record.index, post }];
+    }) : [];
+    const activePosts = [...this.posts.entries()].filter(([, record]) => record.threadId === input.threadId && record.status !== "complete").map(([postId, record]) => this.postFromRecord(postId, record)).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);
+    const nextCursor = start + limit < merged.length ? String(start + limit) : null;
+    return { items, nextCursor };
+  }
+  async appendPost(input) {
+    if (input.idempotencyKey) {
+      const existing = this.idempotency.get(input.idempotencyKey);
+      if (existing?.kind === "append") {
+        return { ok: true, post: existing.post, head: existing.head };
+      }
+    }
+    const thread = await this.requireThread(input.threadId);
+    const currentHead = thread.defaultHeadId ? this.heads.get(thread.defaultHeadId) : null;
+    if (input.expectedHeadPostVersionId !== undefined && (currentHead?.headPostVersionId ?? null) !== (input.expectedHeadPostVersionId ?? null)) {
+      if (!currentHead) {
+        throw new ChatConflictError("head_conflict", "expected head but thread is empty");
+      }
+      return { ok: false, reason: "head_conflict", currentHead };
+    }
+    const previousVersion = currentHead ? this.versions.get(currentHead.headPostVersionId) : null;
+    const prepared = prepareAppendPost({
+      ...input,
+      previousPostVersionId: previousVersion?.id ?? null,
+      previousLineageHash: previousVersion?.lineageHash ?? null
+    });
+    const nextIndex = (this.threadIndexes.get(input.threadId) ?? 0) + 1;
+    this.threadIndexes.set(input.threadId, nextIndex);
+    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,
+      signature: input.signature,
+      createdAtMs: prepared.createdAtMs
+    };
+    this.posts.set(prepared.postId, {
+      threadId: input.threadId,
+      index: nextIndex,
+      status: "complete",
+      author: prepared.author,
+      streamRevision: 0,
+      completedVersionId: version.id,
+      createdAtMs: prepared.createdAtMs,
+      updatedAtMs: null,
+      deletedAtMs: null
+    });
+    this.versions.set(version.id, version);
+    const head = {
+      id: currentHead?.id ?? createId(),
+      threadId: input.threadId,
+      name: currentHead?.name ?? DEFAULT_HEAD_NAME,
+      headPostVersionId: version.id,
+      createdAtMs: currentHead?.createdAtMs ?? prepared.createdAtMs
+    };
+    this.heads.set(head.id, head);
+    this.threads.set(input.threadId, {
+      ...thread,
+      defaultHeadId: head.id
+    });
+    const post = postFromVersion(version, nextIndex);
+    if (input.idempotencyKey) {
+      this.idempotency.set(input.idempotencyKey, {
+        kind: "append",
+        post,
+        head
+      });
+    }
+    return { ok: true, post, head };
+  }
+  async editPost(input) {
+    if (input.idempotencyKey) {
+      const existing = this.idempotency.get(input.idempotencyKey);
+      if (existing?.kind === "edit") {
+        return { ok: true, post: existing.post, head: existing.head };
+      }
+    }
+    const parentVersion = await this.getPostVersion(input.parentVersionId);
+    if (!parentVersion) {
+      throw new ChatNotFoundError("post_version", input.parentVersionId);
+    }
+    const thread = await this.requireThread(parentVersion.threadId);
+    const currentHead = thread.defaultHeadId ? this.heads.get(thread.defaultHeadId) : null;
+    if (input.expectedHeadPostVersionId !== undefined && (currentHead?.headPostVersionId ?? null) !== (input.expectedHeadPostVersionId ?? null)) {
+      if (!currentHead) {
+        throw new ChatConflictError("head_conflict", "expected head but thread is empty");
+      }
+      return { ok: false, reason: "head_conflict", currentHead };
+    }
+    const previousInChain = parentVersion.previousPostVersionId ? this.versions.get(parentVersion.previousPostVersionId) ?? null : null;
+    const prepared = prepareEditPost({
+      ...input,
+      threadId: parentVersion.threadId,
+      previousPostVersionId: parentVersion.previousPostVersionId ?? null,
+      previousLineageHash: previousInChain?.lineageHash ?? null
+    });
+    const record = this.posts.get(input.postId);
+    if (!record)
+      throw new ChatNotFoundError("post", input.postId);
+    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,
+      model: prepared.model,
+      usage: prepared.usage,
+      createdAtMs: prepared.createdAtMs
+    };
+    this.versions.set(version.id, version);
+    let head;
+    if (currentHead?.headPostVersionId === input.parentVersionId) {
+      head = {
+        ...currentHead,
+        headPostVersionId: version.id
+      };
+      this.heads.set(head.id, head);
+    } else if (currentHead) {
+      head = currentHead;
+    } else {
+      head = {
+        id: createId(),
+        threadId: parentVersion.threadId,
+        name: DEFAULT_HEAD_NAME,
+        headPostVersionId: version.id,
+        createdAtMs: prepared.createdAtMs
+      };
+      this.heads.set(head.id, head);
+      this.threads.set(parentVersion.threadId, {
+        ...thread,
+        defaultHeadId: head.id
+      });
+    }
+    const post = postFromVersion(version, record.index, record.deletedAtMs);
+    if (input.idempotencyKey) {
+      this.idempotency.set(input.idempotencyKey, {
+        kind: "edit",
+        post,
+        head
+      });
+    }
+    return { ok: true, post, head };
+  }
+  async deletePost(input) {
+    const post = await this.requirePost(input.postId);
+    const record = this.posts.get(input.postId);
+    if (!record)
+      throw new ChatNotFoundError("post", input.postId);
+    const deletedAtMs = input.deletedAtMs ?? Date.now();
+    this.posts.set(input.postId, { ...record, deletedAtMs });
+    return { ...post, deletedAtMs };
+  }
+  async addChannelMember(input) {
+    await this.requireChannel(input.channelId);
+    const members = this.channelMembers.get(input.channelId) ?? new Map;
+    members.set(scopeKey(input.scope), {
+      role: input.role,
+      createdAtMs: Date.now()
+    });
+    this.channelMembers.set(input.channelId, members);
+    const previousAclEventId = this.aclEvents.length > 0 ? this.aclEvents[this.aclEvents.length - 1]?.id : null;
+    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: Date.now()
+    };
+    this.aclEvents.push(event);
+    return event;
+  }
+  async removeChannelMember(input) {
+    await this.requireChannel(input.channelId);
+    const members = this.channelMembers.get(input.channelId);
+    members?.delete(scopeKey(input.scope));
+    const previousAclEventId = this.aclEvents.length > 0 ? this.aclEvents[this.aclEvents.length - 1]?.id : null;
+    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: Date.now()
+    };
+    this.aclEvents.push(event);
+    return event;
+  }
+  async addThreadParticipant(input) {
+    await this.requireThread(input.threadId);
+    const participants = this.threadParticipants.get(input.threadId) ?? new Map;
+    participants.set(scopeKey(input.scope), {
+      role: input.role,
+      createdAtMs: Date.now()
+    });
+    this.threadParticipants.set(input.threadId, participants);
+    const previousAclEventId = this.aclEvents.length > 0 ? this.aclEvents[this.aclEvents.length - 1]?.id : null;
+    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: Date.now()
+    };
+    this.aclEvents.push(event);
+    return event;
+  }
+  async removeThreadParticipant(input) {
+    await this.requireThread(input.threadId);
+    const participants = this.threadParticipants.get(input.threadId);
+    participants?.delete(scopeKey(input.scope));
+    const previousAclEventId = this.aclEvents.length > 0 ? this.aclEvents[this.aclEvents.length - 1]?.id : null;
+    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: Date.now()
+    };
+    this.aclEvents.push(event);
+    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.heads.set(head.id, head);
+    return head;
+  }
+  async listChannelMembers(channelId) {
+    const members = this.channelMembers.get(channelId);
+    if (!members)
+      return [];
+    return [...members.keys()].map(scopeRefFromKey);
+  }
+  async listThreadParticipants(threadId) {
+    const participants = this.threadParticipants.get(threadId);
+    if (!participants)
+      return [];
+    return [...participants.keys()].map(scopeRefFromKey);
+  }
+  async listAclEvents(input) {
+    let events2 = [...this.aclEvents];
+    if (input.channelId) {
+      events2 = events2.filter((event) => event.type.startsWith("channel.") && ("channelId" in event) && event.channelId === input.channelId);
+    }
+    if (input.threadId) {
+      events2 = events2.filter((event) => event.type.startsWith("thread.") && ("threadId" in event) && event.threadId === input.threadId);
+    }
+    return events2.slice(0, input.limit ?? events2.length);
+  }
+  async listPostStreamEvents(postId) {
+    return this.streamEvents.filter((event) => event.postId === postId).sort((a, b) => a.revision - b.revision);
+  }
+  async startStreamedPost(input) {
+    if (input.idempotencyKey) {
+      const existing = this.streamIdempotency.get(input.idempotencyKey);
+      if (existing) {
+        const post2 = await this.getPost(existing.postId);
+        if (post2?.status !== "streaming") {
+          throw new ChatConflictError("idempotency_mismatch", "idempotency key reused");
+        }
+        return { post: post2, revision: existing.revision };
+      }
+    }
+    await this.requireThread(input.threadId);
+    const postId = input.message.id || createId();
+    const nextIndex = (this.threadIndexes.get(input.threadId) ?? 0) + 1;
+    this.threadIndexes.set(input.threadId, nextIndex);
+    const createdAtMs = Date.now();
+    const message = { ...input.message, id: postId };
+    const revision = 1;
+    const event = {
+      id: createId(),
+      postId,
+      threadId: input.threadId,
+      eventType: "stream.started",
+      revision,
+      message,
+      mentions: input.mentions,
+      model: input.model,
+      usage: input.usage,
+      idempotencyKey: input.idempotencyKey,
+      createdAtMs
+    };
+    this.streamEvents.push(event);
+    this.posts.set(postId, {
+      threadId: input.threadId,
+      index: nextIndex,
+      status: "streaming",
+      author: input.author,
+      message,
+      mentions: input.mentions,
+      model: input.model,
+      usage: input.usage,
+      streamRevision: revision,
+      createdAtMs,
+      updatedAtMs: null,
+      deletedAtMs: null
+    });
+    if (input.idempotencyKey) {
+      this.streamIdempotency.set(input.idempotencyKey, {
+        postId,
+        revision,
+        eventId: event.id
+      });
+    }
+    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 applyPostDelta(input) {
+    if (input.idempotencyKey) {
+      const existing = this.streamIdempotency.get(input.idempotencyKey);
+      if (existing && existing.postId === input.postId) {
+        const post2 = await this.getPost(input.postId);
+        if (post2?.status !== "streaming") {
+          throw new ChatConflictError("idempotency_mismatch", "idempotency key reused");
+        }
+        return { post: post2, revision: existing.revision };
+      }
+    }
+    const record = this.posts.get(input.postId);
+    if (!record)
+      throw new ChatNotFoundError("post", input.postId);
+    if (record.status !== "streaming") {
+      throw new ChatValidationError(`post ${input.postId} is not streaming`);
+    }
+    if (input.expectedRevision !== undefined && record.streamRevision !== input.expectedRevision) {
+      throw new ChatConflictError("stream_revision_conflict", `expected revision ${input.expectedRevision}, current ${record.streamRevision}`);
+    }
+    const revision = record.streamRevision + 1;
+    const updatedAtMs = Date.now();
+    const message = { ...input.message, id: input.postId };
+    const event = {
+      id: createId(),
+      postId: input.postId,
+      threadId: record.threadId,
+      eventType: "stream.delta",
+      revision,
+      message,
+      delta: input.delta,
+      mentions: input.mentions ?? record.mentions,
+      model: input.model ?? record.model,
+      usage: input.usage ?? record.usage,
+      idempotencyKey: input.idempotencyKey,
+      createdAtMs: updatedAtMs
+    };
+    this.streamEvents.push(event);
+    this.posts.set(input.postId, {
+      ...record,
+      message,
+      mentions: input.mentions ?? record.mentions,
+      model: input.model ?? record.model,
+      usage: input.usage ?? record.usage,
+      streamRevision: revision,
+      updatedAtMs
+    });
+    if (input.idempotencyKey) {
+      this.streamIdempotency.set(input.idempotencyKey, {
+        postId: input.postId,
+        revision,
+        eventId: event.id
+      });
+    }
+    const post = streamingPostFromCache({
+      postId: input.postId,
+      threadId: record.threadId,
+      author: record.author,
+      message,
+      mentions: input.mentions ?? record.mentions,
+      model: input.model ?? record.model,
+      usage: input.usage ?? record.usage,
+      index: record.index,
+      streamRevision: revision,
+      createdAtMs: record.createdAtMs,
+      updatedAtMs,
+      deletedAtMs: record.deletedAtMs
+    });
+    return { post, revision };
+  }
+  async completeStreamedPost(input) {
+    const record = this.posts.get(input.postId);
+    if (!record)
+      throw new ChatNotFoundError("post", input.postId);
+    if (record.status !== "streaming") {
+      throw new ChatValidationError(`post ${input.postId} is not streaming`);
+    }
+    if (input.expectedRevision !== undefined && record.streamRevision !== input.expectedRevision) {
+      throw new ChatConflictError("stream_revision_conflict", `expected revision ${input.expectedRevision}, current ${record.streamRevision}`);
+    }
+    if (!record.message) {
+      throw new ChatValidationError(`post ${input.postId} has no streamed message`);
+    }
+    const thread = await this.requireThread(record.threadId);
+    const currentHead = thread.defaultHeadId ? this.heads.get(thread.defaultHeadId) : null;
+    if (input.expectedHeadPostVersionId !== undefined && (currentHead?.headPostVersionId ?? null) !== (input.expectedHeadPostVersionId ?? null)) {
+      if (!currentHead) {
+        throw new ChatConflictError("head_conflict", "expected head but thread is empty");
+      }
+      return { ok: false, reason: "head_conflict", currentHead };
+    }
+    const previousVersion = currentHead ? this.versions.get(currentHead.headPostVersionId) : null;
+    const prepared = prepareAppendPost({
+      threadId: record.threadId,
+      author: record.author,
+      message: record.message,
+      mentions: record.mentions,
+      model: record.model,
+      usage: record.usage,
+      previousPostVersionId: previousVersion?.id ?? null,
+      previousLineageHash: previousVersion?.lineageHash ?? null
+    });
+    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
+    };
+    this.versions.set(version.id, version);
+    const head = {
+      id: currentHead?.id ?? createId(),
+      threadId: record.threadId,
+      name: currentHead?.name ?? DEFAULT_HEAD_NAME,
+      headPostVersionId: version.id,
+      createdAtMs: currentHead?.createdAtMs ?? prepared.createdAtMs
+    };
+    this.heads.set(head.id, head);
+    this.threads.set(record.threadId, { ...thread, defaultHeadId: head.id });
+    const completedRevision = record.streamRevision + 1;
+    const completedAtMs = Date.now();
+    this.streamEvents.push({
+      id: createId(),
+      postId: input.postId,
+      threadId: record.threadId,
+      eventType: "stream.completed",
+      revision: completedRevision,
+      message: record.message,
+      mentions: record.mentions,
+      model: record.model,
+      usage: record.usage,
+      createdAtMs: completedAtMs
+    });
+    this.posts.set(input.postId, {
+      ...record,
+      status: "complete",
+      streamRevision: completedRevision,
+      completedVersionId: version.id,
+      updatedAtMs: completedAtMs,
+      message: undefined,
+      mentions: undefined
+    });
+    const post = postFromVersion(version, record.index, record.deletedAtMs);
+    return { ok: true, post, head };
+  }
+  async abortStreamedPost(input) {
+    const record = this.posts.get(input.postId);
+    if (!record)
+      throw new ChatNotFoundError("post", input.postId);
+    if (record.status !== "streaming") {
+      throw new ChatValidationError(`post ${input.postId} is not streaming`);
+    }
+    const deletedAtMs = input.deletedAtMs ?? Date.now();
+    const revision = record.streamRevision + 1;
+    this.streamEvents.push({
+      id: createId(),
+      postId: input.postId,
+      threadId: record.threadId,
+      eventType: "stream.aborted",
+      revision,
+      message: record.message,
+      mentions: record.mentions,
+      model: record.model,
+      usage: record.usage,
+      createdAtMs: deletedAtMs
+    });
+    this.posts.set(input.postId, {
+      ...record,
+      status: "aborted",
+      streamRevision: revision,
+      deletedAtMs,
+      updatedAtMs: deletedAtMs
+    });
+    const post = await this.getPost(input.postId);
+    if (post?.status !== "aborted") {
+      throw new ChatNotFoundError("post", input.postId);
+    }
+    return { post };
+  }
+  async rebuildStreamedPostCache(postId) {
+    const record = this.posts.get(postId);
+    if (!record)
+      throw new ChatNotFoundError("post", postId);
+    if (record.status !== "streaming") {
+      throw new ChatValidationError(`post ${postId} is not streaming`);
+    }
+    const events2 = await this.listPostStreamEvents(postId);
+    const rebuilt = rebuildStreamCacheFromEvents(events2);
+    this.posts.set(postId, {
+      ...record,
+      message: rebuilt.message,
+      mentions: rebuilt.mentions,
+      streamRevision: rebuilt.revision,
+      updatedAtMs: Date.now()
+    });
+    return streamingPostFromCache({
+      postId,
+      threadId: record.threadId,
+      author: record.author,
+      message: rebuilt.message,
+      mentions: rebuilt.mentions,
+      index: record.index,
+      streamRevision: rebuilt.revision,
+      createdAtMs: record.createdAtMs,
+      updatedAtMs: Date.now(),
+      deletedAtMs: record.deletedAtMs
+    });
+  }
+  async setPostVersionSignature(versionId, signature) {
+    const version = this.versions.get(versionId);
+    if (!version)
+      throw new ChatNotFoundError("post_version", versionId);
+    this.versions.set(versionId, { ...version, signature });
+  }
+}
+function createMemoryChatPersistence() {
+  return new MemoryChatPersistence;
+}
+// src/persistence/core/persistence/signed-persistence.ts
+function scopesEqual(a, b) {
+  return a.type === b.type && a.id === b.id;
+}
+function preparedToSignable(prepared) {
+  return {
+    postId: prepared.postId,
+    versionId: prepared.versionId,
+    threadId: prepared.threadId,
+    author: prepared.author,
+    role: prepared.message.role,
+    parts: prepared.message.parts,
+    metadata: prepared.message.metadata,
+    mentions: prepared.mentions,
+    model: prepared.model,
+    usage: prepared.usage,
+    parentVersionId: prepared.parentVersionId ?? null,
+    previousPostVersionId: prepared.previousPostVersionId,
+    contentHash: prepared.contentHash,
+    lineageHash: prepared.lineageHash
+  };
+}
+async function prepareAppendForSigning(persistence, input) {
+  const tip = await persistence.getThreadTip(input.threadId);
+  return prepareAppendPost({
+    ...input,
+    previousPostVersionId: tip?.id ?? null,
+    previousLineageHash: tip?.lineageHash ?? null
+  });
+}
+async function signPreparedAppendPost(signer, author, prepared) {
+  const payload = canonicalSignedPostVersionPayload(preparedToSignable(prepared));
+  return signer.sign(signedPayloadBytes(payload), author);
+}
+async function assertValidAppendSignature(prepared, author, envelope, verifier) {
+  if (!scopesEqual(envelope.signer, author)) {
+    throw new ChatValidationError("appendPost signature signer must match author");
+  }
+  const payload = canonicalSignedPostVersionPayload(preparedToSignable(prepared));
+  const ok = await verifier.verify(signedPayloadBytes(payload), envelope);
+  if (!ok) {
+    throw new ChatValidationError("invalid post signature");
+  }
+}
+function signableFromCommittedPost(post) {
+  return {
+    postId: post.id,
+    versionId: post.versionId,
+    threadId: post.threadId,
+    author: post.author,
+    role: post.role,
+    parts: post.parts,
+    metadata: post.metadata,
+    mentions: post.mentions,
+    model: post.model,
+    usage: post.usage,
+    parentVersionId: post.previousVersionId ?? null,
+    previousPostVersionId: post.previousPostVersionId ?? null,
+    contentHash: post.contentHash,
+    lineageHash: post.lineageHash
+  };
+}
+function withSignedChatPersistence(persistence, options) {
+  return new Proxy(persistence, {
+    get(target, prop, receiver) {
+      if (prop === "appendPost") {
+        return async (input) => {
+          if (!input.signature) {
+            throw new ChatValidationError("appendPost requires a signed envelope");
+          }
+          const prepared = await prepareAppendForSigning(target, input);
+          await assertValidAppendSignature(prepared, input.author, input.signature, options.verifier);
+          return target.appendPost({
+            ...input,
+            message: prepared.message,
+            versionId: prepared.versionId,
+            createdAtMs: prepared.createdAtMs,
+            signature: input.signature
+          });
+        };
+      }
+      if (prop === "completeStreamedPost") {
+        return async (input) => {
+          const result = await target.completeStreamedPost(input);
+          if (!result.ok)
+            return result;
+          const signable = signableFromCommittedPost(result.post);
+          const payload = canonicalSignedPostVersionPayload(signable);
+          const envelope = await options.signer.sign(signedPayloadBytes(payload), result.post.author);
+          await target.setPostVersionSignature(result.post.versionId, envelope);
+          return {
+            ok: true,
+            post: { ...result.post, signature: envelope },
+            head: result.head
+          };
+        };
+      }
+      const value = Reflect.get(target, prop, receiver);
+      return typeof value === "function" ? value.bind(target) : value;
+    }
+  });
+}
+export {
+  withSignedChatPersistence,
+  signPreparedAppendPost,
+  prepareEditPost,
+  prepareAppendPost,
+  prepareAppendForSigning,
+  createMemoryChatPersistence,
+  buildAclEventContentHash,
+  MemoryChatPersistence,
+  BaseChatPersistence
+};