@gentbajko/slopify 0.5.1 → 0.7.0

package/dist/edge/http/fonts.js

@@ -0,0 +1,147 @@
+import { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
+import { Busboy } from "@fastify/busboy";
+import { zValidator } from "@hono/zod-validator";
+import { Hono } from "hono";
+import { z } from "zod";
+import { fontIdPattern, fontMaxBytes, isMissingFont, listFonts, previewFont, uploadFont, } from "../../slices/fonts/index.js";
+import { problem, titleOf } from "./problem.js";
+const idParam = z.object({ id: z.string().regex(fontIdPattern) });
+// Inferred so the Hono client retains all response shapes.
+export function fontsRoutes(deps) {
+    return new Hono()
+        .get("/", async (c) => c.json({ fonts: await listFonts(deps.paths) }))
+        .post("/", async (c) => {
+        const contentType = c.req.header("content-type");
+        if (contentType === undefined || !contentType.toLowerCase().startsWith("multipart/form-data"))
+            return problem(c, {
+                status: 415,
+                title: titleOf(415),
+                detail: "Upload one .ttf or .otf file as multipart/form-data.",
+            });
+        const body = c.req.raw.body;
+        if (body === null)
+            return problem(c, {
+                status: 400,
+                title: titleOf(400),
+                detail: "The request carried no font file.",
+            });
+        const part = await readUpload(contentType, body);
+        if (!part.ok) {
+            const tooLarge = part.reason === "too-large";
+            return problem(c, {
+                status: tooLarge ? 413 : 400,
+                title: tooLarge ? "Content Too Large" : titleOf(400),
+                detail: tooLarge
+                    ? "A font file must be no larger than 32 MiB."
+                    : "Upload exactly one complete font file in the file part.",
+            });
+        }
+        const result = await uploadFont(deps.paths, part.upload);
+        if (!result.ok)
+            return problem(c, failure(result.reason));
+        return c.json({ font: result.font }, 201);
+    })
+        .get("/:id/file", zValidator("param", idParam, (result, c) => {
+        if (!result.success)
+            return problem(c, { status: 404, title: titleOf(404), detail: "No font has that id." });
+        return undefined;
+    }), async (c) => {
+        try {
+            const preview = await previewFont(deps.paths, c.req.valid("param").id);
+            return c.body(Uint8Array.from(preview.content), 200, {
+                "content-type": preview.contentType,
+                "x-content-type-options": "nosniff",
+                "cache-control": "private, max-age=300",
+            });
+        }
+        catch (error) {
+            if (!isMissingFont(error))
+                throw error;
+            return problem(c, { status: 404, title: titleOf(404), detail: "No font has that id." });
+        }
+    });
+}
+// Bounded buffering is intentional for small font files. No file is committed until
+// the entire multipart envelope finishes, so a second part or truncation cannot save it.
+async function readUpload(contentType, body) {
+    let parser;
+    try {
+        parser = new Busboy({
+            headers: { "content-type": contentType },
+            preservePath: true,
+            limits: { files: 1, fields: 0, parts: 1, fileSize: fontMaxBytes + 1 },
+        });
+    }
+    catch {
+        return { ok: false, reason: "multipart" };
+    }
+    const chunks = [];
+    let filename;
+    let count = 0;
+    let invalid = false;
+    let tooLarge = false;
+    parser.on("file", (field, stream, name) => {
+        filename = name;
+        if (field !== "file")
+            invalid = true;
+        stream.on("data", (chunk) => {
+            count += chunk.byteLength;
+            if (count > fontMaxBytes)
+                tooLarge = true;
+            else
+                chunks.push(chunk);
+        });
+        stream.on("limit", () => {
+            tooLarge = true;
+        });
+        stream.on("error", (error) => {
+            invalid = true;
+            parser.destroy(error);
+        });
+    });
+    parser.on("filesLimit", () => {
+        invalid = true;
+    });
+    parser.on("fieldsLimit", () => {
+        invalid = true;
+    });
+    parser.on("partsLimit", () => {
+        invalid = true;
+    });
+    try {
+        await pipeline(Readable.fromWeb(body), parser);
+    }
+    catch {
+        return { ok: false, reason: "multipart" };
+    }
+    if (tooLarge)
+        return { ok: false, reason: "too-large" };
+    if (invalid || filename === undefined)
+        return { ok: false, reason: "multipart" };
+    return { ok: true, upload: { filename, content: Buffer.concat(chunks, count) } };
+}
+function failure(reason) {
+    switch (reason) {
+        case "too-large":
+            return {
+                status: 413,
+                title: "Content Too Large",
+                detail: "A font file must be no larger than 32 MiB.",
+            };
+        case "unsupported-format":
+            return { status: 415, title: titleOf(415), detail: "Choose a .ttf or .otf font file." };
+        case "unsafe-filename":
+            return {
+                status: 400,
+                title: titleOf(400),
+                detail: "The font filename cannot contain a path or control character.",
+            };
+        case "invalid-font":
+            return {
+                status: 400,
+                title: titleOf(400),
+                detail: "This file is not a supported, valid TrueType or OpenType font.",
+            };
+    }
+}

package/dist/edge/http/projects.js

@@ -6,6 +6,7 @@ import { listProjects, projectById, runDraftSchema, stageStandingsByProject, sta
 import { admit } from "../../slices/admission/rules.js";
 import { startRun } from "../../slices/admission/start.js";
 import { withProjectControl } from "../../slices/control/lock.js";
+import { resolveFont } from "../../slices/fonts/index.js";
 import { pickTemplates, renderPicked } from "../../slices/library/slots.js";
 import { deleteProject } from "../../slices/storage/delete-project.js";
 import { outputsOf, stagedFiles } from "../../slices/storage/repo.js";
@@ -44,7 +45,28 @@ export function projectRoutes(deps) {
         status: derive(stagesOf(deps.db, project.id), project.paused),
     });
     return (new Hono()
-        .post("/", zValidator("json", runDraftSchema, onInvalid), (c) => {
+        .post("/", zValidator("json", runDraftSchema, onInvalid), async (c) => {
+        const requestedSubtitles = c.req.valid("json").subtitles;
+        if (requestedSubtitles !== undefined && requestedSubtitles.mode !== "off") {
+            try {
+                await resolveFont(deps.paths, requestedSubtitles.fontId);
+            }
+            catch {
+                return problem(c, {
+                    status: 400,
+                    title: titleOf(400),
+                    detail: "Choose an available subtitle font before starting.",
+                    extensions: {
+                        fields: [
+                            {
+                                field: "subtitles.fontId",
+                                message: "This font is no longer available; choose another or upload it again.",
+                            },
+                        ],
+                    },
+                });
+            }
+        }
         // The bodies are read here, at the click, so an edit made since the
         // prompt was selected is the one that runs.
         const picked = pickTemplates(deps.db, c.req.valid("json"));

package/dist/edge/http/providers.js

@@ -1,30 +1,58 @@
 import { zValidator } from "@hono/zod-validator";
 import { Hono } from "hono";
 import { z } from "zod";
+import { cliPathMaxLength, saveCliPath } from "../../slices/settings/cli-paths.js";
 import { keyStatus, removeProviderKey, saveProviderKey } from "../../slices/settings/keys.js";
 import { providerById, providerIds } from "../../slices/settings/model.js";
+import { createModelCatalog } from "../../slices/settings/models.js";
 import { providerStatuses } from "../../slices/settings/readiness.js";
 import { onInvalid, problem, titleOf } from "./problem.js";
 const providerParam = z.object({ id: z.enum(providerIds) });
 // ceiling: no format check is allowed on a key, so the only thing said about the value is
 // that it is a string of a length a key could plausibly have. Raise the bound if a provider
 // ever issues something longer.
+const pathBody = z.object({ path: z.string().max(cliPathMaxLength) });
 const keyBody = z.object({ key: z.string().min(1).max(4096) });
 // The return type is inferred so Hono keeps the route types the SPA's client is
 // generated from; see stagingRoutes.
 export function providerRoutes(deps) {
     const keys = { db: deps.db, clock: deps.clock };
     const readiness = { db: deps.db, probe: deps.probe };
+    const catalog = createModelCatalog({
+        load: deps.modelsFor ?? (() => Promise.reject(new Error("Model catalog unavailable"))),
+        fallback: deps.fallbackModelsFor ?? (() => []),
+        now: () => deps.clock.now().getTime(),
+        report: (provider) => deps.log.write("warn", "model-catalog", { detail: `Could not load models for ${provider}` }),
+    });
     return (new Hono()
         // What Settings draws its rails from and Play its dropdowns: every provider, with
         // the one fact that decides whether it is selectable.
         .get("/", async (c) => c.json({ providers: await providerStatuses(readiness) }))
+        .get("/:id/models", zValidator("param", providerParam, onInvalid), async (c) => {
+        const { id } = c.req.valid("param");
+        const result = await catalog.get(id, providerById(id).family, c.req.query("refresh") === "1");
+        c.header("Cache-Control", "no-store");
+        return c.json(result);
+    })
+        .put("/:id/path", zValidator("param", providerParam, onInvalid), zValidator("json", pathBody, onInvalid), async (c) => {
+        const result = await saveCliPath(readiness, c.req.valid("param").id, c.req.valid("json").path);
+        if (!result.ok)
+            return problem(c, {
+                status: 400,
+                title: titleOf(400),
+                detail: result.message,
+                extensions: { fields: [{ field: "path", message: result.message }] },
+            });
+        catalog.invalidate(c.req.valid("param").id);
+        return c.json(result.status);
+    })
         .put("/:id/key", zValidator("param", providerParam, onInvalid), zValidator("json", keyBody, onInvalid), (c) => {
         const { id } = c.req.valid("param");
         const result = saveProviderKey(keys, id, c.req.valid("json").key);
         if (!result.ok) {
             return refusal(c, id, result.reason);
         }
+        catalog.invalidate(id);
         // The response says a key is stored and shows the mask, never the value.
         return c.json(keyStatus(keys, id));
     })
@@ -34,6 +62,7 @@ export function providerRoutes(deps) {
         if (!result.ok) {
             return refusal(c, id, result.reason);
         }
+        catalog.invalidate(id);
         return c.body(null, 204);
     }));
 }

package/dist/edge/http/subtitles.js

@@ -0,0 +1,92 @@
+import { zValidator } from "@hono/zod-validator";
+import { Hono } from "hono";
+import { z } from "zod";
+import { transact } from "../../kernel/db/tx.js";
+import { derive } from "../../kernel/runner/graph.js";
+import { projectById, resetStage, stagesOf, updateProjectConfig, } from "../../slices/admission/repo.js";
+import { withProjectControl } from "../../slices/control/lock.js";
+import { resolveFont } from "../../slices/fonts/index.js";
+import { outputsOf } from "../../slices/storage/repo.js";
+import { subtitleConfigSchema } from "../../slices/subtitles/model.js";
+import { onInvalid, problem, titleOf } from "./problem.js";
+const idParam = z.object({
+    id: z
+        .string()
+        .min(1)
+        .max(64)
+        .regex(/^[0-9A-Za-z_-]+$/),
+});
+export function subtitleRoutes(deps) {
+    return new Hono().patch("/:id/subtitles", zValidator("param", idParam, onInvalid), zValidator("json", subtitleConfigSchema, onInvalid), async (c) => {
+        const { id } = c.req.valid("param");
+        return withProjectControl(deps.db, id, async () => {
+            const project = projectById(deps.db, id);
+            if (project === undefined)
+                return problem(c, {
+                    status: 404,
+                    title: titleOf(404),
+                    detail: "No project has that id.",
+                });
+            const stages = stagesOf(deps.db, id);
+            if (stages.some((stage) => stage.state === "running") || deps.runner.hasInflight?.(id))
+                return problem(c, {
+                    status: 409,
+                    title: titleOf(409),
+                    detail: "Pause the run and wait for its active work to stop before changing subtitles.",
+                });
+            const chosen = c.req.valid("json");
+            if (chosen.mode !== "off" && project.config.sources.audio === "off")
+                return problem(c, {
+                    status: 400,
+                    title: titleOf(400),
+                    detail: "Subtitles need narration audio.",
+                });
+            const subtitles = project.config.sources.video === "off" && chosen.mode === "burn-in"
+                ? { ...chosen, mode: "files" }
+                : chosen;
+            if (subtitles.mode !== "off" && subtitles.fontId !== project.config.subtitles?.fontId) {
+                try {
+                    await resolveFont(deps.paths, subtitles.fontId);
+                }
+                catch {
+                    return problem(c, {
+                        status: 400,
+                        title: titleOf(400),
+                        detail: "That font is no longer available. Choose another font or upload it again.",
+                    });
+                }
+            }
+            // Font discovery awaits filesystem work; a pending runner may have claimed a
+            // stage during that time. Recheck synchronously immediately before the write.
+            if (stagesOf(deps.db, id).some((stage) => stage.state === "running") ||
+                deps.runner.hasInflight?.(id)) {
+                return problem(c, {
+                    status: 409,
+                    title: titleOf(409),
+                    detail: "Pause the run before changing subtitles.",
+                });
+            }
+            const video = stages.find((stage) => stage.kind === "video");
+            transact(deps.db, () => {
+                updateProjectConfig(deps.db, id, { ...project.config, subtitles }, deps.clock.now().toISOString());
+                // Only the local final export is invalidated. Existing provider outputs and
+                // the last finished export remain intact until its replacement succeeds.
+                if (video !== undefined &&
+                    (project.config.sources.audio !== "off" || project.config.sources.video !== "off"))
+                    resetStage(deps.db, video.id);
+            });
+            deps.hub.emit(id, { type: "project.updated", projectId: id });
+            if (project.paused !== true)
+                deps.runner.tick(id);
+            const current = stagesOf(deps.db, id);
+            return c.json({
+                project: {
+                    ...projectById(deps.db, id),
+                    status: derive(current, project.paused === true),
+                },
+                stages: current,
+                outputs: outputsOf(deps.db, id),
+            });
+        });
+    });
+}

package/dist/edge/http/update.js

@@ -0,0 +1,57 @@
+import { Hono } from "hono";
+import { problem, titleOf } from "./problem.js";
+export function updateRoutes(deps) {
+    const unavailable = {
+        currentVersion: deps.version,
+        latestVersion: null,
+        available: false,
+        busy: false,
+        canUpdate: false,
+        status: "idle",
+        blockedReason: "In-app updates are unavailable for this server.",
+    };
+    return new Hono()
+        .get("/ready", (c) => {
+        c.header("Cache-Control", "no-store");
+        if (!deps.updater?.ready(c.req.header("X-Slopify-Update-Token") ?? ""))
+            return problem(c, { status: 403, title: titleOf(403) });
+        return c.json({ status: "ok", version: deps.version });
+    })
+        .post("/activate", async (c) => {
+        c.header("Cache-Control", "no-store");
+        const token = c.req.header("X-Slopify-Update-Token") ?? "";
+        if (!deps.updater?.ready(token))
+            return problem(c, { status: 403, title: titleOf(403) });
+        if (!(await deps.updater.activate(token)))
+            return problem(c, { status: 409, title: titleOf(409) });
+        return c.json({ status: "ok", version: deps.version });
+    })
+        .get("/", async (c) => {
+        c.header("Cache-Control", "no-store");
+        return c.json(deps.updater === undefined
+            ? unavailable
+            : await deps.updater.check(c.req.query("refresh") === "1"));
+    })
+        .post("/", 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: "Start updates from the Slopify page on this server.",
+            });
+        if (deps.updater === undefined)
+            return problem(c, { status: 409, title: titleOf(409), detail: unavailable.blockedReason });
+        const result = await deps.updater.start();
+        if (result.ok)
+            return c.json(result.info, 202);
+        const status = result.code ?? 409;
+        return problem(c, {
+            status,
+            title: titleOf(status),
+            detail: result.info.blockedReason ??
+                result.info.error ??
+                "No newer published update is available.",
+        });
+    });
+}

package/dist/edge/update-worker.js

@@ -0,0 +1,44 @@
+import { readFile, rm } from "node:fs/promises";
+import { updatePlanSchema } from "../updater/plan.js";
+import { performUpdate } from "../updater/worker.js";
+const planPath = process.argv[2];
+try {
+    if (planPath === undefined || !process.connected)
+        throw new Error("An update plan and parent process are required.");
+    const plan = updatePlanSchema.parse(JSON.parse(await readFile(planPath, "utf8")));
+    await rm(planPath, { force: true });
+    await performUpdate(plan, () => new Promise((resolve, reject) => {
+        if (!process.connected) {
+            reject(new Error("The update parent disconnected."));
+            return;
+        }
+        const fail = () => {
+            clearTimeout(timer);
+            reject(new Error("The update parent disconnected."));
+        };
+        const timer = setTimeout(() => reject(new Error("The update handoff timed out.")), 60_000);
+        process.once("disconnect", fail);
+        process.once("message", (message) => {
+            clearTimeout(timer);
+            process.off("disconnect", fail);
+            if (typeof message === "object" &&
+                message !== null &&
+                "type" in message &&
+                message.type === "handoff")
+                resolve();
+            else
+                reject(new Error("The update handoff was refused."));
+        });
+        process.send?.({ type: "installed" }, (error) => {
+            if (error !== null)
+                fail();
+        });
+    }));
+    if (process.connected)
+        process.disconnect?.();
+}
+catch {
+    if (process.connected)
+        process.disconnect?.();
+    process.exitCode = 1;
+}

package/dist/kernel/audio-preview.js

@@ -0,0 +1,188 @@
+import { randomUUID } from "node:crypto";
+const inactive = { append: () => { }, complete: () => { }, interrupt: () => { } };
+// A preview is a disposable copy of bytes from the paid call already in flight.
+// It never initiates synthesis, persists audio, or backpressures the provider.
+// Readers pull from shared bounded storage, so a slow browser cannot grow a queue.
+export function createAudioPreviewStore(limits = {}) {
+    const maxBytes = limits.maxBytes ?? 64 * 1024 * 1024;
+    const maxEntryBytes = limits.maxEntryBytes ?? 16 * 1024 * 1024;
+    const maxEntries = limits.maxEntries ?? 128;
+    const keepMs = limits.keepMs ?? 5 * 60_000;
+    const now = limits.now ?? Date.now;
+    const entries = new Map();
+    let retained = 0;
+    let closed = false;
+    const notify = (entry) => {
+        const listeners = [...entry.changed];
+        entry.changed.clear();
+        for (const listener of listeners)
+            listener();
+    };
+    const stop = (entry, state) => {
+        retained -= entry.bytes;
+        entry.bytes = 0;
+        entry.chunks.length = 0;
+        entry.state = state;
+        entry.endedAt = now();
+        notify(entry);
+    };
+    const remove = (entry) => {
+        stop(entry, "interrupted");
+        entries.delete(entry.id);
+    };
+    const prune = () => {
+        for (const entry of entries.values()) {
+            if (entry.endedAt !== undefined && now() - entry.endedAt >= keepMs)
+                remove(entry);
+        }
+    };
+    const expiry = setInterval(prune, Math.min(keepMs, 30_000));
+    expiry.unref();
+    const store = {
+        begin(projectId, key, label) {
+            if (closed)
+                return inactive;
+            prune();
+            for (const entry of entries.values()) {
+                if (entry.projectId === projectId && entry.key === key)
+                    remove(entry);
+            }
+            // At capacity, completed previews yield to current generation. Otherwise
+            // this request has no preview; the normal durable narration still succeeds.
+            if (entries.size >= maxEntries) {
+                const oldest = [...entries.values()].find((entry) => entry.state !== "streaming");
+                if (oldest !== undefined)
+                    remove(oldest);
+            }
+            if (entries.size >= maxEntries)
+                return inactive;
+            const entry = {
+                id: randomUUID(),
+                projectId,
+                key,
+                label,
+                chunks: [],
+                changed: new Set(),
+                state: "streaming",
+                bytes: 0,
+                endedAt: undefined,
+            };
+            entries.set(entry.id, entry);
+            const active = () => entries.get(entry.id) === entry && entry.state === "streaming";
+            return {
+                append(bytes) {
+                    if (!active() || bytes.byteLength === 0)
+                        return;
+                    if (retained + bytes.byteLength > maxBytes ||
+                        entry.bytes + bytes.byteLength > maxEntryBytes) {
+                        stop(entry, "unavailable");
+                        return;
+                    }
+                    // Own these bounded buffers. A provider may reuse its read buffer.
+                    for (let at = 0; at < bytes.byteLength; at += 64 * 1024) {
+                        entry.chunks.push(bytes.slice(at, at + 64 * 1024));
+                    }
+                    retained += bytes.byteLength;
+                    entry.bytes += bytes.byteLength;
+                    notify(entry);
+                },
+                complete() {
+                    if (!active())
+                        return;
+                    entry.state = "ready";
+                    entry.endedAt = now();
+                    notify(entry);
+                },
+                interrupt() {
+                    if (active())
+                        stop(entry, "interrupted");
+                },
+            };
+        },
+        list(projectId) {
+            prune();
+            return [...entries.values()]
+                .filter((entry) => entry.projectId === projectId)
+                .map(({ id, label, state, bytes }) => ({ id, label, state, bytes }));
+        },
+        stream(projectId, id, signal) {
+            prune();
+            const entry = entries.get(id);
+            if (entry === undefined ||
+                entry.projectId !== projectId ||
+                entry.state === "interrupted" ||
+                entry.state === "unavailable")
+                return undefined;
+            return follow(entry, signal);
+        },
+        clear(projectId) {
+            for (const entry of entries.values())
+                if (entry.projectId === projectId)
+                    remove(entry);
+        },
+        close() {
+            closed = true;
+            clearInterval(expiry);
+            for (const entry of entries.values())
+                remove(entry);
+        },
+    };
+    return store;
+}
+function follow(entry, signal) {
+    let index = 0;
+    let ended = false;
+    let wake;
+    let control;
+    const detach = () => {
+        ended = true;
+        signal.removeEventListener("abort", abort);
+        if (wake !== undefined) {
+            entry.changed.delete(wake);
+            wake();
+            wake = undefined;
+        }
+    };
+    const abort = () => {
+        if (ended)
+            return;
+        detach();
+        control?.error(new Error("Audio preview disconnected"));
+    };
+    return new ReadableStream({
+        start(controller) {
+            control = controller;
+            if (signal.aborted)
+                abort();
+            else
+                signal.addEventListener("abort", abort, { once: true });
+        },
+        async pull(controller) {
+            while (!ended) {
+                if (entry.state === "interrupted" || entry.state === "unavailable") {
+                    detach();
+                    controller.error(new Error("Audio preview was interrupted"));
+                    return;
+                }
+                const bytes = entry.chunks[index];
+                if (bytes !== undefined) {
+                    index += 1;
+                    controller.enqueue(bytes);
+                    return;
+                }
+                if (entry.state === "ready") {
+                    detach();
+                    controller.close();
+                    return;
+                }
+                await new Promise((resolve) => {
+                    wake = resolve;
+                    entry.changed.add(resolve);
+                });
+            }
+        },
+        cancel() {
+            detach();
+        },
+    }, { highWaterMark: 0 });
+}

package/dist/kernel/cli-command.js

@@ -0,0 +1,45 @@
+import { readFileSync, statSync } from "node:fs";
+import { extname, isAbsolute, join, resolve, win32 } from "node:path";
+// Keep prompts out of cmd.exe: npm launchers name a JavaScript entry point that
+// Node can execute directly with an argv array, including quotes and newlines.
+export function cliCommand(binary) {
+    const file = process.platform === "win32" ? windowsFile(binary) : binary;
+    if (/\.[cm]?js$/i.test(file))
+        return { file: process.execPath, args: [resolve(file)] };
+    if (process.platform !== "win32" || !/\.(cmd|bat)$/i.test(file))
+        return { file, args: [] };
+    const stat = statSync(file);
+    if (!stat.isFile() || stat.size > 64 * 1024)
+        throw unsupportedShim();
+    const target = windowsShimTarget(file, readFileSync(file, "utf8"));
+    if (target === undefined || !statSync(target, { throwIfNoEntry: false })?.isFile())
+        throw unsupportedShim();
+    return { file: process.execPath, args: [target] };
+}
+export function windowsShimTarget(file, source) {
+    if (!/(?:node|bun)(?:\.exe)?/i.test(source))
+        return undefined;
+    // npm's cmd-shim uses %dp0%, older launchers use %~dp0. The remainder must
+    // be a literal relative script path, followed by the original argument list.
+    const matched = /"(?:%dp0%|%~dp0)[\\/]?([^"%\r\n]+\.[cm]?js)"\s+%\*/i.exec(source);
+    if (matched?.[1] === undefined || win32.isAbsolute(matched[1]))
+        return undefined;
+    return win32.resolve(win32.dirname(file), matched[1]);
+}
+function windowsFile(binary) {
+    const path = Object.entries(process.env).find(([key]) => key.toLowerCase() === "path")?.[1] ?? "";
+    const directories = isAbsolute(binary) || /[\\/]/.test(binary) ? [""] : path.split(";");
+    const suffixes = extname(binary) === "" ? [".exe", ".com", ".cmd", ".bat", ""] : [""];
+    for (const directory of directories) {
+        for (const suffix of suffixes) {
+            const file = directory === "" ? binary + suffix : join(directory.replace(/^"|"$/g, ""), binary + suffix);
+            if (statSync(file, { throwIfNoEntry: false })?.isFile())
+                return resolve(file);
+        }
+    }
+    // Let spawn report its usual ENOENT when no executable exists.
+    return binary;
+}
+function unsupportedShim() {
+    return new Error("This batch launcher is not a supported Node CLI shim. Select the CLI's .exe or JavaScript entry file instead.");
+}