nixamp 0.27.1 → 0.27.3

package/dist/event-writer.d.ts

@@ -0,0 +1,39 @@
+export interface EventDraft {
+    title: string;
+    description: string;
+    topic: string;
+}
+export interface WriterInput extends EventDraft {
+    hostName: string;
+    startsAt: string;
+    timezone: string;
+    duration: string;
+    recurrence: string;
+}
+export interface EventDraftResult {
+    draft: EventDraft;
+    provider: "openai" | "claude";
+}
+export declare class EventWriterError extends Error {
+    readonly status: number;
+    readonly retryAfter?: number | undefined;
+    constructor(message: string, status: number, retryAfter?: number | undefined);
+}
+export declare function writerInput(value: unknown): WriterInput;
+export interface EventWriterOptions {
+    openaiKey?: string;
+    anthropicKey?: string;
+    openaiModel?: string;
+    claudeModel?: string;
+    fetch?: typeof globalThis.fetch;
+    timeoutMs?: number;
+}
+/** Server-side only. Drafting has no access to the event store and cannot publish. */
+export declare class EventWriter {
+    private readonly options;
+    private readonly guard;
+    private readonly active;
+    constructor(options: EventWriterOptions);
+    draft(accountId: string, value: unknown, signal?: AbortSignal): Promise<EventDraftResult>;
+    private generate;
+}

package/dist/event-writer.js

@@ -0,0 +1,139 @@
+import { Guard } from "./guard.js";
+export class EventWriterError extends Error {
+    status;
+    retryAfter;
+    constructor(message, status, retryAfter) {
+        super(message);
+        this.status = status;
+        this.retryAfter = retryAfter;
+    }
+}
+class Refused extends EventWriterError {
+    constructor() { super("The writer could not draft these notes. Try rephrasing the event details.", 422); }
+}
+const LIMITS = { title: 160, description: 5000, topic: 100, hostName: 100, startsAt: 40, timezone: 100, duration: 20, recurrence: 20 };
+export function writerInput(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new EventWriterError("Send event details as an object.", 400);
+    const source = value;
+    const result = {};
+    for (const key of Object.keys(LIMITS)) {
+        const field = source[key] ?? "";
+        if (typeof field !== "string" || field.length > LIMITS[key])
+            throw new EventWriterError(`The ${key} field is too long or is not text.`, 422);
+        result[key] = field.trim();
+    }
+    if (!result.title && !result.description && !result.topic)
+        throw new EventWriterError("Add a title, description, or topic first, then click Write with AI.", 422);
+    return result;
+}
+const SCHEMA = {
+    type: "object", properties: { title: { type: "string" }, description: { type: "string" }, topic: { type: "string" } },
+    required: ["title", "description", "topic"], additionalProperties: false,
+};
+const INSTRUCTIONS = `You write useful, welcoming event details for BackToSchool.help, a live learning platform.
+Use the supplied form text as the writing prompt. Rough notes and requests in that text describe what the host wants to teach.
+Return a clear title (at most 160 characters), a description (at most 5000 characters, usually 100–250 words), and a short topic (at most 100 characters).
+Write in the language of the host's notes. Describe what students will learn and what will happen, using only information supported by the notes.
+Keep concrete names and facts. Do not invent dates, prices, qualifications, prerequisites, links, credentials, or promises. Omit unknown logistics. Do not expand into unrelated subjects.
+The schedule and host name are context only; never propose changing them. Return plain text in the required JSON fields, with no HTML. Short paragraphs or simple bullet lists are fine.`;
+function draftFrom(text) {
+    const value = JSON.parse(text);
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new Error("invalid draft");
+    const row = value;
+    const draft = {};
+    for (const key of ["title", "description", "topic"]) {
+        const field = row[key];
+        if (typeof field !== "string" || !field.trim() || field.length > LIMITS[key])
+            throw new Error("invalid draft");
+        draft[key] = field.trim();
+    }
+    return draft;
+}
+/** Server-side only. Drafting has no access to the event store and cannot publish. */
+export class EventWriter {
+    options;
+    guard = new Guard();
+    active = new Set();
+    constructor(options) {
+        this.options = options;
+    }
+    async draft(accountId, value, signal) {
+        if (!accountId)
+            throw new EventWriterError("Sign in to use the AI writer.", 401);
+        const input = writerInput(value);
+        if (!this.options.openaiKey && !this.options.anthropicKey)
+            throw new EventWriterError("The AI writer is temporarily unavailable. You can keep writing here.", 503);
+        if (this.active.has(accountId))
+            throw new EventWriterError("A draft is already being written. Wait for it or cancel it first.", 429, 5);
+        if (this.active.size >= 4)
+            throw new EventWriterError("The AI writer is busy. Try again in a moment.", 503, 10);
+        const limit = this.guard.check(accountId, { allowed: 6, windowMs: 10 * 60_000 });
+        if (!limit.ok)
+            throw new EventWriterError("You have requested several drafts. Try again in a few minutes.", 429, limit.retryAfter);
+        this.active.add(accountId);
+        try {
+            for (const provider of ["openai", "claude"]) {
+                const key = provider === "openai" ? this.options.openaiKey : this.options.anthropicKey;
+                if (!key)
+                    continue;
+                if (signal?.aborted)
+                    throw new EventWriterError("Draft cancelled.", 499);
+                try {
+                    const draft = await this.generate(provider, key, input, signal);
+                    if (signal?.aborted)
+                        throw new EventWriterError("Draft cancelled.", 499);
+                    return { draft, provider };
+                }
+                catch (error) {
+                    if (signal?.aborted)
+                        throw new EventWriterError("Draft cancelled.", 499);
+                    // Refusals are a response to the content, not a provider outage.
+                    if (error instanceof Refused)
+                        throw error;
+                    // Never log prompts, credentials, or a provider's raw response body.
+                    console.warn(`nixamp: event writer ${provider} request failed`);
+                }
+            }
+            throw new EventWriterError("The AI writer could not finish this draft. Your text is unchanged; please try again.", 503);
+        }
+        finally {
+            this.active.delete(accountId);
+        }
+    }
+    async generate(provider, key, input, signal) {
+        const timeout = AbortSignal.timeout(this.options.timeoutMs ?? 25_000);
+        const requestSignal = signal ? AbortSignal.any([signal, timeout]) : timeout;
+        const prompt = JSON.stringify(input);
+        const openai = provider === "openai";
+        const response = await (this.options.fetch ?? globalThis.fetch)(openai ? "https://api.openai.com/v1/responses" : "https://api.anthropic.com/v1/messages", {
+            method: "POST", signal: requestSignal,
+            headers: { "content-type": "application/json", ...(openai ? { authorization: `Bearer ${key}` } : { "x-api-key": key, "anthropic-version": "2023-06-01" }) },
+            body: JSON.stringify(openai ? {
+                model: this.options.openaiModel ?? "gpt-5-mini", store: false,
+                instructions: INSTRUCTIONS, input: [{ role: "user", content: prompt }],
+                reasoning: { effort: "minimal" }, max_output_tokens: 2048,
+                text: { format: { type: "json_schema", name: "event_draft", strict: true, schema: SCHEMA } },
+            } : {
+                model: this.options.claudeModel ?? "claude-haiku-4-5", max_tokens: 2048,
+                system: INSTRUCTIONS, messages: [{ role: "user", content: prompt }],
+                output_config: { format: { type: "json_schema", schema: SCHEMA } },
+            }),
+        });
+        if (!response.ok) {
+            await response.body?.cancel();
+            throw new Error("provider unavailable");
+        }
+        const body = await response.json();
+        const blocks = openai
+            ? (Array.isArray(body["output"]) ? body["output"].flatMap(item => item?.type === "message" && Array.isArray(item.content) ? item.content : []) : [])
+            : (Array.isArray(body["content"]) ? body["content"] : []);
+        if (body["stop_reason"] === "refusal" || blocks.some(block => block?.type === "refusal"))
+            throw new Refused();
+        if (openai ? body["status"] !== "completed" : body["stop_reason"] !== "end_turn")
+            throw new Error("incomplete draft");
+        const text = blocks.filter(block => block?.type === (openai ? "output_text" : "text")).map(block => typeof block.text === "string" ? block.text : "").join("");
+        return draftFrom(text);
+    }
+}

package/dist/live-api.d.ts

@@ -1,3 +1,4 @@
+import { type EventWriter } from "./event-writer.ts";
 import type { IncomingMessage, ServerResponse } from "node:http";
 import { type Accounts } from "./accounts.ts";
 import { type LiveEvent, type LiveEvents } from "./live-events.ts";
@@ -6,6 +7,7 @@ import { type Tickets } from "./tickets.ts";
 import { type Rooms } from "./rooms.ts";
 export interface LiveApiOptions {
     events: LiveEvents;
+    eventWriter?: EventWriter;
     accounts?: Accounts;
     layouts?: Layouts;
     rooms?: Rooms;

package/dist/live-api.js

@@ -1,3 +1,4 @@
+import { EventWriterError } from "./event-writer.js";
 import { tokenFrom } from "./accounts.js";
 import { INVITATION_STATES, LIVE_EVENT_KINDS, LIVE_EVENT_STATUSES, LiveEventError, isTicketed, } from "./live-events.js";
 import { LAYOUT_SCOPES, LayoutError, PANEL_REGISTRY, layoutNameFor, presetLayout, } from "./layouts.js";
@@ -19,13 +20,13 @@ function json(response, code, body) {
     });
     response.end(value);
 }
-async function body(request) {
+async function body(request, limit = 64 * 1024) {
     const chunks = [];
     let size = 0;
     for await (const chunk of request) {
         const buffer = chunk;
         size += buffer.length;
-        if (size > 64 * 1024)
+        if (size > limit)
             throw new LiveEventError("body too large", 413);
         chunks.push(buffer);
     }
@@ -187,6 +188,32 @@ export async function handleLiveApi(request, response, url, options) {
         !path.startsWith("/api/v1/layout-presets"))
         return false;
     try {
+        if (path === "/api/v1/events/ai-draft") {
+            if (request.method !== "POST") {
+                json(response, 405, { error: "POST only" });
+                return true;
+            }
+            const account = await requiredAccount(request, response, options);
+            if (!account)
+                return true;
+            if (!options.eventWriter) {
+                json(response, 503, { error: "The AI writer is temporarily unavailable. You can keep writing here." });
+                return true;
+            }
+            const input = await body(request, 12 * 1024);
+            const controller = new AbortController();
+            const closed = () => controller.abort();
+            response.once("close", closed);
+            try {
+                const result = await options.eventWriter.draft(account.id, input, controller.signal);
+                if (!response.destroyed)
+                    json(response, 200, result);
+            }
+            finally {
+                response.off("close", closed);
+            }
+            return true;
+        }
         if (path === "/api/v1/events") {
             if (request.method === "GET") {
                 const account = await signedIn(request, options.accounts);
@@ -559,6 +586,14 @@ export async function handleLiveApi(request, response, url, options) {
         return true;
     }
     catch (error) {
+        if (error instanceof EventWriterError) {
+            if (!response.destroyed) {
+                if (error.retryAfter)
+                    response.setHeader("retry-after", String(error.retryAfter));
+                json(response, error.status, { error: error.message });
+            }
+            return true;
+        }
         if (error instanceof LiveEventError || error instanceof LayoutError || error instanceof RoomError) {
             json(response, error.status, { error: error.message });
             return true;

package/dist/live-events.d.ts

@@ -1,3 +1,4 @@
+import { type ClassroomSettings } from "./classroom.ts";
 import type { Queryable } from "./follows.ts";
 export declare const LIVE_EVENT_STATUSES: readonly ["draft", "scheduled", "starting", "live", "encore", "ended", "cancelled", "archived"];
 export declare const LIVE_EVENT_VISIBILITIES: readonly ["public", "unlisted", "private"];
@@ -18,7 +19,7 @@ export type LiveEventVisibility = (typeof LIVE_EVENT_VISIBILITIES)[number];
 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;
@@ -72,6 +73,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;

package/dist/live-events.js

@@ -1,3 +1,4 @@
+import { classroomBroadcast, publicWebUrl } from "./classroom.js";
 import { createHash, randomBytes, randomUUID } from "node:crypto";
 export const LIVE_EVENT_STATUSES = [
     "draft",
@@ -85,6 +86,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);
 
@@ -101,7 +103,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
@@ -190,6 +192,45 @@ function text(value, name, limit, required = false) {
         throw new LiveEventError(`${name} is too long`, 422);
     return cleaned;
 }
+function classroomSettings(input, current = {}) {
+    const settings = {};
+    for (const key of ["hostName", "homepageUrl", "avatarUrl", "broadcastUrl"]) {
+        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) {
+    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, name) {
     if (value === undefined || value === null || value === "")
         return null;
@@ -271,6 +312,7 @@ export function payToAddress(value, name = "payTo") {
 }
 function eventFrom(row) {
     return {
+        ...((row["classroom"] && typeof row["classroom"] === "object") ? row["classroom"] : {}),
         id: String(row["id"] ?? ""),
         slug: String(row["slug"] ?? ""),
         ownerId: String(row["owner_id"] ?? ""),
@@ -432,6 +474,9 @@ 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,
@@ -448,7 +493,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"),
@@ -457,6 +502,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;
@@ -466,10 +512,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));
         }
         catch (error) {
@@ -481,10 +527,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));
         }
         const row = rows[0];
@@ -595,9 +641,9 @@ export class LiveEvents {
             throw new LiveEventError("the event changed; reload it and try again", 409);
         }
         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) {
@@ -611,13 +657,41 @@ 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);
         }
         if (nextStatus === "scheduled" && !startsAt) {
             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,
         description = $5,
@@ -639,6 +713,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
@@ -651,7 +726,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"),
@@ -660,7 +735,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,
@@ -670,6 +745,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];
         if (!row)

package/dist/live-interpreter.d.ts

@@ -49,6 +49,8 @@ export declare class Interpreter {
     private controller;
     private translating;
     private translationController;
+    private recognitionFailures;
+    private translationFailures;
     private translations;
     constructor(options: {
         language: () => string;
@@ -57,7 +59,7 @@ export declare class Interpreter {
         channel: () => string;
         lines: (lines: Caption[]) => void;
         status: (text: string) => void;
-        failed: () => void;
+        failed: (message: string) => void;
         fetcher?: typeof fetch;
     });
     reset(): void;