@khoralabs/chat 0.1.0

package/dist/http/routes.d.ts

@@ -0,0 +1,15 @@
+import type { ChatService } from "../service.js";
+export type AuthorizeRequest = (req: Request) => Response | null | Promise<Response | null>;
+export declare function requireInternalToken(req: Request, expected: string): Response | null;
+export declare function createTokenAuthorizer(token: string): AuthorizeRequest;
+export declare function readJson<T>(req: Request): Promise<T | null>;
+export type RouteHandler = (req: Request) => Response | Promise<Response>;
+export type CreateChatRoutesOptions = {
+    /** Default: shared-secret Bearer via `token`. */
+    authorize?: AuthorizeRequest;
+    token?: string;
+};
+export declare function createChatRoutes(chat: ChatService, tokenOrOptions: string | CreateChatRoutesOptions): Record<string, RouteHandler>;
+export declare function createChatRoutesWithParams(chat: ChatService, tokenOrOptions: string | CreateChatRoutesOptions): Record<string, RouteHandler>;
+export declare function dispatchChatRoute(routes: Record<string, RouteHandler>, req: Request): Promise<Response>;
+//# sourceMappingURL=routes.d.ts.map

package/dist/http/routes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"routes.d.ts","sourceRoot":"","sources":["../../src/http/routes.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAejD,MAAM,MAAM,gBAAgB,GAAG,CAAC,GAAG,EAAE,OAAO,KAAK,QAAQ,GAAG,IAAI,GAAG,OAAO,CAAC,QAAQ,GAAG,IAAI,CAAC,CAAC;AAE5F,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,GAAG,QAAQ,GAAG,IAAI,CAMpF;AAED,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,MAAM,GAAG,gBAAgB,CAErE;AAED,wBAAsB,QAAQ,CAAC,CAAC,EAAE,GAAG,EAAE,OAAO,GAAG,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC,CAMjE;AAeD,MAAM,MAAM,YAAY,GAAG,CAAC,GAAG,EAAE,OAAO,KAAK,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;AAE1E,MAAM,MAAM,uBAAuB,GAAG;IACpC,iDAAiD;IACjD,SAAS,CAAC,EAAE,gBAAgB,CAAC;IAC7B,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAUF,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,WAAW,EACjB,cAAc,EAAE,MAAM,GAAG,uBAAuB,GAC/C,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CA8S9B;AAcD,wBAAgB,0BAA0B,CACxC,IAAI,EAAE,WAAW,EACjB,cAAc,EAAE,MAAM,GAAG,uBAAuB,GAC/C,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CA0C9B;AAED,wBAAsB,iBAAiB,CACrC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,EACpC,GAAG,EAAE,OAAO,GACX,OAAO,CAAC,QAAQ,CAAC,CAwBnB"}

package/dist/http/routes.js

@@ -0,0 +1,645 @@
+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/http/routes.ts
+function json(value, init) {
+  return Response.json(value, init);
+}
+function extractBearerToken(req) {
+  const auth = req.headers.get("authorization")?.trim() ?? "";
+  const match = /^Bearer\s+(.+)$/i.exec(auth);
+  const headerToken = match?.[1]?.trim() ?? "";
+  if (headerToken.length > 0)
+    return headerToken;
+  const url = new URL(req.url);
+  return url.searchParams.get("token")?.trim() ?? "";
+}
+function requireInternalToken(req, expected) {
+  const token = extractBearerToken(req);
+  if (token.length === 0 || token !== expected) {
+    return json({ error: "Unauthorized" }, { status: 401 });
+  }
+  return null;
+}
+function createTokenAuthorizer(token) {
+  return (req) => requireInternalToken(req, token);
+}
+async function readJson(req) {
+  try {
+    return await req.json();
+  } catch {
+    return null;
+  }
+}
+function stringField(body, key) {
+  const value = body[key];
+  return typeof value === "string" && value.length > 0 ? value : null;
+}
+function errorResponse(error) {
+  if (error instanceof ChatNotFoundError) {
+    return json({ error: error.message }, { status: 404 });
+  }
+  const message = error instanceof Error ? error.message : String(error);
+  return json({ error: message }, { status: 500 });
+}
+function resolveAuthorize(options) {
+  if (options.authorize !== undefined)
+    return options.authorize;
+  if (options.token !== undefined && options.token.length > 0) {
+    return createTokenAuthorizer(options.token);
+  }
+  throw new Error("createChatRoutes requires token or authorize");
+}
+function createChatRoutes(chat, tokenOrOptions) {
+  const options = typeof tokenOrOptions === "string" ? { token: tokenOrOptions } : tokenOrOptions;
+  const authorized = resolveAuthorize(options);
+  return {
+    "GET /health": async () => json({ ok: true }),
+    "POST /channels/get": async (req) => {
+      const error = await authorized(req);
+      if (error !== null)
+        return error;
+      const body = await readJson(req);
+      const channelId = body === null ? null : stringField(body, "channelId");
+      if (channelId === null)
+        return json({ error: "channelId is required" }, { status: 400 });
+      try {
+        return json(await chat.getChannel(channelId));
+      } catch (err) {
+        return errorResponse(err);
+      }
+    },
+    "POST /channels/create": async (req) => {
+      const error = await authorized(req);
+      if (error !== null)
+        return error;
+      const body = await readJson(req);
+      const id = body === null ? null : stringField(body, "id");
+      if (id === null)
+        return json({ error: "id is required" }, { status: 400 });
+      try {
+        return json(await chat.createChannel({
+          id,
+          metadata: body?.metadata
+        }));
+      } catch (err) {
+        return errorResponse(err);
+      }
+    },
+    "POST /threads/get": async (req) => {
+      const error = await authorized(req);
+      if (error !== null)
+        return error;
+      const body = await readJson(req);
+      const threadId = body === null ? null : stringField(body, "threadId");
+      if (threadId === null)
+        return json({ error: "threadId is required" }, { status: 400 });
+      try {
+        return json(await chat.getThread(threadId));
+      } catch (err) {
+        return errorResponse(err);
+      }
+    },
+    "POST /threads/create": async (req) => {
+      const error = await authorized(req);
+      if (error !== null)
+        return error;
+      const body = await readJson(req);
+      if (body?.id === undefined || body.root === undefined) {
+        return json({ error: "id and root are required" }, { status: 400 });
+      }
+      try {
+        return json(await chat.createThread({
+          id: body.id,
+          root: body.root,
+          metadata: body.metadata
+        }));
+      } catch (err) {
+        return errorResponse(err);
+      }
+    },
+    "POST /threads/list": async (req) => {
+      const error = await authorized(req);
+      if (error !== null)
+        return error;
+      const body = await readJson(req);
+      if (body?.channelId === undefined) {
+        return json({ error: "channelId is required" }, { status: 400 });
+      }
+      try {
+        return json(await chat.listThreads({
+          channelId: body.channelId,
+          participant: body.participant,
+          limit: body.limit,
+          cursor: body.cursor
+        }));
+      } catch (err) {
+        return errorResponse(err);
+      }
+    },
+    "POST /threads/list-posts": async (req) => {
+      const error = await authorized(req);
+      if (error !== null)
+        return error;
+      const body = await readJson(req);
+      if (body?.threadId === undefined) {
+        return json({ error: "threadId is required" }, { status: 400 });
+      }
+      try {
+        return json(await chat.listPosts({ threadId: body.threadId, limit: body.limit, cursor: body.cursor }));
+      } catch (err) {
+        return errorResponse(err);
+      }
+    },
+    "POST /threads/tip": async (req) => {
+      const error = await authorized(req);
+      if (error !== null)
+        return error;
+      const body = await readJson(req);
+      const threadId = body === null ? null : stringField(body, "threadId");
+      if (threadId === null)
+        return json({ error: "threadId is required" }, { status: 400 });
+      try {
+        return json({ tip: await chat.getThreadTip(threadId) });
+      } catch (err) {
+        return errorResponse(err);
+      }
+    },
+    "POST /threads/list-participants": async (req) => {
+      const error = await authorized(req);
+      if (error !== null)
+        return error;
+      const body = await readJson(req);
+      const threadId = body === null ? null : stringField(body, "threadId");
+      if (threadId === null)
+        return json({ error: "threadId is required" }, { status: 400 });
+      try {
+        return json({ participants: await chat.listThreadParticipants(threadId) });
+      } catch (err) {
+        return errorResponse(err);
+      }
+    },
+    "POST /threads/add-participant": async (req) => {
+      const error = await authorized(req);
+      if (error !== null)
+        return error;
+      const body = await readJson(req);
+      if (body?.threadId === undefined || body.scope === undefined || body.actor === undefined) {
+        return json({ error: "threadId, scope, and actor are required" }, { status: 400 });
+      }
+      try {
+        return json(await chat.addThreadParticipant({
+          threadId: body.threadId,
+          scope: body.scope,
+          role: body.role ?? "participant",
+          actor: body.actor
+        }));
+      } catch (err) {
+        return errorResponse(err);
+      }
+    },
+    "POST /threads/append-post": async (req) => {
+      const error = await authorized(req);
+      if (error !== null)
+        return error;
+      const body = await readJson(req);
+      if (body?.threadId === undefined || body.author === undefined || body.message === undefined) {
+        return json({ error: "threadId, author, and message are required" }, { status: 400 });
+      }
+      try {
+        return json(await chat.appendPost({
+          threadId: body.threadId,
+          author: body.author,
+          message: body.message,
+          expectedHeadPostVersionId: body.expectedHeadPostVersionId,
+          versionId: body.versionId,
+          createdAtMs: body.createdAtMs,
+          signature: body.signature
+        }));
+      } catch (err) {
+        return errorResponse(err);
+      }
+    },
+    "POST /posts/set-signature": async (req) => {
+      const error = await authorized(req);
+      if (error !== null)
+        return error;
+      const body = await readJson(req);
+      if (body?.versionId === undefined || body.signature === undefined) {
+        return json({ error: "versionId and signature are required" }, { status: 400 });
+      }
+      try {
+        await chat.setPostVersionSignature(body.versionId, body.signature);
+        return json({ ok: true });
+      } catch (err) {
+        return errorResponse(err);
+      }
+    },
+    "POST /internal/chat/streamed-posts": async (req) => {
+      const error = await authorized(req);
+      if (error !== null)
+        return error;
+      const body = await readJson(req);
+      if (body?.author === undefined || body.message === undefined || body.threadId === undefined) {
+        return json({ error: "threadId, author, and message are required" }, { status: 400 });
+      }
+      try {
+        return json(await chat.startStreamedPost({
+          threadId: body.threadId,
+          author: body.author,
+          idempotencyKey: body.idempotencyKey,
+          message: body.message
+        }));
+      } catch (err) {
+        return errorResponse(err);
+      }
+    },
+    "POST /internal/chat/posts/:postId/deltas": async (req) => {
+      const error = await authorized(req);
+      if (error !== null)
+        return error;
+      const url = new URL(req.url);
+      const postId = url.pathname.split("/").at(-2);
+      if (postId === undefined)
+        return json({ error: "postId is required" }, { status: 400 });
+      const body = await readJson(req);
+      if (body?.message === undefined) {
+        return json({ error: "message is required" }, { status: 400 });
+      }
+      try {
+        return json(await chat.applyPostDelta({
+          postId,
+          expectedRevision: body.expectedRevision,
+          message: body.message,
+          model: body.model,
+          usage: body.usage
+        }));
+      } catch (err) {
+        return errorResponse(err);
+      }
+    },
+    "POST /internal/chat/posts/:postId/complete": async (req) => {
+      const error = await authorized(req);
+      if (error !== null)
+        return error;
+      const url = new URL(req.url);
+      const postId = url.pathname.split("/").at(-2);
+      if (postId === undefined)
+        return json({ error: "postId is required" }, { status: 400 });
+      const body = await readJson(req);
+      try {
+        return json(await chat.completeStreamedPost({
+          postId,
+          expectedRevision: body?.expectedRevision,
+          idempotencyKey: body?.idempotencyKey
+        }));
+      } catch (err) {
+        return errorResponse(err);
+      }
+    },
+    "POST /internal/chat/posts/:postId/abort": async (req) => {
+      const error = await authorized(req);
+      if (error !== null)
+        return error;
+      const url = new URL(req.url);
+      const postId = url.pathname.split("/").at(-2);
+      if (postId === undefined)
+        return json({ error: "postId is required" }, { status: 400 });
+      try {
+        const post = await chat.abortStreamedPost({ postId });
+        return json({ post });
+      } catch (err) {
+        return errorResponse(err);
+      }
+    }
+  };
+}
+function createChatRoutesWithParams(chat, tokenOrOptions) {
+  const options = typeof tokenOrOptions === "string" ? { token: tokenOrOptions } : tokenOrOptions;
+  const base = createChatRoutes(chat, options);
+  const authorized = resolveAuthorize(options);
+  return {
+    ...base,
+    "POST /internal/chat/threads/:threadId/streamed-posts": async (req) => {
+      const error = await authorized(req);
+      if (error !== null)
+        return error;
+      const url = new URL(req.url);
+      const parts = url.pathname.split("/");
+      const threadIdx = parts.indexOf("threads");
+      const threadId = threadIdx >= 0 ? decodeURIComponent(parts[threadIdx + 1] ?? "") : undefined;
+      const body = await readJson(req);
+      if (threadId === undefined || threadId.length === 0 || body?.author === undefined || body.message === undefined) {
+        return json({ error: "threadId, author, and message are required" }, { status: 400 });
+      }
+      try {
+        return json(await chat.startStreamedPost({
+          threadId,
+          author: body.author,
+          idempotencyKey: body.idempotencyKey,
+          message: body.message
+        }));
+      } catch (err) {
+        return errorResponse(err);
+      }
+    }
+  };
+}
+async function dispatchChatRoute(routes, req) {
+  const url = new URL(req.url);
+  const paramPaths = [
+    "POST /internal/chat/threads/:threadId/streamed-posts",
+    "POST /internal/chat/posts/:postId/deltas",
+    "POST /internal/chat/posts/:postId/complete",
+    "POST /internal/chat/posts/:postId/abort"
+  ];
+  for (const pattern of paramPaths) {
+    const [method, pathPattern] = pattern.split(" ");
+    if (req.method !== method || pathPattern === undefined)
+      continue;
+    const regex = new RegExp(`^${pathPattern.replace(/:[^/]+/g, "[^/]+")}$`);
+    if (regex.test(url.pathname)) {
+      const handler2 = routes[pattern];
+      if (handler2 !== undefined)
+        return handler2(req);
+    }
+  }
+  const key = `${req.method} ${url.pathname}`;
+  const handler = routes[key];
+  if (handler === undefined)
+    return json({ error: "Not found" }, { status: 404 });
+  return handler(req);
+}
+export {
+  requireInternalToken,
+  readJson,
+  dispatchChatRoute,
+  createTokenAuthorizer,
+  createChatRoutesWithParams,
+  createChatRoutes
+};

package/dist/http/server.d.ts

@@ -0,0 +1,19 @@
+import type { ChatEvent } from "../domain.js";
+import type { ChatService } from "../service.js";
+import { type ChatStorageConfig } from "./service.js";
+export type ChatHttpServerHandle = {
+    port: number;
+    baseUrl: string;
+    token: string;
+    service: ChatService;
+    stop(): void;
+};
+export type StartChatHttpServerOptions = {
+    storage: ChatStorageConfig;
+    token: string;
+    port?: number;
+    onEvent?: (event: ChatEvent) => void;
+};
+/** Start chat HTTP (routes + /health + thread WebSocket fanout) with host-provided storage. */
+export declare function startChatHttpServer(opts: StartChatHttpServerOptions): Promise<ChatHttpServerHandle>;
+//# sourceMappingURL=server.d.ts.map

package/dist/http/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/http/server.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAC9C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAIjD,OAAO,EAAE,KAAK,iBAAiB,EAA4C,MAAM,cAAc,CAAC;AAEhG,MAAM,MAAM,oBAAoB,GAAG;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,WAAW,CAAC;IACrB,IAAI,IAAI,IAAI,CAAC;CACd,CAAC;AAEF,MAAM,MAAM,0BAA0B,GAAG;IACvC,OAAO,EAAE,iBAAiB,CAAC;IAC3B,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,SAAS,KAAK,IAAI,CAAC;CACtC,CAAC;AAOF,+FAA+F;AAC/F,wBAAsB,mBAAmB,CACvC,IAAI,EAAE,0BAA0B,GAC/B,OAAO,CAAC,oBAAoB,CAAC,CAsD/B"}