nixamp 0.27.2 → 0.28.0

package/dist/server.js

@@ -66,6 +66,7 @@ import { createThrottle, presentedCredential } from "@profullstack/throttle";
 import { Durable } from "./durable.js";
 import { notifyAll, resendEmail, webPush } from "./notify.js";
 import { inviteSubject, inviteText, isEmail, isPhone, watchLink } from "./invite.js";
+import { EventWriter } from "./event-writer.js";
 import { handleLiveApi } from "./live-api.js";
 import { LiveEvents, eventStructuredData, isTicketed } from "./live-events.js";
 import { Tickets, needsTicket, ticketFrom, ticketsFromEnv } from "./tickets.js";
@@ -1448,6 +1449,7 @@ export function createHandler(engine, options) {
             return;
         if (options.events && await handleLiveApi(request, response, url, {
             events: options.events,
+            ...(options.eventWriter ? { eventWriter: options.eventWriter } : {}),
             ...(options.accounts ? { accounts: options.accounts } : {}),
             ...(options.layouts ? { layouts: options.layouts } : {}),
             ...(options.rooms ? { rooms: options.rooms } : {}),
@@ -5599,6 +5601,10 @@ export async function serve(argv, version = "0.1.0") {
     const favorites = pool ? new Favorites(pool) : undefined;
     const settingsSync = pool ? new SettingsSync(pool) : undefined;
     const nixampSite = (process.env["NIXAMP_SITE"] ?? DEFAULT_DIRECTORY).replace(/\/+$/, "");
+    const schoolMailKey = process.env["BACKTOSCHOOL_RESEND_API_KEY"] ?? process.env["RESEND_API_KEY"];
+    const schoolMail = schoolMailKey && process.env["BACKTOSCHOOL_MAIL_FROM"] ? {
+        apiKey: schoolMailKey, from: process.env["BACKTOSCHOOL_MAIL_FROM"],
+    } : undefined;
     const events = pool ? new LiveEvents(pool) : undefined;
     const layouts = pool ? new Layouts(pool) : undefined;
     const rooms = pool ? new Rooms(pool) : undefined;
@@ -6118,7 +6124,10 @@ export async function serve(argv, version = "0.1.0") {
         ...(follows ? { follows, vapidPublicKey } : {}),
         ...(favorites ? { favorites } : {}),
         ...(settingsSync ? { settingsSync } : {}),
-        ...(events ? { events } : {}),
+        ...(events ? { events, eventWriter: new EventWriter({
+                openaiKey: process.env["OPENAI_API_KEY"], anthropicKey: process.env["ANTHROPIC_API_KEY"],
+                openaiModel: process.env["NIXAMP_WRITER_OPENAI_MODEL"], claudeModel: process.env["NIXAMP_WRITER_CLAUDE_MODEL"],
+            }) } : {}),
         ...(layouts ? { layouts } : {}),
         ...(rooms ? { rooms } : {}),
         ...(trollbox ? { trollbox } : {}),
@@ -6135,6 +6144,7 @@ export async function serve(argv, version = "0.1.0") {
             resetMail: resendPasswordReset({
                 apiKey: process.env["RESEND_API_KEY"],
                 from: process.env["NIXAMP_MAIL_FROM"] ?? "nixamp <notifications@nixamp.com>",
+                backtoschool: schoolMail,
             }),
         } : {}),
         // Other people's OpenProfiles, read for the voice a line is spoken in,
@@ -6159,6 +6169,8 @@ export async function serve(argv, version = "0.1.0") {
                             email: resendEmail({
                                 apiKey: process.env["RESEND_API_KEY"],
                                 from: process.env["NIXAMP_MAIL_FROM"] ?? "nixamp <notifications@nixamp.com>",
+                                backtoschool: schoolMail,
+                                reason: "You received this email because a host invited you to join a live session.",
                                 onEvent: (message) => console.log(message),
                             }),
                         }

package/dist/shared-translation.d.ts

@@ -27,6 +27,7 @@ export type SharedEvent = {
 } | {
     type: "error";
     error: string;
+    retryable?: boolean;
 };
 type Member = {
     by: string;

package/dist/shared-translation.js

@@ -1,5 +1,6 @@
 /** One live source/language pipeline, paid access for every listening account.
  * Browsers receive the same PCM, never upload a replacement for a public feed. */
+import { transientAudioError } from "./live-recovery.js";
 import { createHash, randomUUID } from "node:crypto";
 import { lookup } from "node:dns/promises";
 import { BlockList, isIP } from "node:net";
@@ -179,15 +180,15 @@ export class SharedTranslations {
             }
         }
     }
-    stop(feed, error) {
-        this.broadcast(feed, { type: "error", error });
+    stop(feed, error, retryable = false) {
+        this.broadcast(feed, { type: "error", error, retryable });
         for (const member of [...feed.members]) {
             this.leave(feed, member);
             member.close();
         }
     }
     make(id, source, language) {
-        const feed = { id, source, language, members: new Set(), controller: new AbortController(), reservations: new Map(), queue: [], speaking: false, previous: Buffer.alloc(0), pending: Buffer.alloc(0), until: Date.now() };
+        const feed = { id, source, language, members: new Set(), controller: new AbortController(), reservations: new Map(), queue: [], speaking: false, voiceFailures: 0, previous: Buffer.alloc(0), pending: Buffer.alloc(0), until: Date.now() };
         // Each account uses free access first, then the same published credit rate.
         // Additional listeners do not trigger recognition or synthesis.
         feed.meter = {
@@ -254,13 +255,10 @@ export class SharedTranslations {
             language: () => language, speakers: () => true, voices: () => voices, channel: () => id,
             status: text => { if (!feed.controller.signal.aborted && !feed.members.size)
                 this.stop(feed, text); },
-            failed: () => this.stop(feed, "Live translation stopped. Enable it again to retry."),
+            failed: message => this.stop(feed, message),
             lines: lines => {
                 feed.queue.push(...lines);
-                if (feed.queue.length > 24) {
-                    this.stop(feed, "Live translation fell behind. Enable it again to retry.");
-                    return;
-                }
+                feed.queue = feed.queue.filter(line => Date.now() - line.until <= 12_000).slice(-24);
                 if (!feed.speaking)
                     void this.speak(feed);
             },
@@ -296,7 +294,7 @@ export class SharedTranslations {
                         samples[index] = pcm.readInt16LE(index * 2) / 32768;
                     feed.interpreter.push({ samples, at: feed.until - samples.length / 16, until: feed.until, freshAt: feed.until - 2000 });
                 }
-            }, () => this.stop(feed, "The live source stopped. Enable translated audio again when playback resumes."), feed.controller.signal);
+            }, () => this.stop(feed, "The live source disconnected.", true), feed.controller.signal);
             if (feed.controller.signal.aborted)
                 input.stop();
             else
@@ -312,24 +310,35 @@ export class SharedTranslations {
             while (feed.queue.length && !feed.controller.signal.aborted) {
                 const line = feed.queue.shift();
                 if (Date.now() - line.until > 12_000)
-                    throw new SpeechError("Live translation fell behind. Enable it again to retry.", 503);
-                const response = await this.options.voice.stream({ text: line.text, language: feed.language, channel: feed.id, speaker: line.speaker, voice: feed.interpreter.tracker.speakers.get(line.speaker ?? "")?.voice }, feed.id, feed.controller.signal, feed.meter);
-                const id = randomUUID();
-                this.broadcast(feed, { type: "line", id, line });
-                const reader = response.body.getReader();
+                    continue;
                 try {
-                    while (true) {
-                        const { done, value } = await reader.read();
-                        if (done)
-                            break;
-                        for (let at = 0; at < value.length; at += 16_384)
-                            this.broadcast(feed, { type: "audio", id, data: Buffer.from(value.subarray(at, at + 16_384)).toString("base64") });
+                    const response = await this.options.voice.stream({ text: line.text, language: feed.language, channel: feed.id, speaker: line.speaker, voice: feed.interpreter.tracker.speakers.get(line.speaker ?? "")?.voice }, feed.id, feed.controller.signal, feed.meter);
+                    const id = randomUUID();
+                    this.broadcast(feed, { type: "line", id, line });
+                    const reader = response.body.getReader();
+                    try {
+                        while (true) {
+                            const { done, value } = await reader.read();
+                            if (done)
+                                break;
+                            for (let at = 0; at < value.length; at += 16_384)
+                                this.broadcast(feed, { type: "audio", id, data: Buffer.from(value.subarray(at, at + 16_384)).toString("base64") });
+                        }
                     }
+                    finally {
+                        reader.releaseLock();
+                        this.broadcast(feed, { type: "end", id });
+                    }
+                    feed.voiceFailures = 0;
                 }
-                finally {
-                    reader.releaseLock();
+                catch (error) {
+                    if (feed.controller.signal.aborted)
+                        return;
+                    if (!transientAudioError(error) || ++feed.voiceFailures >= 3)
+                        throw error;
+                    // A provider failure skips this phrase; the source and other listeners
+                    // remain connected. Never replay partial speech or retry a charge.
                 }
-                this.broadcast(feed, { type: "end", id });
             }
         }
         catch (error) {

package/dist/ui-aliases.d.ts

@@ -0,0 +1,4 @@
+import type { Message } from './i18n.ts';
+/** Existing copy can use a concise shared label in translated interfaces.
+ * English remains verbatim. Never use these aliases for user-authored content. */
+export declare const aliases: Record<string, Message>;

package/dist/ui-aliases.js

@@ -0,0 +1,41 @@
+/** Existing copy can use a concise shared label in translated interfaces.
+ * English remains verbatim. Never use these aliases for user-authored content. */
+export const aliases = {
+    '■ STOPPED': 'Stopped', '▶ PLAYING': 'Playing', 'LOADING': 'Loading…',
+    'no source': 'No source', 'not connected': 'Not connected', 'Now playing': 'Now Playing',
+    '● GO LIVE': 'Go live', '● Go live': 'Go live', '⤓ Download': 'Download',
+    'A man\'s voice': 'Male voice', 'A woman\'s voice': 'Female voice',
+    'Catalogs on this server': 'Catalogs', 'Catalog folders': 'Catalogs',
+    'Parties on this server': 'Parties', 'Servers streaming now': 'Directory',
+    'Playlist (0)': 'Playlist', 'Playlist folders': 'Playlist', 'Playlist pages': 'Playlist',
+    'Filter these files': 'Filter', 'Filter these entries': 'Filter',
+    'Filter the entries': 'Filter', 'Filter the playlist': 'Filter',
+    'Create a free account': 'Create account', 'Create one': 'Create account',
+    'Create your account': 'Create account', 'New here? Create an account': 'Create account',
+    'Already have an account? Sign in': 'Sign in', 'Your NixAmp account': 'Your account',
+    'Your public handle': 'Handle', 'handle': 'Handle', 'password': 'Password',
+    'Phone number for texts': 'Phone number', 'Back to the player': 'Back',
+    'Share what is playing': 'Share', 'Share this stream': 'Share',
+    'Link to this stream': 'Link', 'Copy this stream\'s URL': 'Copy link',
+    'A link to play': 'Link', 'A server\'s link': 'Server', 'Close translated audio purchase': 'Close',
+    'Open secure checkout ↗ (new tab)': 'Open checkout', 'Checking…': 'Loading…',
+    'Browse the directory': 'Directory', 'See what is live': 'Live now',
+    'Join live': 'Join', 'Raise Hand': 'Raise hand', 'Hand Raises': 'Hand raises',
+    'Hide this': 'Hide', 'Log': 'Activity log', 'Status:': 'Status',
+    'Nixamp player': 'Playback controls', 'Nixamp audio and video player': 'Playback controls',
+    'What is being said': 'Transcript', 'The room\'s chat': 'Chat', 'Trollbox': 'Chat',
+    'A line for the trollbox': 'Chat message', 'Say something to the room…': 'Chat message',
+    'Send it': 'Send', 'Something to add': 'Chat message', 'What to call it': 'Catalog name',
+    'call it something': 'Catalog name', 'An m3u catalog to add': 'Catalogs',
+    'On this device': 'Play', 'Play on this device': 'Play', 'What this is': 'About',
+    'Looking for servers…': 'Loading…', 'Finding today’s conversations…': 'Loading…',
+    'Coming up': 'Upcoming', 'Listen after class': 'Replay', 'Schedule live': 'Schedule class',
+    'Schedule a class': 'Schedule class', 'Plan a conversation': 'Schedule class',
+    'Your classroom': 'Event', 'Join in': 'Join', 'Open a room →': 'Start a room',
+    'Chat message': 'Chat message', 'Add to the conversation': 'Chat message',
+    'Create live': 'Create live', 'Host stage': 'Stage', 'Your host': 'Host',
+    'Class host': 'Host', 'Hand raised ✓': 'Raise hand', 'Copied ✓': 'Copied',
+    'Screen share with Pairux ↗': 'Screen share', 'Upload & broadcast in Nixamp ↗': 'Upload and broadcast',
+    'Open Music Folder…': 'Open folder', 'Choose a music folder': 'Open folder',
+    'Main navigation': 'Panels', 'Skip to a section': 'Panels',
+};

package/dist/ui-languages.d.ts

@@ -0,0 +1,62 @@
+/** The UI and audio-translation menus share the same supported targets. */
+export declare const UI_LANGUAGES: readonly [{
+    readonly code: 'en';
+    readonly label: 'English';
+}, {
+    readonly code: 'de';
+    readonly label: 'Deutsch';
+}, {
+    readonly code: 'sv';
+    readonly label: 'Svenska';
+}, {
+    readonly code: 'es';
+    readonly label: 'Español';
+}, {
+    readonly code: 'fr';
+    readonly label: 'Français';
+}, {
+    readonly code: 'it';
+    readonly label: 'Italiano';
+}, {
+    readonly code: 'nl';
+    readonly label: 'Nederlands';
+}, {
+    readonly code: 'da';
+    readonly label: 'Dansk';
+}, {
+    readonly code: 'fi';
+    readonly label: 'Suomi';
+}, {
+    readonly code: 'ru';
+    readonly label: 'Русский';
+}, {
+    readonly code: 'uk';
+    readonly label: 'Українська';
+}, {
+    readonly code: 'cs';
+    readonly label: 'Čeština';
+}, {
+    readonly code: 'hu';
+    readonly label: 'Magyar';
+}, {
+    readonly code: 'zh';
+    readonly label: '中文';
+}, {
+    readonly code: 'ar';
+    readonly label: 'العربية';
+}, {
+    readonly code: 'hi';
+    readonly label: 'हिन्दी';
+}, {
+    readonly code: 'vi';
+    readonly label: 'Tiếng Việt';
+}, {
+    readonly code: 'id';
+    readonly label: 'Bahasa Indonesia';
+}];
+export type UiLanguage = typeof UI_LANGUAGES[number]['code'];
+export declare const UI_LANGUAGE_KEY = "nixamp.ui.language";
+export declare function uiLanguage(value: unknown): UiLanguage;
+/** A saved choice wins; otherwise use the first supported system preference. */
+export declare function preferredUiLanguage(saved: unknown, system?: readonly unknown[]): UiLanguage;
+export declare function terminalUiLanguage(env: Record<string, string | undefined>): UiLanguage;

package/dist/ui-languages.js

@@ -0,0 +1,32 @@
+/** The UI and audio-translation menus share the same supported targets. */
+export const UI_LANGUAGES = [
+    { code: 'en', label: 'English' }, { code: 'de', label: 'Deutsch' },
+    { code: 'sv', label: 'Svenska' }, { code: 'es', label: 'Español' },
+    { code: 'fr', label: 'Français' }, { code: 'it', label: 'Italiano' },
+    { code: 'nl', label: 'Nederlands' }, { code: 'da', label: 'Dansk' },
+    { code: 'fi', label: 'Suomi' }, { code: 'ru', label: 'Русский' },
+    { code: 'uk', label: 'Українська' }, { code: 'cs', label: 'Čeština' },
+    { code: 'hu', label: 'Magyar' }, { code: 'zh', label: '中文' },
+    { code: 'ar', label: 'العربية' }, { code: 'hi', label: 'हिन्दी' },
+    { code: 'vi', label: 'Tiếng Việt' }, { code: 'id', label: 'Bahasa Indonesia' },
+];
+export const UI_LANGUAGE_KEY = 'nixamp.ui.language';
+export function uiLanguage(value) {
+    const code = typeof value === 'string' ? value.trim().toLowerCase().split(/[-_.@]/)[0] : '';
+    return UI_LANGUAGES.find(language => language.code === code)?.code ?? 'en';
+}
+/** A saved choice wins; otherwise use the first supported system preference. */
+export function preferredUiLanguage(saved, system = []) {
+    const match = (value) => {
+        const code = typeof value === 'string' ? value.trim().toLowerCase().split(/[-_.@]/)[0] : '';
+        return UI_LANGUAGES.find(language => language.code === code)?.code;
+    };
+    return match(saved) ?? system.map(match).find(Boolean) ?? 'en';
+}
+export function terminalUiLanguage(env) {
+    if (env['NIXAMP_UI_LANGUAGE'])
+        return uiLanguage(env['NIXAMP_UI_LANGUAGE']);
+    if (env['LC_ALL'])
+        return preferredUiLanguage(null, [env['LC_ALL']]);
+    return preferredUiLanguage(null, env['LANGUAGE']?.split(':') ?? [env['LC_MESSAGES'] || env['LANG']]);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nixamp",
-  "version": "0.27.2",
+  "version": "0.28.0",
   "description": "It really whips the terminal's ass. A Winamp-shaped audio player for your terminal.",
   "license": "MIT",
   "type": "module",

package/src/admin.ts

@@ -1,3 +1,4 @@
+import { t as uiMessage } from "./i18n.ts";
 /**
  * `nixamp admin` — what the daemon is doing, and who is listening to it.
  *
@@ -261,7 +262,7 @@ export function draw(ui: Container, theme: Theme, view: View): void {
   const now = report?.now ?? Date.now();
 
   ui.row({ size: 7, gap: 1 }, (row) => {
-    row.panel({ title: "Server" }, (p) => {
+    row.panel({ title: uiMessage("Server") }, (p) => {
       p.text(view.url, { fg: theme.primary });
       p.label(snapshot?.root ?? "—");
       p.keyValues([
@@ -271,7 +272,7 @@ export function draw(ui: Container, theme: Theme, view: View): void {
       ]);
     });
 
-    row.panel({ title: "Now playing" }, (p) => {
+    row.panel({ title: uiMessage("Now playing") }, (p) => {
       const track = snapshot ? snapshot.tracks[snapshot.index] : undefined;
       p.text(track?.title ?? "nothing", { fg: theme.accent });
       p.label(track?.artist || "—");
@@ -368,9 +369,9 @@ export function draw(ui: Container, theme: Theme, view: View): void {
 
   ui.statusBar({
     items: [
-      { key: "a", label: "Add" },
+      { key: "a", label: uiMessage("Add") },
       { key: "r", label: "Replace" },
-      { key: "q", label: "Quit" },
+      { key: "q", label: uiMessage("Quit") },
     ],
     right: [{ key: "", label: report ? `${report.connections.length} seen` : "connecting" }],
   });

package/src/event-writer.ts

@@ -0,0 +1,126 @@
+import { Guard } from "./guard.ts";
+
+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 class EventWriterError extends Error {
+  constructor(message: string, readonly status: number, readonly retryAfter?: number) { super(message); }
+}
+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} as const;
+export function writerInput(value: unknown): WriterInput {
+  if (!value || typeof value !== "object" || Array.isArray(value)) throw new EventWriterError("Send event details as an object.", 400);
+  const source = value as Record<string, unknown>;
+  const result = {} as WriterInput;
+  for (const key of Object.keys(LIMITS) as Array<keyof WriterInput>) {
+    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: string): EventDraft {
+  const value: unknown = JSON.parse(text);
+  if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("invalid draft");
+  const row = value as Record<string, unknown>;
+  const draft = {} as EventDraft;
+  for (const key of ["title", "description", "topic"] as const) {
+    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;
+}
+
+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 class EventWriter {
+  private readonly guard = new Guard();
+  private readonly active = new Set<string>();
+  constructor(private readonly options: EventWriterOptions) {}
+
+  async draft(accountId: string, value: unknown, signal?: AbortSignal): Promise<EventDraftResult> {
+    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"] as const) {
+        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); }
+  }
+
+  private async generate(provider: "openai" | "claude", key: string, input: WriterInput, signal?: AbortSignal): Promise<EventDraft> {
+    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() as Record<string, unknown>;
+    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/src/i18n.ts

@@ -0,0 +1,74 @@
+import en from './locales/en.ts';
+import { aliases } from './ui-aliases.ts';
+import { uiLanguage, type UiLanguage } from './ui-languages.ts';
+export { UI_LANGUAGES, UI_LANGUAGE_KEY, uiLanguage, preferredUiLanguage, terminalUiLanguage } from './ui-languages.ts';
+export type { UiLanguage } from './ui-languages.ts';
+export type Message = keyof typeof en;
+export type Catalogue = Record<Message, string>;
+const loaders = {
+  en: async () => ({ default: en }),
+  de: () => import('./locales/de.ts'), sv: () => import('./locales/sv.ts'),
+  es: () => import('./locales/es.ts'), fr: () => import('./locales/fr.ts'),
+  it: () => import('./locales/it.ts'), nl: () => import('./locales/nl.ts'),
+  da: () => import('./locales/da.ts'), fi: () => import('./locales/fi.ts'),
+  ru: () => import('./locales/ru.ts'), uk: () => import('./locales/uk.ts'),
+  cs: () => import('./locales/cs.ts'), hu: () => import('./locales/hu.ts'),
+  zh: () => import('./locales/zh.ts'), ar: () => import('./locales/ar.ts'),
+  hi: () => import('./locales/hi.ts'), vi: () => import('./locales/vi.ts'),
+  id: () => import('./locales/id.ts'),
+} satisfies Record<UiLanguage, () => Promise<{ default: Catalogue }>>;
+/** Independent instances prevent one server request from changing another's locale. */
+export class I18n {
+  private code: UiLanguage = 'en';
+  get language(): UiLanguage { return this.code; }
+  constructor(private readonly load = async (language: UiLanguage): Promise<Catalogue> => (await loaders[language]()).default) {}
+  private messages: Catalogue = en;
+  private revision = 0;
+  private numberFormats = new Map<string, Intl.NumberFormat>();
+  private dateFormats = new Map<string, Intl.DateTimeFormat>();
+  private listeners = new Set<() => void>();
+  async setLanguage(value: unknown): Promise<boolean> {
+    const revision = ++this.revision;
+    const language = uiLanguage(value);
+    const catalogue = await this.load(language);
+    if (revision !== this.revision) return false;
+    this.code = language;
+    this.messages = catalogue;
+    this.numberFormats.clear(); this.dateFormats.clear();
+    for (const changed of this.listeners) changed();
+    return true;
+  }
+  onChange(changed: () => void): () => void {
+    this.listeners.add(changed);
+    return () => this.listeners.delete(changed);
+  }
+  text(source: string, values: Record<string, string | number> = {}): string {
+    const key = (this.language !== 'en' && Object.hasOwn(aliases, source) ? aliases[source] : source) as Message;
+    let translated = Object.hasOwn(this.messages, key) ? this.messages[key] : source;
+    if (this.language !== 'en' && Object.hasOwn(aliases, source)) {
+      translated = (source.match(/^[▶■●⤓]\s+/)?.[0] ?? '') + translated + (source.endsWith(' ✓') ? ' ✓' : '');
+    }
+    return translated.replace(/\{([\w]+)\}/g, (original, name: string) => Object.hasOwn(values, name) ? String(values[name]) : original);
+  }
+  number(value: number, options?: Intl.NumberFormatOptions): string {
+    const key = JSON.stringify(options ?? {});
+    let formatter = this.numberFormats.get(key);
+    if (!formatter) {
+      if (this.numberFormats.size >= 64) this.numberFormats.clear();
+      formatter = new Intl.NumberFormat(this.language, options); this.numberFormats.set(key, formatter);
+    }
+    return formatter.format(value);
+  }
+  date(value: Date | number, options?: Intl.DateTimeFormatOptions): string {
+    const key = JSON.stringify(options ?? {});
+    let formatter = this.dateFormats.get(key);
+    if (!formatter) {
+      if (this.dateFormats.size >= 64) this.dateFormats.clear();
+      formatter = new Intl.DateTimeFormat(this.language, options); this.dateFormats.set(key, formatter);
+    }
+    return formatter.format(value);
+  }
+  get direction(): 'ltr' | 'rtl' { return this.language === 'ar' ? 'rtl' : 'ltr'; }
+}
+export const i18n = new I18n();
+export const t = (source: string, values?: Record<string, string | number>): string => i18n.text(source, values);

package/src/live-api.ts

@@ -1,3 +1,4 @@
+import { EventWriterError, type EventWriter } from "./event-writer.ts";
 import type { IncomingMessage, ServerResponse } from "node:http";
 import { tokenFrom, type Account, type Accounts } from "./accounts.ts";
 import {
@@ -26,6 +27,7 @@ import { HAND_RAISE_STATES, RoomError, type Rooms } from "./rooms.ts";
 
 export interface LiveApiOptions {
   events: LiveEvents;
+  eventWriter?: EventWriter;
   accounts?: Accounts;
   layouts?: Layouts;
   rooms?: Rooms;
@@ -52,13 +54,13 @@ function json(response: ServerResponse, code: number, body: unknown): void {
   response.end(value);
 }
 
-async function body(request: IncomingMessage): Promise<Record<string, unknown>> {
+async function body(request: IncomingMessage, limit = 64 * 1024): Promise<Record<string, unknown>> {
   const chunks: Buffer[] = [];
   let size = 0;
   for await (const chunk of request) {
     const buffer = chunk as Buffer;
     size += buffer.length;
-    if (size > 64 * 1024) throw new LiveEventError("body too large", 413);
+    if (size > limit) throw new LiveEventError("body too large", 413);
     chunks.push(buffer);
   }
   try {
@@ -256,6 +258,21 @@ export async function handleLiveApi(
       !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);
@@ -624,6 +641,13 @@ export async function handleLiveApi(
     json(response, 404, { error: "no such endpoint" });
     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;