@astrosheep/keiyaku 4.0.1 → 4.0.2

package/build/src/protocol/placement.d.ts

@@ -3,7 +3,7 @@ import { type PlacementRefusal } from "../core/verbs/placement.js";
 import type { GitDecodeChannel } from "../git/read-observation.js";
 import { type ReconcileResult } from "../git/reconcile.js";
 import { type GitRepository } from "../git/repository.js";
-import { type TargetPlacementRefusal } from "../git/target-placement.js";
+import { type TargetPlacementObservationInput, type TargetPlacementRefusal } from "../git/target-placement.js";
 import { type AcceptedAdmission } from "./attempt.js";
 import { type ProtocolResult } from "./run.js";
 export type PlacementExecutionFailure = Readonly<{
@@ -17,14 +17,25 @@ export type TargetMovedStop = Readonly<{
     expected: SnapshotId;
     observed: SnapshotId | null;
 }>;
-export type PlacementProtocolResult = (AcceptedAdmission & Readonly<{
+export type PlacementProtocolResult<ExtraRefusal = never> = (AcceptedAdmission & Readonly<{
     physical?: ReconcileResult;
-}>) | Exclude<ProtocolResult<PlacementRefusal | TargetPlacementRefusal>, AcceptedAdmission> | TargetMovedStop | PlacementExecutionFailure;
+}>) | Exclude<ProtocolResult<PlacementRefusal | TargetPlacementRefusal | ExtraRefusal>, AcceptedAdmission> | TargetMovedStop | PlacementExecutionFailure;
 type PlacementProtocolInput = Readonly<{
     contractId: ContractId;
     actor?: ActorId;
     at: string;
 }>;
+export type ProspectiveTargetPreview = Readonly<{
+    kind: "ready";
+}> | Readonly<{
+    kind: "refused";
+    refusal: TargetPlacementRefusal;
+}> | Readonly<{
+    kind: "failed";
+    diagnostic: string;
+}>;
+/** Observe prospective target followability without fencing or placing. */
+export declare function observeProspectiveTargetPlacement(repository: GitRepository, input: TargetPlacementObservationInput): Promise<ProspectiveTargetPreview>;
 /** Run the sole placement adjudicator inside the target's physical fence. */
-export declare function admitPlacement(channel: GitDecodeChannel, repository: GitRepository, target: string | undefined, input: PlacementProtocolInput): Promise<PlacementProtocolResult>;
+export declare function admitPlacement<ExtraRefusal = never>(channel: GitDecodeChannel, repository: GitRepository, target: string | undefined, input: PlacementProtocolInput, onDeliveryMissing?: () => Promise<PlacementProtocolResult<ExtraRefusal> | undefined>): Promise<PlacementProtocolResult<ExtraRefusal>>;
 export {};

package/build/src/protocol/placement.js

@@ -2,19 +2,36 @@ import { SqliteTransactionLockError } from "../coordination/sqlite-transaction-l
 import { AuthorityCorruptionError } from "../core/facts/errors.js";
 import { contractState } from "../core/facts/observation.js";
 import { decidePlacement } from "../core/verbs/placement.js";
+import { observeGitForAdmissionAt } from "../git/observe.js";
 import { reconcileEffectFailure } from "../git/reconcile.js";
 import { GitPlumbingError } from "../git/repository.js";
-import { acquireTargetPlacementFence, followTargetPlacement, prepareTargetPlacement, observeTargetHead, } from "../git/target-placement.js";
+import { acquireTargetPlacementFence, followTargetPlacement, prepareTargetPlacement, observeTargetHead, observeTargetPlacement, } from "../git/target-placement.js";
 import { admitDecidedOffer, mintAttempts } from "./attempt.js";
 import { prepareProtocolAttempt, runProtocol, } from "./run.js";
 function placementFailure(error) {
     return { kind: "placement-failed", diagnostic: error instanceof Error ? error.message : String(error) };
 }
-function expectedPlacementFailure(error) {
-    if (error instanceof GitPlumbingError || error instanceof SqliteTransactionLockError)
-        return placementFailure(error);
+function expectedOperationalDiagnostic(error) {
+    if (error instanceof GitPlumbingError || error instanceof SqliteTransactionLockError) {
+        return error instanceof Error ? error.message : String(error);
+    }
     throw error;
 }
+function expectedPlacementFailure(error) {
+    return { kind: "placement-failed", diagnostic: expectedOperationalDiagnostic(error) };
+}
+/** Observe prospective target followability without fencing or placing. */
+export async function observeProspectiveTargetPlacement(repository, input) {
+    try {
+        const observed = await observeTargetPlacement(repository, input);
+        return observed.kind === "ready"
+            ? { kind: "ready" }
+            : { kind: "refused", refusal: observed.refusal };
+    }
+    catch (error) {
+        return { kind: "failed", diagnostic: expectedOperationalDiagnostic(error) };
+    }
+}
 async function runFencedPlacement(repository, input, protocol) {
     for (let index = 0; index < protocol.attempts.length; index += 1) {
         const prepared = await prepareProtocolAttempt(protocol, protocol.attempts[index]);
@@ -25,7 +42,7 @@ async function runFencedPlacement(repository, input, protocol) {
             throw new Error("placement offer has no contract state");
         if (prepared.offer.target === undefined)
             throw new Error("targeted placement offer is missing its target movement");
-        const observed = observeTargetHead(repository, prepared.offer.target.target);
+        const observed = await observeTargetHead(repository, prepared.offer.target.target);
         if (observed !== prepared.offer.target.expectedOid) {
             return {
                 kind: "target-moved",
@@ -35,7 +52,7 @@ async function runFencedPlacement(repository, input, protocol) {
                 observed,
             };
         }
-        const physical = prepareTargetPlacement(repository, state, prepared.offer.target);
+        const physical = await prepareTargetPlacement(repository, state, prepared.offer.target);
         if (physical.kind === "refused")
             return physical;
         const result = await admitDecidedOffer({
@@ -47,7 +64,7 @@ async function runFencedPlacement(repository, input, protocol) {
             primaryContract: input.contractId,
         });
         if (result.kind === "accepted") {
-            return { ...result, physical: followTargetPlacement(repository, physical.placement) };
+            return { ...result, physical: await followTargetPlacement(repository, physical.placement) };
         }
         if (result.kind === "publication-failed")
             return result;
@@ -56,20 +73,8 @@ async function runFencedPlacement(repository, input, protocol) {
     }
     return { kind: "exhausted" };
 }
-/** Run the sole placement adjudicator inside the target's physical fence. */
-export async function admitPlacement(channel, repository, target, input) {
-    const attempts = mintAttempts({ entryCount: 1 });
-    const protocol = {
-        input,
-        channel,
-        repository,
-        contracts: [input.contractId],
-        attempts,
-        decide: decidePlacement,
-    };
-    const run = () => runProtocol(protocol);
-    if (target === undefined)
-        return await run();
+/** Hold the existing target-placement fence for one owner callback. */
+async function runUnderTargetPlacementFence(repository, target, run, onReleaseFailure) {
     let held;
     try {
         held = await acquireTargetPlacementFence(repository, target);
@@ -77,10 +82,12 @@ export async function admitPlacement(channel, repository, target, input) {
     catch (error) {
         return placementFailure(error);
     }
+    let produced;
     let result;
     let exceptional;
     try {
-        result = await runFencedPlacement(repository, input, protocol);
+        produced = await run();
+        result = produced;
     }
     catch (error) {
         if (error instanceof AuthorityCorruptionError || error instanceof TypeError)
@@ -104,11 +111,37 @@ export async function admitPlacement(channel, repository, target, input) {
     if (exceptional !== undefined)
         throw exceptional;
     if (result === undefined)
-        throw new Error("placement produced no result");
+        throw new Error("fenced target work produced no result");
     if (releaseFailure !== undefined) {
-        return result.kind === "accepted"
-            ? { ...result, physical: reconcileEffectFailure(releaseFailure, result.physical) }
+        return produced !== undefined && onReleaseFailure !== undefined
+            ? onReleaseFailure(produced, releaseFailure)
             : placementFailure(releaseFailure);
     }
     return result;
 }
+function isDeliveryMissing(result) {
+    return result.kind === "refused" && result.refusal.kind === "delivery-missing";
+}
+/** Run the sole placement adjudicator inside the target's physical fence. */
+export async function admitPlacement(channel, repository, target, input, onDeliveryMissing) {
+    const attempts = mintAttempts({ entryCount: 1 });
+    const protocol = {
+        input,
+        channel,
+        repository,
+        contracts: [input.contractId],
+        attempts,
+        decide: decidePlacement,
+        observe: (observedRepository, observedChannel, contracts) => observeGitForAdmissionAt(observedRepository, observedChannel, contracts),
+    };
+    if (target === undefined)
+        return await runProtocol(protocol);
+    return await runUnderTargetPlacementFence(repository, target, async () => {
+        const result = await runFencedPlacement(repository, input, protocol);
+        if (onDeliveryMissing === undefined || !isDeliveryMissing(result))
+            return result;
+        return await onDeliveryMissing() ?? result;
+    }, (result, error) => result.kind === "accepted"
+        ? { ...result, physical: reconcileEffectFailure(error, result.physical) }
+        : placementFailure(error));
+}

package/build/src/protocol/read/status.d.ts

@@ -1,7 +1,8 @@
+import type { ContractTargetLag, ContractWorkspaceObservation } from "../../git/workspace.js";
 import type { GitRepository } from "../../git/repository.js";
 import type { GitDecodeChannel, GitReadObservation } from "../../git/read-observation.js";
 import { type GateCurrent } from "../../core/facts/gate.js";
-import type { ContractId, DeliverData, SnapshotId } from "../../core/facts/types.js";
+import type { ContractId, ContractState, DeliverData, SnapshotId } from "../../core/facts/types.js";
 export type ContractPhase = "waiting" | "bound" | "pending-delivery" | "claimed" | "abandoned";
 export type ContractDisposition = "active" | "terminal";
 export type ContractGateCurrent = GateCurrent;
@@ -9,13 +10,18 @@ export type ContractGateReport = Readonly<{
     gate: string;
     current: ContractGateCurrent;
 }>;
+export type { ContractTargetLag, ContractWorkspaceObservation };
 export type ContractRow = Readonly<{
     id: ContractId;
+    title: string | null;
     phase: ContractPhase;
+    phaseAt: string;
     disposition: ContractDisposition;
     workspace: "worktree" | "here";
     worktreePath: string | null;
+    workspaceObservation: ContractWorkspaceObservation;
     target: string | null;
+    targetLag: ContractTargetLag;
     delivery: DeliverData | null;
     targetObservation: Readonly<{
         head: SnapshotId | null;
@@ -38,6 +44,7 @@ export type ContractObservation = Readonly<{
     kind: "present";
     row: ContractRow;
 }>;
+export declare function phaseAtFor(state: Pick<ContractState, "terminal" | "delivery" | "bound">, bindAt: string): string;
 /** Build the Contract board from one immutable git observation. */
 export declare function readContractBoard(observation: GitReadObservation): Promise<ContractBoard>;
 /** Observe one Contract and its target from one fresh ref epoch. */

package/build/src/protocol/read/status.js

@@ -1,28 +1,72 @@
-import { extendContractsForAdmissionAt, observeActiveContractWorld, observeContractsForAdmissionInObservationAt, observeDeliveryTargetAt, withContractReadObservationAt, } from "../../git/observe.js";
-import { deliveryWorktreePath } from "../../git/workspace.js";
+import { observeActiveContractWorld, observeContractsForAdmissionInObservationAt, observeDeliveryTargetAt, withContractReadObservationAt, } from "../../git/observe.js";
+import { decodeContractDocument } from "../../body/decode.js";
+import { observeTargetLag, observeWorkspace, worktreePath, } from "../../git/workspace.js";
+import { appointmentFor, readPlaceRegister, } from "../../workspace-place.js";
 import { gateReports } from "../../core/facts/gate.js";
-import { prerequisiteStatus } from "../../core/facts/observation.js";
-function phaseFor(state, eligible) {
+function titleFor(state) {
+    try {
+        return decodeContractDocument(state.terms.document.bytes).title;
+    }
+    catch (error) {
+        if (error instanceof TypeError)
+            return null;
+        throw error;
+    }
+}
+function phaseFor(state) {
     if (state.terminal?.kind === "claimed")
         return "claimed";
     if (state.terminal?.kind === "abandoned")
         return "abandoned";
     if (state.delivery !== null)
         return "pending-delivery";
-    if (state.bound !== null || eligible)
+    if (state.bound !== null)
         return "bound";
     return "waiting";
 }
-function rowFor(repository, state, targetObservation, eligible) {
+export function phaseAtFor(state, bindAt) {
+    return state.terminal?.at ?? state.delivery?.at ?? state.bound?.at ?? bindAt;
+}
+async function managedWorkspaceFacts(repository, state, register, targetObservation) {
+    const appointed = appointmentFor(register, state.id);
+    if (appointed === undefined) {
+        return {
+            appointed,
+            workspaceObservation: { kind: "unappointed" },
+            targetLag: state.coordinates.target === undefined ? { kind: "none" } : { kind: "unknown" },
+        };
+    }
+    const path = worktreePath(repository, appointed.place);
+    const [workspaceObservation, targetLag] = await Promise.all([
+        observeWorkspace(repository, { kind: "worktree", path }, path),
+        observeTargetLag(repository, path, targetObservation?.head),
+    ]);
+    return { appointed, workspaceObservation, targetLag };
+}
+async function hereWorkspaceFacts(repository, targetObservation) {
+    const [workspaceObservation, targetLag] = await Promise.all([
+        observeWorkspace(repository, { kind: "here" }, repository.effectiveCwd),
+        observeTargetLag(repository, repository.effectiveCwd, targetObservation?.head),
+    ]);
+    return { appointed: undefined, workspaceObservation, targetLag };
+}
+async function rowFor(repository, state, bindAt, targetObservation, register) {
     const workspace = state.coordinates.workspace;
     const gates = gateReports(state);
+    const { appointed, workspaceObservation, targetLag } = workspace === "worktree"
+        ? await managedWorkspaceFacts(repository, state, register, targetObservation)
+        : await hereWorkspaceFacts(repository, targetObservation);
     return {
         id: state.id,
-        phase: phaseFor(state, eligible),
+        title: titleFor(state),
+        phase: phaseFor(state),
+        phaseAt: phaseAtFor(state, bindAt),
         disposition: state.terminal === null ? "active" : "terminal",
         workspace,
-        worktreePath: workspace === "worktree" ? deliveryWorktreePath(repository, state.id) : null,
+        worktreePath: appointed === undefined ? null : worktreePath(repository, appointed.place),
+        workspaceObservation,
         target: state.coordinates.target ?? null,
+        targetLag,
         delivery: state.delivery?.data ?? null,
         targetObservation,
         gates: {
@@ -34,27 +78,30 @@ function rowFor(repository, state, targetObservation, eligible) {
 /** Build the Contract board from one immutable git observation. */
 export async function readContractBoard(observation) {
     const observed = await observeActiveContractWorld(observation);
+    const register = await readPlaceRegister(observation.repository);
     const rows = [];
     for (const value of observed.contracts.values()) {
         if (value.state === null)
             continue;
         const state = value.state;
-        rows.push(observeDeliveryTargetAt(observation, state).then((target) => rowFor(observation.repository, state, target, prerequisiteStatus(state.terms.after, observed.eligibility) === "claimed")));
+        const bindAt = value.entries[0].at;
+        rows.push(observeDeliveryTargetAt(observation, state).then((target) => rowFor(observation.repository, state, bindAt, target, register)));
     }
     return { root: observation.repository.primaryWorktree, state: observed.snapshot, rows: await Promise.all(rows) };
 }
 /** Observe one Contract and its target from one fresh ref epoch. */
 export async function readContractObservationAt(repository, channel, id) {
     return withContractReadObservationAt(repository, channel, id, async (observation) => {
-        let observed = await observeContractsForAdmissionInObservationAt(observation, [id]);
-        const state = observed.decision.get(id) ?? null;
-        if (state !== null)
-            observed = await extendContractsForAdmissionAt(channel, observed, state.terms.after);
+        const observed = await observeContractsForAdmissionInObservationAt(observation, [id]);
+        const record = observed.journals.get(id);
+        if (record === undefined)
+            throw new Error(`missing requested Contract observation: ${id}`);
+        const state = record.state;
         return state === null
             ? { kind: "missing", id }
             : {
                 kind: "present",
-                row: rowFor(observation.repository, state, await observeDeliveryTargetAt(observation, state), prerequisiteStatus(state.terms.after, observed.decision) === "claimed"),
+                row: await rowFor(observation.repository, state, record.entries[0].at, await observeDeliveryTargetAt(observation, state), await readPlaceRegister(observation.repository)),
             };
     });
 }

package/build/src/runtime/proc/line-rpc.d.ts

@@ -1,3 +1,4 @@
+import { type StdioProcessExit } from "./stdio.js";
 export type LineRpcNotification = Readonly<{
     method: string;
     params?: Readonly<Record<string, unknown>>;
@@ -5,20 +6,14 @@ export type LineRpcNotification = Readonly<{
 export type LineRpcServerRequest = LineRpcNotification & Readonly<{
     id: number | string;
 }>;
-export type LineRpcExit = Readonly<{
-    code: number | null;
-    signal: NodeJS.Signals | null;
-    stderr: string;
-}>;
+export type LineRpcExit = StdioProcessExit;
 export declare class LineRpcProcess {
-    private readonly child;
+    private readonly process;
     private readonly pending;
     private readonly notifications;
     private readonly serverRequests;
-    private readonly exited;
     private nextId;
     private stdout;
-    private stderr;
     private closed;
     constructor(input: Readonly<{
         argv: readonly [string, ...string[]];

package/build/src/runtime/proc/line-rpc.js

@@ -1,12 +1,4 @@
-import { spawn } from "node:child_process";
-import { terminateProcessTree } from "./run.js";
-const DEFAULT_DRAIN_TIMEOUT_MS = 1_000;
-function bounded(promise, milliseconds) {
-    return new Promise((resolve, reject) => {
-        const timer = setTimeout(() => resolve(undefined), milliseconds);
-        void promise.then((value) => { clearTimeout(timer); resolve(value); }, (error) => { clearTimeout(timer); reject(error); });
-    });
-}
+import { spawnStdioProcess } from "./stdio.js";
 function object(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value)
         ? value
@@ -16,37 +8,25 @@ function text(value) {
     return typeof value === "string" && value.trim().length > 0 ? value : undefined;
 }
 export class LineRpcProcess {
-    child;
+    process;
     pending = new Map();
     notifications = new Set();
     serverRequests = new Set();
-    exited;
     nextId = 1;
     stdout = "";
-    stderr = "";
     closed = false;
     constructor(input) {
-        this.child = spawn(input.argv[0], input.argv.slice(1), {
-            cwd: input.cwd,
-            env: input.env ?? process.env,
-            detached: true,
-            stdio: ["pipe", "pipe", "pipe"],
-            windowsHide: true,
-        });
-        this.child.stdout.setEncoding("utf8");
-        this.child.stderr.setEncoding("utf8");
-        this.child.stdout.on("data", (chunk) => this.consume(chunk));
-        this.child.stderr.on("data", (chunk) => { this.stderr = `${this.stderr}${chunk}`.slice(-4_000); });
-        this.child.on("error", (error) => this.fail(error));
-        this.exited = new Promise((resolve) => this.child.once("close", (code, signal) => {
+        this.process = spawnStdioProcess(input);
+        this.process.output.setEncoding("utf8");
+        this.process.output.on("data", (chunk) => this.consume(chunk));
+        void this.process.exited.then((exit) => {
             this.closed = true;
-            this.fail(new Error(`line RPC process exited${code === null ? "" : ` with code ${code}`}`));
-            resolve({ code, signal, stderr: this.stderr.trim() });
-        }));
+            this.fail(new Error(`line RPC process exited${exit.code === null ? "" : ` with code ${exit.code}`}`));
+        });
     }
     onNotification(listener) { this.notifications.add(listener); }
     onServerRequest(listener) { this.serverRequests.add(listener); }
-    onExit(listener) { void this.exited.then(listener); }
+    onExit(listener) { void this.process.exited.then(listener); }
     consume(chunk) {
         this.stdout += chunk;
         for (;;) {
@@ -105,7 +85,7 @@ export class LineRpcProcess {
         const id = this.nextId++;
         return new Promise((resolve, reject) => {
             this.pending.set(id, { resolve, reject });
-            this.child.stdin.write(`${JSON.stringify({ id, method, ...(params === undefined ? {} : { params }) })}\n`, (error) => {
+            this.process.input.write(`${JSON.stringify({ id, method, ...(params === undefined ? {} : { params }) })}\n`, (error) => {
                 if (error === null || error === undefined)
                     return;
                 this.pending.delete(id);
@@ -115,31 +95,24 @@ export class LineRpcProcess {
     }
     notify(method) {
         if (!this.closed)
-            this.child.stdin.write(`${JSON.stringify({ method })}\n`);
+            this.process.input.write(`${JSON.stringify({ method })}\n`);
     }
-    async endInputAndDrain(timeoutMs = DEFAULT_DRAIN_TIMEOUT_MS) {
+    async endInputAndDrain(timeoutMs) {
         if (this.closed) {
-            await this.exited;
+            await this.process.exited;
             return;
         }
         this.closed = true;
         this.fail(new Error("line RPC process is closed"));
-        this.child.stdin.end();
-        const drained = await bounded(this.exited, timeoutMs);
-        if (drained === undefined) {
-            await terminateProcessTree(this.child.pid, true);
-            await this.exited;
-        }
+        await this.process.endInputAndDrain(timeoutMs);
     }
     async close(force = false) {
         if (this.closed) {
-            await this.exited;
+            await this.process.exited;
             return;
         }
         this.closed = true;
         this.fail(new Error("line RPC process is closed"));
-        this.child.stdin.end();
-        await terminateProcessTree(this.child.pid, force);
-        await this.exited;
+        await this.process.close(force);
     }
 }

package/build/src/runtime/proc/run.d.ts

@@ -1,3 +1,4 @@
+import { type ChildProcess } from "node:child_process";
 type ProcessLaunch = Readonly<{
     readonly argv: readonly string[];
     readonly cwd?: string;
@@ -28,43 +29,28 @@ type ProcessCancelled = Readonly<{
     readonly kind: "cancelled";
 }>;
 export type ProcessOutcome = ProcessTerminal | ProcessTimeout | ProcessSpawnError | ProcessUnknownExit | ProcessCancelled;
-export type ProcessIdentity = Readonly<{
-    pid: number;
-    spawnedAt: string;
-}>;
-export type ProcessIdentityProbe = Readonly<{
-    kind: "gone" | "alive" | "replaced";
-}> | Readonly<{
-    kind: "unverifiable";
-    diagnostic: string;
-}>;
-export type ProcessCollar = Readonly<{
-    pid: number;
-    processGroup: number;
-    spawnedAt: string;
+type ProcessStreamError = Readonly<{
+    readonly kind: "stream-error";
+    readonly diagnostic: string;
 }>;
-export type ProcessTreeProbe = Readonly<{
-    kind: "gone";
-}> | Readonly<{
-    kind: "alive";
-}> | Readonly<{
-    kind: "unverifiable";
-    diagnostic: string;
+export type ProcessConsumption = Readonly<{
+    readonly outcome: ProcessOutcome | ProcessStreamError;
+    readonly pid: number | null;
 }>;
-export type PutDownEvidence = "killed" | "already-dead" | "alive-after-sigkill" | "unavailable";
 export type DetachedProcessInput = Readonly<{
     argv: readonly string[];
     cwd: string;
     env?: NodeJS.ProcessEnv;
     log: string;
 }>;
-export declare function terminateProcessTree(pid: number | undefined, force?: boolean): Promise<void>;
-export declare function currentProcessCollar(): ProcessCollar;
-export declare function currentProcessIdentity(): ProcessIdentity;
-export declare function probeProcessIdentity(identity: ProcessIdentity): ProcessIdentityProbe;
-export declare function spawnDetachedProcess(input: DetachedProcessInput): Promise<ProcessCollar>;
-export declare function probeProcessTree(collar: ProcessCollar): ProcessTreeProbe;
-export declare function putDownProcessTree(collar: ProcessCollar): Promise<PutDownEvidence>;
+export type OwnedProcess = Readonly<{
+    pid: number;
+    terminate(force?: boolean): Promise<void>;
+    release(): void;
+}>;
+export declare function terminateOwnedProcess(child: ChildProcess, force?: boolean): Promise<void>;
+export declare function spawnDetachedProcess(input: DetachedProcessInput): Promise<OwnedProcess>;
 export declare function runProcess(input: ProcessInput): Promise<ProcessOutcome>;
 export declare function runProcessToExit(input: ProcessLaunch): Promise<ProcessOutcome>;
+export declare function consumeProcessStdout(input: ProcessInput, consume: (chunk: Buffer) => void): Promise<ProcessConsumption>;
 export {};