@qvac/core 0.0.0 → 0.1.0

package/dist-lib/lib/core/image/sniff.js

@@ -0,0 +1,149 @@
+const HEIF_BRANDS = new Set([
+    'heic',
+    'heix',
+    'heim',
+    'heis',
+    'hevc',
+    'hevm',
+    'hevs',
+    'mif1',
+    'msf1'
+]);
+const AVIF_BRANDS = new Set(['avif', 'avis']);
+export function detectImageMime(bytes) {
+    if (isPng(bytes))
+        return 'image/png';
+    if (isJpeg(bytes))
+        return 'image/jpeg';
+    if (isAvif(bytes))
+        return 'image/avif';
+    if (isHeif(bytes))
+        return 'image/heic';
+    if (isWebp(bytes))
+        return 'image/webp';
+    if (isGif(bytes))
+        return 'image/gif';
+    if (isBmp(bytes))
+        return 'image/bmp';
+    if (isTiff(bytes))
+        return 'image/tiff';
+    return null;
+}
+export function mapDeclaredToSniffed(declared) {
+    const normalized = declared.toLowerCase();
+    if (normalized === 'image/png')
+        return 'image/png';
+    if (normalized === 'image/jpeg' || normalized === 'image/jpg')
+        return 'image/jpeg';
+    if (normalized === 'image/heic' || normalized === 'image/heif')
+        return 'image/heic';
+    if (normalized === 'image/avif')
+        return 'image/avif';
+    if (normalized === 'image/webp')
+        return 'image/webp';
+    if (normalized === 'image/gif')
+        return 'image/gif';
+    if (normalized === 'image/bmp' || normalized === 'image/x-ms-bmp')
+        return 'image/bmp';
+    if (normalized === 'image/tiff' || normalized === 'image/tif')
+        return 'image/tiff';
+    return null;
+}
+function isPng(bytes) {
+    return (bytes.length >= 8 &&
+        bytes[0] === 0x89 &&
+        bytes[1] === 0x50 &&
+        bytes[2] === 0x4e &&
+        bytes[3] === 0x47 &&
+        bytes[4] === 0x0d &&
+        bytes[5] === 0x0a &&
+        bytes[6] === 0x1a &&
+        bytes[7] === 0x0a);
+}
+function isJpeg(bytes) {
+    return bytes.length >= 3 && bytes[0] === 0xff && bytes[1] === 0xd8 && bytes[2] === 0xff;
+}
+function isHeif(bytes) {
+    if (bytes.length < 12)
+        return false;
+    if (bytes[4] !== 0x66 || bytes[5] !== 0x74 || bytes[6] !== 0x79 || bytes[7] !== 0x70) {
+        return false;
+    }
+    const b8 = bytes[8];
+    const b9 = bytes[9];
+    const b10 = bytes[10];
+    const b11 = bytes[11];
+    if (b8 === undefined || b9 === undefined || b10 === undefined || b11 === undefined)
+        return false;
+    const brand = String.fromCharCode(b8, b9, b10, b11).toLowerCase();
+    return HEIF_BRANDS.has(brand);
+}
+function isAvif(bytes) {
+    if (bytes.length < 12)
+        return false;
+    if (bytes[4] !== 0x66 || bytes[5] !== 0x74 || bytes[6] !== 0x79 || bytes[7] !== 0x70) {
+        return false;
+    }
+    const major = brandAt(bytes, 8);
+    if (major && AVIF_BRANDS.has(major))
+        return true;
+    const end = ftypBoxEnd(bytes);
+    for (let offset = 16; offset + 4 <= end; offset += 4) {
+        const compatible = brandAt(bytes, offset);
+        if (compatible && AVIF_BRANDS.has(compatible))
+            return true;
+    }
+    return false;
+}
+function brandAt(bytes, offset) {
+    const a = bytes[offset];
+    const b = bytes[offset + 1];
+    const c = bytes[offset + 2];
+    const d = bytes[offset + 3];
+    if (a === undefined || b === undefined || c === undefined || d === undefined)
+        return null;
+    return String.fromCharCode(a, b, c, d).toLowerCase();
+}
+function ftypBoxEnd(bytes) {
+    const s0 = bytes[0];
+    const s1 = bytes[1];
+    const s2 = bytes[2];
+    const s3 = bytes[3];
+    if (s0 === undefined || s1 === undefined || s2 === undefined || s3 === undefined) {
+        return bytes.length;
+    }
+    const declared = s0 * 0x1000000 + (s1 << 16) + (s2 << 8) + s3;
+    return declared > 8 && declared <= bytes.length ? declared : bytes.length;
+}
+function isWebp(bytes) {
+    return (bytes.length >= 12 &&
+        bytes[0] === 0x52 &&
+        bytes[1] === 0x49 &&
+        bytes[2] === 0x46 &&
+        bytes[3] === 0x46 &&
+        bytes[8] === 0x57 &&
+        bytes[9] === 0x45 &&
+        bytes[10] === 0x42 &&
+        bytes[11] === 0x50);
+}
+function isGif(bytes) {
+    if (bytes.length < 6)
+        return false;
+    if (bytes[0] !== 0x47 || bytes[1] !== 0x49 || bytes[2] !== 0x46)
+        return false;
+    if (bytes[3] !== 0x38 || bytes[5] !== 0x61)
+        return false;
+    return bytes[4] === 0x37 || bytes[4] === 0x39;
+}
+function isBmp(bytes) {
+    return bytes.length >= 2 && bytes[0] === 0x42 && bytes[1] === 0x4d;
+}
+function isTiff(bytes) {
+    if (bytes.length < 4)
+        return false;
+    if (bytes[0] === 0x49 && bytes[1] === 0x49)
+        return bytes[2] === 0x2a && bytes[3] === 0x00;
+    if (bytes[0] === 0x4d && bytes[1] === 0x4d)
+        return bytes[2] === 0x00 && bytes[3] === 0x2a;
+    return false;
+}

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

@@ -0,0 +1,14 @@
+import type { QvacAutobeeHead } from '../../spec/mesh/hyperschema/types.d.ts';
+export interface MeshInviteNode {
+    readonly host: string;
+    readonly port: number;
+}
+export interface MeshInvite {
+    readonly baseKey: Buffer;
+    readonly seed: Buffer;
+    readonly fastForward: QvacAutobeeHead | null;
+    readonly additionalNodes?: ReadonlyArray<MeshInviteNode>;
+    readonly blindPeers?: ReadonlyArray<Buffer>;
+}
+export declare function encodeMeshInvite(invite: MeshInvite): string;
+export declare function decodeMeshInvite(raw: string): MeshInvite | null;

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

@@ -0,0 +1,36 @@
+import * as z32 from 'z32';
+import { decode as decodeStruct, encode as encodeStruct } from '../../spec/mesh/hyperschema/index.js';
+const INVITE_STRUCT = '@qvac/mesh-invite';
+const INVITE_PREFIX = 'qvac://mesh/';
+export function encodeMeshInvite(invite) {
+    const payload = {
+        meshKey: invite.baseKey,
+        seed: invite.seed,
+        fastForward: invite.fastForward,
+        additionalNodes: [...(invite.additionalNodes ?? [])],
+        blindPeers: [...(invite.blindPeers ?? [])]
+    };
+    return INVITE_PREFIX + z32.encode(encodeStruct(INVITE_STRUCT, payload));
+}
+export function decodeMeshInvite(raw) {
+    const value = raw.trim().toLowerCase();
+    if (!value.startsWith(INVITE_PREFIX))
+        return null;
+    let payload;
+    try {
+        payload = decodeStruct(INVITE_STRUCT, z32.decode(value.slice(INVITE_PREFIX.length)));
+    }
+    catch {
+        return null;
+    }
+    return {
+        baseKey: payload.meshKey,
+        seed: payload.seed,
+        fastForward: payload.fastForward ? payload.fastForward : null,
+        additionalNodes: (payload.additionalNodes ?? []).map((node) => ({
+            host: node.host,
+            port: node.port
+        })),
+        blindPeers: payload.blindPeers ?? []
+    };
+}

package/dist-lib/lib/core/local/index.d.ts

@@ -0,0 +1,71 @@
+import CorestoreStorage from 'hypercore-storage';
+import HyperDB from 'hyperdb';
+import type { LocalAppConfig, LocalCapabilityProfile, LocalChatNotify, LocalCustomModel, LocalIdentity, LocalMembership, LocalMeshDeparture, LocalModelDownload, LocalModelNotify } from '../../../spec/local/hyperschema/types.d.ts';
+import type { DeviceMetadata } from '../mesh.ts';
+export interface ResolvedSession {
+    readonly seed: Buffer;
+    readonly baseKey: Buffer | undefined;
+    readonly writerSeed: string | undefined;
+    readonly creator: boolean;
+}
+export declare function openLocalStore(storage: CorestoreStorage): LocalStore;
+declare class LocalStore {
+    private readonly _db;
+    private readonly _writeLock;
+    constructor(db: HyperDB);
+    private _locked;
+    get(key: string): Promise<unknown>;
+    set(key: string, value: unknown): Promise<void>;
+    setAll(entries: ReadonlyArray<{
+        readonly key: string;
+        readonly value: unknown;
+    }>): Promise<void>;
+    deleteAll(keys: ReadonlyArray<string>): Promise<void>;
+    getAppConfigRow(): Promise<LocalAppConfig | null>;
+    updateAppConfigRow(mutate: (current: LocalAppConfig | null) => Omit<LocalAppConfig, 'id'>): Promise<LocalAppConfig>;
+    getChatNotify(chatId: string): Promise<LocalChatNotify | null>;
+    ackChatNotify(chatId: string, seq: number): Promise<void>;
+    clearChatNotify(chatId: string): Promise<void>;
+    beginModelTransfer(name: string, { transferred }?: {
+        transferred?: boolean;
+    }): Promise<LocalModelNotify>;
+    completeModelTransfer({ name, transferId, downloaded }: {
+        name: string;
+        transferId: string;
+        downloaded?: boolean;
+    }): Promise<void>;
+    getModelNotifications(): Promise<LocalModelNotify[]>;
+    ackModelNotification(notificationId: string): Promise<void>;
+    getModelDownloadRows(): Promise<LocalModelDownload[]>;
+    putModelDownloadRow(row: LocalModelDownload): Promise<void>;
+    deleteModelDownloadRow(name: string): Promise<void>;
+    getCustomModelRows(): Promise<LocalCustomModel[]>;
+    putCustomModelRow(row: LocalCustomModel): Promise<void>;
+    deleteCustomModelRow(name: string): Promise<void>;
+    ensureDevice(publicKey: Buffer, seed?: DeviceMetadata): Promise<DeviceMetadata | null>;
+    renameDevice(publicKey: Buffer, name: string): Promise<void>;
+    saveDeviceProfile(publicKey: Buffer, capabilityProfile: LocalCapabilityProfile, recommendedModelName: string, platform?: string): Promise<void>;
+    readIdentity(): Promise<LocalIdentity | null>;
+    readMembership(): Promise<LocalMembership | null>;
+    recordMembership(link: Omit<LocalMembership, 'id'>): Promise<void>;
+    ensureIdentity(devicePublicKey: Buffer, createdAt: number): Promise<{
+        identity: LocalIdentity;
+        mnemonic: string | null;
+    }>;
+    resolveSession(deviceId: Buffer, opts?: {
+        seed?: Buffer;
+        baseKey?: Buffer;
+        new?: boolean;
+        writerSeed?: string;
+        creator?: boolean;
+    }): Promise<ResolvedSession>;
+    createCandidateSession(seed: Buffer, baseKey: Buffer): ResolvedSession;
+    recordMesh(deviceId: Buffer, key: Buffer, seed: Buffer, creator: boolean, writerSeed: string | undefined): Promise<void>;
+    recordDeparture(key: Buffer): Promise<void>;
+    departures(): Promise<LocalMeshDeparture[]>;
+    deleteDeparture(key: Buffer): Promise<void>;
+    watch(listener: () => void): void;
+    unwatch(listener: () => void): void;
+    close(): Promise<void>;
+}
+export {};

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

@@ -0,0 +1,391 @@
+import CorestoreStorage from 'hypercore-storage';
+import HyperDB from 'hyperdb';
+import crypto from 'hypercore-crypto';
+import ScopeLock from 'scope-lock';
+import { generateMnemonic, mintIdentity } from "../identity.js";
+import LocalDatabaseSpec from '../../../spec/local/hyperdb/index.js';
+const CONFIG = '@local/config';
+const MESH_SESSION = '@local/mesh-session';
+const MESH_HISTORY = '@local/mesh-history';
+const MESH_DEPARTURE = '@local/mesh-departure';
+const DEVICE = '@local/device';
+const APP_CONFIG = '@local/app-config';
+const MODEL_DOWNLOAD = '@local/model-download';
+const CUSTOM_MODEL = '@local/custom-model';
+const IDENTITY = '@local/identity';
+const IDENTITY_ID = 'identity';
+const MEMBERSHIP = '@local/membership';
+const MEMBERSHIP_ID = 'membership';
+const CHAT_NOTIFY = '@local/chat-notify';
+const MODEL_NOTIFY = '@local/model-notify';
+const APP_CONFIG_ID = 'default';
+function freshWriterSeed() {
+    return `local-${crypto.randomBytes(8).toString('hex')}`;
+}
+export function openLocalStore(storage) {
+    const db = HyperDB.rocks(storage.rocks.columnFamily('assistant/local'), LocalDatabaseSpec);
+    return new LocalStore(db);
+}
+class LocalStore {
+    _db;
+    _writeLock = new ScopeLock();
+    constructor(db) {
+        this._db = db;
+    }
+    async _locked(fn) {
+        await this._writeLock.lock();
+        try {
+            return await fn();
+        }
+        finally {
+            this._writeLock.unlock();
+        }
+    }
+    async get(key) {
+        const row = await this._db.get(CONFIG, { key });
+        return row ? row.value : null;
+    }
+    set(key, value) {
+        return this._locked(async () => {
+            const tx = this._db.transaction();
+            await tx.insert(CONFIG, { key, value });
+            await tx.flush();
+        });
+    }
+    setAll(entries) {
+        return this._locked(async () => {
+            const tx = this._db.transaction();
+            for (const { key, value } of entries)
+                await tx.insert(CONFIG, { key, value });
+            await tx.flush();
+        });
+    }
+    deleteAll(keys) {
+        return this._locked(async () => {
+            const tx = this._db.transaction();
+            for (const key of keys)
+                await tx.delete(CONFIG, { key });
+            await tx.flush();
+        });
+    }
+    getAppConfigRow() {
+        return this._db.get(APP_CONFIG, { id: APP_CONFIG_ID });
+    }
+    updateAppConfigRow(mutate) {
+        return this._locked(async () => {
+            const tx = this._db.transaction();
+            const current = await tx.get(APP_CONFIG, { id: APP_CONFIG_ID });
+            const next = { id: APP_CONFIG_ID, ...mutate(current) };
+            await tx.insert(APP_CONFIG, next);
+            await tx.flush();
+            return next;
+        });
+    }
+    getChatNotify(chatId) {
+        return this._locked(() => this._db.get(CHAT_NOTIFY, { chatId }));
+    }
+    ackChatNotify(chatId, seq) {
+        return this._locked(async () => {
+            const tx = this._db.transaction();
+            const current = await tx.get(CHAT_NOTIFY, { chatId });
+            const ackedThrough = Math.max(current?.ackedThrough ?? 0, seq + 1);
+            await tx.insert(CHAT_NOTIFY, { chatId, ackedThrough });
+            await tx.flush();
+        });
+    }
+    clearChatNotify(chatId) {
+        return this._locked(async () => {
+            const tx = this._db.transaction();
+            await tx.delete(CHAT_NOTIFY, { chatId });
+            await tx.flush();
+        });
+    }
+    beginModelTransfer(name, { transferred = false } = {}) {
+        return this._locked(async () => {
+            const current = await this._db.get(MODEL_NOTIFY, { name });
+            const pending = current && current.transferId !== current.notificationId;
+            if (pending && (!transferred || current.transferred))
+                return current;
+            const next = {
+                name,
+                transferId: pending ? current.transferId : crypto.randomBytes(16).toString('hex'),
+                notificationId: current?.notificationId,
+                completedAt: current?.completedAt,
+                acknowledged: current?.acknowledged,
+                transferred
+            };
+            const tx = this._db.transaction();
+            await tx.insert(MODEL_NOTIFY, next);
+            await tx.flush();
+            return next;
+        });
+    }
+    completeModelTransfer({ name, transferId, downloaded = true }) {
+        return this._locked(async () => {
+            const current = await this._db.get(MODEL_NOTIFY, { name });
+            if (!current || current.transferId !== transferId || current.notificationId === transferId) {
+                return;
+            }
+            if (!downloaded && !current.transferred)
+                return;
+            const tx = this._db.transaction();
+            await tx.insert(MODEL_NOTIFY, {
+                name,
+                transferId,
+                notificationId: transferId,
+                completedAt: Date.now(),
+                acknowledged: false,
+                transferred: true
+            });
+            await tx.flush();
+        });
+    }
+    getModelNotifications() {
+        return this._locked(() => this._db.find(MODEL_NOTIFY).toArray());
+    }
+    ackModelNotification(notificationId) {
+        return this._locked(async () => {
+            const rows = await this._db.find(MODEL_NOTIFY).toArray();
+            const current = rows.find((row) => row.notificationId === notificationId);
+            if (!current || current.acknowledged)
+                return;
+            const tx = this._db.transaction();
+            await tx.insert(MODEL_NOTIFY, {
+                name: current.name,
+                transferId: current.transferId,
+                notificationId: current.notificationId,
+                completedAt: current.completedAt,
+                transferred: current.transferred,
+                acknowledged: true
+            });
+            await tx.flush();
+        });
+    }
+    async getModelDownloadRows() {
+        const rows = [];
+        for await (const row of this._db.find(MODEL_DOWNLOAD))
+            rows.push(row);
+        return rows;
+    }
+    putModelDownloadRow(row) {
+        return this._locked(async () => {
+            const tx = this._db.transaction();
+            await tx.insert(MODEL_DOWNLOAD, row);
+            await tx.flush();
+        });
+    }
+    deleteModelDownloadRow(name) {
+        return this._locked(async () => {
+            const tx = this._db.transaction();
+            await tx.delete(MODEL_DOWNLOAD, { name });
+            await tx.flush();
+        });
+    }
+    async getCustomModelRows() {
+        const rows = [];
+        for await (const row of this._db.find(CUSTOM_MODEL))
+            rows.push(row);
+        return rows;
+    }
+    putCustomModelRow(row) {
+        return this._locked(async () => {
+            const tx = this._db.transaction();
+            await tx.insert(CUSTOM_MODEL, row);
+            await tx.flush();
+        });
+    }
+    deleteCustomModelRow(name) {
+        return this._locked(async () => {
+            const tx = this._db.transaction();
+            await tx.delete(CUSTOM_MODEL, { name });
+            await tx.flush();
+        });
+    }
+    ensureDevice(publicKey, seed) {
+        return this._locked(async () => {
+            const existing = await this._db.get(DEVICE, { publicKey });
+            if (existing) {
+                return {
+                    name: existing.name,
+                    capabilityProfile: existing.capabilityProfile,
+                    recommendedModelName: existing.recommendedModelName,
+                    platform: existing.platform ?? undefined
+                };
+            }
+            if (!seed)
+                return null;
+            const tx = this._db.transaction();
+            await tx.insert(DEVICE, { publicKey, ...seed });
+            await tx.flush();
+            return seed;
+        });
+    }
+    renameDevice(publicKey, name) {
+        return this._locked(async () => {
+            const existing = await this._db.get(DEVICE, { publicKey });
+            if (!existing)
+                return;
+            const tx = this._db.transaction();
+            await tx.insert(DEVICE, { ...existing, name });
+            await tx.flush();
+        });
+    }
+    saveDeviceProfile(publicKey, capabilityProfile, recommendedModelName, platform) {
+        return this._locked(async () => {
+            const existing = await this._db.get(DEVICE, { publicKey });
+            if (!existing)
+                return;
+            const tx = this._db.transaction();
+            await tx.insert(DEVICE, {
+                ...existing,
+                capabilityProfile,
+                recommendedModelName,
+                platform: platform ?? existing.platform
+            });
+            await tx.flush();
+        });
+    }
+    readIdentity() {
+        return this._db.get(IDENTITY, { id: IDENTITY_ID });
+    }
+    readMembership() {
+        return this._db.get(MEMBERSHIP, { id: MEMBERSHIP_ID });
+    }
+    recordMembership(link) {
+        return this._locked(async () => {
+            const existing = await this._db.get(MEMBERSHIP, { id: MEMBERSHIP_ID });
+            if (existing && existing.attestedAt >= link.attestedAt)
+                return;
+            const tx = this._db.transaction();
+            await tx.insert(MEMBERSHIP, { id: MEMBERSHIP_ID, ...link });
+            await tx.flush();
+        });
+    }
+    ensureIdentity(devicePublicKey, createdAt) {
+        return this._locked(async () => {
+            const existing = await this._db.get(IDENTITY, { id: IDENTITY_ID });
+            if (existing)
+                return { identity: existing, mnemonic: null };
+            const mnemonic = await generateMnemonic();
+            const minted = await mintIdentity(mnemonic, devicePublicKey);
+            const identity = {
+                id: IDENTITY_ID,
+                publicKey: minted.publicKey,
+                proof: minted.proof,
+                createdAt
+            };
+            const tx = this._db.transaction();
+            await tx.insert(IDENTITY, identity);
+            await tx.flush();
+            return { identity, mnemonic };
+        });
+    }
+    resolveSession(deviceId, opts = {}) {
+        return this._locked(async () => {
+            const tx = this._db.transaction();
+            const session = await tx.get(MESH_SESSION, { deviceId });
+            const sameSeed = Boolean(opts.seed && session?.meshSeed?.equals(opts.seed));
+            if (opts.seed && !sameSeed) {
+                await tx.insert(MESH_SESSION, {
+                    deviceId,
+                    meshSeed: opts.seed,
+                    meshKey: opts.baseKey ?? null,
+                    meshCreator: opts.creator ?? false
+                });
+                await tx.flush();
+                return {
+                    seed: opts.seed,
+                    baseKey: opts.baseKey,
+                    writerSeed: opts.writerSeed ?? freshWriterSeed(),
+                    creator: opts.creator ?? false
+                };
+            }
+            if (session?.meshSeed && !opts.new) {
+                const baseKey = !session.meshCreator && session.meshKey ? session.meshKey : undefined;
+                const history = await tx.findOne(MESH_HISTORY);
+                await tx.close();
+                return {
+                    seed: session.meshSeed,
+                    baseKey,
+                    writerSeed: history?.writerSeed ?? undefined,
+                    creator: session.meshCreator ?? false
+                };
+            }
+            const seed = crypto.randomBytes(32);
+            await tx.insert(MESH_SESSION, {
+                deviceId,
+                meshSeed: seed,
+                meshKey: null,
+                meshCreator: true
+            });
+            await tx.flush();
+            return { seed, baseKey: undefined, writerSeed: undefined, creator: true };
+        });
+    }
+    createCandidateSession(seed, baseKey) {
+        return {
+            seed,
+            baseKey,
+            writerSeed: freshWriterSeed(),
+            creator: false
+        };
+    }
+    recordMesh(deviceId, key, seed, creator, writerSeed) {
+        return this._locked(async () => {
+            const tx = this._db.transaction();
+            const current = await tx.findOne(MESH_HISTORY);
+            if (current && !current.key.equals(key)) {
+                await tx.delete(MESH_HISTORY, { key: current.key });
+            }
+            await tx.insert(MESH_HISTORY, { key, seed, creator, writerSeed });
+            const session = await tx.get(MESH_SESSION, { deviceId });
+            await tx.insert(MESH_SESSION, {
+                ...session,
+                deviceId,
+                meshSeed: seed,
+                meshKey: key,
+                meshCreator: creator
+            });
+            await tx.flush();
+        });
+    }
+    recordDeparture(key) {
+        return this._locked(async () => {
+            const tx = this._db.transaction();
+            const history = await tx.get(MESH_HISTORY, { key });
+            if (!history) {
+                await tx.close();
+                return;
+            }
+            await tx.insert(MESH_DEPARTURE, {
+                key: history.key,
+                seed: history.seed,
+                creator: history.creator,
+                writerSeed: history.writerSeed
+            });
+            await tx.flush();
+        });
+    }
+    async departures() {
+        const rows = [];
+        for await (const row of this._db.find(MESH_DEPARTURE))
+            rows.push(row);
+        return rows;
+    }
+    deleteDeparture(key) {
+        return this._locked(async () => {
+            const tx = this._db.transaction();
+            await tx.delete(MESH_DEPARTURE, { key });
+            await tx.flush();
+        });
+    }
+    watch(listener) {
+        this._db.watch(listener);
+    }
+    unwatch(listener) {
+        this._db.unwatch(listener);
+    }
+    async close() {
+        await this._locked(() => this._db.close());
+    }
+}

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

@@ -0,0 +1,15 @@
+import type { KeyPair } from 'hyperswarm';
+import type { Logger } from '../../index.ts';
+import type { QvacDevice } from '../../spec/mesh/hyperschema/types.d.ts';
+import type { Mesh } from './mesh.ts';
+export interface MembershipView {
+    readonly members: number;
+    readonly own: QvacDevice | null;
+    readonly unattested: ReadonlyArray<Buffer>;
+}
+export interface MembershipContext {
+    readonly deviceKeyPair: KeyPair;
+    readonly log: Logger | null;
+}
+export declare function membershipView(mesh: Mesh, deviceId: Buffer): Promise<MembershipView>;
+export declare function attestUnattestedDevices(mesh: Mesh, { deviceKeyPair, log }: MembershipContext): Promise<void>;