@oscharko-dev/keiko-server 0.2.0

package/dist/editor/codingContextProviders.js

@@ -0,0 +1,348 @@
+// Governed coding-context providers (Issue #1211, ADR-0042 D6). Each provider wraps an EXISTING
+// retrieval seam and returns redacted, byte-bounded excerpt candidates plus a content-free omission
+// when the source is unavailable, not-ready, denied, or excluded for the request's purpose. No
+// provider invents retrieval logic: repo-search reuses keiko-workspace `searchText`/`readExcerpt`,
+// Local Knowledge reuses the query-only `runLocalKnowledgeRetrieval` path (no answer generation), and
+// memory reuses the `retrieveMemoryContext` pipeline already wired for /api/memory/context. Retrieved
+// text is untrusted model input (OWASP LLM08/LLM01): every candidate is tagged with its source tier
+// (by the orchestrator) and stripped of unsafe format characters before it can reach a model or the
+// harness.
+import { stripUnsafeFormatChars, } from "@oscharko-dev/keiko-contracts";
+import { DEFAULT_SEARCH_LIMITS, detectWorkspaceAt, readExcerpt, searchText, } from "@oscharko-dev/keiko-workspace";
+import { nodeWorkspaceFs } from "@oscharko-dev/keiko-workspace/internal/fs";
+import { readCitationExcerpt } from "@oscharko-dev/keiko-local-knowledge";
+import { retrieveMemoryContext } from "@oscharko-dev/keiko-memory-retrieval";
+import { memoryTextEgressRejectionReason } from "@oscharko-dev/keiko-memory-capture";
+import { openStoreForDeps } from "../local-knowledge-grounded-qa.js";
+import { vaultAsQueryPort } from "../memory-conv-handlers.js";
+import { LOCAL_CONVERSATION_MEMORY_USER_ID } from "../memory-conversation-context.js";
+import { memoryCapturePolicyForDeps } from "../memory-capture-policy.js";
+import { buildConversationRetrievalSignals, conversationFusionMode, } from "../memory-retrieval-signals.js";
+import { buildLocalKnowledgeScope, retrieveEditorLocalKnowledge, } from "./localKnowledgeRetrieval.js";
+const REPO_SEARCH_MAX_HITS = 6;
+const FILES_FOCUS_MAX_LINES = 240;
+const FILES_FOCUS_MAX_CHANGED_FILES = 4;
+const LOCAL_KNOWLEDGE_MAX_REFERENCES = 8;
+const MEMORY_MAX_ENTRIES = 8;
+const MAX_CITATION_REF_CHARS = 160;
+function basename(scopePath) {
+    const parts = scopePath.split("/");
+    return parts[parts.length - 1] ?? scopePath;
+}
+// strip-then-redact, mirroring grounded-qa redactString: format-char stripping first (GRD-001)
+// prevents Trojan-source splits from confusing the redactor; the redactor then removes secrets.
+function redactExcerpt(deps, text) {
+    return String(deps.redactor(stripUnsafeFormatChars(text)));
+}
+function sanitizeCitationRef(ctx, citationRef) {
+    if (citationRef === undefined) {
+        return undefined;
+    }
+    const redacted = String(ctx.deps.redactor(stripUnsafeFormatChars(citationRef)));
+    let out = "";
+    let pendingSpace = false;
+    for (const char of redacted) {
+        const code = char.codePointAt(0) ?? 0;
+        if (code <= 0x20 || code === 0x7f) {
+            pendingSpace = out.length > 0;
+            continue;
+        }
+        if (pendingSpace) {
+            out += " ";
+            pendingSpace = false;
+        }
+        out += char;
+        if (out.length >= MAX_CITATION_REF_CHARS) {
+            break;
+        }
+    }
+    const trimmed = out.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+}
+// UTF-8-safe byte clamp (no multi-byte split).
+function clampToBytes(text, maxBytes) {
+    if (maxBytes <= 0) {
+        return { text: "", truncated: true };
+    }
+    const encoded = new TextEncoder().encode(text);
+    if (encoded.length <= maxBytes) {
+        return { text, truncated: false };
+    }
+    const decoded = new TextDecoder("utf-8", { fatal: false })
+        .decode(encoded.subarray(0, maxBytes))
+        .replace(/�+$/u, "");
+    return { text: decoded, truncated: true };
+}
+function prepareExcerpt(ctx, raw) {
+    const redacted = redactExcerpt(ctx.deps, raw.text);
+    const clamped = clampToBytes(redacted, ctx.maxBytesPerExcerpt);
+    if (clamped.text.length === 0) {
+        return undefined;
+    }
+    return {
+        sourceKind: raw.sourceKind,
+        id: raw.id,
+        score: raw.score,
+        citationRef: sanitizeCitationRef(ctx, raw.citationRef),
+        text: clamped.text,
+        // truncated if the upstream read clamped OR our per-excerpt cap clamped.
+        truncated: (raw.truncated ?? false) || clamped.truncated,
+    };
+}
+function omission(sourceKind, reason) {
+    return { sourceKind, reason };
+}
+function buildScope(realRoot, relativePaths) {
+    return {
+        workspace: detectWorkspaceAt(realRoot, nodeWorkspaceFs),
+        scopeId: "editor-coding-context",
+        relativePaths,
+    };
+}
+function buildQuery(text, symbol, nowMs) {
+    return {
+        kind: symbol !== undefined ? "exact-symbol" : "natural-language",
+        text,
+        caseSensitive: false,
+        maxResults: REPO_SEARCH_MAX_HITS,
+        emittedAtMs: nowMs,
+    };
+}
+async function readHitExcerpt(signal, scope, atom, maxBytes) {
+    const startLine = atom.lineRange?.startLine ?? 1;
+    const endLine = atom.lineRange?.endLine ?? startLine;
+    try {
+        const result = await readExcerpt(scope, {
+            scopePath: atom.scopePath,
+            startLine,
+            endLine,
+            maxBytes,
+        }, { signal });
+        return { content: result.content, truncated: result.truncated };
+    }
+    catch {
+        return undefined;
+    }
+}
+// AbortSignal.aborted is a live getter that can flip true across an await, but TS narrows it to
+// `false` after an early-return guard. Reading it through this helper defeats that narrowing so the
+// cooperative cancellation checks stay live (and lint-clean).
+function isAborted(signal) {
+    return signal.aborted;
+}
+// ─── files-focus + repo-search provider ─────────────────────────────────────────────
+// Grounds the model in the active document and the top lexical hits for the symbol/query, all from
+// the contained workspace via the governed keiko-workspace facade (deny/realpath/size enforced there).
+async function readFocusExcerpt(ctx, scope, documentPath, score = 1) {
+    try {
+        const focus = await readExcerpt(scope, {
+            scopePath: documentPath,
+            startLine: 1,
+            endLine: FILES_FOCUS_MAX_LINES,
+            maxBytes: ctx.maxBytesPerExcerpt,
+        }, { signal: ctx.signal });
+        return prepareExcerpt(ctx, {
+            sourceKind: "files-focus",
+            id: focus.atom.stableId,
+            score,
+            citationRef: basename(documentPath),
+            text: focus.content,
+            truncated: focus.truncated,
+        });
+    }
+    catch {
+        return "denied";
+    }
+}
+async function searchHitExcerpts(ctx, scope, term, symbol) {
+    let hits;
+    try {
+        hits = await searchText(scope, buildQuery(term, symbol, ctx.nowMs), DEFAULT_SEARCH_LIMITS, {
+            signal: ctx.signal,
+        });
+    }
+    catch {
+        return "unavailable";
+    }
+    const excerpts = [];
+    for (const atom of hits.atoms.slice(0, REPO_SEARCH_MAX_HITS)) {
+        if (isAborted(ctx.signal)) {
+            break;
+        }
+        const hit = await readHitExcerpt(ctx.signal, scope, atom, ctx.maxBytesPerExcerpt);
+        if (hit === undefined) {
+            continue;
+        }
+        const prepared = prepareExcerpt(ctx, {
+            sourceKind: "repo-search",
+            id: atom.stableId,
+            score: atom.score,
+            citationRef: basename(atom.scopePath),
+            text: hit.content,
+            truncated: hit.truncated,
+        });
+        if (prepared !== undefined) {
+            excerpts.push(prepared);
+        }
+    }
+    return excerpts;
+}
+async function readFocusExcerpts(ctx, scope, documentPath, changedFiles) {
+    const focus = await readFocusExcerpt(ctx, scope, documentPath);
+    if (focus === "denied") {
+        return "denied";
+    }
+    const excerpts = focus !== undefined ? [focus] : [];
+    for (const changed of (changedFiles ?? []).slice(0, FILES_FOCUS_MAX_CHANGED_FILES)) {
+        if (changed === documentPath || isAborted(ctx.signal)) {
+            continue;
+        }
+        const changedFocus = await readFocusExcerpt(ctx, scope, changed, 0.85);
+        if (changedFocus !== undefined && changedFocus !== "denied") {
+            excerpts.push(changedFocus);
+        }
+    }
+    return excerpts;
+}
+export async function runRepoSearchProvider(ctx, input) {
+    if (isAborted(ctx.signal)) {
+        return { excerpts: [], omission: omission("repo-search", "unavailable") };
+    }
+    const focusPaths = [input.documentPath, ...(input.changedFiles ?? [])];
+    const focusScope = buildScope(ctx.realRoot, focusPaths);
+    const searchScope = buildScope(ctx.realRoot, []);
+    const excerpts = await readFocusExcerpts(ctx, focusScope, input.documentPath, input.changedFiles);
+    if (excerpts === "denied") {
+        return { excerpts: [], omission: omission("files-focus", "denied") };
+    }
+    const term = input.symbol ?? input.queryText ?? basename(input.documentPath);
+    if (term.trim().length === 0 || isAborted(ctx.signal)) {
+        return { excerpts, omission: undefined };
+    }
+    const hits = await searchHitExcerpts(ctx, searchScope, term, input.symbol);
+    if (hits === "unavailable") {
+        return { excerpts, omission: omission("repo-search", "unavailable") };
+    }
+    return { excerpts: [...excerpts, ...hits], omission: undefined };
+}
+// ─── Local Knowledge provider (query-only, no answer generation) ─────────────────────
+function localKnowledgeExcerpts(ctx, store, references) {
+    const excerpts = [];
+    for (const reference of references.slice(0, LOCAL_KNOWLEDGE_MAX_REFERENCES)) {
+        if (isAborted(ctx.signal)) {
+            break;
+        }
+        const text = readCitationExcerpt(store, reference.capsuleId, reference.citation);
+        const prepared = prepareExcerpt(ctx, {
+            sourceKind: "local-knowledge",
+            id: reference.chunkId,
+            score: reference.score,
+            citationRef: reference.citation.safeDisplayName,
+            text,
+        });
+        if (prepared !== undefined) {
+            excerpts.push(prepared);
+        }
+    }
+    return excerpts;
+}
+export async function runLocalKnowledgeProvider(ctx, input) {
+    const query = input.queryText;
+    if (query === undefined || query.trim().length === 0) {
+        return { excerpts: [], omission: omission("local-knowledge", "unavailable") };
+    }
+    const scope = buildLocalKnowledgeScope(input.capsuleId, input.capsuleSetId);
+    if (scope === undefined) {
+        return { excerpts: [], omission: omission("local-knowledge", "unavailable") };
+    }
+    let env;
+    try {
+        env = openStoreForDeps(ctx.deps);
+    }
+    catch {
+        return { excerpts: [], omission: omission("local-knowledge", "unavailable") };
+    }
+    try {
+        const outcome = await retrieveEditorLocalKnowledge(ctx.deps, env.store, scope, query, ctx.signal);
+        if (outcome.kind === "conflict") {
+            return { excerpts: [], omission: omission("local-knowledge", "denied") };
+        }
+        if (outcome.kind === "not-ready" || outcome.noEvidence) {
+            return { excerpts: [], omission: omission("local-knowledge", "not-ready") };
+        }
+        return {
+            excerpts: localKnowledgeExcerpts(ctx, env.store, outcome.references),
+            omission: undefined,
+        };
+    }
+    catch {
+        return { excerpts: [], omission: omission("local-knowledge", "unavailable") };
+    }
+    finally {
+        env.close();
+    }
+}
+// ─── Memory provider (query-only, reuses retrieveMemoryContext) ───────────────────────
+function editorMemoryScopes(realRoot) {
+    return [
+        { kind: "workspace", workspaceId: realRoot },
+        { kind: "project", projectId: realRoot },
+        { kind: "user", userId: LOCAL_CONVERSATION_MEMORY_USER_ID },
+        { kind: "global" },
+    ];
+}
+async function runMemoryRetrieval(ctx, vault, queryText, scopes) {
+    if (isAborted(ctx.signal)) {
+        throw new Error("memory retrieval aborted");
+    }
+    // Embedding egress gate (#204 O-F4): never send a secret-shaped query to the secondary embedding
+    // model — identical to the conversation memory path.
+    const safeForSecondaryModel = queryText === undefined ||
+        memoryTextEgressRejectionReason(queryText, memoryCapturePolicyForDeps(ctx.deps)) === null;
+    const signals = await buildConversationRetrievalSignals(ctx.deps, vault, queryText, scopes, ctx.nowMs, safeForSecondaryModel, ctx.signal);
+    if (isAborted(ctx.signal)) {
+        throw new Error("memory retrieval aborted");
+    }
+    return retrieveMemoryContext({
+        scopes,
+        nowMs: ctx.nowMs,
+        maxIncluded: MEMORY_MAX_ENTRIES,
+        budgetTokens: Math.max(1, Math.ceil((ctx.maxBytesPerExcerpt * MEMORY_MAX_ENTRIES) / 4)),
+        ...(queryText !== undefined ? { queryText } : {}),
+        fusion: conversationFusionMode(ctx.deps),
+        ...(signals.semanticById !== undefined ? { semanticById: signals.semanticById } : {}),
+        ...(signals.strengthById.size > 0 ? { strengthById: signals.strengthById } : {}),
+        ...(signals.embeddingById.size > 0 ? { embeddingById: signals.embeddingById } : {}),
+    }, vaultAsQueryPort(vault));
+}
+function memoryExcerpts(ctx, result) {
+    const scoreById = new Map(result.included.map((item) => [item.memoryId, item.score]));
+    const excerpts = [];
+    for (const entry of result.contextBlock.memories.slice(0, MEMORY_MAX_ENTRIES)) {
+        const prepared = prepareExcerpt(ctx, {
+            sourceKind: "memory",
+            id: entry.memoryId,
+            score: scoreById.get(entry.memoryId) ?? entry.confidence,
+            citationRef: entry.inclusionReason,
+            text: entry.bodyExcerpt,
+        });
+        if (prepared !== undefined) {
+            excerpts.push(prepared);
+        }
+    }
+    return excerpts;
+}
+export async function runMemoryProvider(ctx, input) {
+    const vault = ctx.deps.memoryVault;
+    if (vault === undefined) {
+        return { excerpts: [], omission: omission("memory", "unavailable") };
+    }
+    let result;
+    try {
+        result = await runMemoryRetrieval(ctx, vault, input.queryText, editorMemoryScopes(ctx.realRoot));
+    }
+    catch {
+        return { excerpts: [], omission: omission("memory", "unavailable") };
+    }
+    return { excerpts: memoryExcerpts(ctx, result), omission: undefined };
+}

package/dist/editor/completionModelEvidence.d.ts

@@ -0,0 +1,16 @@
+import type { CompletionInteractionMode, UsageMetadata } from "@oscharko-dev/keiko-contracts";
+import type { EvidenceStore } from "@oscharko-dev/keiko-contracts";
+import type { Redactor } from "../deps.js";
+export declare const EDITOR_COMPLETION_MODEL_EVIDENCE_SCHEMA_VERSION: "1";
+export interface EditorCompletionModelEvidenceInput {
+    readonly modelId: string;
+    readonly modelMode: CompletionInteractionMode;
+    readonly latencyClass: string | undefined;
+    readonly gatewayPolicyVersion: string;
+    readonly promptHash: string;
+    readonly itemCount: number;
+    readonly truncated: boolean;
+    readonly usage: UsageMetadata | undefined;
+}
+export declare function recordEditorCompletionModelEvidence(store: EvidenceStore, redactor: Redactor, input: EditorCompletionModelEvidenceInput, emittedAtMs: number): string;
+//# sourceMappingURL=completionModelEvidence.d.ts.map

package/dist/editor/completionModelEvidence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"completionModelEvidence.d.ts","sourceRoot":"","sources":["../../src/editor/completionModelEvidence.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EACV,yBAAyB,EACzB,aAAa,EACd,MAAM,+BAA+B,CAAC;AACvC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AACnE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE3C,eAAO,MAAM,+CAA+C,EAAG,GAAY,CAAC;AAE5E,MAAM,WAAW,kCAAkC;IACjD,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,SAAS,EAAE,yBAAyB,CAAC;IAC9C,QAAQ,CAAC,YAAY,EAAE,MAAM,GAAG,SAAS,CAAC;IAC1C,QAAQ,CAAC,oBAAoB,EAAE,MAAM,CAAC;IACtC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B,QAAQ,CAAC,KAAK,EAAE,aAAa,GAAG,SAAS,CAAC;CAC3C;AAkBD,wBAAgB,mCAAmC,CACjD,KAAK,EAAE,aAAa,EACpB,QAAQ,EAAE,QAAQ,EAClB,KAAK,EAAE,kCAAkC,EACzC,WAAW,EAAE,MAAM,GAClB,MAAM,CA+BR"}

package/dist/editor/completionModelEvidence.js

@@ -0,0 +1,50 @@
+// Content-free audit linkage for governed editor completion model calls (Issue #1199). The record
+// carries only model ids, policy/version ids, prompt hash, item counts, and Gateway usage metadata.
+// It never persists prompts, overlay text, retrieved context, or generated insert text.
+import { createHash } from "node:crypto";
+export const EDITOR_COMPLETION_MODEL_EVIDENCE_SCHEMA_VERSION = "1";
+function completionModelEvidenceRunId(input, emittedAtMs) {
+    const material = [
+        input.modelId,
+        input.modelMode,
+        input.gatewayPolicyVersion,
+        input.promptHash,
+        String(emittedAtMs),
+        input.usage?.requestId ?? "no-gateway-request",
+    ].join("\n");
+    const digest = createHash("sha256").update(material).digest("hex").slice(0, 16);
+    return `editor-completion-model-${digest}`;
+}
+export function recordEditorCompletionModelEvidence(store, redactor, input, emittedAtMs) {
+    const runId = completionModelEvidenceRunId(input, emittedAtMs);
+    const manifest = {
+        editorCompletionModelSchemaVersion: EDITOR_COMPLETION_MODEL_EVIDENCE_SCHEMA_VERSION,
+        runId,
+        emittedAtMs,
+        modelId: input.modelId,
+        modelMode: input.modelMode,
+        latencyClass: input.latencyClass,
+        gatewayPolicyVersion: input.gatewayPolicyVersion,
+        promptHash: input.promptHash,
+        itemCount: input.itemCount,
+        truncated: input.truncated,
+        ...(input.usage === undefined
+            ? {}
+            : {
+                usage: {
+                    requestId: input.usage.requestId,
+                    promptTokens: input.usage.promptTokens,
+                    completionTokens: input.usage.completionTokens,
+                    latencyMs: input.usage.latencyMs,
+                    costClass: input.usage.costClass,
+                },
+            }),
+    };
+    try {
+        store.put(runId, JSON.stringify(redactor(manifest)));
+    }
+    catch {
+        // Evidence persistence is best-effort; a write failure must not break editing.
+    }
+    return runId;
+}

package/dist/editor/completionRoutes.d.ts

@@ -0,0 +1,37 @@
+import { type LanguageServiceLimits } from "@oscharko-dev/keiko-contracts";
+import type { GatewayConfig } from "@oscharko-dev/keiko-model-gateway";
+import { type RouteContext, type RouteResult } from "../routes.js";
+import { type UiHandlerDeps } from "../deps.js";
+import { type ModelChatFn } from "./editorCompletionModel.js";
+import { type EditorModelTokenBudget } from "./editorModelTokenBudget.js";
+export declare const COMPLETION_LANGUAGE_SERVICE_LIMITS: {
+    readonly deadlineMs: 500;
+    readonly maxDocumentBytes: number;
+    readonly maxCompletionItems: number;
+    readonly maxDiagnostics: number;
+    readonly maxSymbols: number;
+    readonly maxFormattingEdits: number;
+    readonly maxHoverChars: number;
+    readonly maxLabelChars: number;
+    readonly maxDetailChars: number;
+    readonly maxDocumentationChars: number;
+    readonly maxMessageChars: number;
+    readonly maxWorkspaceReadBytes: number;
+    readonly maxWorkspaceReadFileBytes: number;
+    readonly maxWorkspaceReadFiles: number;
+};
+/** Builds the chat function for the elected model. Injectable so tests avoid a live model call. */
+export type CompletionChatFactory = (config: GatewayConfig, modelId: string) => ModelChatFn;
+export interface EditorCompletionRouteOptions {
+    readonly chatFactory?: CompletionChatFactory | undefined;
+    /** Injectable per-root token budget (tests supply a fresh one); defaults to a shared instance. */
+    readonly tokenBudget?: EditorModelTokenBudget | undefined;
+    /** Injectable clock for the token budget; defaults to `Date.now`. */
+    readonly now?: (() => number) | undefined;
+    /** Test-only deterministic language-service limits seam; production keeps the default deadline. */
+    readonly languageServiceLimits?: LanguageServiceLimits | undefined;
+    /** Test-only deterministic language-service clock seam; production keeps the real clock. */
+    readonly languageServiceNow?: (() => number) | undefined;
+}
+export declare function handleEditorCompletion(ctx: RouteContext, deps: UiHandlerDeps, options?: EditorCompletionRouteOptions): Promise<RouteResult>;
+//# sourceMappingURL=completionRoutes.d.ts.map

package/dist/editor/completionRoutes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"completionRoutes.d.ts","sourceRoot":"","sources":["../../src/editor/completionRoutes.ts"],"names":[],"mappings":"AAkBA,OAAO,EAqBL,KAAK,qBAAqB,EAG3B,MAAM,+BAA+B,CAAC;AAEvC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAEvE,OAAO,EAAa,KAAK,YAAY,EAAE,KAAK,WAAW,EAAE,MAAM,cAAc,CAAC;AAC9E,OAAO,EAAwB,KAAK,aAAa,EAAE,MAAM,YAAY,CAAC;AAOtE,OAAO,EAIL,KAAK,WAAW,EAEjB,MAAM,4BAA4B,CAAC;AACpC,OAAO,EAIL,KAAK,sBAAsB,EAE5B,MAAM,6BAA6B,CAAC;AASrC,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;CAGrC,CAAC;AAGX,mGAAmG;AACnG,MAAM,MAAM,qBAAqB,GAAG,CAAC,MAAM,EAAE,aAAa,EAAE,OAAO,EAAE,MAAM,KAAK,WAAW,CAAC;AAE5F,MAAM,WAAW,4BAA4B;IAC3C,QAAQ,CAAC,WAAW,CAAC,EAAE,qBAAqB,GAAG,SAAS,CAAC;IACzD,kGAAkG;IAClG,QAAQ,CAAC,WAAW,CAAC,EAAE,sBAAsB,GAAG,SAAS,CAAC;IAC1D,qEAAqE;IACrE,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC,MAAM,MAAM,CAAC,GAAG,SAAS,CAAC;IAC1C,mGAAmG;IACnG,QAAQ,CAAC,qBAAqB,CAAC,EAAE,qBAAqB,GAAG,SAAS,CAAC;IACnE,4FAA4F;IAC5F,QAAQ,CAAC,kBAAkB,CAAC,EAAE,CAAC,MAAM,MAAM,CAAC,GAAG,SAAS,CAAC;CAC1D;AAufD,wBAAsB,sBAAsB,CAC1C,GAAG,EAAE,YAAY,EACjB,IAAI,EAAE,aAAa,EACnB,OAAO,GAAE,4BAAiC,GACzC,OAAO,CAAC,WAAW,CAAC,CA6CtB"}