@ai-matrx/chat 0.6.6 → 0.7.1

package/dist/host/defaults/gates.js

@@ -0,0 +1,72 @@
+"use client";
+import { useCallback, useEffect, useState, useSyncExternalStore } from "react";
+import { NO_ACCESS, resolveResourceAccess } from "../../ui/access-core.js";
+import { toDbPermissionLevel } from "../../ui/permission-levels.js";
+import { getChatHost, isChatHostConfigured } from "../configure.js";
+const noSubscribe = () => () => void 0;
+function useDefaultAccess(resourceType, resourceId) {
+  const [state, setState] = useState({ key: "", access: null, failed: false });
+  const [tick, setTick] = useState(0);
+  const key = resourceType && resourceId ? `${resourceType}:${resourceId}` : "";
+  useEffect(() => {
+    if (!key || !isChatHostConfigured()) return void 0;
+    let live = true;
+    resolveResourceAccess(getChatHost().db, resourceType, resourceId, { strict: true }).then(
+      (access) => live && setState({ key, access, failed: false }),
+      () => live && setState({ key, access: null, failed: true })
+    );
+    return () => {
+      live = false;
+    };
+  }, [key, resourceType, resourceId, tick]);
+  const answered = state.key === key ? state : null;
+  const loading = Boolean(key) && isChatHostConfigured() && !answered;
+  const refresh = useCallback(async () => setTick((t) => t + 1), []);
+  return { ...answered?.access ?? NO_ACCESS, loading, refresh };
+}
+function useDefaultOrganizationRequired() {
+  const host = isChatHostConfigured() ? getChatHost() : null;
+  const org = useSyncExternalStore(host?.org.subscribe ?? noSubscribe, () => host?.org.active() ?? null, () => null);
+  const identity = useSyncExternalStore(host?.identity.subscribe ?? noSubscribe, () => host?.identity.current() ?? null, () => null);
+  const organizationId = org?.id ?? null;
+  const canLoad = organizationId != null;
+  const signedOut = !canLoad && host != null && identity != null && !identity.userId;
+  const organizationState = canLoad ? "ready" : !host ? "unavailable" : signedOut ? "signed_out" : "required";
+  const retry = useCallback(() => {
+    host?.org.require("work here", { interactive: true }).catch(() => void 0);
+  }, [host]);
+  return {
+    organizationId,
+    canLoad,
+    organizationRequired: organizationState === "required",
+    resolving: false,
+    organizationState,
+    unavailableReason: host ? null : "no chat host",
+    retry
+  };
+}
+async function defaultEnsureOrgAvailability(options) {
+  if (!isChatHostConfigured()) return { success: false, error: "No chat host to grant access through." };
+  const db = getChatHost().db;
+  try {
+    const { data, error } = await db.rpc("grant_org_availability", {
+      p_resource_type: options.resourceType,
+      p_resource_id: options.resourceId,
+      p_target_org_id: options.organizationId,
+      p_permission_level: options.permissionLevel ? toDbPermissionLevel(options.permissionLevel) : void 0
+    });
+    if (error) return { success: false, error: error.message };
+    const o = data && typeof data === "object" ? data : {};
+    if (o.success === true) return { success: true, message: typeof o.message === "string" ? o.message : "Available to everyone in the organization" };
+    const err = typeof o.error === "string" ? o.error : "Could not make this available to the organization";
+    if (err === "Organization already has access") return { success: true, message: err };
+    return { success: false, error: err };
+  } catch (cause) {
+    return { success: false, error: cause instanceof Error ? cause.message : "Could not make this available to the organization" };
+  }
+}
+export {
+  defaultEnsureOrgAvailability,
+  useDefaultAccess,
+  useDefaultOrganizationRequired
+};

package/dist/host/defaults/media-client.d.ts

@@ -0,0 +1,15 @@
+/**
+ * The media client a bare host's file cards resolve through (gap 6, AUDIT-C): tool-result files and
+ * images, attachment thumbnails and media bodies all read `@ai-matrx/media`'s `MediaProvider`. A
+ * host with only a db had none, so every one of them threw on mount. `BareHostChrome` mounts this
+ * one — `@ai-matrx/data/files` over the files service, carrying the host's bearer and active
+ * organization — unless a `MediaProvider` is already above the chat (the host's own wins).
+ */
+import { type ReactNode } from "react";
+import type { MediaClient } from "@ai-matrx/media";
+import type { ResolvedChatHost } from "../contract.js";
+export declare function createBareMediaClient(host: ResolvedChatHost): MediaClient;
+export declare function BareMediaProvider({ host, children }: {
+    host: ResolvedChatHost;
+    children?: ReactNode;
+}): import("react").JSX.Element;

package/dist/host/defaults/media-client.js

@@ -0,0 +1,40 @@
+"use client";
+import { Fragment, jsx } from "react/jsx-runtime";
+import { useState } from "react";
+import { createMatrxFilesClient } from "@ai-matrx/data/files";
+import { MediaProvider, useMediaClient } from "@ai-matrx/media/core";
+import { DEFAULT_FILES_SERVICE_URL } from "./files-host.js";
+function createBareMediaClient(host) {
+  return createMatrxFilesClient({
+    filesBaseUrl: DEFAULT_FILES_SERVICE_URL,
+    credentials: {
+      async get() {
+        const accessToken = await host.identity.getAccessToken();
+        return accessToken ? { kind: "user", accessToken } : null;
+      }
+    },
+    async fetchImpl(input, init) {
+      const headers = new Headers(init?.headers ?? (input instanceof Request ? input.headers : {}));
+      const organizationId = host.org.active()?.id;
+      if (headers.has("Authorization") && organizationId && !headers.has("X-Organization-Id")) headers.set("X-Organization-Id", organizationId);
+      return fetch(input, { ...init, headers });
+    }
+  });
+}
+function useHasMediaClient() {
+  try {
+    useMediaClient();
+    return true;
+  } catch {
+    return false;
+  }
+}
+function BareMediaProvider({ host, children }) {
+  const hasClient = useHasMediaClient();
+  const [client] = useState(() => hasClient ? null : createBareMediaClient(host));
+  return client ? /* @__PURE__ */ jsx(MediaProvider, { client, children }) : /* @__PURE__ */ jsx(Fragment, { children });
+}
+export {
+  BareMediaProvider,
+  createBareMediaClient
+};

package/dist/host/defaults/voice.d.ts

@@ -0,0 +1,81 @@
+import { BrowserAudioKernel } from "@ai-matrx/browser-audio/core";
+import { ReadAloudButton } from "@ai-matrx/media/react";
+import type { ComponentProps } from "react";
+import type { ResolvedChatHost } from "../contract.js";
+/** THE page's audio kernel over the configured chat host (created on first use). */
+export declare function getChatAudioKernel(): BrowserAudioKernel;
+/** Test seam: drop the page's kernel. */
+export declare function resetChatAudioKernelForTests(): void;
+/** Same return shape as the website's `useRecordAndTranscribe` (the members chat reads). */
+export declare function useDefaultRecordAndTranscribe(props?: {
+    onTranscriptionComplete?: (result: {
+        success: boolean;
+        text: string;
+        error?: string;
+    }) => void;
+    onChunkTranscribed?: (chunkText: string, accumulatedText: string) => void;
+    onError?: (error: string, errorCode?: string) => void;
+    autoTranscribe?: boolean;
+}): {
+    isRecording: boolean;
+    isPaused: boolean;
+    duration: number;
+    audioLevel: number;
+    isTranscribing: boolean;
+    liveTranscript: string;
+    failedChunkCount: number;
+    isProcessing: boolean;
+    startRecording: () => Promise<void>;
+    stopRecording: () => void | undefined;
+    pauseRecording: () => void | undefined;
+    resumeRecording: () => Promise<void> | undefined;
+    reset: () => void | undefined;
+};
+export interface DefaultMicrophoneIconButtonProps {
+    id?: string;
+    onTranscriptionComplete: (text: string) => void;
+    onTranscriptOnlyComplete?: (text: string) => void;
+    onLiveTranscript?: (text: string) => void;
+    onRecordingStateChange?: (state: {
+        isRecording: boolean;
+        isTranscribing: boolean;
+    }) => void;
+    onError?: (error: string, code?: string) => void;
+    className?: string;
+    iconClassName?: string;
+    disabled?: boolean;
+    label?: string;
+}
+/** The composer's mic: one press records, the next stops; the transcript arrives through the props. */
+export declare const DefaultMicrophoneIconButton: import("react").ForwardRefExoticComponent<DefaultMicrophoneIconButtonProps & import("react").RefAttributes<{
+    stopForTranscriptOnly: () => void;
+}>>;
+/** "Transcribing (0:12)…" while a recording turns into text. */
+export declare function DefaultTranscriptionLoader({ message, duration, className, }: {
+    message?: string;
+    duration?: number;
+    className?: string;
+    size?: "sm" | "md" | "lg";
+}): import("react").JSX.Element;
+/** The mic's device caret: lists the microphones and keeps the choice for every recording. */
+export declare function DefaultMicDeviceMenu({ className, disabled, ariaLabel }: {
+    className?: string;
+    disabled?: boolean;
+    ariaLabel?: string;
+}): import("react").JSX.Element;
+type ReadAloudVariant = ComponentProps<typeof ReadAloudButton>["variant"];
+/** Read one assistant message aloud (THE one speech engine, footer size). */
+export declare function DefaultSpeakerButton({ text: given, className, variant, disabled }: {
+    text?: string;
+    className?: string;
+    variant?: ReadAloudVariant;
+    processMarkdown?: boolean;
+    disabled?: boolean;
+}): import("react").JSX.Element;
+/**
+ * Give THE speech engine what it needs on a host that wired none of it: a Cartesia token from the
+ * platform's broker over this host's server, and the engine's own voice defaults. Ports a host
+ * already set are left alone (`isSpeechConfigured`).
+ */
+export declare function installBareHostSpeech(host: ResolvedChatHost): void;
+export {};

package/dist/host/defaults/voice.js

@@ -0,0 +1,239 @@
+"use client";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { forwardRef, useCallback, useEffect, useId, useImperativeHandle, useRef, useState, useSyncExternalStore } from "react";
+import { ChevronDown, Loader2, Mic, Square } from "lucide-react";
+import { BrowserAudioKernel, getPreferredInputDeviceId, setPreferredInputDeviceId } from "@ai-matrx/browser-audio/core";
+import { createMatrxAudioClient } from "@ai-matrx/browser-audio/matrx";
+import { configureSpeech, isSpeechConfigured } from "@ai-matrx/media/speech";
+import { ReadAloudButton, useReadAloud } from "@ai-matrx/media/react";
+import { Button } from "@ai-matrx/design-system/controls";
+import { Popover, PopoverContent, PopoverTrigger } from "@ai-matrx/design-system";
+import { formatDurationSeconds } from "@ai-matrx/kit/format";
+import { getChatHost, isChatHostConfigured } from "../configure.js";
+let sharedKernel = null;
+function getChatAudioKernel() {
+  if (sharedKernel) return sharedKernel;
+  if (!isChatHostConfigured()) throw new Error("@ai-matrx/chat: voice input needs a chat host (ChatProvider).");
+  const host = getChatHost();
+  const client = createMatrxAudioClient({
+    baseUrl: host.server.baseUrl(),
+    getAccessToken: () => host.identity.getAccessToken(),
+    getOrganizationId: () => host.org.active()?.id ?? null
+  });
+  sharedKernel = new BrowserAudioKernel({ transport: client, persistence: client });
+  return sharedKernel;
+}
+function resetChatAudioKernelForTests() {
+  sharedKernel?.dispose();
+  sharedKernel = null;
+}
+const IDLE_SNAPSHOT = Object.freeze({
+  status: "idle",
+  ownerId: null,
+  liveTranscript: "",
+  audioLevel: 0,
+  durationMs: 0,
+  error: null,
+  recoverableCount: 0
+});
+const noSubscribe = () => () => void 0;
+function useKernelSnapshot() {
+  const kernel = isChatHostConfigured() ? getChatAudioKernel() : null;
+  const snapshot = useSyncExternalStore(
+    kernel?.subscribe ?? noSubscribe,
+    kernel?.getSnapshot ?? (() => IDLE_SNAPSHOT),
+    () => IDLE_SNAPSHOT
+  );
+  return { kernel, snapshot };
+}
+function useDefaultRecordAndTranscribe(props = {}) {
+  const ownerId = useId();
+  const { kernel, snapshot } = useKernelSnapshot();
+  const cb = useRef(props);
+  cb.current = props;
+  const owns = snapshot.ownerId === ownerId;
+  const isRecording = owns && (snapshot.status === "recording" || snapshot.status === "paused");
+  const isPaused = owns && snapshot.status === "paused";
+  const isTranscribing = owns && snapshot.status === "transcribing";
+  const liveTranscript = owns ? snapshot.liveTranscript : "";
+  const previous = useRef("");
+  useEffect(() => {
+    if (!liveTranscript || liveTranscript === previous.current) return;
+    const delta = liveTranscript.startsWith(previous.current) ? liveTranscript.slice(previous.current.length) : liveTranscript;
+    previous.current = liveTranscript;
+    cb.current.onChunkTranscribed?.(delta, liveTranscript);
+  }, [liveTranscript]);
+  const startRecording = useCallback(async () => {
+    if (!kernel) {
+      cb.current.onError?.("Voice input is not available here.", "NO_HOST");
+      return;
+    }
+    previous.current = "";
+    await kernel.start({
+      ownerId,
+      onFinalTranscript: (text) => {
+        if (cb.current.autoTranscribe === false) return;
+        cb.current.onTranscriptionComplete?.({ success: true, text });
+      },
+      onError: (error) => cb.current.onError?.(error.message, error.code)
+    });
+  }, [kernel, ownerId]);
+  return {
+    isRecording,
+    isPaused,
+    duration: owns ? Math.round(snapshot.durationMs / 1e3) : 0,
+    audioLevel: owns ? snapshot.audioLevel : 0,
+    isTranscribing,
+    liveTranscript,
+    failedChunkCount: 0,
+    isProcessing: isRecording || isTranscribing,
+    startRecording,
+    stopRecording: () => kernel?.stop(ownerId),
+    pauseRecording: () => kernel?.pause(ownerId),
+    resumeRecording: () => kernel?.resume(ownerId),
+    reset: () => kernel?.cancel(ownerId)
+  };
+}
+const DefaultMicrophoneIconButton = forwardRef(
+  function DefaultMicrophoneIconButton2(props, ref) {
+    const transcriptOnly = useRef(false);
+    const recorder = useDefaultRecordAndTranscribe({
+      onTranscriptionComplete: ({ text }) => {
+        if (transcriptOnly.current && props.onTranscriptOnlyComplete) props.onTranscriptOnlyComplete(text);
+        else props.onTranscriptionComplete(text);
+        transcriptOnly.current = false;
+      },
+      onChunkTranscribed: (_delta, all) => props.onLiveTranscript?.(all),
+      ...props.onError ? { onError: props.onError } : {}
+    });
+    const { isRecording, isTranscribing } = recorder;
+    const onState = useRef(props.onRecordingStateChange);
+    onState.current = props.onRecordingStateChange;
+    useEffect(() => {
+      onState.current?.({ isRecording, isTranscribing });
+    }, [isRecording, isTranscribing]);
+    useImperativeHandle(ref, () => ({
+      stopForTranscriptOnly: () => {
+        transcriptOnly.current = true;
+        recorder.stopRecording();
+      }
+    }));
+    const label = isRecording ? "Stop recording" : isTranscribing ? "Transcribing" : props.label ?? "Start recording";
+    const icon = isTranscribing ? /* @__PURE__ */ jsx(Loader2, { className: "animate-spin" }) : isRecording ? /* @__PURE__ */ jsx(Square, { className: "text-destructive" }) : /* @__PURE__ */ jsx(Mic, { className: props.iconClassName });
+    return /* @__PURE__ */ jsx(
+      Button,
+      {
+        id: props.id,
+        variant: "quiet",
+        icon,
+        "aria-label": label,
+        title: label,
+        "aria-pressed": isRecording,
+        disabled: props.disabled || isTranscribing,
+        className: props.className,
+        "data-chat-default": "microphone",
+        onClick: () => isRecording ? recorder.stopRecording() : void recorder.startRecording()
+      }
+    );
+  }
+);
+function DefaultTranscriptionLoader({
+  message = "Transcribing",
+  duration,
+  className
+}) {
+  return /* @__PURE__ */ jsxs("div", { className: `flex items-center gap-2 text-sm text-muted-foreground ${className ?? ""}`, role: "status", "data-chat-default": "transcription-loader", children: [
+    /* @__PURE__ */ jsx(Loader2, { className: "h-4 w-4 animate-spin" }),
+    /* @__PURE__ */ jsxs("span", { children: [
+      message,
+      duration !== void 0 ? ` (${formatDurationSeconds(duration, { style: "clock" })})` : ""
+    ] })
+  ] });
+}
+function DefaultMicDeviceMenu({ className, disabled, ariaLabel = "Choose microphone" }) {
+  const [devices, setDevices] = useState([]);
+  const [chosen, setChosen] = useState(() => getPreferredInputDeviceId());
+  const load = () => {
+    void navigator.mediaDevices?.enumerateDevices().then((all) => setDevices(all.filter((d) => d.kind === "audioinput"))).catch(() => setDevices([]));
+  };
+  return /* @__PURE__ */ jsxs(Popover, { onOpenChange: (open) => open && load(), children: [
+    /* @__PURE__ */ jsx(PopoverTrigger, { asChild: true, children: /* @__PURE__ */ jsx(Button, { variant: "quiet", disabled, "aria-label": ariaLabel, icon: /* @__PURE__ */ jsx(ChevronDown, {}), className, "data-chat-default": "mic-device-menu" }) }),
+    /* @__PURE__ */ jsx(PopoverContent, { sizing: "content", align: "end", side: "bottom", sideOffset: 6, className: "p-1", onOpenAutoFocus: (e) => e.preventDefault(), children: /* @__PURE__ */ jsxs("div", { role: "listbox", "aria-label": ariaLabel, className: "flex min-w-48 flex-col", children: [
+      devices.length === 0 ? /* @__PURE__ */ jsx("span", { className: "px-2 py-1.5 text-sm text-muted-foreground", children: "No microphone found" }) : null,
+      devices.map((d, i) => {
+        const selected = (chosen ?? "default") === d.deviceId || !chosen && i === 0;
+        return /* @__PURE__ */ jsx(
+          "button",
+          {
+            type: "button",
+            role: "option",
+            "aria-selected": selected,
+            className: `rounded px-2 py-1.5 text-left text-sm hover:bg-accent ${selected ? "font-medium" : ""}`,
+            onClick: () => {
+              setPreferredInputDeviceId(d.deviceId || null);
+              setChosen(d.deviceId || null);
+            },
+            children: d.label || `Microphone ${i + 1}`
+          },
+          d.deviceId || i
+        );
+      })
+    ] }) })
+  ] });
+}
+function DefaultSpeakerButton({ text: given, className, variant, disabled }) {
+  const text = given ?? "";
+  const { status, error, onPress } = useReadAloud(text);
+  return /* @__PURE__ */ jsx(
+    ReadAloudButton,
+    {
+      status,
+      error,
+      onPress,
+      disabled: disabled || !text.trim(),
+      ...variant !== void 0 ? { variant } : { size: "compact" },
+      ...className !== void 0 && { className }
+    }
+  );
+}
+const CARTESIA_REQUEST = { audience: "cartesia_tts", tierPolicy: "none", scopes: ["tts"], ttlSeconds: 600 };
+function installBareHostSpeech(host) {
+  let cached = null;
+  const ports = {};
+  if (!isSpeechConfigured("getCartesiaToken")) {
+    ports.getCartesiaToken = async (opts) => {
+      if (cached && !opts?.forceRefresh && Date.now() - cached.at < (CARTESIA_REQUEST.ttlSeconds - 60) * 1e3) return cached.token;
+      const api = host.server.api;
+      if (!api.mintCredential) throw new Error("Read-aloud needs a server that can mint a speech credential.");
+      const credential = await api.mintCredential(CARTESIA_REQUEST.audience, CARTESIA_REQUEST.tierPolicy, {
+        scopes: [...CARTESIA_REQUEST.scopes],
+        ttlSeconds: CARTESIA_REQUEST.ttlSeconds
+      });
+      if (!credential?.token) throw new Error("The credential service returned no speech token.");
+      cached = { token: credential.token, at: Date.now() };
+      return credential.token;
+    };
+    ports.invalidateCartesiaToken = () => {
+      cached = null;
+    };
+  }
+  if (!isSpeechConfigured("resolveVoiceSettings")) {
+    ports.resolveVoiceSettings = async () => ({
+      voice: null,
+      language: typeof navigator !== "undefined" && navigator.language?.split("-")[0] || "en",
+      speed: 1
+    });
+  }
+  if (!isSpeechConfigured("notifyError")) ports.notifyError = (title, description) => host.notify.error(`${title}: ${description}`);
+  if (Object.keys(ports).length > 0) configureSpeech(ports);
+}
+export {
+  DefaultMicDeviceMenu,
+  DefaultMicrophoneIconButton,
+  DefaultSpeakerButton,
+  DefaultTranscriptionLoader,
+  getChatAudioKernel,
+  installBareHostSpeech,
+  resetChatAudioKernelForTests,
+  useDefaultRecordAndTranscribe
+};

package/dist/host/device-tool-handoff.d.ts

@@ -0,0 +1,26 @@
+/**
+ * host/device-tool-handoff — delegated device-tool calls that outlive the document.
+ *
+ * A host that IS the device (the Chrome side panel) runs a cloud agent's tools through
+ * `deviceTools.invoke`; the package submits each result from the same document. When that document
+ * goes away (the panel closes) mid-call, the promise dies with it and the result is lost — the call
+ * stays pending on the server and, on reopen, would run a SECOND time (cold resume).
+ *
+ * So every in-flight call is tracked here, and on `pagehide` the package hands the whole set to the
+ * host (`deviceTools.handOff`). From that moment the host owns each call's result: this document
+ * will not submit it (`handedOff()` is true), whether or not the document actually dies. A host
+ * without `handOff` is untouched — nothing is tracked on its behalf and nothing is skipped.
+ */
+import type { ChatDeviceToolHandOff } from "./contract.js";
+/** Hand every in-flight call to the host now. Returns what was handed (empty when the host has no `handOff`). */
+export declare function handOffInFlightDeviceCalls(): readonly ChatDeviceToolHandOff[];
+export interface TrackedDeviceCall {
+    /** True once the host was handed this call; the caller must not submit a result for it. */
+    handedOff(): boolean;
+    /** The call settled (or failed) in this document. */
+    done(): void;
+}
+/** Track a call from `invoke` start to its settle. Cheap and inert for a host with no `handOff`. */
+export declare function trackInFlightDeviceCall(call: ChatDeviceToolHandOff): TrackedDeviceCall;
+/** Tests only. */
+export declare function resetDeviceToolHandoffForTests(): void;

package/dist/host/device-tool-handoff.js

@@ -0,0 +1,45 @@
+import { getChatHost, isChatHostConfigured } from "./configure.js";
+const inFlight = /* @__PURE__ */ new Map();
+let bound = false;
+function handOffInFlightDeviceCalls() {
+  if (inFlight.size === 0 || !isChatHostConfigured()) return [];
+  const port = getChatHost().deviceTools;
+  if (!port?.handOff) return [];
+  const pending = [...inFlight.values()].filter((e) => !e.handedOff);
+  if (pending.length === 0) return [];
+  const calls = pending.map((e) => e.call);
+  for (const e of pending) e.handedOff = true;
+  try {
+    port.handOff(calls);
+  } catch (error) {
+    console.error("[Matrx] deviceTools.handOff threw; these calls are not owned by anyone:", calls, error);
+  }
+  return calls;
+}
+function bind() {
+  if (bound || typeof window === "undefined") return;
+  bound = true;
+  window.addEventListener("pagehide", (event) => {
+    if (event.persisted) return;
+    handOffInFlightDeviceCalls();
+  });
+}
+function trackInFlightDeviceCall(call) {
+  const entry = { call, handedOff: false };
+  inFlight.set(call.callId, entry);
+  bind();
+  return {
+    handedOff: () => entry.handedOff,
+    done: () => {
+      if (inFlight.get(call.callId) === entry) inFlight.delete(call.callId);
+    }
+  };
+}
+function resetDeviceToolHandoffForTests() {
+  inFlight.clear();
+}
+export {
+  handOffInFlightDeviceCalls,
+  resetDeviceToolHandoffForTests,
+  trackInFlightDeviceCall
+};

package/dist/host/index.d.ts

@@ -3,6 +3,7 @@
  */
 export * from "./contract.js";
 export { configureChat, DEFAULT_CHAT_APP, getChatHost, isChatHostConfigured, resolveChatHost, _resetChatHostForTests, } from "./configure.js";
+export { isMicrophonePermissionRefusal, withMicrophoneGrant } from "./microphone.js";
 export { attributionForSend, currentChatApp, type WireAttribution } from "./app-identity.js";
 export { ChatHostInvalidError, ChatHostNotConfiguredError, ChatOrganizationRequiredError, } from "./errors.js";
 export { createLogClientErrorDiagnostics, isChatSourceApp, CHAT_SOURCE_FEATURE, DIAGNOSTICS_FLUSH_DELAY_MS, DIAGNOSTICS_MAX_PER_FLUSH, } from "./defaults/diagnostics.js";

package/dist/host/index.js

@@ -7,6 +7,7 @@ import {
   resolveChatHost,
   _resetChatHostForTests
 } from "./configure.js";
+import { isMicrophonePermissionRefusal, withMicrophoneGrant } from "./microphone.js";
 import { attributionForSend, currentChatApp } from "./app-identity.js";
 import {
   ChatHostInvalidError,
@@ -107,8 +108,10 @@ export {
   isChatNoDatabaseError,
   isChatSourceApp,
   isChatWindowId,
+  isMicrophonePermissionRefusal,
   isNoDatabase,
   resolveChatHost,
   schedulerDb,
-  supabase
+  supabase,
+  withMicrophoneGrant
 };

package/dist/host/microphone.d.ts

@@ -0,0 +1,11 @@
+/**
+ * The microphone grant door. A browser that cannot show its permission prompt where the chat lives
+ * (a Chrome side panel) gives the microphone no way to be allowed there; the HOST knows where the
+ * prompt CAN appear (a small popup window) and says so through `ChatHost.microphone`. Package code
+ * that opens the microphone wraps its `getUserMedia` in `withMicrophoneGrant`: on a refusal it asks
+ * the host once, and only if the host reports the person allowed it tries again — once.
+ */
+import type { ChatMicrophonePort } from "./contract.js";
+/** True for the browser's permission verdict (`NotAllowedError`), not a missing or busy device. */
+export declare function isMicrophonePermissionRefusal(error: unknown): boolean;
+export declare function withMicrophoneGrant<T>(acquire: () => Promise<T>, port: ChatMicrophonePort | null | undefined): Promise<T>;

package/dist/host/microphone.js

@@ -0,0 +1,17 @@
+function isMicrophonePermissionRefusal(error) {
+  return error?.name === "NotAllowedError";
+}
+async function withMicrophoneGrant(acquire, port) {
+  try {
+    return await acquire();
+  } catch (error) {
+    if (!port || !isMicrophonePermissionRefusal(error)) throw error;
+    const granted = await port.requestPermission().catch(() => false);
+    if (!granted) throw error;
+    return acquire();
+  }
+}
+export {
+  isMicrophonePermissionRefusal,
+  withMicrophoneGrant
+};