@gentbajko/slopify 3.25.8 → 4.0.0

package/dist/adapters/account-limits.js

@@ -0,0 +1,30 @@
+import { statfs } from "node:fs/promises";
+import { z } from "zod";
+// The autopilot's hourly look at what may stop the schedules: the OpenRouter key's spending
+// limit (`GET /api/v1/key`, the same read Settings → Providers' Test makes) and the free disk.
+// Read-only: neither starts paid work.
+const keyAnswer = z.object({
+    data: z.object({ limit: z.number().nullable(), limit_remaining: z.number().nullable() }).loose(),
+});
+// The key's limit and what is left of it; null for a key with no limit. Throws, with the
+// status only, when OpenRouter refuses or answers something else: the caller skips the check.
+export async function openRouterKeyLimit(fetchImpl, key, signal) {
+    const response = await fetchImpl("https://openrouter.ai/api/v1/key", {
+        headers: { Authorization: `Bearer ${key}` },
+        signal,
+    });
+    if (!response.ok)
+        throw new Error(`OpenRouter answered ${String(response.status)}`);
+    const parsed = keyAnswer.safeParse(await response.json());
+    if (!parsed.success)
+        throw new Error("OpenRouter's answer wasn't the key's limits");
+    const { limit, limit_remaining: remaining } = parsed.data.data;
+    return limit === null || remaining === null ? null : { limit, remaining };
+}
+export async function diskSpaceAt(path) {
+    const stats = await statfs(path);
+    return {
+        freeBytes: Number(stats.bavail) * Number(stats.bsize),
+        totalBytes: Number(stats.blocks) * Number(stats.bsize),
+    };
+}

package/dist/adapters/alignment/cache.js

@@ -5,6 +5,7 @@ import { join } from "node:path";
 import { Readable } from "node:stream";
 import { pipeline } from "node:stream/promises";
 import { setTimeout as delay } from "node:timers/promises";
+import { hasErrnoCode } from "../../kernel/errors.js";
 import { defaultEnglishSubtitleModel, } from "../../kernel/ports/subtitles.js";
 // Xenova/wav2vec2-base-960h at one pinned revision, which carries the same model at three
 // precisions. Each keeps its own file name so the cache can hold any of them at once; int8
@@ -144,7 +145,7 @@ async function downloadModel(input, deps, target) {
         catch (error) {
             if (await verified(target, deps.model, input.signal))
                 return target;
-            if (!isCode(error, "EEXIST") && !isCode(error, "EPERM"))
+            if (!hasErrnoCode(error, "EEXIST") && !hasErrnoCode(error, "EPERM"))
                 throw error;
             await rm(target, { force: true });
             await rename(part, target);
@@ -187,11 +188,8 @@ async function verified(path, model, signal) {
         return hash.digest("hex") === model.sha256;
     }
     catch (error) {
-        if (isCode(error, "ENOENT"))
+        if (hasErrnoCode(error, "ENOENT"))
             return false;
         throw error;
     }
 }
-function isCode(error, code) {
-    return error instanceof Error && "code" in error && error.code === code;
-}

package/dist/adapters/alignment/ctc.js

@@ -1,6 +1,5 @@
-import { englishMismatch, englishSpec } from "./spec.js";
+import { englishSpec } from "./spec.js";
 export const frameSeconds = 0.02;
-export const mismatch = englishMismatch;
 export function alignWindow(logits, frames, words, complete, spec = englishSpec) {
     const labels = spec.labels;
     if (frames < 1 || frames > 1100 || logits.length !== frames * labels)

package/dist/adapters/alignment/lock.js

@@ -1,6 +1,7 @@
 import { open, readFile, rm, stat } from "node:fs/promises";
 import { join } from "node:path";
 import { setTimeout } from "node:timers/promises";
+import { hasErrnoCode } from "../../kernel/errors.js";
 // Models run one at a time per data directory, including requests from separate app
 // processes. A canceled waiter never removes another request's lock.
 export async function claimWorker(cacheDir, signal) {
@@ -26,7 +27,7 @@ export async function claimWorker(cacheDir, signal) {
             };
         }
         catch (error) {
-            if (!(error instanceof Error && "code" in error && error.code === "EEXIST"))
+            if (!hasErrnoCode(error, "EEXIST"))
                 throw error;
         }
         try {
@@ -41,7 +42,7 @@ export async function claimWorker(cacheDir, signal) {
                     process.kill(owner, 0);
                 }
                 catch (error) {
-                    if (error instanceof Error && "code" in error && error.code === "ESRCH") {
+                    if (hasErrnoCode(error, "ESRCH")) {
                         await rm(path, { force: true });
                         continue;
                     }
@@ -50,7 +51,7 @@ export async function claimWorker(cacheDir, signal) {
             }
         }
         catch (error) {
-            if (!(error instanceof Error && "code" in error && error.code === "ENOENT"))
+            if (!hasErrnoCode(error, "ENOENT"))
                 throw error;
         }
         await setTimeout(250, undefined, { signal });

package/dist/adapters/alignment/multilingual.js

@@ -121,9 +121,6 @@ export const multilingualGates = {
     anchorLetters: 20,
     anchorConfidence: 0.75,
 };
-export function multilingualLanguages() {
-    return Object.keys(alphabets);
-}
 // The model and language view the aligner uses for a project language. English keeps its own
 // model and every constant it had.
 export function alignmentSpecFor(language) {

package/dist/adapters/alignment/prefetch.js

@@ -1,5 +1,6 @@
 import { mkdir, readFile, rm } from "node:fs/promises";
 import { join } from "node:path";
+import { hasErrnoCode } from "../../kernel/errors.js";
 import { defaultEnglishSubtitleModel, } from "../../kernel/ports/subtitles.js";
 import { englishModels, prepareModel } from "./cache.js";
 import { claimWorker } from "./lock.js";
@@ -31,7 +32,7 @@ async function clearOwnLock(cacheDir) {
         owner = await readFile(path, "utf8");
     }
     catch (error) {
-        if (error instanceof Error && "code" in error && error.code === "ENOENT")
+        if (hasErrnoCode(error, "ENOENT"))
             return;
         throw error;
     }

package/dist/adapters/alignment/worker.js

@@ -1,4 +1,5 @@
 import { open, readFile, stat } from "node:fs/promises";
+import { errorText } from "../../kernel/errors.js";
 import { SubtitleMismatch } from "../../kernel/ports/subtitles.js";
 import { alignmentSpecFor } from "./multilingual.js";
 import { workerInput } from "./protocol.js";
@@ -15,7 +16,7 @@ process.once("message", (raw) => {
     }
     run(input.data).then((words) => send({ type: "done", words }), (error) => send({
         type: "error",
-        message: error instanceof Error ? error.message : String(error),
+        message: errorText(error),
         ...(error instanceof SubtitleMismatch
             ? { mismatch: { at: error.at, expected: error.expected, heard: error.heard } }
             : {}),

package/dist/adapters/explain.js

@@ -58,9 +58,6 @@ export function refusedImage(provider, detail) {
 export function voiceFix(voiceId) {
     return `Check that voice "${voiceId}" still exists in Settings → Voices and that each narration part fits the model's length limit (Chunking, in the Providers section of Edit project), then use Try again.`;
 }
-export function internalError(what) {
-    return `Slopify hit an internal error (${what}). Use Try again; if it happens again, use Download diagnostics in Settings and report it.`;
-}
 const cliNames = {
     claude: "Claude Code CLI",
     "claude-code": "Claude Code CLI",

package/dist/adapters/ffmpeg.js

@@ -4,6 +4,7 @@ import { createRequire } from "node:module";
 import { join } from "node:path";
 import { promisify } from "node:util";
 import { z } from "zod";
+import { errorText } from "../kernel/errors.js";
 import { redact } from "../kernel/log.js";
 // ffmpeg-static exports a path even when npm skipped its install script. Recover using
 // that dependency's own downloader, including its source notice and license, without
@@ -73,6 +74,23 @@ async function verify(bin) {
         throw new Error(`ffmpeg at ${bin} could not be started. Reinstall ffmpeg or check your antivirus has not quarantined it, then restart Slopify. ${remedy} ${detail(error)}`);
     }
 }
+// One short ffmpeg run to its end, answering its stdout; a failure carries the last thing it
+// said on stderr. For questions about an ffmpeg (its encoders, a test encode), never renders.
+export async function ffmpegOutput(bin, args) {
+    try {
+        const { stdout } = await promisify(execFile)(bin, [...args], {
+            windowsHide: true,
+            timeout: 30_000,
+            maxBuffer: 4 * 1024 * 1024,
+        });
+        return stdout;
+    }
+    catch (error) {
+        const stderr = z.object({ stderr: z.string() }).safeParse(error);
+        const said = stderr.success ? stderr.data.stderr.trim().split("\n").slice(-2).join(" / ") : "";
+        throw new Error(said === "" ? detail(error) : redact(said));
+    }
+}
 function detail(error) {
-    return redact(error instanceof Error ? error.message : String(error));
+    return redact(errorText(error));
 }

package/dist/adapters/host-cli/index.js

@@ -1,10 +1,11 @@
 import { redact } from "../../kernel/log.js";
 import { bridgeLimits, decodeHostImageReport, hostFaultSchema, hostFrameSchema, hostHealthSchema, hostImageReportHeader, hostImageSchema, hostLlmSchema, hostModelsSchema, hostOpenedSchema, hostOpenFolderSchema, hostStatusSchema, } from "../../kernel/ports/host-cli.js";
 import { agentImageTimeoutMs } from "../../kernel/ports/image.js";
-import { isProviderError, providerError } from "../../kernel/ports/model.js";
+import { isProviderError, providerError, } from "../../kernel/ports/model.js";
 import { sniffImage } from "../image/bytes.js";
 import { claudePlanLimit } from "../llm/claude-code.js";
 import { codexPlanLimit } from "../llm/codex-limits.js";
+import { accessField } from "../model-access.js";
 import { hostRequest, hostUnavailable, readHostBytes, } from "./transport.js";
 const tooBigForHost = "Slopify could not send this request to the host helper because it is larger than, or shaped differently from, what the helper accepts. Make the inputs shorter in Edit project, then use Try again; if it happens again, use Download diagnostics in Settings and report it.";
 export function createHostCliClient(options) {
@@ -16,7 +17,7 @@ export function createHostCliClient(options) {
             try {
                 const parsed = hostFaultSchema.safeParse(JSON.parse((await readHostBytes(response, bridgeLimits.status)).toString("utf8")));
                 if (parsed.success)
-                    throw providerError({ kind: parsed.data.kind, message: redact(parsed.data.message) });
+                    throw bridgedFault(parsed.data.kind, parsed.data.message);
             }
             catch (error) {
                 if (isProviderError(error))
@@ -163,6 +164,16 @@ export function createHostCliClient(options) {
                                 base64: Buffer.from(req.reference.bytes).toString("base64"),
                             },
                         }),
+                    ...(req.edit === undefined
+                        ? {}
+                        : {
+                            edit: {
+                                source: {
+                                    mime: req.edit.source.mime,
+                                    base64: Buffer.from(req.edit.source.bytes).toString("base64"),
+                                },
+                            },
+                        }),
                     ...(req.cast === undefined
                         ? {}
                         : {
@@ -216,6 +227,11 @@ export function createHostCliClient(options) {
         },
     };
 }
+// A fault from the host helper carries its kind and the host adapter's words only; whether it
+// was about the model's access is read again from those words, as the plan limit is below.
+export function bridgedFault(kind, message) {
+    return providerError({ kind, message: redact(message), ...accessField(null, message) });
+}
 // A used-up plan crosses the bridge as a rate-limit fault carrying the CLI's own words, which
 // the host-side adapter already quoted; they are read again here so a Docker run waits for the
 // reset like a local one instead of failing.
@@ -256,7 +272,7 @@ async function* readEvents(response) {
                     throw hostUnavailable(true);
                 const event = hostFrameSchema.parse(JSON.parse(line));
                 if (event.type === "error")
-                    throw providerError({ kind: event.kind, message: redact(event.message) });
+                    throw bridgedFault(event.kind, event.message);
                 if (event.type === "done")
                     terminal = event;
                 else

package/dist/adapters/http-failure.js

@@ -0,0 +1,53 @@
+import { providerError } from "../kernel/ports/model.js";
+import { missingKey } from "./explain.js";
+import { retryAfter } from "./retry-after.js";
+// The plumbing every HTTP provider adapter repeats around a failed call. What the provider
+// said and which sentence it earns stay in each adapter; only the shape is shared.
+export function safeJson(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return undefined;
+    }
+}
+// The body of a failed response, or nothing when it cannot be read.
+export async function failureText(response) {
+    return await response.text().catch(() => "");
+}
+// Only the adapter sees the vendor's status code, so only the adapter names the kind.
+export function kindOfStatus(status) {
+    if (status === 401 || status === 403) {
+        return "auth";
+    }
+    if (status === 429) {
+        return "rate_limit";
+    }
+    // ceiling: everything else is `other` and is retried, so a request the provider will never
+    // accept fails the same way four times over. A terminal "this will never work" kind has to
+    // reach the port's error contract first, which is not an adapter's to widen.
+    // The provider's own server failed; the same request may well succeed later.
+    if (status >= 500)
+        return "dropped";
+    return "other";
+}
+// `missing_key`, not `auth`, because that rule makes it terminal: an absent key never becomes
+// a request.
+export function requireKey(key, provider) {
+    if (key === undefined || key === "") {
+        throw providerError({ kind: "missing_key", message: missingKey(provider) });
+    }
+    return key;
+}
+// A 429's Retry-After replaces the fixed backoff; `fallbackRetryMs` is the provider's own
+// hint, used when the header is absent. `access` is what the failure says about the chosen
+// model (see model-access.ts); it never changes the kind.
+export function httpProviderError(response, kind, message, fallbackRetryMs, access) {
+    const retryAfterMs = retryAfter(response.headers.get("retry-after")) ?? fallbackRetryMs;
+    return providerError({
+        kind,
+        message,
+        ...(access === undefined ? {} : { access }),
+        ...(retryAfterMs === undefined ? {} : { retryAfterMs }),
+    });
+}

package/dist/adapters/image/codex.js

@@ -11,8 +11,9 @@ import { codexLimitError, readingOf } from "../llm/codex.js";
 import { codexPlanLimit } from "../llm/codex-limits.js";
 import { cliEvent, cliShaped, endedKind, endedWithout, stopCliRun, } from "../llm/run-cli.js";
 import { lines } from "../llm/sse-lines.js";
+import { accessField } from "../model-access.js";
 import { codexGeneratedImage, codexImageCount } from "./codex-output.js";
-import { referencePictures } from "./reference.js";
+import { attachedPictures, editNote } from "./reference.js";
 // "Codex default" puts no model and no effort on the command line, so the CLI's own defaults
 // draw the image; it is what every project saved before the choice existed runs. Every other
 // model id is one of the Codex CLI's own models - the list the Codex text provider shows -
@@ -46,7 +47,7 @@ const alwaysDisabled = [
 function reviews(req) {
     return (req.model !== codexImageModel.id ||
         req.thinking !== undefined ||
-        referencePictures(req).length > 0);
+        attachedPictures(req).length > 0);
 }
 // The binary's image tool (`ImagegenArgs`: prompt, referenced_image_paths,
 // num_last_images_to_include) takes each referenced image as an absolute path it reads
@@ -57,10 +58,12 @@ export function codexReferencePath(directory, image) {
 // Every picture the request carries, each at its own path: the establishing image keeps the
 // name it always had, the cast pictures follow it as reference-2, reference-3 and so on.
 export function codexReferencePaths(directory, req) {
-    return referencePictures(req).map((picture, index) => ({
+    return attachedPictures(req).map((picture, index) => ({
         picture,
         path: index === 0
-            ? codexReferencePath(directory, picture.image)
+            ? req.edit === undefined
+                ? codexReferencePath(directory, picture.image)
+                : join(directory, picture.image.mime === "image/jpeg" ? "source.jpg" : "source.png")
             : join(directory, `reference-${String(index + 1)}${picture.image.mime === "image/jpeg" ? ".jpg" : ".png"}`),
     }));
 }
@@ -78,7 +81,34 @@ function describeMember(req, name) {
     const description = req.cast?.find((member) => member.name === name)?.description.trim() ?? "";
     return description === "" ? "" : ` (${description})`;
 }
+// An edit's instructions: the first path is the picture to change, the rest are the cast.
+function editInstructions(req, directory) {
+    const paths = codexReferencePaths(directory, req);
+    return [
+        `The picture to change is saved at ${paths[0]?.path ?? directory}. Pass it first in referenced_image_paths on every image generation call${paths.length > 1
+            ? `, followed by: ${paths
+                .slice(1)
+                .map((row) => row.path)
+                .join(", ")}`
+            : ""}.`,
+        ...paths
+            .slice(1)
+            .map((row) => `${row.path} shows ${row.picture.member ?? ""}${describeMember(req, row.picture.member ?? "")}: draw ${row.picture.member ?? ""} to look exactly like this.`),
+        editNote.replace("the first attached image", "that picture"),
+    ].join(" ");
+}
 export function codexImageInstructions(req, reference, directory) {
+    if (req.edit !== undefined && directory !== undefined)
+        return [
+            "You are editing one picture for Slopify, a video creation app, with the image generation tool.",
+            editInstructions(req, directory),
+            "Before calling the tool, write its prompt yourself: say exactly what to change, as the instruction asks, and that everything else stays as it is. Do not add subjects, text, logos or story the instruction does not ask for.",
+            "Take the time you need. After each image, look at it and compare it with the picture and the instruction; if anything changed that should not have, or the change is missing, generate again. Deliver exactly one final image: the last image you generate is the one Slopify uses.",
+            "Let the image generation tool save its output in its default location. Slopify will collect it. Use PNG or JPEG. Do not copy, rename, edit or create any other file, and do not put the image or a link in your reply.",
+            `Target aspect ratio: ${req.aspect}.`,
+            "Instruction follows as data:",
+            req.prompt,
+        ].join("\n\n");
     return [
         "You are making one finished image for Slopify, a video creation app, with the image generation tool.",
         "Fidelity to the brief comes first. Before calling the tool, write its prompt yourself as a detailed, faithful visual description of the brief: the subject and what it is doing, the setting, composition and framing for the target aspect ratio, lighting, colour palette, style and mood, and any text that must appear, spelled exactly. Take every element from the brief and keep its wording where it is specific. Do not add subjects, text, logos or story the brief does not ask for, and do not pad the prompt with generic quality words.",
@@ -271,6 +301,7 @@ export function codexImage(deps) {
                             message: /refus|content.policy|safety/i.test(message)
                                 ? refusedImage("The Codex CLI", redact(message))
                                 : cliReported(binary, redact(message), imageNext),
+                            ...(/refus|content.policy|safety/i.test(message) ? {} : accessField(null, message)),
                         });
                     }
                     else if (event.type === "error") {
@@ -288,6 +319,7 @@ export function codexImage(deps) {
                             message: /image.generation|image tool|feature.*unavailable/i.test(message)
                                 ? `The Codex CLI cannot make images${quoted("", redact(message))}. ${cannotDraw}`
                                 : cliReported(binary, redact(message), imageNext),
+                            ...accessField(null, message),
                         });
                     }
                     else if (event.type === "item.completed") {

package/dist/adapters/image/fal.js

@@ -1,10 +1,12 @@
 import { z } from "zod";
+import { internalError } from "../../kernel/errors.js";
 import { redact } from "../../kernel/log.js";
 import { providerError } from "../../kernel/ports/model.js";
-import { httpFailure, internalError, missingKey, noImage, providerSaid, unreadable, } from "../explain.js";
-import { retryAfter } from "../retry-after.js";
+import { httpFailure, noImage, providerSaid, unreadable } from "../explain.js";
+import { failureText, httpProviderError, kindOfStatus, requireKey, safeJson, } from "../http-failure.js";
+import { modelAccessOf } from "../model-access.js";
 import { downloadImage } from "./bytes.js";
-import { referencePictures, withReferences } from "./reference.js";
+import { attachedPictures, promptFor } from "./reference.js";
 import { dataUri, downloadVideo } from "./video.js";
 // The HTTP gateway adapter for fal.ai: `fetch` and the downloader beside this file, no SDK.
 // `@fal-ai/client` would buy queue polling, which only the video clips need and which is three
@@ -60,6 +62,7 @@ const editModels = [
 function editEndpoint(model) {
     return editModels.includes(model) ? `${model}/edit` : undefined;
 }
+export const falEditRefusal = "This fal.ai model can't edit a picture. Choose FLUX.2 or Nano Banana 2 on fal.ai, or Codex CLI, OpenAI or Google, under Made with … · change.";
 // Image-to-video runs on fal's queue, not the synchronous host: a clip takes one to five
 // minutes, and fal documents the queue as the way to call anything that slow. A request is
 // submitted, its status polled until it completes, and its answer fetched from the links the
@@ -104,8 +107,10 @@ export function falImage(deps) {
             // `image_urls`; only the models that have one are marked as taking a reference.
             // Cast pictures ride the same list; a model without an edit endpoint gets the cast in
             // words instead, since only the establishing image is something the user turned on.
-            const pictures = referencePictures(req);
+            const pictures = attachedPictures(req);
             const edit = pictures.length === 0 ? undefined : editEndpoint(req.model);
+            if (req.edit !== undefined && edit === undefined)
+                throw providerError({ kind: "unsupported", message: falEditRefusal });
             if (req.reference !== undefined && edit === undefined)
                 throw providerError({
                     kind: "unsupported",
@@ -116,7 +121,7 @@ export function falImage(deps) {
                 signal: req.signal,
                 headers: { Authorization: `Key ${keyOf(deps)}`, "Content-Type": "application/json" },
                 body: JSON.stringify({
-                    prompt: withReferences(req.prompt, req, edit === undefined ? 0 : pictures.length),
+                    prompt: promptFor(req.prompt, req, edit === undefined ? 0 : pictures.length),
                     ...(edit === undefined
                         ? {}
                         : { image_urls: pictures.map((picture) => dataUri(picture.image)) }),
@@ -129,7 +134,7 @@ export function falImage(deps) {
                 }),
             });
             if (!response.ok) {
-                throw await failure(response);
+                throw await failure(response, "image request", true);
             }
             const answer = parse(await response.text());
             refused(answer, req.prompt);
@@ -162,7 +167,7 @@ export function falImage(deps) {
                 }),
             });
             if (!submitted.ok)
-                throw await failure(submitted, "video clip request");
+                throw await failure(submitted, "video clip request", true);
             const links = read(queued, await submitted.text());
             for (;;) {
                 const status = await deps.fetch(links.status_url, { signal: req.signal, headers });
@@ -198,12 +203,7 @@ function read(schema, text) {
     return parsed.data;
 }
 function keyOf(deps) {
-    // `missing_key`, not `auth`, because that rule makes it terminal.
-    const key = deps.key();
-    if (key === undefined || key === "") {
-        throw providerError({ kind: "missing_key", message: missingKey("fal.ai") });
-    }
-    return key;
+    return requireKey(deps.key(), "fal.ai");
 }
 // A content-policy refusal is final, named here and made terminal by the wrapper. fal declines
 // inside a 200 - the safety checker flags the image and hands back a blank one. With no
@@ -217,37 +217,12 @@ function refused(answer, prompt) {
         });
     }
 }
-// Only the adapter sees the vendor's status code, so only the adapter names the kind.
-function kindOf(status) {
-    if (status === 401 || status === 403) {
-        return "auth";
-    }
-    if (status === 429) {
-        return "rate_limit";
-    }
-    // ceiling: everything else is `other` and is retried, so a 422 naming an input this model
-    // does not take fails the same way four times over. A terminal "this will never work" kind
-    // has to reach the port's error contract first, which is not this adapter's to widen.
-    // The provider's own server failed; the same request may well succeed later.
-    if (status >= 500)
-        return "dropped";
-    return "other";
-}
-async function failure(response, subject = "image request") {
-    const text = await response.text().catch(() => "");
+// `atModel`: the request went to the model's own address, so a 404 or 403 is about the model.
+async function failure(response, subject = "image request", atModel = false) {
+    const text = await failureText(response);
     // The provider's own words, through the redactor - an error body may quote the key back.
     const message = redact(detailOf(text) || response.statusText);
-    const retryAfterMs = retryAfter(response.headers.get("retry-after"));
-    return providerError({
-        kind: kindOf(response.status),
-        message: httpFailure({
-            provider: "fal.ai",
-            status: response.status,
-            detail: message,
-            subject,
-        }),
-        ...(retryAfterMs === undefined ? {} : { retryAfterMs }),
-    });
+    return httpProviderError(response, kindOfStatus(response.status), httpFailure({ provider: "fal.ai", status: response.status, detail: message, subject }), undefined, modelAccessOf(response.status, text, atModel));
 }
 function detailOf(text) {
     const parsed = errorBody.safeParse(safeJson(text));
@@ -270,11 +245,3 @@ function parse(text) {
     }
     return parsed.data;
 }
-function safeJson(text) {
-    try {
-        return JSON.parse(text);
-    }
-    catch {
-        return undefined;
-    }
-}