egaki 0.5.0 → 0.7.0

package/dist/cli/transcription-models.js

@@ -0,0 +1,100 @@
+// Transcription model registry for egaki.
+// Maps transcription model IDs to their provider and direct HTTP provider factory.
+// Follows the same pattern as speech-models.ts: provider factory map with lazy
+// imports, auth source detection, and key validation.
+//
+// No AI SDK dependency — all providers use direct HTTP calls via
+// TranscriptionProvider implementations in transcription-providers.ts.
+import pc from 'picocolors';
+import { PROVIDERS, injectCredentialsToEnv, } from './credentials.js';
+import { ValidationError } from './models.js';
+import { TRANSCRIPTION_CATALOG, findTranscriptionModel, } from './transcription-catalog.js';
+export {};
+export const TRANSCRIPTION_MODELS = TRANSCRIPTION_CATALOG.map((m) => m.id);
+export const DEFAULT_TRANSCRIPTION_MODEL = 'whisper-1';
+const TRANSCRIPTION_PROVIDER_FACTORIES = {
+    openai: async () => {
+        const { createOpenAITranscriptionProvider } = await import('./transcription-providers.js');
+        return createOpenAITranscriptionProvider();
+    },
+    elevenlabs: async () => {
+        const { createElevenLabsTranscriptionProvider } = await import('./transcription-providers.js');
+        return createElevenLabsTranscriptionProvider();
+    },
+    deepgram: async () => {
+        const { createDeepgramTranscriptionProvider } = await import('./transcription-providers.js');
+        return createDeepgramTranscriptionProvider();
+    },
+    groq: async () => {
+        const { createGroqTranscriptionProvider } = await import('./transcription-providers.js');
+        return createGroqTranscriptionProvider();
+    },
+    cartesia: async () => {
+        const { createCartesiaTranscriptionProvider } = await import('./transcription-providers.js');
+        return createCartesiaTranscriptionProvider();
+    },
+};
+// ─── key checking ────────────────────────────────────────────────────────────
+function hasDirectProviderKey(providerName) {
+    const info = PROVIDERS[providerName];
+    if (!info)
+        return false;
+    return Boolean(process.env[info.envVar]);
+}
+// ─── config lookup ───────────────────────────────────────────────────────────
+export function getTranscriptionModelConfig(modelId) {
+    const entry = findTranscriptionModel(modelId);
+    if (!entry) {
+        return new ValidationError(`Unknown transcription model: ${modelId}`);
+    }
+    return entry;
+}
+function resolveAuthSource(providerName) {
+    const info = PROVIDERS[providerName];
+    if (info && process.env[info.envVar]) {
+        return { type: 'api-key', label: info.envVar };
+    }
+    return { type: 'api-key', label: 'unknown' };
+}
+function logAuthSource(source) {
+    console.error(pc.dim(`Auth: ${source.label}`));
+}
+// ─── ensure key ──────────────────────────────────────────────────────────────
+export function ensureTranscriptionProviderKey(providerName) {
+    if (hasDirectProviderKey(providerName))
+        return undefined;
+    const info = PROVIDERS[providerName];
+    const label = info?.label || providerName;
+    return new ValidationError(`Missing API key for ${label}. ` +
+        `Run: egaki login --provider ${providerName} --key <key>. ` +
+        (info ? info.hint : ''));
+}
+// ─── provider cache ──────────────────────────────────────────────────────────
+/** Global cache of provider instances, keyed by provider name. */
+const providerCache = globalThis.__egakiTranscriptionProviderCache ??= new Map();
+// ─── public factory ──────────────────────────────────────────────────────────
+export function getTranscriptionProvider(providerName) {
+    injectCredentialsToEnv();
+    const keyError = ensureTranscriptionProviderKey(providerName);
+    if (keyError)
+        return keyError;
+    const authSource = resolveAuthSource(providerName);
+    logAuthSource(authSource);
+    const factory = TRANSCRIPTION_PROVIDER_FACTORIES[providerName];
+    if (!factory) {
+        return new Error(`Transcription is not supported for provider: ${providerName}`);
+    }
+    // Return a lazy provider: the factory is async but we want getTranscriptionProvider
+    // to be sync for ergonomic use in transcribeAudioUncached. The provider promise
+    // is cached globally per provider name so the factory runs once across all calls.
+    return {
+        async transcribe(options) {
+            const cached = providerCache.get(providerName);
+            if (cached)
+                return (await cached).transcribe(options);
+            const promise = factory();
+            providerCache.set(providerName, promise);
+            return (await promise).transcribe(options);
+        },
+    };
+}

package/dist/cli/transcription-providers.d.ts

@@ -0,0 +1,22 @@
+import type { TranscriptionSegment } from './transcription-generate.js';
+export interface TranscriptionProviderOptions {
+    audio: Uint8Array;
+    modelId: string;
+    language?: string;
+    abortSignal?: AbortSignal;
+}
+export interface TranscriptionProviderResult {
+    text: string;
+    segments: TranscriptionSegment[];
+    language?: string;
+    durationInSeconds?: number;
+}
+export interface TranscriptionProvider {
+    transcribe(options: TranscriptionProviderOptions): Promise<TranscriptionProviderResult>;
+}
+export declare function createOpenAITranscriptionProvider(): TranscriptionProvider;
+export declare function createGroqTranscriptionProvider(): TranscriptionProvider;
+export declare function createElevenLabsTranscriptionProvider(): TranscriptionProvider;
+export declare function createDeepgramTranscriptionProvider(): TranscriptionProvider;
+export declare function createCartesiaTranscriptionProvider(): TranscriptionProvider;
+//# sourceMappingURL=transcription-providers.d.ts.map

package/dist/cli/transcription-providers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transcription-providers.d.ts","sourceRoot":"","sources":["../../src/cli/transcription-providers.ts"],"names":[],"mappings":"AAmBA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AAIvE,MAAM,WAAW,4BAA4B;IAC3C,KAAK,EAAE,UAAU,CAAA;IACjB,OAAO,EAAE,MAAM,CAAA;IACf,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,WAAW,CAAC,EAAE,WAAW,CAAA;CAC1B;AAED,MAAM,WAAW,2BAA2B;IAC1C,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,EAAE,oBAAoB,EAAE,CAAA;IAChC,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,iBAAiB,CAAC,EAAE,MAAM,CAAA;CAC3B;AAED,MAAM,WAAW,qBAAqB;IACpC,UAAU,CAAC,OAAO,EAAE,4BAA4B,GAAG,OAAO,CAAC,2BAA2B,CAAC,CAAA;CACxF;AAiED,wBAAgB,iCAAiC,IAAI,qBAAqB,CAkDzE;AAgBD,wBAAgB,+BAA+B,IAAI,qBAAqB,CA6CvE;AAmBD,wBAAgB,qCAAqC,IAAI,qBAAqB,CAqD7E;AAsBD,wBAAgB,mCAAmC,IAAI,qBAAqB,CAmD3E;AAmBD,wBAAgB,mCAAmC,IAAI,qBAAqB,CA+C3E"}

package/dist/cli/transcription-providers.js

@@ -0,0 +1,290 @@
+// Direct HTTP transcription providers for egaki.
+// Each provider sends multipart form or raw audio to the provider API
+// and parses the response, including word-level timestamps.
+//
+// This replaces the AI SDK's experimental_transcribe + @ai-sdk/* provider
+// packages, giving us full control over request/response handling.
+// In particular, we can:
+//   - Send verbose_json + word timestamp granularities for whisper-1
+//   - Avoid verbose_json for gpt-4o-transcribe models, which only support json/text
+//   - Parse the top-level `words` array from Groq responses (the AI SDK
+//     Groq provider only parses `segments`)
+//
+// API reference / OpenAPI specs:
+//   OpenAI:     https://platform.openai.com/docs/api-reference/audio/createTranscription
+//   Groq:       https://console.groq.com/docs/api-reference#audio-transcription
+//               (OpenAI-compatible endpoint at /openai/v1/audio/transcriptions)
+//   ElevenLabs: https://elevenlabs.io/docs/api-reference/speech-to-text/convert
+//   Deepgram:   https://developers.deepgram.com/reference/listen-file
+// ─── shared helpers ──────────────────────────────────────────────────────────
+function mediaTypeFromAudioBytes(audio) {
+    if (audio.length >= 3 && audio[0] === 0x49 && audio[1] === 0x44 && audio[2] === 0x33)
+        return 'audio/mpeg'; // ID3 header
+    if (audio.length >= 2 && audio[0] === 0xff && (audio[1] & 0xe0) === 0xe0)
+        return 'audio/mpeg'; // MP3 sync word
+    // MP4/M4A: ftyp box at byte offset 4 (box size in first 4 bytes, then 'ftyp')
+    if (audio.length >= 12 && audio[4] === 0x66 && audio[5] === 0x74 && audio[6] === 0x79 && audio[7] === 0x70)
+        return 'audio/mp4';
+    // WebM: EBML header magic bytes
+    if (audio.length >= 4 && audio[0] === 0x1a && audio[1] === 0x45 && audio[2] === 0xdf && audio[3] === 0xa3)
+        return 'audio/webm';
+    if (audio.length >= 4 && audio[0] === 0x52 && audio[1] === 0x49 && audio[2] === 0x46 && audio[3] === 0x46)
+        return 'audio/wav'; // RIFF
+    if (audio.length >= 4 && audio[0] === 0x4f && audio[1] === 0x67 && audio[2] === 0x67 && audio[3] === 0x53)
+        return 'audio/ogg'; // OggS
+    if (audio.length >= 4 && audio[0] === 0x66 && audio[1] === 0x4c && audio[2] === 0x61 && audio[3] === 0x43)
+        return 'audio/flac'; // fLaC
+    return 'audio/mpeg';
+}
+function extensionFromMediaType(mediaType) {
+    const map = {
+        'audio/mpeg': 'mp3',
+        'audio/mp3': 'mp3',
+        'audio/wav': 'wav',
+        'audio/x-wav': 'wav',
+        'audio/ogg': 'ogg',
+        'audio/flac': 'flac',
+        'audio/webm': 'webm',
+        'audio/mp4': 'm4a',
+        'audio/m4a': 'm4a',
+        'audio/x-m4a': 'm4a',
+    };
+    return map[mediaType] || 'mp3';
+}
+function buildAudioFormData(audio, modelId) {
+    const mediaType = mediaTypeFromAudioBytes(audio);
+    const ext = extensionFromMediaType(mediaType);
+    const formData = new FormData();
+    // Copy into a fresh ArrayBuffer to satisfy TypeScript's BlobPart constraint
+    // (Uint8Array backed by SharedArrayBuffer is not assignable to BlobPart).
+    const buf = new Uint8Array(audio);
+    const blob = new Blob([buf], { type: mediaType });
+    formData.append('file', new File([blob], `audio.${ext}`, { type: mediaType }), `audio.${ext}`);
+    formData.append('model', modelId);
+    return { formData, mediaType };
+}
+// ─── OpenAI ──────────────────────────────────────────────────────────────────
+// POST https://api.openai.com/v1/audio/transcriptions
+// Multipart form: file, model, response_format, timestamp_granularities[], language
+//
+// gpt-4o-transcribe and gpt-4o-mini-transcribe only support response_format=json
+// (NOT verbose_json). Word timestamps require verbose_json, so these models
+// cannot return word-level timestamps. This is an OpenAI API limitation, not ours.
+// whisper-1 supports verbose_json and returns word timestamps.
+const GPT4O_TRANSCRIBE_MODELS = ['gpt-4o-transcribe', 'gpt-4o-mini-transcribe'];
+export function createOpenAITranscriptionProvider() {
+    return {
+        async transcribe(options) {
+            const apiKey = process.env['OPENAI_API_KEY'];
+            if (!apiKey) {
+                throw new Error('Missing OPENAI_API_KEY. Run: egaki login --provider openai --key <key>');
+            }
+            const { formData } = buildAudioFormData(options.audio, options.modelId);
+            // gpt-4o-transcribe models only support "json" format;
+            // whisper-1 supports "verbose_json" which enables word timestamps.
+            const isGpt4oTranscribe = GPT4O_TRANSCRIBE_MODELS.includes(options.modelId);
+            formData.append('response_format', isGpt4oTranscribe ? 'json' : 'verbose_json');
+            if (!isGpt4oTranscribe) {
+                formData.append('timestamp_granularities[]', 'word');
+            }
+            if (options.language) {
+                formData.append('language', options.language);
+            }
+            const response = await fetch('https://api.openai.com/v1/audio/transcriptions', {
+                method: 'POST',
+                headers: { 'Authorization': `Bearer ${apiKey}` },
+                body: formData,
+                signal: options.abortSignal,
+            });
+            if (!response.ok) {
+                const errorText = await response.text().catch(() => '');
+                throw new Error(`OpenAI transcription API error ${response.status}: ${errorText || response.statusText}`);
+            }
+            const json = await response.json();
+            // Prefer word-level segments from the `words` array; fall back to
+            // sentence-level `segments` if words are not present.
+            const segments = json.words?.map((w) => ({ text: w.word, startSecond: w.start, endSecond: w.end }))
+                ?? json.segments?.map((s) => ({ text: s.text, startSecond: s.start, endSecond: s.end }))
+                ?? [];
+            return {
+                text: json.text,
+                segments,
+                language: json.language,
+                durationInSeconds: json.duration,
+            };
+        },
+    };
+}
+export function createGroqTranscriptionProvider() {
+    return {
+        async transcribe(options) {
+            const apiKey = process.env['GROQ_API_KEY'];
+            if (!apiKey) {
+                throw new Error('Missing GROQ_API_KEY. Run: egaki login --provider groq --key <key>');
+            }
+            const { formData } = buildAudioFormData(options.audio, options.modelId);
+            formData.append('response_format', 'verbose_json');
+            formData.append('timestamp_granularities[]', 'word');
+            formData.append('timestamp_granularities[]', 'segment');
+            if (options.language) {
+                formData.append('language', options.language);
+            }
+            const response = await fetch('https://api.groq.com/openai/v1/audio/transcriptions', {
+                method: 'POST',
+                headers: { 'Authorization': `Bearer ${apiKey}` },
+                body: formData,
+                signal: options.abortSignal,
+            });
+            if (!response.ok) {
+                const errorText = await response.text().catch(() => '');
+                throw new Error(`Groq transcription API error ${response.status}: ${errorText || response.statusText}`);
+            }
+            const json = await response.json();
+            // Prefer word-level from the `words` array (now parsed correctly);
+            // fall back to sentence-level `segments`.
+            const segments = json.words?.map((w) => ({ text: w.word, startSecond: w.start, endSecond: w.end }))
+                ?? json.segments?.map((s) => ({ text: s.text, startSecond: s.start, endSecond: s.end }))
+                ?? [];
+            return {
+                text: json.text,
+                segments,
+                language: json.language,
+                durationInSeconds: json.duration,
+            };
+        },
+    };
+}
+export function createElevenLabsTranscriptionProvider() {
+    return {
+        async transcribe(options) {
+            const apiKey = process.env['ELEVENLABS_API_KEY'];
+            if (!apiKey) {
+                throw new Error('Missing ELEVENLABS_API_KEY. Run: egaki login --provider elevenlabs --key <key>');
+            }
+            const mediaType = mediaTypeFromAudioBytes(options.audio);
+            const ext = extensionFromMediaType(mediaType);
+            const formData = new FormData();
+            const buf = new Uint8Array(options.audio);
+            const blob = new Blob([buf], { type: mediaType });
+            formData.append('file', new File([blob], `audio.${ext}`, { type: mediaType }), `audio.${ext}`);
+            formData.append('model_id', options.modelId);
+            formData.append('timestamps_granularity', 'word');
+            formData.append('tag_audio_events', 'true');
+            if (options.language) {
+                formData.append('language_code', options.language);
+            }
+            const response = await fetch('https://api.elevenlabs.io/v1/speech-to-text', {
+                method: 'POST',
+                headers: { 'xi-api-key': apiKey },
+                body: formData,
+                signal: options.abortSignal,
+            });
+            if (!response.ok) {
+                const errorText = await response.text().catch(() => '');
+                throw new Error(`ElevenLabs transcription API error ${response.status}: ${errorText || response.statusText}`);
+            }
+            const json = await response.json();
+            // Filter to only 'word' type entries (skip 'spacing' and 'audio_event')
+            const segments = json.words
+                ?.filter((w) => w.type === 'word' && w.text.trim())
+                .map((w) => ({ text: w.text, startSecond: w.start ?? 0, endSecond: w.end ?? 0 }))
+                ?? [];
+            // Duration is the end time of the last word
+            const lastWord = json.words?.findLast((w) => w.type === 'word' && w.end != null);
+            const durationInSeconds = lastWord?.end ?? undefined;
+            return {
+                text: json.text,
+                segments,
+                language: json.language_code,
+                durationInSeconds,
+            };
+        },
+    };
+}
+export function createDeepgramTranscriptionProvider() {
+    return {
+        async transcribe(options) {
+            const apiKey = process.env['DEEPGRAM_API_KEY'];
+            if (!apiKey) {
+                throw new Error('Missing DEEPGRAM_API_KEY. Run: egaki login --provider deepgram --key <key>');
+            }
+            const mediaType = mediaTypeFromAudioBytes(options.audio);
+            const params = new URLSearchParams();
+            params.append('model', options.modelId);
+            params.append('smart_format', 'true');
+            if (options.language) {
+                params.append('language', options.language);
+            }
+            else {
+                params.append('detect_language', 'true');
+            }
+            const response = await fetch(`https://api.deepgram.com/v1/listen?${params}`, {
+                method: 'POST',
+                headers: {
+                    'Authorization': `Token ${apiKey}`,
+                    'Content-Type': mediaType,
+                },
+                body: new Uint8Array(options.audio),
+                signal: options.abortSignal,
+            });
+            if (!response.ok) {
+                const errorText = await response.text().catch(() => '');
+                throw new Error(`Deepgram transcription API error ${response.status}: ${errorText || response.statusText}`);
+            }
+            const json = await response.json();
+            const channel = json.results?.channels?.[0];
+            const alt = channel?.alternatives?.[0];
+            const segments = alt?.words?.map((w) => ({ text: w.word, startSecond: w.start, endSecond: w.end }))
+                ?? [];
+            return {
+                text: alt?.transcript ?? '',
+                segments,
+                language: channel?.detected_language,
+                durationInSeconds: json.metadata?.duration,
+            };
+        },
+    };
+}
+const CARTESIA_API_BASE = 'https://api.cartesia.ai';
+const CARTESIA_API_VERSION = '2026-03-01';
+export function createCartesiaTranscriptionProvider() {
+    return {
+        async transcribe(options) {
+            const apiKey = process.env['CARTESIA_API_KEY'];
+            if (!apiKey) {
+                throw new Error('Missing CARTESIA_API_KEY. Run: egaki login --provider cartesia --key <key>');
+            }
+            const mediaType = mediaTypeFromAudioBytes(options.audio);
+            const ext = extensionFromMediaType(mediaType);
+            const formData = new FormData();
+            const buf = new Uint8Array(options.audio);
+            const blob = new Blob([buf], { type: mediaType });
+            formData.append('file', new File([blob], `audio.${ext}`, { type: mediaType }), `audio.${ext}`);
+            formData.append('model', options.modelId);
+            formData.append('language', options.language || 'en');
+            formData.append('timestamp_granularities[]', 'word');
+            const response = await fetch(`${CARTESIA_API_BASE}/stt`, {
+                method: 'POST',
+                headers: {
+                    'Cartesia-Version': CARTESIA_API_VERSION,
+                    'Authorization': `Bearer ${apiKey}`,
+                },
+                body: formData,
+                signal: options.abortSignal,
+            });
+            if (!response.ok) {
+                const errorText = await response.text().catch(() => '');
+                throw new Error(`Cartesia STT API error ${response.status}: ${errorText || response.statusText}`);
+            }
+            const json = await response.json();
+            const segments = json.words?.map((w) => ({ text: w.word, startSecond: w.start, endSecond: w.end }))
+                ?? [];
+            return {
+                text: json.text,
+                segments,
+                language: json.language,
+                durationInSeconds: json.duration,
+            };
+        },
+    };
+}

package/dist/cli/video-model-catalog.d.ts

@@ -0,0 +1,2 @@
+export { VIDEO_CATALOG, findVideoModel, type VideoModelEntry, type VideoModelFeatures, type VideoModelCost, type PerVideoSecondCost, type UnknownCost as UnknownVideoCost, type VideoDurationPricingTier, } from './model-catalog.js';
+//# sourceMappingURL=video-model-catalog.d.ts.map

package/dist/cli/video-model-catalog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"video-model-catalog.d.ts","sourceRoot":"","sources":["../../src/cli/video-model-catalog.ts"],"names":[],"mappings":"AAIA,OAAO,EACL,aAAa,EACb,cAAc,EACd,KAAK,eAAe,EACpB,KAAK,kBAAkB,EACvB,KAAK,cAAc,EACnB,KAAK,kBAAkB,EACvB,KAAK,WAAW,IAAI,gBAAgB,EACpC,KAAK,wBAAwB,GAC9B,MAAM,oBAAoB,CAAA"}

package/dist/cli/video-model-catalog.js

@@ -0,0 +1,5 @@
+// Re-exports from the unified model catalog.
+// video-model-catalog.ts used to be a separate file. All video model data now
+// lives in model-catalog.ts alongside image models. This file exists only so
+// existing imports (gateway/src/plans.ts, etc.) keep working without changes.
+export { VIDEO_CATALOG, findVideoModel, } from './model-catalog.js';

package/dist/cli/xai-auth.d.ts

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+export type XaiAuth = {
+    email?: string;
+    access: string;
+    refresh: string;
+    expires: number;
+};
+declare const tokenResponseSchema: z.ZodObject<{
+    access_token: z.ZodString;
+    refresh_token: z.ZodOptional<z.ZodString>;
+    id_token: z.ZodOptional<z.ZodString>;
+    expires_in: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+type TokenResponse = z.infer<typeof tokenResponseSchema>;
+/** Returns true if the access token's exp claim is within the skew window. */
+export declare function accessTokenIsExpiring(token: string | undefined, skewMs?: number): boolean;
+export declare function refreshXaiToken(refreshToken: string): Promise<TokenResponse>;
+/**
+ * Run the xAI OAuth browser flow. Opens the system browser for authorization,
+ * waits for the callback, and returns an XaiAuth object with tokens.
+ */
+export declare function xaiOAuthLogin(): Promise<XaiAuth>;
+/**
+ * Returns a valid XaiAuth, refreshing the access token if it's expired or
+ * about to expire. Calls `save` to persist the refreshed tokens.
+ */
+export declare function getValidXaiAuth(auth: XaiAuth, save: (auth: XaiAuth) => void): Promise<XaiAuth | Error>;
+export {};
+//# sourceMappingURL=xai-auth.d.ts.map

package/dist/cli/xai-auth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"xai-auth.d.ts","sourceRoot":"","sources":["../../src/cli/xai-auth.ts"],"names":[],"mappings":"AAeA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAwBvB,MAAM,MAAM,OAAO,GAAG;IACpB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,MAAM,EAAE,MAAM,CAAA;IACd,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,MAAM,CAAA;CAChB,CAAA;AAED,QAAA,MAAM,mBAAmB;;;;;iBAKvB,CAAA;AAEF,KAAK,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AA+DxD,8EAA8E;AAC9E,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,MAAM,GAAG,SAAS,EACzB,MAAM,GAAE,MAAqC,GAC5C,OAAO,CAKT;AA6BD,wBAAsB,eAAe,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC,CAelF;AAwHD;;;GAGG;AACH,wBAAsB,aAAa,IAAI,OAAO,CAAC,OAAO,CAAC,CAoEtD;AAID;;;GAGG;AACH,wBAAsB,eAAe,CACnC,IAAI,EAAE,OAAO,EACb,IAAI,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,IAAI,GAC5B,OAAO,CAAC,OAAO,GAAG,KAAK,CAAC,CAuB1B"}