cloving 1.2.0 → 1.3.0

package/dist/src/cli/report-github.js

@@ -0,0 +1,200 @@
+export async function readReportGithub(input) {
+    const reader = await repositoryReader(input).catch(() => null);
+    if (reader === null)
+        return {
+            observedSince: null,
+            issues: null,
+            pulls: null,
+            sources: {
+                issues: { status: "unavailable", reason: "configuration-or-identity" },
+                pulls: { status: "unavailable", reason: "configuration-or-identity" },
+                history: { status: "unavailable", reason: "configuration-or-identity" },
+            },
+        };
+    const [issues, pulls, history] = await Promise.allSettled([
+        issuesOf(reader, input.since),
+        pullsOf(reader, input.since),
+        repositoryCreatedAt(reader),
+    ]);
+    return {
+        observedSince: history.status === "fulfilled" ? history.value : null,
+        issues: issues.status === "fulfilled" ? issues.value : null,
+        pulls: pulls.status === "fulfilled" ? pulls.value : null,
+        sources: {
+            issues: source(issues),
+            pulls: source(pulls),
+            history: source(history),
+        },
+    };
+}
+import { record } from "../protocol.js";
+import { githubRetry } from "./github-retry.js";
+import { prRepository } from "./watch-pr-identity.js";
+function commandOf(value) {
+    const command = JSON.parse(value ?? '["gh"]');
+    if (!Array.isArray(command) ||
+        command.length === 0 ||
+        !command.every((part) => typeof part === "string" && part !== "" && !part.includes("\0")))
+        throw new Error("configuration");
+    return command.map(String);
+}
+function rows(value) {
+    if (!Array.isArray(value))
+        throw new Error("response");
+    return value.map((item) => {
+        const row = record(item);
+        if (row === undefined)
+            throw new Error("response");
+        return row;
+    });
+}
+function identity(row, context) {
+    const { repository, kind } = context;
+    const number = row["number"];
+    const url = row["html_url"];
+    if (typeof number !== "number" ||
+        !Number.isSafeInteger(number) ||
+        number <= 0 ||
+        typeof url !== "string" ||
+        url.toLowerCase() !==
+            `https://${repository.host}/${repository.owner}/${repository.repository}/${kind}/${String(number)}`)
+        throw new Error("identity");
+    return number;
+}
+function timestamp(value) {
+    if (typeof value !== "string" || !Number.isFinite(Date.parse(value)))
+        throw new Error("response");
+    return Date.parse(value);
+}
+async function issuesOf(reader, since) {
+    const result = [];
+    const seen = new Set();
+    for (let page = 1;; page += 1) {
+        const values = rows(await reader.read(`issues?state=closed&since=${encodeURIComponent(since)}&per_page=100&page=${String(page)}`, [
+            "--jq",
+            'map({number, html_url, closed_at, state, state_reason} + (if has("pull_request") then {pull_request: {}} else {} end))',
+        ]));
+        for (const row of values) {
+            if (Object.hasOwn(row, "pull_request"))
+                continue;
+            const number = identity(row, {
+                repository: reader.repository,
+                kind: "issues",
+            });
+            if (seen.has(number))
+                throw new Error("response");
+            seen.add(number);
+            if (!completedIssue(row))
+                continue;
+            result.push({
+                at: timestamp(row["closed_at"]),
+                value: 1,
+                evidence: { issue: number },
+            });
+        }
+        if (values.length < 100)
+            return result;
+    }
+}
+async function pullsOf(reader, since) {
+    const result = [];
+    const seen = new Set();
+    for (let page = 1;; page += 1) {
+        const values = rows(await reader.read(`pulls?state=closed&sort=updated&direction=desc&per_page=100&page=${String(page)}`));
+        for (const row of values) {
+            const number = identity(row, {
+                repository: reader.repository,
+                kind: "pull",
+            });
+            if (seen.has(number))
+                throw new Error("response");
+            seen.add(number);
+            timestamp(row["updated_at"]);
+            if (row["merged_at"] === null)
+                continue;
+            result.push({
+                at: timestamp(row["merged_at"]),
+                value: 1,
+                evidence: { pullRequest: number },
+            });
+        }
+        if (values.length < 100 ||
+            values.some((row) => Date.parse(String(row["updated_at"])) < Date.parse(since)))
+            return result;
+    }
+}
+async function repositoryReader(input) {
+    const settings = input.settings;
+    if (settings?.repository === undefined)
+        throw new Error("configuration");
+    const command = commandOf(settings.githubCommand);
+    const signal = AbortSignal.timeout(120_000);
+    const origin = await settings.execute({
+        command: ["git", "config", "--local", "--get-all", "remote.origin.url"],
+        directory: settings.repository,
+        signal,
+    });
+    const repository = origin.status === 0 && origin.errorCode === null
+        ? prRepository(origin.stdout)
+        : null;
+    if (repository === null)
+        throw new Error("identity");
+    const directory = settings.repository;
+    return {
+        repository,
+        read: async (endpoint, flags = []) => {
+            const output = await githubRetry({
+                signal,
+                pollMilliseconds: input.retryMilliseconds ?? 30_000,
+                action: async () => {
+                    const output = await settings.execute({
+                        directory,
+                        signal,
+                        command: [
+                            ...command,
+                            "api",
+                            "--method",
+                            "GET",
+                            "--hostname",
+                            repository.host,
+                            `repos/${repository.owner}/${repository.repository}${endpoint === "" ? "" : `/${endpoint}`}`,
+                            ...flags,
+                        ],
+                    });
+                    if (output.status !== 0 || output.errorCode !== null)
+                        throw Object.assign(new Error("github-call-failed"), {
+                            status: Number(/\(HTTP (\d{3})\)/.exec(output.stderr)?.[1]),
+                            detail: output.stderr,
+                        });
+                    return output.stdout;
+                },
+            });
+            const parsed = JSON.parse(output);
+            return parsed;
+        },
+    };
+}
+function source(result) {
+    if (result.status === "fulfilled")
+        return { status: "available" };
+    const reason = result.reason instanceof Error &&
+        result.reason.message === "github-network-failed"
+        ? "github-network-failed"
+        : "read-failed";
+    return { status: "unavailable", reason };
+}
+async function repositoryCreatedAt(reader) {
+    const repository = record(await reader.read(""));
+    const name = repository?.["full_name"];
+    if (typeof name !== "string" ||
+        name.toLowerCase() !==
+            `${reader.repository.owner}/${reader.repository.repository}`)
+        throw new Error("identity");
+    return timestamp(repository?.["created_at"]);
+}
+function completedIssue(row) {
+    if (row["state"] !== "closed" ||
+        !["completed", "not_planned", "duplicate"].includes(String(row["state_reason"])))
+        throw new Error("response");
+    return row["state_reason"] === "completed";
+}

package/dist/src/cli/report.d.ts

@@ -0,0 +1,17 @@
+import { type Fields } from "../protocol.ts";
+import { type ReportCompletion } from "../report.ts";
+import type { WatchPrSettings } from "./watch-pr-settings.ts";
+interface ReportEnvironment {
+    readonly runtimeDirectory: string;
+    readonly workingDirectory: string;
+    readonly watchPr?: WatchPrSettings;
+    readonly terminal: {
+        readonly out: (text: string) => void;
+    };
+}
+export declare function reportCommand(invocation: {
+    readonly since: number;
+    readonly json: boolean;
+}, environment: ReportEnvironment): Promise<number>;
+export declare function reportCompletion(event: Fields): ReportCompletion | null;
+export {};

package/dist/src/cli/report.js

@@ -0,0 +1,192 @@
+import { record } from "../protocol.js";
+import { loopReport, } from "../report.js";
+import { send } from "./client.js";
+import { readReportGithub } from "./report-github.js";
+function reportRecord(value, after) {
+    const event = record(value) ?? {};
+    const sequence = event["sequence"];
+    const at = event["recordedAt"];
+    if (typeof sequence !== "number" ||
+        !Number.isSafeInteger(sequence) ||
+        sequence <= after ||
+        typeof at !== "string" ||
+        !Number.isFinite(Date.parse(at)))
+        throw new Error("invalid-report-cursor");
+    return { event, sequence, at: Date.parse(at) };
+}
+function appendEvents(snapshot, values) {
+    for (const value of values) {
+        const parsed = reportRecord(value, snapshot.after);
+        if (snapshot.latest !== null && parsed.sequence > snapshot.latest)
+            break;
+        snapshot.after = parsed.sequence;
+        if (snapshot.observedSince === null || parsed.at < snapshot.observedSince)
+            snapshot.observedSince = parsed.at;
+        const completion = reportCompletion(parsed.event);
+        if (completion === null)
+            continue;
+        if (snapshot.completions.has(completion.runId))
+            throw new Error("duplicate-report-completion");
+        snapshot.completions.set(completion.runId, completion);
+    }
+}
+async function daemonReport(runtime) {
+    const snapshot = {
+        after: 0,
+        latest: null,
+        observedSince: null,
+        completions: new Map(),
+    };
+    for (;;) {
+        const reply = await send(runtime, {
+            operation: "events",
+            parameters: { after: snapshot.after, limit: 1000 },
+        });
+        if (reply.kind === "error")
+            throw new Error(reply.error.code);
+        const latest = reply.result["latestSequence"];
+        if (typeof latest !== "number" ||
+            !Number.isSafeInteger(latest) ||
+            latest < snapshot.after)
+            throw new Error("invalid-report-snapshot");
+        snapshot.latest ??= latest;
+        const events = reply.result["events"];
+        if (!Array.isArray(events))
+            throw new Error("invalid-report-events");
+        appendEvents(snapshot, events);
+        if (snapshot.after >= snapshot.latest)
+            return {
+                completions: [...snapshot.completions.values()],
+                observedSince: snapshot.observedSince,
+            };
+        if (events.length < 1000)
+            throw new Error("incomplete-report-snapshot");
+    }
+}
+function settledSpending(run) {
+    const condition = run["condition"];
+    const effects = run["effects"];
+    return (["completed", "failed", "cancelled"].includes(String(condition)) &&
+        Array.isArray(effects) &&
+        effects.every((value) => ["completed", "failed", "stopped", "cancelled", "refused"].includes(String(record(value)?.["state"]))));
+}
+async function runCost(runtime, runId) {
+    const reply = await send(runtime, {
+        operation: "status",
+        parameters: { runId },
+    });
+    if (reply.kind === "error")
+        return { runId, turns: null };
+    const run = record(reply.result["run"]);
+    const turns = run?.["workerTurns"];
+    if (run?.["runId"] !== runId ||
+        !Array.isArray(turns) ||
+        !settledSpending(run))
+        return { runId, turns: null };
+    const parsed = turns.map((value) => {
+        const turn = record(value);
+        const operationId = turn?.["operationId"];
+        const costUsd = turn?.["costUsd"];
+        return typeof operationId === "string" &&
+            (costUsd === null ||
+                (typeof costUsd === "number" &&
+                    Number.isFinite(costUsd) &&
+                    costUsd >= 0))
+            ? { operationId, costUsd }
+            : null;
+    });
+    return {
+        runId,
+        turns: parsed.some((turn) => turn === null)
+            ? null
+            : parsed.filter((turn) => turn !== null),
+    };
+}
+function textReport(report) {
+    const lines = [`Loop report ${JSON.stringify(report["window"])}`];
+    for (const [name, value] of Object.entries(record(report["metrics"]) ?? {})) {
+        const metric = record(value) ?? {};
+        lines.push(`${name}: ${metric["status"] === "unavailable" ? "unavailable" : String(metric["value"])}`);
+        const baseline = record(metric["baseline"]) ?? {};
+        lines.push(`  history: ${String(baseline["history"])}; median: ${String(baseline["median"])}; band: ${JSON.stringify(baseline["band"])}${metric["mark"] === "outside" ? "; outside" : ""}`);
+        lines.push(`  comparison value: ${String(metric["comparisonValue"])}`);
+        lines.push(`  evidence: ${JSON.stringify(metric["evidence"])}`);
+        lines.push(`  baseline evidence: ${JSON.stringify(baseline["evidence"])}`);
+    }
+    lines.push(`Run costs (USD): ${JSON.stringify(report["runCosts"])}`);
+    lines.push(`Sources: ${JSON.stringify(report["sources"])}`);
+    lines.push(`Coverage: ${JSON.stringify(report["coverage"])}`);
+    return lines.join("\n") + "\n";
+}
+export async function reportCommand(invocation, environment) {
+    const now = Date.now();
+    const since = new Date(now - (invocation.since + 168) * 3_600_000).toISOString();
+    const settings = environment.watchPr === undefined ? {} : { settings: environment.watchPr };
+    const [daemonRead, githubRead] = await Promise.allSettled([
+        daemonReport(environment.runtimeDirectory),
+        readReportGithub({ since, ...settings }),
+    ]);
+    const daemon = daemonRead.status === "fulfilled"
+        ? daemonRead.value
+        : { completions: null, observedSince: null };
+    const github = githubRead.status === "fulfilled" ? { github: githubRead.value } : {};
+    const costs = [];
+    for (const event of daemon.completions ?? [])
+        if (event.at >= now - (invocation.since + 168) * 3_600_000 &&
+            event.at < now)
+            costs.push(await runCost(environment.runtimeDirectory, event.runId));
+    const calculated = loopReport({
+        since: invocation.since,
+        now,
+        ...daemon,
+        costs,
+        ...github,
+    });
+    const report = {
+        ...calculated,
+        window: {
+            ...calculated.window,
+            start: new Date(calculated.window.start).toISOString(),
+            end: new Date(now).toISOString(),
+        },
+        runCosts: calculated.runCosts.map((cost) => ({
+            ...cost,
+            completedAt: new Date(cost.completedAt).toISOString(),
+        })),
+    };
+    environment.terminal.out(invocation.json ? `${JSON.stringify(report)}\n` : textReport(report));
+    return 0;
+}
+function outcomeOf(event) {
+    if (event["type"] === "run.failed")
+        return "failed";
+    if (event["type"] === "run.cancelled")
+        return "cancelled";
+    if (event["type"] !== "run.completed")
+        return null;
+    const payload = record(event["payload"]) ?? {};
+    if (payload["outcome"] === "handoff_requested" &&
+        payload["ticketStatus"] === "partial")
+        return "partial";
+    const outcome = payload["outcome"];
+    if (outcome === undefined || outcome === "handoff_requested")
+        return "completed";
+    return outcome === "blocked" ? "blocked" : null;
+}
+export function reportCompletion(event) {
+    const terminal = ["run.completed", "run.failed", "run.cancelled"].includes(String(event["type"]));
+    if (!terminal)
+        return null;
+    const outcome = outcomeOf(event);
+    if (outcome === null)
+        throw new Error("invalid-report-event");
+    const runId = event["runId"];
+    const sequence = event["sequence"];
+    const at = event["recordedAt"];
+    if (typeof runId !== "string" ||
+        typeof sequence !== "number" ||
+        typeof at !== "string" ||
+        !Number.isFinite(Date.parse(at)))
+        throw new Error("invalid-report-event");
+    return { runId, sequence, at: Date.parse(at), outcome };
+}

package/dist/src/cli/repository-arguments.d.ts

@@ -0,0 +1,5 @@
+import { type ParseArgsConfig } from "node:util";
+export declare function repositoryArguments(argumentsList: readonly string[], options: NonNullable<ParseArgsConfig["options"]>): {
+    readonly argumentsList: readonly string[];
+    readonly repository: string | undefined;
+} | string;

package/dist/src/cli/repository-arguments.js

@@ -0,0 +1,34 @@
+import { parseArgs } from "node:util";
+export function repositoryArguments(argumentsList, options) {
+    if (!argumentsList.some((argument) => argument === "--repository" || argument.startsWith("--repository=")))
+        return { argumentsList, repository: undefined };
+    try {
+        const parsed = parseArgs({
+            args: [...argumentsList],
+            options: {
+                ...options,
+                repository: { type: "string" },
+            },
+            tokens: true,
+            allowPositionals: true,
+            strict: false,
+        });
+        const selectors = parsed.tokens.filter((token) => token.kind === "option" && token.name === "repository");
+        if (selectors.length > 1)
+            return "repeated-option";
+        const removed = new Set(selectors.flatMap((token) => token.kind === "option" && !token.inlineValue
+            ? [token.index, token.index + 1]
+            : [token.index]));
+        const repository = parsed.values["repository"];
+        if (selectors.length > 0 &&
+            (typeof repository !== "string" || repository === ""))
+            return "missing-value";
+        return {
+            argumentsList: argumentsList.filter((_, index) => !removed.has(index)),
+            repository: typeof repository === "string" ? repository : undefined,
+        };
+    }
+    catch {
+        return "missing-value";
+    }
+}

package/dist/src/cli/runtime-arguments.d.ts

@@ -11,6 +11,10 @@ export type RunSource = {
 type DecisionCommand = "answer" | "approve" | "deny";
 type RunCommand = "pause" | "resume" | "drop";
 export type RuntimeInvocation = {
+    readonly kind: "report";
+    readonly since: number;
+    readonly json: boolean;
+} | {
     readonly kind: "command-help";
     readonly command: string;
 } | {

package/dist/src/cli/runtime-arguments.js

@@ -51,6 +51,15 @@ const shapes = new Map([
             build: events,
         },
     ],
+    [
+        "report",
+        {
+            subject: "none",
+            required: [],
+            allowed: () => ["since", "json"],
+            build: report,
+        },
+    ],
     [
         "watch",
         {
@@ -246,3 +255,9 @@ function events(request) {
     const json = given(request, "json");
     return { kind: "events", runId, after: after ?? 0, limit, follow, json };
 }
+function report(request) {
+    const since = whole(valueOf(request, "since"), { minimum: 1, maximum: 168 });
+    if (since === invalid)
+        return "invalid-option-value";
+    return { kind: "report", since: since ?? 24, json: given(request, "json") };
+}

package/dist/src/cli/runtime-directory.d.ts

@@ -1,4 +1,8 @@
 type Environment = Readonly<Record<string, string | undefined>>;
-export declare function clientCommand(environment: Environment): string;
-export declare function runtimeDirectory(environment: Environment): string | undefined;
+export declare function shellArgument(value: string): string;
+export declare function clientCommand(environment: Environment, repository?: string): string;
+export declare function repositoryRuntimeName(repository: string): string;
+export declare function adoptionRecordPath(environment: Environment, repository: string): string | undefined;
+export declare function legacyRuntimeDirectory(environment: Environment): string | undefined;
+export declare function runtimeDirectory(environment: Environment, repository?: string): string | undefined;
 export {};

package/dist/src/cli/runtime-directory.js

@@ -1,25 +1,83 @@
-import { join } from "node:path";
+import { repositoryFileName } from "../repository-identity.js";
+import { createHash } from "node:crypto";
+import { readFileSync, realpathSync } from "node:fs";
+import { basename, isAbsolute, join } from "node:path";
+import { record } from "../protocol.js";
 function given(value) {
     return value !== undefined && value.length > 0;
 }
-export function clientCommand(environment) {
+export function shellArgument(value) {
+    return /^[A-Za-z0-9_./-]+$/.test(value)
+        ? value
+        : `'${value.replaceAll("'", "'\\''")}'`;
+}
+export function clientCommand(environment, repository) {
     const explicit = environment["CLOVING_RUNTIME_DIR"];
     return given(explicit)
-        ? `CLOVING_RUNTIME_DIR=${explicit} cloving`
-        : "cloving";
+        ? `CLOVING_RUNTIME_DIR=${shellArgument(explicit)} cloving`
+        : `cloving${repository === undefined ? "" : ` --repository ${shellArgument(repository)}`}`;
+}
+function stateRoot(environment) {
+    const state = environment["XDG_STATE_HOME"];
+    if (given(state))
+        return state;
+    const home = environment["HOME"];
+    return given(home) ? join(home, ".local", "state") : undefined;
+}
+export function repositoryRuntimeName(repository) {
+    const canonical = realpathSync(repository);
+    return repositoryFileName({
+        name: basename(canonical),
+        sha256: createHash("sha256").update(canonical).digest("hex"),
+    });
+}
+export function adoptionRecordPath(environment, repository) {
+    const state = stateRoot(environment);
+    return state === undefined
+        ? undefined
+        : join(state, "cloving", "adopted-runtime", `${repositoryRuntimeName(repository)}.json`);
+}
+export function legacyRuntimeDirectory(environment) {
+    const runtime = environment["XDG_RUNTIME_DIR"];
+    if (given(runtime))
+        return join(runtime, "cloving");
+    const state = stateRoot(environment);
+    return state === undefined ? undefined : join(state, "cloving", "run");
+}
+function adoptedRuntime(environment, repository) {
+    const path = adoptionRecordPath(environment, repository);
+    if (path === undefined)
+        return undefined;
+    try {
+        return runtimeRecord(path, repository);
+    }
+    catch (error) {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT")
+            return undefined;
+        throw error;
+    }
 }
-export function runtimeDirectory(environment) {
+function runtimeRecord(path, repository) {
+    const value = record(JSON.parse(readFileSync(path, "utf8")));
+    if (value?.["schemaVersion"] === 1 &&
+        value["repository"] === realpathSync(repository) &&
+        typeof value["runtimeDirectory"] === "string" &&
+        isAbsolute(value["runtimeDirectory"]))
+        return value["runtimeDirectory"];
+    throw new Error("invalid-runtime-record");
+}
+export function runtimeDirectory(environment, repository) {
     const explicit = environment["CLOVING_RUNTIME_DIR"];
     if (given(explicit))
         return explicit;
+    if (repository === undefined)
+        return undefined;
+    const adopted = adoptedRuntime(environment, repository);
+    if (adopted !== undefined)
+        return adopted;
     const runtime = environment["XDG_RUNTIME_DIR"];
-    if (given(runtime))
-        return join(runtime, "cloving");
-    const state = environment["XDG_STATE_HOME"];
-    if (given(state))
-        return join(state, "cloving", "run");
-    const home = environment["HOME"];
-    return given(home)
-        ? join(home, ".local", "state", "cloving", "run")
-        : undefined;
+    const root = given(runtime) ? runtime : stateRoot(environment);
+    return root === undefined
+        ? undefined
+        : join(root, "cloving", repositoryRuntimeName(repository), "run");
 }

package/dist/src/cli/toolchain.d.ts

@@ -1,3 +1,5 @@
 import type { ToolchainIdentity } from "../workflow-admission.ts";
+export declare const supportedNodes: string;
+export declare function supportedNode(version: string): boolean;
 export declare function observedToolchain(start: string): Promise<ToolchainIdentity>;
 export declare function qualifiedToolchain(observed: ToolchainIdentity, start: string): Promise<ToolchainIdentity>;

package/dist/src/cli/toolchain.js

@@ -3,7 +3,27 @@ import { createHash } from "node:crypto";
 import { access, readFile, realpath } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import packageMetadata from "#package" with { type: "json" };
-const qualifiedNode = "v26.9.0";
+export const supportedNodes = packageMetadata.engines.node;
+export function supportedNode(version) {
+    const release = /^v(\d+)\.(\d+)\.(\d+)$/.exec(version);
+    if (release === null)
+        return false;
+    const observed = release.slice(1).map(Number);
+    return supportedNodes.split(" || ").some((range) => {
+        const bounds = /^>=(\d+)\.(\d+)\.(\d+) <(\d+)$/
+            .exec(range)
+            ?.slice(1)
+            .map(Number);
+        if (bounds === undefined)
+            return false;
+        return (atLeast(observed, bounds.slice(0, 3)) &&
+            (observed[0] ?? 0) < (bounds[3] ?? 0));
+    });
+}
+function atLeast(observed, minimum) {
+    const index = observed.findIndex((part, position) => part !== minimum[position]);
+    return index === -1 || (observed[index] ?? 0) > (minimum[index] ?? 0);
+}
 export async function observedToolchain(start) {
     const root = await projectRoot(start);
     const sdk = await packageDirectory(start, "workflow");
@@ -29,7 +49,7 @@ export async function qualifiedToolchain(observed, start) {
         sdk: `workflow@${packageMetadata.dependencies.workflow}`,
         world: `@workflow/world-local@${typeof declared === "string" ? declared : "undeclared"}`,
         builder: `@workflow/builders@${packageMetadata.dependencies["@workflow/builders"]}`,
-        node: qualifiedNode,
+        node: supportedNode(observed.node) ? observed.node : supportedNodes,
         dependencies: observed.dependencies,
     };
 }

package/dist/src/cli/usage-render.d.ts

@@ -1,3 +1,8 @@
+import { type WorkerAttemptUsage } from "../worker-usage.ts";
 export declare function priceText(value: unknown, estimate?: unknown): string;
 export declare function usageText(value: unknown): string;
 export declare function totalsSuffix(state: unknown): string;
+export declare function statusJson(result: Fields): Fields;
+import { type Fields } from "../protocol.ts";
+export declare function attemptText(attempt: WorkerAttemptUsage): string;
+export declare function attemptTexts(value: unknown): readonly string[];