@gentbajko/slopify 0.5.1 → 0.7.0

package/dist/adapters/tts/inworld-text.js

@@ -0,0 +1,32 @@
+// Inworld's streaming endpoint accepts 4,000 characters. Split inside the
+// adapter so whole-text narration and long intros/outros all remain usable.
+// UTF-16 length is conservative for Unicode; never cut a surrogate pair.
+export function inworldTextParts(text) {
+    const parts = [];
+    let current = "";
+    for (const sentence of new Intl.Segmenter("en", { granularity: "sentence" }).segment(text)) {
+        if (current.length + sentence.segment.length <= 4000) {
+            current += sentence.segment;
+            continue;
+        }
+        if (current.trim())
+            parts.push(current.trim());
+        let remaining = sentence.segment;
+        while (remaining.length > 4000) {
+            const window = remaining.slice(0, 4000);
+            const boundary = Math.max(window.lastIndexOf(" "), window.lastIndexOf("\n"), window.lastIndexOf("\t"));
+            let cut = boundary > 0 ? boundary : 4000;
+            const last = remaining.charCodeAt(cut - 1);
+            if (last >= 0xd800 && last <= 0xdbff)
+                cut--;
+            const piece = remaining.slice(0, cut).trim();
+            if (piece)
+                parts.push(piece);
+            remaining = remaining.slice(cut).trimStart();
+        }
+        current = remaining;
+    }
+    if (current.trim())
+        parts.push(current.trim());
+    return parts;
+}

package/dist/adapters/tts/inworld.js

@@ -0,0 +1,170 @@
+import { z } from "zod";
+import { redact } from "../../kernel/log.js";
+import { providerError } from "../../kernel/ports/model.js";
+import { retryAfter } from "../retry-after.js";
+import { inworldAsync } from "./inworld-async.js";
+import { inworldTextParts } from "./inworld-text.js";
+export const inworldModels = [
+    { id: "inworld-tts-2", name: "Realtime TTS-2" },
+    { id: "inworld-tts-2-flash", name: "Realtime TTS-2 Flash" },
+];
+const envelope = z.object({
+    result: z.object({ audioContent: z.string().optional() }).optional(),
+    error: z.object({ code: z.number().optional(), message: z.string().optional() }).optional(),
+});
+export function inworldTts(deps) {
+    return {
+        id: "inworld",
+        capabilities: { streams: true },
+        models: async () => inworldModels,
+        synthesize: async (request) => {
+            const key = deps
+                .key()
+                ?.trim()
+                .replace(/^Basic\s+/i, "");
+            if (!key)
+                throw providerError({ kind: "missing_key", message: "No Inworld API key is stored." });
+            const cancel = new AbortController();
+            const signal = AbortSignal.any([request.signal, cancel.signal]);
+            const iterator = synthesizeParts(deps, { ...request, signal }, key);
+            return {
+                container: "mp3",
+                audio: new ReadableStream({
+                    async pull(controller) {
+                        try {
+                            const next = await iterator.next();
+                            if (next.done)
+                                controller.close();
+                            else
+                                controller.enqueue(next.value);
+                        }
+                        catch (error) {
+                            controller.error(error);
+                        }
+                    },
+                    async cancel() {
+                        cancel.abort();
+                        await iterator.return();
+                    },
+                }, { highWaterMark: 0 }),
+            };
+        },
+    };
+}
+async function* synthesizeParts(deps, request, key) {
+    if ((request.model ?? "inworld-tts-2") === "inworld-tts-2" && request.text.length > 4000) {
+        yield* inworldAsync(deps, request, key);
+        return;
+    }
+    const parts = inworldTextParts(request.text);
+    if (parts.length === 0)
+        throw providerError({ kind: "unsupported", message: "Inworld needs text to narrate." });
+    for (const text of parts) {
+        request.signal.throwIfAborted();
+        const response = await deps.fetch("https://api.inworld.ai/tts/v1/voice:stream", {
+            method: "POST",
+            redirect: "error",
+            signal: request.signal,
+            headers: { Authorization: `Basic ${key}`, "Content-Type": "application/json" },
+            body: JSON.stringify({
+                text,
+                voiceId: request.voiceId,
+                modelId: request.model ?? "inworld-tts-2",
+                audioConfig: { audioEncoding: "MP3", sampleRateHertz: 48_000, bitRate: 128_000 },
+            }),
+        });
+        if (!response.ok) {
+            const detail = clean(await response.text().catch(() => ""), key);
+            const retryAfterMs = retryAfter(response.headers.get("retry-after"));
+            throw providerError({
+                kind: response.status === 401 || response.status === 403
+                    ? "auth"
+                    : response.status === 429
+                        ? "rate_limit"
+                        : response.status === 400 || response.status === 404
+                            ? "unsupported"
+                            : "other",
+                message: clean(`Inworld answered ${response.status} for voice ${request.voiceId}: ${detail || response.statusText}`, key),
+                ...(retryAfterMs === undefined ? {} : { retryAfterMs }),
+            });
+        }
+        if (response.body === null)
+            throw invalid("answered with no audio");
+        let heard = false;
+        for await (const line of lines(response.body)) {
+            request.signal.throwIfAborted();
+            let raw;
+            try {
+                raw = JSON.parse(line);
+            }
+            catch {
+                throw invalid("sent an unreadable audio chunk");
+            }
+            const parsed = envelope.safeParse(raw);
+            if (!parsed.success || (!parsed.data.result && !parsed.data.error))
+                throw invalid("sent an unreadable audio chunk");
+            if (parsed.data.error) {
+                const { code, message } = parsed.data.error;
+                throw providerError({
+                    kind: code === 16 || code === 7
+                        ? "auth"
+                        : code === 8
+                            ? "rate_limit"
+                            : code === 3 || code === 5
+                                ? "unsupported"
+                                : "other",
+                    message: `Inworld stream failed: ${clean(message ?? "audio generation stopped", key)}`,
+                });
+            }
+            const encoded = parsed.data.result?.audioContent;
+            if (!encoded)
+                continue;
+            if (!/^[A-Za-z0-9+/]*={0,2}$/.test(encoded) || encoded.length % 4 === 1)
+                throw invalid("sent invalid encoded audio");
+            const audio = Buffer.from(encoded, "base64");
+            if (audio.length === 0)
+                continue;
+            heard = true;
+            yield audio;
+        }
+        if (!heard)
+            throw invalid("answered with no audio");
+    }
+}
+async function* lines(body) {
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    let pending = "";
+    try {
+        for (;;) {
+            const { done, value } = await reader.read();
+            pending += done ? decoder.decode() : decoder.decode(value, { stream: true });
+            let end = pending.indexOf("\n");
+            while (end !== -1) {
+                if (end > 8 * 1024 * 1024)
+                    throw invalid("sent an oversized audio chunk");
+                const line = pending.slice(0, end).trim();
+                pending = pending.slice(end + 1);
+                if (line)
+                    yield line;
+                end = pending.indexOf("\n");
+            }
+            if (pending.length > 8 * 1024 * 1024)
+                throw invalid("sent an oversized audio chunk");
+            if (done)
+                break;
+        }
+        if (pending.trim())
+            yield pending.trim();
+    }
+    finally {
+        await reader.cancel().catch(() => { });
+        reader.releaseLock();
+    }
+}
+function clean(message, key) {
+    return redact(message.replaceAll(key, "[redacted]"));
+}
+function invalid(detail) {
+    return providerError({ kind: "other", message: `Inworld ${detail}.` });
+}

package/dist/adapters/tts/openai.js

@@ -5,9 +5,18 @@ import { retryAfter } from "../retry-after.js";
 // The HTTP gateway adapter for OpenAI's speech endpoint. `fetch` and nothing else; the response
 // body is already the stream the port asks for.
 export const openAiAudioBase = "https://api.openai.com/v1";
-// gpt-4o-mini-tts, tts-1 and tts-1-hd; the first is the current one and the cheapest of the
-// three per character.
+// Older callers can omit a model; saved project choices always supply one.
 export const openAiTtsModel = "gpt-4o-mini-tts";
+export const openAiTtsModels = [
+    { id: "gpt-4o-mini-tts", name: "GPT-4o mini TTS" },
+    { id: "gpt-4o-mini-tts-2025-12-15", name: "GPT-4o mini TTS (2025-12-15)" },
+    { id: "tts-1", name: "TTS-1" },
+    { id: "tts-1-hd", name: "TTS-1 HD" },
+];
+const modelList = z.object({ data: z.array(z.object({ id: z.string().min(1) })) });
+// /models has no capability metadata. Only the speech endpoint's documented model families
+// and dated snapshots belong here; realtime and transcription models use different APIs.
+const speechModel = /^(?:tts-1(?:-hd)?(?:-\d{4})?|gpt-4o-mini-tts(?:-\d{4}-\d{2}-\d{2})?)$/;
 const errorBody = z.object({
     error: z.object({ message: z.string(), code: z.string().nullish() }),
 });
@@ -19,6 +28,24 @@ export function openAiTts(deps) {
     return {
         id: "openai-tts",
         capabilities: { streams: true },
+        models: async () => {
+            const response = await deps.fetch(`${openAiAudioBase}/models`, {
+                headers: { Authorization: `Bearer ${keyOf(deps)}` },
+                signal: AbortSignal.timeout(10_000),
+            });
+            if (!response.ok)
+                throw await failure(response);
+            const parsed = modelList.safeParse(safeJson(await response.text()));
+            if (!parsed.success) {
+                throw providerError({
+                    kind: "other",
+                    message: "OpenAI's model list was not in the shape this app can read",
+                });
+            }
+            return parsed.data.data
+                .filter((model) => speechModel.test(model.id))
+                .map((model) => ({ id: model.id, name: model.id }));
+        },
         synthesize: async (req) => {
             const response = await deps.fetch(`${openAiAudioBase}/audio/speech`, {
                 method: "POST",
@@ -31,7 +58,7 @@ export function openAiTts(deps) {
                 // 400 and that is what the stage shows, so a user who chose Whole text learns the limit
                 // from the provider that set it.
                 body: JSON.stringify({
-                    model: openAiTtsModel,
+                    model: req.model ?? openAiTtsModel,
                     input: req.text,
                     voice: voiceOf(req.voiceId),
                     response_format: "mp3",
@@ -80,7 +107,7 @@ async function failure(response, voiceId) {
         kind: kindOf(response.status),
         // The voice ID is named, so a rejected voice reads differently from
         // a rejected key.
-        message: `OpenAI answered ${response.status} for voice ${voiceId}: ${message}`,
+        message: `OpenAI answered ${response.status}${voiceId === undefined ? "" : ` for voice ${voiceId}`}: ${message}`,
         ...(retryAfterMs === undefined ? {} : { retryAfterMs }),
     });
 }

package/dist/assets/fonts/OFL.txt

@@ -0,0 +1,93 @@
+Copyright 2017 The Barlow Project Authors (https://github.com/jpt/barlow)
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+This license is copied below, and is also available with a FAQ at:
+http://scripts.sil.org/OFL
+
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded,
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.

package/dist/assets/fonts/SOURCE.txt

@@ -0,0 +1,7 @@
+Barlow-Regular.ttf
+Source: https://raw.githubusercontent.com/google/fonts/6cdf01867df0813c2390f90dff7dc66c87f14cf7/ofl/barlow/Barlow-Regular.ttf
+SHA-256: 95aa02c7c43096e0dd44d787ba6216864a67157e402adab59b35572e0c1577ea
+
+OFL.txt
+Source: https://raw.githubusercontent.com/google/fonts/6cdf01867df0813c2390f90dff7dc66c87f14cf7/ofl/barlow/OFL.txt
+SHA-256: 186d750eb496a4c17a76385f82be6aea2ac1cf2de074a811d63786cf374ea73f

package/dist/edge/cli.js

@@ -1,7 +1,9 @@
 #!/usr/bin/env node
 import { parseArgs } from "node:util";
 import { configFrom } from "../kernel/config/index.js";
+import { readVersion } from "../kernel/version.js";
 import { boot } from "../main.js";
+import { forwardManagedUpdate } from "../updater/forward.js";
 import { openBrowser } from "./open-browser.js";
 const { values } = parseArgs({
     options: {
@@ -13,6 +15,9 @@ const { values } = parseArgs({
 });
 try {
     const config = configFrom(values, process.env);
+    const forwarded = await forwardManagedUpdate(config.dataDir, readVersion(), process.argv.slice(2));
+    if (forwarded !== undefined)
+        process.exit(forwarded);
     const { paths, url, stop } = await boot(config);
     console.log(`Slopify is running at ${url}`);
     console.log(`Slopify data directory: ${paths.dataDir}`);

package/dist/edge/events/hub.js

@@ -1,4 +1,6 @@
+import { createPreviewCache } from "./preview-cache.js";
 export function createHub(deps) {
+    const previews = createPreviewCache();
     const projects = new Map();
     const globals = new Set();
     // The tally a page needs before anything else happens. The runner emits it when it
@@ -43,11 +45,15 @@ export function createHub(deps) {
         subscribe: (projectId, stream, signal) => {
             const set = projects.get(projectId) ?? new Set();
             projects.set(projectId, set);
-            return join(set, stream, signal, () => {
+            const subscriber = join(set, stream, signal, () => {
                 if (set.size === 0) {
                     projects.delete(projectId);
                 }
-            }).done;
+            });
+            if (set.has(subscriber))
+                for (const event of previews.snapshot(projectId))
+                    send(subscriber, event);
+            return subscriber.done;
         },
         subscribeGlobal: (stream, signal) => {
             const subscriber = join(globals, stream, signal, () => { });
@@ -57,6 +63,7 @@ export function createHub(deps) {
             return subscriber.done;
         },
         emit: (projectId, event) => {
+            previews.observe(event);
             for (const subscriber of projects.get(projectId) ?? []) {
                 send(subscriber, event);
             }

package/dist/edge/events/preview-cache.js

@@ -0,0 +1,40 @@
+// Preview memory is bounded independently from durable outputs. A subscriber joining
+// mid-call receives only visible response text, never prompts or provider reasoning.
+export function createPreviewCache() {
+    const projects = new Map();
+    return {
+        observe: (event) => {
+            if (event.type === "stage.state") {
+                const calls = projects.get(event.projectId);
+                if (calls) {
+                    for (const [id, call] of calls)
+                        if (call.stage === event.stage)
+                            calls.delete(id);
+                    if (calls.size === 0)
+                        projects.delete(event.projectId);
+                }
+                return;
+            }
+            if (event.type !== "llm.preview")
+                return;
+            const calls = projects.get(event.projectId) ?? new Map();
+            const prior = calls.get(event.callId);
+            const text = (event.reset ? event.text : `${prior?.text ?? ""}${event.text}`).slice(-64 * 1024);
+            calls.delete(event.callId);
+            calls.set(event.callId, { ...event, text, reset: true });
+            while (calls.size > 8) {
+                const id = calls.keys().next().value;
+                if (id !== undefined)
+                    calls.delete(id);
+            }
+            projects.delete(event.projectId);
+            projects.set(event.projectId, calls);
+            while (projects.size > 16) {
+                const id = projects.keys().next().value;
+                if (id !== undefined)
+                    projects.delete(id);
+            }
+        },
+        snapshot: (projectId) => [...(projects.get(projectId)?.values() ?? [])],
+    };
+}

package/dist/edge/http/actions.js

@@ -9,6 +9,7 @@ import { changeProviders, pauseProject, resumeProject } from "../../slices/contr
 import { withProjectControl } from "../../slices/control/lock.js";
 import { providerChangesSchema } from "../../slices/control/providers.js";
 import { deleteImage, editArticle, regenerateImage, rerunStage, retryStage, } from "../../slices/reruns/index.js";
+import { allowsCustomModel } from "../../slices/settings/models.js";
 import { providerStatuses } from "../../slices/settings/readiness.js";
 import { outputsOf } from "../../slices/storage/repo.js";
 import { onInvalid, problem, titleOf } from "./problem.js";
@@ -79,6 +80,7 @@ export function actionRoutes(deps) {
         runner: deps.runner,
         emit: (projectId, event) => deps.hub.emit(projectId, event),
         providers: () => providerStatuses({ db: deps.db, probe: deps.probe }),
+        allowsCustomModels: allowsCustomModel,
         modelsFor: deps.modelsFor ?? (() => Promise.reject(new Error("Model catalog unavailable"))),
     };
     const view = (projectId) => {

package/dist/edge/http/app.js

@@ -3,15 +3,19 @@ import { serveStatic } from "@hono/node-server/serve-static";
 import { Hono } from "hono";
 import { streamSSE } from "hono/streaming";
 import { actionRoutes } from "./actions.js";
+import { audioPreviewRoutes } from "./audio-preview.js";
 import { entryRoutes } from "./entries.js";
 import { fileRoutes } from "./files.js";
+import { fontsRoutes } from "./fonts.js";
 import { problem, problemFromError, titleOf } from "./problem.js";
 import { projectRoutes } from "./projects.js";
 import { promptRoutes } from "./prompts.js";
 import { providerRoutes } from "./providers.js";
 import { settingsRoutes } from "./settings.js";
 import { stagingRoutes } from "./staging.js";
+import { subtitleRoutes } from "./subtitles.js";
 import { telemetryRoutes } from "./telemetry.js";
+import { updateRoutes } from "./update.js";
 import { usageRoutes } from "./usage.js";
 const notBuilt = "The Slopify UI is not built yet. The API is running: try /api/health.\n" +
     "Build the SPA with `npm run build` at the repository root.\n";
@@ -24,9 +28,13 @@ function apiRoutes(deps, startedAt) {
     }))
         .route("/staging", stagingRoutes(deps))
         .route("/projects", projectRoutes(deps))
+        .route("/projects", audioPreviewRoutes(deps))
+        .route("/update", updateRoutes(deps))
         // The re-run and cancel actions sit on the same prefix as the project itself; they
         // are their own router because they are their own concern.
         .route("/projects", actionRoutes(deps))
+        .route("/projects", subtitleRoutes(deps))
+        .route("/fonts", fontsRoutes(deps))
         .route("/prompts", promptRoutes(deps))
         .route("/entries", entryRoutes(deps))
         .route("/telemetry", telemetryRoutes(deps))
@@ -38,8 +46,29 @@ export function createApp(deps) {
     const startedAt = deps.clock.now().getTime();
     const app = new Hono()
         .use("*", async (c, next) => {
-        c.header("X-Slopify-Version", deps.version);
+        // A provisional candidate must not trigger the stale-tab Reload dialog.
+        if (!deps.updater?.locked())
+            c.header("X-Slopify-Version", deps.version);
         await next();
+    })
+        .use("/api/*", async (c, next) => {
+        if (deps.updater === undefined ||
+            ["GET", "HEAD", "OPTIONS"].includes(c.req.method) ||
+            ["/api/update", "/api/update/", "/api/update/activate", "/api/update/activate/"].includes(c.req.path))
+            return next();
+        const release = deps.updater.beginMutation();
+        if (release === undefined)
+            return problem(c, {
+                status: 409,
+                title: titleOf(409),
+                detail: "Slopify is updating. Wait for it to restart before making changes.",
+            });
+        try {
+            await next();
+        }
+        finally {
+            release();
+        }
     })
         .onError((error, c) => problemFromError(c, error, deps))
         .notFound(missing)

package/dist/edge/http/audio-preview.js

@@ -0,0 +1,46 @@
+import { zValidator } from "@hono/zod-validator";
+import { Hono } from "hono";
+import { z } from "zod";
+import { projectTitle } from "../../slices/storage/repo.js";
+import { onInvalid, problem, titleOf } from "./problem.js";
+const projectParam = z.object({
+    projectId: z
+        .string()
+        .min(1)
+        .max(64)
+        .regex(/^[0-9A-Za-z_-]+$/),
+});
+const previewParam = projectParam.extend({ previewId: z.uuid() });
+export function audioPreviewRoutes(deps) {
+    return new Hono()
+        .get("/:projectId/audio-preview", zValidator("param", projectParam, onInvalid), (c) => {
+        const { projectId } = c.req.valid("param");
+        if (projectTitle(deps.db, projectId) === undefined)
+            return missing(c);
+        c.header("Cache-Control", "no-store");
+        return c.json({ previews: deps.audioPreviews?.list(projectId) ?? [] });
+    })
+        .get("/:projectId/audio-preview/:previewId", zValidator("param", previewParam, onInvalid), (c) => {
+        const { projectId, previewId } = c.req.valid("param");
+        if (projectTitle(deps.db, projectId) === undefined)
+            return missing(c);
+        const stream = deps.audioPreviews?.stream(projectId, previewId, c.req.raw.signal);
+        if (stream === undefined)
+            return missing(c);
+        // A growing MP3 has no final length or seek range. A native audio element
+        // can consume it progressively; late listeners receive the retained prefix.
+        return c.body(stream, 200, {
+            "Content-Type": "audio/mpeg",
+            "Cache-Control": "no-store",
+            "Accept-Ranges": "none",
+            "X-Content-Type-Options": "nosniff",
+        });
+    });
+}
+function missing(c) {
+    return problem(c, {
+        status: 404,
+        title: titleOf(404),
+        detail: "This live audio preview is no longer available. Finished narration is available in the audio outputs.",
+    });
+}