@antfly/embedded 0.0.0 → 0.3.0-rc.1

package/dist/database-BY3WSLgt.d.cts

@@ -0,0 +1,558 @@
+import { LibraryHandle, KoffiFunc } from 'koffi';
+
+/** Where a resolved libantfly path came from, for diagnostics/logging. */
+type LibrarySource = "ANTFLY_LIBRARY" | "ANTFLY_LIB_DIR" | "embedded-package" | "source-tree" | "system";
+interface ResolvedLibrary {
+    /** Absolute path to the shared library, or a bare loader name for "system". */
+    path: string;
+    source: LibrarySource;
+}
+declare class LibraryNotFoundError extends Error {
+    constructor(message: string);
+}
+declare class UnsupportedPlatformError extends Error {
+    constructor(platform: string);
+}
+/** The libantfly shared library file name for a platform, e.g. "libantfly.dylib". */
+declare function platformLibraryFileName(platform: NodeJS.Platform): string | undefined;
+/** The Apache @antfly/embedded-<platform> package that ships libantfly. */
+declare function embeddedPlatformPackageName(platform: NodeJS.Platform, arch: string): string | undefined;
+interface ResolveLibraryOptions {
+    platform?: NodeJS.Platform;
+    arch?: string;
+    env?: NodeJS.ProcessEnv;
+    /** Directory to walk up from when looking for zig/zig-out/lib (a source checkout). Defaults to this package's own directory. */
+    startDir?: string;
+    existsSync?: (path: string) => boolean;
+    /** Like require.resolve; used to locate an installed @antfly/embedded-<platform> package. */
+    resolve?: (specifier: string) => string;
+}
+/**
+ * Resolves the libantfly shared library to load, in order:
+ *
+ * 1. `ANTFLY_LIBRARY` env var: an exact file path.
+ * 2. `ANTFLY_LIB_DIR` env var: a directory containing the platform library file.
+ * 3. The installed `@antfly/embedded-<platform>` package's `lib/` directory.
+ * 4. `zig/zig-out/lib/` found by walking up from this package (a source checkout).
+ * 5. The bare system loader name, resolved by the OS's shared library search
+ *    path (LD_LIBRARY_PATH / DYLD_LIBRARY_PATH / PATH / rpath).
+ *
+ * Throws LibraryNotFoundError if an explicit env var names a path that does
+ * not exist, so misconfiguration fails loudly instead of silently falling
+ * through to another tier.
+ */
+declare function resolveLibrary(options?: ResolveLibraryOptions): ResolvedLibrary;
+
+/** How a database is opened (antfly_open_mode_* in antfly.h). */
+declare enum OpenMode {
+    Writer = 0,
+    Readonly = 1,
+    StatusOnly = 2
+}
+/**
+ * How a database is stored (antfly_storage_kind_* in antfly.h). The zero
+ * value, Lite, is a single-file .aflite database.
+ */
+declare enum Storage {
+    /** A single-file .aflite database. */
+    Lite = 0,
+    /** A normal single-node Antfly directory. */
+    Directory = 1
+}
+/** The Lite runtime profile (antfly_profile_* in antfly.h). */
+declare enum Profile {
+    Native = 0,
+    Hosted = 1
+}
+/** Graph edge traversal direction (antfly_graph_direction_* in antfly.h). */
+declare enum GraphDirection {
+    Out = 0,
+    In = 1,
+    Both = 2
+}
+/** Transaction intent lifecycle state (antfly_txn_status in antfly.h). */
+declare enum TxnStatus {
+    Pending = 0,
+    Committed = 1,
+    Aborted = 2
+}
+/** Inference mode strings returned by Lite status and capabilities JSON. */
+declare const InferenceMode: {
+    readonly CallerSuppliedOrDisabled: "caller_supplied_or_disabled";
+    readonly CallerSuppliedArtifacts: "caller_supplied_artifacts";
+    readonly RemoteProvider: "remote_provider";
+    readonly LocalEmbedded: "local_embedded";
+    readonly ManualMaintenance: "manual_maintenance";
+    readonly DisabledDeferred: "disabled_deferred";
+};
+/** The only libantfly threading contract (antfly_threading_mode() return value), like sqlite3_threadsafe(). */
+declare const THREADING_SERIALIZED = 1;
+/** The Antfly C ABI version this binding was written against (antfly_abi_version()). */
+declare const SUPPORTED_ABI_VERSION = 3;
+/** Configures TTL cleanup for a native-profile Lite handle. */
+interface TTLCleanupOptions {
+    enabled: boolean;
+    leaseOwned: boolean;
+    ownerId?: string;
+    leaseTtlMs?: Uint64Like;
+    intervalMs?: Uint64Like;
+    batchSize?: number;
+    gracePeriodNs?: Uint64Like;
+}
+/**
+ * Configures open/create. See antfly_open_options in antfly.h and
+ * zig/LITE.md's "Local Embedded Inference" section for the inference budget
+ * fields. All fields are optional; unset numeric budgets mean "automatic".
+ */
+interface OpenOptions {
+    /** Selects a .aflite file (the default) or a directory. Directory storage is created by opening a missing path; createWithOptions only creates .aflite files. */
+    storage?: Storage;
+    mode?: OpenMode;
+    profile?: Profile;
+    noSync?: boolean;
+    remoteProviderConfigured?: boolean;
+    localRuntimeConfigured?: boolean;
+    generatedEnrichmentReplay?: boolean;
+    mapSize?: Uint64Like;
+    ttlCleanup?: TTLCleanupOptions;
+    /** Milliseconds to retry while another writer holds the writer lock (ANTFLY_BUSY), like sqlite3_busy_timeout. 0 (default) fails immediately. */
+    busyTimeoutMs?: Uint64Like;
+    inferenceHostBudgetMb?: number;
+    inferenceBackendBudgetMb?: number;
+    inferenceCombinedBudgetMb?: number;
+    inferenceKvBudgetMb?: number;
+    inferenceScratchBudgetMb?: number;
+    inferenceProcessMemoryBudgetMb?: number;
+}
+/** A single key/value write or delete in a batch. */
+interface WriteIntent {
+    key: string;
+    value?: Uint8Array | Record<string, unknown>;
+    delete?: boolean;
+}
+/** Configures restore() and restoreFile(). */
+interface RestoreOptions {
+    /** Selects the kind of database created at the destination: a .aflite file (the default) or a directory. */
+    storage?: Storage;
+    /** Atomically replaces an existing destination. */
+    replace?: boolean;
+}
+interface StorageStatus {
+    format: string;
+    engine: string;
+    primary_layout: string;
+    replay_layout: string;
+    index_layout: string;
+    index_namespace?: string;
+    format_version?: number;
+    page_size?: number;
+    active_checkpoint?: number;
+    checkpoint_sequence?: number;
+    page_count?: number;
+}
+/** Historical snapshot of the local runtime's last denied memory admission. */
+interface MemoryAdmissionStats {
+    pressure: string;
+    denied_count: number;
+    last_denied_ns: number;
+    request_count: number;
+    requested_host_bytes: number;
+    requested_backend_bytes: number;
+    requested_kv_bytes: number;
+    requested_scratch_bytes: number;
+    admitted_host_bytes: number;
+    admitted_backend_bytes: number;
+    host_limit_bytes: number;
+    backend_limit_bytes: number;
+    combined_limit_bytes: number;
+    available_memory_bytes: number;
+}
+interface InferenceStatus {
+    mode: string;
+    available_modes: string[];
+    configured: boolean;
+    remote_provider_configured: boolean;
+    local_runtime_configured: boolean;
+    local_runtime_available: boolean;
+    caller_supplied_artifacts: boolean;
+    no_inference_configured_ok: boolean;
+    host_budget_mb: number;
+    backend_budget_mb: number;
+    combined_budget_mb: number;
+    kv_budget_mb: number;
+    scratch_budget_mb: number;
+    process_memory_budget_mb: number;
+    process_memory_limit_bytes: number;
+    process_memory_limit_source: string;
+    memory_admission?: MemoryAdmissionStats;
+}
+interface Capabilities {
+    freestanding_build: boolean;
+    /** Always "serialized" for the current libantfly (see THREADING_SERIALIZED). */
+    threading: string;
+    hosted_profile: boolean;
+    manual_maintenance: boolean;
+    background_enrichment_runtime: boolean;
+    ttl_cleanup_runtime: boolean;
+    transaction_recovery_runtime: boolean;
+    local_template_rendering: boolean;
+    remote_template_rendering: boolean;
+    remote_template_host_callbacks: boolean;
+    inference_mode: string;
+    supported_inference_modes: string[];
+    available_inference_modes: string[];
+    inference_required: boolean;
+    no_inference_configured_ok: boolean;
+    caller_supplied_artifacts: boolean;
+    caller_supplied_embeddings: boolean;
+    remote_inference_providers: boolean;
+    local_inference_runtime: boolean;
+    generated_enrichment_planning: boolean;
+    text_search: boolean;
+    dense_vector_search: boolean;
+    sparse_vector_search: boolean;
+    hybrid_search: boolean;
+    graph_search: boolean;
+    distributed_shard_ownership: boolean;
+    raft_replication: boolean;
+    cluster_placement: boolean;
+    cross_node_joins: boolean;
+    remote_shard_fanout: boolean;
+    distributed_transaction_coordination: boolean;
+    cluster_heartbeat_status_aggregation: boolean;
+    server_side_autoscaling: boolean;
+    kubernetes_operator: boolean;
+    object_storage_primary: boolean;
+}
+interface PendingWorkStatus {
+    derived_target_sequence: number;
+    has_async_indexes: boolean;
+    portable_import_publication_in_progress: boolean;
+    portable_import_recovery_required: boolean;
+    portable_runtime_activation_pending: boolean;
+    enrichment: unknown;
+    resolution: unknown;
+    promotion: unknown;
+    text_merge: unknown;
+    replacements?: unknown[];
+}
+interface Status {
+    storage: StorageStatus;
+    stats: unknown;
+    pending_work: PendingWorkStatus;
+    inference: InferenceStatus;
+    capabilities: Capabilities;
+}
+interface ReplayGeneratedEnrichmentsResult {
+    replayed: number;
+}
+interface CheckReport {
+    valid: boolean;
+    file_size: number;
+    valid_prefix_size: number;
+    tail_bytes: number;
+    record_count: number;
+    live_file_count: number;
+    live_bytes: number;
+    compact_size: number;
+    reclaimable_bytes: number;
+    issue?: string;
+}
+interface VacuumReport {
+    before_size: number;
+    after_size: number;
+    reclaimed_bytes: number;
+    live_file_count: number;
+    live_bytes: number;
+}
+interface CompactReport {
+    compacted: boolean;
+    vacuum: VacuumReport;
+}
+interface StableSnapshotReport {
+    source_size: number;
+    snapshot_size: number;
+    checkpoint_sequence: number;
+    page_count: number;
+    tail_bytes: number;
+}
+/**
+ * Configures Inference.open(). See antfly_inference_options in antfly.h.
+ * All fields are optional; unset numeric budgets mean "automatic".
+ */
+interface InferenceOptions {
+    /** Models directory. Empty (default) uses $ANTFLY_INFERENCE_MODELS_DIR, else ~/.antfly/inference/models. */
+    modelsDir?: string;
+    hostBudgetMb?: number;
+    backendBudgetMb?: number;
+    processMemoryBudgetMb?: number;
+    combinedBudgetMb?: number;
+    kvBudgetMb?: number;
+    scratchBudgetMb?: number;
+    /** Deadline for each call in milliseconds; 0 (default) means none. */
+    callTimeoutMs?: Uint64Like;
+}
+/** One progress report from Inference.pull(), mirroring antfly_inference_pull_progress. */
+interface PullProgress {
+    /** The model reference being pulled (one report series per requested variant). */
+    model: string;
+    file: string;
+    bytesDownloaded: bigint;
+    /** 0n when unknown. */
+    totalBytes: bigint;
+    filesDone: bigint;
+    filesTotal: bigint;
+    /** The file was already present and verified; nothing was downloaded. */
+    cached: boolean;
+}
+
+interface NativeLibrary {
+    handle: LibraryHandle;
+    resolved: ResolvedLibrary;
+    abiVersion: KoffiFunc<() => number>;
+    threadingMode: KoffiFunc<() => number>;
+    openOptionsSize: KoffiFunc<() => number>;
+    errorCodeName: KoffiFunc<(code: number) => string>;
+    errorCodeDescription: KoffiFunc<(code: number) => string>;
+    openOptionsInit: KoffiFunc<(options: object) => number>;
+    dbOpenWithOptions: KoffiFunc<(path: string, options: object, outHandle: unknown[]) => number>;
+    dbCreateWithOptions: KoffiFunc<(path: string, options: object, outHandle: unknown[]) => number>;
+    liteOpenHosted: KoffiFunc<(path: string, outHandle: unknown[]) => number>;
+    liteCreateHosted: KoffiFunc<(path: string, outHandle: unknown[]) => number>;
+    dbClose: KoffiFunc<(handle: unknown) => void>;
+    bufferFree: KoffiFunc<(buffer: object) => void>;
+    dbSqlJson: KoffiFunc<(handle: unknown, request: object, out: object) => number>;
+    dbOpenTable: KoffiFunc<(handle: unknown, name: object, out: unknown[]) => number>;
+    dbCreateTableJson: KoffiFunc<(handle: unknown, name: object, schema: object) => number>;
+    dbDropTable: KoffiFunc<(handle: unknown, name: object) => number>;
+    dbListTablesJson: KoffiFunc<(handle: unknown, out: object) => number>;
+    dbSqlSessionOpen: KoffiFunc<(handle: unknown, out: unknown[]) => number>;
+    dbSqlSessionClose: KoffiFunc<(handle: unknown, session: number | bigint) => number>;
+    dbSqlOpenCursorJson: KoffiFunc<(handle: unknown, request: object, cursor: unknown[], out: object) => number>;
+    dbSqlFetchCursorJson: KoffiFunc<(handle: unknown, cursor: number | bigint, rows: number, out: object) => number>;
+    dbSqlCloseCursor: KoffiFunc<(handle: unknown, cursor: number | bigint) => number>;
+    dbStatusJson: KoffiFunc<(handle: unknown, out: object) => number>;
+    dbCapabilitiesJson: KoffiFunc<(handle: unknown, out: object) => number>;
+    dbBackup: KoffiFunc<(handle: unknown, out: object) => number>;
+    dbImportBackup: KoffiFunc<(handle: unknown, backup: object) => number>;
+    restoreBackupJson: KoffiFunc<(destPath: string, options: object | null, backup: object, replace: boolean, out: object) => number>;
+    restoreBackupFileJson: KoffiFunc<(destPath: string, options: object | null, backupPath: string, replace: boolean, out: object) => number>;
+    liteCheckJson: KoffiFunc<(handle: unknown, out: object) => number>;
+    liteCheckFileJson: KoffiFunc<(path: string, out: object) => number>;
+    liteCopyStableSnapshotJson: KoffiFunc<(handle: unknown, destPath: string, replace: boolean, out: object) => number>;
+    liteCopyStableSnapshotFileJson: KoffiFunc<(srcPath: string, destPath: string, replace: boolean, out: object) => number>;
+    liteCompactJson: KoffiFunc<(handle: unknown, out: object) => number>;
+    liteVacuumJson: KoffiFunc<(handle: unknown, out: object) => number>;
+    dbRunUntilIdle: KoffiFunc<(handle: unknown) => number>;
+    dbRunUntilIdleJson: KoffiFunc<(handle: unknown, out: object) => number>;
+    dbReplayGeneratedEnrichmentsJson: KoffiFunc<(handle: unknown, out: object) => number>;
+    dbPendingWorkStatsJson: KoffiFunc<(handle: unknown, out: object) => number>;
+    dbBatch: KoffiFunc<(handle: unknown, writes: object[] | null, writeCount: number, predicates: object[] | null, predicateCount: number, timestampNs: number | bigint, syncLevel: number) => number>;
+    dbBatchJson: KoffiFunc<(handle: unknown, request: object, out: object) => number>;
+    dbBeginTransactionWithId: KoffiFunc<(handle: unknown, txnId: Uint8Array, timestampNs: number | bigint, participants: object[] | null, participantCount: number) => number>;
+    dbWriteTransaction: KoffiFunc<(handle: unknown, txnId: Uint8Array, writes: object[] | null, writeCount: number, predicates: object[] | null, predicateCount: number) => number>;
+    dbResolveIntents: KoffiFunc<(handle: unknown, txnId: Uint8Array, status: number, commitVersion: number | bigint) => number>;
+    dbGetTransactionStatus: KoffiFunc<(handle: unknown, txnId: Uint8Array, outStatus: number[]) => number>;
+    dbGetCommitVersion: KoffiFunc<(handle: unknown, txnId: Uint8Array, outVersion: (number | bigint)[]) => number>;
+    dbLookupJson: KoffiFunc<(handle: unknown, key: object, out: object) => number>;
+    dbGetRaw: KoffiFunc<(handle: unknown, key: object, out: object) => number>;
+    dbGetSchemaJson: KoffiFunc<(handle: unknown, out: object) => number>;
+    dbSetSchemaJson: KoffiFunc<(handle: unknown, schema: object) => number>;
+    dbListIndexesJson: KoffiFunc<(handle: unknown, out: object) => number>;
+    dbAddIndexJson: KoffiFunc<(handle: unknown, config: object) => number>;
+    dbDeleteIndex: KoffiFunc<(handle: unknown, name: object, outDeleted: boolean[]) => number>;
+    dbListEnrichmentsJson: KoffiFunc<(handle: unknown, out: object) => number>;
+    dbAddEnrichmentJson: KoffiFunc<(handle: unknown, config: object) => number>;
+    dbDeleteEnrichment: KoffiFunc<(handle: unknown, kind: object, name: object, outDeleted: boolean[]) => number>;
+    dbScanJson: KoffiFunc<(handle: unknown, request: object, out: object) => number>;
+    dbStatsJson: KoffiFunc<(handle: unknown, out: object) => number>;
+    dbSearchJson: KoffiFunc<(handle: unknown, request: object, out: object) => number>;
+    dbSearchDenseWire: KoffiFunc<(handle: unknown, request: object, out: object) => number>;
+    dbSearchTextMatchWire: KoffiFunc<(handle: unknown, request: object, out: object) => number>;
+    dbSearchTextTermWire: KoffiFunc<(handle: unknown, request: object, out: object) => number>;
+    dbSearchTextMatchPhraseWire: KoffiFunc<(handle: unknown, request: object, out: object) => number>;
+    dbAggregateHitsJson: KoffiFunc<(handle: unknown, request: object, out: object) => number>;
+    dbLookupArtifactJson: KoffiFunc<(handle: unknown, artifactIdBase64: object, out: object) => number>;
+    decodeArtifactIdJson: KoffiFunc<(artifactIdBase64: object, out: object) => number>;
+    dbExtractEnrichmentsJson: KoffiFunc<(handle: unknown, request: object, out: object) => number>;
+    dbComputeEnrichmentsJson: KoffiFunc<(handle: unknown, request: object, out: object) => number>;
+    dbGetEdgesJson: KoffiFunc<(handle: unknown, indexName: object, key: object, edgeType: object, direction: number, out: object) => number>;
+    dbTraverseEdgesJson: KoffiFunc<(handle: unknown, request: object, out: object) => number>;
+    dbExecuteGraphQueriesJson: KoffiFunc<(handle: unknown, request: object, out: object) => number>;
+    dbGetNeighborsJson: KoffiFunc<(handle: unknown, indexName: object, key: object, edgeType: object, direction: number, out: object) => number>;
+    dbFindShortestPathJson: KoffiFunc<(handle: unknown, request: object, out: object) => number>;
+    dbFindKShortestPathsJson: KoffiFunc<(handle: unknown, request: object, out: object) => number>;
+    dbMatchPatternJson: KoffiFunc<(handle: unknown, request: object, out: object) => number>;
+    inferenceOptionsSize: KoffiFunc<() => number>;
+    inferenceOptionsInit: KoffiFunc<(options: object) => number>;
+    inferenceOpen: KoffiFunc<(options: object | null, outHandle: unknown[]) => number>;
+    inferenceClose: KoffiFunc<(handle: unknown) => void>;
+    inferenceEmbedJson: KoffiFunc<(handle: unknown, request: object, out: object) => number>;
+    inferenceRerankJson: KoffiFunc<(handle: unknown, request: object, out: object) => number>;
+    inferenceChunkJson: KoffiFunc<(handle: unknown, request: object, out: object) => number>;
+    inferenceGenerateJson: KoffiFunc<(handle: unknown, request: object, out: object) => number>;
+    inferenceGenerateStreamJson: KoffiFunc<(handle: unknown, request: object, onChunk: unknown, chunkContext: unknown, out: object) => number>;
+    inferenceGenerateBatchJson: KoffiFunc<(handle: unknown, request: object, out: object) => number>;
+    inferenceRewriteJson: KoffiFunc<(handle: unknown, request: object, out: object) => number>;
+    inferenceDecideJson: KoffiFunc<(handle: unknown, request: object, out: object) => number>;
+    inferenceExtractJson: KoffiFunc<(handle: unknown, request: object, out: object) => number>;
+    inferenceReadJson: KoffiFunc<(handle: unknown, request: object, out: object) => number>;
+    inferenceTranscribeJson: KoffiFunc<(handle: unknown, request: object, out: object) => number>;
+    inferenceListModelsJson: KoffiFunc<(handle: unknown, out: object) => number>;
+    inferencePullJson: KoffiFunc<(handle: unknown, request: object, progress: unknown, progressContext: unknown, out: object) => number>;
+}
+/**
+ * Native stack for every libantfly call. koffi runs foreign calls on its own
+ * stacks (128 KiB for async calls by default), but libantfly needs the
+ * minimum documented in zig/CAPI.md "Thread Safety" (ANTFLY_MIN_THREAD_STACK_SIZE
+ * in antfly.h): 8 MiB. Smaller stacks crash inside the storage engine.
+ */
+declare const NATIVE_STACK_SIZE: number;
+
+/** Accepted shapes for a uint64_t argument: plain number (safe up to 2^53) or bigint. */
+type Uint64Like = number | bigint;
+/** Accepted shapes for a JSON request body: an object (JSON.stringify'd), a raw JSON string, or raw bytes. */
+type JsonInput = Record<string, unknown> | unknown[] | string | Uint8Array;
+
+/**
+ * An embedded Antfly database handle.
+ *
+ * A Database is safe for concurrent use from any number of in-flight
+ * promises: libantfly runs in serialized threading mode (see
+ * threadingMode()) -- reads run in parallel, writes on one handle queue
+ * behind each other, and schema/index changes wait for in-flight calls (see
+ * zig/CAPI.md "Thread Safety"). All handle operations are async and run on
+ * koffi's worker thread pool so they never block the event loop; see the
+ * package README for a note on koffi's threadpool size.
+ *
+ * close() waits for every call this binding has dispatched (queued or
+ * in-flight) to finish before freeing the native handle, and rejects new
+ * calls immediately once close() has started. Node's own async FFI queueing
+ * means a call can be queued but not yet "entered" the C library when
+ * close() runs; libantfly's own close only drains calls that already entered
+ * it, so this extra bookkeeping is required to avoid a use-after-free.
+ */
+declare class Database implements AsyncDisposable {
+    #private;
+    readonly owner?: Database | undefined;
+    /** @internal use open()/create()/openHosted()/etc. instead of the constructor. */
+    constructor(native: NativeLibrary, handle: unknown, owner?: Database | undefined);
+    sqlJson(request: JsonInput): Promise<unknown>;
+    createTable(name: string, schema: JsonInput): Promise<void>;
+    dropTable(name: string): Promise<void>;
+    listTables(): Promise<string[]>;
+    openSqlSession(): Promise<Uint64Like>;
+    closeSqlSession(id: Uint64Like): Promise<void>;
+    openSqlCursor(request: JsonInput): Promise<Uint64Like>;
+    fetchSqlCursor(id: Uint64Like, rows?: number): Promise<unknown>;
+    closeSqlCursor(id: Uint64Like): Promise<void>;
+    /** Idempotent; waits for in-flight calls before freeing the native handle. Calls made after close() rejects with InvalidArgumentError. */
+    close(): Promise<void>;
+    [Symbol.asyncDispose](): Promise<void>;
+    /** Open a table-scoped document/schema/index/enrichment handle. */
+    openTable(name: string): Promise<Database>;
+    statusRaw(): Promise<Buffer>;
+    status(): Promise<Status>;
+    capabilitiesRaw(): Promise<Buffer>;
+    capabilities(): Promise<Capabilities>;
+    checkRaw(): Promise<Buffer>;
+    check(): Promise<CheckReport>;
+    vacuumRaw(): Promise<Buffer>;
+    vacuum(): Promise<VacuumReport>;
+    compactRaw(): Promise<Buffer>;
+    compact(): Promise<CompactReport>;
+    copyStableSnapshotRaw(destPath: string, replace: boolean): Promise<Buffer>;
+    copyStableSnapshot(destPath: string, replace: boolean): Promise<StableSnapshotReport>;
+    pendingWorkStatsRaw(): Promise<Buffer>;
+    pendingWorkStats(): Promise<PendingWorkStatus>;
+    /** Drains pending enrichment and index work; returns no result (see runUntilIdleStatus for the post-drain report). */
+    runUntilIdle(): Promise<void>;
+    runUntilIdleStatusRaw(): Promise<Buffer>;
+    runUntilIdleStatus(): Promise<PendingWorkStatus>;
+    replayGeneratedEnrichmentsRaw(): Promise<Buffer>;
+    replayGeneratedEnrichments(): Promise<ReplayGeneratedEnrichmentsResult>;
+    /** Returns a portable Antfly backup archive (.afb) of this database, which restores or imports into either storage kind. */
+    backup(): Promise<Buffer>;
+    /** Imports a portable Antfly backup archive into this empty database. OutcomeUnknown means the live handle adopted the imported generation, but crash durability could not be confirmed; inspect the handle and do not retry automatically. */
+    importBackup(backup: Uint8Array): Promise<void>;
+    backupToFile(path: string): Promise<void>;
+    batch(writes: WriteIntent[], timestampNs: Uint64Like): Promise<void>;
+    batchJsonRaw(request: JsonInput): Promise<Buffer>;
+    batchJson(request: JsonInput): Promise<unknown>;
+    lookupRaw(key: string | Uint8Array): Promise<Buffer>;
+    lookup(key: string | Uint8Array): Promise<unknown>;
+    /** Raw stored bytes for key (antfly_db_get_raw), not JSON. */
+    getRaw(key: string | Uint8Array): Promise<Buffer>;
+    getSchemaRaw(): Promise<Buffer>;
+    getSchema(): Promise<unknown>;
+    setSchema(schema: JsonInput): Promise<void>;
+    listIndexesRaw(): Promise<Buffer>;
+    listIndexes(): Promise<unknown>;
+    addIndex(config: JsonInput): Promise<void>;
+    deleteIndex(name: string): Promise<boolean>;
+    listEnrichmentsRaw(): Promise<Buffer>;
+    listEnrichments(): Promise<unknown>;
+    addEnrichment(config: JsonInput): Promise<void>;
+    deleteEnrichment(kind: string, name: string): Promise<boolean>;
+    scanRaw(request: JsonInput): Promise<Buffer>;
+    scan(request: JsonInput): Promise<unknown>;
+    statsRaw(): Promise<Buffer>;
+    stats(): Promise<unknown>;
+    searchRaw(request: JsonInput): Promise<Buffer>;
+    search(request: JsonInput): Promise<unknown>;
+    denseSearchWire(request: Uint8Array): Promise<Buffer>;
+    textMatchWire(request: Uint8Array): Promise<Buffer>;
+    textTermWire(request: Uint8Array): Promise<Buffer>;
+    textMatchPhraseWire(request: Uint8Array): Promise<Buffer>;
+    aggregateHitsRaw(request: JsonInput): Promise<Buffer>;
+    aggregateHits(request: JsonInput): Promise<unknown>;
+    lookupArtifactRaw(artifactIdBase64: string): Promise<Buffer>;
+    lookupArtifact(artifactIdBase64: string): Promise<unknown>;
+    extractEnrichmentsRaw(request: JsonInput): Promise<Buffer>;
+    extractEnrichments(request: JsonInput): Promise<unknown>;
+    computeEnrichmentsRaw(request: JsonInput): Promise<Buffer>;
+    computeEnrichments(request: JsonInput): Promise<unknown>;
+    edgesRaw(indexName: string, key: string, edgeType: string, direction: number): Promise<Buffer>;
+    edges(indexName: string, key: string, edgeType: string, direction: number): Promise<unknown>;
+    neighborsRaw(indexName: string, key: string, edgeType: string, direction: number): Promise<Buffer>;
+    neighbors(indexName: string, key: string, edgeType: string, direction: number): Promise<unknown>;
+    traverseEdgesRaw(request: JsonInput): Promise<Buffer>;
+    traverseEdges(request: JsonInput): Promise<unknown>;
+    executeGraphQueriesRaw(request: JsonInput): Promise<Buffer>;
+    executeGraphQueries(request: JsonInput): Promise<unknown>;
+    findShortestPathRaw(request: JsonInput): Promise<Buffer>;
+    findShortestPath(request: JsonInput): Promise<unknown>;
+    findKShortestPathsRaw(request: JsonInput): Promise<Buffer>;
+    findKShortestPaths(request: JsonInput): Promise<unknown>;
+    matchPatternRaw(request: JsonInput): Promise<Buffer>;
+    matchPattern(request: JsonInput): Promise<unknown>;
+    beginTransaction(txnId: Uint8Array | string, timestampNs: Uint64Like, participants?: string[]): Promise<void>;
+    writeTransaction(txnId: Uint8Array | string, writes: WriteIntent[]): Promise<void>;
+    resolveTransaction(txnId: Uint8Array | string, status: TxnStatus, commitVersion?: Uint64Like): Promise<void>;
+    transactionStatus(txnId: Uint8Array | string): Promise<TxnStatus>;
+    commitVersion(txnId: Uint8Array | string): Promise<bigint>;
+}
+/** Opens an existing native Antfly Lite database file for writing. */
+declare function open(path: string): Promise<Database>;
+/** Creates a new native Antfly Lite database file for writing. */
+declare function create(path: string): Promise<Database>;
+/** Opens an existing Antfly Lite database file read-only. */
+declare function openReadonly(path: string): Promise<Database>;
+/** Opens enough of an Antfly Lite database to read status. */
+declare function openStatusOnly(path: string): Promise<Database>;
+/** Opens an Antfly Lite database using explicit C ABI options. */
+declare function openWithOptions(path: string, options?: OpenOptions): Promise<Database>;
+/** Creates an Antfly Lite database using explicit C ABI options. */
+declare function createWithOptions(path: string, options?: OpenOptions): Promise<Database>;
+/**
+ * Opens an existing Antfly Lite database in hosted/manual maintenance mode.
+ * In this profile callers drive pending work explicitly with runUntilIdle.
+ */
+declare function openHosted(path: string): Promise<Database>;
+/**
+ * Creates a new Antfly Lite database in hosted/manual maintenance mode. In
+ * this profile callers drive pending work explicitly with runUntilIdle.
+ */
+declare function createHosted(path: string): Promise<Database>;
+
+export { openWithOptions as A, platformLibraryFileName as B, type CheckReport as C, Database as D, resolveLibrary as E, GraphDirection as G, type InferenceOptions as I, type JsonInput as J, LibraryNotFoundError as L, type MemoryAdmissionStats as M, type NativeLibrary as N, OpenMode as O, type PullProgress as P, type RestoreOptions as R, type StableSnapshotReport as S, THREADING_SERIALIZED as T, type Uint64Like as U, type VacuumReport as V, type WriteIntent as W, type Capabilities as a, type CompactReport as b, InferenceMode as c, type InferenceStatus as d, type LibrarySource as e, NATIVE_STACK_SIZE as f, type OpenOptions as g, type PendingWorkStatus as h, Profile as i, type ReplayGeneratedEnrichmentsResult as j, type ResolvedLibrary as k, SUPPORTED_ABI_VERSION as l, type Status as m, Storage as n, type StorageStatus as o, type TTLCleanupOptions as p, TxnStatus as q, UnsupportedPlatformError as r, create as s, createHosted as t, createWithOptions as u, embeddedPlatformPackageName as v, open as w, openHosted as x, openReadonly as y, openStatusOnly as z };