@codingame/monaco-vscode-chat-service-override 36.2.7 → 37.0.0

package/vscode/src/vs/workbench/contrib/chat/browser/planReviewFeedback/planReviewFeedbackEditorContribution.js

@@ -1,572 +0,0 @@
-
-import { registerCss } from '@codingame/monaco-vscode-api/css';
-import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
-import * as planReviewFeedback from './media/planReviewFeedback.css';
-import { DisposableStore, Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
-import { OverlayWidgetPositionPreference } from '@codingame/monaco-vscode-api/vscode/vs/editor/browser/editorBrowser';
-import { registerEditorContribution, EditorContributionInstantiation } from '@codingame/monaco-vscode-api/vscode/vs/editor/browser/editorExtensions';
-import { EditorOption } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/config/editorOptions';
-import { SelectionDirection } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/selection';
-import { Range } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range';
-import { OverviewRulerLane } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/model';
-import { themeColorFromId } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/themeService';
-import { overviewRulerInfo } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/editorColorRegistry';
-import { createElement, getWindow, getActiveElement, addStandardDisposableListener, isActiveElement } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
-import { KeyCode } from '@codingame/monaco-vscode-api/vscode/vs/base/common/keyCodes';
-import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
-import { ActionBar } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/actionbar/actionbar';
-import { Action } from '@codingame/monaco-vscode-api/vscode/vs/base/common/actions';
-import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
-import { ThemeIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/themables';
-import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
-import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
-import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
-import { MenuWorkbenchToolBar, HiddenItemStrategy } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/browser/toolbar';
-import { IPlanReviewFeedbackService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/planReviewFeedback/planReviewFeedbackService.service';
-import { PlanReviewFeedbackMenuId, navigationBearingFakeActionId, hasPlanReviewFeedback } from './planReviewFeedbackEditorActions.js';
-import { ActionViewItem } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/actionbar/actionViewItems';
-import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
-import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
-import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
-
-registerCss(planReviewFeedback);
-class PlanReviewFeedbackInputWidget {
-    static {
-        this._ID = "planReviewFeedback.inputWidget";
-    }
-    static {
-        this._MIN_WIDTH = 150;
-    }
-    static {
-        this._MAX_WIDTH = 400;
-    }
-    constructor(_editor) {
-        this._editor = _editor;
-        this.allowEditorOverflow = false;
-        this._position = null;
-        this._lineHeight = 22;
-        this._onDidTriggerAdd = ( new Emitter());
-        this.onDidTriggerAdd = this._onDidTriggerAdd.event;
-        this._domNode = createElement("div");
-        this._domNode.classList.add("plan-review-feedback-input-widget");
-        this._domNode.style.display = "none";
-        this._inputElement = createElement("textarea");
-        this._inputElement.rows = 1;
-        this._inputElement.placeholder = ( localize(7428, "Add Feedback"));
-        this._domNode.appendChild(this._inputElement);
-        this._measureElement = createElement("span");
-        this._measureElement.classList.add("plan-review-feedback-input-measure");
-        this._domNode.appendChild(this._measureElement);
-        const actionsContainer = createElement("div");
-        actionsContainer.classList.add("plan-review-feedback-input-actions");
-        this._domNode.appendChild(actionsContainer);
-        this._addAction = ( new Action("planReviewFeedback.add", ( localize(7429, "Add Feedback (Enter)")), ThemeIcon.asClassName(Codicon.plus), false, () => {
-            this._onDidTriggerAdd.fire();
-            return Promise.resolve();
-        }));
-        this._actionBar = ( new ActionBar(actionsContainer));
-        this._actionBar.push(this._addAction, {
-            icon: true,
-            label: false,
-            keybinding: ( localize(7430, "Enter"))
-        });
-        this._inputElement.style.lineHeight = `${this._lineHeight}px`;
-    }
-    getId() {
-        return PlanReviewFeedbackInputWidget._ID;
-    }
-    getDomNode() {
-        return this._domNode;
-    }
-    getPosition() {
-        return this._position;
-    }
-    get inputElement() {
-        return this._inputElement;
-    }
-    setPosition(position) {
-        this._position = position;
-        this._editor.layoutOverlayWidget(this);
-    }
-    show() {
-        this._domNode.style.display = "";
-    }
-    hide() {
-        this._domNode.style.display = "none";
-    }
-    clearInput() {
-        this._inputElement.value = "";
-        this._updateActionEnabled();
-        this._autoSize();
-    }
-    autoSize() {
-        this._autoSize();
-    }
-    updateActionEnabled() {
-        this._updateActionEnabled();
-    }
-    _updateActionEnabled() {
-        const hasText = this._inputElement.value.trim().length > 0;
-        this._addAction.enabled = hasText;
-    }
-    _autoSize() {
-        const text = this._inputElement.value || this._inputElement.placeholder;
-        this._measureElement.textContent = text;
-        const textWidth = this._measureElement.scrollWidth;
-        const width = Math.max(
-            PlanReviewFeedbackInputWidget._MIN_WIDTH,
-            Math.min(textWidth + 10, PlanReviewFeedbackInputWidget._MAX_WIDTH)
-        );
-        this._inputElement.style.width = `${width}px`;
-        this._inputElement.style.height = "auto";
-        const newHeight = Math.max(this._inputElement.scrollHeight, this._lineHeight);
-        this._inputElement.style.height = `${newHeight}px`;
-    }
-    dispose() {
-        this._actionBar.dispose();
-        this._addAction.dispose();
-        this._onDidTriggerAdd.dispose();
-    }
-}
-class PlanReviewFeedbackOverlayWidget {
-    static {
-        this._ID = "planReviewFeedback.overlayWidget";
-    }
-    constructor(_codeEditor, _instaService) {
-        this._instaService = _instaService;
-        this._showStore = ( new DisposableStore());
-        this._navigationBearings = observableValue("planReviewFeedbackBearings", {
-            activeIdx: -1,
-            totalCount: 0
-        });
-        this._domNode = createElement("div");
-        this._domNode.classList.add("plan-review-feedback-overlay-widget");
-        this._domNode.style.display = "none";
-        this._toolbarNode = createElement("div");
-        this._toolbarNode.classList.add("plan-review-feedback-overlay-toolbar");
-        this._domNode.appendChild(this._toolbarNode);
-    }
-    getId() {
-        return PlanReviewFeedbackOverlayWidget._ID;
-    }
-    getDomNode() {
-        return this._domNode;
-    }
-    getPosition() {
-        return {
-            preference: OverlayWidgetPositionPreference.BOTTOM_RIGHT_CORNER
-        };
-    }
-    show(navigationBearings) {
-        this._showStore.clear();
-        this._navigationBearings.set(navigationBearings, undefined);
-        this._domNode.style.display = "";
-        this._showStore.add(
-            this._instaService.createInstance(MenuWorkbenchToolBar, this._toolbarNode, PlanReviewFeedbackMenuId, {
-                telemetrySource: "planReviewFeedback.overlayToolbar",
-                hiddenItemStrategy: HiddenItemStrategy.Ignore,
-                toolbarOptions: {
-                    primaryGroup: () => true,
-                    useSeparatorsInPrimaryActions: true
-                },
-                menuOptions: {
-                    renderShortTitle: true
-                },
-                actionViewItemProvider: (action, options) => {
-                    if (action.id === navigationBearingFakeActionId) {
-                        const that = this;
-                        return new (class extends ActionViewItem {
-                            constructor() {
-                                super(undefined, action, {
-                                    ...options,
-                                    icon: false,
-                                    label: true,
-                                    keybindingNotRenderedWithLabel: true
-                                });
-                            }
-                            render(container) {
-                                super.render(container);
-                                container.classList.add("label-item");
-                                this._store.add(autorun(r => {
-                                    if (!this.label) {
-                                        return;
-                                    }
-                                    const {
-                                        activeIdx,
-                                        totalCount
-                                    } = that._navigationBearings.read(r);
-                                    if (totalCount > 0) {
-                                        const current = activeIdx === -1 ? 1 : activeIdx + 1;
-                                        this.label.innerText = ( localize(7431, "{0}/{1}", current, totalCount));
-                                    } else {
-                                        this.label.innerText = ( localize(7432, "0/0"));
-                                    }
-                                }));
-                            }
-                        })();
-                    }
-                    return ( new ActionViewItem(undefined, action, {
-                        ...options,
-                        icon: true,
-                        label: false,
-                        keybindingNotRenderedWithLabel: true
-                    }));
-                }
-            })
-        );
-    }
-    hide() {
-        this._showStore.clear();
-        this._domNode.style.display = "none";
-        this._navigationBearings.set({
-            activeIdx: -1,
-            totalCount: 0
-        }, undefined);
-    }
-    dispose() {
-        this._showStore.dispose();
-    }
-}
-let PlanReviewFeedbackEditorContribution = class PlanReviewFeedbackEditorContribution extends Disposable {
-    static {
-        this.ID = "planReviewFeedback.editorContribution";
-    }
-    constructor(
-        _editor,
-        _planReviewFeedbackService,
-        contextKeyService,
-        _instantiationService
-    ) {
-        super();
-        this._editor = _editor;
-        this._planReviewFeedbackService = _planReviewFeedbackService;
-        this._instantiationService = _instantiationService;
-        this._visible = false;
-        this._mouseDown = false;
-        this._suppressSelectionChangeOnce = false;
-        this._isActivePlan = false;
-        this._widgetListeners = this._register(( new DisposableStore()));
-        this._decorations = this._editor.createDecorationsCollection();
-        this._hasFeedbackContextKey = hasPlanReviewFeedback.bindTo(contextKeyService);
-        this._register(this._editor.onDidChangeCursorSelection(() => this._onSelectionChanged()));
-        this._register(this._editor.onDidChangeModel(() => this._onModelChanged()));
-        this._register(this._editor.onDidScrollChange(() => {
-            if (this._visible) {
-                this._updatePosition();
-            }
-        }));
-        this._register(this._editor.onMouseDown(e => {
-            if (this._isWidgetTarget(e.event.target)) {
-                return;
-            }
-            this._mouseDown = true;
-            this._hide();
-        }));
-        this._register(this._editor.onMouseUp(e => {
-            this._mouseDown = false;
-            if (this._isWidgetTarget(e.event.target)) {
-                return;
-            }
-            this._onSelectionChanged();
-        }));
-        this._register(this._editor.onDidBlurEditorWidget(() => {
-            if (!this._visible) {
-                return;
-            }
-            getWindow(this._editor.getDomNode()).setTimeout(() => {
-                if (!this._visible) {
-                    return;
-                }
-                if (this._isWidgetTarget(getActiveElement(this._editor.getDomNode().ownerDocument))) {
-                    return;
-                }
-                this._hide();
-            }, 0);
-        }));
-        this._register(this._editor.onDidFocusEditorText(() => this._onSelectionChanged()));
-        this._register(
-            this._planReviewFeedbackService.onDidChangeRegistrations(() => this._onModelChanged())
-        );
-        this._register(
-            this._planReviewFeedbackService.onDidChangeFeedback(() => this._updateDecorations())
-        );
-        this._register(
-            this._planReviewFeedbackService.onDidChangeNavigation(() => this._updateDecorations())
-        );
-        this._onModelChanged();
-    }
-    _isWidgetTarget(target) {
-        return !!this._widget && !!target && this._widget.getDomNode().contains(target);
-    }
-    _ensureWidget() {
-        if (!this._widget) {
-            this._widget = ( new PlanReviewFeedbackInputWidget(this._editor));
-            this._register(this._widget.onDidTriggerAdd(() => this._addFeedback()));
-            this._editor.addOverlayWidget(this._widget);
-        }
-        return this._widget;
-    }
-    _onModelChanged() {
-        this._hide();
-        this._suppressSelectionChangeOnce = false;
-        const model = this._editor.getModel();
-        this._isActivePlan = !!model && this._planReviewFeedbackService.isActivePlanReview(model.uri);
-        this._updateDecorations();
-    }
-    _onSelectionChanged() {
-        if (this._suppressSelectionChangeOnce) {
-            this._suppressSelectionChangeOnce = false;
-            return;
-        }
-        if (this._mouseDown || !this._editor.hasTextFocus()) {
-            return;
-        }
-        if (!this._isActivePlan) {
-            this._hide();
-            return;
-        }
-        const selection = this._editor.getSelection();
-        if (!selection) {
-            this._hide();
-            return;
-        }
-        const model = this._editor.getModel();
-        if (!model) {
-            this._hide();
-            return;
-        }
-        this._show();
-    }
-    _show() {
-        const widget = this._ensureWidget();
-        const wasVisible = this._visible;
-        if (!wasVisible) {
-            this._visible = true;
-            this._registerWidgetListeners(widget);
-            widget.clearInput();
-        }
-        widget.show();
-        this._updatePosition();
-    }
-    _hide() {
-        if (!this._visible) {
-            return;
-        }
-        this._visible = false;
-        this._widgetListeners.clear();
-        if (this._widget) {
-            this._widget.hide();
-            this._widget.setPosition(null);
-            this._widget.clearInput();
-        }
-    }
-    _registerWidgetListeners(widget) {
-        this._widgetListeners.clear();
-        const editorDomNode = this._editor.getDomNode();
-        if (editorDomNode) {
-            this._widgetListeners.add(addStandardDisposableListener(editorDomNode, "keydown", e => {
-                if (!this._visible) {
-                    return;
-                }
-                if (!this._editor.hasTextFocus()) {
-                    return;
-                }
-                if (e.keyCode === KeyCode.Ctrl || e.keyCode === KeyCode.Shift || e.keyCode === KeyCode.Alt || e.keyCode === KeyCode.Meta) {
-                    return;
-                }
-                if (e.keyCode === KeyCode.Escape) {
-                    this._hide();
-                    this._editor.focus();
-                    return;
-                }
-                if ((e.ctrlKey || e.metaKey) && e.keyCode === KeyCode.KeyI) {
-                    e.preventDefault();
-                    e.stopPropagation();
-                    widget.inputElement.focus();
-                    return;
-                }
-                if (e.ctrlKey || e.altKey || e.metaKey) {
-                    return;
-                }
-                if (e.keyCode === KeyCode.UpArrow || e.keyCode === KeyCode.DownArrow || e.keyCode === KeyCode.LeftArrow || e.keyCode === KeyCode.RightArrow) {
-                    return;
-                }
-                if (!this._editor.getOption(EditorOption.readOnly)) {
-                    return;
-                }
-                if (!isActiveElement(widget.inputElement)) {
-                    widget.inputElement.focus();
-                }
-            }));
-        }
-        this._widgetListeners.add(addStandardDisposableListener(widget.inputElement, "keydown", e => {
-            if (e.keyCode === KeyCode.Escape) {
-                e.preventDefault();
-                e.stopPropagation();
-                this._hide();
-                this._editor.focus();
-                return;
-            }
-            if (e.keyCode === KeyCode.Enter && !e.shiftKey) {
-                e.preventDefault();
-                e.stopPropagation();
-                this._addFeedback();
-                return;
-            }
-        }));
-        this._widgetListeners.add(addStandardDisposableListener(widget.inputElement, "keypress", e => {
-            e.stopPropagation();
-        }));
-        this._widgetListeners.add(addStandardDisposableListener(widget.inputElement, "input", () => {
-            widget.autoSize();
-            widget.updateActionEnabled();
-            this._updatePosition();
-        }));
-        this._widgetListeners.add(addStandardDisposableListener(widget.inputElement, "blur", () => {
-            const win = getWindow(widget.inputElement);
-            win.setTimeout(() => {
-                if (!this._visible) {
-                    return;
-                }
-                if (this._editor.hasWidgetFocus()) {
-                    return;
-                }
-                this._hide();
-            }, 0);
-        }));
-    }
-    _hideAndRefocusEditor() {
-        this._suppressSelectionChangeOnce = true;
-        this._hide();
-        this._editor.focus();
-    }
-    _addFeedback() {
-        if (!this._widget) {
-            return false;
-        }
-        const text = this._widget.inputElement.value.trim();
-        if (!text) {
-            return false;
-        }
-        const selection = this._editor.getSelection();
-        const model = this._editor.getModel();
-        if (!selection || !model) {
-            return false;
-        }
-        const line = selection.startLineNumber;
-        const column = selection.startColumn;
-        this._planReviewFeedbackService.addFeedback(model.uri, line, column, text);
-        this._hideAndRefocusEditor();
-        return true;
-    }
-    _updatePosition() {
-        if (!this._widget || !this._visible) {
-            return;
-        }
-        const selection = this._editor.getSelection();
-        if (!selection) {
-            this._hide();
-            return;
-        }
-        const lineHeight = this._editor.getOption(EditorOption.lineHeight);
-        const layoutInfo = this._editor.getLayoutInfo();
-        const widgetDom = this._widget.getDomNode();
-        const widgetHeight = widgetDom.offsetHeight || 30;
-        const widgetWidth = widgetDom.offsetWidth || 150;
-        const cursorPosition = selection.getDirection() === SelectionDirection.LTR ? selection.getEndPosition() : selection.getStartPosition();
-        const scrolledPosition = this._editor.getScrolledVisiblePosition(cursorPosition);
-        if (!scrolledPosition) {
-            this._widget.setPosition(null);
-            return;
-        }
-        let top;
-        if (selection.getDirection() === SelectionDirection.LTR) {
-            top = scrolledPosition.top + lineHeight;
-            if (top + widgetHeight > layoutInfo.height) {
-                top = scrolledPosition.top - widgetHeight;
-            }
-        } else {
-            top = scrolledPosition.top - widgetHeight;
-            if (top < 0) {
-                top = scrolledPosition.top + lineHeight;
-            }
-        }
-        top = Math.max(0, Math.min(top, layoutInfo.height - widgetHeight));
-        const left = Math.max(0, Math.min(scrolledPosition.left, layoutInfo.width - widgetWidth));
-        this._widget.setPosition({
-            preference: {
-                top,
-                left
-            }
-        });
-    }
-    _updateDecorations() {
-        const model = this._editor.getModel();
-        if (!model || !this._isActivePlan) {
-            this._decorations.clear();
-            this._hasFeedbackContextKey.set(false);
-            this._hideOverlayToolbar();
-            return;
-        }
-        const items = this._planReviewFeedbackService.getFeedback(model.uri);
-        this._hasFeedbackContextKey.set(items.length > 0);
-        if (items.length > 0) {
-            const bearings = this._planReviewFeedbackService.getNavigationBearing(model.uri);
-            this._showOverlayToolbar(bearings);
-        } else {
-            this._hideOverlayToolbar();
-        }
-        this._decorations.set(( items.map(item => ({
-            range: ( new Range(item.line, item.column, item.line, item.column)),
-            options: {
-                description: "plan-review-feedback",
-                glyphMarginClassName: ThemeIcon.asClassName(Codicon.comment),
-                glyphMarginHoverMessage: {
-                    value: item.text
-                },
-                overviewRuler: {
-                    color: themeColorFromId(overviewRulerInfo),
-                    position: OverviewRulerLane.Center
-                },
-                lineNumberClassName: "plan-review-feedback-line-number"
-            }
-        }))));
-    }
-    _ensureOverlayWidget() {
-        if (!this._overlayWidget) {
-            this._overlayWidget = ( new PlanReviewFeedbackOverlayWidget(this._editor, this._instantiationService));
-            this._editor.addOverlayWidget(this._overlayWidget);
-        }
-        return this._overlayWidget;
-    }
-    _showOverlayToolbar(bearings) {
-        const widget = this._ensureOverlayWidget();
-        widget.show(bearings);
-    }
-    _hideOverlayToolbar() {
-        if (this._overlayWidget) {
-            this._overlayWidget.hide();
-        }
-    }
-    dispose() {
-        if (this._widget) {
-            this._editor.removeOverlayWidget(this._widget);
-            this._widget.dispose();
-            this._widget = undefined;
-        }
-        if (this._overlayWidget) {
-            this._editor.removeOverlayWidget(this._overlayWidget);
-            this._overlayWidget.dispose();
-            this._overlayWidget = undefined;
-        }
-        super.dispose();
-    }
-};
-PlanReviewFeedbackEditorContribution = ( __decorate([( __param(1, IPlanReviewFeedbackService)), ( __param(2, IContextKeyService)), ( __param(3, IInstantiationService))], PlanReviewFeedbackEditorContribution));
-registerEditorContribution(
-    PlanReviewFeedbackEditorContribution.ID,
-    PlanReviewFeedbackEditorContribution,
-    EditorContributionInstantiation.Eventually
-);
-
-export { PlanReviewFeedbackEditorContribution };

package/vscode/src/vs/workbench/contrib/chat/browser/voiceClient/micCaptureService.d.ts

@@ -1,125 +0,0 @@
-import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
-import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
-import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
-import { INotificationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/notification/common/notification.service";
-import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
-import { IMicCaptureService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/voiceClient/micCaptureService.service";
-/**
- * Per-PTT-press diagnostic emitted after `pttUp` once the diagnostic
- * window closes. Logged + sent to backend so we can correlate frontend
- * audio bookkeeping with backend ASR results via `turnId`.
- *
- * Drain model: after `pttUp` the service keeps streaming audio chunks
- * for a fixed "drain window" (~500ms by default). The drain ends as
- * soon as it has shipped enough samples to cover the window (or a
- * fallback timer trips if `onaudioprocess` stops firing). Only AFTER
- * the drain has closed does `_onPttEnd` fire. The diagnostic window is
- * intentionally LONGER than the drain window so any audio still
- * produced after drain end (within the diagnostic window) is counted
- * as `postReleaseCallbacks` -- a direct signal that the drain window
- * is too short for this device/load and the fix needs to extend it.
- *
- * Field interpretation:
- *  - `drainChunks` / `drainSamples` => audio captured during the drain
- *    window and shipped to the backend. Non-zero in normal operation.
- *  - `postReleaseCallbacks > 0` => the WebAudio pipeline produced more
- *    audio AFTER the drain window closed but before the diagnostic
- *    window. This audio was DROPPED; if it happens often the drain
- *    window needs to grow.
- *  - `drainSkippedBy*` > 0 => the drain was muted or AEC-suppressed.
- *    Tail audio for that press was lost; investigate the mute / AEC
- *    suppression path rather than the drain window.
- *  - `pttUpWithoutCapture` => pttUp arrived while mic was not capturing.
- *  - `releasedDuringAcquire` => user released while mic was still being
- *    acquired; no audio was ever recorded for this press.
- */
-export interface IPttDiagnostic {
-    readonly turnId: string;
-    readonly msHeld: number;
-    readonly chunksSent: number;
-    readonly samplesSent: number;
-    readonly drainFired: boolean;
-    readonly drainChunks: number;
-    readonly drainSamples: number;
-    readonly drainWindowMs: number;
-    readonly drainSkippedByMute: number;
-    readonly drainSkippedBySuppression: number;
-    readonly postReleaseCallbacks: number;
-    readonly postReleaseSamples: number;
-    readonly postReleaseSkippedByMute: number;
-    readonly postReleaseSkippedBySuppression: number;
-    readonly postReleaseWindowMs: number;
-    readonly releasedDuringAcquire: boolean;
-    readonly pttUpWithoutCapture: boolean;
-}
-export declare class MicCaptureService extends Disposable implements IMicCaptureService {
-    private readonly storageService;
-    private readonly notificationService;
-    private readonly logService;
-    readonly _serviceBrand: undefined;
-    constructor(storageService: IStorageService, notificationService: INotificationService, logService: ILogService);
-    private _window;
-    private _micStream;
-    private _micCtx;
-    private _scriptNode;
-    private _analyserNode;
-    private _isCapturing;
-    private _pttHeld;
-    private _pttStreaming;
-    private _isMuted;
-    private _suppressUntilTs;
-    private _pttAcquiring;
-    private _pttReleasedDuringAcquire;
-    private static readonly _PTT_DRAIN_WINDOW_MS;
-    private _pttDrainTargetSamples;
-    private _pttDrainSamplesSent;
-    private _pttDrainFallbackTimer;
-    private static readonly _DIAG_POST_RELEASE_WINDOW_MS;
-    private _diagTurnId;
-    private _diagPttDownTs;
-    private _diagPttUpTs;
-    private _diagChunksSent;
-    private _diagSamplesSent;
-    private _diagDrainFired;
-    private _diagDrainChunks;
-    private _diagDrainSamples;
-    private _diagDrainSkippedByMute;
-    private _diagDrainSkippedBySuppression;
-    private _diagPostReleaseCallbacks;
-    private _diagPostReleaseSamples;
-    private _diagPostReleaseSkippedByMute;
-    private _diagPostReleaseSkippedBySuppression;
-    private _diagReleasedDuringAcquire;
-    private _diagPttUpWithoutCapture;
-    private _diagFireTimer;
-    private readonly _onPttStart;
-    readonly onPttStart: Event<void>;
-    private readonly _onPttAudioChunk;
-    readonly onPttAudioChunk: Event<string>;
-    private readonly _onPttEnd;
-    readonly onPttEnd: Event<void>;
-    private readonly _onPttDiagnostic;
-    readonly onPttDiagnostic: Event<IPttDiagnostic>;
-    get isCapturing(): boolean;
-    get analyserNode(): AnalyserNode | undefined;
-    get isMuted(): boolean;
-    set isMuted(value: boolean);
-    suppressUntil(timestamp: number): void;
-    prepare(window: Window & typeof globalThis): void;
-    pttDown(turnId: string): Promise<void>;
-    pttUp(): void;
-    startCapture(window: Window & typeof globalThis): Promise<void>;
-    private _notifyMicPermissionDenied;
-    stopCapture(): void;
-    dispose(): void;
-    /**
-     * End the post-release drain phase: stop accepting more audio for
-     * this turn and fire `_onPttEnd`. Idempotent. Safe to call when no
-     * drain is in progress.
-     */
-    private _finishDrain;
-    private _resetDiagnosticCounters;
-    private _scheduleDiagnosticFire;
-    private _flushPendingDiagnostic;
-    private _emitDiagnostic;
-}