@gentbajko/slopify 1.2.1 → 1.3.1

package/dist/slices/rebuild/runtime-local.js

@@ -6,6 +6,7 @@ import { splitEndMatter } from "../article/split.js";
 import { joinNarration } from "../narration/concat.js";
 import { allocateAsset, discardPreparedAssets, sealAsset } from "../storage/assets.js";
 import { outputPath } from "../storage/layout.js";
+import { publishNarrationText } from "./runtime-narration-text.js";
 import { executionPlan, executionView, savedCatalogue } from "./runtime-plan.js";
 import { preparedResult, preparedText, preparedTexts, publishResult, } from "./runtime-publication.js";
 export async function executeLocalRecipe(deps, context, piece) {
@@ -43,6 +44,10 @@ export async function executeLocalRecipe(deps, context, piece) {
     }
     if (input.kind !== "local")
         throw new Error("Expected an exact local recipe.");
+    if (input.operation === "narration-files-v1") {
+        await publishNarrationText(deps, context, piece);
+        return "done";
+    }
     if (input.operation === "concat-narration") {
         await concatenate(deps, context, piece);
         return "done";

package/dist/slices/rebuild/runtime-materialize.js

@@ -95,6 +95,8 @@ function desiredAnchor(deps, projectId, head, row) {
         (row.desired_fingerprint ?? row.fingerprint));
 }
 function futureKey(recipe) {
+    if (recipe.input.kind === "llm" && recipe.input.preparation !== undefined)
+        return `narration:prepare:${recipe.input.preparation.segment}:future`;
     if (recipe.input.kind === "tts")
         return `audio:${recipe.input.segment}:future`;
     if (recipe.key.startsWith("research:chapter:"))

package/dist/slices/rebuild/runtime-narration-reuse.js

@@ -112,6 +112,7 @@ export function bindNarrationReuse(deps, view, recipe, ordinal) {
             payload: JSON.stringify({
                 ...(typeof payload === "object" && payload !== null ? payload : {}),
                 text: input.text,
+                spokenText: input.spokenText,
                 logicalKey: input.logicalKey,
                 logicalText: input.logicalText,
                 segment: input.segment,

package/dist/slices/rebuild/runtime-narration-text.js

@@ -0,0 +1,75 @@
+import { z } from "zod";
+import { executionPlan, executionView, savedCatalogue } from "./runtime-plan.js";
+import { preparedTexts, publishResult } from "./runtime-publication.js";
+export function joinedNarration(parts) {
+    return parts
+        .map((part, index) => `${index > 0 && parts[index - 1]?.logicalKey !== part.logicalKey ? "\n" : ""}${part.spokenText}`)
+        .join("");
+}
+export function narrationTextParts(view, plan, segment) {
+    const concat = plan.recipes.find((row) => row.key === (segment === "body" ? "audio:body:concat" : `audio:${segment}`));
+    if (concat === undefined)
+        throw new Error(`The saved ${segment} narration is missing.`);
+    return concat.dependsOn.map((key) => {
+        const recipe = plan.recipes.find((row) => row.key === key);
+        const selected = view.pieces.find((row) => row.key === key &&
+            row.selected &&
+            row.available &&
+            row.piece.state === "done" &&
+            row.fingerprint === recipe?.fingerprint);
+        if (selected === undefined || recipe === undefined)
+            throw new Error("The saved narration transcript is incomplete.");
+        const input = recipe.input;
+        if (input.kind === "provided" &&
+            Array.isArray(input.semantic) &&
+            typeof input.semantic[0] === "string")
+            return {
+                logicalKey: key.slice(0, key.lastIndexOf(":")),
+                spokenText: input.semantic[0],
+                requestText: null,
+            };
+        if (input.kind !== "tts")
+            throw new Error("The narration source has not resolved.");
+        const payload = z
+            .object({ text: z.string().optional(), spokenText: z.string().optional() })
+            .parse(JSON.parse(selected.piece.payload ?? "{}"));
+        if (input.spokenText !== undefined &&
+            (payload.spokenText !== input.spokenText || payload.text !== input.text))
+            throw new Error("Prepared narration is missing its exact clean transcript.");
+        return {
+            logicalKey: input.logicalKey,
+            spokenText: input.spokenText === undefined ? (payload.text ?? input.text) : (payload.spokenText ?? ""),
+            requestText: input.text,
+        };
+    });
+}
+export async function publishNarrationText(deps, context, piece) {
+    if (piece.input.kind !== "local")
+        throw new Error("Expected a narration-file recipe.");
+    const { segment } = z
+        .object({ segment: z.enum(["body", "intro", "outro"]) })
+        .parse(piece.input.values);
+    const view = executionView(deps, context.work.projectId, context.work.revisionId);
+    const row = deps.db
+        .prepare("SELECT recipe_context FROM revision_work WHERE id=?")
+        .get(context.work.workId);
+    if (view === undefined)
+        throw new Error("The pinned narration revision is missing.");
+    const plan = executionPlan(deps, view, savedCatalogue(row?.recipe_context));
+    if (!plan.recipes.some((recipe) => recipe.key === piece.key && recipe.fingerprint === piece.fingerprint))
+        throw new Error("Narration text no longer matches the admitted inputs.");
+    const parts = narrationTextParts(view, plan, segment);
+    const outputs = preparedTexts(deps, context, piece, [
+        ["narration_txt", `${segment}-narration.txt`, joinedNarration(parts)],
+        [
+            "tts_script",
+            `${segment}-tts-script.txt`,
+            parts.flatMap((part) => (part.requestText === null ? [] : [part.requestText])).join("\n\n"),
+        ],
+    ]).map((output) => ({
+        ...output,
+        slot: `${piece.key}:${output.output.role}`,
+        output: { ...output.output, meta: { ...output.output.meta, segment } },
+    }));
+    await publishResult(deps, context, piece, outputs, { segment });
+}

package/dist/slices/rebuild/runtime-provider.js

@@ -1,6 +1,8 @@
 import { plainText } from "../article/plain.js";
 import { splitEndMatter } from "../article/split.js";
 import { observeNarration } from "../narration/live.js";
+import { validatePreparation } from "../narration/preparation.js";
+import { prepareRequests } from "../narration/steering.js";
 import { chaptersFrom } from "../research/planner.js";
 import { sourcedAnswer } from "../research/synthesis.js";
 import { discardPreparedAssets, writeAsset } from "../storage/assets.js";
@@ -28,7 +30,7 @@ export async function executeProviderRecipe(deps, context, providers, piece) {
                 messages: input.messages,
                 webSearch: input.webSearch,
                 previewLabel: piece.key,
-                check: (value) => checkAnswer(piece, value),
+                check: (value) => checkAnswer(piece, value) ?? checkPreparation(deps, context, piece, value),
             });
         if (!answer.ok)
             return "held";
@@ -63,6 +65,7 @@ export async function executeProviderRecipe(deps, context, providers, piece) {
                         : await probeDurationMs(deps.ffmpeg, outputPath(deps.paths, context.work.projectId, asset.path), context.signal, deps.log);
             await publishResult(deps, context, piece, [], {
                 text: input.text,
+                ...(input.spokenText === undefined ? {} : { spokenText: input.spokenText }),
                 logicalKey: input.logicalKey,
                 logicalText: input.logicalText,
                 segment: input.segment,
@@ -125,6 +128,18 @@ function checkAnswer(piece, answer) {
     return undefined;
 }
 async function publishText(deps, context, piece, answer) {
+    if (piece.input.kind === "llm" && piece.input.preparation !== undefined) {
+        const checked = validatePreparation(answer.text, piece.input.preparation.source);
+        if (!checked.ok)
+            throw new Error(checked.reason);
+        await publishResult(deps, context, piece, [], {
+            text: answer.text,
+            preparation: piece.input.preparation,
+            cues: checked.cues,
+            logicalFingerprint: piece.logicalFingerprint ?? piece.fingerprint,
+        });
+        return;
+    }
     if (piece.key === "article:body") {
         const parts = splitEndMatter(answer.text);
         await publishResult(deps, context, piece, preparedTexts(deps, context, piece, [
@@ -182,3 +197,17 @@ function narrationLabel(deps, context, piece) {
     const index = parts.findIndex((recipe) => recipe.key === piece.key);
     return parts.length > 1 && index >= 0 ? `${name} part ${index + 1} of ${parts.length}` : name;
 }
+function checkPreparation(deps, context, piece, answer) {
+    if (piece.input.kind !== "llm" || piece.input.preparation === undefined)
+        return undefined;
+    const source = piece.input.preparation.source;
+    const checked = validatePreparation(answer.text, source);
+    if (!checked.ok)
+        return checked.reason;
+    const row = deps.db
+        .prepare("SELECT recipe_context FROM revision_work WHERE id=?")
+        .get(context.work.workId);
+    const model = savedCatalogue(row?.recipe_context).tts.find((model) => model.provider === "inworld" && model.id === "inworld-tts-2");
+    const prepared = prepareRequests(source, checked.cues, model?.tts.maxCharacters ?? 4000);
+    return prepared.ok ? undefined : prepared.reason;
+}

package/dist/slices/rebuild/runtime-publication.js

@@ -80,6 +80,8 @@ export async function publishResult(deps, context, piece, outputs, payload, asse
     }
 }
 function pieceKind(piece) {
+    if (piece.input.kind === "llm" && piece.input.preparation !== undefined)
+        return "prompt_written";
     if (piece.input.kind === "tts")
         return piece.input.segment === "body" ? "chunk" : "segment";
     if (piece.input.kind === "provided" && /^audio:body:.+:\d+$/.test(piece.key))
@@ -97,6 +99,10 @@ function pieceKind(piece) {
     return "article_written";
 }
 function pieceIndex(deps, context, piece) {
+    if (piece.input.kind === "llm" && piece.input.preparation?.segment === "intro")
+        return 1;
+    if (piece.input.kind === "llm" && piece.input.preparation?.segment === "outro")
+        return 2;
     // Intro and outro can resolve independently. Reserve alternating ordinals so a
     // late intro part cannot collide with an outro that was already published.
     const segment = /^audio:(intro|outro):(\d+)$/.exec(piece.key);
@@ -116,6 +122,9 @@ function pieceIndex(deps, context, piece) {
         "subtitles:files",
         "export:wav",
         "export:video",
+        "narration:files:body",
+        "narration:files:intro",
+        "narration:files:outro",
     ];
     const localIndex = localOrder.indexOf(piece.key);
     if (localIndex >= 0)
@@ -126,10 +135,13 @@ function pieceIndex(deps, context, piece) {
         .get(context.work.workId);
     if (view !== undefined && row?.recipe_context !== null && row?.recipe_context !== undefined) {
         const keys = executionPlan(deps, view, savedCatalogue(row.recipe_context)).recipes.filter((recipe) => recipe.stage === context.work.kind &&
+            (piece.input.kind !== "llm" ||
+                piece.input.preparation?.segment !== "body" ||
+                (recipe.input.kind === "llm" && recipe.input.preparation?.segment === "body")) &&
             pieceKind({ ...piece, key: recipe.key, input: recipe.input }) === pieceKind(piece));
         const index = keys.findIndex((recipe) => recipe.key === piece.key);
         if (index >= 0)
-            return index + 1;
+            return (index + (piece.input.kind === "llm" && piece.input.preparation?.segment === "body" ? 3 : 1));
     }
     const last = piece.key.split(":").at(-1);
     return last !== undefined && /^\d+$/.test(last) ? Number(last) : 1;

package/dist/slices/rebuild/runtime-store.js

@@ -26,6 +26,7 @@ export function executionStages(deps, projectId) {
         .prepare("SELECT work_key FROM revision_work_reservations WHERE revision_id=?")
         .all(head)
         .map((row) => String(row.work_key)));
+    const futureKeys = new Map();
     return rows
         .filter((row) => workPieces(deps.db, String(row.id)).some((piece) => {
         if (!keys.has(piece.key))
@@ -33,8 +34,18 @@ export function executionStages(deps, projectId) {
         if (piece.key === "subtitles:timing" && view?.revision.content.subtitleCues !== undefined)
             return false;
         if (piece.input.kind === "deferred" && piece.key.endsWith(":future")) {
-            const prefix = piece.key.slice(0, -"future".length);
-            return !rows.some((candidate) => workPieces(deps.db, String(candidate.id)).some((part) => part.input.kind === "tts" && part.key.startsWith(prefix)));
+            const cacheKey = String(row.id);
+            let deferred = futureKeys.get(cacheKey);
+            if (deferred === undefined) {
+                const origin = executionView(deps, projectId, String(row.revision_id));
+                if (origin === undefined || row.recipe_context === null)
+                    return true;
+                deferred = new Set(executionPlan(deps, origin, savedCatalogue(row.recipe_context))
+                    .recipes.filter((recipe) => recipe.deferred)
+                    .map((recipe) => recipe.key));
+                futureKeys.set(cacheKey, deferred);
+            }
+            return deferred.has(piece.key);
         }
         return true;
     }))

package/dist/slices/revisions/rules.js

@@ -79,9 +79,11 @@ export function validateNarrationIntent(base, edit) {
     });
     const keys = new Set(recipes.flatMap((row) => row.input.kind === "tts"
         ? [row.input.logicalKey]
-        : row.stage === "audio" && row.key.endsWith(":1")
-            ? [row.key.slice(0, -2)]
-            : []));
+        : row.input.kind === "llm" && row.input.preparation !== undefined
+            ? [row.input.preparation.logicalKey]
+            : row.stage === "audio" && row.key.endsWith(":1")
+                ? [row.key.slice(0, -2)]
+                : []));
     const fields = [];
     for (const [key, value] of Object.entries(edit.content.narrationOverrides))
         if (!isDeepStrictEqual(value, base.revision.content.narrationOverrides[key]) && !keys.has(key))

package/dist/slices/settings/cli-paths.js

@@ -13,11 +13,14 @@ const pathSchema = z
     .refine((value) => value === "" || (isAbsolute(value) && !/[\p{Cc}]/u.test(value)));
 const storedPathSchema = z.string().max(cliPathMaxLength).nullable();
 const saves = new WeakMap();
+function installationId(id) {
+    return id === "codex-image" ? "codex" : id;
+}
 export function cliPathStatus(db, id) {
     const provider = providerById(id);
     if (provider.auth !== "cli")
         throw new Error(`${id} is not a CLI provider`);
-    const stored = readSetting(db, `cli.path.${id}`);
+    const stored = readSetting(db, `cli.path.${installationId(id)}`);
     const configured = stored === undefined ? null : storedPathSchema.parse(JSON.parse(stored));
     return { configured, command: configured ?? provider.binary };
 }
@@ -32,16 +35,17 @@ export async function saveCliPath(deps, id, raw) {
         queue = new Map();
         saves.set(deps.db, queue);
     }
-    const previous = queue.get(id) ?? Promise.resolve();
+    const sharedId = installationId(id);
+    const previous = queue.get(sharedId) ?? Promise.resolve();
     const next = previous.then(() => save(deps, id, raw));
     const settled = next.then(() => { }, () => { });
-    queue.set(id, settled);
+    queue.set(sharedId, settled);
     try {
         return await next;
     }
     finally {
-        if (queue.get(id) === settled)
-            queue.delete(id);
+        if (queue.get(sharedId) === settled)
+            queue.delete(sharedId);
     }
 }
 async function save(deps, id, raw) {
@@ -84,7 +88,7 @@ async function save(deps, id, raw) {
             message: probed.error ??
                 `${provider.displayName} did not answer --version successfully within ${cliProbeTimeoutMs / 1000} seconds. Choose its executable file without arguments.`,
         };
-    writeSetting(deps.db, `cli.path.${id}`, JSON.stringify(configured));
+    writeSetting(deps.db, `cli.path.${installationId(id)}`, JSON.stringify(configured));
     return {
         ok: true,
         status: {

package/dist/slices/settings/cli-status.js

@@ -35,7 +35,7 @@ export function readinessFromProbe(result, provider) {
         return { kind: "cli", installed: false };
     }
     const version = versionFrom(result.stdout);
-    if (provider.id !== "codex")
+    if (provider.id !== "codex" && provider.id !== "codex-image")
         return version === undefined
             ? { kind: "cli", installed: true }
             : { kind: "cli", installed: true, version };

package/dist/slices/settings/model.js

@@ -17,6 +17,7 @@ export const providerIds = [
     "replicate",
     "openai-image",
     "google-image",
+    "codex-image",
 ];
 export function isLocalCliProvider(id) {
     return id === "claude-code" || id === "codex" || id === "gemini" || id === "codex-image";
@@ -55,6 +56,14 @@ export const providers = [
     { id: "replicate", family: "image", displayName: "Replicate", auth: "key" },
     { id: "openai-image", family: "image", displayName: "OpenAI", auth: "key" },
     { id: "google-image", family: "image", displayName: "Google", auth: "key" },
+    {
+        id: "codex-image",
+        family: "image",
+        displayName: "Codex CLI",
+        auth: "cli",
+        binary: "codex",
+        versionArgs: ["--version"],
+    },
 ];
 export function providerById(id) {
     const found = providers.find((provider) => provider.id === id);

package/dist/slices/settings/readiness.js

@@ -1,5 +1,5 @@
 import { cliPathStatus } from "./cli-paths.js";
-import { cliReadiness } from "./cli-status.js";
+import { cliProbeTimeoutMs, readinessFromProbe } from "./cli-status.js";
 import { providers } from "./model.js";
 import { keyedProviders } from "./repo.js";
 // Every supported provider is listed, keyed or not, found or not, so Play can grey one out with
@@ -7,15 +7,22 @@ import { keyedProviders } from "./repo.js";
 // when its binary answers. Readiness is computed per request using the latest saved executable override.
 export async function providerStatuses(deps) {
     const keyed = keyedProviders(deps.db);
+    const probes = new Map();
     return await Promise.all(providers.map(async (provider) => {
         const base = { id: provider.id, family: provider.family, displayName: provider.displayName };
         if (provider.auth !== "cli")
             return { ...base, readiness: keyedReadiness(keyed, provider.id) };
         const cliPath = cliPathStatus(deps.db, provider.id);
+        const probeKey = JSON.stringify([cliPath.command, provider.versionArgs]);
+        let result = probes.get(probeKey);
+        if (result === undefined) {
+            result = deps.probe(cliPath.command, provider.versionArgs, cliProbeTimeoutMs);
+            probes.set(probeKey, result);
+        }
         return {
             ...base,
             cliPath,
-            readiness: await cliReadiness(deps.probe, { ...provider, binary: cliPath.command }),
+            readiness: readinessFromProbe(await result, provider),
         };
     }));
 }

package/dist/slices/storage/asset-name.js

@@ -7,6 +7,9 @@
 // research and the article each store what they sent.
 export function assetOf(output) {
     const asset = output.role.replaceAll("_", "-");
+    if ((output.role === "narration_txt" || output.role === "tts_script") &&
+        output.meta.segment !== undefined)
+        return `${asset}-${output.meta.segment}`;
     if (output.role === "instructions") {
         return `${output.stageKind}-${asset}`;
     }

package/dist/slices/storage/layout.js

@@ -30,6 +30,10 @@ export function outputFileName(role, index, extension, stageKind) {
             return "article.md";
         case "article_txt":
             return "article.txt";
+        case "narration_txt":
+            return "narration.txt";
+        case "tts_script":
+            return "tts-script.txt";
         case "sources":
             return "sources.txt";
         case "glossary":

package/dist/slices/storage/model.js

@@ -6,6 +6,8 @@ export const outputRoles = [
     "notes",
     "article_md",
     "article_txt",
+    "narration_txt",
+    "tts_script",
     "sources",
     "glossary",
     "audio_body",

package/dist/slices/storage/schema.js

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import { outputRoles, stagedFileStates, stageKinds } from "./model.js";
 export const metaSchema = z.object({
+    segment: z.enum(["body", "intro", "outro"]).optional(),
     subtitleOmissions: z
         .array(z.object({ start: z.number().finite().nonnegative(), text: z.string() }))
         .optional(),