pinme 2.0.9 → 2.0.10-beta.2

package/dist/index.js

@@ -103,8 +103,8 @@ var require_package = __commonJS({
 // node_modules/.pnpm/dotenv@16.5.0/node_modules/dotenv/lib/main.js
 var require_main = __commonJS({
   "node_modules/.pnpm/dotenv@16.5.0/node_modules/dotenv/lib/main.js"(exports2, module2) {
-    var fs17 = require("fs");
-    var path18 = require("path");
+    var fs18 = require("fs");
+    var path19 = require("path");
     var os6 = require("os");
     var crypto3 = require("crypto");
     var packageJson = require_package();
@@ -207,7 +207,7 @@ var require_main = __commonJS({
       if (options && options.path && options.path.length > 0) {
         if (Array.isArray(options.path)) {
           for (const filepath of options.path) {
-            if (fs17.existsSync(filepath)) {
+            if (fs18.existsSync(filepath)) {
               possibleVaultPath = filepath.endsWith(".vault") ? filepath : `${filepath}.vault`;
             }
           }
@@ -215,15 +215,15 @@ var require_main = __commonJS({
           possibleVaultPath = options.path.endsWith(".vault") ? options.path : `${options.path}.vault`;
         }
       } else {
-        possibleVaultPath = path18.resolve(process.cwd(), ".env.vault");
+        possibleVaultPath = path19.resolve(process.cwd(), ".env.vault");
       }
-      if (fs17.existsSync(possibleVaultPath)) {
+      if (fs18.existsSync(possibleVaultPath)) {
         return possibleVaultPath;
       }
       return null;
     }
     function _resolveHome(envPath) {
-      return envPath[0] === "~" ? path18.join(os6.homedir(), envPath.slice(1)) : envPath;
+      return envPath[0] === "~" ? path19.join(os6.homedir(), envPath.slice(1)) : envPath;
     }
     function _configVault(options) {
       const debug = Boolean(options && options.debug);
@@ -239,7 +239,7 @@ var require_main = __commonJS({
       return { parsed };
     }
     function configDotenv(options) {
-      const dotenvPath = path18.resolve(process.cwd(), ".env");
+      const dotenvPath = path19.resolve(process.cwd(), ".env");
       let encoding = "utf8";
       const debug = Boolean(options && options.debug);
       if (options && options.encoding) {
@@ -262,13 +262,13 @@ var require_main = __commonJS({
       }
       let lastError;
       const parsedAll = {};
-      for (const path19 of optionPaths) {
+      for (const path20 of optionPaths) {
         try {
-          const parsed = DotenvModule.parse(fs17.readFileSync(path19, { encoding }));
+          const parsed = DotenvModule.parse(fs18.readFileSync(path20, { encoding }));
           DotenvModule.populate(parsedAll, parsed, options);
         } catch (e) {
           if (debug) {
-            _debug(`Failed to load ${path19} ${e.message}`);
+            _debug(`Failed to load ${path20} ${e.message}`);
           }
           lastError = e;
         }
@@ -828,9 +828,9 @@ function isVisitable(thing) {
 function removeBrackets(key) {
   return utils_default.endsWith(key, "[]") ? key.slice(0, -2) : key;
 }
-function renderKey(path18, key, dots) {
-  if (!path18) return key;
-  return path18.concat(key).map(function each(token, i) {
+function renderKey(path19, key, dots) {
+  if (!path19) return key;
+  return path19.concat(key).map(function each(token, i) {
     token = removeBrackets(token);
     return !dots && i ? "[" + token + "]" : token;
   }).join(dots ? "." : "");
@@ -872,9 +872,9 @@ function toFormData(obj, formData, options) {
     }
     return value;
   }
-  function defaultVisitor(value, key, path18) {
+  function defaultVisitor(value, key, path19) {
     let arr = value;
-    if (value && !path18 && typeof value === "object") {
+    if (value && !path19 && typeof value === "object") {
       if (utils_default.endsWith(key, "{}")) {
         key = metaTokens ? key : key.slice(0, -2);
         value = JSON.stringify(value);
@@ -893,7 +893,7 @@ function toFormData(obj, formData, options) {
     if (isVisitable(value)) {
       return true;
     }
-    formData.append(renderKey(path18, key, dots), convertValue(value));
+    formData.append(renderKey(path19, key, dots), convertValue(value));
     return false;
   }
   const stack = [];
@@ -902,10 +902,10 @@ function toFormData(obj, formData, options) {
     convertValue,
     isVisitable
   });
-  function build(value, path18) {
+  function build(value, path19) {
     if (utils_default.isUndefined(value)) return;
     if (stack.indexOf(value) !== -1) {
-      throw Error("Circular reference detected in " + path18.join("."));
+      throw Error("Circular reference detected in " + path19.join("."));
     }
     stack.push(value);
     utils_default.forEach(value, function each(el, key) {
@@ -913,11 +913,11 @@ function toFormData(obj, formData, options) {
         formData,
         el,
         utils_default.isString(key) ? key.trim() : key,
-        path18,
+        path19,
         exposedHelpers
       );
       if (result === true) {
-        build(el, path18 ? path18.concat(key) : [key]);
+        build(el, path19 ? path19.concat(key) : [key]);
       }
     });
     stack.pop();
@@ -1137,7 +1137,7 @@ var init_platform = __esm({
 // node_modules/.pnpm/axios@1.3.2/node_modules/axios/lib/helpers/toURLEncodedForm.js
 function toURLEncodedForm(data, options) {
   return toFormData_default(data, new node_default.classes.URLSearchParams(), Object.assign({
-    visitor: function(value, key, path18, helpers) {
+    visitor: function(value, key, path19, helpers) {
       if (node_default.isNode && utils_default.isBuffer(value)) {
         this.append(key, value.toString("base64"));
         return false;
@@ -1174,10 +1174,10 @@ function arrayToObject(arr) {
   return obj;
 }
 function formDataToJSON(formData) {
-  function buildPath(path18, value, target, index) {
-    let name = path18[index++];
+  function buildPath(path19, value, target, index) {
+    let name = path19[index++];
     const isNumericKey = Number.isFinite(+name);
-    const isLast = index >= path18.length;
+    const isLast = index >= path19.length;
     name = !name && utils_default.isArray(target) ? target.length : name;
     if (isLast) {
       if (utils_default.hasOwnProp(target, name)) {
@@ -1190,7 +1190,7 @@ function formDataToJSON(formData) {
     if (!target[name] || !utils_default.isObject(target[name])) {
       target[name] = [];
     }
-    const result = buildPath(path18, value, target[name], index);
+    const result = buildPath(path19, value, target[name], index);
     if (result && utils_default.isArray(target[name])) {
       target[name] = arrayToObject(target[name]);
     }
@@ -3516,9 +3516,9 @@ var init_http = __esm({
           auth = urlUsername + ":" + urlPassword;
         }
         auth && headers.delete("authorization");
-        let path18;
+        let path19;
         try {
-          path18 = buildURL(
+          path19 = buildURL(
             parsed.pathname + parsed.search,
             config.params,
             config.paramsSerializer
@@ -3536,7 +3536,7 @@ var init_http = __esm({
           false
         );
         const options = {
-          path: path18,
+          path: path19,
           method,
           headers: headers.toJSON(),
           agents: { http: config.httpAgent, https: config.httpsAgent },
@@ -3763,14 +3763,14 @@ var init_cookies = __esm({
       // Standard browser envs support document.cookie
       /* @__PURE__ */ function standardBrowserEnv() {
         return {
-          write: function write(name, value, expires, path18, domain, secure) {
+          write: function write(name, value, expires, path19, domain, secure) {
             const cookie = [];
             cookie.push(name + "=" + encodeURIComponent(value));
             if (utils_default.isNumber(expires)) {
               cookie.push("expires=" + new Date(expires).toGMTString());
             }
-            if (utils_default.isString(path18)) {
-              cookie.push("path=" + path18);
+            if (utils_default.isString(path19)) {
+              cookie.push("path=" + path19);
             }
             if (utils_default.isString(domain)) {
               cookie.push("domain=" + domain);
@@ -5978,7 +5978,7 @@ var import_chalk26 = __toESM(require("chalk"));
 var import_figlet5 = __toESM(require("figlet"));
 
 // package.json
-var version = "2.0.9";
+var version = "2.0.10-beta.2";
 
 // bin/upload.ts
 var import_path7 = __toESM(require("path"));
@@ -6089,6 +6089,8 @@ var import_fs2 = __toESM(require("fs"));
 var import_path4 = __toESM(require("path"));
 var import_child_process2 = require("child_process");
 var REQUEST_TIMEOUT_MS = 1500;
+var TRACK_VALUE_LIMIT = 200;
+var TRACK_REASON_LIMIT = 255;
 var DEFAULT_GATEWAY = "https://pinme.dev";
 var DEFAULT_PRODUCT = "pinme-cli";
 var ACTION_OVERRIDES = {
@@ -6106,6 +6108,12 @@ var ACTION_OVERRIDES = {
   upload_history_cleared: "click",
   upload_history_failed: "fail"
 };
+var EV_OVERRIDES = {
+  upload_success: "upload",
+  upload_failed: "upload",
+  project_save_success: "project_save",
+  project_save_failed: "project_save"
+};
 var TRACK_CHILD_SCRIPT = `
 const rawUrl = process.argv[1];
 if (!rawUrl) process.exit(0);
@@ -6132,11 +6140,11 @@ function trimTrailingSlash2(value) {
 function shouldDisableTracking() {
   return process.env.PINME_TRACKING_DISABLED === "1" || process.env.DO_NOT_TRACK === "1";
 }
-function sanitizeTrackValue(value) {
+function sanitizeTrackValue(value, maxLength = TRACK_VALUE_LIMIT) {
   if (value === void 0 || value === null) {
     return void 0;
   }
-  return String(value).trim().slice(0, 200);
+  return String(value).trim().slice(0, maxLength);
 }
 function getTrackErrorReason(error) {
   var _a2, _b, _c, _d, _e;
@@ -6171,6 +6179,12 @@ function resolveTrackAction(event, data = {}) {
   }
   return "view";
 }
+function resolveTrackEvent(event) {
+  return EV_OVERRIDES[event] || event;
+}
+function resolveTrackReason(data) {
+  return sanitizeTrackValue(data.re || data.reason, TRACK_REASON_LIMIT);
+}
 var cachedProjectContext = null;
 var cachedProjectContextCwd = null;
 function resolveProjectContext() {
@@ -6248,6 +6262,7 @@ var Tracker = class _Tracker {
   buildPayload(event, page, data) {
     const projectContext = resolveProjectContext();
     const action = resolveTrackAction(event, data);
+    const ev = resolveTrackEvent(event);
     const payload = {
       ...data,
       u: getUid(),
@@ -6255,9 +6270,10 @@ var Tracker = class _Tracker {
       pd: this.product,
       p: page,
       a: action,
-      ev: event,
+      ev,
       event,
-      project_name: projectContext.projectName,
+      re: resolveTrackReason(data),
+      project_name: projectContext.projectName || data.project_name,
       project_dir: projectContext.projectDir,
       cli_version: version,
       node_version: process.version,
@@ -6266,7 +6282,10 @@ var Tracker = class _Tracker {
     };
     const filtered = {};
     for (const [key, value] of Object.entries(payload)) {
-      const normalized = sanitizeTrackValue(value);
+      const normalized = sanitizeTrackValue(
+        value,
+        key === "re" ? TRACK_REASON_LIMIT : TRACK_VALUE_LIMIT
+      );
       if (normalized) {
         filtered[key] = normalized;
       }
@@ -9035,6 +9054,7 @@ async function loginCmd(options = {}) {
     void tracker_default.trackEvent(TRACK_EVENTS.cliLoginSuccess, TRACK_PAGES.login, {
       a: resolveTrackAction2(TRACK_EVENTS.cliLoginSuccess),
       env,
+      source: "cli",
       has_token_address: true,
       merged_anonymous_history: ok
     });
@@ -9043,6 +9063,7 @@ async function loginCmd(options = {}) {
     void tracker_default.trackEvent(TRACK_EVENTS.cliLoginFailed, TRACK_PAGES.login, {
       a: resolveTrackAction2(TRACK_EVENTS.cliLoginFailed),
       env,
+      source: "cli",
       reason: getTrackErrorReason(e)
     });
     console.log(import_chalk18.default.red(`
@@ -9053,8 +9074,8 @@ Login failed: ${(e == null ? void 0 : e.message) || e}`));
 
 // bin/create.ts
 var import_chalk20 = __toESM(require("chalk"));
-var import_fs_extra6 = __toESM(require("fs-extra"));
-var import_path12 = __toESM(require("path"));
+var import_fs_extra7 = __toESM(require("fs-extra"));
+var import_path13 = __toESM(require("path"));
 var import_inquirer8 = __toESM(require("inquirer"));
 init_axios2();
 var import_adm_zip = __toESM(require("adm-zip"));
@@ -9069,8 +9090,24 @@ var import_chalk19 = __toESM(require("chalk"));
 var import_child_process3 = require("child_process");
 var INSTALL_TIMEOUT_MS = 10 * 60 * 1e3;
 var SLOW_INSTALL_NOTICE_MS = 60 * 1e3;
+var CAPTURED_OUTPUT_LIMIT = 12e3;
+var STALE_LOG_ONLY_MARKER_MS = 90 * 1e3;
+var STOP_BACKGROUND_GRACE_MS = 3e3;
+var STOP_BACKGROUND_KILL_GRACE_MS = 2e3;
+var STOP_BACKGROUND_POLL_MS = 200;
 var INSTALL_LOG_FILE = ".pinme-install.log";
 var INSTALL_EXITCODE_FILE = ".pinme-install.exitcode";
+var INSTALL_PID_FILE = ".pinme-install.pid";
+var DependencyInstallError = class extends Error {
+  command;
+  constructor(command, cause) {
+    const reason = cause instanceof Error ? cause.message : String(cause);
+    super(`${command} failed: ${reason}`);
+    this.name = "DependencyInstallError";
+    this.command = command;
+    this.cause = cause;
+  }
+};
 function makeTempCacheDir() {
   return import_fs_extra5.default.mkdtempSync(import_path11.default.join(import_os5.default.tmpdir(), "pinme-npm-cache-"));
 }
@@ -9090,10 +9127,8 @@ function getInstallScript(cwd, mode) {
   return hasPackageLock(cwd) ? "ci" : "install";
 }
 function getInstallArgs(script, cacheDir) {
-  return [
+  const args = [
     script,
-    "--cache",
-    cacheDir,
     "--no-audit",
     "--no-fund",
     "--fetch-retries=3",
@@ -9102,6 +9137,100 @@ function getInstallArgs(script, cacheDir) {
     "--fetch-retry-maxtimeout=60000",
     "--fetch-timeout=60000"
   ];
+  if (cacheDir) {
+    args.splice(1, 0, "--cache", cacheDir);
+  }
+  return args;
+}
+function formatInstallCommand(script, cacheMode = "default") {
+  const parts = [
+    `npm ${script}`,
+    "--no-audit",
+    "--no-fund",
+    "--fetch-retries=3",
+    "--fetch-timeout=60000"
+  ];
+  if (cacheMode === "isolated") {
+    parts.splice(1, 0, "--cache <isolated npm cache>");
+  }
+  return parts.join(" ");
+}
+function appendCapturedOutput(output, chunk) {
+  const next = output + chunk.toString();
+  if (next.length <= CAPTURED_OUTPUT_LIMIT) {
+    return next;
+  }
+  return next.slice(next.length - CAPTURED_OUTPUT_LIMIT);
+}
+function runInstall(cwd, script, cacheDir) {
+  const npm = getNpmCommand();
+  const args = getInstallArgs(script, cacheDir);
+  const env = {
+    ...process.env,
+    npm_config_audit: "false",
+    npm_config_fund: "false",
+    npm_config_fetch_retries: "3",
+    npm_config_fetch_retry_factor: "2",
+    npm_config_fetch_retry_mintimeout: "10000",
+    npm_config_fetch_retry_maxtimeout: "60000",
+    npm_config_fetch_timeout: "60000"
+  };
+  if (cacheDir) {
+    env.npm_config_cache = cacheDir;
+  }
+  return new Promise((resolve, reject) => {
+    var _a2, _b;
+    let capturedOutput = "";
+    let settled = false;
+    let timedOut = false;
+    const child = (0, import_child_process3.spawn)(npm, args, {
+      cwd,
+      stdio: ["inherit", "pipe", "pipe"],
+      shell: process.platform === "win32",
+      env
+    });
+    const slowNoticeTimer = setTimeout(() => {
+      console.log(import_chalk19.default.yellow("   Still installing dependencies. Slow npm registry or network can make this take a few minutes..."));
+    }, SLOW_INSTALL_NOTICE_MS);
+    const timeoutTimer = setTimeout(() => {
+      timedOut = true;
+      child.kill();
+    }, INSTALL_TIMEOUT_MS);
+    const cleanup = () => {
+      clearTimeout(slowNoticeTimer);
+      clearTimeout(timeoutTimer);
+    };
+    (_a2 = child.stdout) == null ? void 0 : _a2.on("data", (chunk) => {
+      process.stdout.write(chunk);
+      capturedOutput = appendCapturedOutput(capturedOutput, chunk);
+    });
+    (_b = child.stderr) == null ? void 0 : _b.on("data", (chunk) => {
+      process.stderr.write(chunk);
+      capturedOutput = appendCapturedOutput(capturedOutput, chunk);
+    });
+    child.on("error", (error) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      reject(error);
+    });
+    child.on("close", (code, signal) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      if (timedOut) {
+        reject(new Error(`npm ${script} timed out after 10 minutes.
+${capturedOutput}`));
+        return;
+      }
+      if (code !== 0) {
+        reject(new Error(`npm ${script} failed with exit code ${code}${signal ? ` and signal ${signal}` : ""}.
+${capturedOutput}`));
+        return;
+      }
+      resolve();
+    });
+  });
 }
 function quoteForShell(value) {
   if (process.platform === "win32") {
@@ -9111,11 +9240,12 @@ function quoteForShell(value) {
 }
 function startBackgroundInstall(cwd) {
   const script = getInstallScript(cwd, "auto");
-  const cacheDir = makeTempCacheDir();
-  const args = getInstallArgs(script, cacheDir);
+  const args = getInstallArgs(script);
   const logPath = import_path11.default.join(cwd, INSTALL_LOG_FILE);
   const exitCodePath = import_path11.default.join(cwd, INSTALL_EXITCODE_FILE);
+  const pidPath = import_path11.default.join(cwd, INSTALL_PID_FILE);
   import_fs_extra5.default.removeSync(exitCodePath);
+  import_fs_extra5.default.removeSync(pidPath);
   import_fs_extra5.default.writeFileSync(logPath, `[pinme] ${(/* @__PURE__ */ new Date()).toISOString()} starting "npm ${script}"
 `);
   const npmCmd = process.platform === "win32" ? "npm" : getNpmCommand();
@@ -9139,7 +9269,6 @@ function startBackgroundInstall(cwd) {
     stdio: "ignore",
     env: {
       ...process.env,
-      npm_config_cache: cacheDir,
       npm_config_audit: "false",
       npm_config_fund: "false",
       npm_config_fetch_retries: "3",
@@ -9150,11 +9279,92 @@ function startBackgroundInstall(cwd) {
     }
   });
   child.unref();
+  if (child.pid) {
+    import_fs_extra5.default.writeFileSync(pidPath, String(child.pid));
+  }
   return { logPath };
 }
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return (error == null ? void 0 : error.code) === "EPERM";
+  }
+}
+function readPidFile(pidPath) {
+  if (!import_fs_extra5.default.existsSync(pidPath)) {
+    return null;
+  }
+  const raw = import_fs_extra5.default.readFileSync(pidPath, "utf-8").trim();
+  const pid = Number.parseInt(raw, 10);
+  if (!Number.isFinite(pid) || pid <= 0) {
+    return null;
+  }
+  return pid;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function signalInstallProcess(pid, signal) {
+  try {
+    if (process.platform === "win32") {
+      process.kill(pid, signal);
+    } else {
+      process.kill(-pid, signal);
+    }
+    return true;
+  } catch {
+    try {
+      process.kill(pid, signal);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+}
+async function waitForProcessExit(pid, timeoutMs) {
+  const startedAt = Date.now();
+  while (Date.now() - startedAt < timeoutMs) {
+    if (!isProcessAlive(pid)) {
+      return true;
+    }
+    await sleep(STOP_BACKGROUND_POLL_MS);
+  }
+  return !isProcessAlive(pid);
+}
+async function stopBackgroundInstall(cwd) {
+  const pidPath = import_path11.default.join(cwd, INSTALL_PID_FILE);
+  const pid = readPidFile(pidPath);
+  let stopped = false;
+  if (pid !== null && isProcessAlive(pid)) {
+    if (signalInstallProcess(pid, "SIGTERM")) {
+      stopped = true;
+      const stoppedGracefully = await waitForProcessExit(
+        pid,
+        STOP_BACKGROUND_GRACE_MS
+      );
+      if (!stoppedGracefully) {
+        signalInstallProcess(pid, "SIGKILL");
+        await waitForProcessExit(pid, STOP_BACKGROUND_KILL_GRACE_MS);
+      }
+    }
+  }
+  import_fs_extra5.default.removeSync(pidPath);
+  return stopped;
+}
+function isStaleLogOnlyMarker(logPath) {
+  try {
+    const ageMs = Date.now() - import_fs_extra5.default.statSync(logPath).mtimeMs;
+    return ageMs > STALE_LOG_ONLY_MARKER_MS;
+  } catch {
+    return false;
+  }
+}
 function readBackgroundInstallStatus(cwd) {
   const logPath = import_path11.default.join(cwd, INSTALL_LOG_FILE);
   const exitCodePath = import_path11.default.join(cwd, INSTALL_EXITCODE_FILE);
+  const pidPath = import_path11.default.join(cwd, INSTALL_PID_FILE);
   if (import_fs_extra5.default.existsSync(exitCodePath)) {
     const raw = import_fs_extra5.default.readFileSync(exitCodePath, "utf-8").trim();
     const code = Number.parseInt(raw, 10);
@@ -9164,6 +9374,17 @@ function readBackgroundInstallStatus(cwd) {
     return { status: code === 0 ? "success" : "failed", exitCode: code, logPath };
   }
   if (import_fs_extra5.default.existsSync(logPath)) {
+    const pid = readPidFile(pidPath);
+    if (pid !== null) {
+      return {
+        status: isProcessAlive(pid) ? "running" : "interrupted",
+        exitCode: null,
+        logPath
+      };
+    }
+    if (isStaleLogOnlyMarker(logPath)) {
+      return { status: "interrupted", exitCode: null, logPath };
+    }
     return { status: "running", exitCode: null, logPath };
   }
   return { status: "idle", exitCode: null, logPath };
@@ -9176,12 +9397,214 @@ function readBackgroundInstallLogTail(cwd, maxChars = 1500) {
   const content = import_fs_extra5.default.readFileSync(logPath, "utf-8");
   return content.length > maxChars ? content.slice(content.length - maxChars) : content;
 }
+async function installProjectDependencies(cwd, options = {}) {
+  const mode = options.mode || "auto";
+  const script = getInstallScript(cwd, mode);
+  const command = formatInstallCommand(script);
+  let lastError;
+  if (script === "ci" && !hasPackageLock(cwd)) {
+    throw new DependencyInstallError(
+      command,
+      new Error("package-lock.json is required for npm ci but was not found.")
+    );
+  }
+  for (let attempt = 1; attempt <= 2; attempt += 1) {
+    const useIsolatedCache = attempt > 1;
+    const cacheDir = useIsolatedCache ? makeTempCacheDir() : void 0;
+    try {
+      if (attempt > 1) {
+        console.log(import_chalk19.default.yellow("   Retrying dependency install with a fresh npm cache..."));
+      }
+      if (attempt === 1 && script === "ci" && mode === "auto") {
+        console.log(import_chalk19.default.gray("   package-lock.json found; using npm ci for a reproducible install."));
+      } else if (attempt === 1 && script === "ci") {
+        console.log(import_chalk19.default.gray("   Using npm ci for a clean, reproducible install."));
+      }
+      await runInstall(cwd, script, cacheDir);
+      return;
+    } catch (error) {
+      lastError = error;
+    } finally {
+      if (cacheDir) {
+        import_fs_extra5.default.removeSync(cacheDir);
+      }
+    }
+  }
+  throw new DependencyInstallError(
+    formatInstallCommand(script, "isolated"),
+    lastError
+  );
+}
 
 // bin/create.ts
 init_cliError();
 init_config();
+
+// bin/utils/prebuiltDistConfig.ts
+var import_fs_extra6 = __toESM(require("fs-extra"));
+var import_path12 = __toESM(require("path"));
+init_cliError();
+var PLACEHOLDERS = {
+  apiUrl: "__PINME_VITE_API_URL__",
+  authApiKey: "__PINME_AUTH_API_KEY__",
+  authDomain: "__PINME_AUTH_DOMAIN__",
+  authProjectId: "__PINME_AUTH_PROJECT_ID__",
+  tenantId: "__PINME_TENANT_ID__"
+};
+var PATCHABLE_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".html",
+  ".js",
+  ".css",
+  ".json",
+  ".map"
+]);
+function toReplacementValue(value) {
+  if (value === void 0 || value === null) {
+    return "";
+  }
+  return String(value);
+}
+function countOccurrences(content, needle) {
+  if (!needle) {
+    return 0;
+  }
+  return content.split(needle).length - 1;
+}
+function listPatchableFiles(dir) {
+  const result = [];
+  for (const entry of import_fs_extra6.default.readdirSync(dir, { withFileTypes: true })) {
+    const entryPath = import_path12.default.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      result.push(...listPatchableFiles(entryPath));
+      continue;
+    }
+    if (entry.isFile() && PATCHABLE_EXTENSIONS.has(import_path12.default.extname(entry.name))) {
+      result.push(entryPath);
+    }
+  }
+  return result;
+}
+function patchPrebuiltFrontendDist(frontendDistDir, workerData) {
+  if (!workerData.api_domain) {
+    throw createConfigError("`api_domain` is missing from project creation response.", [
+      "Retry `pinme create`.",
+      "If the problem persists, check the `/create_worker` API response."
+    ]);
+  }
+  if (!import_fs_extra6.default.existsSync(frontendDistDir)) {
+    throw createConfigError("Prebuilt frontend output not found: `frontend/dist/`.", [
+      "The template should ship a prebuilt `frontend/dist/`.",
+      "Once dependencies finish installing, run `npm run build:frontend` in the project, then `pinme save`."
+    ]);
+  }
+  const authConfig = workerData.public_client_config ?? {};
+  const replacements = /* @__PURE__ */ new Map([
+    [PLACEHOLDERS.apiUrl, workerData.api_domain],
+    [PLACEHOLDERS.authApiKey, toReplacementValue(authConfig.auth_api_key)],
+    [PLACEHOLDERS.authDomain, toReplacementValue(authConfig.auth_domain)],
+    [PLACEHOLDERS.authProjectId, toReplacementValue(authConfig.auth_project_id)],
+    [PLACEHOLDERS.tenantId, toReplacementValue(authConfig.tenant_id)]
+  ]);
+  const files = listPatchableFiles(frontendDistDir);
+  let filesPatched = 0;
+  let apiUrlReplacements = 0;
+  let authReplacements = 0;
+  for (const filePath of files) {
+    const content = import_fs_extra6.default.readFileSync(filePath, "utf8");
+    let nextContent = content;
+    for (const [placeholder, replacement] of replacements) {
+      const count = countOccurrences(nextContent, placeholder);
+      if (count === 0) {
+        continue;
+      }
+      if (placeholder === PLACEHOLDERS.apiUrl) {
+        apiUrlReplacements += count;
+      } else {
+        authReplacements += count;
+      }
+      nextContent = nextContent.split(placeholder).join(replacement);
+    }
+    if (nextContent !== content) {
+      import_fs_extra6.default.writeFileSync(filePath, nextContent);
+      filesPatched += 1;
+    }
+  }
+  if (apiUrlReplacements === 0) {
+    throw createConfigError("Prebuilt frontend dist is missing required Pinme config placeholder.", [
+      "Expected to find `__PINME_VITE_API_URL__` in `frontend/dist`.",
+      "Rebuild the template frontend from placeholder-enabled source before publishing the template.",
+      "After dependencies finish installing, users can recover by running `npm run build:frontend` and `pinme save`."
+    ]);
+  }
+  return {
+    filesScanned: files.length,
+    filesPatched,
+    apiUrlReplacements,
+    authReplacements
+  };
+}
+
+// bin/utils/workerMetadata.ts
+init_cliError();
+function parseWorkerMetadata(metadataContent) {
+  try {
+    return JSON.parse(metadataContent);
+  } catch (error) {
+    throw createConfigError("Worker metadata must be valid JSON.", [
+      "The `/create_worker` API should return JSON metadata for backend deployment.",
+      "Retry `pinme create`."
+    ]);
+  }
+}
+function isRealBindingValue(value) {
+  if (typeof value !== "string") {
+    return false;
+  }
+  const trimmed = value.trim();
+  return Boolean(trimmed) && trimmed !== "xxx" && trimmed !== "project_name" && !trimmed.startsWith("__PINME_");
+}
+function findBinding(metadata, name) {
+  var _a2;
+  return (_a2 = metadata.bindings) == null ? void 0 : _a2.find((binding) => binding.name === name);
+}
+function validateWorkerMetadataForCreate(metadataContent, projectName) {
+  const metadata = parseWorkerMetadata(metadataContent);
+  const apiKeyBinding = findBinding(metadata, "API_KEY");
+  const projectNameBinding = findBinding(metadata, "PROJECT_NAME");
+  if (!isRealBindingValue(apiKeyBinding == null ? void 0 : apiKeyBinding.text)) {
+    throw createConfigError("Worker metadata is missing a real API_KEY binding.", [
+      "The template metadata contains placeholder values and cannot be deployed as-is.",
+      "Retry `pinme create` so Pinme can fetch fresh worker metadata from `/create_worker`."
+    ]);
+  }
+  if ((projectNameBinding == null ? void 0 : projectNameBinding.text) !== projectName) {
+    throw createConfigError("Worker metadata is missing a matching PROJECT_NAME binding.", [
+      `Expected PROJECT_NAME binding text to be \`${projectName}\`.`,
+      "Retry `pinme create` so Pinme can fetch fresh worker metadata from `/create_worker`."
+    ]);
+  }
+  if (metadata.project_name && metadata.project_name !== projectName) {
+    throw createConfigError("Worker metadata project_name does not match the created project.", [
+      `Expected metadata project_name to be \`${projectName}\`.`,
+      `Received metadata project_name \`${metadata.project_name}\`.`
+    ]);
+  }
+}
+function getValidatedWorkerMetadataContent(metadata, projectName) {
+  if (!metadata) {
+    throw createConfigError("Worker metadata is missing from project creation response.", [
+      "The `/create_worker` API should return backend metadata before the prebuilt worker is deployed.",
+      "Retry `pinme create`."
+    ]);
+  }
+  const metadataContent = typeof metadata === "string" ? metadata : JSON.stringify(metadata, null, 2);
+  validateWorkerMetadataForCreate(metadataContent, projectName);
+  return metadataContent;
+}
+
+// bin/create.ts
 var PROJECT_DIR = process.cwd();
-var TEMPLATE_BRANCH = "main";
+var TEMPLATE_BRANCH = "feat/dev";
 var TEMPLATE_REPO = "glitternetwork/pinme-worker-template";
 var TEMPLATE_REPO_NAME = TEMPLATE_REPO.split("/").pop() || "pinme-worker-template";
 function getTemplateZipUrl(branch) {
@@ -9208,7 +9631,7 @@ ${configExport}
 `;
 }
 function resolveExtractedTemplateDir(extractDir) {
-  const entries = import_fs_extra6.default.readdirSync(extractDir, { withFileTypes: true });
+  const entries = import_fs_extra7.default.readdirSync(extractDir, { withFileTypes: true });
   const templateDir = entries.find((entry) => entry.isDirectory() && entry.name.startsWith(`${TEMPLATE_REPO_NAME}-`));
   if (!templateDir) {
     throw createConfigError("Downloaded template archive structure is invalid.", [
@@ -9216,10 +9639,10 @@ function resolveExtractedTemplateDir(extractDir) {
       `Template branch: ${TEMPLATE_BRANCH}`
     ]);
   }
-  return import_path12.default.join(extractDir, templateDir.name);
+  return import_path13.default.join(extractDir, templateDir.name);
 }
 function updateFrontendUrlInConfig(configPath, frontendUrl) {
-  let config = import_fs_extra6.default.readFileSync(configPath, "utf-8");
+  let config = import_fs_extra7.default.readFileSync(configPath, "utf-8");
   if (config.includes("frontend_url")) {
     config = config.replace(
       /frontend_url\s*=\s*"[^"]*"/,
@@ -9232,7 +9655,7 @@ function updateFrontendUrlInConfig(configPath, frontendUrl) {
 `
     );
   }
-  import_fs_extra6.default.writeFileSync(configPath, config);
+  import_fs_extra7.default.writeFileSync(configPath, config);
 }
 function getProjectManagementUrl(projectName) {
   return `${APP_CONFIG.projectPeviewUrl}${projectName}`;
@@ -9265,8 +9688,8 @@ async function createCmd(options) {
       ]);
       projectName = answers.projectName;
     }
-    const targetDir = import_path12.default.join(PROJECT_DIR, projectName);
-    if (import_fs_extra6.default.existsSync(targetDir) && !options.force) {
+    const targetDir = import_path13.default.join(PROJECT_DIR, projectName);
+    if (import_fs_extra7.default.existsSync(targetDir) && !options.force) {
       console.log(import_chalk20.default.yellow(`
 Directory "${projectName}" already exists.`));
       const answers = await import_inquirer8.default.prompt([
@@ -9281,7 +9704,7 @@ Directory "${projectName}" already exists.`));
         console.log(import_chalk20.default.gray("Cancelled."));
         process.exit(0);
       }
-      import_fs_extra6.default.removeSync(targetDir);
+      import_fs_extra7.default.removeSync(targetDir);
     }
     console.log(import_chalk20.default.blue("\n1. Creating worker and database..."));
     const apiUrl = getPinmeApiUrl("/create_worker");
@@ -9316,8 +9739,8 @@ Directory "${projectName}" already exists.`));
       ]);
     }
     console.log(import_chalk20.default.blue("\n2. Downloading template from repository..."));
-    const zipPath = import_path12.default.join(PROJECT_DIR, "template.zip");
-    const extractDir = import_path12.default.join(PROJECT_DIR, `.pinme-template-${Date.now()}`);
+    const zipPath = import_path13.default.join(PROJECT_DIR, "template.zip");
+    const extractDir = import_path13.default.join(PROJECT_DIR, `.pinme-template-${Date.now()}`);
     const templateZipUrl = getTemplateZipUrl(TEMPLATE_BRANCH);
     let downloadSuccess = false;
     console.log(import_chalk20.default.gray(`   Template branch: ${TEMPLATE_BRANCH}`));
@@ -9327,14 +9750,14 @@ Directory "${projectName}" already exists.`));
         (0, import_child_process4.execSync)(`curl -L --retry 3 --retry-delay 2 -o "${zipPath}" "${templateZipUrl}"`, {
           stdio: "inherit"
         });
-        if (!import_fs_extra6.default.existsSync(zipPath) || import_fs_extra6.default.statSync(zipPath).size < 100) {
+        if (!import_fs_extra7.default.existsSync(zipPath) || import_fs_extra7.default.statSync(zipPath).size < 100) {
           throw new Error("Downloaded file is too small or empty");
         }
         downloadSuccess = true;
       } catch (downloadError) {
         console.log(import_chalk20.default.yellow(`   Attempt ${attempt} failed: ${downloadError.message}`));
-        if (import_fs_extra6.default.existsSync(zipPath)) {
-          import_fs_extra6.default.removeSync(zipPath);
+        if (import_fs_extra7.default.existsSync(zipPath)) {
+          import_fs_extra7.default.removeSync(zipPath);
         }
         if (attempt === 3) {
           throw new Error(`Failed to download template after 3 attempts: ${downloadError.message}`);
@@ -9342,22 +9765,22 @@ Directory "${projectName}" already exists.`));
       }
     }
     try {
-      import_fs_extra6.default.ensureDirSync(extractDir);
+      import_fs_extra7.default.ensureDirSync(extractDir);
       const templateZip = new import_adm_zip.default(zipPath);
       templateZip.extractAllTo(extractDir, true);
       const subDir = resolveExtractedTemplateDir(extractDir);
-      import_fs_extra6.default.copySync(subDir, targetDir);
-      import_fs_extra6.default.removeSync(zipPath);
-      import_fs_extra6.default.removeSync(extractDir);
-      const nodeModulesPath = import_path12.default.join(targetDir, "node_modules");
-      if (import_fs_extra6.default.existsSync(nodeModulesPath)) {
+      import_fs_extra7.default.copySync(subDir, targetDir);
+      import_fs_extra7.default.removeSync(zipPath);
+      import_fs_extra7.default.removeSync(extractDir);
+      const nodeModulesPath = import_path13.default.join(targetDir, "node_modules");
+      if (import_fs_extra7.default.existsSync(nodeModulesPath)) {
         console.log(import_chalk20.default.gray("   Removing existing node_modules..."));
-        import_fs_extra6.default.removeSync(nodeModulesPath);
+        import_fs_extra7.default.removeSync(nodeModulesPath);
       }
-      const frontendNodeModules = import_path12.default.join(targetDir, "frontend", "node_modules");
-      const backendNodeModules = import_path12.default.join(targetDir, "backend", "node_modules");
-      if (import_fs_extra6.default.existsSync(frontendNodeModules)) import_fs_extra6.default.removeSync(frontendNodeModules);
-      if (import_fs_extra6.default.existsSync(backendNodeModules)) import_fs_extra6.default.removeSync(backendNodeModules);
+      const frontendNodeModules = import_path13.default.join(targetDir, "frontend", "node_modules");
+      const backendNodeModules = import_path13.default.join(targetDir, "backend", "node_modules");
+      if (import_fs_extra7.default.existsSync(frontendNodeModules)) import_fs_extra7.default.removeSync(frontendNodeModules);
+      if (import_fs_extra7.default.existsSync(backendNodeModules)) import_fs_extra7.default.removeSync(backendNodeModules);
       console.log(import_chalk20.default.green(`   Template downloaded to: ${targetDir}`));
     } catch (error) {
       throw createCommandError("template extraction", `extract "${zipPath}" to "${extractDir}"`, error, [
@@ -9365,58 +9788,61 @@ Directory "${projectName}" already exists.`));
       ]);
     }
     console.log(import_chalk20.default.blue("\n3. Updating configuration..."));
-    const configPath = import_path12.default.join(targetDir, "pinme.toml");
-    const config = import_fs_extra6.default.readFileSync(configPath, "utf-8");
+    const configPath = import_path13.default.join(targetDir, "pinme.toml");
+    const config = import_fs_extra7.default.readFileSync(configPath, "utf-8");
     let updatedConfig = config.replace(
       /project_name = ".*"/,
       `project_name = "${workerData.project_name}"`
     );
-    import_fs_extra6.default.writeFileSync(configPath, updatedConfig);
+    import_fs_extra7.default.writeFileSync(configPath, updatedConfig);
     console.log(import_chalk20.default.green(`   Updated pinme.toml`));
     console.log(import_chalk20.default.gray(`   metadata: ${workerData.metadata}`));
-    const backendDir = import_path12.default.join(targetDir, "backend");
-    if (import_fs_extra6.default.existsSync(backendDir) && workerData.metadata) {
-      const metadataContent = typeof workerData.metadata === "string" ? workerData.metadata : JSON.stringify(workerData.metadata, null, 2);
-      import_fs_extra6.default.writeFileSync(
-        import_path12.default.join(backendDir, "metadata.json"),
-        metadataContent
+    const workerMetadataContent = getValidatedWorkerMetadataContent(
+      workerData.metadata,
+      workerData.project_name
+    );
+    const backendDir = import_path13.default.join(targetDir, "backend");
+    if (import_fs_extra7.default.existsSync(backendDir)) {
+      import_fs_extra7.default.writeFileSync(
+        import_path13.default.join(backendDir, "metadata.json"),
+        workerMetadataContent
       );
       console.log(import_chalk20.default.green(`   Saved metadata.json`));
     }
-    const wranglerPath = import_path12.default.join(backendDir, "wrangler.toml");
-    if (import_fs_extra6.default.existsSync(wranglerPath) && workerData.api_key) {
-      let wranglerContent = import_fs_extra6.default.readFileSync(wranglerPath, "utf-8");
+    const wranglerPath = import_path13.default.join(backendDir, "wrangler.toml");
+    if (import_fs_extra7.default.existsSync(wranglerPath) && workerData.api_key) {
+      let wranglerContent = import_fs_extra7.default.readFileSync(wranglerPath, "utf-8");
       wranglerContent = wranglerContent.replace(
         /^name = ".*"$/m,
         `name = "${workerData.project_name}"`
       );
-      import_fs_extra6.default.writeFileSync(wranglerPath, wranglerContent);
+      import_fs_extra7.default.writeFileSync(wranglerPath, wranglerContent);
       console.log(import_chalk20.default.green(`   Updated backend/wrangler.toml API_KEY`));
     }
-    const frontendConfigPath = import_path12.default.join(targetDir, "frontend", "src", "utils", "config.ts");
+    const frontendConfigPath = import_path13.default.join(targetDir, "frontend", "src", "utils", "config.ts");
     if (workerData.public_client_config) {
-      const frontendConfigContent = import_fs_extra6.default.existsSync(frontendConfigPath) ? import_fs_extra6.default.readFileSync(frontendConfigPath, "utf-8") : "";
-      import_fs_extra6.default.ensureDirSync(import_path12.default.dirname(frontendConfigPath));
-      import_fs_extra6.default.writeFileSync(
+      const frontendConfigContent = import_fs_extra7.default.existsSync(frontendConfigPath) ? import_fs_extra7.default.readFileSync(frontendConfigPath, "utf-8") : "";
+      import_fs_extra7.default.ensureDirSync(import_path13.default.dirname(frontendConfigPath));
+      import_fs_extra7.default.writeFileSync(
         frontendConfigPath,
         injectPublicClientConfigIntoFile(frontendConfigContent, workerData.public_client_config)
       );
       console.log(import_chalk20.default.green(`   Updated frontend/src/utils/config.ts public_client_config`));
     }
-    const envExamplePath = import_path12.default.join(targetDir, "frontend", ".env.example");
-    const envPath = import_path12.default.join(targetDir, "frontend", ".env");
-    if (import_fs_extra6.default.existsSync(envExamplePath)) {
-      let envContent = import_fs_extra6.default.readFileSync(envExamplePath, "utf-8");
+    const envExamplePath = import_path13.default.join(targetDir, "frontend", ".env.example");
+    const envPath = import_path13.default.join(targetDir, "frontend", ".env");
+    if (import_fs_extra7.default.existsSync(envExamplePath)) {
+      let envContent = import_fs_extra7.default.readFileSync(envExamplePath, "utf-8");
       envContent = envContent.replace(/your-project/g, workerData.project_name);
       envContent = envContent.replace(
         /^VITE_API_URL=.*$/m,
         `VITE_API_URL=${workerData.api_domain}`
       );
-      import_fs_extra6.default.writeFileSync(envPath, envContent);
+      import_fs_extra7.default.writeFileSync(envPath, envContent);
       console.log(import_chalk20.default.green(`   Created frontend/.env file`));
       console.log(import_chalk20.default.gray(`   VITE_API_URL: ${workerData.api_domain}`));
     }
-    let pinmeConfig = import_fs_extra6.default.readFileSync(configPath, "utf-8");
+    let pinmeConfig = import_fs_extra7.default.readFileSync(configPath, "utf-8");
     if (pinmeConfig.includes("api_url")) {
       pinmeConfig = pinmeConfig.replace(
         /api_url\s*=\s*"[^"]*"/,
@@ -9433,7 +9859,7 @@ Directory "${projectName}" already exists.`));
       }
       pinmeConfig = newLines.join("\n");
     }
-    import_fs_extra6.default.writeFileSync(configPath, pinmeConfig);
+    import_fs_extra7.default.writeFileSync(configPath, pinmeConfig);
     console.log(import_chalk20.default.green(`   Updated pinme.toml with api_url`));
     console.log(import_chalk20.default.blue("\n4. Installing dependencies in the background..."));
     try {
@@ -9446,27 +9872,27 @@ Directory "${projectName}" already exists.`));
       console.log(import_chalk20.default.yellow("   Run `npm install` inside the project before `pinme save`."));
     }
     console.log(import_chalk20.default.blue("\n5. Preparing backend worker..."));
-    const distWorkerDir = import_path12.default.join(targetDir, "dist-worker");
-    const workerJsPath = import_path12.default.join(distWorkerDir, "worker.js");
-    if (!import_fs_extra6.default.existsSync(distWorkerDir) || !import_fs_extra6.default.existsSync(workerJsPath)) {
+    const distWorkerDir = import_path13.default.join(targetDir, "dist-worker");
+    const workerJsPath = import_path13.default.join(distWorkerDir, "worker.js");
+    if (!import_fs_extra7.default.existsSync(distWorkerDir) || !import_fs_extra7.default.existsSync(workerJsPath)) {
       throw createConfigError("Prebuilt worker output not found: `dist-worker/worker.js`.", [
         "The template should ship a prebuilt `dist-worker/`.",
         "Once dependencies finish installing, run `npm run build:worker` in the project, then `pinme save`."
       ]);
     }
     const modulePaths = [];
-    const files = import_fs_extra6.default.readdirSync(distWorkerDir);
+    const files = import_fs_extra7.default.readdirSync(distWorkerDir);
     for (const file of files) {
       if (file.endsWith(".js") && file !== "worker.js") {
-        modulePaths.push(import_path12.default.join(distWorkerDir, file));
+        modulePaths.push(import_path13.default.join(distWorkerDir, file));
       }
     }
-    const sqlDir = import_path12.default.join(targetDir, "db");
+    const sqlDir = import_path13.default.join(targetDir, "db");
     const sqlFiles = [];
-    if (import_fs_extra6.default.existsSync(sqlDir)) {
-      const sqlFileNames = import_fs_extra6.default.readdirSync(sqlDir).filter((f) => f.endsWith(".sql")).sort();
+    if (import_fs_extra7.default.existsSync(sqlDir)) {
+      const sqlFileNames = import_fs_extra7.default.readdirSync(sqlDir).filter((f) => f.endsWith(".sql")).sort();
       for (const filename of sqlFileNames) {
-        sqlFiles.push(import_path12.default.join(sqlDir, filename));
+        sqlFiles.push(import_path13.default.join(sqlDir, filename));
         console.log(import_chalk20.default.gray(`   Including SQL: ${filename}`));
       }
     }
@@ -9477,24 +9903,23 @@ Directory "${projectName}" already exists.`));
       const FormData4 = (await import("formdata-node")).FormData;
       const Blob2 = (await import("formdata-node")).Blob;
       const formData = new FormData4();
-      const metadataContent = typeof workerData.metadata === "string" ? workerData.metadata : JSON.stringify(workerData.metadata, null, 2);
-      formData.append("metadata", new Blob2([metadataContent], {
+      formData.append("metadata", new Blob2([workerMetadataContent], {
         type: "application/json"
       }), "metadata.json");
-      const workerCode = import_fs_extra6.default.readFileSync(workerJsPath, "utf-8");
+      const workerCode = import_fs_extra7.default.readFileSync(workerJsPath, "utf-8");
       formData.append("worker.js", new Blob2([workerCode], {
         type: "application/javascript+module"
       }), "worker.js");
       for (const modulePath of modulePaths) {
-        const filename = import_path12.default.basename(modulePath);
-        const content = import_fs_extra6.default.readFileSync(modulePath, "utf-8");
+        const filename = import_path13.default.basename(modulePath);
+        const content = import_fs_extra7.default.readFileSync(modulePath, "utf-8");
         formData.append(filename, new Blob2([content], {
           type: "application/javascript+module"
         }), filename);
       }
       for (const sqlFile of sqlFiles) {
-        const filename = import_path12.default.basename(sqlFile);
-        const content = import_fs_extra6.default.readFileSync(sqlFile, "utf-8");
+        const filename = import_path13.default.basename(sqlFile);
+        const content = import_fs_extra7.default.readFileSync(sqlFile, "utf-8");
         formData.append("sql_file", new Blob2([content], {
           type: "application/sql"
         }), filename);
@@ -9527,15 +9952,20 @@ Directory "${projectName}" already exists.`));
       ]);
     }
     console.log(import_chalk20.default.blue("\n7. Preparing frontend..."));
-    const frontendDir = import_path12.default.join(targetDir, "frontend");
-    const frontendDistDir = import_path12.default.join(frontendDir, "dist");
-    if (import_fs_extra6.default.existsSync(frontendDir)) {
-      if (!import_fs_extra6.default.existsSync(frontendDistDir)) {
+    const frontendDir = import_path13.default.join(targetDir, "frontend");
+    const frontendDistDir = import_path13.default.join(frontendDir, "dist");
+    if (import_fs_extra7.default.existsSync(frontendDir)) {
+      if (!import_fs_extra7.default.existsSync(frontendDistDir)) {
         throw createConfigError("Prebuilt frontend output not found: `frontend/dist/`.", [
           "The template should ship a prebuilt `frontend/dist/`.",
           "Once dependencies finish installing, run `npm run build:frontend` in the project, then `pinme save`."
         ]);
       }
+      const patchResult = patchPrebuiltFrontendDist(frontendDistDir, workerData);
+      console.log(import_chalk20.default.green("   Patched prebuilt frontend dist config"));
+      console.log(import_chalk20.default.gray(
+        `   Replacements: API URL ${patchResult.apiUrlReplacements}, auth ${patchResult.authReplacements}`
+      ));
       console.log(import_chalk20.default.blue("   Uploading to IPFS..."));
       try {
         const uploadResult = await uploadPath(frontendDistDir, {
@@ -9545,7 +9975,7 @@ Directory "${projectName}" already exists.`));
         });
         printHighlightedUrl("Frontend URL", uploadResult.publicUrl, "primary");
         updateFrontendUrlInConfig(
-          import_path12.default.join(targetDir, "pinme.toml"),
+          import_path13.default.join(targetDir, "pinme.toml"),
           uploadResult.publicUrl
         );
         console.log(import_chalk20.default.green("   Updated pinme.toml with frontend URL"));
@@ -9598,8 +10028,8 @@ Next steps:`));
 // bin/save.ts
 var import_chalk21 = __toESM(require("chalk"));
 var import_ora3 = __toESM(require("ora"));
-var import_fs_extra7 = __toESM(require("fs-extra"));
-var import_path13 = __toESM(require("path"));
+var import_fs_extra8 = __toESM(require("fs-extra"));
+var import_path14 = __toESM(require("path"));
 init_axios2();
 var import_child_process5 = require("child_process");
 init_webLogin();
@@ -9609,14 +10039,14 @@ init_cliError();
 init_config();
 var PROJECT_DIR2 = process.cwd();
 function loadConfig() {
-  const configPath = import_path13.default.join(PROJECT_DIR2, "pinme.toml");
-  if (!import_fs_extra7.default.existsSync(configPath)) {
+  const configPath = import_path14.default.join(PROJECT_DIR2, "pinme.toml");
+  if (!import_fs_extra8.default.existsSync(configPath)) {
     throw createConfigError("`pinme.toml` not found in the current directory.", [
       "Run this command from the Pinme project root.",
       "If the project has not been initialized yet, create or restore `pinme.toml` first."
     ]);
   }
-  const configContent = import_fs_extra7.default.readFileSync(configPath, "utf-8");
+  const configContent = import_fs_extra8.default.readFileSync(configPath, "utf-8");
   const projectNameMatch = configContent.match(/project_name\s*=\s*"([^"]+)"/);
   return {
     project_name: (projectNameMatch == null ? void 0 : projectNameMatch[1]) || ""
@@ -9626,12 +10056,12 @@ function getProjectManagementUrl2(projectName) {
   return `${APP_CONFIG.projectPeviewUrl}${projectName}`;
 }
 function getMetadata() {
-  const metadataPath = import_path13.default.join(PROJECT_DIR2, "backend", "metadata.json");
-  if (!import_fs_extra7.default.existsSync(metadataPath)) {
+  const metadataPath = import_path14.default.join(PROJECT_DIR2, "backend", "metadata.json");
+  if (!import_fs_extra8.default.existsSync(metadataPath)) {
     console.log(import_chalk21.default.yellow("   Warning: metadata.json not found, using empty metadata"));
     return {};
   }
-  return import_fs_extra7.default.readJsonSync(metadataPath);
+  return import_fs_extra8.default.readJsonSync(metadataPath);
 }
 function buildWorker() {
   console.log(import_chalk21.default.blue("Building worker..."));
@@ -9653,11 +10083,11 @@ function buildWorker() {
   }
 }
 function dependenciesMissingError(summary, logTail) {
-  const installLogPath = import_path13.default.join(PROJECT_DIR2, ".pinme-install.log");
+  const installLogPath = import_path14.default.join(PROJECT_DIR2, ".pinme-install.log");
   const suggestions = [
     "Run `npm install` in the project root, wait for it to finish, then rerun `pinme save`."
   ];
-  if (import_fs_extra7.default.existsSync(installLogPath)) {
+  if (import_fs_extra8.default.existsSync(installLogPath)) {
     suggestions.push(
       `Background install log: ${installLogPath}`
     );
@@ -9684,10 +10114,10 @@ function isMissingDependencyError(error) {
 function dependenciesPresent() {
   return hasLocalBinary("wrangler") && hasLocalBinary("vite");
 }
-function sleep(ms) {
+function sleep2(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
-var WAIT_FOR_INSTALL_TIMEOUT_MS = 12 * 60 * 1e3;
+var WAIT_FOR_INSTALL_TIMEOUT_MS = 15 * 1e3;
 var WAIT_POLL_INTERVAL_MS = 2e3;
 async function ensureDependenciesReady() {
   if (dependenciesPresent()) {
@@ -9696,20 +10126,25 @@ async function ensureDependenciesReady() {
   }
   const initial = readBackgroundInstallStatus(PROJECT_DIR2);
   if (initial.status === "idle") {
-    throw dependenciesMissingError(
-      "Project dependencies are not installed and no install is running."
-    );
+    await installDependenciesInForeground();
+    return;
   }
   if (initial.status === "failed") {
-    throw dependenciesMissingError(
-      `The background dependency install (started by \`pinme create\`) failed with exit code ${initial.exitCode}.`,
-      readBackgroundInstallLogTail(PROJECT_DIR2)
-    );
+    console.log(import_chalk21.default.yellow(
+      `Background dependency install failed with exit code ${initial.exitCode}. Retrying in this terminal...`
+    ));
+    await installDependenciesInForeground();
+    return;
+  }
+  if (initial.status === "interrupted") {
+    console.log(import_chalk21.default.yellow("Background dependency install was interrupted. Continuing in this terminal..."));
+    await installDependenciesInForeground();
+    return;
   }
-  const spinner = (0, import_ora3.default)("Waiting for background dependency install to finish...").start();
+  const spinner = (0, import_ora3.default)("Waiting briefly for background dependency install...").start();
   const startedAt = Date.now();
   while (true) {
-    await sleep(WAIT_POLL_INTERVAL_MS);
+    await sleep2(WAIT_POLL_INTERVAL_MS);
     if (dependenciesPresent()) {
       spinner.succeed("Dependencies installed.");
       return;
@@ -9717,10 +10152,16 @@ async function ensureDependenciesReady() {
     const state = readBackgroundInstallStatus(PROJECT_DIR2);
     if (state.status === "failed") {
       spinner.fail("Background dependency install failed.");
-      throw dependenciesMissingError(
-        `The background dependency install (started by \`pinme create\`) failed with exit code ${state.exitCode}.`,
-        readBackgroundInstallLogTail(PROJECT_DIR2)
-      );
+      console.log(import_chalk21.default.yellow(
+        `Retrying dependency install in this terminal after exit code ${state.exitCode}...`
+      ));
+      await installDependenciesInForeground();
+      return;
+    }
+    if (state.status === "interrupted") {
+      spinner.fail("Background dependency install was interrupted.");
+      await installDependenciesInForeground();
+      return;
     }
     if (state.status === "success") {
       spinner.succeed("Dependencies installed.");
@@ -9728,60 +10169,79 @@ async function ensureDependenciesReady() {
     }
     const elapsedMs = Date.now() - startedAt;
     if (elapsedMs > WAIT_FOR_INSTALL_TIMEOUT_MS) {
-      spinner.fail("Timed out waiting for the dependency install.");
-      throw dependenciesMissingError(
-        "Timed out waiting for the background dependency install to finish.",
-        readBackgroundInstallLogTail(PROJECT_DIR2)
-      );
+      spinner.warn("Background dependency install is not ready yet; continuing in this terminal.");
+      await stopBackgroundInstall(PROJECT_DIR2);
+      await installDependenciesInForeground();
+      return;
     }
-    spinner.text = `Waiting for background dependency install to finish... (${Math.round(elapsedMs / 1e3)}s)`;
+    spinner.text = `Waiting briefly for background dependency install... (${Math.round(elapsedMs / 1e3)}s)`;
+  }
+}
+async function installDependenciesInForeground() {
+  console.log(import_chalk21.default.blue("Installing project dependencies..."));
+  try {
+    await stopBackgroundInstall(PROJECT_DIR2);
+    await installProjectDependencies(PROJECT_DIR2);
+  } catch (error) {
+    throw dependenciesMissingError(
+      "Project dependency install failed.",
+      readBackgroundInstallLogTail(PROJECT_DIR2) || (error == null ? void 0 : error.message)
+    );
+  }
+  if (!dependenciesPresent()) {
+    throw dependenciesMissingError(
+      "Project dependencies were installed, but required build CLIs are still missing.",
+      readBackgroundInstallLogTail(PROJECT_DIR2)
+    );
   }
+  console.log(import_chalk21.default.green("Project dependencies installed."));
 }
 function cleanupInstallMarkers() {
   try {
-    import_fs_extra7.default.removeSync(import_path13.default.join(PROJECT_DIR2, INSTALL_LOG_FILE));
-    import_fs_extra7.default.removeSync(import_path13.default.join(PROJECT_DIR2, INSTALL_EXITCODE_FILE));
+    import_fs_extra8.default.removeSync(import_path14.default.join(PROJECT_DIR2, INSTALL_LOG_FILE));
+    import_fs_extra8.default.removeSync(import_path14.default.join(PROJECT_DIR2, INSTALL_EXITCODE_FILE));
+    import_fs_extra8.default.removeSync(import_path14.default.join(PROJECT_DIR2, INSTALL_PID_FILE));
   } catch {
   }
 }
 function hasLocalBinary(name) {
   const binDirs = [
-    import_path13.default.join(PROJECT_DIR2, "node_modules", ".bin"),
-    import_path13.default.join(PROJECT_DIR2, "backend", "node_modules", ".bin"),
-    import_path13.default.join(PROJECT_DIR2, "frontend", "node_modules", ".bin")
+    import_path14.default.join(PROJECT_DIR2, "node_modules", ".bin"),
+    import_path14.default.join(PROJECT_DIR2, "backend", "node_modules", ".bin"),
+    import_path14.default.join(PROJECT_DIR2, "frontend", "node_modules", ".bin")
   ];
   const candidates = process.platform === "win32" ? [name, `${name}.cmd`, `${name}.exe`, `${name}.ps1`] : [name];
-  return binDirs.some((dir) => candidates.some((candidate) => import_fs_extra7.default.existsSync(import_path13.default.join(dir, candidate))));
+  return binDirs.some((dir) => candidates.some((candidate) => import_fs_extra8.default.existsSync(import_path14.default.join(dir, candidate))));
 }
 function getBuiltWorker() {
-  const distWorkerDir = import_path13.default.join(PROJECT_DIR2, "dist-worker");
-  if (!import_fs_extra7.default.existsSync(distWorkerDir)) {
+  const distWorkerDir = import_path14.default.join(PROJECT_DIR2, "dist-worker");
+  if (!import_fs_extra8.default.existsSync(distWorkerDir)) {
     throw createConfigError("Built worker output not found: `dist-worker/`.", [
       "Make sure `npm run build:worker` completed successfully."
     ]);
   }
-  const workerJsPath = import_path13.default.join(distWorkerDir, "worker.js");
-  if (!import_fs_extra7.default.existsSync(workerJsPath)) {
+  const workerJsPath = import_path14.default.join(distWorkerDir, "worker.js");
+  if (!import_fs_extra8.default.existsSync(workerJsPath)) {
     throw createConfigError("Built worker entry file not found: `dist-worker/worker.js`.", [
       "Check the worker build output and bundler config."
     ]);
   }
   const modulePaths = [];
-  const files = import_fs_extra7.default.readdirSync(distWorkerDir);
+  const files = import_fs_extra8.default.readdirSync(distWorkerDir);
   for (const file of files) {
     if (file.endsWith(".js") && file !== "worker.js") {
-      modulePaths.push(import_path13.default.join(distWorkerDir, file));
+      modulePaths.push(import_path14.default.join(distWorkerDir, file));
     }
   }
   return { workerJsPath, modulePaths };
 }
 function getSqlFiles() {
-  const sqlDir = import_path13.default.join(PROJECT_DIR2, "db");
-  if (!import_fs_extra7.default.existsSync(sqlDir)) {
+  const sqlDir = import_path14.default.join(PROJECT_DIR2, "db");
+  if (!import_fs_extra8.default.existsSync(sqlDir)) {
     return [];
   }
-  const files = import_fs_extra7.default.readdirSync(sqlDir).filter((f) => f.endsWith(".sql")).sort();
-  return files.map((f) => import_path13.default.join(sqlDir, f));
+  const files = import_fs_extra8.default.readdirSync(sqlDir).filter((f) => f.endsWith(".sql")).sort();
+  return files.map((f) => import_path14.default.join(sqlDir, f));
 }
 async function saveWorker(workerJsPath, modulePaths, sqlFiles, metadata, projectName) {
   var _a2, _b;
@@ -9801,20 +10261,20 @@ async function saveWorker(workerJsPath, modulePaths, sqlFiles, metadata, project
     formData.append("metadata", new Blob2([JSON.stringify(metadata)], {
       type: "application/json"
     }), "metadata.json");
-    const workerCode = import_fs_extra7.default.readFileSync(workerJsPath, "utf-8");
+    const workerCode = import_fs_extra8.default.readFileSync(workerJsPath, "utf-8");
     formData.append("worker.js", new Blob2([workerCode], {
       type: "application/javascript+module"
     }), "worker.js");
     for (const modulePath of modulePaths) {
-      const filename = import_path13.default.basename(modulePath);
-      const content = import_fs_extra7.default.readFileSync(modulePath, "utf-8");
+      const filename = import_path14.default.basename(modulePath);
+      const content = import_fs_extra8.default.readFileSync(modulePath, "utf-8");
       formData.append(filename, new Blob2([content], {
         type: "application/javascript+module"
       }), filename);
     }
     for (const sqlFile of sqlFiles) {
-      const filename = import_path13.default.basename(sqlFile);
-      const content = import_fs_extra7.default.readFileSync(sqlFile, "utf-8");
+      const filename = import_path14.default.basename(sqlFile);
+      const content = import_fs_extra8.default.readFileSync(sqlFile, "utf-8");
       formData.append("sql_file", new Blob2([content], {
         type: "application/sql"
       }), filename);
@@ -9869,7 +10329,7 @@ function buildFrontend() {
   }
 }
 function updateFrontendUrlInConfig2(configPath, frontendUrl) {
-  let config = import_fs_extra7.default.readFileSync(configPath, "utf-8");
+  let config = import_fs_extra8.default.readFileSync(configPath, "utf-8");
   if (config.includes("frontend_url")) {
     config = config.replace(
       /frontend_url\s*=\s*"[^"]*"/,
@@ -9882,18 +10342,18 @@ function updateFrontendUrlInConfig2(configPath, frontendUrl) {
 `
     );
   }
-  import_fs_extra7.default.writeFileSync(configPath, config);
+  import_fs_extra8.default.writeFileSync(configPath, config);
 }
 async function deployFrontend(projectName) {
   console.log(import_chalk21.default.blue("Deploying frontend to IPFS..."));
   try {
     const headers = getAuthHeaders();
-    const uploadResult = await uploadPath(import_path13.default.join(PROJECT_DIR2, "frontend", "dist"), {
+    const uploadResult = await uploadPath(import_path14.default.join(PROJECT_DIR2, "frontend", "dist"), {
       action: "project_save",
       projectName,
       uid: headers["token-address"]
     });
-    updateFrontendUrlInConfig2(import_path13.default.join(PROJECT_DIR2, "pinme.toml"), uploadResult.publicUrl);
+    updateFrontendUrlInConfig2(import_path14.default.join(PROJECT_DIR2, "pinme.toml"), uploadResult.publicUrl);
     return {
       contentHash: uploadResult.contentHash,
       publicUrl: uploadResult.publicUrl
@@ -9943,11 +10403,11 @@ async function saveCmd(options) {
         "Run `pinme login` and retry."
       ]);
     }
-    const projectDir = options.projectName || options.name ? import_path13.default.join(PROJECT_DIR2, options.projectName || options.name) : PROJECT_DIR2;
-    const tokenFileSrc = import_path13.default.join(PROJECT_DIR2, ".token.json");
-    const tokenFileDst = import_path13.default.join(projectDir, ".token.json");
-    if (import_fs_extra7.default.existsSync(tokenFileSrc) && !import_fs_extra7.default.existsSync(tokenFileDst)) {
-      import_fs_extra7.default.copySync(tokenFileSrc, tokenFileDst);
+    const projectDir = options.projectName || options.name ? import_path14.default.join(PROJECT_DIR2, options.projectName || options.name) : PROJECT_DIR2;
+    const tokenFileSrc = import_path14.default.join(PROJECT_DIR2, ".token.json");
+    const tokenFileDst = import_path14.default.join(projectDir, ".token.json");
+    if (import_fs_extra8.default.existsSync(tokenFileSrc) && !import_fs_extra8.default.existsSync(tokenFileDst)) {
+      import_fs_extra8.default.copySync(tokenFileSrc, tokenFileDst);
     }
     console.log(import_chalk21.default.blue("Deploying to platform...\n"));
     console.log(import_chalk21.default.gray(`Project dir: ${PROJECT_DIR2}`));
@@ -10013,40 +10473,40 @@ async function saveCmd(options) {
 
 // bin/updateDb.ts
 var import_chalk22 = __toESM(require("chalk"));
-var import_fs_extra8 = __toESM(require("fs-extra"));
-var import_path14 = __toESM(require("path"));
+var import_fs_extra9 = __toESM(require("fs-extra"));
+var import_path15 = __toESM(require("path"));
 init_axios2();
 init_webLogin();
 init_cliError();
 init_config();
 var PROJECT_DIR3 = process.cwd();
 function loadConfig2() {
-  const configPath = import_path14.default.join(PROJECT_DIR3, "pinme.toml");
-  if (!import_fs_extra8.default.existsSync(configPath)) {
+  const configPath = import_path15.default.join(PROJECT_DIR3, "pinme.toml");
+  if (!import_fs_extra9.default.existsSync(configPath)) {
     throw createConfigError("`pinme.toml` not found in the current directory.", [
       "Run this command from the Pinme project root."
     ]);
   }
-  const configContent = import_fs_extra8.default.readFileSync(configPath, "utf-8");
+  const configContent = import_fs_extra9.default.readFileSync(configPath, "utf-8");
   const projectNameMatch = configContent.match(/project_name\s*=\s*"([^"]+)"/);
   return {
     project_name: (projectNameMatch == null ? void 0 : projectNameMatch[1]) || ""
   };
 }
 function getSqlFiles2() {
-  const sqlDir = import_path14.default.join(PROJECT_DIR3, "db");
-  if (!import_fs_extra8.default.existsSync(sqlDir)) {
+  const sqlDir = import_path15.default.join(PROJECT_DIR3, "db");
+  if (!import_fs_extra9.default.existsSync(sqlDir)) {
     throw createConfigError("SQL directory not found: `db/`.", [
       "Create a `db/` directory and add at least one `.sql` migration file."
     ]);
   }
-  const files = import_fs_extra8.default.readdirSync(sqlDir).filter((f) => f.endsWith(".sql")).sort();
+  const files = import_fs_extra9.default.readdirSync(sqlDir).filter((f) => f.endsWith(".sql")).sort();
   if (files.length === 0) {
     throw createConfigError("No `.sql` files were found in `db/`.", [
       "Add one or more migration files before running `pinme update-db`."
     ]);
   }
-  return files.map((f) => import_path14.default.join(sqlDir, f));
+  return files.map((f) => import_path15.default.join(sqlDir, f));
 }
 async function updateDb(sqlFiles, projectName) {
   console.log(import_chalk22.default.blue("Importing SQL files to database..."));
@@ -10061,8 +10521,8 @@ async function updateDb(sqlFiles, projectName) {
     const formData = new FormData4();
     let totalSize = 0;
     for (const sqlFile of sqlFiles) {
-      const filename = import_path14.default.basename(sqlFile);
-      const content = import_fs_extra8.default.readFileSync(sqlFile);
+      const filename = import_path15.default.basename(sqlFile);
+      const content = import_fs_extra9.default.readFileSync(sqlFile);
       totalSize += content.length;
       if (totalSize > 10 * 1024 * 1024) {
         throw createConfigError("Total SQL payload exceeds the 10MB platform limit.", [
@@ -10117,11 +10577,11 @@ async function updateDbCmd(options) {
         "Run `pinme login` and retry."
       ]);
     }
-    const projectDir = (options == null ? void 0 : options.projectName) || (options == null ? void 0 : options.name) ? import_path14.default.join(PROJECT_DIR3, options.projectName || options.name) : PROJECT_DIR3;
-    const tokenFileSrc = import_path14.default.join(PROJECT_DIR3, ".token.json");
-    const tokenFileDst = import_path14.default.join(projectDir, ".token.json");
-    if (import_fs_extra8.default.existsSync(tokenFileSrc) && !import_fs_extra8.default.existsSync(tokenFileDst)) {
-      import_fs_extra8.default.copySync(tokenFileSrc, tokenFileDst);
+    const projectDir = (options == null ? void 0 : options.projectName) || (options == null ? void 0 : options.name) ? import_path15.default.join(PROJECT_DIR3, options.projectName || options.name) : PROJECT_DIR3;
+    const tokenFileSrc = import_path15.default.join(PROJECT_DIR3, ".token.json");
+    const tokenFileDst = import_path15.default.join(projectDir, ".token.json");
+    if (import_fs_extra9.default.existsSync(tokenFileSrc) && !import_fs_extra9.default.existsSync(tokenFileDst)) {
+      import_fs_extra9.default.copySync(tokenFileSrc, tokenFileDst);
     }
     console.log(import_chalk22.default.blue("Importing SQL to database...\n"));
     console.log(import_chalk22.default.gray(`Project dir: ${PROJECT_DIR3}`));
@@ -10164,8 +10624,8 @@ async function updateDbCmd(options) {
 
 // bin/updateWorker.ts
 var import_chalk23 = __toESM(require("chalk"));
-var import_fs_extra9 = __toESM(require("fs-extra"));
-var import_path15 = __toESM(require("path"));
+var import_fs_extra10 = __toESM(require("fs-extra"));
+var import_path16 = __toESM(require("path"));
 init_axios2();
 var import_child_process6 = require("child_process");
 init_webLogin();
@@ -10173,26 +10633,26 @@ init_cliError();
 init_config();
 var PROJECT_DIR4 = process.cwd();
 function loadConfig3() {
-  const configPath = import_path15.default.join(PROJECT_DIR4, "pinme.toml");
-  if (!import_fs_extra9.default.existsSync(configPath)) {
+  const configPath = import_path16.default.join(PROJECT_DIR4, "pinme.toml");
+  if (!import_fs_extra10.default.existsSync(configPath)) {
     throw createConfigError("`pinme.toml` not found in the current directory.", [
       "Run this command from the Pinme project root."
     ]);
   }
-  const configContent = import_fs_extra9.default.readFileSync(configPath, "utf-8");
+  const configContent = import_fs_extra10.default.readFileSync(configPath, "utf-8");
   const projectNameMatch = configContent.match(/project_name\s*=\s*"([^"]+)"/);
   return {
     project_name: (projectNameMatch == null ? void 0 : projectNameMatch[1]) || ""
   };
 }
 function getMetadata2() {
-  const metadataPath = import_path15.default.join(PROJECT_DIR4, "backend", "metadata.json");
-  if (!import_fs_extra9.default.existsSync(metadataPath)) {
+  const metadataPath = import_path16.default.join(PROJECT_DIR4, "backend", "metadata.json");
+  if (!import_fs_extra10.default.existsSync(metadataPath)) {
     throw createConfigError("`backend/metadata.json` not found.", [
       "Create `backend/metadata.json` or restore it from the project template."
     ]);
   }
-  return import_fs_extra9.default.readJsonSync(metadataPath);
+  return import_fs_extra10.default.readJsonSync(metadataPath);
 }
 function buildWorker2() {
   console.log(import_chalk23.default.blue("Building worker..."));
@@ -10209,23 +10669,23 @@ function buildWorker2() {
   }
 }
 function getBuiltWorker2() {
-  const distWorkerDir = import_path15.default.join(PROJECT_DIR4, "dist-worker");
-  if (!import_fs_extra9.default.existsSync(distWorkerDir)) {
+  const distWorkerDir = import_path16.default.join(PROJECT_DIR4, "dist-worker");
+  if (!import_fs_extra10.default.existsSync(distWorkerDir)) {
     throw createConfigError("Built worker output not found: `dist-worker/`.", [
       "Make sure `npm run build:worker` completed successfully."
     ]);
   }
-  const workerJsPath = import_path15.default.join(distWorkerDir, "worker.js");
-  if (!import_fs_extra9.default.existsSync(workerJsPath)) {
+  const workerJsPath = import_path16.default.join(distWorkerDir, "worker.js");
+  if (!import_fs_extra10.default.existsSync(workerJsPath)) {
     throw createConfigError("Built worker entry file not found: `dist-worker/worker.js`.", [
       "Check the worker build output and bundler config."
     ]);
   }
   const modulePaths = [];
-  const files = import_fs_extra9.default.readdirSync(distWorkerDir);
+  const files = import_fs_extra10.default.readdirSync(distWorkerDir);
   for (const file of files) {
     if (file.endsWith(".js") && file !== "worker.js") {
-      modulePaths.push(import_path15.default.join(distWorkerDir, file));
+      modulePaths.push(import_path16.default.join(distWorkerDir, file));
     }
   }
   return { workerJsPath, modulePaths };
@@ -10246,13 +10706,13 @@ async function updateWorker(workerJsPath, modulePaths, metadata, projectName) {
     formData.append("metadata", new Blob2([JSON.stringify(metadata)], {
       type: "application/json"
     }), "metadata.json");
-    const workerCode = import_fs_extra9.default.readFileSync(workerJsPath, "utf-8");
+    const workerCode = import_fs_extra10.default.readFileSync(workerJsPath, "utf-8");
     formData.append("worker.js", new Blob2([workerCode], {
       type: "application/javascript+module"
     }), "worker.js");
     for (const modulePath of modulePaths) {
-      const filename = import_path15.default.basename(modulePath);
-      const content = import_fs_extra9.default.readFileSync(modulePath, "utf-8");
+      const filename = import_path16.default.basename(modulePath);
+      const content = import_fs_extra10.default.readFileSync(modulePath, "utf-8");
       formData.append(filename, new Blob2([content], {
         type: "application/javascript+module"
       }), filename);
@@ -10314,11 +10774,11 @@ async function updateWorkerCmd(options) {
         "Run `pinme login` and retry."
       ]);
     }
-    const projectDir = (options == null ? void 0 : options.projectName) || (options == null ? void 0 : options.name) ? import_path15.default.join(PROJECT_DIR4, options.projectName || options.name) : PROJECT_DIR4;
-    const tokenFileSrc = import_path15.default.join(PROJECT_DIR4, ".token.json");
-    const tokenFileDst = import_path15.default.join(projectDir, ".token.json");
-    if (import_fs_extra9.default.existsSync(tokenFileSrc) && !import_fs_extra9.default.existsSync(tokenFileDst)) {
-      import_fs_extra9.default.copySync(tokenFileSrc, tokenFileDst);
+    const projectDir = (options == null ? void 0 : options.projectName) || (options == null ? void 0 : options.name) ? import_path16.default.join(PROJECT_DIR4, options.projectName || options.name) : PROJECT_DIR4;
+    const tokenFileSrc = import_path16.default.join(PROJECT_DIR4, ".token.json");
+    const tokenFileDst = import_path16.default.join(projectDir, ".token.json");
+    if (import_fs_extra10.default.existsSync(tokenFileSrc) && !import_fs_extra10.default.existsSync(tokenFileDst)) {
+      import_fs_extra10.default.copySync(tokenFileSrc, tokenFileDst);
     }
     console.log(import_chalk23.default.blue("Updating worker...\n"));
     console.log(import_chalk23.default.gray(`Project dir: ${PROJECT_DIR4}`));
@@ -10366,21 +10826,21 @@ async function updateWorkerCmd(options) {
 
 // bin/updateWeb.ts
 var import_chalk24 = __toESM(require("chalk"));
-var import_fs_extra10 = __toESM(require("fs-extra"));
-var import_path16 = __toESM(require("path"));
+var import_fs_extra11 = __toESM(require("fs-extra"));
+var import_path17 = __toESM(require("path"));
 var import_child_process7 = require("child_process");
 init_webLogin();
 init_cliError();
 init_config();
 var PROJECT_DIR5 = process.cwd();
 function loadConfig4() {
-  const configPath = import_path16.default.join(PROJECT_DIR5, "pinme.toml");
-  if (!import_fs_extra10.default.existsSync(configPath)) {
+  const configPath = import_path17.default.join(PROJECT_DIR5, "pinme.toml");
+  if (!import_fs_extra11.default.existsSync(configPath)) {
     throw createConfigError("`pinme.toml` not found in the current directory.", [
       "Run this command from the Pinme project root."
     ]);
   }
-  const configContent = import_fs_extra10.default.readFileSync(configPath, "utf-8");
+  const configContent = import_fs_extra11.default.readFileSync(configPath, "utf-8");
   const projectNameMatch = configContent.match(/project_name\s*=\s*"([^"]+)"/);
   return {
     project_name: (projectNameMatch == null ? void 0 : projectNameMatch[1]) || ""
@@ -10407,7 +10867,7 @@ async function deployFrontend2(projectName) {
   console.log(import_chalk24.default.blue("Deploying frontend to IPFS..."));
   try {
     const headers = getAuthHeaders();
-    const uploadResult = await uploadPath(import_path16.default.join(PROJECT_DIR5, "frontend", "dist"), {
+    const uploadResult = await uploadPath(import_path17.default.join(PROJECT_DIR5, "frontend", "dist"), {
       action: "project_update_web",
       projectName,
       uid: headers["token-address"]
@@ -10432,11 +10892,11 @@ async function updateWebCmd(options) {
         "Run `pinme login` and retry."
       ]);
     }
-    const projectDir = (options == null ? void 0 : options.projectName) || (options == null ? void 0 : options.name) ? import_path16.default.join(PROJECT_DIR5, options.projectName || options.name) : PROJECT_DIR5;
-    const tokenFileSrc = import_path16.default.join(PROJECT_DIR5, ".token.json");
-    const tokenFileDst = import_path16.default.join(projectDir, ".token.json");
-    if (import_fs_extra10.default.existsSync(tokenFileSrc) && !import_fs_extra10.default.existsSync(tokenFileDst)) {
-      import_fs_extra10.default.copySync(tokenFileSrc, tokenFileDst);
+    const projectDir = (options == null ? void 0 : options.projectName) || (options == null ? void 0 : options.name) ? import_path17.default.join(PROJECT_DIR5, options.projectName || options.name) : PROJECT_DIR5;
+    const tokenFileSrc = import_path17.default.join(PROJECT_DIR5, ".token.json");
+    const tokenFileDst = import_path17.default.join(projectDir, ".token.json");
+    if (import_fs_extra11.default.existsSync(tokenFileSrc) && !import_fs_extra11.default.existsSync(tokenFileDst)) {
+      import_fs_extra11.default.copySync(tokenFileSrc, tokenFileDst);
     }
     console.log(import_chalk24.default.blue("Updating web (frontend)...\n"));
     console.log(import_chalk24.default.gray(`Project dir: ${PROJECT_DIR5}`));
@@ -10480,16 +10940,16 @@ async function updateWebCmd(options) {
 var import_chalk25 = __toESM(require("chalk"));
 var import_inquirer9 = __toESM(require("inquirer"));
 init_axios2();
-var import_fs_extra11 = __toESM(require("fs-extra"));
-var import_path17 = __toESM(require("path"));
+var import_fs_extra12 = __toESM(require("fs-extra"));
+var import_path18 = __toESM(require("path"));
 init_webLogin();
 init_config();
 function getProjectName() {
-  const configPath = import_path17.default.join(process.cwd(), "pinme.toml");
-  if (!import_fs_extra11.default.existsSync(configPath)) {
+  const configPath = import_path18.default.join(process.cwd(), "pinme.toml");
+  if (!import_fs_extra12.default.existsSync(configPath)) {
     return null;
   }
-  const config = import_fs_extra11.default.readFileSync(configPath, "utf-8");
+  const config = import_fs_extra12.default.readFileSync(configPath, "utf-8");
   const match = config.match(/project_name\s*=\s*"([^"]+)"/);
   return (match == null ? void 0 : match[1]) || null;
 }