cloving 1.0.1 → 1.2.0

package/dist/tools/admit-workflow.js

@@ -0,0 +1,94 @@
+import { spawn } from "node:child_process";
+import { createHash } from "node:crypto";
+import { mkdir, mkdtemp, readFile, realpath, rm, symlink, writeFile, } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { findPackageJSON } from "node:module";
+import { dirname, extname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { checkWorkflowCandidate, } from "../src/workflow-candidate.js";
+import { candidatePackageRoot, } from "./workflow-candidate-program.js";
+import { analyzeWorkflowCandidate } from "./workflow-candidate-source.js";
+import { isWorkflowManifest } from "./workflow-manifest.js";
+export async function admitWorkflowCandidate(input, installed = {}) {
+    const { source, declaration } = input;
+    if (Buffer.from(source, "utf8").toString("utf8") !== source)
+        return { kind: "refused", codes: ["unsupported-source"] };
+    try {
+        const packageRoot = resolve(installed.packageRoot ?? candidatePackageRoot);
+        const facts = analyzeWorkflowCandidate(source, { packageRoot });
+        const codes = checkWorkflowCandidate({ declaration, ...facts });
+        if (codes.length > 0)
+            return { kind: "refused", codes };
+        return await compiledCandidate(source, packageRoot);
+    }
+    catch {
+        return { kind: "refused", codes: ["compile-failed"] };
+    }
+}
+async function compiledCandidate(source, packageRoot) {
+    const directory = await realpath(await mkdtemp(join(tmpdir(), "cloving-candidate-")));
+    try {
+        await prepareCandidateProject(directory, { source, packageRoot });
+        if (!(await compile(directory)))
+            return { kind: "refused", codes: ["compile-failed"] };
+        const artifactDirectory = join(directory, "artifacts");
+        const manifest = JSON.parse(await readFile(join(artifactDirectory, "manifest.json"), "utf8"));
+        if (!isWorkflowManifest(manifest) ||
+            Object.values(manifest.workflows ?? {}).flatMap((entries) => Object.values(entries)).length !== 1)
+            return { kind: "refused", codes: ["compile-failed"] };
+        const digest = createHash("sha256");
+        for (const name of [
+            "manifest.json",
+            "flow.mjs",
+            "steps.mjs",
+            "client.mjs",
+        ]) {
+            const bytes = await readFile(join(artifactDirectory, name));
+            digest.update(JSON.stringify([name, bytes.length]));
+            digest.update(bytes);
+        }
+        return { kind: "admitted", artifactDigest: digest.digest("hex") };
+    }
+    finally {
+        await rm(directory, { recursive: true, force: true });
+    }
+}
+async function prepareCandidateProject(directory, input) {
+    const { source, packageRoot } = input;
+    await mkdir(join(directory, "workflows"));
+    await mkdir(join(directory, "node_modules"));
+    await symlink(packageRoot, join(directory, "node_modules/cloving"));
+    const runtime = findPackageJSON("workflow", import.meta.url);
+    if (!runtime)
+        throw new Error("candidate-runtime-unavailable");
+    await symlink(dirname(runtime), join(directory, "node_modules/workflow"));
+    await writeFile(join(directory, "package.json"), '{"name":"candidate-project","private":true,"type":"module"}');
+    await writeFile(join(directory, "tsconfig.json"), JSON.stringify({
+        compilerOptions: {
+            target: "ES2024",
+            module: "ESNext",
+            moduleResolution: "Bundler",
+            types: [],
+        },
+        include: ["workflows/candidate.ts"],
+    }));
+    await writeFile(join(directory, "workflows/candidate.ts"), source, "utf8");
+}
+function compile(directory) {
+    const extension = extname(fileURLToPath(import.meta.url));
+    const executable = fileURLToPath(new URL(`./compile-workflows${extension}`, import.meta.url));
+    return new Promise((settle) => {
+        const child = spawn(process.execPath, [executable, "workflows", "artifacts"], {
+            cwd: directory,
+            env: { PATH: dirname(process.execPath), TMPDIR: tmpdir() },
+            stdio: "ignore",
+            timeout: 30000,
+        });
+        child.once("error", () => {
+            settle(false);
+        });
+        child.once("close", (code) => {
+            settle(code === 0);
+        });
+    });
+}

package/dist/tools/self-host-processes.js

@@ -4,7 +4,7 @@ import { extname, join } from "node:path";
 import { setTimeout as delay } from "node:timers/promises";
 import { promisify } from "node:util";
 import { selfUpdater } from "./self-update.js";
-import { workerTurnActive } from "./self-update-host.js";
+import { selfUpdateActive } from "./self-update-host.js";
 function launched(argumentsList, settings) {
     const child = spawn(process.execPath, argumentsList, {
         cwd: settings.directory,
@@ -58,7 +58,11 @@ async function polled(settings, lifecycle) {
         directory: settings.directory,
         git: updatingGit(settings, lifecycle.stopping),
         active: async () => lifecycle.stopping.aborted ||
-            (await workerTurnActive(settings.directory)),
+            (await selfUpdateActive({
+                directory: settings.directory,
+                runtimeDirectory: settings.runtime,
+                signal: lifecycle.stopping,
+            })),
         stop: async () => {
             if (lifecycle.stopping.aborted)
                 throw new Error("self-update-stopped");
@@ -102,6 +106,7 @@ function hostedChildren(settings) {
             environment: {
                 ...process.env,
                 CLOVING_RUNTIME_DIR: settings.runtime,
+                CLOVING_WATCH_REPOSITORY: settings.repository,
             },
         }),
     ];

package/dist/tools/self-host-project.d.ts

@@ -0,0 +1,17 @@
+import { type DeclaredWorkflow } from "../src/workflow-declaration.ts";
+import type { WorkflowRefusal } from "../src/workflow-refusals.ts";
+interface ProjectSettings {
+    readonly product: string;
+    readonly project: string;
+    readonly repository: string;
+    readonly home: string;
+    readonly xdgConfigHome?: string | undefined;
+}
+export interface RegisteredWorkflows {
+    readonly repository: string;
+    readonly manifests: Readonly<Record<string, string>>;
+    readonly declarations: readonly DeclaredWorkflow[];
+    readonly workflowRefusals: readonly WorkflowRefusal[];
+}
+export declare function preparedProject(settings: ProjectSettings): Promise<RegisteredWorkflows>;
+export {};

package/dist/tools/self-host-project.js

@@ -0,0 +1,177 @@
+import { spawn } from "node:child_process";
+import { createHash } from "node:crypto";
+import { copyFile, mkdir, readFile, rm, symlink, writeFile, } from "node:fs/promises";
+import { findPackageJSON } from "node:module";
+import { basename, dirname, extname, join, resolve } from "node:path";
+import packageMetadata from "#package" with { type: "json" };
+import { record } from "../src/protocol.js";
+import { isWorkflowDeclaration, } from "../src/workflow-declaration.js";
+import { bundledWorkflowIds, } from "../src/workflow-discovery.js";
+import { workflowDeclarations, workflowFiles, workflowManifests, } from "./self-host-workflows.js";
+import { loadWorkflowFolders, } from "./workflow-folders.js";
+import { isWorkflowManifest } from "./workflow-manifest.js";
+import { retainWorkflowBundle } from "./workflow-bundles.js";
+import { workflowBundleDependencies, workflowPackageRoot, } from "./workflow-bundle-dependencies.js";
+async function initializeProject(settings) {
+    const { project, product } = settings;
+    await rm(project, { recursive: true, force: true });
+    await mkdir(join(project, "workflows"), { recursive: true, mode: 0o700 });
+    await writeFile(join(project, "package.json"), '{"name":"cloving-self-host","private":true,"type":"module"}');
+    const files = await workflowFiles(join(product, "workflows"));
+    for (const file of files)
+        await copyWorkflow(settings, file);
+    const modules = join(project, "node_modules");
+    await mkdir(join(modules, "cloving"), { recursive: true });
+    for (const name of Object.keys(packageMetadata.dependencies)) {
+        const location = findPackageJSON(name, join(product, "package.json"));
+        if (location === undefined)
+            throw new Error(`missing-runtime-dependency: ${name}`);
+        await mkdir(dirname(join(modules, name)), { recursive: true });
+        await symlink(dirname(location), join(modules, name));
+    }
+    await symlink(join(product, "src"), join(modules, "cloving", "src"));
+    await writeFile(join(modules, "cloving", "package.json"), JSON.stringify({
+        name: packageMetadata.name,
+        version: packageMetadata.version,
+        type: "module",
+        exports: Object.fromEntries(Object.keys(packageMetadata.exports)
+            .filter((subpath) => subpath.startsWith("./workflows"))
+            .map((subpath) => [
+            subpath,
+            `./src/${subpath.slice("./workflows/".length) || "workflows"}${extname(import.meta.filename)}`,
+        ])),
+    }));
+    return files;
+}
+async function compile(settings) {
+    const { product, project } = settings;
+    await rm(join(project, "artifacts"), { recursive: true, force: true });
+    await new Promise((settle, reject) => {
+        const child = spawn(process.execPath, [
+            join(product, `tools/compile-workflows${extname(import.meta.filename)}`),
+            "workflows",
+            "artifacts",
+        ], { cwd: project, env: process.env, stdio: "ignore", timeout: 30000 });
+        child.once("error", reject);
+        child.once("close", (code) => {
+            if (code === 0)
+                settle();
+            else
+                reject(new Error("The workflows did not compile."));
+        });
+    });
+    const compiled = JSON.parse(await readFile(join(project, "artifacts/manifest.json"), "utf8"));
+    if (!isWorkflowManifest(compiled))
+        throw new Error("The compiled workflow manifest is invalid.");
+    return compiled;
+}
+function reservations(input) {
+    const { files, manifests, declarations } = input;
+    return [
+        ...files.map((file) => ({
+            baseName: basename(file, extname(file)),
+        })),
+        ...Object.entries(manifests).map(([functionName, manifest]) => ({
+            baseName: manifest.name,
+            workflowId: manifest.workflowId,
+            functionName,
+        })),
+        ...[
+            ...Object.values(bundledWorkflowIds),
+            ...declarations.map((item) => item.workflowId),
+        ].map((workflowId) => ({ workflowId })),
+    ];
+}
+async function stageCandidates(project, candidates) {
+    if (candidates.length === 0)
+        return [];
+    const directory = join(project, "workflows", "operators");
+    await mkdir(directory, { mode: 0o700 });
+    const staged = [];
+    for (const candidate of candidates) {
+        const name = createHash("sha256")
+            .update(JSON.stringify([
+            candidate.scope,
+            candidate.baseName,
+            candidate.source,
+            candidate.declaration,
+        ]))
+            .digest("hex");
+        const file = join(directory, `${name}.ts`);
+        await writeFile(file, candidate.source);
+        await writeFile(join(directory, `${name}.declaration.json`), candidate.declaration);
+        staged.push({ candidate, file });
+    }
+    return staged;
+}
+function operatorDeclaration(staged, compiled) {
+    const { candidate, project } = staged;
+    const declaration = record(JSON.parse(candidate.declaration))?.["workflow"];
+    const entries = Object.entries(compiled.workflows ?? {}).filter(([file]) => resolve(project, file) === staged.file);
+    const functions = entries.flatMap(([, functions]) => Object.values(functions));
+    const [workflow] = functions;
+    if (!isWorkflowDeclaration(declaration) ||
+        functions.length !== 1 ||
+        workflow === undefined)
+        throw new Error("The admitted workflow is missing from the compiled bundle.");
+    return {
+        ...declaration,
+        capabilities: [...new Set(declaration.capabilities)],
+        functionName: workflow.workflowId.slice(workflow.workflowId.lastIndexOf("//") + 2),
+    };
+}
+async function copyWorkflow(settings, file) {
+    const { product, project } = settings;
+    await copyFile(join(product, "workflows", file), join(project, "workflows", file));
+    const sidecar = `${basename(file, extname(file))}.declaration.json`;
+    const declaration = await readFile(join(product, "workflows", sidecar)).catch((error) => {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT")
+            return undefined;
+        throw error;
+    });
+    if (declaration !== undefined)
+        await writeFile(join(project, "workflows", sidecar), declaration);
+}
+export async function preparedProject(settings) {
+    const { product, project } = settings;
+    const files = await initializeProject(settings);
+    let compiled = await compile(settings);
+    const bundled = workflowManifests(compiled);
+    const declarations = await workflowDeclarations(join(project, "workflows"), bundled);
+    const folders = await loadWorkflowFolders({
+        ...settings,
+        bundled: reservations({ files, manifests: bundled, declarations }),
+    }, { packageRoot: await workflowPackageRoot(product) });
+    const staged = await stageCandidates(project, folders.candidates);
+    if (staged.length > 0)
+        compiled = await compile(settings);
+    const combined = [
+        ...declarations,
+        ...staged.map((candidate) => operatorDeclaration({ ...candidate, project }, compiled)),
+    ];
+    const manifests = {};
+    for (const [functionName, manifest] of Object.entries(workflowManifests(compiled, combined))) {
+        const path = join(project, `${manifest.name}.workflow.json`);
+        await writeFile(path, JSON.stringify(manifest));
+        Object.defineProperty(manifests, functionName, {
+            value: path,
+            enumerable: true,
+        });
+    }
+    await writeFile(join(project, "declarations.json"), JSON.stringify(combined));
+    await writeFile(join(project, "dependencies.json"), await workflowBundleDependencies({
+        product,
+        packages: Object.keys(packageMetadata.dependencies),
+    }));
+    await retainWorkflowBundle({
+        project,
+        repository: folders.repository,
+        directory: join(dirname(project), "workflow-bundles"),
+    });
+    return {
+        repository: folders.repository,
+        manifests,
+        declarations: combined,
+        workflowRefusals: folders.refusals,
+    };
+}

package/dist/tools/self-host-workflows.d.ts

@@ -11,5 +11,5 @@ interface HostManifest {
 }
 export declare function workflowFiles(directory: string): Promise<string[]>;
 export declare function workflowDeclarations(directory: string, manifests: Readonly<Record<string, HostManifest>>): Promise<readonly DeclaredWorkflow[]>;
-export declare function workflowManifests(compiled: WorkflowManifest): Readonly<Record<string, HostManifest>>;
+export declare function workflowManifests(compiled: WorkflowManifest, declarations?: readonly DeclaredWorkflow[]): Readonly<Record<string, HostManifest>>;
 export {};

package/dist/tools/self-host-workflows.js

@@ -45,7 +45,7 @@ export async function workflowDeclarations(directory, manifests) {
     }
     return declarations;
 }
-export function workflowManifests(compiled) {
+export function workflowManifests(compiled, declarations = []) {
     const names = new Set();
     const steps = Object.values(compiled.steps ?? {})
         .flatMap((entries) => Object.values(entries))
@@ -68,7 +68,7 @@ export function workflowManifests(compiled) {
                     name: basename(file, extname(file)),
                     workflowId,
                     steps,
-                    capabilities: ["claude", "github"],
+                    capabilities: declarations.find((declaration) => declaration.functionName === functionName)?.capabilities ?? ["claude", "github"],
                     resources: [],
                     artifacts: "artifacts",
                 },

package/dist/tools/self-host.js

@@ -1,12 +1,11 @@
 import { isProfilesFile } from "../src/turn-profile.js";
-import { execFileSync, spawn } from "node:child_process";
-import { copyFile, mkdir, readFile, rm, symlink, writeFile, } from "node:fs/promises";
+import { parseFallbackModels, parseTokenPrices, } from "../src/token-prices.js";
+import { execFileSync } from "node:child_process";
+import { readFile, realpath, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
 import { dirname, extname, join, resolve } from "node:path";
-import packageMetadata from "#package" with { type: "json" };
-import { findPackageJSON } from "node:module";
 import { pathToFileURL } from "node:url";
-import { workflowDeclarations, workflowFiles, workflowManifests, } from "./self-host-workflows.js";
-import { isWorkflowManifest } from "./workflow-manifest.js";
+import { preparedProject, } from "./self-host-project.js";
 import { selfUpdateMilliseconds } from "./self-update-host.js";
 import { hostedPrograms } from "./self-host-processes.js";
 const product = resolve(import.meta.dirname, "..");
@@ -31,7 +30,7 @@ if (runtimeArgument === undefined)
     throw new Error("The start program needs --runtime. Use: cloving start");
 const runtime = resolve(runtimeArgument);
 const directory = dirname(runtime);
-const repository = topLevel(resolve(flag("--repository") ?? process.cwd()));
+const repository = await realpath(topLevel(resolve(flag("--repository") ?? process.cwd())));
 const updateMilliseconds = await selfUpdateMilliseconds({
     seconds: process.env["CLOVING_SELF_UPDATE_SECONDS"],
     repository,
@@ -83,6 +82,16 @@ async function profilesFile() {
     }
     throw new Error("The daemon did not start: invalid-profiles");
 }
+function queueLanes() {
+    const value = process.env["CLOVING_QUEUE_LANES"];
+    if (value === undefined)
+        return 1;
+    if (!/^[1-4]$/.test(value))
+        throw new Error("The daemon did not start: invalid-queue-lanes");
+    if (process.env["CLOVING_QUEUE_SECONDS"] === undefined)
+        throw new Error("The daemon did not start: queue-lanes-needs-queue");
+    return Number(value);
+}
 function queueInterval(commands) {
     const value = process.env["CLOVING_QUEUE_SECONDS"];
     if (value === undefined)
@@ -108,65 +117,6 @@ function listed(name) {
         throw new Error(`${name} is not a JSON list of texts.`);
     return list.map(String);
 }
-function record(value) {
-    return typeof value === "object" && value !== null ? { ...value } : {};
-}
-function ended(argumentsList, environment) {
-    return new Promise((settle, reject) => {
-        const child = spawn(process.execPath, argumentsList, {
-            cwd: project,
-            env: environment,
-            stdio: "inherit",
-        });
-        for (const signal of ["SIGINT", "SIGTERM"])
-            process.on(signal, () => child.kill(signal));
-        child.once("error", reject);
-        child.once("close", (status) => {
-            settle(status ?? 1);
-        });
-    });
-}
-async function linkedPackages() {
-    const modules = join(project, "node_modules");
-    await mkdir(join(modules, "cloving"), { recursive: true });
-    for (const name of Object.keys(packageMetadata.dependencies)) {
-        const location = findPackageJSON(name, join(product, "package.json"));
-        if (location === undefined)
-            throw new Error(`missing-runtime-dependency: ${name}`);
-        await mkdir(dirname(join(modules, name)), { recursive: true });
-        await symlink(dirname(location), join(modules, name));
-    }
-    const manifest = record(packageMetadata);
-    const exported = Object.keys(record(manifest["exports"])).filter((subpath) => subpath.startsWith("./workflows"));
-    await symlink(join(product, "src"), join(modules, "cloving", "src"));
-    await writeFile(join(modules, "cloving", "package.json"), JSON.stringify({
-        name: manifest["name"],
-        version: manifest["version"],
-        type: "module",
-        exports: Object.fromEntries(exported.map((subpath) => [
-            subpath,
-            `./src/${subpath.slice("./workflows/".length) || "workflows"}${extname(import.meta.filename)}`,
-        ])),
-    }));
-}
-async function registered() {
-    const compiled = JSON.parse(await readFile(join(project, "artifacts/manifest.json"), "utf8"));
-    if (!isWorkflowManifest(compiled))
-        throw new Error("The compiled workflow manifest is invalid.");
-    const manifests = workflowManifests(compiled);
-    const declarations = await workflowDeclarations(join(product, "workflows"), manifests);
-    const paths = new Map();
-    for (const [functionName, manifest] of Object.entries(manifests)) {
-        const path = join(project, `${manifest.name}.workflow.json`);
-        const declared = declarations.find((entry) => entry.functionName === functionName);
-        await writeFile(path, JSON.stringify({
-            ...manifest,
-            capabilities: declared?.capabilities ?? manifest.capabilities,
-        }));
-        paths.set(functionName, path);
-    }
-    return { manifests: Object.fromEntries(paths), declarations };
-}
 function source(file) {
     return JSON.stringify(pathToFileURL(join(product, file.replace(/\.ts$/, extname(import.meta.filename)))).href);
 }
@@ -174,7 +124,6 @@ async function launchers(commands, workflows) {
     const settings = {
         ...commands,
         directory,
-        repository,
         concurrency,
         runtimeDirectory: runtime,
         ...workflows,
@@ -213,22 +162,8 @@ function guide() {
         "",
     ].join("\n");
 }
-async function prepared() {
-    await rm(project, { recursive: true, force: true });
-    await mkdir(join(project, "workflows"), { recursive: true });
-    await writeFile(join(project, "package.json"), '{"name":"cloving-self-host","private":true,"type":"module"}');
-    for (const file of await workflowFiles(join(product, "workflows")))
-        await copyFile(join(product, "workflows", file), join(project, "workflows", file));
-    await linkedPackages();
-    const compiled = await ended([
-        join(product, `tools/compile-workflows${extname(import.meta.filename)}`),
-        "workflows",
-        "artifacts",
-    ], process.env);
-    if (compiled !== 0)
-        throw new Error("The workflows did not compile.");
-    return registered();
-}
+const tokenPrices = parseTokenPrices(process.env["CLOVING_TOKEN_PRICES"]);
+const fallbackModels = parseFallbackModels(process.env["CLOVING_FALLBACK_MODELS"]);
 const profiles = await profilesFile();
 const worker = selectedWorker();
 const command = worker === "codex"
@@ -236,15 +171,26 @@ const command = worker === "codex"
     : (listed("CLOVING_CLAUDE_COMMAND") ?? defaultCommand);
 const nextCommand = listed("CLOVING_NEXT_COMMAND");
 const ticketCommand = listed("CLOVING_TICKET_COMMAND");
+const lanes = queueLanes();
 const queueMilliseconds = queueInterval({ nextCommand, ticketCommand });
-const manifests = await prepared();
+const manifests = await preparedProject({
+    product,
+    project,
+    repository,
+    home: homedir(),
+    xdgConfigHome: process.env["XDG_CONFIG_HOME"],
+});
 await launchers({
+    tokenPrices,
+    fallbackModels,
     worker,
     profiles,
     command,
     ticketCommand,
     nextCommand,
     queueMilliseconds,
+    queueLanes: lanes,
+    resetQueue: flags.includes("--reset-queue"),
     notifyCommand: listed("CLOVING_NOTIFY_COMMAND"),
     githubCommand: listed("CLOVING_GH_COMMAND"),
     checkCommand: listed("CLOVING_CHECK_COMMAND"),

package/dist/tools/self-update-host.d.ts

@@ -1,6 +1,13 @@
+interface ActivitySettings {
+    readonly directory: string;
+    readonly runtimeDirectory: string;
+    readonly signal?: AbortSignal;
+}
+export declare function selfUpdateActive(settings: ActivitySettings): Promise<boolean>;
 export declare function selfUpdateMilliseconds(settings: {
     readonly seconds: string | undefined;
     readonly repository: string;
     readonly product: string;
 }): Promise<number | undefined>;
 export declare function workerTurnActive(directory: string): Promise<boolean>;
+export {};

package/dist/tools/self-update-host.js

@@ -1,5 +1,52 @@
 import { access, readdir, realpath } from "node:fs/promises";
-import { join } from "node:path";
+import { execFile } from "node:child_process";
+import { extname, join } from "node:path";
+import { promisify } from "node:util";
+import { record } from "../src/protocol.js";
+async function runPage(settings, after) {
+    const output = await promisify(execFile)(process.execPath, [
+        join(import.meta.dirname, `../src/cli${extname(import.meta.filename)}`),
+        "status",
+        "--json",
+        "--limit",
+        "500",
+        ...(after === "" ? [] : ["--after", after]),
+    ], {
+        env: { ...process.env, CLOVING_RUNTIME_DIR: settings.runtimeDirectory },
+        encoding: "utf8",
+        timeout: 30000,
+        signal: settings.signal,
+    });
+    const page = record(JSON.parse(output.stdout));
+    if (!page)
+        throw new Error("invalid-run-list");
+    return page;
+}
+export async function selfUpdateActive(settings) {
+    if (await present(join(settings.directory, "queue-submission")))
+        return true;
+    if (await workerTurnActive(settings.directory))
+        return true;
+    let after = "";
+    do {
+        const page = await runPage(settings, after);
+        const runs = page["runs"];
+        if (!Array.isArray(runs))
+            throw new Error("invalid-run-list");
+        if (runs.some((value) => {
+            const run = record(value);
+            if (!run)
+                throw new Error("invalid-run-status");
+            return !["completed", "failed", "cancelled"].includes(String(run["state"]));
+        }))
+            return true;
+        const next = page["next"];
+        if (next !== null && (typeof next !== "string" || next <= after))
+            throw new Error("invalid-run-page");
+        after = next;
+    } while (after !== null);
+    return false;
+}
 export async function selfUpdateMilliseconds(settings) {
     const { seconds } = settings;
     if (seconds === undefined)

package/dist/tools/self-update.d.ts

@@ -5,6 +5,7 @@ export interface SelfUpdateSettings {
     readonly stop: () => Promise<void>;
     readonly error: (line: string) => void;
 }
+export declare function lockRequiresInstall(before: string, after: string): boolean;
 export declare function selfUpdater(settings: SelfUpdateSettings): {
     readonly check: () => Promise<number | undefined>;
 };