@rivetkit/sqlite-vfs 2.0.4-rc.1

package/dist/tsup/index.js

@@ -0,0 +1,857 @@
+// src/vfs.ts
+import * as VFS from "@rivetkit/sqlite/src/VFS.js";
+import {
+  Factory,
+  SQLITE_OPEN_CREATE as SQLITE_OPEN_CREATE2,
+  SQLITE_OPEN_READWRITE,
+  SQLITE_ROW
+} from "@rivetkit/sqlite";
+import { readFileSync } from "fs";
+import { createRequire } from "module";
+
+// src/kv.ts
+var CHUNK_SIZE = 4096;
+var SQLITE_PREFIX = 8;
+var SQLITE_SCHEMA_VERSION = 1;
+var META_PREFIX = 0;
+var CHUNK_PREFIX = 1;
+var FILE_TAG_MAIN = 0;
+var FILE_TAG_JOURNAL = 1;
+var FILE_TAG_WAL = 2;
+var FILE_TAG_SHM = 3;
+function getMetaKey(fileTag) {
+  const key = new Uint8Array(4);
+  key[0] = SQLITE_PREFIX;
+  key[1] = SQLITE_SCHEMA_VERSION;
+  key[2] = META_PREFIX;
+  key[3] = fileTag;
+  return key;
+}
+function getChunkKey(fileTag, chunkIndex) {
+  const key = new Uint8Array(8);
+  key[0] = SQLITE_PREFIX;
+  key[1] = SQLITE_SCHEMA_VERSION;
+  key[2] = CHUNK_PREFIX;
+  key[3] = fileTag;
+  key[4] = chunkIndex >>> 24 & 255;
+  key[5] = chunkIndex >>> 16 & 255;
+  key[6] = chunkIndex >>> 8 & 255;
+  key[7] = chunkIndex & 255;
+  return key;
+}
+
+// schemas/file-meta/versioned.ts
+import { createVersionedDataHandler } from "vbare";
+
+// dist/schemas/file-meta/v1.ts
+import * as bare from "@rivetkit/bare-ts";
+var config = /* @__PURE__ */ bare.Config({});
+function readFileMeta(bc) {
+  return {
+    size: bare.readU64(bc)
+  };
+}
+function writeFileMeta(bc, x) {
+  bare.writeU64(bc, x.size);
+}
+function encodeFileMeta(x) {
+  const bc = new bare.ByteCursor(
+    new Uint8Array(config.initialBufferLength),
+    config
+  );
+  writeFileMeta(bc, x);
+  return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
+}
+function decodeFileMeta(bytes) {
+  const bc = new bare.ByteCursor(bytes, config);
+  const result = readFileMeta(bc);
+  if (bc.offset < bc.view.byteLength) {
+    throw new bare.BareError(bc.offset, "remaining bytes");
+  }
+  return result;
+}
+
+// schemas/file-meta/versioned.ts
+var CURRENT_VERSION = 1;
+var FILE_META_VERSIONED = createVersionedDataHandler({
+  deserializeVersion: (bytes, version) => {
+    switch (version) {
+      case 1:
+        return decodeFileMeta(bytes);
+      default:
+        throw new Error(`Unknown version ${version}`);
+    }
+  },
+  serializeVersion: (data, version) => {
+    switch (version) {
+      case 1:
+        return encodeFileMeta(data);
+      default:
+        throw new Error(`Unknown version ${version}`);
+    }
+  },
+  deserializeConverters: () => [],
+  serializeConverters: () => []
+});
+
+// src/vfs.ts
+var TEXT_ENCODER = new TextEncoder();
+var TEXT_DECODER = new TextDecoder();
+var SQLITE_MAX_PATHNAME_BYTES = 64;
+var UINT32_SIZE = 4294967296;
+var MAX_CHUNK_INDEX = 4294967295;
+var MAX_FILE_SIZE_BYTES = (MAX_CHUNK_INDEX + 1) * CHUNK_SIZE;
+var MAX_FILE_SIZE_HI32 = Math.floor(MAX_FILE_SIZE_BYTES / UINT32_SIZE);
+var MAX_FILE_SIZE_LO32 = MAX_FILE_SIZE_BYTES % UINT32_SIZE;
+var SQLITE_ASYNC_METHODS = /* @__PURE__ */ new Set([
+  "xOpen",
+  "xClose",
+  "xRead",
+  "xWrite",
+  "xTruncate",
+  "xSync",
+  "xFileSize",
+  "xDelete",
+  "xAccess"
+]);
+function isSqliteEsmFactory(value) {
+  return typeof value === "function";
+}
+function isSQLiteModule(value) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const candidate = value;
+  return typeof candidate.UTF8ToString === "function" && candidate.HEAPU8 instanceof Uint8Array;
+}
+async function loadSqliteRuntime() {
+  const specifier = ["@rivetkit/sqlite", "dist", "wa-sqlite-async.mjs"].join("/");
+  const sqliteModule = await import(specifier);
+  if (!isSqliteEsmFactory(sqliteModule.default)) {
+    throw new Error("Invalid SQLite ESM factory export");
+  }
+  const sqliteEsmFactory = sqliteModule.default;
+  const require2 = createRequire(import.meta.url);
+  const sqliteDistPath = "@rivetkit/sqlite/dist/";
+  const wasmPath = require2.resolve(sqliteDistPath + "wa-sqlite-async.wasm");
+  const wasmBinary = readFileSync(wasmPath);
+  const module = await sqliteEsmFactory({ wasmBinary });
+  if (!isSQLiteModule(module)) {
+    throw new Error("Invalid SQLite runtime module");
+  }
+  return {
+    sqlite3: Factory(module),
+    module
+  };
+}
+function encodeFileMeta2(size) {
+  const meta = { size: BigInt(size) };
+  return FILE_META_VERSIONED.serializeWithEmbeddedVersion(
+    meta,
+    CURRENT_VERSION
+  );
+}
+function decodeFileMeta2(data) {
+  const meta = FILE_META_VERSIONED.deserializeWithEmbeddedVersion(data);
+  return Number(meta.size);
+}
+function isValidFileSize(size) {
+  return Number.isSafeInteger(size) && size >= 0 && size <= MAX_FILE_SIZE_BYTES;
+}
+var AsyncMutex = class {
+  #locked = false;
+  #waiting = [];
+  async acquire() {
+    while (this.#locked) {
+      await new Promise((resolve) => this.#waiting.push(resolve));
+    }
+    this.#locked = true;
+  }
+  release() {
+    this.#locked = false;
+    const next = this.#waiting.shift();
+    if (next) {
+      next();
+    }
+  }
+  async run(fn) {
+    await this.acquire();
+    try {
+      return await fn();
+    } finally {
+      this.release();
+    }
+  }
+};
+var Database = class {
+  #sqlite3;
+  #handle;
+  #fileName;
+  #onClose;
+  #sqliteMutex;
+  constructor(sqlite3, handle, fileName, onClose, sqliteMutex) {
+    this.#sqlite3 = sqlite3;
+    this.#handle = handle;
+    this.#fileName = fileName;
+    this.#onClose = onClose;
+    this.#sqliteMutex = sqliteMutex;
+  }
+  /**
+   * Execute SQL with optional row callback
+   * @param sql - SQL statement to execute
+   * @param callback - Called for each result row with (row, columns)
+   */
+  async exec(sql, callback) {
+    await this.#sqliteMutex.run(async () => {
+      await this.#sqlite3.exec(this.#handle, sql, callback);
+    });
+  }
+  /**
+   * Execute a parameterized SQL statement (no result rows)
+   * @param sql - SQL statement with ? placeholders
+   * @param params - Parameter values to bind
+   */
+  async run(sql, params) {
+    await this.#sqliteMutex.run(async () => {
+      for await (const stmt of this.#sqlite3.statements(this.#handle, sql)) {
+        if (params) {
+          this.#sqlite3.bind_collection(stmt, params);
+        }
+        while (await this.#sqlite3.step(stmt) === SQLITE_ROW) {
+        }
+      }
+    });
+  }
+  /**
+   * Execute a parameterized SQL query and return results
+   * @param sql - SQL query with ? placeholders
+   * @param params - Parameter values to bind
+   * @returns Object with rows (array of arrays) and columns (column names)
+   */
+  async query(sql, params) {
+    return this.#sqliteMutex.run(async () => {
+      const rows = [];
+      let columns = [];
+      for await (const stmt of this.#sqlite3.statements(this.#handle, sql)) {
+        if (params) {
+          this.#sqlite3.bind_collection(stmt, params);
+        }
+        while (await this.#sqlite3.step(stmt) === SQLITE_ROW) {
+          if (columns.length === 0) {
+            columns = this.#sqlite3.column_names(stmt);
+          }
+          rows.push(this.#sqlite3.row(stmt));
+        }
+      }
+      return { rows, columns };
+    });
+  }
+  /**
+   * Close the database
+   */
+  async close() {
+    await this.#sqliteMutex.run(async () => {
+      await this.#sqlite3.close(this.#handle);
+    });
+    this.#onClose();
+  }
+  /**
+   * Get the raw @rivetkit/sqlite API (for advanced usage)
+   */
+  get sqlite3() {
+    return this.#sqlite3;
+  }
+  /**
+   * Get the raw database handle (for advanced usage)
+   */
+  get handle() {
+    return this.#handle;
+  }
+};
+var SqliteVfs = class {
+  #sqlite3 = null;
+  #sqliteSystem = null;
+  #initPromise = null;
+  #openMutex = new AsyncMutex();
+  #sqliteMutex = new AsyncMutex();
+  #instanceId;
+  #destroyed = false;
+  constructor() {
+    this.#instanceId = crypto.randomUUID().replace(/-/g, "").slice(0, 8);
+  }
+  /**
+   * Initialize @rivetkit/sqlite and VFS (called once per instance)
+   */
+  async #ensureInitialized() {
+    if (this.#destroyed) {
+      throw new Error("SqliteVfs is closed");
+    }
+    if (this.#sqlite3 && this.#sqliteSystem) {
+      return;
+    }
+    if (!this.#initPromise) {
+      this.#initPromise = (async () => {
+        const { sqlite3, module } = await loadSqliteRuntime();
+        if (this.#destroyed) {
+          return;
+        }
+        this.#sqlite3 = sqlite3;
+        this.#sqliteSystem = new SqliteSystem(
+          sqlite3,
+          module,
+          `kv-vfs-${this.#instanceId}`
+        );
+        this.#sqliteSystem.register();
+      })();
+    }
+    try {
+      await this.#initPromise;
+    } catch (error) {
+      this.#initPromise = null;
+      throw error;
+    }
+  }
+  /**
+   * Open a SQLite database using KV storage backend
+   *
+   * @param fileName - The database file name (typically the actor ID)
+   * @param options - KV storage operations for this database
+   * @returns A Database instance
+   */
+  async open(fileName, options) {
+    if (this.#destroyed) {
+      throw new Error("SqliteVfs is closed");
+    }
+    await this.#openMutex.acquire();
+    try {
+      await this.#ensureInitialized();
+      if (!this.#sqlite3 || !this.#sqliteSystem) {
+        throw new Error("Failed to initialize SQLite");
+      }
+      const sqlite3 = this.#sqlite3;
+      const sqliteSystem = this.#sqliteSystem;
+      sqliteSystem.registerFile(fileName, options);
+      const db = await this.#sqliteMutex.run(
+        async () => sqlite3.open_v2(
+          fileName,
+          SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE2,
+          sqliteSystem.name
+        )
+      );
+      const onClose = () => {
+        sqliteSystem.unregisterFile(fileName);
+      };
+      return new Database(
+        sqlite3,
+        db,
+        fileName,
+        onClose,
+        this.#sqliteMutex
+      );
+    } finally {
+      this.#openMutex.release();
+    }
+  }
+  /**
+   * Tears down this VFS instance and releases internal references.
+   */
+  async destroy() {
+    if (this.#destroyed) {
+      return;
+    }
+    this.#destroyed = true;
+    const initPromise = this.#initPromise;
+    if (initPromise) {
+      try {
+        await initPromise;
+      } catch {
+      }
+    }
+    if (this.#sqliteSystem) {
+      await this.#sqliteSystem.close();
+    }
+    this.#sqliteSystem = null;
+    this.#sqlite3 = null;
+    this.#initPromise = null;
+  }
+  /**
+   * Alias for destroy to align with DB-style lifecycle naming.
+   */
+  async close() {
+    await this.destroy();
+  }
+};
+var SqliteSystem = class {
+  name;
+  mxPathName = SQLITE_MAX_PATHNAME_BYTES;
+  mxPathname = SQLITE_MAX_PATHNAME_BYTES;
+  #mainFileName = null;
+  #mainFileOptions = null;
+  #openFiles = /* @__PURE__ */ new Map();
+  #sqlite3;
+  #module;
+  #heapDataView;
+  #heapDataViewBuffer;
+  constructor(sqlite3, module, name) {
+    this.name = name;
+    this.#sqlite3 = sqlite3;
+    this.#module = module;
+    this.#heapDataViewBuffer = module.HEAPU8.buffer;
+    this.#heapDataView = new DataView(this.#heapDataViewBuffer);
+  }
+  async close() {
+    this.#openFiles.clear();
+    this.#mainFileName = null;
+    this.#mainFileOptions = null;
+  }
+  isReady() {
+    return true;
+  }
+  hasAsyncMethod(methodName) {
+    return SQLITE_ASYNC_METHODS.has(methodName);
+  }
+  /**
+   * Registers the VFS with SQLite
+   */
+  register() {
+    this.#sqlite3.vfs_register(this, false);
+  }
+  /**
+   * Registers a file with its KV options (before opening)
+   */
+  registerFile(fileName, options) {
+    if (!this.#mainFileName) {
+      this.#mainFileName = fileName;
+      this.#mainFileOptions = options;
+      return;
+    }
+    if (this.#mainFileName !== fileName) {
+      throw new Error(
+        `SqliteSystem is actor-scoped and expects one main file. Got ${fileName}, expected ${this.#mainFileName}.`
+      );
+    }
+    this.#mainFileOptions = options;
+  }
+  /**
+   * Unregisters a file's KV options (after closing)
+   */
+  unregisterFile(fileName) {
+    if (this.#mainFileName === fileName) {
+      this.#mainFileName = null;
+      this.#mainFileOptions = null;
+    }
+  }
+  /**
+   * Resolve file path to the actor's main DB file or known SQLite sidecars.
+   */
+  #resolveFile(path) {
+    if (!this.#mainFileName || !this.#mainFileOptions) {
+      return null;
+    }
+    if (path === this.#mainFileName) {
+      return { options: this.#mainFileOptions, fileTag: FILE_TAG_MAIN };
+    }
+    if (path === `${this.#mainFileName}-journal`) {
+      return { options: this.#mainFileOptions, fileTag: FILE_TAG_JOURNAL };
+    }
+    if (path === `${this.#mainFileName}-wal`) {
+      return { options: this.#mainFileOptions, fileTag: FILE_TAG_WAL };
+    }
+    if (path === `${this.#mainFileName}-shm`) {
+      return { options: this.#mainFileOptions, fileTag: FILE_TAG_SHM };
+    }
+    return null;
+  }
+  #resolveFileOrThrow(path) {
+    const resolved = this.#resolveFile(path);
+    if (resolved) {
+      return resolved;
+    }
+    if (!this.#mainFileName) {
+      throw new Error(`No KV options registered for file: ${path}`);
+    }
+    throw new Error(
+      `Unsupported SQLite file path ${path}. Expected one of ${this.#mainFileName}, ${this.#mainFileName}-journal, ${this.#mainFileName}-wal, ${this.#mainFileName}-shm.`
+    );
+  }
+  #chunkKey(file, chunkIndex) {
+    return getChunkKey(file.fileTag, chunkIndex);
+  }
+  async xOpen(_pVfs, zName, fileId, flags, pOutFlags) {
+    const path = this.#decodeFilename(zName, flags);
+    if (!path) {
+      return VFS.SQLITE_CANTOPEN;
+    }
+    const { options, fileTag } = this.#resolveFileOrThrow(path);
+    const metaKey = getMetaKey(fileTag);
+    const sizeData = await options.get(metaKey);
+    let size;
+    if (sizeData) {
+      size = decodeFileMeta2(sizeData);
+      if (!isValidFileSize(size)) {
+        return VFS.SQLITE_IOERR;
+      }
+    } else if (flags & VFS.SQLITE_OPEN_CREATE) {
+      size = 0;
+      await options.put(metaKey, encodeFileMeta2(size));
+    } else {
+      return VFS.SQLITE_CANTOPEN;
+    }
+    this.#openFiles.set(fileId, {
+      path,
+      fileTag,
+      metaKey,
+      size,
+      metaDirty: false,
+      flags,
+      options
+    });
+    this.#writeInt32(pOutFlags, flags);
+    return VFS.SQLITE_OK;
+  }
+  async xClose(fileId) {
+    const file = this.#openFiles.get(fileId);
+    if (!file) {
+      return VFS.SQLITE_OK;
+    }
+    if (file.flags & VFS.SQLITE_OPEN_DELETEONCLOSE) {
+      await this.#delete(file.path);
+      this.#openFiles.delete(fileId);
+      return VFS.SQLITE_OK;
+    }
+    if (file.metaDirty) {
+      await file.options.put(file.metaKey, encodeFileMeta2(file.size));
+      file.metaDirty = false;
+    }
+    this.#openFiles.delete(fileId);
+    return VFS.SQLITE_OK;
+  }
+  async xRead(fileId, pData, iAmt, iOffsetLo, iOffsetHi) {
+    if (iAmt === 0) {
+      return VFS.SQLITE_OK;
+    }
+    const file = this.#openFiles.get(fileId);
+    if (!file) {
+      return VFS.SQLITE_IOERR_READ;
+    }
+    const data = this.#module.HEAPU8.subarray(pData, pData + iAmt);
+    const options = file.options;
+    const requestedLength = iAmt;
+    const iOffset = delegalize(iOffsetLo, iOffsetHi);
+    if (iOffset < 0) {
+      return VFS.SQLITE_IOERR_READ;
+    }
+    const fileSize = file.size;
+    if (iOffset >= fileSize) {
+      data.fill(0);
+      return VFS.SQLITE_IOERR_SHORT_READ;
+    }
+    const startChunk = Math.floor(iOffset / CHUNK_SIZE);
+    const endChunk = Math.floor((iOffset + requestedLength - 1) / CHUNK_SIZE);
+    const chunkKeys = [];
+    for (let i = startChunk; i <= endChunk; i++) {
+      chunkKeys.push(this.#chunkKey(file, i));
+    }
+    const chunks = await options.getBatch(chunkKeys);
+    for (let i = startChunk; i <= endChunk; i++) {
+      const chunkData = chunks[i - startChunk];
+      const chunkOffset = i * CHUNK_SIZE;
+      const readStart = Math.max(0, iOffset - chunkOffset);
+      const readEnd = Math.min(
+        CHUNK_SIZE,
+        iOffset + requestedLength - chunkOffset
+      );
+      if (chunkData) {
+        const sourceStart = readStart;
+        const sourceEnd = Math.min(readEnd, chunkData.length);
+        const destStart = chunkOffset + readStart - iOffset;
+        if (sourceEnd > sourceStart) {
+          data.set(chunkData.subarray(sourceStart, sourceEnd), destStart);
+        }
+        if (sourceEnd < readEnd) {
+          const zeroStart = destStart + (sourceEnd - sourceStart);
+          const zeroEnd = destStart + (readEnd - readStart);
+          data.fill(0, zeroStart, zeroEnd);
+        }
+      } else {
+        const destStart = chunkOffset + readStart - iOffset;
+        const destEnd = destStart + (readEnd - readStart);
+        data.fill(0, destStart, destEnd);
+      }
+    }
+    const actualBytes = Math.min(requestedLength, fileSize - iOffset);
+    if (actualBytes < requestedLength) {
+      data.fill(0, actualBytes);
+      return VFS.SQLITE_IOERR_SHORT_READ;
+    }
+    return VFS.SQLITE_OK;
+  }
+  async xWrite(fileId, pData, iAmt, iOffsetLo, iOffsetHi) {
+    if (iAmt === 0) {
+      return VFS.SQLITE_OK;
+    }
+    const file = this.#openFiles.get(fileId);
+    if (!file) {
+      return VFS.SQLITE_IOERR_WRITE;
+    }
+    const data = this.#module.HEAPU8.subarray(pData, pData + iAmt);
+    const iOffset = delegalize(iOffsetLo, iOffsetHi);
+    if (iOffset < 0) {
+      return VFS.SQLITE_IOERR_WRITE;
+    }
+    const options = file.options;
+    const writeLength = iAmt;
+    const writeEndOffset = iOffset + writeLength;
+    if (writeEndOffset > MAX_FILE_SIZE_BYTES) {
+      return VFS.SQLITE_IOERR_WRITE;
+    }
+    const startChunk = Math.floor(iOffset / CHUNK_SIZE);
+    const endChunk = Math.floor((iOffset + writeLength - 1) / CHUNK_SIZE);
+    const plans = [];
+    const chunkKeysToFetch = [];
+    for (let i = startChunk; i <= endChunk; i++) {
+      const chunkOffset = i * CHUNK_SIZE;
+      const writeStart = Math.max(0, iOffset - chunkOffset);
+      const writeEnd = Math.min(
+        CHUNK_SIZE,
+        iOffset + writeLength - chunkOffset
+      );
+      const existingBytesInChunk = Math.max(
+        0,
+        Math.min(CHUNK_SIZE, file.size - chunkOffset)
+      );
+      const needsExisting = writeStart > 0 || existingBytesInChunk > writeEnd;
+      const chunkKey = this.#chunkKey(file, i);
+      let existingChunkIndex = -1;
+      if (needsExisting) {
+        existingChunkIndex = chunkKeysToFetch.length;
+        chunkKeysToFetch.push(chunkKey);
+      }
+      plans.push({
+        chunkKey,
+        chunkOffset,
+        writeStart,
+        writeEnd,
+        existingChunkIndex
+      });
+    }
+    const existingChunks = chunkKeysToFetch.length > 0 ? await options.getBatch(chunkKeysToFetch) : [];
+    const entriesToWrite = [];
+    for (const plan of plans) {
+      const existingChunk = plan.existingChunkIndex >= 0 ? existingChunks[plan.existingChunkIndex] : null;
+      let newChunk;
+      if (existingChunk) {
+        newChunk = new Uint8Array(Math.max(existingChunk.length, plan.writeEnd));
+        newChunk.set(existingChunk);
+      } else {
+        newChunk = new Uint8Array(plan.writeEnd);
+      }
+      const sourceStart = plan.chunkOffset + plan.writeStart - iOffset;
+      const sourceEnd = sourceStart + (plan.writeEnd - plan.writeStart);
+      newChunk.set(data.subarray(sourceStart, sourceEnd), plan.writeStart);
+      entriesToWrite.push([plan.chunkKey, newChunk]);
+    }
+    const previousSize = file.size;
+    const newSize = Math.max(file.size, writeEndOffset);
+    if (newSize !== previousSize) {
+      file.size = newSize;
+      file.metaDirty = true;
+    }
+    if (file.metaDirty) {
+      entriesToWrite.push([file.metaKey, encodeFileMeta2(file.size)]);
+    }
+    await options.putBatch(entriesToWrite);
+    if (file.metaDirty) {
+      file.metaDirty = false;
+    }
+    return VFS.SQLITE_OK;
+  }
+  async xTruncate(fileId, sizeLo, sizeHi) {
+    const file = this.#openFiles.get(fileId);
+    if (!file) {
+      return VFS.SQLITE_IOERR_TRUNCATE;
+    }
+    const size = delegalize(sizeLo, sizeHi);
+    if (size < 0 || size > MAX_FILE_SIZE_BYTES) {
+      return VFS.SQLITE_IOERR_TRUNCATE;
+    }
+    const options = file.options;
+    if (size >= file.size) {
+      if (size > file.size) {
+        file.size = size;
+        file.metaDirty = true;
+        await options.put(file.metaKey, encodeFileMeta2(file.size));
+        file.metaDirty = false;
+      }
+      return VFS.SQLITE_OK;
+    }
+    const lastChunkToKeep = Math.floor((size - 1) / CHUNK_SIZE);
+    const lastExistingChunk = Math.floor((file.size - 1) / CHUNK_SIZE);
+    const keysToDelete = [];
+    for (let i = lastChunkToKeep + 1; i <= lastExistingChunk; i++) {
+      keysToDelete.push(this.#chunkKey(file, i));
+    }
+    if (keysToDelete.length > 0) {
+      await options.deleteBatch(keysToDelete);
+    }
+    if (size > 0 && size % CHUNK_SIZE !== 0) {
+      const lastChunkKey = this.#chunkKey(file, lastChunkToKeep);
+      const lastChunkData = await options.get(lastChunkKey);
+      if (lastChunkData && lastChunkData.length > size % CHUNK_SIZE) {
+        const truncatedChunk = lastChunkData.subarray(0, size % CHUNK_SIZE);
+        await options.put(lastChunkKey, truncatedChunk);
+      }
+    }
+    file.size = size;
+    file.metaDirty = true;
+    await options.put(file.metaKey, encodeFileMeta2(file.size));
+    file.metaDirty = false;
+    return VFS.SQLITE_OK;
+  }
+  async xSync(fileId, _flags) {
+    const file = this.#openFiles.get(fileId);
+    if (!file || !file.metaDirty) {
+      return VFS.SQLITE_OK;
+    }
+    await file.options.put(file.metaKey, encodeFileMeta2(file.size));
+    file.metaDirty = false;
+    return VFS.SQLITE_OK;
+  }
+  async xFileSize(fileId, pSize) {
+    const file = this.#openFiles.get(fileId);
+    if (!file) {
+      return VFS.SQLITE_IOERR_FSTAT;
+    }
+    this.#writeBigInt64(pSize, BigInt(file.size));
+    return VFS.SQLITE_OK;
+  }
+  async xDelete(_pVfs, zName, _syncDir) {
+    await this.#delete(this.#module.UTF8ToString(zName));
+    return VFS.SQLITE_OK;
+  }
+  /**
+   * Internal delete implementation
+   */
+  async #delete(path) {
+    const { options, fileTag } = this.#resolveFileOrThrow(path);
+    const metaKey = getMetaKey(fileTag);
+    const sizeData = await options.get(metaKey);
+    if (!sizeData) {
+      return;
+    }
+    const size = decodeFileMeta2(sizeData);
+    const keysToDelete = [metaKey];
+    const numChunks = Math.ceil(size / CHUNK_SIZE);
+    for (let i = 0; i < numChunks; i++) {
+      keysToDelete.push(getChunkKey(fileTag, i));
+    }
+    await options.deleteBatch(keysToDelete);
+  }
+  async xAccess(_pVfs, zName, _flags, pResOut) {
+    const path = this.#module.UTF8ToString(zName);
+    const resolved = this.#resolveFile(path);
+    if (!resolved) {
+      this.#writeInt32(pResOut, 0);
+      return VFS.SQLITE_OK;
+    }
+    const compactMetaKey = getMetaKey(resolved.fileTag);
+    const metaData = await resolved.options.get(compactMetaKey);
+    this.#writeInt32(pResOut, metaData ? 1 : 0);
+    return VFS.SQLITE_OK;
+  }
+  xCheckReservedLock(_fileId, pResOut) {
+    this.#writeInt32(pResOut, 0);
+    return VFS.SQLITE_OK;
+  }
+  xLock(_fileId, _flags) {
+    return VFS.SQLITE_OK;
+  }
+  xUnlock(_fileId, _flags) {
+    return VFS.SQLITE_OK;
+  }
+  xFileControl(_fileId, _flags, _pArg) {
+    return VFS.SQLITE_NOTFOUND;
+  }
+  xDeviceCharacteristics(_fileId) {
+    return 0;
+  }
+  xFullPathname(_pVfs, zName, nOut, zOut) {
+    const path = this.#module.UTF8ToString(zName);
+    const bytes = TEXT_ENCODER.encode(path);
+    const out = this.#module.HEAPU8.subarray(zOut, zOut + nOut);
+    if (bytes.length >= out.length) {
+      return VFS.SQLITE_IOERR;
+    }
+    out.set(bytes, 0);
+    out[bytes.length] = 0;
+    return VFS.SQLITE_OK;
+  }
+  #decodeFilename(zName, flags) {
+    if (!zName) {
+      return null;
+    }
+    if (flags & VFS.SQLITE_OPEN_URI) {
+      let pName = zName;
+      let state = 1;
+      const charCodes = [];
+      while (state) {
+        const charCode = this.#module.HEAPU8[pName++];
+        if (charCode) {
+          charCodes.push(charCode);
+          continue;
+        }
+        if (!this.#module.HEAPU8[pName]) {
+          state = null;
+        }
+        switch (state) {
+          case 1:
+            charCodes.push("?".charCodeAt(0));
+            state = 2;
+            break;
+          case 2:
+            charCodes.push("=".charCodeAt(0));
+            state = 3;
+            break;
+          case 3:
+            charCodes.push("&".charCodeAt(0));
+            state = 2;
+            break;
+        }
+      }
+      return TEXT_DECODER.decode(new Uint8Array(charCodes));
+    }
+    return this.#module.UTF8ToString(zName);
+  }
+  #heapView() {
+    const heapBuffer = this.#module.HEAPU8.buffer;
+    if (heapBuffer !== this.#heapDataViewBuffer) {
+      this.#heapDataViewBuffer = heapBuffer;
+      this.#heapDataView = new DataView(heapBuffer);
+    }
+    return this.#heapDataView;
+  }
+  #writeInt32(pointer, value) {
+    const heapByteOffset = this.#module.HEAPU8.byteOffset + pointer;
+    this.#heapView().setInt32(heapByteOffset, value, true);
+  }
+  #writeBigInt64(pointer, value) {
+    const heapByteOffset = this.#module.HEAPU8.byteOffset + pointer;
+    this.#heapView().setBigInt64(heapByteOffset, value, true);
+  }
+};
+function delegalize(lo32, hi32) {
+  const hi = hi32 >>> 0;
+  const lo = lo32 >>> 0;
+  if (hi > MAX_FILE_SIZE_HI32) {
+    return -1;
+  }
+  if (hi === MAX_FILE_SIZE_HI32 && lo > MAX_FILE_SIZE_LO32) {
+    return -1;
+  }
+  return hi * UINT32_SIZE + lo;
+}
+export {
+  Database,
+  SqliteVfs
+};
+//# sourceMappingURL=index.js.map