@yolk-sdk/knowledge 0.0.1-canary.9 → 0.1.0-canary.101

package/README.md

@@ -1,106 +1,186 @@
 # @yolk-sdk/knowledge
 
-Domain-free knowledge record, artifact, representation, search, provenance, link, store, and context contracts.
+Domain-free knowledge document/source/file/context, ingestion, hybrid search, and lookup/manage tool helpers for agents.
 
 ## Install
 
 ```bash
-pnpm add @yolk-sdk/knowledge@canary @yolk-sdk/agent@canary effect
+pnpm add @yolk-sdk/knowledge@canary @yolk-sdk/agent@canary effect@4.0.0
 ```
 
 Canary APIs are unstable. Keep all `@yolk-sdk/*` packages on the same version.
+Use the SDK's matching Effect version (`4.0.0`) in host code.
+Published package metadata requires Node.js 22+.
+
+## Model
+
+```txt
+KnowledgeDocument
+  id
+  slug
+  title
+  purpose
+  origin
+  content
+  summary?
+  errorMessage?
+  reviewedAt?
+  metadata?
+  status: processing | ready | error
+  availability: pinned | searchable | archived
+  createdAt
+  updatedAt
+```
+
+- `pinned`: host may inject into startup context and search.
+- `searchable`: host may expose through search tools.
+- `archived`: retained, normally omitted from prompt and search.
+
+Optional files and chunks are modeled as `KnowledgeFile` and `KnowledgeChunk`. File records carry
+metadata and host-owned blob keys; `KnowledgeFileBlobStore` stores the bytes separately. Chunks are
+search-index records. Hosts own blob storage, chunk persistence, transactions, and lifecycle.
+
+`KnowledgeSource` is a separate ingestion ADT. Build variants with `Schema.TaggedStruct` constructors
+from `@yolk-sdk/knowledge/documents`:
+
+- `KnowledgeFileSource.make({ ref, name?, mediaType? })` — host-owned `ref` plus optional name/media type
+- `KnowledgeUrlSource.make({ url })` — host-owned URL string
+- `KnowledgeTextSource.make({ label? })` — optional label; bytes/text arrive through `LoadedKnowledgeSource.content`
+
+`IndexedKnowledgeDocument` is the search-index record. It carries `source`, indexing `status`, and
+optional title/summary/error/hash/count metadata. It is distinct from the content-oriented
+`KnowledgeDocument` managed through `KnowledgeStore`.
+
+Status and availability are independent:
+
+- `processing`: saved/indexing, not ready for prompt or search
+- `ready`: usable when availability allows
+- `error`: retained with an ingestion/indexing failure
+- `pinned`: host may include in startup context and search
+- `searchable`: host may expose through search
+- `archived`: retained but normally omitted from prompt and search
+
+These are contracts, not automatic policy. `buildKnowledgeContext` formats exactly the documents
+you pass; `searchKnowledge` delegates candidate filtering to `SearchIndexStore`. Hosts must select
+ready/pinned documents and exclude processing, error, or archived records as appropriate.
+
+`KnowledgeScope` and `KnowledgeSearchScope` are opaque, caller-provided routing metadata. Hosts
+construct and enforce them; the package does not infer identity, tenancy, or permissions from scope
+ids or kinds. The **value** `KnowledgeSearchScope` is the single-id constructor
+(`KnowledgeSearchScope.make({ id })`, tag `KnowledgeScope`). `KnowledgeSearchScopes.make({ ids })`
+is the non-empty-ids variant. The **type** `KnowledgeSearchScope` remains the union of both.
+Scope and document references use the branded `KnowledgeScopeId` and `KnowledgeDocumentId`
+(non-empty trimmed strings, same wire representation). Hosts Effect-decode raw external/persisted
+ids at their boundary and use `.make` for trusted constants and minted values.
 
 ## Subpaths
 
-| Subpath | Purpose |
-| --- | --- |
-| `@yolk-sdk/knowledge/records` | Knowledge record schemas and roles |
-| `@yolk-sdk/knowledge/artifacts` | Artifact catalog and blob-store contract |
-| `@yolk-sdk/knowledge/representations` | Agent-readable/searchable representations |
-| `@yolk-sdk/knowledge/chunking` | Search chunker contracts and defaults |
-| `@yolk-sdk/knowledge/embeddings` | Embedder contract and vector types |
-| `@yolk-sdk/knowledge/errors` | Shared knowledge error types |
-| `@yolk-sdk/knowledge/extraction` | Loaded source/extractor contract |
-| `@yolk-sdk/knowledge/ingestion` | Generic search ingestion pipeline |
-| `@yolk-sdk/knowledge/search` | Search interface, hybrid search, context packing |
-| `@yolk-sdk/knowledge/documents` | Collection, document, chunk, and search scope schemas |
-| `@yolk-sdk/knowledge/search-store` | Collection/document/chunk/search lifecycle store |
-| `@yolk-sdk/knowledge/vector-store` | Compatibility aliases for vector search/store types |
-| `@yolk-sdk/knowledge/summarization` | Optional title/summary service contract |
-| `@yolk-sdk/knowledge/provenance` | Source/provenance metadata |
-| `@yolk-sdk/knowledge/links` | Typed links between records |
-| `@yolk-sdk/knowledge/store` | Knowledge store lifecycle contract |
-| `@yolk-sdk/knowledge/context` | Context assembly helpers |
-| `@yolk-sdk/knowledge/agent` | Agent-facing helper contracts |
+| Subpath                             | Purpose                                                                |
+| ----------------------------------- | ---------------------------------------------------------------------- |
+| `@yolk-sdk/knowledge`               | Root context/store/file/error helpers                                  |
+| `@yolk-sdk/knowledge/documents`     | Document, source, file, chunk, status, availability, and scope schemas |
+| `@yolk-sdk/knowledge/files`         | File blob-store contract                                               |
+| `@yolk-sdk/knowledge/store`         | Document store and search-index store contracts                        |
+| `@yolk-sdk/knowledge/context`       | Pinned context builder                                                 |
+| `@yolk-sdk/knowledge/chunking`      | Text chunker contracts and defaults                                    |
+| `@yolk-sdk/knowledge/embeddings`    | Embedder contract and vector types                                     |
+| `@yolk-sdk/knowledge/extraction`    | Source/extractor contract                                              |
+| `@yolk-sdk/knowledge/ingestion`     | Extract/chunk/embed/summarize/index pipeline                           |
+| `@yolk-sdk/knowledge/search`        | Vector/hybrid chunk search helpers                                     |
+| `@yolk-sdk/knowledge/summarization` | Optional title/summary service contract                                |
+| `@yolk-sdk/knowledge/agent`         | `knowledge_lookup` and `knowledge_manage` tool factories               |
+| `@yolk-sdk/knowledge/errors`        | Shared error types                                                     |
 
 ## Imports
 
 ```ts
 import { buildKnowledgeContext, KnowledgeStore } from '@yolk-sdk/knowledge'
-import { KnowledgeRecord } from '@yolk-sdk/knowledge/records'
-import { KnowledgeArtifactStore } from '@yolk-sdk/knowledge/artifacts'
-import { makeDefaultKnowledgeChunker } from '@yolk-sdk/knowledge/chunking'
-import { searchKnowledge } from '@yolk-sdk/knowledge/search'
+import {
+  KnowledgeFileSource,
+  KnowledgeSearchScope,
+  KnowledgeSearchScopes,
+  KnowledgeTextSource,
+  KnowledgeUrlSource,
+  type KnowledgeDocument
+} from '@yolk-sdk/knowledge/documents'
+import { KnowledgeFileBlobStore } from '@yolk-sdk/knowledge/files'
+import { makeKnowledgeLookupTool, makeKnowledgeManageTool } from '@yolk-sdk/knowledge/agent'
 ```
 
-## Migration
-
-Search APIs use canonical search naming. Removed retrieval APIs are intentionally not backward-compatible.
-
-| Removed | Use |
-| --- | --- |
-| Retrieval subpath | `@yolk-sdk/knowledge/search` |
-| `KnowledgeRetriever` | `KnowledgeSearcher` |
-| `retrieve(input)` | `search(input)` |
-| `KnowledgeRetrievalError` | `KnowledgeSearchError` |
-
-## Glossary
-
-| Term | Meaning |
-| --- | --- |
-| Knowledge record | Stable logical thing an agent can know about. Domain-free; hosts decide product meaning. |
-| Artifact | Stored source/blob attached to knowledge, such as a file or captured output. |
-| Representation | Agent-readable or searchable form of knowledge, usually text plus metadata. |
-| Provenance | Source metadata explaining where knowledge came from and how it was produced. |
-| Link | Typed relationship between knowledge records. |
-| Context | Model-ready knowledge selected for a run. Built from host policy. |
-| Context policy | Host intent for use: `pinned`, `routable`, `searchable`, or `archived`. |
-| Search index | Searchable corpus built from source documents, chunks, embeddings, and metadata. |
-| Collection | Named searchable document group with shared embedding and chunking config. |
-| Document | Source item tracked through search ingestion: pending, processing, ready, or error. |
-| Source | Document origin: file ref, URL, or raw text. |
-| Chunk | Searchable slice of a document with position and token count. |
-| Embedding | Numeric vector for semantic search. Hosts provide the embedding provider. |
-| Chunker | Service that splits extracted text into chunks. |
-| Extractor | Service that loads source content into text/title/summary/metadata. |
-| Ingestion | Pipeline that extracts, chunks, embeds, stores chunks, and marks document status. |
-| Search | Query-time search over search chunks, optionally packed into context text. |
-| Hybrid search | Search mode that fuses vector and text search rankings. |
-| Search scope | Caller-provided collection or collections to search. Package does not interpret tenant semantics. |
-| Search index store | Persistence contract for collections, documents, chunks, status, and search. |
-| Vector store | Compatibility naming over search-store chunk search contracts. |
-| Knowledge store | Persistence contract for non-index knowledge records and context assembly. |
-| Artifact store | Persistence contract for artifact bytes/metadata. |
-| Host | App using the package; owns auth, DB, object storage, providers, permissions, and policy. |
-
-## Context policy
-
-| Policy | Meaning |
-| --- | --- |
-| `pinned` | Host may inject into model startup context |
-| `routable` | Host may use for routing/dispatch decisions |
-| `searchable` | Host may expose through search tools |
-| `archived` | Retained but normally omitted from active context/search |
+## Use pinned knowledge as context
+
+```ts
+import { buildKnowledgeContext } from '@yolk-sdk/knowledge/context'
+
+const context = buildKnowledgeContext({
+  documents,
+  maxCharacters: 6000
+})
+```
+
+Add the resulting text to your system prompt. Your app chooses which documents are pinned.
+
+## Agent tools
+
+`makeKnowledgeLookupTool` creates the read-only `knowledge_lookup` tool with `search` and `get`
+operations. `makeKnowledgeManageTool` creates the write-classified `knowledge_manage` tool with
+`upsert`, `set_availability`, `rename_slug`, and `delete` operations.
+
+```ts
+import { makeKnowledgeLookupTool, makeKnowledgeManageTool } from '@yolk-sdk/knowledge/agent'
+
+const lookupTool = makeKnowledgeLookupTool({ search: searchKnowledge, get: getKnowledge })
+const manageTool = makeKnowledgeManageTool({
+  upsert: upsertKnowledge,
+  setAvailability: setKnowledgeAvailability,
+  renameSlug: renameKnowledgeSlug,
+  delete: deleteKnowledge
+})
+```
+
+The callbacks are host adapters and receive the agent tool context. Hosts own authorization,
+storage, scope enforcement, and safe `ToolError` mapping.
+
+Both tools declare an output (`KnowledgeLookupOutput`, `KnowledgeManageOutput`) and return its JSON
+encoding as `structuredContent` (dates as ISO strings) next to the text, so code mode scripts get
+`{ operation: 'search', results }`, `{ operation: 'get', document }`, or
+`{ operation, document: { id, slug, title } }`. A handler value that does not encode fails the call
+with an `execution` `ToolError`. Unknown argument keys are model-visible validation errors with a
+hint naming the allowed keys, not stripped.
+
+## Ingestion semantics
+
+`ingestKnowledgeDocument` upserts a `processing` index record, extracts, chunks, embeds and
+summarizes concurrently, checks embedding cardinality, calls `replaceDocumentChunks`, then marks
+the index record `ready`.
+
+`DefaultKnowledgeChunkerLive` uses the bundled `gpt-tokenizer` `o200k_base` encoding for default
+chunk boundaries and token counts. Hosts can provide another `KnowledgeChunker` layer when they
+need model-specific tokenization.
+
+Failures are returned as `KnowledgeIngestionError` with a `store`, `extract`, `chunk`, `embed`, or
+`summarize` stage. The pipeline then best-effort calls `markDocumentError` with the error message;
+failure to mark the error is suppressed so the original failure survives.
+
+The pipeline is not a transaction and does not update `KnowledgeStore`. The host
+`SearchIndexStore` adapter owns atomic chunk replacement, rollback/transaction behavior, ready/error
+filtering, and any coordination with the content document store.
 
 ## Host responsibilities
 
-- Own users, teams, permissions, routing, and product policy.
-- Implement `KnowledgeStore` and `KnowledgeArtifactStore` with app storage.
-- Own concrete extraction, embeddings, search ingestion, R2/S3 layout, and DB schema.
-- Decide which knowledge is pinned, searchable, routable, or archived.
+- Own users, workspaces, permissions, routing, and product policy.
+- Implement `KnowledgeStore` with app storage.
+- Implement `KnowledgeFileBlobStore` with R2/S3/blob storage when files are needed.
+- When using ingestion, provide `KnowledgeExtractor`, `KnowledgeChunker`, `KnowledgeEmbedder`,
+  `KnowledgeSummarizer`, and `SearchIndexStore` layers. Summary/title values may be absent, but the
+  current pipeline still requires the summarizer service.
+- Own concrete extraction, embeddings, search SQL/vector storage, and upload URLs.
+  `@yolk-sdk/extractors/knowledge` provides a `KnowledgeExtractor` for PDF, DOCX, XLSX, PPTX, and
+  text files (`FileKnowledgeExtractorLayer`) on top of its Node `FileExtractor`.
+- Keep slug uniqueness scoped to the host boundary.
 
 ## Boundaries
 
 - No app auth, DB drivers, object storage SDKs, React, Next.js, or provider SDKs.
-- Search/chunking APIs are exposed as flat knowledge subpaths; concrete stores and providers remain app-owned.
-- Package owns semantics and contracts only.
+- Package owns simple schemas, contracts, context formatting, tool factories, chunking, and search helpers.
+- Host owns all IO and policy.

package/dist/agent.d.mts

@@ -1,26 +1,129 @@
-import { KnowledgeScope } from "./records.mjs";
-import { KnowledgeSearchScope } from "./documents.mjs";
-import { KnowledgeSearcher } from "./search.mjs";
+import { KnowledgeAvailability, KnowledgeDocument } from "./documents.mjs";
 import { Effect } from "effect";
+import * as Schema from "effect/Schema";
 import { ToolError } from "@yolk-sdk/agent/loop";
 import { ToolRegistration } from "@yolk-sdk/agent/tools";
 
 //#region src/agent.d.ts
-type ResolveKnowledgeScope<Context> = (context: Context) => KnowledgeScope;
-type KnowledgeAgentContextOptions = {
-  readonly maxPinnedContextCharacters: number;
+/** Declared output of `makeKnowledgeLookupTool`; `structuredContent` is its JSON encoding
+ * (`Schema.toCodecJson`: document dates become ISO strings). */
+declare const KnowledgeLookupOutput: Schema.Union<readonly [Schema.Struct<{
+  readonly operation: Schema.Literal<"search">;
+  readonly results: Schema.$Array<Schema.Struct<{
+    readonly document: Schema.Struct<{
+      readonly id: Schema.brand<Schema.Trimmed, "KnowledgeDocumentId">;
+      readonly slug: Schema.Trimmed;
+      readonly title: Schema.Trimmed;
+      readonly purpose: Schema.Trimmed;
+      readonly origin: Schema.Trimmed;
+      readonly content: Schema.Trimmed;
+      readonly status: Schema.Literals<readonly ["processing", "ready", "error"]>;
+      readonly availability: Schema.Literals<readonly ["pinned", "searchable", "archived"]>;
+      readonly summary: Schema.optional<Schema.String>;
+      readonly errorMessage: Schema.optional<Schema.String>;
+      readonly reviewedAt: Schema.optional<Schema.DateTimeUtc>;
+      readonly metadata: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+      readonly createdAt: Schema.DateTimeUtc;
+      readonly updatedAt: Schema.DateTimeUtc;
+    }>;
+    readonly score: Schema.optionalKey<Schema.Number>;
+    readonly context: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+      readonly content: Schema.String;
+    }>>>;
+  }>>;
+}>, Schema.Struct<{
+  readonly operation: Schema.Literal<"get">;
+  readonly document: Schema.Struct<{
+    readonly id: Schema.brand<Schema.Trimmed, "KnowledgeDocumentId">;
+    readonly slug: Schema.Trimmed;
+    readonly title: Schema.Trimmed;
+    readonly purpose: Schema.Trimmed;
+    readonly origin: Schema.Trimmed;
+    readonly content: Schema.Trimmed;
+    readonly status: Schema.Literals<readonly ["processing", "ready", "error"]>;
+    readonly availability: Schema.Literals<readonly ["pinned", "searchable", "archived"]>;
+    readonly summary: Schema.optional<Schema.String>;
+    readonly errorMessage: Schema.optional<Schema.String>;
+    readonly reviewedAt: Schema.optional<Schema.DateTimeUtc>;
+    readonly metadata: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+    readonly createdAt: Schema.DateTimeUtc;
+    readonly updatedAt: Schema.DateTimeUtc;
+  }>;
+}>]>;
+type KnowledgeLookupOutput = typeof KnowledgeLookupOutput.Type;
+/** Declared output of `makeKnowledgeManageTool`; `structuredContent` is its JSON encoding. */
+declare const KnowledgeManageOutput: Schema.Struct<{
+  readonly operation: Schema.Literals<readonly ["upsert", "set_availability", "rename_slug", "delete"]>;
+  readonly document: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly slug: Schema.String;
+    readonly title: Schema.String;
+  }>;
+}>;
+type KnowledgeManageOutput = typeof KnowledgeManageOutput.Type;
+type KnowledgeTarget = {
+  readonly slug: string;
+  readonly scope?: string;
 };
-declare const defaultKnowledgeAgentContextOptions: KnowledgeAgentContextOptions;
-type KnowledgeSearchToolScopeResolver<Context> = KnowledgeSearchScope | ((context: Context) => Effect.Effect<KnowledgeSearchScope, ToolError>);
-type MakeKnowledgeSearchToolOptions<Context> = {
-  readonly scope: KnowledgeSearchToolScopeResolver<Context>;
+type KnowledgeLookupResult = {
+  readonly document: KnowledgeDocument;
+  readonly score?: number;
+  readonly context?: ReadonlyArray<{
+    readonly content: string;
+  }>;
+};
+type KnowledgeSavedDocument = {
+  readonly id: string;
+  readonly slug: string;
+  readonly title: string;
+};
+type KnowledgeLookupHandlers<Context> = {
+  readonly search: (input: {
+    readonly context: Context;
+    readonly query: string;
+    readonly limit?: number;
+    readonly minScore?: number;
+    readonly contextChunks?: number;
+  }) => Effect.Effect<ReadonlyArray<KnowledgeLookupResult>, ToolError>;
+  readonly get: (input: {
+    readonly context: Context;
+    readonly id?: string;
+    readonly target?: KnowledgeTarget;
+  }) => Effect.Effect<KnowledgeDocument, ToolError>;
+};
+type KnowledgeManageHandlers<Context> = {
+  readonly upsert: (input: {
+    readonly context: Context;
+    readonly target: KnowledgeTarget;
+    readonly title: string;
+    readonly purpose: string;
+    readonly origin: string;
+    readonly content: string;
+    readonly availability: KnowledgeAvailability;
+  }) => Effect.Effect<KnowledgeSavedDocument, ToolError>;
+  readonly setAvailability: (input: {
+    readonly context: Context;
+    readonly target: KnowledgeTarget;
+    readonly availability: KnowledgeAvailability;
+  }) => Effect.Effect<KnowledgeSavedDocument, ToolError>;
+  readonly renameSlug: (input: {
+    readonly context: Context;
+    readonly target: KnowledgeTarget;
+    readonly nextSlug: string;
+  }) => Effect.Effect<KnowledgeSavedDocument, ToolError>;
+  readonly delete: (input: {
+    readonly context: Context;
+    readonly target: KnowledgeTarget;
+  }) => Effect.Effect<KnowledgeSavedDocument, ToolError>;
+};
+declare const makeKnowledgeLookupTool: <Context>(handlers: KnowledgeLookupHandlers<Context>, options?: {
   readonly name?: string;
   readonly description?: string;
-  readonly limit?: number;
-  readonly minScore?: number;
-  readonly contextChunks?: number;
-};
-declare const makeKnowledgeSearchTool: <Context>(searcher: KnowledgeSearcher, options: MakeKnowledgeSearchToolOptions<Context>) => ToolRegistration<Context>;
+}) => ToolRegistration<Context>;
+declare const makeKnowledgeManageTool: <Context>(handlers: KnowledgeManageHandlers<Context>, options?: {
+  readonly name?: string;
+  readonly description?: string;
+}) => ToolRegistration<Context>;
 //#endregion
-export { KnowledgeAgentContextOptions, KnowledgeSearchToolScopeResolver, MakeKnowledgeSearchToolOptions, ResolveKnowledgeScope, defaultKnowledgeAgentContextOptions, makeKnowledgeSearchTool };
+export { KnowledgeLookupHandlers, KnowledgeLookupOutput, KnowledgeLookupResult, KnowledgeManageHandlers, KnowledgeManageOutput, KnowledgeSavedDocument, KnowledgeTarget, makeKnowledgeLookupTool, makeKnowledgeManageTool };
 //# sourceMappingURL=agent.d.mts.map

package/dist/agent.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"agent.d.mts","names":[],"sources":["../src/agent.ts"],"mappings":";;;;;;;;KAUY,qBAAA,aAAkC,OAAA,EAAS,OAAA,KAAY,cAAc;AAAA,KAErE,4BAAA;EAAA,SACD,0BAA0B;AAAA;AAAA,cAGxB,mCAAA,EAAqC,4BAEjD;AAAA,KAWW,gCAAA,YACR,oBAAA,KACE,OAAA,EAAS,OAAA,KAAY,MAAA,CAAO,MAAA,CAAO,oBAAA,EAAsB,SAAA;AAAA,KAEnD,8BAAA;EAAA,SACD,KAAA,EAAO,gCAAgC,CAAC,OAAA;EAAA,SACxC,IAAA;EAAA,SACA,WAAA;EAAA,SACA,KAAA;EAAA,SACA,QAAA;EAAA,SACA,aAAA;AAAA;AAAA,cAWE,uBAAA,YACX,QAAA,EAAU,iBAAA,EACV,OAAA,EAAS,8BAAA,CAA+B,OAAA,MACvC,gBAAA,CAAiB,OAAA"}
+{"version":3,"file":"agent.d.mts","names":[],"sources":["../src/agent.ts"],"mappings":";;;;;;;;;cA6Ea,qBAAA,EAAqB,MAAA,CAAA,KAAA,WAAA,MAAA,CAAA,MAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAWtB,qBAAA,UAA+B,qBAAA,CAAsB,IAAI;;cAGxD,qBAAA,EAAqB,MAAA,CAAA,MAAA;EAAA;;;;;;;KAKtB,qBAAA,UAA+B,qBAAA,CAAsB,IAAI;AAAA,KAqBzD,eAAA;EAAA,SACD,IAAA;EAAA,SACA,KAAK;AAAA;AAAA,KAGJ,qBAAA;EAAA,SACD,QAAA,EAAU,iBAAA;EAAA,SACV,KAAA;EAAA,SACA,OAAA,GAAU,aAAa;IAAA,SAAY,OAAA;EAAA;AAAA;AAAA,KAGlC,sBAAA;EAAA,SACD,EAAA;EAAA,SACA,IAAA;EAAA,SACA,KAAA;AAAA;AAAA,KAGC,uBAAA;EAAA,SACD,MAAA,GAAS,KAAA;IAAA,SACP,OAAA,EAAS,OAAA;IAAA,SACT,KAAA;IAAA,SACA,KAAA;IAAA,SACA,QAAA;IAAA,SACA,aAAA;EAAA,MACL,MAAA,CAAO,MAAA,CAAO,aAAA,CAAc,qBAAA,GAAwB,SAAA;EAAA,SACjD,GAAA,GAAM,KAAA;IAAA,SACJ,OAAA,EAAS,OAAA;IAAA,SACT,EAAA;IAAA,SACA,MAAA,GAAS,eAAA;EAAA,MACd,MAAA,CAAO,MAAA,CAAO,iBAAA,EAAmB,SAAA;AAAA;AAAA,KAG7B,uBAAA;EAAA,SACD,MAAA,GAAS,KAAA;IAAA,SACP,OAAA,EAAS,OAAA;IAAA,SACT,MAAA,EAAQ,eAAA;IAAA,SACR,KAAA;IAAA,SACA,OAAA;IAAA,SACA,MAAA;IAAA,SACA,OAAA;IAAA,SACA,YAAA,EAAc,qBAAA;EAAA,MACnB,MAAA,CAAO,MAAA,CAAO,sBAAA,EAAwB,SAAA;EAAA,SACnC,eAAA,GAAkB,KAAA;IAAA,SAChB,OAAA,EAAS,OAAA;IAAA,SACT,MAAA,EAAQ,eAAA;IAAA,SACR,YAAA,EAAc,qBAAA;EAAA,MACnB,MAAA,CAAO,MAAA,CAAO,sBAAA,EAAwB,SAAA;EAAA,SACnC,UAAA,GAAa,KAAA;IAAA,SACX,OAAA,EAAS,OAAA;IAAA,SACT,MAAA,EAAQ,eAAA;IAAA,SACR,QAAA;EAAA,MACL,MAAA,CAAO,MAAA,CAAO,sBAAA,EAAwB,SAAA;EAAA,SACnC,MAAA,GAAS,KAAA;IAAA,SACP,OAAA,EAAS,OAAA;IAAA,SACT,MAAA,EAAQ,eAAA;EAAA,MACb,MAAA,CAAO,MAAA,CAAO,sBAAA,EAAwB,SAAA;AAAA;AAAA,cA2FjC,uBAAA,YACX,QAAA,EAAU,uBAAA,CAAwB,OAAA,GAClC,OAAA;EAAA,SAAoB,IAAA;EAAA,SAAwB,WAAA;AAAA,MAC3C,gBAAA,CAAiB,OAAA;AAAA,cA0DP,uBAAA,YACX,QAAA,EAAU,uBAAA,CAAwB,OAAA,GAClC,OAAA;EAAA,SAAoB,IAAA;EAAA,SAAwB,WAAA;AAAA,MAC3C,gBAAA,CAAiB,OAAA"}