@gentbajko/slopify 0.1.0

package/dist/kernel/ports/model.js

@@ -0,0 +1,34 @@
+// The vocabulary that crosses the provider seam. Domain types only: a vendor's payload
+// shape never leaves its adapter (01-architecture §Q10, §Q33).
+export const providerFamilies = ["llm", "tts", "image"];
+export const providerErrorKinds = [
+    "auth",
+    // Distinct from `auth`, which is a key the provider rejected. `logic/02` §Q13 splits
+    // them: a bad key runs the whole retry policy (§Q11) and an absent one "fails
+    // immediately, without retries", so the wrapper needs two kinds to tell apart.
+    "missing_key",
+    "rate_limit",
+    "refusal",
+    "unsupported",
+    "timeout",
+    "other",
+];
+export function providerError(init) {
+    return Object.assign(new Error(init.message), {
+        fault: {
+            kind: init.kind,
+            ...(init.retryAfterMs === undefined ? {} : { retryAfterMs: init.retryAfterMs }),
+        },
+    });
+}
+export function isProviderError(value) {
+    if (!(value instanceof Error) || !("fault" in value)) {
+        return false;
+    }
+    const fault = value.fault;
+    if (typeof fault !== "object" || fault === null || !("kind" in fault)) {
+        return false;
+    }
+    const kinds = providerErrorKinds;
+    return typeof fault.kind === "string" && kinds.includes(fault.kind);
+}

package/dist/kernel/ports/registry.js

@@ -0,0 +1 @@
+export {};

package/dist/kernel/ports/tts.js

@@ -0,0 +1 @@
+export {};

package/dist/kernel/runner/attempt-repo.js

@@ -0,0 +1,50 @@
+import { z } from "zod";
+import { providerErrorKinds } from "../ports/model.js";
+// One row per provider call attempt (02-models, `logic/01` §Q4). The project page reads
+// the last error text off these rows and the Usage page counts them, so an attempt is
+// written when it opens rather than when it ends: a process that dies mid-call leaves
+// the evidence behind (`logic/01` §Q7).
+export const attemptOutcomes = ["ok", "canceled", ...providerErrorKinds];
+const attemptRow = z.object({
+    id: z.string(),
+    stage_id: z.string(),
+    piece_id: z.string().nullable(),
+    n: z.number(),
+    started_at: z.string(),
+    ended_at: z.string().nullable(),
+    outcome: z.enum(attemptOutcomes).nullable(),
+    error_text: z.string().nullable(),
+});
+export function sqliteAttempts(db, ids) {
+    return {
+        start: (attempt) => {
+            const id = ids.next();
+            db.prepare("INSERT INTO attempts (id, stage_id, piece_id, n, started_at) VALUES (?, ?, ?, ?, ?)").run(id, attempt.stageId, attempt.pieceId, attempt.n, attempt.startedAt);
+            // `logic/01` §Q3: the stage shows the attempt count beside the error. A stage with
+            // pieces (twenty images) shows the count of the call being attempted, not a sum.
+            db.prepare("UPDATE stages SET attempt_count = ? WHERE id = ?").run(attempt.n, attempt.stageId);
+            return id;
+        },
+        end: (id, ended) => {
+            db.prepare("UPDATE attempts SET ended_at = ?, outcome = ?, error_text = ? WHERE id = ?").run(ended.endedAt, ended.outcome, ended.errorText, id);
+        },
+    };
+}
+export function attemptsOf(db, stageId) {
+    return db
+        .prepare("SELECT * FROM attempts WHERE stage_id = ? ORDER BY rowid")
+        .all(stageId)
+        .map((row) => toAttempt(attemptRow.parse(row)));
+}
+function toAttempt(row) {
+    return {
+        id: row.id,
+        stageId: row.stage_id,
+        pieceId: row.piece_id,
+        n: row.n,
+        startedAt: row.started_at,
+        endedAt: row.ended_at,
+        outcome: row.outcome,
+        errorText: row.error_text,
+    };
+}

package/dist/kernel/runner/attempt.js

@@ -0,0 +1,146 @@
+import { redact } from "../log.js";
+import { isProviderError, providerError } from "../ports/model.js";
+// The retry policy of `logic/01` step 6, in one place. Every provider call in the app
+// goes through here: a stage slice is handed the wrapped calls of `providers.ts` and
+// never an adapter, so there is no way round it.
+// "attempted up to 4 times: the first attempt plus 3 retries, waiting 2 s, 8 s, 30 s
+// between attempts" (`logic/01` step 6, §Q4).
+export const attemptLimit = 4;
+export const backoffMs = [2000, 8000, 30_000];
+// "each attempt times out at 120 s ... except image-generation calls, which time out at
+// 300 s" (`logic/01` step 6, §Q62; `logic/09` §Q77).
+export const timeoutMs = {
+    llm: 120_000,
+    tts: 120_000,
+    image: 300_000,
+};
+// `logic/09` §Q74 and `logic/06` §Q47: a refusal and an unsupported capability are the
+// provider's final answer. Retrying either would only spend the user's money again.
+// `logic/02` §Q13 adds the third: a key removed mid-run leaves nothing to call with, so
+// "the next attempt finds no key, fails immediately without retries" - unlike a key the
+// provider rejected, which is an `auth` failure and is retried like any other (§Q11).
+const terminalKinds = ["refusal", "unsupported", "missing_key"];
+export async function attempt(ctx, call, opts) {
+    ctx.signal.throwIfAborted();
+    const limit = timeoutMs[opts.kind];
+    for (let n = 1;; n += 1) {
+        const id = ctx.attempts.start({
+            stageId: ctx.stageId,
+            pieceId: ctx.pieceId ?? null,
+            n,
+            startedAt: ctx.clock.now().toISOString(),
+        });
+        const window = deadline(ctx.clock, ctx.signal, limit, opts.streaming === true);
+        let result;
+        try {
+            result = { ok: true, value: await call(window.signal, window.progress) };
+        }
+        catch (error) {
+            result = { ok: false, at: error };
+        }
+        const expired = window.expired();
+        window.dispose();
+        if (result.ok) {
+            ctx.attempts.end(id, {
+                outcome: "ok",
+                endedAt: ctx.clock.now().toISOString(),
+                errorText: null,
+            });
+            return result.value;
+        }
+        if (ctx.signal.aborted) {
+            // `logic/13` §Q112: an aborted call counts nothing. The row is closed so the page
+            // is not left with an attempt that never ended, and it carries no error text: the
+            // user stopped it, the provider did not fail.
+            ctx.attempts.end(id, {
+                outcome: "canceled",
+                endedAt: ctx.clock.now().toISOString(),
+                errorText: null,
+            });
+            throw result.at;
+        }
+        const failure = classify(result.at, expired, opts, limit);
+        ctx.attempts.end(id, {
+            outcome: failure.fault.kind,
+            endedAt: ctx.clock.now().toISOString(),
+            errorText: failure.message,
+        });
+        ctx.log.write("warn", "provider.attempt", {
+            projectId: ctx.projectId,
+            stage: ctx.stage,
+            detail: `${opts.kind} attempt ${n} of ${attemptLimit} failed (${failure.fault.kind}): ${failure.message}`,
+        });
+        if (terminalKinds.includes(failure.fault.kind) || n >= attemptLimit) {
+            throw failure;
+        }
+        // §Q4: a 429 that names a Retry-After replaces the fixed wait with the provider's.
+        await ctx.clock.sleep(failure.fault.retryAfterMs ?? backoffMs[n - 1] ?? 0, ctx.signal);
+    }
+}
+// The wrapper is the only place a provider failure is named (03-standards). Everything
+// downstream reads `fault.kind` and shows `message`.
+function classify(error, expired, opts, limit) {
+    if (expired) {
+        const seconds = Math.round(limit / 1000);
+        return providerError({
+            kind: "timeout",
+            message: opts.streaming === true
+                ? `the provider sent nothing for ${seconds} s`
+                : `the provider did not answer within ${seconds} s`,
+        });
+    }
+    if (isProviderError(error)) {
+        // Rebuilt rather than rethrown so the text that reaches the stage row, the page and
+        // the log has been through the redactor: a provider is free to quote the key back.
+        return providerError({
+            kind: error.fault.kind,
+            message: redact(error.message),
+            ...(error.fault.retryAfterMs === undefined ? {} : { retryAfterMs: error.fault.retryAfterMs }),
+        });
+    }
+    return providerError({
+        kind: "other",
+        message: redact(error instanceof Error ? error.message : String(error)),
+    });
+}
+// `logic/01` §Q62: the same number of milliseconds, measured two ways. `idle` restarts
+// the count on every chunk, so a long answer that keeps arriving is never cut off, and a
+// stream that stalls is. Composed with AbortSignal.any so the stage's cancel still wins.
+function deadline(clock, parent, ms, idle) {
+    const timer = new AbortController();
+    const signal = AbortSignal.any([parent, timer.signal]);
+    let due = clock.now().getTime() + ms;
+    let expired = false;
+    let disposed = false;
+    const watch = async () => {
+        while (!disposed) {
+            const left = due - clock.now().getTime();
+            if (left <= 0) {
+                expired = true;
+                timer.abort(new Error(`the provider call passed its ${Math.round(ms / 1000)} s limit`));
+                return;
+            }
+            try {
+                await clock.sleep(left, timer.signal);
+            }
+            catch {
+                // Disposed, or the call already ended: nothing left to time.
+                return;
+            }
+        }
+    };
+    void watch();
+    return {
+        signal,
+        progress: () => {
+            if (idle) {
+                due = clock.now().getTime() + ms;
+            }
+        },
+        expired: () => expired,
+        dispose: () => {
+            disposed = true;
+            timer.abort();
+        },
+    };
+}

package/dist/kernel/runner/graph.js

@@ -0,0 +1,82 @@
+// logic/01 steps 2-5: research → article → {audio ∥ images ∥ thumbnail} → video.
+export const deps = {
+    research: [],
+    article: ["research"],
+    audio: ["article"],
+    images: ["article"],
+    thumbnail: ["article"],
+    video: ["audio", "images", "thumbnail"],
+};
+// logic/01 §Q2: a dependency is released by `provided` and `skipped` exactly as by `done`.
+export function satisfied(state) {
+    return state === "done" || state === "provided" || state === "skipped";
+}
+// logic/01 §Q9, in its order. Derived on every read, never stored.
+export function derive(stages) {
+    if (stages.some((stage) => stage.state === "running")) {
+        return "running";
+    }
+    if (stages.some((stage) => stage.state === "canceled")) {
+        return "canceled";
+    }
+    if (stages.some((stage) => stage.state === "failed")) {
+        return "failed";
+    }
+    if (stages.some((stage) => stage.kind === "video" && stage.state === "done")) {
+        return "done";
+    }
+    // Extended rule, not one of §Q9's four. §Q9 offers no answer for a project that matches
+    // none of them, and `pending` was chosen for the window between creating a project and
+    // the runner claiming its first stage. `logic/13` §Q113 makes a second case reachable:
+    // when the only running stage stores its output in the same instant as the cancel it
+    // stays `done`, so nothing is `canceled` and a run the user stopped would read as one
+    // about to start. `logic/13` step 3 is unconditional - "the project reads `canceled`" -
+    // so that is what a run which started and stopped reads here.
+    //
+    // A stage in a terminal state is what tells the two apart: at creation every stage is
+    // `pending`, `provided` or `skipped`, and only a stage the runner carried to the end is
+    // `done`. Nothing restarts such a project by itself (§Q111), so `pending` is the one
+    // answer that is certainly wrong.
+    //
+    // ceiling: a process killed between a stage finishing and its dependent being claimed
+    // leaves the same rows and reads `canceled` too - `logic/01` §Q7 only reaches a stage
+    // found `running`. Telling that apart needs the cancel recorded on the project, which is
+    // the upgrade if it ever matters; §Q9 keeps status derived and stores nothing.
+    if (stages.some((stage) => stage.state === "done")) {
+        return "canceled";
+    }
+    return "pending";
+}
+// The thin meter under a running row on 07 Projects, "averaging stage progress"
+// (uiux/screens/07-projects.md). Every stage the run actually asks for counts once: a
+// finished one whole, a running one by its own progress, a waiting, failed or canceled
+// one not at all.
+//
+// `provided` and `skipped` are left out of the average rather than counted as finished.
+// Nothing was asked of them, and counting them would put a run with research off and a
+// supplied article at a third of the way along before the first call was made.
+export function progressOf(stages) {
+    const asked = stages.filter((stage) => stage.state !== "provided" && stage.state !== "skipped");
+    // A run made entirely of supplied files has nothing outstanding, and a division by zero
+    // would answer NaN.
+    if (asked.length === 0) {
+        return 1;
+    }
+    const share = asked.reduce((total, stage) => total + shareOf(stage), 0);
+    return share / asked.length;
+}
+function shareOf(stage) {
+    if (satisfied(stage.state)) {
+        return 1;
+    }
+    if (stage.state !== "running") {
+        return 0;
+    }
+    const total = stage.progressTotal ?? 0;
+    if (total <= 0) {
+        // A stage that has not yet said how many chapters or chunks there are. Guessing would
+        // be a meter that moves backwards when the count arrives.
+        return 0;
+    }
+    return Math.min(1, Math.max(0, (stage.progressCurrent ?? 0) / total));
+}

package/dist/kernel/runner/index.js

@@ -0,0 +1,205 @@
+import { derive, deps as graph, satisfied } from "./graph.js";
+export function createRunner(deps) {
+    const inflight = new Map();
+    // ceiling: one entry per project ticked since boot, never evicted, so it costs a few
+    // dozen bytes per project of a single user's local app and is emptied by any restart.
+    // Evicting on a terminal state would re-announce that state on the next tick of the
+    // same project, so the upgrade is to drop the entry when the project is deleted.
+    const announced = new Map();
+    // The projects a cancel is walking through. It is a set rather than a flag because
+    // `logic/13` D14 leaves every other project untouched, and it is held for the whole of
+    // abortProject rather than for the abort call alone: a stage of this project that
+    // stores its output in the same instant as the cancel stays `done` (§Q113), and its
+    // hand-over to the next stage is exactly what must not happen.
+    const stopped = new Set();
+    let count = 0;
+    let shuttingDown = false;
+    const emitStage = (stage, state, reason) => {
+        deps.emit(stage.projectId, {
+            type: "stage.state",
+            projectId: stage.projectId,
+            stage: stage.kind,
+            state,
+            ...(reason === null ? {} : { failureReason: reason }),
+        });
+    };
+    // The global tally is the number of projects with a stage in flight, so it is read off
+    // the in-flight set rather than counted in the database (04-data-flow, Run step 5).
+    const retally = () => {
+        const projects = new Set();
+        for (const entry of inflight.values()) {
+            projects.add(entry.projectId);
+        }
+        if (projects.size !== count) {
+            count = projects.size;
+            deps.emitRunningCount(count);
+        }
+    };
+    const announce = (projectId) => {
+        const state = derive(deps.stages.stagesOf(projectId));
+        if (announced.get(projectId) === state) {
+            return;
+        }
+        announced.set(projectId, state);
+        deps.emit(projectId, { type: "project.state", projectId, state });
+    };
+    const conclude = (stage, state, reason) => {
+        try {
+            deps.stages.finish(stage.id, state, reason);
+        }
+        catch (error) {
+            // The page would otherwise sit on a stage that never leaves `running`; the event
+            // still goes out, and the next boot marks the row interrupted (logic/01 §Q7).
+            deps.log.write("error", "stage.finish", {
+                projectId: stage.projectId,
+                stage: stage.kind,
+                detail: reasonOf(error),
+            });
+        }
+        emitStage(stage, state, reason);
+    };
+    async function execute(stage, controller) {
+        try {
+            const run = deps.runs[stage.kind];
+            if (run === undefined) {
+                throw new Error(`no implementation is registered for the ${stage.kind} stage`);
+            }
+            await run({
+                stage,
+                signal: controller.signal,
+                emit: (event) => {
+                    deps.emit(stage.projectId, event);
+                },
+            });
+            conclude(stage, "done", null);
+        }
+        catch (error) {
+            if (controller.signal.aborted) {
+                // logic/13 step 3 fixes the wording; a late rejection from the aborted call is
+                // the expected way a stage learns it was canceled, so it is not logged as a fault.
+                conclude(stage, "canceled", "canceled by user");
+                return;
+            }
+            deps.log.write("error", "stage.failed", {
+                projectId: stage.projectId,
+                stage: stage.kind,
+                detail: reasonOf(error),
+            });
+            conclude(stage, "failed", reasonOf(error));
+        }
+    }
+    function start(stage) {
+        const controller = new AbortController();
+        let release = () => { };
+        const entry = {
+            projectId: stage.projectId,
+            controller,
+            settled: new Promise((resolve) => {
+                release = resolve;
+            }),
+        };
+        // Registered before the stage body is invoked: a tick arriving while this stage is
+        // starting has to see it in flight.
+        inflight.set(stage.id, entry);
+        retally();
+        emitStage(stage, "running", null);
+        void execute(stage, controller)
+            .finally(() => {
+            inflight.delete(stage.id);
+            release();
+            try {
+                // The next stage is claimed before the tally is read, so a fan-out handing over
+                // to the video stage never reports the project as briefly not running.
+                tick(stage.projectId);
+            }
+            finally {
+                // stagesOf parses rows and can throw. The tally is replayed to every page that
+                // opens afterwards, so it is read whether or not the tick got that far.
+                retally();
+            }
+        })
+            .catch((error) => {
+            deps.log.write("error", "stage.execute", {
+                projectId: stage.projectId,
+                stage: stage.kind,
+                detail: reasonOf(error),
+            });
+        });
+    }
+    function tick(projectId) {
+        // A stage that finished in the same instant as the shutdown or a cancel would
+        // otherwise release its dependent, and the abort would then be waiting on a render
+        // nobody asked for - or, worse, leaving one running under a controller nobody
+        // aborted. The project's state still goes out, so an open page sees the run stop.
+        if (!shuttingDown && !stopped.has(projectId)) {
+            startEligible(projectId);
+        }
+        announce(projectId);
+    }
+    function startEligible(projectId) {
+        const stages = deps.stages.stagesOf(projectId);
+        const stateOf = (kind) => stages.find((stage) => stage.kind === kind)?.state ?? "pending";
+        for (const stage of stages) {
+            if (stage.state !== "pending" || inflight.has(stage.id)) {
+                continue;
+            }
+            if (!graph[stage.kind].every((kind) => satisfied(stateOf(kind)))) {
+                continue;
+            }
+            // Nothing is awaited in this loop, so the fan-out after the article starts audio,
+            // images and thumbnail together rather than one after another.
+            if (deps.stages.claim(stage.id)) {
+                start({ ...stage, state: "running" });
+            }
+        }
+    }
+    async function settled() {
+        while (inflight.size > 0) {
+            await Promise.all([...inflight.values()].map((entry) => entry.settled));
+        }
+    }
+    async function settledOf(projectId) {
+        for (;;) {
+            const waiting = [...inflight.values()].filter((entry) => entry.projectId === projectId);
+            if (waiting.length === 0) {
+                return;
+            }
+            await Promise.all(waiting.map((entry) => entry.settled));
+        }
+    }
+    return {
+        tick,
+        settled,
+        abortProject: async (projectId) => {
+            // Up before the first abort and down only once every stage of the project has
+            // stopped: in between, the tick each finishing stage fires starts nothing.
+            stopped.add(projectId);
+            try {
+                for (const entry of inflight.values()) {
+                    if (entry.projectId === projectId) {
+                        entry.controller.abort();
+                    }
+                }
+                // §Q109's invariant: "no provider call of the project continues after cancel
+                // returns". Waiting here is what makes that true rather than hoped for.
+                await settledOf(projectId);
+            }
+            finally {
+                stopped.delete(projectId);
+            }
+            // The last stage's own tick announced the project while the barrier was up and the
+            // rows may not all have been written yet; this is the state the user asked for.
+            announce(projectId);
+        },
+        abortAll: async () => {
+            shuttingDown = true;
+            for (const entry of inflight.values()) {
+                entry.controller.abort();
+            }
+            await settled();
+        },
+    };
+}
+function reasonOf(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/kernel/runner/piece-repo.js

@@ -0,0 +1,58 @@
+import { z } from "zod";
+// One row per resumable sub-unit of a stage (02-models, `stage_pieces`): a research
+// chapter, an audio chunk, an image index. It sits beside the attempt store because the
+// attempt wrapper stamps `piece_id` on every row it writes and the kernel may not import
+// the slices that fill these in. The payload is carried as the JSON text it is stored
+// as: its shape belongs to whichever stage owns the kind, and nothing here reads inside.
+export const pieceKinds = ["chapter", "chunk", "segment", "image", "prompt_written"];
+export const pieceStates = ["pending", "running", "done", "failed"];
+const pieceRow = z.object({
+    id: z.string(),
+    stage_id: z.string(),
+    kind: z.enum(pieceKinds),
+    idx: z.number(),
+    state: z.enum(pieceStates),
+    payload: z.string().nullable(),
+});
+export function insertPiece(db, piece) {
+    db.prepare("INSERT INTO stage_pieces (id, stage_id, kind, idx, state, payload) VALUES (?, ?, ?, ?, ?, ?)").run(piece.id, piece.stageId, piece.kind, piece.idx, piece.state, piece.payload);
+}
+// In `idx` order: the resume of `logic/06` §Q54 re-runs the pieces a previous attempt did
+// not finish and keeps the rest, and the order they were planned in is the order the
+// stage's output is assembled in.
+export function piecesOf(db, stageId, kind) {
+    return db
+        .prepare("SELECT * FROM stage_pieces WHERE stage_id = ? AND kind = ? ORDER BY idx")
+        .all(stageId, kind)
+        .map((row) => toPiece(pieceRow.parse(row)));
+}
+// Every piece of a stage whatever its kind, for the one caller that does not care: a
+// re-run throws the whole plan away, because the text a chunk was cut from and the prompt
+// an image was sent with are what changed (`logic/12` §Q101, §Q104).
+export function allPiecesOf(db, stageId) {
+    return db
+        .prepare("SELECT * FROM stage_pieces WHERE stage_id = ? ORDER BY kind, idx")
+        .all(stageId)
+        .map((row) => toPiece(pieceRow.parse(row)));
+}
+export function deletePieces(db, stageId) {
+    db.prepare("DELETE FROM stage_pieces WHERE stage_id = ?").run(stageId);
+}
+// One piece, for `logic/09` §Q75: an image the user deleted leaves no row behind, or the
+// next run of the stage would look at the plan and make it again.
+export function deletePiece(db, id) {
+    db.prepare("DELETE FROM stage_pieces WHERE id = ?").run(id);
+}
+export function setPiece(db, id, state, payload) {
+    db.prepare("UPDATE stage_pieces SET state = ?, payload = ? WHERE id = ?").run(state, payload, id);
+}
+function toPiece(row) {
+    return {
+        id: row.id,
+        stageId: row.stage_id,
+        kind: row.kind,
+        idx: row.idx,
+        state: row.state,
+        payload: row.payload,
+    };
+}

package/dist/kernel/runner/providers.js

@@ -0,0 +1,92 @@
+import { attempt } from "./attempt.js";
+export function stageProviders(deps, context, pieceId) {
+    const ctx = {
+        clock: deps.clock,
+        log: deps.log,
+        attempts: deps.attempts,
+        projectId: context.stage.projectId,
+        stage: context.stage.kind,
+        stageId: context.stage.id,
+        ...(pieceId === undefined ? {} : { pieceId }),
+        signal: context.signal,
+    };
+    return {
+        llm: (call, onEvent) => {
+            // Resolved once: an adapter reads the stored key when it builds each request, so a
+            // key replaced mid-run still reaches the next attempt (`logic/02` §Q16).
+            const port = deps.registry.llm(call.provider);
+            return attempt(ctx, async (signal, progress) => {
+                let text = "";
+                let usage = null;
+                let finishReason = null;
+                for await (const event of port.complete({
+                    model: call.model,
+                    messages: call.messages,
+                    ...(call.webSearch === undefined ? {} : { webSearch: call.webSearch }),
+                    signal,
+                })) {
+                    // Every event is a sign of life, so the idle clock restarts here rather than
+                    // in each slice that consumes one.
+                    progress();
+                    if (event.type === "delta") {
+                        text += event.text;
+                    }
+                    else {
+                        usage = event.usage;
+                        finishReason = event.finishReason;
+                    }
+                    onEvent?.(event);
+                }
+                const answer = { text, usage, finishReason };
+                const unusable = call.check?.(answer);
+                if (unusable !== undefined) {
+                    // Thrown bare: the wrapper is the one place a failure is named, and it names
+                    // this `other`, which is retried like any other bad answer.
+                    throw new Error(unusable);
+                }
+                return answer;
+            }, { kind: "llm", streaming: port.capabilities.streams });
+        },
+        tts: (call) => {
+            const port = deps.registry.tts(call.provider);
+            return attempt(ctx, async (signal, progress) => {
+                const spoken = await port.synthesize({
+                    voiceId: call.voiceId,
+                    text: call.text,
+                    signal,
+                });
+                const reader = spoken.audio.getReader();
+                const chunks = [];
+                let total = 0;
+                for (;;) {
+                    const { done, value } = await reader.read();
+                    if (done || value === undefined) {
+                        break;
+                    }
+                    progress();
+                    chunks.push(value);
+                    total += value.length;
+                }
+                const bytes = new Uint8Array(total);
+                let at = 0;
+                for (const chunk of chunks) {
+                    bytes.set(chunk, at);
+                    at += chunk.length;
+                }
+                return { bytes, container: spoken.container };
+            }, { kind: "tts", streaming: port.capabilities.streams });
+        },
+        image: (call) => {
+            const port = deps.registry.image(call.provider);
+            return attempt(ctx, (signal) => port.generate({
+                model: call.model,
+                prompt: call.prompt,
+                aspect: call.aspect,
+                signal,
+            }), 
+            // One request, one answer: the 300 s runs over the whole call (`logic/09` §Q77).
+            { kind: "image" });
+        },
+        forPiece: (piece) => stageProviders(deps, context, piece),
+    };
+}