postgres-memory-server 0.1.0 → 0.2.1

package/dist/cli.js

@@ -1,12 +1,14 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import process from "process";
+import process3 from "process";
 
 // src/PostgresMemoryServer.ts
-import { promises as fs } from "fs";
-import path from "path";
-import { PostgreSqlContainer } from "@testcontainers/postgresql";
+import { promises as fs2, rmSync } from "fs";
+import os2 from "os";
+import path2 from "path";
+import process2 from "process";
+import EmbeddedPostgres from "embedded-postgres";
 import { Client } from "pg";
 
 // src/errors.ts
@@ -28,20 +30,439 @@ var ServerStoppedError = class extends PostgresMemoryServerError {
     super("The PostgresMemoryServer has already been stopped.");
   }
 };
+var ExtensionInstallError = class extends PostgresMemoryServerError {
+  constructor(extensionName, cause) {
+    super(
+      `Failed to install the "${extensionName}" extension. ${cause?.message ?? ""}`.trim(),
+      cause ? { cause } : void 0
+    );
+  }
+};
+
+// src/native.ts
+import { promises as fs, readFileSync, existsSync } from "fs";
+import { createRequire } from "module";
+import { execFile as execFileCb } from "child_process";
+import { promisify } from "util";
+import net from "net";
+import os from "os";
+import path from "path";
+var execFile = promisify(execFileCb);
+async function getFreePort() {
+  return new Promise((resolve, reject) => {
+    const server = net.createServer();
+    server.listen(0, () => {
+      const { port } = server.address();
+      server.close(() => resolve(port));
+    });
+    server.on("error", reject);
+  });
+}
+function getPgMajorVersion() {
+  const req = createRequire(import.meta.url);
+  const mainEntry = req.resolve("embedded-postgres");
+  let dir = path.dirname(mainEntry);
+  while (dir !== path.dirname(dir)) {
+    const candidate = path.join(dir, "package.json");
+    try {
+      const content = readFileSync(candidate, "utf8");
+      const pkg = JSON.parse(content);
+      if (pkg.name === "embedded-postgres" && pkg.version) {
+        const major = pkg.version.split(".")[0];
+        if (major) return major;
+      }
+    } catch {
+    }
+    dir = path.dirname(dir);
+  }
+  throw new Error(
+    "Could not determine embedded-postgres version. Ensure embedded-postgres is installed."
+  );
+}
+function getNativeDir() {
+  const platform = os.platform();
+  const arch = os.arch();
+  const platformPkgNames = {
+    darwin: {
+      arm64: "@embedded-postgres/darwin-arm64",
+      x64: "@embedded-postgres/darwin-x64"
+    },
+    linux: {
+      x64: "@embedded-postgres/linux-x64",
+      arm64: "@embedded-postgres/linux-arm64"
+    },
+    win32: {
+      x64: "@embedded-postgres/windows-x64"
+    }
+  };
+  const pkgName = platformPkgNames[platform]?.[arch];
+  if (!pkgName) {
+    throw new Error(`Unsupported platform: ${platform}-${arch}`);
+  }
+  const req = createRequire(import.meta.url);
+  const mainEntry = req.resolve(pkgName);
+  let dir = path.dirname(mainEntry);
+  while (dir !== path.dirname(dir)) {
+    const nativeDir = path.join(dir, "native");
+    if (existsSync(nativeDir)) {
+      return nativeDir;
+    }
+    dir = path.dirname(dir);
+  }
+  throw new Error(
+    `Could not find native directory for ${pkgName}. Ensure embedded-postgres is installed correctly.`
+  );
+}
+function getCacheDir() {
+  const xdgCache = process.env.XDG_CACHE_HOME;
+  const base = xdgCache || path.join(os.homedir(), ".cache");
+  return path.join(base, "postgres-memory-server");
+}
+async function installParadeDBExtension(nativeDir, paradedbVersion, pgMajorVersion) {
+  const libDir = path.join(nativeDir, "lib", "postgresql");
+  const extDir = path.join(nativeDir, "share", "postgresql", "extension");
+  const soName = os.platform() === "darwin" && parseInt(pgMajorVersion, 10) >= 16 ? "pg_search.dylib" : "pg_search.so";
+  try {
+    await fs.access(path.join(libDir, soName));
+    await fs.access(path.join(extDir, "pg_search.control"));
+    return;
+  } catch {
+  }
+  const cacheDir = getCacheDir();
+  const platform = os.platform();
+  const arch = os.arch();
+  const cacheKey = `paradedb-${paradedbVersion}-pg${pgMajorVersion}-${platform}-${arch}`;
+  const cachedDir = path.join(cacheDir, cacheKey);
+  let cached = false;
+  try {
+    await fs.access(path.join(cachedDir, "lib", soName));
+    cached = true;
+  } catch {
+  }
+  if (!cached) {
+    const url = buildDownloadUrl(
+      paradedbVersion,
+      pgMajorVersion,
+      platform,
+      arch
+    );
+    const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "paradedb-"));
+    try {
+      const filename = decodeURIComponent(url.split("/").pop());
+      const archivePath = path.join(tmpDir, filename);
+      await downloadFile(url, archivePath);
+      const extractedDir = path.join(tmpDir, "extracted");
+      await fs.mkdir(extractedDir, { recursive: true });
+      if (platform === "darwin") {
+        await extractPkg(archivePath, extractedDir);
+      } else {
+        await extractDeb(archivePath, extractedDir);
+      }
+      const cacheLibDir2 = path.join(cachedDir, "lib");
+      const cacheExtDir2 = path.join(cachedDir, "extension");
+      await fs.mkdir(cacheLibDir2, { recursive: true });
+      await fs.mkdir(cacheExtDir2, { recursive: true });
+      const soFiles = await findFiles(
+        extractedDir,
+        /pg_search\.(so|dylib)$/
+      );
+      for (const soFile of soFiles) {
+        await copyFileWithPermissions(soFile, path.join(cacheLibDir2, path.basename(soFile)));
+      }
+      const extFiles = await findFiles(
+        extractedDir,
+        /pg_search[^/]*(\.control|\.sql)$/
+      );
+      for (const extFile of extFiles) {
+        await copyFileWithPermissions(
+          extFile,
+          path.join(cacheExtDir2, path.basename(extFile))
+        );
+      }
+    } finally {
+      await fs.rm(tmpDir, { recursive: true, force: true });
+    }
+  }
+  await fs.mkdir(libDir, { recursive: true });
+  await fs.mkdir(extDir, { recursive: true });
+  const cacheLibDir = path.join(cachedDir, "lib");
+  const cacheExtDir = path.join(cachedDir, "extension");
+  for (const file of await fs.readdir(cacheLibDir)) {
+    await copyFileWithPermissions(path.join(cacheLibDir, file), path.join(libDir, file));
+  }
+  for (const file of await fs.readdir(cacheExtDir)) {
+    await copyFileWithPermissions(path.join(cacheExtDir, file), path.join(extDir, file));
+  }
+}
+function buildDownloadUrl(version, pgMajorVersion, platform, arch) {
+  const base = `https://github.com/paradedb/paradedb/releases/download/v${version}`;
+  if (platform === "darwin") {
+    if (arch !== "arm64") {
+      throw new Error(
+        "ParadeDB only provides macOS binaries for arm64 (Apple Silicon). Intel Macs are not supported."
+      );
+    }
+    const macosName = getMacOSCodename();
+    return `${base}/pg_search%40${pgMajorVersion}--${version}.arm64_${macosName}.pkg`;
+  }
+  if (platform === "linux") {
+    const debArch = arch === "arm64" ? "arm64" : "amd64";
+    return `${base}/postgresql-${pgMajorVersion}-pg-search_${version}-1PARADEDB-bookworm_${debArch}.deb`;
+  }
+  throw new Error(
+    `ParadeDB does not provide prebuilt binaries for ${platform}. Use the Docker-based preset instead.`
+  );
+}
+function getMacOSCodename() {
+  const release = os.release();
+  const majorVersion = parseInt(release.split(".")[0] ?? "0", 10);
+  if (majorVersion >= 24) return "sequoia";
+  if (majorVersion >= 23) return "sonoma";
+  throw new Error(
+    `ParadeDB requires macOS 14 (Sonoma) or later. Detected Darwin ${release}.`
+  );
+}
+async function downloadFile(url, destPath) {
+  const response = await fetch(url, { redirect: "follow" });
+  if (!response.ok) {
+    throw new Error(
+      `Failed to download ParadeDB extension from ${url}: ${response.status} ${response.statusText}`
+    );
+  }
+  const buffer = Buffer.from(await response.arrayBuffer());
+  await fs.writeFile(destPath, buffer);
+}
+async function extractDeb(debPath, extractDir) {
+  await execFile("ar", ["x", debPath], { cwd: extractDir });
+  const files = await fs.readdir(extractDir);
+  const dataTar = files.find((f) => f.startsWith("data.tar"));
+  if (!dataTar) {
+    throw new Error(
+      "No data.tar.* found in .deb archive. The ParadeDB package format may have changed."
+    );
+  }
+  const dataDir = path.join(extractDir, "data");
+  await fs.mkdir(dataDir, { recursive: true });
+  await execFile("tar", [
+    "xf",
+    path.join(extractDir, dataTar),
+    "-C",
+    dataDir
+  ]);
+}
+async function extractPkg(pkgPath, extractDir) {
+  const pkgDir = path.join(extractDir, "pkg");
+  await execFile("pkgutil", ["--expand-full", pkgPath, pkgDir]);
+}
+async function copyFileWithPermissions(src, dest) {
+  const content = await fs.readFile(src);
+  await fs.writeFile(dest, content, { mode: 493 });
+}
+async function findFiles(dir, pattern) {
+  const results = [];
+  async function walk(currentDir) {
+    const entries = await fs.readdir(currentDir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path.join(currentDir, entry.name);
+      if (entry.isDirectory()) {
+        await walk(fullPath);
+      } else if (pattern.test(entry.name)) {
+        results.push(fullPath);
+      }
+    }
+  }
+  await walk(dir);
+  return results;
+}
+async function installPgVectorExtension(nativeDir, pgMajorVersion) {
+  const libDir = path.join(nativeDir, "lib", "postgresql");
+  const extDir = path.join(nativeDir, "share", "postgresql", "extension");
+  const soName = os.platform() === "darwin" ? "vector.dylib" : "vector.so";
+  try {
+    await fs.access(path.join(libDir, soName));
+    await fs.access(path.join(extDir, "vector.control"));
+    return;
+  } catch {
+  }
+  const platform = os.platform();
+  const arch = os.arch();
+  const cacheDir = getCacheDir();
+  const cacheKey = `pgvector-pg${pgMajorVersion}-${platform}-${arch}`;
+  const cachedDir = path.join(cacheDir, cacheKey);
+  let cached = false;
+  try {
+    await fs.access(path.join(cachedDir, "lib", soName));
+    cached = true;
+  } catch {
+  }
+  if (!cached) {
+    const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "pgvector-"));
+    try {
+      const formulaRes = await fetch(
+        "https://formulae.brew.sh/api/formula/pgvector.json"
+      );
+      if (!formulaRes.ok) {
+        throw new Error(
+          `Failed to fetch pgvector formula: ${formulaRes.status}`
+        );
+      }
+      const formula = await formulaRes.json();
+      const bottleTag = getHomebrewBottleTag(platform, arch);
+      const fileInfo = formula.bottle.stable.files[bottleTag];
+      if (!fileInfo) {
+        throw new Error(
+          `No pgvector Homebrew bottle for ${bottleTag}. Available: ${Object.keys(formula.bottle.stable.files).join(", ")}`
+        );
+      }
+      const tokenRes = await fetch(
+        "https://ghcr.io/token?scope=repository:homebrew/core/pgvector:pull"
+      );
+      if (!tokenRes.ok) {
+        throw new Error(`Failed to get GHCR token: ${tokenRes.status}`);
+      }
+      const { token } = await tokenRes.json();
+      const blobUrl = `https://ghcr.io/v2/homebrew/core/pgvector/blobs/sha256:${fileInfo.sha256}`;
+      const blobRes = await fetch(blobUrl, {
+        headers: { Authorization: `Bearer ${token}` },
+        redirect: "follow"
+      });
+      if (!blobRes.ok) {
+        throw new Error(
+          `Failed to download pgvector bottle: ${blobRes.status}`
+        );
+      }
+      const bottlePath = path.join(tmpDir, "pgvector.tar.gz");
+      const buffer = Buffer.from(await blobRes.arrayBuffer());
+      await fs.writeFile(bottlePath, buffer);
+      const extractDir = path.join(tmpDir, "extracted");
+      await fs.mkdir(extractDir, { recursive: true });
+      await execFile("tar", ["xzf", bottlePath, "-C", extractDir]);
+      const cacheLibDir2 = path.join(cachedDir, "lib");
+      const cacheExtDir2 = path.join(cachedDir, "extension");
+      await fs.mkdir(cacheLibDir2, { recursive: true });
+      await fs.mkdir(cacheExtDir2, { recursive: true });
+      const pgSubdir = `postgresql@${pgMajorVersion}`;
+      let soFiles = await findFiles(
+        extractDir,
+        new RegExp(`${pgSubdir}.*vector\\.(so|dylib)$`)
+      );
+      if (soFiles.length === 0) {
+        soFiles = await findFiles(extractDir, /vector\.(so|dylib)$/);
+      }
+      for (const f of soFiles) {
+        await copyFileWithPermissions(f, path.join(cacheLibDir2, path.basename(f)));
+      }
+      let extFiles = await findFiles(
+        extractDir,
+        new RegExp(`${pgSubdir}.*vector[^/]*(\\.control|\\.sql)$`)
+      );
+      if (extFiles.length === 0) {
+        extFiles = await findFiles(extractDir, /vector[^/]*(\.control|\.sql)$/);
+      }
+      for (const f of extFiles) {
+        await copyFileWithPermissions(f, path.join(cacheExtDir2, path.basename(f)));
+      }
+    } finally {
+      await fs.rm(tmpDir, { recursive: true, force: true });
+    }
+  }
+  await fs.mkdir(libDir, { recursive: true });
+  await fs.mkdir(extDir, { recursive: true });
+  const cacheLibDir = path.join(cachedDir, "lib");
+  const cacheExtDir = path.join(cachedDir, "extension");
+  for (const file of await fs.readdir(cacheLibDir)) {
+    await copyFileWithPermissions(path.join(cacheLibDir, file), path.join(libDir, file));
+  }
+  for (const file of await fs.readdir(cacheExtDir)) {
+    await copyFileWithPermissions(path.join(cacheExtDir, file), path.join(extDir, file));
+  }
+}
+function getHomebrewBottleTag(platform, arch) {
+  if (platform === "darwin") {
+    const release = os.release();
+    const major = parseInt(release.split(".")[0] ?? "0", 10);
+    const prefix = arch === "arm64" ? "arm64_" : "";
+    if (major >= 25) return `${prefix}tahoe`;
+    if (major >= 24) return `${prefix}sequoia`;
+    if (major >= 23) return `${prefix}sonoma`;
+    return `${prefix}ventura`;
+  }
+  if (platform === "linux") {
+    return arch === "arm64" ? "aarch64_linux" : "x86_64_linux";
+  }
+  throw new Error(`No Homebrew bottles available for ${platform}-${arch}`);
+}
+var ORPHAN_MIN_AGE_MS = 6e4;
+async function sweepOrphanedDataDirs(minAgeMs = ORPHAN_MIN_AGE_MS) {
+  const tmpDir = os.tmpdir();
+  let entries;
+  try {
+    entries = await fs.readdir(tmpDir);
+  } catch {
+    return;
+  }
+  const cutoff = Date.now() - minAgeMs;
+  await Promise.all(
+    entries.filter((name) => name.startsWith("postgres-memory-server-")).map(async (name) => {
+      const fullPath = path.join(tmpDir, name);
+      let stat;
+      try {
+        stat = await fs.stat(fullPath);
+        if (!stat.isDirectory()) return;
+      } catch {
+        return;
+      }
+      const pidFile = path.join(fullPath, "postmaster.pid");
+      let pid = null;
+      let pidFileExists = false;
+      try {
+        const content = await fs.readFile(pidFile, "utf8");
+        pidFileExists = true;
+        const firstLine = content.split("\n")[0]?.trim();
+        const parsed = firstLine ? parseInt(firstLine, 10) : NaN;
+        if (!Number.isNaN(parsed) && parsed > 0) {
+          pid = parsed;
+        }
+      } catch {
+      }
+      if (pid !== null) {
+        try {
+          process.kill(pid, 0);
+          return;
+        } catch (err) {
+          const code = err.code;
+          if (code === "EPERM") {
+            return;
+          }
+        }
+      }
+      if (!pidFileExists && stat.mtimeMs > cutoff) {
+        return;
+      }
+      await fs.rm(fullPath, { recursive: true, force: true }).catch(() => {
+      });
+    })
+  );
+}
+function parseParadeDBVersion(version) {
+  const match = version.match(/^(\d+\.\d+\.\d+)(?:-pg(\d+))?$/);
+  if (!match || !match[1]) {
+    return { extVersion: version };
+  }
+  return {
+    extVersion: match[1],
+    pgVersion: match[2]
+  };
+}
 
 // src/presets.ts
+var DEFAULT_PARADEDB_EXT_VERSION = "0.22.5";
+var DEFAULT_POSTGRES_VERSION = getPgMajorVersion();
+var DEFAULT_PARADEDB_VERSION = `${DEFAULT_PARADEDB_EXT_VERSION}-pg${DEFAULT_POSTGRES_VERSION}`;
+var DEFAULT_POSTGRES_IMAGE = `postgres:${DEFAULT_POSTGRES_VERSION}`;
+var DEFAULT_PARADEDB_IMAGE = `paradedb:${DEFAULT_PARADEDB_VERSION}`;
 var POSTGRES_IMAGE_REPOSITORY = "postgres";
-var PARADEDB_IMAGE_REPOSITORY = "paradedb/paradedb";
-var DEFAULT_POSTGRES_VERSION = "17";
-var DEFAULT_PARADEDB_VERSION = "0.22.3-pg17";
-var DEFAULT_POSTGRES_IMAGE = getImageForVersion(
-  "postgres",
-  DEFAULT_POSTGRES_VERSION
-);
-var DEFAULT_PARADEDB_IMAGE = getImageForVersion(
-  "paradedb",
-  DEFAULT_PARADEDB_VERSION
-);
+var PARADEDB_IMAGE_REPOSITORY = "paradedb";
 var DEFAULT_DATABASE = "testdb";
 var DEFAULT_USERNAME = "testuser";
 var DEFAULT_PASSWORD = "testpassword";
@@ -49,7 +470,7 @@ var PARADEDB_DEFAULT_EXTENSIONS = ["pg_search", "vector"];
 function normalizeOptions(options = {}) {
   const preset = options.preset ?? "postgres";
   const version = options.version;
-  const image = options.image ?? getImage(preset, version);
+  const image = getImageLabel(preset, version);
   const database = options.database ?? DEFAULT_DATABASE;
   const username = options.username ?? DEFAULT_USERNAME;
   const password = options.password ?? DEFAULT_PASSWORD;
@@ -73,8 +494,11 @@ function getImageForVersion(preset, version) {
 function getDefaultImage(preset) {
   return preset === "paradedb" ? DEFAULT_PARADEDB_IMAGE : DEFAULT_POSTGRES_IMAGE;
 }
-function getImage(preset, version) {
-  return version ? getImageForVersion(preset, version) : getDefaultImage(preset);
+function getImageLabel(preset, version) {
+  if (version) {
+    return getImageForVersion(preset, version);
+  }
+  return getDefaultImage(preset);
 }
 function getDefaultExtensions(preset) {
   return preset === "paradedb" ? [...PARADEDB_DEFAULT_EXTENSIONS] : [];
@@ -85,6 +509,21 @@ function buildInitStatements(options) {
   );
   return [...extensionStatements, ...options.initSql];
 }
+function resolveParadeDBVersion(version) {
+  if (!version) {
+    return DEFAULT_PARADEDB_EXT_VERSION;
+  }
+  const parsed = parseParadeDBVersion(version);
+  if (parsed.pgVersion) {
+    const installedPg = DEFAULT_POSTGRES_VERSION;
+    if (parsed.pgVersion !== installedPg) {
+      throw new Error(
+        `ParadeDB version "${version}" targets PostgreSQL ${parsed.pgVersion}, but embedded-postgres provides PostgreSQL ${installedPg}. Install embedded-postgres@${parsed.pgVersion}.x to match, or use version "${parsed.extVersion}" without the -pg suffix.`
+      );
+    }
+  }
+  return parsed.extVersion;
+}
 function quoteIdentifier(name) {
   if (/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(name)) {
     return name;
@@ -93,23 +532,117 @@ function quoteIdentifier(name) {
 }
 
 // src/PostgresMemoryServer.ts
+var liveInstances = /* @__PURE__ */ new Set();
+var exitHandlersRegistered = false;
+var orphanSweepDone = false;
+function registerExitHandlers() {
+  if (exitHandlersRegistered) return;
+  exitHandlersRegistered = true;
+  const cleanup = () => {
+    for (const instance of liveInstances) {
+      try {
+        instance._cleanupSync();
+      } catch {
+      }
+    }
+  };
+  process2.once("exit", cleanup);
+  const signalCleanup = (signal) => {
+    cleanup();
+    process2.removeListener(signal, signalCleanup);
+    process2.kill(process2.pid, signal);
+  };
+  process2.on("SIGINT", signalCleanup);
+  process2.on("SIGTERM", signalCleanup);
+  process2.on("SIGHUP", signalCleanup);
+}
 var PostgresMemoryServer = class _PostgresMemoryServer {
-  constructor(container, options) {
-    this.container = container;
+  constructor(pg, port, dataDir, options) {
+    this.pg = pg;
+    this.port = port;
+    this.dataDir = dataDir;
     this.options = options;
     this.snapshotSupported = options.database !== "postgres";
   }
   stopped = false;
   snapshotSupported;
+  hasSnapshot = false;
   static async create(options = {}) {
+    if (!orphanSweepDone) {
+      orphanSweepDone = true;
+      await sweepOrphanedDataDirs().catch(() => {
+      });
+    }
     const normalized = normalizeOptions(options);
-    const container = await new PostgreSqlContainer(normalized.image).withDatabase(normalized.database).withUsername(normalized.username).withPassword(normalized.password).start();
-    const server = new _PostgresMemoryServer(container, normalized);
-    const initStatements = buildInitStatements(normalized);
-    if (initStatements.length > 0) {
-      await server.runSql(initStatements);
+    const port = await getFreePort();
+    const dataDir = await fs2.mkdtemp(
+      path2.join(os2.tmpdir(), "postgres-memory-server-")
+    );
+    let pg;
+    try {
+      const postgresFlags = [];
+      if (normalized.preset === "paradedb") {
+        const nativeDir = getNativeDir();
+        const extVersion = resolveParadeDBVersion(normalized.version);
+        const pgMajor = DEFAULT_POSTGRES_VERSION;
+        try {
+          await installParadeDBExtension(nativeDir, extVersion, pgMajor);
+        } catch (error) {
+          throw new ExtensionInstallError(
+            "pg_search",
+            error instanceof Error ? error : new Error(String(error))
+          );
+        }
+        if (normalized.extensions.includes("vector")) {
+          try {
+            await installPgVectorExtension(nativeDir, pgMajor);
+          } catch (error) {
+            throw new ExtensionInstallError(
+              "vector",
+              error instanceof Error ? error : new Error(String(error))
+            );
+          }
+        }
+        if (normalized.extensions.includes("pg_search") || normalized.extensions.length === 0) {
+          postgresFlags.push("-c", "shared_preload_libraries=pg_search");
+        }
+      }
+      pg = new EmbeddedPostgres({
+        databaseDir: dataDir,
+        port,
+        user: normalized.username,
+        password: normalized.password,
+        persistent: false,
+        postgresFlags,
+        onLog: () => {
+        },
+        onError: () => {
+        }
+      });
+      await pg.initialise();
+      await pg.start();
+      if (normalized.database !== "postgres") {
+        await pg.createDatabase(normalized.database);
+      }
+      const server = new _PostgresMemoryServer(pg, port, dataDir, normalized);
+      liveInstances.add(server);
+      registerExitHandlers();
+      const initStatements = buildInitStatements(normalized);
+      if (initStatements.length > 0) {
+        await server.runSql(initStatements);
+      }
+      return server;
+    } catch (error) {
+      if (pg) {
+        try {
+          await pg.stop();
+        } catch {
+        }
+      }
+      await fs2.rm(dataDir, { recursive: true, force: true }).catch(() => {
+      });
+      throw error;
     }
-    return server;
   }
   static createPostgres(options = {}) {
     return _PostgresMemoryServer.create({ ...options, preset: "postgres" });
@@ -119,15 +652,15 @@ var PostgresMemoryServer = class _PostgresMemoryServer {
   }
   getUri() {
     this.ensureRunning();
-    return this.container.getConnectionUri();
+    return `postgres://${this.options.username}:${this.options.password}@localhost:${this.port}/${this.options.database}`;
   }
   getHost() {
     this.ensureRunning();
-    return this.container.getHost();
+    return "localhost";
   }
   getPort() {
     this.ensureRunning();
-    return this.container.getPort();
+    return this.port;
   }
   getDatabase() {
     return this.options.database;
@@ -141,6 +674,14 @@ var PostgresMemoryServer = class _PostgresMemoryServer {
   getImage() {
     return this.options.image;
   }
+  /**
+   * Returns the absolute path to the temporary PostgreSQL data directory
+   * for this instance. Useful for debugging or backing up state. The
+   * directory is automatically removed by `stop()`.
+   */
+  getDataDir() {
+    return this.dataDir;
+  }
   getConnectionOptions() {
     return {
       host: this.getHost(),
@@ -182,35 +723,115 @@ var PostgresMemoryServer = class _PostgresMemoryServer {
     });
   }
   async runSqlFile(filePath) {
-    const sql = await fs.readFile(filePath, "utf8");
+    const sql = await fs2.readFile(filePath, "utf8");
     await this.runSql(sql);
   }
   async runMigrationsDir(dirPath) {
-    const entries = await fs.readdir(dirPath, { withFileTypes: true });
+    const entries = await fs2.readdir(dirPath, { withFileTypes: true });
     const files = entries.filter(
       (entry) => entry.isFile() && entry.name.toLowerCase().endsWith(".sql")
     ).map((entry) => entry.name).sort((left, right) => left.localeCompare(right));
     for (const file of files) {
-      await this.runSqlFile(path.join(dirPath, file));
+      await this.runSqlFile(path2.join(dirPath, file));
     }
     return files;
   }
+  /**
+   * Create a snapshot of the current database state.
+   * Uses PostgreSQL template databases for fast, native snapshots.
+   */
   async snapshot() {
     this.ensureRunning();
     this.ensureSnapshotSupported();
-    await this.container.snapshot();
+    const snapshotDb = `${this.options.database}_snapshot`;
+    await this.withAdminClient(async (client) => {
+      await client.query(
+        `SELECT pg_terminate_backend(pid) FROM pg_stat_activity WHERE datname = $1 AND pid != pg_backend_pid()`,
+        [this.options.database]
+      );
+      if (this.hasSnapshot) {
+        await client.query(`DROP DATABASE IF EXISTS "${snapshotDb}"`);
+      }
+      await client.query(
+        `CREATE DATABASE "${snapshotDb}" TEMPLATE "${this.options.database}"`
+      );
+    });
+    this.hasSnapshot = true;
   }
+  /**
+   * Restore the database to the last snapshot.
+   * Drops and recreates the database from the snapshot template.
+   */
   async restore() {
     this.ensureRunning();
     this.ensureSnapshotSupported();
-    await this.container.restoreSnapshot();
+    if (!this.hasSnapshot) {
+      throw new Error(
+        "No snapshot exists. Call snapshot() before calling restore()."
+      );
+    }
+    const snapshotDb = `${this.options.database}_snapshot`;
+    await this.withAdminClient(async (client) => {
+      await client.query(
+        `SELECT pg_terminate_backend(pid) FROM pg_stat_activity WHERE datname = $1 AND pid != pg_backend_pid()`,
+        [this.options.database]
+      );
+      await client.query(`DROP DATABASE "${this.options.database}"`);
+      await client.query(
+        `CREATE DATABASE "${this.options.database}" TEMPLATE "${snapshotDb}"`
+      );
+    });
   }
   async stop() {
     if (this.stopped) {
       return;
     }
     this.stopped = true;
-    await this.container.stop();
+    liveInstances.delete(this);
+    try {
+      await this.pg.stop();
+    } catch {
+    }
+    await fs2.rm(this.dataDir, { recursive: true, force: true }).catch(() => {
+    });
+  }
+  /**
+   * Synchronous cleanup for use in process exit handlers. Cannot await,
+   * so we just remove the data directory and let the OS reap the postgres
+   * child process. embedded-postgres registers its own exit hook to kill
+   * the process; this method is a backup for the data directory only.
+   *
+   * @internal
+   */
+  _cleanupSync() {
+    if (this.stopped) {
+      return;
+    }
+    this.stopped = true;
+    liveInstances.delete(this);
+    try {
+      rmSync(this.dataDir, { recursive: true, force: true });
+    } catch {
+    }
+  }
+  /**
+   * Connect to the "postgres" system database for admin operations
+   * (snapshot, restore, etc.).
+   */
+  async withAdminClient(callback) {
+    const client = new Client({
+      host: "localhost",
+      port: this.port,
+      database: "postgres",
+      user: this.options.username,
+      password: this.options.password
+    });
+    await client.connect();
+    try {
+      return await callback(client);
+    } finally {
+      await client.end();
+    }
   }
   ensureRunning() {
     if (this.stopped) {
@@ -226,7 +847,7 @@ var PostgresMemoryServer = class _PostgresMemoryServer {
 
 // src/cli.ts
 async function main() {
-  const { options, initFiles, json } = parseArgs(process.argv.slice(2));
+  const { options, initFiles, json } = parseArgs(process3.argv.slice(2));
   const server = await PostgresMemoryServer.create(options);
   try {
     for (const file of initFiles) {
@@ -242,45 +863,46 @@ async function main() {
       image: server.getImage()
     };
     if (json) {
-      process.stdout.write(`${JSON.stringify(payload, null, 2)}
+      process3.stdout.write(`${JSON.stringify(payload, null, 2)}
 `);
     } else {
-      process.stdout.write(`POSTGRES_MEMORY_SERVER_URI=${payload.uri}
+      process3.stdout.write(`POSTGRES_MEMORY_SERVER_URI=${payload.uri}
 `);
-      process.stdout.write(`POSTGRES_MEMORY_SERVER_HOST=${payload.host}
+      process3.stdout.write(`POSTGRES_MEMORY_SERVER_HOST=${payload.host}
 `);
-      process.stdout.write(`POSTGRES_MEMORY_SERVER_PORT=${payload.port}
+      process3.stdout.write(`POSTGRES_MEMORY_SERVER_PORT=${payload.port}
 `);
-      process.stdout.write(
+      process3.stdout.write(
         `POSTGRES_MEMORY_SERVER_DATABASE=${payload.database}
 `
       );
-      process.stdout.write(
+      process3.stdout.write(
         `POSTGRES_MEMORY_SERVER_USERNAME=${payload.username}
 `
       );
-      process.stdout.write(
+      process3.stdout.write(
         `POSTGRES_MEMORY_SERVER_PASSWORD=${payload.password}
 `
       );
-      process.stdout.write(`POSTGRES_MEMORY_SERVER_IMAGE=${payload.image}
+      process3.stdout.write(`POSTGRES_MEMORY_SERVER_IMAGE=${payload.image}
 `);
-      process.stdout.write("\nPress Ctrl+C to stop the container.\n");
+      process3.stdout.write("\nPress Ctrl+C to stop the server.\n");
     }
     const stop = async () => {
       await server.stop();
-      process.exit(0);
+      process3.exit(0);
     };
-    process.on("SIGINT", () => {
+    process3.on("SIGINT", () => {
       void stop();
     });
-    process.on("SIGTERM", () => {
+    process3.on("SIGTERM", () => {
       void stop();
     });
     await new Promise(() => {
     });
   } catch (error) {
-    await server.stop();
+    await server.stop().catch(() => {
+    });
     throw error;
   }
 }
@@ -302,7 +924,7 @@ function parseArgs(argv) {
         break;
       }
       case "--image": {
-        options.image = readValue(argv, ++index, arg);
+        readValue(argv, ++index, arg);
         break;
       }
       case "--version": {
@@ -335,7 +957,7 @@ function parseArgs(argv) {
       }
       case "--help": {
         printHelp();
-        process.exit(0);
+        process3.exit(0);
       }
       default: {
         throw new Error(`Unknown argument: ${arg}`);
@@ -355,36 +977,36 @@ function readValue(argv, index, flag) {
   return value;
 }
 function printHelp() {
-  process.stdout.write(`postgres-memory-server
+  process3.stdout.write(`postgres-memory-server
 
 `);
-  process.stdout.write(`Options:
+  process3.stdout.write(`Options:
 `);
-  process.stdout.write(`  --preset postgres|paradedb
+  process3.stdout.write(`  --preset postgres|paradedb
 `);
-  process.stdout.write(`  --version <tag>
+  process3.stdout.write(`  --version <tag>
 `);
-  process.stdout.write(`  --image <image>
+  process3.stdout.write(`  --image <image>         (deprecated, ignored)
 `);
-  process.stdout.write(`  --database <name>
+  process3.stdout.write(`  --database <name>
 `);
-  process.stdout.write(`  --username <name>
+  process3.stdout.write(`  --username <name>
 `);
-  process.stdout.write(`  --password <password>
+  process3.stdout.write(`  --password <password>
 `);
-  process.stdout.write(`  --extension <name>      repeatable
+  process3.stdout.write(`  --extension <name>      repeatable
 `);
-  process.stdout.write(`  --init-file <path>      repeatable
+  process3.stdout.write(`  --init-file <path>      repeatable
 `);
-  process.stdout.write(`  --json
+  process3.stdout.write(`  --json
 `);
-  process.stdout.write(`  --help
+  process3.stdout.write(`  --help
 `);
 }
 void main().catch((error) => {
   const message = error instanceof Error ? error.stack ?? error.message : String(error);
-  process.stderr.write(`${message}
+  process3.stderr.write(`${message}
 `);
-  process.exit(1);
+  process3.exit(1);
 });
 //# sourceMappingURL=cli.js.map