humanish 0.109.1 → 0.110.1

package/dist/run/run.js

@@ -2,14 +2,17 @@
 // token that lets the Observer and automatic analysis read it. Routes build bundles and write
 // their own evidence files; this module owns when the run starts, how it is published, and how it
 // is closed on every exit.
+import { redactText } from "../evidence/redaction.js";
 import { buildObserverData } from "../observer/data.js";
 import { renderObserver } from "../observer/render.js";
 import { RUN_BUNDLE_FILE, PUBLIC_TARGET_CWD } from "./bundle.js";
+import { judgeExecution, } from "./judge.js";
 import {} from "./results.js";
 import { createRunArtifactPaths, validatePreparedRunArtifactPaths, } from "./paths.js";
 import { registerActiveRun } from "./active-runs.js";
 import { writeContainedOutputFile, writePreparedRunLatestPointer } from "./contained-output.js";
-import { beginRunStatus, runStatusOutcome } from "./status.js";
+import { scrubRunSandboxIds, withPublicSandboxIds } from "./sandbox-ids.js";
+import { beginRunStatus, runStatusOutcome, } from "./status.js";
 /** An entry point called in a state that does not admit it. */
 class RunLifecycleError extends Error {
     name = "RunLifecycleError";
@@ -23,38 +26,169 @@ const issueKey = Symbol("FinishedRun");
  */
 export class FinishedRun {
     #observer;
-    #status;
+    #recordFailure;
+    #outcome;
     runId;
     /** The paths created by startRun and validated at the start of `finish`. */
     paths;
-    constructor(key, runId, paths, observer, status) {
+    constructor(key, runId, paths, observer, outcome, recordFailure) {
         if (key !== issueKey)
             throw new Error("Only Run.finish issues a FinishedRun.");
         this.runId = runId;
         this.paths = paths;
         this.#observer = observer;
-        this.#status = status;
+        this.#outcome = outcome;
+        this.#recordFailure = recordFailure;
     }
     static isIssued(value) {
         return typeof value === "object" && value !== null && #observer in value;
     }
-    /** Render the Observer for exactly these paths, never a directory re-resolved by name. */
-    renderObserver() {
-        const target = this.#observer;
-        if (target === undefined) {
-            return Promise.reject(new RunLifecycleError("This run was started without an Observer."));
-        }
-        return target.render(target.cwd, this.runId, { open: target.open, expectedRun: this.paths });
+    /**
+     * The run's ok and execution outcome as run.json records them: what the route passed to
+     * finish, plus an Observer that did not render. A route's result reads them from here.
+     */
+    get outcome() {
+        return this.#outcome;
     }
     /**
-     * Record the result's ok and execution outcome in status.json. A route calls it once, after the
-     * Observer render, with the values its result returns, so the two agree.
+     * Render the Observer for exactly these paths, never a directory re-resolved by name. An
+     * Observer that did not render is an `evidence` failure: it is added to run.json's outcome and
+     * status.json under the route's policy before this resolves. No page exists then that could
+     * show the run without it. A render that throws records nothing and rejects.
      */
-    recordOutcome(result) {
-        return this.#status.settle(result);
+    async renderObserver() {
+        const target = this.#observer;
+        if (target === undefined)
+            throw new RunLifecycleError("This run was started without an Observer.");
+        const observer = await target.render(target.cwd, this.runId, {
+            open: target.open,
+            expectedRun: this.paths,
+        });
+        if (!observer.ok) {
+            this.#outcome = await this.#recordFailure({
+                kind: "evidence",
+                message: observer.error?.message ?? "The Observer did not render.",
+            });
+        }
+        return observer;
     }
 }
 const json = (value) => `${JSON.stringify(value, null, 2)}\n`;
+/** An execution outcome as run.json records it, each message through the shape redaction. */
+function redactedExecution(execution) {
+    const redacted = (failure) => ({
+        kind: failure.kind,
+        message: redactText(failure.message),
+    });
+    return {
+        succeeded: execution.succeeded,
+        failures: execution.failures.map(redacted),
+        ...(execution.warnings === undefined ? {} : { warnings: execution.warnings.map(redacted) }),
+    };
+}
+/** Where FinishedRun renders the Observer, when the run was started with one. */
+function observerTarget(options) {
+    return options.observer === undefined
+        ? undefined
+        : {
+            cwd: options.cwd,
+            open: options.observer.open,
+            render: options.observer.render ?? renderObserver,
+        };
+}
+function runPublisher(args) {
+    const { options, runId, paths, runStatus, now, admit } = args;
+    const observer = observerTarget(options);
+    let pointerWritten = false;
+    // The bundle of the last write asked for, and the outcome every later write carries once a
+    // signal stopped the run, so no write after the interrupt can drop it.
+    let lastBundle;
+    let interrupted;
+    // One chain serializes every write. A rejection reaches only the caller of that write; the
+    // chain itself continues, so a failed snapshot never blocks the final publication.
+    let tail = Promise.resolve();
+    const enqueue = (write) => {
+        const written = tail.then(write);
+        tail = written.then(() => undefined, () => undefined);
+        return written;
+    };
+    const writePointer = async () => {
+        const pointer = {
+            schema: "humanish.latest-run.v1",
+            runId,
+            path: paths.relativeRunRoot,
+            updatedAt: new Date(now()).toISOString(),
+        };
+        await writePreparedRunLatestPointer(paths, json(pointer), "utf8");
+        pointerWritten = true;
+    };
+    /** run.json with its outcome, then `afterBundle`, then the review and projections. */
+    const writeBundleFiles = async (bundle, outcome, afterBundle) => {
+        await validatePreparedRunArtifactPaths(paths);
+        // The run owns `outcome`: a bundle read back from disk keeps none of its own.
+        const { outcome: _previous, ...evidence } = bundle;
+        const recorded = interrupted ?? outcome;
+        const publicBundle = await withPublicSandboxIds(paths, {
+            ...evidence,
+            cwd: PUBLIC_TARGET_CWD,
+            ...(recorded === undefined ? {} : { outcome: recorded }),
+        });
+        await writeContainedOutputFile(paths, RUN_BUNDLE_FILE, json(publicBundle), "utf8");
+        await afterBundle(publicBundle);
+        await writeContainedOutputFile(paths, "review.json", json(publicBundle.review), "utf8");
+        await writeContainedOutputFile(paths, "review.md", options.renderReview(publicBundle), "utf8");
+        const events = publicBundle.events.map((event) => JSON.stringify(event)).join("\n");
+        await writeContainedOutputFile(paths, "events.ndjson", `${events}\n`, "utf8");
+        await writeContainedOutputFile(paths, "observer/observer-data.json", json(buildObserverData(publicBundle)), "utf8");
+    };
+    const snapshot = async (bundle) => {
+        await writeBundleFiles(bundle, undefined, async () => { });
+        if (!pointerWritten)
+            await writePointer();
+    };
+    const finishedOutcome = (outcome) => ({
+        state: "finished",
+        ok: outcome.ok,
+        execution: redactedExecution(outcome.execution),
+    });
+    const publish = async (bundle, outcome) => {
+        await writeBundleFiles(bundle, finishedOutcome(outcome), (publicBundle) => runStatus.finish(runStatusOutcome(publicBundle)));
+        await scrubRunSandboxIds(paths);
+        await writePointer();
+        let current = { ok: outcome.ok, execution: outcome.execution };
+        // An Observer that did not render, judged under the route's policy and written to run.json
+        // and status.json, so the two agree with the result the route returns. A run directory that
+        // can no longer be written (replaced, or a disk error) keeps the files it has, and the
+        // result still carries the failure.
+        const recordFailure = (failure) => admit(enqueue(async () => {
+            const { failures, warnings = [] } = current.execution;
+            const execution = judgeExecution([...failures, ...warnings, failure], outcome.policy);
+            current = { ok: current.ok && execution.succeeded, execution };
+            await writeBundleFiles(bundle, finishedOutcome(current), (publicBundle) => runStatus.restate(runStatusOutcome(publicBundle))).catch(() => undefined);
+            return current;
+        }));
+        return new FinishedRun(issueKey, runId, paths, observer, current, recordFailure);
+    };
+    const interrupt = async (signal) => {
+        interrupted = { state: "interrupted", ok: false, signal, at: new Date(now()).toISOString() };
+        const written = lastBundle;
+        if (written === undefined)
+            return;
+        // A failed write leaves status.json as the record of the interrupt.
+        await enqueue(() => writeBundleFiles(written, undefined, async () => { })).catch(() => undefined);
+    };
+    return {
+        snapshot(bundle) {
+            lastBundle = bundle;
+            return enqueue(() => snapshot(bundle));
+        },
+        publish(bundle, outcome) {
+            lastBundle = bundle;
+            return enqueue(() => publish(bundle, outcome));
+        },
+        interrupt,
+    };
+}
 /**
  * Run `fn` as the lifetime of at most one run. When `fn` settles the scope closes synchronously,
  * so the scope and its run admit no further calls, even through references `fn` leaked into
@@ -89,70 +223,40 @@ export async function runScope(fn) {
             if (!created.ok)
                 return created;
             // beginRunStatus reads only the mode and the study provenance from the run's options.
-            status = beginRunStatus(created.paths, { ...options, runId });
+            const runStatus = beginRunStatus(created.paths, { ...options, runId });
+            status = runStatus;
+            let interruptBundle;
             // Registered before the first write lands: a signal while it is still settling reaches
-            // the handle, whose interrupt queues behind that write.
-            unregister = registerActiveRun({ cwd: options.cwd, runId, paths: created.paths, status });
-            await status.started;
-            return { ok: true, run: openRun(options, runId, created.paths, status) };
+            // the handle, whose interrupt queues behind that write. The interrupt lands in
+            // status.json first, then in run.json once the run has written one.
+            unregister = registerActiveRun({
+                cwd: options.cwd,
+                runId,
+                paths: created.paths,
+                status: {
+                    async interrupt(signal) {
+                        const recorded = await runStatus.interrupt(signal);
+                        if (recorded)
+                            await interruptBundle?.(signal);
+                        return recorded;
+                    },
+                },
+            });
+            await runStatus.started;
+            const run = openRun(options, runId, created.paths, runStatus);
+            interruptBundle = run.interrupt;
+            return { ok: true, run: run.run };
         })());
     };
     const openRun = (options, runId, paths, runStatus) => {
         const now = options.now ?? Date.now;
         const createdAt = new Date(now()).toISOString();
-        const observer = options.observer === undefined
-            ? undefined
-            : {
-                cwd: options.cwd,
-                open: options.observer.open,
-                render: options.observer.render ?? renderObserver,
-            };
+        const publisher = runPublisher({ options, runId, paths, runStatus, now, admit });
         let finishCalled = false;
-        let pointerWritten = false;
-        // One chain serializes every write. A rejection reaches only the caller of that write; the
-        // chain itself continues, so a failed snapshot never blocks the final publication.
-        let tail = Promise.resolve();
-        const enqueue = (write) => {
-            const written = tail.then(write);
-            tail = written.then(() => undefined, () => undefined);
-            return written;
-        };
         const checkIdentity = (bundle) => bundle.runId !== runId || bundle.mode !== options.mode
             ? "The bundle names another run or mode than this run."
             : undefined;
-        const writePointer = async () => {
-            const pointer = {
-                schema: "humanish.latest-run.v1",
-                runId,
-                path: paths.relativeRunRoot,
-                updatedAt: new Date(now()).toISOString(),
-            };
-            await writePreparedRunLatestPointer(paths, json(pointer), "utf8");
-            pointerWritten = true;
-        };
-        /** run.json, then `afterBundle`, then the review and projections. */
-        const writeBundleFiles = async (bundle, afterBundle) => {
-            await validatePreparedRunArtifactPaths(paths);
-            const publicBundle = { ...bundle, cwd: PUBLIC_TARGET_CWD };
-            await writeContainedOutputFile(paths, RUN_BUNDLE_FILE, json(publicBundle), "utf8");
-            await afterBundle(publicBundle);
-            await writeContainedOutputFile(paths, "review.json", json(publicBundle.review), "utf8");
-            await writeContainedOutputFile(paths, "review.md", options.renderReview(publicBundle), "utf8");
-            const events = publicBundle.events.map((event) => JSON.stringify(event)).join("\n");
-            await writeContainedOutputFile(paths, "events.ndjson", `${events}\n`, "utf8");
-            await writeContainedOutputFile(paths, "observer/observer-data.json", json(buildObserverData(publicBundle)), "utf8");
-        };
-        const snapshot = async (bundle) => {
-            await writeBundleFiles(bundle, async () => { });
-            if (!pointerWritten)
-                await writePointer();
-        };
-        const publish = async (bundle) => {
-            await writeBundleFiles(bundle, (publicBundle) => runStatus.finish(runStatusOutcome(publicBundle)));
-            await writePointer();
-            return new FinishedRun(issueKey, runId, paths, observer, runStatus);
-        };
-        return {
+        const run = {
             runId,
             createdAt,
             mode: options.mode,
@@ -166,9 +270,9 @@ export async function runScope(fn) {
                 const mismatch = checkIdentity(bundle);
                 if (mismatch !== undefined)
                     return refuse(mismatch);
-                return admit(enqueue(() => snapshot(bundle)));
+                return admit(publisher.snapshot(bundle));
             },
-            finish(bundle) {
+            finish(bundle, outcome) {
                 if (closed)
                     return refuse("The run scope has closed.");
                 if (finishCalled)
@@ -177,12 +281,13 @@ export async function runScope(fn) {
                 if (mismatch !== undefined)
                     return refuse(mismatch);
                 finishCalled = true;
-                return admit(enqueue(() => publish(bundle)).then((issued) => {
+                return admit(publisher.publish(bundle, outcome).then((issued) => {
                     finished = issued;
                     return issued;
                 }));
             },
         };
+        return { run, interrupt: publisher.interrupt };
     };
     let outcome;
     try {

package/dist/run/sandbox-creates.d.ts

@@ -0,0 +1,59 @@
+import type { PreparedOutputRoot } from "./contained-output.js";
+import type { SandboxOwnerTags } from "./sandbox-receipts.js";
+/** Refuses a sandbox create for a run directory whose process is stopping. */
+export declare class SandboxCreateRefusedError extends Error {
+    constructor();
+}
+/** One sandbox a create in this process reported, and what its route did with it. */
+export interface CreatedSandbox {
+    sandboxId: string;
+    /** The participant or subject label the receipt also records. */
+    participantId: string;
+    /** True once the route's own release confirmed the sandbox gone. */
+    released: boolean;
+}
+/**
+ * The E2B metadata that ties a sandbox to the directory that journals it. `runId` is the
+ * directory's name: the run id, or a preflight probe's id. `runKey` is a digest of the directory's
+ * inode and creation time, so two projects that both use `--run-id smoke` never match each other's
+ * sandboxes, and a renamed project directory still matches its own. `tool` is the owner tag every
+ * route already sets.
+ */
+export declare function sandboxOwnerTags(root: PreparedOutputRoot): SandboxOwnerTags;
+/** A create in progress; the acquire step in src/substrates/e2b/sandbox.ts holds one per create. */
+export interface SandboxCreateTicket {
+    /** Whether the directory's process has started stopping; checked before each attempt. */
+    stopping(): boolean;
+    /** The provider reported a sandbox id for this create. Safe to call twice with one id. */
+    created(sandboxId: string): void;
+    /** The route's release confirmed this sandbox gone. */
+    released(sandboxId: string): void;
+    /** The create resolved or threw, and its receipt write, if any, has finished. */
+    settled(): void;
+}
+/** Register a create for `root`. Throws SandboxCreateRefusedError once the directory is stopping. */
+export declare function beginSandboxCreate(root: PreparedOutputRoot, participantId: string): SandboxCreateTicket;
+/**
+ * Run `write` once per directory and return its promise to every caller. Creates that start
+ * together then resume in the order they called, so the order they reach the provider does not
+ * depend on which file append finishes first. A write that reports failure is forgotten, so the
+ * next create tries again.
+ */
+export declare function recordSandboxOwnerOnce(root: PreparedOutputRoot, write: () => Promise<boolean>): Promise<void>;
+/** What the signal handler holds after stopping a directory's creates. */
+export interface StoppedSandboxCreates {
+    /**
+     * Calls `listener` at once for every sandbox a create has reported so far, then for each one an
+     * in-flight create reports later, until the returned function is called.
+     */
+    watch(listener: (sandbox: CreatedSandbox) => void): () => void;
+    /** Resolves once every create that was in flight at the stop has settled. */
+    settled: Promise<void>;
+    /** How many of those creates have not settled yet. */
+    inFlight(): number;
+}
+/**
+ * Stop `root`'s creates: any create that starts from now on is refused. Called synchronously when
+ * the signal arrives, before anything is awaited, so no create can slip in after it.
+ */
+export declare function stopSandboxCreates(root: PreparedOutputRoot): StoppedSandboxCreates;

package/dist/run/sandbox-creates.js

@@ -0,0 +1,138 @@
+// The sandboxes this process is creating for each run directory, and the E2B tags that name the
+// directory. A receipt reaches sandbox-receipts.ndjson only after `Sandbox.create` resolves, and
+// on @e2b/desktop that is after desktop startup, seconds after E2B has created the sandbox. The
+// CLI's signal handler (src/cli/commands/run-signals.ts) uses this registry to cover that window:
+// it stops new creates, kills every id a create has reported, and kills each in-flight create's
+// sandbox as soon as its id arrives. The tags let `humanish reclaim` find a sandbox whose id
+// never reached this process at all.
+import { createHash } from "node:crypto";
+import path from "node:path";
+/** Refuses a sandbox create for a run directory whose process is stopping. */
+export class SandboxCreateRefusedError extends Error {
+    constructor() {
+        super("The run is stopping, so no further sandbox is created.");
+        this.name = "SandboxCreateRefusedError";
+    }
+}
+const directories = new Map();
+// A process runs one study at a time; the cap only bounds a long-lived library caller, and only
+// idle entries count against it.
+const MAX_REMEMBERED_DIRECTORIES = 64;
+function identityOf(root) {
+    return "physicalRunRoot" in root
+        ? { where: root.physicalRunRoot, identity: root.runRootIdentity }
+        : { where: root.physicalPath, identity: root.identity };
+}
+function directoryKey(root) {
+    const { where, identity } = identityOf(root);
+    return `${where}\0${identity.dev}:${identity.ino}:${identity.birthtimeNs}`;
+}
+function directoryFor(root) {
+    const key = directoryKey(root);
+    const existing = directories.get(key);
+    if (existing !== undefined)
+        return existing;
+    const created = {
+        stopping: false,
+        created: new Map(),
+        inFlight: new Set(),
+        listeners: new Set(),
+    };
+    directories.set(key, created);
+    // Only an idle entry is forgotten: a stopping one keeps refusing creates, and one with a create
+    // in flight or a sandbox its route has not released is still needed by the signal handler.
+    for (const [oldest, entry] of directories) {
+        if (directories.size <= MAX_REMEMBERED_DIRECTORIES)
+            break;
+        if (entry === created || !idle(entry))
+            continue;
+        directories.delete(oldest);
+    }
+    return created;
+}
+function idle(entry) {
+    return (!entry.stopping &&
+        entry.inFlight.size === 0 &&
+        [...entry.created.values()].every((sandbox) => sandbox.released));
+}
+/**
+ * The E2B metadata that ties a sandbox to the directory that journals it. `runId` is the
+ * directory's name: the run id, or a preflight probe's id. `runKey` is a digest of the directory's
+ * inode and creation time, so two projects that both use `--run-id smoke` never match each other's
+ * sandboxes, and a renamed project directory still matches its own. `tool` is the owner tag every
+ * route already sets.
+ */
+export function sandboxOwnerTags(root) {
+    const { where, identity } = identityOf(root);
+    const runKey = createHash("sha256")
+        .update(`${identity.ino}:${identity.birthtimeNs}`)
+        .digest("hex")
+        .slice(0, 16);
+    return { tool: "humanish", runId: path.basename(where), runKey };
+}
+/** Register a create for `root`. Throws SandboxCreateRefusedError once the directory is stopping. */
+export function beginSandboxCreate(root, participantId) {
+    const directory = directoryFor(root);
+    if (directory.stopping)
+        throw new SandboxCreateRefusedError();
+    let settle;
+    const done = new Promise((resolve) => {
+        settle = resolve;
+    });
+    directory.inFlight.add(done);
+    return {
+        stopping: () => directory.stopping,
+        created(sandboxId) {
+            if (directory.created.has(sandboxId))
+                return;
+            const sandbox = { sandboxId, participantId, released: false };
+            directory.created.set(sandboxId, sandbox);
+            for (const listener of directory.listeners)
+                listener(sandbox);
+        },
+        released(sandboxId) {
+            const sandbox = directory.created.get(sandboxId);
+            if (sandbox !== undefined)
+                sandbox.released = true;
+        },
+        settled() {
+            directory.inFlight.delete(done);
+            settle();
+        },
+    };
+}
+/**
+ * Run `write` once per directory and return its promise to every caller. Creates that start
+ * together then resume in the order they called, so the order they reach the provider does not
+ * depend on which file append finishes first. A write that reports failure is forgotten, so the
+ * next create tries again.
+ */
+export function recordSandboxOwnerOnce(root, write) {
+    const directory = directoryFor(root);
+    const pending = (directory.ownerLine ??= write().then((written) => {
+        if (!written && directory.ownerLine === pending)
+            delete directory.ownerLine;
+    }));
+    return pending;
+}
+/**
+ * Stop `root`'s creates: any create that starts from now on is refused. Called synchronously when
+ * the signal arrives, before anything is awaited, so no create can slip in after it.
+ */
+export function stopSandboxCreates(root) {
+    const directory = directoryFor(root);
+    directory.stopping = true;
+    const pending = [...directory.inFlight];
+    return {
+        watch(listener) {
+            for (const sandbox of directory.created.values())
+                listener(sandbox);
+            directory.listeners.add(listener);
+            return () => {
+                directory.listeners.delete(listener);
+            };
+        },
+        settled: Promise.all(pending).then(() => undefined),
+        inFlight: () => pending.filter((create) => directory.inFlight.has(create)).length,
+    };
+}

package/dist/run/sandbox-ids.d.ts

@@ -0,0 +1,53 @@
+import { type PreparedOutputRoot } from "./contained-output.js";
+import { type PreparedRunArtifactPaths } from "./paths.js";
+/** `text` with every occurrence of each raw id replaced by its label, longest id first. */
+export declare function scrubSandboxIds(text: string, ids: Iterable<string>, label?: (id: string) => string): string;
+/**
+ * `value` as it may be written or returned: ids at the sandbox-id keys become the marker and a
+ * digest, and any raw id left in free text or a URL becomes its label.
+ */
+export declare function publicSandboxView<T>(value: T, ids: Iterable<string>): T;
+/**
+ * The raw ids at sandbox-id keys in `value`, such as a run.json recorded before 0.110. A value
+ * shorter than an E2B id is left to the key rule, so the text scrub never rewrites a common word.
+ */
+export declare function keyedSandboxIds(value: unknown): string[];
+/**
+ * Every raw sandbox id a run's files name: the receipts', and any at a sandbox-id key in its
+ * JSON, which is where a run from before 0.110 that has no receipts still records them.
+ */
+export declare function inventorySandboxIds(files: readonly {
+    path: string;
+    bytes: Buffer;
+}[]): string[];
+/** Whether a run file's JSON holds a raw id at a sandbox-id key, which no receipt may name. */
+export declare function holdsKeyedSandboxId(file: string, text: string): boolean;
+/**
+ * The raw sandbox ids a run's receipts journal, with any this process receipted whose append
+ * failed; empty when there are none or the journal cannot be read.
+ */
+export declare function readRunSandboxIds(root: PreparedOutputRoot): Promise<string[]>;
+/**
+ * `value` as a run writes it: raw sandbox ids stay in the run's sandbox-receipts.ndjson, and the
+ * file names each by marker and digest.
+ */
+export declare function withPublicSandboxIds<T>(root: PreparedOutputRoot, value: T): Promise<T>;
+/**
+ * The bytes of `file` with each raw id replaced by its label: the same buffer when none occurs, or
+ * when the bytes are not the plain text verify and export read as text.
+ */
+export declare function scrubSandboxIdBytes(file: string, bytes: Buffer, ids: readonly string[]): Buffer;
+/**
+ * Rewrite each file of a finished run that names one of its raw sandbox ids, apart from the
+ * receipts, with the label in place of the id. Writers such as a participant's actor.json can
+ * quote an SDK error that names the sandbox. Run.finish calls it before analysis reads the run.
+ * Best effort: verify grades a file this misses.
+ */
+export declare function scrubRunSandboxIds(paths: PreparedRunArtifactPaths): Promise<void>;
+/**
+ * A run's result as it may be returned or printed: the same object when it names no sandbox,
+ * otherwise its public view, scrubbed of the ids the run's receipts journal.
+ */
+export declare function publicRunResult<T extends {
+    runId?: string;
+}>(result: T, cwd: string): Promise<T>;