@qvac/core 0.0.0 → 0.1.0

package/dist-lib/lib/core/membership.js

@@ -0,0 +1,40 @@
+import { attestDeviceProof } from "./identity.js";
+export async function membershipView(mesh, deviceId) {
+    const snap = mesh.view.snapshot();
+    try {
+        let members = 0;
+        let own = null;
+        const unattested = [];
+        for await (const _member of snap.find('@qvac/members'))
+            members++;
+        for await (const device of snap.find('@qvac/devices')) {
+            if (device.id.equals(deviceId))
+                own = device;
+            else if (!device.revoked && !device.memberId)
+                unattested.push(device.id);
+        }
+        return { members, own, unattested };
+    }
+    finally {
+        await snap.close();
+    }
+}
+export async function attestUnattestedDevices(mesh, { deviceKeyPair, log }) {
+    const { own, unattested } = await membershipView(mesh, deviceKeyPair.publicKey);
+    if (!own?.memberId || !own.memberProof || unattested.length === 0)
+        return;
+    const now = Date.now();
+    const batch = mesh.batch();
+    for (const id of unattested) {
+        batch.dispatch('attest-member-device', {
+            deviceId: id,
+            memberId: own.memberId,
+            proof: await attestDeviceProof(id, deviceKeyPair, own.memberProof),
+            attestedAt: now
+        });
+    }
+    await batch.flush();
+    log?.info(['p2p', 'mesh'], 'every device we hold is attested to our member', {
+        attested: unattested.length
+    });
+}

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

@@ -0,0 +1,153 @@
+import Autobee, { type AutobeeChanges, type AutobeeHost, type AutobeeNode, type AutobeeOplogRef } from 'autobee';
+import Corestore from 'corestore';
+import HyperDB from 'hyperdb';
+import Hyperblobs from 'hyperblobs';
+import type Wakeup from 'protomux-wakeup';
+import ReadyResource from 'ready-resource';
+import { Files } from './files/index.ts';
+import type { Logger } from '../../index.ts';
+import { Router } from '../../spec/mesh/hyperdispatch/index.js';
+import type { QvacCapabilityProfile, QvacMember } from '../../spec/mesh/hyperschema/types.d.ts';
+import type { BlindPeeringOpts } from './blind-peers.ts';
+import type { AttachmentUrl } from './attachment-link.ts';
+import { type DeviceAttestation } from './device-attestation.ts';
+import { type SyncActivity } from './sync-status.ts';
+export interface MeshView {
+    readonly db: HyperDB;
+}
+export interface DeviceMetadata {
+    readonly name: string;
+    readonly capabilityProfile: QvacCapabilityProfile;
+    readonly recommendedModelName: string;
+    readonly platform?: string;
+}
+export interface OrphanedBlobSweepStatus {
+    readonly state: 'pending' | 'running' | 'succeeded' | 'failed';
+    readonly error?: string;
+}
+export interface MeshOptions {
+    seed?: Buffer;
+    key?: Buffer | null;
+    writerSeed?: string;
+    deviceId?: Buffer;
+    logger?: Logger | null;
+    blindPeerKeys?: ReadonlyArray<Buffer>;
+    blindPeeringOpts?: BlindPeeringOpts;
+    bootFrom?: AutobeeOplogRef | null;
+    wakeup?: Wakeup;
+    attachmentUrl?: AttachmentUrl | null;
+}
+export declare function isOurTrustedWriter(snap: HyperDB, writerKey: Buffer, ourMemberId: Buffer | null): Promise<boolean>;
+export type BirthRow = {
+    readonly id: Buffer;
+    readonly joinedAt: number;
+} & DeviceMetadata;
+export interface BirthMember {
+    readonly member: QvacMember;
+    readonly proof: Buffer;
+}
+export interface MembershipStats {
+    readonly members: number;
+    readonly attested: number;
+    readonly unattested: number;
+    readonly revoked: number;
+}
+export declare function claimableDevice(row: BirthRow): {
+    id: Buffer<ArrayBufferLike>;
+    joinedAt: number;
+    name: string;
+    capabilityProfile: QvacCapabilityProfile;
+    recommendedModelName: string;
+};
+export declare class Mesh extends ReadyResource {
+    private _files;
+    get files(): Files;
+    private readonly _store;
+    private readonly _seed;
+    private readonly _key;
+    private readonly _writerSeed;
+    private readonly _log;
+    private readonly _blindPeerKeys;
+    private readonly _blindPeeringOpts;
+    private readonly _bootFrom;
+    private readonly _wakeup;
+    readonly attachmentUrl: AttachmentUrl | null;
+    private readonly _scope;
+    readonly router: Router;
+    private readonly _keyPair;
+    private readonly _deviceKeyPair;
+    private readonly _encryptionKey;
+    private _blindPeering;
+    private _orphanedBlobSweepStatus;
+    private _bootInterrupted;
+    private _localWriterUploadedLength;
+    private _ourMemberId;
+    private _membership;
+    private readonly _deviceId;
+    autobee: Autobee<MeshView>;
+    blobs: Hyperblobs;
+    readonly discoveryKey: Buffer;
+    syncActivity: SyncActivity;
+    get publicKey(): Buffer;
+    get devicePublicKey(): Buffer;
+    get key(): Buffer;
+    get encryptionKey(): Buffer;
+    get blindPeerKeys(): ReadonlyArray<Buffer>;
+    get orphanedBlobSweepStatus(): OrphanedBlobSweepStatus;
+    blindPeerStats(): Array<{
+        key: string;
+        connected: boolean;
+        connects: number;
+        uploaded: number;
+    }>;
+    get ourMemberId(): Buffer | null;
+    get membership(): MembershipStats;
+    refreshMembership(): Promise<void>;
+    refreshOurMember(): Promise<void>;
+    sign(message: Buffer): Buffer;
+    attestDevice(deviceId: Buffer): DeviceAttestation;
+    constructor(store: Corestore, opts?: MeshOptions);
+    _open(): Promise<void>;
+    startBlindPeering(dht: unknown): void;
+    openBlobs(coreKey: Buffer): Promise<Hyperblobs>;
+    interruptBoot(): void;
+    _close(): Promise<void>;
+    private _sweepOrphanedBlobs;
+    get view(): HyperDB;
+    get localWriterKey(): Buffer<ArrayBufferLike>;
+    get writable(): boolean;
+    get localLength(): number;
+    dispatch(name: string, payload: unknown, opts?: {
+        optimistic?: boolean;
+    }): Promise<void>;
+    batch(): MeshBatch;
+    appendBirthOp(deviceId: Buffer, device?: DeviceMetadata, member?: BirthMember): Promise<void>;
+    get interrupted(): unknown;
+    throwIfInterrupted(): void;
+    waitForWritable(): Promise<void>;
+    pendingUploads(): number;
+    suspend(): Promise<void>;
+    resume(): Promise<void>;
+    watch(listener: () => void): void;
+    unwatch(listener: () => void): void;
+    _autobeeIsTrusted(key: Buffer, reference: MeshView): Promise<boolean>;
+    _autobeeMostRecentTrusted(target: MeshView, reference: MeshView | null): Promise<AutobeeOplogRef | null>;
+    _autobeeOpen(bee: unknown): MeshView;
+    _autobeeApply(nodes: ReadonlyArray<AutobeeNode>, view: MeshView, host: AutobeeHost): Promise<void>;
+    private _halt;
+    _autobeeUpdate(view: MeshView, changes: AutobeeChanges): Promise<void>;
+    checkResumedRevocation(): Promise<'kicked' | 'left' | null>;
+}
+export interface MeshDispatcher {
+    dispatch(name: string, payload: unknown): void | Promise<void>;
+}
+export declare class MeshBatch {
+    private readonly _autobee;
+    private _ops;
+    constructor(autobee: Autobee<MeshView>);
+    get size(): number;
+    dispatch(name: string, payload: unknown): void;
+    flush(opts?: {
+        optimistic?: boolean;
+    }): Promise<void>;
+}

package/dist-lib/lib/core/mesh.js

@@ -0,0 +1,509 @@
+import Autobee, {} from 'autobee';
+import BlindPeering from 'blind-peering';
+import Corestore from 'corestore';
+import HyperDB from 'hyperdb';
+import { ERRORS } from 'hyperdispatch/runtime';
+import Hyperblobs from 'hyperblobs';
+import crypto from 'hypercore-crypto';
+import ReadyResource from 'ready-resource';
+import { Files } from "./files/index.js";
+import MeshDefinition from '../../spec/mesh/hyperdb/index.js';
+import { Router, encode } from '../../spec/mesh/hyperdispatch/index.js';
+import { syncChanges } from "./sync/index.js";
+import { buildDefaultSeed, isOwnKickedRow, isOwnRevokedRow } from "./helpers/index.js";
+import { raceResource } from "../race-resource.js";
+import { signDeviceAttestation } from "./device-attestation.js";
+import { liveDeviceForWriter } from "./contract/activity.js";
+import { registerRoutes } from "./contract/index.js";
+import { createSyncActivity } from "./sync-status.js";
+import { buildHealthAssistant } from "./health-assistant.js";
+const [MESH_KEYPAIR, MESH_ENCRYPTION, MESH_DEVICE] = crypto.namespace('@qvac/core/mesh', 3);
+const LIVE_WRITERS_BY_MOST_RECENT = '@qvac/live-writers-by-most-recent';
+export async function isOurTrustedWriter(snap, writerKey, ourMemberId) {
+    const device = await liveDeviceForWriter(snap, writerKey);
+    if (!device)
+        return false;
+    if (!ourMemberId)
+        return true;
+    return device.memberId?.equals(ourMemberId) === true;
+}
+export function claimableDevice(row) {
+    return {
+        id: row.id,
+        joinedAt: row.joinedAt,
+        name: row.name,
+        capabilityProfile: row.capabilityProfile,
+        recommendedModelName: row.recommendedModelName
+    };
+}
+export class Mesh extends ReadyResource {
+    _files = null;
+    get files() {
+        this._files ??= new Files(this);
+        return this._files;
+    }
+    _store;
+    _seed;
+    _key;
+    _writerSeed;
+    _log;
+    _blindPeerKeys;
+    _blindPeeringOpts;
+    _bootFrom;
+    _wakeup;
+    attachmentUrl;
+    _scope;
+    router;
+    _keyPair;
+    _deviceKeyPair;
+    _encryptionKey;
+    _blindPeering = null;
+    _orphanedBlobSweepStatus = { state: 'pending' };
+    _bootInterrupted = false;
+    _localWriterUploadedLength = 0;
+    _ourMemberId = null;
+    _membership = {
+        members: 0,
+        attested: 0,
+        unattested: 0,
+        revoked: 0
+    };
+    _deviceId;
+    autobee;
+    blobs;
+    discoveryKey;
+    syncActivity;
+    get publicKey() {
+        return this._keyPair.publicKey;
+    }
+    get devicePublicKey() {
+        return this._deviceKeyPair.publicKey;
+    }
+    get key() {
+        return this.autobee.key;
+    }
+    get encryptionKey() {
+        return this._encryptionKey;
+    }
+    get blindPeerKeys() {
+        return this._blindPeerKeys;
+    }
+    get orphanedBlobSweepStatus() {
+        return this._orphanedBlobSweepStatus;
+    }
+    blindPeerStats() {
+        const peering = this._blindPeering;
+        if (!peering?.blindPeers)
+            return [];
+        return [...peering.blindPeers.values()].map((bp) => ({
+            key: bp.remotePublicKey.toString('hex').slice(0, 16),
+            connected: bp.connected,
+            connects: bp.connects,
+            uploaded: bp.uploaded
+        }));
+    }
+    get ourMemberId() {
+        return this._ourMemberId;
+    }
+    get membership() {
+        return this._membership;
+    }
+    async refreshMembership() {
+        const snap = this.view.snapshot();
+        try {
+            let members = 0;
+            let attested = 0;
+            let unattested = 0;
+            let revoked = 0;
+            for await (const _member of snap.find('@qvac/members'))
+                members++;
+            for await (const device of snap.find('@qvac/devices')) {
+                if (device.revoked)
+                    revoked++;
+                else if (device.memberId)
+                    attested++;
+                else
+                    unattested++;
+            }
+            this._membership = {
+                members,
+                attested,
+                unattested,
+                revoked
+            };
+        }
+        finally {
+            await snap.close();
+        }
+    }
+    async refreshOurMember() {
+        if (!this._deviceId)
+            return;
+        const own = await this.view.get('@qvac/devices', { id: this._deviceId });
+        this._ourMemberId = own?.memberId ?? null;
+        if (own?.memberId && own.memberProof)
+            this.emit('membership', own);
+    }
+    sign(message) {
+        return crypto.sign(message, this._keyPair.secretKey);
+    }
+    attestDevice(deviceId) {
+        return signDeviceAttestation(this._deviceKeyPair.secretKey, deviceId);
+    }
+    constructor(store, opts = {}) {
+        super();
+        this._store = store;
+        this._seed = opts.seed ?? crypto.randomBytes(32);
+        this._key = opts.key ?? null;
+        this._writerSeed = opts.writerSeed;
+        this._log = opts.logger ?? null;
+        this._blindPeerKeys = opts.blindPeerKeys ?? [];
+        this._blindPeeringOpts = opts.blindPeeringOpts;
+        this._bootFrom = opts.bootFrom;
+        this._deviceId = opts.deviceId ?? null;
+        this._wakeup = opts.wakeup;
+        this.attachmentUrl = opts.attachmentUrl ?? null;
+        this.router = new Router();
+        this._keyPair = crypto.keyPair(crypto.hash([MESH_KEYPAIR, this._seed]));
+        this._deviceKeyPair = crypto.keyPair(crypto.hash([MESH_DEVICE, this._seed]));
+        this._encryptionKey = crypto.hash([MESH_ENCRYPTION, this._seed]);
+        this.discoveryKey = crypto.discoveryKey(this._keyPair.publicKey);
+        this._scope = ['p2p', 'mesh', this._keyPair.publicKey.toString('hex').slice(0, 8)];
+        registerRoutes(this.router);
+    }
+    async _open() {
+        this._log?.info(this._scope, 'opening');
+        const namespace = this._store.namespace(this.discoveryKey);
+        const blobCore = namespace.get({ name: 'qvac-blobs', encryptionKey: this._encryptionKey });
+        this.blobs = new Hyperblobs(blobCore);
+        try {
+            await raceResource(this.blobs.core, this.blobs.ready(), 'blobs');
+            this._log?.info(this._scope, 'blob store opened');
+            const writerKeyPair = await namespace.createKeyPair(this._writerSeed ?? 'local');
+            this.autobee = new Autobee(namespace, this._key, {
+                open: this._autobeeOpen.bind(this),
+                apply: this._autobeeApply.bind(this),
+                update: this._autobeeUpdate.bind(this),
+                isTrusted: this._autobeeIsTrusted.bind(this),
+                mostRecentTrusted: this._autobeeMostRecentTrusted.bind(this),
+                keyPair: writerKeyPair,
+                encrypted: true,
+                encryptionKey: this._encryptionKey,
+                wakeupCapability: { key: this._keyPair.publicKey, discoveryKey: this.discoveryKey },
+                wakeup: this._wakeup,
+                fastForward: { boot: this._bootFrom ? { head: this._bootFrom } : null }
+            });
+            this.autobee.on('error', (err) => this._log?.warn(this._scope, 'autobee error', err));
+            this.autobee.on('move-to', (to, from) => this._log?.info(this._scope, 'fast-forwarded onto a head', {
+                from: from?.length ?? 0,
+                to: to?.length ?? 0,
+                fastForwards: this.autobee.stats.fastForwards
+            }));
+            this.autobee.on('interrupt', (err) => this._log?.warn(this._scope, 'autobee interrupt', err));
+            if (this._bootInterrupted)
+                void this.autobee.close().catch(noop);
+            await raceResource(this.autobee, this.autobee.ready(), 'autobee');
+        }
+        catch (err) {
+            await this.autobee?.close().catch(noop);
+            await this.blobs.close().catch(noop);
+            throw err;
+        }
+        this.autobee.local.on('upload', (index) => {
+            this._localWriterUploadedLength = Math.max(this._localWriterUploadedLength, index + 1);
+        });
+        this.syncActivity = createSyncActivity(this);
+        void this.refreshOurMember().catch((err) => this._log?.warn(this._scope, 'reading our member failed', err));
+        this._log?.info(this._scope, 'autobee opened', {
+            writable: this.autobee.writable,
+            creator: this._key === null
+        });
+        void this._sweepOrphanedBlobs(this.blobs.core.length);
+        this.files.start({ deviceId: this._deviceId });
+    }
+    startBlindPeering(dht) {
+        if (this.closing || !this.autobee || !this.blobs)
+            return;
+        this._blindPeering = new BlindPeering(dht, this._store, {
+            pick: 2,
+            wakeup: this._wakeup,
+            ...this._blindPeeringOpts
+        });
+        this._blindPeering.addAutobaseBackground(this.autobee, {
+            target: this._keyPair.publicKey,
+            keys: this._blindPeerKeys
+        });
+        this._blindPeering.addCoreBackground(this.blobs.core, {
+            target: this._keyPair.publicKey,
+            keys: this._blindPeerKeys
+        });
+        this._log?.info(this._scope, 'blind peering started');
+    }
+    async openBlobs(coreKey) {
+        const core = this._store.get({ key: coreKey, encryptionKey: this._encryptionKey });
+        const blobs = new Hyperblobs(core);
+        await blobs.ready();
+        return blobs;
+    }
+    interruptBoot() {
+        this._bootInterrupted = true;
+        if (this.autobee)
+            void this.autobee.close().catch(noop);
+    }
+    async _close() {
+        this._log?.info(this._scope, 'closing');
+        await this._files?.close();
+        await Promise.all([this.autobee.close(), this.blobs.close(), this._blindPeering?.close()]);
+        this._blindPeering = null;
+    }
+    async _sweepOrphanedBlobs(blobLength) {
+        this._orphanedBlobSweepStatus = { state: 'running' };
+        try {
+            await this.autobee.update();
+            await this.files.sweepOrphans(blobLength);
+            this._orphanedBlobSweepStatus = { state: 'succeeded' };
+            this._log?.info(this._scope, 'orphaned blob sweep finished');
+        }
+        catch (err) {
+            if (this.closing)
+                return;
+            const error = err instanceof Error ? err.message : String(err);
+            this._orphanedBlobSweepStatus = { state: 'failed', error };
+            this._log?.warn(this._scope, 'orphaned blob sweep failed', err);
+        }
+    }
+    get view() {
+        return this.autobee.view.db;
+    }
+    get localWriterKey() {
+        return this.autobee.local.key;
+    }
+    get writable() {
+        return this.autobee.writable;
+    }
+    get localLength() {
+        return this.autobee.local.length;
+    }
+    async dispatch(name, payload, opts) {
+        await this.autobee.append(encode(`@qvac/${name}`, payload), opts);
+    }
+    batch() {
+        return new MeshBatch(this.autobee);
+    }
+    async appendBirthOp(deviceId, device, member) {
+        if (this.autobee.local.length > 0)
+            return;
+        const localKey = this.autobee.local.key;
+        const row = device
+            ? { id: deviceId, joinedAt: Date.now(), ...device }
+            : undefined;
+        if (this._key === null) {
+            const birth = this.batch();
+            birth.dispatch('add-writer', { writerKey: localKey, device: row });
+            if (row) {
+                birth.dispatch('attest-device', this.attestDevice(deviceId));
+                if (member)
+                    birth.dispatch('mint-member', member);
+                birth.dispatch('seed-defaults', buildDefaultSeed(row, this._blindPeerKeys));
+                birth.dispatch('put-agent', { agent: buildHealthAssistant(row) });
+            }
+            await birth.flush();
+        }
+        else if (!this.autobee.writable) {
+            const signature = this.sign(localKey);
+            const device = row ? claimableDevice(row) : undefined;
+            const claim = this.batch();
+            claim.dispatch('join', { signature, deviceId, device });
+            if (row)
+                claim.dispatch('attest-device', this.attestDevice(deviceId));
+            await claim.flush({ optimistic: true });
+        }
+        await this.autobee.update();
+        this.throwIfInterrupted();
+    }
+    get interrupted() {
+        return this.autobee.interrupted;
+    }
+    throwIfInterrupted() {
+        if (this.interrupted)
+            throw this.interrupted;
+    }
+    async waitForWritable() {
+        if (this.closing || this.autobee.writable)
+            return;
+        await new Promise((resolve) => {
+            const done = () => {
+                this.autobee.off('writable', done);
+                this.off('close', done);
+                resolve();
+            };
+            this.autobee.on('writable', done);
+            this.on('close', done);
+        });
+    }
+    pendingUploads() {
+        const peers = this.autobee.local.peers;
+        if (this.closing || peers.length === 0)
+            return 0;
+        const taken = Math.max(this._localWriterUploadedLength, ...peers.map((peer) => peer.remoteLength));
+        return Math.max(0, this.autobee.local.length - taken);
+    }
+    async suspend() {
+        await this._files?.suspend();
+        if (this._blindPeering)
+            await this._blindPeering.suspend();
+    }
+    async resume() {
+        if (this._blindPeering)
+            await this._blindPeering.resume();
+        this._files?.resume();
+    }
+    watch(listener) {
+        this.view.watch(listener);
+    }
+    unwatch(listener) {
+        this.view.unwatch(listener);
+    }
+    async _autobeeIsTrusted(key, reference) {
+        if (this.closing)
+            return false;
+        const snap = reference.db.snapshot();
+        try {
+            const trusted = await isOurTrustedWriter(snap, key, this._ourMemberId);
+            if (!trusted) {
+                this._log?.debug(this._scope, 'writer is no device of ours', {
+                    writerKey: key.toString('hex').slice(0, 16)
+                });
+            }
+            return trusted;
+        }
+        finally {
+            await snap.close();
+        }
+    }
+    async _autobeeMostRecentTrusted(target, reference) {
+        if (this.closing)
+            return null;
+        const snap = (reference ?? target).db.snapshot();
+        try {
+            for await (const writer of target.db.find(LIVE_WRITERS_BY_MOST_RECENT, {
+                reverse: true
+            })) {
+                if (await isOurTrustedWriter(snap, writer.writerKey, this._ourMemberId)) {
+                    this._log?.debug(this._scope, 'vouching for a head', {
+                        writerKey: writer.writerKey.toString('hex').slice(0, 16),
+                        length: writer.length
+                    });
+                    return { key: writer.writerKey, length: writer.length };
+                }
+            }
+            this._log?.debug(this._scope, 'vouching for no head: no writer of ours has been active');
+            return null;
+        }
+        finally {
+            await snap.close();
+        }
+    }
+    _autobeeOpen(bee) {
+        const db = HyperDB.bee2(bee, MeshDefinition, { autoUpdate: true });
+        return { db };
+    }
+    async _autobeeApply(nodes, view, host) {
+        const tx = view.db.transaction();
+        try {
+            for (const node of nodes) {
+                if (!node.value)
+                    continue;
+                try {
+                    await this.router.dispatch(node.value, {
+                        tx,
+                        host,
+                        node,
+                        meshPublicKey: this.publicKey,
+                        meshDevicePublicKey: this.devicePublicKey,
+                        log: this._log
+                    });
+                }
+                catch (err) {
+                    if (!isFromANewerBuild(err))
+                        throw err;
+                    this._halt(err, host);
+                }
+            }
+            await tx.flush();
+        }
+        catch (err) {
+            await tx.close();
+            if (isInterrupt(err))
+                throw err;
+            if (isFromANewerBuild(err))
+                this._halt(err, host);
+            this._log?.error(this._scope, 'autobee apply', err);
+            throw err;
+        }
+    }
+    _halt(err, host) {
+        this._log?.warn(this._scope, 'halting apply: the mesh moved past this build', err);
+        return host.interrupt(err);
+    }
+    async _autobeeUpdate(view, changes) {
+        if (this.closing)
+            return;
+        const change = changes.get('view');
+        if (!change)
+            return;
+        const shared = change.shared;
+        const from = shared?.key ? { key: shared.key, length: shared.length } : change.from;
+        try {
+            await syncChanges(this, view, from);
+        }
+        catch (err) {
+            this._log?.warn(this._scope, 'change sync failed', err);
+        }
+    }
+    async checkResumedRevocation() {
+        const snap = this.view.snapshot();
+        try {
+            for await (const device of snap.find('@qvac/devices')) {
+                if (!isOwnRevokedRow(this, device))
+                    continue;
+                return isOwnKickedRow(this, device) ? 'kicked' : 'left';
+            }
+            return null;
+        }
+        finally {
+            await snap.close();
+        }
+    }
+}
+export class MeshBatch {
+    _autobee;
+    _ops = [];
+    constructor(autobee) {
+        this._autobee = autobee;
+    }
+    get size() {
+        return this._ops.length;
+    }
+    dispatch(name, payload) {
+        this._ops.push(encode(`@qvac/${name}`, payload));
+    }
+    async flush(opts) {
+        if (this._ops.length === 0)
+            return;
+        const ops = this._ops;
+        this._ops = [];
+        await this._autobee.append(ops, opts);
+    }
+}
+function noop() { }
+const NEWER_BUILD_MESSAGES = new Set(['Unsupported version', 'Unknown enum', 'Out of bounds']);
+function isInterrupt(err) {
+    return err instanceof Error && err.message === 'Apply interrupted';
+}
+function isFromANewerBuild(err) {
+    if (typeof err === 'object' && err !== null && 'code' in err) {
+        return err.code === ERRORS.HANDLER_NOT_FOUND_BY_ID;
+    }
+    return err instanceof Error && NEWER_BUILD_MESSAGES.has(err.message);
+}