@prized/sdk 0.0.0-stage → 0.1.0

package/dist/esm/outcome.js

@@ -0,0 +1,152 @@
+// What an error says about a command that may have run. A command, a file
+// write, a remove or a signal (`exec` retry mode) is never sent again once it
+// may have reached the sandbox, so its error has to say what the caller cannot
+// see: whether it happened. The Python SDK words these the same (_core.py).
+import { defaultMessage, PrizedError } from './errors.js';
+const NOT_SENT_AGAIN = 'It was not sent again';
+export function commandEffect() {
+    return {
+        maybe: 'the command may or may not have run',
+        did: 'The command ran',
+        check: `${NOT_SENT_AGAIN}: check for its effects (the files it writes, the processes it starts) before you run it again.`,
+        // The sandbox runs a command under its request, in a process group of
+        // its own that it KILLs when the request ends, and the edge forwards the
+        // request under the caller's connection: a closed connection kills it.
+        onClose: 'The sandbox stops a command (and its process group) once its connection closes, so it may have run in part.',
+    };
+}
+export function writeEffect(path) {
+    return {
+        maybe: `${path} may or may not have been written`,
+        did: `${path} was written`,
+        check: `${NOT_SENT_AGAIN}: read it back with files.read() to see which.`,
+    };
+}
+export function removeEffect(path) {
+    return {
+        maybe: `${path} may or may not have been removed`,
+        did: `The remove of ${path} ran`,
+        check: `${NOT_SENT_AGAIN}: files.exists() tells you which.`,
+    };
+}
+/** For CommandHandle.kill (`signal` without its SIG prefix). */
+export function signalEffect(runId, signal) {
+    return {
+        maybe: `SIG${signal} may or may not have reached ${runId}`,
+        did: `The kill of ${runId} ran`,
+        check: `${NOT_SENT_AGAIN}: status() tells you whether the command is still running.`,
+    };
+}
+/** For a background start (or a streamed or long exec, which runs as one): said before what the SDK did about it (startAbandoned). A 2xx proves only that the start ran. */
+export function startEffect() {
+    return { maybe: 'the command may or may not have started', did: 'The sandbox ran the start', check: '' };
+}
+/** For an SDK helper sent in `exec` mode that names no effect of its own. */
+export function helperEffect() {
+    return { maybe: 'it may or may not have taken effect', did: 'It ran', check: `${NOT_SENT_AGAIN}.` };
+}
+const acted = new WeakSet();
+/** Whether withOutcome said the sandbox may have acted on the request. */
+export function mayHaveActed(error) {
+    return error instanceof PrizedError && acted.has(error);
+}
+/** `error` with another message (and, given, another status, code, sandbox or cause), every other field kept. */
+export function restate(error, message, init = {}) {
+    return new PrizedError(init.code ?? error.code, message, {
+        status: init.status ?? error.status,
+        reason: error.reason,
+        sandboxId: error.sandboxId ?? init.sandboxId ?? null,
+        body: error.body,
+        retryAfter: error.retryAfter,
+        cause: 'cause' in init ? init.cause : error.cause,
+    });
+}
+/** `error` restated with `message` (and, given, another sandbox or cause), as one after which the sandbox may have acted. */
+function acting(error, message, init = {}) {
+    const restated = restate(error, message, init);
+    acted.add(restated);
+    return restated;
+}
+function trimmed(text) {
+    return text.replace(/[.\s]+$/, '');
+}
+/** The failure in a few words, for inside a sentence. */
+function detail(error) {
+    const message = trimmed(error.message);
+    if (error.status === null || error.code === 'http_error' || error.code === 'bad_response')
+        return message;
+    const head = `HTTP ${error.status} ${error.code}`;
+    return message === trimmed(defaultMessage(error.code)) ? head : `${head}: ${message}`;
+}
+/** What follows "so" when no clear answer came: what may have happened, then (`closed`: the caller aborted) what a closed connection does, then how to check. */
+function maybeTail(effect, closed) {
+    let tail = `${effect.maybe}.`;
+    if (closed && effect.onClose)
+        tail += ` ${effect.onClose}`;
+    if (effect.check)
+        tail += ` ${effect.check}`;
+    return tail;
+}
+/** `error` (same code, status and body), its message saying what it means for `effect`. */
+export function withOutcome(error, effect, outcome) {
+    if (outcome === null)
+        return error;
+    if (outcome === 'never')
+        return restate(error, `${trimmed(error.message)}. It never reached the sandbox, so it had no effect.`);
+    if (outcome === 'did')
+        return acting(error, `${effect.did}, but the answer could not be read (${detail(error)}).`);
+    return acting(error, `No clear answer came back (${detail(error)}), so ${maybeTail(effect, false)}`);
+}
+/**
+ * `error` (code `aborted`) for a request with an `effect`: `never` when
+ * nothing that may have reached the sandbox was sent (the signal was
+ * aborted before an attempt, or while the SDK waited to send one again
+ * after attempts that never arrived), `did` when a 2xx status came before
+ * the abort cut its body, else `maybe`, with what the sandbox does once a
+ * connection closes. TypeScript only: the Python SDK takes no signal.
+ */
+export function withAbort(error, effect, outcome) {
+    if (outcome !== 'maybe')
+        return withOutcome(error, effect, outcome);
+    return acting(error, `Aborted before a clear answer came, so ${maybeTail(effect, true)}`);
+}
+/** What the SDK did about a run it stopped by its id (`stopped`), or could not confirm it did. */
+function stopTail(runId, stopped) {
+    return stopped
+        ? ` The SDK stopped ${runId}, or it had already ended.`
+        : ` The SDK could not confirm it stopped: it may still be running as ${runId} (exec('ps -ef | grep ${runId}') finds it).`;
+}
+/**
+ * A background start that may have started (`error`, from withOutcome or
+ * withAbort) and that the SDK then stopped by its run id (`stopped`: the
+ * abandon script answered exit 0, so the run can no longer start, was
+ * killed with its group, or had already ended), or could not confirm it did
+ * (no answer, or exit 3: no pid came, so the command may yet run). The
+ * Python SDK's start_abandoned.
+ */
+export function startAbandoned(error, runId, stopped) {
+    const said = error.message.trimEnd();
+    return acting(error, (/[.!?]$/.test(said) ? said : `${said}.`) + stopTail(runId, stopped));
+}
+/**
+ * A streamed or long exec the caller aborted after its run started
+ * (`error`, code `aborted`, from `sandboxId`), saying whether the SDK then
+ * stopped the run by its id (`stopped`: its KILL was sent, or the run had
+ * already ended), or could not confirm it did.
+ */
+export function runAborted(error, runId, stopped, sandboxId) {
+    return acting(error, `${trimmed(error.message)}.${stopTail(runId, stopped)}`, { sandboxId });
+}
+/**
+ * A streamed or long exec whose poll failed after its run started (`error`:
+ * a lost connection, a 5xx, an answer that could not be read, a refused
+ * key), saying whether the SDK then stopped the run by its id (`stopped`),
+ * or could not confirm it did: with the network down, the command may still
+ * be running. Same code, status and body (and `sandboxId` when it names
+ * none); `error` itself is the cause. The Python SDK's poll_failed.
+ */
+export function pollFailed(error, runId, stopped, sandboxId) {
+    // One sentence, whatever lines the poll's own error carries (a script's stderr).
+    const said = detail(error).replace(/\s+/g, ' ');
+    return acting(error, `Polling the command failed (${said}).${stopTail(runId, stopped)}`, { sandboxId, cause: error });
+}

package/dist/esm/output.d.ts

@@ -0,0 +1,59 @@
+import { type Toolbox } from './toolbox.js';
+import type { ExecResult } from './types.js';
+export declare const OUTPUT_DIR = "/home/prized/.prized/exec";
+export declare const OUTPUT_ID_RE: RegExp;
+/** Each stream of a fullOutput command keeps at most this many bytes: one download. */
+export declare const FULL_OUTPUT_BYTES: number;
+/**
+ * The variables that carry the script and the caller's command, so neither
+ * is in the argv of any process but the command's own shell: `pkill -f`
+ * finds what it finds in a plain exec. The script unsets both first.
+ */
+export declare const SCRIPT_VAR = "PRIZED_EXEC_SCRIPT";
+export declare const COMMAND_VAR = "PRIZED_EXEC_COMMAND";
+/** What a fullOutput exec sends as its command: the script, from SCRIPT_VAR. */
+export declare const RUN_SCRIPT = "eval \"${PRIZED_EXEC_SCRIPT:?}\"";
+/**
+ * The script a fullOutput exec runs (RUN_SCRIPT, from SCRIPT_VAR). The
+ * caller's command, from COMMAND_VAR, runs as a plain exec runs it (`bash
+ * -c`, or `sh -c` where there is no bash, stdin from /dev/null), with the
+ * request's cwd and env.
+ *
+ * Nothing is assigned before it runs but the positional parameters, so every
+ * variable the caller's env sets reaches it unchanged, PATH included; and
+ * every step holds under an errexit the env may switch on (SHELLOPTS). As in
+ * a plain exec, the readers stop 5 s after the command ends if a process it
+ * left running still holds its output, keeping what came through. A command
+ * a signal ends exits 128+n, as a background command does. Without tee,
+ * setsid or a directory to write to, the command runs as a plain exec.
+ */
+export declare function captureScript(id: string): string;
+/**
+ * What a fullOutput command left when the script could not print it (its
+ * time limit, or a signal, ended the script): the marker line, or `gone`,
+ * with the directory removed, when there is nothing to read (it was never
+ * made, or its output was already printed back).
+ */
+export declare function collectScript(id: string): string;
+/**
+ * Remove a fullOutput command's directory (keyed by the SDK's own id, safe to
+ * send again), and any an earlier one left over an hour ago, when it got no
+ * answer to remove its own.
+ */
+export declare function removeOutputScript(id: string): string;
+/** The marker's byte counts (a stream cut at FULL_OUTPUT_BYTES reads more), `gone`, or null for no marker. */
+export declare function parseMarker(stdout: string, id: string): {
+    out: number;
+    err: number;
+} | 'gone' | null;
+/**
+ * A blocking exec that keeps the whole output (up to FULL_OUTPUT_BYTES of
+ * each stream). The result is a plain exec's, timeouts included: the caller
+ * (execCommand) turns a timed-out one into CommandTimeoutError.
+ */
+export declare function execFullOutput(toolbox: Toolbox, id: string, req: {
+    command: string;
+    cwd?: string | undefined;
+    env?: Record<string, string> | undefined;
+    timeoutMs: number;
+}, signal: AbortSignal | undefined): Promise<ExecResult>;

package/dist/esm/output.js

@@ -0,0 +1,280 @@
+// exec(..., { fullOutput: true }): one call that keeps a command's whole
+// output, not just the first 4 MiB of each stream the sandbox answers with.
+//
+// The command's stdout and stderr stay pipes, as in a plain exec. A reader on
+// each copies what comes through to a file in the exec's own directory, at a
+// fixed path under the sandbox user's home, and drops what passes 100 MiB, so
+// a runaway command cannot fill the disk:
+//
+//   ~/.prized/exec/<exec id>/stdout
+//   ~/.prized/exec/<exec id>/stderr
+//
+// Both under 4 MiB: the script prints them back and removes the directory,
+// so the answer carries the same output a plain exec's does. Bigger: it
+// prints one marker line instead, and the SDK downloads both files through
+// the files API and removes the directory. The scripts are the Python SDK's
+// (sdk/python/src/prized/_output.py), rendered the same; both SDKs check
+// them against sdk/output-scripts/.
+import { PrizedError } from './errors.js';
+import { request } from './http.js';
+import { restate } from './outcome.js';
+import { LAUNCH_PATH } from './shell.js';
+import { helperExec, MAX_FILE_BYTES, MAX_OUTPUT_BYTES, rawExec } from './toolbox.js';
+export const OUTPUT_DIR = '/home/prized/.prized/exec';
+export const OUTPUT_ID_RE = /^exec_[0-9a-f]{16}$/;
+/** Each stream of a fullOutput command keeps at most this many bytes: one download. */
+export const FULL_OUTPUT_BYTES = MAX_FILE_BYTES;
+/**
+ * The variables that carry the script and the caller's command, so neither
+ * is in the argv of any process but the command's own shell: `pkill -f`
+ * finds what it finds in a plain exec. The script unsets both first.
+ */
+export const SCRIPT_VAR = 'PRIZED_EXEC_SCRIPT';
+export const COMMAND_VAR = 'PRIZED_EXEC_COMMAND';
+/** What a fullOutput exec sends as its command: the script, from SCRIPT_VAR. */
+export const RUN_SCRIPT = `eval "\${${SCRIPT_VAR}:?}"`;
+/** How long the readers may run on after the command (the sandbox's own wait for a plain exec's pipes). */
+const GRACE_S = 5;
+/**
+ * A directory older than this is one an earlier exec could not remove: no
+ * exec runs it that long (MAX_BLOCKING_EXEC_MS, then GRACE_S and READ_MS).
+ */
+const STALE_MIN = 60;
+/** The bound on each request the SDK makes on its own to collect or remove the files. */
+const TEARDOWN_MS = 10_000;
+/** The bound on reading the files back, retries included (files.ts FILE_TIMEOUT_MS). */
+const READ_MS = 10 * 60_000;
+function checkId(id) {
+    if (!OUTPUT_ID_RE.test(id))
+        throw new Error(`unreachable: bad exec id ${id}`);
+}
+/**
+ * The reader on one stream: tee copies it to the file as it comes (each read
+ * written at once) until the file reaches FULL_OUTPUT_BYTES and one 512-byte
+ * block more, which tells a cut stream from a full one. The file size limit
+ * (ulimit -f, in 512-byte blocks in POSIX mode) stops the file there with
+ * EFBIG, not SIGXFSZ, and tee goes on draining into /dev/null, so the command
+ * never meets a closed pipe and a runaway one cannot fill the disk. One
+ * process per stream (exec), in a session of its own (setsid, same pid): a
+ * time limit or a `kill 0` that ends the command's process group leaves it to
+ * drain what the pipe still holds.
+ */
+function reader(d, name, fifo) {
+    const blocks = FULL_OUTPUT_BYTES / 512 + 1;
+    return (`( exec > /dev/null 2>&1; PATH=${LAUNCH_PATH}; trap '' XFSZ; ( set -o posix ) && set -o posix; ` +
+        `ulimit -f ${blocks} || :; exec setsid tee ${d}/${name} < ${d}/${fifo} ) &`);
+}
+/**
+ * The bound on waiting for the readers once the command has ended: GRACE_S
+ * seconds, as the sandbox waits for a plain exec's pipes, then the readers
+ * still running stop (a pid is checked to be this exec's tee first, never
+ * one reused since), and a process the command left holding its output
+ * meets a closed pipe, as it would there. Stopped early (TERM, once the
+ * readers are done), it takes its sleep with it.
+ */
+function watchdog(d) {
+    return (`( s=; trap '[ -z "$s" ] || kill "$s" 2> /dev/null; exit 0' TERM; sleep ${GRACE_S} & s=$!; wait "$s" || :; ` +
+        `for p in "$2" "$3"; do if tr "\\0" " " < "/proc/$p/cmdline" 2> /dev/null | grep -qF -- ${d}/; then kill "$p" 2> /dev/null || :; fi; done ) > /dev/null 2>&1 &`);
+}
+/** Sizes, the cut past FULL_OUTPUT_BYTES and the marker line, with `d` set to the directory. */
+function reportLines(id) {
+    const max = FULL_OUTPUT_BYTES;
+    return {
+        sizes: ['o=$(stat -c %s "$d/stdout" 2> /dev/null || echo 0)', 'e=$(stat -c %s "$d/stderr" 2> /dev/null || echo 0)'],
+        cut: [
+            `if [ "$o" -gt ${max} ]; then truncate -s ${max} "$d/stdout" || :; fi`,
+            `if [ "$e" -gt ${max} ]; then truncate -s ${max} "$d/stderr" || :; fi`,
+            `echo "prized-output ${id} $o $e"`,
+        ],
+    };
+}
+/**
+ * The script a fullOutput exec runs (RUN_SCRIPT, from SCRIPT_VAR). The
+ * caller's command, from COMMAND_VAR, runs as a plain exec runs it (`bash
+ * -c`, or `sh -c` where there is no bash, stdin from /dev/null), with the
+ * request's cwd and env.
+ *
+ * Nothing is assigned before it runs but the positional parameters, so every
+ * variable the caller's env sets reaches it unchanged, PATH included; and
+ * every step holds under an errexit the env may switch on (SHELLOPTS). As in
+ * a plain exec, the readers stop 5 s after the command ends if a process it
+ * left running still holds its output, keeping what came through. A command
+ * a signal ends exits 128+n, as a background command does. Without tee,
+ * setsid or a directory to write to, the command runs as a plain exec.
+ */
+export function captureScript(id) {
+    checkId(id);
+    const d = `${OUTPUT_DIR}/${id}`;
+    const { sizes, cut } = reportLines(id);
+    return [
+        `set -- "\${${COMMAND_VAR}:?}" /bin/bash; unset ${COMMAND_VAR} ${SCRIPT_VAR}; [ -x "$2" ] || set -- "$1" /bin/sh`,
+        `if ( PATH=${LAUNCH_PATH}; mkdir -p ${OUTPUT_DIR} && mkdir ${d} ) 2> /dev/null; then`,
+        `if ( PATH=${LAUNCH_PATH}; command -v tee && command -v setsid && mkfifo ${d}/o ${d}/e ) > /dev/null 2>&1; then`,
+        reader(d, 'stdout', 'o'),
+        'set -- "$1" "$2" "$!"',
+        reader(d, 'stderr', 'e'),
+        'set -- "$1" "$2" "$3" "$!"',
+        // bash's "Killed" line for a command a signal ended goes to the braces' /dev/null.
+        `if { "$2" -c "$1" > ${d}/o 2> ${d}/e < /dev/null; } 2> /dev/null; then set -- 0 "$3" "$4"; else set -- "$?" "$3" "$4"; fi`,
+        `PATH=${LAUNCH_PATH}`,
+        `c=$1; d=${d}`,
+        watchdog(d),
+        'w=$!',
+        'wait "$2" "$3" 2> /dev/null || :',
+        'kill "$w" 2> /dev/null || :',
+        ...sizes,
+        `if [ "$o" -lt ${MAX_OUTPUT_BYTES} ] && [ "$e" -lt ${MAX_OUTPUT_BYTES} ]; then ` +
+            'cat "$d/stdout" 2> /dev/null || :; cat "$d/stderr" >&2 2> /dev/null || :; rm -rf "$d" || :; exit "$c"; fi',
+        ...cut,
+        'exit "$c"',
+        'fi',
+        `( PATH=${LAUNCH_PATH}; rm -rf ${d} ) 2> /dev/null || :`,
+        'fi',
+        'exec "$2" -c "$1" < /dev/null',
+    ].join('\n');
+}
+/**
+ * What a fullOutput command left when the script could not print it (its
+ * time limit, or a signal, ended the script): the marker line, or `gone`,
+ * with the directory removed, when there is nothing to read (it was never
+ * made, or its output was already printed back).
+ */
+export function collectScript(id) {
+    checkId(id);
+    const { sizes, cut } = reportLines(id);
+    return [
+        `d=${OUTPUT_DIR}/${id}`,
+        `PATH=${LAUNCH_PATH}`,
+        `if [ ! -f "$d/stdout" ] || [ ! -f "$d/stderr" ]; then rm -rf "$d" || :; echo "prized-output ${id} gone"; exit 0; fi`,
+        ...sizes,
+        ...cut,
+    ].join('\n');
+}
+/**
+ * Remove a fullOutput command's directory (keyed by the SDK's own id, safe to
+ * send again), and any an earlier one left over an hour ago, when it got no
+ * answer to remove its own.
+ */
+export function removeOutputScript(id) {
+    checkId(id);
+    return (`PATH=${LAUNCH_PATH}; rm -rf ${OUTPUT_DIR}/${id}; ` +
+        `find ${OUTPUT_DIR} -mindepth 1 -maxdepth 1 -name 'exec_*' -mmin +${STALE_MIN} -exec rm -rf -- {} + 2> /dev/null || :`);
+}
+/** The marker's byte counts (a stream cut at FULL_OUTPUT_BYTES reads more), `gone`, or null for no marker. */
+export function parseMarker(stdout, id) {
+    const m = new RegExp(`(?:^|\\n)prized-output ${id} (?:([0-9]+) ([0-9]+)|(gone))\\n$`).exec(stdout);
+    if (m === null)
+        return null;
+    if (m[3] === 'gone')
+        return 'gone';
+    return { out: Number(m[1]), err: Number(m[2]) };
+}
+/** A request the SDK sends on its own to collect or remove the files: best effort, within TEARDOWN_MS. */
+async function teardown(toolbox, script) {
+    try {
+        return await helperExec(toolbox, script, { deadline: toolbox.config.now() + TEARDOWN_MS });
+    }
+    catch {
+        return null;
+    }
+}
+async function download(toolbox, path, signal) {
+    const result = await request(toolbox.config, {
+        method: 'GET',
+        url: `${toolbox.base()}/files/download?path=${encodeURIComponent(path)}`,
+        retry: 'safe',
+        read: 'bytes',
+        timeoutMs: READ_MS,
+        deadline: toolbox.config.now() + READ_MS,
+        signal,
+        sandboxId: toolbox.sandboxId,
+    });
+    // A leading BOM is the command's own output, as in the answer.
+    return new TextDecoder('utf-8', { ignoreBOM: true }).decode(result.bytes ?? new Uint8Array(0));
+}
+/** The files' contents in place of the answer's output. */
+async function readBack(toolbox, id, sizes, result, signal) {
+    const dir = `${OUTPUT_DIR}/${id}`;
+    // Both at once; one that fails stops the other, as the caller's abort stops both.
+    const both = new AbortController();
+    const stop = () => both.abort();
+    if (signal?.aborted)
+        stop();
+    signal?.addEventListener('abort', stop, { once: true });
+    const read = (name, size) => size > 0
+        ? download(toolbox, `${dir}/${name}`, both.signal).catch((error) => {
+            stop();
+            throw error;
+        })
+        : Promise.resolve('');
+    let stdout;
+    let stderr;
+    try {
+        [stdout, stderr] = await Promise.all([read('stdout', sizes.out), read('stderr', sizes.err)]);
+    }
+    finally {
+        signal?.removeEventListener('abort', stop);
+    }
+    return {
+        ...result,
+        stdout,
+        stderr,
+        truncated: sizes.out > FULL_OUTPUT_BYTES || sizes.err > FULL_OUTPUT_BYTES,
+    };
+}
+/**
+ * A blocking exec that keeps the whole output (up to FULL_OUTPUT_BYTES of
+ * each stream). The result is a plain exec's, timeouts included: the caller
+ * (execCommand) turns a timed-out one into CommandTimeoutError.
+ */
+export async function execFullOutput(toolbox, id, req, signal) {
+    const raw = {
+        command: RUN_SCRIPT,
+        env: { ...req.env, [SCRIPT_VAR]: captureScript(id), [COMMAND_VAR]: req.command },
+        timeoutMs: req.timeoutMs,
+    };
+    if (req.cwd !== undefined)
+        raw.cwd = req.cwd;
+    let result;
+    try {
+        // A plain exec's retry rules: sent again only if it provably never arrived.
+        result = await rawExec(toolbox, raw, { retry: 'exec', signal });
+    }
+    catch (error) {
+        // The caller has no way to read what it printed: its files go.
+        await teardown(toolbox, removeOutputScript(id));
+        throw error;
+    }
+    let sizes = parseMarker(result.stdout, id);
+    if (sizes === null && (result.timedOut || result.exitCode === -1)) {
+        // Its time limit (or a signal) ended the script with the command, before
+        // it printed anything back: what the command printed is in its files.
+        const collected = await teardown(toolbox, collectScript(id));
+        sizes = collected === null ? null : parseMarker(collected.stdout, id);
+        if (sizes === null)
+            return result; // no answer: nothing more to be done
+    }
+    // No marker: the output came back in the answer (or the command ran as a
+    // plain exec), and the directory is already gone.
+    if (sizes === null || sizes === 'gone')
+        return result;
+    let full;
+    try {
+        full = await readBack(toolbox, id, sizes, result, signal);
+    }
+    catch (error) {
+        const aborted = !(error instanceof PrizedError) || error.code === 'aborted';
+        if (aborted || result.timedOut) {
+            // Leaving, or the timeout is the caller's error: the files go.
+            await teardown(toolbox, removeOutputScript(id));
+            if (aborted)
+                throw error;
+            return result;
+        }
+        const dir = `${OUTPUT_DIR}/${id}`;
+        throw restate(error, `The command ran (exit ${result.exitCode}), but its output could not be read back (${error.message.replace(/[.\s]+$/, '')}). ` +
+            `It is kept in ${dir}/stdout and ${dir}/stderr for an hour: read them with files.read(), then remove ${dir}.`);
+    }
+    await teardown(toolbox, removeOutputScript(id));
+    return full;
+}