@fungi.computer/veil 0.4.0 → 0.5.0

package/dist/connections/cleanup.d.ts

@@ -0,0 +1,21 @@
+import * as Effect from "effect/Effect";
+import type * as Schema from "effect/Schema";
+import type { ConnectionsOptions } from "./contract.js";
+import { type AttemptRow, type ConnectionRow } from "./internal.js";
+/** The cleanup outbox, attempt retirement and reconnect marking over the owner's SQLite. */
+export declare function createCleanup(deps: {
+    ownerId: string;
+    custody: ConnectionsOptions["custody"];
+    clock: () => number;
+    sql: ConnectionsOptions["store"]["sql"];
+    transactionSync: <A>(body: () => A) => A;
+    rows: <S extends Schema.Decoder<unknown>>(schema: S, statement: string, ...bindings: (string | number | null)[]) => S["Type"][];
+    bump: () => void;
+}): {
+    cleanupPending: () => number;
+    sweep: () => Effect.Effect<void, import("./contract.js").ConnectionsError, never>;
+    enqueueLocator: (connectionId: string, locator: string, credential: ConnectionRow["credential"]) => void;
+    enqueueCleanup: (row: ConnectionRow) => void;
+    markReconnect: (id: string) => void;
+    retireAttempt: (attempt: AttemptRow, status: string) => void;
+};

package/dist/connections/cleanup.js

@@ -0,0 +1,66 @@
+import * as Effect from "effect/Effect";
+import { attemptRow, cleanupRow, connectionRow, count, sync, } from "./internal.js";
+const cleanupLimit = 5;
+/** The cleanup outbox, attempt retirement and reconnect marking over the owner's SQLite. */
+export function createCleanup(deps) {
+    const { sql, rows, bump, transactionSync } = deps;
+    /** Sealed credentials still waiting to be deleted; hosts wake their alarm while this is positive. */
+    const cleanupPending = () => rows(count, "SELECT COUNT(*) AS n FROM veil_connection_cleanup WHERE attempts < ?", cleanupLimit)[0]?.n ?? 0;
+    const sweep = () => Effect.gen(function* () {
+        yield* sync(expireAttempts);
+        const due = yield* sync(() => rows(cleanupRow, "SELECT * FROM veil_connection_cleanup WHERE attempts < ?", cleanupLimit));
+        for (const job of due) {
+            const outcome = yield* deps.custody
+                .remove({
+                ownerId: deps.ownerId,
+                connectionId: job.connectionId,
+                credential: job.credential,
+            }, job.locator)
+                .pipe(Effect.result);
+            yield* sync(() => {
+                if (outcome._tag === "Success")
+                    sql.exec("DELETE FROM veil_connection_cleanup WHERE id = ?", job.id);
+                else
+                    sql.exec("UPDATE veil_connection_cleanup SET attempts = attempts + 1 WHERE id = ?", job.id);
+            });
+        }
+    });
+    const enqueueLocator = (connectionId, locator, credential) => {
+        sql.exec("INSERT INTO veil_connection_cleanup (connectionId, locator, credential, attempts) VALUES (?, ?, ?, 0)", connectionId, locator, JSON.stringify(credential));
+    };
+    const enqueueCleanup = (row) => {
+        if (row.locator !== null)
+            enqueueLocator(row.id, row.locator, row.credential);
+    };
+    const markReconnect = (id) => {
+        sql.exec("UPDATE veil_connections SET state = 'reconnect_required', authorityVersion = authorityVersion + 1 WHERE id = ? AND state = 'active'", id);
+        bump();
+    };
+    /** An attempt ends: its sealed verifier goes to cleanup and a still-pending connection is withdrawn. */
+    const retireAttempt = (attempt, status) => {
+        sql.exec("UPDATE veil_connection_attempts SET status = ?, pkceVerifierSealed = NULL WHERE state = ?", status, attempt.state);
+        const row = rows(connectionRow, "SELECT * FROM veil_connections WHERE id = ?", attempt.connectionId)[0];
+        if (row === undefined)
+            return;
+        if (attempt.pkceVerifierSealed !== null)
+            enqueueLocator(row.id, attempt.pkceVerifierSealed, row.credential);
+        if (row.state === "pending") {
+            sql.exec("UPDATE veil_connections SET state = 'revoked', authorityVersion = authorityVersion + 1 WHERE id = ?", row.id);
+            bump();
+        }
+    };
+    const expireAttempts = () => {
+        transactionSync(() => {
+            for (const attempt of rows(attemptRow, "SELECT * FROM veil_connection_attempts WHERE status IN ('pending', 'consumed') AND expiresAt <= ?", deps.clock()))
+                retireAttempt(attempt, "expired");
+        });
+    };
+    return {
+        cleanupPending,
+        sweep,
+        enqueueLocator,
+        enqueueCleanup,
+        markReconnect,
+        retireAttempt,
+    };
+}

package/dist/connections/contract.d.ts

@@ -1,7 +1,7 @@
 import * as Effect from "effect/Effect";
 import * as Schema from "effect/Schema";
 import type { PublicEgressPolicy } from "../public-egress-policy.js";
-export type ConnectionsRefusal = "invalid_input" | "denied" | "revoked" | "conflict" | "unsupported" | "too_large" | "reconnect_required" | "invalid_response" | "unavailable";
+export type ConnectionsRefusal = "invalid_input" | "denied" | "revoked" | "conflict" | "unsupported" | "too_large" | "reconnect_required" | "pending" | "invalid_response" | "unavailable";
 /** Fixed codes only: upstream bodies, URLs and credential bytes never enter errors. */
 export declare class ConnectionsError extends Error {
     readonly code: ConnectionsRefusal;
@@ -15,7 +15,11 @@ declare const placementSchema: Schema.Union<readonly [Schema.Literal<"bearer">,
     readonly query: Schema.String;
 }>]>;
 export type Placement = typeof placementSchema.Type;
-/** How the final request is authorized. OAuth joins this union in slice 3. */
+/**
+ * How the final request is authorized. For `oauth` the owner may bring its own
+ * client (`clientId`, with the client secret as the draft's `secret`); without
+ * one the server's dynamic registration is used.
+ */
 export declare const credentialSchema: Schema.Union<readonly [Schema.Struct<{
     readonly kind: Schema.Literal<"none">;
 }>, Schema.Struct<{
@@ -25,6 +29,12 @@ export declare const credentialSchema: Schema.Union<readonly [Schema.Struct<{
     }>, Schema.Struct<{
         readonly query: Schema.String;
     }>]>;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"oauth">;
+    readonly scope: Schema.optional<Schema.String>;
+    readonly clientId: Schema.optional<Schema.String>;
+    /** An operator-registered REST provider; absent for an MCP server's own sign-in. */
+    readonly provider: Schema.optional<Schema.String>;
 }>]>;
 export type Credential = typeof credentialSchema.Type;
 export type SurfaceView = Readonly<{
@@ -33,21 +43,27 @@ export type SurfaceView = Readonly<{
 }> | Readonly<{
     kind: "openapi";
     baseUrl: string;
-    table: unknown;
+    table: readonly unknown[];
+    /** Digest of the decoded operation table. */
+    digest: string;
 }>;
-export declare const toolsSchema: Schema.Union<readonly [Schema.Literal<"all">, Schema.$Array<Schema.String>]>;
+export declare const toolsSchema: Schema.Union<readonly [Schema.Literal<"all">, Schema.Struct<{
+    readonly effect: Schema.Literal<"read">;
+}>, Schema.$Array<Schema.String>]>;
 export type Tools = typeof toolsSchema.Type;
 export declare const draftSchema: Schema.Struct<{
     /** Idempotency key: a replay with the same request returns the same connection. */
     readonly requestId: Schema.String;
     readonly name: Schema.String;
+    /** Display text for owners; defaults to the name. */
+    readonly label: Schema.optional<Schema.String>;
     readonly surface: Schema.Union<readonly [Schema.Struct<{
         readonly kind: Schema.Literal<"mcp">;
         readonly url: Schema.String;
     }>, Schema.Struct<{
         readonly kind: Schema.Literal<"openapi">;
         readonly baseUrl: Schema.String;
-        readonly table: Schema.Unknown;
+        readonly table: Schema.$Array<Schema.Unknown>;
     }>]>;
     readonly credential: Schema.Union<readonly [Schema.Struct<{
         readonly kind: Schema.Literal<"none">;
@@ -58,6 +74,12 @@ export declare const draftSchema: Schema.Struct<{
         }>, Schema.Struct<{
             readonly query: Schema.String;
         }>]>;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"oauth">;
+        readonly scope: Schema.optional<Schema.String>;
+        readonly clientId: Schema.optional<Schema.String>;
+        /** An operator-registered REST provider; absent for an MCP server's own sign-in. */
+        readonly provider: Schema.optional<Schema.String>;
     }>]>;
     readonly secret: Schema.optional<Schema.String>;
 }>;
@@ -65,9 +87,54 @@ export type ConnectionDraft = typeof draftSchema.Type;
 export declare const grantInputSchema: Schema.Struct<{
     readonly connectionId: Schema.String;
     readonly agentId: Schema.String;
-    readonly tools: Schema.Union<readonly [Schema.Literal<"all">, Schema.$Array<Schema.String>]>;
+    readonly tools: Schema.Union<readonly [Schema.Literal<"all">, Schema.Struct<{
+        readonly effect: Schema.Literal<"read">;
+    }>, Schema.$Array<Schema.String>]>;
 }>;
 export type GrantInput = typeof grantInputSchema.Type;
+/** The authorization server's redirect back to the owner. */
+export declare const completeInputSchema: Schema.Struct<{
+    readonly state: Schema.String;
+    readonly code: Schema.String;
+    readonly iss: Schema.optional<Schema.String>;
+}>;
+export type CompleteInput = typeof completeInputSchema.Type;
+/** Owner edits to a live connection, guarded by the version the owner last saw. */
+export declare const updateInputSchema: Schema.Struct<{
+    readonly requestId: Schema.String;
+    readonly connectionId: Schema.String;
+    readonly expectedVersion: Schema.Number;
+    readonly label: Schema.optional<Schema.String>;
+    readonly name: Schema.optional<Schema.String>;
+    /** Replacement OpenAPI operation table, decoded by Forage. */
+    readonly table: Schema.optional<Schema.$Array<Schema.Unknown>>;
+    readonly baseUrl: Schema.optional<Schema.String>;
+    /** Credential swap; `none` and `static` only. */
+    readonly credential: Schema.optional<Schema.Union<readonly [Schema.Struct<{
+        readonly kind: Schema.Literal<"none">;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"static">;
+        readonly placement: Schema.Union<readonly [Schema.Literal<"bearer">, Schema.Struct<{
+            readonly header: Schema.String;
+        }>, Schema.Struct<{
+            readonly query: Schema.String;
+        }>]>;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"oauth">;
+        readonly scope: Schema.optional<Schema.String>;
+        readonly clientId: Schema.optional<Schema.String>;
+        /** An operator-registered REST provider; absent for an MCP server's own sign-in. */
+        readonly provider: Schema.optional<Schema.String>;
+    }>]>>;
+    readonly secret: Schema.optional<Schema.String>;
+}>;
+export type UpdateInput = typeof updateInputSchema.Type;
+/** One typed OpenAPI operation call. */
+export declare const callInputSchema: Schema.Struct<{
+    readonly operation: Schema.String;
+    readonly input: Schema.Unknown;
+}>;
+export type CallInput = typeof callInputSchema.Type;
 export declare const egressRefSchema: Schema.Struct<{
     readonly connectionId: Schema.String;
     readonly grantVersion: Schema.Number;
@@ -87,6 +154,35 @@ export type CustodyAdapter = Readonly<{
     put: (address: CustodyAddress, secret: string) => Effect.Effect<string, ConnectionsError>;
     inject: (address: CustodyAddress, locator: string, request: Request) => Effect.Effect<Response, ConnectionsError>;
     remove: (address: CustodyAddress, locator: string) => Effect.Effect<"deleted" | "absent", ConnectionsError>;
+    /**
+     * Release a sealed OAuth bundle to the owner's connections core, which runs
+     * the authorization flow and refreshes tokens. Never reaches an Agent.
+     */
+    open?: (address: CustodyAddress, locator: string) => Effect.Effect<string, ConnectionsError>;
+    /**
+     * A custodian that runs the authorization itself (Nango's Connect) returns
+     * the page to send the owner to; it settles through a signed completion
+     * (`complete`) carrying the `state` given here, not through our callback.
+     */
+    connect?: (address: CustodyAddress, attempt: Readonly<{
+        state: string;
+        actor: string;
+        integrationId: string;
+    }>) => Effect.Effect<Readonly<{
+        connectUrl: string;
+        expiresAt: number;
+    }>, ConnectionsError>;
+}>;
+/**
+ * What a custodian proves after it ran an authorization: the attempt's state
+ * and where it keeps the credential. The host verifies the custodian's
+ * signature before it builds one.
+ */
+export type CustodyCompletion = Readonly<{
+    state: string;
+    locator: string;
+    /** The integration the custodian ran it through; it must be the one the attempt began with. */
+    integrationId: string;
 }>;
 export type SqlValue = string | number | null;
 /** The owner's SQLite in Cloudflare `ctx.storage` shape. */
@@ -98,13 +194,54 @@ export type SqlStore = Readonly<{
     }>;
     transactionSync: <A>(operation: () => A) => A;
 }>;
+/**
+ * A REST provider the operator registered an app with. Such providers publish
+ * no metadata the SDK can discover, and many require a pre-registered client,
+ * so the host names the endpoints and holds the client. Only the operator's
+ * configuration reaches this type; neither an Agent nor an owner supplies one.
+ */
+export type StaticOAuthProvider = Readonly<{
+    issuer: string;
+    authorizationEndpoint: string;
+    tokenEndpoint: string;
+    /** Scopes requested when the owner names none. */
+    scope?: string;
+    client: {
+        client_id: string;
+        client_secret?: string | undefined;
+    };
+}>;
 export type ConnectionsOptions = Readonly<{
     ownerId: string;
     store: SqlStore;
     custody: CustodyAdapter;
     /** Host authority read: may this actor manage connections, or still stand as a grantor? */
     authorize: (actorId: string, purpose: "manage" | "grantor") => boolean;
+    /**
+     * Asked right before every send, with the grantor who stands behind the
+     * grant. The host keeps its own live recheck here (membership, write
+     * rights); the core never learns what the host's policy is.
+     */
+    check?: (grantor: string, grant: Readonly<{
+        agentId: string;
+        connectionId: string;
+        tools: Tools;
+    }>, operation: Readonly<{
+        name: string;
+        effect: "read" | "write" | null;
+    }> | null) => Promise<boolean>;
     egressPolicy?: PublicEgressPolicy;
+    /**
+     * Needed only for `oauth` connections: where the authorization server sends
+     * the owner back, and the checked public transport for discovery, token and
+     * refresh requests. Custody must also implement `open`.
+     */
+    oauth?: Readonly<{
+        callbackUrl: string;
+        fetch: (request: Request) => Promise<Response>;
+        /** REST providers the operator registered an app with, by id. */
+        providers?: Readonly<Record<string, StaticOAuthProvider>>;
+    }> | undefined;
     clock: () => number;
     ids: () => string;
 }>;
@@ -116,6 +253,8 @@ export type ConnectionProjection = Readonly<{
         name: string;
         surface: SurfaceView;
         tools: Tools;
+        /** Bumped by every `update`. */
+        version: number;
         authorityVersion: number;
         grantVersion: number;
     }>[];
@@ -123,17 +262,24 @@ export type ConnectionProjection = Readonly<{
 export type ConnectionView = Readonly<{
     connectionId: string;
     name: string;
+    label: string;
     surface: Readonly<{
         kind: "mcp" | "openapi";
         origin: string;
+        url: string;
+        digest: string | null;
     }>;
     credentialKind: Credential["kind"];
-    state: "active" | "reconnect_required" | "revoked";
+    /** How the secret is placed; the secret itself never appears. */
+    credential: Credential;
+    state: "pending" | "active" | "reconnect_required" | "revoked";
+    version: number;
     authorityVersion: number;
     grants: readonly Readonly<{
         agentId: string;
         tools: Tools;
         version: number;
+        grantor: string;
     }>[];
 }>;
 /** The Agent's narrowed capability: only the owner opens the credential. */

package/dist/connections/contract.js

@@ -18,10 +18,21 @@ const placementSchema = Schema.Union([
     Schema.Struct({ header: headerName }),
     Schema.Struct({ query: queryName }),
 ]);
-/** How the final request is authorized. OAuth joins this union in slice 3. */
+/**
+ * How the final request is authorized. For `oauth` the owner may bring its own
+ * client (`clientId`, with the client secret as the draft's `secret`); without
+ * one the server's dynamic registration is used.
+ */
 export const credentialSchema = Schema.Union([
     Schema.Struct({ kind: Schema.Literal("none") }),
     Schema.Struct({ kind: Schema.Literal("static"), placement: placementSchema }),
+    Schema.Struct({
+        kind: Schema.Literal("oauth"),
+        scope: Schema.optional(Schema.String),
+        clientId: Schema.optional(Schema.String),
+        /** An operator-registered REST provider; absent for an MCP server's own sign-in. */
+        provider: Schema.optional(Schema.String),
+    }),
 ]);
 /** What the Agent can call. The OpenAPI table is decoded by Forage before it is stored. */
 const surfaceDraftSchema = Schema.Union([
@@ -29,17 +40,21 @@ const surfaceDraftSchema = Schema.Union([
     Schema.Struct({
         kind: Schema.Literal("openapi"),
         baseUrl: Schema.String,
-        table: Schema.Unknown,
+        table: Schema.Array(Schema.Unknown),
     }),
 ]);
 export const toolsSchema = Schema.Union([
     Schema.Literal("all"),
+    /** OpenAPI only: every operation whose stored effect is `read`. */
+    Schema.Struct({ effect: Schema.Literal("read") }),
     Schema.Array(Schema.String.pipe(Schema.check(Schema.isMinLength(1), Schema.isMaxLength(256)))).pipe(Schema.check(Schema.isMaxLength(256))),
 ]);
 export const draftSchema = Schema.Struct({
     /** Idempotency key: a replay with the same request returns the same connection. */
     requestId: identifier,
     name: Schema.String.pipe(Schema.check(Schema.isMinLength(1), Schema.isMaxLength(128))),
+    /** Display text for owners; defaults to the name. */
+    label: Schema.optional(Schema.String.pipe(Schema.check(Schema.isMinLength(1), Schema.isMaxLength(128)))),
     surface: surfaceDraftSchema,
     credential: credentialSchema,
     secret: Schema.optional(Schema.String.pipe(Schema.check(Schema.isPattern(/^[\x21-\x7e]{1,16384}$/u)))),
@@ -49,6 +64,31 @@ export const grantInputSchema = Schema.Struct({
     agentId: identifier,
     tools: toolsSchema,
 });
+/** The authorization server's redirect back to the owner. */
+export const completeInputSchema = Schema.Struct({
+    state: Schema.String.pipe(Schema.check(Schema.isMaxLength(512))),
+    code: Schema.String.pipe(Schema.check(Schema.isMaxLength(4096))),
+    iss: Schema.optional(Schema.String.pipe(Schema.check(Schema.isMaxLength(2048)))),
+});
+/** Owner edits to a live connection, guarded by the version the owner last saw. */
+export const updateInputSchema = Schema.Struct({
+    requestId: identifier,
+    connectionId: identifier,
+    expectedVersion: version,
+    label: Schema.optional(Schema.String.pipe(Schema.check(Schema.isMinLength(1), Schema.isMaxLength(128)))),
+    name: Schema.optional(Schema.String.pipe(Schema.check(Schema.isMinLength(1), Schema.isMaxLength(128)))),
+    /** Replacement OpenAPI operation table, decoded by Forage. */
+    table: Schema.optional(Schema.Array(Schema.Unknown)),
+    baseUrl: Schema.optional(Schema.String),
+    /** Credential swap; `none` and `static` only. */
+    credential: Schema.optional(credentialSchema),
+    secret: Schema.optional(Schema.String.pipe(Schema.check(Schema.isPattern(/^[\x21-\x7e]{1,16384}$/u)))),
+});
+/** One typed OpenAPI operation call. */
+export const callInputSchema = Schema.Struct({
+    operation: Schema.String.pipe(Schema.check(Schema.isMaxLength(256))),
+    input: Schema.Unknown,
+});
 export const egressRefSchema = Schema.Struct({
     connectionId: identifier,
     grantVersion: version,

package/dist/connections/core.d.ts

@@ -1,10 +1,16 @@
 import * as Effect from "effect/Effect";
-import { ConnectionsError, type ConnectionDraft, type GrantInput, type ConnectionsOptions, type EgressRef, type NarrowFetch, type SurfaceView } from "./contract.js";
+import { ConnectionsError, type CallInput, type ConnectionDraft, type Tools, type GrantInput, type ConnectionsOptions, type EgressRef, type NarrowFetch, type SurfaceView } from "./contract.js";
 /** One owner's connections: attempts, connections, grants, receipts and cleanup in its SQLite. */
 export declare function createConnections(options: ConnectionsOptions): {
     begin: (actor: string, input: ConnectionDraft) => Effect.Effect<{
         connectionId: string;
-        authorizeUrl: null;
+        authorizeUrl: string | null;
+    }, ConnectionsError, never>;
+    complete: (actor: string, input: import("./contract.js").CompleteInput) => Effect.Effect<{
+        connectionId: string;
+    }, ConnectionsError, never>;
+    completeCustody: (input: import("./contract.js").CustodyCompletion) => Effect.Effect<{
+        connectionId: string;
     }, ConnectionsError, never>;
     grant: (actor: string, input: GrantInput) => Effect.Effect<{
         grantVersion: number;
@@ -22,7 +28,10 @@ export declare function createConnections(options: ConnectionsOptions): {
             connectionId: string;
             name: string;
             surface: SurfaceView;
-            tools: readonly string[] | "all";
+            tools: readonly string[] | "all" | {
+                readonly effect: "read";
+            };
+            version: number;
             authorityVersion: number;
             grantVersion: number;
         }[];
@@ -30,19 +39,60 @@ export declare function createConnections(options: ConnectionsOptions): {
     list: (actor: string) => Effect.Effect<Readonly<{
         connectionId: string;
         name: string;
+        label: string;
         surface: Readonly<{
             kind: "mcp" | "openapi";
             origin: string;
+            url: string;
+            digest: string | null;
         }>;
         credentialKind: import("./contract.js").Credential["kind"];
-        state: "active" | "reconnect_required" | "revoked";
+        credential: import("./contract.js").Credential;
+        state: "pending" | "active" | "reconnect_required" | "revoked";
+        version: number;
         authorityVersion: number;
         grants: readonly Readonly<{
             agentId: string;
-            tools: import("./contract.js").Tools;
+            tools: Tools;
             version: number;
+            grantor: string;
         }>[];
     }>[], ConnectionsError, never>;
     egress: (agentId: string, input: EgressRef) => NarrowFetch;
+    call: (agentId: string, input: EgressRef, raw: CallInput) => Effect.Effect<import("zod").JSONType, ConnectionsError, never>;
+    ownerCall: (actor: string, at: Readonly<{
+        connectionId: string;
+        expectedVersion: number;
+    }>, raw: CallInput) => Effect.Effect<import("zod").JSONType, ConnectionsError, never>;
+    tools: (actor: string, connectionId: string) => Effect.Effect<readonly string[], ConnectionsError, never>;
+    operations: (actor: string, id: string) => Effect.Effect<{
+        operations: {
+            status: "supported";
+            name: string;
+            method: "GET" | "HEAD" | "OPTIONS" | "POST" | "PUT" | "PATCH" | "DELETE";
+            path: string;
+            effect: "write" | "read";
+            description: string & import("zod").$brand<"ThirdPartyText">;
+            textSource: "third_party";
+            tags: (string & import("zod").$brand<"ThirdPartyText">)[];
+            parameters: {
+                name: string;
+                in: "header" | "path" | "query";
+                required: boolean;
+                schema: boolean | Record<string, import("zod").JSONType>;
+                style?: string | undefined;
+                explode?: boolean | undefined;
+                allowReserved?: boolean | undefined;
+            }[];
+            input: boolean | Record<string, import("zod").JSONType>;
+            output: boolean | Record<string, import("zod").JSONType>;
+        }[];
+        digest: string;
+    }, ConnectionsError, never>;
+    update: (actor: string, raw: import("./contract.js").UpdateInput) => Effect.Effect<{
+        connectionId: string;
+        version: number;
+    }, ConnectionsError, never>;
     sweep: () => Effect.Effect<void, ConnectionsError, never>;
+    cleanupPending: () => number;
 };