@astrosheep/keiyaku 2.9.13 → 4.0.1

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

@@ -0,0 +1,23 @@
+import type { ContractHead, ContractState, JournalEntry } from "../core/facts/types.js";
+import type { AcceptedAdmission } from "./attempt.js";
+import type { ProtocolResult, ProtocolTerminal } from "./run.js";
+import type { ReconcileResult } from "../git/reconcile.js";
+export type AcceptedProtocolStep = AcceptedAdmission & Readonly<{
+    physical?: ReconcileResult;
+}>;
+export type IntentOutcome<Value, Refusal = never> = Readonly<{
+    kind: "accepted";
+    facts: readonly JournalEntry[];
+    head: ContractHead;
+    value: Value;
+    physical?: ReconcileResult;
+}> | Readonly<{
+    kind: "refused";
+    refusal: Refusal;
+}> | Readonly<{
+    kind: "retry";
+    reason: ProtocolTerminal;
+}>;
+export declare function accepted<Value, Refusal = never>(state: ContractState, facts: readonly JournalEntry[], value: Value, physical?: ReconcileResult): IntentOutcome<Value, Refusal>;
+export declare function admitted<Value, Refusal = never>(admission: AcceptedProtocolStep, value: Value): IntentOutcome<Value, Refusal>;
+export declare function complete<Value, Refusal>(result: ProtocolResult<Refusal>, value: Value): IntentOutcome<Value, Refusal>;

package/build/src/protocol/outcome.js

@@ -0,0 +1,21 @@
+export function accepted(state, facts, value, physical) {
+    if (state.head === null)
+        throw new Error("accepted contract is missing its journal head");
+    return {
+        kind: "accepted",
+        facts,
+        head: state.head,
+        value,
+        ...(physical === undefined ? {} : { physical }),
+    };
+}
+export function admitted(admission, value) {
+    return accepted(admission.state, admission.facts, value, admission.physical);
+}
+export function complete(result, value) {
+    if (result.kind === "refused")
+        return { kind: "refused", refusal: result.refusal };
+    if (result.kind !== "accepted")
+        return { kind: "retry", reason: result };
+    return admitted(result, value);
+}

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

@@ -0,0 +1,30 @@
+import type { ActorId, ContractId, SnapshotId } from "../core/facts/types.js";
+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 AcceptedAdmission } from "./attempt.js";
+import { type ProtocolResult } from "./run.js";
+export type PlacementExecutionFailure = Readonly<{
+    kind: "placement-failed";
+    diagnostic: string;
+}>;
+export type TargetMovedStop = Readonly<{
+    kind: "target-moved";
+    contractId: ContractId;
+    target: string;
+    expected: SnapshotId;
+    observed: SnapshotId | null;
+}>;
+export type PlacementProtocolResult = (AcceptedAdmission & Readonly<{
+    physical?: ReconcileResult;
+}>) | Exclude<ProtocolResult<PlacementRefusal | TargetPlacementRefusal>, AcceptedAdmission> | TargetMovedStop | PlacementExecutionFailure;
+type PlacementProtocolInput = Readonly<{
+    contractId: ContractId;
+    actor?: ActorId;
+    at: string;
+}>;
+/** 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 {};

package/build/src/protocol/placement.js

@@ -0,0 +1,114 @@
+import { SqliteTransactionLockError } from "../coordination/sqlite-transaction-lock.js";
+import { AuthorityCorruptionError } from "../core/facts/errors.js";
+import { contractState } from "../core/facts/observation.js";
+import { decidePlacement } from "../core/verbs/placement.js";
+import { reconcileEffectFailure } from "../git/reconcile.js";
+import { GitPlumbingError } from "../git/repository.js";
+import { acquireTargetPlacementFence, followTargetPlacement, prepareTargetPlacement, observeTargetHead, } 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);
+    throw 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]);
+        if (prepared.kind === "refused")
+            return prepared;
+        const state = contractState(prepared.observation.decision, input.contractId);
+        if (state === null)
+            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);
+        if (observed !== prepared.offer.target.expectedOid) {
+            return {
+                kind: "target-moved",
+                contractId: input.contractId,
+                target: prepared.offer.target.target,
+                expected: prepared.offer.target.expectedOid,
+                observed,
+            };
+        }
+        const physical = prepareTargetPlacement(repository, state, prepared.offer.target);
+        if (physical.kind === "refused")
+            return physical;
+        const result = await admitDecidedOffer({
+            channel: protocol.channel,
+            repository,
+            decisionObservation: prepared.observation,
+            attempt: prepared.attempt,
+            offer: prepared.offer,
+            primaryContract: input.contractId,
+        });
+        if (result.kind === "accepted") {
+            return { ...result, physical: followTargetPlacement(repository, physical.placement) };
+        }
+        if (result.kind === "publication-failed")
+            return result;
+        if (result.kind === "collision" && index + 1 === protocol.attempts.length)
+            return result;
+    }
+    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();
+    let held;
+    try {
+        held = await acquireTargetPlacementFence(repository, target);
+    }
+    catch (error) {
+        return placementFailure(error);
+    }
+    let result;
+    let exceptional;
+    try {
+        result = await runFencedPlacement(repository, input, protocol);
+    }
+    catch (error) {
+        if (error instanceof AuthorityCorruptionError || error instanceof TypeError)
+            exceptional = error;
+        else {
+            try {
+                result = expectedPlacementFailure(error);
+            }
+            catch (unexpected) {
+                exceptional = unexpected;
+            }
+        }
+    }
+    let releaseFailure;
+    try {
+        held.close();
+    }
+    catch (error) {
+        releaseFailure = error;
+    }
+    if (exceptional !== undefined)
+        throw exceptional;
+    if (result === undefined)
+        throw new Error("placement produced no result");
+    if (releaseFailure !== undefined) {
+        return result.kind === "accepted"
+            ? { ...result, physical: reconcileEffectFailure(releaseFailure, result.physical) }
+            : placementFailure(releaseFailure);
+    }
+    return result;
+}

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

@@ -0,0 +1,31 @@
+import { type GitDecodeChannel } from "../../git/read-observation.js";
+import type { GitRepository } from "../../git/repository.js";
+import type { ContractId, ContractState, DeliverData, FactKind, Gate, JournalEntry, SnapshotId } from "../../core/facts/types.js";
+export type { FactKind } from "../../core/facts/types.js";
+export type TimelineEntry = Readonly<{
+    kind: FactKind;
+    at: string;
+    sincePrior: number | null;
+    attestation?: Readonly<{
+        gate: Gate;
+        verdict: "satisfied" | "unsatisfied";
+        summary?: string;
+    }>;
+}>;
+export type AuditReport = Readonly<{
+    reworks: number;
+    reviews: number;
+    timeline: readonly TimelineEntry[];
+    delivery?: DeliverData;
+    targetObservation?: Readonly<{
+        head: SnapshotId | null;
+        drift: boolean;
+    }>;
+}>;
+type AuditRead = Readonly<{
+    state: ContractState | null;
+    entries: readonly JournalEntry[];
+    report: AuditReport;
+}>;
+export declare function auditReport(entries: readonly JournalEntry[], reviewed: Gate, state?: ContractState, targetObservation?: AuditReport["targetObservation"]): AuditReport;
+export declare function readAuditAt(repository: GitRepository, channel: GitDecodeChannel, contract: ContractId, reviewed: Gate): Promise<AuditRead>;

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

@@ -0,0 +1,55 @@
+import { observeContractWorld, observeDeliveryTargetAt } from "../../git/observe.js";
+import { withGitReadObservation } from "../../git/read-observation.js";
+function elapsedSince(prior, current) {
+    if (prior === undefined)
+        return null;
+    const priorMs = Date.parse(prior);
+    const currentMs = Date.parse(current);
+    return currentMs - priorMs;
+}
+export function auditReport(entries, reviewed, state, targetObservation) {
+    let reworks = 0;
+    let reviews = 0;
+    const timeline = entries.map((entry, index) => {
+        if (entry.kind === "deliver")
+            reworks += 1;
+        if (entry.kind === "attestation" && entry.data.gate === reviewed)
+            reviews += 1;
+        return {
+            kind: entry.kind,
+            at: entry.at,
+            sincePrior: elapsedSince(entries[index - 1]?.at, entry.at),
+            ...(entry.kind === "attestation" ? {
+                attestation: {
+                    gate: entry.data.gate,
+                    verdict: entry.data.verdict,
+                    ...(entry.data.summary === undefined ? {} : { summary: entry.data.summary }),
+                },
+            } : {}),
+        };
+    });
+    const delivery = state?.delivery?.data;
+    return {
+        reworks,
+        reviews,
+        timeline,
+        ...(delivery === undefined ? {} : { delivery }),
+        ...(targetObservation === undefined ? {} : { targetObservation }),
+    };
+}
+export async function readAuditAt(repository, channel, contract, reviewed) {
+    return withGitReadObservation(repository, channel, async (observation) => {
+        const world = await observeContractWorld(observation, [contract]);
+        const record = world.contracts.get(contract);
+        if (record === undefined)
+            throw new Error(`missing requested contract observation: ${contract}`);
+        const targetObservation = record.state === null
+            ? undefined
+            : await observeDeliveryTargetAt(observation, record.state) ?? undefined;
+        return {
+            state: record.state,
+            entries: record.entries,
+            report: auditReport(record.entries, reviewed, record.state ?? undefined, targetObservation),
+        };
+    });
+}

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

@@ -0,0 +1,8 @@
+import type { GitReadObservation } from "../../git/read-observation.js";
+import type { ContractId } from "../../core/facts/types.js";
+export type ContractDocumentProjection = Readonly<{
+    contract: ContractId;
+    documentBytes: string;
+}>;
+/** Read every live contract document from one immutable Git snapshot. */
+export declare function readDocuments(observation: GitReadObservation): Promise<readonly ContractDocumentProjection[]>;

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

@@ -0,0 +1,16 @@
+import { observeActiveContractWorld } from "../../git/observe.js";
+/** Read every live contract document from one immutable Git snapshot. */
+export async function readDocuments(observation) {
+    const observed = await observeActiveContractWorld(observation);
+    const documents = [];
+    for (const [contract, observation] of observed.contracts) {
+        const state = observation.state;
+        if (state === null)
+            continue;
+        documents.push({
+            contract,
+            documentBytes: state.terms.document.bytes,
+        });
+    }
+    return documents;
+}

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

@@ -0,0 +1,44 @@
+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";
+export type ContractPhase = "waiting" | "bound" | "pending-delivery" | "claimed" | "abandoned";
+export type ContractDisposition = "active" | "terminal";
+export type ContractGateCurrent = GateCurrent;
+export type ContractGateReport = Readonly<{
+    gate: string;
+    current: ContractGateCurrent;
+}>;
+export type ContractRow = Readonly<{
+    id: ContractId;
+    phase: ContractPhase;
+    disposition: ContractDisposition;
+    workspace: "worktree" | "here";
+    worktreePath: string | null;
+    target: string | null;
+    delivery: DeliverData | null;
+    targetObservation: Readonly<{
+        head: SnapshotId | null;
+        drift: boolean;
+    }> | null;
+    gates: Readonly<{
+        reports: readonly ContractGateReport[];
+        satisfied: boolean;
+    }>;
+}>;
+export type ContractBoard = Readonly<{
+    root: string;
+    state: SnapshotId | null;
+    rows: readonly ContractRow[];
+}>;
+export type ContractObservation = Readonly<{
+    kind: "missing";
+    id: ContractId;
+}> | Readonly<{
+    kind: "present";
+    row: ContractRow;
+}>;
+/** 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. */
+export declare function readContractObservationAt(repository: GitRepository, channel: GitDecodeChannel, id: ContractId): Promise<ContractObservation>;

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

@@ -0,0 +1,60 @@
+import { extendContractsForAdmissionAt, observeActiveContractWorld, observeContractsForAdmissionInObservationAt, observeDeliveryTargetAt, withContractReadObservationAt, } from "../../git/observe.js";
+import { deliveryWorktreePath } from "../../git/workspace.js";
+import { gateReports } from "../../core/facts/gate.js";
+import { prerequisiteStatus } from "../../core/facts/observation.js";
+function phaseFor(state, eligible) {
+    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)
+        return "bound";
+    return "waiting";
+}
+function rowFor(repository, state, targetObservation, eligible) {
+    const workspace = state.coordinates.workspace;
+    const gates = gateReports(state);
+    return {
+        id: state.id,
+        phase: phaseFor(state, eligible),
+        disposition: state.terminal === null ? "active" : "terminal",
+        workspace,
+        worktreePath: workspace === "worktree" ? deliveryWorktreePath(repository, state.id) : null,
+        target: state.coordinates.target ?? null,
+        delivery: state.delivery?.data ?? null,
+        targetObservation,
+        gates: {
+            reports: gates.reports.map((report) => ({ gate: report.gate, current: report.current })),
+            satisfied: gates.satisfied,
+        },
+    };
+}
+/** Build the Contract board from one immutable git observation. */
+export async function readContractBoard(observation) {
+    const observed = await observeActiveContractWorld(observation);
+    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")));
+    }
+    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);
+        return state === null
+            ? { kind: "missing", id }
+            : {
+                kind: "present",
+                row: rowFor(observation.repository, state, await observeDeliveryTargetAt(observation, state), prerequisiteStatus(state.terms.after, observed.decision) === "claimed"),
+            };
+    });
+}

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

@@ -0,0 +1,81 @@
+import { type GitDecisionObservation } from "../git/observe.js";
+import type { GitDecodeChannel, GitTreeSelection } from "../git/read-observation.js";
+import type { GitRepository } from "../git/repository.js";
+import type { GitRefAssertion } from "../git/repository.js";
+import type { AttemptContext, DecideInput, OfferDecision } from "../core/decide.js";
+import type { Offer, TreeUpdate } from "../core/facts/offer.js";
+import { type ContractId } from "../core/facts/types.js";
+import { type AcceptedAdmission, type AttemptTerminal } from "./attempt.js";
+export type ProtocolTerminal = Readonly<{
+    kind: "exhausted";
+}> | AttemptTerminal;
+export type ProtocolResult<Refusal> = AcceptedAdmission | Readonly<{
+    kind: "refused";
+    refusal: Refusal;
+}> | ProtocolTerminal;
+export type CompanionDecorator = (input: Readonly<{
+    repository: GitRepository;
+    observation: GitDecisionObservation;
+    contractId: ContractId;
+    offer: Offer;
+}>) => readonly TreeUpdate[] | Promise<readonly TreeUpdate[]>;
+export type RunProtocolInput<Input extends Readonly<{
+    contractId: ContractId;
+}>, Refusal, Seed extends Readonly<{
+    contractId: ContractId;
+}> = Input> = Readonly<{
+    channel: GitDecodeChannel;
+    repository: GitRepository;
+    contracts: readonly ContractId[];
+    attempts: readonly AttemptContext[];
+    decide: (input: DecideInput<Input>) => OfferDecision<Refusal>;
+    /** Override the targeted observer only for intents that need a full snapshot. */
+    observe?: (repository: GitRepository, channel: GitDecodeChannel, contracts: readonly ContractId[]) => Promise<GitDecisionObservation>;
+    /** Mint verb-owned entries from the exact size of this attempt's observation. */
+    extendAttempt?: (attempt: AttemptContext, observedContractCount: number) => AttemptContext;
+    /** Add opaque companions from the exact immutable observation for this attempt. */
+    decorateOffer?: CompanionDecorator;
+    observationSelection?: GitTreeSelection;
+}> & (Readonly<{
+    input: Input;
+    prepareInput?: never;
+}> | Readonly<{
+    input: Seed;
+    prepareInput: (observation: GitDecisionObservation, input: Seed) => Readonly<{
+        kind: "prepared";
+        input: Input;
+        assertions?: readonly GitRefAssertion[];
+    }> | Readonly<{
+        kind: "refused";
+        refusal: Refusal;
+    }> | Promise<Readonly<{
+        kind: "prepared";
+        input: Input;
+        assertions?: readonly GitRefAssertion[];
+    }> | Readonly<{
+        kind: "refused";
+        refusal: Refusal;
+    }>>;
+}>);
+export type PreparedProtocolAttempt<Refusal> = Readonly<{
+    kind: "refused";
+    refusal: Refusal;
+}> | Readonly<{
+    kind: "offered";
+    observation: GitDecisionObservation;
+    attempt: AttemptContext;
+    offer: Offer;
+    assertions: readonly GitRefAssertion[];
+}>;
+/** Form one decided offer without admitting or reinterpreting it. */
+export declare function prepareProtocolAttempt<Input extends Readonly<{
+    contractId: ContractId;
+}>, Refusal, Seed extends Readonly<{
+    contractId: ContractId;
+}> = Input>(input: RunProtocolInput<Input, Refusal, Seed>, baseAttempt: AttemptContext): Promise<PreparedProtocolAttempt<Refusal>>;
+/** Run bounded, verb-neutral attempts and return one real admission on acceptance. */
+export declare function runProtocol<Input extends Readonly<{
+    contractId: ContractId;
+}>, Refusal, Seed extends Readonly<{
+    contractId: ContractId;
+}> = Input>(input: RunProtocolInput<Input, Refusal, Seed>): Promise<ProtocolResult<Refusal>>;

package/build/src/protocol/run.js

@@ -0,0 +1,64 @@
+import { extendAdmissionPathsAt, observeContractsForAdmissionAt, } from "../git/observe.js";
+import { admitDecidedOffer } from "./attempt.js";
+/** Form one decided offer without admitting or reinterpreting it. */
+export async function prepareProtocolAttempt(input, baseAttempt) {
+    const decisionObservation = input.observe === undefined
+        ? await observeContractsForAdmissionAt(input.repository, input.channel, input.contracts, input.observationSelection)
+        : await input.observe(input.repository, input.channel, input.contracts);
+    const observation = decisionObservation.decision;
+    const preparedInput = "prepareInput" in input && input.prepareInput !== undefined
+        ? await input.prepareInput(decisionObservation, input.input)
+        : { kind: "prepared", input: input.input, assertions: [] };
+    if (preparedInput.kind === "refused")
+        return preparedInput;
+    const attempt = input.extendAttempt === undefined
+        ? baseAttempt
+        : input.extendAttempt(baseAttempt, observation.size);
+    const decision = input.decide({ input: preparedInput.input, attempt, observation });
+    if (decision.kind === "refused")
+        return decision;
+    const companions = input.decorateOffer === undefined
+        ? []
+        : await input.decorateOffer({
+            repository: input.repository,
+            observation: decisionObservation,
+            contractId: input.input.contractId,
+            offer: decision.offer,
+        });
+    const offer = companions.length === 0
+        ? decision.offer
+        : { ...decision.offer, companions: [...(decision.offer.companions ?? []), ...companions] };
+    const admissionObservation = companions.length === 0
+        ? decisionObservation
+        : await extendAdmissionPathsAt(input.channel, decisionObservation, companions.map(({ path }) => path));
+    return {
+        kind: "offered",
+        observation: admissionObservation,
+        attempt,
+        offer,
+        assertions: preparedInput.assertions ?? [],
+    };
+}
+/** Run bounded, verb-neutral attempts and return one real admission on acceptance. */
+export async function runProtocol(input) {
+    const attempts = input.attempts;
+    for (let index = 0; index < attempts.length; index += 1) {
+        const prepared = await prepareProtocolAttempt(input, attempts[index]);
+        if (prepared.kind === "refused")
+            return prepared;
+        const result = await admitDecidedOffer({
+            channel: input.channel,
+            repository: input.repository,
+            decisionObservation: prepared.observation,
+            attempt: prepared.attempt,
+            offer: prepared.offer,
+            primaryContract: input.input.contractId,
+            assertions: prepared.assertions,
+        });
+        if (result.kind === "accepted" || result.kind === "publication-failed")
+            return result;
+        if (result.kind === "collision" && index + 1 === attempts.length)
+            return result;
+    }
+    return { kind: "exhausted" };
+}

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

@@ -0,0 +1,38 @@
+export type LineRpcNotification = Readonly<{
+    method: string;
+    params?: Readonly<Record<string, unknown>>;
+}>;
+export type LineRpcServerRequest = LineRpcNotification & Readonly<{
+    id: number | string;
+}>;
+export type LineRpcExit = Readonly<{
+    code: number | null;
+    signal: NodeJS.Signals | null;
+    stderr: string;
+}>;
+export declare class LineRpcProcess {
+    private readonly child;
+    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[]];
+        cwd: string;
+        env?: NodeJS.ProcessEnv;
+    }>);
+    onNotification(listener: (value: LineRpcNotification) => void): void;
+    onServerRequest(listener: (value: LineRpcServerRequest) => void): void;
+    onExit(listener: (value: LineRpcExit) => void): void;
+    private consume;
+    private receive;
+    private fail;
+    request(method: string, params?: Readonly<Record<string, unknown>>): Promise<unknown>;
+    notify(method: string): void;
+    endInputAndDrain(timeoutMs?: number): Promise<void>;
+    close(force?: boolean): Promise<void>;
+}