@specific.dev/cli 0.1.49 → 0.1.51

package/dist/cli.js

@@ -238,15 +238,15 @@ var init_wsl_utils = __esm({
       const { stdout } = await executePowerShell(command, { powerShellPath: psPath });
       return stdout.trim();
     };
-    convertWslPathToWindows = async (path24) => {
-      if (/^[a-z]+:\/\//i.test(path24)) {
-        return path24;
+    convertWslPathToWindows = async (path26) => {
+      if (/^[a-z]+:\/\//i.test(path26)) {
+        return path26;
       }
       try {
-        const { stdout } = await execFile2("wslpath", ["-aw", path24], { encoding: "utf8" });
+        const { stdout } = await execFile2("wslpath", ["-aw", path26], { encoding: "utf8" });
         return stdout.trim();
       } catch {
-        return path24;
+        return path26;
       }
     };
   }
@@ -637,19 +637,19 @@ var init_open = __esm({
       }
       const subprocess = childProcess3.spawn(command, cliArguments, childProcessOptions);
       if (options2.wait) {
-        return new Promise((resolve7, reject) => {
+        return new Promise((resolve10, reject) => {
           subprocess.once("error", reject);
           subprocess.once("close", (exitCode) => {
             if (!options2.allowNonzeroExitCode && exitCode !== 0) {
               reject(new Error(`Exited with code ${exitCode}`));
               return;
             }
-            resolve7(subprocess);
+            resolve10(subprocess);
           });
         });
       }
       if (isFallbackAttempt) {
-        return new Promise((resolve7, reject) => {
+        return new Promise((resolve10, reject) => {
           subprocess.once("error", reject);
           subprocess.once("spawn", () => {
             subprocess.once("close", (exitCode) => {
@@ -659,17 +659,17 @@ var init_open = __esm({
                 return;
               }
               subprocess.unref();
-              resolve7(subprocess);
+              resolve10(subprocess);
             });
           });
         });
       }
       subprocess.unref();
-      return new Promise((resolve7, reject) => {
+      return new Promise((resolve10, reject) => {
         subprocess.once("error", reject);
         subprocess.once("spawn", () => {
           subprocess.off("error", reject);
-          resolve7(subprocess);
+          resolve10(subprocess);
         });
       });
     };
@@ -754,8 +754,8 @@ var require_dist = __commonJS({
       var $global, $module, $NaN = NaN;
       if ("undefined" != typeof window ? $global = window : "undefined" != typeof self ? $global = self : "undefined" != typeof global ? ($global = global).require = __require : $global = this, void 0 === $global || void 0 === $global.Array) throw new Error("no global object found");
       if ("undefined" != typeof module && ($module = module), !$global.fs && $global.require) try {
-        var fs26 = $global.require("fs");
-        "object" == typeof fs26 && null !== fs26 && 0 !== Object.keys(fs26).length && ($global.fs = fs26);
+        var fs28 = $global.require("fs");
+        "object" == typeof fs28 && null !== fs28 && 0 !== Object.keys(fs28).length && ($global.fs = fs28);
       } catch (e) {
       }
       if (!$global.fs) {
@@ -183682,7 +183682,7 @@ async function pollUntilToken(deviceAuth, isCancelled) {
   return null;
 }
 function sleep(ms) {
-  return new Promise((resolve7) => setTimeout(resolve7, ms));
+  return new Promise((resolve10) => setTimeout(resolve10, ms));
 }
 
 // src/lib/auth/login.tsx
@@ -183699,7 +183699,7 @@ function LoginUI({
   return /* @__PURE__ */ React.createElement(Box, { flexDirection: "column", gap: 1 }, isReauthentication && /* @__PURE__ */ React.createElement(Text, { color: "yellow" }, "Session expired. Please log in again."), /* @__PURE__ */ React.createElement(Text, { bold: true }, "Log in to Specific"), state.phase === "waiting-for-browser" ? /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement(Box, { flexDirection: "column" }, /* @__PURE__ */ React.createElement(Text, null, "Your authentication code:", " ", /* @__PURE__ */ React.createElement(Text, { color: "cyan", bold: true }, state.userCode))), /* @__PURE__ */ React.createElement(Box, null, /* @__PURE__ */ React.createElement(Text, { color: "blue" }, /* @__PURE__ */ React.createElement(Spinner, { type: "dots" })), /* @__PURE__ */ React.createElement(Text, null, " Waiting for authentication in browser...")), /* @__PURE__ */ React.createElement(Text, { dimColor: true }, "If the browser didn't open, visit: ", state.verificationUri)) : /* @__PURE__ */ React.createElement(Box, null, /* @__PURE__ */ React.createElement(Text, { color: "blue" }, /* @__PURE__ */ React.createElement(Spinner, { type: "dots" })), /* @__PURE__ */ React.createElement(Text, null, " Initiating login...")));
 }
 function performLogin(options2 = {}) {
-  return new Promise((resolve7) => {
+  return new Promise((resolve10) => {
     let currentState = { phase: "initiating" };
     let flowHandle;
     const instance = render(
@@ -183739,14 +183739,14 @@ function performLogin(options2 = {}) {
             process.off("SIGINT", handleExit);
             process.off("SIGTERM", handleExit);
             instance.unmount();
-            resolve7({ success: true, userEmail: newState.email });
+            resolve10({ success: true, userEmail: newState.email });
           }, 100);
         } else if (newState.phase === "error") {
           setTimeout(() => {
             process.off("SIGINT", handleExit);
             process.off("SIGTERM", handleExit);
             instance.unmount();
-            resolve7({ success: false, error: new Error(newState.message) });
+            resolve10({ success: false, error: new Error(newState.message) });
           }, 100);
         }
       }
@@ -183873,7 +183873,7 @@ function trackEvent(event, properties) {
     event,
     properties: {
       ...properties,
-      cli_version: "0.1.49",
+      cli_version: "0.1.51",
       platform: process.platform,
       node_version: process.version,
       project_id: getProjectId(),
@@ -184235,35 +184235,95 @@ Valid agents: ${VALID_AGENT_IDS.join(", ")}`
 }
 
 // src/commands/docs.tsx
-import { readFileSync as readFileSync5, existsSync as existsSync5 } from "fs";
-import { join as join6, dirname as dirname2 } from "path";
+import { readFileSync as readFileSync6, existsSync as existsSync6 } from "fs";
+import { join as join7, dirname as dirname2 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
+
+// src/lib/beta/registry.ts
+var BETA_REGISTRY = [
+  {
+    name: "reshape",
+    description: "Zero-downtime database schema migrations using Reshape"
+  }
+];
+
+// src/lib/beta/storage.ts
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync5, existsSync as existsSync5, mkdirSync as mkdirSync6 } from "fs";
+import { join as join6 } from "path";
+var BETAS_FILE = ".specific/betas.json";
+function loadEnabledBetas(projectDir = process.cwd()) {
+  const filePath = join6(projectDir, BETAS_FILE);
+  if (!existsSync5(filePath)) {
+    return [];
+  }
+  try {
+    const content = readFileSync5(filePath, "utf-8");
+    const data = JSON.parse(content);
+    return data.enabled ?? [];
+  } catch {
+    return [];
+  }
+}
+function enableBeta(name, projectDir = process.cwd()) {
+  const enabled = loadEnabledBetas(projectDir);
+  if (!enabled.includes(name)) {
+    enabled.push(name);
+    saveBetas(enabled, projectDir);
+  }
+}
+function disableBeta(name, projectDir = process.cwd()) {
+  const enabled = loadEnabledBetas(projectDir).filter((b) => b !== name);
+  saveBetas(enabled, projectDir);
+}
+function saveBetas(enabled, projectDir) {
+  const specificDir = join6(projectDir, ".specific");
+  if (!existsSync5(specificDir)) {
+    mkdirSync6(specificDir, { recursive: true });
+  }
+  const data = { enabled };
+  writeFileSync5(
+    join6(projectDir, BETAS_FILE),
+    JSON.stringify(data, null, 2) + "\n"
+  );
+}
+
+// src/commands/docs.tsx
 var __dirname2 = dirname2(fileURLToPath2(import.meta.url));
-var docsDir = join6(__dirname2, "docs");
-function docsCommand(path24) {
-  const docPath = resolveDocPath(path24);
+var docsDir = join7(__dirname2, "docs");
+function docsCommand(path26) {
+  const docPath = resolveDocPath(path26);
   if (!docPath) {
     console.error(
-      `Documentation not found: ${path24 || "index"}
+      `Documentation not found: ${path26 || "index"}
 
 Run 'specific docs' to see available topics.`
     );
     process.exit(1);
   }
-  const content = readFileSync5(docPath, "utf-8");
+  const enabledBetas = new Set(loadEnabledBetas());
+  let content = readFileSync6(docPath, "utf-8");
+  content = filterBetaTags(content, enabledBetas);
   console.log(content);
 }
-function resolveDocPath(path24) {
-  if (!path24) {
-    const indexPath2 = join6(docsDir, "index.md");
-    return existsSync5(indexPath2) ? indexPath2 : null;
+function filterBetaTags(content, enabledBetas) {
+  return content.replace(
+    /<!-- beta:(\w[\w-]*) -->\n?([\s\S]*?)<!-- \/beta:\1 -->\n?/g,
+    (_, betaName, betaContent) => {
+      return enabledBetas.has(betaName) ? betaContent : "";
+    }
+  );
+}
+function resolveDocPath(path26) {
+  if (!path26) {
+    const indexPath2 = join7(docsDir, "index.md");
+    return existsSync6(indexPath2) ? indexPath2 : null;
   }
-  const directPath = join6(docsDir, `${path24}.md`);
-  if (existsSync5(directPath)) {
+  const directPath = join7(docsDir, `${path26}.md`);
+  if (existsSync6(directPath)) {
     return directPath;
   }
-  const indexPath = join6(docsDir, path24, "index.md");
-  if (existsSync5(indexPath)) {
+  const indexPath = join7(docsDir, path26, "index.md");
+  if (existsSync6(indexPath)) {
     return indexPath;
   }
   return null;
@@ -184273,8 +184333,9 @@ function resolveDocPath(path24) {
 import React3, { useState as useState2, useEffect as useEffect2 } from "react";
 import { render as render3, Text as Text3, Box as Box3 } from "ink";
 import Spinner3 from "ink-spinner";
-import * as fs11 from "fs";
-import * as path7 from "path";
+import * as fs12 from "fs";
+import * as path8 from "path";
+import { execFile as execFile7 } from "child_process";
 
 // node_modules/.pnpm/@specific+config@file+..+config/node_modules/@specific/config/dist/parser.js
 var import_hcl2_json_parser = __toESM(require_dist(), 1);
@@ -184468,6 +184529,9 @@ function parseBuilds(buildData) {
     if (fieldObj.context) {
       build.context = String(fieldObj.context);
     }
+    if (fieldObj.root) {
+      build.root = String(fieldObj.root);
+    }
     if (dev) {
       build.dev = dev;
     }
@@ -184555,6 +184619,9 @@ function parseServices(serviceData) {
     if (fieldObj.command) {
       service.command = String(fieldObj.command);
     }
+    if (fieldObj.root) {
+      service.root = String(fieldObj.root);
+    }
     const endpoints = parseEndpoints(fieldObj);
     if (fieldObj.expose !== void 0) {
       service.expose = {};
@@ -184589,13 +184656,43 @@ function parseServices(serviceData) {
   }
   return services;
 }
+function parseReshapeBlock(reshape) {
+  if (!reshape) {
+    return void 0;
+  }
+  const reshapeArray = Array.isArray(reshape) ? reshape : [reshape];
+  const reshapeObj = reshapeArray[0];
+  if (!reshapeObj || typeof reshapeObj !== "object" || Array.isArray(reshapeObj)) {
+    return void 0;
+  }
+  const fieldObj = reshapeObj;
+  if (fieldObj.enabled !== true) {
+    return void 0;
+  }
+  const result = {
+    enabled: true
+  };
+  if (typeof fieldObj.migrations_dir === "string") {
+    result.migrations_dir = fieldObj.migrations_dir;
+  }
+  return result;
+}
 function parsePostgres(data) {
   if (!data || typeof data !== "object" || Array.isArray(data)) {
     return [];
   }
   const result = [];
-  for (const [name] of Object.entries(data)) {
-    result.push({ name });
+  for (const [name, fieldsArray] of Object.entries(data)) {
+    const postgres = { name };
+    const fields = Array.isArray(fieldsArray) ? fieldsArray[0] : fieldsArray;
+    if (fields && typeof fields === "object" && !Array.isArray(fields)) {
+      const fieldObj = fields;
+      const reshape = parseReshapeBlock(fieldObj.reshape);
+      if (reshape) {
+        postgres.reshape = reshape;
+      }
+    }
+    result.push(postgres);
   }
   return result;
 }
@@ -184826,13 +184923,374 @@ function validateEndpointReferences(config) {
   return errors;
 }
 
+// src/lib/bin/types.ts
+var BinaryNotFoundError = class extends Error {
+  constructor(binaryName, version, platformInfo) {
+    super(
+      `Binary "${binaryName}" version ${version} is not available for ${platformInfo.platform}-${platformInfo.arch}`
+    );
+    this.binaryName = binaryName;
+    this.version = version;
+    this.platformInfo = platformInfo;
+    this.name = "BinaryNotFoundError";
+  }
+};
+var DownloadError = class extends Error {
+  constructor(url, statusCode, cause) {
+    super(
+      statusCode ? `Failed to download ${url}: HTTP ${statusCode}` : `Failed to download ${url}: ${cause?.message || "Unknown error"}`
+    );
+    this.url = url;
+    this.statusCode = statusCode;
+    this.cause = cause;
+    this.name = "DownloadError";
+  }
+};
+var ExtractionError = class extends Error {
+  constructor(archivePath, cause) {
+    super(
+      `Failed to extract ${archivePath}: ${cause?.message || "Unknown error"}`
+    );
+    this.archivePath = archivePath;
+    this.cause = cause;
+    this.name = "ExtractionError";
+  }
+};
+
+// src/lib/bin/manager.ts
+import * as fs11 from "fs";
+import * as path7 from "path";
+import * as os6 from "os";
+import { createReadStream } from "fs";
+import { createTarExtractor, extractTo } from "tar-vern";
+function getLibraryEnv(binary) {
+  if (!binary.libraryPath) {
+    return {};
+  }
+  const platform4 = os6.platform();
+  if (platform4 === "darwin") {
+    return { DYLD_LIBRARY_PATH: binary.libraryPath };
+  } else if (platform4 === "linux") {
+    return { LD_LIBRARY_PATH: binary.libraryPath };
+  }
+  return {};
+}
+function getBinBaseDir() {
+  return path7.join(os6.homedir(), ".specific", "bin");
+}
+function getPlatformInfo() {
+  const platform4 = os6.platform();
+  const arch3 = os6.arch();
+  if (platform4 !== "darwin" && platform4 !== "linux") {
+    throw new Error(
+      `Unsupported platform: ${platform4}. Only macOS and Linux are supported.`
+    );
+  }
+  const archStr = arch3;
+  let mappedArch;
+  if (archStr === "x64" || archStr === "x86_64") {
+    mappedArch = "x64";
+  } else if (archStr === "arm64" || archStr === "aarch64") {
+    mappedArch = "arm64";
+  } else {
+    throw new Error(
+      `Unsupported architecture: ${arch3}. Only x64 and arm64 are supported.`
+    );
+  }
+  return { platform: platform4, arch: mappedArch };
+}
+function getBinaryDir(definition, version, platformInfo) {
+  return path7.join(
+    getBinBaseDir(),
+    definition.name,
+    version,
+    `${platformInfo.platform}-${platformInfo.arch}`
+  );
+}
+function isBinaryInstalled(definition, version, platformInfo) {
+  const binDir = getBinaryDir(definition, version, platformInfo);
+  for (const execPath of definition.executables) {
+    const fullPath = path7.join(binDir, execPath);
+    if (!fs11.existsSync(fullPath)) {
+      return false;
+    }
+  }
+  return true;
+}
+function buildDownloadUrl(definition, version, platformInfo) {
+  const mapping = definition.platformMapping[platformInfo.platform]?.[platformInfo.arch];
+  if (!mapping) {
+    throw new BinaryNotFoundError(definition.name, version, platformInfo);
+  }
+  return definition.urlTemplate.replace(/{version}/g, version).replace(/{platform}/g, mapping.platform).replace(/{arch}/g, mapping.arch);
+}
+async function downloadFile(url, destPath, onProgress) {
+  let response;
+  try {
+    response = await fetch(url);
+  } catch (error) {
+    throw new DownloadError(url, void 0, error);
+  }
+  if (!response.ok) {
+    throw new DownloadError(url, response.status);
+  }
+  const totalBytes = parseInt(
+    response.headers.get("content-length") || "0",
+    10
+  );
+  let bytesDownloaded = 0;
+  const parentDir = path7.dirname(destPath);
+  if (!fs11.existsSync(parentDir)) {
+    fs11.mkdirSync(parentDir, { recursive: true });
+  }
+  const partPath = destPath + ".part";
+  const fileStream = fs11.createWriteStream(partPath);
+  try {
+    const reader = response.body.getReader();
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      bytesDownloaded += value.length;
+      fileStream.write(Buffer.from(value));
+      if (onProgress) {
+        onProgress({
+          phase: "downloading",
+          bytesDownloaded,
+          totalBytes: totalBytes || void 0,
+          percent: totalBytes ? Math.round(bytesDownloaded / totalBytes * 100) : void 0
+        });
+      }
+    }
+    await new Promise((resolve10, reject) => {
+      fileStream.end((err) => {
+        if (err) reject(err);
+        else resolve10();
+      });
+    });
+    fs11.renameSync(partPath, destPath);
+  } catch (error) {
+    try {
+      fileStream.close();
+      if (fs11.existsSync(partPath)) {
+        fs11.unlinkSync(partPath);
+      }
+    } catch {
+    }
+    throw new DownloadError(url, void 0, error);
+  }
+}
+async function extractTarball(archivePath, destDir, definition, onProgress) {
+  onProgress?.({ phase: "extracting" });
+  if (!fs11.existsSync(destDir)) {
+    fs11.mkdirSync(destDir, { recursive: true });
+  }
+  try {
+    const fileStream = createReadStream(archivePath);
+    const entries = createTarExtractor(fileStream, "gzip");
+    await extractTo(entries, destDir);
+    onProgress?.({ phase: "finalizing" });
+    for (const execPath of definition.executables) {
+      const fullPath = path7.join(destDir, execPath);
+      if (fs11.existsSync(fullPath)) {
+        fs11.chmodSync(fullPath, 493);
+      }
+    }
+  } catch (error) {
+    throw new ExtractionError(archivePath, error);
+  }
+}
+async function ensureBinary(definition, version, onProgress) {
+  const platformInfo = getPlatformInfo();
+  const resolvedVersion = version || definition.versions[0];
+  if (!definition.versions.includes(resolvedVersion)) {
+    throw new Error(
+      `Version ${resolvedVersion} not supported for ${definition.name}. Supported versions: ${definition.versions.join(", ")}`
+    );
+  }
+  const binDir = getBinaryDir(definition, resolvedVersion, platformInfo);
+  if (!isBinaryInstalled(definition, resolvedVersion, platformInfo)) {
+    const url = buildDownloadUrl(definition, resolvedVersion, platformInfo);
+    if (definition.type === "binary") {
+      if (definition.executables.length !== 1) {
+        throw new Error(
+          `Binary type definitions must have exactly one executable, got ${definition.executables.length}`
+        );
+      }
+      if (!fs11.existsSync(binDir)) {
+        fs11.mkdirSync(binDir, { recursive: true });
+      }
+      const execPath = path7.join(binDir, definition.executables[0]);
+      await downloadFile(url, execPath, onProgress);
+      fs11.chmodSync(execPath, 493);
+      onProgress?.({ phase: "finalizing" });
+    } else {
+      const downloadDir = path7.join(getBinBaseDir(), "downloads");
+      const archiveName = `${definition.name}-${resolvedVersion}-${platformInfo.platform}-${platformInfo.arch}.tar.gz`;
+      const archivePath = path7.join(downloadDir, archiveName);
+      try {
+        await downloadFile(url, archivePath, onProgress);
+        await extractTarball(archivePath, binDir, definition, onProgress);
+      } finally {
+        try {
+          if (fs11.existsSync(archivePath)) {
+            fs11.unlinkSync(archivePath);
+          }
+        } catch {
+        }
+      }
+    }
+  }
+  const executables = {};
+  for (const execPath of definition.executables) {
+    const name = path7.basename(execPath);
+    executables[name] = path7.join(binDir, execPath);
+  }
+  const libraryPath = definition.libraryDir ? path7.join(binDir, definition.libraryDir) : void 0;
+  return {
+    rootDir: binDir,
+    version: resolvedVersion,
+    executables,
+    libraryPath
+  };
+}
+
+// src/lib/bin/definitions/postgres.ts
+var postgresBinary = {
+  name: "postgres",
+  versions: ["18.1"],
+  // URL: binaries.specific.dev/{SOFTWARE}/{VERSION}/{ARCH}.tar.gz
+  urlTemplate: "https://binaries.specific.dev/postgres/{version}/{arch}.tar.gz",
+  platformMapping: {
+    darwin: {
+      arm64: { platform: "macos", arch: "macos_arm" },
+      x64: { platform: "macos", arch: "macos_x86" }
+    },
+    linux: {
+      arm64: { platform: "linux", arch: "linux_arm" },
+      x64: { platform: "linux", arch: "linux_x86" }
+    }
+  },
+  // Archive contains bin/ and lib/ directories at root
+  stripComponents: 0,
+  // Core PostgreSQL executables (in bin/ directory)
+  executables: ["bin/postgres", "bin/initdb", "bin/psql"],
+  // Library directory relative to root (for setting LD_LIBRARY_PATH)
+  libraryDir: "lib"
+};
+
+// src/lib/bin/definitions/redis.ts
+var redisBinary = {
+  name: "redis",
+  versions: ["8.4.0"],
+  // URL: binaries.specific.dev/{SOFTWARE}/{VERSION}/{ARCH}.tar.gz
+  urlTemplate: "https://binaries.specific.dev/redis/{version}/{arch}.tar.gz",
+  platformMapping: {
+    darwin: {
+      arm64: { platform: "macos", arch: "macos_arm" },
+      x64: { platform: "macos", arch: "macos_x86" }
+    },
+    linux: {
+      arm64: { platform: "linux", arch: "linux_arm" },
+      x64: { platform: "linux", arch: "linux_x86" }
+    }
+  },
+  // Binaries are at the root of the archive
+  stripComponents: 0,
+  // Core Redis executable
+  executables: ["redis-server"]
+};
+
+// src/lib/bin/definitions/electric.ts
+var electricBinary = {
+  name: "electric",
+  versions: ["1.2.11"],
+  // URL: binaries.specific.dev/{SOFTWARE}/{VERSION}/{ARCH}.tar.gz
+  urlTemplate: "https://binaries.specific.dev/electric/{version}/{arch}.tar.gz",
+  platformMapping: {
+    darwin: {
+      arm64: { platform: "macos", arch: "macos_arm" },
+      x64: { platform: "macos", arch: "macos_x86" }
+    },
+    linux: {
+      arm64: { platform: "linux", arch: "linux_arm" },
+      x64: { platform: "linux", arch: "linux_x86" }
+    }
+  },
+  // Binaries are at the root of the archive
+  stripComponents: 0,
+  // Core Electric executable
+  executables: ["electric"]
+};
+
+// src/lib/bin/definitions/drizzle-gateway.ts
+var drizzleGatewayBinary = {
+  name: "drizzle-gateway",
+  versions: ["1.2.0"],
+  // Official Drizzle Gateway download URL from R2
+  urlTemplate: "https://pub-e240a4fd7085425baf4a7951e7611520.r2.dev/drizzle-gateway-{version}-{arch}",
+  platformMapping: {
+    darwin: {
+      arm64: { platform: "macos", arch: "macos-arm64" },
+      x64: { platform: "macos", arch: "macos-x64" }
+    },
+    linux: {
+      arm64: { platform: "linux", arch: "linux-arm64" },
+      x64: { platform: "linux", arch: "linux-x64" }
+    }
+  },
+  // Raw binary, not a tarball
+  type: "binary",
+  // The executable name
+  executables: ["drizzle-gateway"]
+};
+
+// src/lib/bin/definitions/reshape.ts
+var reshapeBinary = {
+  name: "reshape",
+  versions: ["0.9.1"],
+  // GitHub release assets
+  urlTemplate: "https://github.com/fabianlindfors/reshape/releases/download/v{version}/reshape-{arch}",
+  platformMapping: {
+    darwin: {
+      arm64: { platform: "darwin", arch: "darwin_aarch64" },
+      x64: { platform: "darwin", arch: "darwin_amd64" }
+    },
+    linux: {
+      arm64: { platform: "linux", arch: "linux_aarch64" },
+      x64: { platform: "linux", arch: "linux_amd64" }
+    }
+  },
+  // Raw binary, not a tarball
+  type: "binary",
+  // The executable name
+  executables: ["reshape"]
+};
+
 // src/commands/check.tsx
+async function runReshapeCheck(migrationsDir) {
+  try {
+    const binary = await ensureBinary(reshapeBinary);
+    const reshapePath = binary.executables["reshape"];
+    return new Promise((resolve10) => {
+      execFile7(reshapePath, ["check", "--dirs", migrationsDir], (err, _stdout, stderr) => {
+        if (err) {
+          const errorMsg = stderr.trim() || err.message;
+          resolve10({ success: false, error: errorMsg });
+        } else {
+          resolve10({ success: true });
+        }
+      });
+    });
+  } catch (err) {
+    return { success: false, error: err instanceof Error ? err.message : String(err) };
+  }
+}
 function CheckUI() {
   const [state, setState] = useState2({ status: "loading" });
   useEffect2(() => {
     async function load() {
-      const configPath = path7.join(process.cwd(), "specific.hcl");
-      if (!fs11.existsSync(configPath)) {
+      const configPath = path8.join(process.cwd(), "specific.hcl");
+      if (!fs12.existsSync(configPath)) {
         setState({
           status: "error",
           error: "No specific.hcl found in current directory"
@@ -184840,9 +185298,36 @@ function CheckUI() {
         return;
       }
       try {
-        const hcl = fs11.readFileSync(configPath, "utf-8");
+        const hcl = fs12.readFileSync(configPath, "utf-8");
         const config2 = await parseConfig(hcl);
-        setState({ status: "success", config: config2 });
+        const reshapeChecks2 = [];
+        for (const pg of config2.postgres) {
+          if (pg.reshape?.enabled) {
+            const migrationsDir = path8.resolve(
+              process.cwd(),
+              pg.reshape.migrations_dir ?? "migrations"
+            );
+            if (!fs12.existsSync(migrationsDir)) {
+              reshapeChecks2.push({
+                databaseName: pg.name,
+                migrationsDir: pg.reshape.migrations_dir ?? "migrations",
+                success: false,
+                error: `Migrations directory not found: ${migrationsDir}`
+              });
+              continue;
+            }
+            const result = await runReshapeCheck(migrationsDir);
+            reshapeChecks2.push({
+              databaseName: pg.name,
+              migrationsDir: pg.reshape.migrations_dir ?? "migrations",
+              ...result
+            });
+          }
+        }
+        if (reshapeChecks2.some((r) => !r.success)) {
+          process.exitCode = 1;
+        }
+        setState({ status: "success", config: config2, reshapeChecks: reshapeChecks2 });
       } catch (err) {
         setState({
           status: "error",
@@ -184862,7 +185347,10 @@ function CheckUI() {
   if (!config) {
     return null;
   }
-  return /* @__PURE__ */ React3.createElement(Box3, { flexDirection: "column", gap: 1 }, /* @__PURE__ */ React3.createElement(Text3, { color: "green" }, "Configuration is valid"), config.builds.length > 0 && /* @__PURE__ */ React3.createElement(Box3, { flexDirection: "column" }, /* @__PURE__ */ React3.createElement(Text3, { bold: true }, "Builds (", config.builds.length, "):"), config.builds.map((b) => /* @__PURE__ */ React3.createElement(Text3, { key: b.name }, "  ", "- ", b.name))), config.services.length > 0 && /* @__PURE__ */ React3.createElement(Box3, { flexDirection: "column" }, /* @__PURE__ */ React3.createElement(Text3, { bold: true }, "Services (", config.services.length, "):"), config.services.map((s) => /* @__PURE__ */ React3.createElement(Text3, { key: s.name }, "  ", "- ", s.name))), config.postgres.length > 0 && /* @__PURE__ */ React3.createElement(Box3, { flexDirection: "column" }, /* @__PURE__ */ React3.createElement(Text3, { bold: true }, "Postgres (", config.postgres.length, "):"), config.postgres.map((p) => /* @__PURE__ */ React3.createElement(Text3, { key: p.name }, "  ", "- ", p.name))), config.redis.length > 0 && /* @__PURE__ */ React3.createElement(Box3, { flexDirection: "column" }, /* @__PURE__ */ React3.createElement(Text3, { bold: true }, "Redis (", config.redis.length, "):"), config.redis.map((r) => /* @__PURE__ */ React3.createElement(Text3, { key: r.name }, "  ", "- ", r.name))), config.storage.length > 0 && /* @__PURE__ */ React3.createElement(Box3, { flexDirection: "column" }, /* @__PURE__ */ React3.createElement(Text3, { bold: true }, "Storage (", config.storage.length, "):"), config.storage.map((s) => /* @__PURE__ */ React3.createElement(Text3, { key: s.name }, "  ", "- ", s.name))), config.configs.length > 0 && /* @__PURE__ */ React3.createElement(Box3, { flexDirection: "column" }, /* @__PURE__ */ React3.createElement(Text3, { bold: true }, "Config (", config.configs.length, "):"), config.configs.map((c) => /* @__PURE__ */ React3.createElement(Text3, { key: c.name }, "  ", "- ", c.name, c.default ? ` (default: ${c.default})` : ""))), config.environments.length > 0 && /* @__PURE__ */ React3.createElement(Box3, { flexDirection: "column" }, /* @__PURE__ */ React3.createElement(Text3, { bold: true }, "Environments (", config.environments.length, "):"), config.environments.map((e) => /* @__PURE__ */ React3.createElement(Text3, { key: e.name }, "  ", "- ", e.name))));
+  const reshapeChecks = state.reshapeChecks ?? [];
+  const reshapeErrors = reshapeChecks.filter((r) => !r.success);
+  const hasReshapeErrors = reshapeErrors.length > 0;
+  return /* @__PURE__ */ React3.createElement(Box3, { flexDirection: "column", gap: 1 }, /* @__PURE__ */ React3.createElement(Text3, { color: hasReshapeErrors ? "yellow" : "green" }, hasReshapeErrors ? "Configuration is valid but reshape migrations have errors" : "Configuration is valid"), config.builds.length > 0 && /* @__PURE__ */ React3.createElement(Box3, { flexDirection: "column" }, /* @__PURE__ */ React3.createElement(Text3, { bold: true }, "Builds (", config.builds.length, "):"), config.builds.map((b) => /* @__PURE__ */ React3.createElement(Text3, { key: b.name }, "  ", "- ", b.name))), config.services.length > 0 && /* @__PURE__ */ React3.createElement(Box3, { flexDirection: "column" }, /* @__PURE__ */ React3.createElement(Text3, { bold: true }, "Services (", config.services.length, "):"), config.services.map((s) => /* @__PURE__ */ React3.createElement(Text3, { key: s.name }, "  ", "- ", s.name))), config.postgres.length > 0 && /* @__PURE__ */ React3.createElement(Box3, { flexDirection: "column" }, /* @__PURE__ */ React3.createElement(Text3, { bold: true }, "Postgres (", config.postgres.length, "):"), config.postgres.map((p) => /* @__PURE__ */ React3.createElement(Text3, { key: p.name }, "  ", "- ", p.name, p.reshape?.enabled ? " (reshape enabled)" : ""))), reshapeChecks.length > 0 && /* @__PURE__ */ React3.createElement(Box3, { flexDirection: "column" }, /* @__PURE__ */ React3.createElement(Text3, { bold: true }, "Reshape Migrations:"), reshapeChecks.map((r) => /* @__PURE__ */ React3.createElement(Box3, { key: r.databaseName, flexDirection: "column" }, /* @__PURE__ */ React3.createElement(Text3, null, "  ", /* @__PURE__ */ React3.createElement(Text3, { color: r.success ? "green" : "red" }, r.success ? "pass" : "fail"), " ", r.databaseName, " (", r.migrationsDir, ")"), r.error && /* @__PURE__ */ React3.createElement(Text3, { color: "red" }, "       ", r.error)))), config.redis.length > 0 && /* @__PURE__ */ React3.createElement(Box3, { flexDirection: "column" }, /* @__PURE__ */ React3.createElement(Text3, { bold: true }, "Redis (", config.redis.length, "):"), config.redis.map((r) => /* @__PURE__ */ React3.createElement(Text3, { key: r.name }, "  ", "- ", r.name))), config.storage.length > 0 && /* @__PURE__ */ React3.createElement(Box3, { flexDirection: "column" }, /* @__PURE__ */ React3.createElement(Text3, { bold: true }, "Storage (", config.storage.length, "):"), config.storage.map((s) => /* @__PURE__ */ React3.createElement(Text3, { key: s.name }, "  ", "- ", s.name))), config.configs.length > 0 && /* @__PURE__ */ React3.createElement(Box3, { flexDirection: "column" }, /* @__PURE__ */ React3.createElement(Text3, { bold: true }, "Config (", config.configs.length, "):"), config.configs.map((c) => /* @__PURE__ */ React3.createElement(Text3, { key: c.name }, "  ", "- ", c.name, c.default ? ` (default: ${c.default})` : ""))), config.environments.length > 0 && /* @__PURE__ */ React3.createElement(Box3, { flexDirection: "column" }, /* @__PURE__ */ React3.createElement(Text3, { bold: true }, "Environments (", config.environments.length, "):"), config.environments.map((e) => /* @__PURE__ */ React3.createElement(Text3, { key: e.name }, "  ", "- ", e.name))));
 }
 function checkCommand() {
   render3(/* @__PURE__ */ React3.createElement(CheckUI, null));
@@ -184872,8 +185360,8 @@ function checkCommand() {
 import React6, { useState as useState5, useEffect as useEffect3, useRef } from "react";
 import { render as render4, Text as Text6, Box as Box6, useApp as useApp2, Static } from "ink";
 import Spinner4 from "ink-spinner";
-import * as fs20 from "fs";
-import * as path17 from "path";
+import * as fs21 from "fs";
+import * as path18 from "path";
 
 // node_modules/.pnpm/chokidar@5.0.0/node_modules/chokidar/index.js
 import { EventEmitter } from "node:events";
@@ -184965,7 +185453,7 @@ var ReaddirpStream = class extends Readable {
     this._directoryFilter = normalizeFilter(opts.directoryFilter);
     const statMethod = opts.lstat ? lstat : stat;
     if (wantBigintFsStats) {
-      this._stat = (path24) => statMethod(path24, { bigint: true });
+      this._stat = (path26) => statMethod(path26, { bigint: true });
     } else {
       this._stat = statMethod;
     }
@@ -184990,8 +185478,8 @@ var ReaddirpStream = class extends Readable {
         const par = this.parent;
         const fil = par && par.files;
         if (fil && fil.length > 0) {
-          const { path: path24, depth } = par;
-          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path24));
+          const { path: path26, depth } = par;
+          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path26));
           const awaited = await Promise.all(slice);
           for (const entry of awaited) {
             if (!entry)
@@ -185031,21 +185519,21 @@ var ReaddirpStream = class extends Readable {
       this.reading = false;
     }
   }
-  async _exploreDir(path24, depth) {
+  async _exploreDir(path26, depth) {
     let files;
     try {
-      files = await readdir(path24, this._rdOptions);
+      files = await readdir(path26, this._rdOptions);
     } catch (error) {
       this._onError(error);
     }
-    return { files, depth, path: path24 };
+    return { files, depth, path: path26 };
   }
-  async _formatEntry(dirent, path24) {
+  async _formatEntry(dirent, path26) {
     let entry;
-    const basename5 = this._isDirent ? dirent.name : dirent;
+    const basename6 = this._isDirent ? dirent.name : dirent;
     try {
-      const fullPath = presolve(pjoin(path24, basename5));
-      entry = { path: prelative(this._root, fullPath), fullPath, basename: basename5 };
+      const fullPath = presolve(pjoin(path26, basename6));
+      entry = { path: prelative(this._root, fullPath), fullPath, basename: basename6 };
       entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
     } catch (err) {
       this._onError(err);
@@ -185444,16 +185932,16 @@ var delFromSet = (main, prop, item) => {
 };
 var isEmptySet = (val) => val instanceof Set ? val.size === 0 : !val;
 var FsWatchInstances = /* @__PURE__ */ new Map();
-function createFsWatchInstance(path24, options2, listener, errHandler, emitRaw) {
+function createFsWatchInstance(path26, options2, listener, errHandler, emitRaw) {
   const handleEvent = (rawEvent, evPath) => {
-    listener(path24);
-    emitRaw(rawEvent, evPath, { watchedPath: path24 });
-    if (evPath && path24 !== evPath) {
-      fsWatchBroadcast(sp.resolve(path24, evPath), KEY_LISTENERS, sp.join(path24, evPath));
+    listener(path26);
+    emitRaw(rawEvent, evPath, { watchedPath: path26 });
+    if (evPath && path26 !== evPath) {
+      fsWatchBroadcast(sp.resolve(path26, evPath), KEY_LISTENERS, sp.join(path26, evPath));
     }
   };
   try {
-    return fs_watch(path24, {
+    return fs_watch(path26, {
       persistent: options2.persistent
     }, handleEvent);
   } catch (error) {
@@ -185469,12 +185957,12 @@ var fsWatchBroadcast = (fullPath, listenerType, val1, val2, val3) => {
     listener(val1, val2, val3);
   });
 };
-var setFsWatchListener = (path24, fullPath, options2, handlers) => {
+var setFsWatchListener = (path26, fullPath, options2, handlers) => {
   const { listener, errHandler, rawEmitter } = handlers;
   let cont = FsWatchInstances.get(fullPath);
   let watcher;
   if (!options2.persistent) {
-    watcher = createFsWatchInstance(path24, options2, listener, errHandler, rawEmitter);
+    watcher = createFsWatchInstance(path26, options2, listener, errHandler, rawEmitter);
     if (!watcher)
       return;
     return watcher.close.bind(watcher);
@@ -185485,7 +185973,7 @@ var setFsWatchListener = (path24, fullPath, options2, handlers) => {
     addAndConvert(cont, KEY_RAW, rawEmitter);
   } else {
     watcher = createFsWatchInstance(
-      path24,
+      path26,
       options2,
       fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS),
       errHandler,
@@ -185500,7 +185988,7 @@ var setFsWatchListener = (path24, fullPath, options2, handlers) => {
         cont.watcherUnusable = true;
       if (isWindows && error.code === "EPERM") {
         try {
-          const fd = await open2(path24, "r");
+          const fd = await open2(path26, "r");
           await fd.close();
           broadcastErr(error);
         } catch (err) {
@@ -185531,7 +186019,7 @@ var setFsWatchListener = (path24, fullPath, options2, handlers) => {
   };
 };
 var FsWatchFileInstances = /* @__PURE__ */ new Map();
-var setFsWatchFileListener = (path24, fullPath, options2, handlers) => {
+var setFsWatchFileListener = (path26, fullPath, options2, handlers) => {
   const { listener, rawEmitter } = handlers;
   let cont = FsWatchFileInstances.get(fullPath);
   const copts = cont && cont.options;
@@ -185553,7 +186041,7 @@ var setFsWatchFileListener = (path24, fullPath, options2, handlers) => {
         });
         const currmtime = curr.mtimeMs;
         if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
-          foreach(cont.listeners, (listener2) => listener2(path24, curr));
+          foreach(cont.listeners, (listener2) => listener2(path26, curr));
         }
       })
     };
@@ -185583,13 +186071,13 @@ var NodeFsHandler = class {
    * @param listener on fs change
    * @returns closer for the watcher instance
    */
-  _watchWithNodeFs(path24, listener) {
+  _watchWithNodeFs(path26, listener) {
     const opts = this.fsw.options;
-    const directory = sp.dirname(path24);
-    const basename5 = sp.basename(path24);
+    const directory = sp.dirname(path26);
+    const basename6 = sp.basename(path26);
     const parent = this.fsw._getWatchedDir(directory);
-    parent.add(basename5);
-    const absolutePath = sp.resolve(path24);
+    parent.add(basename6);
+    const absolutePath = sp.resolve(path26);
     const options2 = {
       persistent: opts.persistent
     };
@@ -185598,13 +186086,13 @@ var NodeFsHandler = class {
     let closer;
     if (opts.usePolling) {
       const enableBin = opts.interval !== opts.binaryInterval;
-      options2.interval = enableBin && isBinaryPath(basename5) ? opts.binaryInterval : opts.interval;
-      closer = setFsWatchFileListener(path24, absolutePath, options2, {
+      options2.interval = enableBin && isBinaryPath(basename6) ? opts.binaryInterval : opts.interval;
+      closer = setFsWatchFileListener(path26, absolutePath, options2, {
         listener,
         rawEmitter: this.fsw._emitRaw
       });
     } else {
-      closer = setFsWatchListener(path24, absolutePath, options2, {
+      closer = setFsWatchListener(path26, absolutePath, options2, {
         listener,
         errHandler: this._boundHandleError,
         rawEmitter: this.fsw._emitRaw
@@ -185621,12 +186109,12 @@ var NodeFsHandler = class {
       return;
     }
     const dirname8 = sp.dirname(file);
-    const basename5 = sp.basename(file);
+    const basename6 = sp.basename(file);
     const parent = this.fsw._getWatchedDir(dirname8);
     let prevStats = stats;
-    if (parent.has(basename5))
+    if (parent.has(basename6))
       return;
-    const listener = async (path24, newStats) => {
+    const listener = async (path26, newStats) => {
       if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5))
         return;
       if (!newStats || newStats.mtimeMs === 0) {
@@ -185640,18 +186128,18 @@ var NodeFsHandler = class {
             this.fsw._emit(EV.CHANGE, file, newStats2);
           }
           if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats2.ino) {
-            this.fsw._closeFile(path24);
+            this.fsw._closeFile(path26);
             prevStats = newStats2;
             const closer2 = this._watchWithNodeFs(file, listener);
             if (closer2)
-              this.fsw._addPathCloser(path24, closer2);
+              this.fsw._addPathCloser(path26, closer2);
           } else {
             prevStats = newStats2;
           }
         } catch (error) {
-          this.fsw._remove(dirname8, basename5);
+          this.fsw._remove(dirname8, basename6);
         }
-      } else if (parent.has(basename5)) {
+      } else if (parent.has(basename6)) {
         const at = newStats.atimeMs;
         const mt = newStats.mtimeMs;
         if (!at || at <= mt || mt !== prevStats.mtimeMs) {
@@ -185676,7 +186164,7 @@ var NodeFsHandler = class {
    * @param item basename of this item
    * @returns true if no more processing is needed for this entry.
    */
-  async _handleSymlink(entry, directory, path24, item) {
+  async _handleSymlink(entry, directory, path26, item) {
     if (this.fsw.closed) {
       return;
     }
@@ -185686,7 +186174,7 @@ var NodeFsHandler = class {
       this.fsw._incrReadyCount();
       let linkPath;
       try {
-        linkPath = await fsrealpath(path24);
+        linkPath = await fsrealpath(path26);
       } catch (e) {
         this.fsw._emitReady();
         return true;
@@ -185696,12 +186184,12 @@ var NodeFsHandler = class {
       if (dir.has(item)) {
         if (this.fsw._symlinkPaths.get(full) !== linkPath) {
           this.fsw._symlinkPaths.set(full, linkPath);
-          this.fsw._emit(EV.CHANGE, path24, entry.stats);
+          this.fsw._emit(EV.CHANGE, path26, entry.stats);
         }
       } else {
         dir.add(item);
         this.fsw._symlinkPaths.set(full, linkPath);
-        this.fsw._emit(EV.ADD, path24, entry.stats);
+        this.fsw._emit(EV.ADD, path26, entry.stats);
       }
       this.fsw._emitReady();
       return true;
@@ -185731,9 +186219,9 @@ var NodeFsHandler = class {
         return;
       }
       const item = entry.path;
-      let path24 = sp.join(directory, item);
+      let path26 = sp.join(directory, item);
       current.add(item);
-      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path24, item)) {
+      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path26, item)) {
         return;
       }
       if (this.fsw.closed) {
@@ -185742,11 +186230,11 @@ var NodeFsHandler = class {
       }
       if (item === target || !target && !previous.has(item)) {
         this.fsw._incrReadyCount();
-        path24 = sp.join(dir, sp.relative(dir, path24));
-        this._addToNodeFs(path24, initialAdd, wh, depth + 1);
+        path26 = sp.join(dir, sp.relative(dir, path26));
+        this._addToNodeFs(path26, initialAdd, wh, depth + 1);
       }
     }).on(EV.ERROR, this._boundHandleError);
-    return new Promise((resolve7, reject) => {
+    return new Promise((resolve10, reject) => {
       if (!stream)
         return reject();
       stream.once(STR_END, () => {
@@ -185755,7 +186243,7 @@ var NodeFsHandler = class {
           return;
         }
         const wasThrottled = throttler ? throttler.clear() : false;
-        resolve7(void 0);
+        resolve10(void 0);
         previous.getChildren().filter((item) => {
           return item !== directory && !current.has(item);
         }).forEach((item) => {
@@ -185812,13 +186300,13 @@ var NodeFsHandler = class {
    * @param depth Child path actually targeted for watch
    * @param target Child path actually targeted for watch
    */
-  async _addToNodeFs(path24, initialAdd, priorWh, depth, target) {
+  async _addToNodeFs(path26, initialAdd, priorWh, depth, target) {
     const ready = this.fsw._emitReady;
-    if (this.fsw._isIgnored(path24) || this.fsw.closed) {
+    if (this.fsw._isIgnored(path26) || this.fsw.closed) {
       ready();
       return false;
     }
-    const wh = this.fsw._getWatchHelpers(path24);
+    const wh = this.fsw._getWatchHelpers(path26);
     if (priorWh) {
       wh.filterPath = (entry) => priorWh.filterPath(entry);
       wh.filterDir = (entry) => priorWh.filterDir(entry);
@@ -185834,8 +186322,8 @@ var NodeFsHandler = class {
       const follow = this.fsw.options.followSymlinks;
       let closer;
       if (stats.isDirectory()) {
-        const absPath = sp.resolve(path24);
-        const targetPath = follow ? await fsrealpath(path24) : path24;
+        const absPath = sp.resolve(path26);
+        const targetPath = follow ? await fsrealpath(path26) : path26;
         if (this.fsw.closed)
           return;
         closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
@@ -185845,29 +186333,29 @@ var NodeFsHandler = class {
           this.fsw._symlinkPaths.set(absPath, targetPath);
         }
       } else if (stats.isSymbolicLink()) {
-        const targetPath = follow ? await fsrealpath(path24) : path24;
+        const targetPath = follow ? await fsrealpath(path26) : path26;
         if (this.fsw.closed)
           return;
         const parent = sp.dirname(wh.watchPath);
         this.fsw._getWatchedDir(parent).add(wh.watchPath);
         this.fsw._emit(EV.ADD, wh.watchPath, stats);
-        closer = await this._handleDir(parent, stats, initialAdd, depth, path24, wh, targetPath);
+        closer = await this._handleDir(parent, stats, initialAdd, depth, path26, wh, targetPath);
         if (this.fsw.closed)
           return;
         if (targetPath !== void 0) {
-          this.fsw._symlinkPaths.set(sp.resolve(path24), targetPath);
+          this.fsw._symlinkPaths.set(sp.resolve(path26), targetPath);
         }
       } else {
         closer = this._handleFile(wh.watchPath, stats, initialAdd);
       }
       ready();
       if (closer)
-        this.fsw._addPathCloser(path24, closer);
+        this.fsw._addPathCloser(path26, closer);
       return false;
     } catch (error) {
       if (this.fsw._handleError(error)) {
         ready();
-        return path24;
+        return path26;
       }
     }
   }
@@ -185910,24 +186398,24 @@ function createPattern(matcher) {
   }
   return () => false;
 }
-function normalizePath(path24) {
-  if (typeof path24 !== "string")
+function normalizePath(path26) {
+  if (typeof path26 !== "string")
     throw new Error("string expected");
-  path24 = sp2.normalize(path24);
-  path24 = path24.replace(/\\/g, "/");
+  path26 = sp2.normalize(path26);
+  path26 = path26.replace(/\\/g, "/");
   let prepend = false;
-  if (path24.startsWith("//"))
+  if (path26.startsWith("//"))
     prepend = true;
-  path24 = path24.replace(DOUBLE_SLASH_RE, "/");
+  path26 = path26.replace(DOUBLE_SLASH_RE, "/");
   if (prepend)
-    path24 = "/" + path24;
-  return path24;
+    path26 = "/" + path26;
+  return path26;
 }
 function matchPatterns(patterns, testString, stats) {
-  const path24 = normalizePath(testString);
+  const path26 = normalizePath(testString);
   for (let index = 0; index < patterns.length; index++) {
     const pattern = patterns[index];
-    if (pattern(path24, stats)) {
+    if (pattern(path26, stats)) {
       return true;
     }
   }
@@ -185965,19 +186453,19 @@ var toUnix = (string) => {
   }
   return str;
 };
-var normalizePathToUnix = (path24) => toUnix(sp2.normalize(toUnix(path24)));
-var normalizeIgnored = (cwd = "") => (path24) => {
-  if (typeof path24 === "string") {
-    return normalizePathToUnix(sp2.isAbsolute(path24) ? path24 : sp2.join(cwd, path24));
+var normalizePathToUnix = (path26) => toUnix(sp2.normalize(toUnix(path26)));
+var normalizeIgnored = (cwd = "") => (path26) => {
+  if (typeof path26 === "string") {
+    return normalizePathToUnix(sp2.isAbsolute(path26) ? path26 : sp2.join(cwd, path26));
   } else {
-    return path24;
+    return path26;
   }
 };
-var getAbsolutePath = (path24, cwd) => {
-  if (sp2.isAbsolute(path24)) {
-    return path24;
+var getAbsolutePath = (path26, cwd) => {
+  if (sp2.isAbsolute(path26)) {
+    return path26;
   }
-  return sp2.join(cwd, path24);
+  return sp2.join(cwd, path26);
 };
 var EMPTY_SET = Object.freeze(/* @__PURE__ */ new Set());
 var DirEntry = class {
@@ -186042,10 +186530,10 @@ var WatchHelper = class {
   dirParts;
   followSymlinks;
   statMethod;
-  constructor(path24, follow, fsw) {
+  constructor(path26, follow, fsw) {
     this.fsw = fsw;
-    const watchPath = path24;
-    this.path = path24 = path24.replace(REPLACER_RE, "");
+    const watchPath = path26;
+    this.path = path26 = path26.replace(REPLACER_RE, "");
     this.watchPath = watchPath;
     this.fullWatchPath = sp2.resolve(watchPath);
     this.dirParts = [];
@@ -186185,20 +186673,20 @@ var FSWatcher = class extends EventEmitter {
     this._closePromise = void 0;
     let paths = unifyPaths(paths_);
     if (cwd) {
-      paths = paths.map((path24) => {
-        const absPath = getAbsolutePath(path24, cwd);
+      paths = paths.map((path26) => {
+        const absPath = getAbsolutePath(path26, cwd);
         return absPath;
       });
     }
-    paths.forEach((path24) => {
-      this._removeIgnoredPath(path24);
+    paths.forEach((path26) => {
+      this._removeIgnoredPath(path26);
     });
     this._userIgnored = void 0;
     if (!this._readyCount)
       this._readyCount = 0;
     this._readyCount += paths.length;
-    Promise.all(paths.map(async (path24) => {
-      const res = await this._nodeFsHandler._addToNodeFs(path24, !_internal, void 0, 0, _origAdd);
+    Promise.all(paths.map(async (path26) => {
+      const res = await this._nodeFsHandler._addToNodeFs(path26, !_internal, void 0, 0, _origAdd);
       if (res)
         this._emitReady();
       return res;
@@ -186220,17 +186708,17 @@ var FSWatcher = class extends EventEmitter {
       return this;
     const paths = unifyPaths(paths_);
     const { cwd } = this.options;
-    paths.forEach((path24) => {
-      if (!sp2.isAbsolute(path24) && !this._closers.has(path24)) {
+    paths.forEach((path26) => {
+      if (!sp2.isAbsolute(path26) && !this._closers.has(path26)) {
         if (cwd)
-          path24 = sp2.join(cwd, path24);
-        path24 = sp2.resolve(path24);
+          path26 = sp2.join(cwd, path26);
+        path26 = sp2.resolve(path26);
       }
-      this._closePath(path24);
-      this._addIgnoredPath(path24);
-      if (this._watched.has(path24)) {
+      this._closePath(path26);
+      this._addIgnoredPath(path26);
+      if (this._watched.has(path26)) {
         this._addIgnoredPath({
-          path: path24,
+          path: path26,
           recursive: true
         });
       }
@@ -186294,38 +186782,38 @@ var FSWatcher = class extends EventEmitter {
    * @param stats arguments to be passed with event
    * @returns the error if defined, otherwise the value of the FSWatcher instance's `closed` flag
    */
-  async _emit(event, path24, stats) {
+  async _emit(event, path26, stats) {
     if (this.closed)
       return;
     const opts = this.options;
     if (isWindows)
-      path24 = sp2.normalize(path24);
+      path26 = sp2.normalize(path26);
     if (opts.cwd)
-      path24 = sp2.relative(opts.cwd, path24);
-    const args = [path24];
+      path26 = sp2.relative(opts.cwd, path26);
+    const args = [path26];
     if (stats != null)
       args.push(stats);
     const awf = opts.awaitWriteFinish;
     let pw;
-    if (awf && (pw = this._pendingWrites.get(path24))) {
+    if (awf && (pw = this._pendingWrites.get(path26))) {
       pw.lastChange = /* @__PURE__ */ new Date();
       return this;
     }
     if (opts.atomic) {
       if (event === EVENTS.UNLINK) {
-        this._pendingUnlinks.set(path24, [event, ...args]);
+        this._pendingUnlinks.set(path26, [event, ...args]);
         setTimeout(() => {
-          this._pendingUnlinks.forEach((entry, path25) => {
+          this._pendingUnlinks.forEach((entry, path27) => {
             this.emit(...entry);
             this.emit(EVENTS.ALL, ...entry);
-            this._pendingUnlinks.delete(path25);
+            this._pendingUnlinks.delete(path27);
           });
         }, typeof opts.atomic === "number" ? opts.atomic : 100);
         return this;
       }
-      if (event === EVENTS.ADD && this._pendingUnlinks.has(path24)) {
+      if (event === EVENTS.ADD && this._pendingUnlinks.has(path26)) {
         event = EVENTS.CHANGE;
-        this._pendingUnlinks.delete(path24);
+        this._pendingUnlinks.delete(path26);
       }
     }
     if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
@@ -186343,16 +186831,16 @@ var FSWatcher = class extends EventEmitter {
           this.emitWithAll(event, args);
         }
       };
-      this._awaitWriteFinish(path24, awf.stabilityThreshold, event, awfEmit);
+      this._awaitWriteFinish(path26, awf.stabilityThreshold, event, awfEmit);
       return this;
     }
     if (event === EVENTS.CHANGE) {
-      const isThrottled = !this._throttle(EVENTS.CHANGE, path24, 50);
+      const isThrottled = !this._throttle(EVENTS.CHANGE, path26, 50);
       if (isThrottled)
         return this;
     }
     if (opts.alwaysStat && stats === void 0 && (event === EVENTS.ADD || event === EVENTS.ADD_DIR || event === EVENTS.CHANGE)) {
-      const fullPath = opts.cwd ? sp2.join(opts.cwd, path24) : path24;
+      const fullPath = opts.cwd ? sp2.join(opts.cwd, path26) : path26;
       let stats2;
       try {
         stats2 = await stat3(fullPath);
@@ -186383,23 +186871,23 @@ var FSWatcher = class extends EventEmitter {
    * @param timeout duration of time to suppress duplicate actions
    * @returns tracking object or false if action should be suppressed
    */
-  _throttle(actionType, path24, timeout) {
+  _throttle(actionType, path26, timeout) {
     if (!this._throttled.has(actionType)) {
       this._throttled.set(actionType, /* @__PURE__ */ new Map());
     }
     const action = this._throttled.get(actionType);
     if (!action)
       throw new Error("invalid throttle");
-    const actionPath = action.get(path24);
+    const actionPath = action.get(path26);
     if (actionPath) {
       actionPath.count++;
       return false;
     }
     let timeoutObject;
     const clear = () => {
-      const item = action.get(path24);
+      const item = action.get(path26);
       const count = item ? item.count : 0;
-      action.delete(path24);
+      action.delete(path26);
       clearTimeout(timeoutObject);
       if (item)
         clearTimeout(item.timeoutObject);
@@ -186407,7 +186895,7 @@ var FSWatcher = class extends EventEmitter {
     };
     timeoutObject = setTimeout(clear, timeout);
     const thr = { timeoutObject, clear, count: 0 };
-    action.set(path24, thr);
+    action.set(path26, thr);
     return thr;
   }
   _incrReadyCount() {
@@ -186421,44 +186909,44 @@ var FSWatcher = class extends EventEmitter {
    * @param event
    * @param awfEmit Callback to be called when ready for event to be emitted.
    */
-  _awaitWriteFinish(path24, threshold, event, awfEmit) {
+  _awaitWriteFinish(path26, threshold, event, awfEmit) {
     const awf = this.options.awaitWriteFinish;
     if (typeof awf !== "object")
       return;
     const pollInterval = awf.pollInterval;
     let timeoutHandler;
-    let fullPath = path24;
-    if (this.options.cwd && !sp2.isAbsolute(path24)) {
-      fullPath = sp2.join(this.options.cwd, path24);
+    let fullPath = path26;
+    if (this.options.cwd && !sp2.isAbsolute(path26)) {
+      fullPath = sp2.join(this.options.cwd, path26);
     }
     const now = /* @__PURE__ */ new Date();
     const writes = this._pendingWrites;
     function awaitWriteFinishFn(prevStat) {
       statcb(fullPath, (err, curStat) => {
-        if (err || !writes.has(path24)) {
+        if (err || !writes.has(path26)) {
           if (err && err.code !== "ENOENT")
             awfEmit(err);
           return;
         }
         const now2 = Number(/* @__PURE__ */ new Date());
         if (prevStat && curStat.size !== prevStat.size) {
-          writes.get(path24).lastChange = now2;
+          writes.get(path26).lastChange = now2;
         }
-        const pw = writes.get(path24);
+        const pw = writes.get(path26);
         const df = now2 - pw.lastChange;
         if (df >= threshold) {
-          writes.delete(path24);
+          writes.delete(path26);
           awfEmit(void 0, curStat);
         } else {
           timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
         }
       });
     }
-    if (!writes.has(path24)) {
-      writes.set(path24, {
+    if (!writes.has(path26)) {
+      writes.set(path26, {
         lastChange: now,
         cancelWait: () => {
-          writes.delete(path24);
+          writes.delete(path26);
           clearTimeout(timeoutHandler);
           return event;
         }
@@ -186469,8 +186957,8 @@ var FSWatcher = class extends EventEmitter {
   /**
    * Determines whether user has asked to ignore this path.
    */
-  _isIgnored(path24, stats) {
-    if (this.options.atomic && DOT_RE.test(path24))
+  _isIgnored(path26, stats) {
+    if (this.options.atomic && DOT_RE.test(path26))
       return true;
     if (!this._userIgnored) {
       const { cwd } = this.options;
@@ -186480,17 +186968,17 @@ var FSWatcher = class extends EventEmitter {
       const list = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored];
       this._userIgnored = anymatch(list, void 0);
     }
-    return this._userIgnored(path24, stats);
+    return this._userIgnored(path26, stats);
   }
-  _isntIgnored(path24, stat4) {
-    return !this._isIgnored(path24, stat4);
+  _isntIgnored(path26, stat4) {
+    return !this._isIgnored(path26, stat4);
   }
   /**
    * Provides a set of common helpers and properties relating to symlink handling.
    * @param path file or directory pattern being watched
    */
-  _getWatchHelpers(path24) {
-    return new WatchHelper(path24, this.options.followSymlinks, this);
+  _getWatchHelpers(path26) {
+    return new WatchHelper(path26, this.options.followSymlinks, this);
   }
   // Directory helpers
   // -----------------
@@ -186522,63 +187010,63 @@ var FSWatcher = class extends EventEmitter {
    * @param item      base path of item/directory
    */
   _remove(directory, item, isDirectory) {
-    const path24 = sp2.join(directory, item);
-    const fullPath = sp2.resolve(path24);
-    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path24) || this._watched.has(fullPath);
-    if (!this._throttle("remove", path24, 100))
+    const path26 = sp2.join(directory, item);
+    const fullPath = sp2.resolve(path26);
+    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path26) || this._watched.has(fullPath);
+    if (!this._throttle("remove", path26, 100))
       return;
     if (!isDirectory && this._watched.size === 1) {
       this.add(directory, item, true);
     }
-    const wp = this._getWatchedDir(path24);
+    const wp = this._getWatchedDir(path26);
     const nestedDirectoryChildren = wp.getChildren();
-    nestedDirectoryChildren.forEach((nested) => this._remove(path24, nested));
+    nestedDirectoryChildren.forEach((nested) => this._remove(path26, nested));
     const parent = this._getWatchedDir(directory);
     const wasTracked = parent.has(item);
     parent.remove(item);
     if (this._symlinkPaths.has(fullPath)) {
       this._symlinkPaths.delete(fullPath);
     }
-    let relPath = path24;
+    let relPath = path26;
     if (this.options.cwd)
-      relPath = sp2.relative(this.options.cwd, path24);
+      relPath = sp2.relative(this.options.cwd, path26);
     if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
       const event = this._pendingWrites.get(relPath).cancelWait();
       if (event === EVENTS.ADD)
         return;
     }
-    this._watched.delete(path24);
+    this._watched.delete(path26);
     this._watched.delete(fullPath);
     const eventName = isDirectory ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
-    if (wasTracked && !this._isIgnored(path24))
-      this._emit(eventName, path24);
-    this._closePath(path24);
+    if (wasTracked && !this._isIgnored(path26))
+      this._emit(eventName, path26);
+    this._closePath(path26);
   }
   /**
    * Closes all watchers for a path
    */
-  _closePath(path24) {
-    this._closeFile(path24);
-    const dir = sp2.dirname(path24);
-    this._getWatchedDir(dir).remove(sp2.basename(path24));
+  _closePath(path26) {
+    this._closeFile(path26);
+    const dir = sp2.dirname(path26);
+    this._getWatchedDir(dir).remove(sp2.basename(path26));
   }
   /**
    * Closes only file-specific watchers
    */
-  _closeFile(path24) {
-    const closers = this._closers.get(path24);
+  _closeFile(path26) {
+    const closers = this._closers.get(path26);
     if (!closers)
       return;
     closers.forEach((closer) => closer());
-    this._closers.delete(path24);
+    this._closers.delete(path26);
   }
-  _addPathCloser(path24, closer) {
+  _addPathCloser(path26, closer) {
     if (!closer)
       return;
-    let list = this._closers.get(path24);
+    let list = this._closers.get(path26);
     if (!list) {
       list = [];
-      this._closers.set(path24, list);
+      this._closers.set(path26, list);
     }
     list.push(closer);
   }
@@ -186627,8 +187115,8 @@ var PortAllocator = class {
 };
 
 // src/lib/dev/stable-port-allocator.ts
-import * as fs12 from "fs";
-import * as path8 from "path";
+import * as fs13 from "fs";
+import * as path9 from "path";
 var PORT_RANGE_START2 = 4e4;
 var PORT_RANGE_END2 = 49999;
 var StablePortAllocator = class {
@@ -186637,16 +187125,16 @@ var StablePortAllocator = class {
   savedPorts = {};
   usedPorts = /* @__PURE__ */ new Set();
   constructor(projectRoot, key = "default") {
-    this.portsDir = path8.join(projectRoot, ".specific", "keys", key);
-    this.portsFilePath = path8.join(this.portsDir, "ports.json");
+    this.portsDir = path9.join(projectRoot, ".specific", "keys", key);
+    this.portsFilePath = path9.join(this.portsDir, "ports.json");
     this.loadPorts();
   }
   loadPorts() {
-    if (!fs12.existsSync(this.portsFilePath)) {
+    if (!fs13.existsSync(this.portsFilePath)) {
       return;
     }
     try {
-      const content = fs12.readFileSync(this.portsFilePath, "utf-8");
+      const content = fs13.readFileSync(this.portsFilePath, "utf-8");
       const data = JSON.parse(content);
       if (data.version === 1 && data.ports) {
         this.savedPorts = data.ports;
@@ -186659,14 +187147,14 @@ var StablePortAllocator = class {
     }
   }
   savePorts() {
-    if (!fs12.existsSync(this.portsDir)) {
-      fs12.mkdirSync(this.portsDir, { recursive: true });
+    if (!fs13.existsSync(this.portsDir)) {
+      fs13.mkdirSync(this.portsDir, { recursive: true });
     }
     const data = {
       version: 1,
       ports: this.savedPorts
     };
-    fs12.writeFileSync(this.portsFilePath, JSON.stringify(data, null, 2));
+    fs13.writeFileSync(this.portsFilePath, JSON.stringify(data, null, 2));
   }
   allocateRandom() {
     const rangeSize = PORT_RANGE_END2 - PORT_RANGE_START2 + 1;
@@ -186697,329 +187185,6 @@ import * as fs14 from "fs";
 import * as path10 from "path";
 import * as net from "net";
 import { spawn } from "child_process";
-
-// src/lib/bin/types.ts
-var BinaryNotFoundError = class extends Error {
-  constructor(binaryName, version, platformInfo) {
-    super(
-      `Binary "${binaryName}" version ${version} is not available for ${platformInfo.platform}-${platformInfo.arch}`
-    );
-    this.binaryName = binaryName;
-    this.version = version;
-    this.platformInfo = platformInfo;
-    this.name = "BinaryNotFoundError";
-  }
-};
-var DownloadError = class extends Error {
-  constructor(url, statusCode, cause) {
-    super(
-      statusCode ? `Failed to download ${url}: HTTP ${statusCode}` : `Failed to download ${url}: ${cause?.message || "Unknown error"}`
-    );
-    this.url = url;
-    this.statusCode = statusCode;
-    this.cause = cause;
-    this.name = "DownloadError";
-  }
-};
-var ExtractionError = class extends Error {
-  constructor(archivePath, cause) {
-    super(
-      `Failed to extract ${archivePath}: ${cause?.message || "Unknown error"}`
-    );
-    this.archivePath = archivePath;
-    this.cause = cause;
-    this.name = "ExtractionError";
-  }
-};
-
-// src/lib/bin/manager.ts
-import * as fs13 from "fs";
-import * as path9 from "path";
-import * as os6 from "os";
-import { createReadStream } from "fs";
-import { createTarExtractor, extractTo } from "tar-vern";
-function getLibraryEnv(binary) {
-  if (!binary.libraryPath) {
-    return {};
-  }
-  const platform4 = os6.platform();
-  if (platform4 === "darwin") {
-    return { DYLD_LIBRARY_PATH: binary.libraryPath };
-  } else if (platform4 === "linux") {
-    return { LD_LIBRARY_PATH: binary.libraryPath };
-  }
-  return {};
-}
-function getBinBaseDir() {
-  return path9.join(os6.homedir(), ".specific", "bin");
-}
-function getPlatformInfo() {
-  const platform4 = os6.platform();
-  const arch3 = os6.arch();
-  if (platform4 !== "darwin" && platform4 !== "linux") {
-    throw new Error(
-      `Unsupported platform: ${platform4}. Only macOS and Linux are supported.`
-    );
-  }
-  const archStr = arch3;
-  let mappedArch;
-  if (archStr === "x64" || archStr === "x86_64") {
-    mappedArch = "x64";
-  } else if (archStr === "arm64" || archStr === "aarch64") {
-    mappedArch = "arm64";
-  } else {
-    throw new Error(
-      `Unsupported architecture: ${arch3}. Only x64 and arm64 are supported.`
-    );
-  }
-  return { platform: platform4, arch: mappedArch };
-}
-function getBinaryDir(definition, version, platformInfo) {
-  return path9.join(
-    getBinBaseDir(),
-    definition.name,
-    version,
-    `${platformInfo.platform}-${platformInfo.arch}`
-  );
-}
-function isBinaryInstalled(definition, version, platformInfo) {
-  const binDir = getBinaryDir(definition, version, platformInfo);
-  for (const execPath of definition.executables) {
-    const fullPath = path9.join(binDir, execPath);
-    if (!fs13.existsSync(fullPath)) {
-      return false;
-    }
-  }
-  return true;
-}
-function buildDownloadUrl(definition, version, platformInfo) {
-  const mapping = definition.platformMapping[platformInfo.platform]?.[platformInfo.arch];
-  if (!mapping) {
-    throw new BinaryNotFoundError(definition.name, version, platformInfo);
-  }
-  return definition.urlTemplate.replace(/{version}/g, version).replace(/{platform}/g, mapping.platform).replace(/{arch}/g, mapping.arch);
-}
-async function downloadFile(url, destPath, onProgress) {
-  let response;
-  try {
-    response = await fetch(url);
-  } catch (error) {
-    throw new DownloadError(url, void 0, error);
-  }
-  if (!response.ok) {
-    throw new DownloadError(url, response.status);
-  }
-  const totalBytes = parseInt(
-    response.headers.get("content-length") || "0",
-    10
-  );
-  let bytesDownloaded = 0;
-  const parentDir = path9.dirname(destPath);
-  if (!fs13.existsSync(parentDir)) {
-    fs13.mkdirSync(parentDir, { recursive: true });
-  }
-  const partPath = destPath + ".part";
-  const fileStream = fs13.createWriteStream(partPath);
-  try {
-    const reader = response.body.getReader();
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) break;
-      bytesDownloaded += value.length;
-      fileStream.write(Buffer.from(value));
-      if (onProgress) {
-        onProgress({
-          phase: "downloading",
-          bytesDownloaded,
-          totalBytes: totalBytes || void 0,
-          percent: totalBytes ? Math.round(bytesDownloaded / totalBytes * 100) : void 0
-        });
-      }
-    }
-    await new Promise((resolve7, reject) => {
-      fileStream.end((err) => {
-        if (err) reject(err);
-        else resolve7();
-      });
-    });
-    fs13.renameSync(partPath, destPath);
-  } catch (error) {
-    try {
-      fileStream.close();
-      if (fs13.existsSync(partPath)) {
-        fs13.unlinkSync(partPath);
-      }
-    } catch {
-    }
-    throw new DownloadError(url, void 0, error);
-  }
-}
-async function extractTarball(archivePath, destDir, definition, onProgress) {
-  onProgress?.({ phase: "extracting" });
-  if (!fs13.existsSync(destDir)) {
-    fs13.mkdirSync(destDir, { recursive: true });
-  }
-  try {
-    const fileStream = createReadStream(archivePath);
-    const entries = createTarExtractor(fileStream, "gzip");
-    await extractTo(entries, destDir);
-    onProgress?.({ phase: "finalizing" });
-    for (const execPath of definition.executables) {
-      const fullPath = path9.join(destDir, execPath);
-      if (fs13.existsSync(fullPath)) {
-        fs13.chmodSync(fullPath, 493);
-      }
-    }
-  } catch (error) {
-    throw new ExtractionError(archivePath, error);
-  }
-}
-async function ensureBinary(definition, version, onProgress) {
-  const platformInfo = getPlatformInfo();
-  const resolvedVersion = version || definition.versions[0];
-  if (!definition.versions.includes(resolvedVersion)) {
-    throw new Error(
-      `Version ${resolvedVersion} not supported for ${definition.name}. Supported versions: ${definition.versions.join(", ")}`
-    );
-  }
-  const binDir = getBinaryDir(definition, resolvedVersion, platformInfo);
-  if (!isBinaryInstalled(definition, resolvedVersion, platformInfo)) {
-    const url = buildDownloadUrl(definition, resolvedVersion, platformInfo);
-    if (definition.type === "binary") {
-      if (definition.executables.length !== 1) {
-        throw new Error(
-          `Binary type definitions must have exactly one executable, got ${definition.executables.length}`
-        );
-      }
-      if (!fs13.existsSync(binDir)) {
-        fs13.mkdirSync(binDir, { recursive: true });
-      }
-      const execPath = path9.join(binDir, definition.executables[0]);
-      await downloadFile(url, execPath, onProgress);
-      fs13.chmodSync(execPath, 493);
-      onProgress?.({ phase: "finalizing" });
-    } else {
-      const downloadDir = path9.join(getBinBaseDir(), "downloads");
-      const archiveName = `${definition.name}-${resolvedVersion}-${platformInfo.platform}-${platformInfo.arch}.tar.gz`;
-      const archivePath = path9.join(downloadDir, archiveName);
-      try {
-        await downloadFile(url, archivePath, onProgress);
-        await extractTarball(archivePath, binDir, definition, onProgress);
-      } finally {
-        try {
-          if (fs13.existsSync(archivePath)) {
-            fs13.unlinkSync(archivePath);
-          }
-        } catch {
-        }
-      }
-    }
-  }
-  const executables = {};
-  for (const execPath of definition.executables) {
-    const name = path9.basename(execPath);
-    executables[name] = path9.join(binDir, execPath);
-  }
-  const libraryPath = definition.libraryDir ? path9.join(binDir, definition.libraryDir) : void 0;
-  return {
-    rootDir: binDir,
-    version: resolvedVersion,
-    executables,
-    libraryPath
-  };
-}
-
-// src/lib/bin/definitions/postgres.ts
-var postgresBinary = {
-  name: "postgres",
-  versions: ["18.1"],
-  // URL: binaries.specific.dev/{SOFTWARE}/{VERSION}/{ARCH}.tar.gz
-  urlTemplate: "https://binaries.specific.dev/postgres/{version}/{arch}.tar.gz",
-  platformMapping: {
-    darwin: {
-      arm64: { platform: "macos", arch: "macos_arm" },
-      x64: { platform: "macos", arch: "macos_x86" }
-    },
-    linux: {
-      arm64: { platform: "linux", arch: "linux_arm" },
-      x64: { platform: "linux", arch: "linux_x86" }
-    }
-  },
-  // Archive contains bin/ and lib/ directories at root
-  stripComponents: 0,
-  // Core PostgreSQL executables (in bin/ directory)
-  executables: ["bin/postgres", "bin/initdb", "bin/psql"],
-  // Library directory relative to root (for setting LD_LIBRARY_PATH)
-  libraryDir: "lib"
-};
-
-// src/lib/bin/definitions/redis.ts
-var redisBinary = {
-  name: "redis",
-  versions: ["8.4.0"],
-  // URL: binaries.specific.dev/{SOFTWARE}/{VERSION}/{ARCH}.tar.gz
-  urlTemplate: "https://binaries.specific.dev/redis/{version}/{arch}.tar.gz",
-  platformMapping: {
-    darwin: {
-      arm64: { platform: "macos", arch: "macos_arm" },
-      x64: { platform: "macos", arch: "macos_x86" }
-    },
-    linux: {
-      arm64: { platform: "linux", arch: "linux_arm" },
-      x64: { platform: "linux", arch: "linux_x86" }
-    }
-  },
-  // Binaries are at the root of the archive
-  stripComponents: 0,
-  // Core Redis executable
-  executables: ["redis-server"]
-};
-
-// src/lib/bin/definitions/electric.ts
-var electricBinary = {
-  name: "electric",
-  versions: ["1.2.11"],
-  // URL: binaries.specific.dev/{SOFTWARE}/{VERSION}/{ARCH}.tar.gz
-  urlTemplate: "https://binaries.specific.dev/electric/{version}/{arch}.tar.gz",
-  platformMapping: {
-    darwin: {
-      arm64: { platform: "macos", arch: "macos_arm" },
-      x64: { platform: "macos", arch: "macos_x86" }
-    },
-    linux: {
-      arm64: { platform: "linux", arch: "linux_arm" },
-      x64: { platform: "linux", arch: "linux_x86" }
-    }
-  },
-  // Binaries are at the root of the archive
-  stripComponents: 0,
-  // Core Electric executable
-  executables: ["electric"]
-};
-
-// src/lib/bin/definitions/drizzle-gateway.ts
-var drizzleGatewayBinary = {
-  name: "drizzle-gateway",
-  versions: ["1.2.0"],
-  // Official Drizzle Gateway download URL from R2
-  urlTemplate: "https://pub-e240a4fd7085425baf4a7951e7611520.r2.dev/drizzle-gateway-{version}-{arch}",
-  platformMapping: {
-    darwin: {
-      arm64: { platform: "macos", arch: "macos-arm64" },
-      x64: { platform: "macos", arch: "macos-x64" }
-    },
-    linux: {
-      arm64: { platform: "linux", arch: "linux-arm64" },
-      x64: { platform: "linux", arch: "linux-x64" }
-    }
-  },
-  // Raw binary, not a tarball
-  type: "binary",
-  // The executable name
-  executables: ["drizzle-gateway"]
-};
-
-// src/lib/dev/database-manager.ts
 async function startPostgres(pg, port, dataDir, onProgress) {
   const binary = await ensureBinary(postgresBinary, void 0, onProgress);
   const dbDataPath = path10.join(process.cwd(), dataDir, pg.name);
@@ -187142,7 +187307,7 @@ async function startStorage(storage, port, dataDir) {
   };
 }
 async function runCommand(command, args, env2) {
-  return new Promise((resolve7, reject) => {
+  return new Promise((resolve10, reject) => {
     const proc = spawn(command, args, {
       stdio: ["ignore", "pipe", "pipe"],
       env: env2
@@ -187153,7 +187318,7 @@ async function runCommand(command, args, env2) {
     });
     proc.on("close", (code) => {
       if (code === 0) {
-        resolve7();
+        resolve10();
       } else {
         reject(new Error(`Command failed with code ${code}: ${stderr}`));
       }
@@ -187162,7 +187327,7 @@ async function runCommand(command, args, env2) {
   });
 }
 async function createPostgresDatabase(postgresPath, dataDir, dbName, env2) {
-  return new Promise((resolve7, reject) => {
+  return new Promise((resolve10, reject) => {
     const proc = spawn(
       postgresPath,
       ["--single", "-D", dataDir, "postgres"],
@@ -187176,7 +187341,7 @@ async function createPostgresDatabase(postgresPath, dataDir, dbName, env2) {
       stderr += data.toString();
     });
     proc.on("close", (code) => {
-      resolve7();
+      resolve10();
     });
     proc.on("error", reject);
     proc.stdin?.write(`CREATE DATABASE "${dbName}";
@@ -187196,33 +187361,33 @@ async function waitForTcpPort(host, port, timeoutMs = 3e4) {
   throw new Error(`Port ${port} did not become available within timeout`);
 }
 function checkTcpPort(host, port) {
-  return new Promise((resolve7) => {
+  return new Promise((resolve10) => {
     const socket = new net.Socket();
     socket.setTimeout(1e3);
     socket.on("connect", () => {
       socket.destroy();
-      resolve7(true);
+      resolve10(true);
     });
     socket.on("timeout", () => {
       socket.destroy();
-      resolve7(false);
+      resolve10(false);
     });
     socket.on("error", () => {
       socket.destroy();
-      resolve7(false);
+      resolve10(false);
     });
     socket.connect(port, host);
   });
 }
 async function stopProcess(proc) {
-  return new Promise((resolve7) => {
+  return new Promise((resolve10) => {
     if (proc.killed || proc.exitCode !== null) {
-      resolve7();
+      resolve10();
       return;
     }
     proc.once("exit", () => {
       clearTimeout(forceKillTimeout);
-      resolve7();
+      resolve10();
     });
     proc.kill("SIGTERM");
     const forceKillTimeout = setTimeout(() => {
@@ -187233,7 +187398,7 @@ async function stopProcess(proc) {
   });
 }
 function sleep2(ms) {
-  return new Promise((resolve7) => setTimeout(resolve7, ms));
+  return new Promise((resolve10) => setTimeout(resolve10, ms));
 }
 
 // src/lib/dev/service-runner.ts
@@ -187242,7 +187407,7 @@ import { spawn as spawn2 } from "child_process";
 // src/lib/local/parser.ts
 var import_hcl2_json_parser2 = __toESM(require_dist(), 1);
 import { readFile, writeFile } from "fs/promises";
-import { existsSync as existsSync10 } from "fs";
+import { existsSync as existsSync11 } from "fs";
 var { parseToObject: parseToObject2 } = import_hcl2_json_parser2.default;
 var LOCAL_FILE = "specific.local";
 var HEADER_COMMENT = `# Local secrets and configuration
@@ -187283,7 +187448,7 @@ async function parseLocalFile(content) {
   return { secrets, configs };
 }
 async function loadLocal() {
-  if (!existsSync10(LOCAL_FILE)) {
+  if (!existsSync11(LOCAL_FILE)) {
     return { secrets: /* @__PURE__ */ new Map(), configs: /* @__PURE__ */ new Map() };
   }
   const content = await readFile(LOCAL_FILE, "utf-8");
@@ -187323,7 +187488,7 @@ ${newLine}
 }
 async function saveLocalSecret(name, value) {
   let content = "";
-  if (existsSync10(LOCAL_FILE)) {
+  if (existsSync11(LOCAL_FILE)) {
     content = await readFile(LOCAL_FILE, "utf-8");
   } else {
     content = HEADER_COMMENT;
@@ -187333,7 +187498,7 @@ async function saveLocalSecret(name, value) {
 }
 async function saveLocalConfig(name, value) {
   let content = "";
-  if (existsSync10(LOCAL_FILE)) {
+  if (existsSync11(LOCAL_FILE)) {
     content = await readFile(LOCAL_FILE, "utf-8");
   } else {
     content = HEADER_COMMENT;
@@ -187342,6 +187507,13 @@ async function saveLocalConfig(name, value) {
   await writeFile(LOCAL_FILE, content);
 }
 
+// src/lib/dev/reshape-manager.ts
+function appendSearchPathToUrl(baseUrl, searchPath) {
+  const url = new URL(baseUrl);
+  url.searchParams.set("options", `-c search_path=${searchPath}`);
+  return url.toString();
+}
+
 // src/lib/dev/env-resolver.ts
 var MissingSecretError = class extends Error {
   constructor(secretName) {
@@ -187446,6 +187618,9 @@ function resolveEnvValue(value, resources, secrets, configs, servicePort, servic
       }
       switch (value.attribute) {
         case "url":
+          if (pg.reshapeEnabled && pg.reshapeSearchPath) {
+            return appendSearchPathToUrl(pg.url, pg.reshapeSearchPath);
+          }
           return pg.url;
         case "host":
           return pg.host;
@@ -187577,7 +187752,7 @@ function resolveEnvForExec(env2, resources, secrets, configs) {
 }
 
 // src/lib/dev/service-runner.ts
-function startService(service, resources, secrets, configs, endpointPorts, serviceEndpoints, onLog, publicUrls) {
+function startService(service, resources, secrets, configs, endpointPorts, serviceEndpoints, onLog, publicUrls, cwd) {
   const command = service.dev?.command ?? service.command;
   if (!command) {
     throw new Error(`Service "${service.name}" has no command`);
@@ -187599,7 +187774,7 @@ function startService(service, resources, secrets, configs, endpointPorts, servi
   );
   const child = spawn2(command, {
     shell: true,
-    cwd: process.cwd(),
+    cwd: cwd || process.cwd(),
     env: {
       ...process.env,
       ...resolvedEnv
@@ -187627,14 +187802,14 @@ function startService(service, resources, secrets, configs, endpointPorts, servi
     ports: endpointPorts,
     process: child,
     async stop() {
-      return new Promise((resolve7) => {
+      return new Promise((resolve10) => {
         if (child.killed || child.exitCode !== null) {
-          resolve7();
+          resolve10();
           return;
         }
         child.once("exit", () => {
           clearTimeout(forceKillTimeout);
-          resolve7();
+          resolve10();
         });
         child.kill("SIGTERM");
         const forceKillTimeout = setTimeout(() => {
@@ -187715,7 +187890,7 @@ var InstanceStateManager = class {
             }
             continue;
           }
-          await new Promise((resolve7) => setTimeout(resolve7, 100));
+          await new Promise((resolve10) => setTimeout(resolve10, 100));
         } else {
           throw e;
         }
@@ -187998,7 +188173,7 @@ async function startHttpProxy(services, certificate, getState, instanceKey = "de
     handleRequest
   );
   httpsServer.on("upgrade", handleUpgrade);
-  return new Promise((resolve7, reject) => {
+  return new Promise((resolve10, reject) => {
     let httpStarted = false;
     let httpsStarted = false;
     let failed = false;
@@ -188009,7 +188184,7 @@ async function startHttpProxy(services, certificate, getState, instanceKey = "de
           "proxy",
           `HTTP/HTTPS proxy started on ports ${HTTP_PORT}/${HTTPS_PORT}`
         );
-        resolve7({
+        resolve10({
           httpPort: HTTP_PORT,
           httpsPort: HTTPS_PORT,
           updateServices,
@@ -188021,13 +188196,13 @@ async function startHttpProxy(services, certificate, getState, instanceKey = "de
             writeLog("proxy", "Certificate updated");
           },
           async stop() {
-            return new Promise((resolve8) => {
+            return new Promise((resolve11) => {
               let closed = 0;
               const onClose = () => {
                 closed++;
                 if (closed === 2) {
                   clearTimeout(forceCloseTimeout);
-                  resolve8();
+                  resolve11();
                 }
               };
               httpServer.close(onClose);
@@ -188035,7 +188210,7 @@ async function startHttpProxy(services, certificate, getState, instanceKey = "de
               const forceCloseTimeout = setTimeout(() => {
                 httpServer.closeAllConnections?.();
                 httpsServer.closeAllConnections?.();
-                resolve8();
+                resolve11();
               }, 2e3);
             });
           }
@@ -188198,7 +188373,7 @@ function serveFileContent(res, filePath, contentType, statusCode = 200) {
   }
 }
 async function startAdminServer(getState) {
-  return new Promise((resolve7, reject) => {
+  return new Promise((resolve10, reject) => {
     const server = http.createServer((req, res) => {
       const url = new URL(req.url || "/", "http://localhost");
       res.setHeader("Access-Control-Allow-Origin", "*");
@@ -188230,7 +188405,7 @@ async function startAdminServer(getState) {
       }
       const port = addr.port;
       writeLog("admin", `Admin API server started on port ${port}`);
-      resolve7({
+      resolve10({
         port,
         stop: () => new Promise((res, rej) => {
           server.close((err) => err ? rej(err) : res());
@@ -188246,7 +188421,7 @@ import { spawn as spawn3 } from "child_process";
 
 // src/lib/secrets/parser.ts
 import { readFile as readFile2, writeFile as writeFile2, mkdir } from "fs/promises";
-import { existsSync as existsSync13 } from "fs";
+import { existsSync as existsSync14 } from "fs";
 import * as path13 from "path";
 import * as crypto2 from "crypto";
 var GENERATED_SECRETS_FILE = ".specific/generated-secrets.json";
@@ -188264,7 +188439,7 @@ function generateRandomString(length = 64) {
   return result;
 }
 async function loadGeneratedSecrets() {
-  if (!existsSync13(GENERATED_SECRETS_FILE)) {
+  if (!existsSync14(GENERATED_SECRETS_FILE)) {
     return /* @__PURE__ */ new Map();
   }
   const content = await readFile2(GENERATED_SECRETS_FILE, "utf-8");
@@ -188273,13 +188448,13 @@ async function loadGeneratedSecrets() {
 }
 async function saveGeneratedSecret(name, value) {
   let secrets = {};
-  if (existsSync13(GENERATED_SECRETS_FILE)) {
+  if (existsSync14(GENERATED_SECRETS_FILE)) {
     const content = await readFile2(GENERATED_SECRETS_FILE, "utf-8");
     secrets = JSON.parse(content);
   }
   secrets[name] = value;
   const dir = path13.dirname(GENERATED_SECRETS_FILE);
-  if (!existsSync13(dir)) {
+  if (!existsSync14(dir)) {
     await mkdir(dir, { recursive: true });
   }
   await writeFile2(GENERATED_SECRETS_FILE, JSON.stringify(secrets, null, 2) + "\n");
@@ -188391,33 +188566,33 @@ async function waitForTcpPort2(host, port, timeoutMs = 3e4) {
   throw new Error(`Electric port ${port} did not become available within timeout`);
 }
 function checkTcpPort2(host, port) {
-  return new Promise((resolve7) => {
+  return new Promise((resolve10) => {
     const socket = new net2.Socket();
     socket.setTimeout(1e3);
     socket.on("connect", () => {
       socket.destroy();
-      resolve7(true);
+      resolve10(true);
     });
     socket.on("timeout", () => {
       socket.destroy();
-      resolve7(false);
+      resolve10(false);
     });
     socket.on("error", () => {
       socket.destroy();
-      resolve7(false);
+      resolve10(false);
     });
     socket.connect(port, host);
   });
 }
 async function stopProcess2(proc) {
-  return new Promise((resolve7) => {
+  return new Promise((resolve10) => {
     if (proc.killed || proc.exitCode !== null) {
-      resolve7();
+      resolve10();
       return;
     }
     proc.once("exit", () => {
       clearTimeout(forceKillTimeout);
-      resolve7();
+      resolve10();
     });
     proc.kill("SIGTERM");
     const forceKillTimeout = setTimeout(() => {
@@ -188428,7 +188603,7 @@ async function stopProcess2(proc) {
   });
 }
 function sleep3(ms) {
-  return new Promise((resolve7) => setTimeout(resolve7, ms));
+  return new Promise((resolve10) => setTimeout(resolve10, ms));
 }
 
 // src/lib/dev/drizzle-gateway-manager.ts
@@ -188512,33 +188687,33 @@ async function waitForTcpPort3(host, port, timeoutMs = 3e4) {
   );
 }
 function checkTcpPort3(host, port) {
-  return new Promise((resolve7) => {
+  return new Promise((resolve10) => {
     const socket = new net3.Socket();
     socket.setTimeout(1e3);
     socket.on("connect", () => {
       socket.destroy();
-      resolve7(true);
+      resolve10(true);
     });
     socket.on("timeout", () => {
       socket.destroy();
-      resolve7(false);
+      resolve10(false);
     });
     socket.on("error", () => {
       socket.destroy();
-      resolve7(false);
+      resolve10(false);
     });
     socket.connect(port, host);
   });
 }
 async function stopProcess3(proc) {
-  return new Promise((resolve7) => {
+  return new Promise((resolve10) => {
     if (proc.killed || proc.exitCode !== null) {
-      resolve7();
+      resolve10();
       return;
     }
     proc.once("exit", () => {
       clearTimeout(forceKillTimeout);
-      resolve7();
+      resolve10();
     });
     proc.kill("SIGTERM");
     const forceKillTimeout = setTimeout(() => {
@@ -188549,7 +188724,7 @@ async function stopProcess3(proc) {
   });
 }
 function sleep4(ms) {
-  return new Promise((resolve7) => setTimeout(resolve7, ms));
+  return new Promise((resolve10) => setTimeout(resolve10, ms));
 }
 
 // src/lib/dev/sync-detector.ts
@@ -188569,6 +188744,288 @@ function detectSyncDatabases(config) {
   return needsSync;
 }
 
+// src/lib/dev/reshape-watcher.ts
+import * as fs18 from "fs";
+import * as path15 from "path";
+import { spawnSync } from "child_process";
+function getMigrationFiles(dir, log) {
+  log(`Scanning migrations directory: ${dir}`);
+  if (!fs18.existsSync(dir)) {
+    log(`Migrations directory does not exist: ${dir}`);
+    return [];
+  }
+  const files = fs18.readdirSync(dir);
+  log(`Found ${files.length} files in directory`);
+  const tomlFiles = files.filter((f) => f.endsWith(".toml")).sort((a, b) => a.localeCompare(b));
+  log(`Found ${tomlFiles.length} .toml migration files: ${tomlFiles.join(", ") || "(none)"}`);
+  return tomlFiles;
+}
+function getMigrationName(filename) {
+  return filename.replace(/\.toml$/, "");
+}
+function getSchemaName(filename) {
+  return `migration_${getMigrationName(filename)}`;
+}
+function runReshape(args, databaseUrl, migrationsDir, reshapeBinaryPath, log) {
+  const fullArgs = ["migration", ...args];
+  if (args[0] === "start") {
+    fullArgs.push("--dirs", ".");
+  }
+  log(`Executing: reshape ${fullArgs.join(" ")}`);
+  log(`  Working directory: ${migrationsDir}`);
+  try {
+    const result = spawnSync(reshapeBinaryPath, fullArgs, {
+      cwd: migrationsDir,
+      env: {
+        ...process.env,
+        DB_URL: databaseUrl
+      },
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    const stdout = result.stdout || "";
+    const stderr = result.stderr || "";
+    const output = stdout + stderr;
+    if (result.status !== 0) {
+      log(`Reshape command failed with exit code ${result.status}`);
+      if (stdout.trim()) log(`  stdout: ${stdout.trim()}`);
+      if (stderr.trim()) log(`  stderr: ${stderr.trim()}`);
+      return { success: false, output };
+    }
+    log(`Reshape command succeeded`);
+    if (stdout.trim()) log(`  stdout: ${stdout.trim()}`);
+    if (stderr.trim()) log(`  stderr: ${stderr.trim()}`);
+    return { success: true, output };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    log(`Reshape command threw exception: ${message}`);
+    return { success: false, output: message };
+  }
+}
+function makeReadOnly(filePath, log) {
+  try {
+    fs18.chmodSync(filePath, 292);
+    log(`Set file permissions to read-only (444): ${filePath}`);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    log(`Warning: Failed to make file read-only: ${filePath} - ${message}`);
+  }
+}
+function createReshapeWatcher(options2) {
+  const { databaseUrl, migrationsDir, reshapeBinaryPath, onSearchPathChanged, onError, log } = options2;
+  let watcher = null;
+  let currentMigrationFiles = [];
+  let startedMigration = null;
+  log(`Creating Reshape watcher`);
+  log(`  Migrations directory: ${migrationsDir}`);
+  log(`  Database URL: ${databaseUrl.replace(/:[^:@]+@/, ":***@")}`);
+  const initialize = async () => {
+    log(`Initializing Reshape migrations...`);
+    currentMigrationFiles = getMigrationFiles(migrationsDir, log);
+    if (currentMigrationFiles.length === 0) {
+      log("No migration files found - skipping Reshape initialization");
+      return null;
+    }
+    log(`Processing ${currentMigrationFiles.length} migration file(s)`);
+    if (currentMigrationFiles.length === 1) {
+      const migrationFile = currentMigrationFiles[0];
+      const migrationName = getMigrationName(migrationFile);
+      log(`Single migration detected: ${migrationFile}`);
+      log(`Starting migration "${migrationName}" (will not be completed, allowing iteration)`);
+      const result = runReshape(["start"], databaseUrl, migrationsDir, reshapeBinaryPath, log);
+      if (!result.success) {
+        log(`ERROR: Failed to start migration "${migrationName}"`);
+        onError(new Error(`Failed to start migration: ${result.output}`));
+        return null;
+      }
+      startedMigration = migrationFile;
+      log(`Migration "${migrationName}" started successfully`);
+      log(`  Started migration file: ${startedMigration}`);
+    } else {
+      const secondToLast = currentMigrationFiles[currentMigrationFiles.length - 2];
+      const secondToLastName = getMigrationName(secondToLast);
+      const lastMigration = currentMigrationFiles[currentMigrationFiles.length - 1];
+      const lastMigrationName = getMigrationName(lastMigration);
+      log(`Multiple migrations detected (${currentMigrationFiles.length} total)`);
+      log(`  Migrations to complete: ${currentMigrationFiles.slice(0, -1).join(", ")}`);
+      log(`  Migration to start (latest): ${lastMigration}`);
+      log(`Completing all migrations up to and including "${secondToLastName}"...`);
+      const completeResult = runReshape(
+        ["start", "--complete", "--migration", secondToLastName],
+        databaseUrl,
+        migrationsDir,
+        reshapeBinaryPath,
+        log
+      );
+      if (!completeResult.success) {
+        log(`ERROR: Failed to complete migrations up to "${secondToLastName}"`);
+        onError(new Error(`Failed to complete migrations: ${completeResult.output}`));
+        return null;
+      }
+      log(`Successfully completed ${currentMigrationFiles.length - 1} migration(s)`);
+      log(`Making completed migration files read-only...`);
+      for (let i = 0; i < currentMigrationFiles.length - 1; i++) {
+        const filePath = path15.join(migrationsDir, currentMigrationFiles[i]);
+        makeReadOnly(filePath, log);
+      }
+      log(`Starting latest migration "${lastMigrationName}" (will not be completed, allowing iteration)`);
+      const startResult = runReshape(["start"], databaseUrl, migrationsDir, reshapeBinaryPath, log);
+      if (!startResult.success) {
+        log(`ERROR: Failed to start migration "${lastMigrationName}"`);
+        onError(new Error(`Failed to start last migration: ${startResult.output}`));
+        return null;
+      }
+      startedMigration = lastMigration;
+      log(`Migration "${lastMigrationName}" started successfully`);
+      log(`  Started migration file: ${startedMigration}`);
+    }
+    const searchPath = startedMigration ? getSchemaName(startedMigration) : null;
+    if (searchPath) {
+      log(`Search path (schema name): ${searchPath}`);
+    } else {
+      log(`No search_path (no migration started)`);
+    }
+    log(`Reshape initialization complete`);
+    return searchPath;
+  };
+  const startWatching = () => {
+    log(`Starting file watcher for migrations directory...`);
+    if (!fs18.existsSync(migrationsDir)) {
+      log(`Migrations directory does not exist, creating: ${migrationsDir}`);
+      fs18.mkdirSync(migrationsDir, { recursive: true });
+    }
+    log(`Watching directory: ${migrationsDir}`);
+    watcher = chokidar_default.watch(migrationsDir, {
+      persistent: true,
+      ignoreInitial: true,
+      depth: 0,
+      awaitWriteFinish: {
+        stabilityThreshold: 200,
+        pollInterval: 50
+      }
+    });
+    watcher.on("change", (filePath) => {
+      const filename = path15.basename(filePath);
+      if (!filename.endsWith(".toml")) return;
+      log(`File change detected: ${filename}`);
+      log(`  Full path: ${filePath}`);
+      log(`  Currently started migration: ${startedMigration || "(none)"}`);
+      if (filename === startedMigration) {
+        log(`Changed file is the currently started migration - will abort and restart`);
+        log(`Aborting current migration...`);
+        const abortResult = runReshape(["abort"], databaseUrl, migrationsDir, reshapeBinaryPath, log);
+        if (!abortResult.success) {
+          log(`ERROR: Failed to abort migration`);
+          onError(new Error(`Failed to abort migration: ${abortResult.output}`));
+          return;
+        }
+        log(`Migration aborted successfully`);
+        log(`Restarting migration...`);
+        const startResult = runReshape(["start"], databaseUrl, migrationsDir, reshapeBinaryPath, log);
+        if (!startResult.success) {
+          log(`ERROR: Failed to restart migration`);
+          onError(new Error(`Failed to restart migration: ${startResult.output}`));
+          return;
+        }
+        log(`Migration restarted successfully`);
+        log(`Note: Services do NOT need to restart (search_path unchanged)`);
+      } else {
+        log(`Warning: Completed migration "${filename}" was modified`);
+        log(`  This file should be read-only. Changes may not take effect.`);
+        log(`  To modify this migration, you may need to reset and re-run all migrations.`);
+      }
+    });
+    watcher.on("add", (filePath) => {
+      const filename = path15.basename(filePath);
+      if (!filename.endsWith(".toml")) return;
+      log(`New file detected: ${filename}`);
+      log(`  Full path: ${filePath}`);
+      const newMigrationFiles = getMigrationFiles(migrationsDir, log);
+      log(`Updated migration list: ${newMigrationFiles.join(", ")}`);
+      const isNewest = newMigrationFiles[newMigrationFiles.length - 1] === filename;
+      log(`Is this the newest migration? ${isNewest}`);
+      if (!isNewest) {
+        log(`Warning: Added migration "${filename}" is not the latest in lexical order`);
+        log(`  Latest migration: ${newMigrationFiles[newMigrationFiles.length - 1]}`);
+        log(`  Manual intervention may be needed to ensure correct migration order`);
+        return;
+      }
+      if (startedMigration) {
+        const previousMigrationName = getMigrationName(startedMigration);
+        log(`Completing previous migration "${previousMigrationName}"...`);
+        const completeResult = runReshape(["complete"], databaseUrl, migrationsDir, reshapeBinaryPath, log);
+        if (!completeResult.success) {
+          log(`ERROR: Failed to complete previous migration`);
+          onError(new Error(`Failed to complete previous migration: ${completeResult.output}`));
+          return;
+        }
+        log(`Previous migration completed successfully`);
+        const completedPath = path15.join(migrationsDir, startedMigration);
+        makeReadOnly(completedPath, log);
+      } else {
+        log(`No previous migration was started`);
+      }
+      const newMigrationName = getMigrationName(filename);
+      log(`Starting new migration "${newMigrationName}"...`);
+      const startResult = runReshape(["start"], databaseUrl, migrationsDir, reshapeBinaryPath, log);
+      if (!startResult.success) {
+        log(`ERROR: Failed to start new migration`);
+        onError(new Error(`Failed to start new migration: ${startResult.output}`));
+        return;
+      }
+      const previousStarted = startedMigration;
+      startedMigration = filename;
+      currentMigrationFiles = newMigrationFiles;
+      log(`New migration started successfully`);
+      log(`  Previous started migration: ${previousStarted || "(none)"}`);
+      log(`  New started migration: ${startedMigration}`);
+      const newSearchPath = getSchemaName(filename);
+      log(`New search_path: ${newSearchPath}`);
+      log(`Notifying services to restart with new search_path...`);
+      onSearchPathChanged(newSearchPath);
+    });
+    watcher.on("unlink", (filePath) => {
+      const filename = path15.basename(filePath);
+      if (!filename.endsWith(".toml")) return;
+      log(`File deleted: ${filename}`);
+      log(`  Full path: ${filePath}`);
+      log(`  Currently started migration: ${startedMigration || "(none)"}`);
+      if (filename === startedMigration) {
+        log(`Warning: The currently started migration was deleted!`);
+        log(`  Manual intervention is required to recover.`);
+      } else {
+        log(`Warning: A migration file was deleted. This may cause issues.`);
+      }
+      log(`  Automatic recovery is not supported - manual intervention may be needed.`);
+    });
+    watcher.on("error", (error) => {
+      const err = error instanceof Error ? error : new Error(String(error));
+      log(`File watcher error: ${err.message}`);
+      onError(err);
+    });
+    watcher.on("ready", () => {
+      log(`File watcher is ready and monitoring for changes`);
+    });
+    log(`File watcher started`);
+  };
+  const close = async () => {
+    log(`Closing Reshape watcher...`);
+    if (watcher) {
+      await watcher.close();
+      watcher = null;
+      log(`File watcher closed`);
+    } else {
+      log(`No file watcher was active`);
+    }
+    log(`Reshape watcher closed`);
+  };
+  return {
+    initialize,
+    startWatching,
+    close
+  };
+}
+
 // src/lib/dev/resource-starter.ts
 function findRequiredResources(service) {
   const required = { postgres: [], redis: [], storage: [] };
@@ -188627,11 +189084,14 @@ async function startResources(options2) {
     const instance = await startPostgres(pg, port, dataDir, (progress) => {
       callbacks.onResourceProgress?.(pg.name, progress);
     });
+    if (pg.reshape?.enabled) {
+      instance.reshapeEnabled = true;
+    }
     resources.set(pg.name, instance);
     startedResources.push(instance);
     callbacks.onResourceReady?.(pg.name, instance);
     log(`Postgres "${pg.name}" ready`);
-    await stateManager.registerDatabase(pg.name, {
+    const dbState = {
       engine: "postgres",
       port: instance.port,
       host: instance.host,
@@ -188639,7 +189099,14 @@ async function startResources(options2) {
       password: instance.password,
       dbName: instance.dbName,
       url: instance.url
-    });
+    };
+    if (instance.reshapeEnabled) {
+      dbState.reshapeEnabled = true;
+      if (instance.reshapeSearchPath) {
+        dbState.reshapeSearchPath = instance.reshapeSearchPath;
+      }
+    }
+    await stateManager.registerDatabase(pg.name, dbState);
   }
   for (const redis of redisConfigs) {
     if (signal?.cancelled) {
@@ -188741,24 +189208,24 @@ function watchConfigFile(configPath, debounceMs, onChange) {
 }
 
 // src/lib/dev/subdomain-generator.ts
-import * as fs18 from "fs";
-import * as path15 from "path";
+import * as fs19 from "fs";
+import * as path16 from "path";
 import { generateSlug } from "random-word-slugs";
 var StableSubdomainAllocator = class {
   tunnelsDir;
   tunnelsFilePath;
   baseSlug = null;
   constructor(projectRoot, key = "default") {
-    this.tunnelsDir = path15.join(projectRoot, ".specific", "keys", key);
-    this.tunnelsFilePath = path15.join(this.tunnelsDir, "tunnels.json");
+    this.tunnelsDir = path16.join(projectRoot, ".specific", "keys", key);
+    this.tunnelsFilePath = path16.join(this.tunnelsDir, "tunnels.json");
     this.loadTunnels();
   }
   loadTunnels() {
-    if (!fs18.existsSync(this.tunnelsFilePath)) {
+    if (!fs19.existsSync(this.tunnelsFilePath)) {
       return;
     }
     try {
-      const content = fs18.readFileSync(this.tunnelsFilePath, "utf-8");
+      const content = fs19.readFileSync(this.tunnelsFilePath, "utf-8");
       const data = JSON.parse(content);
       if (data.version === 1 && data.baseSlug) {
         this.baseSlug = data.baseSlug;
@@ -188768,14 +189235,14 @@ var StableSubdomainAllocator = class {
     }
   }
   saveTunnels() {
-    if (!fs18.existsSync(this.tunnelsDir)) {
-      fs18.mkdirSync(this.tunnelsDir, { recursive: true });
+    if (!fs19.existsSync(this.tunnelsDir)) {
+      fs19.mkdirSync(this.tunnelsDir, { recursive: true });
     }
     const data = {
       version: 1,
       baseSlug: this.baseSlug
     };
-    fs18.writeFileSync(this.tunnelsFilePath, JSON.stringify(data, null, 2));
+    fs19.writeFileSync(this.tunnelsFilePath, JSON.stringify(data, null, 2));
   }
   generateBaseSlug() {
     return generateSlug(2, {
@@ -188838,8 +189305,8 @@ async function startTunnel(serviceName, endpointName, port, subdomain, callbacks
 }
 
 // src/lib/dev/proxy-registry.ts
-import * as fs19 from "fs";
-import * as path16 from "path";
+import * as fs20 from "fs";
+import * as path17 from "path";
 import * as os7 from "os";
 import * as net4 from "net";
 var ProxyRegistryManager = class {
@@ -188850,14 +189317,14 @@ var ProxyRegistryManager = class {
   isOwner = false;
   registryWatcher = null;
   constructor() {
-    this.proxyDir = path16.join(os7.homedir(), ".specific", "proxy");
-    this.ownerPath = path16.join(this.proxyDir, "owner.json");
-    this.registryPath = path16.join(this.proxyDir, "registry.json");
-    this.lockPath = path16.join(this.proxyDir, "registry.lock");
+    this.proxyDir = path17.join(os7.homedir(), ".specific", "proxy");
+    this.ownerPath = path17.join(this.proxyDir, "owner.json");
+    this.registryPath = path17.join(this.proxyDir, "registry.json");
+    this.lockPath = path17.join(this.proxyDir, "registry.lock");
   }
   ensureProxyDir() {
-    if (!fs19.existsSync(this.proxyDir)) {
-      fs19.mkdirSync(this.proxyDir, { recursive: true });
+    if (!fs20.existsSync(this.proxyDir)) {
+      fs20.mkdirSync(this.proxyDir, { recursive: true });
     }
   }
   isProcessRunning(pid) {
@@ -188874,7 +189341,7 @@ var ProxyRegistryManager = class {
    * This catches cases where the owner process is alive but the proxy has crashed.
    */
   isProxyListening(port, timeoutMs = 1e3) {
-    return new Promise((resolve7) => {
+    return new Promise((resolve10) => {
       const socket = new net4.Socket();
       let resolved = false;
       const cleanup = () => {
@@ -188886,15 +189353,15 @@ var ProxyRegistryManager = class {
       socket.setTimeout(timeoutMs);
       socket.on("connect", () => {
         cleanup();
-        resolve7(true);
+        resolve10(true);
       });
       socket.on("timeout", () => {
         cleanup();
-        resolve7(false);
+        resolve10(false);
       });
       socket.on("error", () => {
         cleanup();
-        resolve7(false);
+        resolve10(false);
       });
       socket.connect(port, "127.0.0.1");
     });
@@ -188914,15 +189381,15 @@ var ProxyRegistryManager = class {
     const startTime = Date.now();
     while (Date.now() - startTime < timeoutMs) {
       try {
-        const fd = fs19.openSync(
+        const fd = fs20.openSync(
           this.lockPath,
-          fs19.constants.O_CREAT | fs19.constants.O_EXCL | fs19.constants.O_WRONLY
+          fs20.constants.O_CREAT | fs20.constants.O_EXCL | fs20.constants.O_WRONLY
         );
-        fs19.writeSync(fd, String(process.pid));
-        fs19.closeSync(fd);
+        fs20.writeSync(fd, String(process.pid));
+        fs20.closeSync(fd);
         return () => {
           try {
-            fs19.unlinkSync(this.lockPath);
+            fs20.unlinkSync(this.lockPath);
           } catch {
           }
         };
@@ -188931,21 +189398,21 @@ var ProxyRegistryManager = class {
         if (err.code === "EEXIST") {
           try {
             const lockPid = parseInt(
-              fs19.readFileSync(this.lockPath, "utf-8").trim(),
+              fs20.readFileSync(this.lockPath, "utf-8").trim(),
               10
             );
             if (!this.isProcessRunning(lockPid)) {
-              fs19.unlinkSync(this.lockPath);
+              fs20.unlinkSync(this.lockPath);
               continue;
             }
           } catch {
             try {
-              fs19.unlinkSync(this.lockPath);
+              fs20.unlinkSync(this.lockPath);
             } catch {
             }
             continue;
           }
-          await new Promise((resolve7) => setTimeout(resolve7, 100));
+          await new Promise((resolve10) => setTimeout(resolve10, 100));
         } else {
           throw e;
         }
@@ -188960,8 +189427,8 @@ var ProxyRegistryManager = class {
   async claimProxyOwnership(key) {
     const releaseLock = await this.acquireLock();
     try {
-      if (fs19.existsSync(this.ownerPath)) {
-        const content = fs19.readFileSync(this.ownerPath, "utf-8");
+      if (fs20.existsSync(this.ownerPath)) {
+        const content = fs20.readFileSync(this.ownerPath, "utf-8");
         const ownerFile2 = JSON.parse(content);
         if (await this.isProxyOwnerHealthy(ownerFile2.owner.pid)) {
           return false;
@@ -188991,11 +189458,11 @@ var ProxyRegistryManager = class {
     }
     const releaseLock = await this.acquireLock();
     try {
-      if (fs19.existsSync(this.ownerPath)) {
-        const content = fs19.readFileSync(this.ownerPath, "utf-8");
+      if (fs20.existsSync(this.ownerPath)) {
+        const content = fs20.readFileSync(this.ownerPath, "utf-8");
         const ownerFile = JSON.parse(content);
         if (ownerFile.owner.pid === process.pid) {
-          fs19.unlinkSync(this.ownerPath);
+          fs20.unlinkSync(this.ownerPath);
         }
       }
       this.isOwner = false;
@@ -189007,12 +189474,12 @@ var ProxyRegistryManager = class {
    * Get the current proxy owner.
    */
   async getProxyOwner() {
-    if (!fs19.existsSync(this.ownerPath)) {
+    if (!fs20.existsSync(this.ownerPath)) {
       return null;
     }
     const releaseLock = await this.acquireLock();
     try {
-      const content = fs19.readFileSync(this.ownerPath, "utf-8");
+      const content = fs20.readFileSync(this.ownerPath, "utf-8");
       const ownerFile = JSON.parse(content);
       if (!await this.isProxyOwnerHealthy(ownerFile.owner.pid)) {
         return null;
@@ -189106,7 +189573,7 @@ var ProxyRegistryManager = class {
    */
   watchRegistry(onChange) {
     this.ensureProxyDir();
-    if (!fs19.existsSync(this.registryPath)) {
+    if (!fs20.existsSync(this.registryPath)) {
       const emptyRegistry = {
         version: 1,
         keys: {},
@@ -189150,13 +189617,13 @@ var ProxyRegistryManager = class {
   async attemptElection(key) {
     const releaseLock = await this.acquireLock();
     try {
-      if (fs19.existsSync(this.ownerPath)) {
-        const content = fs19.readFileSync(this.ownerPath, "utf-8");
+      if (fs20.existsSync(this.ownerPath)) {
+        const content = fs20.readFileSync(this.ownerPath, "utf-8");
         const ownerFile2 = JSON.parse(content);
         if (await this.isProxyOwnerHealthy(ownerFile2.owner.pid)) {
           return false;
         }
-        fs19.unlinkSync(this.ownerPath);
+        fs20.unlinkSync(this.ownerPath);
       }
       const ownerFile = {
         version: 1,
@@ -189174,7 +189641,7 @@ var ProxyRegistryManager = class {
     }
   }
   readRegistry() {
-    if (!fs19.existsSync(this.registryPath)) {
+    if (!fs20.existsSync(this.registryPath)) {
       return {
         version: 1,
         keys: {},
@@ -189182,7 +189649,7 @@ var ProxyRegistryManager = class {
       };
     }
     try {
-      const content = fs19.readFileSync(this.registryPath, "utf-8");
+      const content = fs20.readFileSync(this.registryPath, "utf-8");
       return JSON.parse(content);
     } catch {
       return {
@@ -189195,8 +189662,8 @@ var ProxyRegistryManager = class {
   writeFileAtomic(filePath, data) {
     this.ensureProxyDir();
     const tmpPath = filePath + ".tmp";
-    fs19.writeFileSync(tmpPath, JSON.stringify(data, null, 2));
-    fs19.renameSync(tmpPath, filePath);
+    fs20.writeFileSync(tmpPath, JSON.stringify(data, null, 2));
+    fs20.renameSync(tmpPath, filePath);
   }
 };
 
@@ -189341,6 +189808,7 @@ function DevUI({ instanceKey, tunnelEnabled }) {
   const proxyRegistryRef = useRef(null);
   const electricInstancesRef = useRef([]);
   const drizzleGatewayRef = useRef(null);
+  const reshapeWatchersRef = useRef([]);
   const registryWatcherCleanupRef = useRef(null);
   const electionIntervalRef = useRef(null);
   const tunnelsRef = useRef([]);
@@ -189348,6 +189816,7 @@ function DevUI({ instanceKey, tunnelEnabled }) {
   const adminServerRef = useRef(null);
   const servicesRef = useRef([]);
   const resourcesRef = useRef(/* @__PURE__ */ new Map());
+  const restartServicesRef = useRef(null);
   const [reloadTrigger, setReloadTrigger] = useState5(0);
   const [readyToStart, setReadyToStart] = useState5(() => caFilesExist());
   const shutdown2 = async () => {
@@ -189374,6 +189843,8 @@ function DevUI({ instanceKey, tunnelEnabled }) {
       ...servicesRef.current.map((service) => service.stop()),
       // Stop all Electric instances
       ...electricInstancesRef.current.map((electric) => electric.stop()),
+      // Stop all Reshape watchers
+      ...reshapeWatchersRef.current.map((watcher) => watcher.close()),
       // Stop Drizzle Gateway
       drizzleGatewayRef.current?.stop(),
       // Stop all resources
@@ -189381,6 +189852,8 @@ function DevUI({ instanceKey, tunnelEnabled }) {
       // Stop all tunnels
       ...tunnelsRef.current.map((tunnel) => tunnel.stop())
     ]);
+    reshapeWatchersRef.current = [];
+    restartServicesRef.current = null;
     if (proxyRegistryRef.current) {
       await proxyRegistryRef.current.unregisterServices(instanceKey);
       await proxyRegistryRef.current.releaseProxyOwnership();
@@ -189413,6 +189886,8 @@ function DevUI({ instanceKey, tunnelEnabled }) {
       ...servicesRef.current.map((service) => service.stop()),
       // Stop all Electric instances
       ...electricInstancesRef.current.map((electric) => electric.stop()),
+      // Stop all Reshape watchers
+      ...reshapeWatchersRef.current.map((watcher) => watcher.close()),
       // Stop Drizzle Gateway
       drizzleGatewayRef.current?.stop(),
       // Stop all resources
@@ -189421,9 +189896,11 @@ function DevUI({ instanceKey, tunnelEnabled }) {
       ...tunnelsRef.current.map((tunnel) => tunnel.stop())
     ]);
     if (tunnelsRef.current.length > 0) {
-      await new Promise((resolve7) => setTimeout(resolve7, 1500));
+      await new Promise((resolve10) => setTimeout(resolve10, 1500));
     }
     electricInstancesRef.current = [];
+    reshapeWatchersRef.current = [];
+    restartServicesRef.current = null;
     drizzleGatewayRef.current = null;
     proxyRef.current = null;
     adminServerRef.current = null;
@@ -189488,10 +189965,10 @@ function DevUI({ instanceKey, tunnelEnabled }) {
   }, [state.status]);
   useEffect3(() => {
     if (state.status !== "running") return;
-    const configPath = path17.join(process.cwd(), "specific.hcl");
+    const configPath = path18.join(process.cwd(), "specific.hcl");
     const watcher = watchConfigFile(configPath, 1e3, () => {
       try {
-        const hcl = fs20.readFileSync(configPath, "utf-8");
+        const hcl = fs21.readFileSync(configPath, "utf-8");
         parseConfig(hcl).then(() => {
           triggerReload();
         }).catch((err) => {
@@ -189616,8 +190093,8 @@ function DevUI({ instanceKey, tunnelEnabled }) {
         }));
         return;
       }
-      const configPath = path17.join(process.cwd(), "specific.hcl");
-      if (!fs20.existsSync(configPath)) {
+      const configPath = path18.join(process.cwd(), "specific.hcl");
+      if (!fs21.existsSync(configPath)) {
         writeLog("system", "Waiting for specific.hcl to appear");
         setState((s) => ({
           ...s,
@@ -189636,7 +190113,7 @@ function DevUI({ instanceKey, tunnelEnabled }) {
       }
       let config2;
       try {
-        const hcl = fs20.readFileSync(configPath, "utf-8");
+        const hcl = fs21.readFileSync(configPath, "utf-8");
         config2 = await parseConfig(hcl);
       } catch (err) {
         setState((s) => ({
@@ -189742,7 +190219,7 @@ function DevUI({ instanceKey, tunnelEnabled }) {
           const drizzleGateway = await startDrizzleGateway(
             postgresResources,
             drizzlePort,
-            path17.join(process.cwd(), ".specific", "keys", instanceKey)
+            path18.join(process.cwd(), ".specific", "keys", instanceKey)
           );
           startedDrizzleGateway = drizzleGateway;
           drizzleGatewayRef.current = drizzleGateway;
@@ -189755,6 +190232,59 @@ function DevUI({ instanceKey, tunnelEnabled }) {
         }
       }
       if (cancelled) return;
+      const startedReshapeWatchers = [];
+      const hasReshapeEnabled = config2.postgres.some((pg) => pg.reshape?.enabled);
+      const reshapeBin = hasReshapeEnabled ? await ensureBinary(reshapeBinary) : void 0;
+      for (const pg of config2.postgres) {
+        if (pg.reshape?.enabled) {
+          const resource = resources2.get(pg.name);
+          if (!resource) continue;
+          const migrationsDir = path18.resolve(
+            process.cwd(),
+            pg.reshape.migrations_dir ?? "migrations"
+          );
+          writeLog("system", `Initializing Reshape migrations for "${pg.name}" from ${migrationsDir}`);
+          const watcher = createReshapeWatcher({
+            databaseUrl: resource.url,
+            migrationsDir,
+            reshapeBinaryPath: reshapeBin.executables["reshape"],
+            onSearchPathChanged: async (newSearchPath) => {
+              resource.reshapeSearchPath = newSearchPath ?? void 0;
+              if (newSearchPath) {
+                await stateManager.updateDatabase(pg.name, {
+                  reshapeSearchPath: newSearchPath
+                });
+              }
+              writeLog("system", `Reshape search_path changed for "${pg.name}": ${newSearchPath}`);
+              if (restartServicesRef.current) {
+                await restartServicesRef.current();
+              }
+            },
+            onError: (err) => {
+              writeLog("system:error", `Reshape error for "${pg.name}": ${err.message}`);
+            },
+            log: (msg) => writeLog("system", `[reshape:${pg.name}] ${msg}`)
+          });
+          try {
+            const initialSearchPath = await watcher.initialize();
+            resource.reshapeSearchPath = initialSearchPath ?? void 0;
+            if (initialSearchPath) {
+              await stateManager.updateDatabase(pg.name, {
+                reshapeSearchPath: initialSearchPath
+              });
+              writeLog("system", `Reshape search_path for "${pg.name}": ${initialSearchPath}`);
+            }
+            startedReshapeWatchers.push(watcher);
+          } catch (err) {
+            writeLog(
+              "system:warning",
+              `Failed to initialize Reshape for "${pg.name}": ${err instanceof Error ? err.message : String(err)}`
+            );
+          }
+        }
+      }
+      reshapeWatchersRef.current = startedReshapeWatchers;
+      if (cancelled) return;
       const secrets = await prepareSecrets(config2.secrets, true);
       const configs = await prepareConfigs(config2.configs, void 0, true);
       const usedSecrets = findUsedSecrets(config2.services, true);
@@ -189876,6 +190406,14 @@ Add them to the config block in specific.local`);
         }
       }
       const services2 = [];
+      function resolveServiceCwd(service) {
+        if (service.root) return path18.resolve(process.cwd(), service.root);
+        if (service.build) {
+          const build = config2.builds.find((b) => b.name === service.build.name);
+          if (build?.root) return path18.resolve(process.cwd(), build.root);
+        }
+        return process.cwd();
+      }
       for (const service of config2.services) {
         if (cancelled) break;
         if (service.serve) {
@@ -189899,7 +190437,8 @@ Add them to the config block in specific.local`);
             endpointPorts,
             serviceEndpoints,
             (line) => addLog(line, colorMap),
-            publicUrls
+            publicUrls,
+            resolveServiceCwd(service)
           );
           services2.push(running);
           startedServices.push(running);
@@ -189927,6 +190466,42 @@ Add them to the config block in specific.local`);
         }
       }
       if (cancelled) return;
+      restartServicesRef.current = async () => {
+        if (shuttingDown.current) return;
+        writeLog("system", "Restarting services (migration changed)");
+        await Promise.all(servicesRef.current.map((s) => s.stop()));
+        const newServices = [];
+        for (const service of config2.services) {
+          if (service.serve) continue;
+          if (!service.command && !service.dev?.command) continue;
+          try {
+            const endpointPorts = serviceEndpointPorts.get(service.name) || /* @__PURE__ */ new Map();
+            const running = startService(
+              service,
+              resources2,
+              secrets,
+              configs,
+              endpointPorts,
+              serviceEndpoints,
+              (line) => addLog(line, colorMap),
+              void 0,
+              resolveServiceCwd(service)
+            );
+            newServices.push(running);
+          } catch (err) {
+            writeLog(
+              "system:error",
+              `Failed to restart service "${service.name}": ${err instanceof Error ? err.message : String(err)}`
+            );
+          }
+        }
+        servicesRef.current = newServices;
+        setState((s) => ({ ...s, services: newServices }));
+        writeLog("system", "Services restarted");
+      };
+      for (const watcher of reshapeWatchersRef.current) {
+        watcher.startWatching();
+      }
       if (tunnelEnabled) {
         writeLog("system", "Tunnel mode enabled, starting tunnels for public services");
         if (exposedServices.length === 0) {
@@ -190144,6 +190719,12 @@ Add them to the config block in specific.local`);
         electric.stop().catch(() => {
         });
       }
+      for (const watcher of reshapeWatchersRef.current) {
+        watcher.close().catch(() => {
+        });
+      }
+      reshapeWatchersRef.current = [];
+      restartServicesRef.current = null;
       if (startedDrizzleGateway) {
         startedDrizzleGateway.stop().catch(() => {
         });
@@ -190366,7 +190947,7 @@ function devCommand(instanceKey, tunnelEnabled = false) {
 
 // src/lib/dev/git-worktree.ts
 import { execSync as execSync2 } from "child_process";
-import * as path18 from "path";
+import * as path19 from "path";
 function isInWorktree() {
   try {
     const commonDir = execSync2("git rev-parse --git-common-dir", {
@@ -190377,8 +190958,8 @@ function isInWorktree() {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
     }).trim();
-    const resolvedCommonDir = path18.resolve(commonDir);
-    const resolvedGitDir = path18.resolve(gitDir);
+    const resolvedCommonDir = path19.resolve(commonDir);
+    const resolvedGitDir = path19.resolve(gitDir);
     return resolvedCommonDir !== resolvedGitDir;
   } catch {
     return false;
@@ -190393,7 +190974,7 @@ function getWorktreeName() {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
     }).trim();
-    return path18.basename(gitDir);
+    return path19.basename(gitDir);
   } catch {
     return null;
   }
@@ -190408,35 +190989,36 @@ init_open();
 import React7, { useState as useState6, useEffect as useEffect4, useCallback } from "react";
 import { render as render5, Text as Text7, Box as Box7, useApp as useApp3, useInput as useInput5 } from "ink";
 import Spinner5 from "ink-spinner";
-import * as fs22 from "fs";
-import * as path20 from "path";
+import * as fs23 from "fs";
+import * as path21 from "path";
 
 // src/lib/deploy/build-tester.ts
 import { spawn as spawn5 } from "child_process";
-import { existsSync as existsSync18 } from "fs";
-import { join as join19 } from "path";
+import { existsSync as existsSync20 } from "fs";
+import { join as join21, resolve as resolve7 } from "path";
 function getDependencyInstallCommand(build, projectDir) {
   switch (build.base) {
     case "node":
-      if (existsSync18(join19(projectDir, "pnpm-lock.yaml"))) {
+      if (existsSync20(join21(projectDir, "pnpm-lock.yaml"))) {
         return "pnpm install --frozen-lockfile";
-      } else if (existsSync18(join19(projectDir, "yarn.lock"))) {
+      } else if (existsSync20(join21(projectDir, "yarn.lock"))) {
         return "yarn install --frozen-lockfile";
-      } else if (existsSync18(join19(projectDir, "package-lock.json"))) {
+      } else if (existsSync20(join21(projectDir, "package-lock.json"))) {
         return "npm ci";
-      } else {
+      } else if (existsSync20(join21(projectDir, "package.json"))) {
         return "npm install";
       }
+      return null;
     case "python":
-      if (existsSync18(join19(projectDir, "poetry.lock"))) {
+      if (existsSync20(join21(projectDir, "poetry.lock"))) {
         return "poetry install --no-interaction";
-      } else if (existsSync18(join19(projectDir, "Pipfile.lock"))) {
+      } else if (existsSync20(join21(projectDir, "Pipfile.lock"))) {
         return "pipenv install --deploy";
-      } else if (existsSync18(join19(projectDir, "Pipfile"))) {
+      } else if (existsSync20(join21(projectDir, "Pipfile"))) {
         return "pipenv install";
-      } else if (existsSync18(join19(projectDir, "pyproject.toml"))) {
+      } else if (existsSync20(join21(projectDir, "pyproject.toml"))) {
         return "pip install .";
-      } else if (existsSync18(join19(projectDir, "requirements.txt"))) {
+      } else if (existsSync20(join21(projectDir, "requirements.txt"))) {
         return "pip install -r requirements.txt";
       }
       return null;
@@ -190450,7 +191032,7 @@ function getDependencyInstallCommand(build, projectDir) {
   }
 }
 function runCommand2(command, projectDir, buildName) {
-  return new Promise((resolve7) => {
+  return new Promise((resolve10) => {
     const stdout = [];
     const stderr = [];
     writeLog("build-test", `[${buildName}] Running: ${command}`);
@@ -190480,7 +191062,7 @@ function runCommand2(command, projectDir, buildName) {
     });
     child.on("error", (err) => {
       writeLog("build-test:error", `[${buildName}] Failed to start: ${err.message}`);
-      resolve7({
+      resolve10({
         success: false,
         output: `Failed to start command: ${err.message}`
       });
@@ -190489,10 +191071,10 @@ function runCommand2(command, projectDir, buildName) {
       const output = [...stdout, ...stderr].join("");
       if (code === 0) {
         writeLog("build-test", `[${buildName}] Command succeeded (exit code 0)`);
-        resolve7({ success: true, output });
+        resolve10({ success: true, output });
       } else {
         writeLog("build-test:error", `[${buildName}] Command failed with exit code ${code}`);
-        resolve7({
+        resolve10({
           success: false,
           output: output || `Exit code: ${code}`
         });
@@ -190503,7 +191085,7 @@ function runCommand2(command, projectDir, buildName) {
 async function testBuild(build, projectDir) {
   const startTime = Date.now();
   const outputs = [];
-  const workDir = projectDir;
+  const workDir = build.root ? resolve7(projectDir, build.root) : projectDir;
   writeLog("build-test", `Starting test for build "${build.name}" (base: ${build.base}, workDir: ${workDir})`);
   const depsCommand = getDependencyInstallCommand(build, workDir);
   if (depsCommand) {
@@ -190582,8 +191164,8 @@ async function testAllBuilds(builds, projectDir) {
 
 // src/lib/tarball/create.ts
 import { execSync as execSync3 } from "child_process";
-import * as fs21 from "fs";
-import * as path19 from "path";
+import * as fs22 from "fs";
+import * as path20 from "path";
 import { createTarPacker, createEntryItemGenerator } from "tar-vern";
 function isInsideGitRepository(dir) {
   try {
@@ -190640,10 +191222,10 @@ var EXCLUDED_DIRS = [
 ];
 async function collectPaths(baseDir, currentDir, exclude) {
   const results = [];
-  const entries = await fs21.promises.readdir(currentDir, { withFileTypes: true });
+  const entries = await fs22.promises.readdir(currentDir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = path19.join(currentDir, entry.name);
-    const relativePath = path19.relative(baseDir, fullPath);
+    const fullPath = path20.join(currentDir, entry.name);
+    const relativePath = path20.relative(baseDir, fullPath);
     if (entry.isDirectory()) {
       if (!exclude.includes(entry.name)) {
         results.push(relativePath);
@@ -190658,8 +191240,8 @@ async function collectPaths(baseDir, currentDir, exclude) {
 }
 async function createTarArchive(projectDir) {
   writeLog("tarball", "Creating tarball using tar-vern (non-git project)");
-  const configPath = path19.join(projectDir, "specific.hcl");
-  if (!fs21.existsSync(configPath)) {
+  const configPath = path20.join(projectDir, "specific.hcl");
+  if (!fs22.existsSync(configPath)) {
     throw new Error("specific.hcl not found in project directory");
   }
   const relativePaths = await collectPaths(projectDir, projectDir, EXCLUDED_DIRS);
@@ -190676,8 +191258,8 @@ async function createTarArchive(projectDir) {
 }
 function findWidestContext(projectDir, contexts) {
   if (contexts.length === 0) return ".";
-  const absolute = contexts.map((c) => path19.resolve(projectDir, c));
-  const segments = absolute.map((p) => p.split(path19.sep).filter(Boolean));
+  const absolute = contexts.map((c) => path20.resolve(projectDir, c));
+  const segments = absolute.map((p) => p.split(path20.sep).filter(Boolean));
   const firstSegments = segments[0];
   if (!firstSegments) return ".";
   const minLen = Math.min(...segments.map((s) => s.length));
@@ -190691,12 +191273,12 @@ function findWidestContext(projectDir, contexts) {
     }
   }
   const ancestorSegments = firstSegments.slice(0, commonLength);
-  const ancestor = path19.sep + ancestorSegments.join(path19.sep);
-  return path19.relative(projectDir, ancestor) || ".";
+  const ancestor = path20.sep + ancestorSegments.join(path20.sep);
+  return path20.relative(projectDir, ancestor) || ".";
 }
 async function createProjectTarball(projectDir, context = ".") {
-  const contextDir = path19.resolve(projectDir, context);
-  const appPath = path19.relative(contextDir, projectDir) || ".";
+  const contextDir = path20.resolve(projectDir, context);
+  const appPath = path20.relative(contextDir, projectDir) || ".";
   writeLog("tarball", `Context: ${contextDir}, appPath: ${appPath}`);
   let tarball;
   if (isInsideGitRepository(contextDir)) {
@@ -191583,14 +192165,14 @@ ${errorMsg}`
   ), phase === "error" && /* @__PURE__ */ React7.createElement(Box7, { marginTop: 1 }, /* @__PURE__ */ React7.createElement(Text7, { color: "red" }, "Error: ", error)), phase === "success" && /* @__PURE__ */ React7.createElement(Box7, { marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React7.createElement(Text7, { color: "green" }, "Deployment successful!"), deployment?.publicUrls && Object.keys(deployment.publicUrls).length > 0 && /* @__PURE__ */ React7.createElement(Box7, { marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React7.createElement(Text7, { bold: true }, "Public URLs:"), Object.entries(deployment.publicUrls).map(([name, url]) => /* @__PURE__ */ React7.createElement(Text7, { key: name }, "  ", name, ": ", /* @__PURE__ */ React7.createElement(Text7, { color: "cyan" }, url))))));
 }
 async function deployCommand(environment, options2) {
-  const configPath = path20.join(process.cwd(), "specific.hcl");
-  if (!fs22.existsSync(configPath)) {
+  const configPath = path21.join(process.cwd(), "specific.hcl");
+  if (!fs23.existsSync(configPath)) {
     console.error("Error: No specific.hcl found in current directory");
     process.exit(1);
   }
   let config;
   try {
-    const hcl = fs22.readFileSync(configPath, "utf-8");
+    const hcl = fs23.readFileSync(configPath, "utf-8");
     config = await parseConfig(hcl);
   } catch (err) {
     console.error(
@@ -191614,8 +192196,8 @@ async function deployCommand(environment, options2) {
 
 // src/commands/exec.tsx
 import { spawn as spawn6 } from "child_process";
-import * as fs23 from "fs";
-import * as path21 from "path";
+import * as fs24 from "fs";
+import * as path22 from "path";
 async function execCommand(serviceName, command, instanceKey = "default") {
   if (command.length === 0) {
     console.error(
@@ -191643,14 +192225,14 @@ async function execCommand(serviceName, command, instanceKey = "default") {
       }
     }
   };
-  const configPath = path21.join(process.cwd(), "specific.hcl");
-  if (!fs23.existsSync(configPath)) {
+  const configPath = path22.join(process.cwd(), "specific.hcl");
+  if (!fs24.existsSync(configPath)) {
     console.error("Error: No specific.hcl found in current directory");
     process.exit(1);
   }
   let config;
   try {
-    const hcl = fs23.readFileSync(configPath, "utf-8");
+    const hcl = fs24.readFileSync(configPath, "utf-8");
     config = await parseConfig(hcl);
   } catch (err) {
     console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
@@ -191697,6 +192279,8 @@ async function execCommand(serviceName, command, instanceKey = "default") {
           bucket: dbState.engine === "object_store" ? name : void 0,
           syncUrl: dbState.syncUrl,
           syncSecret: dbState.syncSecret,
+          reshapeEnabled: dbState.reshapeEnabled,
+          reshapeSearchPath: dbState.reshapeSearchPath,
           async stop() {
           }
         });
@@ -191762,8 +192346,17 @@ async function execCommand(serviceName, command, instanceKey = "default") {
   };
   process.on("SIGINT", () => handleSignal("SIGINT"));
   process.on("SIGTERM", () => handleSignal("SIGTERM"));
+  let effectiveCwd = process.cwd();
+  if (service.root) {
+    effectiveCwd = path22.resolve(process.cwd(), service.root);
+  } else if (service.build) {
+    const build = config.builds.find((b) => b.name === service.build.name);
+    if (build?.root) {
+      effectiveCwd = path22.resolve(process.cwd(), build.root);
+    }
+  }
   child = spawn6(command[0], command.slice(1), {
-    cwd: process.cwd(),
+    cwd: effectiveCwd,
     env: {
       ...process.env,
       ...resolvedEnv
@@ -191787,8 +192380,8 @@ async function execCommand(serviceName, command, instanceKey = "default") {
 
 // src/commands/psql.tsx
 import { spawn as spawn7 } from "child_process";
-import * as fs24 from "fs";
-import * as path22 from "path";
+import * as fs25 from "fs";
+import * as path23 from "path";
 async function psqlCommand(databaseName, instanceKey = "default", extraArgs = []) {
   let startedResources = [];
   let ownsInstances = false;
@@ -191805,14 +192398,14 @@ async function psqlCommand(databaseName, instanceKey = "default", extraArgs = []
       }
     }
   };
-  const configPath = path22.join(process.cwd(), "specific.hcl");
-  if (!fs24.existsSync(configPath)) {
+  const configPath = path23.join(process.cwd(), "specific.hcl");
+  if (!fs25.existsSync(configPath)) {
     console.error("Error: No specific.hcl found in current directory");
     process.exit(1);
   }
   let config;
   try {
-    const hcl = fs24.readFileSync(configPath, "utf-8");
+    const hcl = fs25.readFileSync(configPath, "utf-8");
     config = await parseConfig(hcl);
   } catch (err) {
     console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
@@ -191932,25 +192525,227 @@ async function psqlCommand(databaseName, instanceKey = "default", extraArgs = []
   });
 }
 
+// src/commands/reshape.tsx
+import { spawn as spawn8 } from "child_process";
+import * as fs26 from "fs";
+import * as path24 from "path";
+var VALID_ACTIONS = ["start", "complete", "status", "abort", "check"];
+var MIGRATION_SUBCOMMANDS = ["start", "complete", "abort"];
+var OFFLINE_ACTIONS = ["check"];
+async function reshapeCommand(action, databaseName, instanceKey = "default") {
+  if (!VALID_ACTIONS.includes(action)) {
+    console.error(
+      `Error: Invalid action "${action}". Valid actions: ${VALID_ACTIONS.join(", ")}`
+    );
+    process.exit(1);
+  }
+  const isOfflineAction = OFFLINE_ACTIONS.includes(action);
+  const configPath = path24.join(process.cwd(), "specific.hcl");
+  let config;
+  let migrationsDir = "migrations";
+  let targetDb;
+  try {
+    if (fs26.existsSync(configPath)) {
+      const configContent = fs26.readFileSync(configPath, "utf-8");
+      config = await parseConfig(configContent);
+      if (databaseName) {
+        const postgresConfig = config.postgres.find((p) => p.name === databaseName);
+        if (postgresConfig?.reshape?.migrations_dir) {
+          migrationsDir = postgresConfig.reshape.migrations_dir;
+        }
+        targetDb = databaseName;
+      } else {
+        const reshapePostgres = config.postgres.find((p) => p.reshape?.enabled);
+        if (reshapePostgres) {
+          if (reshapePostgres.reshape?.migrations_dir) {
+            migrationsDir = reshapePostgres.reshape.migrations_dir;
+          }
+          targetDb = reshapePostgres.name;
+        } else if (config.postgres.length > 0) {
+          const first = config.postgres[0];
+          if (first.reshape?.migrations_dir) {
+            migrationsDir = first.reshape.migrations_dir;
+          }
+          targetDb = first.name;
+        }
+      }
+    }
+  } catch {
+  }
+  let dbUrl;
+  let startedResources = [];
+  let ownsInstances = false;
+  let stateManager = null;
+  const cleanup = async () => {
+    if (ownsInstances) {
+      for (const resource of startedResources) {
+        await resource.stop().catch(() => {
+        });
+      }
+      if (stateManager) {
+        await stateManager.releaseOwnership().catch(() => {
+        });
+      }
+    }
+  };
+  if (!isOfflineAction) {
+    stateManager = new InstanceStateManager(process.cwd(), instanceKey);
+    await stateManager.cleanStaleState();
+    const existingInstances = await stateManager.getExistingInstances();
+    if (existingInstances) {
+      const availableDatabases = Object.keys(existingInstances.databases).filter(
+        (name) => existingInstances.databases[name]?.engine === "postgres"
+      );
+      if (availableDatabases.length === 0) {
+        console.error("Error: No PostgreSQL databases found in running instances.");
+        process.exit(1);
+      }
+      if (databaseName) {
+        if (!existingInstances.databases[databaseName]) {
+          console.error(
+            `Error: Database "${databaseName}" not found. Available: ${availableDatabases.join(", ")}`
+          );
+          process.exit(1);
+        }
+        if (existingInstances.databases[databaseName]?.engine !== "postgres") {
+          console.error(
+            `Error: Database "${databaseName}" is not a PostgreSQL database.`
+          );
+          process.exit(1);
+        }
+        targetDb = databaseName;
+      } else {
+        if (availableDatabases.length > 1) {
+          console.error(
+            `Error: Multiple databases available. Specify one: ${availableDatabases.join(", ")}`
+          );
+          process.exit(1);
+        }
+        targetDb = availableDatabases[0];
+      }
+      dbUrl = existingInstances.databases[targetDb].url;
+    } else {
+      if (!config) {
+        console.error("Error: No specific.hcl found in current directory");
+        process.exit(1);
+      }
+      if (!targetDb) {
+        console.error("Error: No PostgreSQL database found in configuration.");
+        process.exit(1);
+      }
+      console.error("Starting resources...");
+      try {
+        await stateManager.claimOwnership("reshape");
+        ownsInstances = true;
+      } catch (err) {
+        console.error(
+          `Error: ${err instanceof Error ? err.message : String(err)}`
+        );
+        process.exit(1);
+      }
+      try {
+        const result = await startResources({
+          config,
+          selection: {
+            mode: "required",
+            postgres: [targetDb],
+            redis: [],
+            storage: []
+          },
+          stateManager,
+          dataDir: `.specific/keys/${instanceKey}/data`,
+          portAllocator: new PortAllocator(),
+          callbacks: {
+            log: (msg) => console.error(msg)
+          },
+          startElectric: false
+        });
+        startedResources = result.startedResources;
+        const resource = result.resources.get(targetDb);
+        if (!resource) {
+          console.error(`Error: Failed to start database "${targetDb}"`);
+          await cleanup();
+          process.exit(1);
+        }
+        dbUrl = resource.url;
+      } catch (err) {
+        console.error(
+          `Error: Failed to start resources: ${err instanceof Error ? err.message : String(err)}`
+        );
+        await cleanup();
+        process.exit(1);
+      }
+    }
+  }
+  const isMigrationSubcommand = MIGRATION_SUBCOMMANDS.includes(action);
+  const reshapeArgs = isMigrationSubcommand ? ["migration", action] : [action];
+  const fullMigrationsPath = path24.join(process.cwd(), migrationsDir);
+  if (action === "check" || action === "start") {
+    if (fs26.existsSync(fullMigrationsPath)) {
+      reshapeArgs.push("--dirs", fullMigrationsPath);
+    } else if (action === "check") {
+      console.error(`Error: Migrations directory not found: ${fullMigrationsPath}`);
+      await cleanup();
+      process.exit(1);
+    }
+  }
+  if (action === "status" && dbUrl) {
+    reshapeArgs.push("--url", dbUrl);
+  }
+  const binary = await ensureBinary(reshapeBinary);
+  const reshapePath = binary.executables["reshape"];
+  let child = null;
+  const handleSignal = async (signal) => {
+    if (child && !child.killed) {
+      child.kill(signal);
+    }
+    await cleanup();
+  };
+  process.on("SIGINT", () => handleSignal("SIGINT"));
+  process.on("SIGTERM", () => handleSignal("SIGTERM"));
+  child = spawn8(reshapePath, reshapeArgs, {
+    cwd: process.cwd(),
+    env: {
+      ...process.env,
+      // For migration subcommands, pass DB_URL via env
+      ...isMigrationSubcommand && dbUrl ? { DB_URL: dbUrl } : {}
+    },
+    stdio: "inherit"
+  });
+  child.on("exit", async (code, signal) => {
+    await cleanup();
+    if (signal) {
+      process.kill(process.pid, signal);
+    } else {
+      process.exit(code ?? 0);
+    }
+  });
+  child.on("error", async (err) => {
+    console.error(`Error: Failed to start reshape: ${err.message}`);
+    await cleanup();
+    process.exit(1);
+  });
+}
+
 // src/commands/clean.tsx
 import React8, { useState as useState7, useEffect as useEffect5 } from "react";
 import { render as render6, Text as Text8, Box as Box8 } from "ink";
 import Spinner6 from "ink-spinner";
-import * as fs25 from "fs";
-import * as path23 from "path";
+import * as fs27 from "fs";
+import * as path25 from "path";
 function CleanUI({ instanceKey }) {
   const [state, setState] = useState7({ status: "checking" });
   useEffect5(() => {
     async function clean() {
       const projectRoot = process.cwd();
-      const specificDir = path23.join(projectRoot, ".specific");
-      if (!fs25.existsSync(specificDir)) {
+      const specificDir = path25.join(projectRoot, ".specific");
+      if (!fs27.existsSync(specificDir)) {
         setState({ status: "nothing" });
         return;
       }
       if (instanceKey) {
-        const keyDir = path23.join(specificDir, "keys", instanceKey);
-        if (!fs25.existsSync(keyDir)) {
+        const keyDir = path25.join(specificDir, "keys", instanceKey);
+        if (!fs27.existsSync(keyDir)) {
           setState({ status: "nothing" });
           return;
         }
@@ -191966,7 +192761,7 @@ function CleanUI({ instanceKey }) {
         await stateManager.cleanStaleState();
         setState({ status: "cleaning" });
         try {
-          fs25.rmSync(keyDir, { recursive: true, force: true });
+          fs27.rmSync(keyDir, { recursive: true, force: true });
           setState({ status: "success" });
         } catch (err) {
           setState({
@@ -191975,21 +192770,23 @@ function CleanUI({ instanceKey }) {
           });
         }
       } else {
-        const keysDir = path23.join(specificDir, "keys");
-        if (fs25.existsSync(keysDir)) {
-          const keys = fs25.readdirSync(keysDir).filter(
-            (f) => fs25.statSync(path23.join(keysDir, f)).isDirectory()
-          );
-          for (const key of keys) {
-            const stateManager2 = new InstanceStateManager(projectRoot, key);
-            const existingInstances2 = await stateManager2.getExistingInstances();
-            if (existingInstances2) {
-              setState({
-                status: "error",
-                error: `Cannot clean while 'specific dev' is running for key "${key}" (PID ${existingInstances2.owner.pid}). Please stop it first.`
-              });
-              return;
-            }
+        const keysDir = path25.join(specificDir, "keys");
+        if (!fs27.existsSync(keysDir)) {
+          setState({ status: "nothing" });
+          return;
+        }
+        const keys = fs27.readdirSync(keysDir).filter(
+          (f) => fs27.statSync(path25.join(keysDir, f)).isDirectory()
+        );
+        for (const key of keys) {
+          const stateManager2 = new InstanceStateManager(projectRoot, key);
+          const existingInstances2 = await stateManager2.getExistingInstances();
+          if (existingInstances2) {
+            setState({
+              status: "error",
+              error: `Cannot clean while 'specific dev' is running for key "${key}" (PID ${existingInstances2.owner.pid}). Please stop it first.`
+            });
+            return;
           }
         }
         const stateManager = new InstanceStateManager(projectRoot);
@@ -192003,7 +192800,7 @@ function CleanUI({ instanceKey }) {
         }
         setState({ status: "cleaning" });
         try {
-          fs25.rmSync(specificDir, { recursive: true, force: true });
+          fs27.rmSync(keysDir, { recursive: true, force: true });
           setState({ status: "success" });
         } catch (err) {
           setState({
@@ -192019,16 +192816,16 @@ function CleanUI({ instanceKey }) {
     return /* @__PURE__ */ React8.createElement(Box8, null, /* @__PURE__ */ React8.createElement(Text8, { color: "blue" }, /* @__PURE__ */ React8.createElement(Spinner6, { type: "dots" })), /* @__PURE__ */ React8.createElement(Text8, null, " Checking for running instances..."));
   }
   if (state.status === "cleaning") {
-    return /* @__PURE__ */ React8.createElement(Box8, null, /* @__PURE__ */ React8.createElement(Text8, { color: "blue" }, /* @__PURE__ */ React8.createElement(Spinner6, { type: "dots" })), /* @__PURE__ */ React8.createElement(Text8, null, " Removing .specific directory..."));
+    return /* @__PURE__ */ React8.createElement(Box8, null, /* @__PURE__ */ React8.createElement(Text8, { color: "blue" }, /* @__PURE__ */ React8.createElement(Spinner6, { type: "dots" })), /* @__PURE__ */ React8.createElement(Text8, null, " Cleaning app data..."));
   }
   if (state.status === "error") {
     return /* @__PURE__ */ React8.createElement(Text8, { color: "red" }, "Error: ", state.error);
   }
   if (state.status === "nothing") {
-    const target2 = instanceKey ? `key "${instanceKey}"` : ".specific directory";
+    const target2 = instanceKey ? `key "${instanceKey}"` : "app data";
     return /* @__PURE__ */ React8.createElement(Text8, { color: "yellow" }, "Nothing to clean (", target2, " does not exist)");
   }
-  const target = instanceKey ? `key "${instanceKey}"` : ".specific directory";
+  const target = instanceKey ? `key "${instanceKey}"` : "app data";
   return /* @__PURE__ */ React8.createElement(Text8, { color: "green" }, "Cleaned ", target);
 }
 function cleanCommand(instanceKey) {
@@ -192086,11 +192883,87 @@ function logoutCommand() {
   render7(/* @__PURE__ */ React9.createElement(LogoutUI, null));
 }
 
+// src/commands/beta.tsx
+import React10, { useState as useState9, useEffect as useEffect7 } from "react";
+import { render as render8, Text as Text10, Box as Box9, useInput as useInput6, useApp as useApp5 } from "ink";
+function BetaToggleUI() {
+  const { exit } = useApp5();
+  const [enabled, setEnabled] = useState9(() => {
+    const current = loadEnabledBetas();
+    const state = {};
+    for (const beta of BETA_REGISTRY) {
+      state[beta.name] = current.includes(beta.name);
+    }
+    return state;
+  });
+  const [focusedIndex, setFocusedIndex] = useState9(0);
+  const [saved, setSaved] = useState9(false);
+  const isSubmitFocused = focusedIndex === BETA_REGISTRY.length;
+  useInput6((input, key) => {
+    if (saved) return;
+    if (key.upArrow || input === "k") {
+      setFocusedIndex((prev) => Math.max(0, prev - 1));
+    } else if (key.downArrow || input === "j") {
+      setFocusedIndex((prev) => Math.min(BETA_REGISTRY.length, prev + 1));
+    } else if (input === " " && !isSubmitFocused) {
+      const beta = BETA_REGISTRY[focusedIndex];
+      setEnabled((prev) => ({ ...prev, [beta.name]: !prev[beta.name] }));
+    } else if ((key.return || input === " ") && isSubmitFocused) {
+      for (const beta of BETA_REGISTRY) {
+        if (enabled[beta.name]) {
+          enableBeta(beta.name);
+        } else {
+          disableBeta(beta.name);
+        }
+      }
+      trackEvent("beta_toggled", {
+        enabled: Object.keys(enabled).filter((k) => enabled[k])
+      });
+      setSaved(true);
+    }
+  });
+  useEffect7(() => {
+    if (saved) {
+      const timer = setTimeout(() => exit(), 100);
+      return () => clearTimeout(timer);
+    }
+  }, [saved, exit]);
+  if (saved) {
+    const enabledNames = Object.keys(enabled).filter((k) => enabled[k]);
+    return /* @__PURE__ */ React10.createElement(Box9, { flexDirection: "column" }, /* @__PURE__ */ React10.createElement(Text10, null, /* @__PURE__ */ React10.createElement(Text10, { color: "green" }, "\u2713"), " Beta features updated"), enabledNames.length > 0 ? /* @__PURE__ */ React10.createElement(Text10, { dimColor: true }, " Enabled: ", enabledNames.join(", ")) : /* @__PURE__ */ React10.createElement(Text10, { dimColor: true }, " No betas enabled"));
+  }
+  return /* @__PURE__ */ React10.createElement(Box9, { flexDirection: "column" }, /* @__PURE__ */ React10.createElement(Text10, null, /* @__PURE__ */ React10.createElement(Text10, { dimColor: true }, "\u25CF"), " Configure beta features", " ", /* @__PURE__ */ React10.createElement(Text10, { dimColor: true }, "(space to select)")), /* @__PURE__ */ React10.createElement(Text10, null, " "), BETA_REGISTRY.map((beta, index) => {
+    const isFocused = focusedIndex === index;
+    const isChecked = enabled[beta.name];
+    return /* @__PURE__ */ React10.createElement(Box9, { key: beta.name }, /* @__PURE__ */ React10.createElement(Text10, { ...isFocused && { color: "cyan" } }, isFocused ? "\u276F " : "  ", isChecked ? "[\u2713]" : "[ ]", " ", beta.name, /* @__PURE__ */ React10.createElement(Text10, { dimColor: true }, " - ", beta.description)));
+  }), /* @__PURE__ */ React10.createElement(Text10, null, " "), /* @__PURE__ */ React10.createElement(Box9, null, /* @__PURE__ */ React10.createElement(Text10, { ...isSubmitFocused && { color: "cyan" } }, isSubmitFocused ? "\u276F " : "  ", /* @__PURE__ */ React10.createElement(
+    Text10,
+    {
+      inverse: isSubmitFocused,
+      ...!isSubmitFocused && { backgroundColor: "gray" }
+    },
+    " ",
+    "Save",
+    " "
+  ))));
+}
+function betaCommand() {
+  if (BETA_REGISTRY.length === 0) {
+    console.log("No beta features available.");
+    return;
+  }
+  if (!isInteractive()) {
+    console.error("Error: specific beta requires an interactive terminal.");
+    process.exit(1);
+  }
+  render8(/* @__PURE__ */ React10.createElement(BetaToggleUI, null));
+}
+
 // src/cli.tsx
 var program = new Command();
 var env = "production";
 var envLabel = env !== "production" ? `[${env.toUpperCase()}] ` : "";
-program.name("specific").description(`${envLabel}Infrastructure-as-code for coding agents`).version("0.1.49").enablePositionalOptions();
+program.name("specific").description(`${envLabel}Infrastructure-as-code for coding agents`).version("0.1.51").enablePositionalOptions();
 program.command("init").description("Initialize project for use with a coding agent").option("--agent <name...>", "Agents to configure (cursor, claude, codex, other)").action((options2) => initCommand(options2));
 program.command("docs [topic]").description("Fetch LLM-optimized documentation").action(docsCommand);
 program.command("check").description("Validate specific.hcl configuration").action(checkCommand);
@@ -192111,9 +192984,14 @@ program.command("psql [database] [args...]").description("Connect to a Postgres
   const key = options2.key ?? getDefaultKey();
   psqlCommand(database, key, filteredArgs);
 });
+program.command("reshape <action> [database]").description("Run Reshape migrations (start|complete|status|abort)").option("-k, --key <key>", "Dev environment namespace (auto-detected from git worktree if not specified)").action((action, database, options2) => {
+  const key = options2.key ?? getDefaultKey();
+  reshapeCommand(action, database, key);
+});
 program.command("clean").description("Remove .specific directory for a clean slate").option("-k, --key <key>", "Clean only the specified dev environment key").action((options2) => {
   cleanCommand(options2.key);
 });
+program.command("beta").description("Manage beta feature flags").action(betaCommand);
 program.command("login").description("Log in to Specific").action(loginCommand);
 program.command("logout").description("Log out of Specific").action(logoutCommand);
 var commandName = process.argv[2] || "help";