@hachej/boring-feedback 0.0.0-stage → 0.2.4

package/dist/page/privacy/policy.js

@@ -0,0 +1,125 @@
+// The privacy policy for page content (FEEDBACK.md, "Privacy policy for page content"; FEEDBACK-8).
+// Allowlist-based: anything not allowed is dropped or masked. Every option that loosens the default is recorded in `widened`.
+/** Marks a region whose text (and `aria-label`/`aria-description`) may leave the page. Presence counts, whatever its value. */
+export const FEEDBACK_VISIBLE_ATTRIBUTE = 'data-feedback-visible';
+/** Marks a subtree that is never serialized, named or picked (the application's own chrome, the agent bar). */
+export const FEEDBACK_IGNORE_ATTRIBUTE = 'data-feedback-ignore';
+/** Marks the picker overlay's host element; it and its subtree are excluded from every snapshot. */
+export const FEEDBACK_OVERLAY_ATTRIBUTE = 'data-feedback-overlay';
+/** The name returned whenever the accessible name would come from masked or disallowed sources. */
+export const MASKED_NAME = 'masked';
+/** Attributes kept by default. Values still pass `keptValue`. */
+export const DEFAULT_KEPT_ATTRIBUTES = Object.freeze([
+    'role', 'type', 'data-testid', 'data-feedback-id', 'data-source',
+    'aria-expanded', 'aria-pressed', 'aria-checked', 'aria-selected', 'aria-disabled', 'aria-hidden', 'aria-current',
+]);
+/** Kept only inside a visible region. */
+export const VISIBLE_REGION_ATTRIBUTES = Object.freeze(['aria-label', 'aria-description']);
+/** Channels that are always masked, so no option can widen them: values, placeholders, event handlers and inline documents. */
+const NEVER_ALLOWED = /^(?:on.*|value|placeholder|srcdoc)$/;
+const ATTRIBUTE_NAME = /^[a-z_:][a-z0-9_.:-]*$/;
+/** Builds the frozen version 1 policy. Throws on attribute names that name an always-masked channel or are malformed. */
+export function createPrivacyPolicy(options = {}) {
+    const allow = [...new Set((options.allowAttributes ?? []).map(name => name.toLowerCase()))].sort();
+    for (const name of allow) {
+        if (!ATTRIBUTE_NAME.test(name))
+            throw new TypeError(`Not an attribute name: ${JSON.stringify(name)}`);
+        if (NEVER_ALLOWED.test(name))
+            throw new TypeError(`The ${name} attribute is always masked and cannot be allowed`);
+    }
+    const extra = allow.filter(name => !DEFAULT_KEPT_ATTRIBUTES.includes(name));
+    const widened = extra.map(name => `allowAttributes:${name}`);
+    const policy = { version: 1, widened, allowAttributes: Object.freeze(extra) };
+    if (options.visibleSelector !== undefined) {
+        const selector = options.visibleSelector.trim();
+        if (!selector)
+            throw new TypeError('visibleSelector must not be empty');
+        policy.visibleSelector = selector;
+        widened.push(`visibleSelector:${selector}`);
+    }
+    if (options.routeOf !== undefined) {
+        if (typeof options.routeOf !== 'function')
+            throw new TypeError('routeOf must be a function');
+        policy.routeOf = options.routeOf;
+        widened.push('routeOf');
+    }
+    if (options.label !== undefined) {
+        policy.label = String(options.label);
+        widened.push('label');
+    }
+    Object.freeze(widened);
+    return Object.freeze(policy);
+}
+/** The policy as a report records it (`observed.policy` in `feedback@1`). */
+export function policyRecord(policy) {
+    return Object.freeze({ version: policy.version, widened: Object.freeze([...policy.widened]) });
+}
+/** The document title as it may leave the page: only the application's label, never `document.title`. */
+export function titleFor(policy) {
+    return policy.label;
+}
+/** `*` of equal length, per code point. */
+export function maskText(text) {
+    return '*'.repeat(Array.from(text).length);
+}
+/** Whitespace runs collapse to one space; ends are trimmed. */
+export function normalizeText(text) {
+    return text.replace(/\s+/g, ' ').trim();
+}
+/** A kept attribute value with three or more digits in a row, or an `@`, is dropped. */
+export function keptValue(value) {
+    return !/\d{3}/.test(value) && !value.includes('@');
+}
+/** `data-source` is code, not page data: a project-relative `path:line` (WP8's development stamp)
+ * is kept whatever its line number; anything else (absolute, parent, URL, `@`, odd characters) is dropped. */
+export const SOURCE_LOCATION = /^(?!\/)(?![A-Za-z]:)(?!.*(?:^|\/)\.\.(?:\/|:))[\w.$+()[\]-]+(?:\/[\w.$+()[\]-]+)*\.[cm]?[jt]sx?:[1-9]\d{0,6}$/;
+export function keptAttributeValue(name, value) {
+    return name === 'data-source' ? SOURCE_LOCATION.test(value) : keptValue(value);
+}
+const closest = (element, selector) => {
+    try {
+        return element.closest(selector) !== null;
+    }
+    catch {
+        return false;
+    } // An invalid selector widens nothing.
+};
+/** True when the element or an ancestor marks a visible region. */
+export function inVisibleRegion(element, policy) {
+    if (closest(element, `[${FEEDBACK_VISIBLE_ATTRIBUTE}]`))
+        return true;
+    return policy.visibleSelector !== undefined && closest(element, policy.visibleSelector);
+}
+/** True when the element is, or is inside, an ignored subtree or the picker overlay. */
+export function isExcluded(element) {
+    return closest(element, `[${FEEDBACK_IGNORE_ATTRIBUTE}],[${FEEDBACK_OVERLAY_ATTRIBUTE}]`);
+}
+const VALUE_CONTAINERS = new Set(['textarea', 'select', 'option', 'optgroup', 'datalist', 'output', 'input']);
+/** Form values, `textarea` and `contenteditable` content: masked even inside a visible region. */
+export function isAlwaysMasked(element) {
+    for (let current = element; current; current = current.parentElement) {
+        if (VALUE_CONTAINERS.has(current.localName))
+            return true;
+        const editable = current.getAttribute('contenteditable');
+        if (editable !== null && editable.toLowerCase() !== 'false')
+            return true;
+    }
+    return false;
+}
+/** The allowed attributes of one element, keys sorted. */
+export function allowedAttributes(element, policy) {
+    const visible = inVisibleRegion(element, policy);
+    const names = [];
+    for (const attribute of Array.from(element.attributes)) {
+        const name = attribute.name.toLowerCase();
+        if (DEFAULT_KEPT_ATTRIBUTES.includes(name) || policy.allowAttributes.includes(name) || (visible && VISIBLE_REGION_ATTRIBUTES.includes(name)))
+            names.push(name);
+    }
+    const attrs = {};
+    for (const name of [...new Set(names)].sort()) {
+        const value = element.getAttribute(name);
+        if (value !== null && keptAttributeValue(name, value))
+            attrs[name] = value;
+    }
+    return attrs;
+}

package/dist/page/privacy/route.d.ts

@@ -0,0 +1,6 @@
+import { type PrivacyPolicy, type RouteLocation } from './policy.js';
+/** Each non-empty path segment becomes `*` of equal length; separators are kept. */
+export declare function maskedPath(pathname: string): string;
+/** `routeOf(location)` when the policy has one and it returns a string, cut before any `?` or `#`; otherwise the masked path. */
+export declare function routeFor(location: RouteLocation, policy: PrivacyPolicy): string;
+//# sourceMappingURL=route.d.ts.map

package/dist/page/privacy/route.js

@@ -0,0 +1,20 @@
+// The route as it may leave the page: the application's template, or the path with every segment masked. Never query or fragment.
+import { maskText } from './policy.js';
+const pathOnly = (value) => value.split(/[?#]/, 1)[0] ?? '';
+/** Each non-empty path segment becomes `*` of equal length; separators are kept. */
+export function maskedPath(pathname) {
+    return pathOnly(pathname).split('/').map(segment => maskText(segment)).join('/');
+}
+/** `routeOf(location)` when the policy has one and it returns a string, cut before any `?` or `#`; otherwise the masked path. */
+export function routeFor(location, policy) {
+    const pathname = String(location.pathname ?? '');
+    if (policy.routeOf) {
+        try {
+            const template = policy.routeOf({ pathname, search: '', hash: '' });
+            if (typeof template === 'string')
+                return pathOnly(template);
+        }
+        catch { /* fall back to the masked path */ }
+    }
+    return maskedPath(pathname);
+}

package/dist/page/privacy/serialize.d.ts

@@ -0,0 +1,42 @@
+import { type PrivacyPolicy } from './policy.js';
+export interface AppDomNode {
+    /** Lower-case local name. */
+    readonly tag: string;
+    /** Allowed attributes only, keys sorted. */
+    readonly attrs: Readonly<Record<string, string>>;
+    /** The element's own text nodes, whitespace-normalized and joined by one space; masked unless visible. */
+    readonly text: string;
+    readonly children: readonly AppDomNode[];
+    /** 0-based position among the parent's element children with the same tag (`:nth-of-type` minus one), counted in the live DOM. */
+    readonly index: number;
+}
+export interface AppDomLimits {
+    /** Maximum number of nodes. */
+    readonly maxNodes: number;
+    /** Maximum depth below the root (the root is depth 0). */
+    readonly maxDepth: number;
+    /** Upper bound on the UTF-8 length of the root's canonical JSON. */
+    readonly maxBytes: number;
+}
+export interface AppDomSnapshot {
+    readonly format: 'app.dom@1';
+    /** `null` when the root itself is excluded (ignored subtree, overlay, or a non-content element). */
+    readonly root: AppDomNode | null;
+    /** True when any limit cut the tree: the snapshot is then a prefix (document order) and must never be treated as complete. */
+    readonly truncated: boolean;
+    readonly nodes: number;
+    readonly limits: AppDomLimits;
+}
+export declare const PAGE_LIMITS: AppDomLimits;
+export declare const ELEMENT_LIMITS: AppDomLimits;
+export interface SerializeElementOptions {
+    /** Maximum nodes in the element's snapshot, the element included. */
+    readonly subtreeLimit?: number;
+    readonly maxDepth?: number;
+    readonly maxBytes?: number;
+}
+/** The masked snapshot of one element and its subtree (default: at most 50 nodes, 16 levels, 2 KiB). */
+export declare function serializeElement(element: Element, policy: PrivacyPolicy, { subtreeLimit, ...rest }?: SerializeElementOptions): AppDomSnapshot;
+/** The masked snapshot of a page from its application root (default: at most 5000 nodes, 64 levels, 512 KiB). */
+export declare function serializePage(root: Element, policy: PrivacyPolicy, limits?: Partial<AppDomLimits>): AppDomSnapshot;
+//# sourceMappingURL=serialize.d.ts.map

package/dist/page/privacy/serialize.js

@@ -0,0 +1,90 @@
+// `app.dom@1`: the masked page snapshot, pure data produced only through the privacy policy (FEEDBACK.md, "Application elements").
+// Light DOM only: shadow roots are omitted and iframes are not entered. Form values are never read.
+import { allowedAttributes, inVisibleRegion, isAlwaysMasked, isExcluded, maskText, normalizeText } from './policy.js';
+export const PAGE_LIMITS = Object.freeze({ maxNodes: 5000, maxDepth: 64, maxBytes: 512 * 1024 });
+export const ELEMENT_LIMITS = Object.freeze({ maxNodes: 50, maxDepth: 16, maxBytes: 2048 });
+/** Never serialized: not page content, or carries no text people see. */
+const SKIPPED = new Set(['head', 'title', 'meta', 'link', 'base', 'script', 'style', 'noscript', 'template']);
+/** Serialized as a leaf: their content is another document or opaque. */
+const LEAVES = new Set(['iframe', 'frame', 'object', 'embed']);
+const ELEMENT_NODE = 1, TEXT_NODE = 3, CDATA_NODE = 4;
+const encoder = new TextEncoder();
+const bytes = (value) => encoder.encode(value).length;
+function sameTagIndex(element) {
+    let index = 0;
+    for (let sibling = element.previousElementSibling; sibling; sibling = sibling.previousElementSibling)
+        if (sibling.localName === element.localName)
+            index++;
+    return index;
+}
+function ownText(element, policy) {
+    const parts = [];
+    for (const child of Array.from(element.childNodes)) {
+        if (child.nodeType !== TEXT_NODE && child.nodeType !== CDATA_NODE)
+            continue;
+        const text = normalizeText(child.nodeValue ?? '');
+        if (text)
+            parts.push(text);
+    }
+    const text = parts.join(' ');
+    if (!text)
+        return '';
+    return !isAlwaysMasked(element) && inVisibleRegion(element, policy) ? text : maskText(text);
+}
+const skip = (element) => SKIPPED.has(element.localName) || isExcluded(element);
+function serialize(start, policy, limits) {
+    let nodes = 0, used = 0, truncated = false;
+    // Pre-order walk; once a node or byte limit is hit the walk stops, so the result is a deterministic document-order prefix.
+    const visit = (element, depth) => {
+        const own = { tag: element.localName, attrs: allowedAttributes(element, policy), text: ownText(element, policy), children: [], index: sameTagIndex(element) };
+        // Canonical JSON of the node with no children, plus a separating comma: the sum over nodes bounds the whole tree's JSON.
+        const cost = bytes(JSON.stringify({ attrs: own.attrs, children: [], index: own.index, tag: own.tag, text: own.text })) + 1;
+        if (nodes + 1 > limits.maxNodes || used + cost > limits.maxBytes) {
+            truncated = true;
+            return undefined;
+        }
+        nodes++;
+        used += cost;
+        if (LEAVES.has(own.tag))
+            return own;
+        for (const child of Array.from(element.children)) {
+            if (truncated)
+                break;
+            if (child.nodeType !== ELEMENT_NODE || skip(child))
+                continue;
+            if (depth + 1 > limits.maxDepth) {
+                truncated = true;
+                break;
+            }
+            const node = visit(child, depth + 1);
+            if (node)
+                own.children.push(node);
+        }
+        return own;
+    };
+    const root = skip(start) ? null : (visit(start, 0) ?? null);
+    return deepFreeze({ format: 'app.dom@1', root, truncated, nodes, limits: Object.freeze({ ...limits }) });
+}
+function deepFreeze(value) {
+    if (value && typeof value === 'object' && !Object.isFrozen(value)) {
+        Object.freeze(value);
+        for (const child of Object.values(value))
+            deepFreeze(child);
+    }
+    return value;
+}
+function limitsFrom(defaults, options) {
+    const limits = { ...defaults, ...options };
+    for (const [name, value] of Object.entries(limits))
+        if (!Number.isInteger(value) || value < 0)
+            throw new RangeError(`${name} must be a non-negative integer`);
+    return limits;
+}
+/** The masked snapshot of one element and its subtree (default: at most 50 nodes, 16 levels, 2 KiB). */
+export function serializeElement(element, policy, { subtreeLimit = ELEMENT_LIMITS.maxNodes, ...rest } = {}) {
+    return serialize(element, policy, limitsFrom(ELEMENT_LIMITS, { maxNodes: subtreeLimit, ...rest }));
+}
+/** The masked snapshot of a page from its application root (default: at most 5000 nodes, 64 levels, 512 KiB). */
+export function serializePage(root, policy, limits = {}) {
+    return serialize(root, policy, limitsFrom(PAGE_LIMITS, limits));
+}

package/dist/page/voice/align.d.ts

@@ -0,0 +1,36 @@
+export interface SpeechWord {
+    readonly start: number;
+    readonly end: number;
+    readonly text: string;
+}
+/** Seconds from the audio start. `words`, when the transcription gives word timings, lets a segment split at pointer changes. */
+export interface SpeechSegment {
+    readonly start: number;
+    readonly end: number;
+    readonly text: string;
+    readonly words?: readonly SpeechWord[];
+}
+/** `t` on the page clock; `target` an index into the session's element list, or null over nothing pickable. */
+export interface PointerSample {
+    readonly t: number;
+    readonly target: number | null;
+}
+export interface PinMark {
+    readonly t: number;
+    readonly target: number;
+}
+export interface AlignedSpeech {
+    readonly target: number | null;
+    readonly text: string;
+    readonly at: number;
+    readonly confidence: 'dwell' | 'pin' | 'none';
+}
+/** How long after a segment ends a pin still claims it (milliseconds). */
+export declare const PIN_AFTER_MS = 1000;
+export declare function alignSpeech(input: {
+    readonly segments: readonly SpeechSegment[];
+    readonly audioStartedAt: number;
+    readonly pointer: readonly PointerSample[];
+    readonly pins: readonly PinMark[];
+}): readonly AlignedSpeech[];
+//# sourceMappingURL=align.d.ts.map

package/dist/page/voice/align.js

@@ -0,0 +1,122 @@
+// Voice and pointer alignment: what a person says while pointing at an element attaches to that element.
+//
+// One clock for everything: `performance.now()` milliseconds of the page. Transcription segments are in seconds from the first
+// audio sample; `audioStartedAt` (from `VoiceCapture.stop`) puts that sample on the page clock. Pure: no DOM, no timers.
+//
+// The rule, applied to each segment (or to each word group, see below):
+// 1. The segment covers the page-time window [a, b] = [audioStartedAt + start × 1000, audioStartedAt + end × 1000].
+// 2. Pin: a pin placed inside [a, b] wins (the earliest one). Otherwise a pin placed in the second after the segment wins
+//    (b, b + PIN_AFTER_MS], unless the next segment has already started, so a pin follows "this one is wrong" said just
+//    before the click but never steals the next sentence's pin. Confidence 'pin'.
+// 3. Dwell: otherwise the element the pointer stayed over longest inside [a, b] (ties: the one reached first). Confidence 'dwell'.
+//    Pointer samples are change points: a sample holds until the next one, the last one holds on. Before the first sample the
+//    pointer is unknown, as over nothing. The session must send `{ target: null }` when the pointer leaves the page or crosses
+//    something not pickable, or a gap reads as dwelling on the last element.
+// 4. Narration: the pointer over nothing for the whole window (and no pin) gives target null, confidence 'none'.
+// 5. Word timings: when a segment carries `words`, it is split where the pointer moves to another element (each word placed by
+//    the dwell over its own time; words over nothing stay with the group before them), and each group gets rules 2–4 on its own
+//    window. Without word timings a segment is never split.
+//
+// The clock was measured, not assumed: `npm run feedback:voice-sync` (tools/feedback-voice-sync.mjs) records beeps in headless
+// Chromium while the pointer moves; the chosen `startedAt` was within 9 ms of an independent reader of the microphone (see
+// .cache/evidence/feedback-voice/RESULT.md), far below the 150 ms target and a segment's own length, so no window is widened.
+/** How long after a segment ends a pin still claims it (milliseconds). */
+export const PIN_AFTER_MS = 1000;
+const finite = (value) => typeof value === 'number' && Number.isFinite(value);
+/** Milliseconds the pointer spent over each element inside [a, b], with the time each was first reached there. */
+function dwell(pointer, a, b) {
+    const out = new Map();
+    for (let i = 0; i < pointer.length; i++) {
+        const sample = pointer[i];
+        const from = Math.max(a, sample.t);
+        const next = i + 1 < pointer.length ? pointer[i + 1].t : Infinity;
+        const until = Math.min(b, next);
+        // A zero-length window (a word or segment with no duration) takes the sample holding at that instant.
+        const holds = a === b ? sample.t <= a && next > a : until > from;
+        if (sample.target === null || !holds)
+            continue;
+        const seen = out.get(sample.target);
+        if (seen)
+            seen.ms += until - from;
+        else
+            out.set(sample.target, { ms: until - from, first: from });
+    }
+    return out;
+}
+function dwellTarget(pointer, a, b) {
+    let best = null, bestMs = -1, bestFirst = Infinity;
+    for (const [target, { ms, first }] of dwell(pointer, a, b)) {
+        if (ms > bestMs || (ms === bestMs && first < bestFirst)) {
+            best = target;
+            bestMs = ms;
+            bestFirst = first;
+        }
+    }
+    return best;
+}
+function pinTarget(pins, a, b, nextStart) {
+    let inside = null, after = null;
+    const limit = Math.min(b + PIN_AFTER_MS, Math.max(b, nextStart));
+    for (const pin of pins) {
+        if (pin.t >= a && pin.t <= b) {
+            if (!inside || pin.t < inside.t)
+                inside = pin;
+        }
+        else if (pin.t > b && pin.t <= limit) {
+            if (!after || pin.t < after.t)
+                after = pin;
+        }
+    }
+    return (inside ?? after)?.target ?? null;
+}
+/** Word groups of one segment: consecutive words over the same element; words over nothing join the group before them. */
+function groups(segment, base, pointer) {
+    const words = (segment.words ?? []).filter(word => finite(word.start) && finite(word.end) && word.text.trim());
+    if (words.length < 2)
+        return null;
+    const out = [];
+    for (const word of words) {
+        const target = dwellTarget(pointer, base + word.start * 1000, base + Math.max(word.start, word.end) * 1000);
+        const last = out[out.length - 1];
+        if (last && (target === null || target === last.target))
+            last.words.push(word);
+        else if (last && last.target === null) {
+            last.target = target;
+            last.words.push(word);
+        }
+        else
+            out.push({ target, words: [word] });
+    }
+    if (out.length < 2)
+        return null;
+    return out.map(group => {
+        const first = group.words[0], last = group.words[group.words.length - 1];
+        return { a: base + first.start * 1000, b: base + Math.max(first.start, last.end) * 1000, start: first.start, text: group.words.map(word => word.text.trim()).join(' ') };
+    });
+}
+export function alignSpeech(input) {
+    const base = input.audioStartedAt;
+    if (!finite(base))
+        return [];
+    const pointer = input.pointer.filter(sample => finite(sample.t)).slice().sort((x, y) => x.t - y.t);
+    const pins = input.pins.filter(pin => finite(pin.t));
+    const spans = [];
+    for (const segment of input.segments) {
+        if (!finite(segment.start) || !finite(segment.end) || !segment.text.trim())
+            continue;
+        const split = groups(segment, base, pointer);
+        if (split)
+            spans.push(...split);
+        else
+            spans.push({ a: base + segment.start * 1000, b: base + Math.max(segment.start, segment.end) * 1000, start: segment.start, text: segment.text.trim() });
+    }
+    spans.sort((x, y) => x.a - y.a);
+    return spans.map((span, i) => {
+        const next = spans.slice(i + 1).find(other => other.a > span.a)?.a ?? Infinity;
+        const pinned = pinTarget(pins, span.a, span.b, next);
+        if (pinned !== null)
+            return { target: pinned, text: span.text, at: span.a, confidence: 'pin' };
+        const target = dwellTarget(pointer, span.a, span.b);
+        return target === null ? { target: null, text: span.text, at: span.a, confidence: 'none' } : { target, text: span.text, at: span.a, confidence: 'dwell' };
+    });
+}

package/dist/page/voice/capture.d.ts

@@ -0,0 +1,43 @@
+/** Why the microphone could not be used, for a short human message: `denied` (the person or the browser refused the permission),
+ * `no-microphone`, `busy` (in use or could not be opened), `insecure` (http on a name other than localhost: no media devices at all),
+ * `unsupported` (no MediaRecorder, or it cannot record this microphone), `failed` (anything else). */
+export type VoiceRefusal = 'denied' | 'no-microphone' | 'busy' | 'insecure' | 'unsupported' | 'failed';
+export type VoiceStart = {
+    readonly kind: 'recording';
+} | {
+    readonly kind: 'refused';
+    readonly reason: string;
+    readonly code?: VoiceRefusal;
+};
+export interface VoiceRecording {
+    readonly audio: Blob;
+    readonly mimeType: string;
+    /** Page time (`performance.now()` ms) of the first recorded sample. */
+    readonly startedAt: number;
+    readonly endedAt: number;
+    /** The recording reached `maxMs` and stopped on its own. */
+    readonly truncated: boolean;
+}
+export interface VoiceCapture {
+    readonly start: () => Promise<VoiceStart>;
+    /** Ends the recording and returns it; null when nothing was recorded (never started, cancelled, or empty). */
+    readonly stop: () => Promise<VoiceRecording | null>;
+    /** Ends the recording, releases the microphone and discards the audio. */
+    readonly cancel: () => void;
+}
+export interface VoiceCaptureOptions {
+    readonly getUserMedia?: (constraints: MediaStreamConstraints) => Promise<MediaStream>;
+    /** Longest recording in milliseconds (default 5 minutes); the recording stops there and `stop()` reports `truncated`. */
+    readonly maxMs?: number;
+    /** The page clock (default `performance.now()`). */
+    readonly now?: () => number;
+}
+export declare const DEFAULT_MAX_VOICE_MS: number;
+/** Container types tried in order; the first the browser records wins. */
+export declare const VOICE_MIME_TYPES: readonly ["audio/webm;codecs=opus", "audio/webm", "audio/mp4", "audio/ogg;codecs=opus"];
+/** The browser's microphone, or null where the page cannot have one (insecure origin, no media devices). */
+export declare function browserGetUserMedia(): ((constraints: MediaStreamConstraints) => Promise<MediaStream>) | null;
+/** Short human messages, one per refusal; each says what to do next. */
+export declare const VOICE_REFUSALS: Readonly<Record<VoiceRefusal, string>>;
+export declare function createVoiceCapture(options?: VoiceCaptureOptions): VoiceCapture;
+//# sourceMappingURL=capture.d.ts.map