@oscharko-dev/keiko-server 0.2.0

package/dist/editor/builtinLanguageProviders.d.ts

@@ -0,0 +1,6 @@
+import type { LanguageProviderDescriptor } from "@oscharko-dev/keiko-contracts";
+import type { LanguageProvider } from "./languageProvider.js";
+export declare function createJsonLanguageProvider(): LanguageProvider;
+export declare function createBuiltinTextLanguageProvider(): LanguageProvider;
+export declare function unavailableExternalLspDescriptors(): readonly LanguageProviderDescriptor[];
+//# sourceMappingURL=builtinLanguageProviders.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"builtinLanguageProviders.d.ts","sourceRoot":"","sources":["../../src/editor/builtinLanguageProviders.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAKV,0BAA0B,EAG3B,MAAM,+BAA+B,CAAC;AACvC,OAAO,KAAK,EAGV,gBAAgB,EAGjB,MAAM,uBAAuB,CAAC;AA2J/B,wBAAgB,0BAA0B,IAAI,gBAAgB,CAgB7D;AAED,wBAAgB,iCAAiC,IAAI,gBAAgB,CAiBpE;AAED,wBAAgB,iCAAiC,IAAI,SAAS,0BAA0B,EAAE,CA8CzF"}

package/dist/editor/builtinLanguageProviders.js

@@ -0,0 +1,221 @@
+import { computeLineStarts, spanToRange } from "./textOffsets.js";
+const BUILTIN_FORMATTING_LANGUAGES = [
+    "css",
+    "scss",
+    "less",
+    "html",
+    "yaml",
+    "markdown",
+];
+function fullDocumentEdit(text, newText) {
+    if (newText === text)
+        return [];
+    const lineStarts = computeLineStarts(text);
+    return [{ range: spanToRange(text, lineStarts, 0, text.length), newText }];
+}
+function ensureFinalNewline(text) {
+    return text.length === 0 || text.endsWith("\n") ? text : `${text}\n`;
+}
+function normalizeTrailingWhitespace(text) {
+    return ensureFinalNewline(text.replace(/[ \t]+$/gmu, ""));
+}
+function formatJson(text, options) {
+    try {
+        const parsed = JSON.parse(text);
+        const spaces = options?.insertSpaces === false ? "\t" : options?.tabSize ?? 2;
+        return `${JSON.stringify(parsed, null, spaces)}\n`;
+    }
+    catch {
+        return null;
+    }
+}
+function formatCssLike(text, options) {
+    const indentUnit = options?.insertSpaces === false ? "\t" : " ".repeat(options?.tabSize ?? 2);
+    const tokens = text
+        .replace(/\r\n?/gu, "\n")
+        .replace(/\{/gu, "{\n")
+        .replace(/\}/gu, "\n}\n")
+        .replace(/;/gu, ";\n")
+        .split("\n")
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0);
+    let depth = 0;
+    const out = [];
+    for (const line of tokens) {
+        if (line.startsWith("}"))
+            depth = Math.max(0, depth - 1);
+        out.push(`${indentUnit.repeat(depth)}${line}`);
+        if (line.endsWith("{"))
+            depth += 1;
+    }
+    return `${out.join("\n")}\n`;
+}
+function isHtmlClosingToken(line) {
+    return line.startsWith("</");
+}
+function isHtmlSelfClosingToken(line) {
+    return line.endsWith("/>") || line.startsWith("<!") || line.startsWith("<?");
+}
+function opensHtmlIndentScope(line) {
+    return /^<[^/!][^>]*>$/u.test(line) && !line.includes("</");
+}
+function formatHtml(text, options) {
+    const indentUnit = options?.insertSpaces === false ? "\t" : " ".repeat(options?.tabSize ?? 2);
+    const tokens = text
+        .replace(/\r\n?/gu, "\n")
+        .replace(/>\s*</gu, ">\n<")
+        .split("\n")
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0);
+    let depth = 0;
+    const out = [];
+    for (const line of tokens) {
+        const closing = isHtmlClosingToken(line);
+        if (closing)
+            depth = Math.max(0, depth - 1);
+        out.push(`${indentUnit.repeat(depth)}${line}`);
+        if (!closing && !isHtmlSelfClosingToken(line) && opensHtmlIndentScope(line))
+            depth += 1;
+    }
+    return `${out.join("\n")}\n`;
+}
+function firstLineRange(text) {
+    return spanToRange(text, computeLineStarts(text), 0, 0);
+}
+function jsonDiagnostics(ctx) {
+    try {
+        JSON.parse(ctx.overlayText);
+        return { diagnostics: [], truncated: false };
+    }
+    catch (error) {
+        const message = error instanceof SyntaxError ? error.message : "Invalid JSON.";
+        const diagnostic = {
+            range: firstLineRange(ctx.overlayText),
+            severity: "error",
+            message,
+            source: "json",
+            code: "JSON_PARSE",
+        };
+        return { diagnostics: [diagnostic], truncated: false };
+    }
+}
+function markdownSymbols(ctx) {
+    const lineStarts = computeLineStarts(ctx.overlayText);
+    const symbols = ctx.overlayText
+        .split("\n")
+        .map((line, index) => ({ line, index }))
+        .filter(({ line }) => /^#{1,6}\s+/u.test(line))
+        .slice(0, ctx.limits.maxSymbols)
+        .map(({ line, index }) => ({
+        name: line.replace(/^#{1,6}\s+/u, "").trim().slice(0, ctx.limits.maxLabelChars),
+        kind: "variable",
+        range: spanToRange(ctx.overlayText, lineStarts, lineStarts[index], line.length),
+    }));
+    return {
+        symbols,
+        truncated: symbols.length >= ctx.limits.maxSymbols,
+    };
+}
+function jsonFormatting(ctx, options) {
+    const formatted = formatJson(ctx.overlayText, options);
+    return {
+        edits: formatted === null ? [] : fullDocumentEdit(ctx.overlayText, formatted),
+        truncated: false,
+    };
+}
+function genericFormatting(ctx, options) {
+    const formatted = ctx.languageId === "css" || ctx.languageId === "scss" || ctx.languageId === "less"
+        ? formatCssLike(ctx.overlayText, options)
+        : ctx.languageId === "html"
+            ? formatHtml(ctx.overlayText, options)
+            : normalizeTrailingWhitespace(ctx.overlayText);
+    return { edits: fullDocumentEdit(ctx.overlayText, formatted), truncated: false };
+}
+const EMPTY_COMPLETIONS = {
+    items: [],
+    isIncomplete: false,
+    truncated: false,
+};
+const EMPTY_HOVER = { contents: null };
+export function createJsonLanguageProvider() {
+    const descriptor = {
+        id: "json",
+        languages: ["json"],
+        operations: ["diagnostics", "symbols", "formatting"],
+        availability: "available",
+    };
+    return {
+        descriptor,
+        supports: (languageId) => languageId === "json",
+        getDiagnostics: jsonDiagnostics,
+        getCompletions: () => EMPTY_COMPLETIONS,
+        getHover: () => EMPTY_HOVER,
+        getSymbols: markdownSymbols,
+        getFormatting: jsonFormatting,
+    };
+}
+export function createBuiltinTextLanguageProvider() {
+    const languages = [...BUILTIN_FORMATTING_LANGUAGES];
+    const descriptor = {
+        id: "builtin-text",
+        languages,
+        operations: ["symbols", "formatting"],
+        availability: "available",
+    };
+    return {
+        descriptor,
+        supports: (languageId) => languages.includes(languageId),
+        getDiagnostics: () => ({ diagnostics: [], truncated: false }),
+        getCompletions: () => EMPTY_COMPLETIONS,
+        getHover: () => EMPTY_HOVER,
+        getSymbols: markdownSymbols,
+        getFormatting: genericFormatting,
+    };
+}
+export function unavailableExternalLspDescriptors() {
+    const unavailableReason = "No configured workspace-contained language server executable.";
+    return [
+        {
+            id: "python-lsp",
+            languages: ["python"],
+            operations: ["diagnostics", "completion", "hover", "symbols", "formatting"],
+            availability: "unavailable",
+            unavailableReason,
+        },
+        {
+            id: "java-lsp",
+            languages: ["java"],
+            operations: ["diagnostics", "completion", "hover", "symbols", "formatting"],
+            availability: "unavailable",
+            unavailableReason,
+        },
+        {
+            id: "go-lsp",
+            languages: ["go"],
+            operations: ["diagnostics", "completion", "hover", "symbols", "formatting"],
+            availability: "unavailable",
+            unavailableReason,
+        },
+        {
+            id: "rust-lsp",
+            languages: ["rust"],
+            operations: ["diagnostics", "completion", "hover", "symbols", "formatting"],
+            availability: "unavailable",
+            unavailableReason,
+        },
+        {
+            id: "shell-lsp",
+            languages: ["shell"],
+            operations: ["diagnostics", "completion", "hover", "symbols", "formatting"],
+            availability: "unavailable",
+            unavailableReason,
+        },
+        {
+            id: "sql-lsp",
+            languages: ["sql"],
+            operations: ["diagnostics", "completion", "hover", "symbols", "formatting"],
+            availability: "unavailable",
+            unavailableReason,
+        },
+    ];
+}

package/dist/editor/codingContext.d.ts

@@ -0,0 +1,12 @@
+import { type CodingContextPack, type CodingContextRequest } from "@oscharko-dev/keiko-contracts";
+import type { UiHandlerDeps } from "../deps.js";
+export interface AssembleCodingContextDeps {
+    readonly deps: UiHandlerDeps;
+    readonly realRoot: string;
+    readonly signal: AbortSignal;
+    readonly nowMs: number;
+    readonly budgetBytes?: number | undefined;
+    readonly allowEmbeddingProviders?: boolean | undefined;
+}
+export declare function assembleCodingContext(request: CodingContextRequest, context: AssembleCodingContextDeps): Promise<CodingContextPack>;
+//# sourceMappingURL=codingContext.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"codingContext.d.ts","sourceRoot":"","sources":["../../src/editor/codingContext.ts"],"names":[],"mappings":"AAUA,OAAO,EAOL,KAAK,iBAAiB,EACtB,KAAK,oBAAoB,EAC1B,MAAM,+BAA+B,CAAC;AAEvC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAgBhD,MAAM,WAAW,yBAAyB;IACxC,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC;IAC7B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC;IAC7B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC1C,QAAQ,CAAC,uBAAuB,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CACxD;AA4ED,wBAAsB,qBAAqB,CACzC,OAAO,EAAE,oBAAoB,EAC7B,OAAO,EAAE,yBAAyB,GACjC,OAAO,CAAC,iBAAiB,CAAC,CA0C5B"}

package/dist/editor/codingContext.js

@@ -0,0 +1,121 @@
+// Governed coding-context assembly orchestrator (Issue #1211, ADR-0042 D6). `assembleCodingContext`
+// composes the existing retrieval seams into a single bounded, redacted CodingContextPack for an
+// editor-originated request. Provider eligibility and the byte budget are purpose-driven: the
+// keystroke-sensitive purposes (inline, diagnostic) run only the cheap deterministic repo-search and
+// EXCLUDE the embedding-cost providers (Local Knowledge, memory), which are recorded as a
+// `too-expensive` omission rather than silently skipped. The pack is content-bearing and stays
+// server-internal; the BFF route projects it to a content-free wire pack before it leaves the process.
+// Cancellation is cooperative: the AbortSignal is checked between providers and passed into the
+// embedding retrieval path.
+import { CODING_CONTEXT_BUDGETS, CODING_CONTEXT_SCHEMA_VERSION, embeddingProvidersAllowed, tierForCodingContextSource, } from "@oscharko-dev/keiko-contracts";
+import { selectScoredTextByByteBudget } from "@oscharko-dev/keiko-workspace";
+import { runLocalKnowledgeProvider, runMemoryProvider, runRepoSearchProvider, } from "./codingContextProviders.js";
+const DEFERRED_CONTEXT_PROVIDERS = [
+    "connected-context",
+    "quality-intelligence",
+    "workflow-context",
+];
+// Greedy byte-budget packer: highest score first, ties broken by id for determinism, dropped when the
+// pack byte budget is exhausted. Reuses the keiko-workspace context-pack budget selector.
+function packExcerpts(candidates, budgetBytes) {
+    const packed = selectScoredTextByByteBudget(candidates, budgetBytes, {
+        id: (candidate) => candidate.id,
+        score: (candidate) => candidate.score,
+        text: (candidate) => candidate.text,
+    });
+    return {
+        excerpts: packed.selected.map(({ item: candidate, byteCount }, rank) => ({
+            citation: {
+                sourceKind: candidate.sourceKind,
+                sourceTier: tierForCodingContextSource(candidate.sourceKind),
+                id: candidate.id,
+                score: candidate.score,
+                rank,
+                citationRef: candidate.citationRef,
+                byteCount,
+                truncated: candidate.truncated,
+            },
+            text: candidate.text,
+        })),
+        usedBytes: packed.usedBytes,
+        droppedForBudget: packed.droppedForBudget,
+    };
+}
+function effectiveCodingContextBudget(purpose, requestedBudgetBytes) {
+    const baseBudget = CODING_CONTEXT_BUDGETS[purpose];
+    const effectiveBudgetBytes = requestedBudgetBytes === undefined
+        ? baseBudget.budgetBytes
+        : Math.min(baseBudget.budgetBytes, Math.max(0, Math.trunc(requestedBudgetBytes)));
+    return {
+        ...baseBudget,
+        budgetBytes: effectiveBudgetBytes,
+        maxBytesPerSource: Math.min(baseBudget.maxBytesPerSource, effectiveBudgetBytes),
+    };
+}
+async function collectEmbeddingProviderContext(request, providerCtx, allowEmbeddingProviders, candidates, omissions) {
+    if (!allowEmbeddingProviders) {
+        // Per-keystroke and deferred-execution exclusions are not silent: embedding-cost providers are
+        // recorded as content-free `too-expensive` omissions so the exclusion is auditable.
+        omissions.push({ sourceKind: "local-knowledge", reason: "too-expensive" });
+        omissions.push({ sourceKind: "memory", reason: "too-expensive" });
+        return;
+    }
+    if (!providerCtx.signal.aborted) {
+        const knowledge = await runLocalKnowledgeProvider(providerCtx, {
+            queryText: request.queryText,
+            capsuleId: request.capsuleId,
+            capsuleSetId: request.capsuleSetId,
+        });
+        collect(knowledge, candidates, omissions);
+    }
+    if (!providerCtx.signal.aborted) {
+        const memory = await runMemoryProvider(providerCtx, { queryText: request.queryText });
+        collect(memory, candidates, omissions);
+    }
+}
+export async function assembleCodingContext(request, context) {
+    const budget = effectiveCodingContextBudget(request.purpose, context.budgetBytes);
+    const providerCtx = {
+        deps: context.deps,
+        realRoot: context.realRoot,
+        signal: context.signal,
+        maxBytesPerExcerpt: budget.maxBytesPerSource,
+        nowMs: context.nowMs,
+    };
+    const candidates = [];
+    const omissions = [];
+    const repo = await runRepoSearchProvider(providerCtx, {
+        documentPath: request.documentPath,
+        symbol: request.symbol,
+        queryText: request.queryText,
+        changedFiles: request.changedFiles,
+    });
+    collect(repo, candidates, omissions);
+    const allowEmbeddingProviders = context.allowEmbeddingProviders ?? embeddingProvidersAllowed(request.purpose);
+    await collectEmbeddingProviderContext(request, providerCtx, allowEmbeddingProviders, candidates, omissions);
+    collectDeferredProviderOmissions(omissions);
+    const packed = packExcerpts(candidates, budget.budgetBytes);
+    return {
+        schemaVersion: CODING_CONTEXT_SCHEMA_VERSION,
+        purpose: request.purpose,
+        excerpts: packed.excerpts,
+        usedBytes: packed.usedBytes,
+        budgetBytes: budget.budgetBytes,
+        droppedForBudget: packed.droppedForBudget,
+        omissions,
+    };
+}
+function collect(outcome, candidates, omissions) {
+    candidates.push(...outcome.excerpts);
+    if (outcome.omission !== undefined) {
+        omissions.push(outcome.omission);
+    }
+}
+function collectDeferredProviderOmissions(omissions) {
+    const seen = new Set(omissions.map((entry) => entry.sourceKind));
+    for (const sourceKind of DEFERRED_CONTEXT_PROVIDERS) {
+        if (!seen.has(sourceKind)) {
+            omissions.push({ sourceKind, reason: "unavailable" });
+        }
+    }
+}

package/dist/editor/codingContextEvidence.d.ts

@@ -0,0 +1,7 @@
+import type { CodingContextWirePack } from "@oscharko-dev/keiko-contracts";
+import type { EvidenceStore } from "@oscharko-dev/keiko-contracts";
+import type { Redactor } from "../deps.js";
+export declare const CODING_CONTEXT_EVIDENCE_SCHEMA_VERSION: "1";
+export declare function codingContextEvidenceRunId(wirePack: CodingContextWirePack, emittedAtMs: number): string;
+export declare function recordCodingContextEvidence(store: EvidenceStore, redactor: Redactor, wirePack: CodingContextWirePack, emittedAtMs: number): string;
+//# sourceMappingURL=codingContextEvidence.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"codingContextEvidence.d.ts","sourceRoot":"","sources":["../../src/editor/codingContextEvidence.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,qBAAqB,EAA2B,MAAM,+BAA+B,CAAC;AAEpG,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AACnE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE3C,eAAO,MAAM,sCAAsC,EAAG,GAAY,CAAC;AAiBnE,wBAAgB,0BAA0B,CACxC,QAAQ,EAAE,qBAAqB,EAC/B,WAAW,EAAE,MAAM,GAClB,MAAM,CAQR;AAED,wBAAgB,2BAA2B,CACzC,KAAK,EAAE,aAAa,EACpB,QAAQ,EAAE,QAAQ,EAClB,QAAQ,EAAE,qBAAqB,EAC/B,WAAW,EAAE,MAAM,GAClB,MAAM,CAqBR"}

package/dist/editor/codingContextEvidence.js

@@ -0,0 +1,52 @@
+// Content-free audit linkage for governed coding-context retrieval (Issue #1211, AC: retrieved
+// context carries content-free provenance/citations suitable for evidence and audit linkage, and the
+// recorded citations are content-free and identify the source tier so cross-tier/cross-tenant flow is
+// auditable). The persisted record carries ONLY the content-free wire pack (citations + tier + counts
+// + omissions) — never excerpt text, raw queries, prompts, workspace roots, or secrets. It uses its
+// own `codingContextSchemaVersion` key and deliberately omits `evidenceSchemaVersion`, so the grounded
+// / QI evidence reader (`listEvidence`) skips it instead of attempting to parse it as a connected-
+// context manifest. Persistence failure never fails the request (mirrors the memory-audit handler).
+import { createHash } from "node:crypto";
+import { CODING_CONTEXT_SOURCE_TIERS } from "@oscharko-dev/keiko-contracts";
+export const CODING_CONTEXT_EVIDENCE_SCHEMA_VERSION = "1";
+function countByTier(wirePack) {
+    const counts = Object.fromEntries(CODING_CONTEXT_SOURCE_TIERS.map((tier) => [tier, 0]));
+    for (const entry of wirePack.entries) {
+        counts[entry.sourceTier] += 1;
+    }
+    return counts;
+}
+// Deterministic, content-free run id. Derived from purpose + the (content-free) citation ids +
+// emission time, so the same retrieval at the same instant links to the same audit record.
+export function codingContextEvidenceRunId(wirePack, emittedAtMs) {
+    const material = [
+        wirePack.purpose,
+        String(emittedAtMs),
+        ...wirePack.entries.map((entry) => `${entry.sourceKind}:${entry.id}`),
+    ].join("\n");
+    const digest = createHash("sha256").update(material).digest("hex").slice(0, 16);
+    return `coding-context-${digest}`;
+}
+export function recordCodingContextEvidence(store, redactor, wirePack, emittedAtMs) {
+    const runId = codingContextEvidenceRunId(wirePack, emittedAtMs);
+    const manifest = {
+        codingContextSchemaVersion: CODING_CONTEXT_EVIDENCE_SCHEMA_VERSION,
+        runId,
+        purpose: wirePack.purpose,
+        emittedAtMs,
+        usedBytes: wirePack.usedBytes,
+        budgetBytes: wirePack.budgetBytes,
+        droppedForBudget: wirePack.droppedForBudget,
+        citationCount: wirePack.entries.length,
+        tierCounts: countByTier(wirePack),
+        citations: wirePack.entries,
+        omissions: wirePack.omissions,
+    };
+    try {
+        store.put(runId, JSON.stringify(redactor(manifest)));
+    }
+    catch {
+        // Audit persistence is best-effort; a write failure must never fail the user's request.
+    }
+    return runId;
+}

package/dist/editor/codingContextProviders.d.ts

@@ -0,0 +1,36 @@
+import { type CodingContextOmission, type CodingContextSourceKind } from "@oscharko-dev/keiko-contracts";
+import type { UiHandlerDeps } from "../deps.js";
+export interface RawExcerpt {
+    readonly sourceKind: CodingContextSourceKind;
+    readonly id: string;
+    readonly score: number;
+    readonly citationRef: string | undefined;
+    readonly text: string;
+    readonly truncated: boolean;
+}
+export interface ProviderOutcome {
+    readonly excerpts: readonly RawExcerpt[];
+    readonly omission: CodingContextOmission | undefined;
+}
+export interface ProviderContext {
+    readonly deps: UiHandlerDeps;
+    readonly realRoot: string;
+    readonly signal: AbortSignal;
+    readonly maxBytesPerExcerpt: number;
+    readonly nowMs: number;
+}
+export declare function runRepoSearchProvider(ctx: ProviderContext, input: {
+    readonly documentPath: string;
+    readonly symbol: string | undefined;
+    readonly queryText: string | undefined;
+    readonly changedFiles: readonly string[] | undefined;
+}): Promise<ProviderOutcome>;
+export declare function runLocalKnowledgeProvider(ctx: ProviderContext, input: {
+    readonly queryText: string | undefined;
+    readonly capsuleId: string | undefined;
+    readonly capsuleSetId: string | undefined;
+}): Promise<ProviderOutcome>;
+export declare function runMemoryProvider(ctx: ProviderContext, input: {
+    readonly queryText: string | undefined;
+}): Promise<ProviderOutcome>;
+//# sourceMappingURL=codingContextProviders.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"codingContextProviders.d.ts","sourceRoot":"","sources":["../../src/editor/codingContextProviders.ts"],"names":[],"mappings":"AAUA,OAAO,EAEL,KAAK,qBAAqB,EAC1B,KAAK,uBAAuB,EAG7B,MAAM,+BAA+B,CAAC;AAavC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAgBhD,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,UAAU,EAAE,uBAAuB,CAAC;IAC7C,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,WAAW,EAAE,MAAM,GAAG,SAAS,CAAC;IACzC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;CAC7B;AAED,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,QAAQ,EAAE,SAAS,UAAU,EAAE,CAAC;IACzC,QAAQ,CAAC,QAAQ,EAAE,qBAAqB,GAAG,SAAS,CAAC;CACtD;AAED,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC;IAC7B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC;IAC7B,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAC;IACpC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AA+OD,wBAAsB,qBAAqB,CACzC,GAAG,EAAE,eAAe,EACpB,KAAK,EAAE;IACL,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC;IACpC,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC;IACvC,QAAQ,CAAC,YAAY,EAAE,SAAS,MAAM,EAAE,GAAG,SAAS,CAAC;CACtD,GACA,OAAO,CAAC,eAAe,CAAC,CAyB1B;AA4BD,wBAAsB,yBAAyB,CAC7C,GAAG,EAAE,eAAe,EACpB,KAAK,EAAE;IACL,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC;IACvC,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC;IACvC,QAAQ,CAAC,YAAY,EAAE,MAAM,GAAG,SAAS,CAAC;CAC3C,GACA,OAAO,CAAC,eAAe,CAAC,CAsC1B;AA2ED,wBAAsB,iBAAiB,CACrC,GAAG,EAAE,eAAe,EACpB,KAAK,EAAE;IAAE,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,CAAA;CAAE,GAChD,OAAO,CAAC,eAAe,CAAC,CAiB1B"}