@glassly/engine 0.1.0-dev.0

package/README.md

@@ -0,0 +1,96 @@
+# @glassly/engine
+
+Glassly Engine — the on-device miniapp library.
+
+## Installation
+
+```sh
+npm install @glassly/engine
+```
+
+> **Peer packages:** the engine's `@glassly/*` peer dependencies (`crust`,
+> `cloud-client`, `cloud-protocol`, `miniapp`) must be available to your
+> package manager. Until every peer is published to npm, consume the engine
+> from this monorepo's workspace (as the example OEM app does).
+
+> **Module format:** the published entry points target **React Native /
+> Metro** consumers (the `react-native` exports condition). Loading
+> `@glassly/engine` from plain Node (`require`/ESM) is not supported at 0.1.x —
+> the `default` condition's build output is ESM with extensionless imports and
+> will not resolve under Node's loader.
+
+## Entry points
+
+The package exposes three entry points (declared in `package.json` `exports`,
+with the `react-native` condition pointing at `src/` so Metro, tsc and jest
+resolve live TypeScript source):
+
+- **`@glassly/engine`** (main, `src/index.ts`) — the OEM-facing surface: the
+  `engine` namespace (`configure`/`start`/`stop` + typed domain facades),
+  contract/read-model types, and pure helpers host UI renders with
+  (`decideReconnect`, `deriveDisplayState`, the `useApps`-style hooks,
+  OTA policy constants, hardware capability tables, `BgTimer`). Judgment rule:
+  read models, commands, pure functions and types are main; anything that
+  mutates runtime state or exposes a store/service is not.
+- **`@glassly/engine/internal`** (`src/internal.ts`) — the migration-era
+  runtime surface: raw zustand stores (`useCoreStore`, `useSettingsStore`,
+  `useAppStatusStore`, …) and service singletons (`appRegistry`, `restComms`,
+  `cloudClientService`, the gallery cluster, the miniapp engine, …). The
+  host's `@/stores/*` shims re-export from here. New host code should use
+  `engine.*` instead; `scripts/check-mobile-runtime-boundary.sh` counts every
+  `/internal` import in `mobile/src` (report-only) as the burn-down metric.
+- **`@glassly/engine/devtools`** (`src/devtools.ts`) — debug-only singletons
+  (`miniappRunningRegistry`, `devServerBridge`) for the internal dev screens.
+
+See `cloud-v2/docs/issues/020-glasses-status-boundary/integration-review.md`
+§D for the burn-down plan.
+
+This module owns the pieces of miniapp logic and handling that aren't tied to
+the rest of the manager app: the WebView message bus, the in-memory running
+registry, and the JS globals that we inject into every miniapp WebView.
+
+The goal is for all miniapp logic to live here over time. Today the move is
+incremental — only the self-contained services have moved. Cross-cutting
+services (LocalMiniappRuntime, MantleManager, Composer install pipeline) still
+live under `mobile/src/` because they reach back into the manager's stores and
+sockets.
+
+## Public surface
+
+```ts
+import {engine, decideDevLaunchRoute} from "@glassly/engine"
+import {webviewBridge, buildMiniappGlobalsScript} from "@glassly/engine/internal"
+import {miniappRunningRegistry} from "@glassly/engine/devtools"
+```
+
+- `webviewBridge` — registers per-package WebView message handlers so any
+  service can `postMessage` JSON into a specific miniapp.
+- `miniappRunningRegistry` — session-scoped set of currently-mounted local
+  miniapp packageNames (foreground + background).
+- `buildMiniappGlobalsScript` — builds the `window.Glassly` injection script
+  (and CSS variables / console-tap shim) used by every miniapp WebView.
+- `decideDevLaunchRoute` — pre-flight a dev URL's `miniapp.json` to decide
+  whether to mount live or take the user to the offline screen.
+
+## Imports
+
+Inside `mobile/modules/engine/src/`, use **relative paths** (`./services/...`,
+`../utils/...`). The mobile app's `@/*` alias is not configured here — there
+is no build-time path rewriter for this module.
+
+## Testing
+
+Run the suite with `bun run test` (from this directory). It executes
+`scripts/test.sh`, which runs **each test file in its own bun process** — do
+not replace it with a single `bun test src`.
+
+Why: bun's `mock.module` patches one process-wide module registry with live
+ESM bindings, last write wins. Several suites mock the same specifiers
+(`"@glassly/bluetooth-sdk/internal"` alone is mocked by `audioTestMocks.ts`,
+`PhonePhotoCoordinator.test.ts`, and others), so in a shared process one
+file's mock clobbers another's and suites that pass alone fail in the
+combined run. Per-file processes give every suite an isolated registry.
+
+The same rule applies when writing tests: it is fine to `mock.module` any
+specifier your suite needs, but never rely on a mock installed by a
+*different* test file — each file must set up everything it imports.

package/build/devtools.d.ts

@@ -0,0 +1,11 @@
+/**
+ * `@glassly/engine/devtools` — the devtools-only surface.
+ *
+ * Debug/diagnostic singletons consumed by the Glassly app's internal dev
+ * screens (stress test, miniapp dev-server tooling). Never import this from
+ * product UI or host services; every `/devtools` import in mobile/src is
+ * counted (report-only) by scripts/check-mobile-runtime-boundary.sh.
+ */
+export { miniappRunningRegistry } from "./services/MiniappRunningRegistry";
+export { default as devServerBridge } from "./services/DevServerBridge";
+//# sourceMappingURL=devtools.d.ts.map

package/build/devtools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"devtools.d.ts","sourceRoot":"","sources":["../src/devtools.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,EAAC,sBAAsB,EAAC,MAAM,mCAAmC,CAAA;AAExE,OAAO,EAAC,OAAO,IAAI,eAAe,EAAC,MAAM,4BAA4B,CAAA"}

package/build/devtools.js

@@ -0,0 +1,13 @@
+/**
+ * `@glassly/engine/devtools` — the devtools-only surface.
+ *
+ * Debug/diagnostic singletons consumed by the Glassly app's internal dev
+ * screens (stress test, miniapp dev-server tooling). Never import this from
+ * product UI or host services; every `/devtools` import in mobile/src is
+ * counted (report-only) by scripts/check-mobile-runtime-boundary.sh.
+ */
+// Which miniapps the local runtime currently has running (stress-test screen).
+export { miniappRunningRegistry } from "./services/MiniappRunningRegistry";
+// Dev-server connection bridge for live-reloading local miniapps.
+export { default as devServerBridge } from "./services/DevServerBridge";
+//# sourceMappingURL=devtools.js.map

package/build/devtools.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"devtools.js","sourceRoot":"","sources":["../src/devtools.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,+EAA+E;AAC/E,OAAO,EAAC,sBAAsB,EAAC,MAAM,mCAAmC,CAAA;AACxE,kEAAkE;AAClE,OAAO,EAAC,OAAO,IAAI,eAAe,EAAC,MAAM,4BAA4B,CAAA","sourcesContent":["/**\n * `@glassly/engine/devtools` — the devtools-only surface.\n *\n * Debug/diagnostic singletons consumed by the Glassly app's internal dev\n * screens (stress test, miniapp dev-server tooling). Never import this from\n * product UI or host services; every `/devtools` import in mobile/src is\n * counted (report-only) by scripts/check-mobile-runtime-boundary.sh.\n */\n\n// Which miniapps the local runtime currently has running (stress-test screen).\nexport {miniappRunningRegistry} from \"./services/MiniappRunningRegistry\"\n// Dev-server connection bridge for live-reloading local miniapps.\nexport {default as devServerBridge} from \"./services/DevServerBridge\"\n"]}

package/build/engine.d.ts

@@ -0,0 +1,336 @@
+/**
+ * `engine` — the namespaced OEM-facing engine API (the "(A) host API" from the
+ * Phase-1 contract). Host UI calls `engine.<domain>.<method>()`; each domain is a
+ * typed facade over the runtime. (Exported from the `@glassly/engine` module, whose
+ * name stays `engine` in code; the public API surface is `engine`.)
+ *
+ * It grows one facade at a time. The migration-era flat store/service exports
+ * live on the `@glassly/engine/internal` entry (and the debug singletons on
+ * `@glassly/engine/devtools`); they shrink as screens move onto `engine.*`.
+ */
+import { configure, updateUiSeams } from "./runtime/bootstrap";
+export declare const engine: {
+    /** Front door — hand engine auth + config, then start/stop the runtime. */
+    configure: typeof configure;
+    /** Merge host-UI seams on a running runtime (scan overlay, wifi setup, …). */
+    updateUiSeams: typeof updateUiSeams;
+    /** Start the runtime: mark started + construct/connect the cloud client + begin
+     * syncing device settings to the glasses. */
+    start(): Promise<void>;
+    /** Stop the runtime: tear down the settings sync + cloud client + mark stopped.
+     * Each step is guarded so one failing teardown can't skip the rest and leak
+     * the remaining runtime services. */
+    stop(): Promise<void>;
+    glasses: {
+        connectDefault: () => Promise<void>;
+        disconnect: () => Promise<void>;
+        forget: () => Promise<void>;
+        connect: (device: import("@glassly/bluetooth-sdk").Device, options?: import("@glassly/bluetooth-sdk").ConnectOptions | undefined) => Promise<void>;
+        connectSimulated: () => Promise<void>;
+        setDefault: (device: import("@glassly/bluetooth-sdk").Device | null) => Promise<void>;
+        reconnect: () => Promise<boolean>;
+        isFirstPairing: () => boolean;
+        hasDefaultDevice: () => Promise<boolean>;
+        status: () => import("./facades/glasses").GlassesStatusSnapshot;
+        onStatus: (cb: (status: import("./facades/glasses").GlassesStatusSnapshot) => void) => (() => void);
+        info: () => import("./facades/glasses").GlassesInfoSnapshot;
+        onInfo: (cb: (info: import("./facades/glasses").GlassesInfoSnapshot) => void) => (() => void);
+        capabilities: () => import("./types").Capabilities;
+        requestVersionInfo: () => Promise<import("@glassly/bluetooth-sdk").VersionInfoResult>;
+        onButtonPress: (cb: (event: import("@glassly/bluetooth-sdk").ButtonPressEvent) => void) => (() => void);
+        onTouchGesture: (cb: (event: import("@glassly/bluetooth-sdk").TouchEvent) => void) => (() => void);
+        controller: {
+            connectDefault: () => Promise<void>;
+            disconnect: () => Promise<void>;
+            forget: () => Promise<void>;
+            status: () => import("./facades/glasses").ControllerStatusSnapshot;
+            onStatus: (cb: (status: import("./facades/glasses").ControllerStatusSnapshot) => void) => (() => void);
+        };
+        audio: {
+            getMediaVolume: () => Promise<import("@glassly/bluetooth-sdk").GlassesMediaVolumeGetResult>;
+            setMediaVolume: (level: number) => Promise<import("@glassly/bluetooth-sdk").GlassesMediaVolumeSetResult>;
+            setOwnAppPlaying: (playing: boolean) => Promise<void>;
+        };
+        wifi: {
+            scan(): Promise<import("@glassly/bluetooth-sdk").WifiSearchResult[]>;
+            onScanResult(cb: (networks: import("@glassly/bluetooth-sdk").WifiSearchResult[]) => void): () => void;
+            connect(ssid: string, password: string): Promise<void>;
+            forget(ssid: string): Promise<void>;
+            status(): import("@glassly/bluetooth-sdk").WifiStatus;
+            onStatus(cb: (status: import("@glassly/bluetooth-sdk").WifiStatus, previous: import("@glassly/bluetooth-sdk").WifiStatus) => void): () => void;
+        };
+        settings: {
+            get: <T = unknown>(key: string) => T | undefined;
+            set: <T = unknown>(key: string, value: T) => import("typesafe-ts").AsyncResult<void, Error>;
+            onChanged: <T = unknown>(key: string, cb: (value: T | undefined) => void) => (() => void);
+            descriptor: (key: string) => import("./stores/settings").Setting;
+            available: () => string[];
+        };
+    };
+    speech: {
+        restartTranscriber: () => Promise<void>;
+        stt: {
+            currentLanguage: () => string;
+            languages: () => import("./internal").SttLanguageConfig[];
+            languageInfo: () => Promise<import("./internal").SttLanguageInfo[]>;
+            download: (code?: string | undefined, onProgress?: ((progress: import("./internal").SttDownloadProgress) => void) | undefined, onExtractionProgress?: ((progress: import("./internal").SttExtractionProgress) => void) | undefined) => Promise<void>;
+            activate: (code: string) => void;
+            cancelDownload: () => Promise<void>;
+            deleteModel: (code?: string | undefined) => Promise<void>;
+            status: () => import("./internal").OfflineModelDownloadStatus | null;
+            onStatusChanged: (listener: (status: import("./internal").OfflineModelDownloadStatus | null) => void) => () => void;
+        };
+        sonioxDirect: {
+            getStatus: () => import("./services/soniox/SonioxDirectService").SonioxDirectStatus;
+            onStatusChanged: (cb: (s: import("./services/soniox/SonioxDirectService").SonioxDirectStatus) => void) => () => void;
+            validateKey: (key: string) => Promise<{
+                ok: true;
+            } | {
+                ok: false;
+                reason: "invalid_key" | "network";
+            }>;
+        };
+        tts: {
+            currentLanguage: () => string;
+            languages: () => import("./services/TTSModelManager").TTSLanguageConfig[];
+            languageInfo: () => Promise<import("./services/TTSModelManager").TTSLanguageInfo[]>;
+            download: (code?: string | undefined, onProgress?: ((progress: import("./services/TTSModelManager").TTSDownloadProgress) => void) | undefined, onExtractionProgress?: ((progress: import("./services/TTSModelManager").TTSExtractionProgress) => void) | undefined) => Promise<void>;
+            activate: (code: string) => void;
+            cancelDownload: () => Promise<void>;
+            deleteModel: (_code?: string | undefined) => Promise<void>;
+        };
+    };
+    /** Cloud (cloud-v2) live-session status + account ops — engine owns the client. */
+    session: {
+        status: () => import(".").CloudClientStatusSnapshot;
+        onStatus: (cb: (status: import(".").CloudClientStatusSnapshot) => void) => (() => void);
+        isConnected: () => boolean;
+        legacyWebsocketStatus: () => import(".").WebSocketStatus;
+        onLegacyWebsocketStatus: (cb: (status: import(".").WebSocketStatus) => void) => (() => void);
+    };
+    /** Typed keyed user settings over the engine-owned settings store. */
+    settings: {
+        get: <T = unknown>(key: string) => T | undefined;
+        set: <T = unknown>(key: string, value: T, syncToServer?: boolean) => import("typesafe-ts").AsyncResult<void, Error>;
+        onChanged: <T = unknown>(key: string, cb: (value: T | undefined) => void) => (() => void);
+        descriptor: (key: string) => import("./stores/settings").Setting;
+        keys: () => string[];
+        resetAllLocal: () => void;
+        loadAll: () => import("typesafe-ts").AsyncResult<void, Error>;
+        getAll: () => Record<string, unknown>;
+        setManyLocal: (values: Record<string, unknown>) => import("typesafe-ts").AsyncResult<void, Error>;
+    };
+    /** Developer/debug surface (backend+cloud URL overrides, reconnect, min version). */
+    dev: {
+        cloudUrls: () => {
+            core?: string;
+            runtime?: string;
+        };
+        setCloudUrls: (urls: {
+            core?: string;
+            runtime?: string;
+        }) => void;
+        reconnectCloud: () => void;
+        getMemoryMB: () => number;
+        bluetoothStatus: () => Record<string, unknown>;
+        loadDevMiniapp: (url: string, name?: string) => Promise<{
+            ok: true;
+            packageName: string;
+            name: string;
+        } | {
+            ok: false;
+            error: string;
+        }>;
+        runtimeStatus: () => import("./facades/dev").DevRuntimeStatusSnapshot;
+        onRuntimeStatus: (cb: (status: import("./facades/dev").DevRuntimeStatusSnapshot) => void) => (() => void);
+    };
+    /** Bug-report, automatic runtime report, and feedback submission. */
+    reports: {
+        submit(input: import(".").EngineSubmitReportInput): Promise<import(".").ReportSubmitResult>;
+    };
+    /** Firmware OTA read/observe surface (updateAvailable/status + on* subscriptions). */
+    ota: {
+        install: (otaVersionUrl?: string | null | undefined) => Promise<import("@glassly/bluetooth-sdk").OtaStartAckEvent>;
+        ping: () => Promise<void>;
+        checkForUpdates: (options?: import(".").OtaCheckCurrentGlassesOptions) => Promise<import(".").OtaCheckCurrentGlassesResult>;
+        clearUpdateAvailable: () => void;
+        clearProgress: () => void;
+        replacePendingUpdateSequence: (updates: import("@glassly/bluetooth-sdk/internal").OtaUpdateInfo["updates"]) => import("@glassly/bluetooth-sdk/internal").OtaUpdateInfo | null;
+        clearBuildNumberForNextCheck: () => void;
+        markMtkUpdatedThisSession: (updated: boolean) => void;
+        installSession: {
+            prepare: (result: import(".").OtaCheckCurrentGlassesResult) => "wifi" | "hotspot";
+            attach: () => void;
+            detach: () => void;
+            retry: () => void;
+            finish: () => void;
+            discard: () => void;
+            snapshot: () => import(".").OtaInstallSnapshot;
+            onSnapshot: (cb: (snapshot: import(".").OtaInstallSnapshot) => void) => (() => void);
+        };
+        updateAvailable: () => import("@glassly/bluetooth-sdk/internal").OtaUpdateInfo | null;
+        status: () => import("@glassly/bluetooth-sdk").OtaStatus | null;
+        snapshot: () => import(".").OtaSnapshot;
+        onUpdateAvailable: (cb: (info: import("@glassly/bluetooth-sdk/internal").OtaUpdateInfo | null) => void) => (() => void);
+        onStatus: (cb: (status: import("@glassly/bluetooth-sdk").OtaStatus | null) => void) => (() => void);
+        onSnapshot: (cb: (snapshot: import(".").OtaSnapshot) => void) => (() => void);
+    };
+    /** Gallery sync: status/onStatus · onNotice (host renders) · sync/cancel. */
+    gallery: {
+        status: () => import("./facades/gallery").GallerySyncStatus;
+        onStatus: (cb: (status: import("./facades/gallery").GallerySyncStatus) => void) => (() => void);
+        onNotice: (cb: (notice: import(".").GalleryNotice) => void) => (() => void);
+        sync: () => Promise<void>;
+        cancel: () => Promise<void>;
+        refreshStatus: () => Promise<void>;
+        removeFilesFromQueue: (fileNames: string[]) => void;
+        clearQueue: () => void;
+        clearGlassesGalleryStatus: () => void;
+    };
+    /** Miniapp lifecycle (the WebView bridge primitives are exported separately). */
+    miniapps: {
+        list: () => import("./types").ClientApp[];
+        onChanged: (cb: (apps: import("./types").ClientApp[]) => void) => (() => void);
+        buttonPressSubscribers: () => string[];
+        onButtonPressSubscribersChanged: (cb: (packageNames: string[]) => void) => (() => void);
+        refresh: () => Promise<void>;
+        start: (app: import("./types").ClientApp, opts?: import(".").StartOptions | undefined) => Promise<boolean>;
+        stop: (packageName: string) => Promise<void>;
+        setForeground: (packageName: string) => Promise<void>;
+        clearForeground: () => void;
+        stopAll: () => import("typesafe-ts").AsyncResult<void, Error>;
+        install: (url: string, opts?: {
+            versionOverride?: string;
+        } | undefined) => import("typesafe-ts").AsyncResult<void, Error>;
+        uninstall: (packageName: string, version?: string | undefined) => import("typesafe-ts").AsyncResult<void, Error>;
+        saveScreenshot: (packageName: string, screenshot: string) => Promise<void>;
+        setHiddenStatus: (packageName: string, status: boolean) => void;
+    };
+    /** First-time glasses discovery + pairing. */
+    pairing: {
+        readiness: () => import("./facades/pairing").PairingReadinessSnapshot;
+        onReadiness: (cb: (readiness: import("./facades/pairing").PairingReadinessSnapshot) => void) => (() => void);
+        identity: () => import(".").IdentitySnapshot;
+        onIdentity: (cb: (identity: import(".").IdentitySnapshot) => void) => (() => void);
+        markPendingSelection: (model: string) => import("typesafe-ts").AsyncResult<void, Error>;
+        scan: (model: import("@glassly/bluetooth-sdk").DeviceModel) => Promise<void>;
+        scanning: () => boolean;
+        onScanning: (cb: (scanning: boolean) => void) => (() => void);
+        scanningController: () => boolean;
+        onScanningController: (cb: (scanning: boolean) => void) => (() => void);
+        otherBtConnected: () => boolean;
+        onOtherBtConnected: (cb: (connected: boolean) => void) => (() => void);
+        searchResults: () => {
+            id: string;
+            model: import("@glassly/bluetooth-sdk").DeviceModel;
+            name: string;
+            address?: string;
+            projectName?: string;
+            rssi?: number;
+        }[];
+        onFound: (cb: (results: ReturnType<() => import("./stores/core").CoreState>["searchResults"]) => void) => (() => void);
+        pair: (device: import("@glassly/bluetooth-sdk").Device, options?: import("@glassly/bluetooth-sdk").ConnectOptions) => Promise<void>;
+        setDefault: (device: import("@glassly/bluetooth-sdk").Device | null) => Promise<void>;
+        setBluetoothClassicTarget: (device: import("@glassly/bluetooth-sdk").Device) => Promise<void>;
+        abandonAttempt: () => Promise<void>;
+        onPairFailure: (cb: (event: import("@glassly/bluetooth-sdk").PairFailureEvent) => void) => (() => void);
+        onGlassesNotReady: (cb: (event: import("@glassly/bluetooth-sdk").GlassesNotReadyEvent) => void) => (() => void);
+        waitForReady: (options?: import("./facades/pairing").PairingReadyWaitOptions) => Promise<boolean>;
+        waitForBluetoothClassic: (options?: Pick<import("./facades/pairing").PairingReadyWaitOptions, "timeoutMs" | "signal">) => Promise<boolean>;
+    };
+    /** Phone→glasses notification forwarding (Android). */
+    phoneNotifications: {
+        installedApps: () => Promise<Array<{
+            packageName: string;
+            appName: string;
+            icon: string | null;
+        }>>;
+        blocklist: () => string[];
+        setBlocklist: (packageNames: string[]) => import("typesafe-ts").AsyncResult<void, Error>;
+        hasListenerPermission: () => Promise<boolean>;
+        requestListenerPermission: () => Promise<boolean> | undefined;
+    };
+    /** OS permissions (check/request/openSettings + per-miniapp requirements). */
+    permissions: {
+        check(feature: string): Promise<boolean>;
+        request(feature: string): Promise<boolean>;
+        openSettings: () => Promise<void>;
+        requirementsForMiniapp(packageName: string): Promise<import("./types").AppletPermission[]>;
+    };
+    /** Inbound alerts engine→host (crashloop, version-incompatible, connection loss). */
+    notifications: {
+        onNotification: (cb: (notification: import(".").IslandNotification) => void) => (() => void);
+    };
+    /** Maps providers — user-supplied Mapbox access token (Settings > Keys). */
+    maps: {
+        mapbox: {
+            validateKey: (apiKey: string) => Promise<{
+                ok: true;
+            } | {
+                ok: false;
+                reason: "invalid_key" | "network";
+            }>;
+        };
+    };
+    /** Shared user-scoped memory timeline (Settings > Memory + session.memory). */
+    memory: {
+        notes: () => Promise<import("@glassly/miniapp").MemoryEntry[]>;
+        addNote: (text: string, at?: number) => Promise<import("@glassly/miniapp").MemoryEntry | null>;
+        updateNote: (id: string, text: string) => Promise<boolean>;
+        removeEntry: (id: string) => Promise<boolean>;
+        sessions: () => Promise<import("@glassly/miniapp").MemorySession[]>;
+        removeScope: (scope: "session" | "day", at: number) => Promise<void>;
+        stats: () => Promise<import(".").MemoryStats>;
+        clearAll: () => Promise<void>;
+        onChanged: (listener: () => void) => (() => void);
+        retentionExtended: () => boolean;
+        retentionDays: (extended?: boolean) => number;
+        setRetentionExtended: (extended: boolean) => void;
+    };
+    /** Device-local voice profiles for on-device speaker ID (Settings > Speakers). */
+    speakers: {
+        getSelf: () => Promise<import(".").SpeakerProfile | null>;
+        onChanged: (listener: () => void) => (() => void);
+        enrollSelf: (opts?: {
+            targetSpeechSeconds?: number;
+        }) => Promise<import(".").EnrollOutcome>;
+        improveSelf: (opts?: {
+            targetSpeechSeconds?: number;
+        }) => Promise<import(".").EnrollOutcome>;
+        removeSelf: () => Promise<boolean>;
+        cancelEnrollment: () => void;
+        onEnrollProgress: (listener: (progress: import("@glassly/bluetooth-sdk/internal").SpeakerEnrollProgressEvent) => void) => (() => void);
+        model: {
+            isAvailable: () => Promise<boolean>;
+            sizeBytes: () => number;
+            download: (onProgress?: (p: import("./services/SpeakerIdModelManager").SpeakerIdModelProgress) => void) => Promise<void>;
+            cancelDownload: () => Promise<void>;
+        };
+    };
+    /** AI/voice provider key validation — user-supplied keys (Settings > API Keys). */
+    providerKeys: {
+        anthropic: {
+            validateKey: (apiKey: string) => Promise<import("./services/ProviderKeyValidation").KeyValidationResult>;
+        };
+        gemini: {
+            validateKey: (apiKey: string) => Promise<import("./services/ProviderKeyValidation").KeyValidationResult>;
+        };
+        openai: {
+            validateKey: (apiKey: string) => Promise<import("./services/ProviderKeyValidation").KeyValidationResult>;
+        };
+        elevenlabs: {
+            validateKey: (apiKey: string) => Promise<import("./services/ProviderKeyValidation").KeyValidationResult>;
+        };
+    };
+    display: {
+        mirror: {
+            current(): import(".").DisplayMirrorEvent;
+            onMirror(cb: (event: import(".").DisplayMirrorEvent) => void): () => void;
+            view(): string;
+            setView(view: "main" | "dashboard"): void;
+        };
+        text: (text: string, x?: number | undefined, y?: number | undefined, size?: number | undefined) => Promise<void>;
+        clear: () => Promise<void>;
+    };
+};
+//# sourceMappingURL=engine.d.ts.map

package/build/engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../src/engine.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,EAAC,SAAS,EAAkD,aAAa,EAAC,MAAM,qBAAqB,CAAA;AAsC5G,eAAO,MAAM,MAAM;IACjB,2EAA2E;;IAE3E,8EAA8E;;IAE9E;iDAC6C;;IAiF7C;;yCAEqC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA6BrC,mFAAmF;;;;;;;;IAEnF,sEAAsE;;;;;;;;;;;;IAEtE,qFAAqF;;;gBApGV,CAAC;mBACvE,CAAA;;;gBAIyD,CAAC;mBAM7D,CALC;;;;;;;;;;;;;;;;IAgGH,qEAAqE;;;;IAErE,sFAAsF;;;;;;;;;;;;;;;;;;;;;;;;;;;IAEtF,6EAA6E;;;;;;;;;;;;IAE7E,iFAAiF;;;;;;;;;;;;;;;;;;;IAEjF,8CAA8C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAE9C,uDAAuD;;;;;;;;;;;;IAEvD,8EAA8E;;;;;;;IAE9E,qFAAqF;;;;IAErF,4EAA4E;;;;;;;;;;;IAE5E,+EAA+E;;;;;;;;;;;;;;;IAE/E,kFAAkF;;;;;+BAtH/B,CAAC;;;+BAUmB,CAAA;;;;;;;;;;;;IA8GvE,mFAAmF;;;;;;;;;;;;;;;;;;;;;;;;;CAGpF,CAAA"}