@stringsync/splates 0.0.60 → 1.13.3

package/vendor/core/dictate/microphone.d.ts

@@ -0,0 +1,42 @@
+import type { Resource } from "../disposable/index.js";
+import type { Eventful } from "../events/index.js";
+import { Duration } from "../time/index.js";
+import type { Cue } from "./cue";
+/** How often a recording says how loud it is. */
+export declare const TICK: Duration;
+/** Whether the browser hands over the mic, asks first, or refuses; "unknown" when it will not say. */
+export type MicPermission = PermissionState | "unknown";
+/** Somewhere to record from: the browser's mic, or a fake in a test. */
+export interface Microphone {
+    /** Whether starting will ask the user for the mic. */
+    permission(): Promise<MicPermission>;
+    /**
+     * Starts recording, asking for the mic the first time, and sends `sink`
+     * each stretch of audio as it comes. Called on the tap itself, before any
+     * await, so a phone counts it as the user's gesture.
+     */
+    start(sink: AudioSink): Promise<Recording>;
+}
+/** Where a recording's audio goes as it comes: the server's live socket, or a test. */
+export interface AudioSink {
+    /** Takes the next stretch of audio, PCM16 at `SAMPLE_RATE`. */
+    send(pcm: Uint8Array<ArrayBuffer>): void;
+}
+export interface RecordingEvents extends Record<string, unknown> {
+    /**
+     * Every {@link TICK}: how loud the input was since the last, from 0 to 1,
+     * or null when no audio arrived at all.
+     */
+    tick: number | null;
+    /** Why the recording stopped hearing: the page was hidden, a call took the mic. */
+    interrupted: string;
+}
+/** A recording under way: `dispose` hands over what is left and lets go of the mic. */
+export interface Recording extends Eventful<RecordingEvents>, Resource {
+    /**
+     * Plays `cue` out loud, quietly. The `start` cue keeps its own sound out of
+     * the recording; a `stop` cue waits for `dispose`, which plays it once the
+     * mic is let go.
+     */
+    cue(cue: Cue): void;
+}

package/vendor/core/dictate/openai-transcriber.d.ts

@@ -0,0 +1,22 @@
+import type { Transcriber, Transcription } from "./transcriber";
+/**
+ * Streams text as the audio arrives. `gpt-4o-transcribe` would only start on
+ * a turn once it ended, so the text would come a pause at a time.
+ */
+export declare const MODEL = "gpt-live-transcribe";
+export interface OpenAiTranscriberOptions {
+    /** What the take is, read before the audio. */
+    prompt?: string;
+    /** Names the model should spell the way this repo does. */
+    keywords?: string[];
+    /** OpenAI's by default; a test hands in its own. */
+    url?: string;
+}
+/** Transcribes through OpenAI's Realtime API, a websocket per take. */
+export declare class OpenAiTranscriber implements Transcriber {
+    private readonly apiKey;
+    private readonly opts;
+    private readonly url;
+    constructor(apiKey: string, opts?: OpenAiTranscriberOptions);
+    listen(): Promise<Transcription>;
+}

package/vendor/core/dictate/openai-transcription.d.ts

@@ -0,0 +1,27 @@
+import type { Transcription, TranscriptionEvents } from "./transcriber";
+/** One take's websocket to OpenAI's Realtime API. */
+export declare class OpenAiTranscription implements Transcription {
+    private readonly socket;
+    private readonly dispatcher;
+    readonly events: import("../events/index.js").Events<TranscriptionEvents>;
+    /** Each item's text, in the order it was first heard. */
+    private readonly items;
+    private readonly completed;
+    private committed;
+    private sent;
+    private finishing;
+    private failure;
+    private constructor();
+    /** Connects with `apiKey` and sets the session up with `update`. */
+    static open(url: string, apiKey: string, update: object): Promise<OpenAiTranscription>;
+    append(pcm: Uint8Array<ArrayBuffer>): void;
+    finish(): Promise<string>;
+    dispose(): void;
+    private readonly receive;
+    private readonly closed;
+    /** Resolves `finish` once every item, the committed one too, is final. */
+    private settle;
+    private fail;
+    private text;
+    private send;
+}

package/vendor/core/dictate/pcm.d.ts

@@ -0,0 +1,5 @@
+/**
+ * The rate of the audio the page streams, which OpenAI's Realtime API takes:
+ * mono, 16-bit little-endian PCM, this many samples a second.
+ */
+export declare const SAMPLE_RATE = 24000;

package/vendor/core/dictate/pcm16-encoder.d.ts

@@ -0,0 +1,20 @@
+import type { AudioSink } from "./microphone";
+/**
+ * Turns the mic's float samples, at whatever rate the browser runs at, into
+ * PCM16 at {@link SAMPLE_RATE}: `push` each block as it comes, and `flush`
+ * once the take ends. Sends `sink` each tenth of a second.
+ */
+export declare class Pcm16Encoder {
+    private readonly sink;
+    private readonly step;
+    /** Where the next sample falls in the next input, -1 being the last one before it. */
+    private position;
+    private previous;
+    private chunk;
+    private filled;
+    constructor(inputRate: number, sink: AudioSink);
+    push(samples: Float32Array): void;
+    /** Sends what is left of the last chunk. */
+    flush(): void;
+    private write;
+}

package/vendor/core/dictate/server.d.ts

@@ -0,0 +1 @@
+export { MODEL, OpenAiTranscriber, type OpenAiTranscriberOptions, } from "./openai-transcriber";

package/vendor/core/dictate/server.js

@@ -0,0 +1,153 @@
+import {
+  SAMPLE_RATE2
+} from "../index-qk5dj664.js";
+
+// dictate/openai-transcription.ts
+import { Dispatcher } from "../events/index.js";
+
+class OpenAiTranscription {
+  socket;
+  dispatcher = new Dispatcher;
+  events = this.dispatcher.events;
+  items = new Map;
+  completed = new Set;
+  committed;
+  sent = false;
+  finishing;
+  failure;
+  constructor(socket) {
+    this.socket = socket;
+    socket.addEventListener("message", this.receive);
+    socket.addEventListener("close", this.closed);
+  }
+  static async open(url, apiKey, update) {
+    const options = {
+      headers: { Authorization: `Bearer ${apiKey}` }
+    };
+    const socket = new WebSocket(url, options);
+    await new Promise((resolve, reject) => {
+      socket.addEventListener("open", resolve, { once: true });
+      socket.addEventListener("error", () => reject(new Error("could not reach OpenAI's Realtime API")), { once: true });
+    });
+    const transcription = new OpenAiTranscription(socket);
+    transcription.send(update);
+    return transcription;
+  }
+  append(pcm) {
+    if (this.failure !== undefined || this.finishing !== undefined) {
+      return;
+    }
+    this.sent = true;
+    this.send({
+      type: "input_audio_buffer.append",
+      audio: Buffer.from(pcm).toString("base64")
+    });
+  }
+  finish() {
+    if (this.failure !== undefined) {
+      return Promise.reject(this.failure);
+    }
+    if (this.finishing === undefined) {
+      this.finishing = Promise.withResolvers();
+      if (this.sent) {
+        this.send({ type: "input_audio_buffer.commit" });
+      } else {
+        this.finishing.resolve(this.text());
+      }
+    }
+    return this.finishing.promise;
+  }
+  dispose() {
+    this.socket.removeEventListener("message", this.receive);
+    this.socket.removeEventListener("close", this.closed);
+    this.socket.close();
+    this.dispatcher.dispose();
+  }
+  receive = ({ data }) => {
+    const event = JSON.parse(String(data));
+    switch (event.type) {
+      case "conversation.item.input_audio_transcription.delta":
+        this.items.set(event.item_id, (this.items.get(event.item_id) ?? "") + event.delta);
+        this.dispatcher.dispatch("heard", this.text());
+        break;
+      case "conversation.item.input_audio_transcription.completed":
+        this.items.set(event.item_id, event.transcript);
+        this.completed.add(event.item_id);
+        this.dispatcher.dispatch("heard", this.text());
+        this.settle();
+        break;
+      case "input_audio_buffer.committed":
+        this.committed = event.item_id;
+        this.settle();
+        break;
+      case "error":
+        this.fail(new Error(`OpenAI said: ${event.error.message}`));
+        break;
+    }
+  };
+  closed = ({ code, reason }) => {
+    this.fail(new Error(`OpenAI closed the connection (${code}${reason ? `: ${reason}` : ""})`));
+  };
+  settle() {
+    if (this.finishing === undefined || this.committed === undefined || !this.completed.has(this.committed)) {
+      return;
+    }
+    for (const id of this.items.keys()) {
+      if (!this.completed.has(id)) {
+        return;
+      }
+    }
+    this.finishing.resolve(this.text());
+  }
+  fail(error) {
+    if (this.failure !== undefined) {
+      return;
+    }
+    this.failure = error;
+    this.dispatcher.dispatch("failed", error);
+    this.finishing?.reject(error);
+  }
+  text() {
+    return [...this.items.values()].map((text) => text.trim()).filter((text) => text !== "").join(" ");
+  }
+  send(event) {
+    this.socket.send(JSON.stringify(event));
+  }
+}
+
+// dictate/openai-transcriber.ts
+var MODEL = "gpt-live-transcribe";
+
+class OpenAiTranscriber {
+  apiKey;
+  opts;
+  url;
+  constructor(apiKey, opts = {}) {
+    this.apiKey = apiKey;
+    this.opts = opts;
+    this.url = opts.url ?? "wss://api.openai.com/v1/realtime?intent=transcription";
+  }
+  async listen() {
+    return OpenAiTranscription.open(this.url, this.apiKey, {
+      type: "session.update",
+      session: {
+        type: "transcription",
+        audio: {
+          input: {
+            format: { type: "audio/pcm", rate: SAMPLE_RATE2 },
+            transcription: {
+              model: MODEL,
+              prompt: this.opts.prompt,
+              keywords: this.opts.keywords
+            },
+            turn_detection: null
+          }
+        }
+      }
+    });
+  }
+}
+export {
+  MODEL,
+  OpenAiTranscriber
+};

package/vendor/core/dictate/transcriber.d.ts

@@ -0,0 +1,23 @@
+import type { Resource } from "../disposable/index.js";
+import type { Eventful } from "../events/index.js";
+/** Hears a take as it is spoken. */
+export interface Transcriber {
+    /** Opens a transcription for one take. */
+    listen(): Promise<Transcription>;
+}
+export interface TranscriptionEvents extends Record<string, unknown> {
+    /** All the take's text so far, rough until the take is finished. */
+    heard: string;
+    /** Why the transcription broke off; `finish` fails with it too. */
+    failed: Error;
+}
+/**
+ * One take being transcribed: audio goes in as it is recorded, and text comes
+ * out as it is heard.
+ */
+export interface Transcription extends Eventful<TranscriptionEvents>, Resource {
+    /** Sends the next stretch of audio, PCM16 at `SAMPLE_RATE`. */
+    append(pcm: Uint8Array<ArrayBuffer>): void;
+    /** Ends the take, resolving with its final text. */
+    finish(): Promise<string>;
+}

package/vendor/core/disposable/async-disposer.d.ts

@@ -0,0 +1,15 @@
+import type { AsyncResource } from "./async-resource";
+/** A stack of async resources, released in reverse order of registration. */
+export declare class AsyncDisposer implements AsyncResource {
+    private resources;
+    private _disposed;
+    private disposing;
+    get disposed(): boolean;
+    use<T extends AsyncResource>(resource: T): T;
+    adopt<T>(value: T, disposeAsync: (value: T) => Promise<void>): T;
+    defer(onDispose: () => Promise<void>): void;
+    /** Safe to call twice: a second call waits for the first to finish. */
+    disposeAsync: () => Promise<void>;
+    private release;
+    private assertOpen;
+}

package/vendor/core/disposable/async-resource.d.ts

@@ -0,0 +1,4 @@
+/** Something holding a resource whose release has to be awaited. */
+export interface AsyncResource {
+    disposeAsync(): Promise<void>;
+}

package/vendor/core/disposable/disposables.d.ts

@@ -0,0 +1,8 @@
+import type { Resource } from "./resource";
+/** Ways of getting a `Resource` when you do not have an object to hand. */
+export declare class disposables {
+    private constructor();
+    static noop(): Resource;
+    static callback(dispose: () => void): Resource;
+    static nullable(resource: Resource | null): Resource;
+}

package/vendor/core/disposable/disposer.d.ts

@@ -0,0 +1,13 @@
+import type { Resource } from "./resource";
+/** A stack of resources, released in reverse order of registration. */
+export declare class Disposer implements Resource {
+    private resources;
+    private _disposed;
+    get disposed(): boolean;
+    use<T extends Resource>(resource: T): T;
+    adopt<T>(value: T, dispose: (value: T) => void): T;
+    defer(onDispose: () => void): void;
+    /** Releases in reverse order, so a resource outlives whatever it depends on. */
+    dispose(): void;
+    private assertOpen;
+}

package/vendor/core/disposable/index.d.ts

@@ -0,0 +1,5 @@
+export { AsyncDisposer } from "./async-disposer";
+export type { AsyncResource } from "./async-resource";
+export { disposables } from "./disposables";
+export { Disposer } from "./disposer";
+export type { Resource } from "./resource";

package/vendor/core/disposable/index.js

@@ -0,0 +1,96 @@
+// disposable/async-disposer.ts
+class AsyncDisposer {
+  resources = [];
+  _disposed = false;
+  disposing;
+  get disposed() {
+    return this._disposed;
+  }
+  use(resource) {
+    this.assertOpen();
+    this.resources.push(resource);
+    return resource;
+  }
+  adopt(value, disposeAsync) {
+    this.assertOpen();
+    this.resources.push({ disposeAsync: () => disposeAsync(value) });
+    return value;
+  }
+  defer(onDispose) {
+    this.assertOpen();
+    this.resources.push({ disposeAsync: onDispose });
+  }
+  disposeAsync = () => {
+    this._disposed = true;
+    this.disposing ??= this.release();
+    return this.disposing;
+  };
+  async release() {
+    let resource = this.resources.pop();
+    while (resource) {
+      await resource.disposeAsync();
+      resource = this.resources.pop();
+    }
+  }
+  assertOpen() {
+    if (this._disposed) {
+      throw new Error("cannot register a resource on a disposed AsyncDisposer");
+    }
+  }
+}
+// disposable/disposables.ts
+class disposables {
+  constructor() {}
+  static noop() {
+    return disposables.callback(() => {});
+  }
+  static callback(dispose) {
+    return { dispose };
+  }
+  static nullable(resource) {
+    return resource ?? disposables.noop();
+  }
+}
+// disposable/disposer.ts
+class Disposer {
+  resources = [];
+  _disposed = false;
+  get disposed() {
+    return this._disposed;
+  }
+  use(resource) {
+    this.assertOpen();
+    this.resources.push(resource);
+    return resource;
+  }
+  adopt(value, dispose) {
+    this.assertOpen();
+    this.resources.push(disposables.callback(() => dispose(value)));
+    return value;
+  }
+  defer(onDispose) {
+    this.assertOpen();
+    this.resources.push(disposables.callback(onDispose));
+  }
+  dispose() {
+    if (this._disposed) {
+      return;
+    }
+    this._disposed = true;
+    let resource = this.resources.pop();
+    while (resource) {
+      resource.dispose();
+      resource = this.resources.pop();
+    }
+  }
+  assertOpen() {
+    if (this._disposed) {
+      throw new Error("cannot register a resource on a disposed Disposer");
+    }
+  }
+}
+export {
+  AsyncDisposer,
+  Disposer,
+  disposables
+};

package/vendor/core/disposable/resource.d.ts

@@ -0,0 +1,4 @@
+/** Something holding a resource that must be released. */
+export interface Resource {
+    dispose(): void;
+}

package/vendor/core/events/dispatcher.d.ts

@@ -0,0 +1,18 @@
+import type { Resource } from "../disposable/index.js";
+import type { AnyListener, Events, Listener, ListenerOptions, Unlisten } from "./events";
+/**
+ * Raises typed events. The owner keeps the dispatcher and calls `dispatch`;
+ * everyone else gets `events` and can only listen.
+ */
+export declare class Dispatcher<T extends Record<string, unknown>> implements Events<T>, Resource {
+    readonly events: Events<T>;
+    private scopedEntries;
+    private universalEntries;
+    private nextId;
+    private nextOrder;
+    on<K extends keyof T>(type: K, listener: Listener<T[K]>, opts?: ListenerOptions): Unlisten;
+    all<K extends keyof T>(typeListener: AnyListener<K, T[K]>, opts?: ListenerOptions): Unlisten;
+    dispatch<K extends keyof T>(type: K, ...args: T[K] extends undefined ? [] : [event: T[K]]): void;
+    dispose(): void;
+    private off;
+}

package/vendor/core/events/eventful.d.ts

@@ -0,0 +1,7 @@
+import type { Events } from "./events";
+/** Something that raises events, exposing only the read side. */
+export interface Eventful<EventMap extends Record<string, unknown>> {
+    readonly events: Events<EventMap>;
+}
+/** The event map of an `Eventful`, for constraining event names to its own. */
+export type EventMapOf<T extends Eventful<Record<string, unknown>>> = T extends Eventful<infer E> ? E : never;

package/vendor/core/events/events.d.ts

@@ -0,0 +1,14 @@
+export type Listener<T> = (event: T) => void;
+export type Unlisten = () => void;
+export type AnyListener<T, E> = (type: T, event: E) => void;
+export type ListenerOptions = {
+    once?: boolean;
+};
+/**
+ * The read side of a `Dispatcher`. Hand this out to whoever needs to react to
+ * something; keep the dispatcher itself with whoever raises it.
+ */
+export interface Events<T extends Record<string, unknown>> {
+    on<K extends keyof T>(type: K, listener: Listener<T[K]>, opts?: ListenerOptions): Unlisten;
+    all<K extends keyof T>(listener: AnyListener<K, T[K]>, opts?: ListenerOptions): Unlisten;
+}

package/vendor/core/events/index.d.ts

@@ -0,0 +1,4 @@
+export { Dispatcher } from "./dispatcher";
+export type { Eventful, EventMapOf } from "./eventful";
+export type { AnyListener, Events, Listener, ListenerOptions, Unlisten, } from "./events";
+export { NoopEvents } from "./noop-events";

package/vendor/core/events/index.js

@@ -0,0 +1,75 @@
+// events/dispatcher.ts
+class Dispatcher {
+  events = this;
+  scopedEntries = new Map;
+  universalEntries = [];
+  nextId = 0;
+  nextOrder = 0;
+  on(type, listener, opts) {
+    const id = this.nextId++;
+    const entries = this.scopedEntries.get(type) ?? [];
+    entries.push({
+      kind: "scoped",
+      listener,
+      once: opts?.once ?? false,
+      id,
+      order: this.nextOrder++
+    });
+    this.scopedEntries.set(type, entries);
+    return () => this.off(id);
+  }
+  all(typeListener, opts) {
+    const id = this.nextId++;
+    this.universalEntries.push({
+      kind: "universal",
+      typeListener,
+      once: opts?.once ?? false,
+      id,
+      order: this.nextOrder++
+    });
+    return () => this.off(id);
+  }
+  dispatch(type, ...args) {
+    const entries = [
+      ...this.scopedEntries.get(type) ?? [],
+      ...this.universalEntries
+    ].sort((left, right) => left.order - right.order);
+    const event = args[0];
+    for (const entry of entries) {
+      if (entry.kind === "scoped") {
+        entry.listener(event);
+      } else {
+        entry.typeListener(type, event);
+      }
+      if (entry.once) {
+        this.off(entry.id);
+      }
+    }
+  }
+  dispose() {
+    this.scopedEntries.clear();
+    this.universalEntries.length = 0;
+  }
+  off(id) {
+    for (const [type, entries] of this.scopedEntries) {
+      const kept = entries.filter((entry) => entry.id !== id);
+      if (kept.length !== entries.length) {
+        this.scopedEntries.set(type, kept);
+      }
+    }
+    this.universalEntries = this.universalEntries.filter((entry) => entry.id !== id);
+  }
+}
+// events/noop-events.ts
+class NoopEvents {
+  on() {
+    return () => {};
+  }
+  all() {
+    return () => {};
+  }
+}
+export {
+  Dispatcher,
+  NoopEvents
+};

package/vendor/core/events/noop-events.d.ts

@@ -0,0 +1,6 @@
+import type { Events, Unlisten } from "./events";
+/** For when something needs an `Events` but nothing will ever be raised. */
+export declare class NoopEvents<T extends Record<string, unknown>> implements Events<T> {
+    on(): Unlisten;
+    all(): Unlisten;
+}

package/vendor/core/id/counter-id-provider.d.ts

@@ -0,0 +1,6 @@
+import type { IdProvider } from "./id-provider";
+/** Counts up from zero, so a test can say which id it expects. */
+export declare class CounterIdProvider implements IdProvider {
+    private counter;
+    next(): string;
+}

package/vendor/core/id/id-provider.d.ts

@@ -0,0 +1,7 @@
+/**
+ * A source of identifiers, so code that has to name something does not decide
+ * how. Inject `CounterIdProvider` in tests and the ids stop being noise.
+ */
+export interface IdProvider {
+    next(): string;
+}

package/vendor/core/id/index.d.ts

@@ -0,0 +1,3 @@
+export { CounterIdProvider } from "./counter-id-provider";
+export type { IdProvider } from "./id-provider";
+export { UuidProvider } from "./uuid-provider";

package/vendor/core/id/index.js

@@ -0,0 +1,17 @@
+// id/counter-id-provider.ts
+class CounterIdProvider {
+  counter = 0;
+  next() {
+    return String(this.counter++);
+  }
+}
+// id/uuid-provider.ts
+class UuidProvider {
+  next() {
+    return crypto.randomUUID();
+  }
+}
+export {
+  CounterIdProvider,
+  UuidProvider
+};

package/vendor/core/id/uuid-provider.d.ts

@@ -0,0 +1,11 @@
+import type { IdProvider } from "./id-provider";
+/**
+ * Random v4 UUIDs from `crypto.randomUUID`, a global in Node 19+, Bun, Deno,
+ * workers and browsers alike.
+ *
+ * In a browser it needs a secure context, so it is there over https and on
+ * `http://localhost`, but not over plain http to a LAN address.
+ */
+export declare class UuidProvider implements IdProvider {
+    next(): string;
+}

package/vendor/core/index-qk5dj664.js

@@ -0,0 +1,4 @@
+// dictate/pcm.ts
+var SAMPLE_RATE2 = 24000;
+
+export { SAMPLE_RATE2 };

package/vendor/core/log/color.d.ts

@@ -0,0 +1,22 @@
+export declare class color {
+    private constructor();
+    static red(value: unknown): string;
+    static yellow(value: unknown): string;
+    static green(value: unknown): string;
+    static blue(value: unknown): string;
+    static magenta(value: unknown): string;
+    static dim(value: unknown): string;
+    static bold(value: unknown): string;
+    static gray(value: unknown): string;
+    /**
+     * Removes the color from a value, for output that is read rather than
+     * displayed: a test assertion, a log file, a pipe.
+     */
+    static strip(value: unknown): string;
+    /**
+     * Read per call rather than once at import, so setting `NO_COLOR` takes
+     * effect wherever it is set (a test, a `--` wrapper) without caring
+     * whether this module was loaded first.
+     */
+    private static wrap;
+}