@qvac/core 0.0.0 → 0.1.1

package/dist-lib/lib/core/contract/index.js

@@ -0,0 +1,30 @@
+import { registerAgentRoutes } from "./agents.js";
+import { registerApprovalRuleRoutes } from "./approval-rules.js";
+import { registerAttestationRoutes } from "./attestations.js";
+import { registerChatRoutes } from "./chat.js";
+import { registerChatGroupRoutes } from "./chat-group.js";
+import { registerChunkRoutes } from "./chunks.js";
+import { registerDeviceRoutes } from "./devices.js";
+import { registerIndexingRoutes } from "./indexing.js";
+import { registerKnowledgeRoutes } from "./knowledge.js";
+import { registerMemberRoutes } from "./members.js";
+import { registerSeedDefaultsRoutes } from "./seed-defaults.js";
+import { registerToolActivityRoutes } from "./tool-activity.js";
+import { registerToolConfigsRoutes } from "./tool-configs.js";
+import { registerWriterRoutes } from "./writers.js";
+export function registerRoutes(router) {
+    registerWriterRoutes(router);
+    registerChunkRoutes(router);
+    registerAgentRoutes(router);
+    registerChatRoutes(router);
+    registerChatGroupRoutes(router);
+    registerApprovalRuleRoutes(router);
+    registerDeviceRoutes(router);
+    registerKnowledgeRoutes(router);
+    registerIndexingRoutes(router);
+    registerSeedDefaultsRoutes(router);
+    registerToolConfigsRoutes(router);
+    registerToolActivityRoutes(router);
+    registerAttestationRoutes(router);
+    registerMemberRoutes(router);
+}

package/dist-lib/lib/core/contract/indexing.d.ts

@@ -0,0 +1,4 @@
+import type { Router } from '../../../spec/mesh/hyperdispatch/index.js';
+export declare const INDEXING_CLAIM_TTL_MS: number;
+export declare const INDEXING_MAX_CLOCK_SKEW_MS: number;
+export declare function registerIndexingRoutes(router: Router): void;

package/dist-lib/lib/core/contract/indexing.js

@@ -0,0 +1,82 @@
+import { trackActivity } from "./activity.js";
+import { claimSource } from "../files/index.js";
+const INDEXING_STATUS = '@qvac/indexing-status';
+const KNOWLEDGE_ARTIFACTS = '@qvac/knowledge-artifacts';
+export const INDEXING_CLAIM_TTL_MS = 10 * 60 * 1000;
+export const INDEXING_MAX_CLOCK_SKEW_MS = 60 * 60 * 1000;
+export function registerIndexingRoutes(router) {
+    router.add('@qvac/claim-indexing', trackActivity(async (op, { tx, node, log }) => {
+        const knowledge = await claimSource(tx, op.knowledgeId);
+        if (!knowledge || knowledge.deletedAt) {
+            log?.debug('contract', 'claim-indexing dropped: no live knowledge', { id: op.id });
+            return;
+        }
+        const existing = await tx.get(INDEXING_STATUS, { id: op.id });
+        if (existing) {
+            if (existing.status === 'ready') {
+                log?.debug('contract', 'claim-indexing dropped: already ready', { id: op.id });
+                return;
+            }
+            const poisoned = existing.at > op.at + INDEXING_MAX_CLOCK_SKEW_MS;
+            if (!poisoned) {
+                if (existing.status === 'indexing' && existing.expiresAt > op.at) {
+                    log?.debug('contract', 'claim-indexing dropped: live claim', { id: op.id });
+                    return;
+                }
+                if (op.at <= existing.at) {
+                    log?.debug('contract', 'claim-indexing dropped: stale claim', { id: op.id });
+                    return;
+                }
+            }
+        }
+        const claimed = {
+            id: op.id,
+            knowledgeId: op.knowledgeId,
+            chatId: knowledge.chatId,
+            status: 'indexing',
+            claimId: op.claimId,
+            claimedBy: node.key,
+            at: op.at,
+            expiresAt: op.at + INDEXING_CLAIM_TTL_MS
+        };
+        await tx.insert(INDEXING_STATUS, claimed);
+        return claimed;
+    }));
+    router.add('@qvac/resolve-indexing', trackActivity(async (op, { tx, node, log }) => {
+        const existing = await tx.get(INDEXING_STATUS, { id: op.id });
+        if (!existing) {
+            log?.debug('contract', 'resolve-indexing dropped: unknown row', { id: op.id });
+            return;
+        }
+        if (existing.status !== 'indexing') {
+            log?.debug('contract', 'resolve-indexing dropped: not in flight', { id: op.id });
+            return;
+        }
+        if (existing.claimId !== op.claimId || !existing.claimedBy.equals(node.key)) {
+            log?.debug('contract', 'resolve-indexing dropped: not the claim holder', { id: op.id });
+            return;
+        }
+        const knowledge = await claimSource(tx, existing.knowledgeId);
+        if (!knowledge || knowledge.deletedAt) {
+            log?.debug('contract', 'resolve-indexing dropped: no live knowledge', { id: op.id });
+            return;
+        }
+        if (op.status === 'ready') {
+            const artifact = await tx.get(KNOWLEDGE_ARTIFACTS, { id: op.id });
+            if (!artifact || artifact.knowledgeId !== existing.knowledgeId) {
+                log?.debug('contract', 'resolve-indexing dropped: ready without its artifact', {
+                    id: op.id
+                });
+                return;
+            }
+        }
+        const settled = {
+            ...existing,
+            status: op.status,
+            at: existing.at + 1,
+            error: op.status === 'failed' ? (op.error ?? null) : null
+        };
+        await tx.insert(INDEXING_STATUS, settled);
+        return settled;
+    }));
+}

package/dist-lib/lib/core/contract/knowledge.d.ts

@@ -0,0 +1,2 @@
+import type { Router } from '../../../spec/mesh/hyperdispatch/index.js';
+export declare function registerKnowledgeRoutes(router: Router): void;

package/dist-lib/lib/core/contract/knowledge.js

@@ -0,0 +1,55 @@
+import { trackActivity } from "./activity.js";
+import { assertArtifactOutput } from "../files/index.js";
+const CHATS = '@qvac/chats';
+const KNOWLEDGE = '@qvac/knowledge';
+const KNOWLEDGE_ARTIFACTS = '@qvac/knowledge-artifacts';
+export function registerKnowledgeRoutes(router) {
+    router.add('@qvac/add-knowledge', trackActivity(async ({ knowledge }, { tx, log }) => {
+        const chat = await tx.get(CHATS, { id: knowledge.chatId });
+        if (chat?.deletedAt) {
+            log?.debug('contract', 'add-knowledge dropped: chat is deleted', {
+                chatId: knowledge.chatId,
+                id: knowledge.id
+            });
+            return;
+        }
+        const existing = await tx.get(KNOWLEDGE, { id: knowledge.id });
+        if (existing && existing.updatedAt > knowledge.updatedAt) {
+            log?.debug('contract', 'add-knowledge dropped: stale updatedAt', { id: knowledge.id });
+            return;
+        }
+        await tx.insert(KNOWLEDGE, knowledge);
+        return knowledge;
+    }));
+    router.add('@qvac/remove-knowledge', trackActivity(async (op, { tx, log }) => {
+        const existing = await tx.get(KNOWLEDGE, { id: op.knowledgeId });
+        if (!existing) {
+            log?.debug('contract', 'remove-knowledge dropped: unknown knowledge', {
+                id: op.knowledgeId
+            });
+            return;
+        }
+        if (existing.deletedAt)
+            return;
+        const updatedAt = Math.max(existing.updatedAt + 1, op.at);
+        const tombstoned = { ...existing, deletedAt: op.at, updatedAt };
+        await tx.insert(KNOWLEDGE, tombstoned);
+        return tombstoned;
+    }));
+    router.add('@qvac/add-knowledge-artifact', trackActivity(async ({ artifact }, { tx, log }) => {
+        try {
+            assertArtifactOutput(artifact);
+        }
+        catch (error) {
+            log?.debug('contract', 'artifact dropped: invalid output', { id: artifact.id, error });
+            return;
+        }
+        const existing = await tx.get(KNOWLEDGE_ARTIFACTS, {
+            id: artifact.id
+        });
+        if (existing)
+            return;
+        await tx.insert(KNOWLEDGE_ARTIFACTS, artifact);
+        return artifact;
+    }));
+}

package/dist-lib/lib/core/contract/members.d.ts

@@ -0,0 +1,2 @@
+import type { Router } from '../../../spec/mesh/hyperdispatch/index.js';
+export declare function registerMemberRoutes(router: Router): void;

package/dist-lib/lib/core/contract/members.js

@@ -0,0 +1,96 @@
+import { verifyDeviceProof } from "../identity.js";
+import { liveDeviceForWriter, trackActivity } from "./activity.js";
+const DEVICES = '@qvac/devices';
+const MEMBERS = '@qvac/members';
+function link(device, memberId, proof, attestedAt) {
+    return { ...device, memberId, memberProof: proof, attestedAt };
+}
+export function registerMemberRoutes(router) {
+    router.add('@qvac/mint-member', trackActivity(async ({ member, proof }, { tx, node, log }) => {
+        const minter = await liveDeviceForWriter(tx, node.key);
+        if (!minter) {
+            log?.warn('contract', 'mint-member dropped: the writer has no device row');
+            return;
+        }
+        if (minter.memberId) {
+            log?.warn('contract', 'mint-member dropped: the writer is already inside a member');
+            return;
+        }
+        if (await tx.findOne(MEMBERS)) {
+            log?.warn('contract', 'mint-member dropped: the mesh already holds a member');
+            return;
+        }
+        if (!(await verifyDeviceProof(proof, { memberId: member.id, deviceId: minter.id }))) {
+            log?.warn('contract', 'mint-member dropped: the proof does not root the minter at the member');
+            return;
+        }
+        const minted = {
+            id: member.id,
+            name: member.name,
+            joinedAt: member.joinedAt,
+            updatedAt: member.updatedAt
+        };
+        await tx.insert(MEMBERS, minted);
+        await tx.insert(DEVICES, link(minter, member.id, proof, member.joinedAt));
+        log?.info('contract', 'member minted', { id: member.id.toString('hex').slice(0, 16) });
+        return minted;
+    }));
+    router.add('@qvac/update-member', trackActivity(async ({ member }, { tx, node, log }) => {
+        const author = await liveDeviceForWriter(tx, node.key);
+        if (!author?.memberId?.equals(member.id)) {
+            log?.warn('contract', 'update-member dropped: the writer is no device of this member');
+            return;
+        }
+        const existing = await tx.get(MEMBERS, { id: member.id });
+        if (!existing) {
+            log?.debug('contract', 'update-member dropped: unknown member');
+            return;
+        }
+        if (member.updatedAt < existing.updatedAt) {
+            log?.debug('contract', 'update-member dropped: not newer than the stored row');
+            return;
+        }
+        const next = {
+            id: member.id,
+            name: member.name,
+            joinedAt: existing.joinedAt,
+            updatedAt: member.updatedAt
+        };
+        await tx.insert(MEMBERS, next);
+        return next;
+    }));
+    router.add('@qvac/attest-member-device', async (op, { tx, node, log }) => {
+        const device = await tx.get(DEVICES, { id: op.deviceId });
+        if (!device) {
+            log?.debug('contract', 'attest-member-device dropped: unknown device');
+            return;
+        }
+        if (device.memberId && !device.memberId.equals(op.memberId)) {
+            log?.warn('contract', 'attest-member-device dropped: a device may not change member');
+            return;
+        }
+        const signer = await liveDeviceForWriter(tx, node.key);
+        const speaksForMember = signer?.memberId?.equals(op.memberId) || signer?.id.equals(op.deviceId);
+        if (!speaksForMember) {
+            log?.warn('contract', 'attest-member-device dropped: the writer speaks for another member');
+            return;
+        }
+        const member = await tx.get(MEMBERS, { id: op.memberId });
+        if (!member) {
+            log?.debug('contract', 'attest-member-device dropped: no member row to attest into');
+            return;
+        }
+        if (!(await verifyDeviceProof(op.proof, { memberId: op.memberId, deviceId: op.deviceId }))) {
+            log?.warn('contract', 'attest-member-device dropped: the proof does not stand');
+            return;
+        }
+        if (device.memberId?.equals(op.memberId) && op.attestedAt <= (device.attestedAt || 0)) {
+            log?.debug('contract', 'attest-member-device dropped: not newer than the stored attestation');
+            return;
+        }
+        await tx.insert(DEVICES, link(device, op.memberId, op.proof, op.attestedAt));
+        log?.info('contract', 'device attested to a member', {
+            id: op.deviceId.toString('hex').slice(0, 16)
+        });
+    });
+}

package/dist-lib/lib/core/contract/seed-defaults.d.ts

@@ -0,0 +1,2 @@
+import type { Router } from '../../../spec/mesh/hyperdispatch/index.js';
+export declare function registerSeedDefaultsRoutes(router: Router): void;

package/dist-lib/lib/core/contract/seed-defaults.js

@@ -0,0 +1,29 @@
+import { trackActivity } from "./activity.js";
+const AGENTS = '@qvac/agents';
+const CHATS = '@qvac/chats';
+const MESH_BLIND_PEERS = '@qvac/mesh-blind-peers';
+export function registerSeedDefaultsRoutes(router) {
+    router.add('@qvac/seed-defaults', trackActivity(async (op, { tx, log }) => {
+        let seeded = false;
+        if (!(await tx.get(AGENTS, { id: op.agent.id }))) {
+            await tx.insert(AGENTS, op.agent);
+            log?.info('contract', 'seeded default agent', {
+                id: op.agent.id,
+                model: op.agent.modelName
+            });
+            seeded = true;
+        }
+        if (!(await tx.get(CHATS, { id: op.chat.id }))) {
+            await tx.insert(CHATS, op.chat);
+            log?.info('contract', 'seeded first chat', { id: op.chat.id });
+            seeded = true;
+        }
+        for (const peer of op.blindPeers ?? []) {
+            if (!(await tx.get(MESH_BLIND_PEERS, { key: peer.key }))) {
+                await tx.insert(MESH_BLIND_PEERS, peer);
+                seeded = true;
+            }
+        }
+        return seeded;
+    }));
+}

package/dist-lib/lib/core/contract/tool-activity.d.ts

@@ -0,0 +1,2 @@
+import type { Router } from '../../../spec/mesh/hyperdispatch/index.js';
+export declare function registerToolActivityRoutes(router: Router): void;

package/dist-lib/lib/core/contract/tool-activity.js

@@ -0,0 +1,25 @@
+import { capToolActivityArguments } from "../../../schema/qvac.js";
+const TOOL_ACTIVITY = '@qvac/tool-activity';
+const TOOL_ACTIVITY_COUNTERS = '@qvac/tool-activity-counter';
+export function registerToolActivityRoutes(router) {
+    router.add('@qvac/append-tool-activity', async ({ activity }, { tx, log }) => {
+        const existing = await tx.get(TOOL_ACTIVITY, { id: activity.id });
+        if (existing)
+            return;
+        const counter = await tx.get(TOOL_ACTIVITY_COUNTERS, {
+            agentId: activity.agentId
+        });
+        const seq = (counter?.count ?? 0) + 1;
+        const capped = capToolActivityArguments(activity.arguments);
+        await tx.insert(TOOL_ACTIVITY_COUNTERS, {
+            agentId: activity.agentId,
+            count: seq
+        });
+        await tx.insert(TOOL_ACTIVITY, { ...activity, arguments: capped, seq });
+        log?.debug('contract', 'tool activity recorded', {
+            agentId: activity.agentId,
+            toolName: activity.toolName,
+            decision: activity.decision
+        });
+    });
+}

package/dist-lib/lib/core/contract/tool-configs.d.ts

@@ -0,0 +1,2 @@
+import type { Router } from '../../../spec/mesh/hyperdispatch/index.js';
+export declare function registerToolConfigsRoutes(router: Router): void;

package/dist-lib/lib/core/contract/tool-configs.js

@@ -0,0 +1,50 @@
+import { toolConfigsWithinBounds } from "../../../schema/qvac.js";
+import { toolConfigsCarrySecret } from "../tool-configs.js";
+import { trackActivity } from "./activity.js";
+const TOOL_CONFIGS = '@qvac/tool-configs';
+const AGENTS = '@qvac/agents';
+export function registerToolConfigsRoutes(router) {
+    router.add('@qvac/put-tool-configs', trackActivity(async ({ settings }, { tx, log }) => {
+        if (!toolConfigsWithinBounds(settings.settings)) {
+            log?.debug('contract', 'put-tool-configs dropped: settings exceed the wire cap', {
+                agentId: settings.agentId,
+                toolName: settings.toolName
+            });
+            return;
+        }
+        if (toolConfigsCarrySecret(settings.settings)) {
+            log?.debug('contract', 'put-tool-configs dropped: settings carry a replicated secret', {
+                agentId: settings.agentId,
+                toolName: settings.toolName
+            });
+            return;
+        }
+        const existing = await tx.get(TOOL_CONFIGS, {
+            agentId: settings.agentId,
+            toolName: settings.toolName
+        });
+        if (existing && existing.updatedAt > settings.updatedAt) {
+            log?.debug('contract', 'put-tool-configs dropped: stale updatedAt', {
+                agentId: settings.agentId,
+                toolName: settings.toolName
+            });
+            return;
+        }
+        if (!settings.deletedAt) {
+            const agent = await tx.get(AGENTS, { id: settings.agentId });
+            if (!agent || agent.deletedAt) {
+                log?.debug('contract', 'put-tool-configs dropped: agent missing or deleted', {
+                    agentId: settings.agentId,
+                    toolName: settings.toolName
+                });
+                return;
+            }
+        }
+        await tx.insert(TOOL_CONFIGS, settings);
+        log?.debug('contract', existing ? 'tool configs updated' : 'tool configs created', {
+            agentId: settings.agentId,
+            toolName: settings.toolName
+        });
+        return settings;
+    }));
+}

package/dist-lib/lib/core/contract/types.d.ts

@@ -0,0 +1,11 @@
+import type { AutobeeHost, AutobeeNode } from 'autobee';
+import type HyperDB from 'hyperdb';
+import type { Logger } from '../../log.ts';
+export interface RouterContext {
+    readonly tx: HyperDB;
+    readonly host: AutobeeHost;
+    readonly node: AutobeeNode;
+    readonly meshPublicKey: Buffer;
+    readonly meshDevicePublicKey: Buffer;
+    readonly log: Logger | null;
+}

package/dist-lib/lib/core/contract/types.js

@@ -0,0 +1 @@
+export {};

package/dist-lib/lib/core/contract/writers.d.ts

@@ -0,0 +1,2 @@
+import type { Router } from '../../../spec/mesh/hyperdispatch/index.js';
+export declare function registerWriterRoutes(router: Router): void;

package/dist-lib/lib/core/contract/writers.js

@@ -0,0 +1,112 @@
+import crypto from 'hypercore-crypto';
+import { markWriterRevoked, trackActivity } from "./activity.js";
+const DEVICES = '@qvac/devices';
+async function admitDevice({ tx, log }, id, device, writerKey) {
+    const existing = await tx.get(DEVICES, { id });
+    if (!device) {
+        if (!existing)
+            return 'writer-only';
+        log?.debug('contract', 'admission refused: no profile to weigh against the existing row');
+        return 'refused';
+    }
+    if (existing &&
+        (existing.revoked ? device.joinedAt <= existing.joinedAt : device.joinedAt < existing.joinedAt)) {
+        log?.debug('contract', 'admission refused: claim is not newer than the device row');
+        return 'refused';
+    }
+    const alreadyAdmitted = existing && !existing.revoked && existing.writerKey?.equals(writerKey) === true;
+    await tx.insert(DEVICES, {
+        ...existing,
+        name: device.name,
+        joinedAt: device.joinedAt,
+        capabilityProfile: device.capabilityProfile,
+        recommendedModelName: device.recommendedModelName,
+        installedToolNames: device.installedToolNames ?? existing?.installedToolNames,
+        installedSkillNames: device.installedSkillNames ?? existing?.installedSkillNames,
+        installedModelNames: device.installedModelNames ?? existing?.installedModelNames,
+        cachedModelNames: device.cachedModelNames ?? existing?.cachedModelNames,
+        readySkillNames: device.readySkillNames ?? existing?.readySkillNames,
+        appVersion: device.appVersion ?? existing?.appVersion,
+        appBuild: device.appBuild ?? existing?.appBuild,
+        appChannel: device.appChannel ?? existing?.appChannel,
+        platform: device.platform ?? existing?.platform,
+        id,
+        writerKey,
+        revoked: false,
+        revokedAt: 0,
+        revokedBy: null
+    });
+    if (existing?.writerKey && !existing.writerKey.equals(writerKey)) {
+        await markWriterRevoked(tx, existing.writerKey, true);
+    }
+    await markWriterRevoked(tx, writerKey, false);
+    if (!alreadyAdmitted) {
+        log?.info('contract', 'device admitted', { id: id.toString('hex').slice(0, 16) });
+    }
+    return 'admitted';
+}
+export function registerWriterRoutes(router) {
+    router.add('@qvac/add-writer', trackActivity(async (payload, context) => {
+        if (!payload.device) {
+            await context.host.addWriter(payload.writerKey);
+            return;
+        }
+        const admission = await admitDevice(context, payload.device.id, payload.device, payload.writerKey);
+        if (admission !== 'admitted')
+            return;
+        await context.host.addWriter(payload.writerKey);
+        return payload.device;
+    }));
+    router.add('@qvac/remove-writer', trackActivity(async (payload, context) => {
+        await context.host.removeWriter(payload.writerKey);
+        const id = payload.deviceId;
+        if (!id)
+            return;
+        const existing = await context.tx.get(DEVICES, { id });
+        if (!existing) {
+            context.log?.debug('contract', 'remove-writer: no device row to revoke');
+            return;
+        }
+        if (existing.writerKey && !existing.writerKey.equals(payload.writerKey)) {
+            context.log?.debug('contract', 'remove-writer dropped: writer key already superseded');
+            return;
+        }
+        const revoked = {
+            ...existing,
+            revoked: true,
+            revokedAt: payload.revokedAt ?? 0,
+            revokedBy: context.node.key
+        };
+        await context.tx.insert(DEVICES, revoked);
+        await markWriterRevoked(context.tx, payload.writerKey, true);
+        context.log?.info('contract', 'writer removed, device revoked', {
+            id: id.toString('hex').slice(0, 16)
+        });
+        if (context.node.key.equals(payload.writerKey))
+            return;
+        return revoked;
+    }));
+    router.add('@qvac/join', trackActivity(async (payload, context) => {
+        let valid = false;
+        try {
+            valid = crypto.verify(context.node.key, payload.signature, context.meshPublicKey);
+        }
+        catch {
+            valid = false;
+        }
+        if (!valid) {
+            context.log?.warn('contract', 'join dropped: invalid writer-claim signature');
+            return;
+        }
+        const id = payload.deviceId;
+        if (!id) {
+            await context.host.addWriter(context.node.key);
+            return;
+        }
+        const admission = await admitDevice(context, id, payload.device, context.node.key);
+        if (admission === 'refused')
+            return;
+        await context.host.addWriter(context.node.key);
+        return admission === 'admitted' ? payload.device : null;
+    }));
+}

package/dist-lib/lib/core/cpu-info-node.d.ts

@@ -0,0 +1,3 @@
+import type CPUInfo from 'bare-cpu-info';
+declare const ctor: (new () => CPUInfo) | null;
+export default ctor;

package/dist-lib/lib/core/cpu-info-node.js

@@ -0,0 +1,2 @@
+const ctor = null;
+export default ctor;

package/dist-lib/lib/core/departures.d.ts

@@ -0,0 +1,41 @@
+import type Corestore from 'corestore';
+import type Hyperswarm from 'hyperswarm';
+import type Wakeup from 'protomux-wakeup';
+import type { Logger } from '../../index.ts';
+import type { LocalMeshDeparture } from '../../spec/local/hyperschema/types.d.ts';
+import type { BlindPeeringOpts } from './blind-peers.ts';
+interface DepartureRows {
+    departures(): Promise<LocalMeshDeparture[]>;
+    deleteDeparture(key: Buffer): Promise<void>;
+}
+export interface PendingDeparturesOptions {
+    swarm: Hyperswarm;
+    logger?: Logger | null;
+    blindPeerKeys?: ReadonlyArray<Buffer>;
+    blindPeeringOpts?: BlindPeeringOpts;
+    wakeup?: Wakeup;
+}
+export declare class PendingDepartures {
+    private readonly _store;
+    private readonly _local;
+    private readonly _swarm;
+    private readonly _log;
+    private readonly _blindPeerKeys;
+    private readonly _blindPeeringOpts;
+    private readonly _wakeup;
+    private readonly _active;
+    private readonly _parked;
+    private readonly _lock;
+    private _closing;
+    constructor(store: Corestore, local: DepartureRows, opts: PendingDeparturesOptions);
+    flush(activeKey?: Buffer | null): void;
+    private _flush;
+    private _deliver;
+    park(key: Buffer): Promise<void>;
+    unpark(key: Buffer): void;
+    drop(key: Buffer): Promise<void>;
+    suspend(): Promise<void>;
+    resume(): Promise<void>;
+    close(): Promise<void>;
+}
+export {};