@loucompanion/forge-bridge 0.1.3-dev.fbe15023cdfe → 0.1.4-dev.bfa11ebe98c6

package/dist/runtime/prepared-runtime-readiness.js

@@ -0,0 +1,285 @@
+import { randomUUID } from "node:crypto";
+import { GitClient } from "../shared/git/git.js";
+import { loadHostRuntimeContract } from "./host-runtime-contract.js";
+import { configuredLaunchPortNames, hostRuntimeContractFingerprint, hostRuntimeParallelEligible } from "./host-runtime-promotion.js";
+import { preparedRuntimeIdentity } from "./prepared-runtime-identity.js";
+/** Foreground barrier: prepare a wave, verify its exact runtimes, then release agents. */
+export class PreparedRuntimeReadiness {
+    runtime;
+    store;
+    releasePreparation;
+    admissionExpired;
+    preparations = new Map();
+    draining = new Set();
+    constructor(runtime, store, releasePreparation, admissionExpired) {
+        this.runtime = runtime;
+        this.store = store;
+        this.releasePreparation = releasePreparation;
+        this.admissionExpired = admissionExpired;
+    }
+    async acquire(dispatch, signal) {
+        const id = dispatch.sandbox.dispatchAttemptId;
+        if (this.preparations.has(id))
+            throw new Error("host_runtime_preparation_conflict: duplicate preparation.");
+        const controller = new AbortController();
+        const abort = () => this.cancel(id, dispatch.lease.fencingToken);
+        const entry = { dispatch, controller, phase: "preparing", expiresAt: dispatch.lease.expiresAt,
+            removeAbort: () => signal?.removeEventListener("abort", abort) };
+        this.preparations.set(id, entry);
+        this.scheduleDeadline(entry);
+        signal?.addEventListener("abort", abort, { once: true });
+        if (signal?.aborted)
+            abort();
+        try {
+            // Preparation consumes normal capacity, but no project-runtime claim.
+            return await this.runtime.acquire({ ...dispatch,
+                runtimeIntent: { ...dispatch.runtimeIntent, executionClass: "analysis_only", applicationRuntimeRequired: false },
+            }, controller.signal);
+        }
+        catch (error) {
+            const failure = controller.signal.aborted ? controller.signal.reason : error;
+            this.cancel(id, dispatch.lease.fencingToken);
+            throw failure;
+        }
+    }
+    has(id) { return this.preparations.has(id); }
+    hasPending() { return this.preparations.size > 0; }
+    pendingSnapshots() {
+        return [...this.preparations.values()].map(entry => ({
+            repoId: entry.dispatch.repo.id,
+            dispatchAttemptId: entry.dispatch.sandbox.dispatchAttemptId,
+            fencingToken: entry.dispatch.lease.fencingToken,
+            ...(entry.probe
+                ? {
+                    probeDispatchAttemptId: entry.probe.sandbox.dispatchAttemptId,
+                    probeFencingToken: entry.probe.lease.fencingToken,
+                }
+                : {}),
+        }));
+    }
+    async verify(dispatch, worktree, checkpoint) {
+        const id = dispatch.sandbox.dispatchAttemptId;
+        const entry = this.preparations.get(id);
+        if (!entry || entry.dispatch.lease.fencingToken !== dispatch.lease.fencingToken) {
+            throw new Error("host_runtime_preparation_missing: preparation ownership changed.");
+        }
+        // Release preparation headroom before waiting for peers; otherwise a one-slot
+        // host would deadlock while the rest of the wave tries to prepare.
+        await this.releasePreparation(id, dispatch.lease.fencingToken);
+        entry.controller.signal.throwIfAborted();
+        const completion = new Promise((resolve, reject) => {
+            entry.resolve = resolve;
+            entry.reject = reject;
+        });
+        entry.check = () => this.check(entry, worktree, checkpoint);
+        entry.phase = "queued";
+        void this.drain(dispatch.repo.id);
+        return await completion;
+    }
+    async renew(id, fence, expiresAt) {
+        const entry = this.preparations.get(id);
+        if (!entry || entry.dispatch.lease.fencingToken !== fence || Date.parse(expiresAt) <= Date.parse(entry.expiresAt))
+            return;
+        entry.expiresAt = expiresAt;
+        this.scheduleDeadline(entry);
+        if (entry.probe)
+            await this.runtime.updateLease(entry.probe.sandbox.dispatchAttemptId, entry.probe.lease.fencingToken, expiresAt);
+    }
+    cancel(id, fence, reason = new Error("host_runtime_preparation_cancelled: prepared readiness was cancelled.")) {
+        const entry = this.preparations.get(id);
+        if (!entry || entry.dispatch.lease.fencingToken !== fence)
+            return;
+        if (entry.deadline)
+            clearTimeout(entry.deadline);
+        entry.controller.abort(reason);
+        // Do not return to session teardown while a supervised probe still owns the worktree.
+        if (entry.phase === "checking")
+            return;
+        entry.reject?.(entry.controller.signal.reason);
+        entry.removeAbort();
+        this.preparations.delete(id);
+        void this.drain(entry.dispatch.repo.id);
+    }
+    async drain(repoId) {
+        if (this.draining.has(repoId))
+            return;
+        const entries = () => [...this.preparations.values()].filter(entry => entry.dispatch.repo.id === repoId);
+        if (entries().some(entry => entry.phase === "preparing"))
+            return;
+        this.draining.add(repoId);
+        const completed = [];
+        try {
+            for (const entry of entries()) {
+                if (entry.phase !== "queued")
+                    continue;
+                entry.phase = "checking";
+                try {
+                    completed.push({ entry, identity: await entry.check() });
+                }
+                catch (error) {
+                    completed.push({ entry, error });
+                }
+            }
+            // No provider from this wave can start while a sibling proof is running.
+            for (const result of completed) {
+                const { entry } = result;
+                this.preparations.delete(entry.dispatch.sandbox.dispatchAttemptId);
+                if (entry.deadline)
+                    clearTimeout(entry.deadline);
+                entry.removeAbort();
+                if (entry.controller.signal.aborted)
+                    entry.reject?.(entry.controller.signal.reason);
+                else if (result.error)
+                    entry.reject?.(result.error);
+                else
+                    entry.resolve?.(result.identity);
+            }
+        }
+        finally {
+            this.draining.delete(repoId);
+            if (entries().some(entry => entry.phase === "queued"))
+                void this.drain(repoId);
+        }
+    }
+    scheduleDeadline(entry) {
+        if (entry.deadline)
+            clearTimeout(entry.deadline);
+        const delay = Date.parse(entry.expiresAt) - Date.now();
+        entry.deadline = setTimeout(() => this.cancel(entry.dispatch.sandbox.dispatchAttemptId, entry.dispatch.lease.fencingToken, this.admissionExpired()), Number.isFinite(delay) ? Math.max(0, Math.min(delay, 2_147_483_647)) : 0);
+        entry.deadline.unref();
+    }
+    async check(entry, worktree, checkpoint) {
+        const { dispatch, controller } = entry;
+        if (!dispatch.runtimeIntent.applicationRuntimeRequired)
+            return undefined;
+        const contract = await loadHostRuntimeContract(worktree);
+        if (!hostRuntimeParallelEligible(contract))
+            return undefined;
+        const preparedDiagnostics = { entries: new Map() };
+        const identity = await preparedRuntimeIdentity(worktree, controller.signal, preparedDiagnostics);
+        if (hostRuntimeContractFingerprint(contract) !== identity.runtimeContractFingerprint) {
+            throw new Error("host_runtime_prepared_source_changed: runtime contract changed while capturing its source identity.");
+        }
+        if (await this.store.load(dispatch.repo.id, identity))
+            return identity;
+        await checkpoint?.({ code: "host_runtime_prepared_probe_started", expiresAt: entry.expiresAt,
+            message: `Verifying prepared runtime ${identity.inputCommitSha.slice(0, 12)} before agent admission; project-default readiness is not a substitute.` });
+        const probeId = randomUUID();
+        const probe = { ...dispatch,
+            cycleRun: { ...dispatch.cycleRun, phase: "prepared_readiness" },
+            lease: { ...dispatch.lease, id: probeId, fencingToken: randomUUID(), expiresAt: entry.expiresAt },
+            sandbox: { ...dispatch.sandbox, dispatchAttemptId: probeId, executionLeaseId: probeId,
+                inputCommitSha: identity.inputCommitSha },
+        };
+        entry.probe = probe;
+        const stopPreparedHeadMonitor = new AbortController();
+        const preparedHeadMonitor = monitorPreparedHead(worktree, identity.inputCommitSha, controller, stopPreparedHeadMonitor.signal);
+        let cleanupConfirmed;
+        let verifiedRuntimeContractFingerprint;
+        let verifiedPorts;
+        try {
+            controller.signal.throwIfAborted();
+            await this.runtime.acquire(probe, controller.signal);
+            const prepared = await this.runtime.start(probe, worktree, controller.signal);
+            if (hostRuntimeContractFingerprint(prepared.runtimeContract) !== identity.runtimeContractFingerprint) {
+                throw new Error("host_runtime_prepared_source_changed: probe loaded a different runtime contract; application was not started.");
+            }
+            const started = await this.runtime.startConfiguredProject(probeId, probe.lease.fencingToken, controller.signal, progress => checkpoint?.({ code: "host_runtime_prepared_probe_progress", expiresAt: entry.expiresAt,
+                message: progress.message }));
+            verifiedRuntimeContractFingerprint = hostRuntimeContractFingerprint(started.runtimeContract);
+            verifiedPorts = started.lease.resources.ports.map(port => port.name).sort();
+        }
+        finally {
+            stopPreparedHeadMonitor.abort();
+            await preparedHeadMonitor;
+            // A failed teardown must not publish reusable evidence.
+            cleanupConfirmed = Boolean(await this.runtime.release(probeId, probe.lease.fencingToken));
+            entry.probe = undefined;
+        }
+        if (!cleanupConfirmed) {
+            throw new Error("host_runtime_prepared_probe_cleanup_unconfirmed: matching probe teardown was not confirmed.");
+        }
+        // Probe-owned processes may create transient, untracked files while they
+        // are alive. Verify the prepared source only after matching teardown is
+        // confirmed: persistent source edits still fail closed, while files that
+        // belong to the probe lifecycle cannot create a false source-change loop.
+        const currentDiagnostics = { entries: new Map() };
+        const currentIdentity = await preparedRuntimeIdentity(worktree, controller.signal, currentDiagnostics);
+        const changed = [];
+        if (verifiedRuntimeContractFingerprint !== identity.runtimeContractFingerprint
+            || currentIdentity.runtimeContractFingerprint !== identity.runtimeContractFingerprint) {
+            changed.push("runtime contract");
+        }
+        if (currentIdentity.inputCommitSha !== identity.inputCommitSha)
+            changed.push("HEAD");
+        if (currentIdentity.sourceFingerprint !== identity.sourceFingerprint) {
+            const paths = changedIdentityPaths(preparedDiagnostics.entries, currentDiagnostics.entries);
+            changed.push(paths.length > 0
+                ? `source fingerprint (${paths.join(", ")})`
+                : "source fingerprint");
+        }
+        if (changed.length > 0) {
+            throw new Error(`host_runtime_prepared_source_changed: ${changed.join(", ")} changed during isolation verification.`);
+        }
+        if (JSON.stringify(verifiedPorts) !== JSON.stringify(configuredLaunchPortNames(contract))) {
+            throw new Error("host_runtime_prepared_probe_incomplete: assigned-port verification did not confirm every configured launch port.");
+        }
+        controller.signal.throwIfAborted();
+        await this.store.observe(dispatch.repo.id, contract, probeId, configuredLaunchPortNames(contract), identity.inputCommitSha, identity.sourceFingerprint);
+        await checkpoint?.({ code: "host_runtime_prepared_probe_completed", expiresAt: entry.expiresAt,
+            message: `Prepared runtime ${identity.inputCommitSha.slice(0, 12)} passed isolation verification; its source-bound proof is retained independently.` });
+        return identity;
+    }
+}
+const preparedHeadPollIntervalMs = 1_000;
+async function monitorPreparedHead(worktree, expectedCommitSha, preparationController, stopSignal) {
+    const git = new GitClient();
+    while (!stopSignal.aborted && !preparationController.signal.aborted) {
+        try {
+            const currentCommitSha = (await git.run(worktree, ["rev-parse", "--verify", "HEAD^{commit}"]))
+                .trim()
+                .toLowerCase();
+            if (currentCommitSha !== expectedCommitSha.toLowerCase()) {
+                throw new Error("host_runtime_prepared_source_changed: HEAD changed during isolation verification; the obsolete probe was cancelled.");
+            }
+        }
+        catch (error) {
+            if (!stopSignal.aborted && !preparationController.signal.aborted) {
+                const failure = error instanceof Error && error.message.startsWith("host_runtime_prepared_source_changed:")
+                    ? error
+                    : new Error(`host_runtime_prepared_source_changed: HEAD could not be revalidated during isolation verification: ${errorMessage(error)}`);
+                preparationController.abort(failure);
+            }
+            return;
+        }
+        await waitForPreparedHeadPoll(stopSignal);
+    }
+}
+async function waitForPreparedHeadPoll(signal) {
+    if (signal.aborted)
+        return;
+    await new Promise(resolve => {
+        const complete = () => {
+            clearTimeout(timer);
+            signal.removeEventListener("abort", complete);
+            resolve();
+        };
+        const timer = setTimeout(complete, preparedHeadPollIntervalMs);
+        timer.unref();
+        signal.addEventListener("abort", complete, { once: true });
+        if (signal.aborted)
+            complete();
+    });
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function changedIdentityPaths(before, after) {
+    const paths = new Set([...before.keys(), ...after.keys()]);
+    const changed = [...paths]
+        .filter(path => before.get(path) !== after.get(path))
+        .sort((left, right) => left.localeCompare(right));
+    if (changed.length <= 8)
+        return changed;
+    return [...changed.slice(0, 8), `+${changed.length - 8} more`];
+}

package/dist/runtime/runtime-isolation-lease.js

@@ -57,7 +57,10 @@ export function transitionRuntimeIsolationLease(lease, nextState, occurredAt = n
     return transitioned;
 }
 export function renewRuntimeIsolationLease(lease, fencingToken, expiresAt) {
-    if (lease.fencingToken !== fencingToken || lease.state === "released" || !validTimestamp(expiresAt))
+    if (lease.fencingToken !== fencingToken
+        || lease.state === "releasing"
+        || lease.state === "released"
+        || !validTimestamp(expiresAt))
         return null;
     const renewed = { ...lease, expiresAt };
     return validRuntimeIsolationLease(renewed) ? renewed : null;

package/dist/runtime/workspace-resource-estimator.d.ts

@@ -0,0 +1,17 @@
+export declare const minimumWorkspaceEstimateBytes: number;
+export declare const architectMinimumWorkspaceEstimateBytes: number;
+export interface RepositoryWorkspaceFootprint {
+    readonly sourceBytes: number;
+    readonly hasNode: boolean;
+    readonly hasDotNet: boolean;
+    readonly hasBrowser: boolean;
+    readonly serviceCount: number;
+}
+export interface WorkspaceEstimateHints {
+    readonly role?: string | null;
+    readonly serviceCount?: number;
+    readonly browser?: boolean;
+}
+export declare function estimateWorkspaceBytesFromRepo(repoPath: string, hints?: WorkspaceEstimateHints): Promise<number>;
+export declare function calculateWorkspaceBytes(footprint: RepositoryWorkspaceFootprint, role?: string | null): number;
+export declare function measureRepositoryWorkspace(repoPath: string): Promise<RepositoryWorkspaceFootprint>;

package/dist/runtime/workspace-resource-estimator.js

@@ -0,0 +1,174 @@
+import { spawn } from "node:child_process";
+import fs from "node:fs/promises";
+import path from "node:path";
+import readline from "node:readline";
+const GiB = 1024 ** 3;
+const alignmentBytes = 512 * 1024 ** 2;
+export const minimumWorkspaceEstimateBytes = 2 * GiB;
+export const architectMinimumWorkspaceEstimateBytes = GiB;
+const maximumBytes = 100 * GiB;
+const footprintCacheLifetimeMs = 5 * 60_000;
+const excludedDirectories = new Set([
+    ".git",
+    ".artifacts",
+    ".forge-worktrees",
+    ".local",
+    ".next",
+    ".nuget",
+    ".pnpm-store",
+    ".tmp",
+    ".turbo",
+    "artifacts",
+    "bin",
+    "build",
+    "coverage",
+    "dist",
+    "node_modules",
+    "obj",
+    "testresults",
+]);
+const footprintCache = new Map();
+export async function estimateWorkspaceBytesFromRepo(repoPath, hints = {}) {
+    const cacheKey = path.resolve(repoPath);
+    const cached = footprintCache.get(cacheKey);
+    const footprint = cached && Date.now() - cached.measuredAt < footprintCacheLifetimeMs
+        ? cached.footprint
+        : await measureRepositoryWorkspace(cacheKey);
+    if (!cached || cached.footprint !== footprint) {
+        footprintCache.set(cacheKey, { measuredAt: Date.now(), footprint });
+    }
+    return calculateWorkspaceBytes({
+        ...footprint,
+        hasBrowser: footprint.hasBrowser || hints.browser === true,
+        serviceCount: Math.max(footprint.serviceCount, Math.max(0, hints.serviceCount ?? 0)),
+    }, hints.role);
+}
+export function calculateWorkspaceBytes(footprint, role) {
+    const normalizedRole = role?.trim().toLowerCase() ?? "";
+    if (normalizedRole === "architect") {
+        // Architect owns a checkout and planning artifacts, not dependencies,
+        // build outputs, browser state, services, or application runtime output.
+        const estimate = architectMinimumWorkspaceEstimateBytes
+            + Math.max(0, footprint.sourceBytes) * 2;
+        return Math.min(maximumBytes, Math.max(architectMinimumWorkspaceEstimateBytes, alignUp(estimate, alignmentBytes)));
+    }
+    let estimate = 2 * GiB + Math.max(0, footprint.sourceBytes) * 3;
+    if (footprint.hasNode)
+        estimate += 3 * GiB;
+    if (footprint.hasDotNet)
+        estimate += 2 * GiB;
+    if (footprint.hasBrowser)
+        estimate += 1536 * 1024 ** 2;
+    estimate += Math.max(0, footprint.serviceCount) * GiB;
+    if (["qa", "ci_repair", "pr_fix"].includes(normalizedRole)) {
+        estimate += GiB;
+    }
+    return Math.min(maximumBytes, Math.max(minimumWorkspaceEstimateBytes, alignUp(estimate, alignmentBytes)));
+}
+export async function measureRepositoryWorkspace(repoPath) {
+    return await measureGitWorkspace(repoPath) ?? await measureFilesystemFallback(repoPath);
+}
+async function measureGitWorkspace(repoPath) {
+    let sourceBytes = 0;
+    let hasNode = false;
+    let hasDotNet = false;
+    let hasBrowser = false;
+    let serviceCount = 0;
+    const child = spawn("git", ["-c", "core.quotepath=false", "ls-files", "--cached", "--others", "--exclude-standard"], {
+        cwd: repoPath,
+        env: { ...process.env, GIT_OPTIONAL_LOCKS: "0" },
+        stdio: ["ignore", "pipe", "ignore"],
+        windowsHide: true,
+    });
+    const closed = new Promise((resolve) => {
+        child.once("close", resolve);
+        child.once("error", () => resolve(null));
+    });
+    try {
+        const lines = readline.createInterface({ input: child.stdout, crlfDelay: Infinity });
+        for await (const relativePath of lines) {
+            if (!relativePath.trim())
+                continue;
+            const file = await inspectWorkspaceFile(path.join(repoPath, relativePath));
+            if (!file)
+                continue;
+            sourceBytes += file.bytes;
+            hasNode ||= file.hasNode;
+            hasDotNet ||= file.hasDotNet;
+            hasBrowser ||= file.hasBrowser;
+            serviceCount = Math.max(serviceCount, file.serviceCount);
+        }
+        return await closed === 0 ? { sourceBytes, hasNode, hasDotNet, hasBrowser, serviceCount } : null;
+    }
+    catch {
+        child.kill();
+        await closed;
+        return null;
+    }
+}
+async function measureFilesystemFallback(repoPath) {
+    let sourceBytes = 0;
+    let hasNode = false;
+    let hasDotNet = false;
+    let hasBrowser = false;
+    let serviceCount = 0;
+    const pending = [path.resolve(repoPath)];
+    while (pending.length > 0) {
+        const current = pending.pop();
+        const entries = await fs.readdir(current, { withFileTypes: true }).catch(() => []);
+        for (const entry of entries) {
+            const entryPath = path.join(current, entry.name);
+            if (entry.isDirectory()) {
+                if (!excludedDirectories.has(entry.name.toLowerCase()))
+                    pending.push(entryPath);
+                continue;
+            }
+            if (!entry.isFile())
+                continue;
+            const file = await inspectWorkspaceFile(entryPath);
+            if (!file)
+                continue;
+            sourceBytes += file.bytes;
+            hasNode ||= file.hasNode;
+            hasDotNet ||= file.hasDotNet;
+            hasBrowser ||= file.hasBrowser;
+            serviceCount = Math.max(serviceCount, file.serviceCount);
+        }
+    }
+    return { sourceBytes, hasNode, hasDotNet, hasBrowser, serviceCount };
+}
+async function inspectWorkspaceFile(filePath) {
+    const stat = await fs.stat(filePath).catch(() => null);
+    if (!stat?.isFile())
+        return null;
+    const name = path.basename(filePath).toLowerCase();
+    const sandbox = name === "forge.sandbox.yml" || name === "forge.sandbox.yaml";
+    return {
+        bytes: stat.size,
+        hasNode: ["package.json", "pnpm-lock.yaml", "package-lock.json", "yarn.lock"].includes(name),
+        hasDotNet: name.endsWith(".sln") || name.endsWith(".csproj") || name.endsWith(".fsproj"),
+        hasBrowser: name.startsWith("playwright.config"),
+        serviceCount: sandbox
+            ? countSandboxServices(await fs.readFile(filePath, "utf8").catch(() => ""))
+            : 0,
+    };
+}
+function countSandboxServices(yaml) {
+    let inServices = false;
+    let count = 0;
+    for (const rawLine of yaml.split(/\r?\n/gu)) {
+        const line = rawLine.trim();
+        if (!line || line.startsWith("#"))
+            continue;
+        if (!/^\s/u.test(rawLine)) {
+            inServices = line.toLowerCase() === "services:";
+            continue;
+        }
+        if (inServices && line.startsWith("-"))
+            count += 1;
+    }
+    return count;
+}
+function alignUp(value, alignment) {
+    return Math.ceil(value / alignment) * alignment;
+}

package/dist/sandbox/preflight.d.ts

@@ -19,23 +19,53 @@ export declare class DockerPreflight {
     private readonly cacheMs;
     private generation;
     private cached;
-    private cacheAt;
+    private fullPreflightAt;
+    private staticPreflight;
+    private inspectionInFlight;
+    private lastCapacitySample;
     private readonly options;
     private readonly docker;
     private readonly ownership;
     private diskPressureLatched;
+    private readonly memoryAvailability;
     constructor(options?: DockerPreflightOptions | string, commands?: CommandRunner, cacheMs?: number);
+    private unavailable;
+    private memoryReserveBytes;
+    private defaultAdmissionMemoryBytes;
     current(): SandboxPreflightResult | null;
     refresh(): Promise<SandboxPreflightResult>;
     release(): Promise<void>;
     run(force?: boolean): Promise<SandboxPreflightResult>;
+    /**
+     * Refreshes only the admission inputs that change while the daemon's static
+     * capability snapshot remains valid. Heartbeats use this path so periodic
+     * liveness reporting does not wake Docker/WSL to rerun feature probes.
+     */
+    refreshCapacity(): Promise<SandboxPreflightResult>;
+    /**
+     * When the cached static preflight remains usable, produces a capacity sample
+     * that began after this admission request. An older inspection is awaited,
+     * not preempted or reused. Later admission callers may share the next sample
+     * only when it began after they entered this method. Without a usable static
+     * snapshot, the existing fail-closed result is returned without probing.
+     */
+    refreshCapacityForAdmission(): Promise<SandboxPreflightResult>;
+    private startInspection;
     private inspect;
+    private inspectCapacity;
 }
+/**
+ * Uses the same reviewed reserve vector as host-runtime admission. The input
+ * is always the physical host total; Docker Desktop's VM total is tracked as
+ * a separate daemon commitment domain.
+ */
+export declare function resolveSandboxHostMemoryReserveBytes(totalMemoryBytes: number, explicitBytes?: number, environment?: NodeJS.ProcessEnv): number;
 export declare function canRunDockerMaintenance(preflight: {
     readonly healthy: boolean;
     readonly unavailableCode?: string | null;
 }): boolean;
 export declare function evaluateDiskPressure(availableBytes: number, totalBytes: number, minimumAvailableBytes: number, highWatermarkPercent: number, lowWatermarkPercent: number, pressureLatched: boolean): boolean;
+export declare function requiredAvailableBytesToClearDiskPressure(totalBytes: number, minimumAvailableBytes: number, lowWatermarkPercent: number): number;
 export declare function storagePolicyAvailable(storageQuota: boolean, environment?: NodeJS.ProcessEnv): boolean;
 export declare class DockerContextOwnershipLock {
     private lockPath;