@shrkcrft/ai 0.1.0-alpha.2 → 0.1.0-alpha.20

package/dist/llamacpp/llama-cpp-provider.js

@@ -0,0 +1,296 @@
+import { existsSync } from 'node:fs';
+import * as nodePath from 'node:path';
+import { AppErrorImpl, ERROR_CODES, err, ok } from '@shrkcrft/core';
+import { AbstractAiProvider } from "../ai-provider.js";
+import { AiMessageRole } from "../ai-request.js";
+const DEFAULT_CONTEXT_SIZE = 8192;
+const DEFAULT_MAX_TOKENS = 1024;
+/**
+ * In-process generative provider backed by `node-llama-cpp` (a Node
+ * binding for llama.cpp). No HTTP. No daemon. The model is loaded
+ * once into process memory and reused across requests.
+ *
+ * Configuration (env or `IAiProviderConfig`):
+ *   - `LLAMACPP_MODEL_PATH`   — absolute or repo-relative path to a
+ *                               local `.gguf` file. If unset, the
+ *                               provider is `isReady() === false`.
+ *   - `LLAMACPP_CONTEXT_SIZE` — context window in tokens (default 8192).
+ *   - `LLAMACPP_GPU`          — `auto` (default) | `metal` | `cuda` | `off`.
+ *
+ * The first `send()` call pays the model-load cost (typically 1–10 s
+ * for a 3B Q4 model on Apple Silicon). Subsequent calls reuse
+ * the same `LlamaModel` + `LlamaContext`. A fresh `LlamaChatSession`
+ * is created per request so context isn't leaked between unrelated
+ * tasks.
+ *
+ * Tests can inject a fake generator via `_overrideForTests` to avoid
+ * pulling in the native binding and a 2 GB model file.
+ */
+export class LlamaCppProvider extends AbstractAiProvider {
+    id = 'llamacpp';
+    name = 'llama.cpp (in-process)';
+    /** Test hook — bypasses the native binding when set. */
+    static _overrideForTests = null;
+    /**
+     * Reads the module-level cache to expose the active model path for
+     * tools that need it (mostly the disposer). Returns null when no
+     * model has been loaded in this process.
+     */
+    static activeModelPath() {
+        return sharedLlamaState?.modelPath ?? null;
+    }
+    isReady() {
+        return resolveModelPath(this.config.model) !== null;
+    }
+    async send(request) {
+        const modelPath = resolveModelPath(request.model ?? this.config.model);
+        if (modelPath === null) {
+            return err(new AppErrorImpl(ERROR_CODES.INVALID_INPUT, 'LLAMACPP_MODEL_PATH is not set or the file does not exist.', {
+                suggestion: 'Set LLAMACPP_MODEL_PATH=/path/to/qwen2.5-coder-3b.gguf in .env, or pass --model <path> on the CLI.',
+            }));
+        }
+        if (LlamaCppProvider._overrideForTests) {
+            try {
+                const value = await LlamaCppProvider._overrideForTests(request, modelPath);
+                return ok(value);
+            }
+            catch (e) {
+                return err(new AppErrorImpl(ERROR_CODES.IO_ERROR, `Test override failed: ${e.message}`, {
+                    cause: e,
+                }));
+            }
+        }
+        let promptAbort;
+        let promptTimer;
+        let promptTimedOut = false;
+        try {
+            const tf = (await import('node-llama-cpp'));
+            const { LlamaChatSession } = tf;
+            const { model, context } = await this.ensureLoaded(modelPath);
+            const sequence = context.getSequence();
+            const session = new LlamaChatSession({
+                contextSequence: sequence,
+                systemPrompt: collectSystemPrompt(request.messages),
+            });
+            // Prior assistant/user turns get fed into the session in order so
+            // the model sees the conversation history. The trailing user turn
+            // is what we ask `prompt()` to respond to.
+            const turns = nonSystemTurns(request.messages);
+            for (let i = 0; i < turns.length - 1; i += 1) {
+                const turn = turns[i];
+                if (turn.role === AiMessageRole.Assistant) {
+                    // node-llama-cpp 3.x exposes session.addAssistantMessage in some
+                    // versions; older versions don't. Best effort: skip silently.
+                    const fn = session.addAssistantMessage;
+                    if (typeof fn === 'function')
+                        fn.call(session, turn.content);
+                    continue;
+                }
+                // For user turns that aren't the trailing one, prime them so the
+                // assistant response gets folded back into the context too.
+                await session.prompt(turn.content, {
+                    maxTokens: 1,
+                    stopOnAbortSignal: true,
+                });
+            }
+            const lastUser = turns[turns.length - 1];
+            const userPrompt = lastUser && lastUser.role === AiMessageRole.User ? lastUser.content : '';
+            const maxTokens = request.maxTokens ?? DEFAULT_MAX_TOKENS;
+            const wantsJson = !!request.responseFormat;
+            // When the caller wants JSON, ask llama.cpp to enforce it at
+            // sample time via a grammar. This eliminates a whole class of
+            // parse failures (preamble prose, trailing markdown, runaway
+            // continuation) that small models routinely produce. Best effort:
+            // if the grammar constructor isn't available in this version we
+            // fall back to plain prompting + trim.
+            let grammar = undefined;
+            if (wantsJson) {
+                try {
+                    const Ctor = tf.LlamaJsonSchemaGrammar;
+                    // CRITICAL: pass the *same* Llama instance the model was
+                    // loaded with. node-llama-cpp rejects mixing grammars from
+                    // one instance with a session from another ("The
+                    // LlamaGrammar … was created with a different Llama
+                    // instance"). Calling getLlama() again would also leak a
+                    // second native Metal device, which then crashes the
+                    // process on exit (`ggml_metal_device_free`).
+                    const sharedLlama = sharedLlamaState?.llama;
+                    if (Ctor && request.responseFormat?.schema && sharedLlama) {
+                        grammar = new Ctor(sharedLlama, request.responseFormat.schema);
+                    }
+                }
+                catch {
+                    grammar = undefined;
+                }
+            }
+            const start = Date.now();
+            const onChunk = request.onTokenStream;
+            // Per-call wall-clock timeout: abort the decode if it overruns so a
+            // slow model can't hang the command. node-llama-cpp honours an
+            // AbortSignal when `stopOnAbortSignal` is set.
+            const timeoutMs = request.timeoutMs ?? this.config.timeoutMs;
+            if (timeoutMs && timeoutMs > 0) {
+                promptAbort = new AbortController();
+                promptTimer = setTimeout(() => {
+                    promptTimedOut = true;
+                    promptAbort?.abort();
+                }, timeoutMs);
+            }
+            const text = await session.prompt(userPrompt, {
+                maxTokens,
+                ...(request.temperature !== undefined ? { temperature: request.temperature } : {}),
+                ...(wantsJson ? { trimWhitespaceSuffix: true } : {}),
+                ...(grammar ? { grammar: grammar } : {}),
+                ...(promptAbort ? { signal: promptAbort.signal, stopOnAbortSignal: true } : {}),
+                ...(onChunk
+                    ? {
+                        onTextChunk: (chunk) => {
+                            try {
+                                onChunk(chunk);
+                            }
+                            catch {
+                                // never let a callback failure break inference
+                            }
+                        },
+                    }
+                    : {}),
+            });
+            const elapsedMs = Date.now() - start;
+            // Release the LlamaContext sequence so the next send() can take it.
+            // Without this we hit "No sequences left" on the second call. The
+            // LlamaModel + LlamaContext themselves stay loaded across calls.
+            const sessionDisposable = session;
+            if (typeof sessionDisposable.dispose === 'function')
+                sessionDisposable.dispose();
+            const seqDisposable = sequence;
+            if (typeof seqDisposable.dispose === 'function')
+                seqDisposable.dispose();
+            return ok({
+                content: text,
+                model: nodePath.basename(modelPath),
+                finishReason: 'stop',
+                usage: {
+                // node-llama-cpp does not surface input/output token counts in a
+                // stable v3 API path; we leave usage undefined and let callers
+                // approximate from char count if needed.
+                },
+                raw: { backend: 'node-llama-cpp', modelPath, elapsedMs },
+            });
+        }
+        catch (e) {
+            if (promptTimedOut) {
+                return err(new AppErrorImpl(ERROR_CODES.TIMEOUT, `node-llama-cpp decode exceeded the per-call timeout and was aborted.`, {
+                    suggestion: 'The model is too slow for the budget. Try a smaller model, fewer --enhance-passes, or raise the budget.',
+                }));
+            }
+            return err(new AppErrorImpl(ERROR_CODES.IO_ERROR, `node-llama-cpp call failed: ${e.message}`, {
+                cause: e,
+                suggestion: 'Verify LLAMACPP_MODEL_PATH points to a valid .gguf file readable by llama.cpp.',
+            }));
+        }
+        finally {
+            if (promptTimer)
+                clearTimeout(promptTimer);
+        }
+    }
+    async ensureLoaded(modelPath) {
+        // Cached at MODULE scope so the disposer can find it on process
+        // exit. (Per-instance caching used to live here, but the disposer
+        // doesn't know which provider instance to ask.)
+        if (sharedLlamaState && sharedLlamaState.modelPath === modelPath) {
+            return { model: sharedLlamaState.model, context: sharedLlamaState.context };
+        }
+        if (sharedLlamaState) {
+            // Different model requested — tear down the old one before
+            // loading a new one. Best-effort; failures are tolerated.
+            await disposeLlamaCppRuntime();
+        }
+        const { getLlama } = (await import('node-llama-cpp'));
+        const llama = await getLlama({
+            gpu: resolveGpuChoice(this.config.baseUrl),
+        });
+        const model = await llama.loadModel({ modelPath });
+        const contextSize = Number.isFinite(this.config.timeoutMs)
+            ? DEFAULT_CONTEXT_SIZE
+            : Number(process.env.LLAMACPP_CONTEXT_SIZE ?? DEFAULT_CONTEXT_SIZE);
+        const context = await model.createContext({ contextSize });
+        sharedLlamaState = { llama, model, context, modelPath };
+        return { model, context };
+    }
+}
+let sharedLlamaState = null;
+/**
+ * Release the loaded llama.cpp model + context so the process can
+ * exit cleanly.
+ *
+ * Without this, the libc++ destructor for the Metal device list
+ * aborts on `exit()` with `ggml_metal_device_free` because the
+ * device list isn't empty — same shape of teardown crash as the
+ * ONNX mutex issue, different native library. Disposing in the
+ * order session → context → model → llama lets the destructors
+ * run while the JS runtime is still healthy.
+ *
+ * Safe to call multiple times. Safe to call when no model was
+ * loaded. Errors during dispose are swallowed (the alternative is
+ * the abort we're trying to prevent).
+ */
+export async function disposeLlamaCppRuntime() {
+    const state = sharedLlamaState;
+    sharedLlamaState = null;
+    if (!state)
+        return false;
+    // Context first — it holds the sequence pool that depends on the model.
+    await callMaybeDispose(state.context);
+    // Then the model, which depends on the llama runtime.
+    await callMaybeDispose(state.model);
+    // Finally the Llama instance itself (releases the Metal device).
+    await callMaybeDispose(state.llama);
+    // libggml/Metal was loaded — even after disposing, this Node version still
+    // runs the native static destructor during `exit()` and it can abort with a
+    // GGML backtrace. The caller redirects fd 2 to a log file to contain it.
+    return true;
+}
+async function callMaybeDispose(target) {
+    if (!target || typeof target !== 'object')
+        return;
+    const maybe = target;
+    if (typeof maybe.dispose !== 'function')
+        return;
+    try {
+        const r = maybe.dispose();
+        if (r && typeof r.then === 'function') {
+            await r.catch(() => undefined);
+        }
+    }
+    catch {
+        // ignore
+    }
+}
+function resolveModelPath(explicit) {
+    const envPath = process.env.LLAMACPP_MODEL_PATH;
+    const candidate = explicit && explicit.length > 0 ? explicit : envPath;
+    if (!candidate)
+        return null;
+    if (nodePath.isAbsolute(candidate)) {
+        return existsSync(candidate) ? candidate : null;
+    }
+    const fromCwd = nodePath.resolve(process.cwd(), candidate);
+    return existsSync(fromCwd) ? fromCwd : null;
+}
+function resolveGpuChoice(_baseUrl) {
+    const choice = (process.env.LLAMACPP_GPU ?? 'auto').trim().toLowerCase();
+    if (choice === 'metal')
+        return 'metal';
+    if (choice === 'cuda')
+        return 'cuda';
+    if (choice === 'off' || choice === 'false' || choice === 'no' || choice === 'cpu')
+        return false;
+    return 'auto';
+}
+function collectSystemPrompt(messages) {
+    const parts = messages.filter((m) => m.role === AiMessageRole.System).map((m) => m.content);
+    return parts.join('\n\n');
+}
+function nonSystemTurns(messages) {
+    return messages.filter((m) => m.role !== AiMessageRole.System);
+}

package/dist/llm-hints.d.ts

@@ -0,0 +1,36 @@
+import type { AiProviderKind } from './provider-resolver.js';
+import type { IAiProvider } from './ai-provider.js';
+export type AiHintLevel = 'setup' | 'upgrade' | 'info';
+export interface IAiHint {
+    level: AiHintLevel;
+    title: string;
+    steps: readonly string[];
+}
+export interface IAiBlock {
+    reachable: boolean;
+    requestedProvider: AiProviderKind;
+    providerId: string | null;
+    enhancementSkipped: boolean;
+    hints: readonly IAiHint[];
+}
+export interface IBuildAiBlockInput {
+    /** What `selectAiProvider` returned, or null if the caller didn't try. */
+    selection?: {
+        requested: AiProviderKind;
+        provider: IAiProvider | null;
+    } | null;
+    /** True when --no-enhance was passed (user opted out — don't nag). */
+    userOptedOut?: boolean;
+}
+/**
+ * Produces the structured `ai` block that lives on every audit report
+ * and any command using `enrichWithLlmRecommendations`. Without the
+ * AI block, `--no-enhance` and "no provider reachable" look the same
+ * to a downstream agent. The block disambiguates.
+ *
+ * Lives in `@shrkcrft/ai` so any package (CLI, packs, MCP server's
+ * read-only surfaces) can construct the same shape.
+ */
+export declare function buildAiBlock(input?: IBuildAiBlockInput): IAiBlock;
+export declare function renderAiBlockMarkdown(block: IAiBlock): string;
+//# sourceMappingURL=llm-hints.d.ts.map

package/dist/llm-hints.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"llm-hints.d.ts","sourceRoot":"","sources":["../src/llm-hints.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAC7D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAEpD,MAAM,MAAM,WAAW,GAAG,OAAO,GAAG,SAAS,GAAG,MAAM,CAAC;AAEvD,MAAM,WAAW,OAAO;IACtB,KAAK,EAAE,WAAW,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;CAC1B;AAED,MAAM,WAAW,QAAQ;IACvB,SAAS,EAAE,OAAO,CAAC;IACnB,iBAAiB,EAAE,cAAc,CAAC;IAClC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,kBAAkB,EAAE,OAAO,CAAC;IAC5B,KAAK,EAAE,SAAS,OAAO,EAAE,CAAC;CAC3B;AAED,MAAM,WAAW,kBAAkB;IACjC,0EAA0E;IAC1E,SAAS,CAAC,EAAE;QAAE,SAAS,EAAE,cAAc,CAAC;QAAC,QAAQ,EAAE,WAAW,GAAG,IAAI,CAAA;KAAE,GAAG,IAAI,CAAC;IAC/E,sEAAsE;IACtE,YAAY,CAAC,EAAE,OAAO,CAAC;CACxB;AAED;;;;;;;;GAQG;AACH,wBAAgB,YAAY,CAAC,KAAK,GAAE,kBAAuB,GAAG,QAAQ,CAiErE;AAED,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,QAAQ,GAAG,MAAM,CAiB7D"}

package/dist/llm-hints.js

@@ -0,0 +1,92 @@
+import { selectAiProvider } from "./provider-resolver.js";
+/**
+ * Produces the structured `ai` block that lives on every audit report
+ * and any command using `enrichWithLlmRecommendations`. Without the
+ * AI block, `--no-enhance` and "no provider reachable" look the same
+ * to a downstream agent. The block disambiguates.
+ *
+ * Lives in `@shrkcrft/ai` so any package (CLI, packs, MCP server's
+ * read-only surfaces) can construct the same shape.
+ */
+export function buildAiBlock(input = {}) {
+    // Honour an explicitly-passed selection (including {provider: null} when
+    // --no-enhance is in play) without re-probing the auto chain. Only fall
+    // back to live probing when the caller didn't supply a selection at all.
+    const selection = input.selection !== undefined && input.selection !== null
+        ? input.selection
+        : input.userOptedOut
+            ? { requested: 'auto', provider: null }
+            : selectAiProvider(undefined);
+    const reachable = selection.provider !== null;
+    const providerId = selection.provider?.id ?? null;
+    const requested = selection.requested;
+    const userOptedOut = Boolean(input.userOptedOut);
+    const hints = [];
+    if (!reachable && !userOptedOut) {
+        hints.push({
+            level: 'setup',
+            title: 'Enable LLM enrichment for deeper analysis',
+            steps: [
+                'Local-first: install Ollama (https://ollama.com/download) or set LLAMACPP_MODEL_PATH for in-process inference.',
+                'Pull a model that fits your machine — e.g. `ollama pull llama3.2` (good general-purpose) or `ollama pull qwen2.5-coder:7b` (code-aware).',
+                'Optional: export OLLAMA_HOST=http://localhost:11434 (default) or point at a remote daemon.',
+                'Optional: export OLLAMA_MODEL=<id> to pin the model used by shrk.',
+                'Re-run without --no-enhance. The deterministic findings are unchanged; LLM critique appears under `llmFindings`.',
+            ],
+        });
+    }
+    else if (!reachable && userOptedOut) {
+        hints.push({
+            level: 'info',
+            title: 'LLM enrichment disabled by --no-enhance',
+            steps: [
+                'Deterministic findings are first-class; LLM is purely additive.',
+                'Drop --no-enhance to layer LLM critique on top when a provider is available.',
+            ],
+        });
+    }
+    else {
+        hints.push({
+            level: 'info',
+            title: `LLM enrichment active via ${providerId}`,
+            steps: [
+                'LLM-derived findings appear with `[llm]` tags and a confidence score.',
+                'Tune behavior: --provider ollama|llamacpp, --model <id>, AI_PROVIDER env var (overrides --provider when unset).',
+            ],
+        });
+        hints.push({
+            level: 'upgrade',
+            title: 'Sharpen LLM output if findings feel thin',
+            steps: [
+                'Prefer a code-aware model for technical staleness checks (e.g. qwen2.5-coder:7b, deepseek-coder-v2).',
+                'Larger models notice more drift but cost latency — try 7B for code, 14B+ for nuanced doc-content review.',
+                'For fix-plan enrichment, the same provider is reused; no separate config needed.',
+            ],
+        });
+    }
+    return {
+        reachable,
+        requestedProvider: requested,
+        providerId,
+        enhancementSkipped: userOptedOut,
+        hints,
+    };
+}
+export function renderAiBlockMarkdown(block) {
+    const out = [];
+    const status = block.reachable
+        ? `active via \`${block.providerId}\``
+        : block.enhancementSkipped
+            ? 'disabled by `--no-enhance`'
+            : 'unavailable (no local LLM detected)';
+    out.push(`## AI configuration — ${status}`);
+    out.push('');
+    for (const hint of block.hints) {
+        out.push(`### [${hint.level}] ${hint.title}`);
+        for (const step of hint.steps) {
+            out.push(`- ${step}`);
+        }
+        out.push('');
+    }
+    return out.join('\n');
+}

package/dist/llm-recommendations.d.ts

@@ -0,0 +1,72 @@
+import type { IAiProvider } from './ai-provider.js';
+import { type IAiBlock } from './llm-hints.js';
+export type RecommendationSeverity = 'info' | 'warn' | 'error';
+export interface ILlmRecommendation {
+    severity: RecommendationSeverity;
+    category: string;
+    /** Short, one-sentence description of what's recommended. */
+    title: string;
+    /** Detailed prose; typically 1-3 sentences with concrete next-steps. */
+    detail: string;
+    /** Optional target identifier (rule id, template id, file path) the recommendation applies to. */
+    target?: string;
+    /** Confidence in [0, 1]; lower for fuzzier judgments. */
+    confidence: number;
+}
+export interface IRecommendationEnvelope {
+    /** Always present, even when LLM is unavailable. */
+    ai: IAiBlock;
+    recommendations: readonly ILlmRecommendation[];
+}
+export interface IEnrichWithLlmRecommendationsInput {
+    /**
+     * The shape of the deterministic surface (e.g., 'doctor', 'templates-drift').
+     * Used in the LLM prompt so the model knows what it's looking at.
+     */
+    surface: string;
+    /**
+     * Human-readable description of the deterministic findings (what's already
+     * known). Should be tight — the prompt fits into one LLM call.
+     */
+    deterministicSummary: string;
+    /**
+     * Provider kind to request. Defaults to 'auto' (local-first walk).
+     */
+    providerKind?: string;
+    /**
+     * Override the auto-selection by passing an already-resolved provider
+     * (useful for tests).
+     */
+    providerOverride?: IAiProvider | null;
+    /**
+     * True when the caller's --no-enhance equivalent was passed.
+     * When true, no LLM call is made and the AI block records the opt-out.
+     */
+    userOptedOut?: boolean;
+    /**
+     * Per-surface ask: what should the LLM produce on top of the
+     * deterministic summary? E.g. "for each warning, produce one concrete
+     * next-step the user can run from the CLI."
+     */
+    ask: string;
+    /**
+     * Optional override for the model used by the provider.
+     */
+    model?: string;
+    maxTokens?: number;
+}
+/**
+ * Shared utility for layering LLM recommendations onto any deterministic
+ * surface. The deterministic portion is the caller's responsibility; this
+ * helper only adds the `ai` block and a structured `recommendations` array.
+ *
+ * Hard guarantee: if no LLM is reachable (or `userOptedOut` is true), the
+ * call is a no-op apart from emitting the `ai` block with setup hints.
+ *
+ * Lives in `@shrkcrft/ai` so any callable surface (CLI commands, packs,
+ * read-only MCP tools that want recommendations alongside their data)
+ * can reuse the same envelope shape.
+ */
+export declare function enrichWithLlmRecommendations(input: IEnrichWithLlmRecommendationsInput): Promise<IRecommendationEnvelope>;
+export declare function renderRecommendationsMarkdown(envelope: IRecommendationEnvelope): string;
+//# sourceMappingURL=llm-recommendations.d.ts.map

package/dist/llm-recommendations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"llm-recommendations.d.ts","sourceRoot":"","sources":["../src/llm-recommendations.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAEpD,OAAO,EAAgB,KAAK,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE7D,MAAM,MAAM,sBAAsB,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC;AAE/D,MAAM,WAAW,kBAAkB;IACjC,QAAQ,EAAE,sBAAsB,CAAC;IACjC,QAAQ,EAAE,MAAM,CAAC;IACjB,6DAA6D;IAC7D,KAAK,EAAE,MAAM,CAAC;IACd,wEAAwE;IACxE,MAAM,EAAE,MAAM,CAAC;IACf,kGAAkG;IAClG,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,yDAAyD;IACzD,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,uBAAuB;IACtC,oDAAoD;IACpD,EAAE,EAAE,QAAQ,CAAC;IACb,eAAe,EAAE,SAAS,kBAAkB,EAAE,CAAC;CAChD;AAED,MAAM,WAAW,kCAAkC;IACjD;;;OAGG;IACH,OAAO,EAAE,MAAM,CAAC;IAChB;;;OAGG;IACH,oBAAoB,EAAE,MAAM,CAAC;IAC7B;;OAEG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;OAGG;IACH,gBAAgB,CAAC,EAAE,WAAW,GAAG,IAAI,CAAC;IACtC;;;OAGG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB;;;;OAIG;IACH,GAAG,EAAE,MAAM,CAAC;IACZ;;OAEG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,4BAA4B,CAChD,KAAK,EAAE,kCAAkC,GACxC,OAAO,CAAC,uBAAuB,CAAC,CAoClC;AA2FD,wBAAgB,6BAA6B,CAAC,QAAQ,EAAE,uBAAuB,GAAG,MAAM,CA+BvF"}