@khoralabs/chat 0.1.0

package/dist/persistence/testing/index.js

@@ -0,0 +1,689 @@
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/persistence/testing/persistence/contract.ts
+import { describe, expect, test } from "bun:test";
+
+// 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/testing/persistence/contract.ts
+function runChatPersistenceContractTests(name, createPersistence) {
+  describe(`${name} persistence contract`, () => {
+    test("creates channel and thread under channel", async () => {
+      const persistence = await createPersistence();
+      const channel = await persistence.createChannel({ metadata: { name: "general" } });
+      const thread = await persistence.createThread({
+        root: { type: "channel", channelId: channel.id }
+      });
+      expect(await persistence.getChannel(channel.id)).toEqual(channel);
+      expect(await persistence.getThread(thread.id)).toEqual(thread);
+      const threads = await persistence.listThreads({ channelId: channel.id });
+      expect(threads.items).toHaveLength(1);
+    });
+    test("appends posts with monotonic indexes", async () => {
+      const persistence = await createPersistence();
+      const channel = await persistence.createChannel({});
+      const thread = await persistence.createThread({
+        root: { type: "channel", channelId: channel.id }
+      });
+      const author = { type: "account", id: "user-1" };
+      const first = await persistence.appendPost({
+        threadId: thread.id,
+        author,
+        message: { id: "m1", role: "user", parts: [{ type: "text", text: "hello" }] }
+      });
+      expect(first.ok).toBe(true);
+      if (!first.ok)
+        return;
+      const second = await persistence.appendPost({
+        threadId: thread.id,
+        author,
+        message: { id: "m2", role: "assistant", parts: [{ type: "text", text: "hi" }] },
+        expectedHeadPostVersionId: first.head.headPostVersionId
+      });
+      expect(second.ok).toBe(true);
+      if (!second.ok)
+        return;
+      const posts = await persistence.listPosts({ threadId: thread.id });
+      expect(posts.items).toHaveLength(2);
+      expect(posts.items[0]?.index).toBe(1);
+      expect(posts.items[1]?.index).toBe(2);
+      expect(posts.items[0]?.parts[0]).toEqual({ type: "text", text: "hello" });
+    });
+    test("returns head conflict on stale append", async () => {
+      const persistence = await createPersistence();
+      const channel = await persistence.createChannel({});
+      const thread = await persistence.createThread({
+        root: { type: "channel", channelId: channel.id }
+      });
+      const author = { type: "account", id: "user-1" };
+      const first = await persistence.appendPost({
+        threadId: thread.id,
+        author,
+        message: { id: "m1", role: "user", parts: [{ type: "text", text: "one" }] }
+      });
+      expect(first.ok).toBe(true);
+      if (!first.ok)
+        return;
+      const conflict = await persistence.appendPost({
+        threadId: thread.id,
+        author,
+        message: { id: "m2", role: "user", parts: [{ type: "text", text: "two" }] },
+        expectedHeadPostVersionId: null
+      });
+      expect(conflict.ok).toBe(false);
+      if (conflict.ok)
+        return;
+      expect(conflict.reason).toBe("head_conflict");
+    });
+    test("supports recursive thread rooted at post", async () => {
+      const persistence = await createPersistence();
+      const channel = await persistence.createChannel({});
+      const parentThread = await persistence.createThread({
+        root: { type: "channel", channelId: channel.id }
+      });
+      const author = { type: "account", id: "user-1" };
+      const parentPost = await persistence.appendPost({
+        threadId: parentThread.id,
+        author,
+        message: { id: "root-post", role: "user", parts: [{ type: "text", text: "root" }] }
+      });
+      expect(parentPost.ok).toBe(true);
+      if (!parentPost.ok)
+        return;
+      const childThread = await persistence.createThread({
+        root: { type: "post", postId: parentPost.post.id }
+      });
+      const childPosts = await persistence.listThreads({ postId: parentPost.post.id });
+      expect(childPosts.items.some((item) => item.id === childThread.id)).toBe(true);
+    });
+    test("edits create immutable versions and preserve lineage", async () => {
+      const persistence = await createPersistence();
+      const channel = await persistence.createChannel({});
+      const thread = await persistence.createThread({
+        root: { type: "channel", channelId: channel.id }
+      });
+      const author = { type: "account", id: "user-1" };
+      const appended = await persistence.appendPost({
+        threadId: thread.id,
+        author,
+        message: { id: "m1", role: "user", parts: [{ type: "text", text: "draft" }] }
+      });
+      expect(appended.ok).toBe(true);
+      if (!appended.ok || appended.post.status !== "complete")
+        return;
+      const edited = await persistence.editPost({
+        postId: appended.post.id,
+        parentVersionId: appended.post.versionId,
+        author,
+        message: { id: "m1", role: "user", parts: [{ type: "text", text: "final" }] }
+      });
+      expect(edited.ok).toBe(true);
+      if (!edited.ok || edited.post.status !== "complete")
+        return;
+      const posts = await persistence.listPosts({ threadId: thread.id });
+      expect(posts.items).toHaveLength(1);
+      expect(posts.items[0]?.parts[0]).toEqual({ type: "text", text: "final" });
+      expect(edited.post.previousVersionId).toBe(appended.post.versionId);
+    });
+    test("soft delete preserves ledger order", async () => {
+      const persistence = await createPersistence();
+      const channel = await persistence.createChannel({});
+      const thread = await persistence.createThread({
+        root: { type: "channel", channelId: channel.id }
+      });
+      const author = { type: "account", id: "user-1" };
+      const first = await persistence.appendPost({
+        threadId: thread.id,
+        author,
+        message: { id: "m1", role: "user", parts: [{ type: "text", text: "keep" }] }
+      });
+      expect(first.ok).toBe(true);
+      if (!first.ok)
+        return;
+      const second = await persistence.appendPost({
+        threadId: thread.id,
+        author,
+        message: { id: "m2", role: "user", parts: [{ type: "text", text: "remove" }] },
+        expectedHeadPostVersionId: first.head.headPostVersionId
+      });
+      expect(second.ok).toBe(true);
+      if (!second.ok)
+        return;
+      await persistence.deletePost({ postId: second.post.id });
+      const posts = await persistence.listPosts({ threadId: thread.id });
+      expect(posts.items).toHaveLength(2);
+      expect(posts.items[1]?.deletedAtMs).not.toBeNull();
+      expect(posts.items[0]?.index).toBe(1);
+      expect(posts.items[1]?.index).toBe(2);
+    });
+    test("records ACL membership changes", async () => {
+      const persistence = await createPersistence();
+      const channel = await persistence.createChannel({});
+      const actor = { type: "account", id: "admin" };
+      const member = { type: "account", id: "member" };
+      await persistence.addChannelMember({
+        channelId: channel.id,
+        scope: member,
+        role: "member",
+        actor
+      });
+      const members = await persistence.listChannelMembers(channel.id);
+      expect(members).toEqual([member]);
+      const events2 = await persistence.listAclEvents({ channelId: channel.id });
+      expect(events2).toHaveLength(1);
+      expect(events2[0]?.type).toBe("channel.member.added");
+    });
+    test("supports idempotency keys for append", async () => {
+      const persistence = await createPersistence();
+      const channel = await persistence.createChannel({});
+      const thread = await persistence.createThread({
+        root: { type: "channel", channelId: channel.id }
+      });
+      const author = { type: "account", id: "user-1" };
+      const input = {
+        threadId: thread.id,
+        author,
+        idempotencyKey: "retry-1",
+        message: {
+          id: "m1",
+          role: "user",
+          parts: [{ type: "text", text: "once" }]
+        }
+      };
+      const first = await persistence.appendPost(input);
+      const second = await persistence.appendPost(input);
+      expect(first.ok).toBe(true);
+      expect(second.ok).toBe(true);
+      if (!first.ok || !second.ok || first.post.status !== "complete" || second.post.status !== "complete")
+        return;
+      expect(second.post.versionId).toBe(first.post.versionId);
+      const posts = await persistence.listPosts({ threadId: thread.id });
+      expect(posts.items).toHaveLength(1);
+    });
+    test("walks lineage between ancestor and head", async () => {
+      const persistence = await createPersistence();
+      const channel = await persistence.createChannel({});
+      const thread = await persistence.createThread({
+        root: { type: "channel", channelId: channel.id }
+      });
+      const author = { type: "account", id: "user-1" };
+      let headVersionId = null;
+      const versions = new Map;
+      for (const text of ["a", "b", "c"]) {
+        const result = await persistence.appendPost({
+          threadId: thread.id,
+          author,
+          message: { id: `m-${text}`, role: "user", parts: [{ type: "text", text }] },
+          expectedHeadPostVersionId: headVersionId
+        });
+        expect(result.ok).toBe(true);
+        if (!result.ok)
+          return;
+        headVersionId = result.head.headPostVersionId;
+        const version = await persistence.getPostVersion(result.post.status === "complete" ? result.post.versionId : "");
+        if (version) {
+          versions.set(version.id, version);
+        }
+      }
+      const middle = [...versions.values()].find((version) => version.postId === "m-b");
+      expect(middle).toBeDefined();
+      if (!middle || !headVersionId)
+        return;
+      const slice = lineageBetween(headVersionId, middle.id, versions);
+      expect(slice?.map((version) => version.postId)).toEqual(["m-b", "m-c"]);
+    });
+    test("streams post deltas until completion commits immutable version", async () => {
+      const persistence = await createPersistence();
+      const channel = await persistence.createChannel({});
+      const thread = await persistence.createThread({
+        root: { type: "channel", channelId: channel.id }
+      });
+      const author = { type: "agent", id: "a1" };
+      const started = await persistence.startStreamedPost({
+        threadId: thread.id,
+        author,
+        message: {
+          id: "stream-1",
+          role: "assistant",
+          parts: [{ type: "text", text: "hel", state: "streaming" }]
+        }
+      });
+      expect(started.post.status).toBe("streaming");
+      expect(started.revision).toBe(1);
+      const listed = await persistence.listPosts({ threadId: thread.id });
+      expect(listed.items).toHaveLength(1);
+      expect(listed.items[0]?.status).toBe("streaming");
+      const delta = await persistence.applyPostDelta({
+        postId: started.post.id,
+        message: {
+          id: started.post.id,
+          role: "assistant",
+          parts: [{ type: "text", text: "hello", state: "streaming" }]
+        },
+        expectedRevision: 1
+      });
+      expect(delta.revision).toBe(2);
+      const retry = await persistence.applyPostDelta({
+        postId: started.post.id,
+        message: {
+          id: started.post.id,
+          role: "assistant",
+          parts: [{ type: "text", text: "hello", state: "streaming" }]
+        },
+        idempotencyKey: "delta-retry",
+        expectedRevision: 2
+      });
+      const retryAgain = await persistence.applyPostDelta({
+        postId: started.post.id,
+        message: {
+          id: started.post.id,
+          role: "assistant",
+          parts: [{ type: "text", text: "hello", state: "streaming" }]
+        },
+        idempotencyKey: "delta-retry",
+        expectedRevision: 2
+      });
+      expect(retryAgain.revision).toBe(retry.revision);
+      const completed = await persistence.completeStreamedPost({
+        postId: started.post.id,
+        expectedRevision: retry.revision
+      });
+      expect(completed.ok).toBe(true);
+      if (!completed.ok)
+        return;
+      expect(completed.post.status).toBe("complete");
+      expect(completed.post.parts[0]).toEqual({ type: "text", text: "hello", state: "streaming" });
+      const events2 = await persistence.listPostStreamEvents(started.post.id);
+      expect(events2.length).toBeGreaterThanOrEqual(3);
+      await expect(persistence.applyPostDelta({
+        postId: started.post.id,
+        message: {
+          id: started.post.id,
+          role: "assistant",
+          parts: [{ type: "text", text: "nope" }]
+        }
+      })).rejects.toThrow();
+      const rebuilt = await persistence.rebuildStreamedPostCache(started.post.id).catch(() => null);
+      expect(rebuilt).toBeNull();
+    });
+    test("rebuilds cached stream state from append-only events", async () => {
+      const persistence = await createPersistence();
+      const channel = await persistence.createChannel({});
+      const thread = await persistence.createThread({
+        root: { type: "channel", channelId: channel.id }
+      });
+      const author = { type: "agent", id: "a1" };
+      const started = await persistence.startStreamedPost({
+        threadId: thread.id,
+        author,
+        message: { id: "stream-2", role: "assistant", parts: [{ type: "text", text: "a" }] }
+      });
+      await persistence.applyPostDelta({
+        postId: started.post.id,
+        message: { id: started.post.id, role: "assistant", parts: [{ type: "text", text: "ab" }] }
+      });
+      const rebuilt = await persistence.rebuildStreamedPostCache(started.post.id);
+      expect(rebuilt.parts[0]).toEqual({ type: "text", text: "ab" });
+    });
+    test("getThreadTip returns default-head lineage tip", async () => {
+      const persistence = await createPersistence();
+      const channel = await persistence.createChannel({});
+      const thread = await persistence.createThread({
+        root: { type: "channel", channelId: channel.id }
+      });
+      expect(await persistence.getThreadTip(thread.id)).toBeNull();
+      const author = { type: "account", id: "user-1" };
+      const first = await persistence.appendPost({
+        threadId: thread.id,
+        author,
+        message: { id: "m1", role: "user", parts: [{ type: "text", text: "one" }] }
+      });
+      expect(first.ok).toBe(true);
+      if (!first.ok || first.post.status !== "complete")
+        return;
+      const tip = await persistence.getThreadTip(thread.id);
+      expect(tip).toEqual({
+        id: first.post.versionId,
+        lineageHash: first.post.lineageHash
+      });
+    });
+    test("listThreads filters by participant and channel", async () => {
+      const persistence = await createPersistence();
+      const channel = await persistence.createChannel({});
+      const alice = { type: "account", id: "alice" };
+      const bob = { type: "account", id: "bob" };
+      const shared = await persistence.createThread({
+        root: { type: "channel", channelId: channel.id }
+      });
+      const privateThread = await persistence.createThread({
+        root: { type: "channel", channelId: channel.id }
+      });
+      await persistence.addThreadParticipant({
+        threadId: shared.id,
+        scope: alice,
+        role: "owner",
+        actor: alice
+      });
+      await persistence.addThreadParticipant({
+        threadId: shared.id,
+        scope: bob,
+        role: "participant",
+        actor: alice
+      });
+      await persistence.addThreadParticipant({
+        threadId: privateThread.id,
+        scope: alice,
+        role: "owner",
+        actor: alice
+      });
+      const bobThreads = await persistence.listThreads({
+        channelId: channel.id,
+        participant: bob
+      });
+      expect(bobThreads.items.map((thread) => thread.id)).toEqual([shared.id]);
+      const aliceThreads = await persistence.listThreads({
+        channelId: channel.id,
+        participant: alice
+      });
+      expect(aliceThreads.items.map((thread) => thread.id).sort()).toEqual([shared.id, privateThread.id].sort());
+    });
+    test("setPostVersionSignature persists and overwrites", async () => {
+      const persistence = await createPersistence();
+      const channel = await persistence.createChannel({});
+      const thread = await persistence.createThread({
+        root: { type: "channel", channelId: channel.id }
+      });
+      const author = { type: "account", id: "user-1" };
+      const appended = await persistence.appendPost({
+        threadId: thread.id,
+        author,
+        message: { id: "m-sig", role: "user", parts: [{ type: "text", text: "signed" }] }
+      });
+      expect(appended.ok).toBe(true);
+      if (!appended.ok || appended.post.status !== "complete")
+        return;
+      const versionId = appended.post.versionId;
+      const envelope = {
+        algorithm: "test",
+        signer: author,
+        signature: "sig-1",
+        signedAtMs: Date.now()
+      };
+      await persistence.setPostVersionSignature(versionId, envelope);
+      const version = await persistence.getPostVersion(versionId);
+      expect(version?.signature).toEqual(envelope);
+      const overwrite = { ...envelope, signature: "sig-2" };
+      await persistence.setPostVersionSignature(versionId, overwrite);
+      const updated = await persistence.getPostVersion(versionId);
+      expect(updated?.signature).toEqual(overwrite);
+      await expect(persistence.setPostVersionSignature("missing-version", envelope)).rejects.toThrow(/not found/);
+    });
+  });
+}
+export {
+  runChatPersistenceContractTests
+};

package/dist/persistence/testing/persistence/contract.d.ts

@@ -0,0 +1,3 @@
+import type { ChatPersistence } from "../../../domain.js";
+export declare function runChatPersistenceContractTests(name: string, createPersistence: () => ChatPersistence | Promise<ChatPersistence>): void;
+//# sourceMappingURL=contract.d.ts.map

package/dist/persistence/testing/persistence/contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract.d.ts","sourceRoot":"","sources":["../../../../src/persistence/testing/persistence/contract.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAG1D,wBAAgB,+BAA+B,CAC7C,IAAI,EAAE,MAAM,EACZ,iBAAiB,EAAE,MAAM,eAAe,GAAG,OAAO,CAAC,eAAe,CAAC,QA2cpE"}