@gentbajko/slopify 2.5.0 → 3.0.0

package/dist/kernel/ports/languages.js

@@ -0,0 +1,157 @@
+import { z } from "zod";
+// The language a project is made in: what the LLM writes, what the voice speaks, how the
+// narration is split into sentences and how the captions are timed. Absent on every run
+// config, draft, template and channel saved before it existed, and absent is English, so
+// nothing about those changes. Only a language other than English is ever stored.
+export const writingSystems = [
+    "latin",
+    "cyrillic",
+    "greek",
+    "arabic",
+    "hebrew",
+    "devanagari",
+    "thai",
+    "cjk",
+    "hangul",
+];
+export const languageList = [
+    { code: "en", name: "English", native: "English", script: "latin", timing: "english" },
+    { code: "es", name: "Spanish", native: "Español", script: "latin", timing: "multilingual" },
+    { code: "de", name: "German", native: "Deutsch", script: "latin", timing: "multilingual" },
+    { code: "fr", name: "French", native: "Français", script: "latin", timing: "multilingual" },
+    { code: "it", name: "Italian", native: "Italiano", script: "latin", timing: "multilingual" },
+    { code: "pt", name: "Portuguese", native: "Português", script: "latin", timing: "multilingual" },
+    { code: "nl", name: "Dutch", native: "Nederlands", script: "latin", timing: "multilingual" },
+    { code: "ca", name: "Catalan", native: "Català", script: "latin", timing: "multilingual" },
+    { code: "pl", name: "Polish", native: "Polski", script: "latin", timing: "multilingual" },
+    { code: "cs", name: "Czech", native: "Čeština", script: "latin", timing: "multilingual" },
+    { code: "ro", name: "Romanian", native: "Română", script: "latin", timing: "sentences" },
+    { code: "sv", name: "Swedish", native: "Svenska", script: "latin", timing: "sentences" },
+    { code: "da", name: "Danish", native: "Dansk", script: "latin", timing: "sentences" },
+    { code: "nb", name: "Norwegian", native: "Norsk bokmål", script: "latin", timing: "sentences" },
+    { code: "fi", name: "Finnish", native: "Suomi", script: "latin", timing: "sentences" },
+    { code: "hu", name: "Hungarian", native: "Magyar", script: "latin", timing: "sentences" },
+    { code: "tr", name: "Turkish", native: "Türkçe", script: "latin", timing: "sentences" },
+    {
+        code: "id",
+        name: "Indonesian",
+        native: "Bahasa Indonesia",
+        script: "latin",
+        timing: "sentences",
+    },
+    { code: "vi", name: "Vietnamese", native: "Tiếng Việt", script: "latin", timing: "sentences" },
+    { code: "el", name: "Greek", native: "Ελληνικά", script: "greek", timing: "sentences" },
+    { code: "ru", name: "Russian", native: "Русский", script: "cyrillic", timing: "sentences" },
+    { code: "uk", name: "Ukrainian", native: "Українська", script: "cyrillic", timing: "sentences" },
+    { code: "ar", name: "Arabic", native: "العربية", script: "arabic", timing: "sentences" },
+    { code: "he", name: "Hebrew", native: "עברית", script: "hebrew", timing: "sentences" },
+    { code: "hi", name: "Hindi", native: "हिन्दी", script: "devanagari", timing: "sentences" },
+    { code: "th", name: "Thai", native: "ไทย", script: "thai", timing: "sentences" },
+    { code: "ja", name: "Japanese", native: "日本語", script: "cjk", timing: "sentences" },
+    { code: "zh", name: "Chinese", native: "中文", script: "cjk", timing: "sentences" },
+    { code: "ko", name: "Korean", native: "한국어", script: "hangul", timing: "sentences" },
+];
+export const languageCodes = languageList.map((language) => language.code);
+export const defaultLanguage = "en";
+export const languageSchema = z.enum(languageCodes);
+export function languageInfo(code) {
+    return (languageList.find((language) => language.code === (code ?? defaultLanguage)) ?? languageList[0]);
+}
+// The project's language; absent is English.
+export function projectLanguage(config) {
+    return config.language ?? defaultLanguage;
+}
+export function isEnglish(config) {
+    return projectLanguage(config) === defaultLanguage;
+}
+// The line added to every prompt that writes for the audience, when the project is not in
+// English. It is the app's own sentence, added after the user's prompt rather than written
+// into it, so the prompt library stays as the user wrote it; an English project gets nothing,
+// and its requests (and their fingerprints) stay exactly as they were.
+export function languageInstruction(language) {
+    if (language === undefined || language === defaultLanguage)
+        return undefined;
+    const { name, native } = languageInfo(language);
+    return `Language: write everything meant for the audience (article, narration, titles, descriptions, chapter names, hashtags and tags) in ${name} (${native}), even where the instructions above are written in English. Keep JSON keys, markup and any heading or label the instructions say to use exactly as given.`;
+}
+// The messages with the language line added: to the system message when there is one, since
+// the last user message is sometimes the source text itself; otherwise to the end of the last
+// user message. English returns the very same messages.
+export function withLanguage(messages, language) {
+    const instruction = languageInstruction(language);
+    if (instruction === undefined)
+        return messages;
+    const system = messages.findIndex((message) => message.role === "system");
+    const target = system !== -1 ? system : messages.findLastIndex((message) => message.role === "user");
+    if (target === -1)
+        return messages;
+    return messages.map((message, index) => index === target ? { ...message, content: `${message.content}\n\n${instruction}` } : message);
+}
+// Why word-by-word features are off in a language timed by sentences, or undefined when they
+// are available. The same sentence is shown beside every control it turns off.
+export function wordTimingUnavailable(code) {
+    const language = languageInfo(code);
+    if (language.timing !== "sentences")
+        return undefined;
+    return `Word timing isn't available for ${language.name} yet, so captions are timed sentence by sentence: each sentence is shown for the part of the narration that reads it. Word-by-word captions and cuts that follow the narration need word timing and are off.`;
+}
+// The letters a caption font needs for a language: its alphabet beyond a–z, or a sample of
+// its script. A font missing any of them draws empty boxes in that language's captions.
+const extraLetters = {
+    es: "áéíóúüñ¿¡",
+    de: "äöüß",
+    fr: "àâæçèéêëîïôœùûüÿ",
+    it: "àèéìíîòóù",
+    pt: "áâãàçéêíóôõú",
+    ca: "àèéíïòóúüç·",
+    nl: "éëïóöü",
+    pl: "ąćęłńóśźż",
+    cs: "áčďéěíňóřšťúůýž",
+    ro: "ăâîșț",
+    sv: "åäö",
+    da: "æøå",
+    nb: "æøå",
+    fi: "äö",
+    hu: "áéíóöőúüű",
+    tr: "çğıöşü",
+    vi: "ăâđêôơưạảấầẩẫậắằẳẵặẹẻẽếềểễệỉịọỏốồổỗộớờởỡợụủứừửữựỳỵỷỹ",
+    el: "αβγδεζηθικλμνξοπρστυφχψωάέήίόύώΑΩ",
+    ru: "абвгдеёжзийклмнопрстуфхцчшщъыьэюяАЯ",
+    uk: "абвгґдеєжзиіїйклмнопрстуфхцчшщьюяАЯ",
+    ar: "ابتثجحخدذرزسشصضطظعغفقكلمنهوي",
+    he: "אבגדהוזחטיכלמנסעפצקרשת",
+    hi: "अआइईउऊएऐओऔकखगघचछजझटठडढणतथदधनपफबभमयरलवशषसह",
+    th: "กขคงจฉชซญดตถทนบปผพฟภมยรลวสหอฮ",
+    ja: "あいうえおかきくけこアイウエオ日本語",
+    zh: "的一是不了人我在有他这中大来上国个到说们为子和你地出道也时年",
+    ko: "가나다라마바사아자차카타파하한국어",
+};
+export function languageLetters(code) {
+    const info = languageInfo(code);
+    const letters = `${info.script === "latin" ? "abcdefghijklmnopqrstuvwxyz" : ""}${extraLetters[info.code] ?? ""}`;
+    return [...new Set(Array.from(letters, (letter) => letter.codePointAt(0) ?? 0))];
+}
+// Whether a codepoint belongs to a writing system; used to decide whether a caption font
+// covers the project's letters without reading the font for every character.
+export function writingSystemOf(codepoint) {
+    const inRange = (from, to) => codepoint >= from && codepoint <= to;
+    if (inRange(0x41, 0x5a) || inRange(0x61, 0x7a) || inRange(0xc0, 0x24f) || inRange(0x1e00, 0x1eff))
+        return "latin";
+    if (inRange(0x370, 0x3ff) || inRange(0x1f00, 0x1fff))
+        return "greek";
+    if (inRange(0x400, 0x52f))
+        return "cyrillic";
+    if (inRange(0x590, 0x5ff))
+        return "hebrew";
+    if (inRange(0x600, 0x6ff) || inRange(0x750, 0x77f) || inRange(0xfb50, 0xfdff))
+        return "arabic";
+    if (inRange(0x900, 0x97f))
+        return "devanagari";
+    if (inRange(0xe00, 0xe7f))
+        return "thai";
+    if (inRange(0x1100, 0x11ff) || inRange(0xac00, 0xd7af))
+        return "hangul";
+    if (inRange(0x3040, 0x30ff) || inRange(0x3400, 0x4dbf) || inRange(0x4e00, 0x9fff))
+        return "cjk";
+    return undefined;
+}

package/dist/kernel/ports/model.js

@@ -7,15 +7,17 @@ export function readinessIsUsable(readiness) {
         : readiness.installed && readiness.issue === undefined;
 }
 export const providerErrorKinds = [
+    // A key the provider rejected. Like an absent one it fails at once: no wait fixes it.
     "auth",
-    // Distinct from `auth`, a key the provider rejected: a bad key runs the whole retry
-    // policy, an absent one fails immediately.
     "missing_key",
     "unavailable",
     "rate_limit",
     "refusal",
     "unsupported",
     "timeout",
+    // The connection, the provider's server or the CLI process went away before an answer:
+    // nothing says the request itself was wrong, so it is worth sending again later.
+    "dropped",
     "other",
 ];
 export function providerError(init) {
@@ -23,6 +25,7 @@ export function providerError(init) {
         fault: {
             kind: init.kind,
             ...(init.retryAfterMs === undefined ? {} : { retryAfterMs: init.retryAfterMs }),
+            ...(init.planLimit === undefined ? {} : { planLimit: init.planLimit }),
         },
     });
 }

package/dist/kernel/ports/narration-aliases.js

@@ -0,0 +1,60 @@
+// Narration aliases: a written word or phrase and how the narrator should say it ("Dr." as
+// "Doctor"). They change only what is sent to the voice (and to Narration Preparation);
+// the article, the transcript and the captions keep the written form. The same matcher runs
+// where the text is narrated and where captions are timed against that narration, so both
+// agree on which words were said differently. It lives with the ports because the caption
+// aligner (an adapter, which may import only ports) needs it as much as the recipes do.
+export const aliasWrittenMax = 200;
+export const aliasSpokenMax = 500;
+export const aliasCountMax = 1000;
+const wordCharacter = /[\p{L}\p{M}\p{N}_]/u;
+// Every place an alias applies: leftmost first, the longest written form where two start at
+// the same place, never overlapping.
+export function aliasMatches(text, aliases) {
+    const found = [];
+    for (const alias of aliases) {
+        const written = alias.written.trim();
+        if (written === "")
+            continue;
+        const pattern = written
+            .split(/\s+/u)
+            .map((word) => word.replace(/[|\\{}()[\]^$+*?.]/gu, "\\$&"))
+            .join("\\s+");
+        const expression = new RegExp(pattern, alias.caseSensitive ? "gu" : "giu");
+        const first = Array.from(written)[0] ?? "";
+        const last = Array.from(written).at(-1) ?? "";
+        for (const match of text.matchAll(expression)) {
+            const start = match.index;
+            const end = start + match[0].length;
+            if (alias.wholeWord) {
+                const before = Array.from(text.slice(Math.max(0, start - 2), start)).at(-1) ?? "";
+                const after = Array.from(text.slice(end, end + 2))[0] ?? "";
+                if (wordCharacter.test(first) && wordCharacter.test(before))
+                    continue;
+                if (wordCharacter.test(last) && wordCharacter.test(after))
+                    continue;
+            }
+            found.push({ start, end, spoken: alias.spoken });
+        }
+    }
+    found.sort((a, b) => a.start - b.start || b.end - a.end);
+    const chosen = [];
+    let reached = 0;
+    for (const match of found) {
+        if (match.start < reached)
+            continue;
+        chosen.push(match);
+        reached = match.end;
+    }
+    return chosen;
+}
+// The same text as the narrator should read it.
+export function applyAliases(text, aliases) {
+    let out = "";
+    let at = 0;
+    for (const match of aliasMatches(text, aliases)) {
+        out += text.slice(at, match.start) + match.spoken;
+        at = match.end;
+    }
+    return out + text.slice(at);
+}

package/dist/kernel/ports/plan-limits.js

@@ -0,0 +1,36 @@
+// The plan limits of the command-line agents: Claude Code, Codex and Gemini are billed to
+// the user's subscription, which gives them a share of a 5-hour and a weekly allowance rather
+// than a bill. Only what a CLI reports is ever recorded here; nothing is estimated.
+// The subscription a CLI provider draws on. Codex text and Codex images share one login and
+// so one allowance.
+export const planAccounts = ["claude-code", "codex", "gemini"];
+export function planAccountOf(provider) {
+    if (provider === "claude-code")
+        return "claude-code";
+    if (provider === "codex" || provider === "codex-image")
+        return "codex";
+    if (provider === "gemini")
+        return "gemini";
+    return undefined;
+}
+export const planAccountNames = {
+    "claude-code": "Claude",
+    codex: "Codex",
+    gemini: "Gemini",
+};
+// A window of `minutes` length, named the way the screens name it.
+export function windowKindOf(minutes) {
+    if (minutes === 300)
+        return "five_hour";
+    if (minutes === 10_080)
+        return "weekly";
+    return "other";
+}
+// Epoch seconds or milliseconds to ISO, null for anything that is not a plausible time.
+export function isoOfEpoch(value) {
+    if (value === null || value === undefined || !Number.isFinite(value) || value <= 0)
+        return null;
+    const ms = value < 1e12 ? value * 1000 : value;
+    const date = new Date(ms);
+    return Number.isNaN(date.getTime()) ? null : date.toISOString();
+}

package/dist/kernel/runner/attempt.js

@@ -14,15 +14,18 @@ export const timeoutMs = {
     video: 900_000,
 };
 // A refusal and an unsupported capability are the provider's final answer; retrying only
-// spends the user's money again. The third is a key removed mid-run, which leaves nothing
-// to call with. A key the provider rejected is different: that is an `auth` failure,
-// retried like any other.
+// spends the user's money again. A key the provider rejected, or one removed mid-run, needs
+// the user in Settings before any call can succeed.
 const terminalKinds = [
     "refusal",
     "unsupported",
+    "auth",
     "missing_key",
     "unavailable",
 ];
+// A Retry-After longer than this is not slept through with the stage holding its provider
+// slot: the call fails here and the runner's persisted wait (`retry-policy.ts`) takes over.
+export const inCallRetryAfterCeilingMs = 60_000;
 export async function attempt(ctx, call, opts) {
     ctx.signal.throwIfAborted();
     const limit = opts.timeoutMs ?? timeoutMs[opts.kind];
@@ -84,7 +87,12 @@ export async function attempt(ctx, call, opts) {
             stage: ctx.stage,
             detail: `${opts.kind} attempt ${n} of ${attemptLimit} failed (${failure.fault.kind}): ${failure.message}`,
         });
-        if (terminalKinds.includes(failure.fault.kind) || n >= attemptLimit) {
+        // A used-up plan allowance is not retried here: the call waits for the reset outside the
+        // provider queue (providers.ts), so a waiting stage holds no slot other work needs.
+        if (terminalKinds.includes(failure.fault.kind) ||
+            failure.fault.planLimit !== undefined ||
+            n >= attemptLimit ||
+            (failure.fault.retryAfterMs ?? 0) > inCallRetryAfterCeilingMs) {
             throw failure;
         }
         // A 429 that names a Retry-After replaces the fixed wait with the provider's.
@@ -102,8 +110,8 @@ function classify(error, expired, opts, limit) {
         return providerError({
             kind: "timeout",
             message: opts.streaming === true
-                ? `The ${callee[opts.kind]} sent nothing for ${seconds} seconds, so Slopify stopped waiting. It may be overloaded: wait a few minutes, then use Retry stage.`
-                : `The ${callee[opts.kind]} did not answer within ${seconds} seconds. It may be overloaded: wait a few minutes, then use Retry stage, or choose another model in the Providers section of Edit project.`,
+                ? `The ${callee[opts.kind]} sent nothing for ${seconds} seconds, so Slopify stopped waiting. It may be overloaded: wait a few minutes, then use Try again.`
+                : `The ${callee[opts.kind]} did not answer within ${seconds} seconds. It may be overloaded: wait a few minutes, then use Try again, or choose another model in the Providers section of Edit project.`,
         });
     }
     if (isProviderError(error)) {
@@ -113,14 +121,15 @@ function classify(error, expired, opts, limit) {
             kind: error.fault.kind,
             message: redact(error.message),
             ...(error.fault.retryAfterMs === undefined ? {} : { retryAfterMs: error.fault.retryAfterMs }),
+            ...(error.fault.planLimit === undefined ? {} : { planLimit: error.fault.planLimit }),
         });
     }
     if (unreachable(error)) {
         // `fetch` names only itself; the cause's code (ENOTFOUND, ECONNREFUSED) is the clue.
         const code = causeCode(error);
         return providerError({
-            kind: "other",
-            message: `Slopify could not reach the ${callee[opts.kind]} over the internet${code === undefined ? "" : ` (${code})`}. Check your internet connection, firewall or VPN, then use Retry stage.`,
+            kind: "dropped",
+            message: `Slopify could not reach the ${callee[opts.kind]} over the internet${code === undefined ? "" : ` (${code})`}. Check your internet connection, firewall or VPN, then use Try again.`,
         });
     }
     return providerError({

package/dist/kernel/runner/audition.js

@@ -0,0 +1,36 @@
+import { attempt } from "./attempt.js";
+const unrecorded = {
+    start: () => "audition",
+    end: () => { },
+};
+export function auditionVoice(deps, call, signal) {
+    const port = deps.registry.tts(call.provider);
+    return attempt({
+        work: {
+            projectId: "audition",
+            revisionId: "audition",
+            workId: "audition",
+            stageId: "audition",
+            kind: "audio",
+            fingerprint: "audition",
+        },
+        maySubmit: () => true,
+        clock: deps.clock,
+        log: deps.log,
+        attempts: unrecorded,
+        projectId: "audition",
+        stage: "audio",
+        stageId: "audition",
+        signal,
+    }, async (inner, progress) => {
+        const spoken = await port.synthesize({
+            model: call.model,
+            voiceId: call.voiceId,
+            text: call.text,
+            signal: inner,
+            onActivity: progress,
+        });
+        const bytes = new Uint8Array(await new Response(spoken.audio).arrayBuffer());
+        return { bytes, container: spoken.container };
+    }, { kind: "tts", streaming: port.capabilities.streams });
+}

package/dist/kernel/runner/graph.js

@@ -1,33 +1,39 @@
 // Images use saved prompts and can run immediately. A thumbnail's source and an
 // audio-only export narrow these dependencies through dependenciesOf(). The document is
 // laid out from the article alone, with the thumbnail as its cover when there is one, so it
-// runs beside narration and images rather than after them.
+// runs beside narration and images rather than after them. The video never reads the
+// thumbnail, so a thumbnail that fails does not hold the video back.
 export const deps = {
     research: [],
     article: ["research"],
     audio: ["article"],
     images: [],
     thumbnail: ["article"],
-    video: ["article", "audio", "images", "thumbnail"],
+    video: ["article", "audio", "images"],
     document: ["article", "thumbnail"],
 };
 // `provided` and `skipped` release a dependency exactly as `done` does.
 export function satisfied(state) {
     return state === "done" || state === "provided" || state === "skipped";
 }
+// What a run is for, in order: the first of these the run asks for is the one that has to be
+// there for the run to count as finished. Anything else failing leaves it done with
+// problems rather than failed.
+const headline = ["video", "audio", "article"];
 // Stage state is derived; an explicit persisted pause takes precedence while calls
-// drain. Completed independent images do not imply that a run was canceled.
+// drain. Completed independent images do not imply that a run was canceled. A stage
+// waiting out a rate limit is still part of a run in progress.
 export function derive(stages, paused = false) {
     if (paused)
         return "paused";
-    if (stages.some((stage) => stage.state === "running")) {
+    if (stages.some((stage) => stage.state === "running" || waiting(stage))) {
         return "running";
     }
     if (stages.some((stage) => stage.state === "canceled")) {
         return "canceled";
     }
     if (stages.some((stage) => stage.state === "failed")) {
-        return "failed";
+        return headlineMade(stages) ? "partial" : "failed";
     }
     if (stages.length > 0 && stages.every((stage) => satisfied(stage.state))) {
         return "done";
@@ -35,6 +41,19 @@ export function derive(stages, paused = false) {
     // Includes a run created but not yet claimed and unfinished work after restart.
     return "pending";
 }
+function waiting(stage) {
+    return stage.state === "pending" && stage.retryAt !== undefined && stage.retryAt !== null;
+}
+function headlineMade(stages) {
+    for (const kind of headline) {
+        const stage = stages.find((one) => one.kind === kind);
+        if (stage === undefined || stage.state === "skipped")
+            continue;
+        // A file the user supplied is not something this run made.
+        return stage.state === "done";
+    }
+    return false;
+}
 export function dependenciesOf(kind, sources) {
     if (kind === "thumbnail" && sources.thumbnail === "from_prompt")
         return [];

package/dist/kernel/runner/index.js

@@ -1,6 +1,7 @@
 import { causedBy } from "../errors.js";
 import { derive, deps as graph, satisfied } from "./graph.js";
 import { progressGate } from "./progress.js";
+import { faultOf } from "./retry-policy.js";
 const pauseReason = new Error("paused by user");
 export function createRunner(deps) {
     const inflight = new Map();
@@ -15,7 +16,7 @@ export function createRunner(deps) {
     const stopped = new Set();
     let count = 0;
     let shuttingDown = false;
-    const emitStage = (stage, state, reason) => {
+    const emitStage = (stage, state, reason, detail = {}) => {
         deps.emit(stage.projectId, {
             type: "stage.state",
             revisionId: stage.work.revisionId,
@@ -24,6 +25,8 @@ export function createRunner(deps) {
             stage: stage.kind,
             state,
             ...(reason === null ? {} : { failureReason: reason }),
+            ...(detail.retryAt === undefined ? {} : { retryAt: detail.retryAt }),
+            ...(detail.failureKind === undefined ? {} : { failureKind: detail.failureKind }),
         });
     };
     // The global tally counts projects with a stage in flight, read off the in-flight set
@@ -46,9 +49,9 @@ export function createRunner(deps) {
         announced.set(projectId, state);
         deps.emit(projectId, { type: "project.state", projectId, state });
     };
-    const conclude = (stage, state, reason) => {
+    const conclude = (stage, state, reason, kind) => {
         try {
-            deps.stages.finish(stage.work, state, reason);
+            deps.stages.finish(stage.work, state, reason, kind ?? null);
         }
         catch (error) {
             // The row stays `running` when the write fails. The event still goes out, and the
@@ -59,7 +62,31 @@ export function createRunner(deps) {
                 detail: reasonOf(error),
             });
         }
-        emitStage(stage, state, reason);
+        emitStage(stage, state, reason, { failureKind: kind });
+    };
+    // False when the failure is to be shown now.
+    const deferred = (stage, fault, reason) => {
+        let at;
+        try {
+            at = deps.stages.waitToRetry?.(stage.work, fault, reason);
+        }
+        catch (error) {
+            deps.log.write("error", "stage.retry", {
+                projectId: stage.projectId,
+                stage: stage.kind,
+                detail: reasonOf(error),
+            });
+            return false;
+        }
+        if (at === undefined)
+            return false;
+        deps.log.write("warn", "stage.retry", {
+            projectId: stage.projectId,
+            stage: stage.kind,
+            detail: `waiting until ${at} to run again after ${fault?.kind ?? "a failure"}: ${reason}`,
+        });
+        emitStage(stage, "pending", reason, { retryAt: at, failureKind: fault?.kind });
+        return true;
     };
     async function execute(stage, controller) {
         const tag = (event) => ({
@@ -103,12 +130,15 @@ export function createRunner(deps) {
                 conclude(stage, paused ? "pending" : "canceled", paused ? null : "canceled by user");
                 return;
             }
+            const fault = faultOf(error);
+            if (deferred(stage, fault, reasonOf(error)))
+                return;
             deps.log.write("error", "stage.failed", {
                 projectId: stage.projectId,
                 stage: stage.kind,
                 detail: causedBy(error),
             });
-            conclude(stage, "failed", reasonOf(error));
+            conclude(stage, "failed", reasonOf(error), fault?.kind);
         }
     }
     function start(stage) {

package/dist/kernel/runner/meter.js

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