@extentos/mcp-server 0.0.56 → 0.0.58

package/dist/tools/data/codeExamples.js

@@ -0,0 +1,494 @@
+// Code-example catalog for getCodeExample. Each entry is a complete
+// SDK pattern in both Kotlin (Android) and Swift (iOS). These are the
+// canonical compositions a fresh agent should peel from when building
+// the most common voice-glasses use cases. Names match
+// `getCodeExample({pattern: "..."})`.
+//
+// Authorship contract: every example COMPILES against the post-pivot
+// library APIs (`glasses.audio.*`, `glasses.camera.*`,
+// `glasses.connection.state`, `glasses.toggles.*`). No spec runtime, no
+// app_callback, no triggers/blocks/actions DSL. Customer-side LLM
+// clients are referenced as `anthropic` / `vision` / `repo` without
+// importing — agents wire those to their existing backend.
+const VOICE_QA_ASSISTANT = {
+    pattern: "voice_qa_assistant",
+    title: "Voice Q&A assistant (wake + question + LLM + speak)",
+    description: "The canonical Strava-style flow: user says a wake phrase, AI greets, captures the user's free-form question with silence-VAD, calls the LLM, speaks the answer. Multi-turn loop optional. This is the F21 / F23 friction-log resolution — the single use case that motivated the pure-SDK pivot.",
+    code: {
+        kotlin: `class CoachHandler(
+    private val glasses: ExtentosGlasses,
+    private val anthropic: AnthropicClient,
+    private val workouts: WorkoutRepository,
+) {
+    private val scope = CoroutineScope(SupervisorJob() + Dispatchers.Default)
+
+    fun start() = scope.launch {
+        glasses.audio.transcriptions().collect { t ->
+            if (!t.isFinal) return@collect
+            if ("ask my coach" !in t.text.lowercase()) return@collect
+
+            glasses.audio.speak("What would you like to know?")
+
+            // Multi-turn loop: keep listening until user goes silent or
+            // says "stop". Each turn captures one utterance via the
+            // built-in silence-VAD (silence_timeout_seconds = 3).
+            while (currentCoroutineContext().isActive) {
+                val recording = glasses.audio.recordDiscrete(
+                    AudioRecordConfig(silenceTimeoutSeconds = 3.0)
+                ).getOrNull() ?: break
+
+                val question = recording.transcript.trim()
+                if (question.isEmpty() || "stop" in question.lowercase()) break
+
+                val answer = anthropic.ask(
+                    question = question,
+                    workoutHistory = workouts.recent(),
+                )
+                glasses.audio.speak(answer)
+            }
+        }
+    }
+
+    fun stop() = scope.cancel()
+}`,
+        swift: `final class CoachHandler: @unchecked Sendable {
+    private let glasses: any ExtentosGlasses
+    private let anthropic: AnthropicClient
+    private let workouts: WorkoutRepository
+    private var task: Task<Void, Never>?
+
+    init(glasses: any ExtentosGlasses, anthropic: AnthropicClient, workouts: WorkoutRepository) {
+        self.glasses = glasses
+        self.anthropic = anthropic
+        self.workouts = workouts
+    }
+
+    func start() {
+        task = Task { [glasses, anthropic, workouts] in
+            for await t in glasses.audio.transcriptions() {
+                guard case .final(let text, _, _, _) = t,
+                      text.lowercased().contains("ask my coach")
+                else { continue }
+
+                _ = await glasses.audio.speak("What would you like to know?")
+
+                // Multi-turn loop — silence-VAD per turn.
+                while !Task.isCancelled {
+                    let result = await glasses.audio.recordDiscrete(
+                        config: AudioRecordConfig(silenceTimeoutSeconds: 3)
+                    )
+                    guard case .success(let recording) = result else { break }
+
+                    let question = recording.transcript.trimmingCharacters(in: .whitespaces)
+                    if question.isEmpty || question.lowercased().contains("stop") { break }
+
+                    if let answer = try? await anthropic.ask(
+                        question: question,
+                        workoutHistory: workouts.recent()
+                    ) {
+                        _ = await glasses.audio.speak(answer)
+                    }
+                }
+            }
+        }
+    }
+
+    func stop() { task?.cancel() }
+}`,
+    },
+    explanation: "Three SDK primitives wired together: (1) glasses.audio.transcriptions() — continuous Flow of partial+final transcripts; customer matches the wake phrase via plain string contains. (2) glasses.audio.recordDiscrete(silenceTimeoutSeconds) — one-shot capture that auto-stops on N seconds of silence and returns the transcribed text. (3) glasses.audio.speak() — TTS via the platform engine. The while-loop is multi-turn voice mode (the F23 friction-log finding); break-condition is silence (recordDiscrete returns null), an empty utterance, or the user saying 'stop'.",
+    gotchas: [
+        "transcriptions() yields BOTH partial and final transcripts — always guard on t.isFinal before matching, or you'll fire the wake on a half-heard phrase.",
+        "recordDiscrete blocks until silence — call it from a coroutine/Task that's safe to suspend. Inside the while-loop is fine because it's already in a launched scope.",
+        "Don't subscribe to transcriptions() inside the while-loop — that creates a new recognizer per turn. Subscribe once outside the loop.",
+        "speak() blocks until done by default. If you want speak + listen-for-barge-in simultaneously, see the barge_in_speak pattern.",
+        "BuildConfig API-key fields don't reflect rotations because kotlinc inlines them at compile time. Use resValue / R.string.X for Android secrets. See getCredentialGuide.",
+    ],
+    relatedFeatures: ["voice_command", "transcription_incremental", "record_audio"],
+};
+const BARGE_IN_SPEAK = {
+    pattern: "barge_in_speak",
+    title: "Barge-in: cancel TTS when user starts speaking",
+    description: "The user interrupts the AI mid-response by talking. The AI shuts up immediately and listens. This is the F24 friction-log resolution; needs glasses.audio.cancelSpeak() which lands with this commit.",
+    code: {
+        kotlin: `suspend fun speakInterruptible(
+    glasses: ExtentosGlasses,
+    text: String,
+) = coroutineScope {
+    val speakJob = launch { glasses.audio.speak(text) }
+    val bargeIn = async {
+        glasses.audio.transcriptions()
+            .filter { it.isFinal && it.text.isNotBlank() }
+            .first()
+    }
+
+    // Whichever finishes first wins. If TTS completes naturally,
+    // bargeIn keeps waiting — cancel it to clean up.
+    speakJob.join()
+    if (bargeIn.isCompleted) {
+        // User barged in. Stop TTS, then handle the interrupting
+        // utterance (e.g. feed it back into your conversation loop).
+        glasses.audio.cancelSpeak()
+        val utterance = bargeIn.await()
+        handleInterrupt(utterance.text)
+    } else {
+        bargeIn.cancel()
+    }
+}`,
+        swift: `func speakInterruptible(
+    glasses: any ExtentosGlasses,
+    text: String
+) async {
+    await withTaskGroup(of: BargeOutcome.self) { group in
+        group.addTask {
+            _ = await glasses.audio.speak(text)
+            return .speakFinished
+        }
+        group.addTask {
+            for await t in glasses.audio.transcriptions() {
+                if case .final(let utterance, _, _, _) = t, !utterance.isEmpty {
+                    return .bargedIn(utterance)
+                }
+            }
+            return .speakFinished
+        }
+
+        // Take whichever completes first.
+        if let first = await group.next() {
+            group.cancelAll()
+            if case .bargedIn(let utterance) = first {
+                await glasses.audio.cancelSpeak()
+                await handleInterrupt(utterance)
+            }
+        }
+    }
+}
+
+enum BargeOutcome {
+    case speakFinished
+    case bargedIn(String)
+}`,
+    },
+    explanation: "Run speak() and a transcription-listener concurrently. The first to finish wins. If the user starts speaking before TTS finishes, cancelSpeak() shuts the engine off mid-utterance (Android tts.stop() / iOS synthesizer.stopSpeaking(at: .immediate)) and the customer handles the interrupting text. The race-and-cancel pattern is standard coroutine / TaskGroup territory; the SDK piece is glasses.audio.cancelSpeak().",
+    gotchas: [
+        "cancelSpeak() is fire-and-forget — it doesn't await a 'really stopped' confirmation. The platform TTS engines have their own state machines.",
+        "If transcriptions() captures the AI's own voice bleeding through the mic, the loop fires on its own speech. Meta DAT's HFP profile generally suppresses this via hardware echo cancellation, but verify on real hardware — BrowserSim doesn't replicate it.",
+        "Don't filter Partial transcripts unless you really mean it; the user's first half-syllable shouldn't trigger barge-in. Wait for isFinal.",
+    ],
+    relatedFeatures: ["transcription_incremental"],
+};
+const PHOTO_DESCRIBE_VOICE = {
+    pattern: "photo_describe_voice",
+    title: "Voice-activated photo + vision-LLM description",
+    description: "User says 'describe what you see', glasses capture a photo, customer's vision LLM (Anthropic Claude Vision / OpenAI GPT-4V / Gemini) describes it, AI speaks the description. The canonical 'AI vision on glasses' demo.",
+    code: {
+        kotlin: `class VisionHandler(
+    private val glasses: ExtentosGlasses,
+    private val vision: VisionClient,
+) {
+    private val scope = CoroutineScope(SupervisorJob() + Dispatchers.Default)
+
+    fun start() = scope.launch {
+        glasses.audio.transcriptions().collect { t ->
+            if (!t.isFinal) return@collect
+            if ("describe what you see" !in t.text.lowercase()) return@collect
+
+            val photo = glasses.camera.capturePhoto(
+                PhotoConfig(resolution = "MEDIUM", format = "jpeg")
+            ).getOrNull() ?: run {
+                glasses.audio.speak("I couldn't take a photo.")
+                return@collect
+            }
+
+            val description = vision.describe(
+                imageUri = photo.uri,
+                prompt = "Describe this scene briefly, conversationally.",
+            )
+            glasses.audio.speak(description.ifBlank { "I couldn't describe that one." })
+        }
+    }
+
+    fun stop() = scope.cancel()
+}`,
+        swift: `final class VisionHandler: @unchecked Sendable {
+    private let glasses: any ExtentosGlasses
+    private let vision: VisionClient
+    private var task: Task<Void, Never>?
+
+    init(glasses: any ExtentosGlasses, vision: VisionClient) {
+        self.glasses = glasses
+        self.vision = vision
+    }
+
+    func start() {
+        task = Task { [glasses, vision] in
+            for await t in glasses.audio.transcriptions() {
+                guard case .final(let text, _, _, _) = t,
+                      text.lowercased().contains("describe what you see")
+                else { continue }
+
+                let captureResult = await glasses.camera.capturePhoto(
+                    config: PhotoConfig(resolution: .medium, format: .jpeg)
+                )
+                guard case .success(let photo) = captureResult else {
+                    _ = await glasses.audio.speak("I couldn't take a photo.")
+                    continue
+                }
+
+                // Photo.url is a URL whose scheme varies by transport
+                // (file:// on RealMeta / LocalSim, data: on BrowserSim).
+                // Decode via the bundled extension; pass the bytes to
+                // your vision LLM however it expects them (base64, Data).
+                let image = await photo.loadImage()
+                let description = (try? await vision.describe(
+                    image: image,
+                    prompt: "Describe this scene briefly, conversationally."
+                )) ?? ""
+                let answer = description.isEmpty
+                    ? "I couldn't describe that one."
+                    : description
+                _ = await glasses.audio.speak(answer)
+            }
+        }
+    }
+
+    func stop() { task?.cancel() }
+}`,
+    },
+    explanation: "Voice wake → photo capture → vision LLM → spoken response. The photo URL shape varies by transport (data: in BrowserSim, file: in RealMeta + LocalSim). Android consumers use Photos.loadBase64(uri) / Photos.mediaTypeFromUri(uri) helpers; iOS consumers use the bundled `photo.loadImage()` extension on Photo to materialize a UIImage from either scheme.",
+    gotchas: [
+        "capturePhoto blocks until the photo is captured (~300-500ms on Meta DAT). Don't call it on a UI thread.",
+        "Android: Photos.loadBase64(uri) bridges both data: and file: URIs into bytes ready for Claude Vision / GPT-4V request bodies. iOS: `photo.loadImage()` (extension on Photo) returns a UIImage; for base64 you encode the JPEG/PNG data yourself via Data.base64EncodedString().",
+        "Vision LLM response time is 2-8 seconds p95; the user is staring at the glasses waiting. Consider an earcon at capture time so they know it worked.",
+    ],
+    relatedFeatures: ["capture_photo", "voice_command", "transcription_incremental"],
+};
+const LIVE_TRANSCRIPTION_UI = {
+    pattern: "live_transcription_ui",
+    title: "Live transcription feeding into your app's UI",
+    description: "Continuous transcripts from the glasses mic, surfaced as live captions in your existing Compose / SwiftUI state. The canonical 'live captions' / meeting-notes / translation-app shape.",
+    code: {
+        kotlin: `class TranscriptionViewModel(
+    private val glasses: ExtentosGlasses,
+) : ViewModel() {
+    private val _transcript = MutableStateFlow<String>("")
+    val transcript: StateFlow<String> = _transcript.asStateFlow()
+
+    init {
+        viewModelScope.launch {
+            glasses.audio.transcriptions(
+                TranscriptionConfig(language = "en-US")
+            ).collect { t ->
+                if (t.isFinal) {
+                    // Append finalized segments; partials replace the
+                    // tentative tail. Simple naive concatenation here —
+                    // production apps usually segment by speaker / time.
+                    _transcript.value = _transcript.value + " " + t.text
+                }
+            }
+        }
+    }
+}
+
+// In your Compose UI:
+//   val transcript by viewModel.transcript.collectAsState()
+//   Text(transcript)`,
+        swift: `@MainActor
+final class TranscriptionViewModel: ObservableObject {
+    @Published var transcript: String = ""
+    private var task: Task<Void, Never>?
+
+    init(glasses: any ExtentosGlasses) {
+        // The class is @MainActor-isolated, so the Task created here
+        // inherits MainActor isolation — mutating @Published transcript
+        // is synchronous-on-main, no MainActor.run hop required.
+        let stream = glasses.audio.transcriptions(
+            config: TranscriptionConfig(language: "en-US")
+        )
+        task = Task { [weak self] in
+            for await t in stream {
+                guard case .final(let text, _, _, _) = t else { continue }
+                self?.transcript += " " + text
+            }
+        }
+    }
+
+    deinit { task?.cancel() }
+}
+
+// In your SwiftUI view:
+//   @StateObject var vm = TranscriptionViewModel(glasses: glasses)
+//   Text(vm.transcript)`,
+    },
+    explanation: "Subscribe to transcriptions() once at view-model init, append final segments to your state. Compose / SwiftUI re-renders on the StateFlow / @Published update. The library auto-restarts the recognizer between utterances to keep the stream continuous (~100-300ms gap).",
+    gotchas: [
+        "transcriptions() is gated by listening_mode + audio_capture_enabled + privacy_mode toggles. If transcripts stop arriving unexpectedly, check those — likely listening_mode flipped to 'off' from a UI control.",
+        "Mic audio routes over HFP while transcriptions are active; A2DP music playback drops to mono 8 kHz for the duration. Show a 'listening…' indicator so the user knows why.",
+        "Partial transcripts arrive 5-20 per second on a normal-speed utterance. Throttle / debounce in your UI if you render every emission — rendering 200 Compose updates per second is wasteful.",
+    ],
+    relatedFeatures: ["transcription_incremental"],
+};
+const VOICE_NOTES = {
+    pattern: "voice_notes",
+    title: "Voice note (wake + record + persist)",
+    description: "'Take a note' style flow: wake phrase → record_audio with silence-VAD → save the transcript to the customer's notes repository (Notion, Supabase, filesystem, etc.).",
+    code: {
+        kotlin: `class NotesHandler(
+    private val glasses: ExtentosGlasses,
+    private val notes: NotesRepository,
+) {
+    private val scope = CoroutineScope(SupervisorJob() + Dispatchers.Default)
+
+    fun start() = scope.launch {
+        glasses.audio.transcriptions().collect { t ->
+            if (!t.isFinal) return@collect
+            if ("take a note" !in t.text.lowercase()) return@collect
+
+            glasses.audio.speak("Recording.")
+            val recording = glasses.audio.recordDiscrete(
+                AudioRecordConfig(
+                    maxDurationSeconds = 30,
+                    silenceTimeoutSeconds = 3.0,
+                )
+            ).getOrNull() ?: run {
+                glasses.audio.speak("I didn't catch that.")
+                return@collect
+            }
+
+            if (recording.transcript.isBlank()) {
+                glasses.audio.speak("I didn't catch that.")
+                return@collect
+            }
+
+            notes.save(recording.transcript)
+            glasses.audio.speak("Saved.")
+        }
+    }
+
+    fun stop() = scope.cancel()
+}`,
+        swift: `final class NotesHandler: @unchecked Sendable {
+    private let glasses: any ExtentosGlasses
+    private let notes: NotesRepository
+    private var task: Task<Void, Never>?
+
+    init(glasses: any ExtentosGlasses, notes: NotesRepository) {
+        self.glasses = glasses
+        self.notes = notes
+    }
+
+    func start() {
+        task = Task { [glasses, notes] in
+            for await t in glasses.audio.transcriptions() {
+                guard case .final(let text, _, _, _) = t,
+                      text.lowercased().contains("take a note")
+                else { continue }
+
+                _ = await glasses.audio.speak("Recording.")
+                let result = await glasses.audio.recordDiscrete(
+                    config: AudioRecordConfig(
+                        maxDurationSeconds: 30,
+                        silenceTimeoutSeconds: 3
+                    )
+                )
+                guard case .success(let recording) = result,
+                      !recording.transcript.isEmpty
+                else {
+                    _ = await glasses.audio.speak("I didn't catch that.")
+                    continue
+                }
+
+                await notes.save(recording.transcript)
+                _ = await glasses.audio.speak("Saved.")
+            }
+        }
+    }
+
+    func stop() { task?.cancel() }
+}`,
+    },
+    explanation: "Same recordDiscrete primitive as voice_qa_assistant, just terminating in a persistence call instead of an LLM round-trip. The 'Recording.' speech is optional — give the user audible feedback that the capture started, since the silence-VAD doesn't beep on its own.",
+    gotchas: [
+        "Pre-warm the mic with the 'Recording.' speech_text — the SCO mic profile takes ~150-300ms to switch from A2DP. Calling recordDiscrete immediately after the wake-phrase match can drop the first half-syllable.",
+        "maxDurationSeconds caps at 60 in the SDK; if you need longer notes use audio_chunks + your own buffering.",
+    ],
+    relatedFeatures: ["voice_command", "record_audio", "transcription_incremental"],
+};
+const CONNECTION_PAGE_SETUP = {
+    pattern: "connection_page_setup",
+    title: "Bootstrap + ExtentosConnectionPage placement",
+    description: "The minimum wiring for any Extentos integration: bootstrap the library in Application onCreate / AppDelegate, and drop ExtentosConnectionPage into the customer's existing navigation. From there every other SDK call works.",
+    code: {
+        kotlin: `// In your Application subclass (e.g. MyApp.kt):
+class MyApp : Application(), ExtentosBootstrap {
+    override lateinit var glasses: ExtentosGlasses
+
+    override fun onCreate() {
+        super.onCreate()
+        glasses = ExtentosGlasses.create(
+            ExtentosConfig(applicationContext = this)
+        )
+    }
+}
+
+// In your AndroidManifest.xml:
+//   <application android:name=".MyApp" ...>
+//
+// In your NavHost (or wherever your tabs/screens live):
+//
+//   val bootstrap = LocalContext.current.applicationContext as ExtentosBootstrap
+//
+//   NavHost(navController = nav, startDestination = "home") {
+//       composable("home") { HomeScreen() }
+//       composable("glasses") { ExtentosConnectionPage(bootstrap.glasses) }
+//   }
+//
+// Wire a tab or button to navigate to "glasses".`,
+        swift: `// In your App / AppDelegate:
+@main
+struct MyApp: App {
+    let glasses: any ExtentosGlasses
+
+    init() {
+        glasses = Extentos.create(config: ExtentosConfig())
+    }
+
+    var body: some Scene {
+        WindowGroup {
+            ContentView(glasses: glasses)
+        }
+    }
+}
+
+// In your top-level view:
+struct ContentView: View {
+    let glasses: any ExtentosGlasses
+
+    var body: some View {
+        TabView {
+            HomeView()
+                .tabItem { Label("Home", systemImage: "house") }
+            ExtentosConnectionPage(glasses: glasses)
+                .tabItem { Label("Glasses", systemImage: "eyeglasses") }
+        }
+    }
+}`,
+    },
+    explanation: "Two pieces of wiring: (1) construct the ExtentosGlasses instance once at app init — that starts the auto-bind probe, install registration, and telemetry hooks; (2) drop the connection page into navigation. Everything else (audio.X, camera.X, etc.) just uses the glasses reference passed through your DI / view models.",
+    gotchas: [
+        "Don't construct multiple ExtentosGlasses instances — there's no caching and each one fires its own auto-bind probe + telemetry registration. Hold one at the Application level and pass it down.",
+        "Android: applicationContext must be non-null in ExtentosConfig if any handler needs Context (e.g., to use filesDir). The canonical bootstrap class implements ExtentosBootstrap so handlers can pull it via `LocalContext.current.applicationContext as ExtentosBootstrap`.",
+        "The connection page renders the pairing flow / sim status / capability indicators automatically — don't try to build your own. Customize via ConnectionPageConfig if you need to hide sections.",
+    ],
+    relatedFeatures: [],
+};
+export const CODE_EXAMPLES = {
+    voice_qa_assistant: VOICE_QA_ASSISTANT,
+    barge_in_speak: BARGE_IN_SPEAK,
+    photo_describe_voice: PHOTO_DESCRIBE_VOICE,
+    live_transcription_ui: LIVE_TRANSCRIPTION_UI,
+    voice_notes: VOICE_NOTES,
+    connection_page_setup: CONNECTION_PAGE_SETUP,
+};
+export const CODE_EXAMPLE_PATTERNS = Object.keys(CODE_EXAMPLES).sort();
+//# sourceMappingURL=codeExamples.js.map

package/dist/tools/data/codeExamples.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"codeExamples.js","sourceRoot":"","sources":["../../../src/tools/data/codeExamples.ts"],"names":[],"mappings":"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"}

package/dist/tools/data/version.js

@@ -6,13 +6,13 @@
 // scaffold a project pointing at 1.0.0 (no probe code) while running
 // 0.0.7+ server-side smarts that needed 1.1.x to function.
 //
-// Pre-public-Maven note: 1.1.27-pair currently lives only on the dev's
+// Pre-public-Maven note: 1.1.28-pair currently lives only on the dev's
 // mavenLocal (./gradlew :glasses-core:publishToMavenLocal). Until a
 // public Maven Central / JitPack publish lands, scaffolded projects
 // require the dev to run mavenLocal-publish first. Document next to
 // the dependency notation in generateConnectionModule.
 export const VERSION_INFO = {
-    latestStable: "1.1.27-pair",
+    latestStable: "1.1.28-pair",
     specVersion: "1.0",
     android: {
         minimumSdk: 31,
@@ -26,7 +26,7 @@ export const VERSION_INFO = {
         kotlinVersion: "2.0.0",
         // Toolchain minimums (F-R4-8 from DOGFOOD_R4). The library's transitive
         // Compose deps determine the floor:
-        // - com.extentos:glasses-ui:1.1.27-pair brings in androidx.compose.* 1.9.0
+        // - com.extentos:glasses-ui:1.1.28-pair brings in androidx.compose.* 1.9.0
         //   (via compose-bom 2024.10.00 and direct deps)
         // - Compose 1.9.0 AAR-metadata declares "requires AGP >= 8.6.0"
         // - AGP 8.6+ requires Gradle 8.7+ (Android Gradle Plugin compatibility table)
@@ -50,13 +50,13 @@ export const VERSION_INFO = {
     },
     artifacts: {
         android: {
-            core: "com.extentos:glasses:1.1.27-pair",
-            ui: "com.extentos:glasses-ui:1.1.27-pair",
-            debug: "com.extentos:glasses-debug:1.1.27-pair",
+            core: "com.extentos:glasses:1.1.28-pair",
+            ui: "com.extentos:glasses-ui:1.1.28-pair",
+            debug: "com.extentos:glasses-debug:1.1.28-pair",
         },
         ios: {
             package: "https://github.com/extentos/swift-glasses",
-            version: "1.1.27-pair",
+            version: "1.1.28-pair",
             products: ["GlassesCore", "GlassesUI", "GlassesDebug", "GlassesLifecycle", "GlassesTesting"],
         },
     },

package/dist/tools/definitions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"definitions.d.ts","sourceRoot":"","sources":["../../src/tools/definitions.ts"],"names":[],"mappings":"AAKA,MAAM,WAAW,OAAO;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IAMpB,WAAW,EAAE;QACX,IAAI,EAAE,QAAQ,CAAC;QACf,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QACpC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;QACpB,oBAAoB,EAAE,KAAK,CAAC;KAC7B,CAAC;CACH;AAMD,eAAO,MAAM,eAAe,EAAE,OAAO,EAkdpC,CAAC;AAEF,eAAO,MAAM,SAAS,QAAyB,CAAC;AAShD,wBAAgB,iCAAiC,CAC/C,IAAI,GAAE,SAAS,OAAO,EAAoB,GACzC,IAAI,CAiBN"}
+{"version":3,"file":"definitions.d.ts","sourceRoot":"","sources":["../../src/tools/definitions.ts"],"names":[],"mappings":"AAcA,MAAM,WAAW,OAAO;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IAMpB,WAAW,EAAE;QACX,IAAI,EAAE,QAAQ,CAAC;QACf,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QACpC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;QACpB,oBAAoB,EAAE,KAAK,CAAC;KAC7B,CAAC;CACH;AAMD,eAAO,MAAM,eAAe,EAAE,OAAO,EAiXpC,CAAC;AAEF,eAAO,MAAM,SAAS,QAAyB,CAAC;AAShD,wBAAgB,iCAAiC,CAC/C,IAAI,GAAE,SAAS,OAAO,EAAoB,GACzC,IAAI,CAiBN"}