@gentbajko/slopify 3.25.8 → 4.0.0

package/dist/web/index.html

@@ -6,8 +6,8 @@
     <meta name="viewport" content="width=device-width, initial-scale=1" />
     <meta name="color-scheme" content="dark light" />
     <title>Slopify</title>
-    <script type="module" crossorigin src="/assets/index-D8LqNsCl.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-BadsoORk.css">
+    <script type="module" crossorigin src="/assets/index-DcD0cdfo.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-CkAI_2E7.css">
   </head>
   <body>
     <div id="root"></div>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gentbajko/slopify",
-  "version": "3.25.8",
+  "version": "4.0.0",
   "description": "Turn a prompt into a finished video, locally, with your own provider keys",
   "license": "Apache-2.0",
   "author": "Gent Bajko",
@@ -45,5 +45,9 @@
     "ulid": "^3.0.2",
     "yaml": "^2.9.1",
     "zod": "^4.5.4"
+  },
+  "devDependencies": {
+    "@types/mdast": "^4.0.4",
+    "esbuild": "^0.28.1"
   }
 }

package/dist/slices/article/provided-entries.js

@@ -1,66 +0,0 @@
-import { readFileSync } from "node:fs";
-import { piecesOf } from "../../kernel/runner/piece-repo.js";
-import { projectById, stagesOf } from "../admission/repo.js";
-import { outputPath } from "../storage/layout.js";
-import { outputsOf } from "../storage/repo.js";
-import { storeText } from "../storage/staging.js";
-import { categories, instructionsText, keepSegment, writeSegment } from "./segments.js";
-// A provided Article never runs its writer. Prepare its selected entries as part
-// of Audio's cancellable work, retaining Article ownership of the resulting text.
-export async function prepareProvidedArticleSegments(deps, audioContext, providers) {
-    const { projectId } = audioContext.stage;
-    const project = projectById(deps.db, projectId);
-    if (!project)
-        throw new Error("This project no longer exists; it may have been deleted while it was running.");
-    const { config } = project;
-    if (config.sources.article !== "provide" || config.sources.audio !== "generate")
-        return "done";
-    if (!config.intro && !config.outro)
-        return "done";
-    audioContext.signal.throwIfAborted();
-    const article = stagesOf(deps.db, projectId).find((stage) => stage.kind === "article");
-    if (!article)
-        throw new Error("Slopify hit an internal error (the project has no article stage). Try again; if it happens again, use Download diagnostics in Settings and report it.");
-    const outputs = outputsOf(deps.db, projectId);
-    const plain = outputs.find((output) => output.role === "article_txt");
-    if (!plain)
-        throw new Error("The article text you provided is missing, so the intro and outro can't be written from it. Paste the article again in Edit project → Article, then Try again.");
-    const narration = readFileSync(outputPath(deps.paths, projectId, plain.path), "utf8");
-    const saved = outputs.find((output) => output.stageKind === "article" && output.role === "instructions");
-    let instructions = saved
-        ? readFileSync(outputPath(deps.paths, projectId, saved.path), "utf8")
-        : "";
-    const completed = piecesOf(deps.db, article.id, "segment");
-    for (const [index, category] of categories.entries()) {
-        audioContext.signal.throwIfAborted();
-        if (completed.some((piece) => piece.idx === index + 1 && piece.state === "done"))
-            continue;
-        const sent = [];
-        const result = await writeSegment(providers, config.llm, config, category, narration, sent);
-        audioContext.signal.throwIfAborted();
-        if (!result.ok)
-            return "held";
-        const segment = result.value;
-        if (!segment)
-            continue;
-        if (sent.length > 0) {
-            instructions += `${instructions === "" ? "" : "\n"}${instructionsText(sent)}`;
-            storeText(deps, {
-                projectId,
-                stageKind: "article",
-                role: "instructions",
-                text: instructions,
-            });
-        }
-        keepSegment(deps, { stage: article }, segment, index + 1);
-        deps.count("stage.completed", {
-            stage: "article",
-            segment: category,
-            ...(segment.mode === "llm" && config.llm
-                ? { provider: config.llm.provider, model: config.llm.model }
-                : {}),
-            ...segment.tokens,
-        });
-    }
-    return "done";
-}

package/dist/slices/article/run.js

@@ -1,145 +0,0 @@
-import { existsSync, readFileSync } from "node:fs";
-import { z } from "zod";
-import { messageRoles } from "../../kernel/ports/llm.js";
-import { insertPiece, piecesOf, setPiece } from "../../kernel/runner/piece-repo.js";
-import { projectById } from "../admission/repo.js";
-import { withEarlierEpisodes } from "../episodes/related.js";
-import { outputPath } from "../storage/layout.js";
-import { outputsOf } from "../storage/repo.js";
-import { storeText } from "../storage/staging.js";
-import { writeArticle } from "./continuation.js";
-import { categories, instructionsText, keepSegment, writeSegment } from "./segments.js";
-import { storeArticleText } from "./store.js";
-export async function runArticle(deps, context, providers) {
-    const { projectId } = context.stage;
-    const project = projectById(deps.db, projectId);
-    if (project === undefined) {
-        throw new Error("This project no longer exists; it may have been deleted while it was running.");
-    }
-    const choice = project.config.llm;
-    const articlePrompt = project.config.rendered.article;
-    if (choice === undefined || articlePrompt === undefined) {
-        // Admission refuses a run whose article is Generate without both, so
-        // reaching here is a bug in admission rather than something the user did.
-        throw new Error("No AI model or article prompt is set for writing the article. Choose a model in Edit project → Providers and check Edit project → Prompts, then Try again.");
-    }
-    const notes = researchNotes(deps, projectId);
-    const brief = {
-        articlePrompt: withEarlierEpisodes(articlePrompt, project.config.earlierEpisodes),
-        ...(notes === undefined ? {} : { notes }),
-    };
-    const result = await articleBody(deps, context, providers, choice, brief);
-    if (!result.ok)
-        return "held";
-    const completed = result.value;
-    const { narration } = completed;
-    const sent = [...completed.sent];
-    for (const [index, category] of categories.entries()) {
-        if (project.config.sources.audio !== "generate")
-            break;
-        if (completed.resumed &&
-            piecesOf(deps.db, context.stage.id, "segment").some((piece) => piece.idx === index + 1 && piece.state === "done"))
-            continue;
-        const result = await writeSegment(providers, choice, project.config, category, narration, sent);
-        if (!result.ok)
-            return "held";
-        const segment = result.value;
-        if (segment !== undefined) {
-            keepSegment(deps, context, segment, index + 1);
-            checkpointArticle(deps, context, sent);
-            // One event per intro/outro text, named by its segment. A text-mode entry is
-            // rendered rather than written, so it made no call, names no provider and reports
-            // zero tokens rather than an estimate.
-            deps.count("stage.completed", {
-                stage: "article",
-                segment: category,
-                ...(segment.mode === "llm" ? { provider: choice.provider, model: choice.model } : {}),
-                ...segment.tokens,
-            });
-        }
-    }
-    // The exact messages sent, the continuations and the entry calls among them.
-    storeText(deps, {
-        projectId,
-        stageKind: "article",
-        role: "instructions",
-        text: instructionsText(sent),
-    });
-    deps.log.write("info", "article.done", {
-        projectId,
-        stage: "article",
-        detail: `${String(narration.length)} characters to narrate`,
-    });
-    return "done";
-}
-// Once the article is stored, a pause during end matter resumes that end matter
-// instead of buying and replacing the article again. Re-run clears this checkpoint.
-const articleCheckpoint = z.object({
-    sent: z.array(z.object({
-        label: z.string(),
-        messages: z.array(z.object({ role: z.enum(messageRoles), content: z.string() })),
-    })),
-});
-async function articleBody(deps, context, providers, choice, brief) {
-    const { projectId } = context.stage;
-    const saved = piecesOf(deps.db, context.stage.id, "article_written")[0];
-    const outputs = outputsOf(deps.db, projectId);
-    const plain = outputs.find((output) => output.role === "article_txt");
-    const markdown = outputs.find((output) => output.role === "article_md");
-    if (saved?.payload !== null &&
-        saved?.payload !== undefined &&
-        plain &&
-        markdown &&
-        existsSync(outputPath(deps.paths, projectId, plain.path)) &&
-        existsSync(outputPath(deps.paths, projectId, markdown.path))) {
-        return {
-            ok: true,
-            value: {
-                narration: readFileSync(outputPath(deps.paths, projectId, plain.path), "utf8"),
-                sent: articleCheckpoint.parse(JSON.parse(saved.payload)).sent,
-                resumed: true,
-            },
-        };
-    }
-    const result = await writeArticle(providers, choice, brief, (text) => {
-        context.emit({ type: "article.delta", projectId, text });
-    });
-    if (!result.ok)
-        return result;
-    const written = result.value;
-    storeText(deps, { projectId, stageKind: "article", role: "article_md", text: written.markdown });
-    const narration = storeArticleText(deps, { projectId, markdown: written.markdown });
-    checkpointArticle(deps, context, written.sent);
-    deps.count("stage.completed", {
-        stage: "article",
-        provider: choice.provider,
-        model: choice.model,
-        ...written.tokens,
-    });
-    return { ok: true, value: { narration, sent: written.sent, resumed: false } };
-}
-function checkpointArticle(deps, context, sent) {
-    const existing = piecesOf(deps.db, context.stage.id, "article_written")[0];
-    const payload = JSON.stringify({ sent });
-    if (existing)
-        setPiece(deps.db, existing.id, "done", payload);
-    else
-        insertPiece(deps.db, {
-            id: deps.ids.next(),
-            stageId: context.stage.id,
-            kind: "article_written",
-            idx: 1,
-            state: "done",
-            payload,
-        });
-}
-// Research writes its notes as an output of its own, and a provided research stage stores the
-// pasted text the same way, so one lookup covers both. No row means research was Off or
-// skipped, and the article is written from the prompt alone.
-function researchNotes(deps, projectId) {
-    const notes = outputsOf(deps.db, projectId).find((output) => output.role === "notes");
-    if (notes === undefined) {
-        return undefined;
-    }
-    return readFileSync(outputPath(deps.paths, projectId, notes.path), "utf8");
-}

package/dist/slices/images/run.js

@@ -1,234 +0,0 @@
-import { existsSync, mkdirSync, writeFileSync } from "node:fs";
-import { dirname } from "node:path";
-import { z } from "zod";
-import { transact } from "../../kernel/db/tx.js";
-import { insertPiece, piecesOf, setPiece } from "../../kernel/runner/piece-repo.js";
-import { projectById } from "../admission/repo.js";
-import { setStageProgress } from "../admission/stage-writes.js";
-import { outputFileName, outputPath } from "../storage/layout.js";
-import { insertOutput, outputsOf } from "../storage/repo.js";
-import { imageCountsOf } from "./scale.js";
-// What an image piece carries between runs: what was asked for, and the file it came back
-// as once the provider answered. That is the whole of the resume.
-const imagePayload = z.object({
-    promptName: z.string(),
-    prompt: z.string(),
-    // Which ticked prompt this send belongs to, and which send of that prompt it is. Both
-    // are stored rather than derived, because the user can delete an image and the pieces
-    // that are left must still say where each one came from.
-    promptIndex: z.number(),
-    indexInPrompt: z.number(),
-    file: z.string().optional(),
-});
-export async function runImages(deps, context, providers) {
-    const { projectId } = context.stage;
-    const project = projectById(deps.db, projectId);
-    if (project === undefined) {
-        throw new Error("This project no longer exists; it may have been deleted while it was running.");
-    }
-    const choice = project.config.images;
-    if (choice === undefined) {
-        // Admission refuses a run whose images are Generate without a provider and a model, so
-        // reaching here is a bug in admission rather than the user's.
-        throw new Error("No image model is set for this project. Choose one in Edit project → Providers, then Try again.");
-    }
-    const pieces = plan(deps, context, project.config);
-    if (pieces.length === 0) {
-        // Admission makes an image source mandatory and puts the Number at one or more, so an
-        // empty plan is a bug upstream rather than a run with no pictures.
-        throw new Error("Slopify hit an internal error (no image prompt was selected). Try again; if it happens again, use Download diagnostics in Settings and report it.");
-    }
-    // The run's own frame. The adapter turns it into whatever its provider spells the
-    // closest supported size, and the render crops whatever is left over.
-    const result = await sendAll(deps, context, providers, choice, pieces, project.format);
-    if (!result.ok)
-        return "held";
-    const made = result.value;
-    // Images made means images stored, and only the ones this run stored: a resume does not
-    // count an image the previous run made, and a regenerated image counts again.
-    //
-    // ceiling: a run that fails partway records nothing, so the images it did store are
-    // counted by no event and the resume counts only its own. One event is written when the
-    // stage completes; the upgrade, if the drift ever matters, is an event per image.
-    deps.count("stage.completed", {
-        stage: "images",
-        provider: choice.provider,
-        model: choice.model,
-        images: made,
-    });
-    deps.log.write("info", "images.done", {
-        projectId,
-        stage: "images",
-        detail: `${String(pieces.length)} images from ${String(project.config.imagePrompts.length)} prompts`,
-    });
-    return "done";
-}
-// For each ticked image prompt, its rendered text is sent Number times as independent
-// parallel calls. The plan is made once and kept, so a retry finds the rows the first run
-// wrote and sends only what did not land.
-//
-// `idx` is the slideshow order - prompts in selection order, then the index within each
-// prompt - so the order is fixed here and never depends on which image arrives first.
-function plan(deps, context, config) {
-    const existing = piecesOf(deps.db, context.stage.id, "image");
-    if (existing.length > 0) {
-        return existing;
-    }
-    const planned = [];
-    // Each prompt's Number, or more when the run scales its images (`scale.ts`).
-    const counts = imageCountsOf(config);
-    for (const [at, picked] of config.imagePrompts.entries()) {
-        // `slices/library/slots.ts` names the rendered body after the draft field that picked
-        // it, so the run carries the substituted text under this key.
-        const prompt = config.rendered[`imagePrompts.${String(at)}`];
-        if (prompt === undefined) {
-            throw new Error(`Slopify hit an internal error (the image prompt ${picked.name} was never filled in). Try again; if it happens again, use Download diagnostics in Settings and report it.`);
-        }
-        for (let send = 1; send <= (counts[at] ?? picked.number); send += 1) {
-            planned.push({
-                id: deps.ids.next(),
-                stageId: context.stage.id,
-                kind: "image",
-                idx: planned.length + 1,
-                state: "pending",
-                payload: JSON.stringify({
-                    promptName: picked.name,
-                    prompt,
-                    promptIndex: at + 1,
-                    indexInPrompt: send,
-                }),
-            });
-        }
-    }
-    transact(deps.db, () => {
-        for (const piece of planned) {
-            insertPiece(deps.db, piece);
-        }
-    });
-    return planned;
-}
-// An image a previous run stored is not made again, and one that fails takes down the
-// whole stage while its siblings finish and keep their images for the next resume. A
-// refusal is the wrapper's to make terminal; nothing here counts attempts.
-async function sendAll(deps, context, providers, choice, pieces, format) {
-    const { projectId } = context.stage;
-    // Read once, before anything is written: a piece counts as landed only when its row and
-    // its file both survived, and the parallel sends below each add one of each.
-    const stored = outputsOf(deps.db, projectId);
-    const total = pieces.length;
-    let done = pieces.filter((piece) => landed(deps, projectId, piece, stored)).length;
-    report(deps, context, done, total);
-    const outcomes = await Promise.all(pieces.map(async (piece) => {
-        const asked = payloadOf(piece);
-        if (landed(deps, projectId, piece, stored)) {
-            return { ok: true, made: false };
-        }
-        setPiece(deps.db, piece.id, "running", piece.payload);
-        try {
-            const result = await providers.forPiece(piece.id).image({
-                provider: choice.provider,
-                model: choice.model,
-                prompt: asked.prompt,
-                aspect: format,
-            });
-            if (!result.ok) {
-                setPiece(deps.db, piece.id, "pending", piece.payload);
-                return result;
-            }
-            const made = result.value;
-            const file = keep(deps, projectId, piece.idx, made);
-            // The prompt text, the prompt name, the index within the prompt, the
-            // provider and the model travel with the image.
-            const output = record(deps, projectId, piece, asked, file, made, choice);
-            // The row and the file are both there before the piece says so: a crash between
-            // them leaves a piece that is not `done`, which the next run simply sends again.
-            setPiece(deps.db, piece.id, "done", JSON.stringify({ ...asked, file }));
-            done += 1;
-            // The project page fills in as each one arrives.
-            context.emit({ type: "image.landed", projectId, outputId: output.id, index: piece.idx });
-            report(deps, context, done, total);
-            return { ok: true, made: true };
-        }
-        catch (error) {
-            // A cancel is not this image failing: an aborted call counts as nothing, and the
-            // resume runs a `pending` image exactly as a failed one.
-            setPiece(deps.db, piece.id, context.signal.aborted ? "pending" : "failed", piece.payload);
-            return { ok: false, error };
-        }
-    }));
-    let made = 0;
-    for (const outcome of outcomes) {
-        if (!outcome.ok) {
-            if ("reason" in outcome)
-                return outcome;
-            throw outcome.error;
-        }
-        made += outcome.made ? 1 : 0;
-    }
-    return { ok: true, value: made };
-}
-// An image counts as landed only when its row and its file are both still there: they are
-// written one after the other, the boot reconcile can remove a file whose row survived,
-// and the user can delete one on purpose. Answering "done" for a missing file would hand
-// the render a path to nothing.
-function landed(deps, projectId, piece, stored) {
-    const file = payloadOf(piece).file;
-    if (file === undefined) {
-        return false;
-    }
-    if (!stored.some((output) => output.role === "image" && output.path === file)) {
-        return false;
-    }
-    return existsSync(outputPath(deps.paths, projectId, file));
-}
-function keep(deps, projectId, idx, made) {
-    // Stored as received, png or jpg. The adapter read the mime off the bytes,
-    // so the extension is what the file actually is rather than what a header claimed.
-    const name = outputFileName("image", idx, made.mime === "image/png" ? ".png" : ".jpg", "images");
-    const target = outputPath(deps.paths, projectId, name);
-    mkdirSync(dirname(target), { recursive: true, mode: 0o700 });
-    writeFileSync(target, made.bytes, { mode: 0o600 });
-    return name;
-}
-function record(deps, projectId, piece, asked, file, made, choice) {
-    const output = {
-        id: deps.ids.next(),
-        projectId,
-        stageKind: "images",
-        role: "image",
-        path: file,
-        originalFilename: null,
-        bytes: made.bytes.byteLength,
-        durationMs: null,
-        // `index` is the slideshow place the render sorts on, and it is the piece's own `idx`
-        // rather than the order the images came back in.
-        meta: {
-            index: piece.idx,
-            promptName: asked.promptName,
-            prompt: asked.prompt,
-            provider: choice.provider,
-            model: choice.model,
-        },
-        createdAt: deps.clock.now().toISOString(),
-    };
-    insertOutput(deps.db, output);
-    return output;
-}
-// K of N images made. Written as well as emitted, so a page opened mid-stage reads the count
-// off the row rather than waiting for the next image.
-function report(deps, context, done, total) {
-    setStageProgress(deps.db, context.stage.id, done, total);
-    context.emit({
-        type: "stage.progress",
-        projectId: context.stage.projectId,
-        stage: "images",
-        current: done,
-        total,
-    });
-}
-function payloadOf(piece) {
-    if (piece.payload === null) {
-        throw new Error("Slopify hit an internal error (a saved image step is empty). Try again; if it happens again, use Download diagnostics in Settings and report it.");
-    }
-    return imagePayload.parse(JSON.parse(piece.payload));
-}

package/dist/slices/narration/legacy-plan.js

@@ -1,58 +0,0 @@
-import { z } from "zod";
-import { transact } from "../../kernel/db/tx.js";
-import { splitText } from "../../kernel/ports/text.js";
-import { insertPiece, piecesOf } from "../../kernel/runner/piece-repo.js";
-const payload = z.object({ text: z.string(), file: z.string().optional() });
-// Old whole-text plans can exceed a newly known account limit. Preserve finished
-// pieces and their paths, and split only unfinished work before any request starts.
-export function planLegacyNarration(deps, stageId, texts, maxCharacters, finished) {
-    const old = piecesOf(deps.db, stageId, "chunk");
-    const source = old.length
-        ? old
-        : texts.map((text, idx) => ({
-            id: deps.ids.next(),
-            stageId,
-            kind: "chunk",
-            idx: idx + 1,
-            state: "pending",
-            payload: JSON.stringify({ text }),
-        }));
-    const planned = [];
-    for (const piece of source) {
-        const data = payload.parse(JSON.parse(piece.payload ?? "null"));
-        if (finished(piece)) {
-            planned.push({ ...piece, idx: planned.length + 1 });
-            continue;
-        }
-        for (const [part, text] of splitText(data.text, maxCharacters).entries())
-            planned.push({
-                ...piece,
-                id: part === 0 ? piece.id : deps.ids.next(),
-                idx: planned.length + 1,
-                state: "pending",
-                payload: JSON.stringify({ text }),
-            });
-    }
-    if (old.length &&
-        planned.length === old.length &&
-        planned.every((p, i) => p.id === old[i]?.id &&
-            payload.parse(JSON.parse(p.payload ?? "null")).text ===
-                payload.parse(JSON.parse(old[i]?.payload ?? "null")).text))
-        return old;
-    transact(deps.db, () => {
-        // Negative temporary indices avoid colliding with a retained completed piece.
-        deps.db
-            .prepare("UPDATE stage_pieces SET idx=-idx WHERE stage_id=? AND kind='chunk'")
-            .run(stageId);
-        const known = new Set(old.map((p) => p.id));
-        for (const piece of planned) {
-            if (known.has(piece.id))
-                deps.db
-                    .prepare("UPDATE stage_pieces SET idx=?,state=?,payload=? WHERE id=?")
-                    .run(piece.idx, piece.state, piece.payload, piece.id);
-            else
-                insertPiece(deps.db, piece);
-        }
-    });
-    return planned;
-}