@catmint-fs/sqlite-adapter 0.0.0-prealpha.0

package/dist/index.js

@@ -0,0 +1,809 @@
+// src/sqlite-adapter.ts
+import Database from "better-sqlite3";
+
+// src/schema.ts
+function initializeSchema(db, caseSensitive) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS files (
+      path TEXT PRIMARY KEY,
+      type TEXT NOT NULL CHECK(type IN ('file', 'directory', 'symlink')),
+      content BLOB,
+      target TEXT,
+      mode INTEGER NOT NULL DEFAULT 438,
+      uid INTEGER NOT NULL DEFAULT 0,
+      gid INTEGER NOT NULL DEFAULT 0,
+      size INTEGER NOT NULL DEFAULT 0,
+      created_at INTEGER NOT NULL,
+      modified_at INTEGER NOT NULL
+    )
+  `);
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS metadata (
+      key TEXT PRIMARY KEY,
+      value TEXT
+    )
+  `);
+  const existing = db.prepare("SELECT value FROM metadata WHERE key = 'schema_version'").get();
+  if (!existing) {
+    const insertMeta = db.prepare(
+      "INSERT OR IGNORE INTO metadata (key, value) VALUES (?, ?)"
+    );
+    const initMeta = db.transaction(() => {
+      insertMeta.run("schema_version", "1");
+      insertMeta.run("case_sensitive", caseSensitive ? "true" : "false");
+    });
+    initMeta();
+  }
+}
+
+// src/import-export.ts
+import * as fs from "fs";
+import * as path from "path";
+function importFrom(db, sourcePath) {
+  const insertStmt = db.prepare(`
+    INSERT OR REPLACE INTO files (path, type, content, target, mode, uid, gid, size, created_at, modified_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `);
+  const importAll = db.transaction(() => {
+    const rootStat = fs.lstatSync(sourcePath);
+    insertStmt.run(
+      "/",
+      "directory",
+      null,
+      null,
+      rootStat.mode,
+      rootStat.uid,
+      rootStat.gid,
+      0,
+      Math.floor(rootStat.birthtimeMs),
+      Math.floor(rootStat.mtimeMs)
+    );
+    walkAndImport(insertStmt, sourcePath, "/");
+  });
+  importAll();
+}
+function walkAndImport(insertStmt, hostPath, dbPath) {
+  const entries = fs.readdirSync(hostPath, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullHostPath = path.join(hostPath, entry.name);
+    const fullDbPath = dbPath === "/" ? `/${entry.name}` : `${dbPath}/${entry.name}`;
+    const lstatResult = fs.lstatSync(fullHostPath);
+    if (entry.isSymbolicLink()) {
+      const target = fs.readlinkSync(fullHostPath);
+      insertStmt.run(
+        fullDbPath,
+        "symlink",
+        null,
+        target,
+        lstatResult.mode,
+        lstatResult.uid,
+        lstatResult.gid,
+        0,
+        Math.floor(lstatResult.birthtimeMs),
+        Math.floor(lstatResult.mtimeMs)
+      );
+    } else if (entry.isDirectory()) {
+      insertStmt.run(
+        fullDbPath,
+        "directory",
+        null,
+        null,
+        lstatResult.mode,
+        lstatResult.uid,
+        lstatResult.gid,
+        0,
+        Math.floor(lstatResult.birthtimeMs),
+        Math.floor(lstatResult.mtimeMs)
+      );
+      walkAndImport(insertStmt, fullHostPath, fullDbPath);
+    } else if (entry.isFile()) {
+      const content = fs.readFileSync(fullHostPath);
+      insertStmt.run(
+        fullDbPath,
+        "file",
+        content,
+        null,
+        lstatResult.mode,
+        lstatResult.uid,
+        lstatResult.gid,
+        content.length,
+        Math.floor(lstatResult.birthtimeMs),
+        Math.floor(lstatResult.mtimeMs)
+      );
+    }
+  }
+}
+function exportTo(db, destPath) {
+  const allRows = db.prepare("SELECT * FROM files ORDER BY path").all();
+  const directories = [];
+  const files = [];
+  const symlinks = [];
+  for (const row of allRows) {
+    switch (row.type) {
+      case "directory":
+        directories.push(row);
+        break;
+      case "file":
+        files.push(row);
+        break;
+      case "symlink":
+        symlinks.push(row);
+        break;
+    }
+  }
+  directories.sort((a, b) => {
+    const depthA = a.path === "/" ? 0 : a.path.split("/").length;
+    const depthB = b.path === "/" ? 0 : b.path.split("/").length;
+    return depthA - depthB;
+  });
+  for (const dir of directories) {
+    const hostPath = dbPathToHost(dir.path, destPath);
+    fs.mkdirSync(hostPath, { recursive: true, mode: dir.mode & 4095 });
+    try {
+      fs.chownSync(hostPath, dir.uid, dir.gid);
+    } catch {
+    }
+    try {
+      const atime = dir.modified_at / 1e3;
+      const mtime = dir.modified_at / 1e3;
+      fs.utimesSync(hostPath, atime, mtime);
+    } catch {
+    }
+  }
+  for (const file of files) {
+    const hostPath = dbPathToHost(file.path, destPath);
+    const content = file.content ?? Buffer.alloc(0);
+    fs.writeFileSync(hostPath, content, { mode: file.mode & 4095 });
+    try {
+      fs.chownSync(hostPath, file.uid, file.gid);
+    } catch {
+    }
+    try {
+      const atime = file.modified_at / 1e3;
+      const mtime = file.modified_at / 1e3;
+      fs.utimesSync(hostPath, atime, mtime);
+    } catch {
+    }
+  }
+  for (const symlink of symlinks) {
+    const hostPath = dbPathToHost(symlink.path, destPath);
+    const target = symlink.target ?? "";
+    try {
+      fs.unlinkSync(hostPath);
+    } catch {
+    }
+    fs.symlinkSync(target, hostPath);
+    try {
+      fs.lchownSync(hostPath, symlink.uid, symlink.gid);
+    } catch {
+    }
+  }
+}
+function dbPathToHost(dbPath, destPath) {
+  if (dbPath === "/") {
+    return destPath;
+  }
+  return path.join(destPath, dbPath.slice(1));
+}
+
+// src/types.ts
+import { FsError } from "@catmint-fs/core";
+
+// src/sqlite-adapter.ts
+var MAX_SYMLINK_HOPS = 40;
+var DEFAULT_FILE_MODE = 438;
+var DEFAULT_DIR_MODE = 511;
+var SqliteAdapter = class {
+  db;
+  caseSensitiveMode;
+  closed = false;
+  // Prepared statements for performance
+  stmtGetByPath;
+  stmtGetByPathNoCase;
+  stmtInsert;
+  stmtUpsert;
+  stmtDelete;
+  stmtUpdateMode;
+  stmtUpdateOwner;
+  stmtUpdatePath;
+  constructor(options) {
+    const { database, caseSensitive = true } = options;
+    this.caseSensitiveMode = caseSensitive;
+    this.db = new Database(database);
+    this.db.pragma("journal_mode = WAL");
+    this.db.pragma("foreign_keys = ON");
+    initializeSchema(this.db, this.caseSensitiveMode);
+    this.stmtGetByPath = this.db.prepare(
+      "SELECT * FROM files WHERE path = ?"
+    );
+    this.stmtGetByPathNoCase = this.db.prepare(
+      "SELECT * FROM files WHERE path = ? COLLATE NOCASE"
+    );
+    this.stmtInsert = this.db.prepare(`
+      INSERT INTO files (path, type, content, target, mode, uid, gid, size, created_at, modified_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+    this.stmtUpsert = this.db.prepare(`
+      INSERT INTO files (path, type, content, target, mode, uid, gid, size, created_at, modified_at)
+      VALUES (@path, @type, @content, @target, @mode, @uid, @gid, @size, @created_at, @modified_at)
+      ON CONFLICT(path) DO UPDATE SET
+        type = @type,
+        content = @content,
+        target = @target,
+        mode = @mode,
+        uid = @uid,
+        gid = @gid,
+        size = @size,
+        modified_at = @modified_at
+    `);
+    this.stmtDelete = this.db.prepare("DELETE FROM files WHERE path = ?");
+    this.stmtUpdateMode = this.db.prepare(
+      "UPDATE files SET mode = ?, modified_at = ? WHERE path = ?"
+    );
+    this.stmtUpdateOwner = this.db.prepare(
+      "UPDATE files SET uid = ?, gid = ?, modified_at = ? WHERE path = ?"
+    );
+    this.stmtUpdatePath = this.db.prepare(
+      "UPDATE files SET path = ?, modified_at = ? WHERE path = ?"
+    );
+    this.ensureRoot();
+  }
+  assertNotClosed() {
+    if (this.closed) {
+      throw new FsError("DISPOSED", "adapter is closed");
+    }
+  }
+  ensureRoot() {
+    const root = this.getRow("/");
+    if (!root) {
+      const now = Date.now();
+      this.stmtInsert.run(
+        "/",
+        "directory",
+        null,
+        null,
+        DEFAULT_DIR_MODE,
+        0,
+        0,
+        0,
+        now,
+        now
+      );
+    }
+  }
+  /**
+   * Normalize a path for lookup. For case-insensitive mode, converts to lowercase.
+   */
+  normalizePath(p) {
+    if (!p.startsWith("/")) {
+      p = "/" + p;
+    }
+    p = p.replace(/\/+/g, "/");
+    if (p.length > 1 && p.endsWith("/")) {
+      p = p.slice(0, -1);
+    }
+    if (!this.caseSensitiveMode) {
+      p = p.toLowerCase();
+    }
+    return p;
+  }
+  /**
+   * Get a row from the files table, respecting case sensitivity.
+   */
+  getRow(dbPath) {
+    if (this.caseSensitiveMode) {
+      return this.stmtGetByPath.get(dbPath);
+    }
+    return this.stmtGetByPathNoCase.get(dbPath);
+  }
+  /**
+   * Resolve symlinks for a given path, returning the final resolved row.
+   * Throws ELOOP if the symlink chain exceeds MAX_SYMLINK_HOPS.
+   * Throws ENOENT if any hop in the chain is missing.
+   */
+  resolveSymlinks(dbPath) {
+    let currentPath = dbPath;
+    let hops = 0;
+    while (true) {
+      const row = this.getRow(currentPath);
+      if (!row) {
+        throw new FsError(
+          "ENOENT",
+          `no such file or directory: ${currentPath}`
+        );
+      }
+      if (row.type !== "symlink") {
+        return row;
+      }
+      hops++;
+      if (hops > MAX_SYMLINK_HOPS) {
+        throw new FsError(
+          "ELOOP",
+          `too many levels of symbolic links: ${dbPath}`
+        );
+      }
+      const target = row.target;
+      if (target.startsWith("/")) {
+        currentPath = this.normalizePath(target);
+      } else {
+        const parent = getParentPath(currentPath);
+        currentPath = this.normalizePath(
+          parent === "/" ? `/${target}` : `${parent}/${target}`
+        );
+      }
+    }
+  }
+  /**
+   * Check that the parent directory of a path exists and is actually a directory.
+   */
+  ensureParentExists(p) {
+    if (p === "/") return;
+    const parent = getParentPath(p);
+    const parentRow = this.getRow(parent);
+    if (!parentRow) {
+      throw new FsError(
+        "ENOENT",
+        `no such file or directory: ${parent}`
+      );
+    }
+    if (parentRow.type === "symlink") {
+      const resolved = this.resolveSymlinks(parent);
+      if (resolved.type !== "directory") {
+        throw new FsError("ENOTDIR", `not a directory: ${parent}`);
+      }
+    } else if (parentRow.type !== "directory") {
+      throw new FsError("ENOTDIR", `not a directory: ${parent}`);
+    }
+  }
+  /**
+   * Get direct children of a directory using SQL.
+   */
+  getDirectChildren(dirPath) {
+    if (dirPath === "/") {
+      if (this.caseSensitiveMode) {
+        return this.db.prepare(
+          "SELECT * FROM files WHERE path != '/' AND path LIKE '/%' ESCAPE '\\' AND path NOT LIKE '/%/%' ESCAPE '\\'"
+        ).all();
+      }
+      return this.db.prepare(
+        "SELECT * FROM files WHERE path != '/' COLLATE NOCASE AND path LIKE '/%' ESCAPE '\\' COLLATE NOCASE AND path NOT LIKE '/%/%' ESCAPE '\\' COLLATE NOCASE"
+      ).all();
+    }
+    const prefix = escapeLike(dirPath) + "/%";
+    const deepPrefix = escapeLike(dirPath) + "/%/%";
+    if (this.caseSensitiveMode) {
+      return this.db.prepare(
+        "SELECT * FROM files WHERE path LIKE ? ESCAPE '\\' AND path NOT LIKE ? ESCAPE '\\'"
+      ).all(prefix, deepPrefix);
+    }
+    return this.db.prepare(
+      "SELECT * FROM files WHERE path LIKE ? ESCAPE '\\' COLLATE NOCASE AND path NOT LIKE ? ESCAPE '\\' COLLATE NOCASE"
+    ).all(prefix, deepPrefix);
+  }
+  rowToStatResult(row) {
+    const type = row.type;
+    return {
+      mode: row.mode,
+      uid: row.uid,
+      gid: row.gid,
+      size: row.size,
+      atimeMs: row.modified_at,
+      mtimeMs: row.modified_at,
+      ctimeMs: row.modified_at,
+      birthtimeMs: row.created_at,
+      isFile: () => type === "file",
+      isDirectory: () => type === "directory",
+      isSymbolicLink: () => type === "symlink"
+    };
+  }
+  rowToDirentEntry(row) {
+    const name = getBaseName(row.path);
+    const type = row.type;
+    return {
+      name,
+      isFile: () => type === "file",
+      isDirectory: () => type === "directory",
+      isSymbolicLink: () => type === "symlink"
+    };
+  }
+  // ─── FsAdapter implementation ────────────────────────────────────
+  capabilities() {
+    return {
+      permissions: true,
+      symlinks: true,
+      caseSensitive: this.caseSensitiveMode
+    };
+  }
+  async readFile(filePath) {
+    this.assertNotClosed();
+    const p = this.normalizePath(filePath);
+    const row = this.resolveSymlinks(p);
+    if (row.type === "directory") {
+      throw new FsError(
+        "EISDIR",
+        `illegal operation on a directory: ${p}`
+      );
+    }
+    if (!row.content) {
+      return new Uint8Array(0);
+    }
+    return new Uint8Array(row.content);
+  }
+  createReadStream(filePath) {
+    this.assertNotClosed();
+    const p = this.normalizePath(filePath);
+    const row = this.resolveSymlinks(p);
+    if (row.type === "directory") {
+      throw new FsError(
+        "EISDIR",
+        `illegal operation on a directory: ${p}`
+      );
+    }
+    const content = row.content ? new Uint8Array(row.content) : new Uint8Array(0);
+    return new ReadableStream({
+      start(controller) {
+        controller.enqueue(content);
+        controller.close();
+      }
+    });
+  }
+  async readdir(dirPath) {
+    this.assertNotClosed();
+    const p = this.normalizePath(dirPath);
+    const row = this.resolveSymlinks(p);
+    if (row.type !== "directory") {
+      throw new FsError("ENOTDIR", `not a directory: ${p}`);
+    }
+    const children = this.getDirectChildren(row.path);
+    return children.map((child) => this.rowToDirentEntry(child));
+  }
+  async stat(filePath) {
+    this.assertNotClosed();
+    const p = this.normalizePath(filePath);
+    const row = this.resolveSymlinks(p);
+    return this.rowToStatResult(row);
+  }
+  async lstat(filePath) {
+    this.assertNotClosed();
+    const p = this.normalizePath(filePath);
+    const row = this.getRow(p);
+    if (!row) {
+      throw new FsError(
+        "ENOENT",
+        `no such file or directory: ${p}`
+      );
+    }
+    return this.rowToStatResult(row);
+  }
+  async readlink(filePath) {
+    this.assertNotClosed();
+    const p = this.normalizePath(filePath);
+    const row = this.getRow(p);
+    if (!row) {
+      throw new FsError(
+        "ENOENT",
+        `no such file or directory: ${p}`
+      );
+    }
+    if (row.type !== "symlink") {
+      throw new FsError("EINVAL", `invalid argument: ${p}`);
+    }
+    return row.target;
+  }
+  async exists(filePath) {
+    this.assertNotClosed();
+    const p = this.normalizePath(filePath);
+    try {
+      this.resolveSymlinks(p);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async writeFile(filePath, data, options) {
+    this.assertNotClosed();
+    const p = this.normalizePath(filePath);
+    this.ensureParentExists(p);
+    let resolvedPath = p;
+    const row = this.getRow(p);
+    if (row && row.type === "symlink") {
+      const resolved = this.resolveSymlinks(p);
+      resolvedPath = resolved.path;
+    }
+    const existing = resolvedPath !== p ? this.getRow(resolvedPath) : row;
+    if (existing && existing.type === "directory") {
+      throw new FsError(
+        "EISDIR",
+        `illegal operation on a directory: ${resolvedPath}`
+      );
+    }
+    const now = Date.now();
+    const mode = options?.mode ?? DEFAULT_FILE_MODE;
+    const uid = options?.uid ?? 0;
+    const gid = options?.gid ?? 0;
+    const content = Buffer.from(data);
+    this.stmtUpsert.run({
+      path: resolvedPath,
+      type: "file",
+      content,
+      target: null,
+      mode,
+      uid,
+      gid,
+      size: content.length,
+      created_at: existing ? existing.created_at : now,
+      modified_at: now
+    });
+  }
+  async mkdir(dirPath, options) {
+    this.assertNotClosed();
+    const p = this.normalizePath(dirPath);
+    const mode = options?.mode ?? DEFAULT_DIR_MODE;
+    const uid = options?.uid ?? 0;
+    const gid = options?.gid ?? 0;
+    const recursive = options?.recursive ?? false;
+    if (recursive) {
+      this.mkdirRecursive(p, mode, uid, gid);
+    } else {
+      const existing = this.getRow(p);
+      if (existing) {
+        throw new FsError("EEXIST", `file already exists: ${p}`);
+      }
+      this.ensureParentExists(p);
+      const now = Date.now();
+      this.stmtInsert.run(
+        p,
+        "directory",
+        null,
+        null,
+        mode,
+        uid,
+        gid,
+        0,
+        now,
+        now
+      );
+    }
+  }
+  mkdirRecursive(p, mode, uid, gid) {
+    if (p === "/") return;
+    const existing = this.getRow(p);
+    if (existing) {
+      if (existing.type === "directory") {
+        return;
+      }
+      throw new FsError("EEXIST", `file already exists: ${p}`);
+    }
+    const parent = getParentPath(p);
+    this.mkdirRecursive(parent, mode, uid, gid);
+    const now = Date.now();
+    this.stmtInsert.run(p, "directory", null, null, mode, uid, gid, 0, now, now);
+  }
+  async rm(filePath, options) {
+    this.assertNotClosed();
+    const p = this.normalizePath(filePath);
+    const recursive = options?.recursive ?? false;
+    const force = options?.force ?? false;
+    const row = this.getRow(p);
+    if (!row) {
+      if (force) return;
+      throw new FsError(
+        "ENOENT",
+        `no such file or directory: ${p}`
+      );
+    }
+    if (row.type === "directory" && !recursive) {
+      throw new FsError(
+        "EISDIR",
+        `illegal operation on a directory: ${p}`
+      );
+    }
+    if (recursive) {
+      if (p === "/") {
+        this.db.prepare("DELETE FROM files WHERE path != '/'").run();
+      } else {
+        const prefix = escapeLike(p + "/");
+        this.db.prepare(
+          "DELETE FROM files WHERE path = ? OR path LIKE ? ESCAPE '\\'"
+        ).run(p, prefix + "%");
+      }
+    } else {
+      this.stmtDelete.run(p);
+    }
+  }
+  async rmdir(dirPath) {
+    this.assertNotClosed();
+    const p = this.normalizePath(dirPath);
+    const row = this.getRow(p);
+    if (!row) {
+      throw new FsError(
+        "ENOENT",
+        `no such file or directory: ${p}`
+      );
+    }
+    if (row.type !== "directory") {
+      throw new FsError("ENOTDIR", `not a directory: ${p}`);
+    }
+    const children = this.getDirectChildren(p);
+    if (children.length > 0) {
+      throw new FsError("ENOTEMPTY", `directory not empty: ${p}`);
+    }
+    this.stmtDelete.run(p);
+  }
+  async rename(from, to) {
+    this.assertNotClosed();
+    const fromPath = this.normalizePath(from);
+    const toPath = this.normalizePath(to);
+    const row = this.getRow(fromPath);
+    if (!row) {
+      throw new FsError(
+        "ENOENT",
+        `no such file or directory: ${fromPath}`
+      );
+    }
+    this.ensureParentExists(toPath);
+    const existingTo = this.getRow(toPath);
+    if (existingTo) {
+      if (existingTo.type === "directory") {
+        const children = this.getDirectChildren(toPath);
+        if (children.length > 0) {
+          throw new FsError(
+            "ENOTEMPTY",
+            `directory not empty: ${toPath}`
+          );
+        }
+      }
+      this.stmtDelete.run(toPath);
+    }
+    const now = Date.now();
+    if (row.type === "directory") {
+      const renameAll = this.db.transaction(() => {
+        const prefix = escapeLike(fromPath + "/");
+        const descendants = this.db.prepare(
+          "SELECT path FROM files WHERE path LIKE ? ESCAPE '\\'"
+        ).all(prefix + "%");
+        this.stmtUpdatePath.run(toPath, now, fromPath);
+        const updateStmt = this.db.prepare(
+          "UPDATE files SET path = ?, modified_at = ? WHERE path = ?"
+        );
+        for (const desc of descendants) {
+          const newPath = toPath + desc.path.slice(fromPath.length);
+          updateStmt.run(newPath, now, desc.path);
+        }
+      });
+      renameAll();
+    } else {
+      this.stmtUpdatePath.run(toPath, now, fromPath);
+    }
+  }
+  async symlink(target, linkPath) {
+    this.assertNotClosed();
+    const p = this.normalizePath(linkPath);
+    const existing = this.getRow(p);
+    if (existing) {
+      throw new FsError("EEXIST", `file already exists: ${p}`);
+    }
+    this.ensureParentExists(p);
+    const now = Date.now();
+    this.stmtInsert.run(p, "symlink", null, target, 511, 0, 0, 0, now, now);
+  }
+  async chmod(filePath, mode) {
+    this.assertNotClosed();
+    const p = this.normalizePath(filePath);
+    const row = this.resolveSymlinks(p);
+    const now = Date.now();
+    const changes = this.stmtUpdateMode.run(mode, now, row.path);
+    if (changes.changes === 0) {
+      throw new FsError(
+        "ENOENT",
+        `no such file or directory: ${p}`
+      );
+    }
+  }
+  async chown(filePath, uid, gid) {
+    this.assertNotClosed();
+    const p = this.normalizePath(filePath);
+    const row = this.resolveSymlinks(p);
+    const now = Date.now();
+    const changes = this.stmtUpdateOwner.run(uid, gid, now, row.path);
+    if (changes.changes === 0) {
+      throw new FsError(
+        "ENOENT",
+        `no such file or directory: ${p}`
+      );
+    }
+  }
+  async lchown(filePath, uid, gid) {
+    this.assertNotClosed();
+    const p = this.normalizePath(filePath);
+    const row = this.getRow(p);
+    if (!row) {
+      throw new FsError(
+        "ENOENT",
+        `no such file or directory: ${p}`
+      );
+    }
+    const now = Date.now();
+    this.stmtUpdateOwner.run(uid, gid, now, row.path);
+  }
+  async checkPermission(filePath, op) {
+    this.assertNotClosed();
+    const p = this.normalizePath(filePath);
+    const row = this.resolveSymlinks(p);
+    const mode = row.mode;
+    let bit;
+    switch (op) {
+      case "read":
+        bit = 4;
+        break;
+      case "write":
+        bit = 2;
+        break;
+      case "execute":
+        bit = 1;
+        break;
+    }
+    const ownerBits = mode >> 6 & 7;
+    const groupBits = mode >> 3 & 7;
+    const otherBits = mode & 7;
+    if ((ownerBits & bit) !== 0) return;
+    if ((groupBits & bit) !== 0) return;
+    if ((otherBits & bit) !== 0) return;
+    throw new FsError("EACCES", `permission denied: ${p}`);
+  }
+  async initialize(root) {
+    this.assertNotClosed();
+  }
+  // ─── Extra methods ───────────────────────────────────────────────
+  /**
+   * Import files from a host filesystem path into this database.
+   */
+  async importFrom(sourcePath) {
+    this.assertNotClosed();
+    importFrom(this.db, sourcePath);
+  }
+  /**
+   * Export files from this database to a host filesystem path.
+   */
+  async exportTo(destPath) {
+    this.assertNotClosed();
+    exportTo(this.db, destPath);
+  }
+  /**
+   * Close the database connection.
+   */
+  async close() {
+    if (this.closed) return;
+    this.closed = true;
+    this.db.close();
+  }
+  /**
+   * Get the underlying better-sqlite3 Database instance.
+   * Useful for advanced operations or testing.
+   */
+  getDatabase() {
+    this.assertNotClosed();
+    return this.db;
+  }
+};
+function getParentPath(p) {
+  if (p === "/") return "/";
+  const lastSlash = p.lastIndexOf("/");
+  if (lastSlash === 0) return "/";
+  return p.slice(0, lastSlash);
+}
+function getBaseName(p) {
+  if (p === "/") return "/";
+  const lastSlash = p.lastIndexOf("/");
+  return p.slice(lastSlash + 1);
+}
+function escapeLike(s) {
+  return s.replace(/\\/g, "\\\\").replace(/%/g, "\\%").replace(/_/g, "\\_");
+}
+export {
+  FsError,
+  SqliteAdapter,
+  exportTo,
+  importFrom,
+  initializeSchema
+};