@specific.dev/cli 0.1.48 → 0.1.50

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 (path23) => {
-      if (/^[a-z]+:\/\//i.test(path23)) {
-        return path23;
+    convertWslPathToWindows = async (path26) => {
+      if (/^[a-z]+:\/\//i.test(path26)) {
+        return path26;
       }
       try {
-        const { stdout } = await execFile2("wslpath", ["-aw", path23], { encoding: "utf8" });
+        const { stdout } = await execFile2("wslpath", ["-aw", path26], { encoding: "utf8" });
         return stdout.trim();
       } catch {
-        return path23;
+        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((resolve9, reject) => {
           subprocess.once("error", reject);
           subprocess.once("close", (exitCode) => {
             if (!options2.allowNonzeroExitCode && exitCode !== 0) {
               reject(new Error(`Exited with code ${exitCode}`));
               return;
             }
-            resolve7(subprocess);
+            resolve9(subprocess);
           });
         });
       }
       if (isFallbackAttempt) {
-        return new Promise((resolve7, reject) => {
+        return new Promise((resolve9, 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);
+              resolve9(subprocess);
             });
           });
         });
       }
       subprocess.unref();
-      return new Promise((resolve7, reject) => {
+      return new Promise((resolve9, reject) => {
         subprocess.once("error", reject);
         subprocess.once("spawn", () => {
           subprocess.off("error", reject);
-          resolve7(subprocess);
+          resolve9(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 fs25 = $global.require("fs");
-        "object" == typeof fs25 && null !== fs25 && 0 !== Object.keys(fs25).length && ($global.fs = fs25);
+        var fs28 = $global.require("fs");
+        "object" == typeof fs28 && null !== fs28 && 0 !== Object.keys(fs28).length && ($global.fs = fs28);
       } catch (e) {
       }
       if (!$global.fs) {
@@ -183055,13 +183055,13 @@ function removeCA() {
   }
 }
 function installCAToTrustStore(certPath) {
-  const platform5 = os.platform();
-  if (platform5 === "darwin") {
+  const platform4 = os.platform();
+  if (platform4 === "darwin") {
     execSync(
       `sudo security add-trusted-cert -d -r trustRoot -k /Library/Keychains/System.keychain "${certPath}"`,
       { stdio: "inherit" }
     );
-  } else if (platform5 === "linux") {
+  } else if (platform4 === "linux") {
     if (fs.existsSync("/usr/local/share/ca-certificates")) {
       execSync(
         `sudo cp "${certPath}" /usr/local/share/ca-certificates/specific-local-ca.crt`,
@@ -183078,7 +183078,7 @@ function installCAToTrustStore(certPath) {
       throw new Error("Could not detect Linux certificate trust mechanism");
     }
   } else {
-    throw new Error(`Unsupported platform: ${platform5}`);
+    throw new Error(`Unsupported platform: ${platform4}`);
   }
 }
 function generateCertificate(domain, keys = []) {
@@ -183682,7 +183682,7 @@ async function pollUntilToken(deviceAuth, isCancelled) {
   return null;
 }
 function sleep(ms) {
-  return new Promise((resolve7) => setTimeout(resolve7, ms));
+  return new Promise((resolve9) => setTimeout(resolve9, 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((resolve9) => {
     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 });
+            resolve9({ 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) });
+            resolve9({ success: false, error: new Error(newState.message) });
           }, 100);
         }
       }
@@ -183873,7 +183873,7 @@ function trackEvent(event, properties) {
     event,
     properties: {
       ...properties,
-      cli_version: "0.1.48",
+      cli_version: "0.1.50",
       platform: process.platform,
       node_version: process.version,
       project_id: getProjectId(),
@@ -183888,6 +183888,11 @@ async function shutdown() {
   }
 }
 
+// src/lib/ui/interactive.ts
+function isInteractive() {
+  return process.stdin.isTTY === true && process.stdout.isTTY === true;
+}
+
 // src/commands/init.tsx
 var SPECIFIC_INSTRUCTIONS = `Use Specific to handle all infrastructure and development environments: like deployments, databases, real-time sync, services, secrets, configuration and environment variables. Run \`specific docs\` to learn how to use Specific. ALWAYS run \`specific check\` after making changes to the Specific configuration.`;
 var CURSOR_MDC_CONTENT = `---
@@ -184156,40 +184161,169 @@ function InitUI() {
     " "
   ))));
 }
-function initCommand() {
-  render2(/* @__PURE__ */ React2.createElement(InitUI, null));
+var VALID_AGENT_IDS = options.map((o) => o.id);
+function initCommand(opts) {
+  if (isInteractive()) {
+    render2(/* @__PURE__ */ React2.createElement(InitUI, null));
+    return;
+  }
+  if (!opts.agent || opts.agent.length === 0) {
+    console.error(
+      `Error: --agent is required in non-interactive environments.
+Usage: specific init --agent cursor claude codex
+Valid agents: ${VALID_AGENT_IDS.join(", ")}`
+    );
+    process.exit(1);
+  }
+  const invalid = opts.agent.filter((a) => !VALID_AGENT_IDS.includes(a));
+  if (invalid.length > 0) {
+    console.error(
+      `Error: Unknown agent(s): ${invalid.join(", ")}
+Valid agents: ${VALID_AGENT_IDS.join(", ")}`
+    );
+    process.exit(1);
+  }
+  const checked = {};
+  for (const agent of opts.agent) {
+    checked[agent] = true;
+  }
+  const result = configureAgents(checked);
+  trackEvent("project_initialized", {
+    agents: opts.agent
+  });
+  const selectedAgents = opts.agent.length;
+  const agentChanges = result.agents.filesCreated.length > 0 || result.agents.filesModified.length > 0;
+  console.log("\u2713 Coding agents configured");
+  if (result.agents.filesCreated.length > 0) {
+    console.log(`  Created: ${result.agents.filesCreated.join(", ")}`);
+  }
+  if (result.agents.filesModified.length > 0) {
+    console.log(`  Modified: ${result.agents.filesModified.join(", ")}`);
+  }
+  if (!agentChanges && selectedAgents > 0) {
+    console.log("  No changes needed (files already configured)");
+  }
+  if (result.git) {
+    const gitChanges = result.git.filesCreated.length > 0 || result.git.filesModified.length > 0;
+    console.log("\u2713 Git configured");
+    if (result.git.filesCreated.length > 0) {
+      console.log(`  Created: ${result.git.filesCreated.join(", ")}`);
+    }
+    if (result.git.filesModified.length > 0) {
+      console.log(`  Modified: ${result.git.filesModified.join(", ")}`);
+    }
+    if (!gitChanges) {
+      console.log("  No changes needed (.gitignore already configured)");
+    }
+  }
+  if (!caFilesExist()) {
+    console.log(
+      "\u26A0 TLS certificates not installed (run `specific init` in a terminal to set up)"
+    );
+  }
+  if (result.showManualInstructions) {
+    console.log("\n\u2713 Manual configuration selected");
+    console.log("\n  Add this to your agent's system prompt:");
+    console.log("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+    console.log(`  ${SPECIFIC_INSTRUCTIONS}`);
+    console.log("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+    console.log(
+      "\n  We also recommend allowing your agent to run `specific docs *`"
+    );
+    console.log("  and `specific check *` without confirmation.");
+  }
 }
 
 // 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(path23) {
-  const docPath = resolveDocPath(path23);
+var docsDir = join7(__dirname2, "docs");
+function docsCommand(path26) {
+  const docPath = resolveDocPath(path26);
   if (!docPath) {
     console.error(
-      `Documentation not found: ${path23 || "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(path23) {
-  if (!path23) {
-    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, `${path23}.md`);
-  if (existsSync5(directPath)) {
+  const directPath = join7(docsDir, `${path26}.md`);
+  if (existsSync6(directPath)) {
     return directPath;
   }
-  const indexPath = join6(docsDir, path23, "index.md");
-  if (existsSync5(indexPath)) {
+  const indexPath = join7(docsDir, path26, "index.md");
+  if (existsSync6(indexPath)) {
     return indexPath;
   }
   return null;
@@ -184199,8 +184333,9 @@ function resolveDocPath(path23) {
 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);
@@ -184283,7 +184418,7 @@ function parseReferenceString(str) {
       attribute: "port"
     };
   }
-  const serviceEndpointMatch = str.match(/^service\.(\w+)\.endpoint\.(\w+)\.(url|host|port)$/);
+  const serviceEndpointMatch = str.match(/^service\.(\w+)\.endpoint\.(\w+)\.(url|private_url|host|port|public_url)$/);
   if (serviceEndpointMatch && serviceEndpointMatch[1] && serviceEndpointMatch[2] && serviceEndpointMatch[3]) {
     return {
       type: "service",
@@ -184292,7 +184427,7 @@ function parseReferenceString(str) {
       attribute: serviceEndpointMatch[3]
     };
   }
-  const serviceMatch = str.match(/^service\.(\w+)\.(url|host|port)$/);
+  const serviceMatch = str.match(/^service\.(\w+)\.(url|private_url|host|port|public_url)$/);
   if (serviceMatch && serviceMatch[1] && serviceMatch[2]) {
     return {
       type: "service",
@@ -184397,6 +184532,17 @@ function parseBuilds(buildData) {
     if (dev) {
       build.dev = dev;
     }
+    const env2 = parseEnv(fieldObj.env);
+    if (env2) {
+      for (const [key, value] of Object.entries(env2)) {
+        if (typeof value === "string")
+          continue;
+        if (value.type === "service" && value.attribute === "public_url")
+          continue;
+        throw new Error(`Build "${name}" env var "${key}" uses an unsupported reference type. Build env vars only support string literals and \${service.<name>.public_url} references.`);
+      }
+      build.env = env2;
+    }
     builds.push(build);
   }
   return builds;
@@ -184504,13 +184650,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;
 }
@@ -184704,6 +184880,26 @@ function validateEndpointReferences(config) {
               });
             }
           }
+          if (serviceRef.attribute === "public_url") {
+            const endpointName = serviceRef.endpointName;
+            if (endpointName) {
+              const targetEndpoint = targetEndpoints.find((e) => e.name === endpointName);
+              if (targetEndpoint && !targetEndpoint.public) {
+                errors.push({
+                  service: service.name,
+                  message: `Service "${service.name}" references public_url of endpoint "${endpointName}" on service "${serviceRef.serviceName}" in env var "${key}", but that endpoint is not public. Add \`public = true\` to the endpoint.`
+                });
+              }
+            } else {
+              const defaultEndpoint = targetEndpoints.length === 1 ? targetEndpoints[0] : targetEndpoints.find((e) => e.name === "default");
+              if (defaultEndpoint && !defaultEndpoint.public) {
+                errors.push({
+                  service: service.name,
+                  message: `Service "${service.name}" references public_url of service "${serviceRef.serviceName}" in env var "${key}", but its endpoint is not public. Add \`public = true\` to the endpoint.`
+                });
+              }
+            }
+          }
         }
         if (typeof value === "object" && value.type === "endpoint") {
           const endpointRef = value;
@@ -184721,13 +184917,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((resolve9, reject) => {
+      fileStream.end((err) => {
+        if (err) reject(err);
+        else resolve9();
+      });
+    });
+    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.0"],
+  // 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((resolve9) => {
+      execFile7(reshapePath, ["check", "--dirs", migrationsDir], (err, _stdout, stderr) => {
+        if (err) {
+          const errorMsg = stderr.trim() || err.message;
+          resolve9({ success: false, error: errorMsg });
+        } else {
+          resolve9({ 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"
@@ -184735,9 +185292,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",
@@ -184757,7 +185341,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));
@@ -184767,8 +185354,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";
@@ -184860,7 +185447,7 @@ var ReaddirpStream = class extends Readable {
     this._directoryFilter = normalizeFilter(opts.directoryFilter);
     const statMethod = opts.lstat ? lstat : stat;
     if (wantBigintFsStats) {
-      this._stat = (path23) => statMethod(path23, { bigint: true });
+      this._stat = (path26) => statMethod(path26, { bigint: true });
     } else {
       this._stat = statMethod;
     }
@@ -184885,8 +185472,8 @@ var ReaddirpStream = class extends Readable {
         const par = this.parent;
         const fil = par && par.files;
         if (fil && fil.length > 0) {
-          const { path: path23, depth } = par;
-          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path23));
+          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)
@@ -184926,21 +185513,21 @@ var ReaddirpStream = class extends Readable {
       this.reading = false;
     }
   }
-  async _exploreDir(path23, depth) {
+  async _exploreDir(path26, depth) {
     let files;
     try {
-      files = await readdir(path23, this._rdOptions);
+      files = await readdir(path26, this._rdOptions);
     } catch (error) {
       this._onError(error);
     }
-    return { files, depth, path: path23 };
+    return { files, depth, path: path26 };
   }
-  async _formatEntry(dirent, path23) {
+  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(path23, 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);
@@ -185339,16 +185926,16 @@ var delFromSet = (main, prop, item) => {
 };
 var isEmptySet = (val) => val instanceof Set ? val.size === 0 : !val;
 var FsWatchInstances = /* @__PURE__ */ new Map();
-function createFsWatchInstance(path23, options2, listener, errHandler, emitRaw) {
+function createFsWatchInstance(path26, options2, listener, errHandler, emitRaw) {
   const handleEvent = (rawEvent, evPath) => {
-    listener(path23);
-    emitRaw(rawEvent, evPath, { watchedPath: path23 });
-    if (evPath && path23 !== evPath) {
-      fsWatchBroadcast(sp.resolve(path23, evPath), KEY_LISTENERS, sp.join(path23, 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(path23, {
+    return fs_watch(path26, {
       persistent: options2.persistent
     }, handleEvent);
   } catch (error) {
@@ -185364,12 +185951,12 @@ var fsWatchBroadcast = (fullPath, listenerType, val1, val2, val3) => {
     listener(val1, val2, val3);
   });
 };
-var setFsWatchListener = (path23, 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(path23, options2, listener, errHandler, rawEmitter);
+    watcher = createFsWatchInstance(path26, options2, listener, errHandler, rawEmitter);
     if (!watcher)
       return;
     return watcher.close.bind(watcher);
@@ -185380,7 +185967,7 @@ var setFsWatchListener = (path23, fullPath, options2, handlers) => {
     addAndConvert(cont, KEY_RAW, rawEmitter);
   } else {
     watcher = createFsWatchInstance(
-      path23,
+      path26,
       options2,
       fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS),
       errHandler,
@@ -185395,7 +185982,7 @@ var setFsWatchListener = (path23, fullPath, options2, handlers) => {
         cont.watcherUnusable = true;
       if (isWindows && error.code === "EPERM") {
         try {
-          const fd = await open2(path23, "r");
+          const fd = await open2(path26, "r");
           await fd.close();
           broadcastErr(error);
         } catch (err) {
@@ -185426,7 +186013,7 @@ var setFsWatchListener = (path23, fullPath, options2, handlers) => {
   };
 };
 var FsWatchFileInstances = /* @__PURE__ */ new Map();
-var setFsWatchFileListener = (path23, fullPath, options2, handlers) => {
+var setFsWatchFileListener = (path26, fullPath, options2, handlers) => {
   const { listener, rawEmitter } = handlers;
   let cont = FsWatchFileInstances.get(fullPath);
   const copts = cont && cont.options;
@@ -185448,7 +186035,7 @@ var setFsWatchFileListener = (path23, fullPath, options2, handlers) => {
         });
         const currmtime = curr.mtimeMs;
         if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
-          foreach(cont.listeners, (listener2) => listener2(path23, curr));
+          foreach(cont.listeners, (listener2) => listener2(path26, curr));
         }
       })
     };
@@ -185478,13 +186065,13 @@ var NodeFsHandler = class {
    * @param listener on fs change
    * @returns closer for the watcher instance
    */
-  _watchWithNodeFs(path23, listener) {
+  _watchWithNodeFs(path26, listener) {
     const opts = this.fsw.options;
-    const directory = sp.dirname(path23);
-    const basename5 = sp.basename(path23);
+    const directory = sp.dirname(path26);
+    const basename6 = sp.basename(path26);
     const parent = this.fsw._getWatchedDir(directory);
-    parent.add(basename5);
-    const absolutePath = sp.resolve(path23);
+    parent.add(basename6);
+    const absolutePath = sp.resolve(path26);
     const options2 = {
       persistent: opts.persistent
     };
@@ -185493,13 +186080,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(path23, absolutePath, options2, {
+      options2.interval = enableBin && isBinaryPath(basename6) ? opts.binaryInterval : opts.interval;
+      closer = setFsWatchFileListener(path26, absolutePath, options2, {
         listener,
         rawEmitter: this.fsw._emitRaw
       });
     } else {
-      closer = setFsWatchListener(path23, absolutePath, options2, {
+      closer = setFsWatchListener(path26, absolutePath, options2, {
         listener,
         errHandler: this._boundHandleError,
         rawEmitter: this.fsw._emitRaw
@@ -185516,12 +186103,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 (path23, newStats) => {
+    const listener = async (path26, newStats) => {
       if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5))
         return;
       if (!newStats || newStats.mtimeMs === 0) {
@@ -185535,18 +186122,18 @@ var NodeFsHandler = class {
             this.fsw._emit(EV.CHANGE, file, newStats2);
           }
           if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats2.ino) {
-            this.fsw._closeFile(path23);
+            this.fsw._closeFile(path26);
             prevStats = newStats2;
             const closer2 = this._watchWithNodeFs(file, listener);
             if (closer2)
-              this.fsw._addPathCloser(path23, 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) {
@@ -185571,7 +186158,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, path23, item) {
+  async _handleSymlink(entry, directory, path26, item) {
     if (this.fsw.closed) {
       return;
     }
@@ -185581,7 +186168,7 @@ var NodeFsHandler = class {
       this.fsw._incrReadyCount();
       let linkPath;
       try {
-        linkPath = await fsrealpath(path23);
+        linkPath = await fsrealpath(path26);
       } catch (e) {
         this.fsw._emitReady();
         return true;
@@ -185591,12 +186178,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, path23, 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, path23, entry.stats);
+        this.fsw._emit(EV.ADD, path26, entry.stats);
       }
       this.fsw._emitReady();
       return true;
@@ -185626,9 +186213,9 @@ var NodeFsHandler = class {
         return;
       }
       const item = entry.path;
-      let path23 = sp.join(directory, item);
+      let path26 = sp.join(directory, item);
       current.add(item);
-      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path23, item)) {
+      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path26, item)) {
         return;
       }
       if (this.fsw.closed) {
@@ -185637,11 +186224,11 @@ var NodeFsHandler = class {
       }
       if (item === target || !target && !previous.has(item)) {
         this.fsw._incrReadyCount();
-        path23 = sp.join(dir, sp.relative(dir, path23));
-        this._addToNodeFs(path23, 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((resolve9, reject) => {
       if (!stream)
         return reject();
       stream.once(STR_END, () => {
@@ -185650,7 +186237,7 @@ var NodeFsHandler = class {
           return;
         }
         const wasThrottled = throttler ? throttler.clear() : false;
-        resolve7(void 0);
+        resolve9(void 0);
         previous.getChildren().filter((item) => {
           return item !== directory && !current.has(item);
         }).forEach((item) => {
@@ -185707,13 +186294,13 @@ var NodeFsHandler = class {
    * @param depth Child path actually targeted for watch
    * @param target Child path actually targeted for watch
    */
-  async _addToNodeFs(path23, initialAdd, priorWh, depth, target) {
+  async _addToNodeFs(path26, initialAdd, priorWh, depth, target) {
     const ready = this.fsw._emitReady;
-    if (this.fsw._isIgnored(path23) || this.fsw.closed) {
+    if (this.fsw._isIgnored(path26) || this.fsw.closed) {
       ready();
       return false;
     }
-    const wh = this.fsw._getWatchHelpers(path23);
+    const wh = this.fsw._getWatchHelpers(path26);
     if (priorWh) {
       wh.filterPath = (entry) => priorWh.filterPath(entry);
       wh.filterDir = (entry) => priorWh.filterDir(entry);
@@ -185729,8 +186316,8 @@ var NodeFsHandler = class {
       const follow = this.fsw.options.followSymlinks;
       let closer;
       if (stats.isDirectory()) {
-        const absPath = sp.resolve(path23);
-        const targetPath = follow ? await fsrealpath(path23) : path23;
+        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);
@@ -185740,29 +186327,29 @@ var NodeFsHandler = class {
           this.fsw._symlinkPaths.set(absPath, targetPath);
         }
       } else if (stats.isSymbolicLink()) {
-        const targetPath = follow ? await fsrealpath(path23) : path23;
+        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, path23, 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(path23), targetPath);
+          this.fsw._symlinkPaths.set(sp.resolve(path26), targetPath);
         }
       } else {
         closer = this._handleFile(wh.watchPath, stats, initialAdd);
       }
       ready();
       if (closer)
-        this.fsw._addPathCloser(path23, closer);
+        this.fsw._addPathCloser(path26, closer);
       return false;
     } catch (error) {
       if (this.fsw._handleError(error)) {
         ready();
-        return path23;
+        return path26;
       }
     }
   }
@@ -185805,24 +186392,24 @@ function createPattern(matcher) {
   }
   return () => false;
 }
-function normalizePath(path23) {
-  if (typeof path23 !== "string")
+function normalizePath(path26) {
+  if (typeof path26 !== "string")
     throw new Error("string expected");
-  path23 = sp2.normalize(path23);
-  path23 = path23.replace(/\\/g, "/");
+  path26 = sp2.normalize(path26);
+  path26 = path26.replace(/\\/g, "/");
   let prepend = false;
-  if (path23.startsWith("//"))
+  if (path26.startsWith("//"))
     prepend = true;
-  path23 = path23.replace(DOUBLE_SLASH_RE, "/");
+  path26 = path26.replace(DOUBLE_SLASH_RE, "/");
   if (prepend)
-    path23 = "/" + path23;
-  return path23;
+    path26 = "/" + path26;
+  return path26;
 }
 function matchPatterns(patterns, testString, stats) {
-  const path23 = normalizePath(testString);
+  const path26 = normalizePath(testString);
   for (let index = 0; index < patterns.length; index++) {
     const pattern = patterns[index];
-    if (pattern(path23, stats)) {
+    if (pattern(path26, stats)) {
       return true;
     }
   }
@@ -185860,19 +186447,19 @@ var toUnix = (string) => {
   }
   return str;
 };
-var normalizePathToUnix = (path23) => toUnix(sp2.normalize(toUnix(path23)));
-var normalizeIgnored = (cwd = "") => (path23) => {
-  if (typeof path23 === "string") {
-    return normalizePathToUnix(sp2.isAbsolute(path23) ? path23 : sp2.join(cwd, path23));
+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 path23;
+    return path26;
   }
 };
-var getAbsolutePath = (path23, cwd) => {
-  if (sp2.isAbsolute(path23)) {
-    return path23;
+var getAbsolutePath = (path26, cwd) => {
+  if (sp2.isAbsolute(path26)) {
+    return path26;
   }
-  return sp2.join(cwd, path23);
+  return sp2.join(cwd, path26);
 };
 var EMPTY_SET = Object.freeze(/* @__PURE__ */ new Set());
 var DirEntry = class {
@@ -185937,10 +186524,10 @@ var WatchHelper = class {
   dirParts;
   followSymlinks;
   statMethod;
-  constructor(path23, follow, fsw) {
+  constructor(path26, follow, fsw) {
     this.fsw = fsw;
-    const watchPath = path23;
-    this.path = path23 = path23.replace(REPLACER_RE, "");
+    const watchPath = path26;
+    this.path = path26 = path26.replace(REPLACER_RE, "");
     this.watchPath = watchPath;
     this.fullWatchPath = sp2.resolve(watchPath);
     this.dirParts = [];
@@ -186080,20 +186667,20 @@ var FSWatcher = class extends EventEmitter {
     this._closePromise = void 0;
     let paths = unifyPaths(paths_);
     if (cwd) {
-      paths = paths.map((path23) => {
-        const absPath = getAbsolutePath(path23, cwd);
+      paths = paths.map((path26) => {
+        const absPath = getAbsolutePath(path26, cwd);
         return absPath;
       });
     }
-    paths.forEach((path23) => {
-      this._removeIgnoredPath(path23);
+    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 (path23) => {
-      const res = await this._nodeFsHandler._addToNodeFs(path23, !_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;
@@ -186115,17 +186702,17 @@ var FSWatcher = class extends EventEmitter {
       return this;
     const paths = unifyPaths(paths_);
     const { cwd } = this.options;
-    paths.forEach((path23) => {
-      if (!sp2.isAbsolute(path23) && !this._closers.has(path23)) {
+    paths.forEach((path26) => {
+      if (!sp2.isAbsolute(path26) && !this._closers.has(path26)) {
         if (cwd)
-          path23 = sp2.join(cwd, path23);
-        path23 = sp2.resolve(path23);
+          path26 = sp2.join(cwd, path26);
+        path26 = sp2.resolve(path26);
       }
-      this._closePath(path23);
-      this._addIgnoredPath(path23);
-      if (this._watched.has(path23)) {
+      this._closePath(path26);
+      this._addIgnoredPath(path26);
+      if (this._watched.has(path26)) {
         this._addIgnoredPath({
-          path: path23,
+          path: path26,
           recursive: true
         });
       }
@@ -186189,38 +186776,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, path23, stats) {
+  async _emit(event, path26, stats) {
     if (this.closed)
       return;
     const opts = this.options;
     if (isWindows)
-      path23 = sp2.normalize(path23);
+      path26 = sp2.normalize(path26);
     if (opts.cwd)
-      path23 = sp2.relative(opts.cwd, path23);
-    const args = [path23];
+      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(path23))) {
+    if (awf && (pw = this._pendingWrites.get(path26))) {
       pw.lastChange = /* @__PURE__ */ new Date();
       return this;
     }
     if (opts.atomic) {
       if (event === EVENTS.UNLINK) {
-        this._pendingUnlinks.set(path23, [event, ...args]);
+        this._pendingUnlinks.set(path26, [event, ...args]);
         setTimeout(() => {
-          this._pendingUnlinks.forEach((entry, path24) => {
+          this._pendingUnlinks.forEach((entry, path27) => {
             this.emit(...entry);
             this.emit(EVENTS.ALL, ...entry);
-            this._pendingUnlinks.delete(path24);
+            this._pendingUnlinks.delete(path27);
           });
         }, typeof opts.atomic === "number" ? opts.atomic : 100);
         return this;
       }
-      if (event === EVENTS.ADD && this._pendingUnlinks.has(path23)) {
+      if (event === EVENTS.ADD && this._pendingUnlinks.has(path26)) {
         event = EVENTS.CHANGE;
-        this._pendingUnlinks.delete(path23);
+        this._pendingUnlinks.delete(path26);
       }
     }
     if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
@@ -186238,16 +186825,16 @@ var FSWatcher = class extends EventEmitter {
           this.emitWithAll(event, args);
         }
       };
-      this._awaitWriteFinish(path23, awf.stabilityThreshold, event, awfEmit);
+      this._awaitWriteFinish(path26, awf.stabilityThreshold, event, awfEmit);
       return this;
     }
     if (event === EVENTS.CHANGE) {
-      const isThrottled = !this._throttle(EVENTS.CHANGE, path23, 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, path23) : path23;
+      const fullPath = opts.cwd ? sp2.join(opts.cwd, path26) : path26;
       let stats2;
       try {
         stats2 = await stat3(fullPath);
@@ -186278,23 +186865,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, path23, 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(path23);
+    const actionPath = action.get(path26);
     if (actionPath) {
       actionPath.count++;
       return false;
     }
     let timeoutObject;
     const clear = () => {
-      const item = action.get(path23);
+      const item = action.get(path26);
       const count = item ? item.count : 0;
-      action.delete(path23);
+      action.delete(path26);
       clearTimeout(timeoutObject);
       if (item)
         clearTimeout(item.timeoutObject);
@@ -186302,7 +186889,7 @@ var FSWatcher = class extends EventEmitter {
     };
     timeoutObject = setTimeout(clear, timeout);
     const thr = { timeoutObject, clear, count: 0 };
-    action.set(path23, thr);
+    action.set(path26, thr);
     return thr;
   }
   _incrReadyCount() {
@@ -186316,44 +186903,44 @@ var FSWatcher = class extends EventEmitter {
    * @param event
    * @param awfEmit Callback to be called when ready for event to be emitted.
    */
-  _awaitWriteFinish(path23, 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 = path23;
-    if (this.options.cwd && !sp2.isAbsolute(path23)) {
-      fullPath = sp2.join(this.options.cwd, path23);
+    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(path23)) {
+        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(path23).lastChange = now2;
+          writes.get(path26).lastChange = now2;
         }
-        const pw = writes.get(path23);
+        const pw = writes.get(path26);
         const df = now2 - pw.lastChange;
         if (df >= threshold) {
-          writes.delete(path23);
+          writes.delete(path26);
           awfEmit(void 0, curStat);
         } else {
           timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
         }
       });
     }
-    if (!writes.has(path23)) {
-      writes.set(path23, {
+    if (!writes.has(path26)) {
+      writes.set(path26, {
         lastChange: now,
         cancelWait: () => {
-          writes.delete(path23);
+          writes.delete(path26);
           clearTimeout(timeoutHandler);
           return event;
         }
@@ -186364,8 +186951,8 @@ var FSWatcher = class extends EventEmitter {
   /**
    * Determines whether user has asked to ignore this path.
    */
-  _isIgnored(path23, stats) {
-    if (this.options.atomic && DOT_RE.test(path23))
+  _isIgnored(path26, stats) {
+    if (this.options.atomic && DOT_RE.test(path26))
       return true;
     if (!this._userIgnored) {
       const { cwd } = this.options;
@@ -186375,17 +186962,17 @@ var FSWatcher = class extends EventEmitter {
       const list = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored];
       this._userIgnored = anymatch(list, void 0);
     }
-    return this._userIgnored(path23, stats);
+    return this._userIgnored(path26, stats);
   }
-  _isntIgnored(path23, stat4) {
-    return !this._isIgnored(path23, 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(path23) {
-    return new WatchHelper(path23, this.options.followSymlinks, this);
+  _getWatchHelpers(path26) {
+    return new WatchHelper(path26, this.options.followSymlinks, this);
   }
   // Directory helpers
   // -----------------
@@ -186417,63 +187004,63 @@ var FSWatcher = class extends EventEmitter {
    * @param item      base path of item/directory
    */
   _remove(directory, item, isDirectory) {
-    const path23 = sp2.join(directory, item);
-    const fullPath = sp2.resolve(path23);
-    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path23) || this._watched.has(fullPath);
-    if (!this._throttle("remove", path23, 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(path23);
+    const wp = this._getWatchedDir(path26);
     const nestedDirectoryChildren = wp.getChildren();
-    nestedDirectoryChildren.forEach((nested) => this._remove(path23, 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 = path23;
+    let relPath = path26;
     if (this.options.cwd)
-      relPath = sp2.relative(this.options.cwd, path23);
+      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(path23);
+    this._watched.delete(path26);
     this._watched.delete(fullPath);
     const eventName = isDirectory ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
-    if (wasTracked && !this._isIgnored(path23))
-      this._emit(eventName, path23);
-    this._closePath(path23);
+    if (wasTracked && !this._isIgnored(path26))
+      this._emit(eventName, path26);
+    this._closePath(path26);
   }
   /**
    * Closes all watchers for a path
    */
-  _closePath(path23) {
-    this._closeFile(path23);
-    const dir = sp2.dirname(path23);
-    this._getWatchedDir(dir).remove(sp2.basename(path23));
+  _closePath(path26) {
+    this._closeFile(path26);
+    const dir = sp2.dirname(path26);
+    this._getWatchedDir(dir).remove(sp2.basename(path26));
   }
   /**
    * Closes only file-specific watchers
    */
-  _closeFile(path23) {
-    const closers = this._closers.get(path23);
+  _closeFile(path26) {
+    const closers = this._closers.get(path26);
     if (!closers)
       return;
     closers.forEach((closer) => closer());
-    this._closers.delete(path23);
+    this._closers.delete(path26);
   }
-  _addPathCloser(path23, closer) {
+  _addPathCloser(path26, closer) {
     if (!closer)
       return;
-    let list = this._closers.get(path23);
+    let list = this._closers.get(path26);
     if (!list) {
       list = [];
-      this._closers.set(path23, list);
+      this._closers.set(path26, list);
     }
     list.push(closer);
   }
@@ -186522,8 +187109,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 {
@@ -186532,16 +187119,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;
@@ -186554,14 +187141,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;
@@ -186591,331 +187178,7 @@ var StablePortAllocator = class {
 import * as fs14 from "fs";
 import * as path10 from "path";
 import * as net from "net";
-import * as os7 from "os";
 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 getBinBaseDir() {
-  return path9.join(os6.homedir(), ".specific", "bin");
-}
-function getPlatformInfo() {
-  const platform5 = os6.platform();
-  const arch3 = os6.arch();
-  if (platform5 !== "darwin" && platform5 !== "linux") {
-    throw new Error(
-      `Unsupported platform: ${platform5}. 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: platform5, 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"],
-  // 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
-function getLibraryEnv(binary) {
-  if (!binary.libraryPath) {
-    return {};
-  }
-  const platform5 = os7.platform();
-  if (platform5 === "darwin") {
-    return { DYLD_LIBRARY_PATH: binary.libraryPath };
-  } else if (platform5 === "linux") {
-    return { LD_LIBRARY_PATH: binary.libraryPath };
-  }
-  return {};
-}
 async function startPostgres(pg, port, dataDir, onProgress) {
   const binary = await ensureBinary(postgresBinary, void 0, onProgress);
   const dbDataPath = path10.join(process.cwd(), dataDir, pg.name);
@@ -187038,7 +187301,7 @@ async function startStorage(storage, port, dataDir) {
   };
 }
 async function runCommand(command, args, env2) {
-  return new Promise((resolve7, reject) => {
+  return new Promise((resolve9, reject) => {
     const proc = spawn(command, args, {
       stdio: ["ignore", "pipe", "pipe"],
       env: env2
@@ -187049,7 +187312,7 @@ async function runCommand(command, args, env2) {
     });
     proc.on("close", (code) => {
       if (code === 0) {
-        resolve7();
+        resolve9();
       } else {
         reject(new Error(`Command failed with code ${code}: ${stderr}`));
       }
@@ -187058,7 +187321,7 @@ async function runCommand(command, args, env2) {
   });
 }
 async function createPostgresDatabase(postgresPath, dataDir, dbName, env2) {
-  return new Promise((resolve7, reject) => {
+  return new Promise((resolve9, reject) => {
     const proc = spawn(
       postgresPath,
       ["--single", "-D", dataDir, "postgres"],
@@ -187072,7 +187335,7 @@ async function createPostgresDatabase(postgresPath, dataDir, dbName, env2) {
       stderr += data.toString();
     });
     proc.on("close", (code) => {
-      resolve7();
+      resolve9();
     });
     proc.on("error", reject);
     proc.stdin?.write(`CREATE DATABASE "${dbName}";
@@ -187092,33 +187355,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((resolve9) => {
     const socket = new net.Socket();
     socket.setTimeout(1e3);
     socket.on("connect", () => {
       socket.destroy();
-      resolve7(true);
+      resolve9(true);
     });
     socket.on("timeout", () => {
       socket.destroy();
-      resolve7(false);
+      resolve9(false);
     });
     socket.on("error", () => {
       socket.destroy();
-      resolve7(false);
+      resolve9(false);
     });
     socket.connect(port, host);
   });
 }
 async function stopProcess(proc) {
-  return new Promise((resolve7) => {
+  return new Promise((resolve9) => {
     if (proc.killed || proc.exitCode !== null) {
-      resolve7();
+      resolve9();
       return;
     }
     proc.once("exit", () => {
       clearTimeout(forceKillTimeout);
-      resolve7();
+      resolve9();
     });
     proc.kill("SIGTERM");
     const forceKillTimeout = setTimeout(() => {
@@ -187129,7 +187392,7 @@ async function stopProcess(proc) {
   });
 }
 function sleep2(ms) {
-  return new Promise((resolve7) => setTimeout(resolve7, ms));
+  return new Promise((resolve9) => setTimeout(resolve9, ms));
 }
 
 // src/lib/dev/service-runner.ts
@@ -187138,7 +187401,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
@@ -187179,7 +187442,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");
@@ -187219,7 +187482,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;
@@ -187229,7 +187492,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;
@@ -187238,6 +187501,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) {
@@ -187271,7 +187541,7 @@ config {
     this.name = "MissingConfigError";
   }
 };
-function resolveEnvValue(value, resources, secrets, configs, servicePort, serviceEndpoints, currentServicePorts) {
+function resolveEnvValue(value, resources, secrets, configs, servicePort, serviceEndpoints, currentServicePorts, publicUrls) {
   if (typeof value === "string") {
     return value;
   }
@@ -187312,11 +187582,25 @@ function resolveEnvValue(value, resources, secrets, configs, servicePort, servic
       }
       switch (serviceRef.attribute) {
         case "url":
+        case "private_url":
           return `localhost:${endpoint.port}`;
         case "host":
           return "localhost";
         case "port":
           return String(endpoint.port);
+        case "public_url": {
+          if (!publicUrls) {
+            throw new Error("public_url reference used but no public URL map provided");
+          }
+          const k8sName = endpointName === "default" ? serviceRef.serviceName : `${serviceRef.serviceName}-${endpointName}`;
+          const publicUrl = publicUrls.get(k8sName);
+          if (!publicUrl) {
+            throw new Error(
+              `No public URL found for service "${serviceRef.serviceName}" endpoint "${endpointName}"`
+            );
+          }
+          return publicUrl;
+        }
         default:
           throw new Error(`Unknown service attribute: ${serviceRef.attribute}`);
       }
@@ -187328,6 +187612,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;
@@ -187421,7 +187708,7 @@ function resolveEnvValue(value, resources, secrets, configs, servicePort, servic
       throw new Error(`Unknown reference type`);
   }
 }
-function resolveEnv(env2, resources, secrets, configs, servicePort, serviceEndpoints, currentServicePorts) {
+function resolveEnv(env2, resources, secrets, configs, servicePort, serviceEndpoints, currentServicePorts, publicUrls) {
   if (!env2) {
     return {};
   }
@@ -187434,7 +187721,8 @@ function resolveEnv(env2, resources, secrets, configs, servicePort, serviceEndpo
       configs,
       servicePort,
       serviceEndpoints,
-      currentServicePorts
+      currentServicePorts,
+      publicUrls
     );
   }
   return resolved;
@@ -187458,7 +187746,7 @@ function resolveEnvForExec(env2, resources, secrets, configs) {
 }
 
 // src/lib/dev/service-runner.ts
-function startService(service, resources, secrets, configs, endpointPorts, serviceEndpoints, onLog) {
+function startService(service, resources, secrets, configs, endpointPorts, serviceEndpoints, onLog, publicUrls) {
   const command = service.dev?.command ?? service.command;
   if (!command) {
     throw new Error(`Service "${service.name}" has no command`);
@@ -187475,7 +187763,8 @@ function startService(service, resources, secrets, configs, endpointPorts, servi
     configs,
     defaultPort,
     serviceEndpoints,
-    endpointPorts
+    endpointPorts,
+    publicUrls
   );
   const child = spawn2(command, {
     shell: true,
@@ -187507,14 +187796,14 @@ function startService(service, resources, secrets, configs, endpointPorts, servi
     ports: endpointPorts,
     process: child,
     async stop() {
-      return new Promise((resolve7) => {
+      return new Promise((resolve9) => {
         if (child.killed || child.exitCode !== null) {
-          resolve7();
+          resolve9();
           return;
         }
         child.once("exit", () => {
           clearTimeout(forceKillTimeout);
-          resolve7();
+          resolve9();
         });
         child.kill("SIGTERM");
         const forceKillTimeout = setTimeout(() => {
@@ -187595,7 +187884,7 @@ var InstanceStateManager = class {
             }
             continue;
           }
-          await new Promise((resolve7) => setTimeout(resolve7, 100));
+          await new Promise((resolve9) => setTimeout(resolve9, 100));
         } else {
           throw e;
         }
@@ -187878,7 +188167,7 @@ async function startHttpProxy(services, certificate, getState, instanceKey = "de
     handleRequest
   );
   httpsServer.on("upgrade", handleUpgrade);
-  return new Promise((resolve7, reject) => {
+  return new Promise((resolve9, reject) => {
     let httpStarted = false;
     let httpsStarted = false;
     let failed = false;
@@ -187889,7 +188178,7 @@ async function startHttpProxy(services, certificate, getState, instanceKey = "de
           "proxy",
           `HTTP/HTTPS proxy started on ports ${HTTP_PORT}/${HTTPS_PORT}`
         );
-        resolve7({
+        resolve9({
           httpPort: HTTP_PORT,
           httpsPort: HTTPS_PORT,
           updateServices,
@@ -187901,13 +188190,13 @@ async function startHttpProxy(services, certificate, getState, instanceKey = "de
             writeLog("proxy", "Certificate updated");
           },
           async stop() {
-            return new Promise((resolve8) => {
+            return new Promise((resolve10) => {
               let closed = 0;
               const onClose = () => {
                 closed++;
                 if (closed === 2) {
                   clearTimeout(forceCloseTimeout);
-                  resolve8();
+                  resolve10();
                 }
               };
               httpServer.close(onClose);
@@ -187915,7 +188204,7 @@ async function startHttpProxy(services, certificate, getState, instanceKey = "de
               const forceCloseTimeout = setTimeout(() => {
                 httpServer.closeAllConnections?.();
                 httpsServer.closeAllConnections?.();
-                resolve8();
+                resolve10();
               }, 2e3);
             });
           }
@@ -188078,7 +188367,7 @@ function serveFileContent(res, filePath, contentType, statusCode = 200) {
   }
 }
 async function startAdminServer(getState) {
-  return new Promise((resolve7, reject) => {
+  return new Promise((resolve9, reject) => {
     const server = http.createServer((req, res) => {
       const url = new URL(req.url || "/", "http://localhost");
       res.setHeader("Access-Control-Allow-Origin", "*");
@@ -188110,7 +188399,7 @@ async function startAdminServer(getState) {
       }
       const port = addr.port;
       writeLog("admin", `Admin API server started on port ${port}`);
-      resolve7({
+      resolve9({
         port,
         stop: () => new Promise((res, rej) => {
           server.close((err) => err ? rej(err) : res());
@@ -188126,7 +188415,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";
@@ -188144,7 +188433,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");
@@ -188153,13 +188442,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");
@@ -188271,33 +188560,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((resolve9) => {
     const socket = new net2.Socket();
     socket.setTimeout(1e3);
     socket.on("connect", () => {
       socket.destroy();
-      resolve7(true);
+      resolve9(true);
     });
     socket.on("timeout", () => {
       socket.destroy();
-      resolve7(false);
+      resolve9(false);
     });
     socket.on("error", () => {
       socket.destroy();
-      resolve7(false);
+      resolve9(false);
     });
     socket.connect(port, host);
   });
 }
 async function stopProcess2(proc) {
-  return new Promise((resolve7) => {
+  return new Promise((resolve9) => {
     if (proc.killed || proc.exitCode !== null) {
-      resolve7();
+      resolve9();
       return;
     }
     proc.once("exit", () => {
       clearTimeout(forceKillTimeout);
-      resolve7();
+      resolve9();
     });
     proc.kill("SIGTERM");
     const forceKillTimeout = setTimeout(() => {
@@ -188308,7 +188597,7 @@ async function stopProcess2(proc) {
   });
 }
 function sleep3(ms) {
-  return new Promise((resolve7) => setTimeout(resolve7, ms));
+  return new Promise((resolve9) => setTimeout(resolve9, ms));
 }
 
 // src/lib/dev/drizzle-gateway-manager.ts
@@ -188392,33 +188681,33 @@ async function waitForTcpPort3(host, port, timeoutMs = 3e4) {
   );
 }
 function checkTcpPort3(host, port) {
-  return new Promise((resolve7) => {
+  return new Promise((resolve9) => {
     const socket = new net3.Socket();
     socket.setTimeout(1e3);
     socket.on("connect", () => {
       socket.destroy();
-      resolve7(true);
+      resolve9(true);
     });
     socket.on("timeout", () => {
       socket.destroy();
-      resolve7(false);
+      resolve9(false);
     });
     socket.on("error", () => {
       socket.destroy();
-      resolve7(false);
+      resolve9(false);
     });
     socket.connect(port, host);
   });
 }
 async function stopProcess3(proc) {
-  return new Promise((resolve7) => {
+  return new Promise((resolve9) => {
     if (proc.killed || proc.exitCode !== null) {
-      resolve7();
+      resolve9();
       return;
     }
     proc.once("exit", () => {
       clearTimeout(forceKillTimeout);
-      resolve7();
+      resolve9();
     });
     proc.kill("SIGTERM");
     const forceKillTimeout = setTimeout(() => {
@@ -188429,7 +188718,7 @@ async function stopProcess3(proc) {
   });
 }
 function sleep4(ms) {
-  return new Promise((resolve7) => setTimeout(resolve7, ms));
+  return new Promise((resolve9) => setTimeout(resolve9, ms));
 }
 
 // src/lib/dev/sync-detector.ts
@@ -188449,6 +188738,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: [] };
@@ -188507,11 +189078,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,
@@ -188519,7 +189093,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) {
@@ -188621,24 +189202,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;
@@ -188648,14 +189229,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, {
@@ -188718,9 +189299,9 @@ 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 os8 from "os";
+import * as fs20 from "fs";
+import * as path17 from "path";
+import * as os7 from "os";
 import * as net4 from "net";
 var ProxyRegistryManager = class {
   proxyDir;
@@ -188730,14 +189311,14 @@ var ProxyRegistryManager = class {
   isOwner = false;
   registryWatcher = null;
   constructor() {
-    this.proxyDir = path16.join(os8.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) {
@@ -188754,7 +189335,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((resolve9) => {
       const socket = new net4.Socket();
       let resolved = false;
       const cleanup = () => {
@@ -188766,15 +189347,15 @@ var ProxyRegistryManager = class {
       socket.setTimeout(timeoutMs);
       socket.on("connect", () => {
         cleanup();
-        resolve7(true);
+        resolve9(true);
       });
       socket.on("timeout", () => {
         cleanup();
-        resolve7(false);
+        resolve9(false);
       });
       socket.on("error", () => {
         cleanup();
-        resolve7(false);
+        resolve9(false);
       });
       socket.connect(port, "127.0.0.1");
     });
@@ -188794,15 +189375,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 {
           }
         };
@@ -188811,21 +189392,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((resolve9) => setTimeout(resolve9, 100));
         } else {
           throw e;
         }
@@ -188840,8 +189421,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;
@@ -188871,11 +189452,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;
@@ -188887,12 +189468,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;
@@ -188986,7 +189567,7 @@ var ProxyRegistryManager = class {
    */
   watchRegistry(onChange) {
     this.ensureProxyDir();
-    if (!fs19.existsSync(this.registryPath)) {
+    if (!fs20.existsSync(this.registryPath)) {
       const emptyRegistry = {
         version: 1,
         keys: {},
@@ -189030,13 +189611,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,
@@ -189054,7 +189635,7 @@ var ProxyRegistryManager = class {
     }
   }
   readRegistry() {
-    if (!fs19.existsSync(this.registryPath)) {
+    if (!fs20.existsSync(this.registryPath)) {
       return {
         version: 1,
         keys: {},
@@ -189062,7 +189643,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 {
@@ -189075,8 +189656,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);
   }
 };
 
@@ -189175,11 +189756,6 @@ function ConfigInput({ configName, onSubmit, onCancel }) {
   return /* @__PURE__ */ React5.createElement(Box5, { flexDirection: "column", marginTop: 1 }, /* @__PURE__ */ React5.createElement(Text5, null, "Enter value for config ", /* @__PURE__ */ React5.createElement(Text5, { color: "cyan" }, configName), ":"), /* @__PURE__ */ React5.createElement(Box5, null, /* @__PURE__ */ React5.createElement(Text5, { color: "cyan" }, "> "), /* @__PURE__ */ React5.createElement(Text5, null, value), /* @__PURE__ */ React5.createElement(Text5, { color: "gray" }, "|")), /* @__PURE__ */ React5.createElement(Text5, { dimColor: true }, "(Press Enter to save, Esc to cancel)"));
 }
 
-// src/lib/ui/interactive.ts
-function isInteractive() {
-  return process.stdin.isTTY === true && process.stdout.isTTY === true;
-}
-
 // src/commands/dev.tsx
 var COLORS = ["cyan", "yellow", "green", "magenta", "blue"];
 function DevUI({ instanceKey, tunnelEnabled }) {
@@ -189226,6 +189802,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([]);
@@ -189233,6 +189810,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 () => {
@@ -189259,6 +189837,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
@@ -189266,6 +189846,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();
@@ -189298,6 +189880,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
@@ -189305,7 +189889,12 @@ function DevUI({ instanceKey, tunnelEnabled }) {
       // Stop all tunnels
       ...tunnelsRef.current.map((tunnel) => tunnel.stop())
     ]);
+    if (tunnelsRef.current.length > 0) {
+      await new Promise((resolve9) => setTimeout(resolve9, 1500));
+    }
     electricInstancesRef.current = [];
+    reshapeWatchersRef.current = [];
+    restartServicesRef.current = null;
     drizzleGatewayRef.current = null;
     proxyRef.current = null;
     adminServerRef.current = null;
@@ -189370,10 +189959,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) => {
@@ -189498,8 +190087,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,
@@ -189518,7 +190107,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) => ({
@@ -189624,7 +190213,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;
@@ -189637,6 +190226,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);
@@ -189724,6 +190366,39 @@ Add them to the config block in specific.local`);
         serviceEndpointPorts.set(service.name, endpointPorts);
         serviceEndpoints.set(service.name, endpointInfos);
       }
+      const serviceInfos = [];
+      const exposedServices = [];
+      for (const service of config2.services) {
+        const endpointInfos = serviceEndpoints.get(service.name) || [];
+        for (const info of endpointInfos) {
+          const endpointConfig = service.endpoints.find(
+            (e) => e.name === info.endpointName
+          );
+          if (endpointConfig?.public) {
+            const proxyName = info.endpointName === "default" ? service.name : `${service.name}-${info.endpointName}`;
+            exposedServices.push({ name: proxyName, port: info.port });
+            serviceInfos.push({
+              serviceName: proxyName,
+              port: info.port
+            });
+          }
+        }
+      }
+      const publicUrls = /* @__PURE__ */ new Map();
+      let subdomainAllocator;
+      if (tunnelEnabled && exposedServices.length > 0) {
+        subdomainAllocator = new StableSubdomainAllocator(process.cwd(), instanceKey);
+        const multipleServices = exposedServices.length > 1;
+        for (const svc of exposedServices) {
+          const subdomain = subdomainAllocator.allocate(svc.name, multipleServices);
+          publicUrls.set(svc.name, `${subdomain}.tunnel.spcf.app`);
+        }
+      } else {
+        const keySuffix = instanceKey === "default" ? "" : `.${instanceKey}`;
+        for (const svc of exposedServices) {
+          publicUrls.set(svc.name, `${svc.name}${keySuffix}.local.spcf.app`);
+        }
+      }
       const services2 = [];
       for (const service of config2.services) {
         if (cancelled) break;
@@ -189747,7 +190422,8 @@ Add them to the config block in specific.local`);
             configs,
             endpointPorts,
             serviceEndpoints,
-            (line) => addLog(line, colorMap)
+            (line) => addLog(line, colorMap),
+            publicUrls
           );
           services2.push(running);
           startedServices.push(running);
@@ -189775,30 +190451,45 @@ Add them to the config block in specific.local`);
         }
       }
       if (cancelled) return;
-      const serviceInfos = [];
-      const exposedServices = [];
-      for (const service of config2.services) {
-        const endpointInfos = serviceEndpoints.get(service.name) || [];
-        for (const info of endpointInfos) {
-          const endpointConfig = service.endpoints.find(
-            (e) => e.name === info.endpointName
-          );
-          if (endpointConfig?.public) {
-            const proxyName = info.endpointName === "default" ? service.name : `${service.name}-${info.endpointName}`;
-            exposedServices.push({ name: proxyName, port: info.port });
-            serviceInfos.push({
-              serviceName: proxyName,
-              port: info.port
-            });
+      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)
+            );
+            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) {
           writeLog("system", "No public services to tunnel");
         } else {
-          const subdomainAllocator = new StableSubdomainAllocator(process.cwd(), instanceKey);
           const multipleServices = exposedServices.length > 1;
           const tunnelInstances = [];
           const tunnelStatusMap = /* @__PURE__ */ new Map();
@@ -190011,6 +190702,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(() => {
         });
@@ -190233,7 +190930,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", {
@@ -190244,8 +190941,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;
@@ -190260,7 +190957,7 @@ function getWorktreeName() {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
     }).trim();
-    return path18.basename(gitDir);
+    return path19.basename(gitDir);
   } catch {
     return null;
   }
@@ -190275,35 +190972,35 @@ 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 } 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 {
         return "npm install";
       }
     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;
@@ -190317,7 +191014,7 @@ function getDependencyInstallCommand(build, projectDir) {
   }
 }
 function runCommand2(command, projectDir, buildName) {
-  return new Promise((resolve7) => {
+  return new Promise((resolve9) => {
     const stdout = [];
     const stderr = [];
     writeLog("build-test", `[${buildName}] Running: ${command}`);
@@ -190347,7 +191044,7 @@ function runCommand2(command, projectDir, buildName) {
     });
     child.on("error", (err) => {
       writeLog("build-test:error", `[${buildName}] Failed to start: ${err.message}`);
-      resolve7({
+      resolve9({
         success: false,
         output: `Failed to start command: ${err.message}`
       });
@@ -190356,10 +191053,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 });
+        resolve9({ success: true, output });
       } else {
         writeLog("build-test:error", `[${buildName}] Command failed with exit code ${code}`);
-        resolve7({
+        resolve9({
           success: false,
           output: output || `Exit code: ${code}`
         });
@@ -190449,8 +191146,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 {
@@ -190507,10 +191204,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);
@@ -190525,8 +191222,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);
@@ -190543,8 +191240,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));
@@ -190558,12 +191255,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)) {
@@ -191450,14 +192147,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(
@@ -191481,8 +192178,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(
@@ -191510,14 +192207,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)}`);
@@ -191564,6 +192261,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() {
           }
         });
@@ -191654,27 +192353,48 @@ async function execCommand(serviceName, command, instanceKey = "default") {
 
 // src/commands/psql.tsx
 import { spawn as spawn7 } from "child_process";
-async function psqlCommand(databaseName, instanceKey = "default") {
-  const stateManager = new InstanceStateManager(process.cwd(), instanceKey);
-  await stateManager.cleanStaleState();
-  const existingInstances = await stateManager.getExistingInstances();
-  if (!existingInstances) {
-    console.error("Error: No running instances found. Run `specific dev` first.");
+import * as fs25 from "fs";
+import * as path23 from "path";
+async function psqlCommand(databaseName, instanceKey = "default", extraArgs = []) {
+  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(() => {
+        });
+      }
+    }
+  };
+  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);
   }
-  const availableDatabases = Object.keys(existingInstances.databases);
+  let config;
+  try {
+    const hcl = fs25.readFileSync(configPath, "utf-8");
+    config = await parseConfig(hcl);
+  } catch (err) {
+    console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+  }
+  const availableDatabases = config.postgres.map((p) => p.name);
   if (availableDatabases.length === 0) {
-    console.error("Error: No databases found in running instances.");
+    console.error("Error: No postgres databases defined in specific.hcl");
     process.exit(1);
   }
   let targetDb;
+  if (databaseName && !availableDatabases.includes(databaseName)) {
+    extraArgs = [databaseName, ...extraArgs];
+    databaseName = void 0;
+  }
   if (databaseName) {
-    if (!existingInstances.databases[databaseName]) {
-      console.error(
-        `Error: Database "${databaseName}" not found. Available: ${availableDatabases.join(", ")}`
-      );
-      process.exit(1);
-    }
     targetDb = databaseName;
   } else {
     if (availableDatabases.length > 1) {
@@ -191685,24 +192405,297 @@ async function psqlCommand(databaseName, instanceKey = "default") {
     }
     targetDb = availableDatabases[0];
   }
-  const dbState = existingInstances.databases[targetDb];
-  const child = spawn7("psql", ["-h", dbState.host, "-p", String(dbState.port), "-U", dbState.user, "-d", dbState.dbName], {
+  stateManager = new InstanceStateManager(process.cwd(), instanceKey);
+  await stateManager.cleanStaleState();
+  const existingInstances = await stateManager.getExistingInstances();
+  let dbState;
+  if (existingInstances && existingInstances.databases[targetDb]) {
+    const db = existingInstances.databases[targetDb];
+    dbState = { host: db.host, port: db.port, user: db.user, password: db.password, dbName: db.dbName };
+  } else {
+    console.error("Starting database...");
+    try {
+      await stateManager.claimOwnership("psql");
+      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);
+      }
+      dbState = {
+        host: resource.host,
+        port: resource.port,
+        user: resource.user,
+        password: resource.password,
+        dbName: resource.dbName
+      };
+    } catch (err) {
+      console.error(
+        `Error: Failed to start database: ${err instanceof Error ? err.message : String(err)}`
+      );
+      await cleanup();
+      process.exit(1);
+    }
+  }
+  const binary = await ensureBinary(postgresBinary);
+  const psqlPath = binary.executables["psql"];
+  const libraryEnv = getLibraryEnv(binary);
+  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 = spawn7(psqlPath, ["-h", dbState.host, "-p", String(dbState.port), "-U", dbState.user, "-d", dbState.dbName, ...extraArgs], {
     cwd: process.cwd(),
     env: {
       ...process.env,
+      ...libraryEnv,
       PGPASSWORD: dbState.password
     },
     stdio: "inherit"
   });
-  child.on("exit", (code, signal) => {
+  child.on("exit", async (code, signal) => {
+    await cleanup();
     if (signal) {
       process.kill(process.pid, signal);
     } else {
       process.exit(code ?? 0);
     }
   });
-  child.on("error", (err) => {
+  child.on("error", async (err) => {
     console.error(`Error: Failed to start psql: ${err.message}`);
+    await cleanup();
+    process.exit(1);
+  });
+}
+
+// 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);
   });
 }
@@ -191711,21 +192704,21 @@ async function psqlCommand(databaseName, instanceKey = "default") {
 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 fs24 from "fs";
-import * as path22 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 = path22.join(projectRoot, ".specific");
-      if (!fs24.existsSync(specificDir)) {
+      const specificDir = path25.join(projectRoot, ".specific");
+      if (!fs27.existsSync(specificDir)) {
         setState({ status: "nothing" });
         return;
       }
       if (instanceKey) {
-        const keyDir = path22.join(specificDir, "keys", instanceKey);
-        if (!fs24.existsSync(keyDir)) {
+        const keyDir = path25.join(specificDir, "keys", instanceKey);
+        if (!fs27.existsSync(keyDir)) {
           setState({ status: "nothing" });
           return;
         }
@@ -191741,7 +192734,7 @@ function CleanUI({ instanceKey }) {
         await stateManager.cleanStaleState();
         setState({ status: "cleaning" });
         try {
-          fs24.rmSync(keyDir, { recursive: true, force: true });
+          fs27.rmSync(keyDir, { recursive: true, force: true });
           setState({ status: "success" });
         } catch (err) {
           setState({
@@ -191750,10 +192743,10 @@ function CleanUI({ instanceKey }) {
           });
         }
       } else {
-        const keysDir = path22.join(specificDir, "keys");
-        if (fs24.existsSync(keysDir)) {
-          const keys = fs24.readdirSync(keysDir).filter(
-            (f) => fs24.statSync(path22.join(keysDir, f)).isDirectory()
+        const keysDir = path25.join(specificDir, "keys");
+        if (fs27.existsSync(keysDir)) {
+          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);
@@ -191778,7 +192771,7 @@ function CleanUI({ instanceKey }) {
         }
         setState({ status: "cleaning" });
         try {
-          fs24.rmSync(specificDir, { recursive: true, force: true });
+          fs27.rmSync(specificDir, { recursive: true, force: true });
           setState({ status: "success" });
         } catch (err) {
           setState({
@@ -191861,12 +192854,88 @@ 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.48").enablePositionalOptions();
-program.command("init").description("Initialize project for use with a coding agent").action(initCommand);
+program.name("specific").description(`${envLabel}Infrastructure-as-code for coding agents`).version("0.1.50").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);
 program.command("dev").description("Start local development environment").option("-k, --key <key>", "Namespace for isolated dev environment (auto-detected from git worktree if not specified)").option("--tunnel", "Expose public services via localtunnel URLs").action((options2) => {
@@ -191881,13 +192950,19 @@ program.command("exec <service> [args...]").description("Run a one-off command w
   const key = options2.key ?? getDefaultKey();
   await execCommand(service, filteredArgs, key);
 });
-program.command("psql [database]").description("Connect to a running Postgres database").option("-k, --key <key>", "Dev environment namespace (auto-detected from git worktree if not specified)").action((database, options2) => {
+program.command("psql [database] [args...]").description("Connect to a Postgres database").option("-k, --key <key>", "Dev environment namespace (auto-detected from git worktree if not specified)").passThroughOptions().action((database, args, options2) => {
+  const filteredArgs = args[0] === "--" ? args.slice(1) : args;
+  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();
-  psqlCommand(database, key);
+  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";