@gentbajko/slopify 2.4.0 → 3.0.0

package/dist/slices/estimate/requests.js

@@ -1,4 +1,6 @@
 import { z } from "zod";
+import { apiEquivalentOf, tokenCost } from "../run-cost/pricing.js";
+import { isLocalCliProvider } from "../settings/model.js";
 const quantity = z.number().finite().nonnegative();
 const common = z.object({
     stage: z.string(),
@@ -6,7 +8,12 @@ const common = z.object({
     variable: z.boolean().optional(),
     expectedWords: quantity.optional(),
 });
-const provider = common.extend({ provider: z.string(), model: z.string() });
+const provider = common.extend({
+    provider: z.string(),
+    model: z.string(),
+    // A CLI request whose API figure cannot be told in advance.
+    apiUnknown: z.literal(true).optional(),
+});
 const requestSchema = z.discriminatedUnion("kind", [
     provider
         .extend({ kind: z.literal("llm"), inputCharacters: quantity, outputCharacters: quantity })
@@ -26,6 +33,7 @@ export function estimateRequests(requests, catalogue) {
         low: rows.reduce((total, row) => total + (row.low ?? 0), 0),
         high: rows.reduce((total, row) => total + (row.high ?? 0), 0),
         unknown: rows.filter((row) => row.low === null).length,
+        ...apiTotals(rows),
         expectedWords: parsed.reduce((total, request) => total + (request.expectedWords ?? 0), 0),
         catalogueDate: catalogue.updatedAt,
         assumptions: [
@@ -39,16 +47,64 @@ export function groupEstimateRows(estimate) {
     const grouped = new Map();
     for (const row of estimate.rows) {
         const previous = grouped.get(row.stage);
+        const plan = previous?.onPlan === true || row.onPlan === true;
+        const sum = (left, right) => (left === null || right === null ? null : (left ?? 0) + (right ?? 0));
         grouped.set(row.stage, previous === undefined
             ? row
             : {
                 ...previous,
                 low: previous.low === null || row.low === null ? null : previous.low + row.low,
                 high: previous.high === null || row.high === null ? null : previous.high + row.high,
+                ...(plan
+                    ? {
+                        onPlan: true,
+                        apiLow: sum(previous.apiLow, row.apiLow),
+                        apiHigh: sum(previous.apiHigh, row.apiHigh),
+                    }
+                    : {}),
             });
     }
     const rows = [...grouped.values()];
-    return { ...estimate, rows, unknown: rows.filter((row) => row.low === null).length };
+    return {
+        ...estimate,
+        rows,
+        unknown: rows.filter((row) => row.low === null).length,
+        ...apiTotals(rows),
+    };
+}
+function apiTotals(rows) {
+    const plan = rows.filter((row) => row.onPlan === true);
+    if (plan.length === 0)
+        return {};
+    return {
+        apiLow: plan.reduce((total, row) => total + (row.apiLow ?? 0), 0),
+        apiHigh: plan.reduce((total, row) => total + (row.apiHigh ?? 0), 0),
+        apiUnknown: plan.filter((row) => row.apiLow === null || row.apiLow === undefined).length,
+    };
+}
+// A CLI call adds nothing to the bill - it runs on the user's plan - so it is known at $0,
+// with what the same tokens would cost through the API beside it, priced by the same
+// catalogue and the same token assumptions as a keyed model. A Codex image has no API
+// figure: how many drafts the agent draws is not known in advance.
+function onPlan(request, catalogue) {
+    const api = request.kind === "llm"
+        ? apiEquivalentOf(request.provider, request.model, catalogue)
+        : undefined;
+    const amount = api === undefined || request.kind !== "llm" || request.apiUnknown === true
+        ? null
+        : tokenCost(api.pricing, request.inputCharacters / 4, request.outputCharacters / 4);
+    return {
+        stage: request.stage,
+        low: 0,
+        high: 0,
+        detail: request.detail ??
+            (amount === null
+                ? "Runs on your CLI plan, so it adds no charge; no API price is listed for this model."
+                : `Runs on your CLI plan, so it adds no charge; priced as ${api?.name ?? "the API model"} through the API.`),
+        onPlan: true,
+        apiLow: amount === null ? null : amount * 0.5,
+        apiHigh: amount === null ? null : amount * 1.5,
+    };
 }
 function price(request, catalogue) {
     if (request.kind === "unknown")
@@ -65,6 +121,8 @@ function price(request, catalogue) {
             high: 0,
             detail: request.detail ?? "Local processing or retained output; no API fee.",
         };
+    if ((request.kind === "llm" || request.kind === "image") && isLocalCliProvider(request.provider))
+        return onPlan(request, catalogue);
     const family = request.kind === "tts-estimate" ? "tts" : request.kind;
     const model = catalogue[family].find((entry) => entry.provider === request.provider &&
         entry.id === request.model &&

package/dist/slices/fixes/rules.js

@@ -0,0 +1,73 @@
+import { providers } from "../settings/model.js";
+const signIn = {
+    "claude-code": { name: "Claude Code", command: "claude auth login" },
+    codex: { name: "Codex", command: "codex login" },
+    gemini: { name: "Gemini", command: "gemini" },
+};
+const signedOut = /not signed in|sign-in has expired|not logged in|run\s+"?(?:codex login|claude auth login)|authentication required/i;
+const diskFull = /ENOSPC|no space left on device|disk (?:is )?full|not enough (?:free )?(?:disk )?space/i;
+const refusedWords = /refused to make|content (?:rules|policy|filter)|safety (?:system|filter)|flagged|moderation/i;
+const retiredModel = /\bunknown model\b|\bmodel\b[^\n]{0,80}?\b(?:not found|does not exist|retired|deprecated|decommissioned|no longer (?:available|supported)|is not available)/i;
+const keyTrouble = /did not accept the API key|API key is saved|invalid api key|key may be wrong/i;
+// Stages whose failed call draws an image from a prompt, which Soften and retry can reword.
+const drawn = ["images", "thumbnail"];
+export function fixFor(step) {
+    const reason = step.reason ?? "";
+    const cli = cliOf(step.provider, reason);
+    if (cli !== undefined && (signedOut.test(reason) || step.kind === "auth"))
+        return {
+            kind: "sign-in",
+            label: `Sign in to ${signIn[cli].name}`,
+            cli,
+            command: signIn[cli].command,
+        };
+    if (diskFull.test(reason))
+        return { kind: "free-space", label: "Free space" };
+    if (step.kind === "refusal" || refusedWords.test(reason))
+        return drawn.includes(step.stage)
+            ? { kind: "refused", label: "Soften and retry", soften: true }
+            : { kind: "refused", label: "Edit prompt", soften: false };
+    if (retiredModel.test(reason))
+        return { kind: "switch-model", label: "Switch model" };
+    if (step.kind === "auth" || step.kind === "missing_key" || keyTrouble.test(reason)) {
+        const name = nameOf(step.provider);
+        return {
+            kind: "provider-settings",
+            label: name === undefined ? "Open Settings → Providers" : `Open Settings → Providers → ${name}`,
+            provider: step.provider ?? "",
+        };
+    }
+    return undefined;
+}
+// The CLI a failure names: the project's own choice, or the one its sentence mentions.
+function cliOf(provider, reason) {
+    if (provider === "claude-code" || provider === "gemini")
+        return provider;
+    if (provider === "codex" || provider === "codex-image")
+        return "codex";
+    if (/Codex CLI/.test(reason))
+        return "codex";
+    if (/Claude Code CLI/.test(reason))
+        return "claude-code";
+    if (/Gemini CLI/.test(reason))
+        return "gemini";
+    return undefined;
+}
+function nameOf(provider) {
+    return providers.find((one) => one.id === provider)?.displayName;
+}
+// Which provider a stage's calls go to, from the project's choices.
+export function stageProvider(config, stage) {
+    switch (stage) {
+        case "audio":
+            return config.audio?.provider;
+        case "images":
+        case "thumbnail":
+            return config.images?.provider;
+        case "research":
+        case "article":
+            return config.llm?.provider;
+        default:
+            return undefined;
+    }
+}

package/dist/slices/fonts/coverage.js

@@ -0,0 +1,82 @@
+import { fileURLToPath } from "node:url";
+import { languageInfo, languageLetters } from "../../kernel/ports/languages.js";
+import { resolveBoldFont, resolveFont } from "./catalog.js";
+import { discoverSystemFonts } from "./discovery.js";
+import { readFontFile } from "./files.js";
+import { mappedCodepoints, readFontMetadata } from "./sfnt.js";
+// Captions in a language the chosen font can't draw would come out as empty boxes. For every
+// language but English the chosen font is checked against that language's letters
+// (`languageLetters`); when it misses any, the captions use a bundled Noto font for the script,
+// else a font on this computer that has them all, else the render stops and says how to fix
+// it. English is never checked, so an English project renders with exactly the font it chose.
+// Small enough to ship: Latin, Greek and Cyrillic in one family, and the other alphabets'
+// own. Chinese, Japanese and Korean fonts run to 10-20 MB each, so they are not bundled.
+const bundled = {
+    latin: "NotoSans-Regular.ttf",
+    greek: "NotoSans-Regular.ttf",
+    cyrillic: "NotoSans-Regular.ttf",
+    arabic: "NotoSansArabic-Regular.ttf",
+    hebrew: "NotoSansHebrew-Regular.ttf",
+    devanagari: "NotoSansDevanagari-Regular.ttf",
+    thai: "NotoSansThai-Regular.ttf",
+};
+export function captionFontDeps(paths) {
+    return {
+        resolve: (id) => resolveFont(paths, id),
+        system: discoverSystemFonts,
+        bundledDir: fileURLToPath(new URL("../../assets/fonts/noto/", import.meta.url)),
+    };
+}
+// The font captions are drawn in, for the chosen font and the project language.
+export async function captionFont(deps, fontId, language) {
+    const chosen = await deps.resolve(fontId);
+    if (language === undefined || language === "en")
+        return chosen;
+    const letters = languageLetters(language);
+    if (await covers(chosen, letters))
+        return chosen;
+    const info = languageInfo(language);
+    const file = bundled[info.script];
+    if (file !== undefined) {
+        const font = await fontFile(`${deps.bundledDir}${file}`);
+        if (font !== undefined && (await covers(font, letters)))
+            return font;
+    }
+    for (const font of await deps.system())
+        if (await covers(font, letters))
+            return font;
+    throw new Error(`The caption font ${chosen.name} has no ${info.name} letters, and Slopify doesn't ship a font for ${info.name} (they are 10-20 MB). Upload a font that has them in Settings → Fonts (for example Noto Sans ${info.code === "ja" ? "JP" : info.code === "ko" ? "KR" : "SC"} from fonts.google.com), choose it in Edit project → Subtitles, then Try again.`);
+}
+// The same for text drawn bold (the shorts' captions): the chosen font's bold face when it has
+// the letters, else the fallback, which the renderer emboldens.
+export async function captionBoldFont(paths, fontId, language) {
+    if (language === undefined || language === "en")
+        return resolveBoldFont(paths, fontId);
+    const chosen = await resolveFont(paths, fontId);
+    const font = await captionFont(captionFontDeps(paths), fontId, language);
+    return font.path === chosen.path ? resolveBoldFont(paths, fontId) : font;
+}
+async function covers(font, letters) {
+    const bytes = await readFontFile(font.path);
+    if (bytes === undefined)
+        return false;
+    const found = mappedCodepoints(bytes, font.faceIndex, letters);
+    // A font whose cmap can't be read is taken at its word: it was chosen for this.
+    return found === undefined || found.size === letters.length;
+}
+async function fontFile(path) {
+    const bytes = await readFontFile(path);
+    const face = bytes === undefined ? undefined : readFontMetadata(bytes)?.[0];
+    if (face === undefined)
+        return undefined;
+    return {
+        id: "default",
+        name: face.name,
+        family: face.family,
+        source: "bundled",
+        path,
+        extension: ".ttf",
+        assName: face.assName,
+        faceIndex: 0,
+    };
+}

package/dist/slices/fonts/sfnt.js

@@ -260,3 +260,77 @@ function checksum(bytes) {
         sum = (sum + bytes.readUInt32BE(at)) >>> 0;
     return sum;
 }
+// Which of `codepoints` the face maps to a glyph, read from its Unicode cmap (format 4 or 12,
+// the two every modern font carries). Undefined when the font has neither; the caller then
+// cannot tell, and treats the font as covering what it was chosen for.
+export function mappedCodepoints(content, index, codepoints) {
+    const bytes = Buffer.from(content.buffer, content.byteOffset, content.byteLength);
+    const face = directories(bytes)?.[index];
+    const table = face?.tables.get("cmap");
+    if (face === undefined || table === undefined || !validCmap(bytes, table))
+        return undefined;
+    const count = bytes.readUInt16BE(table.offset + 2);
+    let best;
+    for (let entry = 0; entry < count; entry += 1) {
+        const record = table.offset + 4 + entry * 8;
+        const platform = bytes.readUInt16BE(record);
+        const encoding = bytes.readUInt16BE(record + 2);
+        const at = table.offset + bytes.readUInt32BE(record + 4);
+        const format = bytes.readUInt16BE(at);
+        const unicode = platform === 0 || (platform === 3 && (encoding === 1 || encoding === 10));
+        if (!unicode || (format !== 4 && format !== 12))
+            continue;
+        if (best === undefined || format > best.format)
+            best = { at, format };
+    }
+    if (best === undefined)
+        return undefined;
+    const end = table.offset + table.length;
+    const found = new Set();
+    for (const codepoint of codepoints)
+        if (glyphOf(bytes, best.at, best.format, codepoint, end) !== 0)
+            found.add(codepoint);
+    return found;
+}
+function glyphOf(bytes, at, format, codepoint, end) {
+    if (format === 12) {
+        const groups = bytes.readUInt32BE(at + 12);
+        if (at + 16 + groups * 12 > end)
+            return 0;
+        for (let group = 0; group < groups; group += 1) {
+            const row = at + 16 + group * 12;
+            const first = bytes.readUInt32BE(row);
+            const last = bytes.readUInt32BE(row + 4);
+            if (codepoint >= first && codepoint <= last)
+                return bytes.readUInt32BE(row + 8) + (codepoint - first);
+        }
+        return 0;
+    }
+    if (codepoint > 0xffff)
+        return 0;
+    const segments = bytes.readUInt16BE(at + 6) / 2;
+    const ends = at + 14;
+    const starts = ends + segments * 2 + 2;
+    const deltas = starts + segments * 2;
+    const ranges = deltas + segments * 2;
+    if (ranges + segments * 2 > end)
+        return 0;
+    for (let segment = 0; segment < segments; segment += 1) {
+        const last = bytes.readUInt16BE(ends + segment * 2);
+        if (codepoint > last)
+            continue;
+        const first = bytes.readUInt16BE(starts + segment * 2);
+        if (codepoint < first)
+            return 0;
+        const delta = bytes.readInt16BE(deltas + segment * 2);
+        const range = bytes.readUInt16BE(ranges + segment * 2);
+        if (range === 0)
+            return (codepoint + delta) & 0xffff;
+        const glyphAt = ranges + segment * 2 + range + (codepoint - first) * 2;
+        if (glyphAt + 2 > end)
+            return 0;
+        const glyph = bytes.readUInt16BE(glyphAt);
+        return glyph === 0 ? 0 : (glyph + delta) & 0xffff;
+    }
+    return 0;
+}

package/dist/slices/images/run.js

@@ -6,6 +6,7 @@ import { insertPiece, piecesOf, setPiece } from "../../kernel/runner/piece-repo.
 import { projectById, setStageProgress } from "../admission/repo.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({
@@ -28,13 +29,13 @@ export async function runImages(deps, context, providers) {
     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 Retry stage.");
+        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). Retry stage; if it happens again, use Download diagnostics in Settings and report it.");
+        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.
@@ -73,14 +74,16 @@ function plan(deps, context, config) {
         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). Retry stage; if it happens again, use Download diagnostics in Settings and report it.`);
+            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 <= picked.number; send += 1) {
+        for (let send = 1; send <= (counts[at] ?? picked.number); send += 1) {
             planned.push({
                 id: deps.ids.next(),
                 stageId: context.stage.id,
@@ -224,7 +227,7 @@ function report(deps, context, done, total) {
 }
 function payloadOf(piece) {
     if (piece.payload === null) {
-        throw new Error("Slopify hit an internal error (a saved image step is empty). Retry stage; if it happens again, use Download diagnostics in Settings and report it.");
+        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/images/scale.js

@@ -0,0 +1,84 @@
+import { imagesPerRunMax } from "../admission/rules.js";
+// ceiling: one image an hour is the least that still scales; one every 15 seconds is the
+// most, which is already as fast as the default Seconds per image shows them.
+export const imagesPerHourMin = 1;
+export const imagesPerHourMax = 240;
+// "Every N minutes" spells the same range.
+export const everyMinutesMin = 60 / imagesPerHourMax;
+export const everyMinutesMax = 60 / imagesPerHourMin;
+// ceiling: a hand-set run stops at `imagesPerRunMax` (60), which is one image every two
+// minutes of a two-hour video. A scaled run may plan up to 240, four hours at one a minute:
+// the images are drawn a few at a time under the image provider's own rate limits and the
+// render joins its clips one at a time, so the count costs time and money, both of which the
+// estimate shows before the run starts, rather than anything breaking. Past 240 the count is
+// capped and Play says so.
+export const scaledImagesMax = 240;
+export const expectedWordsMax = 100000;
+// Play's starting expected words (Review).
+export const defaultExpectedWords = 1500;
+// The estimate's own assumption (`estimate/requests.ts`).
+export const spokenWordsPerMinute = 150;
+// How many images a project's revision may hold: a scaled run's cap, else the hand-set one.
+export function imagesPerVideoMax(config) {
+    return config.imageScale === undefined ? imagesPerRunMax : scaledImagesMax;
+}
+export function wordCount(text) {
+    return text.split(/\s+/).filter((word) => word !== "").length;
+}
+export function narrationMinutes(words) {
+    return words / spokenWordsPerMinute;
+}
+// Images per hour, rounded to four places so "every 7 minutes" is stored as a plain number
+// that reads back as 7.
+export function perHourFromMinutes(minutes) {
+    return Math.round((60 / minutes) * 10000) / 10000;
+}
+// The setting as Play's control spells it: "every N minutes" when N is a whole or a quarter
+// minute, else "N per hour".
+export function imageScaleForm(scale) {
+    const minutes = 60 / scale.perHour;
+    const quarters = Math.round(minutes * 4);
+    return Math.abs(minutes * 4 - quarters) < 0.001
+        ? { every: "minutes", value: String(quarters / 4) }
+        : { every: "hour", value: String(scale.perHour) };
+}
+// What the length asks for, before the prompts' own Numbers are counted: one image per
+// started stretch, capped at `scaledImagesMax`.
+export function scaledTarget(scale) {
+    // The small epsilon keeps a length that is exactly a whole number of stretches (a rounded
+    // 60 / 7) from asking for one more.
+    const exact = (narrationMinutes(scale.words) * scale.perHour) / 60;
+    return Math.min(Math.max(Math.ceil(exact - 1e-9), 0), scaledImagesMax);
+}
+// Whether the run scales its images: set, and the images are generated from prompts.
+export function scalesImages(draft) {
+    return draft.imageScale !== undefined && draft.sources.images === "generate";
+}
+// How many images each ticked prompt makes, in prompt order. Without the setting it is each
+// prompt's Number, exactly as before it existed.
+export function imageCountsOf(draft) {
+    const counts = draft.imagePrompts.map((prompt) => prompt.number);
+    if (!scalesImages(draft) || counts.length === 0)
+        return counts;
+    const floor = counts.reduce((sum, count) => sum + count, 0);
+    const extra = scaledTarget(draft.imageScale) - floor;
+    for (let at = 0; at < extra; at += 1) {
+        const index = at % counts.length;
+        counts[index] = (counts[index] ?? 0) + 1;
+    }
+    return counts;
+}
+// The images the run makes from its prompts.
+export function plannedImageCount(draft) {
+    return imageCountsOf(draft).reduce((sum, count) => sum + count, 0);
+}
+// Admission's sentence for a stored setting out of range; Play's control says the same.
+export function imageScaleProblem(scale) {
+    if (!Number.isFinite(scale.perHour) ||
+        scale.perHour < imagesPerHourMin ||
+        scale.perHour > imagesPerHourMax)
+        return `Enter between ${String(imagesPerHourMin)} and ${String(imagesPerHourMax)} images per hour (one every ${String(everyMinutesMin)} to ${String(everyMinutesMax)} minutes) under Images → More images for long videos.`;
+    if (!Number.isInteger(scale.words) || scale.words < 1 || scale.words > expectedWordsMax)
+        return `Enter the expected words (Review) as a whole number between 1 and ${String(expectedWordsMax)}; the image count for long videos is planned from it.`;
+    return undefined;
+}

package/dist/slices/library/diff.js

@@ -0,0 +1,122 @@
+// A word-level diff for History's side-by-side view. Browser-safe: the Library screen diffs the
+// two versions it already holds. Words and the whitespace between them are the units, so a
+// changed word is marked on its own and line breaks survive for the view to show.
+// Past this many changed words the two texts are too different for a word diff to help, and
+// the Myers trace would grow with it: the view shows the one removed and the other added.
+const maxEdits = 4000;
+export function tokens(text) {
+    return text.match(/\s+|[^\s]+/gu) ?? [];
+}
+// The parts of both texts in order. `same` parts belong to both sides, `removed` to the older
+// text only and `added` to the newer only; neighbours of one kind are joined.
+export function wordDiff(before, after) {
+    const a = tokens(before);
+    const b = tokens(after);
+    // The common head and tail are cut first: most edits touch a small part of a long prompt.
+    let head = 0;
+    while (head < a.length && head < b.length && a[head] === b[head])
+        head += 1;
+    let tail = 0;
+    while (tail < a.length - head &&
+        tail < b.length - head &&
+        a[a.length - 1 - tail] === b[b.length - 1 - tail])
+        tail += 1;
+    const parts = [];
+    push(parts, "same", a.slice(0, head).join(""));
+    const middleA = a.slice(head, a.length - tail);
+    const middleB = b.slice(head, b.length - tail);
+    for (const part of myers(middleA, middleB))
+        push(parts, part.op, part.text);
+    push(parts, "same", a.slice(a.length - tail).join(""));
+    return parts;
+}
+// One side of the side-by-side view: the older text keeps what was removed, the newer what
+// was added.
+export function sideOf(parts, side) {
+    const hidden = side === "before" ? "added" : "removed";
+    return parts.filter((part) => part.op !== hidden);
+}
+export function diffCounts(parts) {
+    const words = (op) => parts
+        .filter((part) => part.op === op)
+        .reduce((sum, part) => sum + tokens(part.text).filter((one) => one.trim() !== "").length, 0);
+    return { added: words("added"), removed: words("removed") };
+}
+function push(parts, op, text) {
+    if (text === "")
+        return;
+    const last = parts.at(-1);
+    if (last !== undefined && last.op === op)
+        parts[parts.length - 1] = { op, text: last.text + text };
+    else
+        parts.push({ op, text });
+}
+// Myers' O((N+M)D) shortest edit script, walked back from the end through the saved frontiers.
+function myers(a, b) {
+    if (a.length === 0 && b.length === 0)
+        return [];
+    if (a.length === 0)
+        return [{ op: "added", text: b.join("") }];
+    if (b.length === 0)
+        return [{ op: "removed", text: a.join("") }];
+    const n = a.length;
+    const m = b.length;
+    const max = Math.min(n + m, maxEdits);
+    const offset = max + 1;
+    let v = new Int32Array(2 * max + 3);
+    const trace = [];
+    let found = false;
+    for (let d = 0; d <= max && !found; d += 1) {
+        trace.push(v.slice());
+        const next = v.slice();
+        for (let k = -d; k <= d; k += 2) {
+            const down = k === -d || (k !== d && (v[offset + k - 1] ?? 0) < (v[offset + k + 1] ?? 0));
+            let x = down ? (v[offset + k + 1] ?? 0) : (v[offset + k - 1] ?? 0) + 1;
+            let y = x - k;
+            while (x < n && y < m && a[x] === b[y]) {
+                x += 1;
+                y += 1;
+            }
+            next[offset + k] = x;
+            if (x >= n && y >= m) {
+                found = true;
+                break;
+            }
+        }
+        v = next;
+    }
+    if (!found)
+        return [
+            { op: "removed", text: a.join("") },
+            { op: "added", text: b.join("") },
+        ];
+    // Backtrack: each frontier in `trace` is the state before step d.
+    const script = [];
+    let x = n;
+    let y = m;
+    for (let d = trace.length - 1; d >= 0; d -= 1) {
+        const before = trace[d] ?? new Int32Array(0);
+        const k = x - y;
+        const down = k === -d || (k !== d && (before[offset + k - 1] ?? 0) < (before[offset + k + 1] ?? 0));
+        const previousK = down ? k + 1 : k - 1;
+        const previousX = before[offset + previousK] ?? 0;
+        const previousY = previousX - previousK;
+        while (x > previousX && y > previousY) {
+            script.push({ op: "same", text: a[x - 1] ?? "" });
+            x -= 1;
+            y -= 1;
+        }
+        if (d > 0) {
+            if (down)
+                script.push({ op: "added", text: b[y - 1] ?? "" });
+            else
+                script.push({ op: "removed", text: a[x - 1] ?? "" });
+            x = previousX;
+            y = previousY;
+        }
+    }
+    const parts = [];
+    for (const part of script.reverse())
+        push(parts, part.op, part.text);
+    return parts;
+}