nixamp 0.27.1 → 0.27.3

package/src/live-events.ts

@@ -1,3 +1,4 @@
+import { classroomBroadcast, publicWebUrl, type ClassroomSettings } from "./classroom.ts";
 import { createHash, randomBytes, randomUUID } from "node:crypto";
 import type { Queryable } from "./follows.ts";
 
@@ -37,7 +38,7 @@ export type LiveEventKind = (typeof LIVE_EVENT_KINDS)[number];
 export type InvitationRole = (typeof INVITATION_ROLES)[number];
 export type InvitationState = (typeof INVITATION_STATES)[number];
 
-export interface LiveEvent {
+export interface LiveEvent extends ClassroomSettings {
   id: string;
   slug: string;
   ownerId: string;
@@ -94,6 +95,11 @@ export interface CreatedInvitation extends EventInvitation {
 
 export interface CreateLiveEventInput {
   title: unknown;
+  broadcastUrl?: unknown;
+  hostName?: unknown;
+  homepageUrl?: unknown;
+  avatarUrl?: unknown;
+  recurrence?: unknown;
   description?: unknown;
   topic?: unknown;
   kind?: unknown;
@@ -187,6 +193,7 @@ const EVENT_SCHEMA = `
   ALTER TABLE live_events ADD COLUMN IF NOT EXISTS ticket_currency    TEXT    NOT NULL DEFAULT 'USD';
   ALTER TABLE live_events ADD COLUMN IF NOT EXISTS ticket_minutes     INTEGER NOT NULL DEFAULT 1440;
   ALTER TABLE live_events ADD COLUMN IF NOT EXISTS pay_to             TEXT;
+  ALTER TABLE live_events ADD COLUMN IF NOT EXISTS classroom JSONB NOT NULL DEFAULT '{}'::jsonb;
   CREATE INDEX IF NOT EXISTS live_events_kind
     ON live_events (kind, status, starts_at);
 
@@ -203,7 +210,7 @@ const EVENT_SCHEMA = `
     END LOOP;
     FOR stale IN
       SELECT conname FROM pg_constraint
-      WHERE conrelid = 'live_event_invitations'::regclass AND contype = 'c'
+      WHERE conrelid = to_regclass('live_event_invitations') AND contype = 'c'
         AND conname <> 'live_event_invitations_role_allowed'
         AND pg_get_constraintdef(oid) LIKE '%moderator%'
     LOOP
@@ -292,6 +299,37 @@ function text(value: unknown, name: string, limit: number, required = false): st
   return cleaned;
 }
 
+function classroomSettings(input: CreateLiveEventInput | UpdateLiveEventInput, current: ClassroomSettings = {}): ClassroomSettings {
+  const settings: ClassroomSettings = {};
+  for (const key of ["hostName", "homepageUrl", "avatarUrl", "broadcastUrl"] as const) {
+    const value = input[key] === undefined ? current[key] ?? "" : text(input[key], key, key === "hostName" ? 100 : 2048);
+    if (!value) continue;
+    if (key === "hostName") settings[key] = value;
+    else if (key === "broadcastUrl") {
+      const broadcast = classroomBroadcast(value);
+      if (!broadcast) throw new LiveEventError("Use a Pairux live/join link or a Nixamp Share link with a stream selected. Admin links cannot be shared.", 422);
+      settings[key] = broadcast.url;
+    } else {
+      const safe = publicWebUrl(value);
+      if (!safe) throw new LiveEventError(`${key} must be an HTTPS link without credentials`, 422);
+      settings[key] = safe;
+    }
+  }
+  const recurrence = input.recurrence === undefined ? current.recurrence ?? "none" : input.recurrence;
+  if (recurrence !== "none" && recurrence !== "daily" && recurrence !== "weekly") {
+    throw new LiveEventError("recurrence must be none, daily, or weekly", 422);
+  }
+  if (recurrence !== "none") settings.recurrence = recurrence;
+  return settings;
+}
+
+function classroomTimezone(value: unknown): string {
+  const zone = text(value, "timezone", 100, true);
+  try { new Intl.DateTimeFormat("en", { timeZone: zone }).format(); }
+  catch { throw new LiveEventError("timezone must be a valid time zone", 422); }
+  return zone;
+}
+
 function timestamp(value: unknown, name: string): string | null {
   if (value === undefined || value === null || value === "") return null;
   if (typeof value !== "string") throw new LiveEventError(`${name} must be an ISO timestamp`, 422);
@@ -374,6 +412,7 @@ export function payToAddress(value: unknown, name = "payTo"): string {
 
 function eventFrom(row: Record<string, unknown>): LiveEvent {
   return {
+    ...((row["classroom"] && typeof row["classroom"] === "object") ? row["classroom"] as ClassroomSettings : {}),
     id: String(row["id"] ?? ""),
     slug: String(row["slug"] ?? ""),
     ownerId: String(row["owner_id"] ?? ""),
@@ -544,6 +583,8 @@ export class LiveEvents {
     if (ticketPriceCents > 0 && !payTo) {
       throw new LiveEventError("a ticketed event needs a payTo address", 422);
     }
+    const classroom = classroomSettings(input);
+    if (classroom.recurrence && !startsAt) throw new LiveEventError("a recurring class needs a start time", 422);
     const baseSlug = eventSlug(title);
     const values = [
       id,
@@ -560,7 +601,7 @@ export class LiveEvents {
       payTo,
       startsAt,
       endsAt,
-      text(input.timezone ?? "UTC", "timezone", 100, true),
+      classroomTimezone(input.timezone ?? "UTC"),
       optionalInteger(input.expectedDurationMinutes, "expectedDurationMinutes"),
       startsAt ? "scheduled" : "draft",
       enumValue(input.visibility, LIVE_EVENT_VISIBILITIES, "public", "visibility"),
@@ -569,6 +610,7 @@ export class LiveEvents {
       boolean(input.handRaiseEnabled, true, "handRaiseEnabled"),
       boolean(input.recordingEnabled, false, "recordingEnabled"),
       text(input.layoutId, "layoutId", 100),
+      JSON.stringify(classroom),
     ];
     await this.ensure();
     let rows: Record<string, unknown>[];
@@ -579,10 +621,10 @@ export class LiveEvents {
           ticket_price_cents, ticket_currency, ticket_minutes, pay_to,
           starts_at, ends_at, timezone,
           expected_duration_minutes, status, visibility, room_id, chat_enabled,
-          hand_raise_enabled, recording_enabled, layout_id
+          hand_raise_enabled, recording_enabled, layout_id, classroom
         ) VALUES (
           $1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, NULLIF($12, ''), $13, $14, $15,
-          $16, $17, $18, $19, $20, $21, $22, NULLIF($23, '')
+          $16, $17, $18, $19, $20, $21, $22, NULLIF($23, ''), $24::jsonb
         ) RETURNING *`,
         values,
       ));
@@ -595,10 +637,10 @@ export class LiveEvents {
           ticket_price_cents, ticket_currency, ticket_minutes, pay_to,
           starts_at, ends_at, timezone,
           expected_duration_minutes, status, visibility, room_id, chat_enabled,
-          hand_raise_enabled, recording_enabled, layout_id
+          hand_raise_enabled, recording_enabled, layout_id, classroom
         ) VALUES (
           $1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, NULLIF($12, ''), $13, $14, $15,
-          $16, $17, $18, $19, $20, $21, $22, NULLIF($23, '')
+          $16, $17, $18, $19, $20, $21, $22, NULLIF($23, ''), $24::jsonb
         ) RETURNING *`,
         values,
       ));
@@ -722,9 +764,9 @@ export class LiveEvents {
     }
 
     const title = input.title === undefined ? current.title : text(input.title, "title", 160, true);
-    const startsAt = input.startsAt === undefined ? current.startsAt ?? null : timestamp(input.startsAt, "startsAt");
-    const endsAt = input.endsAt === undefined ? current.endsAt ?? null : timestamp(input.endsAt, "endsAt");
-    const doorsOpenAt = input.doorsOpenAt === undefined
+    let startsAt = input.startsAt === undefined ? current.startsAt ?? null : timestamp(input.startsAt, "startsAt");
+    let endsAt = input.endsAt === undefined ? current.endsAt ?? null : timestamp(input.endsAt, "endsAt");
+    let doorsOpenAt = input.doorsOpenAt === undefined
       ? current.doorsOpenAt ?? null
       : timestamp(input.doorsOpenAt, "doorsOpenAt");
     if (startsAt && endsAt && endsAt <= startsAt) {
@@ -738,7 +780,7 @@ export class LiveEvents {
     if (ticketPriceCents > 0 && !payTo) {
       throw new LiveEventError("a ticketed event needs a payTo address", 422);
     }
-    const nextStatus = enumValue(input.status, LIVE_EVENT_STATUSES, current.status, "status");
+    let nextStatus = enumValue(input.status, LIVE_EVENT_STATUSES, current.status, "status");
     if (!canTransition(current.status, nextStatus)) {
       throw new LiveEventError(`an event cannot move from ${current.status} to ${nextStatus}`, 409);
     }
@@ -746,6 +788,30 @@ export class LiveEvents {
       throw new LiveEventError("a scheduled event needs startsAt", 422);
     }
 
+    const classroom = classroomSettings(input, current);
+    const timezone = input.timezone === undefined ? current.timezone : classroomTimezone(input.timezone);
+    if (classroom.recurrence && !startsAt) throw new LiveEventError("a recurring class needs a start time", 422);
+    let recurringNext = false;
+    if (nextStatus === "ended" && classroom.recurrence && startsAt) {
+      // Calendar arithmetic in Postgres preserves the host's local time over DST.
+      // Consider only the next three candidates, even if many sessions were missed.
+      const days = classroom.recurrence === "daily" ? 1 : 7;
+      const next = await this.db.query(`WITH anchor AS (
+        SELECT $1::timestamptz AT TIME ZONE $2 AS local_start
+      ), candidates AS (
+        SELECT (local_start + n * $3::int * interval '1 day') AT TIME ZONE $2 AS starts_at
+        FROM anchor CROSS JOIN LATERAL generate_series(
+          GREATEST(1, ((now() AT TIME ZONE $2)::date - local_start::date) / $3::int),
+          GREATEST(1, ((now() AT TIME ZONE $2)::date - local_start::date) / $3::int) + 2
+        ) n
+      ) SELECT starts_at FROM candidates
+        WHERE starts_at > GREATEST(now(), $1::timestamptz) ORDER BY starts_at LIMIT 1`, [startsAt, timezone, days]);
+      const nextStart = iso(next.rows[0]?.["starts_at"]);
+      if (!nextStart) throw new LiveEventError("could not schedule the next class", 503);
+      startsAt = nextStart; endsAt = null; doorsOpenAt = null;
+      nextStatus = "scheduled"; recurringNext = true;
+    }
+
     const { rows } = await this.db.query(
       `UPDATE live_events SET
         title = $4,
@@ -768,6 +834,7 @@ export class LiveEvents {
         ticket_currency = $21,
         ticket_minutes = $22,
         pay_to = NULLIF($23, ''),
+        classroom = $24::jsonb,
         version = version + 1,
         updated_at = now()
        WHERE (id = $1 OR slug = $1) AND owner_id = $2 AND version = $3
@@ -781,7 +848,7 @@ export class LiveEvents {
         input.topic === undefined ? current.topic ?? "" : text(input.topic, "topic", 100),
         startsAt,
         endsAt,
-        input.timezone === undefined ? current.timezone : text(input.timezone, "timezone", 100, true),
+        timezone,
         input.expectedDurationMinutes === undefined
           ? current.expectedDurationMinutes ?? null
           : optionalInteger(input.expectedDurationMinutes, "expectedDurationMinutes"),
@@ -790,7 +857,7 @@ export class LiveEvents {
         boolean(input.chatEnabled, current.chatEnabled, "chatEnabled"),
         boolean(input.handRaiseEnabled, current.handRaiseEnabled, "handRaiseEnabled"),
         boolean(input.recordingEnabled, current.recordingEnabled, "recordingEnabled"),
-        input.recordingId === undefined ? current.recordingId ?? null : text(input.recordingId, "recordingId", 160) || null,
+        recurringNext ? null : input.recordingId === undefined ? current.recordingId ?? null : text(input.recordingId, "recordingId", 160) || null,
         input.layoutId === undefined ? current.layoutId ?? null : text(input.layoutId, "layoutId", 100) || null,
         enumValue(input.kind, LIVE_EVENT_KINDS, current.kind, "kind"),
         doorsOpenAt,
@@ -800,6 +867,7 @@ export class LiveEvents {
           : text(input.ticketCurrency, "ticketCurrency", 8, true).toUpperCase(),
         minutes(input.ticketMinutes, current.ticketMinutes, "ticketMinutes"),
         payTo,
+        JSON.stringify(classroom),
       ],
     );
     const row = rows[0];

package/src/live-interpreter.ts

@@ -1,3 +1,4 @@
+import { audioError, transientAudioError } from "./live-recovery.ts";
 import { encodeWav } from "./pcm-wav.ts";
 import type { SpeakerTranscript, SpeakerTurn } from "./speaker-turns.ts";
 export interface Caption { channel: string; at: number; until: number; text: string; language?: string; original?: string; sourceLanguage?: string; speaker?: string; voiceProfile?: "lower" | "higher" | "unknown"; }
@@ -58,17 +59,20 @@ export class Interpreter {
   private controller: AbortController | null = null;
   private translating: number | null = null;
   private translationController: AbortController | null = null;
+  private recognitionFailures = 0;
+  private translationFailures = 0;
   private translations: { lines: Caption[]; language: string; target: string; until: number }[] = [];
   constructor(private readonly options: {
     language: () => string; speakers: () => boolean; voices: () => VoiceChoice[];
     channel: () => string; lines: (lines: Caption[]) => void;
-    status: (text: string) => void; failed: () => void;
+    status: (text: string) => void; failed: (message: string) => void;
     fetcher?: typeof fetch;
   }) {}
 
   reset(): void {
     this.generation++; this.controller?.abort(); this.translationController?.abort();
     this.pending = null; this.running = null; this.translating = null;
+    this.recognitionFailures = this.translationFailures = 0;
     this.translations = []; this.committedUntil = null; this.tracker.reset();
   }
   push(window: AudioWindow): void {
@@ -79,7 +83,7 @@ export class Interpreter {
   private async json(path: string, init: RequestInit, signal: AbortSignal): Promise<any> {
     const response = await (this.options.fetcher ?? fetch)(path, { ...init, signal });
     const body = await response.json();
-    if (!response.ok) throw new Error(body.error || "Audio translation is unavailable.");
+    if (!response.ok) throw audioError(body.error || "Audio translation is unavailable.", response.status);
     return body;
   }
   private async run(generation: number): Promise<void> {
@@ -87,60 +91,68 @@ export class Interpreter {
     try {
       while (this.pending && generation === this.generation) {
         const window = this.pending; this.pending = null;
-        if (Date.now() - window.until > 12_000) continue;
-        const controller = new AbortController(); this.controller = controller;
-        const signal = AbortSignal.any([controller.signal, AbortSignal.timeout(12_000)]);
-        const speakers = this.options.speakers(), target = this.options.language();
-        const heard = await this.json(speakers ? "/api/v1/speech/speakers" : "/api/v1/speech/transcribe?live=1", {
-          method: "POST", headers: { "content-type": "audio/wav" }, body: new Uint8Array(encodeWav(speakers ? window.samples : window.samples.slice(-80_000))),
-        }, signal) as SpeakerTranscript & { text?: string };
-        if (generation !== this.generation) return;
-        const language = heard.language;
-        let lines: Caption[] = [];
-        if (speakers) {
-          const links = this.tracker.reconcile(heard.turns ?? [], window.at, this.options.voices());
-          // The watermark follows emitted words, not the newest capture
-          // interval: an overlapping window can recover audio that arrived
-          // while recognition/translation was busy. Keep unfinished phrases
-          // in that overlap so short capture intervals do not split every
-          // sentence (especially damaging when German changes word order).
-          const cutoff = this.committedUntil ?? window.freshAt;
-          const turns = heard.turns ?? [];
-          for (const [index, turn] of turns.entries()) {
-            const speaker = links.get(turn.speaker)!;
-            const words = turn.words.filter(word =>
-              window.at + (word.start + word.end) * 500 >= cutoff &&
-              (window.at + word.end * 1000 <= window.until - 100 || /[.!?。！？]$/.test(word.text)));
-            let phrase: typeof words = [];
-            const emit = (): void => {
-              if (!phrase.length) return;
-              lines.push({ channel: this.options.channel(), at: window.at + phrase[0]!.start * 1000,
-                until: window.at + phrase.at(-1)!.end * 1000, text: phrase.map(word => word.text).join(" ").trim(),
-                language, speaker: speaker.id, voiceProfile: turn.profile });
-              phrase = [];
-            };
-            for (const word of words) {
-              if (phrase.length && word.start - phrase.at(-1)!.end >= 0.45) emit();
-              phrase.push(word);
-              if (/[.!?。！？]$/.test(word.text) || phrase.map(word => word.text).join(" ").length >= 400) emit();
+        try {
+          if (Date.now() - window.until > 12_000) continue;
+          const controller = new AbortController(); this.controller = controller;
+          const signal = AbortSignal.any([controller.signal, AbortSignal.timeout(12_000)]);
+          const speakers = this.options.speakers(), target = this.options.language();
+          const heard = await this.json(speakers ? "/api/v1/speech/speakers" : "/api/v1/speech/transcribe?live=1", {
+            method: "POST", headers: { "content-type": "audio/wav" }, body: new Uint8Array(encodeWav(speakers ? window.samples : window.samples.slice(-80_000))),
+          }, signal) as SpeakerTranscript & { text?: string };
+          if (generation !== this.generation) return;
+          this.recognitionFailures = 0;
+          const language = heard.language;
+          let lines: Caption[] = [];
+          if (speakers) {
+            const links = this.tracker.reconcile(heard.turns ?? [], window.at, this.options.voices());
+            // The watermark follows emitted words, not the newest capture
+            // interval: an overlapping window can recover audio that arrived
+            // while recognition/translation was busy. Keep unfinished phrases
+            // in that overlap so short capture intervals do not split every
+            // sentence (especially damaging when German changes word order).
+            const cutoff = this.committedUntil ?? window.freshAt;
+            const turns = heard.turns ?? [];
+            for (const [index, turn] of turns.entries()) {
+              const speaker = links.get(turn.speaker)!;
+              const words = turn.words.filter(word =>
+                window.at + (word.start + word.end) * 500 >= cutoff &&
+                (window.at + word.end * 1000 <= window.until - 100 || /[.!?。！？]$/.test(word.text)));
+              let phrase: typeof words = [];
+              const emit = (): void => {
+                if (!phrase.length) return;
+                lines.push({ channel: this.options.channel(), at: window.at + phrase[0]!.start * 1000,
+                  until: window.at + phrase.at(-1)!.end * 1000, text: phrase.map(word => word.text).join(" ").trim(),
+                  language, speaker: speaker.id, voiceProfile: turn.profile });
+                phrase = [];
+              };
+              for (const word of words) {
+                if (phrase.length && word.start - phrase.at(-1)!.end >= 0.45) emit();
+                phrase.push(word);
+                if (/[.!?。！？]$/.test(word.text) || phrase.map(word => word.text).join(" ").length >= 400) emit();
+              }
+              if (phrase.length && (index < turns.length - 1 ||
+                window.until - (window.at + phrase.at(-1)!.end * 1000) >= 350 ||
+                window.until - (window.at + phrase[0]!.start * 1000) >= 3000)) emit();
             }
-            if (phrase.length && (index < turns.length - 1 ||
-              window.until - (window.at + phrase.at(-1)!.end * 1000) >= 350 ||
-              window.until - (window.at + phrase[0]!.start * 1000) >= 3000)) emit();
+          } else if (heard.text) {
+            lines = [{ channel: this.options.channel(), at: window.freshAt, until: window.until, text: heard.text, language }];
           }
-        } else if (heard.text) {
-          lines = [{ channel: this.options.channel(), at: window.freshAt, until: window.until, text: heard.text, language }];
+          if (!lines.length) continue;
+          this.committedUntil = Math.max(this.committedUntil ?? window.freshAt, ...lines.map(line => line.until));
+          // Drop expired work instead of turning off an otherwise healthy stream.
+          this.translations = this.translations.filter(item => Date.now() - item.until <= 12_000).slice(-11);
+          this.translations.push({ lines, language, target, until: window.until });
+          // Recognition of the next audio window can proceed while the text
+          // model translates this phrase. Voice synthesis is a third stage.
+          if (this.translating === null) void this.translate(this.generation);
+        } catch (error) {
+          if (generation !== this.generation) return;
+          if (!transientAudioError(error) || ++this.recognitionFailures >= 3) throw error;
+          this.options.status("Speech recognition interrupted · listening for the next phrase…");
         }
-        if (!lines.length) continue;
-        this.committedUntil = Math.max(this.committedUntil ?? window.freshAt, ...lines.map(line => line.until));
-        if (this.translations.length >= 12) throw new Error("Translation fell behind. Try again after the language model has warmed up.");
-        this.translations.push({ lines, language, target, until: window.until });
-        // Recognition of the next audio window can proceed while the text
-        // model translates this phrase. Voice synthesis is a third stage.
-        if (this.translating === null) void this.translate(this.generation);
       }
     } catch (error) {
-      if (generation === this.generation) { this.reset(); this.options.failed(); this.options.status(error instanceof Error ? error.message : "Live translation stopped."); }
+      if (generation === this.generation) { const message = error instanceof Error ? error.message : "Live translation stopped."; this.reset(); this.options.failed(message); this.options.status(message); }
     } finally { if (this.running === generation) this.running = null; }
   }
 
@@ -149,26 +161,33 @@ export class Interpreter {
     try {
       while (this.translations.length && generation === this.generation) {
         const item = this.translations.shift()!;
-        let { lines } = item;
-        const { language, target, until } = item;
-        if (Date.now() - until > 12_000) throw new Error("Translation fell behind. Try again after the language model has warmed up.");
-        const controller = new AbortController(); this.translationController = controller;
-        if (target && language !== target) {
-          if (!language) throw new Error("The audio language could not be detected. Waiting for clearer speech.");
-          const translated = await this.json("/api/v1/translate?live=1", {
-            method: "POST", headers: { "content-type": "application/json" },
-            body: JSON.stringify({ texts: lines.map(line => line.text), from: language, to: target }),
-          }, AbortSignal.any([controller.signal, AbortSignal.timeout(12_000)])) as { texts: string[] };
-          if (translated.texts.length !== lines.length || translated.texts.some(text => !text.trim())) throw new Error("Translation omitted a phrase. Enable translated audio again to retry.");
-          lines = lines.map((line, i) => ({ ...line, original: line.text, sourceLanguage: language, language: target, text: translated.texts[i]! }));
+        try {
+          let { lines } = item;
+          const { language, target, until } = item;
+          if (Date.now() - until > 12_000) continue;
+          const controller = new AbortController(); this.translationController = controller;
+          if (target && language !== target) {
+            if (!language) throw audioError("The audio language could not be detected. Waiting for clearer speech.", 502);
+            const translated = await this.json("/api/v1/translate?live=1", {
+              method: "POST", headers: { "content-type": "application/json" },
+              body: JSON.stringify({ texts: lines.map(line => line.text), from: language, to: target }),
+            }, AbortSignal.any([controller.signal, AbortSignal.timeout(12_000)])) as { texts: string[] };
+            if (translated.texts.length !== lines.length || translated.texts.some(text => !text.trim())) throw audioError("Translation omitted a phrase. Waiting for the next phrase.", 502);
+            lines = lines.map((line, i) => ({ ...line, original: line.text, sourceLanguage: language, language: target, text: translated.texts[i]! }));
+          }
+          if (generation !== this.generation) return;
+          if (Date.now() - until > 12_000) continue;
+          this.translationFailures = 0;
+          this.options.lines(lines.flatMap(line => splitCaption(line)));
+          this.options.status(target ? `${language} → ${target} · live translation` : `Original audio language: ${language || "detecting…"}`);
+        } catch (error) {
+          if (generation !== this.generation) return;
+          if (!transientAudioError(error) || ++this.translationFailures >= 3) throw error;
+          this.options.status("Translation interrupted · catching up with live speech…");
         }
-        if (generation !== this.generation) return;
-        if (Date.now() - until > 12_000) throw new Error("Translation fell behind. Try again after the language model has warmed up.");
-        this.options.lines(lines.flatMap(line => splitCaption(line)));
-        this.options.status(target ? `${language} → ${target} · live translation` : `Original audio language: ${language || "detecting…"}`);
       }
     } catch (error) {
-      if (generation === this.generation) { this.reset(); this.options.failed(); this.options.status(error instanceof Error ? error.message : "Live translation stopped."); }
+      if (generation === this.generation) { const message = error instanceof Error ? error.message : "Live translation stopped."; this.reset(); this.options.failed(message); this.options.status(message); }
     } finally { if (this.translating === generation) this.translating = null; }
   }
 }

package/src/live-recovery.ts

@@ -0,0 +1,10 @@
+/** Access, billing and throttling failures are terminal. Only transient service
+ * and transport failures may recover, with a bounded consecutive failure count. */
+export function transientAudioError(error: unknown): boolean {
+  const status = (error as { status?: number } | null)?.status;
+  if (typeof status === "number") return [408, 502, 503, 504].includes(status);
+  return error instanceof TypeError || (error instanceof Error && ["AbortError", "TimeoutError"].includes(error.name));
+}
+export function audioError(message: string, status: number): Error & { status: number } {
+  return Object.assign(new Error(message), { status });
+}

package/src/live-voice.ts

@@ -57,9 +57,9 @@ export class LiveVoice {
   /** Optional diarization, billed only while a signed-in listener requests it.
    * Rolling audio is bounded to 15 seconds, including overlap. Every second
    * submitted (also repeated context) consumes the persistent provider budget. */
-  async hear(bytes: Uint8Array, by: string, signal?: AbortSignal, meter = this.billing): Promise<SpeakerTranscript> {
+  async hear(bytes: Uint8Array, by: string, signal?: AbortSignal, meter = this.billing, resource = ""): Promise<SpeakerTranscript> {
     if (!this.available()) throw new SpeechError("speaker voices are unavailable", 503);
-    await meter?.require(by);
+    await meter?.require(by, resource);
     const wav = decodeWav(bytes);
     const seconds = wav.samples.length / wav.rate;
     if (wav.rate !== 16000 || wav.channels !== 1 || seconds < 0.2 || seconds > 15.1) throw new SpeechError("send up to 15 seconds of mono 16 kHz WAV", 400);
@@ -86,7 +86,7 @@ export class LiveVoice {
       form.set("tag_audio_events", "false");
       form.set("timestamps_granularity", "word");
       // No language_code: preserve the source language, including Spanish.
-      reservation = await meter?.reserve(by, "transcription", wav.samples.length);
+      reservation = await meter?.reserve(by, "transcription", wav.samples.length, resource);
       const answer = await this.fetcher("https://api.elevenlabs.io/v1/speech-to-text", {
         method: "POST", headers: { "xi-api-key": this.key }, body: form,
         signal: signal ? AbortSignal.any([signal, AbortSignal.timeout(10_000)]) : AbortSignal.timeout(10_000),
@@ -122,7 +122,7 @@ export class LiveVoice {
   async grant(by: string, channel: string): Promise<{ token: string; expires: number }> {
     if (!/^[\w-]{1,80}$/.test(channel)) throw new SpeechError("choose a playback session or live channel", 400);
     if (!this.requests.check(`grant:${by}`, { allowed: 10, windowMs: 60_000 }).ok) throw new SpeechError("too many audio authorization requests", 429);
-    await this.billing?.require(by);
+    await this.billing?.require(by, channel);
     for (const [token, grant] of this.grants) if (grant.expires <= this.now()) this.grants.delete(token);
     if (this.grants.size >= 5000) throw new SpeechError("audio authorization is busy", 503);
     const token = `nxd_${randomBytes(32).toString("base64url")}`;
@@ -200,7 +200,7 @@ export class LiveVoice {
   /** Stream the first request immediately; concurrent listeners share its cached result. */
   async stream(ask: VoiceRequest, by: string, signal?: AbortSignal, meter = this.billing): Promise<Response> {
     this.checkRequest(by);
-    await meter?.require(by);
+    await meter?.require(by, ask.channel);
     const text = typeof ask.text === "string" ? ask.text.trim() : "";
     if (!text || text.length > 600) throw new SpeechError("translated audio needs a caption of 1–600 characters", 400);
     if (!LIVE_VOICE_LANGUAGES.has(ask.language)) throw new SpeechError("this language is not supported by Flash voices", 400);
@@ -220,7 +220,7 @@ export class LiveVoice {
     if (cached || pending) {
       const bytes = cached?.bytes ?? await pending!;
       signal?.throwIfAborted();
-      const paid = await meter?.reserve(by, "voice", text.length);
+      const paid = await meter?.reserve(by, "voice", text.length, ask.channel);
       if (paid) await meter!.commit(paid);
       return new Response(new Uint8Array(bytes), { headers: HEADERS });
     }
@@ -239,7 +239,7 @@ export class LiveVoice {
     try {
       await this.charge(by, ask.channel ?? "direct", text.length);
       signal?.throwIfAborted();
-      reservation = await meter?.reserve(by, "voice", text.length);
+      reservation = await meter?.reserve(by, "voice", text.length, ask.channel);
       const response = await this.fetcher(`https://api.elevenlabs.io/v1/text-to-speech/${voice.id}/stream?output_format=pcm_16000`, {
         method: "POST",
         headers: { "xi-api-key": this.key, "content-type": "application/json" },

package/src/mail-sender.ts

@@ -0,0 +1,12 @@
+export interface MailSender { apiKey: string; from: string }
+export interface BrandedMailSender extends MailSender { backtoschool?: MailSender }
+
+/** Only the exact school origins select its verified sender and credentials. */
+export function mailSender(options: BrandedMailSender, link: string): MailSender {
+  try {
+    const url = new URL(link);
+    if (options.backtoschool && url.protocol === "https:" &&
+      ["backtoschool.help", "www.backtoschool.help"].includes(url.hostname)) return options.backtoschool;
+  } catch { /* A malformed link never changes the sender. */ }
+  return options;
+}

package/src/notify.ts

@@ -1,3 +1,5 @@
+import { mailSender, type BrandedMailSender } from "./mail-sender.ts";
+
 /**
  * Telling followers a broadcaster went live, wherever they are.
  *
@@ -119,27 +121,28 @@ export async function notifyAll(
  * blocked, and no dependency: a fetch is the whole client.
  */
 export function resendEmail(
-  { apiKey, from, fetch = globalThis.fetch, onEvent }: {
-    apiKey: string;
-    from: string;
+  { apiKey, from, backtoschool, reason = "You are getting this because you follow them on nixamp.", fetch = globalThis.fetch, onEvent }: BrandedMailSender & {
+    reason?: string;
     fetch?: typeof globalThis.fetch;
     onEvent?: (message: string) => void;
   },
 ): (to: string, note: Notification) => Promise<boolean> {
   return async (to, note) => {
     try {
+      const sender = mailSender({apiKey, from, backtoschool}, note.url);
       const response = await fetch("https://api.resend.com/emails", {
         method: "POST",
-        headers: { authorization: `Bearer ${apiKey}`, "content-type": "application/json" },
+        headers: { authorization: `Bearer ${sender.apiKey}`, "content-type": "application/json" },
+        signal: AbortSignal.timeout(15_000),
         body: JSON.stringify({
-          from,
+          from: sender.from,
           to: [to],
           subject: note.title,
-          text: `${note.body}\n\n${note.url}\n\nYou are getting this because you follow them on nixamp.`,
+          text: `${note.body}\n\n${note.url}\n\n${reason}`,
           html:
             `<p>${escapeHtml(note.body)}</p>` +
             `<p><a href="${escapeHtml(note.url)}">${escapeHtml(note.url)}</a></p>` +
-            `<p style="color:#666;font-size:12px">You are getting this because you follow them on nixamp.</p>`,
+            `<p style="color:#666;font-size:12px">${escapeHtml(reason)}</p>`,
         }),
       });
       if (!response.ok) {