@antfly/embedded 0.0.0 → 0.3.0-rc.1

package/dist/index.js

@@ -0,0 +1,2057 @@
+import {
+  Connection,
+  SqlError,
+  __filename
+} from "./chunk-ELM44XQ4.js";
+
+// src/abi.ts
+import koffi2 from "koffi";
+
+// src/native.ts
+import koffi from "koffi";
+
+// src/discovery.ts
+import { existsSync as nodeExistsSync } from "fs";
+import { createRequire } from "module";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+var LibraryNotFoundError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "LibraryNotFoundError";
+  }
+};
+var UnsupportedPlatformError = class extends Error {
+  constructor(platform) {
+    super(`@antfly/embedded does not support platform ${platform}`);
+    this.name = "UnsupportedPlatformError";
+  }
+};
+function platformLibraryFileName(platform) {
+  switch (platform) {
+    case "darwin":
+      return "libantfly.dylib";
+    case "linux":
+      return "libantfly.so";
+    case "win32":
+      return "antfly.dll";
+    default:
+      return void 0;
+  }
+}
+function embeddedPlatformPackageName(platform, arch) {
+  if (platform === "darwin" && arch === "arm64") {
+    return "@antfly/embedded-darwin-arm64";
+  }
+  if (platform === "linux" && (arch === "arm64" || arch === "x64")) {
+    return `@antfly/embedded-linux-${arch}`;
+  }
+  return void 0;
+}
+function moduleFilename() {
+  return typeof __filename === "string" ? __filename : fileURLToPath(import.meta.url);
+}
+function defaultStartDir() {
+  return dirname(moduleFilename());
+}
+function findUp(startDir, relative, existsSync) {
+  let dir = startDir;
+  for (let i = 0; i < 16; i++) {
+    const candidate = join(dir, relative);
+    if (existsSync(candidate)) {
+      return candidate;
+    }
+    if (existsSync(join(dir, ".git"))) {
+      return void 0;
+    }
+    const parent = dirname(dir);
+    if (parent === dir) {
+      return void 0;
+    }
+    dir = parent;
+  }
+  return void 0;
+}
+function resolveLibrary(options = {}) {
+  const platform = options.platform ?? process.platform;
+  const arch = options.arch ?? process.arch;
+  const env = options.env ?? process.env;
+  const existsSync = options.existsSync ?? nodeExistsSync;
+  const fileName = platformLibraryFileName(platform);
+  if (!fileName) {
+    throw new UnsupportedPlatformError(platform);
+  }
+  const explicitLibrary = env.ANTFLY_LIBRARY;
+  if (explicitLibrary) {
+    if (!existsSync(explicitLibrary)) {
+      throw new LibraryNotFoundError(`ANTFLY_LIBRARY=${explicitLibrary} does not exist`);
+    }
+    return { path: explicitLibrary, source: "ANTFLY_LIBRARY" };
+  }
+  const libDir = env.ANTFLY_LIB_DIR;
+  if (libDir) {
+    const candidate = join(libDir, fileName);
+    if (!existsSync(candidate)) {
+      throw new LibraryNotFoundError(`ANTFLY_LIB_DIR=${libDir} does not contain ${fileName}`);
+    }
+    return { path: candidate, source: "ANTFLY_LIB_DIR" };
+  }
+  const packageName = embeddedPlatformPackageName(platform, arch);
+  if (packageName) {
+    try {
+      const resolve = options.resolve ?? createRequire(moduleFilename()).resolve;
+      const packageJsonPath = resolve(`${packageName}/package.json`);
+      const candidate = join(dirname(packageJsonPath), "lib", fileName);
+      if (existsSync(candidate)) {
+        return { path: candidate, source: "embedded-package" };
+      }
+    } catch {
+    }
+  }
+  const startDir = options.startDir ?? defaultStartDir();
+  const sourceTreeLibrary = findUp(startDir, join("zig", "zig-out", "lib", fileName), existsSync);
+  if (sourceTreeLibrary) {
+    return { path: sourceTreeLibrary, source: "source-tree" };
+  }
+  return { path: fileName, source: "system" };
+}
+
+// src/errors.ts
+var ErrorCode = /* @__PURE__ */ ((ErrorCode2) => {
+  ErrorCode2[ErrorCode2["OK"] = 0] = "OK";
+  ErrorCode2[ErrorCode2["InvalidArgument"] = 1] = "InvalidArgument";
+  ErrorCode2[ErrorCode2["NotFound"] = 2] = "NotFound";
+  ErrorCode2[ErrorCode2["VersionConflict"] = 3] = "VersionConflict";
+  ErrorCode2[ErrorCode2["IntentConflict"] = 4] = "IntentConflict";
+  ErrorCode2[ErrorCode2["TxnNotFound"] = 5] = "TxnNotFound";
+  ErrorCode2[ErrorCode2["Busy"] = 6] = "Busy";
+  ErrorCode2[ErrorCode2["OutcomeUnknown"] = 7] = "OutcomeUnknown";
+  ErrorCode2[ErrorCode2["Unsupported"] = 8] = "Unsupported";
+  ErrorCode2[ErrorCode2["Stalled"] = 9] = "Stalled";
+  ErrorCode2[ErrorCode2["Cancelled"] = 10] = "Cancelled";
+  ErrorCode2[ErrorCode2["Internal"] = 255] = "Internal";
+  return ErrorCode2;
+})(ErrorCode || {});
+var ERROR_CODE_NAMES = {
+  [0 /* OK */]: "ANTFLY_OK",
+  [1 /* InvalidArgument */]: "ANTFLY_INVALID_ARGUMENT",
+  [2 /* NotFound */]: "ANTFLY_NOT_FOUND",
+  [3 /* VersionConflict */]: "ANTFLY_VERSION_CONFLICT",
+  [4 /* IntentConflict */]: "ANTFLY_INTENT_CONFLICT",
+  [5 /* TxnNotFound */]: "ANTFLY_TXN_NOT_FOUND",
+  [6 /* Busy */]: "ANTFLY_BUSY",
+  [7 /* OutcomeUnknown */]: "ANTFLY_OUTCOME_UNKNOWN",
+  [8 /* Unsupported */]: "ANTFLY_UNSUPPORTED",
+  [9 /* Stalled */]: "ANTFLY_STALLED",
+  [10 /* Cancelled */]: "ANTFLY_CANCELLED",
+  [255 /* Internal */]: "ANTFLY_INTERNAL"
+};
+var ERROR_CODE_DESCRIPTIONS = {
+  [0 /* OK */]: "operation completed successfully",
+  [1 /* InvalidArgument */]: "an argument, request, path, or open mode is invalid",
+  [2 /* NotFound */]: "the requested database object was not found",
+  [3 /* VersionConflict */]: "a version predicate did not match the current document version",
+  [4 /* IntentConflict */]: "a transaction intent conflicts with the requested operation",
+  [5 /* TxnNotFound */]: "the requested transaction was not found",
+  [6 /* Busy */]: "the requested resource is temporarily busy or changed during streaming; stabilize it and retry",
+  [7 /* OutcomeUnknown */]: "the operation was published, but crash durability could not be confirmed; inspect the destination and do not retry automatically",
+  [8 /* Unsupported */]: "the operation requires a capability that is not supported by this platform or filesystem",
+  [9 /* Stalled */]: "derived work stalled or failed; inspect pending-work diagnostics and repair or reopen the database",
+  [10 /* Cancelled */]: "the caller cancelled the operation",
+  [255 /* Internal */]: "an internal error occurred"
+};
+function errorCodeName(code) {
+  return ERROR_CODE_NAMES[code] ?? "ANTFLY_UNKNOWN_ERROR";
+}
+function errorCodeDescription(code) {
+  return ERROR_CODE_DESCRIPTIONS[code] ?? "unknown Antfly error code";
+}
+var AntflyError = class extends Error {
+  code;
+  codeName;
+  /**
+   * Parsed JSON error body, when the failing call returned one. Currently
+   * only Inference calls populate this (embed/rerank/.../pull): libantfly
+   * always fills their antfly_buffer output with {"error": ..., "message":
+   * ...} on failure, even though the call also returns a non-OK error code.
+   */
+  body;
+  constructor(code, message) {
+    const codeName = errorCodeName(code);
+    super(message ?? `${codeName}: ${errorCodeDescription(code)}`);
+    this.name = "AntflyError";
+    this.code = code;
+    this.codeName = codeName;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var InvalidArgumentError = class extends AntflyError {
+  constructor(message) {
+    super(1 /* InvalidArgument */, message);
+    this.name = "InvalidArgumentError";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var NotFoundError = class extends AntflyError {
+  constructor(message) {
+    super(2 /* NotFound */, message);
+    this.name = "NotFoundError";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var VersionConflictError = class extends AntflyError {
+  constructor(message) {
+    super(3 /* VersionConflict */, message);
+    this.name = "VersionConflictError";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var IntentConflictError = class extends AntflyError {
+  constructor(message) {
+    super(4 /* IntentConflict */, message);
+    this.name = "IntentConflictError";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var TxnNotFoundError = class extends AntflyError {
+  constructor(message) {
+    super(5 /* TxnNotFound */, message);
+    this.name = "TxnNotFoundError";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var BusyError = class extends AntflyError {
+  constructor(message) {
+    super(6 /* Busy */, message);
+    this.name = "BusyError";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var OutcomeUnknownError = class extends AntflyError {
+  constructor(message) {
+    super(7 /* OutcomeUnknown */, message);
+    this.name = "OutcomeUnknownError";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var UnsupportedError = class extends AntflyError {
+  constructor(message) {
+    super(8 /* Unsupported */, message);
+    this.name = "UnsupportedError";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var StalledError = class extends AntflyError {
+  constructor(message) {
+    super(9 /* Stalled */, message);
+    this.name = "StalledError";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var CancelledError = class extends AntflyError {
+  constructor(message) {
+    super(10 /* Cancelled */, message);
+    this.name = "CancelledError";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var InternalError = class extends AntflyError {
+  constructor(message) {
+    super(255 /* Internal */, message);
+    this.name = "InternalError";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var ERROR_CLASSES = {
+  [1 /* InvalidArgument */]: InvalidArgumentError,
+  [2 /* NotFound */]: NotFoundError,
+  [3 /* VersionConflict */]: VersionConflictError,
+  [4 /* IntentConflict */]: IntentConflictError,
+  [5 /* TxnNotFound */]: TxnNotFoundError,
+  [6 /* Busy */]: BusyError,
+  [7 /* OutcomeUnknown */]: OutcomeUnknownError,
+  [8 /* Unsupported */]: UnsupportedError,
+  [9 /* Stalled */]: StalledError,
+  [10 /* Cancelled */]: CancelledError,
+  [255 /* Internal */]: InternalError
+};
+function errorFromCode(code, message) {
+  const Ctor = ERROR_CLASSES[code];
+  if (Ctor) {
+    return new Ctor(message);
+  }
+  return new AntflyError(code, message);
+}
+function checkCode(code) {
+  if (code !== 0 /* OK */) {
+    throw errorFromCode(code);
+  }
+}
+
+// src/types.ts
+var OpenMode = /* @__PURE__ */ ((OpenMode2) => {
+  OpenMode2[OpenMode2["Writer"] = 0] = "Writer";
+  OpenMode2[OpenMode2["Readonly"] = 1] = "Readonly";
+  OpenMode2[OpenMode2["StatusOnly"] = 2] = "StatusOnly";
+  return OpenMode2;
+})(OpenMode || {});
+var Storage = /* @__PURE__ */ ((Storage2) => {
+  Storage2[Storage2["Lite"] = 0] = "Lite";
+  Storage2[Storage2["Directory"] = 1] = "Directory";
+  return Storage2;
+})(Storage || {});
+var Profile = /* @__PURE__ */ ((Profile2) => {
+  Profile2[Profile2["Native"] = 0] = "Native";
+  Profile2[Profile2["Hosted"] = 1] = "Hosted";
+  return Profile2;
+})(Profile || {});
+var GraphDirection = /* @__PURE__ */ ((GraphDirection2) => {
+  GraphDirection2[GraphDirection2["Out"] = 0] = "Out";
+  GraphDirection2[GraphDirection2["In"] = 1] = "In";
+  GraphDirection2[GraphDirection2["Both"] = 2] = "Both";
+  return GraphDirection2;
+})(GraphDirection || {});
+var TxnStatus = /* @__PURE__ */ ((TxnStatus2) => {
+  TxnStatus2[TxnStatus2["Pending"] = 0] = "Pending";
+  TxnStatus2[TxnStatus2["Committed"] = 1] = "Committed";
+  TxnStatus2[TxnStatus2["Aborted"] = 2] = "Aborted";
+  return TxnStatus2;
+})(TxnStatus || {});
+var InferenceMode = {
+  CallerSuppliedOrDisabled: "caller_supplied_or_disabled",
+  CallerSuppliedArtifacts: "caller_supplied_artifacts",
+  RemoteProvider: "remote_provider",
+  LocalEmbedded: "local_embedded",
+  ManualMaintenance: "manual_maintenance",
+  DisabledDeferred: "disabled_deferred"
+};
+var THREADING_SERIALIZED = 1;
+var SUPPORTED_ABI_VERSION = 3;
+
+// src/native.ts
+var ANTFLY_STORAGE_KIND_DIRECTORY = 0;
+var ANTFLY_STORAGE_KIND_LITE = 1;
+function storageKind(storage) {
+  switch (storage ?? 0 /* Lite */) {
+    case 0 /* Lite */:
+      return ANTFLY_STORAGE_KIND_LITE;
+    case 1 /* Directory */:
+      return ANTFLY_STORAGE_KIND_DIRECTORY;
+    default:
+      throw new InvalidArgumentError(`invalid Storage value: ${storage}`);
+  }
+}
+var AntflySlice = koffi.struct("antfly_slice", {
+  ptr: "const uint8_t *",
+  len: "size_t"
+});
+var AntflyBuffer = koffi.struct("antfly_buffer", {
+  ptr: "uint8_t *",
+  len: "size_t"
+});
+var AntflyWriteIntent = koffi.struct("antfly_write_intent", {
+  key: AntflySlice,
+  value: AntflySlice,
+  is_delete: "bool"
+});
+var AntflyVersionPredicate = koffi.struct("antfly_version_predicate", {
+  key: AntflySlice,
+  expected_version: "uint64_t"
+});
+var AntflyDbOpaque = koffi.opaque("antfly_db");
+var PAntflyDb = koffi.pointer(AntflyDbOpaque);
+var PAntflyDbOut = koffi.out(koffi.pointer(AntflyDbOpaque, 2));
+var AntflyOpenOptions = koffi.struct("antfly_open_options", {
+  abi_size: "uint32_t",
+  storage_kind: "uint32_t",
+  open_mode: "uint32_t",
+  profile: "uint32_t",
+  flags: "uint32_t",
+  reserved0: "uint32_t",
+  map_size: "uint64_t",
+  ttl_cleanup_enabled: "bool",
+  ttl_cleanup_lease_owned: "bool",
+  ttl_cleanup_batch_size: "uint32_t",
+  ttl_cleanup_owner_id: AntflySlice,
+  ttl_cleanup_lease_ttl_ms: "uint64_t",
+  ttl_cleanup_interval_ms: "uint64_t",
+  ttl_cleanup_grace_period_ns: "uint64_t",
+  inference_host_budget_mb: "uint32_t",
+  inference_backend_budget_mb: "uint32_t",
+  inference_process_memory_budget_mb: "uint32_t",
+  inference_combined_budget_mb: "uint32_t",
+  inference_kv_budget_mb: "uint32_t",
+  inference_scratch_budget_mb: "uint32_t",
+  busy_timeout_ms: "uint64_t",
+  reserved: koffi.array("uint64_t", 8)
+});
+var PAntflyOpenOptions = koffi.pointer(AntflyOpenOptions);
+var PAntflyOpenOptionsOut = koffi.out(PAntflyOpenOptions);
+var PAntflyBufferOut = koffi.out(koffi.pointer(AntflyBuffer));
+var PAntflyWriteIntentArray = koffi.pointer(AntflyWriteIntent);
+var PAntflyVersionPredicateArray = koffi.pointer(AntflyVersionPredicate);
+var PAntflySliceArray = koffi.pointer(AntflySlice);
+var PUint8Out = koffi.out(koffi.pointer("uint8_t"));
+var PUint64Out = koffi.out(koffi.pointer("uint64_t"));
+var PBoolOut = koffi.out(koffi.pointer("bool"));
+var AntflyInferenceOpaque = koffi.opaque("antfly_inference");
+var PAntflyInference = koffi.pointer(AntflyInferenceOpaque);
+var PAntflyInferenceOut = koffi.out(koffi.pointer(AntflyInferenceOpaque, 2));
+var AntflyInferenceOptions = koffi.struct("antfly_inference_options", {
+  abi_size: "uint32_t",
+  flags: "uint32_t",
+  models_dir: AntflySlice,
+  host_budget_mb: "uint32_t",
+  backend_budget_mb: "uint32_t",
+  process_memory_budget_mb: "uint32_t",
+  combined_budget_mb: "uint32_t",
+  kv_budget_mb: "uint32_t",
+  scratch_budget_mb: "uint32_t",
+  call_timeout_ms: "uint64_t",
+  reserved: koffi.array("uint64_t", 8)
+});
+var PAntflyInferenceOptions = koffi.pointer(AntflyInferenceOptions);
+var PAntflyInferenceOptionsOut = koffi.out(PAntflyInferenceOptions);
+var AntflyInferencePullProgress = koffi.struct("antfly_inference_pull_progress", {
+  abi_size: "uint32_t",
+  reserved0: "uint32_t",
+  model: AntflySlice,
+  file: AntflySlice,
+  bytes_downloaded: "uint64_t",
+  total_bytes: "uint64_t",
+  files_done: "uint64_t",
+  files_total: "uint64_t",
+  cached: "bool"
+});
+var AntflyInferencePullProgressFnProto = koffi.proto(
+  "antfly_inference_pull_progress_fn",
+  "bool",
+  ["void *", koffi.pointer(AntflyInferencePullProgress)]
+);
+var PAntflyInferencePullProgressFn = koffi.pointer(AntflyInferencePullProgressFnProto);
+var AntflyInferenceStreamFnProto = koffi.proto("antfly_inference_stream_fn", "bool", [
+  "void *",
+  AntflySlice
+]);
+var PAntflyInferenceStreamFn = koffi.pointer(AntflyInferenceStreamFnProto);
+var cached;
+var cachedError;
+function loadNative() {
+  if (cached) {
+    return cached;
+  }
+  if (cachedError) {
+    throw cachedError;
+  }
+  try {
+    cached = buildNative();
+    return cached;
+  } catch (err) {
+    cachedError = err;
+    throw err;
+  }
+}
+var NATIVE_STACK_SIZE = 8 * 1024 * 1024;
+function configureKoffiStacks() {
+  const current = koffi.config();
+  if ((current.sync_stack_size ?? 0) >= NATIVE_STACK_SIZE && (current.async_stack_size ?? 0) >= NATIVE_STACK_SIZE) {
+    return;
+  }
+  koffi.config({
+    ...current,
+    sync_stack_size: Math.max(current.sync_stack_size ?? 0, NATIVE_STACK_SIZE),
+    async_stack_size: Math.max(current.async_stack_size ?? 0, NATIVE_STACK_SIZE)
+  });
+}
+function buildNative() {
+  const resolved = resolveLibrary();
+  configureKoffiStacks();
+  const handle = koffi.load(resolved.path);
+  const f = handle.func.bind(handle);
+  return {
+    handle,
+    resolved,
+    abiVersion: f("antfly_abi_version", "uint32_t", []),
+    threadingMode: f("antfly_threading_mode", "uint32_t", []),
+    openOptionsSize: f("antfly_open_options_size", "uint32_t", []),
+    errorCodeName: f("antfly_error_code_name", "str", ["uint32_t"]),
+    errorCodeDescription: f("antfly_error_code_description", "str", ["uint32_t"]),
+    openOptionsInit: f("antfly_open_options_init", "uint32_t", [PAntflyOpenOptionsOut]),
+    dbOpenWithOptions: f("antfly_db_open_with_options", "uint32_t", [
+      "str",
+      PAntflyOpenOptions,
+      PAntflyDbOut
+    ]),
+    dbCreateWithOptions: f("antfly_db_create_with_options", "uint32_t", [
+      "str",
+      PAntflyOpenOptions,
+      PAntflyDbOut
+    ]),
+    liteOpenHosted: f("antfly_lite_open_hosted", "uint32_t", ["str", PAntflyDbOut]),
+    liteCreateHosted: f("antfly_lite_create_hosted", "uint32_t", ["str", PAntflyDbOut]),
+    dbClose: f("antfly_db_close", "void", [PAntflyDb]),
+    bufferFree: f("antfly_buffer_free", "void", [koffi.pointer(AntflyBuffer)]),
+    dbSqlJson: f("antfly_db_sql_json", "uint32_t", [PAntflyDb, AntflySlice, PAntflyBufferOut]),
+    dbOpenTable: f("antfly_db_open_table", "uint32_t", [PAntflyDb, AntflySlice, PAntflyDbOut]),
+    dbCreateTableJson: f("antfly_db_create_table_json", "uint32_t", [
+      PAntflyDb,
+      AntflySlice,
+      AntflySlice
+    ]),
+    dbDropTable: f("antfly_db_drop_table", "uint32_t", [PAntflyDb, AntflySlice]),
+    dbListTablesJson: f("antfly_db_list_tables_json", "uint32_t", [PAntflyDb, PAntflyBufferOut]),
+    dbSqlSessionOpen: f("antfly_db_sql_session_open", "uint32_t", [
+      PAntflyDb,
+      koffi.out(koffi.pointer("uint64_t"))
+    ]),
+    dbSqlSessionClose: f("antfly_db_sql_session_close", "uint32_t", [PAntflyDb, "uint64_t"]),
+    dbSqlOpenCursorJson: f("antfly_db_sql_open_cursor_json", "uint32_t", [
+      PAntflyDb,
+      AntflySlice,
+      koffi.out(koffi.pointer("uint64_t")),
+      PAntflyBufferOut
+    ]),
+    dbSqlFetchCursorJson: f("antfly_db_sql_fetch_cursor_json", "uint32_t", [
+      PAntflyDb,
+      "uint64_t",
+      "uint32_t",
+      PAntflyBufferOut
+    ]),
+    dbSqlCloseCursor: f("antfly_db_sql_close_cursor", "uint32_t", [PAntflyDb, "uint64_t"]),
+    dbStatusJson: f("antfly_db_status_json", "uint32_t", [PAntflyDb, PAntflyBufferOut]),
+    dbCapabilitiesJson: f("antfly_db_capabilities_json", "uint32_t", [PAntflyDb, PAntflyBufferOut]),
+    dbBackup: f("antfly_db_backup", "uint32_t", [PAntflyDb, PAntflyBufferOut]),
+    dbImportBackup: f("antfly_db_import_backup", "uint32_t", [PAntflyDb, AntflySlice]),
+    restoreBackupJson: f("antfly_restore_backup_json", "uint32_t", [
+      "str",
+      PAntflyOpenOptions,
+      AntflySlice,
+      "bool",
+      PAntflyBufferOut
+    ]),
+    restoreBackupFileJson: f("antfly_restore_backup_file_json", "uint32_t", [
+      "str",
+      PAntflyOpenOptions,
+      "str",
+      "bool",
+      PAntflyBufferOut
+    ]),
+    liteCheckJson: f("antfly_lite_check_json", "uint32_t", [PAntflyDb, PAntflyBufferOut]),
+    liteCheckFileJson: f("antfly_lite_check_file_json", "uint32_t", ["str", PAntflyBufferOut]),
+    liteCopyStableSnapshotJson: f("antfly_lite_copy_stable_snapshot_json", "uint32_t", [
+      PAntflyDb,
+      "str",
+      "bool",
+      PAntflyBufferOut
+    ]),
+    liteCopyStableSnapshotFileJson: f("antfly_lite_copy_stable_snapshot_file_json", "uint32_t", [
+      "str",
+      "str",
+      "bool",
+      PAntflyBufferOut
+    ]),
+    liteCompactJson: f("antfly_lite_compact_json", "uint32_t", [PAntflyDb, PAntflyBufferOut]),
+    liteVacuumJson: f("antfly_lite_vacuum_json", "uint32_t", [PAntflyDb, PAntflyBufferOut]),
+    dbRunUntilIdle: f("antfly_db_run_until_idle", "uint32_t", [PAntflyDb]),
+    dbRunUntilIdleJson: f("antfly_db_run_until_idle_json", "uint32_t", [
+      PAntflyDb,
+      PAntflyBufferOut
+    ]),
+    dbReplayGeneratedEnrichmentsJson: f("antfly_db_replay_generated_enrichments_json", "uint32_t", [
+      PAntflyDb,
+      PAntflyBufferOut
+    ]),
+    dbPendingWorkStatsJson: f("antfly_db_pending_work_stats_json", "uint32_t", [
+      PAntflyDb,
+      PAntflyBufferOut
+    ]),
+    dbBatch: f("antfly_db_batch", "uint32_t", [
+      PAntflyDb,
+      PAntflyWriteIntentArray,
+      "size_t",
+      PAntflyVersionPredicateArray,
+      "size_t",
+      "uint64_t",
+      "uint8_t"
+    ]),
+    dbBatchJson: f("antfly_db_batch_json", "uint32_t", [PAntflyDb, AntflySlice, PAntflyBufferOut]),
+    dbBeginTransactionWithId: f("antfly_db_begin_transaction_with_id", "uint32_t", [
+      PAntflyDb,
+      "const uint8_t *",
+      "uint64_t",
+      PAntflySliceArray,
+      "size_t"
+    ]),
+    dbWriteTransaction: f("antfly_db_write_transaction", "uint32_t", [
+      PAntflyDb,
+      "const uint8_t *",
+      PAntflyWriteIntentArray,
+      "size_t",
+      PAntflyVersionPredicateArray,
+      "size_t"
+    ]),
+    dbResolveIntents: f("antfly_db_resolve_intents", "uint32_t", [
+      PAntflyDb,
+      "const uint8_t *",
+      "uint8_t",
+      "uint64_t"
+    ]),
+    dbGetTransactionStatus: f("antfly_db_get_transaction_status", "uint32_t", [
+      PAntflyDb,
+      "const uint8_t *",
+      PUint8Out
+    ]),
+    dbGetCommitVersion: f("antfly_db_get_commit_version", "uint32_t", [
+      PAntflyDb,
+      "const uint8_t *",
+      PUint64Out
+    ]),
+    dbLookupJson: f("antfly_db_lookup_json", "uint32_t", [
+      PAntflyDb,
+      AntflySlice,
+      PAntflyBufferOut
+    ]),
+    dbGetRaw: f("antfly_db_get_raw", "uint32_t", [PAntflyDb, AntflySlice, PAntflyBufferOut]),
+    dbGetSchemaJson: f("antfly_db_get_schema_json", "uint32_t", [PAntflyDb, PAntflyBufferOut]),
+    dbSetSchemaJson: f("antfly_db_set_schema_json", "uint32_t", [PAntflyDb, AntflySlice]),
+    dbListIndexesJson: f("antfly_db_list_indexes_json", "uint32_t", [PAntflyDb, PAntflyBufferOut]),
+    dbAddIndexJson: f("antfly_db_add_index_json", "uint32_t", [PAntflyDb, AntflySlice]),
+    dbDeleteIndex: f("antfly_db_delete_index", "uint32_t", [PAntflyDb, AntflySlice, PBoolOut]),
+    dbListEnrichmentsJson: f("antfly_db_list_enrichments_json", "uint32_t", [
+      PAntflyDb,
+      PAntflyBufferOut
+    ]),
+    dbAddEnrichmentJson: f("antfly_db_add_enrichment_json", "uint32_t", [PAntflyDb, AntflySlice]),
+    dbDeleteEnrichment: f("antfly_db_delete_enrichment", "uint32_t", [
+      PAntflyDb,
+      AntflySlice,
+      AntflySlice,
+      PBoolOut
+    ]),
+    dbScanJson: f("antfly_db_scan_json", "uint32_t", [PAntflyDb, AntflySlice, PAntflyBufferOut]),
+    dbStatsJson: f("antfly_db_stats_json", "uint32_t", [PAntflyDb, PAntflyBufferOut]),
+    dbSearchJson: f("antfly_db_search_json", "uint32_t", [
+      PAntflyDb,
+      AntflySlice,
+      PAntflyBufferOut
+    ]),
+    dbSearchDenseWire: f("antfly_db_search_dense_wire", "uint32_t", [
+      PAntflyDb,
+      AntflySlice,
+      PAntflyBufferOut
+    ]),
+    dbSearchTextMatchWire: f("antfly_db_search_text_match_wire", "uint32_t", [
+      PAntflyDb,
+      AntflySlice,
+      PAntflyBufferOut
+    ]),
+    dbSearchTextTermWire: f("antfly_db_search_text_term_wire", "uint32_t", [
+      PAntflyDb,
+      AntflySlice,
+      PAntflyBufferOut
+    ]),
+    dbSearchTextMatchPhraseWire: f("antfly_db_search_text_match_phrase_wire", "uint32_t", [
+      PAntflyDb,
+      AntflySlice,
+      PAntflyBufferOut
+    ]),
+    dbAggregateHitsJson: f("antfly_db_aggregate_hits_json", "uint32_t", [
+      PAntflyDb,
+      AntflySlice,
+      PAntflyBufferOut
+    ]),
+    dbLookupArtifactJson: f("antfly_db_lookup_artifact_json", "uint32_t", [
+      PAntflyDb,
+      AntflySlice,
+      PAntflyBufferOut
+    ]),
+    decodeArtifactIdJson: f("antfly_decode_artifact_id_json", "uint32_t", [
+      AntflySlice,
+      PAntflyBufferOut
+    ]),
+    dbExtractEnrichmentsJson: f("antfly_db_extract_enrichments_json", "uint32_t", [
+      PAntflyDb,
+      AntflySlice,
+      PAntflyBufferOut
+    ]),
+    dbComputeEnrichmentsJson: f("antfly_db_compute_enrichments_json", "uint32_t", [
+      PAntflyDb,
+      AntflySlice,
+      PAntflyBufferOut
+    ]),
+    dbGetEdgesJson: f("antfly_db_get_edges_json", "uint32_t", [
+      PAntflyDb,
+      AntflySlice,
+      AntflySlice,
+      AntflySlice,
+      "uint8_t",
+      PAntflyBufferOut
+    ]),
+    dbTraverseEdgesJson: f("antfly_db_traverse_edges_json", "uint32_t", [
+      PAntflyDb,
+      AntflySlice,
+      PAntflyBufferOut
+    ]),
+    dbExecuteGraphQueriesJson: f("antfly_db_execute_graph_queries_json", "uint32_t", [
+      PAntflyDb,
+      AntflySlice,
+      PAntflyBufferOut
+    ]),
+    dbGetNeighborsJson: f("antfly_db_get_neighbors_json", "uint32_t", [
+      PAntflyDb,
+      AntflySlice,
+      AntflySlice,
+      AntflySlice,
+      "uint8_t",
+      PAntflyBufferOut
+    ]),
+    dbFindShortestPathJson: f("antfly_db_find_shortest_path_json", "uint32_t", [
+      PAntflyDb,
+      AntflySlice,
+      PAntflyBufferOut
+    ]),
+    dbFindKShortestPathsJson: f("antfly_db_find_k_shortest_paths_json", "uint32_t", [
+      PAntflyDb,
+      AntflySlice,
+      PAntflyBufferOut
+    ]),
+    dbMatchPatternJson: f("antfly_db_match_pattern_json", "uint32_t", [
+      PAntflyDb,
+      AntflySlice,
+      PAntflyBufferOut
+    ]),
+    // --- Embedded inference (antfly_inference_*) ---
+    inferenceOptionsSize: f("antfly_inference_options_size", "uint32_t", []),
+    inferenceOptionsInit: f("antfly_inference_options_init", "uint32_t", [
+      PAntflyInferenceOptionsOut
+    ]),
+    inferenceOpen: f("antfly_inference_open", "uint32_t", [
+      PAntflyInferenceOptions,
+      PAntflyInferenceOut
+    ]),
+    inferenceClose: f("antfly_inference_close", "void", [PAntflyInference]),
+    inferenceEmbedJson: f("antfly_inference_embed_json", "uint32_t", [
+      PAntflyInference,
+      AntflySlice,
+      PAntflyBufferOut
+    ]),
+    inferenceRerankJson: f("antfly_inference_rerank_json", "uint32_t", [
+      PAntflyInference,
+      AntflySlice,
+      PAntflyBufferOut
+    ]),
+    inferenceChunkJson: f("antfly_inference_chunk_json", "uint32_t", [
+      PAntflyInference,
+      AntflySlice,
+      PAntflyBufferOut
+    ]),
+    inferenceGenerateJson: f("antfly_inference_generate_json", "uint32_t", [
+      PAntflyInference,
+      AntflySlice,
+      PAntflyBufferOut
+    ]),
+    inferenceGenerateStreamJson: f("antfly_inference_generate_stream_json", "uint32_t", [
+      PAntflyInference,
+      AntflySlice,
+      PAntflyInferenceStreamFn,
+      "void *",
+      PAntflyBufferOut
+    ]),
+    inferenceGenerateBatchJson: f("antfly_inference_generate_batch_json", "uint32_t", [
+      PAntflyInference,
+      AntflySlice,
+      PAntflyBufferOut
+    ]),
+    inferenceRewriteJson: f("antfly_inference_rewrite_json", "uint32_t", [
+      PAntflyInference,
+      AntflySlice,
+      PAntflyBufferOut
+    ]),
+    inferenceDecideJson: f("antfly_inference_decide_json", "uint32_t", [
+      PAntflyInference,
+      AntflySlice,
+      PAntflyBufferOut
+    ]),
+    inferenceExtractJson: f("antfly_inference_extract_json", "uint32_t", [
+      PAntflyInference,
+      AntflySlice,
+      PAntflyBufferOut
+    ]),
+    inferenceReadJson: f("antfly_inference_read_json", "uint32_t", [
+      PAntflyInference,
+      AntflySlice,
+      PAntflyBufferOut
+    ]),
+    inferenceTranscribeJson: f("antfly_inference_transcribe_json", "uint32_t", [
+      PAntflyInference,
+      AntflySlice,
+      PAntflyBufferOut
+    ]),
+    inferenceListModelsJson: f("antfly_inference_list_models_json", "uint32_t", [
+      PAntflyInference,
+      PAntflyBufferOut
+    ]),
+    inferencePullJson: f("antfly_inference_pull_json", "uint32_t", [
+      PAntflyInference,
+      AntflySlice,
+      PAntflyInferencePullProgressFn,
+      "void *",
+      PAntflyBufferOut
+    ])
+  };
+}
+
+// src/abi.ts
+var AbiMismatchError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "AbiMismatchError";
+  }
+};
+function abiVersion() {
+  return loadNative().abiVersion();
+}
+function threadingMode() {
+  return loadNative().threadingMode();
+}
+function validateAbi() {
+  const native = loadNative();
+  const gotVersion = native.abiVersion();
+  if (gotVersion !== SUPPORTED_ABI_VERSION) {
+    throw new AbiMismatchError(
+      `lite: unsupported C ABI version ${gotVersion}, want ${SUPPORTED_ABI_VERSION}`
+    );
+  }
+  const gotSize = native.openOptionsSize();
+  const wantSize = koffi2.sizeof(AntflyOpenOptions);
+  if (gotSize !== wantSize) {
+    throw new AbiMismatchError(
+      `lite: C ABI open options size ${gotSize}, compiled header size ${wantSize}`
+    );
+  }
+}
+function validateInferenceAbi() {
+  const native = loadNative();
+  const gotSize = native.inferenceOptionsSize();
+  const wantSize = koffi2.sizeof(AntflyInferenceOptions);
+  if (gotSize !== wantSize) {
+    throw new AbiMismatchError(
+      `lite: C ABI inference options size ${gotSize}, compiled header size ${wantSize}`
+    );
+  }
+}
+
+// src/database.ts
+import * as fsp from "fs/promises";
+import { basename, dirname as dirname2, join as join2 } from "path";
+
+// src/marshal.ts
+import { promisify } from "util";
+import koffi3 from "koffi";
+function toRawBytes(input) {
+  if (Buffer.isBuffer(input)) {
+    return input;
+  }
+  if (input instanceof Uint8Array) {
+    return Buffer.from(input.buffer, input.byteOffset, input.byteLength);
+  }
+  throw new InvalidArgumentError(`expected Buffer or Uint8Array, got ${typeof input}`);
+}
+function toJsonBytes(input) {
+  if (typeof input === "string") {
+    return Buffer.from(input, "utf8");
+  }
+  if (Buffer.isBuffer(input) || input instanceof Uint8Array) {
+    return toRawBytes(input);
+  }
+  return Buffer.from(JSON.stringify(input), "utf8");
+}
+function sliceOf(bytes) {
+  return bytes.length === 0 ? { ptr: null, len: 0 } : { ptr: bytes, len: bytes.length };
+}
+function jsonSlice(input) {
+  return sliceOf(toJsonBytes(input));
+}
+function stringSlice(input) {
+  return sliceOf(Buffer.from(input, "utf8"));
+}
+function parseJson(buf) {
+  if (buf.length === 0) {
+    return null;
+  }
+  return JSON.parse(buf.toString("utf8"));
+}
+function newBufferOut() {
+  return { ptr: null, len: 0 };
+}
+function takeBuffer(native, out) {
+  try {
+    const len = Number(out.len ?? 0);
+    if (!out.ptr || len === 0) {
+      return Buffer.alloc(0);
+    }
+    const view = koffi3.decode(out.ptr, "uint8_t", len);
+    return Buffer.from(view);
+  } finally {
+    native.bufferFree(out);
+  }
+}
+function callAsync(fn, ...args) {
+  const bound = promisify(fn.async.bind(fn));
+  return withNativeSlot(() => bound(...args));
+}
+var nativeSlots = Math.max(1, Number.parseInt(process.env.UV_THREADPOOL_SIZE ?? "", 10) || 4);
+var nativeActive = 0;
+var nativeWaiters = [];
+async function withNativeSlot(run) {
+  if (nativeActive >= nativeSlots) {
+    await new Promise((resolve) => nativeWaiters.push(resolve));
+  } else {
+    nativeActive++;
+  }
+  try {
+    return await run();
+  } finally {
+    const next = nativeWaiters.shift();
+    if (next) {
+      next();
+    } else {
+      nativeActive--;
+    }
+  }
+}
+function txnIdBytes(id) {
+  if (typeof id === "string") {
+    if (!/^[0-9a-fA-F]{32}$/.test(id)) {
+      throw new InvalidArgumentError(`txnId must be 32 hex characters, got ${JSON.stringify(id)}`);
+    }
+    return Buffer.from(id, "hex");
+  }
+  const buf = toRawBytes(id);
+  if (buf.length !== 16) {
+    throw new InvalidArgumentError(`txnId must be 16 bytes, got ${buf.length}`);
+  }
+  return buf;
+}
+
+// src/database.ts
+var OPEN_FLAG_NO_SYNC = 1 << 0;
+var OPEN_FLAG_TTL_CLEANUP = 1 << 1;
+var OPEN_FLAG_REMOTE_PROVIDER_CONFIGURED = 1 << 2;
+var OPEN_FLAG_LOCAL_RUNTIME_CONFIGURED = 1 << 3;
+var OPEN_FLAG_GENERATED_ENRICHMENT_REPLAY = 1 << 4;
+function buildOpenOptionsStruct(native, opts) {
+  const options = {};
+  checkCode(native.openOptionsInit(options));
+  options.storage_kind = storageKind(opts.storage);
+  options.open_mode = opts.mode ?? 0 /* Writer */;
+  options.profile = opts.profile ?? 0 /* Native */;
+  let flags = 0;
+  if (opts.noSync) flags |= OPEN_FLAG_NO_SYNC;
+  if (opts.remoteProviderConfigured) flags |= OPEN_FLAG_REMOTE_PROVIDER_CONFIGURED;
+  if (opts.localRuntimeConfigured) flags |= OPEN_FLAG_LOCAL_RUNTIME_CONFIGURED;
+  if (opts.generatedEnrichmentReplay) flags |= OPEN_FLAG_GENERATED_ENRICHMENT_REPLAY;
+  if (opts.ttlCleanup) flags |= OPEN_FLAG_TTL_CLEANUP;
+  options.flags = flags;
+  options.map_size = opts.mapSize ?? 0;
+  options.inference_host_budget_mb = opts.inferenceHostBudgetMb ?? 0;
+  options.inference_backend_budget_mb = opts.inferenceBackendBudgetMb ?? 0;
+  options.inference_combined_budget_mb = opts.inferenceCombinedBudgetMb ?? 0;
+  options.inference_kv_budget_mb = opts.inferenceKvBudgetMb ?? 0;
+  options.inference_scratch_budget_mb = opts.inferenceScratchBudgetMb ?? 0;
+  options.inference_process_memory_budget_mb = opts.inferenceProcessMemoryBudgetMb ?? 0;
+  options.busy_timeout_ms = opts.busyTimeoutMs ?? 0;
+  if (opts.ttlCleanup) {
+    const ttl = opts.ttlCleanup;
+    options.ttl_cleanup_enabled = ttl.enabled;
+    options.ttl_cleanup_lease_owned = ttl.leaseOwned;
+    options.ttl_cleanup_batch_size = ttl.batchSize ?? 0;
+    options.ttl_cleanup_owner_id = stringSlice(ttl.ownerId ?? "");
+    options.ttl_cleanup_lease_ttl_ms = ttl.leaseTtlMs ?? 0;
+    options.ttl_cleanup_interval_ms = ttl.intervalMs ?? 0;
+    options.ttl_cleanup_grace_period_ns = ttl.gracePeriodNs ?? 0;
+  }
+  return options;
+}
+function keySlice(key) {
+  return typeof key === "string" ? stringSlice(key) : sliceOf(toRawBytes(key));
+}
+function writeIntentValueBytes(w) {
+  if (w.delete || w.value == null) {
+    return Buffer.alloc(0);
+  }
+  if (w.value instanceof Uint8Array) {
+    return toRawBytes(w.value);
+  }
+  return Buffer.from(JSON.stringify(w.value), "utf8");
+}
+function toNativeWriteIntent(w) {
+  return {
+    key: stringSlice(w.key),
+    value: sliceOf(writeIntentValueBytes(w)),
+    is_delete: Boolean(w.delete)
+  };
+}
+var Database = class _Database {
+  /** @internal use open()/create()/openHosted()/etc. instead of the constructor. */
+  constructor(native, handle, owner) {
+    this.owner = owner;
+    this.#native = native;
+    this.#handle = handle;
+    finalizationRegistry.register(this, { native, handle }, this.#finalizerToken);
+  }
+  owner;
+  #native;
+  #handle;
+  #state = "open";
+  #pending = /* @__PURE__ */ new Set();
+  #closeTask;
+  #finalizerToken = {};
+  #run(op) {
+    if (this.#state !== "open") {
+      return Promise.reject(new InvalidArgumentError("database handle is closed"));
+    }
+    const handle = this.#handle;
+    const promise = op(handle);
+    this.#pending.add(promise);
+    const cleanup = () => this.#pending.delete(promise);
+    promise.then(cleanup, cleanup);
+    return promise;
+  }
+  // biome-ignore lint/suspicious/noExplicitAny: koffi function signatures vary per call site
+  #invokeCode(fn, ...args) {
+    return this.#run(async (handle) => {
+      const code = await callAsync(fn, handle, ...args);
+      checkCode(code);
+    });
+  }
+  // biome-ignore lint/suspicious/noExplicitAny: koffi function signatures vary per call site
+  #invokeBuffer(fn, ...args) {
+    return this.#run(async (handle) => {
+      const out = newBufferOut();
+      const code = await callAsync(fn, handle, ...args, out);
+      checkCode(code);
+      return takeBuffer(this.#native, out);
+    });
+  }
+  // SQL buffers must be released on failures as well as successful calls.
+  // biome-ignore lint/suspicious/noExplicitAny: native signatures vary
+  #invokeSql(fn, ...args) {
+    return this.#run(async (handle) => {
+      const out = newBufferOut();
+      const code = await callAsync(fn, handle, ...args, out);
+      const body = takeBuffer(this.#native, out);
+      const value = body.length ? JSON.parse(body.toString("utf8")) : void 0;
+      if (code && value?.error) throw new SqlError(value.error, value.transaction_id);
+      checkCode(code);
+      return value;
+    });
+  }
+  sqlJson(request) {
+    return this.#invokeSql(this.#native.dbSqlJson, jsonSlice(request));
+  }
+  createTable(name, schema) {
+    return this.#invokeCode(this.#native.dbCreateTableJson, stringSlice(name), jsonSlice(schema));
+  }
+  dropTable(name) {
+    return this.#invokeCode(this.#native.dbDropTable, stringSlice(name));
+  }
+  async listTables() {
+    return parseJson(await this.#invokeBuffer(this.#native.dbListTablesJson));
+  }
+  async openSqlSession() {
+    return this.#run(async (handle) => {
+      const out = [0];
+      checkCode(await callAsync(this.#native.dbSqlSessionOpen, handle, out));
+      return out[0];
+    });
+  }
+  closeSqlSession(id) {
+    return this.#invokeCode(this.#native.dbSqlSessionClose, id);
+  }
+  async openSqlCursor(request) {
+    const out = [0];
+    await this.#invokeSql(this.#native.dbSqlOpenCursorJson, jsonSlice(request), out);
+    return out[0];
+  }
+  fetchSqlCursor(id, rows = 128) {
+    return this.#invokeSql(this.#native.dbSqlFetchCursorJson, id, rows);
+  }
+  closeSqlCursor(id) {
+    return this.#invokeCode(this.#native.dbSqlCloseCursor, id);
+  }
+  // --- Lifecycle ---
+  /** Idempotent; waits for in-flight calls before freeing the native handle. Calls made after close() rejects with InvalidArgumentError. */
+  async close() {
+    if (this.#state === "closed") return;
+    if (this.#state === "closing") {
+      await this.#closeTask;
+      return;
+    }
+    this.#state = "closing";
+    finalizationRegistry.unregister(this.#finalizerToken);
+    const handle = this.#handle;
+    this.#closeTask = (async () => {
+      while (this.#pending.size > 0) {
+        await Promise.allSettled([...this.#pending]);
+      }
+      if (handle != null) {
+        await callAsync(this.#native.dbClose, handle);
+      }
+      this.#handle = null;
+      this.#state = "closed";
+    })();
+    await this.#closeTask;
+  }
+  async [Symbol.asyncDispose]() {
+    await this.close();
+  }
+  /** Open a table-scoped document/schema/index/enrichment handle. */
+  async openTable(name) {
+    const out = [null];
+    await this.#invokeCode(this.#native.dbOpenTable, stringSlice(name), out);
+    return new _Database(this.#native, out[0], this);
+  }
+  // --- Status / capabilities / maintenance ---
+  statusRaw() {
+    return this.#invokeBuffer(this.#native.dbStatusJson);
+  }
+  async status() {
+    return parseJson(await this.statusRaw());
+  }
+  capabilitiesRaw() {
+    return this.#invokeBuffer(this.#native.dbCapabilitiesJson);
+  }
+  async capabilities() {
+    return parseJson(await this.capabilitiesRaw());
+  }
+  checkRaw() {
+    return this.#invokeBuffer(this.#native.liteCheckJson);
+  }
+  async check() {
+    return parseJson(await this.checkRaw());
+  }
+  vacuumRaw() {
+    return this.#invokeBuffer(this.#native.liteVacuumJson);
+  }
+  async vacuum() {
+    return parseJson(await this.vacuumRaw());
+  }
+  compactRaw() {
+    return this.#invokeBuffer(this.#native.liteCompactJson);
+  }
+  async compact() {
+    return parseJson(await this.compactRaw());
+  }
+  copyStableSnapshotRaw(destPath, replace) {
+    if (!destPath.endsWith(".aflite")) {
+      return Promise.reject(new InvalidArgumentError("destPath must end with .aflite"));
+    }
+    return this.#invokeBuffer(this.#native.liteCopyStableSnapshotJson, destPath, replace);
+  }
+  async copyStableSnapshot(destPath, replace) {
+    return parseJson(await this.copyStableSnapshotRaw(destPath, replace));
+  }
+  pendingWorkStatsRaw() {
+    return this.#invokeBuffer(this.#native.dbPendingWorkStatsJson);
+  }
+  async pendingWorkStats() {
+    return parseJson(await this.pendingWorkStatsRaw());
+  }
+  /** Drains pending enrichment and index work; returns no result (see runUntilIdleStatus for the post-drain report). */
+  runUntilIdle() {
+    return this.#invokeCode(this.#native.dbRunUntilIdle);
+  }
+  runUntilIdleStatusRaw() {
+    return this.#invokeBuffer(this.#native.dbRunUntilIdleJson);
+  }
+  async runUntilIdleStatus() {
+    return parseJson(await this.runUntilIdleStatusRaw());
+  }
+  replayGeneratedEnrichmentsRaw() {
+    return this.#invokeBuffer(this.#native.dbReplayGeneratedEnrichmentsJson);
+  }
+  async replayGeneratedEnrichments() {
+    return parseJson(
+      await this.replayGeneratedEnrichmentsRaw()
+    );
+  }
+  // --- Backup / import ---
+  /** Returns a portable Antfly backup archive (.afb) of this database, which restores or imports into either storage kind. */
+  backup() {
+    return this.#invokeBuffer(this.#native.dbBackup);
+  }
+  /** 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) {
+    return this.#invokeCode(this.#native.dbImportBackup, sliceOf(toRawBytes(backup)));
+  }
+  async backupToFile(path) {
+    if (!path.endsWith(".afb")) throw new InvalidArgumentError("path must end with .afb");
+    await writeFileAtomically(path, await this.backup());
+  }
+  // --- Documents ---
+  batch(writes, timestampNs) {
+    return this.#run(async (handle) => {
+      const cWrites = writes.length ? writes.map(toNativeWriteIntent) : null;
+      const code = await callAsync(
+        this.#native.dbBatch,
+        handle,
+        cWrites,
+        writes.length,
+        null,
+        0,
+        timestampNs,
+        0
+      );
+      checkCode(code);
+    });
+  }
+  batchJsonRaw(request) {
+    return this.#invokeBuffer(this.#native.dbBatchJson, jsonSlice(request));
+  }
+  async batchJson(request) {
+    return parseJson(await this.batchJsonRaw(request));
+  }
+  lookupRaw(key) {
+    return this.#invokeBuffer(this.#native.dbLookupJson, keySlice(key));
+  }
+  async lookup(key) {
+    return parseJson(await this.lookupRaw(key));
+  }
+  /** Raw stored bytes for key (antfly_db_get_raw), not JSON. */
+  getRaw(key) {
+    return this.#invokeBuffer(this.#native.dbGetRaw, keySlice(key));
+  }
+  getSchemaRaw() {
+    return this.#invokeBuffer(this.#native.dbGetSchemaJson);
+  }
+  async getSchema() {
+    return parseJson(await this.getSchemaRaw());
+  }
+  setSchema(schema) {
+    return this.#invokeCode(this.#native.dbSetSchemaJson, jsonSlice(schema));
+  }
+  listIndexesRaw() {
+    return this.#invokeBuffer(this.#native.dbListIndexesJson);
+  }
+  async listIndexes() {
+    return parseJson(await this.listIndexesRaw());
+  }
+  addIndex(config) {
+    return this.#invokeCode(this.#native.dbAddIndexJson, jsonSlice(config));
+  }
+  deleteIndex(name) {
+    return this.#run(async (handle) => {
+      const out = [false];
+      const code = await callAsync(this.#native.dbDeleteIndex, handle, stringSlice(name), out);
+      checkCode(code);
+      return Boolean(out[0]);
+    });
+  }
+  listEnrichmentsRaw() {
+    return this.#invokeBuffer(this.#native.dbListEnrichmentsJson);
+  }
+  async listEnrichments() {
+    return parseJson(await this.listEnrichmentsRaw());
+  }
+  addEnrichment(config) {
+    return this.#invokeCode(this.#native.dbAddEnrichmentJson, jsonSlice(config));
+  }
+  deleteEnrichment(kind, name) {
+    return this.#run(async (handle) => {
+      const out = [false];
+      const code = await callAsync(
+        this.#native.dbDeleteEnrichment,
+        handle,
+        stringSlice(kind),
+        stringSlice(name),
+        out
+      );
+      checkCode(code);
+      return Boolean(out[0]);
+    });
+  }
+  scanRaw(request) {
+    return this.#invokeBuffer(this.#native.dbScanJson, jsonSlice(request));
+  }
+  async scan(request) {
+    return parseJson(await this.scanRaw(request));
+  }
+  statsRaw() {
+    return this.#invokeBuffer(this.#native.dbStatsJson);
+  }
+  async stats() {
+    return parseJson(await this.statsRaw());
+  }
+  searchRaw(request) {
+    return this.#invokeBuffer(this.#native.dbSearchJson, jsonSlice(request));
+  }
+  async search(request) {
+    return parseJson(await this.searchRaw(request));
+  }
+  // --- Packed wire searches (binary wire format, never JSON: request/response are raw bytes) ---
+  denseSearchWire(request) {
+    return this.#invokeBuffer(this.#native.dbSearchDenseWire, sliceOf(toRawBytes(request)));
+  }
+  textMatchWire(request) {
+    return this.#invokeBuffer(this.#native.dbSearchTextMatchWire, sliceOf(toRawBytes(request)));
+  }
+  textTermWire(request) {
+    return this.#invokeBuffer(this.#native.dbSearchTextTermWire, sliceOf(toRawBytes(request)));
+  }
+  textMatchPhraseWire(request) {
+    return this.#invokeBuffer(
+      this.#native.dbSearchTextMatchPhraseWire,
+      sliceOf(toRawBytes(request))
+    );
+  }
+  aggregateHitsRaw(request) {
+    return this.#invokeBuffer(this.#native.dbAggregateHitsJson, jsonSlice(request));
+  }
+  async aggregateHits(request) {
+    return parseJson(await this.aggregateHitsRaw(request));
+  }
+  lookupArtifactRaw(artifactIdBase64) {
+    return this.#invokeBuffer(this.#native.dbLookupArtifactJson, stringSlice(artifactIdBase64));
+  }
+  async lookupArtifact(artifactIdBase64) {
+    return parseJson(await this.lookupArtifactRaw(artifactIdBase64));
+  }
+  extractEnrichmentsRaw(request) {
+    return this.#invokeBuffer(this.#native.dbExtractEnrichmentsJson, jsonSlice(request));
+  }
+  async extractEnrichments(request) {
+    return parseJson(await this.extractEnrichmentsRaw(request));
+  }
+  computeEnrichmentsRaw(request) {
+    return this.#invokeBuffer(this.#native.dbComputeEnrichmentsJson, jsonSlice(request));
+  }
+  async computeEnrichments(request) {
+    return parseJson(await this.computeEnrichmentsRaw(request));
+  }
+  // --- Graph ---
+  edgesRaw(indexName, key, edgeType, direction) {
+    return this.#invokeBuffer(
+      this.#native.dbGetEdgesJson,
+      stringSlice(indexName),
+      stringSlice(key),
+      stringSlice(edgeType),
+      direction
+    );
+  }
+  async edges(indexName, key, edgeType, direction) {
+    return parseJson(await this.edgesRaw(indexName, key, edgeType, direction));
+  }
+  neighborsRaw(indexName, key, edgeType, direction) {
+    return this.#invokeBuffer(
+      this.#native.dbGetNeighborsJson,
+      stringSlice(indexName),
+      stringSlice(key),
+      stringSlice(edgeType),
+      direction
+    );
+  }
+  async neighbors(indexName, key, edgeType, direction) {
+    return parseJson(await this.neighborsRaw(indexName, key, edgeType, direction));
+  }
+  traverseEdgesRaw(request) {
+    return this.#invokeBuffer(this.#native.dbTraverseEdgesJson, jsonSlice(request));
+  }
+  async traverseEdges(request) {
+    return parseJson(await this.traverseEdgesRaw(request));
+  }
+  executeGraphQueriesRaw(request) {
+    return this.#invokeBuffer(this.#native.dbExecuteGraphQueriesJson, jsonSlice(request));
+  }
+  async executeGraphQueries(request) {
+    return parseJson(await this.executeGraphQueriesRaw(request));
+  }
+  findShortestPathRaw(request) {
+    return this.#invokeBuffer(this.#native.dbFindShortestPathJson, jsonSlice(request));
+  }
+  async findShortestPath(request) {
+    return parseJson(await this.findShortestPathRaw(request));
+  }
+  findKShortestPathsRaw(request) {
+    return this.#invokeBuffer(this.#native.dbFindKShortestPathsJson, jsonSlice(request));
+  }
+  async findKShortestPaths(request) {
+    return parseJson(await this.findKShortestPathsRaw(request));
+  }
+  matchPatternRaw(request) {
+    return this.#invokeBuffer(this.#native.dbMatchPatternJson, jsonSlice(request));
+  }
+  async matchPattern(request) {
+    return parseJson(await this.matchPatternRaw(request));
+  }
+  // --- Transactions ---
+  beginTransaction(txnId, timestampNs, participants = []) {
+    return this.#run(async (handle) => {
+      const id = txnIdBytes(txnId);
+      const cParticipants = participants.length ? participants.map(stringSlice) : null;
+      const code = await callAsync(
+        this.#native.dbBeginTransactionWithId,
+        handle,
+        id,
+        timestampNs,
+        cParticipants,
+        participants.length
+      );
+      checkCode(code);
+    });
+  }
+  writeTransaction(txnId, writes) {
+    return this.#run(async (handle) => {
+      const id = txnIdBytes(txnId);
+      const cWrites = writes.length ? writes.map(toNativeWriteIntent) : null;
+      const code = await callAsync(
+        this.#native.dbWriteTransaction,
+        handle,
+        id,
+        cWrites,
+        writes.length,
+        null,
+        0
+      );
+      checkCode(code);
+    });
+  }
+  resolveTransaction(txnId, status, commitVersion = 0) {
+    return this.#invokeCode(
+      this.#native.dbResolveIntents,
+      txnIdBytes(txnId),
+      status,
+      commitVersion
+    );
+  }
+  transactionStatus(txnId) {
+    return this.#run(async (handle) => {
+      const id = txnIdBytes(txnId);
+      const out = [0];
+      const code = await callAsync(this.#native.dbGetTransactionStatus, handle, id, out);
+      checkCode(code);
+      return out[0];
+    });
+  }
+  commitVersion(txnId) {
+    return this.#run(async (handle) => {
+      const id = txnIdBytes(txnId);
+      const out = [0];
+      const code = await callAsync(this.#native.dbGetCommitVersion, handle, id, out);
+      checkCode(code);
+      return BigInt(out[0] ?? 0);
+    });
+  }
+};
+var finalizationRegistry = new FinalizationRegistry(
+  ({ native, handle }) => {
+    if (handle != null) {
+      try {
+        native.dbClose(handle);
+      } catch {
+      }
+    }
+  }
+);
+async function writeFileAtomically(path, data, mode = 384) {
+  const dir = dirname2(path);
+  const tmpPath = join2(
+    dir,
+    `.${basename(path)}.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2)}.tmp`
+  );
+  const handle = await fsp.open(tmpPath, "w", mode);
+  try {
+    await handle.writeFile(data);
+    await handle.sync();
+  } finally {
+    await handle.close();
+  }
+  await fsp.rename(tmpPath, path);
+}
+async function openOrCreate(path, opts, create2) {
+  validateAbi();
+  const native = loadNative();
+  const options = buildOpenOptionsStruct(native, opts);
+  const outHandle = [null];
+  const fn = create2 ? native.dbCreateWithOptions : native.dbOpenWithOptions;
+  const code = await callAsync(fn, path, options, outHandle);
+  checkCode(code);
+  return new Database(native, outHandle[0]);
+}
+function open2(path) {
+  return openWithOptions(path, { mode: 0 /* Writer */, profile: 0 /* Native */ });
+}
+function create(path) {
+  return createWithOptions(path, { mode: 0 /* Writer */, profile: 0 /* Native */ });
+}
+function openReadonly(path) {
+  return openWithOptions(path, { mode: 1 /* Readonly */, profile: 0 /* Native */ });
+}
+function openStatusOnly(path) {
+  return openWithOptions(path, { mode: 2 /* StatusOnly */, profile: 0 /* Native */ });
+}
+function openWithOptions(path, options = {}) {
+  return openOrCreate(path, options, false);
+}
+function createWithOptions(path, options = {}) {
+  return openOrCreate(path, options, true);
+}
+async function openHosted(path) {
+  validateAbi();
+  const native = loadNative();
+  const outHandle = [null];
+  const code = await callAsync(native.liteOpenHosted, path, outHandle);
+  checkCode(code);
+  return new Database(native, outHandle[0]);
+}
+async function createHosted(path) {
+  validateAbi();
+  const native = loadNative();
+  const outHandle = [null];
+  const code = await callAsync(native.liteCreateHosted, path, outHandle);
+  checkCode(code);
+  return new Database(native, outHandle[0]);
+}
+
+// src/files.ts
+function restoreOpenOptions(native, storage) {
+  const options = {};
+  checkCode(native.openOptionsInit(options));
+  options.storage_kind = storageKind(storage);
+  return options;
+}
+async function checkFileRaw(path) {
+  validateAbi();
+  const native = loadNative();
+  const out = newBufferOut();
+  const code = await callAsync(native.liteCheckFileJson, path, out);
+  checkCode(code);
+  return takeBuffer(native, out);
+}
+async function checkFile(path) {
+  return parseJson(await checkFileRaw(path));
+}
+async function copyStableSnapshotFileRaw(srcPath, destPath, replace) {
+  if (!srcPath.endsWith(".aflite") || !destPath.endsWith(".aflite")) {
+    throw new InvalidArgumentError("srcPath and destPath must end with .aflite");
+  }
+  const native = loadNative();
+  const out = newBufferOut();
+  const code = await callAsync(
+    native.liteCopyStableSnapshotFileJson,
+    srcPath,
+    destPath,
+    replace,
+    out
+  );
+  checkCode(code);
+  return takeBuffer(native, out);
+}
+async function copyStableSnapshotFile(srcPath, destPath, replace) {
+  return parseJson(
+    await copyStableSnapshotFileRaw(srcPath, destPath, replace)
+  );
+}
+async function restore(path, backup, opts = {}) {
+  if ((opts.storage ?? 0 /* Lite */) === 0 /* Lite */ && !path.endsWith(".aflite")) {
+    throw new InvalidArgumentError("path must end with .aflite for Storage.Lite");
+  }
+  if (backup.length === 0) {
+    throw new InvalidArgumentError("backup must be non-empty");
+  }
+  const native = loadNative();
+  const options = restoreOpenOptions(native, opts.storage);
+  const out = newBufferOut();
+  const code = await callAsync(
+    native.restoreBackupJson,
+    path,
+    options,
+    sliceOf(toRawBytes(backup)),
+    Boolean(opts.replace),
+    out
+  );
+  checkCode(code);
+  takeBuffer(native, out);
+}
+async function restoreFile(path, backupPath, opts = {}) {
+  if (!backupPath.endsWith(".afb")) {
+    throw new InvalidArgumentError("backupPath must end with .afb");
+  }
+  if ((opts.storage ?? 0 /* Lite */) === 0 /* Lite */ && !path.endsWith(".aflite")) {
+    throw new InvalidArgumentError("path must end with .aflite for Storage.Lite");
+  }
+  const native = loadNative();
+  const options = restoreOpenOptions(native, opts.storage);
+  const out = newBufferOut();
+  const code = await callAsync(
+    native.restoreBackupFileJson,
+    path,
+    options,
+    backupPath,
+    Boolean(opts.replace),
+    out
+  );
+  checkCode(code);
+  takeBuffer(native, out);
+}
+async function decodeArtifactIdRaw(artifactIdBase64) {
+  const native = loadNative();
+  const out = newBufferOut();
+  const code = await callAsync(native.decodeArtifactIdJson, stringSlice(artifactIdBase64), out);
+  checkCode(code);
+  return takeBuffer(native, out);
+}
+async function decodeArtifactId(artifactIdBase64) {
+  return parseJson(await decodeArtifactIdRaw(artifactIdBase64));
+}
+
+// src/inference.ts
+import koffi4 from "koffi";
+function buildInferenceOptionsStruct(native, opts) {
+  const options = {};
+  checkCode(native.inferenceOptionsInit(options));
+  options.models_dir = stringSlice(opts.modelsDir ?? "");
+  options.host_budget_mb = opts.hostBudgetMb ?? 0;
+  options.backend_budget_mb = opts.backendBudgetMb ?? 0;
+  options.process_memory_budget_mb = opts.processMemoryBudgetMb ?? 0;
+  options.combined_budget_mb = opts.combinedBudgetMb ?? 0;
+  options.kv_budget_mb = opts.kvBudgetMb ?? 0;
+  options.scratch_budget_mb = opts.scratchBudgetMb ?? 0;
+  options.call_timeout_ms = opts.callTimeoutMs ?? 0;
+  return options;
+}
+function errorFromResponseBody(code, body) {
+  let parsed;
+  if (body.length > 0) {
+    try {
+      parsed = JSON.parse(body.toString("utf8"));
+    } catch {
+      parsed = void 0;
+    }
+  }
+  let message;
+  if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+    const b = parsed;
+    const errPart = typeof b.error === "string" ? b.error : void 0;
+    const msgPart = typeof b.message === "string" ? b.message : void 0;
+    message = [errPart, msgPart].filter((s) => Boolean(s)).join(": ") || void 0;
+  }
+  const err = errorFromCode(code, message);
+  err.body = parsed;
+  return err;
+}
+function decodeSliceBytes(slice) {
+  if (!slice || slice.ptr == null) {
+    return Buffer.alloc(0);
+  }
+  const len = Number(slice.len ?? 0);
+  if (len === 0) {
+    return Buffer.alloc(0);
+  }
+  const view = koffi4.decode(slice.ptr, "uint8_t", len);
+  return Buffer.from(view);
+}
+function decodeSliceUtf8(slice) {
+  return decodeSliceBytes(slice).toString("utf8");
+}
+function toPullProgress(decoded) {
+  return {
+    model: decodeSliceUtf8(decoded.model),
+    file: decodeSliceUtf8(decoded.file),
+    bytesDownloaded: BigInt(decoded.bytes_downloaded ?? 0),
+    totalBytes: BigInt(decoded.total_bytes ?? 0),
+    filesDone: BigInt(decoded.files_done ?? 0),
+    filesTotal: BigInt(decoded.files_total ?? 0),
+    cached: Boolean(decoded.cached)
+  };
+}
+var Inference = class _Inference {
+  #native;
+  #handle;
+  #state = "open";
+  #pending = /* @__PURE__ */ new Set();
+  #closeTask;
+  #finalizerToken = {};
+  /** @internal use Inference.open() instead of the constructor. */
+  constructor(native, handle) {
+    this.#native = native;
+    this.#handle = handle;
+    inferenceFinalizationRegistry.register(this, { native, handle }, this.#finalizerToken);
+  }
+  /** Starts the embedded inference runtime with no database. Returns UnsupportedError if this build does not link the inference runtime or it cannot start. */
+  static async open(options = {}) {
+    validateAbi();
+    validateInferenceAbi();
+    const native = loadNative();
+    const optsStruct = buildInferenceOptionsStruct(native, options);
+    const outHandle = [null];
+    const code = await callAsync(native.inferenceOpen, optsStruct, outHandle);
+    checkCode(code);
+    return new _Inference(native, outHandle[0]);
+  }
+  #run(op) {
+    if (this.#state !== "open") {
+      return Promise.reject(new InvalidArgumentError("inference handle is closed"));
+    }
+    const handle = this.#handle;
+    const promise = op(handle);
+    this.#pending.add(promise);
+    const cleanup = () => this.#pending.delete(promise);
+    promise.then(cleanup, cleanup);
+    return promise;
+  }
+  #track(promise) {
+    this.#pending.add(promise);
+    const cleanup = () => this.#pending.delete(promise);
+    promise.then(cleanup, cleanup);
+    return promise;
+  }
+  // biome-ignore lint/suspicious/noExplicitAny: koffi function signatures vary per call site
+  #invokeJson(fn, request) {
+    return this.#run(async (handle) => {
+      const out = newBufferOut();
+      const code = await callAsync(fn, handle, jsonSlice(request), out);
+      const body = takeBuffer(this.#native, out);
+      if (code !== 0 /* OK */) {
+        throw errorFromResponseBody(code, body);
+      }
+      return body;
+    });
+  }
+  /** Idempotent; waits for in-flight calls before freeing the native handle. Calls made after close() rejects with InvalidArgumentError. */
+  async close() {
+    if (this.#state === "closed") return;
+    if (this.#state === "closing") {
+      await this.#closeTask;
+      return;
+    }
+    this.#state = "closing";
+    inferenceFinalizationRegistry.unregister(this.#finalizerToken);
+    const handle = this.#handle;
+    this.#closeTask = (async () => {
+      while (this.#pending.size > 0) {
+        await Promise.allSettled([...this.#pending]);
+      }
+      if (handle != null) {
+        await callAsync(this.#native.inferenceClose, handle);
+      }
+      this.#handle = null;
+      this.#state = "closed";
+    })();
+    await this.#closeTask;
+  }
+  async [Symbol.asyncDispose]() {
+    await this.close();
+  }
+  // --- JSON calls (POST /ai/v1/<route>) ---
+  embedRaw(request) {
+    return this.#invokeJson(this.#native.inferenceEmbedJson, request);
+  }
+  async embed(request) {
+    return parseJson(await this.embedRaw(request));
+  }
+  rerankRaw(request) {
+    return this.#invokeJson(this.#native.inferenceRerankJson, request);
+  }
+  async rerank(request) {
+    return parseJson(await this.rerankRaw(request));
+  }
+  chunkRaw(request) {
+    return this.#invokeJson(this.#native.inferenceChunkJson, request);
+  }
+  async chunk(request) {
+    return parseJson(await this.chunkRaw(request));
+  }
+  /** A generate request with "stream": true fails with InvalidArgumentError; responses are always complete. Use generateStream() to stream. */
+  generateRaw(request) {
+    return this.#invokeJson(this.#native.inferenceGenerateJson, request);
+  }
+  async generate(request) {
+    return parseJson(await this.generateRaw(request));
+  }
+  /**
+   * Streams a generate request (antfly_inference_generate_stream_json): the
+   * same request body as generate(), with "stream" set for you. onChunk is
+   * called synchronously, on the calling thread, once per streamed chunk
+   * (a parsed "chat.completion.chunk" JSON object), as the model produces
+   * tokens.
+   *
+   * Returning `false` from onChunk stops generation early; the call then
+   * rejects with CancelledError. A thrown error also stops generation and
+   * is rethrown from this call (generation does not continue in the
+   * background). generateStream() runs synchronously on the JS thread and
+   * blocks the event loop for its duration -- see the class docstring for
+   * why (the same koffi callback-threading constraint as pull()); this is
+   * the reason this binding offers a callback, not an async iterator.
+   *
+   * A request rejected before generation starts (e.g. a missing model)
+   * rejects the same way generate() does, with the JSON error body on
+   * `.body`. A failure mid-stream rejects InternalError with
+   * `.body.error === "STREAM_FAILED"`.
+   */
+  generateStreamRaw(request, onChunk) {
+    if (this.#state !== "open") {
+      return Promise.reject(new InvalidArgumentError("inference handle is closed"));
+    }
+    const handle = this.#handle;
+    const native = this.#native;
+    const run = () => {
+      let callbackError;
+      let callbackThrew = false;
+      const callbackPtr = koffi4.register(
+        (_context, chunk) => {
+          try {
+            return onChunk(decodeSliceBytes(chunk)) !== false;
+          } catch (err) {
+            callbackThrew = true;
+            callbackError = err;
+            return false;
+          }
+        },
+        PAntflyInferenceStreamFn
+      );
+      try {
+        const out = newBufferOut();
+        const code = native.inferenceGenerateStreamJson(
+          handle,
+          jsonSlice(request),
+          callbackPtr,
+          null,
+          out
+        );
+        const body = takeBuffer(native, out);
+        if (callbackThrew) {
+          throw callbackError;
+        }
+        if (code !== 0 /* OK */) {
+          throw errorFromResponseBody(code, body);
+        }
+        return body;
+      } finally {
+        koffi4.unregister(callbackPtr);
+      }
+    };
+    return this.#track(Promise.resolve().then(run));
+  }
+  async generateStream(request, onChunk) {
+    return parseJson(
+      await this.generateStreamRaw(request, (chunkJson) => onChunk(parseJson(chunkJson)))
+    );
+  }
+  /** Up to 128 non-streaming generate requests in one call; per-item failures are reported in the response. */
+  generateBatchRaw(request) {
+    return this.#invokeJson(this.#native.inferenceGenerateBatchJson, request);
+  }
+  async generateBatch(request) {
+    return parseJson(await this.generateBatchRaw(request));
+  }
+  rewriteRaw(request) {
+    return this.#invokeJson(this.#native.inferenceRewriteJson, request);
+  }
+  async rewrite(request) {
+    return parseJson(await this.rewriteRaw(request));
+  }
+  /** Named choice, ordinal score, and Boolean questions using DecideRequest JSON. */
+  decideRaw(request) {
+    return this.#invokeJson(this.#native.inferenceDecideJson, request);
+  }
+  /** Parsed DecideResponse from the same contract as POST /ai/v1/decisions. */
+  async decide(request) {
+    return parseJson(await this.decideRaw(request));
+  }
+  extractRaw(request) {
+    return this.#invokeJson(this.#native.inferenceExtractJson, request);
+  }
+  async extract(request) {
+    return parseJson(await this.extractRaw(request));
+  }
+  /** OCR. */
+  readRaw(request) {
+    return this.#invokeJson(this.#native.inferenceReadJson, request);
+  }
+  async read(request) {
+    return parseJson(await this.readRaw(request));
+  }
+  transcribeRaw(request) {
+    return this.#invokeJson(this.#native.inferenceTranscribeJson, request);
+  }
+  async transcribe(request) {
+    return parseJson(await this.transcribeRaw(request));
+  }
+  /** The installed models, as returned by GET /ai/v1/models. */
+  listModelsRaw() {
+    return this.#run(async (handle) => {
+      const out = newBufferOut();
+      const code = await callAsync(this.#native.inferenceListModelsJson, handle, out);
+      const body = takeBuffer(this.#native, out);
+      if (code !== 0 /* OK */) {
+        throw errorFromResponseBody(code, body);
+      }
+      return body;
+    });
+  }
+  async listModels() {
+    return parseJson(await this.listModelsRaw());
+  }
+  /**
+   * Downloads a model from the Hugging Face Hub into the handle's models
+   * directory, like `antfly inference pull`. request: {"model": "owner/name[:variant]",
+   * required; "variants": [...]; "token": "..." (default $HF_TOKEN);
+   * "tasks"/"capabilities" to override the model manifest; "projector":
+   * "auto" | "none" | "match"; "max_artifact_bytes"/"max_model_bytes"}.
+   *
+   * onProgress (optional) is called synchronously, on the calling thread,
+   * as each file starts, every 16 MiB, and as it completes; see the class
+   * docstring for why pull() itself runs synchronously (blocking the event
+   * loop) rather than on koffi's async worker pool. Returning `false` from
+   * onProgress cancels the pull -- the call then rejects with
+   * CancelledError, and completed files stay staged, so a later pull()
+   * for the same model resumes rather than restarts. A thrown error also
+   * cancels the pull and is rethrown from this call.
+   *
+   * `signal` (optional) is a best-effort, honestly-limited cancellation
+   * knob: because pull() blocks the JS thread for its whole duration,
+   * there is no way to interrupt it asynchronously from the outside the
+   * way `fetch(url, { signal })` can. An already-aborted signal rejects
+   * immediately without starting the pull; otherwise the signal is polled
+   * only at the same report points as onProgress (each file start, every
+   * 16 MiB, file end) -- an abort in between those points is not observed
+   * until the next one. Prefer returning `false` from onProgress when you
+   * need precise control.
+   *
+   * A model missing from the hub rejects with NotFoundError, a bad request
+   * or a model over the size limits with InvalidArgumentError, and a
+   * network or hub failure with BusyError. close() waits for a pull in
+   * progress.
+   */
+  pullRaw(request, onProgress, signal) {
+    if (this.#state !== "open") {
+      return Promise.reject(new InvalidArgumentError("inference handle is closed"));
+    }
+    if (signal?.aborted) {
+      return Promise.reject(cancelledBySignal(signal));
+    }
+    const handle = this.#handle;
+    const native = this.#native;
+    const run = () => {
+      let callbackPtr;
+      let callbackError;
+      let callbackThrew = false;
+      if (onProgress || signal) {
+        callbackPtr = koffi4.register((_context, progressPtr) => {
+          try {
+            if (signal?.aborted) {
+              return false;
+            }
+            const decoded = koffi4.decode(
+              progressPtr,
+              AntflyInferencePullProgress
+            );
+            return onProgress?.(toPullProgress(decoded)) !== false;
+          } catch (err) {
+            callbackThrew = true;
+            callbackError = err;
+            return false;
+          }
+        }, PAntflyInferencePullProgressFn);
+      }
+      try {
+        const out = newBufferOut();
+        const code = native.inferencePullJson(
+          handle,
+          jsonSlice(request),
+          callbackPtr ?? null,
+          null,
+          out
+        );
+        const body = takeBuffer(native, out);
+        if (callbackThrew) {
+          throw callbackError;
+        }
+        if (code !== 0 /* OK */) {
+          throw errorFromResponseBody(code, body);
+        }
+        return body;
+      } finally {
+        if (callbackPtr !== void 0) {
+          koffi4.unregister(callbackPtr);
+        }
+      }
+    };
+    return this.#track(Promise.resolve().then(run));
+  }
+  async pull(request, onProgress, signal) {
+    return parseJson(await this.pullRaw(request, onProgress, signal));
+  }
+};
+function cancelledBySignal(signal) {
+  const reason = signal.reason;
+  const detail = reason instanceof Error ? reason.message : reason !== void 0 ? String(reason) : void 0;
+  return new CancelledError(
+    detail ? `pull cancelled before it started: ${detail}` : "pull cancelled before it started"
+  );
+}
+var inferenceFinalizationRegistry = new FinalizationRegistry(({ native, handle }) => {
+  if (handle != null) {
+    try {
+      native.inferenceClose(handle);
+    } catch {
+    }
+  }
+});
+export {
+  AbiMismatchError,
+  AntflyError,
+  BusyError,
+  CancelledError,
+  Connection,
+  Database,
+  ErrorCode,
+  GraphDirection,
+  Inference,
+  InferenceMode,
+  IntentConflictError,
+  InternalError,
+  InvalidArgumentError,
+  LibraryNotFoundError,
+  NATIVE_STACK_SIZE as MIN_THREAD_STACK_SIZE,
+  NotFoundError,
+  OpenMode,
+  OutcomeUnknownError,
+  Profile,
+  SUPPORTED_ABI_VERSION,
+  SqlError,
+  StalledError,
+  Storage,
+  THREADING_SERIALIZED,
+  TxnNotFoundError,
+  TxnStatus,
+  UnsupportedError,
+  UnsupportedPlatformError,
+  VersionConflictError,
+  abiVersion,
+  checkFile,
+  checkFileRaw,
+  copyStableSnapshotFile,
+  copyStableSnapshotFileRaw,
+  create,
+  createHosted,
+  createWithOptions,
+  decodeArtifactId,
+  decodeArtifactIdRaw,
+  embeddedPlatformPackageName,
+  errorCodeDescription,
+  errorCodeName,
+  open2 as open,
+  openHosted,
+  openReadonly,
+  openStatusOnly,
+  openWithOptions,
+  platformLibraryFileName,
+  resolveLibrary,
+  restore,
+  restoreFile,
+  threadingMode,
+  validateAbi,
+  validateInferenceAbi
+};