@mentra/miniapp 0.3.0-beta.0

package/dist/modules/pivots/instructions.d.ts

@@ -0,0 +1,139 @@
+/**
+ * @fileoverview Routes-API instruction parsing helpers for the pivot
+ * engine.
+ *
+ * The Routes REST API returns per-step `navigationInstruction.instructions`
+ * strings like "Turn left onto Octavia Blvd" that unambiguously name the
+ * road being entered. Parsing these is the most reliable way to label a
+ * turn — more reliable than `StepInfo.road` from the Android Nav SDK,
+ * which lags one step behind for the live currentStep + uses a destination
+ * placeholder for the arrival leg.
+ *
+ * Originally lived in the Navigation miniapp's NavigationPage.tsx; moved
+ * into the SDK so every miniapp using `navigation.onPivot()` gets the
+ * same accurate road names without having to re-implement the parser.
+ *
+ * All helpers are pure — no side effects, no shared state.
+ */
+import type { LatLng, ManeuverKind } from "../navigation";
+/**
+ * Pull a short road name out of a Routes-API instruction string.
+ * Instructions look like:
+ *   "Turn left onto Octavia Blvd"
+ *   "Slight right onto Octavia St"
+ *   "Turn right onto Haight St\nDestination will be on the right"
+ *
+ * Returns null when the parse fails (e.g. instruction is missing, the
+ * "onto" clause is absent, or the captured text contains another
+ * maneuver verb / direction word). Callers treat null as "no road
+ * name available" and hide the label.
+ *
+ * Only "onto" is matched here — `\bon\b` was previously used as a
+ * fallback for depart steps ("Head north on Market St") but it
+ * over-matched, capturing maneuver verbs from stacked instructions
+ * ("Turn left, then turn right on..."). The depart step is the
+ * very first step and is dropped by the slice(0, -1) loop before
+ * this parser is called anyway, so removing the fallback costs us
+ * nothing real.
+ */
+export declare function roadNameFromInstruction(instruction?: string | null): string | null;
+export declare function sameRoad(a: string, b: string): boolean;
+/**
+ * Coarse left/right classifier for a maneuver string. Collapses all
+ * left variants (TURN_LEFT, SLIGHT_LEFT, SHARP_LEFT, UTURN_LEFT) to
+ * "left" and the rights to "right". Returns null when the maneuver
+ * isn't a directional turn (STRAIGHT, NAME_CHANGE, ARRIVE, etc.).
+ */
+export declare function turnDirection(maneuver?: string | null): "left" | "right" | null;
+export declare function bendAngleAt(points: LatLng[], junction: LatLng): number | null;
+/**
+ * Signed polyline bend at a junction. Positive = right turn, negative
+ * = left turn, in [-180, 180]. Used to pick a pivot's left/right
+ * direction from geometry when the Routes API's first-step maneuver
+ * is misleading (e.g. a curb-alignment micro-jog labeled TURN_LEFT
+ * right before the real right turn off Hayes onto Gough).
+ */
+export declare function signedBendAt(points: LatLng[], junction: LatLng): number | null;
+/**
+ * Minimum bend (degrees) for a junction to count as a real turn worth
+ * a pivot. Below this the route is effectively straight through the
+ * point; the Routes API may name it as a turn for legal/lane reasons
+ * but the user perceives no direction change.
+ */
+export declare const MIN_TURN_ANGLE_DEG = 30;
+/**
+ * Shape of a Routes-API computed step (matches `ComputedRouteStep` in
+ * the navigation module). Re-declared locally to avoid a circular
+ * import; the field set this helper needs is small.
+ */
+type ComputedStep = {
+    lat: number;
+    lng: number;
+    endLat: number;
+    endLng: number;
+    distanceMeters: number;
+    maneuver?: ManeuverKind;
+    instruction?: string;
+    /**
+     * Pre-resolved road name from the host's hybrid resolver (Phase 1).
+     * Preferred over `instruction` parsing when present — same parser
+     * runs host-side, just earlier in the pipeline. Older callers that
+     * only pass `instruction` still work via the parse fallback below.
+     */
+    road?: string | null;
+};
+/**
+ * A pivot derived from Routes-API computed steps. Carries the
+ * instruction-parsed road labels alongside the geometric corner,
+ * ready to be merged into the SDK's `Pivot` shape by the caller.
+ *
+ * `fromRoad` is required — we drop pivots whose entry road couldn't
+ * be parsed. `toRoad` is nullable because the LAST real turn before
+ * arrival has a known fromRoad but unknown toRoad (the arrival
+ * step's instruction is "Destination will be on the right", no road
+ * name in it). The pivot engine treats those nulls as candidates
+ * for the reverse-geocode fallback.
+ */
+export type InstructionPivot = {
+    lat: number;
+    lng: number;
+    fromRoad: string;
+    toRoad: string | null;
+    direction: "left" | "right" | null;
+    maneuver: ManeuverKind;
+};
+/**
+ * Derive accurate turn pivots from a Routes-API step list. Each
+ * computed step's `instruction` describes the maneuver that BEGINS
+ * that step ("Turn left onto Guerrero St"). A pivot sits at
+ * `step[i].end` — the junction where you leave step[i]'s road and
+ * turn onto step[i+1]'s road. So for each pair (step[i], step[i+1]):
+ *
+ *   fromRoad = roadNameFromInstruction(step[i].instruction)
+ *   toRoad   = roadNameFromInstruction(step[i+1].instruction)
+ *   anchor   = (step[i].endLat, step[i].endLng)
+ *   maneuver = step[i+1].maneuver (the actual turn type at the corner)
+ *
+ * A pivot survives these filters:
+ *   1. `fromRoad` parsed successfully from step[i]'s instruction.
+ *      Drop the pivot otherwise — we don't know the road the user
+ *      came from, and labeling the dot wouldn't make sense.
+ *   2. If `toRoad` parsed too, it must differ from `fromRoad` (drop
+ *      "stay on same road" jogs). If `toRoad` failed to parse, keep
+ *      the pivot with `toRoad: null` so the engine can recover it
+ *      via reverse-geocode. This is what keeps the LAST real turn
+ *      before arrival in the list — that step's instruction is
+ *      "Destination will be on the right" with no road name, but
+ *      the turn itself is real and the user needs to see it.
+ *   3. The drawn polyline bends ≥ MIN_TURN_ANGLE_DEG at the junction
+ *      (drops phantom turns where the geometry is visually straight).
+ *
+ * The LAST step (the arrival leg itself) is dropped by slice(0, -1) —
+ * the destination isn't a turn.
+ *
+ * Mirrors the Navigation miniapp's preview-turn extraction so live
+ * pivots match preview accuracy.
+ */
+export declare function extractPivotsFromComputedSteps(steps: ComputedStep[] | undefined, polyline: LatLng[]): InstructionPivot[];
+export {};
+//# sourceMappingURL=instructions.d.ts.map

package/dist/modules/pivots/instructions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"instructions.d.ts","sourceRoot":"","sources":["../../../src/modules/pivots/instructions.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EAAC,MAAM,EAAE,YAAY,EAAC,MAAM,eAAe,CAAA;AAqBvD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,uBAAuB,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,GAAG,IAAI,CA0BlF;AAaD,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAEtD;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,CAM/E;AAgBD,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAG7E;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAmB9E;AAED;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,KAAK,CAAA;AAEpC;;;;GAIG;AACH,KAAK,YAAY,GAAG;IAClB,GAAG,EAAE,MAAM,CAAA;IACX,GAAG,EAAE,MAAM,CAAA;IACX,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,EAAE,MAAM,CAAA;IACd,cAAc,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,EAAE,YAAY,CAAA;IACvB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB;;;;;OAKG;IACH,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CACrB,CAAA;AAED;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,gBAAgB,GAAG;IAC7B,GAAG,EAAE,MAAM,CAAA;IACX,GAAG,EAAE,MAAM,CAAA;IACX,QAAQ,EAAE,MAAM,CAAA;IAChB,MAAM,EAAE,MAAM,GAAG,IAAI,CAAA;IACrB,SAAS,EAAE,MAAM,GAAG,OAAO,GAAG,IAAI,CAAA;IAClC,QAAQ,EAAE,YAAY,CAAA;CACvB,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,8BAA8B,CAC5C,KAAK,EAAE,YAAY,EAAE,GAAG,SAAS,EACjC,QAAQ,EAAE,MAAM,EAAE,GACjB,gBAAgB,EAAE,CA6FpB"}

package/dist/modules/pivots/instructions.js

@@ -0,0 +1,280 @@
+/**
+ * @fileoverview Routes-API instruction parsing helpers for the pivot
+ * engine.
+ *
+ * The Routes REST API returns per-step `navigationInstruction.instructions`
+ * strings like "Turn left onto Octavia Blvd" that unambiguously name the
+ * road being entered. Parsing these is the most reliable way to label a
+ * turn — more reliable than `StepInfo.road` from the Android Nav SDK,
+ * which lags one step behind for the live currentStep + uses a destination
+ * placeholder for the arrival leg.
+ *
+ * Originally lived in the Navigation miniapp's NavigationPage.tsx; moved
+ * into the SDK so every miniapp using `navigation.onPivot()` gets the
+ * same accurate road names without having to re-implement the parser.
+ *
+ * All helpers are pure — no side effects, no shared state.
+ */
+import { bearingDeg, haversineMeters, signedAngleDiff } from "./geometry";
+/**
+ * Bare direction words that can sneak through the regex when the
+ * instruction's "onto"/"on" clause is followed directly by a bare
+ * direction ("Head south on the right"). Reject these so the parser
+ * returns null and the caller can hide the label instead of showing
+ * "the right" as a road name.
+ */
+const DIRECTION_WORDS = new Set(["right", "left", "the right", "the left", "north", "south", "east", "west"]);
+/**
+ * Maneuver verbs that appear in stacked instructions like
+ * "Turn left, then turn right onto Linden St" or fragments like
+ * "Continue onto Octavia". If a captured "road" contains any of
+ * these, it's not a road name — it's leftover instruction syntax
+ * from a multi-clause sentence. The parser rejects the capture.
+ */
+const MANEUVER_VERBS = /\b(turn|slight|sharp|continue|head|merge|exit|uturn|u-turn|then|keep)\b/i;
+/**
+ * Pull a short road name out of a Routes-API instruction string.
+ * Instructions look like:
+ *   "Turn left onto Octavia Blvd"
+ *   "Slight right onto Octavia St"
+ *   "Turn right onto Haight St\nDestination will be on the right"
+ *
+ * Returns null when the parse fails (e.g. instruction is missing, the
+ * "onto" clause is absent, or the captured text contains another
+ * maneuver verb / direction word). Callers treat null as "no road
+ * name available" and hide the label.
+ *
+ * Only "onto" is matched here — `\bon\b` was previously used as a
+ * fallback for depart steps ("Head north on Market St") but it
+ * over-matched, capturing maneuver verbs from stacked instructions
+ * ("Turn left, then turn right on..."). The depart step is the
+ * very first step and is dropped by the slice(0, -1) loop before
+ * this parser is called anyway, so removing the fallback costs us
+ * nothing real.
+ */
+export function roadNameFromInstruction(instruction) {
+    if (!instruction)
+        return null;
+    // Only the first line — drop "Destination will be on the right" etc.
+    const firstLine = instruction.split("\n")[0] ?? "";
+    // Match "onto ROAD" only. The "on" fallback was removed because it
+    // matched inside maneuver fragments and captured verbs as fake road
+    // names. Real turn instructions always use "onto"; depart steps
+    // (the only legitimate "on" users) aren't passed through this path.
+    const m = firstLine.match(/\bonto\s+(.+)$/i);
+    let raw = (m ? m[1] : "").trim();
+    if (!raw)
+        return null;
+    // A captured road name never contains a comma. If it does, we
+    // grabbed the rest of a multi-clause sentence by mistake.
+    if (raw.includes(","))
+        return null;
+    // Cut trailing direction/continuation clauses the API appends.
+    raw = raw.split(/\s+(?:toward|towards|to|and|then|for)\b/i)[0]?.trim() ?? "";
+    // Strip a unit/suite suffix ("Hayes St #116" → "Hayes St").
+    raw = raw.replace(/\s+#.*$/, "").trim();
+    if (!raw)
+        return null;
+    // Reject a bare direction word that slipped through.
+    if (DIRECTION_WORDS.has(raw.toLowerCase()))
+        return null;
+    // Reject anything containing maneuver verbs — the regex caught the
+    // wrong clause of a stacked instruction. Real road names don't
+    // contain "turn", "slight", "continue", etc.
+    if (MANEUVER_VERBS.test(raw))
+        return null;
+    return raw;
+}
+/**
+ * Equality check for road names that's robust to suffix variation
+ * ("Gough St" vs "Gough Street"), case, and trailing punctuation.
+ * Used to drop "stay on the same road" turns where the routes API
+ * names a turn but the user perceives a single continuous street.
+ */
+const ROAD_SUFFIXES = /\b(st|street|ave|avenue|blvd|boulevard|rd|road|dr|drive|ln|lane|way|ct|court|pl|place|ter|terrace|hwy|highway)\b\.?/g;
+function normalizeRoad(road) {
+    return road.toLowerCase().replace(ROAD_SUFFIXES, "").replace(/[^a-z0-9 ]/g, "").replace(/\s+/g, " ").trim();
+}
+export function sameRoad(a, b) {
+    return normalizeRoad(a) === normalizeRoad(b);
+}
+/**
+ * Coarse left/right classifier for a maneuver string. Collapses all
+ * left variants (TURN_LEFT, SLIGHT_LEFT, SHARP_LEFT, UTURN_LEFT) to
+ * "left" and the rights to "right". Returns null when the maneuver
+ * isn't a directional turn (STRAIGHT, NAME_CHANGE, ARRIVE, etc.).
+ */
+export function turnDirection(maneuver) {
+    if (!maneuver)
+        return null;
+    const m = maneuver.toUpperCase();
+    if (m.includes("LEFT"))
+        return "left";
+    if (m.includes("RIGHT"))
+        return "right";
+    return null;
+}
+/**
+ * How sharply the polyline actually bends at a given junction, in
+ * degrees [0, 180]. Probe walks outward from the polyline point
+ * nearest the junction until ~PROBE_METERS in each direction, then
+ * compares incoming vs outgoing bearings. The wide probe (22m) is
+ * deliberate: real street corners are rounded over 20–30m and a
+ * tighter probe under-reports the angle.
+ *
+ * Used to drop phantom turns the Routes API names at complex
+ * interchanges (Market → Gough → Market) where the drawn polyline is
+ * visually one straight line. Returns null when the polyline is too
+ * short to measure.
+ */
+const PROBE_METERS = 22;
+export function bendAngleAt(points, junction) {
+    const signed = signedBendAt(points, junction);
+    return signed == null ? null : Math.abs(signed);
+}
+/**
+ * Signed polyline bend at a junction. Positive = right turn, negative
+ * = left turn, in [-180, 180]. Used to pick a pivot's left/right
+ * direction from geometry when the Routes API's first-step maneuver
+ * is misleading (e.g. a curb-alignment micro-jog labeled TURN_LEFT
+ * right before the real right turn off Hayes onto Gough).
+ */
+export function signedBendAt(points, junction) {
+    if (points.length < 3)
+        return null;
+    let mid = 0;
+    let bestDist = Infinity;
+    for (let i = 0; i < points.length; i++) {
+        const d = haversineMeters(points[i], junction);
+        if (d < bestDist) {
+            bestDist = d;
+            mid = i;
+        }
+    }
+    let before = mid;
+    while (before > 0 && haversineMeters(points[before], points[mid]) < PROBE_METERS)
+        before--;
+    let after = mid;
+    while (after < points.length - 1 && haversineMeters(points[after], points[mid]) < PROBE_METERS)
+        after++;
+    if (before === mid || after === mid)
+        return null;
+    const incoming = bearingDeg(points[before], points[mid]);
+    const outgoing = bearingDeg(points[mid], points[after]);
+    return signedAngleDiff(outgoing, incoming);
+}
+/**
+ * Minimum bend (degrees) for a junction to count as a real turn worth
+ * a pivot. Below this the route is effectively straight through the
+ * point; the Routes API may name it as a turn for legal/lane reasons
+ * but the user perceives no direction change.
+ */
+export const MIN_TURN_ANGLE_DEG = 30;
+/**
+ * Derive accurate turn pivots from a Routes-API step list. Each
+ * computed step's `instruction` describes the maneuver that BEGINS
+ * that step ("Turn left onto Guerrero St"). A pivot sits at
+ * `step[i].end` — the junction where you leave step[i]'s road and
+ * turn onto step[i+1]'s road. So for each pair (step[i], step[i+1]):
+ *
+ *   fromRoad = roadNameFromInstruction(step[i].instruction)
+ *   toRoad   = roadNameFromInstruction(step[i+1].instruction)
+ *   anchor   = (step[i].endLat, step[i].endLng)
+ *   maneuver = step[i+1].maneuver (the actual turn type at the corner)
+ *
+ * A pivot survives these filters:
+ *   1. `fromRoad` parsed successfully from step[i]'s instruction.
+ *      Drop the pivot otherwise — we don't know the road the user
+ *      came from, and labeling the dot wouldn't make sense.
+ *   2. If `toRoad` parsed too, it must differ from `fromRoad` (drop
+ *      "stay on same road" jogs). If `toRoad` failed to parse, keep
+ *      the pivot with `toRoad: null` so the engine can recover it
+ *      via reverse-geocode. This is what keeps the LAST real turn
+ *      before arrival in the list — that step's instruction is
+ *      "Destination will be on the right" with no road name, but
+ *      the turn itself is real and the user needs to see it.
+ *   3. The drawn polyline bends ≥ MIN_TURN_ANGLE_DEG at the junction
+ *      (drops phantom turns where the geometry is visually straight).
+ *
+ * The LAST step (the arrival leg itself) is dropped by slice(0, -1) —
+ * the destination isn't a turn.
+ *
+ * Mirrors the Navigation miniapp's preview-turn extraction so live
+ * pivots match preview accuracy.
+ */
+export function extractPivotsFromComputedSteps(steps, polyline) {
+    if (!steps || steps.length < 2)
+        return [];
+    const initial = steps.map((s, i) => ({
+        stepIdx: i,
+        name: s.road ?? roadNameFromInstruction(s.instruction),
+    }));
+    let annotated = initial;
+    for (let pass = 0; pass < 4; pass++) {
+        const collapsed = [];
+        for (let i = 0; i < annotated.length; i++) {
+            const prev = collapsed[collapsed.length - 1];
+            const here = annotated[i];
+            const next = annotated[i + 1];
+            if (prev?.name &&
+                next?.name &&
+                here.name &&
+                !sameRoad(prev.name, here.name) &&
+                sameRoad(prev.name, next.name)) {
+                // `here` is a sandwiched micro-jog — drop it. `next` will be
+                // collapsed against `prev` on the same-road check below.
+                continue;
+            }
+            collapsed.push(here);
+        }
+        if (collapsed.length === annotated.length)
+            break;
+        annotated = collapsed;
+    }
+    const out = [];
+    // Pair each annotated entry with the next one. Note we no longer
+    // walk `steps` directly — `annotated` is the collapsed view, so
+    // adjacent annotated entries already represent the real road
+    // transitions. `stepIdx` is preserved so we can still look up the
+    // junction coordinates and maneuver from the original `steps` array.
+    for (let i = 0; i < annotated.length - 1; i++) {
+        const here = annotated[i];
+        const nextAnn = annotated[i + 1];
+        const s = steps[here.stepIdx];
+        const next = steps[nextAnn.stepIdx];
+        const fromRoad = here.name;
+        const toRoad = nextAnn.name;
+        // fromRoad is required; toRoad is nullable (last-turn-before-arrival
+        // has no road name in the arrival step's instruction).
+        if (!fromRoad)
+            continue;
+        if (toRoad && sameRoad(fromRoad, toRoad))
+            continue;
+        if (!Number.isFinite(s.endLat) || !Number.isFinite(s.endLng))
+            continue;
+        const junction = { lat: s.endLat, lng: s.endLng };
+        const signedBend = signedBendAt(polyline, junction);
+        // No polyline to measure → keep (don't drop a labeled turn just
+        // because geometry was unavailable).
+        if (signedBend != null && Math.abs(signedBend) < MIN_TURN_ANGLE_DEG)
+            continue;
+        // Direction precedence: trust polyline geometry first. The Routes
+        // API decomposes some junctions into micro-step jogs whose first
+        // step's maneuver lies (e.g. a "TURN_LEFT" curb-alignment jog
+        // right before the actual right turn off Hayes onto Gough).
+        // Geometry doesn't lie. Falls back to the maneuver string when
+        // the polyline is too short to measure a bend.
+        const geomDir = signedBend == null ? null : signedBend > 0 ? "right" : "left";
+        const direction = geomDir ?? turnDirection(next.maneuver);
+        out.push({
+            lat: s.endLat,
+            lng: s.endLng,
+            fromRoad,
+            toRoad,
+            direction,
+            maneuver: next.maneuver ?? (direction === "left" ? "TURN_LEFT" : "TURN_RIGHT"),
+        });
+    }
+    return out;
+}
+//# sourceMappingURL=instructions.js.map

package/dist/modules/pivots/instructions.js.map

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

package/dist/modules/speaker.d.ts

@@ -0,0 +1,169 @@
+/**
+ * @fileoverview SpeakerModule — phone-side audio output.
+ *
+ * Mirrors cloud SDK v3's SpeakerManager naming. Audio *input* (transcription,
+ * audio chunks, VAD) lives on session.mic — the split is by I/O direction.
+ *
+ * Imperative surface:
+ *   speaker.play({audioUrl})   — play an arbitrary URL via the phone's
+ *                                AudioPlaybackService.
+ *   speaker.speak(text)        — send a SPEAK request. Phone streams cloud
+ *                                TTS when connected and falls back to local
+ *                                offline TTS when cloud is unavailable.
+ *                                Resolves when playback completes; rejects
+ *                                with a TTS_* error code on cloud failure.
+ *   speaker.createStream(opts) — open a live PCM output stream (16-bit LE).
+ *                                Returns a SpeakerStreamWriter: write() PCM
+ *                                chunks as they arrive (e.g. from a WebSocket
+ *                                in the background), close() to drain, abort()
+ *                                to drop. write() resolves with {bufferedMs}
+ *                                so producers can throttle.
+ *   speaker.stop()             — stop any audio this miniapp is playing.
+ *
+ * State observability:
+ *   speaker.state              — current SpeakerState (sync getter).
+ *   speaker.isPlaying          — true iff state === "playing".
+ *   speaker.onStateChange(h)   — fires on every state transition.
+ *
+ * State machine (per miniapp):
+ *   idle ─── speak()/play() ──► loading ──► playing ──► stopped
+ *                                  │            │           │
+ *                                  └── error ───┴── stop ───┘
+ *
+ * `error` is transient — fires once with errorCode set, then settles to
+ * `stopped` so isPlaying reads false correctly.
+ */
+import { MiniappSession } from "../session";
+import type { UnsubscribeFn } from "./events";
+export interface PlayAudioOptions {
+    audioUrl: string;
+    volume?: number;
+    stopOtherAudio?: boolean;
+}
+export interface SpeakOptions {
+    voice_id?: string;
+    voice_settings?: Record<string, unknown>;
+    volume?: number;
+    stopOtherAudio?: boolean;
+    /**
+     * Force this call to use on-device offline TTS, skipping cloud TTS
+     * entirely — even when cloud is connected. Rejects with `TTS_LOCAL_UNAVAILABLE`
+     * if the offline model isn't ready instead of falling back to cloud.
+     */
+    forceLocal?: boolean;
+}
+export interface SpeakResult {
+    /** True if playback completed; false if playback was interrupted. */
+    completed: boolean;
+}
+export type SpeakerState = "idle" | "loading" | "playing" | "stopped" | "error";
+/** Sample rates the native chunk player accepts. */
+export type SpeakerStreamSampleRate = 16000 | 24000 | 48000;
+export interface SpeakerStreamOptions {
+    /** PCM sample rate in Hz. Default 16000. */
+    sampleRate?: SpeakerStreamSampleRate;
+    /** Channel count. v1 is mono only. Default 1. */
+    channels?: 1;
+    /** Playback volume 0..1. Default 1. */
+    volume?: number;
+    /** Stop any other audio this miniapp is playing first. Default true. */
+    stopOtherAudio?: boolean;
+}
+export interface SpeakerStreamWriteResult {
+    /** Milliseconds of audio queued host-side but not yet played. */
+    bufferedMs: number;
+}
+/** Raw bytes per bridge write. PCM chunks are small; keep messages snappy. */
+export declare const SPEAKER_WRITE_CHUNK_BYTES: number;
+/**
+ * Soft backpressure ceiling. When the host reports more than this buffered,
+ * it holds the WRITE reply until the buffer drains below it, so a producer
+ * that awaits each write self-throttles to realtime.
+ */
+export declare const SPEAKER_STREAM_MAX_BUFFERED_MS = 2000;
+/**
+ * Live PCM writer returned by `speaker.createStream()`. 16-bit little-endian
+ * PCM only — decode compressed formats (MP3/Opus) server-side before sending.
+ *
+ * Call `write()` as chunks arrive (each is auto-split into bridge-safe
+ * messages), then `close()` to drain and finish, or `abort()` to drop
+ * immediately. Shaped like BlobWriter so the two stream APIs feel the same.
+ */
+export declare class SpeakerStreamWriter {
+    private readonly session;
+    readonly streamId: string;
+    private settled;
+    private writeChain;
+    constructor(session: MiniappSession, streamId: string);
+    /**
+     * Append raw PCM bytes (16-bit LE). Auto-chunked. Resolves with the host's
+     * buffered-ms after the last chunk. The host holds the reply while its
+     * buffer is above the backpressure ceiling, so a producer that awaits each
+     * write self-throttles to realtime.
+     */
+    write(chunk: Uint8Array | ArrayBuffer): Promise<SpeakerStreamWriteResult>;
+    /** Append already-base64-encoded PCM bytes (e.g. relayed straight off a WS frame). */
+    writeBase64(b64: string): Promise<SpeakerStreamWriteResult>;
+    /** Drain the remaining buffer and finish. Resolves when playback has ended. */
+    close(): Promise<{
+        durationMs?: number;
+    }>;
+    /** Stop immediately and drop any buffered audio. Idempotent. */
+    abort(): Promise<void>;
+    private assertOpen;
+    private send;
+    /** Preserve PCM ordering even when a producer issues overlapping writes. */
+    private enqueueWrite;
+}
+export interface SpeakerStateEvent {
+    state: SpeakerState;
+    /** When state === "error", the underlying error code (TTS_*, INTERNAL). */
+    errorCode?: string;
+    errorMessage?: string;
+    /** When state === "stopped", how many ms the playback ran (best-effort). */
+    durationMs?: number;
+}
+export declare class SpeakerModule {
+    private readonly session;
+    private _state;
+    private _lastEvent;
+    constructor(session: MiniappSession);
+    /** Current speaker playback state. */
+    get state(): SpeakerState;
+    /** True iff state === "playing". */
+    get isPlaying(): boolean;
+    /** Play a URL. Resolves when playback completes on the phone. */
+    play(options: PlayAudioOptions): Promise<void>;
+    /**
+     * Speak text through the phone. The host streams cloud TTS when connected,
+     * then falls back to local offline TTS.
+     *
+     * Rejects with a MiniappRequestError containing a `code` field on cloud-side
+     * TTS failures: `TTS_TEXT_TOO_LONG`, `TTS_INVALID_VOICE`, `TTS_UPSTREAM_ERROR`.
+     */
+    speak(text: string, options?: SpeakOptions): Promise<SpeakResult>;
+    /**
+     * Open a live PCM output stream (16-bit LE) to the phone's audio playback
+     * service. Use from the background to play audio that arrives in chunks
+     * (e.g. live meeting audio over a WebSocket) with low latency — unlike
+     * `play()`, nothing has to be a file or URL first.
+     *
+     * One stream per miniapp: opening a second closes the first. Rejects with
+     * `NOT_IMPLEMENTED` on hosts that predate streaming. Miniapps that depend on
+     * this API must declare `minHostVersion: "2.13.0"` or newer.
+     */
+    createStream(options?: SpeakerStreamOptions): Promise<SpeakerStreamWriter>;
+    /** Stop any audio this miniapp is currently playing. */
+    stop(): void;
+    /**
+     * Subscribe to speaker state transitions. Fires for every change. Does NOT
+     * fire immediately with the current value — call `state` separately if you
+     * want the seed.
+     */
+    onStateChange(handler: (event: SpeakerStateEvent) => void): UnsubscribeFn;
+    /** @internal — applied by MiniappSession on inbound SPEAKER_STATE envelope. */
+    _applyState(event: SpeakerStateEvent): void;
+    /** @internal — for tests. */
+    _getLastEvent(): SpeakerStateEvent;
+}
+//# sourceMappingURL=speaker.d.ts.map

package/dist/modules/speaker.d.ts.map

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