@gentbajko/slopify 0.8.0 → 0.8.2

package/dist/adapters/alignment/index.js

@@ -22,7 +22,7 @@ export const alignSubtitles = async (request) => {
             const pcmPath = join(working, "audio.f32");
             await decodeAudio(request.ffmpeg, request.audioPath, pcmPath, request.signal);
             request.onProgress?.(25, 100);
-            return await runAlignmentWorker({ modelPath, pcmPath, text: request.text }, request.signal, (current, total) => request.onProgress?.(25 + Math.round((current / total) * 75), 100));
+            return await runAlignmentWorker({ modelPath, pcmPath, text: request.text }, request.signal, (current, total) => request.onProgress?.(25 + Math.round((current / total) * 75), 100), undefined, request.onOmission);
         }
         finally {
             await rm(working, { recursive: true, force: true });

package/dist/adapters/alignment/protocol.js

@@ -4,6 +4,10 @@ export const workerInput = z.object({
     pcmPath: z.string(),
     text: z.string(),
 });
+export const omissionSchema = z.object({
+    start: z.number().finite().nonnegative(),
+    text: z.string().min(1).max(10000),
+});
 export const workerMessage = z.discriminatedUnion("type", [
     z.object({
         type: z.literal("progress"),
@@ -19,5 +23,6 @@ export const workerMessage = z.discriminatedUnion("type", [
             confidence: z.number().finite().min(0).max(1).optional(),
         })),
     }),
+    omissionSchema.extend({ type: z.literal("omission") }),
     z.object({ type: z.literal("error"), message: z.string() }),
 ]);

package/dist/adapters/alignment/quality.js

@@ -1,6 +1,6 @@
 // Compare acoustic recognition with the already aligned transcript. This catches extra
 // speech and missing phrases even when a few forced words individually score well.
-export function agreesWithSpeech(expected, observed) {
+export function agreesWithSpeech(expected, observed, maximumError = 0.42) {
     const left = expected.toUpperCase().replace(/[^A-Z']/g, "");
     const right = observed.toUpperCase().replace(/[^A-Z']/g, "");
     if (left.length === 0 || right.length === 0)
@@ -13,5 +13,5 @@ export function agreesWithSpeech(expected, observed) {
             current[column] = Math.min((previous[column] ?? 0) + 1, (current[column - 1] ?? 0) + 1, (previous[column - 1] ?? 0) + (left[row - 1] === right[column - 1] ? 0 : 1));
         previous = current;
     }
-    return (previous[right.length] ?? Infinity) / Math.max(left.length, right.length) <= 0.42;
+    return (previous[right.length] ?? Infinity) / Math.max(left.length, right.length) <= maximumError;
 }

package/dist/adapters/alignment/runner.js

@@ -1,6 +1,6 @@
 import { fork } from "node:child_process";
 import { workerMessage } from "./protocol.js";
-export async function runAlignmentWorker(input, signal, onProgress, worker = new URL("./worker.js", import.meta.url)) {
+export async function runAlignmentWorker(input, signal, onProgress, worker = new URL("./worker.js", import.meta.url), onOmission) {
     signal.throwIfAborted();
     return new Promise((resolve, reject) => {
         const options = {
@@ -48,7 +48,15 @@ export async function runAlignmentWorker(input, signal, onProgress, worker = new
                 return;
             }
             const message = parsed.data;
-            if (message.type === "progress") {
+            if (message.type === "omission") {
+                try {
+                    onOmission?.({ start: message.start, text: message.text });
+                }
+                catch (error) {
+                    finish(error instanceof Error ? error : new Error(String(error)));
+                }
+            }
+            else if (message.type === "progress") {
                 try {
                     onProgress?.(message.current, message.total);
                 }

package/dist/adapters/alignment/window.js

@@ -0,0 +1,60 @@
+import { alignWindow, frameSeconds, mismatch } from "./ctc.js";
+import { agreesWithSpeech } from "./quality.js";
+import { letters } from "./vocabulary.js";
+// Recovery can only omit a short transcript prefix, never insert guessed words or times.
+export function alignSpeechWindow(logits, frames, candidate, complete, cutoff, skipBudget) {
+    try {
+        return { words: accepted(logits, frames, candidate, complete, cutoff), skipped: 0 };
+    }
+    catch (error) {
+        if (!(error instanceof Error) || error.message !== mismatch)
+            throw error;
+    }
+    const heard = greedy(logits, frames).split(/\s+/);
+    for (let skipped = 1; skipped <= Math.min(40, skipBudget, candidate.length - 4); skipped += 1) {
+        const remaining = candidate.slice(skipped);
+        const anchor = remaining
+            .slice(0, 4)
+            .map((word) => word.spoken)
+            .join(" ");
+        if (anchor.replace(/[^A-Z]/g, "").length < 20 ||
+            !agreesWithSpeech(anchor, heard.slice(0, anchor.split(/\s+/).length).join(" "), 0.2))
+            continue;
+        try {
+            const words = accepted(logits, frames, remaining, complete, cutoff);
+            if (words.length < 4 || words.slice(0, 4).some((word) => (word.confidence ?? 0) < 0.75))
+                continue;
+            return { words, skipped };
+        }
+        catch (error) {
+            if (!(error instanceof Error) || error.message !== mismatch)
+                throw error;
+        }
+    }
+    throw new Error(mismatch);
+}
+function accepted(logits, frames, candidate, complete, cutoff) {
+    const words = alignWindow(logits, frames, candidate, complete).words.filter((word) => word.end <= cutoff);
+    const last = words.at(-1);
+    if (last === undefined ||
+        !agreesWithSpeech(candidate
+            .slice(0, words.length)
+            .map((word) => word.spoken)
+            .join(" "), greedy(logits, Math.min(frames, Math.ceil(last.end / frameSeconds)))))
+        throw new Error(mismatch);
+    return words;
+}
+export function greedy(logits, frames) {
+    let previous = -1;
+    let text = "";
+    for (let frame = 0; frame < frames; frame += 1) {
+        let best = 0;
+        for (let label = 1; label < 32; label += 1)
+            if ((logits[frame * 32 + label] ?? -Infinity) > (logits[frame * 32 + best] ?? -Infinity))
+                best = label;
+        if (best !== previous && best !== 0)
+            text += letters[best] ?? "";
+        previous = best;
+    }
+    return text.trim().replace(/\s+/g, " ");
+}

package/dist/adapters/alignment/worker.js

@@ -1,10 +1,9 @@
 import { open, readFile, stat } from "node:fs/promises";
 import * as ort from "onnxruntime-web/wasm";
-import { alignWindow, frameSeconds, mismatch } from "./ctc.js";
+import { mismatch } from "./ctc.js";
 import { workerInput } from "./protocol.js";
-import { agreesWithSpeech } from "./quality.js";
 import { speechWords } from "./text.js";
-import { letters } from "./vocabulary.js";
+import { alignSpeechWindow, greedy } from "./window.js";
 const sampleRate = 16000;
 const windowSeconds = 12;
 const overlapSeconds = 2;
@@ -31,6 +30,8 @@ async function run(input) {
         const source = speechWords(input.text);
         const output = [];
         let cursor = 0;
+        let omitted = 0;
+        const omissionBudget = Math.min(60, Math.floor(source.length * 0.05));
         let sampleAt = 0;
         while (sampleAt < totalSamples && cursor < source.length) {
             const count = Math.min(windowSeconds * sampleRate, totalSamples - sampleAt);
@@ -62,18 +63,24 @@ async function run(input) {
             const candidate = candidates(source, cursor, observed);
             const finalWindow = sampleAt + count >= totalSamples;
             const complete = finalWindow && cursor + candidate.length === source.length;
-            const aligned = alignWindow(logits.data, frames, candidate, complete).words;
             const cutoff = finalWindow ? count / sampleRate : count / sampleRate - overlapSeconds;
-            const accepted = aligned.filter((word) => word.end <= cutoff);
+            const recovered = alignSpeechWindow(logits.data, frames, candidate, complete, cutoff, cursor === 0 ? 0 : omissionBudget - omitted);
+            const accepted = recovered.words;
             const last = accepted.at(-1);
             if (last === undefined)
                 throw new Error(mismatch);
-            const heard = greedy(logits.data, Math.min(frames, Math.ceil(last.end / frameSeconds)));
-            if (!agreesWithSpeech(candidate
-                .slice(0, accepted.length)
-                .map((word) => word.spoken)
-                .join(" "), heard))
-                throw new Error(mismatch);
+            if (recovered.skipped > 0) {
+                omitted += recovered.skipped;
+                send({
+                    type: "omission",
+                    start: sampleAt / sampleRate,
+                    text: candidate
+                        .slice(0, recovered.skipped)
+                        .map((word) => word.text)
+                        .join(" "),
+                });
+                cursor += recovered.skipped;
+            }
             const offset = sampleAt / sampleRate;
             output.push(...accepted.map((word) => ({
                 ...word,
@@ -147,17 +154,3 @@ function normalize(audio) {
     const divisor = Math.sqrt(variance + 1e-7);
     return Float32Array.from(audio, (value) => (value - mean) / divisor);
 }
-function greedy(logits, frames) {
-    let previous = -1;
-    let text = "";
-    for (let frame = 0; frame < frames; frame += 1) {
-        let best = 0;
-        for (let label = 1; label < 32; label += 1)
-            if ((logits[frame * 32 + label] ?? -Infinity) > (logits[frame * 32 + best] ?? -Infinity))
-                best = label;
-        if (best !== previous && best !== 0)
-            text += letters[best] ?? "";
-        previous = best;
-    }
-    return text.trim().replace(/\s+/g, " ");
-}

package/dist/edge/http/app.js

@@ -7,6 +7,7 @@ import { audioPreviewRoutes } from "./audio-preview.js";
 import { entryRoutes } from "./entries.js";
 import { fileRoutes } from "./files.js";
 import { fontsRoutes } from "./fonts.js";
+import { openFolderRoutes } from "./open-folder.js";
 import { planningRoutes } from "./planning.js";
 import { problem, problemFromError, titleOf } from "./problem.js";
 import { projectRoutes } from "./projects.js";
@@ -30,6 +31,7 @@ function apiRoutes(deps, startedAt) {
         .route("/staging", stagingRoutes(deps))
         .route("/projects", planningRoutes(deps))
         .route("/projects", projectRoutes(deps))
+        .route("/projects", openFolderRoutes(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

package/dist/edge/http/open-folder.js

@@ -0,0 +1,61 @@
+import { dirname } from "node:path";
+import { zValidator } from "@hono/zod-validator";
+import { Hono } from "hono";
+import { z } from "zod";
+import { assetOf, findDownload } from "../../slices/storage/downloads.js";
+import { outputsOf } from "../../slices/storage/repo.js";
+import { onInvalid, problem, titleOf } from "./problem.js";
+export function openFolderRoutes(deps) {
+    return new Hono().post("/:id/open-folder", zValidator("param", z.object({
+        id: z
+            .string()
+            .min(1)
+            .max(64)
+            .regex(/^[0-9A-Za-z_-]+$/),
+    }), onInvalid), zValidator("json", z.object({
+        asset: z
+            .string()
+            .max(64)
+            .regex(/^(?:[a-z0-9-]+|images\.zip)$/),
+    }), onInvalid), async (c) => {
+        const origin = c.req.header("origin");
+        if (origin !== undefined && origin !== new URL(c.req.url).origin) {
+            return problem(c, {
+                status: 403,
+                title: titleOf(403),
+                detail: "Open folders from Slopify itself.",
+            });
+        }
+        const { id } = c.req.valid("param");
+        const { asset } = c.req.valid("json");
+        // The archive is virtual; open the first existing image's folder without building a zip.
+        const assets = asset === "images.zip"
+            ? outputsOf(deps.db, id)
+                .filter((output) => output.role === "image" || output.role === "thumbnail")
+                .map(assetOf)
+            : [asset];
+        const download = assets
+            .map((name) => findDownload(deps, id, name))
+            .find((result) => result.ok);
+        if (download === undefined || !download.ok) {
+            return problem(c, {
+                status: 404,
+                title: titleOf(404),
+                detail: "No saved file was found for this output. Re-run the stage if the file was removed.",
+            });
+        }
+        try {
+            if (deps.openFolder === undefined)
+                throw new Error("No folder opener configured");
+            await deps.openFolder(dirname(download.download.path));
+            return c.json({ opened: true });
+        }
+        catch {
+            return problem(c, {
+                status: 503,
+                title: titleOf(503),
+                detail: "Could not open the file manager on the machine running Slopify. Make sure a desktop session is available.",
+            });
+        }
+    });
+}

package/dist/edge/open-folder.js

@@ -0,0 +1,25 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { isWsl } from "./open-browser.js";
+const execute = promisify(execFile);
+export function folderCommand(platform, path, wsl = false) {
+    if (platform === "win32" || wsl)
+        return ["explorer.exe", [path]];
+    return [platform === "darwin" ? "open" : "xdg-open", [path]];
+}
+export async function openFolder(path) {
+    const wsl = isWsl(process.platform);
+    const target = wsl
+        ? (await execute("wslpath", ["-w", path], { timeout: 5000 })).stdout.trim()
+        : path;
+    const [command, args] = folderCommand(process.platform, target, wsl);
+    try {
+        await execute(command, args, { timeout: 10000 });
+    }
+    catch (error) {
+        // Explorer commonly reports 1 even when it successfully opens an existing window.
+        if (command === "explorer.exe" && error instanceof Error && "code" in error && error.code === 1)
+            return;
+        throw error;
+    }
+}

package/dist/main.js

@@ -11,6 +11,7 @@ import { curateRegistry } from "./catalog/registry.js";
 import { createCatalogueStore } from "./catalog/store.js";
 import { createHub } from "./edge/events/hub.js";
 import { createApp } from "./edge/http/app.js";
+import { openFolder } from "./edge/open-folder.js";
 import { createAudioPreviewStore } from "./kernel/audio-preview.js";
 import { systemClock } from "./kernel/clock.js";
 import { openDb } from "./kernel/db/index.js";
@@ -169,6 +170,7 @@ export async function boot(config) {
             },
         });
         const app = createApp({
+            openFolder,
             db,
             paths,
             hub,

package/dist/slices/admission/repo.js

@@ -43,7 +43,13 @@ export const runDraftSchema = z.object({
     }),
     // Optional until Play carries the control; unknown keys are stripped by this schema, so
     // a mode not listed here would never reach the audio stage.
-    chunking: z.object({ mode: z.enum(chunkModes), words: z.number().optional() }).optional(),
+    chunking: z
+        .object({
+        mode: z.enum(chunkModes),
+        words: z.number().optional(),
+        characters: z.number().int().min(1).max(1000000).optional(),
+    })
+        .optional(),
     silenceGapSeconds: z.number(),
     subtitles: subtitleConfigSchema.optional(),
 });

package/dist/slices/control/index.js

@@ -1,6 +1,7 @@
 import { transact } from "../../kernel/db/tx.js";
 import { derive, satisfied } from "../../kernel/runner/graph.js";
 import { finishStage, projectById, resetStage, setProjectPaused, stagesOf, updateProjectConfig, } from "../admission/repo.js";
+import { sameChunking } from "../narration/chunk.js";
 import { clearUnfinishedAudio } from "../reruns/index.js";
 import { providers as providerCatalog } from "../settings/model.js";
 import { hasKey, listVoices } from "../settings/repo.js";
@@ -137,9 +138,7 @@ export function changeProviders(deps, id, changes) {
             (changes.audio.provider !== project.config.audio?.provider ||
                 changes.audio.model !== project.config.audio?.model ||
                 changes.audio.voice !== project.config.audio?.voice);
-        const chunkingChanged = changes.chunking !== undefined &&
-            (changes.chunking.mode !== (project.config.chunking?.mode ?? "whole") ||
-                (changes.chunking.words ?? 500) !== (project.config.chunking?.words ?? 500));
+        const chunkingChanged = changes.chunking !== undefined && !sameChunking(changes.chunking, project.config.chunking);
         const orphaned = transact(deps.db, () => {
             const files = audioChanged || chunkingChanged ? clearUnfinishedAudio(deps, id) : [];
             updateProjectConfig(deps.db, id, {

package/dist/slices/control/providers.js

@@ -14,7 +14,11 @@ export const providerChangesSchema = z
     audio: choice.extend({ voice: z.string().trim().min(1).max(200) }).optional(),
     images: choice.optional(),
     chunking: z
-        .object({ mode: z.enum(chunkModes), words: z.number().int().min(1).max(10000).optional() })
+        .object({
+        mode: z.enum(chunkModes),
+        words: z.number().int().min(1).max(10000).optional(),
+        characters: z.number().int().min(1).max(1000000).optional(),
+    })
         .strict()
         .optional(),
 })

package/dist/slices/narration/chunk.js

@@ -1,12 +1,6 @@
-// The run's chunking choice: whole text is one request, per paragraph is one request per
-// paragraph, and every ~N words is consecutive chunks each ending at the last sentence
-// boundary at or before N words, N defaulting to 500.
-//
-// Pure, and the only place the rule lives. Chunking sits in the functional core beside
-// substitution and the render plan, so it is testable with no I/O and `run.ts` does nothing
-// but call it.
-export const chunkModes = ["whole", "paragraph", "words"];
+export const chunkModes = ["whole", "paragraph", "words", "characters"];
 export const defaultChunkWords = 500;
+export const defaultChunkCharacters = 3000;
 // A run created before Play carried the control sends the whole text as one request,
 // which is the first case and the one that adds nothing the user did not ask for.
 export const defaultChunking = { mode: "whole" };
@@ -20,7 +14,9 @@ export function chunkNarration(text, chunking) {
         case "paragraph":
             return nonEmpty(text.split(paragraphBreak));
         case "words":
-            return wordRuns(text, chunking.words ?? defaultChunkWords);
+            return sentenceRuns(text, chunking.words ?? defaultChunkWords, wordsIn);
+        case "characters":
+            return sentenceRuns(text, chunking.characters ?? defaultChunkCharacters, (part) => Array.from(part.trim()).length);
     }
 }
 // What "N words" counts: runs of non-space. Exported because it is half of the rule -
@@ -28,29 +24,32 @@ export function chunkNarration(text, chunking) {
 export function wordsIn(text) {
     return text.split(/\s+/).filter((word) => word !== "").length;
 }
-function wordRuns(text, budget) {
-    // A budget below one word would end every chunk before it started; one sentence is the
-    // floor because the rule never cuts inside a sentence.
+export function sameChunking(left, right) {
+    const a = left ?? defaultChunking;
+    const b = right ?? defaultChunking;
+    if (a.mode !== b.mode)
+        return false;
+    if (a.mode === "words")
+        return (a.words ?? defaultChunkWords) === (b.words ?? defaultChunkWords);
+    if (a.mode === "characters")
+        return (a.characters ?? defaultChunkCharacters) === (b.characters ?? defaultChunkCharacters);
+    return true;
+}
+function sentenceRuns(text, budget, measure) {
     const limit = Math.max(1, Math.floor(budget));
     const chunks = [];
     let current = "";
-    let count = 0;
     for (const sentence of sentences(text)) {
-        const words = wordsIn(sentence);
-        // The last sentence boundary at or before N words: the sentence that would push the count
-        // past the budget starts the next chunk instead of being split.
-        if (count > 0 && count + words > limit) {
+        // Measure the joined text so spaces between sentences count toward a character budget.
+        if (current.trim() && measure(current + sentence) > limit) {
             chunks.push(current);
             current = "";
-            count = 0;
         }
         current += sentence;
-        count += words;
     }
     chunks.push(current);
-    // A single sentence longer than the budget lands here whole, on its own: a cut inside a
-    // clause would be an audible pause the writer never wrote. The provider's own per-request
-    // limit is what refuses it, as an error on the stage.
+    // Like word chunking, a sentence longer than the budget stays whole on its own.
+    // The provider-specific planning layer applies any hard request limit afterwards.
     return nonEmpty(chunks);
 }
 // ceiling: segmented as English. `Intl.Segmenter` is the platform's own sentence breaker

package/dist/slices/storage/repo.js

@@ -1,6 +1,9 @@
 import { z } from "zod";
 import { outputRoles, stagedFileStates, stageKinds } from "./model.js";
 const metaSchema = z.object({
+    subtitleOmissions: z
+        .array(z.object({ start: z.number().finite().nonnegative(), text: z.string() }))
+        .optional(),
     subtitlesMode: z.enum(["off", "files", "burn-in"]).optional(),
     promptName: z.string().optional(),
     prompt: z.string().optional(),

package/dist/slices/subtitles/prepare.js

@@ -28,7 +28,14 @@ const fontSchema = z.object({
     assName: z.string(),
     extension: z.enum([".ttf", ".otf", ".ttc"]),
 });
-const cacheSchema = z.object({ key: z.string(), words: z.array(wordSchema), font: fontSchema });
+const cacheSchema = z.object({
+    key: z.string(),
+    words: z.array(wordSchema),
+    font: fontSchema,
+    omissions: z
+        .array(z.object({ start: z.number().finite().nonnegative(), text: z.string() }))
+        .default([]),
+});
 // Preparation writes into a new directory; only writeExport commits its output rows.
 // The old caption files/font/timing stay usable if alignment or rendering fails.
 export async function prepareSubtitles(deps, context, audio, frame) {
@@ -52,7 +59,8 @@ export async function prepareSubtitles(deps, context, audio, frame) {
     const directory = mkdtempSync(join(dir, "captions-"));
     try {
         const font = await snapshotFont(deps, projectId, outputs, config.fontId, cache, directory);
-        const words = cache?.key === key ? cache.words : await alignSegments(deps, context, segments);
+        const omissions = cache?.key === key ? [...cache.omissions] : [];
+        const words = cache?.key === key ? cache.words : await alignSegments(deps, context, segments, omissions);
         context.signal.throwIfAborted();
         const cues = captionCues(words);
         if (cues.length === 0)
@@ -65,7 +73,7 @@ export async function prepareSubtitles(deps, context, audio, frame) {
             fontName: font.assName,
             position: config.position,
         }), { mode: 0o600 });
-        writeFileSync(join(directory, "subtitles.json"), JSON.stringify({ key, words, font }), {
+        writeFileSync(join(directory, "subtitles.json"), JSON.stringify({ key, words, font, omissions }), {
             mode: 0o600,
         });
         const files = [
@@ -77,6 +85,7 @@ export async function prepareSubtitles(deps, context, audio, frame) {
         ];
         return {
             directory,
+            omissions,
             burnIn: config.mode === "burn-in" && project.config.sources.video !== "off",
             assets: files.map(([role, path]) => ({
                 role,
@@ -91,7 +100,7 @@ export async function prepareSubtitles(deps, context, audio, frame) {
 }
 async function timingKey(segments, signal) {
     // Bump when alignment normalization/model changes. Hash file contents, not timestamps.
-    const hash = createHash("sha256").update("wav2vec2-en-a19f851-v1");
+    const hash = createHash("sha256").update("wav2vec2-en-a19f851-v2-omissions");
     for (const segment of segments) {
         signal.throwIfAborted();
         hash.update(JSON.stringify({ kind: segment.kind, seconds: segment.seconds, text: segment.text }));
@@ -103,7 +112,7 @@ async function timingKey(segments, signal) {
     }
     return hash.digest("hex");
 }
-async function alignSegments(deps, context, segments) {
+async function alignSegments(deps, context, segments, omissions) {
     if (deps.alignSubtitles === undefined)
         throw new Error("Local subtitle alignment is unavailable in this build.");
     const words = [];
@@ -114,6 +123,7 @@ async function alignSegments(deps, context, segments) {
         if (segment.path !== null) {
             const aligned = await deps.alignSubtitles({
                 audioPath: segment.path,
+                onOmission: (omission) => omissions.push({ ...omission, start: omission.start + offset }),
                 text: segment.text,
                 cacheDir: join(deps.paths.dataDir, "models", "english-subtitles"),
                 ffmpeg: deps.ffmpeg,

package/dist/slices/video/write-export.js

@@ -90,6 +90,9 @@ export async function writeExport(deps, context, output) {
             }
             store(deps, projectId, "render_params", "render.json", null);
             store(deps, projectId, output.role, output.filename, totalMs, {
+                ...(output.subtitles?.omissions?.length
+                    ? { subtitleOmissions: output.subtitles.omissions }
+                    : {}),
                 subtitlesMode: output.subtitles === undefined ? "off" : output.subtitles.burnIn ? "burn-in" : "files",
             });
             for (const asset of output.subtitles?.assets ?? [])