@rehearsal-db/core 0.1.0-beta.14 → 0.1.0-beta.16

package/dist/src/project/setup.mjs

@@ -0,0 +1,414 @@
+/**
+ * Purpose: Plan and apply conservative first-run Rehearsal scaffolding without
+ * contacting hosted services or overwriting project-owned files.
+ */
+import { randomUUID } from "node:crypto";
+import { createConnection, createServer } from "node:net";
+import { access, mkdir, open, readFile, rename, rm, writeFile, } from "node:fs/promises";
+import { basename, dirname, join, relative, resolve } from "node:path";
+import { findRehearsalConfigPath, inspectDetectedProject, loadRehearsalConfig, renderDetectedConfig, renderDetectedPostgresqlConfig, } from "./configuration.mjs";
+import { resolveRuntimeTarget } from "../targets/target.mjs";
+export { assertSupportedRehearsalNodeRuntime, inspectRehearsalNodeRuntime, } from "../shared/node_runtime.mjs";
+import { assertSupportedRehearsalNodeRuntime } from "../shared/node_runtime.mjs";
+const CONFIG_PATH = "rehearsal.config.mjs";
+const LOCAL_SUPABASE_CONFIG_PATH = "infrastructure/rehearsal/supabase/config.toml";
+const GITIGNORE_PATH = ".gitignore";
+const PORT_OFFSETS = Object.freeze({
+    shadow: 0,
+    api: 1,
+    database: 2,
+    studio: 3,
+    smtp: 4,
+    pooler: 9,
+});
+const hasErrorCode = (error, code) => typeof error === "object" &&
+    error !== null &&
+    "code" in error &&
+    error.code === code;
+const pathExists = (path) => access(path)
+    .then(() => true)
+    .catch((error) => {
+    if (hasErrorCode(error, "ENOENT"))
+        return false;
+    throw error;
+});
+const readOptionalFile = async (path) => {
+    try {
+        return await readFile(path, "utf8");
+    }
+    catch (error) {
+        if (hasErrorCode(error, "ENOENT"))
+            return null;
+        throw error;
+    }
+};
+const canConnectToPort = (port) => new Promise((resolveAvailability) => {
+    const socket = createConnection({ host: "127.0.0.1", port });
+    const finish = (result) => {
+        socket.destroy();
+        resolveAvailability(result);
+    };
+    socket.setTimeout(500);
+    socket.once("connect", () => finish(true));
+    socket.once("error", () => finish(false));
+    socket.once("timeout", () => finish(false));
+});
+const canBindToPort = (port) => new Promise((resolveAvailability) => {
+    const server = createServer();
+    server.unref();
+    server.once("error", () => resolveAvailability(false));
+    server.listen({ host: "127.0.0.1", port, exclusive: true }, () => {
+        server.close(() => resolveAvailability(true));
+    });
+});
+export const isRehearsalPortAvailable = async (port) => {
+    if (await canConnectToPort(port))
+        return false;
+    return canBindToPort(port);
+};
+export const findAvailableRehearsalPorts = async ({ isAvailable = isRehearsalPortAvailable, } = {}) => {
+    for (let base = 58_320; base <= 65_520; base += 20) {
+        const entries = Object.entries(PORT_OFFSETS).map(([name, offset]) => [
+            name,
+            base + offset,
+        ]);
+        const availability = await Promise.all(entries.map(([, port]) => isAvailable(port)));
+        if (availability.every(Boolean))
+            return Object.fromEntries(entries);
+    }
+    throw new Error("Rehearsal could not find an available local port block between 58320 and 65529.");
+};
+const databaseMajorVersionFrom = (source) => {
+    const match = /^\s*major_version\s*=\s*(\d+)\s*(?:#.*)?$/imu.exec(source ?? "");
+    return match ? Number(match[1]) : 17;
+};
+export const renderSafeLocalSupabaseConfig = ({ projectId, applicationUrl, ports, databaseMajorVersion = 17, }) => `# Generated by Rehearsal for a disposable, local-only runtime.
+# Review project-specific Auth or Storage additions before enabling them here.
+project_id = ${JSON.stringify(projectId)}
+
+[api]
+enabled = true
+port = ${ports.api}
+schemas = ["public"]
+extra_search_path = ["public", "extensions"]
+
+[db]
+port = ${ports.database}
+shadow_port = ${ports.shadow}
+major_version = ${databaseMajorVersion}
+
+[db.pooler]
+enabled = false
+port = ${ports.pooler}
+
+[db.migrations]
+enabled = true
+schema_paths = []
+
+[db.seed]
+enabled = false
+sql_paths = []
+
+[studio]
+enabled = true
+port = ${ports.studio}
+api_url = "http://127.0.0.1"
+
+[local_smtp]
+enabled = false
+port = ${ports.smtp}
+
+[auth]
+enabled = true
+site_url = ${JSON.stringify(applicationUrl)}
+enable_signup = false
+
+[storage]
+enabled = true
+
+[realtime]
+enabled = false
+
+[edge_runtime]
+enabled = false
+
+[analytics]
+enabled = false
+`;
+export const appendRehearsalGitignoreEntries = (source) => {
+    const original = source ?? "";
+    const lines = new Set(original
+        .split(/\r?\n/u)
+        .map((line) => line.trim())
+        .filter(Boolean));
+    const entries = [".rehearsal/", ".env.rehearsal-service.local"];
+    const missing = entries.filter((entry) => !lines.has(entry) &&
+        !lines.has(`/${entry}`) &&
+        !lines.has(entry.replace(/\/$/u, "")));
+    if (missing.length === 0)
+        return original;
+    const prefix = original && !original.endsWith("\n") ? `${original}\n` : original;
+    const separator = prefix && !prefix.endsWith("\n\n") ? "\n" : "";
+    return `${prefix}${separator}# Rehearsal local artifacts\n${missing.join("\n")}\n`;
+};
+const findExistingConfigPath = async ({ projectRoot, configPath, }) => {
+    try {
+        return await findRehearsalConfigPath({
+            projectRoot,
+            ...(configPath === undefined ? {} : { configPath }),
+        });
+    }
+    catch (error) {
+        if ((error instanceof Error ? error.message : String(error)).startsWith("No Rehearsal configuration")) {
+            return null;
+        }
+        throw error;
+    }
+};
+const deriveSupabasePorts = (runtimePorts) => {
+    if (runtimePorts.api === undefined || runtimePorts.studio === undefined) {
+        throw new Error("The Supabase runtime requires API and Studio ports.");
+    }
+    return {
+        shadow: runtimePorts.database - 2,
+        api: runtimePorts.api,
+        database: runtimePorts.database,
+        studio: runtimePorts.studio,
+        smtp: runtimePorts.database + 2,
+        pooler: runtimePorts.database + 7,
+    };
+};
+const applyGitignoreChange = async (file) => {
+    if (file.action === "unchanged")
+        return;
+    if (file.action === "create") {
+        if (file.content === null) {
+            throw new Error(`Rehearsal setup content is missing for ${file.path}.`);
+        }
+        await writeFile(file.absolutePath, file.content, {
+            flag: "wx",
+            mode: file.mode,
+        });
+        return;
+    }
+    const lockPath = `${file.absolutePath}.rehearsal.lock`;
+    let lock;
+    let temporaryPath;
+    try {
+        lock = await open(lockPath, "wx", 0o600);
+        const current = await readOptionalFile(file.absolutePath);
+        if (current !== file.originalContent) {
+            throw new Error(".gitignore changed after the setup preview; rerun rehearsal setup before writing.");
+        }
+        temporaryPath = join(dirname(file.absolutePath), `.${basename(file.absolutePath)}.rehearsal-${process.pid}-${randomUUID()}.tmp`);
+        if (file.content === null) {
+            throw new Error(`Rehearsal setup content is missing for ${file.path}.`);
+        }
+        await writeFile(temporaryPath, file.content, {
+            flag: "wx",
+            mode: file.mode,
+        });
+        await rename(temporaryPath, file.absolutePath);
+        temporaryPath = null;
+    }
+    catch (error) {
+        if (hasErrorCode(error, "EEXIST") && !lock) {
+            throw new Error("Another Rehearsal process is updating .gitignore; rerun setup after it finishes.");
+        }
+        throw error;
+    }
+    finally {
+        if (temporaryPath)
+            await rm(temporaryPath, { force: true });
+        if (lock) {
+            await lock.close();
+            await rm(lockPath, { force: true });
+        }
+    }
+};
+const assertCreateTargetAvailable = async (file) => {
+    if (file.action === "create" && (await pathExists(file.absolutePath))) {
+        throw new Error(`Rehearsal setup will not overwrite the existing file at ${file.path}.`);
+    }
+};
+export const planRehearsalSetup = async ({ projectRoot = process.cwd(), configPath, isPortAvailable, target, } = {}) => {
+    const root = resolve(projectRoot);
+    const detected = await inspectDetectedProject({ projectRoot: root });
+    const existingConfigPath = await findExistingConfigPath({
+        projectRoot: root,
+        ...(configPath === undefined ? {} : { configPath }),
+    });
+    const existing = existingConfigPath
+        ? await loadRehearsalConfig({
+            projectRoot: root,
+            ...(configPath === undefined ? {} : { configPath }),
+        })
+        : null;
+    const requestedTarget = resolveRuntimeTarget(target ?? existing?.config.runtime.target ?? "supabase").id;
+    const runtimeTarget = existing?.config.runtime.target ?? requestedTarget;
+    if (existing && target && runtimeTarget !== requestedTarget) {
+        throw new Error(`The existing Rehearsal configuration targets ${runtimeTarget}; setup will not replace it with ${requestedTarget}.`);
+    }
+    const ports = existing
+        ? runtimeTarget === "supabase"
+            ? deriveSupabasePorts(existing.config.runtime.ports)
+            : { database: existing.config.runtime.ports.database }
+        : await findAvailableRehearsalPorts({
+            ...(isPortAvailable ? { isAvailable: isPortAvailable } : {}),
+        });
+    const applicationUrl = existing?.config.runtime.applicationUrl ?? "http://localhost:5175";
+    const projectId = existing?.config.runtime.projectId ?? `${detected.projectName}-rehearsal`;
+    const sourceSupabaseConfig = runtimeTarget === "supabase"
+        ? await readOptionalFile(join(root, "supabase/config.toml"))
+        : null;
+    const originalGitignore = await readOptionalFile(join(root, GITIGNORE_PATH));
+    const nextGitignore = appendRehearsalGitignoreEntries(originalGitignore);
+    const rehearsalConfigPath = existing?.paths.rehearsalConfig;
+    const localSupabasePath = rehearsalConfigPath
+        ? relative(root, rehearsalConfigPath)
+        : LOCAL_SUPABASE_CONFIG_PATH;
+    const localSupabaseExists = rehearsalConfigPath
+        ? await pathExists(rehearsalConfigPath)
+        : false;
+    const supabasePorts = runtimeTarget === "supabase" ? deriveSupabasePorts(ports) : null;
+    const localRuntimeFiles = runtimeTarget === "supabase"
+        ? [
+            {
+                path: localSupabasePath,
+                absolutePath: rehearsalConfigPath ?? join(root, LOCAL_SUPABASE_CONFIG_PATH),
+                action: localSupabaseExists ? "unchanged" : "create",
+                mode: 0o600,
+                content: localSupabaseExists
+                    ? null
+                    : renderSafeLocalSupabaseConfig({
+                        projectId,
+                        applicationUrl,
+                        ports: supabasePorts,
+                        databaseMajorVersion: databaseMajorVersionFrom(sourceSupabaseConfig),
+                    }),
+            },
+        ]
+        : [];
+    const files = [
+        {
+            path: existingConfigPath
+                ? relative(root, existingConfigPath)
+                : CONFIG_PATH,
+            absolutePath: existingConfigPath ?? join(root, CONFIG_PATH),
+            action: existingConfigPath ? "unchanged" : "create",
+            mode: 0o600,
+            content: existingConfigPath
+                ? null
+                : runtimeTarget === "supabase"
+                    ? renderDetectedConfig(detected, {
+                        applicationUrl,
+                        ports: supabasePorts,
+                    })
+                    : renderDetectedPostgresqlConfig(detected, {
+                        applicationUrl,
+                        databasePort: ports.database,
+                    }),
+        },
+        ...localRuntimeFiles,
+        {
+            path: GITIGNORE_PATH,
+            absolutePath: join(root, GITIGNORE_PATH),
+            action: nextGitignore === (originalGitignore ?? "")
+                ? "unchanged"
+                : originalGitignore === null
+                    ? "create"
+                    : "update",
+            mode: 0o644,
+            originalContent: originalGitignore,
+            content: nextGitignore,
+        },
+    ];
+    return {
+        projectRoot: root,
+        configurationPath: existingConfigPath
+            ? relative(root, existingConfigPath)
+            : CONFIG_PATH,
+        project: detected.projectName,
+        projectId,
+        target: runtimeTarget,
+        applicationUrl,
+        detected,
+        ports: runtimeTarget === "supabase" ? ports : { database: ports.database },
+        requiresAvailablePorts: files.some((file) => file.action === "create" &&
+            [CONFIG_PATH, localSupabasePath].includes(file.path)),
+        isPortAvailable: isPortAvailable ?? isRehearsalPortAvailable,
+        files,
+        safety: [
+            "hosted access remains disabled",
+            runtimeTarget === "supabase"
+                ? "the Supabase runtime binds to dedicated local ports"
+                : "PostgreSQL binds only to a dedicated loopback port",
+            ...(runtimeTarget === "supabase"
+                ? [
+                    "external identity providers, realtime, edge functions, and analytics start disabled",
+                ]
+                : [
+                    "the runtime uses an already-installed official PostgreSQL image and never pulls implicitly",
+                ]),
+            "configuration files are never overwritten and .gitignore updates are concurrency-checked",
+        ],
+    };
+};
+export const applyRehearsalSetup = async (plan) => {
+    assertSupportedRehearsalNodeRuntime();
+    const unavailablePorts = plan.requiresAvailablePorts
+        ? (await Promise.all(Object.values(plan.ports).map(async (port) => ({
+            port,
+            available: await plan.isPortAvailable(port),
+        })))).filter(({ available }) => !available)
+        : [];
+    if (unavailablePorts.length) {
+        throw new Error(`Rehearsal setup ports became occupied after the preview (${unavailablePorts.map(({ port }) => port).join(", ")}); rerun setup to choose another local port block.`);
+    }
+    for (const file of plan.files)
+        await assertCreateTargetAvailable(file);
+    const gitignore = plan.files.find((file) => file.path === GITIGNORE_PATH);
+    if (gitignore)
+        await applyGitignoreChange(gitignore);
+    for (const file of plan.files.filter((entry) => entry.action !== "unchanged" && entry.path !== GITIGNORE_PATH)) {
+        await mkdir(dirname(file.absolutePath), { recursive: true, mode: 0o700 });
+        if (file.content === null) {
+            throw new Error(`Rehearsal setup content is missing for ${file.path}.`);
+        }
+        await writeFile(file.absolutePath, file.content, {
+            flag: file.action === "create" ? "wx" : "w",
+            mode: file.mode,
+        });
+    }
+    return {
+        projectRoot: plan.projectRoot,
+        files: plan.files.map((file) => ({
+            path: relative(plan.projectRoot, file.absolutePath),
+            action: file.action,
+        })),
+    };
+};
+export const summarizeRehearsalSetup = (plan, { mode }) => ({
+    mode,
+    configurationPath: plan.configurationPath,
+    configurationAction: plan.files.find((file) => file.path === plan.configurationPath)?.action ??
+        "unchanged",
+    rootConfigGenerationSkipped: plan.configurationPath !== CONFIG_PATH,
+    project: plan.project,
+    projectId: plan.projectId,
+    target: plan.target,
+    applicationUrl: plan.applicationUrl,
+    detected: plan.detected,
+    ports: plan.target === "supabase"
+        ? {
+            api: plan.ports.api,
+            database: plan.ports.database,
+            studio: plan.ports.studio,
+        }
+        : { database: plan.ports.database },
+    files: plan.files.map((file) => ({ path: file.path, action: file.action })),
+    safety: plan.safety,
+    nextAction: mode === "written"
+        ? `Review ${plan.configurationPath}, including its commands and sanitization policy path, then run rehearsal doctor.`
+        : "Review this plan, then rerun rehearsal setup --write to create it.",
+});

package/dist/src/project/support_report.d.mts

@@ -0,0 +1,88 @@
+/**
+ * Build a copy-ready, data-free support report. The report intentionally omits
+ * project names, paths, command output, environment-variable names, row data,
+ * migration contents, and baseline identifiers.
+ */
+import type { RehearsalConfigPathOptions } from "./configuration.mjs";
+interface VersionCommandResult {
+    readonly error?: NodeJS.ErrnoException;
+    readonly status: number | null;
+    readonly stdout: string;
+    readonly stderr: string;
+}
+type VersionCommandRunner = (command: string, args: readonly string[]) => VersionCommandResult;
+interface DoctorCheck {
+    readonly id: string;
+    readonly label: string;
+    readonly status: string;
+    readonly remediation?: string;
+}
+interface DoctorReport {
+    readonly state: string;
+    readonly checks: readonly DoctorCheck[];
+    readonly ambientHostedVariables?: Readonly<{
+        presentButQuarantined: readonly string[];
+    }>;
+}
+interface SupportSystem {
+    readonly platform: string;
+    readonly release: string;
+    readonly architecture: string;
+    readonly node: string;
+}
+interface SupportDependencies {
+    readonly runDoctor?: (options: Record<string, unknown>) => Promise<DoctorReport>;
+    readonly runCommand?: VersionCommandRunner;
+    readonly system?: SupportSystem;
+}
+export declare const REHEARSAL_SUPPORT_URL = "https://github.com/Ddupasquier/rehearsal-db/issues/new?template=bug.yml";
+export declare const collectRehearsalSupportReport: (options?: RehearsalConfigPathOptions, { runDoctor, runCommand, system, }?: SupportDependencies) => Promise<{
+    rehearsalVersion: string;
+    system: SupportSystem;
+    tools: {
+        npm: {
+            status: string;
+            version?: never;
+        } | {
+            status: string;
+            version: unknown;
+        };
+        supabase: {
+            status: string;
+            version?: never;
+        } | {
+            status: string;
+            version: unknown;
+        };
+        dockerClient: {
+            status: string;
+            version?: never;
+        } | {
+            status: string;
+            version: unknown;
+        };
+        dockerServer: {
+            status: string;
+            version?: never;
+        } | {
+            status: string;
+            version: unknown;
+        };
+    };
+    readiness: {
+        state: string;
+        checks: {
+            id: string;
+            label: string;
+            status: string;
+            remediation?: string;
+        }[];
+        quarantinedHostedVariableCount: number;
+    };
+    privacy: {
+        omits: string[];
+        reviewBeforeSharing: boolean;
+    };
+    supportUrl: string;
+}>;
+export {};

package/dist/src/project/support_report.mjs

@@ -0,0 +1,83 @@
+/**
+ * Build a copy-ready, data-free support report. The report intentionally omits
+ * project names, paths, command output, environment-variable names, row data,
+ * migration contents, and baseline identifiers.
+ */
+import { spawnSync } from "node:child_process";
+import { arch, platform, release } from "node:os";
+import { REHEARSAL_VERSION, redactDiagnosticValue, } from "../shared/diagnostics.mjs";
+import { runRehearsalDoctor } from "../runtime/plan.mjs";
+export const REHEARSAL_SUPPORT_URL = "https://github.com/Ddupasquier/rehearsal-db/issues/new?template=bug.yml";
+const safeEnvironment = () => Object.fromEntries(["HOME", "LANG", "LC_ALL", "PATH", "SHELL", "TMPDIR"].flatMap((key) => process.env[key] === undefined ? [] : [[key, process.env[key]]]));
+const runVersionCommand = (command, args) => spawnSync(command, args, {
+    encoding: "utf8",
+    env: safeEnvironment(),
+    stdio: ["ignore", "pipe", "pipe"],
+    timeout: 5_000,
+});
+const inspectTool = ({ command, args, runCommand, }) => {
+    const result = runCommand(command, args);
+    if (result.error?.code === "ENOENT")
+        return { status: "not_installed" };
+    if (result.status !== 0)
+        return { status: "unavailable" };
+    const version = String(result.stdout || result.stderr)
+        .trim()
+        .split(/\r?\n/u)[0]
+        .slice(0, 200);
+    return {
+        status: "available",
+        version: redactDiagnosticValue(version || "version not reported"),
+    };
+};
+export const collectRehearsalSupportReport = async (options = {}, { runDoctor = runRehearsalDoctor, runCommand = runVersionCommand, system = {
+    platform: platform(),
+    release: release(),
+    architecture: arch(),
+    node: process.versions.node,
+}, } = {}) => {
+    const doctor = await runDoctor(options);
+    return {
+        rehearsalVersion: REHEARSAL_VERSION,
+        system,
+        tools: {
+            npm: inspectTool({ command: "npm", args: ["--version"], runCommand }),
+            supabase: inspectTool({
+                command: "supabase",
+                args: ["--version"],
+                runCommand,
+            }),
+            dockerClient: inspectTool({
+                command: "docker",
+                args: ["--version"],
+                runCommand,
+            }),
+            dockerServer: inspectTool({
+                command: "docker",
+                args: ["info", "--format", "{{.ServerVersion}}"],
+                runCommand,
+            }),
+        },
+        readiness: {
+            state: doctor.state,
+            checks: doctor.checks.map(({ id, label, status, remediation }) => ({
+                id,
+                label,
+                status,
+                ...(status === "fail" && remediation ? { remediation } : {}),
+            })),
+            quarantinedHostedVariableCount: doctor.ambientHostedVariables?.presentButQuarantined.length ?? 0,
+        },
+        privacy: {
+            omits: [
+                "row values",
+                "credentials",
+                "project paths",
+                "migration SQL",
+                "baseline identifiers",
+            ],
+            reviewBeforeSharing: true,
+        },
+        supportUrl: REHEARSAL_SUPPORT_URL,
+    };
+};

package/dist/src/runtime/cleanup.d.mts

@@ -0,0 +1,85 @@
+/**
+ * Purpose: Preview and apply narrowly scoped Rehearsal cleanup without global
+ * Docker pruning or deletion of unowned database resources.
+ */
+import { loadRehearsalConfig } from "../project/configuration.mjs";
+type LoadedConfiguration = Awaited<ReturnType<typeof loadRehearsalConfig>>;
+interface DiskUsage {
+    readonly totalBytes: number;
+    readonly usedBytes: number;
+    readonly availableBytes: number;
+    readonly usedPercent: number;
+}
+interface ContainerDiskUsage extends DiskUsage {
+    readonly backend: "colima";
+}
+interface DockerUsage {
+    readonly available: boolean;
+    readonly resources: unknown[];
+    readonly disk: ContainerDiskUsage | null;
+}
+interface DockerImage {
+    readonly Id: string;
+    readonly Created: string;
+    readonly Size: number;
+    readonly RepoTags?: readonly string[];
+}
+interface ImageCandidate {
+    readonly id: string;
+    readonly createdAt: string;
+    readonly bytes: number;
+    readonly tags: string[];
+}
+interface CleanupInspection {
+    readonly inspectDockerUsage: (projectRoot: string) => DockerUsage;
+    readonly runtimeDetected: (loaded: LoadedConfiguration) => Promise<boolean>;
+}
+export interface RehearsalCleanupPlan {
+    readonly project: string;
+    readonly projectId: string;
+    readonly target: "supabase" | "postgresql";
+    readonly retainBaselineGenerations: number;
+    readonly baselines: Readonly<{
+        available: boolean;
+        retained: string[];
+        removed: string[];
+    }>;
+    readonly runtime: Readonly<{
+        included: boolean;
+        detected: boolean;
+    }>;
+    readonly images: Readonly<{
+        requested: boolean;
+        inspected: boolean;
+        candidates: ImageCandidate[];
+    }>;
+    readonly docker: DockerUsage;
+    readonly digest: string;
+}
+export declare const parsePosixDiskUsage: (output: string) => DiskUsage | null;
+export declare const selectOlderUnusedSupabaseImages: ({ images, usedImageIds, }: {
+    images: readonly DockerImage[];
+    usedImageIds: ReadonlySet<string>;
+}) => ImageCandidate[];
+export declare const planRehearsalCleanup: ({ projectRoot, configPath, includeRuntime, includeImages, inspection, }?: {
+    projectRoot?: string;
+    configPath?: string;
+    includeRuntime?: boolean;
+    includeImages?: boolean;
+    inspection?: CleanupInspection;
+}) => Promise<RehearsalCleanupPlan>;
+export declare const applyRehearsalCleanup: ({ plan, confirmation, projectRoot, configPath, removeRuntime, inspection, }?: {
+    plan?: RehearsalCleanupPlan;
+    confirmation?: string;
+    projectRoot?: string;
+    configPath?: string;
+    removeRuntime?: () => Promise<unknown>;
+    inspection?: CleanupInspection;
+}) => Promise<{
+    project: string;
+    projectId: string;
+    baselines: import("../baseline/artifact.mjs").BaselinePrunePlan;
+    runtimeRemoved: boolean;
+    imagesRemoved: string[];
+}>;
+export {};