@b00dea/cockpit 0.1.0 → 0.1.1

package/dist/environment/operator-application.js

@@ -64,6 +64,48 @@ export async function runResetOperatorApplication(input, admission, adapters) {
     await opened.decide('decline');
     return { status: EXIT_CODES.cancelled, diagnostics: [], result: null };
 }
+function pruneUnconfirmed(message) {
+    return { status: 2, result: null, diagnostics: [{ severity: 'error', target: 'stacks',
+                code: 'STACKS_PRUNE_UNCONFIRMED',
+                message, fix: 'a person runs npx --no cockpit stacks prune --config <your cockpit.toml> --interactive in a terminal outside CI, reads the preview and types its digest' }] };
+}
+/**
+ * `stacks prune`: a preview by default. Removing an orphan whose checkout is gone is housekeeping
+ * anyone can undo by bringing the stack up again, so `--apply` passes for an agent; a prune that
+ * deletes volumes deletes data, and passes only where `[autonomy] reset` lets this run reset. That
+ * policy is this cockpit's, so an agent's `--apply` covers only this cockpit's stacks: another
+ * cockpit may require a person for the same removal. `--interactive` is a person's approval of the
+ * exact preview by its digest, and covers every stack on the machine.
+ */
+export async function runStacksPruneOperatorApplication(input, admission, adapters) {
+    if (admission.interactive && (admission.json || admission.ci && admission.ci.length > 0)) {
+        return pruneUnconfirmed('interactive prune requires a human terminal outside CI and JSON modes');
+    }
+    if (admission.interactive && !admission.terminal)
+        return pruneUnconfirmed('interactive prune requires terminal input');
+    const opened = await adapters.begin({ configPath: input.configPath, scope: !admission.interactive && admission.apply ? 'this-cockpit' : 'machine' });
+    if (!('apply' in opened))
+        return opened;
+    if (!admission.interactive && !admission.apply || opened.empty)
+        return opened.preview;
+    if (admission.interactive) {
+        if (await adapters.confirm(opened.preview) !== opened.digest)
+            return pruneUnconfirmed('the typed digest did not match the prune preview; nothing was removed');
+        return opened.apply();
+    }
+    if (opened.deletesData) {
+        const policy = await adapters.policy(input.configPath);
+        if (!isPolicy(policy))
+            return policy;
+        const weakened = policy.recorded ? policyWeakening(policy.recorded, policy.current).filter(row => row.field === 'autonomy.reset') : [];
+        if (weakened.length)
+            return weakeningRefusal(weakened, 'nothing was pruned');
+        const refused = autonomyRefusal('reset', policy.current.autonomy.reset, admission);
+        if (refused)
+            return refused;
+    }
+    return opened.apply();
+}
 function staleRemovalRefusal(message) {
     return refusal('GENERATED_STALE_APPROVAL_REQUIRED', message, 'generated-environment');
 }

package/dist/environment/presence.d.ts

@@ -0,0 +1,4 @@
+import { type Stats } from 'node:fs';
+/** The path's own status, not following a final symbolic link, or undefined when nothing is there. */
+export declare function lstatIfPresent(path: string): Promise<Stats | undefined>;
+export declare function lstatIfPresentSync(path: string): Stats | undefined;

package/dist/environment/presence.js

@@ -0,0 +1,26 @@
+// What is on disk at a path, where "nothing there" (a missing entry or a missing parent) is an answer
+// and any other failure, such as a permission error, is raised for its caller to name.
+import { lstatSync } from 'node:fs';
+import { lstat } from 'node:fs/promises';
+import { isMissing } from './contract.js';
+/** The path's own status, not following a final symbolic link, or undefined when nothing is there. */
+export async function lstatIfPresent(path) {
+    try {
+        return await lstat(path);
+    }
+    catch (error) {
+        if (isMissing(error))
+            return undefined;
+        throw error;
+    }
+}
+export function lstatIfPresentSync(path) {
+    try {
+        return lstatSync(path);
+    }
+    catch (error) {
+        if (isMissing(error))
+            return undefined;
+        throw error;
+    }
+}

package/dist/environment/read-composition.d.ts

@@ -1,9 +1,11 @@
 import type { ExecuteProbeOutcome } from '../environment-exec/execute.js';
 import { type RuntimeEvidenceObservation } from './application/health.js';
 import { type LogsCommandAdapters } from './application/logs.js';
+import { type ServiceCommandAdapters } from './application/services.js';
+import type { ForegroundProcessInput, ForegroundProcessOutcome } from '../environment-exec/execute.js';
 import { type ExecutionStep } from './contract.js';
 import { type RuntimeMeasurementProbeAuthority } from './runtime.js';
-export interface ReadCommandCompositionInput {
+interface ReadCommandCompositionInput {
     readonly configPath: string;
     readonly env: Readonly<Record<string, string | undefined>>;
     readonly sessionId: string;
@@ -12,8 +14,9 @@ export interface ReadCommandCompositionInput {
     readonly signal?: AbortSignal;
     readonly runtimeMeasurementProbeAuthority?: RuntimeMeasurementProbeAuthority;
 }
-export interface ReadCommandAdapterComposition {
+interface ReadCommandAdapterComposition {
     readonly logs: LogsCommandAdapters;
+    readonly services: ServiceCommandAdapters;
     readonly environment: Readonly<{
         observe: (input: {
             readonly configPath: string;
@@ -23,5 +26,7 @@ export interface ReadCommandAdapterComposition {
 type Executor = (step: ExecutionStep, options?: {
     readonly signal?: AbortSignal;
 }) => Promise<ExecuteProbeOutcome>;
-export declare function createReadCommandAdapters(rawInput: ReadCommandCompositionInput, execute: Executor): ReadCommandAdapterComposition;
+export declare function createReadCommandAdapters(rawInput: ReadCommandCompositionInput, execute: Executor, executeForeground?: (input: ForegroundProcessInput, options: {
+    readonly signal?: AbortSignal;
+}) => Promise<ForegroundProcessOutcome>): ReadCommandAdapterComposition;
 export {};

package/dist/environment/read-composition.js

@@ -6,9 +6,12 @@ import {} from './application/health.js';
 import { decodeLifecycleRecord } from './application/lifecycle.js';
 import {} from './application/lifecycle-context.js';
 import {} from './application/logs.js';
+import { publishLifecycleRecord } from './application/lifecycle-state.js';
+import {} from './application/services.js';
 import { createLifecycleCommandAdapters } from './lifecycle-composition.js';
 import { deriveEntrypoints, observeRetainedPortFamily, projectRetainedPortFamilyResult } from './ports.js';
 import { DOCKER_CLIENT_ENVIRONMENT, ENVIRONMENT_CODES, RefusalError } from './contract.js';
+import { loadServedSiblings, servedSiblingVariables } from './sibling-checkouts.js';
 import { DeclarationRefusalError, runtimeNotDeclared, serviceNotDeclared } from './declaration.js';
 import { admitRuntimeServiceHealth, revalidateRuntimeService, } from './runtime.js';
 import { resolveDockerExecutable } from './executable.js';
@@ -133,11 +136,13 @@ function exactCompletedTopology(context) {
     return topologyServices.length === completedServices.length
         && topologyServices.every((service, index) => service === completedServices[index]);
 }
-export function createReadCommandAdapters(rawInput, execute) {
+export function createReadCommandAdapters(rawInput, execute, executeForeground) {
     const input = captureInput(rawInput);
     // `refuse` receives the lifecycle's own refusal, such as an unmeasured runtime, so a caller can
     // report it instead of a generic unavailable context.
-    const prepare = async (signal, refuse) => {
+    // A service verb may act on a stack whose start stopped part-way: rebuilding the service that
+    // failed is how its fixed code gets running. Every other reader needs a started service.
+    const prepare = async (signal, refuse, partial = false) => {
         if (!input || typeof execute !== 'function')
             throw new RefusalError('read command composition is unavailable');
         const lifecycle = createLifecycleCommandAdapters({
@@ -191,7 +196,11 @@ export function createReadCommandAdapters(rawInput, execute) {
         if (lifecycleRead.kind !== 'complete')
             throw new RefusalError('lifecycle state is unavailable');
         const lifecycleValue = decodeLifecycleRecord(lifecycleRead.value, context)?.value;
-        if (!lifecycleValue || lifecycleValue.completedServices.length === 0)
+        if (!lifecycleValue)
+            throw new RefusalError('lifecycle state is malformed');
+        if (lifecycleValue.teardownComplete)
+            throw new RefusalError('down removed the stack');
+        if (lifecycleValue.completedServices.length === 0 && !partial)
             throw new RefusalError('lifecycle state is malformed');
         if (lifecycleValue.holderId !== context.holderId)
             throw new RefusalError('lifecycle holder authority changed');
@@ -207,17 +216,19 @@ export function createReadCommandAdapters(rawInput, execute) {
         if (!confirmedComposeFiles || JSON.stringify(confirmedComposeFiles) !== JSON.stringify(composeFiles)) {
             throw new RefusalError('compose artifacts changed during runtime observation');
         }
+        // The stack interpolates the checkout `use` recorded, so reading it must name the same one.
+        const served = await loadServedSiblings(checkoutRoot, configuration.config);
+        if (served.kind === 'refusal')
+            throw new RefusalError(served.diagnostic.message);
         const ownComposeAuthority = {
             ownComposeFiles: true,
             cockpitId: context.cockpitId,
             stackId: context.stackId,
             portLeaseProjection: ports,
-            siblingDirectories: Object.fromEntries(configuration.config.sibling.map((sibling) => [
-                sibling.var,
-                resolve(checkoutRoot, configuration.config.cockpit.siblings_root, sibling.dir),
-            ])),
+            siblingDirectories: servedSiblingVariables(configuration.config, served.siblings),
         };
         return {
+            run: context,
             ownComposeAuthority,
             configuration,
             namespace: context.namespace,
@@ -343,10 +354,44 @@ export function createReadCommandAdapters(rawInput, execute) {
         };
         return { snapshot: ownedSnapshot, evidence: ownedEvidence };
     };
+    const observeServices = async (request) => {
+        if (!input || resolve(request.configPath) !== input.configPath)
+            throw new RefusalError('service configuration path does not match');
+        const context = await prepare(input.signal, (diagnostics) => { throw new DeclarationRefusalError(diagnostics[0]); }, true);
+        return {
+            topology: context.topology,
+            completedServices: context.lifecycle.completedServices,
+            // The recorded container is what `up`, `preflight` and `logs` revalidate, so a rebuild that
+            // replaced it updates the record rather than leaving the stack looking broken.
+            recordContainer: async (service, containerId) => {
+                const value = { ...context.lifecycle, completedServices: context.lifecycle.completedServices
+                        .map((row) => row.service === service ? { service, containerId } : row) };
+                const published = await publishLifecycleRecord(context.run, context.lifecycleRecord, value);
+                if ('status' in published)
+                    return published.diagnostics;
+                if (published.kind === 'complete')
+                    return [];
+                return [{ severity: 'error',
+                        code: published.kind === 'missing' ? ENVIRONMENT_CODES.STATE_RECORD_MALFORMED : published.code,
+                        target: context.namespace.paths.lifecycle(context.stackId).path,
+                        message: `the rebuilt container of service ${service} runs, and the stack record could not be updated to it${published.kind === 'missing' ? '' : `: ${published.message}`}`,
+                        fix: 'run npx --no cockpit up --config <your cockpit.toml> to record the running containers again' }];
+            },
+        };
+    };
+    const services = {
+        observe: observeServices,
+        execute: (step) => execute(step, input?.signal ? { signal: input.signal } : undefined),
+        executeForeground: async (planned) => {
+            if (!executeForeground)
+                throw new RefusalError('foreground execution is not bound');
+            return executeForeground(planned, input?.signal ? { signal: input.signal } : {});
+        },
+    };
     const logs = {
         observe: observeLogs,
         execute: (step, options) => execute(step, options),
         ...(input?.signal ? { signal: input.signal } : {}),
     };
-    return { logs, environment: { observe: observeEnvironment } };
+    return { logs, services, environment: { observe: observeEnvironment } };
 }

package/dist/environment/readiness-composition.d.ts

@@ -2,7 +2,7 @@ import { loadCockpitConfig } from '../config/load.js';
 import type { ExecuteProbeOutcome } from '../environment-exec/execute.js';
 import { type EnvironmentDiagnostic, type ExecutionStep } from './contract.js';
 import type { ReadinessReport } from '../readiness.js';
-export interface ProjectReadinessInput {
+interface ProjectReadinessInput {
     /** The cockpit root, where cockpit.toml is or will be written. */
     readonly root: string;
     /** Present once cockpit.toml exists; its siblings are the repositories asked. */
@@ -35,4 +35,23 @@ export declare function inspectInitReadiness(input: Omit<ProjectReadinessInput,
     state: ReadinessReport['state'];
     findings: readonly EnvironmentDiagnostic[];
 }>>;
+/**
+ * What the container runtime on this machine offers, measured by the same collector preflight
+ * compares the machine floor with, so init can propose a floor where no Compose limit records one.
+ */
+export declare function measureInitMachine(input: Readonly<{
+    root: string;
+}>, binding: Readonly<{
+    env: ProjectReadinessInput['env'];
+    timeoutMs: number;
+    execute: (step: ExecutionStep) => Promise<ExecuteProbeOutcome>;
+}>): Promise<Readonly<{
+    kind: 'complete';
+    memoryMb: number;
+    cpus: number;
+    observedAt: string;
+}> | Readonly<{
+    kind: 'unavailable';
+    reason: string;
+}>>;
 export {};

package/dist/environment/readiness-composition.js

@@ -9,8 +9,9 @@ import { loadCockpitConfig } from '../config/load.js';
 import { authenticatedExecutionOutcome } from '../environment-exec/execute.js';
 import { inspectTeamReadiness } from '../team-metadata.js';
 import { guardSearchPathRelativeEntry } from '../guards/protected-locations.js';
-import { ENVIRONMENT_CODES, snapshotExecutionStep, RefusalError, isMissing } from './contract.js';
-import { resolveGitExecutable } from './executable.js';
+import { DOCKER_CLIENT_ENVIRONMENT, ENVIRONMENT_CODES, snapshotExecutionStep, RefusalError, isMissing } from './contract.js';
+import { resolveDiskCapacityExecutable, resolveDockerExecutable, resolveGitExecutable } from './executable.js';
+import { measureMachineFloor } from './runtime.js';
 import { gitRepositoryRefusal, inspectTrackedSecretFiles } from './git-observation.js';
 import { declaresNothingToRun } from './declaration.js';
 import { inspectSiblingInstructions } from './sibling-instructions.js';
@@ -128,3 +129,23 @@ export async function inspectInitReadiness(input, binding) {
         : classification === undefined ? 'undetermined' : classification === 'no-runnable-product' ? 'surfaces-only' : 'runtime';
     return { state, findings };
 }
+/**
+ * What the container runtime on this machine offers, measured by the same collector preflight
+ * compares the machine floor with, so init can propose a floor where no Compose limit records one.
+ */
+export async function measureInitMachine(input, binding) {
+    const [docker, disk] = await Promise.all([resolveDockerExecutable(binding.env), resolveDiskCapacityExecutable()]);
+    if (docker.state !== 'available')
+        return { kind: 'unavailable', reason: docker.reason };
+    if (disk.state !== 'available')
+        return { kind: 'unavailable', reason: disk.reason };
+    const env = Object.fromEntries(Object.entries(binding.env)
+        .filter((entry) => DOCKER_CLIENT_ENVIRONMENT.has(entry[0]) && typeof entry[1] === 'string'));
+    const measured = await measureMachineFloor({ runtimeExecutable: docker.value, diskExecutable: disk.value, cwd: input.root,
+        env, timeoutMs: binding.timeoutMs }, binding.execute);
+    if (measured.kind !== 'complete')
+        return { kind: 'unavailable', reason: measured.kind === 'refusal'
+                ? measured.diagnostics.map(row => row.message).join('; ') : 'docker info did not report the runtime\'s memory and CPUs' };
+    return { kind: 'complete', memoryMb: Math.floor(measured.evidence.memoryBytes / 1024 ** 2),
+        cpus: measured.evidence.cpuMillis / 1_000, observedAt: measured.evidence.observedAt };
+}

package/dist/environment/reclaim.d.ts

@@ -4,7 +4,7 @@ import { type CockpitId, type EnvironmentDiagnostic, type ExecutionFence, type E
 import type { ResolvedExecutable } from './executable.js';
 import { type StateAddress, type StateRecord } from './state.js';
 type Executor = (step: ExecutionStep) => Promise<ExecuteProbeOutcome>;
-export interface DockerSelection {
+interface DockerSelection {
     readonly context: string;
     readonly endpoint: string;
 }
@@ -15,7 +15,7 @@ export interface ReclaimDiscovery extends ReclaimDiscoverySnapshot {
     readonly selection: DockerSelection;
 }
 /** What a person or the planner itself approved: the digest, and the discovery it was read from. */
-export interface ReclaimConsent {
+interface ReclaimConsent {
     readonly digest: string;
     readonly observedAt: string;
 }
@@ -24,7 +24,7 @@ export interface ReclaimConsent {
  * to the next. `drain` is the attempt the action ran under, which the next plan matches against
  * the record its outcome published; null until the action runs.
  */
-export interface ReclaimContinuation {
+interface ReclaimContinuation {
     readonly purpose: 'down' | 'reset';
     readonly digest: string;
     readonly completedTargetId: string;
@@ -37,7 +37,7 @@ export interface ReclaimContinuation {
     readonly drain: ReclaimDrainStep | null;
 }
 /** The one removal a plan permits, executed only by `executeReclaimAction` under a reserved attempt. */
-export interface PlannedReclaimAction {
+interface PlannedReclaimAction {
     readonly stackId: StackId;
     readonly configSha256: string;
     /** Null when the interrupted target is already absent and only its removal is recorded. */
@@ -48,7 +48,7 @@ export interface PlannedReclaimAction {
     /** For an absent target: the actionable target ids a later discovery still shows. */
     readonly remainingTargets?: (discovery: ReclaimDiscovery) => Promise<readonly string[] | undefined>;
 }
-export type ReclaimTargetIdentity = ResetVolumeTargetIdentity | TeardownRuntimeTargetIdentity | PathTargetIdentity;
+type ReclaimTargetIdentity = ResetVolumeTargetIdentity | TeardownRuntimeTargetIdentity | PathTargetIdentity;
 interface ResetVolumeTargetIdentity {
     readonly medium: 'runtime';
     readonly scope: 'reset-volume';
@@ -85,10 +85,10 @@ interface PathTargetIdentity {
     readonly birthtimeNs: string;
     readonly ancestors: readonly FilesystemAncestorIdentity[];
 }
-export type ReclaimResourceKind = 'container' | 'network' | 'volume' | 'image' | 'build-cache' | 'cache';
-export type OwnershipEvidence = 'current' | 'stale-config' | 'foreign' | 'unknown' | 'malformed' | 'partial' | 'unlabelled';
-export type Reversibility = 'runtime' | 'regenerable-cache' | 'data-bearing';
-export type ReclaimAction = 'teardown' | 'reclaim' | 'reset-required' | 'report-only';
+type ReclaimResourceKind = 'container' | 'network' | 'volume' | 'image' | 'build-cache' | 'cache';
+type OwnershipEvidence = 'current' | 'stale-config' | 'foreign' | 'unknown' | 'malformed' | 'partial' | 'unlabelled';
+type Reversibility = 'runtime' | 'regenerable-cache' | 'data-bearing';
+type ReclaimAction = 'teardown' | 'reclaim' | 'reset-required' | 'report-only';
 export interface ReclaimResource {
     readonly id: string;
     readonly name: string;
@@ -104,7 +104,7 @@ export interface ReclaimDiscoverySnapshot {
     readonly producer: 'runtime-resource-discovery';
     readonly resources: readonly ReclaimResource[];
 }
-export interface ClassifiedReclaimResource extends ReclaimResource {
+interface ClassifiedReclaimResource extends ReclaimResource {
     readonly ownership: OwnershipEvidence;
     readonly reversibility: Reversibility;
     readonly action: ReclaimAction;
@@ -115,7 +115,7 @@ export interface ClassifiedReclaimResource extends ReclaimResource {
         readonly risk: string;
     };
 }
-export interface ClassifyReclaimInput {
+interface ClassifyReclaimInput {
     readonly stackId: StackId;
     readonly cockpitId: CockpitId;
     readonly configSha256: string;
@@ -123,7 +123,7 @@ export interface ClassifyReclaimInput {
     readonly declaredCacheIds: readonly string[];
     readonly discovery: ReclaimDiscoverySnapshot;
 }
-export type ReclaimResult = {
+type ReclaimResult = {
     readonly kind: 'complete';
     readonly noop: boolean;
     readonly resources: readonly ClassifiedReclaimResource[];
@@ -132,7 +132,7 @@ export type ReclaimResult = {
     readonly diagnostics: readonly EnvironmentDiagnostic[];
 };
 export declare function classifyReclaim(rawInput: ClassifyReclaimInput): ReclaimResult;
-export interface KeptTeardownResource {
+interface KeptTeardownResource {
     readonly kind: ReclaimResourceKind;
     readonly id: string;
     readonly name: string;
@@ -149,7 +149,7 @@ export declare function keptTeardownResources(input: ClassifyReclaimInput): read
  * resources to look at instead of a generic unobservable precondition.
  */
 export declare function inspectionOverflow(step: ExecutionStep, outcome: ExecuteProbeOutcome): string | undefined;
-export interface ReclaimDiscoveryInput {
+interface ReclaimDiscoveryInput {
     readonly executable: ResolvedExecutable;
     readonly cwd: string;
     readonly env: Readonly<Record<string, string>>;
@@ -172,6 +172,43 @@ type DiscoveryRefusal = {
  * complete round covers that race without admitting partial evidence.
  */
 export declare function discoverReclaim(input: ReclaimDiscoveryInput, execute: Executor): Promise<ReclaimDiscovery | DiscoveryRefusal | undefined>;
+/** One container, network or volume that carries every cockpit ownership label, attributed by them alone. */
+export interface MachineStackResource {
+    readonly kind: 'container' | 'network' | 'volume';
+    readonly id: string;
+    readonly name: string;
+    readonly cockpitId: CockpitId;
+    readonly stackId: StackId;
+    /** Containers only: Docker reports it running, restarting or paused. */
+    readonly running: boolean;
+    readonly composeProject: string | null;
+    /** Containers only: the directory Compose ran the project from, as Compose itself labelled it. */
+    readonly workingDir: string | null;
+}
+export interface MachineStackDiscovery {
+    readonly selection: DockerSelection;
+    readonly observedAt: string;
+    readonly resources: readonly MachineStackResource[];
+    /** Resources carrying the stack label whose other ownership labels are missing or malformed: never attributed. */
+    readonly unattributed: number;
+}
+type MachineStackDiscoveryInput = Omit<ReclaimDiscoveryInput, 'stackId' | 'cockpitId'>;
+/**
+ * Lists every container, network and volume on the selected daemon that carries cockpit's stack
+ * label, whichever cockpit or checkout started it, for the machine-wide stack inventory. Ownership
+ * comes from the labels alone; nothing is attributed by its name. The selection is read before and
+ * after the listings, as `discoverReclaim` does, so the listings describe one daemon.
+ */
+export declare function discoverMachineStacks(input: MachineStackDiscoveryInput, execute: Executor): Promise<MachineStackDiscovery | undefined>;
+/**
+ * The Docker removals prune runs for one kind of one orphaned stack's resources, as the machine
+ * discovery attributed them: one client per chunk rather than one per resource. Undefined when the
+ * resources are not all of one kind and one stack, or a step cannot be built.
+ */
+export declare function machineStackRemovalSteps(input: Pick<MachineStackDiscoveryInput, 'executable' | 'cwd' | 'env' | 'timeoutMs'>, selection: DockerSelection, resources: readonly MachineStackResource[]): readonly Readonly<{
+    step: ExecutionStep;
+    resources: readonly MachineStackResource[];
+}>[] | undefined;
 export interface ResetTargetInput {
     readonly kind: 'container' | 'volume' | 'host-path';
     readonly identity: string;
@@ -183,7 +220,7 @@ interface HostPathDeclaration {
     readonly path: string;
     readonly declaration: string;
 }
-export interface DependencyCacheDeclaration {
+interface DependencyCacheDeclaration {
     readonly cacheId: string;
     readonly root: string;
     readonly path: string;
@@ -269,7 +306,7 @@ export type TeardownPlanResult = {
 export declare function planReset(input: PlanResetInput): Promise<ResetPreview | ResetPlanResult>;
 type ByteClasses = Readonly<Record<'orphans' | 'images' | 'buildCache' | 'staleNetworks', number | null>>;
 export declare function planTeardown(input: PlanTeardownInput): Promise<TeardownPlanResult>;
-export interface ReclaimTargetCommitment extends DrainTargetCommitment {
+interface ReclaimTargetCommitment extends DrainTargetCommitment {
     readonly targetId: string;
 }
 export interface ReclaimTargetEnvelope {
@@ -280,7 +317,7 @@ export interface ReclaimTargetEnvelope {
     readonly commitments: readonly ReclaimTargetCommitment[];
 }
 /** A removal the attempt admitted, with the attempt it ran under and what it observed. */
-export interface ExecutedReclaimAction {
+interface ExecutedReclaimAction {
     readonly action: PlannedReclaimAction;
     readonly reservation: DrainReservation;
     readonly attempt: NonNullable<DrainReservation['attempt']>;
@@ -289,7 +326,7 @@ export interface ExecutedReclaimAction {
     readonly receipt: ExecutionReceipt | null;
     readonly fence: ExecutionFence | null;
 }
-export type ReclaimActionExecution = {
+type ReclaimActionExecution = {
     readonly kind: 'executed';
     readonly executed: ExecutedReclaimAction;
 }
@@ -314,7 +351,7 @@ export declare function executeReclaimAction(input: {
     readonly attempt: ReservedDrainAttempt;
     readonly execute: Executor;
 }): Promise<ReclaimActionExecution>;
-export type ReconcileReclaimActionResult = {
+type ReconcileReclaimActionResult = {
     readonly kind: 'complete';
     readonly outcome: DrainOutcome;
     readonly continuation: ReclaimContinuation | null;