percher 0.5.5 → 0.5.7

package/dist/bin/percher.js

@@ -5069,11 +5069,11 @@ var require_tslib = __commonJS((exports, module) => {
     };
     __awaiter = function(thisArg, _arguments, P, generator) {
       function adopt(value) {
-        return value instanceof P ? value : new P(function(resolve7) {
-          resolve7(value);
+        return value instanceof P ? value : new P(function(resolve6) {
+          resolve6(value);
         });
       }
-      return new (P || (P = Promise))(function(resolve7, reject) {
+      return new (P || (P = Promise))(function(resolve6, reject) {
         function fulfilled(value) {
           try {
             step(generator.next(value));
@@ -5089,7 +5089,7 @@ var require_tslib = __commonJS((exports, module) => {
           }
         }
         function step(result) {
-          result.done ? resolve7(result.value) : adopt(result.value).then(fulfilled, rejected);
+          result.done ? resolve6(result.value) : adopt(result.value).then(fulfilled, rejected);
         }
         step((generator = generator.apply(thisArg, _arguments || [])).next());
       });
@@ -5318,14 +5318,14 @@ var require_tslib = __commonJS((exports, module) => {
       }, i);
       function verb(n) {
         i[n] = o[n] && function(v) {
-          return new Promise(function(resolve7, reject) {
-            v = o[n](v), settle(resolve7, reject, v.done, v.value);
+          return new Promise(function(resolve6, reject) {
+            v = o[n](v), settle(resolve6, reject, v.done, v.value);
           });
         };
       }
-      function settle(resolve7, reject, d, v) {
+      function settle(resolve6, reject, d, v) {
         Promise.resolve(v).then(function(v2) {
-          resolve7({ value: v2, done: d });
+          resolve6({ value: v2, done: d });
         }, reject);
       }
     };
@@ -8824,7 +8824,7 @@ var require_util = __commonJS((exports) => {
       }
       path = url2.path;
     }
-    var isAbsolute3 = exports.isAbsolute(path);
+    var isAbsolute2 = exports.isAbsolute(path);
     var parts = path.split(/\/+/);
     for (var part, up = 0, i = parts.length - 1;i >= 0; i--) {
       part = parts[i];
@@ -8844,7 +8844,7 @@ var require_util = __commonJS((exports) => {
     }
     path = parts.join("/");
     if (path === "") {
-      path = isAbsolute3 ? "/" : ".";
+      path = isAbsolute2 ? "/" : ".";
     }
     if (url2) {
       url2.path = path;
@@ -8853,7 +8853,7 @@ var require_util = __commonJS((exports) => {
     return path;
   }
   exports.normalize = normalize2;
-  function join18(aRoot, aPath) {
+  function join17(aRoot, aPath) {
     if (aRoot === "") {
       aRoot = ".";
     }
@@ -8885,11 +8885,11 @@ var require_util = __commonJS((exports) => {
     }
     return joined;
   }
-  exports.join = join18;
+  exports.join = join17;
   exports.isAbsolute = function(aPath) {
     return aPath.charAt(0) === "/" || urlRegexp.test(aPath);
   };
-  function relative4(aRoot, aPath) {
+  function relative3(aRoot, aPath) {
     if (aRoot === "") {
       aRoot = ".";
     }
@@ -8908,7 +8908,7 @@ var require_util = __commonJS((exports) => {
     }
     return Array(level + 1).join("../") + aPath.substr(aRoot.length + 1);
   }
-  exports.relative = relative4;
+  exports.relative = relative3;
   var supportsNullProto = function() {
     var obj = Object.create(null);
     return !("__proto__" in obj);
@@ -9058,7 +9058,7 @@ var require_util = __commonJS((exports) => {
           parsed.path = parsed.path.substring(0, index + 1);
         }
       }
-      sourceURL = join18(urlGenerate(parsed), sourceURL);
+      sourceURL = join17(urlGenerate(parsed), sourceURL);
     }
     return normalize2(sourceURL);
   }
@@ -89384,10 +89384,10 @@ var require_browser = __commonJS((exports) => {
         text = canvas;
         canvas = undefined;
       }
-      return new Promise(function(resolve7, reject) {
+      return new Promise(function(resolve9, reject) {
         try {
           const data2 = QRCode.create(text, opts);
-          resolve7(renderFunc(data2, canvas, opts));
+          resolve9(renderFunc(data2, canvas, opts));
         } catch (e) {
           reject(e);
         }
@@ -89466,11 +89466,11 @@ var require_server = __commonJS((exports) => {
   }
   function render(renderFunc, text, params) {
     if (!params.cb) {
-      return new Promise(function(resolve7, reject) {
+      return new Promise(function(resolve9, reject) {
         try {
           const data2 = QRCode.create(text, params.opts);
           return renderFunc(data2, params.opts, function(err, data3) {
-            return err ? reject(err) : resolve7(data3);
+            return err ? reject(err) : resolve9(data3);
           });
         } catch (e) {
           reject(e);
@@ -89543,6 +89543,462 @@ var init_qr = __esm(() => {
   import_qrcode = __toESM(require_server(), 1);
 });
 
+// ../../node_modules/.bun/isexe@2.0.0/node_modules/isexe/windows.js
+var require_windows = __commonJS((exports, module) => {
+  module.exports = isexe;
+  isexe.sync = sync;
+  var fs = __require("fs");
+  function checkPathExt(path, options) {
+    var pathext = options.pathExt !== undefined ? options.pathExt : process.env.PATHEXT;
+    if (!pathext) {
+      return true;
+    }
+    pathext = pathext.split(";");
+    if (pathext.indexOf("") !== -1) {
+      return true;
+    }
+    for (var i = 0;i < pathext.length; i++) {
+      var p = pathext[i].toLowerCase();
+      if (p && path.substr(-p.length).toLowerCase() === p) {
+        return true;
+      }
+    }
+    return false;
+  }
+  function checkStat(stat2, path, options) {
+    if (!stat2.isSymbolicLink() && !stat2.isFile()) {
+      return false;
+    }
+    return checkPathExt(path, options);
+  }
+  function isexe(path, options, cb) {
+    fs.stat(path, function(er, stat2) {
+      cb(er, er ? false : checkStat(stat2, path, options));
+    });
+  }
+  function sync(path, options) {
+    return checkStat(fs.statSync(path), path, options);
+  }
+});
+
+// ../../node_modules/.bun/isexe@2.0.0/node_modules/isexe/mode.js
+var require_mode2 = __commonJS((exports, module) => {
+  module.exports = isexe;
+  isexe.sync = sync;
+  var fs = __require("fs");
+  function isexe(path, options, cb) {
+    fs.stat(path, function(er, stat2) {
+      cb(er, er ? false : checkStat(stat2, options));
+    });
+  }
+  function sync(path, options) {
+    return checkStat(fs.statSync(path), options);
+  }
+  function checkStat(stat2, options) {
+    return stat2.isFile() && checkMode(stat2, options);
+  }
+  function checkMode(stat2, options) {
+    var mod = stat2.mode;
+    var uid = stat2.uid;
+    var gid = stat2.gid;
+    var myUid = options.uid !== undefined ? options.uid : process.getuid && process.getuid();
+    var myGid = options.gid !== undefined ? options.gid : process.getgid && process.getgid();
+    var u = parseInt("100", 8);
+    var g = parseInt("010", 8);
+    var o = parseInt("001", 8);
+    var ug = u | g;
+    var ret = mod & o || mod & g && gid === myGid || mod & u && uid === myUid || mod & ug && myUid === 0;
+    return ret;
+  }
+});
+
+// ../../node_modules/.bun/isexe@2.0.0/node_modules/isexe/index.js
+var require_isexe = __commonJS((exports, module) => {
+  var fs = __require("fs");
+  var core2;
+  if (process.platform === "win32" || global.TESTING_WINDOWS) {
+    core2 = require_windows();
+  } else {
+    core2 = require_mode2();
+  }
+  module.exports = isexe;
+  isexe.sync = sync;
+  function isexe(path, options, cb) {
+    if (typeof options === "function") {
+      cb = options;
+      options = {};
+    }
+    if (!cb) {
+      if (typeof Promise !== "function") {
+        throw new TypeError("callback not provided");
+      }
+      return new Promise(function(resolve9, reject) {
+        isexe(path, options || {}, function(er, is) {
+          if (er) {
+            reject(er);
+          } else {
+            resolve9(is);
+          }
+        });
+      });
+    }
+    core2(path, options || {}, function(er, is) {
+      if (er) {
+        if (er.code === "EACCES" || options && options.ignoreErrors) {
+          er = null;
+          is = false;
+        }
+      }
+      cb(er, is);
+    });
+  }
+  function sync(path, options) {
+    try {
+      return core2.sync(path, options || {});
+    } catch (er) {
+      if (options && options.ignoreErrors || er.code === "EACCES") {
+        return false;
+      } else {
+        throw er;
+      }
+    }
+  }
+});
+
+// ../../node_modules/.bun/which@2.0.2/node_modules/which/which.js
+var require_which = __commonJS((exports, module) => {
+  var isWindows = process.platform === "win32" || process.env.OSTYPE === "cygwin" || process.env.OSTYPE === "msys";
+  var path = __require("path");
+  var COLON = isWindows ? ";" : ":";
+  var isexe = require_isexe();
+  var getNotFoundError = (cmd) => Object.assign(new Error(`not found: ${cmd}`), { code: "ENOENT" });
+  var getPathInfo = (cmd, opt) => {
+    const colon = opt.colon || COLON;
+    const pathEnv = cmd.match(/\//) || isWindows && cmd.match(/\\/) ? [""] : [
+      ...isWindows ? [process.cwd()] : [],
+      ...(opt.path || process.env.PATH || "").split(colon)
+    ];
+    const pathExtExe = isWindows ? opt.pathExt || process.env.PATHEXT || ".EXE;.CMD;.BAT;.COM" : "";
+    const pathExt = isWindows ? pathExtExe.split(colon) : [""];
+    if (isWindows) {
+      if (cmd.indexOf(".") !== -1 && pathExt[0] !== "")
+        pathExt.unshift("");
+    }
+    return {
+      pathEnv,
+      pathExt,
+      pathExtExe
+    };
+  };
+  var which = (cmd, opt, cb) => {
+    if (typeof opt === "function") {
+      cb = opt;
+      opt = {};
+    }
+    if (!opt)
+      opt = {};
+    const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
+    const found = [];
+    const step = (i) => new Promise((resolve9, reject) => {
+      if (i === pathEnv.length)
+        return opt.all && found.length ? resolve9(found) : reject(getNotFoundError(cmd));
+      const ppRaw = pathEnv[i];
+      const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
+      const pCmd = path.join(pathPart, cmd);
+      const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
+      resolve9(subStep(p, i, 0));
+    });
+    const subStep = (p, i, ii) => new Promise((resolve9, reject) => {
+      if (ii === pathExt.length)
+        return resolve9(step(i + 1));
+      const ext = pathExt[ii];
+      isexe(p + ext, { pathExt: pathExtExe }, (er, is) => {
+        if (!er && is) {
+          if (opt.all)
+            found.push(p + ext);
+          else
+            return resolve9(p + ext);
+        }
+        return resolve9(subStep(p, i, ii + 1));
+      });
+    });
+    return cb ? step(0).then((res) => cb(null, res), cb) : step(0);
+  };
+  var whichSync = (cmd, opt) => {
+    opt = opt || {};
+    const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
+    const found = [];
+    for (let i = 0;i < pathEnv.length; i++) {
+      const ppRaw = pathEnv[i];
+      const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
+      const pCmd = path.join(pathPart, cmd);
+      const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
+      for (let j = 0;j < pathExt.length; j++) {
+        const cur = p + pathExt[j];
+        try {
+          const is = isexe.sync(cur, { pathExt: pathExtExe });
+          if (is) {
+            if (opt.all)
+              found.push(cur);
+            else
+              return cur;
+          }
+        } catch (ex) {}
+      }
+    }
+    if (opt.all && found.length)
+      return found;
+    if (opt.nothrow)
+      return null;
+    throw getNotFoundError(cmd);
+  };
+  module.exports = which;
+  which.sync = whichSync;
+});
+
+// ../../node_modules/.bun/path-key@3.1.1/node_modules/path-key/index.js
+var require_path_key = __commonJS((exports, module) => {
+  var pathKey = (options = {}) => {
+    const environment = options.env || process.env;
+    const platform = options.platform || process.platform;
+    if (platform !== "win32") {
+      return "PATH";
+    }
+    return Object.keys(environment).reverse().find((key) => key.toUpperCase() === "PATH") || "Path";
+  };
+  module.exports = pathKey;
+  module.exports.default = pathKey;
+});
+
+// ../../node_modules/.bun/cross-spawn@7.0.6/node_modules/cross-spawn/lib/util/resolveCommand.js
+var require_resolveCommand = __commonJS((exports, module) => {
+  var path = __require("path");
+  var which = require_which();
+  var getPathKey = require_path_key();
+  function resolveCommandAttempt(parsed, withoutPathExt) {
+    const env = parsed.options.env || process.env;
+    const cwd = process.cwd();
+    const hasCustomCwd = parsed.options.cwd != null;
+    const shouldSwitchCwd = hasCustomCwd && process.chdir !== undefined && !process.chdir.disabled;
+    if (shouldSwitchCwd) {
+      try {
+        process.chdir(parsed.options.cwd);
+      } catch (err) {}
+    }
+    let resolved;
+    try {
+      resolved = which.sync(parsed.command, {
+        path: env[getPathKey({ env })],
+        pathExt: withoutPathExt ? path.delimiter : undefined
+      });
+    } catch (e) {} finally {
+      if (shouldSwitchCwd) {
+        process.chdir(cwd);
+      }
+    }
+    if (resolved) {
+      resolved = path.resolve(hasCustomCwd ? parsed.options.cwd : "", resolved);
+    }
+    return resolved;
+  }
+  function resolveCommand(parsed) {
+    return resolveCommandAttempt(parsed) || resolveCommandAttempt(parsed, true);
+  }
+  module.exports = resolveCommand;
+});
+
+// ../../node_modules/.bun/cross-spawn@7.0.6/node_modules/cross-spawn/lib/util/escape.js
+var require_escape = __commonJS((exports, module) => {
+  var metaCharsRegExp = /([()\][%!^"`<>&|;, *?])/g;
+  function escapeCommand(arg) {
+    arg = arg.replace(metaCharsRegExp, "^$1");
+    return arg;
+  }
+  function escapeArgument(arg, doubleEscapeMetaChars) {
+    arg = `${arg}`;
+    arg = arg.replace(/(?=(\\+?)?)\1"/g, "$1$1\\\"");
+    arg = arg.replace(/(?=(\\+?)?)\1$/, "$1$1");
+    arg = `"${arg}"`;
+    arg = arg.replace(metaCharsRegExp, "^$1");
+    if (doubleEscapeMetaChars) {
+      arg = arg.replace(metaCharsRegExp, "^$1");
+    }
+    return arg;
+  }
+  exports.command = escapeCommand;
+  exports.argument = escapeArgument;
+});
+
+// ../../node_modules/.bun/shebang-regex@3.0.0/node_modules/shebang-regex/index.js
+var require_shebang_regex = __commonJS((exports, module) => {
+  module.exports = /^#!(.*)/;
+});
+
+// ../../node_modules/.bun/shebang-command@2.0.0/node_modules/shebang-command/index.js
+var require_shebang_command = __commonJS((exports, module) => {
+  var shebangRegex = require_shebang_regex();
+  module.exports = (string4 = "") => {
+    const match = string4.match(shebangRegex);
+    if (!match) {
+      return null;
+    }
+    const [path, argument] = match[0].replace(/#! ?/, "").split(" ");
+    const binary = path.split("/").pop();
+    if (binary === "env") {
+      return argument;
+    }
+    return argument ? `${binary} ${argument}` : binary;
+  };
+});
+
+// ../../node_modules/.bun/cross-spawn@7.0.6/node_modules/cross-spawn/lib/util/readShebang.js
+var require_readShebang = __commonJS((exports, module) => {
+  var fs = __require("fs");
+  var shebangCommand = require_shebang_command();
+  function readShebang(command) {
+    const size = 150;
+    const buffer = Buffer.alloc(size);
+    let fd;
+    try {
+      fd = fs.openSync(command, "r");
+      fs.readSync(fd, buffer, 0, size, 0);
+      fs.closeSync(fd);
+    } catch (e) {}
+    return shebangCommand(buffer.toString());
+  }
+  module.exports = readShebang;
+});
+
+// ../../node_modules/.bun/cross-spawn@7.0.6/node_modules/cross-spawn/lib/parse.js
+var require_parse2 = __commonJS((exports, module) => {
+  var path = __require("path");
+  var resolveCommand = require_resolveCommand();
+  var escape = require_escape();
+  var readShebang = require_readShebang();
+  var isWin = process.platform === "win32";
+  var isExecutableRegExp = /\.(?:com|exe)$/i;
+  var isCmdShimRegExp = /node_modules[\\/].bin[\\/][^\\/]+\.cmd$/i;
+  function detectShebang(parsed) {
+    parsed.file = resolveCommand(parsed);
+    const shebang = parsed.file && readShebang(parsed.file);
+    if (shebang) {
+      parsed.args.unshift(parsed.file);
+      parsed.command = shebang;
+      return resolveCommand(parsed);
+    }
+    return parsed.file;
+  }
+  function parseNonShell(parsed) {
+    if (!isWin) {
+      return parsed;
+    }
+    const commandFile = detectShebang(parsed);
+    const needsShell = !isExecutableRegExp.test(commandFile);
+    if (parsed.options.forceShell || needsShell) {
+      const needsDoubleEscapeMetaChars = isCmdShimRegExp.test(commandFile);
+      parsed.command = path.normalize(parsed.command);
+      parsed.command = escape.command(parsed.command);
+      parsed.args = parsed.args.map((arg) => escape.argument(arg, needsDoubleEscapeMetaChars));
+      const shellCommand = [parsed.command].concat(parsed.args).join(" ");
+      parsed.args = ["/d", "/s", "/c", `"${shellCommand}"`];
+      parsed.command = process.env.comspec || "cmd.exe";
+      parsed.options.windowsVerbatimArguments = true;
+    }
+    return parsed;
+  }
+  function parse6(command, args, options) {
+    if (args && !Array.isArray(args)) {
+      options = args;
+      args = null;
+    }
+    args = args ? args.slice(0) : [];
+    options = Object.assign({}, options);
+    const parsed = {
+      command,
+      args,
+      options,
+      file: undefined,
+      original: {
+        command,
+        args
+      }
+    };
+    return options.shell ? parsed : parseNonShell(parsed);
+  }
+  module.exports = parse6;
+});
+
+// ../../node_modules/.bun/cross-spawn@7.0.6/node_modules/cross-spawn/lib/enoent.js
+var require_enoent = __commonJS((exports, module) => {
+  var isWin = process.platform === "win32";
+  function notFoundError(original, syscall) {
+    return Object.assign(new Error(`${syscall} ${original.command} ENOENT`), {
+      code: "ENOENT",
+      errno: "ENOENT",
+      syscall: `${syscall} ${original.command}`,
+      path: original.command,
+      spawnargs: original.args
+    });
+  }
+  function hookChildProcess(cp, parsed) {
+    if (!isWin) {
+      return;
+    }
+    const originalEmit = cp.emit;
+    cp.emit = function(name, arg1) {
+      if (name === "exit") {
+        const err = verifyENOENT(arg1, parsed);
+        if (err) {
+          return originalEmit.call(cp, "error", err);
+        }
+      }
+      return originalEmit.apply(cp, arguments);
+    };
+  }
+  function verifyENOENT(status, parsed) {
+    if (isWin && status === 1 && !parsed.file) {
+      return notFoundError(parsed.original, "spawn");
+    }
+    return null;
+  }
+  function verifyENOENTSync(status, parsed) {
+    if (isWin && status === 1 && !parsed.file) {
+      return notFoundError(parsed.original, "spawnSync");
+    }
+    return null;
+  }
+  module.exports = {
+    hookChildProcess,
+    verifyENOENT,
+    verifyENOENTSync,
+    notFoundError
+  };
+});
+
+// ../../node_modules/.bun/cross-spawn@7.0.6/node_modules/cross-spawn/index.js
+var require_cross_spawn = __commonJS((exports, module) => {
+  var cp = __require("child_process");
+  var parse6 = require_parse2();
+  var enoent = require_enoent();
+  function spawn(command, args, options) {
+    const parsed = parse6(command, args, options);
+    const spawned = cp.spawn(parsed.command, parsed.args, parsed.options);
+    enoent.hookChildProcess(spawned, parsed);
+    return spawned;
+  }
+  function spawnSync(command, args, options) {
+    const parsed = parse6(command, args, options);
+    const result = cp.spawnSync(parsed.command, parsed.args, parsed.options);
+    result.error = result.error || enoent.verifyENOENTSync(result.status, parsed);
+    return result;
+  }
+  module.exports = spawn;
+  module.exports.spawn = spawn;
+  module.exports.sync = spawnSync;
+  module.exports._parse = parse6;
+  module.exports._enoent = enoent;
+});
+
 // ../../node_modules/.bun/picocolors@1.1.1/node_modules/picocolors/picocolors.js
 var require_picocolors = __commonJS((exports, module) => {
   var p = process || {};
@@ -89725,7 +90181,7 @@ __export(exports_prompt_hidden, {
 });
 import { stdin, stdout } from "node:process";
 function promptHiddenWithStreams(question, input, output) {
-  return new Promise((resolve7, reject) => {
+  return new Promise((resolve9, reject) => {
     output.write(`${question} `);
     let buf = "";
     let done = false;
@@ -89741,7 +90197,7 @@ function promptHiddenWithStreams(question, input, output) {
           input.removeListener("error", onError);
           output.write(`
 `);
-          resolve7(buf.replace(/\r$/, ""));
+          resolve9(buf.replace(/\r$/, ""));
           return;
         }
         buf += ch;
@@ -89763,7 +90219,7 @@ function promptHiddenWithStreams(question, input, output) {
       input.removeListener("error", onError);
       output.write(`
 `);
-      resolve7(buf.replace(/\r$/, ""));
+      resolve9(buf.replace(/\r$/, ""));
     };
     input.on("data", onData);
     input.on("error", onError);
@@ -89781,7 +90237,7 @@ async function promptHidden(question) {
   ttyStdin.resume();
   ttyStdin.setEncoding("utf8");
   try {
-    return await new Promise((resolve7, reject) => {
+    return await new Promise((resolve9, reject) => {
       stdout.write(`${question} `);
       let buf = "";
       const onData = (key) => {
@@ -89791,7 +90247,7 @@ async function promptHidden(question) {
             ttyStdin.removeListener("data", onData);
             stdout.write(`
 `);
-            resolve7(buf);
+            resolve9(buf);
             return;
           }
           if (ch === "\x03") {
@@ -105030,10 +105486,17 @@ function loadConfig() {
   const envToken = process.env.PERCHER_TOKEN;
   return {
     apiUrl: envUrl ?? file2.apiUrl ?? DEFAULT_API_URL,
-    token: envToken ?? file2.token ?? null,
-    anonClaim: file2.anonClaim ?? null
+    token: envToken ?? file2.token ?? null
   };
 }
+function readAnonClaims() {
+  const file2 = readFile2();
+  const claims = { ...file2.anonClaims ?? {} };
+  if (file2.anonClaim?.app && !claims[file2.anonClaim.app]) {
+    claims[file2.anonClaim.app] = file2.anonClaim;
+  }
+  return claims;
+}
 function saveConfig(partial2) {
   const p = configPath();
   mkdirSync3(dirname3(p), { recursive: true });
@@ -105043,6 +105506,21 @@ function saveConfig(partial2) {
   writeFileSync3(tmp, JSON.stringify(merged, null, 2), "utf8");
   renameSync(tmp, p);
 }
+function getAnonClaim(app) {
+  return readAnonClaims()[app] ?? null;
+}
+function setAnonClaim(state) {
+  const claims = { ...readAnonClaims(), [state.app]: state };
+  saveConfig({ anonClaims: claims, anonClaim: null });
+}
+function clearAnonClaim(app) {
+  const claims = { ...readAnonClaims() };
+  delete claims[app];
+  saveConfig({ anonClaims: claims, anonClaim: null });
+}
+function listAnonClaimApps() {
+  return Object.keys(readAnonClaims());
+}
 
 // ../client/dist/errors.js
 class PercherApiError extends Error {
@@ -106078,13 +106556,14 @@ var claimInputSchema = exports_external.object({
   claimToken: exports_external.string().optional().describe("The one-time claim token returned by the anonymous publish (pcl_…)")
 });
 async function claim(ctx, input = {}) {
-  const state = loadConfig().anonClaim;
-  const app = input.app ?? state?.app ?? readPercherTomlAppName(ctx.cwd) ?? undefined;
-  const claimToken = input.claimToken ?? state?.claimToken;
+  const tomlApp = readPercherTomlAppName(ctx.cwd) ?? undefined;
+  const remembered = listAnonClaimApps();
+  const app = input.app ?? tomlApp ?? (remembered.length === 1 ? remembered[0] : undefined);
+  const claimToken = input.claimToken ?? (app ? getAnonClaim(app)?.claimToken ?? undefined : undefined);
   if (!app) {
     return {
       status: "needs_token",
-      summary: "No app to claim. Pass --app (or run from the project that published it) and the claim token."
+      summary: remembered.length > 1 ? `Multiple anonymous apps are remembered (${remembered.join(", ")}). Pass --app to choose one.` : "No app to claim. Pass --app (or run from the project that published it) and the claim token."
     };
   }
   if (!claimToken) {
@@ -106094,8 +106573,7 @@ async function claim(ctx, input = {}) {
     };
   }
   const result = await ctx.client.apps.claim(app, { claimToken });
-  if (state)
-    saveConfig({ anonClaim: null });
+  clearAnonClaim(app);
   return {
     status: "claimed",
     app: result.name,
@@ -110410,9 +110888,1332 @@ function collectWarnings2(collections, rlsPolicies, unsupported) {
   }
   return warnings;
 }
+// ../core/dist/commands/migrate-supabase-rewrite.js
+import { mkdir as mkdir3, writeFile as writeFile3 } from "node:fs/promises";
+import { dirname as dirname5, join as join18, relative as relative4, resolve as resolve7 } from "node:path";
+
+// ../core/dist/commands/migrate-supabase-walker.js
+var import_ignore3 = __toESM(require_ignore(), 1);
+import { mkdir as mkdir2, readdir, readFile as readFile3, stat, writeFile as writeFile2 } from "node:fs/promises";
+import { dirname as dirname4, isAbsolute as isAbsolute2, join as join17, relative as relative3, resolve as resolve6, sep as sep3 } from "node:path";
+
+// ../core/dist/commands/migrate-supabase-sdk.js
+var import_jscodeshift = __toESM(require_core3(), 1);
+var tsx = import_jscodeshift.default.withParser("tsx");
+function rewriteSupabaseSdk(input) {
+  const pbName = input.pbIdentifier ?? "pb";
+  const supabaseNames = new Set(input.supabaseIdentifiers ?? ["supabase"]);
+  if (!sourceMentionsSupabase(input.source, supabaseNames)) {
+    return { rewritten: input.source, flags: [], changed: false };
+  }
+  let root;
+  try {
+    root = tsx(input.source);
+  } catch (err) {
+    return {
+      rewritten: input.source,
+      flags: [],
+      changed: false,
+      parseError: err instanceof Error ? err.message : String(err)
+    };
+  }
+  const flags = [];
+  const state = { mutated: false };
+  rewriteAuthCalls(root, supabaseNames, pbName, flags, state);
+  rewriteFromCalls(root, supabaseNames, pbName, flags, state);
+  flagUnsupportedPatterns(root, supabaseNames, flags);
+  if (!state.mutated) {
+    return { rewritten: input.source, flags, changed: false };
+  }
+  return {
+    rewritten: root.toSource({ quote: "double" }),
+    flags,
+    changed: true
+  };
+}
+function consumesDataErrorEnvelope(path) {
+  let outer = path.node;
+  let outerParent = path.parent?.node;
+  if (outerParent?.type === "AwaitExpression") {
+    const aw = outerParent;
+    if (aw.argument === path.node) {
+      outer = outerParent;
+      outerParent = path.parent.parent?.node;
+    }
+  }
+  if (!outerParent)
+    return false;
+  if (outerParent.type === "MemberExpression") {
+    const m = outerParent;
+    if (m.object === outer && m.property.type === "Identifier") {
+      const propName = m.property.name;
+      if (propName === "data" || propName === "error")
+        return true;
+    }
+    return false;
+  }
+  if (outerParent.type === "VariableDeclarator") {
+    const v = outerParent;
+    if (v.init === outer && v.id.type === "ObjectPattern") {
+      return objectPatternHasDataOrError(v.id);
+    }
+    return false;
+  }
+  if (outerParent.type === "AssignmentExpression") {
+    const a = outerParent;
+    if (a.right === outer && a.left.type === "ObjectPattern") {
+      return objectPatternHasDataOrError(a.left);
+    }
+    return false;
+  }
+  return false;
+}
+function objectPatternHasDataOrError(pattern) {
+  for (const prop of pattern.properties) {
+    if ((prop.type === "Property" || prop.type === "ObjectProperty") && "key" in prop && prop.key.type === "Identifier") {
+      const name = prop.key.name;
+      if (name === "data" || name === "error")
+        return true;
+    }
+  }
+  return false;
+}
+function flagEnvelopeManualReview(path, pattern, flags) {
+  flags.push(makeFlag(path, "manual_review", `${pattern}.envelope`, `Call site consumes the Supabase \`{ data, error }\` envelope — PocketBase returns plain values. Skipping rewrite; unwrap the destructure (or .data/.error access) manually, then re-run the migrator.`));
+}
+function sourceMentionsSupabase(source, supabaseNames) {
+  if (source.includes("@supabase/supabase-js"))
+    return true;
+  for (const name of supabaseNames) {
+    if (source.includes(name))
+      return true;
+  }
+  return false;
+}
+function rewriteAuthCalls(root, supabaseNames, pbName, flags, state) {
+  root.find(import_jscodeshift.default.CallExpression).filter((path) => isSupabaseAuthCall(path, supabaseNames)).forEach((path) => {
+    const callee = path.node.callee;
+    const method = callee.property.name;
+    switch (method) {
+      case "signInWithPassword":
+        replaceAuthSignIn(path, pbName, flags, state);
+        return;
+      case "signUp":
+        replaceAuthSignUp(path, pbName, flags, state);
+        return;
+      case "signOut":
+        replaceAuthSignOut(path, pbName, flags, state);
+        return;
+      case "getUser":
+        replaceAuthGetUser(path, pbName, flags, state);
+        return;
+      case "onAuthStateChange":
+        replaceAuthOnChange(path, pbName, flags, state);
+        return;
+    }
+  });
+}
+function replaceAuthOnChange(path, pbName, flags, state) {
+  const callback = path.node.arguments[0];
+  if (!callback) {
+    flags.push(makeFlag(path, "manual_review", "auth.onAuthStateChange", "onAuthStateChange called with no args — manual review."));
+    return;
+  }
+  const replacement = import_jscodeshift.default.callExpression(import_jscodeshift.default.memberExpression(import_jscodeshift.default.memberExpression(import_jscodeshift.default.identifier(pbName), import_jscodeshift.default.identifier("authStore")), import_jscodeshift.default.identifier("onChange")), [callback]);
+  applyRewrite(path, replacement, "manual_review", "auth.onAuthStateChange", "onAuthStateChange → pb.authStore.onChange — the callback signature changes: Supabase passes `(event, session)`, PB passes `(token, model)`. Rewrite the callback body.", flags, state);
+}
+function isSupabaseAuthCall(path, supabaseNames) {
+  const callee = path.node.callee;
+  if (callee.type !== "MemberExpression")
+    return false;
+  if (callee.property.type !== "Identifier")
+    return false;
+  const object2 = callee.object;
+  if (object2.type !== "MemberExpression")
+    return false;
+  if (object2.property.type !== "Identifier" || object2.property.name !== "auth")
+    return false;
+  if (object2.object.type !== "Identifier")
+    return false;
+  return supabaseNames.has(object2.object.name);
+}
+function replaceAuthSignIn(path, pbName, flags, state) {
+  const arg = path.node.arguments[0];
+  if (arg?.type !== "ObjectExpression") {
+    flags.push(makeFlag(path, "manual_review", "auth.signInWithPassword", "auth.signInWithPassword called with non-object argument — manual review needed."));
+    return;
+  }
+  const emailExpr = findObjectProp(arg, "email");
+  const passwordExpr = findObjectProp(arg, "password");
+  if (!emailExpr || !passwordExpr) {
+    flags.push(makeFlag(path, "manual_review", "auth.signInWithPassword", "auth.signInWithPassword object missing email or password — manual review needed."));
+    return;
+  }
+  if (consumesDataErrorEnvelope(path)) {
+    flagEnvelopeManualReview(path, "auth.signInWithPassword", flags);
+    return;
+  }
+  const replacement = import_jscodeshift.default.callExpression(import_jscodeshift.default.memberExpression(import_jscodeshift.default.callExpression(import_jscodeshift.default.memberExpression(import_jscodeshift.default.identifier(pbName), import_jscodeshift.default.identifier("collection")), [import_jscodeshift.default.literal("users")]), import_jscodeshift.default.identifier("authWithPassword")), [emailExpr, passwordExpr]);
+  applyRewrite(path, replacement, "rewritten", "auth.signInWithPassword", 'signInWithPassword → pb.collection("users").authWithPassword', flags, state);
+}
+function replaceAuthSignUp(path, pbName, flags, state) {
+  const arg = path.node.arguments[0];
+  if (arg?.type !== "ObjectExpression") {
+    flags.push(makeFlag(path, "manual_review", "auth.signUp", "auth.signUp called with non-object argument — manual review needed."));
+    return;
+  }
+  const emailExpr = findObjectProp(arg, "email");
+  const passwordExpr = findObjectProp(arg, "password");
+  if (!emailExpr || !passwordExpr) {
+    flags.push(makeFlag(path, "manual_review", "auth.signUp", "auth.signUp object missing email or password — manual review needed."));
+    return;
+  }
+  if (consumesDataErrorEnvelope(path)) {
+    flagEnvelopeManualReview(path, "auth.signUp", flags);
+    return;
+  }
+  const replacement = import_jscodeshift.default.callExpression(import_jscodeshift.default.memberExpression(import_jscodeshift.default.callExpression(import_jscodeshift.default.memberExpression(import_jscodeshift.default.identifier(pbName), import_jscodeshift.default.identifier("collection")), [import_jscodeshift.default.literal("users")]), import_jscodeshift.default.identifier("create")), [
+    import_jscodeshift.default.objectExpression([
+      import_jscodeshift.default.property("init", import_jscodeshift.default.identifier("email"), emailExpr),
+      import_jscodeshift.default.property("init", import_jscodeshift.default.identifier("password"), passwordExpr),
+      import_jscodeshift.default.property("init", import_jscodeshift.default.identifier("passwordConfirm"), passwordExpr)
+    ])
+  ]);
+  applyRewrite(path, replacement, "rewritten", "auth.signUp", 'signUp → pb.collection("users").create({...passwordConfirm})', flags, state);
+}
+function replaceAuthSignOut(path, pbName, flags, state) {
+  if (consumesDataErrorEnvelope(path)) {
+    flagEnvelopeManualReview(path, "auth.signOut", flags);
+    return;
+  }
+  const replacement = import_jscodeshift.default.callExpression(import_jscodeshift.default.memberExpression(import_jscodeshift.default.memberExpression(import_jscodeshift.default.identifier(pbName), import_jscodeshift.default.identifier("authStore")), import_jscodeshift.default.identifier("clear")), []);
+  applyRewrite(path, replacement, "rewritten", "auth.signOut", "signOut → pb.authStore.clear()", flags, state);
+}
+function replaceAuthGetUser(path, pbName, flags, state) {
+  if (consumesDataErrorEnvelope(path)) {
+    flagEnvelopeManualReview(path, "auth.getUser", flags);
+    return;
+  }
+  const replacement = import_jscodeshift.default.memberExpression(import_jscodeshift.default.memberExpression(import_jscodeshift.default.identifier(pbName), import_jscodeshift.default.identifier("authStore")), import_jscodeshift.default.identifier("model"));
+  applyRewrite(path, replacement, "manual_review", "auth.getUser", "getUser → pb.authStore.model — note Supabase returned Promise<{ data: { user } }>, PB returns the record sync; remove awaits + .data.user access.", flags, state);
+}
+function rewriteFromCalls(root, supabaseNames, pbName, flags, state) {
+  root.find(import_jscodeshift.default.CallExpression).filter((path) => isSupabaseFromTerminal(path, supabaseNames)).forEach((path) => {
+    rewriteFromChain(path, supabaseNames, pbName, flags, state);
+  });
+}
+function isSupabaseFromTerminal(path, supabaseNames) {
+  let fromCall = null;
+  let cursor = path.node;
+  while (cursor.type === "CallExpression") {
+    const call = cursor;
+    if (call.callee.type !== "MemberExpression")
+      break;
+    const callee = call.callee;
+    if (callee.property.type === "Identifier" && callee.property.name === "from") {
+      fromCall = call;
+      break;
+    }
+    cursor = callee.object;
+  }
+  if (!fromCall)
+    return false;
+  const fromCallee = fromCall.callee;
+  if (fromCallee.object.type !== "Identifier")
+    return false;
+  if (!supabaseNames.has(fromCallee.object.name))
+    return false;
+  const parent = path.parent?.node;
+  if (parent?.type === "MemberExpression") {
+    const parentMember = parent;
+    if (parentMember.object === path.node)
+      return false;
+  }
+  return true;
+}
+function rewriteFromChain(path, _supabaseNames, pbName, flags, state) {
+  const decomposed = decomposeFromChain(path.node);
+  if (!decomposed) {
+    flags.push(makeFlag(path, "manual_review", "from.chain", "Couldn't decompose .from() chain shape — manual review."));
+    return;
+  }
+  const { table, steps } = decomposed;
+  const terminal = steps[0];
+  if (!terminal) {
+    return;
+  }
+  switch (terminal.method) {
+    case "select":
+      rewriteSelect(path, pbName, table, steps, flags, state);
+      return;
+    case "insert":
+      rewriteInsert(path, pbName, table, terminal, flags, state);
+      return;
+    case "update":
+      rewriteUpdate(path, pbName, table, steps, flags, state);
+      return;
+    case "delete":
+      rewriteDelete(path, pbName, table, steps, flags, state);
+      return;
+    case "upsert":
+      flags.push(makeFlag(path, "unsupported", "from.upsert", `from(${JSON.stringify(table)}).upsert(...) — PB has no upsert primitive. Rewrite as getOne (catch 404) → update-or-create.`));
+      return;
+    default:
+      flags.push(makeFlag(path, "manual_review", `from.${terminal.method}`, `from(${JSON.stringify(table)}).${terminal.method}(...) has no chunk-1 rewrite — manual review.`));
+  }
+}
+function decomposeFromChain(outer) {
+  const reversedSteps = [];
+  let node = outer;
+  while (node.type === "CallExpression") {
+    const call = node;
+    if (call.callee.type !== "MemberExpression")
+      break;
+    const callee = call.callee;
+    const method = callee.property.type === "Identifier" ? callee.property.name : null;
+    if (method === null)
+      return null;
+    if (method === "from") {
+      const arg = call.arguments[0];
+      if (!arg || arg.type !== "Literal" && arg.type !== "StringLiteral")
+        return null;
+      const table = arg.value;
+      if (typeof table !== "string")
+        return null;
+      return { table, steps: reversedSteps.reverse() };
+    }
+    reversedSteps.push({ method, args: call.arguments });
+    node = callee.object;
+  }
+  return null;
+}
+function rewriteSelect(path, pbName, table, steps, flags, state) {
+  if (consumesDataErrorEnvelope(path)) {
+    flagEnvelopeManualReview(path, "from.select", flags);
+    return;
+  }
+  const select = steps[0];
+  if (!select)
+    return;
+  const tail = steps.slice(1);
+  const opts = {};
+  let needsReview = false;
+  const reviewNotes = [];
+  let usePagination = false;
+  let paginationPage = 1;
+  let paginationPerPage = 0;
+  const fieldsValue = extractSelectFields(select);
+  if (fieldsValue !== null)
+    opts.fields = import_jscodeshift.default.literal(fieldsValue);
+  for (const step of tail) {
+    switch (step.method) {
+      case "eq": {
+        const result = buildEqFilter(step);
+        if (!result) {
+          needsReview = true;
+          reviewNotes.push(`.eq() arguments not in the (column-literal, value) shape — manual review.`);
+          continue;
+        }
+        opts.filter = result.identifierValue ? combineFilterDynamic(opts.filter, result.expression) : combineFilterStatic(opts.filter, result.expression);
+        if (result.identifierValue) {
+          needsReview = true;
+          reviewNotes.push(`.eq(${JSON.stringify(result.column)}, <identifier>) — verify the value is escape-safe for PB filter strings (no double-quotes / backslashes).`);
+        }
+        break;
+      }
+      case "order": {
+        const sortFrag = buildSortFragment(step);
+        if (!sortFrag) {
+          needsReview = true;
+          reviewNotes.push(`.order() arguments not in the recognised shape — manual review.`);
+          continue;
+        }
+        opts.sort = import_jscodeshift.default.literal(opts.sort ? `${literalString(opts.sort)},${sortFrag}` : sortFrag);
+        break;
+      }
+      case "limit": {
+        const arg = step.args[0];
+        const n = extractNumber(arg);
+        if (n === null) {
+          needsReview = true;
+          reviewNotes.push(`.limit() argument isn't a literal number — manual review.`);
+          continue;
+        }
+        if (n <= 0) {
+          flags.push(makeFlag(path, "manual_review", "from.select.limit_invalid", `from(${JSON.stringify(table)}).select(...).limit(${n}) — non-positive limit doesn't translate to PB pagination. Manual review.`));
+          return;
+        }
+        usePagination = true;
+        paginationPerPage = Math.max(paginationPerPage, n);
+        break;
+      }
+      case "range": {
+        const startArg = step.args[0];
+        const endArg = step.args[1];
+        const startN = extractNumber(startArg);
+        const endN = extractNumber(endArg);
+        if (startN === null || endN === null) {
+          needsReview = true;
+          reviewNotes.push(`.range() arguments aren't literal numbers — manual review.`);
+          continue;
+        }
+        const perPage = endN - startN + 1;
+        if (perPage <= 0) {
+          flags.push(makeFlag(path, "manual_review", "from.select.range_invalid", `from(${JSON.stringify(table)}).select(...).range(${startN}, ${endN}) — end < start; PB pagination has no equivalent. Manual review.`));
+          return;
+        }
+        usePagination = true;
+        paginationPerPage = Math.max(paginationPerPage, perPage);
+        if (startN === 0) {
+          paginationPage = 1;
+        } else if (startN % perPage === 0) {
+          paginationPage = Math.floor(startN / perPage) + 1;
+        } else {
+          needsReview = true;
+          reviewNotes.push(`.range(${startN}, ${endN}) — start isn't on a page boundary; PB's page math doesn't translate cleanly. Manual review.`);
+        }
+        break;
+      }
+      case "single": {
+        flags.push(makeFlag(path, "manual_review", "from.select.single", `from(${JSON.stringify(table)}).select(...).single() — PB's getFullList returns an array; getFirstListItem(filter) is the single-record equivalent but takes a filter string. Rewrite this chain by hand: pick getFirstListItem with the right filter OR [0]-index the array result.`));
+        return;
+      }
+      default: {
+        flags.push(makeFlag(path, "manual_review", `from.select.${step.method}`, `from(${JSON.stringify(table)}).select(...).${step.method}(...) has no chunk-2 rewrite — manual review.`));
+        return;
+      }
+    }
+  }
+  let methodName;
+  let methodArgs;
+  if (usePagination) {
+    methodName = "getList";
+    const trailingOpts = buildOptionsObject(opts);
+    methodArgs = [import_jscodeshift.default.literal(paginationPage), import_jscodeshift.default.literal(paginationPerPage)];
+    if (trailingOpts)
+      methodArgs.push(trailingOpts);
+  } else {
+    methodName = "getFullList";
+    const optsObj = buildOptionsObject(opts);
+    methodArgs = optsObj ? [optsObj] : [];
+  }
+  const replacement = import_jscodeshift.default.callExpression(import_jscodeshift.default.memberExpression(import_jscodeshift.default.callExpression(import_jscodeshift.default.memberExpression(import_jscodeshift.default.identifier(pbName), import_jscodeshift.default.identifier("collection")), [import_jscodeshift.default.literal(table)]), import_jscodeshift.default.identifier(methodName)), methodArgs);
+  const kind = needsReview ? "manual_review" : "rewritten";
+  const baseNote = `from(${JSON.stringify(table)}).select(...) → pb.collection(...).${methodName}(...)`;
+  const note = needsReview ? `${baseNote} — ${reviewNotes.join(" · ")}` : baseNote;
+  applyRewrite(path, replacement, kind, "from.select", note, flags, state);
+}
+function extractSelectFields(select) {
+  const first = select.args[0];
+  if (!first)
+    return null;
+  if ((first.type === "Literal" || first.type === "StringLiteral") && typeof first.value === "string") {
+    const val = first.value;
+    if (val === "*" || val.length === 0)
+      return null;
+    return val;
+  }
+  return null;
+}
+function buildEqFilter(step) {
+  const colArg = step.args[0];
+  const valArg = step.args[1];
+  if (!colArg || !valArg)
+    return null;
+  if (!(colArg.type === "Literal" || colArg.type === "StringLiteral") || typeof colArg.value !== "string") {
+    return null;
+  }
+  const column = colArg.value;
+  if (valArg.type === "Literal" || valArg.type === "StringLiteral" || valArg.type === "NumericLiteral" || valArg.type === "BooleanLiteral") {
+    const v = valArg.value;
+    if (typeof v === "string") {
+      return {
+        expression: import_jscodeshift.default.literal(`${column} = "${escapeFilterString(v)}"`),
+        column,
+        identifierValue: false
+      };
+    }
+    if (typeof v === "number" || typeof v === "boolean") {
+      return {
+        expression: import_jscodeshift.default.literal(`${column} = ${v}`),
+        column,
+        identifierValue: false
+      };
+    }
+    return null;
+  }
+  const template = import_jscodeshift.default.templateLiteral([
+    import_jscodeshift.default.templateElement({ raw: `${column} = "`, cooked: `${column} = "` }, false),
+    import_jscodeshift.default.templateElement({ raw: `"`, cooked: `"` }, true)
+  ], [valArg]);
+  return {
+    expression: template,
+    column,
+    identifierValue: true
+  };
+}
+function escapeFilterString(s) {
+  return s.replace(/\\/g, "\\\\").replace(/"/g, "\\\"");
+}
+function combineFilterStatic(current, next) {
+  if (!current)
+    return next;
+  const a = literalString(current);
+  const b = literalString(next);
+  if (a !== null && b !== null) {
+    return import_jscodeshift.default.literal(`(${a}) && (${b})`);
+  }
+  return combineFilterDynamic(current, next);
+}
+function combineFilterDynamic(current, next) {
+  if (!current)
+    return next;
+  return import_jscodeshift.default.templateLiteral([
+    import_jscodeshift.default.templateElement({ raw: "(", cooked: "(" }, false),
+    import_jscodeshift.default.templateElement({ raw: ") && (", cooked: ") && (" }, false),
+    import_jscodeshift.default.templateElement({ raw: ")", cooked: ")" }, true)
+  ], [current, next]);
+}
+function literalString(node) {
+  if (node?.type === "Literal" || node?.type === "StringLiteral") {
+    const v = node.value;
+    if (typeof v === "string")
+      return v;
+  }
+  return null;
+}
+function buildSortFragment(step) {
+  const colArg = step.args[0];
+  if (!colArg)
+    return null;
+  if (!(colArg.type === "Literal" || colArg.type === "StringLiteral") || typeof colArg.value !== "string") {
+    return null;
+  }
+  const column = colArg.value;
+  let ascending = true;
+  if (step.args.length >= 2) {
+    const opts = step.args[1];
+    if (opts?.type === "ObjectExpression") {
+      const ascProp = findObjectProp(opts, "ascending");
+      if (ascProp?.type === "Literal" || ascProp?.type === "BooleanLiteral") {
+        ascending = ascProp.value === true;
+      } else if (ascProp) {
+        return null;
+      }
+    }
+  }
+  return ascending ? column : `-${column}`;
+}
+function extractNumber(node) {
+  if (!node)
+    return null;
+  if (node.type === "Literal" || node.type === "NumericLiteral") {
+    const v = node.value;
+    if (typeof v === "number")
+      return v;
+  }
+  if (node.type === "UnaryExpression") {
+    const u = node;
+    if (u.operator === "-") {
+      const inner = extractNumber(u.argument);
+      if (inner !== null)
+        return -inner;
+    }
+  }
+  return null;
+}
+function buildOptionsObject(opts) {
+  const props = [];
+  if (opts.fields !== undefined) {
+    props.push(import_jscodeshift.default.property("init", import_jscodeshift.default.identifier("fields"), opts.fields));
+  }
+  if (opts.filter !== undefined) {
+    props.push(import_jscodeshift.default.property("init", import_jscodeshift.default.identifier("filter"), opts.filter));
+  }
+  if (opts.sort !== undefined) {
+    props.push(import_jscodeshift.default.property("init", import_jscodeshift.default.identifier("sort"), opts.sort));
+  }
+  if (props.length === 0)
+    return null;
+  return import_jscodeshift.default.objectExpression(props);
+}
+function rewriteInsert(path, pbName, table, insert, flags, state) {
+  if (consumesDataErrorEnvelope(path)) {
+    flagEnvelopeManualReview(path, "from.insert", flags);
+    return;
+  }
+  const arg = insert.args[0];
+  if (!arg) {
+    flags.push(makeFlag(path, "manual_review", "from.insert", "from(...).insert() called with no args — manual review."));
+    return;
+  }
+  if (arg.type === "ArrayExpression") {
+    flags.push(makeFlag(path, "manual_review", "from.insert.array", `from(${JSON.stringify(table)}).insert([...]) — PB's create takes one record at a time; wrap in a loop.`));
+    return;
+  }
+  const replacement = import_jscodeshift.default.callExpression(import_jscodeshift.default.memberExpression(import_jscodeshift.default.callExpression(import_jscodeshift.default.memberExpression(import_jscodeshift.default.identifier(pbName), import_jscodeshift.default.identifier("collection")), [import_jscodeshift.default.literal(table)]), import_jscodeshift.default.identifier("create")), [arg]);
+  applyRewrite(path, replacement, "rewritten", "from.insert", `from(${JSON.stringify(table)}).insert({...}) → pb.collection(...).create({...})`, flags, state);
+}
+function rewriteUpdate(path, pbName, table, steps, flags, state) {
+  if (consumesDataErrorEnvelope(path)) {
+    flagEnvelopeManualReview(path, "from.update", flags);
+    return;
+  }
+  const update = steps[0];
+  const eq = steps[1];
+  if (steps.length !== 2 || !update || !eq || eq.method !== "eq") {
+    flags.push(makeFlag(path, "manual_review", "from.update.shape", `from(${JSON.stringify(table)}).update(...) chain isn't the .update({...}).eq("id", v) shape — manual review.`));
+    return;
+  }
+  const eqCol = eq.args[0];
+  const eqVal = eq.args[1];
+  if (!eqCol || !eqVal) {
+    flags.push(makeFlag(path, "manual_review", "from.update.eq", "update().eq(...) call missing args — manual review."));
+    return;
+  }
+  if (!((eqCol.type === "Literal" || eqCol.type === "StringLiteral") && eqCol.value === "id")) {
+    flags.push(makeFlag(path, "manual_review", "from.update.eq_non_id", `from(${JSON.stringify(table)}).update().eq() filters on a non-id column — PB's update needs an id; chunk 2 will handle filter-based updates.`));
+    return;
+  }
+  const updateArg = update.args[0];
+  if (!updateArg) {
+    flags.push(makeFlag(path, "manual_review", "from.update", "update() called with no args — manual review."));
+    return;
+  }
+  const replacement = import_jscodeshift.default.callExpression(import_jscodeshift.default.memberExpression(import_jscodeshift.default.callExpression(import_jscodeshift.default.memberExpression(import_jscodeshift.default.identifier(pbName), import_jscodeshift.default.identifier("collection")), [import_jscodeshift.default.literal(table)]), import_jscodeshift.default.identifier("update")), [eqVal, updateArg]);
+  applyRewrite(path, replacement, "rewritten", "from.update", `from(${JSON.stringify(table)}).update({...}).eq("id", v) → pb.collection(...).update(v, {...})`, flags, state);
+}
+function rewriteDelete(path, pbName, table, steps, flags, state) {
+  if (consumesDataErrorEnvelope(path)) {
+    flagEnvelopeManualReview(path, "from.delete", flags);
+    return;
+  }
+  const eq = steps[1];
+  if (steps.length !== 2 || !eq || eq.method !== "eq") {
+    flags.push(makeFlag(path, "manual_review", "from.delete.shape", `from(${JSON.stringify(table)}).delete() chain isn't the .delete().eq("id", v) shape — manual review.`));
+    return;
+  }
+  const eqCol = eq.args[0];
+  const eqVal = eq.args[1];
+  if (!eqCol || !eqVal) {
+    flags.push(makeFlag(path, "manual_review", "from.delete.eq", "delete().eq(...) call missing args — manual review."));
+    return;
+  }
+  if (!((eqCol.type === "Literal" || eqCol.type === "StringLiteral") && eqCol.value === "id")) {
+    flags.push(makeFlag(path, "manual_review", "from.delete.eq_non_id", `from(${JSON.stringify(table)}).delete().eq() filters on a non-id column — PB's delete needs an id; chunk 2 will handle filter-based deletes.`));
+    return;
+  }
+  const replacement = import_jscodeshift.default.callExpression(import_jscodeshift.default.memberExpression(import_jscodeshift.default.callExpression(import_jscodeshift.default.memberExpression(import_jscodeshift.default.identifier(pbName), import_jscodeshift.default.identifier("collection")), [import_jscodeshift.default.literal(table)]), import_jscodeshift.default.identifier("delete")), [eqVal]);
+  applyRewrite(path, replacement, "rewritten", "from.delete", `from(${JSON.stringify(table)}).delete().eq("id", v) → pb.collection(...).delete(v)`, flags, state);
+}
+function flagUnsupportedPatterns(root, supabaseNames, flags) {
+  root.find(import_jscodeshift.default.CallExpression).forEach((path) => {
+    flagOneUnsupported(path, supabaseNames, flags);
+  });
+}
+function flagOneUnsupported(path, supabaseNames, flags) {
+  const root = findChainRoot(path.node);
+  if (!root)
+    return;
+  if (root.type !== "Identifier")
+    return;
+  if (!supabaseNames.has(root.name))
+    return;
+  const parent = path.parent?.node;
+  if (parent?.type === "MemberExpression") {
+    const m = parent;
+    if (m.object === path.node)
+      return;
+  }
+  const steps = readChainSteps(path.node);
+  const first = steps[0];
+  if (!first)
+    return;
+  if (first.method === "storage") {
+    const opStep = findStorageOperation(steps);
+    const opName = opStep?.method ?? "from";
+    flags.push(makeFlag(path, "unsupported", `storage.${opName}`, `supabase.storage.<bucket>.${opName}(...) — PocketBase models files as record-attached fields, not standalone buckets. Rewrite by hand: create a collection with a \`file\` field, then use pb.collection(c).create({ file: blob }) for uploads and pb.files.getURL(record, record.file) for URLs.`));
+    return;
+  }
+  if (first.method === "channel") {
+    flags.push(makeFlag(path, "unsupported", "channel.subscribe", `supabase.channel(...).on(...).subscribe(...) — PB has realtime via pb.collection(c).subscribe("*", cb) but the event shape and filter model differ from Supabase channels. Rewrite by hand.`));
+    return;
+  }
+  if (first.method === "rpc") {
+    const fnName = first.call ? readFirstStringArg(first.call) ?? "<unknown>" : "<unknown>";
+    flags.push(makeFlag(path, "unsupported", "rpc", `supabase.rpc(${JSON.stringify(fnName)}, ...) — Postgres function calls don't have a PocketBase equivalent. Move the logic into your app server code OR a PB hook (.pb_hooks/).`));
+    return;
+  }
+  const invokeStep = steps[1];
+  if (first.method === "functions" && invokeStep?.method === "invoke") {
+    const fnName = invokeStep.call ? readFirstStringArg(invokeStep.call) ?? "<unknown>" : "<unknown>";
+    flags.push(makeFlag(path, "unsupported", "functions.invoke", `supabase.functions.invoke(${JSON.stringify(fnName)}, ...) — Edge Functions don't run on Percher. Move the function code into the Percher app server, or host it on a separate platform (Deno Deploy, Cloudflare Workers) and call it via fetch.`));
+    return;
+  }
+}
+var STORAGE_OPERATIONS = new Set([
+  "upload",
+  "uploadToSignedUrl",
+  "download",
+  "list",
+  "remove",
+  "move",
+  "copy",
+  "createSignedUrl",
+  "createSignedUrls",
+  "createSignedUploadUrl",
+  "getPublicUrl",
+  "update",
+  "exists",
+  "info"
+]);
+var CHAIN_CONTINUATIONS = new Set(["then", "catch", "finally"]);
+function findStorageOperation(steps) {
+  for (const step of steps) {
+    if (STORAGE_OPERATIONS.has(step.method))
+      return step;
+  }
+  for (let i = steps.length - 1;i >= 0; i--) {
+    const step = steps[i];
+    if (!step)
+      continue;
+    if (step.method === "storage" || step.method === "from")
+      continue;
+    if (CHAIN_CONTINUATIONS.has(step.method))
+      continue;
+    return step;
+  }
+  return null;
+}
+function findChainRoot(node) {
+  let cursor = node;
+  while (true) {
+    if (cursor.type === "CallExpression") {
+      const c = cursor;
+      if (c.callee.type !== "MemberExpression")
+        return null;
+      cursor = c.callee.object;
+      continue;
+    }
+    if (cursor.type === "MemberExpression") {
+      cursor = cursor.object;
+      continue;
+    }
+    return cursor;
+  }
+}
+function readChainSteps(outer) {
+  const reversed = [];
+  let cursor = outer;
+  while (true) {
+    if (cursor.type === "CallExpression") {
+      const call = cursor;
+      if (call.callee.type !== "MemberExpression")
+        break;
+      const callee = call.callee;
+      if (callee.property.type === "Identifier") {
+        reversed.push({
+          method: callee.property.name,
+          call
+        });
+      }
+      cursor = callee.object;
+      continue;
+    }
+    if (cursor.type === "MemberExpression") {
+      const m = cursor;
+      if (m.property.type === "Identifier") {
+        reversed.push({
+          method: m.property.name,
+          call: null
+        });
+      }
+      cursor = m.object;
+      continue;
+    }
+    break;
+  }
+  return reversed.reverse();
+}
+function readFirstStringArg(call) {
+  const a = call.arguments[0];
+  if (!a)
+    return null;
+  if (a.type === "Literal" || a.type === "StringLiteral") {
+    const v = a.value;
+    if (typeof v === "string")
+      return v;
+  }
+  return null;
+}
+function findObjectProp(obj, name) {
+  for (const prop of obj.properties) {
+    if ((prop.type === "Property" || prop.type === "ObjectProperty") && "key" in prop && prop.key.type === "Identifier" && prop.key.name === name) {
+      if (prop.shorthand === true) {
+        return import_jscodeshift.default.identifier(name);
+      }
+      if ("value" in prop) {
+        const val = prop.value;
+        if (val.type !== "SpreadElement" && val.type !== "RestElement") {
+          return val;
+        }
+      }
+    }
+  }
+  return null;
+}
+function makeFlag(pathOrLoc, kind, pattern, note) {
+  let line;
+  let column;
+  if ("node" in pathOrLoc) {
+    const loc = pathOrLoc.node.loc;
+    line = loc?.start.line;
+    column = loc?.start.column;
+  } else {
+    line = pathOrLoc.line;
+    column = pathOrLoc.column;
+  }
+  return { kind, pattern, line, column, note };
+}
+function captureLoc(path) {
+  const loc = path.node.loc;
+  return { line: loc?.start.line, column: loc?.start.column };
+}
+function applyRewrite(path, replacement, kind, pattern, note, flags, state) {
+  const loc = captureLoc(path);
+  path.replace(replacement);
+  flags.push(makeFlag(loc, kind, pattern, note));
+  state.mutated = true;
+}
+
+// ../core/dist/commands/migrate-supabase-walker.js
+var REWRITABLE_EXTENSIONS = new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"]);
+var DEFAULT_EXCLUDES = [
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  ".next",
+  ".svelte-kit",
+  ".astro",
+  ".nuxt",
+  ".output",
+  "coverage",
+  ".bun",
+  ".cache",
+  ".turbo",
+  "migration-preview",
+  "pb_data",
+  "pb_migrations"
+];
+async function walkSupabaseProject(input) {
+  const rootAbs = resolve6(input.rootDir);
+  const ig = import_ignore3.default().add(DEFAULT_EXCLUDES);
+  if (input.extraExcludes && input.extraExcludes.length > 0) {
+    ig.add(input.extraExcludes);
+  }
+  const files = [];
+  const skipped = [];
+  for await (const absPath of walkTree(rootAbs, rootAbs, ig)) {
+    const rel = relative3(rootAbs, absPath).split(sep3).join("/");
+    const kind = classifyFile2(rel);
+    if (kind === null)
+      continue;
+    let source;
+    try {
+      source = await readFile3(absPath, "utf8");
+    } catch (err) {
+      skipped.push({
+        relativePath: rel,
+        reason: "read_error",
+        detail: err instanceof Error ? err.message : String(err)
+      });
+      continue;
+    }
+    if (looksBinary(source)) {
+      skipped.push({ relativePath: rel, reason: "binary" });
+      continue;
+    }
+    if (kind === "code") {
+      const sdkResult = rewriteSupabaseSdk({
+        source,
+        filePath: rel,
+        pbIdentifier: input.pbIdentifier,
+        supabaseIdentifiers: input.supabaseIdentifiers
+      });
+      if (sdkResult.parseError !== undefined) {
+        skipped.push({
+          relativePath: rel,
+          reason: "parse_error",
+          detail: sdkResult.parseError
+        });
+        continue;
+      }
+      files.push({
+        relativePath: rel,
+        kind,
+        source,
+        rewritten: sdkResult.rewritten,
+        changed: sdkResult.changed,
+        flags: sdkResult.flags
+      });
+      continue;
+    }
+    const configResult = kind === "package_json" ? rewritePackageJson(source) : rewriteEnvFile(source);
+    files.push({
+      relativePath: rel,
+      kind,
+      source,
+      rewritten: configResult.rewritten,
+      changed: configResult.changed,
+      flags: configResult.flags
+    });
+  }
+  const flagsByPattern = {};
+  let flagCount = 0;
+  let changedFiles = 0;
+  let packageJsonChanged = false;
+  let envFilesChanged = 0;
+  for (const file2 of files) {
+    if (file2.changed) {
+      changedFiles += 1;
+      if (file2.kind === "package_json")
+        packageJsonChanged = true;
+      if (file2.kind === "env")
+        envFilesChanged += 1;
+    }
+    for (const flag of file2.flags) {
+      flagCount += 1;
+      flagsByPattern[flag.pattern] = (flagsByPattern[flag.pattern] ?? 0) + 1;
+    }
+  }
+  return {
+    files,
+    skipped,
+    flagsByPattern,
+    summary: {
+      totalFiles: files.length,
+      changedFiles,
+      flagCount,
+      packageJsonChanged,
+      envFilesChanged
+    }
+  };
+}
+async function* walkTree(dir, rootAbs, ig) {
+  let entries;
+  try {
+    entries = await readdir(dir);
+  } catch {
+    return;
+  }
+  for (const name of entries) {
+    const abs = join17(dir, name);
+    const rel = relative3(rootAbs, abs).split(sep3).join("/");
+    if (rel.length > 0 && ig.ignores(rel))
+      continue;
+    let st;
+    try {
+      st = await stat(abs);
+    } catch {
+      continue;
+    }
+    if (st.isDirectory()) {
+      if (ig.ignores(`${rel}/`))
+        continue;
+      yield* walkTree(abs, rootAbs, ig);
+      continue;
+    }
+    if (st.isFile()) {
+      yield abs;
+    }
+  }
+}
+function classifyFile2(relPath) {
+  const base = relPath.split("/").pop() ?? relPath;
+  if (base === "package.json")
+    return "package_json";
+  if (base === ".env" || base.startsWith(".env."))
+    return "env";
+  const dot = base.lastIndexOf(".");
+  if (dot < 0)
+    return null;
+  const ext = base.slice(dot);
+  if (REWRITABLE_EXTENSIONS.has(ext))
+    return "code";
+  return null;
+}
+function looksBinary(source) {
+  const limit = Math.min(source.length, 8192);
+  for (let i = 0;i < limit; i++) {
+    if (source.charCodeAt(i) === 0)
+      return true;
+  }
+  return false;
+}
+function rewritePackageJson(source) {
+  let pkg;
+  try {
+    pkg = JSON.parse(source);
+  } catch {
+    return { rewritten: source, changed: false, flags: [] };
+  }
+  const depSections = [
+    "dependencies",
+    "devDependencies",
+    "peerDependencies",
+    "optionalDependencies"
+  ];
+  let changed = false;
+  const flags = [];
+  for (const section of depSections) {
+    const deps = pkg[section];
+    if (!deps || typeof deps !== "object" || Array.isArray(deps))
+      continue;
+    const depsObj = deps;
+    if ("@supabase/supabase-js" in depsObj) {
+      delete depsObj["@supabase/supabase-js"];
+      if (!("pocketbase" in depsObj)) {
+        depsObj.pocketbase = "^0.21.0";
+      }
+      changed = true;
+      flags.push({
+        kind: "rewritten",
+        pattern: `package.${section}`,
+        note: `${section}: @supabase/supabase-js → pocketbase`
+      });
+    }
+  }
+  if (!changed) {
+    return { rewritten: source, changed: false, flags: [] };
+  }
+  const rewritten = `${JSON.stringify(pkg, null, 2)}
+`;
+  return { rewritten, changed: true, flags };
+}
+function rewriteEnvFile(source) {
+  const lines = source.split(/\r?\n/);
+  const flags = [];
+  const seenPrefixes = new Set;
+  const outLines = [];
+  let changed = false;
+  const HEADER_MARKER = "# === Percher migration: Supabase → PocketBase ===";
+  if (source.includes(HEADER_MARKER)) {
+    return { rewritten: source, changed: false, flags: [] };
+  }
+  for (const [i, line] of lines.entries()) {
+    const match = line.match(/^\s*([A-Z][A-Z0-9_]*)\s*=(.*)$/);
+    if (!match) {
+      outLines.push(line);
+      continue;
+    }
+    const key = match[1] ?? "";
+    if (!key.includes("SUPABASE")) {
+      outLines.push(line);
+      continue;
+    }
+    const prefix = extractPublicPrefix(key);
+    seenPrefixes.add(prefix);
+    outLines.push(`# was: ${line.trim()}`);
+    flags.push({
+      kind: "rewritten",
+      pattern: "env.supabase_key",
+      line: i + 1,
+      note: `${key} commented out — replace with the appropriate POCKETBASE_URL value.`
+    });
+    changed = true;
+  }
+  if (!changed) {
+    return { rewritten: source, changed: false, flags: [] };
+  }
+  const stubLines = [];
+  stubLines.push(HEADER_MARKER);
+  stubLines.push("# Old SUPABASE_* keys are kept above as `# was:` comments.");
+  stubLines.push("# Fill in the POCKETBASE_URL values below and remove the comments");
+  stubLines.push("# once you've verified the migration.");
+  for (const prefix of [...seenPrefixes].sort()) {
+    const pbKey = prefix ? `${prefix}POCKETBASE_URL` : "POCKETBASE_URL";
+    stubLines.push(`${pbKey}=`);
+  }
+  stubLines.push("");
+  const rewritten = `${stubLines.join(`
+`)}
+${outLines.join(`
+`)}`;
+  return { rewritten, changed: true, flags };
+}
+function extractPublicPrefix(key) {
+  for (const p of [
+    "NEXT_PUBLIC_",
+    "VITE_",
+    "NUXT_PUBLIC_",
+    "PUBLIC_",
+    "REACT_APP_",
+    "VUE_APP_",
+    "EXPO_PUBLIC_"
+  ]) {
+    if (key.startsWith(p))
+      return p;
+  }
+  return "";
+}
+async function writeWalkResult(input) {
+  const targetAbs = resolve6(input.targetDir);
+  const changedOnly = input.changedOnly !== false;
+  const written = [];
+  for (const file2 of input.result.files) {
+    if (changedOnly && !file2.changed)
+      continue;
+    const abs = resolve6(targetAbs, file2.relativePath);
+    const rel = relative3(targetAbs, abs);
+    const isParentTraversal = rel === ".." || rel.startsWith(`..${sep3}`) || rel.startsWith("../");
+    if (rel.length === 0 || isParentTraversal || isAbsolute2(rel)) {
+      throw new Error(`writeWalkResult refused path-traversing file "${file2.relativePath}" → "${abs}" (would escape targetDir "${targetAbs}").`);
+    }
+    await mkdir2(dirname4(abs), { recursive: true });
+    await writeFile2(abs, file2.rewritten, "utf8");
+    written.push(file2.relativePath);
+  }
+  return { written };
+}
+
+// ../core/dist/commands/migrate-supabase-rewrite.js
+var rewriteSupabaseClientInputSchema = exports_external.object({
+  rootDir: exports_external.string().optional().describe("Project root to rewrite. Relative paths resolve against ctx.cwd. Defaults to ctx.cwd."),
+  outputDir: exports_external.string().optional().describe("Where preview-mode writes the rewritten tree. Ignored when `apply` is true. Defaults to `<root>/migration-preview/rewritten`."),
+  apply: exports_external.boolean().optional().describe("When true, overwrite changed files in place (originals backed up to `migration-preview/backup/` first). Default false = preview only."),
+  pbIdentifier: exports_external.string().optional().describe("PocketBase client variable name to emit. Defaults to `pb`."),
+  supabaseIdentifiers: exports_external.array(exports_external.string()).optional().describe("Extra Supabase client variable names to recognise (beyond `supabase`).")
+});
+async function rewriteSupabaseClient(ctx, input) {
+  const rootAbs = input.rootDir ? resolve7(ctx.cwd, input.rootDir) : resolve7(ctx.cwd);
+  const apply = input.apply === true;
+  const mode = apply ? "apply" : "preview";
+  ctx.status(`Scanning ${relative4(ctx.cwd, rootAbs) || "."} for Supabase SDK calls...`);
+  let walk2;
+  try {
+    walk2 = await walkSupabaseProject({
+      rootDir: rootAbs,
+      pbIdentifier: input.pbIdentifier,
+      supabaseIdentifiers: input.supabaseIdentifiers
+    });
+  } catch (err) {
+    return failure2(rootAbs, mode, err, `Couldn't scan ${relative4(ctx.cwd, rootAbs) || "."}: check the path exists and is readable, then re-run.`);
+  }
+  const changed = walk2.files.filter((f) => f.changed);
+  const flags = collectManualFlags(walk2);
+  if (changed.length === 0 && flags.length === 0 && walk2.skipped.length === 0) {
+    return {
+      status: "ok",
+      mode,
+      rootDir: rootAbs,
+      writtenTo: rootAbs,
+      backupDir: null,
+      filesWritten: [],
+      changedCount: 0,
+      flags: [],
+      flagsByPattern: {},
+      packageJsonChanged: false,
+      envFilesChanged: 0,
+      skipped: [],
+      recovery: recoveryNone(),
+      summary: "No Supabase SDK calls found to rewrite. If you intend to keep Supabase as your backend, " + 'set `[data] mode = "supabase"` in percher.toml instead.'
+    };
+  }
+  const reportNeeded = flags.length > 0 || walk2.skipped.length > 0;
+  const backupDir = apply && changed.length > 0 ? join18(rootAbs, "migration-preview", "backup") : null;
+  const rewriteTarget = apply ? rootAbs : input.outputDir ? resolve7(ctx.cwd, input.outputDir) : join18(rootAbs, "migration-preview", "rewritten");
+  const filesWritten = [];
+  try {
+    if (changed.length > 0) {
+      if (apply && backupDir) {
+        ctx.status(`Backing up ${changed.length} original file(s) to migration-preview/backup/...`);
+        await writeWalkResult({
+          result: { ...walk2, files: changed.map((f) => ({ ...f, rewritten: f.source })) },
+          targetDir: backupDir,
+          changedOnly: false
+        });
+      }
+      ctx.status(apply ? `Rewriting ${changed.length} file(s) in place...` : `Writing ${changed.length} rewritten file(s) to migration-preview/rewritten/...`);
+      const out = await writeWalkResult({
+        result: walk2,
+        targetDir: rewriteTarget,
+        changedOnly: true
+      });
+      for (const rel of out.written) {
+        filesWritten.push(relative4(ctx.cwd, join18(rewriteTarget, rel)));
+      }
+    }
+    if (reportNeeded) {
+      const reportAbs = join18(rootAbs, "migration-preview", "REWRITE_NOTES.md");
+      await mkdir3(dirname5(reportAbs), { recursive: true });
+      await writeFile3(reportAbs, renderReport({ flags, skipped: walk2.skipped }), "utf8");
+      filesWritten.push(relative4(ctx.cwd, reportAbs));
+    }
+  } catch (err) {
+    return failure2(rootAbs, mode, err, apply ? "The in-place rewrite failed partway. Your originals are safe — restore from `migration-preview/backup/` and re-run." : "Couldn't write the rewritten preview. Check the output directory is writeable and re-run.");
+  }
+  const flagsByPattern = {};
+  for (const flag of flags) {
+    flagsByPattern[flag.pattern] = (flagsByPattern[flag.pattern] ?? 0) + 1;
+  }
+  const recovery = reportNeeded ? recoveryAsk({ prompt: buildPrompt(flags, walk2.skipped.length), reasonCode: "unknown" }) : recoveryNone();
+  return {
+    status: "ok",
+    mode,
+    rootDir: rootAbs,
+    writtenTo: changed.length > 0 ? rewriteTarget : rootAbs,
+    backupDir,
+    filesWritten,
+    changedCount: changed.length,
+    flags,
+    flagsByPattern,
+    packageJsonChanged: walk2.summary.packageJsonChanged,
+    envFilesChanged: walk2.summary.envFilesChanged,
+    skipped: walk2.skipped,
+    recovery,
+    summary: renderSummary2({ mode, changed: changed.length, walk: walk2, flagCount: flags.length })
+  };
+}
+function collectManualFlags(walk2) {
+  const out = [];
+  for (const file2 of walk2.files) {
+    for (const flag of file2.flags) {
+      if (flag.kind === "manual_review" || flag.kind === "unsupported") {
+        out.push({
+          file: file2.relativePath,
+          line: flag.line,
+          column: flag.column,
+          kind: flag.kind,
+          pattern: flag.pattern,
+          note: flag.note
+        });
+      }
+    }
+  }
+  return out;
+}
+function buildPrompt(flags, skippedCount) {
+  const rewritten = flags.filter((f) => f.kind === "manual_review").length;
+  const untouched = flags.filter((f) => f.kind === "unsupported").length;
+  const bits = [];
+  if (rewritten > 0) {
+    bits.push(`${rewritten} rewritten to PocketBase but with semantics that differ from Supabase`);
+  }
+  if (untouched > 0) {
+    bits.push(`${untouched} left untouched (no PocketBase equivalent — storage, realtime, rpc, or edge functions)`);
+  }
+  if (skippedCount > 0) {
+    bits.push(`${skippedCount} file${skippedCount === 1 ? "" : "s"} couldn't be parsed`);
+  }
+  return `Some locations need review: ${bits.join("; ")}. Each is listed with its file and line in migration-preview/REWRITE_NOTES.md — check them before deploying.`;
+}
+function renderSummary2(args) {
+  const parts = [];
+  if (args.changed > 0) {
+    const where = args.mode === "apply" ? "rewritten in place (originals in `migration-preview/backup/`)" : "written to `migration-preview/rewritten/` for review";
+    parts.push(`${args.changed} file${args.changed === 1 ? "" : "s"} ${where}.`);
+  } else {
+    parts.push("No files needed automatic rewriting.");
+  }
+  if (args.walk.summary.packageJsonChanged) {
+    parts.push("`package.json` swapped `@supabase/supabase-js` → `pocketbase`.");
+  }
+  if (args.walk.summary.envFilesChanged > 0) {
+    parts.push(`${args.walk.summary.envFilesChanged} .env file${args.walk.summary.envFilesChanged === 1 ? "" : "s"} stubbed with PocketBase keys.`);
+  }
+  if (args.flagCount > 0) {
+    parts.push(`${args.flagCount} pattern${args.flagCount === 1 ? "" : "s"} need manual review — see \`migration-preview/REWRITE_NOTES.md\`.`);
+  }
+  if (args.walk.skipped.length > 0) {
+    parts.push(`${args.walk.skipped.length} file${args.walk.skipped.length === 1 ? "" : "s"} couldn't be parsed (listed in \`REWRITE_NOTES.md\`).`);
+  }
+  return parts.join(" ");
+}
+function renderReport(args) {
+  const lines = [];
+  lines.push("# Supabase → PocketBase — review notes");
+  lines.push("");
+  lines.push("The automated rewrite handled auth and CRUD. The locations below still need a human: some were rewritten but their semantics differ from Supabase, others have no PocketBase equivalent and were left untouched. There are no inline markers — work from this list.");
+  lines.push("");
+  const rewritten = args.flags.filter((f) => f.kind === "manual_review");
+  const untouched = args.flags.filter((f) => f.kind === "unsupported");
+  if (rewritten.length > 0) {
+    lines.push("## Rewritten — verify the semantics");
+    lines.push("");
+    lines.push("These calls were converted to PocketBase, but the behaviour isn't identical (event shapes, filter escaping, pagination). Confirm each still does what you intend.");
+    lines.push("");
+    appendFlagsByFile(lines, rewritten);
+  }
+  if (untouched.length > 0) {
+    lines.push("## Left untouched — rewrite by hand");
+    lines.push("");
+    lines.push("These have no clean PocketBase equivalent, so they remain as Supabase calls in your source. Replace each one yourself.");
+    lines.push("");
+    appendFlagsByFile(lines, untouched);
+  }
+  if (args.skipped.length > 0) {
+    lines.push("## Files that couldn't be parsed");
+    lines.push("");
+    lines.push("These were skipped — review them manually for Supabase calls the rewriter missed.");
+    lines.push("");
+    for (const file2 of args.skipped) {
+      lines.push(`- \`${file2.relativePath}\` — ${file2.reason}${file2.detail ? `: ${file2.detail}` : ""}`);
+    }
+    lines.push("");
+  }
+  return lines.join(`
+`);
+}
+function appendFlagsByFile(lines, flags) {
+  const byFile = new Map;
+  for (const flag of flags) {
+    const list = byFile.get(flag.file) ?? [];
+    list.push(flag);
+    byFile.set(flag.file, list);
+  }
+  for (const [file2, fileFlags] of byFile) {
+    lines.push(`### \`${file2}\``);
+    lines.push("");
+    for (const flag of fileFlags) {
+      const loc = flag.line !== undefined ? `L${flag.line}${flag.column !== undefined ? `:${flag.column}` : ""}` : "(location unknown)";
+      lines.push(`- ${loc} \`${flag.pattern}\` — ${flag.note}`);
+    }
+    lines.push("");
+  }
+}
+function failure2(rootAbs, mode, err, suggestion) {
+  const message = err instanceof Error ? err.message : String(err);
+  return {
+    status: "failed",
+    mode,
+    rootDir: rootAbs,
+    writtenTo: rootAbs,
+    backupDir: null,
+    filesWritten: [],
+    changedCount: 0,
+    flags: [],
+    flagsByPattern: {},
+    packageJsonChanged: false,
+    envFilesChanged: 0,
+    skipped: [],
+    recovery: recoveryAsk({
+      prompt: `${suggestion} (${message})`,
+      reasonCode: "unknown",
+      retryable: true
+    }),
+    summary: `Client rewrite failed: ${message}`,
+    error: {
+      code: "rewrite_failed",
+      title: "Supabase client rewrite failed",
+      explanation: message,
+      suggestion
+    }
+  };
+}
 // ../core/dist/commands/migrate-supabase-schema.js
-import { mkdir as mkdir2, writeFile as writeFile2 } from "node:fs/promises";
-import { isAbsolute as isAbsolute2, join as join17, relative as relative3, resolve as resolve6 } from "node:path";
+import { mkdir as mkdir4, writeFile as writeFile4 } from "node:fs/promises";
+import { isAbsolute as isAbsolute3, join as join19, relative as relative5, resolve as resolve8 } from "node:path";
 
 // ../core/dist/commands/migrate-supabase-scripts.js
 function generateDataImportScripts(preview) {
@@ -110860,7 +112661,7 @@ var migrateSupabaseSchemaInputSchema = exports_external.object({
 });
 async function migrateSupabaseSchema(ctx, input) {
   const outputDirAbs = resolveOutputDir(ctx.cwd, input.outputDir);
-  const outputDirRel = relative3(ctx.cwd, outputDirAbs) || ".";
+  const outputDirRel = relative5(ctx.cwd, outputDirAbs) || ".";
   ctx.status(`Inspecting Supabase project ${input.projectRef}...`);
   const inspection = await inspectSupabase(ctx, {
     projectRef: input.projectRef,
@@ -110906,7 +112707,7 @@ async function migrateSupabaseSchema(ctx, input) {
       }
     };
   }
-  const summary = renderSummary2({
+  const summary = renderSummary3({
     projectRef: input.projectRef,
     outputDirRel,
     inspection,
@@ -110924,28 +112725,28 @@ async function migrateSupabaseSchema(ctx, input) {
 }
 function resolveOutputDir(cwd, requested) {
   const raw = requested ?? "./migration-preview";
-  return isAbsolute2(raw) ? raw : resolve6(cwd, raw);
+  return isAbsolute3(raw) ? raw : resolve8(cwd, raw);
 }
 async function writePreviewFiles(ctx, outputDir, preview) {
-  await mkdir2(outputDir, { recursive: true });
+  await mkdir4(outputDir, { recursive: true });
   const schemaJson = renderSchemaJson(preview);
   const notesMd = renderMigrationNotes(preview);
   const scripts = generateDataImportScripts(preview);
-  const schemaPath = join17(outputDir, "pb_schema.json");
-  const notesPath = join17(outputDir, "MIGRATION_NOTES.md");
-  const migratePath = join17(outputDir, "pb_migrate.js");
-  const storagePath = join17(outputDir, "pb_migrate_storage.js");
-  await writeFile2(schemaPath, schemaJson, "utf8");
-  await writeFile2(notesPath, notesMd, "utf8");
-  await writeFile2(migratePath, scripts.pbMigrate, "utf8");
+  const schemaPath = join19(outputDir, "pb_schema.json");
+  const notesPath = join19(outputDir, "MIGRATION_NOTES.md");
+  const migratePath = join19(outputDir, "pb_migrate.js");
+  const storagePath = join19(outputDir, "pb_migrate_storage.js");
+  await writeFile4(schemaPath, schemaJson, "utf8");
+  await writeFile4(notesPath, notesMd, "utf8");
+  await writeFile4(migratePath, scripts.pbMigrate, "utf8");
   const written = [
-    relative3(ctx.cwd, schemaPath),
-    relative3(ctx.cwd, notesPath),
-    relative3(ctx.cwd, migratePath)
+    relative5(ctx.cwd, schemaPath),
+    relative5(ctx.cwd, notesPath),
+    relative5(ctx.cwd, migratePath)
   ];
   if (scripts.pbMigrateStorage !== null) {
-    await writeFile2(storagePath, scripts.pbMigrateStorage, "utf8");
-    written.push(relative3(ctx.cwd, storagePath));
+    await writeFile4(storagePath, scripts.pbMigrateStorage, "utf8");
+    written.push(relative5(ctx.cwd, storagePath));
   }
   return written;
 }
@@ -111094,7 +112895,7 @@ function renderMigrationNotes(preview) {
   return lines.join(`
 `);
 }
-function renderSummary2(args) {
+function renderSummary3(args) {
   const counts = args.preview.summary;
   return [
     `Wrote migration preview for Supabase project ${args.projectRef} to ${args.outputDirRel}/.`,
@@ -111104,29 +112905,6 @@ function renderSummary2(args) {
     "Review `MIGRATION_NOTES.md` before running the import step."
   ].join(" ");
 }
-// ../core/dist/commands/migrate-supabase-sdk.js
-var import_jscodeshift = __toESM(require_core3(), 1);
-var tsx = import_jscodeshift.default.withParser("tsx");
-var STORAGE_OPERATIONS = new Set([
-  "upload",
-  "uploadToSignedUrl",
-  "download",
-  "list",
-  "remove",
-  "move",
-  "copy",
-  "createSignedUrl",
-  "createSignedUrls",
-  "createSignedUploadUrl",
-  "getPublicUrl",
-  "update",
-  "exists",
-  "info"
-]);
-var CHAIN_CONTINUATIONS = new Set(["then", "catch", "finally"]);
-// ../core/dist/commands/migrate-supabase-walker.js
-var import_ignore3 = __toESM(require_ignore(), 1);
-var REWRITABLE_EXTENSIONS = new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"]);
 // ../core/dist/commands/open.js
 var openInputSchema = exports_external.object({
   app: exports_external.string().optional()
@@ -111184,7 +112962,7 @@ async function previewBranchShow(ctx, input = {}) {
 }
 // ../core/dist/commands/publish.js
 import { existsSync as existsSync14 } from "node:fs";
-import { join as join20 } from "node:path";
+import { join as join22 } from "node:path";
 
 // ../shared/dist/pow.js
 import { createHash as createHash3 } from "node:crypto";
@@ -111561,7 +113339,7 @@ async function runDeployWithRetry(opts) {
 
 // ../core/dist/commands/env-scan.js
 import { readdirSync as readdirSync3, readFileSync as readFileSync10, statSync as statSync3 } from "node:fs";
-import { join as join18 } from "node:path";
+import { join as join20 } from "node:path";
 var SOURCE_EXTS = new Set([
   ".ts",
   ".tsx",
@@ -111598,7 +113376,7 @@ function scanForMissingBuildEnvRefs(cwd, existingKeys) {
       continue;
     let content;
     try {
-      content = readFileSync10(join18(cwd, rel), "utf8");
+      content = readFileSync10(join20(cwd, rel), "utf8");
     } catch {
       continue;
     }
@@ -111630,7 +113408,7 @@ function* walkDir(dir, base) {
   for (const name of entries) {
     if (SKIP_DIRS.has(name))
       continue;
-    const full = join18(dir, name);
+    const full = join20(dir, name);
     let st;
     try {
       st = statSync3(full);
@@ -111991,9 +113769,9 @@ function titleFromCode(code) {
 
 // ../core/dist/commands/publish-node.js
 import { existsSync as existsSync13, readFileSync as readFileSync11 } from "node:fs";
-import { join as join19 } from "node:path";
+import { join as join21 } from "node:path";
 function resolveNodeVersion(cwd) {
-  const nvmrc = join19(cwd, ".nvmrc");
+  const nvmrc = join21(cwd, ".nvmrc");
   if (existsSync13(nvmrc)) {
     try {
       const v = readFileSync11(nvmrc, "utf8").trim();
@@ -112001,7 +113779,7 @@ function resolveNodeVersion(cwd) {
         return { value: v, source: ".nvmrc" };
     } catch {}
   }
-  const pkgPath = join19(cwd, "package.json");
+  const pkgPath = join21(cwd, "package.json");
   if (!existsSync13(pkgPath))
     return null;
   try {
@@ -112027,7 +113805,7 @@ var publishInputSchema = exports_external.object({
 var SUSPICIOUS_BYTES = 50 * 1024 * 1024;
 var SUSPICIOUS_FILES = 1e4;
 function tomlPathFor2(cwd) {
-  return join20(cwd, "percher.toml");
+  return join22(cwd, "percher.toml");
 }
 async function buildReplacedResult2(opts) {
   const { ctx, app, deployment, tarball, cwd } = opts;
@@ -112647,13 +114425,11 @@ async function handleAnonymousPublish(ctx, config2, input, tarball) {
       bundle: { fileCount: tarball.fileCount, bytes: tarball.bytes }
     };
   }
-  saveConfig({
-    token: created.token,
-    anonClaim: {
-      app: created.app.name,
-      claimToken: created.claimToken,
-      expiresAt: created.expiresAt
-    }
+  saveConfig({ token: created.token });
+  setAnonClaim({
+    app: created.app.name,
+    claimToken: created.claimToken,
+    expiresAt: created.expiresAt
   });
   const newClient = new PercherClient({
     apiUrl: ctx.client.apiUrl,
@@ -112694,7 +114470,7 @@ async function handleAnonymousPublish(ctx, config2, input, tarball) {
   };
 }
 async function loadOrGenerate(ctx) {
-  const tomlPath = join20(ctx.cwd, "percher.toml");
+  const tomlPath = join22(ctx.cwd, "percher.toml");
   if (!existsSync14(tomlPath)) {
     ctx.status("No percher.toml found — detecting framework...");
     await init(ctx);
@@ -112745,7 +114521,7 @@ function emitPreflight(ctx, config2, tarball) {
 }
 // ../core/dist/commands/push.js
 import { existsSync as existsSync15 } from "node:fs";
-import { join as join21 } from "node:path";
+import { join as join23 } from "node:path";
 var pushInputSchema = exports_external.object({
   dryRun: exports_external.boolean().optional(),
   force: exports_external.boolean().optional(),
@@ -112756,7 +114532,7 @@ var SUSPICIOUS_BYTES2 = 50 * 1024 * 1024;
 var SUSPICIOUS_FILES2 = 1e4;
 var PLACEHOLDER_PREFIXES = ["add-your-", "your-key-here"];
 async function loadOrGenerate2(ctx) {
-  const tomlPath = join21(ctx.cwd, "percher.toml");
+  const tomlPath = join23(ctx.cwd, "percher.toml");
   if (!existsSync15(tomlPath)) {
     ctx.status("No percher.toml found — detecting framework...");
     const result = await init(ctx);
@@ -112868,7 +114644,7 @@ async function push(ctx, input = {}, internals = {}) {
       fileCount: tarball.fileCount,
       recovery: RECOVERY_NONE,
       summary: `Dry run for ${config2.app.name}: ${tarball.fileCount} files, ${(tarball.bytes / 1024).toFixed(1)} KB — no deploy performed.`,
-      configPath: join21(ctx.cwd, "percher.toml"),
+      configPath: join23(ctx.cwd, "percher.toml"),
       bundle: { fileCount: tarball.fileCount, bytes: tarball.bytes }
     };
   }
@@ -113051,7 +114827,7 @@ ${deployment.errorMessage}` : "";
     fileCount: tarball.fileCount,
     recovery: RECOVERY_NONE,
     summary,
-    configPath: join21(ctx.cwd, "percher.toml"),
+    configPath: join23(ctx.cwd, "percher.toml"),
     bundle: { fileCount: tarball.fileCount, bytes: tarball.bytes }
   };
 }
@@ -113381,7 +115157,7 @@ function failureResult(error48) {
 }
 // ../core/dist/commands/rename.js
 import { existsSync as existsSync16, readFileSync as readFileSync12, writeFileSync as writeFileSync8 } from "node:fs";
-import { join as join22 } from "node:path";
+import { join as join24 } from "node:path";
 var renameInputSchema = exports_external.object({
   app: exports_external.string().optional(),
   name: exports_external.string().min(3).max(40)
@@ -113401,7 +115177,7 @@ async function rename2(ctx, input) {
   };
 }
 function updateLocalTomlName(cwd, oldName, newName) {
-  const p = join22(cwd, "percher.toml");
+  const p = join24(cwd, "percher.toml");
   if (!existsSync16(p))
     return false;
   try {
@@ -113418,18 +115194,18 @@ function updateLocalTomlName(cwd, oldName, newName) {
   }
 }
 // ../core/dist/commands/reproduce.js
-import { spawn } from "node:child_process";
 import { mkdtempSync, writeFileSync as writeFileSync9 } from "node:fs";
 import { tmpdir } from "node:os";
-import { join as join23 } from "node:path";
+import { join as join25 } from "node:path";
+var import_cross_spawn = __toESM(require_cross_spawn(), 1);
 function runProcessExit(cmd, args, opts = {}) {
-  return new Promise((resolve7, reject) => {
-    const child = spawn(cmd, args, {
+  return new Promise((resolve9, reject) => {
+    const child = import_cross_spawn.default(cmd, args, {
       cwd: opts.cwd,
       stdio: opts.inherit ? "inherit" : "ignore"
     });
     child.on("error", reject);
-    child.on("close", (code) => resolve7(code ?? 1));
+    child.on("close", (code) => resolve9(code ?? 1));
   });
 }
 var reproduceInputSchema = exports_external.object({
@@ -113515,8 +115291,8 @@ async function reproduce(ctx, input) {
     const envMap = await ctx.client.env.list(app.id);
     currentAppEnvKeys = Object.keys(envMap).sort();
   } catch {}
-  const tmpDir = mkdtempSync(join23(tmpdir(), `percher-reproduce-${input.deployId}-`));
-  const tarballPath = join23(tmpDir, "source.tar.gz");
+  const tmpDir = mkdtempSync(join25(tmpdir(), `percher-reproduce-${input.deployId}-`));
+  const tarballPath = join25(tmpDir, "source.tar.gz");
   writeFileSync9(tarballPath, bytes);
   let extracted = false;
   try {
@@ -114856,8 +116632,8 @@ function registerAppsCommands(cli, ctx) {
             deployId,
             timeoutSeconds: Math.min(Math.ceil(remainingMs / 1000), 30)
           }, { signal: callController.signal }),
-          new Promise((resolve7) => {
-            raceTimer = setTimeout(() => resolve7(null), remainingMs);
+          new Promise((resolve9) => {
+            raceTimer = setTimeout(() => resolve9(null), remainingMs);
           })
         ]);
       } finally {
@@ -115323,8 +117099,8 @@ function registerDeploysCommands(cli, ctx, argv) {
     const { summary, files } = result;
     await writeLine(ctx, `${summary.filesChanged} file${summary.filesChanged === 1 ? "" : "s"} changed · ${import_picocolors7.default.green(`+${summary.additions}`)} ${import_picocolors7.default.red(`−${summary.deletions}`)}  (${result.base.slice(0, 10)} → ${result.head.slice(0, 10)})`);
     for (const f of files) {
-      const stat = f.binary ? import_picocolors7.default.dim("binary") : `${import_picocolors7.default.green(`+${f.additions}`)} ${import_picocolors7.default.red(`−${f.deletions}`)}`;
-      await writeLine(ctx, `  ${f.status}  ${f.path}  ${stat}${f.truncated ? import_picocolors7.default.dim(" (truncated)") : ""}`);
+      const stat2 = f.binary ? import_picocolors7.default.dim("binary") : `${import_picocolors7.default.green(`+${f.additions}`)} ${import_picocolors7.default.red(`−${f.deletions}`)}`;
+      await writeLine(ctx, `  ${f.status}  ${f.path}  ${stat2}${f.truncated ? import_picocolors7.default.dim(" (truncated)") : ""}`);
       if (options.patch && f.patch) {
         await writeLine(ctx, f.patch.replace(/\n$/, ""));
       }
@@ -115396,7 +117172,7 @@ function registerEnvCommands(cli, ctx) {
     if (action === "set") {
       const { resolveEnvSetInputs: resolveEnvSetInputs2, EnvSetInputError: EnvSetInputError2 } = await Promise.resolve().then(() => (init_env_set_input(), exports_env_set_input));
       const { promptHidden: promptHidden2 } = await Promise.resolve().then(() => (init_prompt_hidden(), exports_prompt_hidden));
-      const { readFile: readFile3 } = await import("node:fs/promises");
+      const { readFile: readFile4 } = await import("node:fs/promises");
       try {
         const values = await resolveEnvSetInputs2({
           args,
@@ -115408,7 +117184,7 @@ function registerEnvCommands(cli, ctx) {
               chunks.push(c);
             return Buffer.concat(chunks).toString("utf8");
           },
-          readFile: async (p) => readFile3(p, "utf8"),
+          readFile: async (p) => readFile4(p, "utf8"),
           promptHidden: promptHidden2
         });
         await envSet(ctx, { app: options.app, values });
@@ -115522,9 +117298,13 @@ function registerGithubCommands(cli, ctx) {
 // src/commands/migrate.ts
 var import_picocolors11 = __toESM(require_picocolors(), 1);
 function registerMigrateCommands(cli, ctx) {
-  cli.command("migrate-from-supabase", "Migrate a Supabase project to PocketBase (FUTURE9 Phase A read-only + Phase B preview writes)").option("--project <ref>", "Supabase project reference (the 20-char id from the project URL)").option("--token <token>", "Supabase personal access token (sbp_...). Read from SUPABASE_ACCESS_TOKEN if omitted.").option("--inspect-only", "Run schema introspection only (Phase A — read-only, no file writes)").option("--output-dir <dir>", "Where to write the Phase B preview files (default: ./migration-preview/)").option("--json", "Output the structured result as JSON").action(async (options) => {
+  cli.command("migrate-from-supabase", "Migrate a Supabase project to PocketBase: schema + data-import script, optionally rewrite SDK calls").option("--project <ref>", "Supabase project reference (the 20-char id from the project URL)").option("--token <token>", "Supabase personal access token (sbp_...). Read from SUPABASE_ACCESS_TOKEN if omitted.").option("--inspect-only", "Only print the schema that would migrate — read-only, no file writes").option("--output-dir <dir>", "Where to write the preview files (default: ./migration-preview/)").option("--rewrite-client", "Also convert your Supabase SDK calls to PocketBase across the project").option("--apply", "With --rewrite-client: overwrite files in place (originals backed up first). Default: preview only.").option("--root <dir>", "Project root to rewrite with --rewrite-client (default: current directory)").option("--json", "Output the structured result as JSON").action(async (options) => {
     const projectRef = options.project;
     const token = options.token ?? ctx.env.SUPABASE_ACCESS_TOKEN;
+    if (options.apply && !options.rewriteClient) {
+      await writeLine(ctx, `${import_picocolors11.default.red("✗")} --apply only applies to the client rewrite. Pass --rewrite-client --apply together.`);
+      throw new SilentExitError(1);
+    }
     if (!projectRef) {
       await writeLine(ctx, `${import_picocolors11.default.red("✗")} Missing --project. Pass your Supabase project ref (e.g. --project abcdefghijklmnopqrst).`);
       throw new SilentExitError(1);
@@ -115551,15 +117331,28 @@ function registerMigrateCommands(cli, ctx) {
       token,
       outputDir: options.outputDir
     });
+    let rewrite;
+    if (options.rewriteClient && result.status === "ok") {
+      rewrite = await rewriteSupabaseClient(ctx, {
+        rootDir: options.root,
+        apply: options.apply === true
+      });
+    }
     if (options.json) {
-      await writeLine(ctx, JSON.stringify(result, null, 2));
-      if (result.status === "failed")
+      await writeLine(ctx, JSON.stringify(rewrite ? { schema: result, rewrite } : result, null, 2));
+      if (result.status === "failed" || rewrite?.status === "failed") {
         throw new SilentExitError(1);
+      }
       return;
     }
-    await renderSchemaHuman(ctx, result);
-    if (result.status === "failed")
+    await renderSchemaHuman(ctx, result, {
+      clientRewriteRequested: options.rewriteClient === true
+    });
+    if (rewrite)
+      await renderRewriteHuman(ctx, rewrite);
+    if (result.status === "failed" || rewrite?.status === "failed") {
       throw new SilentExitError(1);
+    }
   });
 }
 async function renderInspectHuman(ctx, result) {
@@ -115605,9 +117398,9 @@ async function renderInspectHuman(ctx, result) {
     }
   }
   await writeLine(ctx, "");
-  await writeLine(ctx, import_picocolors11.default.dim("--inspect-only is read-only. Drop the flag to also write the Phase B PocketBase-schema preview."));
+  await writeLine(ctx, import_picocolors11.default.dim("--inspect-only is read-only. Drop the flag to also write the PocketBase schema preview + pb_migrate.js data-import script to ./migration-preview/."));
 }
-async function renderSchemaHuman(ctx, result) {
+async function renderSchemaHuman(ctx, result, opts) {
   if (result.status === "failed") {
     const err = result.error;
     await writeLine(ctx, `${import_picocolors11.default.red("✗")} ${err?.title ?? "Migration preview failed"}`);
@@ -115646,7 +117439,55 @@ async function renderSchemaHuman(ctx, result) {
     }
   }
   await writeLine(ctx, "");
-  await writeLine(ctx, import_picocolors11.default.dim("Phase B is a preview. Phase C (data import) and Phase D (client rewrite) ship in later releases. Review MIGRATION_NOTES.md before any import."));
+  await writeLine(ctx, import_picocolors11.default.dim("Preview only — nothing has touched your PocketBase yet. ./migration-preview/ includes pb_migrate.js, the data-import script: review MIGRATION_NOTES.md, then run it against your app's PocketBase to copy your rows over."));
+  if (!opts.clientRewriteRequested) {
+    await writeLine(ctx, import_picocolors11.default.dim("Add --rewrite-client to also convert your Supabase SDK calls to PocketBase (preview first; --apply writes in place)."));
+  }
+}
+async function renderRewriteHuman(ctx, result) {
+  await writeLine(ctx, "");
+  if (result.status === "failed") {
+    const err = result.error;
+    await writeLine(ctx, `${import_picocolors11.default.red("✗")} ${err?.title ?? "Client rewrite failed"}`);
+    if (err?.explanation)
+      await writeLine(ctx, `  ${err.explanation}`);
+    if (err?.suggestion)
+      await writeLine(ctx, import_picocolors11.default.dim(`  ${err.suggestion}`));
+    return;
+  }
+  await writeLine(ctx, `${import_picocolors11.default.green("✓")} ${result.summary}`);
+  if (result.filesWritten.length > 0) {
+    await writeLine(ctx, "");
+    await writeLine(ctx, import_picocolors11.default.bold("Files written"));
+    for (const path of result.filesWritten.slice(0, 20)) {
+      await writeLine(ctx, `  ${import_picocolors11.default.cyan(path)}`);
+    }
+    if (result.filesWritten.length > 20) {
+      await writeLine(ctx, import_picocolors11.default.dim(`  …and ${result.filesWritten.length - 20} more`));
+    }
+  }
+  if (result.flags.length > 0) {
+    await writeLine(ctx, "");
+    await writeLine(ctx, import_picocolors11.default.bold("Needs review (see migration-preview/REWRITE_NOTES.md)"));
+    for (const flag of result.flags.slice(0, 15)) {
+      const loc = flag.line !== undefined ? `:${flag.line}` : "";
+      const tag = flag.kind === "manual_review" ? "rewritten, verify semantics" : "left untouched";
+      await writeLine(ctx, `  ${import_picocolors11.default.yellow("⚠")} ${import_picocolors11.default.cyan(`${flag.file}${loc}`)} ${flag.pattern} ${import_picocolors11.default.dim(`(${tag}) — ${flag.note}`)}`);
+    }
+    if (result.flags.length > 15) {
+      await writeLine(ctx, import_picocolors11.default.dim(`  …and ${result.flags.length - 15} more — see REWRITE_NOTES.md`));
+    }
+  }
+  if (result.skipped.length > 0) {
+    await writeLine(ctx, import_picocolors11.default.dim(`
+${result.skipped.length} file(s) couldn't be parsed and were skipped — listed in REWRITE_NOTES.md.`));
+  }
+  await writeLine(ctx, "");
+  if (result.mode === "apply") {
+    await writeLine(ctx, import_picocolors11.default.dim(result.changedCount > 0 ? "Files rewritten in place. Originals are in ./migration-preview/backup/ — diff against them (or git) before committing." : "No files were rewritten — the work left is the manual review above."));
+  } else {
+    await writeLine(ctx, import_picocolors11.default.dim(result.changedCount > 0 ? "Preview only — diff ./migration-preview/rewritten/ against your project, then re-run with --rewrite-client --apply to write in place." : "Preview only — no files needed automatic rewriting; work through the manual review above."));
+  }
 }
 
 // src/commands/sharing.ts
@@ -115871,16 +117712,16 @@ function registerTransfersCommands(cli, ctx) {
 }
 
 // src/open.ts
-import { spawn as spawn2 } from "node:child_process";
+import { spawn } from "node:child_process";
 async function openUrl(url2) {
   const platform = process.platform;
   try {
     if (platform === "darwin")
-      spawn2("open", [url2], { detached: true, stdio: "ignore" }).unref();
+      spawn("open", [url2], { detached: true, stdio: "ignore" }).unref();
     else if (platform === "win32")
-      spawn2("cmd", ["/c", "start", "", url2], { detached: true, stdio: "ignore" }).unref();
+      spawn("cmd", ["/c", "start", "", url2], { detached: true, stdio: "ignore" }).unref();
     else
-      spawn2("xdg-open", [url2], { detached: true, stdio: "ignore" }).unref();
+      spawn("xdg-open", [url2], { detached: true, stdio: "ignore" }).unref();
   } catch {}
 }
 
@@ -115987,7 +117828,7 @@ async function renderError(stderr, error48) {
 // package.json
 var package_default = {
   name: "percher",
-  version: "0.5.5",
+  version: "0.5.7",
   description: "CLI for the Percher hosting platform — publish apps with one command",
   type: "module",
   bin: {
@@ -116069,9 +117910,9 @@ async function showTelemetryNotice() {
     return;
   const { homedir: homedir2 } = await import("node:os");
   const { existsSync: existsSync17, mkdirSync: mkdirSync6, writeFileSync: writeFileSync10 } = await import("node:fs");
-  const { join: join24 } = await import("node:path");
-  const configDir = join24(homedir2(), ".percher");
-  const markerFile = join24(configDir, ".telemetry-notice-shown");
+  const { join: join26 } = await import("node:path");
+  const configDir = join26(homedir2(), ".percher");
+  const markerFile = join26(configDir, ".telemetry-notice-shown");
   if (existsSync17(markerFile))
     return;
   console.log("Percher sends non-account-linked usage stats (command, result, error type, OS, Bun version).");