@solidrt/core 0.0.73 → 0.0.75

package/AGENTS.md

@@ -118,16 +118,21 @@ tsconfig.json - the two load-bearing lines are jsx + jsxImportSource:
 Peer deps @solidjs/signals and @solidjs/universal must match (currently
 2.0.0-rc.14); bun resolves them from peerDependencies. On a version bump,
 `bun install` only warns ("incorrect peer dependency") and keeps the old
-ones, and `bun update solid-js @solidjs/signals @solidjs/universal` does
-not read the pin either: it adds all three to package.json at registry
-latest (solid-js 1.x, off Solid 2.0 entirely). The recipe that works
-deletes the installed copies and leaves the lockfile alone:
-`rm -rf node_modules/solid-js node_modules/@solidjs && bun install`
-(delete any nested `node_modules/@solidjs` too, or the old copy keeps
-resolving). Removing the directories is what forces re-resolution. Do not
-delete `bun.lock` to force it: that re-resolves every unrelated dependency
-as well, and a package that floats elsewhere fails the typecheck in a way
-that reads exactly like Solid fallout.
+ones, and so does deleting their node_modules copies first (bun 1.3.14
+reinstalls them from bun.lock). `bun update solid-js @solidjs/signals
+@solidjs/universal` does not read the pin either: it adds all three to
+package.json at registry latest (solid-js 1.x, off Solid 2.0 entirely).
+The recipe that works pins all three explicitly at the new version:
+`bun add solid-js@2.0.0-rc.14 @solidjs/signals@2.0.0-rc.14 @solidjs/universal@2.0.0-rc.14`.
+It moves exactly those three lock entries and nothing else. An app `sol
+init` wrote has the three pinned in package.json already (the scaffold
+carries them, and release.yml takes the pins from core's peerDependencies
+at publish), so there the upgrade is the pins edited and `bun install`.
+Do not delete `bun.lock` or its entries to force it: bun then re-resolves
+every dependency, and a package that floats elsewhere fails the typecheck
+in a way that reads exactly like Solid fallout. A Solid bump in this repo
+moves core's peerDependencies and the scaffold's pins
+(packages/cli/src/init/scaffold/package.json) together.
 
 ## Element model (the parts that are easy to get wrong)
 

package/docs/index.md

@@ -157,7 +157,7 @@ let camera = createCamera()
 ```
 
 The same pattern covers `@solidrt/core/microphone`, `/sound`,
-`/speech-recognition`, `/text-input`, `/image`, `/color`, and `/gpu`.
+`/text-input`, `/image`, `/color`, and `/gpu`.
 
 ## Lifecycle
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidrt/core",
-  "version": "0.0.73",
+  "version": "0.0.75",
   "license": "MIT",
   "funding": "https://github.com/sponsors/wellawaretech",
   "author": "Antoine van Wel",
@@ -17,7 +17,6 @@
     "./input": "./src/input.ts",
     "./audio": "./src/audio.ts",
     "./microphone": "./src/microphone.ts",
-    "./speech-recognition": "./src/speech-recognition.ts",
     "./text-input": "./src/text-input.ts",
     "./textures": "./src/textures.ts",
     "./video": "./src/video.ts",
@@ -33,8 +32,8 @@
     "AGENTS.md"
   ],
   "devDependencies": {
-    "@solidrt/flux-types": "0.0.73",
-    "@solidrt/test": "0.0.73"
+    "@solidrt/flux-types": "0.0.75",
+    "@solidrt/test": "0.0.75"
   },
   "peerDependencies": {
     "@solidjs/signals": "2.0.0-rc.14",

package/src/microphone.ts

@@ -1,8 +1,11 @@
 // Microphone capture, reactive (SolidJS) layer. A session delivers raw mono
 // float32 samples at the requested sample rate (the device format is converted
-// by SDL); read() drains whatever was captured since the last call. Captured
-// audio buffers until read, so poll read() regularly (e.g. once per frame) while
-// open.
+// by SDL); read() drains whatever was captured since the last call, out of a
+// 10 s window the session keeps, so nothing has to poll: read when the app
+// wants samples, and a runtime module that works on the audio reads the same
+// session on its own thread, given id(). Opening the microphone IS the
+// permission request (SDL semantics): it resolves once capture runs and
+// rejects if the user denies access.
 //
 // The imperative primitive lives in the `flux:microphone` module; import
 // { open, listMicrophones } from "flux:microphone" for non-reactive use.
@@ -17,33 +20,48 @@ export type MicrophoneOptions = {
   sampleRate?: number
 }
 
-/** A live microphone with reactive lifecycle. */
+/** A live microphone as reactive accessors. */
 export type MicrophoneStream = {
-  /** Sample rate of read() samples (0 if opening failed). */
+  /** The session id to hand a runtime module that reads this microphone, undefined while opening or if opening failed. */
+  id(): number | undefined
+  /** Sample rate of read() samples, 0 while opening or if opening failed. */
   sampleRate(): number
   /** Drain the mono float32 samples captured since the last read (empty if not open). */
   read(): Float32Array
-  /** Set if opening failed. */
+  /** Set if opening failed (e.g. permission denied). */
   error(): Error | undefined
 }
 
 /**
- * Opens a microphone and owns its lifecycle: closes when the reactive owner is
- * disposed. Capture stays pull-based, so read() drains samples on demand (e.g.
- * once per frame). For imperative use, call open() from "flux:microphone".
+ * Opens a microphone and exposes it as reactive signals: id() and
+ * sampleRate() are set once capture runs, error() if the open failed or the
+ * user denied the permission. Closes automatically when the reactive owner
+ * is disposed (e.g. the component unmounts). Capture stays pull-based:
+ * read() drains the samples captured since the last read, out of the
+ * session's 10 s window. For imperative use, call open() from
+ * "flux:microphone".
  */
 export function createMicrophone(options: MicrophoneOptions = {}): MicrophoneStream {
+  let [id, setId] = createSignal<number | undefined>(undefined)
+  let [sampleRate, setSampleRate] = createSignal(0)
   let [error, setError] = createSignal<Error | undefined>(undefined)
-  let session: ReturnType<typeof open> | undefined
-  let rate = 0
-  try {
-    session = open(options)
-    rate = session.sampleRate
-  } catch (e) {
-    setError(e instanceof Error ? e : new Error(String(e)))
-  }
+  let session: Awaited<ReturnType<typeof open>> | undefined
+  let disposed = false
+
+  open(options)
+    .then((mic) => {
+      if (disposed) {
+        mic.close()
+        return
+      }
+      session = mic
+      setId(mic.id)
+      setSampleRate(mic.sampleRate)
+    })
+    .catch((e) => setError(e instanceof Error ? e : new Error(String(e))))
 
   onCleanup(() => {
+    disposed = true
     if (session) {
       session.close()
       session = undefined
@@ -51,7 +69,8 @@ export function createMicrophone(options: MicrophoneOptions = {}): MicrophoneStr
   })
 
   return {
-    sampleRate: () => rate,
+    id,
+    sampleRate,
     read: () => (session ? session.read() : new Float32Array(0)),
     error,
   }

package/src/runtime-modules.d.ts

@@ -258,6 +258,13 @@ declare module "sol:test" {
    * Throws on a size that does not match the pixels.
    */
   export function camera(width: number, height: number, pixels: Uint8Array): void
+  /**
+   * Installs a mono float clip at `sampleRate` Hz as the microphone: every
+   * microphone the app opens at that rate from now on holds it from the
+   * open, with no device, and an open one hears it now. Throws on a rate of
+   * 0 or one that differs from an open test microphone's.
+   */
+  export function microphone(sampleRate: number, samples: Float32Array): void
   /**
    * Runs one frame: timers due by its time fire, then frame callbacks and
    * the flush, then the draw if anything demanded one. Fulfills once the

package/src/types.d.ts

@@ -23,18 +23,6 @@ declare global {
      */
     readonly env: { readonly DEV: boolean }
   }
-
-  let speech: {
-    start(options: {
-      model: Uint8Array, vadModel: Uint8Array, lang?: string, microphone?: number,
-      continuous?: boolean, interimResults?: boolean, wakeWord?: Uint8Array | string | string[], wakeThreshold?: number,
-    }): Promise<{ handle: number }>
-    setResultCallback(handle: number, callback: (result: { transcript: string, isFinal: boolean }) => void): void
-    setSpeechStartCallback(handle: number, callback: () => void): void
-    setSpeechEndCallback(handle: number, callback: () => void): void
-    setWakeCallback(handle: number, callback: () => void): void
-    stop(handle: number): void
-  }
 }
 
 // JSX value model. The element type is solid-js's (its control-flow components

package/src/speech-recognition.ts

@@ -1,150 +0,0 @@
-// Speech recognition. A session captures the microphone, segments utterances
-// by silence (Silero VAD) and transcribes each one with Whisper, delivering
-// final transcripts through onResult. With wakeWord the session starts
-// asleep behind an efficient wake word detector (livekit-wakeword) and only
-// transcribes after the wake word. startRecognition resolves once the models
-// are loaded and listening has begun; it rejects when the microphone cannot be
-// opened or the models fail to load.
-// Models are passed as bytes so any source composes: flux:fs file(), fetch
-// (incl. the dev-server file proxy), or a download cache layered on top.
-// Requires a runtime built with speech support.
-
-import { createSignal, onCleanup } from "@solidjs/signals"
-
-export type SpeechOptions = {
-  /** A ggml Whisper model (file contents, e.g. ggml-tiny.en.bin). */
-  model: Uint8Array
-  /** A ggml Silero VAD model (file contents). */
-  vadModel: Uint8Array
-  /** Whisper language code; "auto" detects (multilingual models only). Default "en". */
-  lang?: string
-  /** Explicit microphone device id from listMicrophones(). */
-  microphone?: number
-  /**
-   * Keep transcribing utterance after utterance. Default true. Set false to
-   * stop after the first final result (with wakeWord: re-arm instead, one
-   * result per wake). Inverse of the Web Speech API default (false there).
-   */
-  continuous?: boolean
-  /** Also deliver snapshot transcripts (final: false) while an utterance is still being spoken. */
-  interimResults?: boolean
-  /**
-   * Wake word: start asleep, fire onWake when it is heard, then transcribe
-   * the speech that follows. How the wake word is specified depends on the
-   * engine. The current engine detects with a trained classifier and takes
-   * the model's bytes (livekit-wakeword ONNX, e.g. the pretrained "hey
-   * livekit"; custom phrases are trained offline with its toolkit). Phrase
-   * strings are reserved for engines that match text; passing them to this
-   * engine rejects with an error.
-   */
-  wakeWord?: Uint8Array | string | string[]
-  /** Detector confidence (0..1) that counts as a wake. Default 0.5. */
-  wakeThreshold?: number
-}
-
-export type SpeechResult = {
-  /** Transcript of the utterance (a snapshot of it when isFinal is false). */
-  transcript: string
-  /** True for the completed utterance, false for interim snapshots. */
-  isFinal: boolean
-}
-
-export type SpeechSession = {
-  /** Receive transcripts (replaces any previous callback). */
-  onResult(callback: (result: SpeechResult) => void): void
-  /** The user started speaking (replaces any previous callback). */
-  onSpeechStart(callback: () => void): void
-  /** The utterance ended; its final result follows once transcribed. */
-  onSpeechEnd(callback: () => void): void
-  /** The wake word was heard (wakeWordModel sessions only). */
-  onWake(callback: () => void): void
-  /** Release the microphone and discard any utterance in progress. */
-  stop(): void
-}
-
-export async function startRecognition(options: SpeechOptions): Promise<SpeechSession> {
-  let started = await speech.start(options)
-  return {
-    onResult: (callback: (result: SpeechResult) => void) => speech.setResultCallback(started.handle, callback),
-    onSpeechStart: (callback: () => void) => speech.setSpeechStartCallback(started.handle, callback),
-    onSpeechEnd: (callback: () => void) => speech.setSpeechEndCallback(started.handle, callback),
-    onWake: (callback: () => void) => speech.setWakeCallback(started.handle, callback),
-    stop: () => speech.stop(started.handle),
-  }
-}
-
-/** A live recognition session as reactive accessors. */
-export type SpeechStream = {
-  /** True once the models are loaded and listening has begun. */
-  ready(): boolean
-  /** Latest transcript, "" until the first result (a snapshot while isFinal is false). */
-  transcript(): string
-  /** Whether transcript() is the completed utterance rather than an interim snapshot. */
-  isFinal(): boolean
-  /** True while the user is mid-utterance (between speech start and end). */
-  speaking(): boolean
-  /** True from when an utterance ends until its transcript arrives. */
-  transcribing(): boolean
-  /**
-   * wakeWord sessions only: true from when the wake word is heard until the
-   * following command is transcribed (the next final result), then false.
-   * Always false without a wakeWord.
-   */
-  awake(): boolean
-  /** Set if loading or starting failed. */
-  error(): Error | undefined
-}
-
-/**
- * Starts speech recognition and exposes it as reactive signals: read
- * transcript()/isFinal() for results, speaking() and awake() for session
- * state. Stops when the reactive owner is disposed. The lower-level
- * startRecognition() is the imperative alternative.
- */
-export function createSpeechRecognition(options: SpeechOptions): SpeechStream {
-  let [ready, setReady] = createSignal(false)
-  let [transcript, setTranscript] = createSignal("")
-  let [isFinal, setIsFinal] = createSignal(false)
-  let [speaking, setSpeaking] = createSignal(false)
-  let [transcribing, setTranscribing] = createSignal(false)
-  let [awake, setAwake] = createSignal(false)
-  let [error, setError] = createSignal<Error | undefined>(undefined)
-  let handle: number | undefined
-  let disposed = false
-
-  speech
-    .start(options)
-    .then((started) => {
-      if (disposed) {
-        speech.stop(started.handle)
-        return
-      }
-      handle = started.handle
-      speech.setResultCallback(started.handle, (result) => {
-        setTranscript(result.transcript)
-        setIsFinal(result.isFinal)
-        if (result.isFinal) {
-          setTranscribing(false)
-          setAwake(false)
-        }
-      })
-      speech.setSpeechStartCallback(started.handle, () => setSpeaking(true))
-      speech.setSpeechEndCallback(started.handle, () => {
-        setSpeaking(false)
-        setTranscribing(true)
-      })
-      speech.setWakeCallback(started.handle, () => setAwake(true))
-      setReady(true)
-    })
-    .catch((e) => setError(e instanceof Error ? e : new Error(String(e))))
-
-  onCleanup(() => {
-    disposed = true
-    if (handle !== undefined) {
-      speech.stop(handle)
-      handle = undefined
-    }
-  })
-
-  return { ready, transcript, isFinal, speaking, transcribing, awake, error }
-}