@contractspec/lib.knowledge 1.56.1 → 1.58.0

package/dist/index.js

@@ -1,12 +1,455 @@
-import { StaticRetriever, createStaticRetriever } from "./retriever/static-retriever.js";
-import { VectorRetriever, createVectorRetriever } from "./retriever/vector-retriever.js";
-import { KnowledgeQueryService } from "./query/service.js";
-import { DocumentProcessor } from "./ingestion/document-processor.js";
-import { EmbeddingService } from "./ingestion/embedding-service.js";
-import { VectorIndexer } from "./ingestion/vector-indexer.js";
-import { GmailIngestionAdapter } from "./ingestion/gmail-adapter.js";
-import { StorageIngestionAdapter } from "./ingestion/storage-adapter.js";
-import "./ingestion/index.js";
-import { KnowledgeAccessGuard } from "./access/guard.js";
-
-export { DocumentProcessor, EmbeddingService, GmailIngestionAdapter, KnowledgeAccessGuard, KnowledgeQueryService, StaticRetriever, StorageIngestionAdapter, VectorIndexer, VectorRetriever, createStaticRetriever, createVectorRetriever };
+// @bun
+// src/access/guard.ts
+var DEFAULT_DISALLOWED_WRITE = ["external", "ephemeral"];
+
+class KnowledgeAccessGuard {
+  disallowedWrite;
+  requireWorkflowBinding;
+  requireAgentBinding;
+  constructor(options = {}) {
+    this.disallowedWrite = new Set(options.disallowWriteCategories ?? DEFAULT_DISALLOWED_WRITE);
+    this.requireWorkflowBinding = options.requireWorkflowBinding ?? true;
+    this.requireAgentBinding = options.requireAgentBinding ?? false;
+  }
+  checkAccess(spaceBinding, context, appConfig) {
+    const { binding, space } = spaceBinding;
+    if (binding.required !== false && !this.isSpaceBound(spaceBinding, appConfig)) {
+      return {
+        allowed: false,
+        reason: `Knowledge space "${space.meta.key}" is not bound in the resolved app config.`
+      };
+    }
+    if (context.operation === "write" && this.disallowedWrite.has(space.meta.category)) {
+      return {
+        allowed: false,
+        reason: `Knowledge space "${space.meta.key}" is category "${space.meta.category}" and is read-only.`
+      };
+    }
+    if (this.requireWorkflowBinding && context.workflowName) {
+      const allowedWorkflows = binding.scope?.workflows;
+      if (allowedWorkflows && !allowedWorkflows.includes(context.workflowName)) {
+        return {
+          allowed: false,
+          reason: `Workflow "${context.workflowName}" is not authorized to access knowledge space "${space.meta.key}".`
+        };
+      }
+    }
+    if (this.requireAgentBinding && context.agentName) {
+      const allowedAgents = binding.scope?.agents;
+      if (allowedAgents && !allowedAgents.includes(context.agentName)) {
+        return {
+          allowed: false,
+          reason: `Agent "${context.agentName}" is not authorized to access knowledge space "${space.meta.key}".`
+        };
+      }
+    }
+    if (space.meta.category === "ephemeral") {
+      return {
+        allowed: true,
+        severity: "warning",
+        reason: `Knowledge space "${space.meta.key}" is ephemeral; results may be transient.`
+      };
+    }
+    return { allowed: true };
+  }
+  isSpaceBound(resolved, appConfig) {
+    return appConfig.knowledge.some((entry) => entry.space.meta.key === resolved.space.meta.key && (resolved.space.meta.version == null || entry.space.meta.version === resolved.space.meta.version));
+  }
+}
+// src/retriever/static-retriever.ts
+class StaticRetriever {
+  content;
+  constructor(config) {
+    this.content = config.content instanceof Map ? config.content : new Map(Object.entries(config.content));
+  }
+  async retrieve(query, options) {
+    const content = this.content.get(options.spaceKey);
+    if (!content)
+      return [];
+    const queryLower = query.toLowerCase();
+    const lines = content.split(`
+`).filter((line) => line.trim());
+    const results = [];
+    for (const line of lines) {
+      if (line.toLowerCase().includes(queryLower)) {
+        results.push({
+          content: line,
+          source: options.spaceKey,
+          score: 1,
+          metadata: { type: "static" }
+        });
+      }
+    }
+    return results.slice(0, options.topK ?? 5);
+  }
+  async getStatic(spaceKey) {
+    return this.content.get(spaceKey) ?? null;
+  }
+  supportsSpace(spaceKey) {
+    return this.content.has(spaceKey);
+  }
+  listSpaces() {
+    return [...this.content.keys()];
+  }
+}
+function createStaticRetriever(content) {
+  return new StaticRetriever({ content });
+}
+
+// src/retriever/vector-retriever.ts
+class VectorRetriever {
+  config;
+  spaceCollections;
+  staticContent;
+  constructor(config) {
+    this.config = config;
+    this.spaceCollections = config.spaceCollections instanceof Map ? config.spaceCollections : new Map(Object.entries(config.spaceCollections));
+    this.staticContent = config.staticContent ? config.staticContent instanceof Map ? config.staticContent : new Map(Object.entries(config.staticContent)) : new Map;
+  }
+  async retrieve(query, options) {
+    const collection = this.spaceCollections.get(options.spaceKey);
+    if (!collection) {
+      return [];
+    }
+    const embedding = await this.config.embeddings.embedQuery(query);
+    const results = await this.config.vectorStore.search({
+      collection,
+      vector: embedding.vector,
+      topK: options.topK ?? this.config.defaultTopK ?? 5,
+      namespace: options.tenantId,
+      filter: options.filter
+    });
+    const minScore = options.minScore ?? this.config.defaultMinScore ?? 0;
+    const filtered = results.filter((r) => r.score >= minScore);
+    return filtered.map((result) => ({
+      content: this.extractContent(result.payload),
+      source: result.id,
+      score: result.score,
+      metadata: result.payload
+    }));
+  }
+  async getStatic(spaceKey) {
+    return this.staticContent.get(spaceKey) ?? null;
+  }
+  supportsSpace(spaceKey) {
+    return this.spaceCollections.has(spaceKey);
+  }
+  listSpaces() {
+    return [...this.spaceCollections.keys()];
+  }
+  extractContent(payload) {
+    if (!payload)
+      return "";
+    if (typeof payload.text === "string")
+      return payload.text;
+    if (typeof payload.content === "string")
+      return payload.content;
+    return JSON.stringify(payload);
+  }
+}
+function createVectorRetriever(config) {
+  return new VectorRetriever(config);
+}
+// src/query/service.ts
+class KnowledgeQueryService {
+  embeddings;
+  vectorStore;
+  llm;
+  config;
+  constructor(embeddings, vectorStore, llm, config) {
+    this.embeddings = embeddings;
+    this.vectorStore = vectorStore;
+    this.llm = llm;
+    this.config = config;
+  }
+  async query(question) {
+    const embedding = await this.embeddings.embedQuery(question);
+    const results = await this.vectorStore.search({
+      collection: this.config.collection,
+      vector: embedding.vector,
+      topK: this.config.topK ?? 5,
+      namespace: this.config.namespace,
+      filter: undefined
+    });
+    const context = buildContext(results);
+    const messages = this.buildMessages(question, context);
+    const response = await this.llm.chat(messages);
+    return {
+      answer: response.message.content.map((part) => ("text" in part) ? part.text : "").join(""),
+      references: results.map((result) => ({
+        ...result,
+        text: extractText(result)
+      })),
+      usage: response.usage
+    };
+  }
+  buildMessages(question, context) {
+    const systemPrompt = this.config.systemPrompt ?? "You are a knowledge assistant that answers questions using the provided context. Cite relevant sources if possible.";
+    return [
+      {
+        role: "system",
+        content: [{ type: "text", text: systemPrompt }]
+      },
+      {
+        role: "user",
+        content: [
+          {
+            type: "text",
+            text: `Question:
+${question}
+
+Context:
+${context}`
+          }
+        ]
+      }
+    ];
+  }
+}
+function buildContext(results) {
+  if (results.length === 0) {
+    return "No relevant documents found.";
+  }
+  return results.map((result, index) => {
+    const text = extractText(result);
+    return `Source ${index + 1} (score: ${result.score.toFixed(3)}):
+${text}`;
+  }).join(`
+
+`);
+}
+function extractText(result) {
+  const payload = result.payload ?? {};
+  if (typeof payload.text === "string")
+    return payload.text;
+  if (typeof payload.content === "string")
+    return payload.content;
+  return JSON.stringify(payload);
+}
+// src/ingestion/document-processor.ts
+import { Buffer as Buffer2 } from "buffer";
+
+class DocumentProcessor {
+  extractors = new Map;
+  constructor() {
+    this.registerExtractor("text/plain", this.extractText.bind(this));
+    this.registerExtractor("application/json", this.extractJson.bind(this));
+  }
+  registerExtractor(mimeType, extractor) {
+    this.extractors.set(mimeType.toLowerCase(), extractor);
+  }
+  async process(document) {
+    const extractor = this.extractors.get(document.mimeType.toLowerCase()) ?? this.extractors.get("*/*");
+    if (!extractor) {
+      throw new Error(`No extractor registered for mime type ${document.mimeType}`);
+    }
+    const fragments = await extractor(document);
+    if (fragments.length === 0) {
+      return [
+        {
+          id: `${document.id}:0`,
+          documentId: document.id,
+          text: "",
+          metadata: document.metadata
+        }
+      ];
+    }
+    return fragments;
+  }
+  async extractText(document) {
+    const text = Buffer2.from(document.data).toString("utf-8");
+    return [
+      {
+        id: `${document.id}:0`,
+        documentId: document.id,
+        text,
+        metadata: document.metadata
+      }
+    ];
+  }
+  async extractJson(document) {
+    const text = Buffer2.from(document.data).toString("utf-8");
+    try {
+      const json = JSON.parse(text);
+      return [
+        {
+          id: `${document.id}:0`,
+          documentId: document.id,
+          text: JSON.stringify(json, null, 2),
+          metadata: {
+            ...document.metadata,
+            contentType: "application/json"
+          }
+        }
+      ];
+    } catch {
+      return this.extractText(document);
+    }
+  }
+}
+
+// src/ingestion/embedding-service.ts
+class EmbeddingService {
+  provider;
+  batchSize;
+  constructor(provider, batchSize = 16) {
+    this.provider = provider;
+    this.batchSize = batchSize;
+  }
+  async embedFragments(fragments) {
+    const results = [];
+    for (let i = 0;i < fragments.length; i += this.batchSize) {
+      const slice = fragments.slice(i, i + this.batchSize);
+      const documents = slice.map((fragment) => ({
+        id: fragment.id,
+        text: fragment.text,
+        metadata: fragment.metadata
+      }));
+      const embeddings = await this.provider.embedDocuments(documents);
+      results.push(...embeddings);
+    }
+    return results;
+  }
+}
+
+// src/ingestion/vector-indexer.ts
+class VectorIndexer {
+  provider;
+  config;
+  constructor(provider, config) {
+    this.provider = provider;
+    this.config = config;
+  }
+  async upsert(fragments, embeddings) {
+    const documents = embeddings.map((embedding) => {
+      const fragment = fragments.find((f) => f.id === embedding.id);
+      return {
+        id: embedding.id,
+        vector: embedding.vector,
+        payload: {
+          ...this.config.metadata,
+          ...fragment?.metadata ?? {},
+          documentId: fragment?.documentId
+        },
+        namespace: this.config.namespace
+      };
+    });
+    const request = {
+      collection: this.config.collection,
+      documents
+    };
+    await this.provider.upsert(request);
+  }
+}
+
+// src/ingestion/gmail-adapter.ts
+class GmailIngestionAdapter {
+  gmail;
+  processor;
+  embeddings;
+  indexer;
+  constructor(gmail, processor, embeddings, indexer) {
+    this.gmail = gmail;
+    this.processor = processor;
+    this.embeddings = embeddings;
+    this.indexer = indexer;
+  }
+  async syncThreads(query) {
+    const threads = await this.gmail.listThreads(query);
+    for (const thread of threads) {
+      await this.ingestThread(thread);
+    }
+  }
+  async ingestThread(thread) {
+    const document = this.toRawDocument(thread);
+    const fragments = await this.processor.process(document);
+    const embeddings = await this.embeddings.embedFragments(fragments);
+    await this.indexer.upsert(fragments, embeddings);
+  }
+  toRawDocument(thread) {
+    const content = composeThreadText(thread);
+    return {
+      id: thread.id,
+      mimeType: "text/plain",
+      data: Buffer.from(content, "utf-8"),
+      metadata: {
+        subject: thread.subject ?? "",
+        participants: thread.participants.map((p) => p.email).join(", "),
+        updatedAt: thread.updatedAt.toISOString()
+      }
+    };
+  }
+}
+function composeThreadText(thread) {
+  const header = [
+    `Subject: ${thread.subject ?? ""}`,
+    `Snippet: ${thread.snippet ?? ""}`
+  ];
+  const messageTexts = thread.messages.map((message) => {
+    const parts = [
+      `From: ${formatAddress(message.from)}`,
+      `To: ${message.to.map(formatAddress).join(", ")}`
+    ];
+    if (message.sentAt) {
+      parts.push(`Date: ${message.sentAt.toISOString()}`);
+    }
+    const body = message.textBody ?? stripHtml(message.htmlBody ?? "");
+    return `${parts.join(`
+`)}
+
+${body ?? ""}`;
+  });
+  return [...header, ...messageTexts].join(`
+
+---
+
+`);
+}
+function formatAddress(address) {
+  return address.name ? `${address.name} <${address.email}>` : address.email;
+}
+function stripHtml(html) {
+  return html.replace(/<[^>]+>/g, " ");
+}
+
+// src/ingestion/storage-adapter.ts
+class StorageIngestionAdapter {
+  processor;
+  embeddings;
+  indexer;
+  constructor(processor, embeddings, indexer) {
+    this.processor = processor;
+    this.embeddings = embeddings;
+    this.indexer = indexer;
+  }
+  async ingestObject(object) {
+    if (!("data" in object) || !object.data) {
+      throw new Error("Storage ingestion requires object data");
+    }
+    const raw = {
+      id: object.key,
+      mimeType: object.contentType ?? "application/octet-stream",
+      data: object.data,
+      metadata: {
+        bucket: object.bucket,
+        checksum: object.checksum ?? ""
+      }
+    };
+    const fragments = await this.processor.process(raw);
+    const embeddings = await this.embeddings.embedFragments(fragments);
+    await this.indexer.upsert(fragments, embeddings);
+  }
+}
+export {
+  createVectorRetriever,
+  createStaticRetriever,
+  VectorRetriever,
+  VectorIndexer,
+  StorageIngestionAdapter,
+  StaticRetriever,
+  KnowledgeQueryService,
+  KnowledgeAccessGuard,
+  GmailIngestionAdapter,
+  EmbeddingService,
+  DocumentProcessor
+};

package/dist/ingestion/document-processor.d.ts

@@ -1,25 +1,23 @@
-//#region src/ingestion/document-processor.d.ts
-interface RawDocument {
-  id: string;
-  mimeType: string;
-  data: Uint8Array;
-  metadata?: Record<string, string>;
+export interface RawDocument {
+    id: string;
+    mimeType: string;
+    data: Uint8Array;
+    metadata?: Record<string, string>;
 }
-interface DocumentFragment {
-  id: string;
-  documentId: string;
-  text: string;
-  metadata?: Record<string, string>;
+export interface DocumentFragment {
+    id: string;
+    documentId: string;
+    text: string;
+    metadata?: Record<string, string>;
 }
 type Extractor = (input: RawDocument) => Promise<DocumentFragment[]>;
-declare class DocumentProcessor {
-  private readonly extractors;
-  constructor();
-  registerExtractor(mimeType: string, extractor: Extractor): void;
-  process(document: RawDocument): Promise<DocumentFragment[]>;
-  private extractText;
-  private extractJson;
+export declare class DocumentProcessor {
+    private readonly extractors;
+    constructor();
+    registerExtractor(mimeType: string, extractor: Extractor): void;
+    process(document: RawDocument): Promise<DocumentFragment[]>;
+    private extractText;
+    private extractJson;
 }
-//#endregion
-export { DocumentFragment, DocumentProcessor, RawDocument };
+export {};
 //# sourceMappingURL=document-processor.d.ts.map

package/dist/ingestion/document-processor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"document-processor.d.ts","names":[],"sources":["../../src/ingestion/document-processor.ts"],"sourcesContent":[],"mappings":";UAEiB,WAAA;EAAA,EAAA,EAAA,MAAA;EAOA,QAAA,EAAA,MAAA;EAOZ,IAAA,EAXG,UAWM;EAAW,QAAA,CAAA,EAVZ,MAUY,CAAA,MAAA,EAAA,MAAA,CAAA;;AAAgB,UAPxB,gBAAA,CAOwB;EAAO,EAAA,EAAA,MAAA;EAEnC,UAAA,EAAA,MAAA;EAQoC,IAAA,EAAA,MAAA;EAIvB,QAAA,CAAA,EAjBb,MAiBa,CAAA,MAAA,EAAA,MAAA,CAAA;;KAdrB,SAAA,GAcmC,CAAA,KAAA,EAdf,WAce,EAAA,GAdC,OAcD,CAdS,gBAcT,EAAA,CAAA;AAAO,cAZlC,iBAAA,CAYkC;;;iDAJE;oBAIvB,cAAc,QAAQ"}
+{"version":3,"file":"document-processor.d.ts","sourceRoot":"","sources":["../../src/ingestion/document-processor.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,WAAW;IAC1B,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,UAAU,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACnC;AAED,MAAM,WAAW,gBAAgB;IAC/B,EAAE,EAAE,MAAM,CAAC;IACX,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACnC;AAED,KAAK,SAAS,GAAG,CAAC,KAAK,EAAE,WAAW,KAAK,OAAO,CAAC,gBAAgB,EAAE,CAAC,CAAC;AAErE,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAgC;;IAO3D,iBAAiB,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,SAAS,GAAG,IAAI;IAIzD,OAAO,CAAC,QAAQ,EAAE,WAAW,GAAG,OAAO,CAAC,gBAAgB,EAAE,CAAC;YAuBnD,WAAW;YAcX,WAAW;CAqB1B"}

package/dist/ingestion/document-processor.js

@@ -1,55 +1,65 @@
-import { Buffer } from "node:buffer";
+// @bun
+// src/ingestion/document-processor.ts
+import { Buffer } from "buffer";
 
-//#region src/ingestion/document-processor.ts
-var DocumentProcessor = class {
-	extractors = /* @__PURE__ */ new Map();
-	constructor() {
-		this.registerExtractor("text/plain", this.extractText.bind(this));
-		this.registerExtractor("application/json", this.extractJson.bind(this));
-	}
-	registerExtractor(mimeType, extractor) {
-		this.extractors.set(mimeType.toLowerCase(), extractor);
-	}
-	async process(document) {
-		const extractor = this.extractors.get(document.mimeType.toLowerCase()) ?? this.extractors.get("*/*");
-		if (!extractor) throw new Error(`No extractor registered for mime type ${document.mimeType}`);
-		const fragments = await extractor(document);
-		if (fragments.length === 0) return [{
-			id: `${document.id}:0`,
-			documentId: document.id,
-			text: "",
-			metadata: document.metadata
-		}];
-		return fragments;
-	}
-	async extractText(document) {
-		const text = Buffer.from(document.data).toString("utf-8");
-		return [{
-			id: `${document.id}:0`,
-			documentId: document.id,
-			text,
-			metadata: document.metadata
-		}];
-	}
-	async extractJson(document) {
-		const text = Buffer.from(document.data).toString("utf-8");
-		try {
-			const json = JSON.parse(text);
-			return [{
-				id: `${document.id}:0`,
-				documentId: document.id,
-				text: JSON.stringify(json, null, 2),
-				metadata: {
-					...document.metadata,
-					contentType: "application/json"
-				}
-			}];
-		} catch {
-			return this.extractText(document);
-		}
-	}
+class DocumentProcessor {
+  extractors = new Map;
+  constructor() {
+    this.registerExtractor("text/plain", this.extractText.bind(this));
+    this.registerExtractor("application/json", this.extractJson.bind(this));
+  }
+  registerExtractor(mimeType, extractor) {
+    this.extractors.set(mimeType.toLowerCase(), extractor);
+  }
+  async process(document) {
+    const extractor = this.extractors.get(document.mimeType.toLowerCase()) ?? this.extractors.get("*/*");
+    if (!extractor) {
+      throw new Error(`No extractor registered for mime type ${document.mimeType}`);
+    }
+    const fragments = await extractor(document);
+    if (fragments.length === 0) {
+      return [
+        {
+          id: `${document.id}:0`,
+          documentId: document.id,
+          text: "",
+          metadata: document.metadata
+        }
+      ];
+    }
+    return fragments;
+  }
+  async extractText(document) {
+    const text = Buffer.from(document.data).toString("utf-8");
+    return [
+      {
+        id: `${document.id}:0`,
+        documentId: document.id,
+        text,
+        metadata: document.metadata
+      }
+    ];
+  }
+  async extractJson(document) {
+    const text = Buffer.from(document.data).toString("utf-8");
+    try {
+      const json = JSON.parse(text);
+      return [
+        {
+          id: `${document.id}:0`,
+          documentId: document.id,
+          text: JSON.stringify(json, null, 2),
+          metadata: {
+            ...document.metadata,
+            contentType: "application/json"
+          }
+        }
+      ];
+    } catch {
+      return this.extractText(document);
+    }
+  }
+}
+export {
+  DocumentProcessor
 };
-
-//#endregion
-export { DocumentProcessor };
-//# sourceMappingURL=document-processor.js.map

package/dist/ingestion/embedding-service.d.ts

@@ -1,13 +1,9 @@
-import { DocumentFragment } from "./document-processor.js";
-import { EmbeddingProvider, EmbeddingResult } from "@contractspec/lib.contracts";
-
-//#region src/ingestion/embedding-service.d.ts
-declare class EmbeddingService {
-  private readonly provider;
-  private readonly batchSize;
-  constructor(provider: EmbeddingProvider, batchSize?: number);
-  embedFragments(fragments: DocumentFragment[]): Promise<EmbeddingResult[]>;
+import type { EmbeddingProvider, EmbeddingResult } from '@contractspec/lib.contracts';
+import type { DocumentFragment } from './document-processor';
+export declare class EmbeddingService {
+    private readonly provider;
+    private readonly batchSize;
+    constructor(provider: EmbeddingProvider, batchSize?: number);
+    embedFragments(fragments: DocumentFragment[]): Promise<EmbeddingResult[]>;
 }
-//#endregion
-export { EmbeddingService };
 //# sourceMappingURL=embedding-service.d.ts.map

package/dist/ingestion/embedding-service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"embedding-service.d.ts","names":[],"sources":["../../src/ingestion/embedding-service.ts"],"sourcesContent":[],"mappings":";;;;cAOa,gBAAA;;EAAA,iBAAA,SAAgB;EAIL,WAAA,CAAA,QAAA,EAAA,iBAAA,EAAA,SAAA,CAAA,EAAA,MAAA;EAMT,cAAA,CAAA,SAAA,EAAA,gBAAA,EAAA,CAAA,EACV,OADU,CACF,eADE,EAAA,CAAA"}
+{"version":3,"file":"embedding-service.d.ts","sourceRoot":"","sources":["../../src/ingestion/embedding-service.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,iBAAiB,EACjB,eAAe,EAChB,MAAM,6BAA6B,CAAC;AACrC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAE7D,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAoB;IAC7C,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;gBAEvB,QAAQ,EAAE,iBAAiB,EAAE,SAAS,SAAK;IAKjD,cAAc,CAClB,SAAS,EAAE,gBAAgB,EAAE,GAC5B,OAAO,CAAC,eAAe,EAAE,CAAC;CAc9B"}