lecodes-sdk 2.2.8 → 2.2.10

package/src/plugins/gen/ar/sdk/controls.ts

@@ -0,0 +1,148 @@
+// GENERATED by scripts/vendor-plugins.ts from lecodes-plugins/plugins/ar/sdk/controls.ts — do not edit here.
+// Change it in the plugin repo and run `bun run vendor:plugins`; `bun run check:plugins` fails when this copy is stale.
+// AR object-placement controls — the classic "drop a model in the room and manipulate it" gesture
+// recipe: ONE finger drags the target over what the session finds under the finger (`hitTest`: a
+// plane), and where it finds nothing — the web, which finds no surfaces, or before one is known —
+// across the ground plane, relative to where the camera looks; TWO fingers pinch to scale and twist
+// to rotate (yaw). Lives on ARScene (`scene.addControls`) because it orchestrates the scene's camera,
+// its hit test and touch input against a target node; it's built entirely on the public API, so
+// it's a convenience, not a primitive.
+
+import { Quat, Vec2, Vec3, type Node, type Scene, type TouchStartEvent } from "../../../../plugin"
+import type { HitTarget } from "../contract"
+
+export type ControlsOptions = {
+  /** Smallest uniform scale the pinch gesture allows (default 0.08). */
+  minScale?: number
+  /** Largest uniform scale the pinch gesture allows (default 2). */
+  maxScale?: number
+  /** One-finger drag moves the target over the surfaces under the finger (default true). */
+  pan?: boolean
+  /** Two-finger pinch scales the target (default true). */
+  pinch?: boolean
+  /** Two-finger twist rotates the target around its Y axis (default true). */
+  twist?: boolean
+}
+
+/** Returned by `addControls` — call `remove()` to detach the gesture listeners. */
+export type ControlsHandle = { remove(): void }
+
+/** The scene the controls work on: ARScene's hit test, a Scene's camera and touches. */
+type PlacingScene = Scene & {
+  hitTest(x: number, y: number, target?: HitTarget): Promise<{ pose: { position: Vec3 } }[]>
+}
+
+type ActiveTouch = { pointerId: number, x: number, y: number }
+
+const clamp = (v: number, lo: number, hi: number): number => (v < lo ? lo : v > hi ? hi : v)
+
+export const attachControls = (scene: PlacingScene, target: Node, options: ControlsOptions = {}): ControlsHandle => {
+  const minScale = options.minScale ?? 0.08
+  const maxScale = options.maxScale ?? 2
+  const pan = options.pan ?? true
+  const pinch = options.pinch ?? true
+  const twist = options.twist ?? true
+
+  const active: ActiveTouch[] = []
+  let removed = false
+
+  // --- one finger: the hit test is a call to the session, so ONE is in flight at a time; the moves
+  // that come meanwhile add up and go with the next ---
+  let pending: { x: number, y: number, dx: number, dy: number } | null = null
+  let asking = false
+
+  /** The target onto a point of the world, its height and turn kept by the surface's. */
+  const placeAt = (world: Vec3): void => {
+    const w = target.worldMatrix.toArray()
+    w[12] = world.x; w[13] = world.y; w[14] = world.z
+    target.worldMatrix = w
+  }
+
+  /** Nothing under the finger: across the ground plane, relative to where the camera looks. */
+  const slide = (dx: number, dy: number): void => {
+    let dir = scene.camera.forward
+    const parent = target.parent
+    if (parent) dir = dir.rotate(parent.quaternion.invert()) // into the parent's local frame
+    dir = dir.withY(0)
+    const k = Math.hypot(dir.x, dir.z)
+    // the move's delta over the view's size: both logical units (a scene touch's, displaySize's), so
+    // a drag across the view slides the target by its distance from the camera on every host
+    const screen = Math.max(...scene.camera.displaySize)
+    if (k > 1e-4 && screen > 0) {
+      const dist = target.worldPosition.distanceTo(scene.camera.worldPosition)
+      const right = new Vec3(-dir.z, 0, dir.x).scale(dx / k / screen * dist)
+      const fwd = dir.scale(-dy / k / screen * dist)
+      const move = right.add(fwd)
+      const p = target.position
+      target.position = new Vec3(p.x + move.x, p.y, p.z + move.z) // keep height fixed
+    }
+  }
+
+  const ask = (): void => {
+    const drag = pending
+    if (!drag || asking) return
+    pending = null
+    asking = true
+    scene.hitTest(drag.x, drag.y, "planes").catch(() => []).then((hits) => {
+      asking = false
+      if (removed) return
+      const hit = hits[0]
+      if (hit) placeAt(hit.pose.position)
+      else slide(drag.dx, drag.dy)
+      ask()
+    })
+  }
+
+  const drag = (x: number, y: number, dx: number, dy: number): void => {
+    if (pending) { pending.x = x; pending.y = y; pending.dx += dx; pending.dy += dy }
+    else pending = { x, y, dx, dy }
+    ask()
+  }
+
+  const onTouchStart = (e: TouchStartEvent<Node | null>): void => {
+    const touch: ActiveTouch = { pointerId: e.pointerId, x: e.clientX, y: e.clientY }
+    active.push(touch)
+    e.track({
+      onMove(m) {
+        if (active.length === 2) {
+          // --- two-finger: pinch-scale + twist-rotate about the gesture axis ---
+          const other = active.find((t) => t !== touch)
+          if (other) {
+            const axis = new Vec2(other.x - touch.x, other.y - touch.y)
+            const span = axis.length()
+            if (span > 1e-3) {
+              const dir = axis.scale(1 / span)
+              const delta = new Vec2(m.deltaX, m.deltaY)
+              if (pinch) {
+                const along = -dir.dot(delta) // movement along the pinch axis
+                target.scale = clamp(target.scale.x * (span + along) / span, minScale * 0.4, maxScale * 1.5)
+              }
+              if (twist) {
+                const tangent = dir.perp().dot(delta) // movement across the axis
+                target.quaternion = target.quaternion.mul(Quat.fromAxisAngle(Vec3.up, Math.atan2(tangent, span)))
+              }
+            }
+          }
+        } else if (active.length === 1 && pan) {
+          drag(m.clientX, m.clientY, m.deltaX, m.deltaY)
+        }
+        touch.x = m.clientX
+        touch.y = m.clientY
+      },
+      onEnd() {
+        const i = active.indexOf(touch)
+        if (i >= 0) active.splice(i, 1)
+      },
+    })
+  }
+
+  scene.addEventListener("touchstart", onTouchStart)
+  return {
+    remove() {
+      removed = true
+      pending = null
+      scene.removeEventListener("touchstart", onTouchStart)
+      active.length = 0
+    },
+  }
+}

package/src/plugins/gen/audio-recorder/contract.d.ts

@@ -0,0 +1,64 @@
+// GENERATED by scripts/vendor-plugins.ts from lecodes-plugins/plugins/audio-recorder/contract.d.ts — do not edit here.
+// Change it in the plugin repo and run `bun run vendor:plugins`; `bun run check:plugins` fails when this copy is stale.
+// audio-recorder — audio recording to a file: voice messages, voice notes.
+// A session is ONE recording (the app-facing `AudioRecorder` opens one per `start()`): start, pause
+// / resume, then `stop()` for the file or `cancel()` to discard it. The microphone permission is the
+// contract's (`@permission microphone` on start): the host asks, the halves never do.
+//
+// The format is the platform's encoder: AAC in an .m4a on iOS and Android, what the browser's
+// MediaRecorder gives on the web (webm/opus in Chrome and Firefox, mp4 in Safari) — `mimeType`
+// says which, the app's server decides whether to transcode.
+
+import type { File, Service, f64 } from "../../../plugin"
+
+export interface RecordOptions {
+  /** Kilobits per second of the encoded audio. Default 64 — speech; 128 for music. */
+  bitrate?: f64
+  /** Samples per second. Default 44100; the browser keeps its own. */
+  sampleRate?: f64
+  /** Stop on its own after this many ms: `ended` fires with "maxDuration", `stop()` then returns
+   *  the recording. Default: no limit. */
+  maxDuration?: f64
+}
+
+export type EndReason = "maxDuration" | "interrupted" | "failed"
+
+export interface Recording {
+  /** The audio file — `recording.m4a` / `.webm` / `.mp4` by the encoder. */
+  file: File
+  /** "audio/mp4", "audio/webm", … — the container, without codec parameters. */
+  mimeType: string
+  /** Seconds of audio (the pauses left out). */
+  duration: f64
+}
+
+export interface AudioRecorderParams {}
+
+export interface AudioRecorderEvents {
+  /** The input level, 0..1, about ten times a second while recording (not while paused): a meter,
+   *  a waveform. */
+  level: { value: f64 }
+  /** The recording stopped on its own: the limit (`maxDuration`), an interruption (a call came in),
+   *  a failure of the encoder. What was recorded is kept until `stop()` (which returns it) or
+   *  `cancel()`. */
+  ended: { reason: EndReason }
+}
+
+export interface AudioRecorder extends Service<"audioRecorder", AudioRecorderParams, AudioRecorderEvents> {
+  /** Start recording. One recording per session: a second start rejects "busy".
+   *  @permission microphone
+   *  @rejects busy failed */
+  start(options?: RecordOptions): Promise<void>
+  /** Pause: the level stops, the duration does not grow. Rejects "notRecording" before a start
+   *  or after the recording ended.
+   *  @rejects notRecording failed */
+  pause(): Promise<void>
+  /** @rejects notRecording failed */
+  resume(): Promise<void>
+  /** Stop and get the recording (also after `ended`: the file was kept). Rejects "failed" when
+   *  nothing could be encoded.
+   *  @rejects notRecording failed */
+  stop(): Promise<Recording>
+  /** Stop and discard. Nothing to discard is not an error. */
+  cancel(): Promise<void>
+}

package/src/plugins/gen/audio-recorder/sdk/audio-recorder.gen.ts

@@ -0,0 +1,76 @@
+// GENERATED by scripts/vendor-plugins.ts from lecodes-plugins/plugins/audio-recorder/sdk/audio-recorder.gen.ts — do not edit here.
+// Change it in the plugin repo and run `bun run vendor:plugins`; `bun run check:plugins` fails when this copy is stale.
+// GENERATED by `lecodes plugin gen` from contract.d.ts — do not edit.
+// audio-recorder: the service "audioRecorder", contract version 1.
+
+import { ServiceChannel, _toFile } from "../../../../plugin"
+import type { AudioRecorderEvents, AudioRecorderParams, RecordOptions, Recording } from "../contract"
+
+/** What the halves register under. */
+export const NAME = "audioRecorder"
+/** The contract's version: the highest `@since` of its members. */
+export const VERSION = 1
+
+const _toRecording = (w: any): Recording => ({ ...w, file: _toFile(w.file) })
+
+// ---- the wire, call by call ----------------------------------------------------------------------
+
+/** Start recording. One recording per session: a second start rejects "busy".
+ *  Needs the "microphone" permission: the host asks before the call, "denied" when refused.
+ *  Rejects with "denied" / "busy" / "failed". */
+export const start = (service: ServiceChannel<AudioRecorderEvents>, options?: RecordOptions): Promise<void> =>
+  service._call("start", [options])
+
+/** Pause: the level stops, the duration does not grow. Rejects "notRecording" before a start
+ *  or after the recording ended.
+ *  Rejects with "notRecording" / "failed". */
+export const pause = (service: ServiceChannel<AudioRecorderEvents>): Promise<void> =>
+  service._call("pause", [])
+
+/** Rejects with "notRecording" / "failed". */
+export const resume = (service: ServiceChannel<AudioRecorderEvents>): Promise<void> =>
+  service._call("resume", [])
+
+/** Stop and get the recording (also after `ended`: the file was kept). Rejects "failed" when
+ *  nothing could be encoded.
+ *  Rejects with "notRecording" / "failed". */
+export const stop = (service: ServiceChannel<AudioRecorderEvents>): Promise<Recording> =>
+  service._call("stop", []).then((w: any) => _toRecording(w))
+
+/** Stop and discard. Nothing to discard is not an error. */
+export const cancel = (service: ServiceChannel<AudioRecorderEvents>): Promise<void> =>
+  service._call("cancel", [])
+
+// ---- what the host's half has --------------------------------------------------------------------
+
+/** A method of the contract. */
+export type Method = "start" | "pause" | "resume" | "stop" | "cancel"
+
+/** Whether this host has the service "audioRecorder" — and, given a method, a half new enough for it
+ *  (a method added after the first version of the contract is tagged `@since`). */
+export const supports = (method?: Method): boolean =>
+  ServiceChannel.supports(NAME)   // every method is of version 1
+
+// ---- the client -----------------------------------------------------------------------------------
+
+/** The service "audioRecorder" with the wire's methods as its own. */
+export class AudioRecorderBase extends ServiceChannel<AudioRecorderEvents> {
+  constructor(params: AudioRecorderParams = {}) { super("AudioRecorder", NAME, params) }
+
+  /** Start recording. One recording per session: a second start rejects "busy".
+   *  Needs the "microphone" permission: the host asks before the call, "denied" when refused.
+   *  Rejects with "denied" / "busy" / "failed". */
+  start(options?: RecordOptions): Promise<void> { return start(this, options) }
+  /** Pause: the level stops, the duration does not grow. Rejects "notRecording" before a start
+   *  or after the recording ended.
+   *  Rejects with "notRecording" / "failed". */
+  pause(): Promise<void> { return pause(this) }
+  /** Rejects with "notRecording" / "failed". */
+  resume(): Promise<void> { return resume(this) }
+  /** Stop and get the recording (also after `ended`: the file was kept). Rejects "failed" when
+   *  nothing could be encoded.
+   *  Rejects with "notRecording" / "failed". */
+  stop(): Promise<Recording> { return stop(this) }
+  /** Stop and discard. Nothing to discard is not an error. */
+  cancel(): Promise<void> { return cancel(this) }
+}

package/src/plugins/gen/audio-recorder/sdk/audio-recorder.ts

@@ -0,0 +1,113 @@
+// GENERATED by scripts/vendor-plugins.ts from lecodes-plugins/plugins/audio-recorder/sdk/audio-recorder.ts — do not edit here.
+// Change it in the plugin repo and run `bun run vendor:plugins`; `bun run check:plugins` fails when this copy is stale.
+// AudioRecorder — audio recording to a file: voice messages, voice notes.
+//
+// Hand-written over the generated wire because the app's object is not the wire's session: an
+// `AudioRecorder` is reusable — every `start()` opens a fresh host session (one recording), `stop()`
+// / `cancel()` close it — and its events are the SDK's `addEventListener` pattern.
+//
+// The microphone permission is asked by the host on `start()` (the contract's `@permission`); to
+// ask earlier, or to act on a denial, `permissions.request("microphone")` / `openSettings()`.
+
+import { Emitter } from "../../../../plugin"
+import { AudioRecorderBase, NAME } from "./audio-recorder.gen"
+import type { EndReason, RecordOptions, Recording } from "../contract"
+
+export type { EndReason, RecordOptions, Recording }
+
+/** `"stopped"` = the recording ended on its own (`ended` fired): `stop()` still returns it. */
+export type RecorderState = "inactive" | "recording" | "paused" | "stopped"
+
+export type AudioRecorderEvents = {
+  /** The input level, 0..1, about ten times a second while recording — a meter, a waveform. */
+  level: (value: number) => void
+  /** The recording stopped on its own: the limit, an interruption (a call came in), a failure.
+   *  `stop()` returns what was recorded. */
+  ended: (reason: EndReason) => void
+}
+
+/**
+ * Records the microphone to a file. `AudioRecorder.isSupported` reports whether this host
+ * registered the service — check it before showing a record button.
+ *
+ * ```ts
+ * const recorder = new AudioRecorder()
+ * recorder.addEventListener('level', v => meter.style({ width: v * 100 }))
+ * await recorder.start({ maxDuration: 60_000 })
+ * const { file, duration, mimeType } = await recorder.stop()
+ * ```
+ */
+export class AudioRecorder extends Emitter<AudioRecorderEvents> {
+  /** Whether this host registered an "audioRecorder" service. */
+  static get isSupported(): boolean { return AudioRecorderBase.supports(NAME) }
+
+  private _session: AudioRecorderBase | null = null
+  private _state: RecorderState = "inactive"
+
+  get state(): RecorderState { return this._state }
+
+  /** Start a recording. The host asks for the microphone first; rejects `"denied"` when refused,
+   *  `"failed"` when the recorder could not start, and before touching the host when it is not
+   *  supported or a recording is under way. */
+  async start(options?: RecordOptions): Promise<void> {
+    if (!AudioRecorder.isSupported) {
+      throw new Error('AudioRecorder isn\'t available on this host — it needs a registered "audioRecorder" service.')
+    }
+    if (this._session) throw new Error("AudioRecorder: a recording is under way — stop() or cancel() it first")
+    const session = new AudioRecorderBase()
+    session.on("level", payload => { if (payload) this.dispatch("level", payload.value) })
+    session.on("ended", payload => {
+      if (!payload || this._session !== session) return
+      this._state = "stopped"
+      this.dispatch("ended", payload.reason)
+    })
+    this._session = session
+    try {
+      await session.start(options ?? {})
+    } catch (e) {
+      this._drop(session)
+      throw e
+    }
+    if (this._session === session && this._state === "inactive") this._state = "recording"
+  }
+
+  /** Pause: the level stops, the duration does not grow. */
+  async pause(): Promise<void> {
+    if (!this._session || this._state !== "recording") throw new Error("AudioRecorder: not recording")
+    await this._session.pause()
+    if (this._state === "recording") this._state = "paused"
+  }
+
+  async resume(): Promise<void> {
+    if (!this._session || this._state !== "paused") throw new Error("AudioRecorder: not paused")
+    await this._session.resume()
+    if (this._state === "paused") this._state = "recording"
+  }
+
+  /** Stop and get the recording — also after `ended`. Rejects `"failed"` when nothing could be
+   *  encoded. The recorder is ready for another `start()` afterwards. */
+  async stop(): Promise<Recording> {
+    const session = this._session
+    if (!session) throw new Error("AudioRecorder: nothing to stop")
+    try {
+      return await session.stop()
+    } finally {
+      this._drop(session)
+    }
+  }
+
+  /** Stop and discard. Nothing under way is not an error. */
+  cancel(): void {
+    const session = this._session
+    if (!session) return
+    session.cancel().catch(() => {})
+    this._drop(session)
+  }
+
+  private _drop(session: AudioRecorderBase): void {
+    if (this._session !== session) return
+    session.close()
+    this._session = null
+    this._state = "inactive"
+  }
+}

package/src/plugins/gen/geolocation/contract.d.ts

@@ -4,8 +4,8 @@
 // The wire has ONE watch per session (startWatch / stopWatch + the `position` event); the
 // app-facing `Geolocation.watch(callback)` fans it out to its subscribers in sdk/.
 //
-// A session opens without a prompt. The OS permission prompt belongs to the first call that needs
-// the position.
+// A session opens without a prompt. The OS permission is the calls' (`@permission location`): the
+// host asks before the first call that needs the position, the halves never do.
 
 import type { Service, f64 } from "../../../plugin"
 
@@ -40,11 +40,13 @@ export interface GeolocationEvents {
 
 export interface Geolocation extends Service<"geolocation", GeolocationParams, GeolocationEvents> {
   /** One fix.
-   *  @rejects denied unavailable timeout */
+   *  @permission location
+   *  @rejects unavailable timeout */
   getCurrent(options?: GeoOptions): Promise<GeoPosition>
-  /** Start the session's watch; resolves once it is live (permission granted, provider started).
+  /** Start the session's watch; resolves once it is live (the provider started).
    *  A second call while watching resolves at once and keeps the first call's options.
-   *  @rejects denied unavailable */
+   *  @permission location
+   *  @rejects unavailable */
   startWatch(options?: GeoOptions): Promise<void>
   stopWatch(): Promise<void>
 }

package/src/plugins/gen/geolocation/sdk/geolocation.gen.ts

@@ -14,12 +14,14 @@ export const VERSION = 1
 // ---- the wire, call by call ----------------------------------------------------------------------
 
 /** One fix.
+ *  Needs the "location" permission: the host asks before the call, "denied" when refused.
  *  Rejects with "denied" / "unavailable" / "timeout". */
 export const getCurrent = (service: ServiceChannel<GeolocationEvents>, options?: GeoOptions): Promise<GeoPosition> =>
   service._call("getCurrent", [options])
 
-/** Start the session's watch; resolves once it is live (permission granted, provider started).
+/** Start the session's watch; resolves once it is live (the provider started).
  *  A second call while watching resolves at once and keeps the first call's options.
+ *  Needs the "location" permission: the host asks before the call, "denied" when refused.
  *  Rejects with "denied" / "unavailable". */
 export const startWatch = (service: ServiceChannel<GeolocationEvents>, options?: GeoOptions): Promise<void> =>
   service._call("startWatch", [options])
@@ -44,10 +46,12 @@ export class GeolocationBase extends ServiceChannel<GeolocationEvents> {
   constructor(params: GeolocationParams = {}) { super("Geolocation", NAME, params) }
 
   /** One fix.
+   *  Needs the "location" permission: the host asks before the call, "denied" when refused.
    *  Rejects with "denied" / "unavailable" / "timeout". */
   getCurrent(options?: GeoOptions): Promise<GeoPosition> { return getCurrent(this, options) }
-  /** Start the session's watch; resolves once it is live (permission granted, provider started).
+  /** Start the session's watch; resolves once it is live (the provider started).
    *  A second call while watching resolves at once and keeps the first call's options.
+   *  Needs the "location" permission: the host asks before the call, "denied" when refused.
    *  Rejects with "denied" / "unavailable". */
   startWatch(options?: GeoOptions): Promise<void> { return startWatch(this, options) }
   stopWatch(): Promise<void> { return stopWatch(this) }

package/src/plugins/gen/speech/contract.d.ts

@@ -0,0 +1,67 @@
+// GENERATED by scripts/vendor-plugins.ts from lecodes-plugins/plugins/speech/contract.d.ts — do not edit here.
+// Change it in the plugin repo and run `bun run vendor:plugins`; `bun run check:plugins` fails when this copy is stale.
+// speech — speech recognition: the microphone to text, live (dictation, voice commands).
+// A session is ONE listening (the app-facing `SpeechRecognizer` opens one per `start()`): results
+// arrive as events, partial ones while the user speaks and a final one after, then `end`. The
+// permissions are the contract's (`@permission speech microphone` on start): the host asks, the
+// halves never do.
+//
+// The recognizer is the platform's: Apple's (SFSpeechRecognizer: on-device where the language
+// allows, else Apple's servers), Google's on Android (the device's RecognitionService — absent on a
+// phone without Google's app: `start` rejects "unavailable"), the browser's on the web (Chrome sends
+// the audio to Google; Safari to Apple). Languages and quality differ with them.
+
+import type { Service, f64 } from "../../../plugin"
+
+export interface SpeechOptions {
+  /** BCP-47 — "en-US", "ru-RU". Default: the device's language. */
+  language?: string
+  /** Keep listening and delivering results until `stop()`; default false: one utterance — the
+   *  listening ends after a pause in the speech. */
+  continuous?: boolean
+  /** Deliver partial results while the user speaks (`isFinal` false). Default true. */
+  interimResults?: boolean
+  /** Recognize on the device only — no audio leaves it; fewer languages, and "unavailable" where
+   *  the device cannot. Default false. The web ignores it. */
+  onDevice?: boolean
+}
+
+export interface SpeechResult {
+  /** The text so far (a partial), or of the utterance (final). */
+  transcript: string
+  isFinal: boolean
+  /** 0..1 when the recognizer says; null when it does not (partials, Android). */
+  confidence: f64 | null
+}
+
+export type SpeechErrorCode = "noSpeech" | "audio" | "network" | "denied" | "aborted" | "unavailable" | "failed"
+
+export interface SpeechParams {}
+
+export interface SpeechEvents {
+  /** A result: partials while speaking (when `interimResults`), then the final one. */
+  result: SpeechResult
+  /** The user started speaking. */
+  speechStart: void
+  /** The user stopped speaking (a pause): the final result follows. */
+  speechEnd: void
+  /** The listening is over — after the final result, after `stop()` / `abort()`, after an error. */
+  end: void
+  /** The listening failed; `end` follows. "noSpeech": nothing was heard (not continuous). */
+  error: { code: SpeechErrorCode, message: string }
+}
+
+export interface Speech extends Service<"speech", SpeechParams, SpeechEvents> {
+  /** Start listening. One listening per session: a second start rejects "busy". "unavailable":
+   *  no recognizer on this device, or none for the language / on the device.
+   *  @permission speech microphone
+   *  @rejects busy unavailable failed */
+  start(options?: SpeechOptions): Promise<void>
+  /** Stop listening and finish: the final result of what was heard, then `end`. Not listening is
+   *  not an error. */
+  stop(): Promise<void>
+  /** Stop and drop what was heard: `end`, no result. */
+  abort(): Promise<void>
+  /** The languages this host recognizes, BCP-47; empty when the host cannot say (the web). */
+  supportedLanguages(): Promise<string[]>
+}

package/src/plugins/gen/speech/sdk/speech.gen.ts

@@ -0,0 +1,64 @@
+// GENERATED by scripts/vendor-plugins.ts from lecodes-plugins/plugins/speech/sdk/speech.gen.ts — do not edit here.
+// Change it in the plugin repo and run `bun run vendor:plugins`; `bun run check:plugins` fails when this copy is stale.
+// GENERATED by `lecodes plugin gen` from contract.d.ts — do not edit.
+// speech: the service "speech", contract version 1.
+
+import { ServiceChannel } from "../../../../plugin"
+import type { SpeechEvents, SpeechOptions, SpeechParams } from "../contract"
+
+/** What the halves register under. */
+export const NAME = "speech"
+/** The contract's version: the highest `@since` of its members. */
+export const VERSION = 1
+
+// ---- the wire, call by call ----------------------------------------------------------------------
+
+/** Start listening. One listening per session: a second start rejects "busy". "unavailable":
+ *  no recognizer on this device, or none for the language / on the device.
+ *  Needs the "speech" and "microphone" permissions: the host asks before the call, "denied" when refused.
+ *  Rejects with "denied" / "busy" / "unavailable" / "failed". */
+export const start = (service: ServiceChannel<SpeechEvents>, options?: SpeechOptions): Promise<void> =>
+  service._call("start", [options])
+
+/** Stop listening and finish: the final result of what was heard, then `end`. Not listening is
+ *  not an error. */
+export const stop = (service: ServiceChannel<SpeechEvents>): Promise<void> =>
+  service._call("stop", [])
+
+/** Stop and drop what was heard: `end`, no result. */
+export const abort = (service: ServiceChannel<SpeechEvents>): Promise<void> =>
+  service._call("abort", [])
+
+/** The languages this host recognizes, BCP-47; empty when the host cannot say (the web). */
+export const supportedLanguages = (service: ServiceChannel<SpeechEvents>): Promise<string[]> =>
+  service._call("supportedLanguages", [])
+
+// ---- what the host's half has --------------------------------------------------------------------
+
+/** A method of the contract. */
+export type Method = "start" | "stop" | "abort" | "supportedLanguages"
+
+/** Whether this host has the service "speech" — and, given a method, a half new enough for it
+ *  (a method added after the first version of the contract is tagged `@since`). */
+export const supports = (method?: Method): boolean =>
+  ServiceChannel.supports(NAME)   // every method is of version 1
+
+// ---- the client -----------------------------------------------------------------------------------
+
+/** The service "speech" with the wire's methods as its own. */
+export class SpeechBase extends ServiceChannel<SpeechEvents> {
+  constructor(params: SpeechParams = {}) { super("Speech", NAME, params) }
+
+  /** Start listening. One listening per session: a second start rejects "busy". "unavailable":
+   *  no recognizer on this device, or none for the language / on the device.
+   *  Needs the "speech" and "microphone" permissions: the host asks before the call, "denied" when refused.
+   *  Rejects with "denied" / "busy" / "unavailable" / "failed". */
+  start(options?: SpeechOptions): Promise<void> { return start(this, options) }
+  /** Stop listening and finish: the final result of what was heard, then `end`. Not listening is
+   *  not an error. */
+  stop(): Promise<void> { return stop(this) }
+  /** Stop and drop what was heard: `end`, no result. */
+  abort(): Promise<void> { return abort(this) }
+  /** The languages this host recognizes, BCP-47; empty when the host cannot say (the web). */
+  supportedLanguages(): Promise<string[]> { return supportedLanguages(this) }
+}