@specific.dev/spectest 0.89.0 → 0.90.0

package/dist/components/android.d.ts

@@ -0,0 +1,74 @@
+import { type AndroidApp, type AndroidRecordingOptions } from "../android.js";
+export interface AndroidOptions {
+    /** Project-relative path to an APK built for the worker's native ABI. */
+    apk: string;
+    /** Android application id, for example com.example.app. */
+    package: string;
+    /** Launch activity, for example .MainActivity. */
+    activity: string;
+    /** Android image; default is the tested Android 14 arm64-only redroid image. */
+    image?: string;
+    /** Optional prebuilt image containing the same tools as ANDROID_TOOLS_DOCKERFILE. */
+    toolsImage?: string;
+    /** Display defaults to Pixel 8 dimensions: 1080 × 2400, at 420 logical dpi. */
+    width?: number;
+    height?: number;
+    dpi?: number;
+    /** Show tap markers in replay and enable native physical-touch feedback. Default true. */
+    showTouches?: boolean;
+    recording?: false | AndroidRecordingOptions;
+    dependsOn?: string[];
+}
+export declare const ANDROID_TOOLS_DOCKERFILE = "FROM node:22-bookworm-slim\nRUN apt-get update && apt-get install -y --no-install-recommends adb aapt apksigner zipalign ffmpeg default-jdk-headless ca-certificates curl gcc pkg-config meson ninja-build libsdl2-dev libavcodec-dev libavdevice-dev libavformat-dev libavutil-dev libswresample-dev libusb-1.0-0-dev && rm -rf /var/lib/apt/lists/*\nRUN curl -fL https://github.com/Genymobile/scrcpy/archive/refs/tags/v3.3.1.tar.gz | tar xz -C /tmp && curl -fL https://github.com/Genymobile/scrcpy/releases/download/v3.3.1/scrcpy-server-v3.3.1 -o /tmp/scrcpy-server && meson setup /tmp/scrcpy-build /tmp/scrcpy-3.3.1 --buildtype=release -Dprebuilt_server=/tmp/scrcpy-server && ninja -C /tmp/scrcpy-build -j4 install && rm -rf /tmp/scrcpy*\nENV ANDROID_HOME=/opt/android JAVA_HOME=/usr/lib/jvm/default-java APPIUM_HOME=/opt/appium\nRUN mkdir -p /opt/android/platform-tools && for tool in adb aapt aapt2 apksigner zipalign; do ln -s /usr/bin/$tool /opt/android/platform-tools/$tool; done && npm install -g appium@3.8.0 && appium driver install uiautomator2@8.7.0\n";
+/** Native Android, Appium and software recording, all inside the environment VM. */
+export declare function android(options: AndroidOptions): import("../index.js").ServiceGroup<{
+    device: {
+        image: {
+            type: "registry";
+            reference: string;
+        };
+        privileged: true;
+        args: string[];
+        ports: number[];
+        dependsOn: string[] | undefined;
+        readyCheck: {
+            type: "exec";
+            command: string;
+            timeoutSecs: number;
+        };
+    };
+    tools: {
+        image: {
+            type: "registry";
+            reference: string;
+            content?: undefined;
+        } | {
+            type: "dockerfile";
+            content: string;
+            reference?: undefined;
+        };
+        command: string;
+        files: {
+            path: string;
+            content: string;
+        }[];
+        volumes: {
+            source: string;
+            target: string;
+            readOnly: true;
+        }[];
+        inputs: string[];
+        env: {
+            ANDROID_SERIAL: string;
+            ANDROID_ACTIVITY: string;
+            ANDROID_SHOW_TOUCHES: string;
+        };
+        ports: number[];
+        readyCheck: {
+            type: "http";
+            port: number;
+            path: string;
+            timeoutSecs: number;
+        };
+    };
+}, AndroidApp, "tools">;

package/dist/components/android.js

@@ -0,0 +1,92 @@
+import { readFileSync } from "node:fs";
+import { posix } from "node:path";
+import { serviceGroup } from "../index.js";
+import { resolveExistingProjectPath } from "../project-files.js";
+import { androidApp } from "../android.js";
+export const ANDROID_TOOLS_DOCKERFILE = `FROM node:22-bookworm-slim
+RUN apt-get update && apt-get install -y --no-install-recommends adb aapt apksigner zipalign ffmpeg default-jdk-headless ca-certificates curl gcc pkg-config meson ninja-build libsdl2-dev libavcodec-dev libavdevice-dev libavformat-dev libavutil-dev libswresample-dev libusb-1.0-0-dev && rm -rf /var/lib/apt/lists/*
+RUN curl -fL https://github.com/Genymobile/scrcpy/archive/refs/tags/v3.3.1.tar.gz | tar xz -C /tmp && curl -fL https://github.com/Genymobile/scrcpy/releases/download/v3.3.1/scrcpy-server-v3.3.1 -o /tmp/scrcpy-server && meson setup /tmp/scrcpy-build /tmp/scrcpy-3.3.1 --buildtype=release -Dprebuilt_server=/tmp/scrcpy-server && ninja -C /tmp/scrcpy-build -j4 install && rm -rf /tmp/scrcpy*
+ENV ANDROID_HOME=/opt/android JAVA_HOME=/usr/lib/jvm/default-java APPIUM_HOME=/opt/appium
+RUN mkdir -p /opt/android/platform-tools && for tool in adb aapt aapt2 apksigner zipalign; do ln -s /usr/bin/$tool /opt/android/platform-tools/$tool; done && npm install -g appium@3.8.0 && appium driver install uiautomator2@8.7.0
+`;
+/** Native Android, Appium and software recording, all inside the environment VM. */
+export function android(options) {
+    if (!options.apk ||
+        !/^[\w]+(?:\.[\w]+)+$/.test(options.package) ||
+        !/^[\w.$]+$/.test(options.activity))
+        throw new Error("android(): apk, package and activity are required");
+    const apk = posix.normalize(options.apk);
+    if (posix.isAbsolute(apk) || apk.startsWith("../") || apk.startsWith("spectest/tests/"))
+        throw new Error("android(): apk must be project-relative and outside spectest/tests so app changes invalidate snapshots");
+    const width = options.width ?? 1080, height = options.height ?? 2400, dpi = options.dpi ?? 420;
+    for (const value of [width, height, dpi])
+        if (!Number.isInteger(value) || value < 1 || value > 4096)
+            throw new Error("android(): invalid display dimensions/density");
+    return serviceGroup({
+        primary: "tools",
+        services: (g) => ({
+            device: {
+                image: {
+                    type: "registry",
+                    reference: options.image ??
+                        "redroid/redroid:14.0.0_64only-latest@sha256:0a611199ba2e0b5d60af39b3327a517f6407231f4352114ed3bd3cbfe2be69aa",
+                },
+                privileged: true,
+                // Android's netd ignores resolv.conf. Use Docker's per-container DNS,
+                // which resolves service aliases and forwards to the in-VM resolver.
+                args: [
+                    `androidboot.redroid_width=${width}`,
+                    `androidboot.redroid_height=${height}`,
+                    `androidboot.redroid_dpi=${dpi}`,
+                    "androidboot.redroid_gpu_mode=guest",
+                    "androidboot.use_memfd=1",
+                    "androidboot.redroid_net_ndns=1",
+                    "androidboot.redroid_net_dns1=127.0.0.11",
+                ],
+                ports: [5555],
+                dependsOn: options.dependsOn,
+                readyCheck: {
+                    type: "exec",
+                    command: 'test "$(getprop sys.boot_completed)" = 1',
+                    timeoutSecs: 180,
+                },
+            },
+            tools: {
+                image: options.toolsImage
+                    ? { type: "registry", reference: options.toolsImage }
+                    : { type: "dockerfile", content: ANDROID_TOOLS_DOCKERFILE },
+                command: "node /spectest-android.mjs",
+                files: [
+                    {
+                        path: "/spectest-android.mjs",
+                        content: readFileSync(new URL("./android-runtime.mjs", import.meta.url), "utf8"),
+                    },
+                ],
+                volumes: [
+                    {
+                        source: resolveExistingProjectPath(apk, "Android APK"),
+                        target: "/spectest/app.apk",
+                        readOnly: true,
+                    },
+                ],
+                inputs: [apk],
+                env: {
+                    ANDROID_SERIAL: `${g.key("device")}.internal:5555`,
+                    ANDROID_ACTIVITY: `${options.package}/${options.activity}`,
+                    ANDROID_SHOW_TOUCHES: options.showTouches === false ? "0" : "1",
+                },
+                ports: [4723, 4725],
+                readyCheck: { type: "http", port: 4725, path: "/ready", timeoutSecs: 240 },
+            },
+        }),
+        helpers: ({ name }) => androidApp({
+            name,
+            endpoint: `http://${name}.internal:4723`,
+            recorderEndpoint: `http://${name}.internal:4725`,
+            serial: `${name}-device.internal:5555`,
+            package: options.package,
+            recording: options.recording ?? {},
+            showTouches: options.showTouches ?? true,
+        }),
+    });
+}

package/dist/components/index.d.ts

@@ -15,3 +15,4 @@ export { microsoft, type MicrosoftOptions } from "./microsoft.js";
 export { okta, type OktaOptions } from "./okta.js";
 export { replayFake, type ReplayFakeOptions, type ReplayMatch, type InjectRule, type InjectMatch, type StringMatch, type SignConfig, type AwsSigV4Sign, type ReplayHelpers, type ReplaySummary, type Cassette, type CassetteInteraction, type CassetteRequest, type CassetteResponse, type CassetteState, } from "./replayFake.js";
 export { electron, type ElectronOptions } from "./electron.js";
+export { android, type AndroidOptions } from "./android.js";

package/dist/components/index.js

@@ -24,3 +24,4 @@ export { microsoft } from "./microsoft.js";
 export { okta } from "./okta.js";
 export { replayFake, } from "./replayFake.js";
 export { electron } from "./electron.js";
+export { android } from "./android.js";

package/dist/daemon.js

@@ -1,3 +1,4 @@
+import { androidScope, androidRecordingChunk, releaseAndroidRecording, isAndroidApp } from "./android.js";
 // Long-running HTTP daemon. Runs as a systemd unit on the VM host (not in
 // a container). Owns:
 //
@@ -51,6 +52,7 @@ import { bindInstrumentationScope, createInstrumentationScope, runInstrumented,
 import { encodeRegistry } from "./harness/names-registry.js";
 import { InterceptRegistry, parseTarget, runChain, } from "./harness/intercept.js";
 import { HOP_BY_HOP_HEADERS, augmentCorsResponse, corsPreflightResponse, isCorsPreflight, } from "./harness/http-proxy.js";
+import { WS_BRIDGE_HANDLERS, openUpstreamWebSocket, parseSubprotocols, upstreamHandshakeHeaders, } from "./harness/ws-bridge.js";
 import { certCovers as hostmatchCertCovers, hostWithoutPort, matchRoute, selectCertName, wildcardSuffix, } from "./harness/hostmatch.js";
 import { INGRESS_HTTPS_PORT, INGRESS_HTTP_PORT, bindRoute, clearTables, emptyTables, planBind, registryTarget, routesFor, unbindRoute, } from "./harness/ingress-table.js";
 import { startTlsTerminator } from "./harness/tls-terminator.js";
@@ -487,6 +489,12 @@ function ensureLocalBuildkitd() {
     return _localBuilder;
 }
 async function bringUpLocalBuildkitd() {
+    if (existsSync("/run/spectest-sticky/consumer.json")) {
+        const ready = await docker(["buildx", "inspect", "--bootstrap", LOCAL_BUILDER_NAME], 30_000);
+        if (ready.code !== 0)
+            throw new Error(`sticky BuildKit unavailable: ${ready.stderr}`);
+        return true;
+    }
     const paths = await imageCachePaths();
     if (!paths)
         return false;
@@ -1977,8 +1985,8 @@ async function unbindRuntimeTls(hostname) {
  * Spin up one Bun.serve listener bound to (port, optional TLS) that
  * dispatches every request to the matching Route by Host header.
  *
- * Shared by the HTTP and HTTPS branches. Also exports a `websocket`
- * handler so reverse-proxy targets can transparently bridge WS
+ * Shared by the HTTP and HTTPS branches. Also carries the `websocket`
+ * handler set so reverse-proxy targets can transparently bridge WS
  * upgrades through to their upstream service.
  */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -2016,81 +2024,9 @@ serve = { proto: "http" }) {
         idleTimeout: 0,
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         fetch: (req, server) => dispatchIngress(req, server, byHost, listenerLabel, proto),
-        websocket: {
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            async open(ws) {
-                const data = ws.data;
-                try {
-                    const upstream = new WebSocket(data.upstreamUrl);
-                    // ArrayBuffer so binary frames can be ws.send()'d to the
-                    // downstream client verbatim — Blob would need an extra
-                    // .arrayBuffer() round-trip on every message.
-                    upstream.binaryType = "arraybuffer";
-                    data.upstream = upstream;
-                    upstream.addEventListener("open", () => {
-                        for (const m of data.pending)
-                            upstream.send(m);
-                        data.pending = [];
-                    });
-                    upstream.addEventListener("message", (ev) => {
-                        try {
-                            ws.send(ev.data);
-                        }
-                        catch {
-                            /* client gone */
-                        }
-                    });
-                    upstream.addEventListener("close", (ev) => {
-                        try {
-                            ws.close(ev.code, ev.reason);
-                        }
-                        catch {
-                            /* already closed */
-                        }
-                    });
-                    upstream.addEventListener("error", () => {
-                        try {
-                            ws.close(1011, "upstream error");
-                        }
-                        catch {
-                            /* already closed */
-                        }
-                    });
-                }
-                catch (err) {
-                    // eslint-disable-next-line no-console
-                    console.warn(`[ingress] ws upstream open failed for ${data.upstreamUrl}:`, err);
-                    try {
-                        ws.close(1011, "upstream open failed");
-                    }
-                    catch {
-                        /* ignore */
-                    }
-                }
-            },
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            message(ws, message) {
-                const data = ws.data;
-                const payload = typeof message === "string" ? message : new Uint8Array(message);
-                if (data.upstream && data.upstream.readyState === WebSocket.OPEN) {
-                    data.upstream.send(payload);
-                }
-                else {
-                    // Buffer until the upstream finishes its handshake.
-                    data.pending.push(payload);
-                }
-            },
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            close(ws, code, reason) {
-                const data = ws.data;
-                try {
-                    data.upstream?.close(code, reason);
-                }
-                catch {
-                    /* ignore */
-                }
-            },
-        },
+        // The frame relay for bridged WebSocket upgrades; `proxyToService`
+        // opens the upstream before it upgrades the client (harness/ws-bridge.ts).
+        websocket: WS_BRIDGE_HANDLERS,
     };
     return Bun.serve(opts);
 }
@@ -2181,8 +2117,12 @@ function ingressClientIp(server, req, proto) {
  * Reverse-proxy a request to `http://<service>:<port>` on
  * `spectest-net`. Handles plain HTTP/1.1 + 2 and WebSocket upgrades:
  *
- *   - WS upgrade requests get routed through `server.upgrade()`, with
- *     the upstream URL stashed on `ws.data`. The shared `websocket`
+ *   - WS upgrade requests open the upstream WebSocket first, with the
+ *     client's full `Sec-WebSocket-Protocol` list and its forwardable
+ *     headers (cookies, authorization, origin, x-forwarded-*). Only after
+ *     that handshake succeeds is the client upgraded, with the protocol
+ *     the upstream selected; a refused upstream handshake is a 502, not a
+ *     101 followed by a close. The open upstream rides on `ws.data`; the shared `websocket`
  *     handler opens the upstream and bridges frames both ways.
  *   - Plain requests pass through via `fetch()` with hop-by-hop
  *     headers stripped; the response body is a ReadableStream returned
@@ -2205,16 +2145,38 @@ server, service, port, listenerLabel, proto) {
     const upgrade = req.headers.get("upgrade")?.toLowerCase() ?? "";
     if (upgrade === "websocket") {
         const upstreamUrl = `ws://${await proxyUpstreamHost(service)}:${port}${upstreamPath}`;
-        const wsData = {
-            upstreamUrl,
-            upstream: null,
-            pending: [],
-        };
-        const ok = server.upgrade(req, { data: wsData });
+        // The upstream handshake carries what the client's did: the whole
+        // subprotocol list (a console ticket often rides as the second entry)
+        // and the forwardable headers. Same provenance stamps as the HTTP path.
+        const protocols = parseSubprotocols(req.headers.get("sec-websocket-protocol"));
+        const headers = upstreamHandshakeHeaders(req.headers, {
+            service,
+            port,
+            proto,
+            clientIp: ingressClientIp(server, req, proto),
+        });
+        const opened = await openUpstreamWebSocket(upstreamUrl, { protocols, headers });
+        if (!opened.ok) {
+            return new Response(`spectest-daemon: ${opened.reason} (${upstreamUrl}) on ${listenerLabel}\n`, { status: 502, headers: { "content-type": "text/plain" } });
+        }
+        const wsData = { upstreamUrl, upstream: opened.socket };
+        // Echo the protocol the upstream selected; Bun would otherwise pick
+        // the client's first entry by itself, which can differ.
+        const selected = opened.socket.protocol;
+        const ok = server.upgrade(req, {
+            data: wsData,
+            headers: selected ? { "sec-websocket-protocol": selected } : undefined,
+        });
         if (ok) {
             // Bun has already taken over the response — return a stub.
             return new Response(null, { status: 101 });
         }
+        try {
+            opened.socket.close(1011, "client upgrade refused");
+        }
+        catch {
+            /* ignore */
+        }
         return new Response(`spectest-daemon: ws upgrade refused on ${listenerLabel}\n`, { status: 426, headers: { "content-type": "text/plain" } });
     }
     const fwdHeaders = new Headers();
@@ -4414,6 +4376,8 @@ function captureConsole(chunks) {
 }
 async function runOne(testCase) {
     const start = Date.now();
+    const nativeAndroid = androidScope(testCase.id, start);
+    let androidRecordings = [];
     const chunks = [];
     const origStdout = process.stdout.write.bind(process.stdout);
     const origStderr = process.stderr.write.bind(process.stderr);
@@ -4567,7 +4531,8 @@ async function runOne(testCase) {
         });
         return term;
     };
-    startRecording();
+    // Share the case clock with native video timestamps and other artifacts.
+    startRecording(start);
     const restoreFetch = installFetchWrapper();
     const fetchScope = createInstrumentationScope();
     // Look up the parent's stored return value (if any). The parent ran in
@@ -4678,6 +4643,7 @@ async function runOne(testCase) {
         openTerminal: recordedOpenTerminal,
         browser: trackedOpenBrowser,
         mobile: trackedOpenMobile,
+        android: nativeAndroid.open,
         desktop: desktopOpener(start, testCase.id, sessions, browserDetaches),
         mcp: openMcp,
         testName: testCase.name,
@@ -4699,10 +4665,10 @@ async function runOne(testCase) {
     });
     // Result events are gathered inside finally (after the final browser
     // drains) so we hoist these out of the try/catch.
-    let outcome;
+    let outcome = { status: "passed" };
     try {
         const value = await Promise.race([
-            Promise.resolve(runInstrumented(fetchScope, () => testCase.run(ctx))),
+            Promise.resolve(runInstrumented(fetchScope, async () => { await nativeAndroid.begin(Object.values(base.svc).filter(isAndroidApp)); return testCase.run(ctx); })),
             timedOut,
         ]);
         // Stash the return value so child cases — which fork from the snapshot
@@ -4720,6 +4686,7 @@ async function runOne(testCase) {
     finally {
         if (timer)
             clearTimeout(timer);
+        nativeAndroid.deactivate();
         RECORDING_EXEC = undefined;
         INTERCEPTORS.endScope();
         fetchScope.active = false;
@@ -4744,6 +4711,10 @@ async function runOne(testCase) {
         }
         for (const s of sessions)
             s.markClosed();
+        androidRecordings = await nativeAndroid.finish();
+        const captureErrors = androidRecordings.flatMap(r => r.error ? [r.error] : []);
+        if (captureErrors.length && outcome.status === "passed")
+            outcome = { status: "failed", error: { message: captureErrors.join("\n") } };
     }
     const durationMs = Date.now() - start;
     // Capture each service's log delta (the lines THIS case added beyond its
@@ -4802,6 +4773,7 @@ async function runOne(testCase) {
     }
     return {
         status: outcome.status,
+        androidRecordings,
         durationMs,
         log: chunks.join(""),
         events,
@@ -5032,6 +5004,7 @@ function explainEvalExportError(code, message) {
 }
 async function evalCode(code) {
     const start = Date.now();
+    const nativeAndroid = androidScope("eval", start, { record: false });
     const chunks = [];
     const origStdout = process.stdout.write.bind(process.stdout);
     const origStderr = process.stderr.write.bind(process.stderr);
@@ -5158,6 +5131,7 @@ async function evalCode(code) {
         openTerminal: evalOpenTerminal,
         browser: trackedOpenBrowser,
         mobile: trackedOpenMobile,
+        android: nativeAndroid.open,
         desktop: desktopOpener(start, "eval", sessions, browserDetaches, artifactCollector),
         mcp: openMcp,
         testName: "eval",
@@ -5218,6 +5192,7 @@ async function evalCode(code) {
         }
         for (const s of sessions)
             s.markClosed();
+        await nativeAndroid.finish();
         if (filePath) {
             fs.unlink(filePath).catch(() => {
                 /* best-effort cleanup */
@@ -5721,6 +5696,8 @@ export function harnessMethods(state) {
         },
         // One chunk of a parked replay bundle. Case ids are arbitrary user
         // strings, so they travel in params rather than a URL path.
+        androidRecordingChunk: async (params) => androidRecordingChunk(String(params.caseId ?? params.id), params.offset, params.limit),
+        releaseAndroidRecording: async (params) => releaseAndroidRecording(String(params.id)),
         replayChunk: async (params) => {
             const caseId = requireString(params, "caseId", "caseId");
             const gz = REPLAY_BUNDLES.get(caseId);

package/dist/harness/main.js

@@ -33,12 +33,13 @@
  * transports. Two tables would each enforce the rule and together break it.
  */
 import net from "node:net";
+import { initializeStickyConsumer, STICKY_CAPABILITY } from "./sticky-consumer";
 import { METHODS } from "../daemon";
 import { codeOf } from "./methods";
 import { PROTOCOL_VERSION, decodeFrame, describeThrow, encodeFrame, fail, ok, } from "./protocol";
 /** Capabilities this build announces. Empty is fine — the slot is what
  *  matters, so a later release has something to negotiate against. */
-const CAPABILITIES = [];
+const CAPABILITIES = [STICKY_CAPABILITY];
 /** Methods this build can serve. Everything else is answered with an
  *  error naming the method, which is far easier to diagnose than a
  *  request that hangs. */
@@ -46,6 +47,10 @@ export function handlers(sdkVersion, onShutdown, methods = METHODS) {
     return {
         // Everything the environment actually does.
         ...methods,
+        stickyInitialize: async (params) => {
+            await initializeStickyConsumer(params);
+            return { initialized: true };
+        },
         // Transport-level methods, which the method table has no business
         // knowing about: they concern this connection, not this environment.
         // Declared after the spread so the table can never shadow them — a

package/dist/harness/sticky-consumer.d.ts

@@ -0,0 +1,28 @@
+export declare const STICKY_CAPABILITY = "sticky-disks-v1";
+export declare const STICKY_COMPATIBILITY = "docker29-ctr21-buildkit032-overlayfs-256g-v2";
+export declare const STICKY_RUNTIME = "/run/spectest-sticky";
+export interface StickyConsumerConfig {
+    path: string;
+    capacityBytes: number;
+    headroomBytes: number;
+    cacheTargetBytes: number;
+    buildkitTargetBytes: number;
+    compatibility: string;
+}
+declare function exec(program: string, args: string[], timeout?: number): Promise<string>;
+export declare function validateStickyConfig(config: StickyConsumerConfig): void;
+export declare function initializeStickyConsumer(config: StickyConsumerConfig): Promise<void>;
+/** Filesystem pressure takes precedence over cache age/BuildKit record sizes.
+ * Only called after runtime containers/volumes have been removed on the
+ * isolated publication clone. Never removes files behind the daemons' backs.
+ */
+export declare function collectStickyCache(config: StickyConsumerConfig, run?: typeof exec, usage?: () => Promise<{
+    freeBytes: number;
+    totalBytes: number;
+}>): Promise<void>;
+/** Only on an isolated maintenance clone; never on the live ready environment. */
+export declare function prepareStickyConsumer(artifact?: boolean): Promise<{
+    prepared: true;
+    freeBytes: number;
+}>;
+export {};