livelocale 0.8.0 → 0.9.0

package/dist/codemod/index.js

@@ -292,14 +292,23 @@ var init_transform = __esm({
 });
 
 // src/codemod/index.ts
-import * as fs5 from "fs";
-import * as path5 from "path";
+import * as fs10 from "fs";
+import * as path15 from "path";
 import * as net from "net";
+
+// src/server/module-dir.ts
+import * as path from "path";
 import { fileURLToPath } from "url";
+function moduleDir() {
+  if (typeof __dirname !== "undefined") {
+    return __dirname;
+  }
+  return path.dirname(fileURLToPath(import.meta.url));
+}
 
 // src/codemod/studio-server.ts
 import * as fs from "fs";
-import * as path from "path";
+import * as path2 from "path";
 import * as http from "http";
 var MIME_TYPES = {
   ".html": "text/html; charset=utf-8",
@@ -328,8 +337,8 @@ function injectStudioConfig(html, config) {
 ${html}`;
 }
 function createStudioServer(options) {
-  const studioDir = path.resolve(options.studioDir);
-  const indexPath = path.join(studioDir, "index.html");
+  const studioDir = path2.resolve(options.studioDir);
+  const indexPath = path2.join(studioDir, "index.html");
   const config = { appOrigin: options.appOrigin };
   const sendIndex = (res) => {
     fs.readFile(indexPath, "utf-8", (err, html) => {
@@ -358,13 +367,13 @@ function createStudioServer(options) {
     const urlPath = req.url?.split("?")[0] || "/";
     let filePath;
     try {
-      filePath = path.resolve(studioDir, `.${decodeURIComponent(urlPath)}`);
+      filePath = path2.resolve(studioDir, `.${decodeURIComponent(urlPath)}`);
     } catch {
       res.statusCode = 400;
       res.end("Bad Request");
       return;
     }
-    if (filePath !== studioDir && !filePath.startsWith(studioDir + path.sep)) {
+    if (filePath !== studioDir && !filePath.startsWith(studioDir + path2.sep)) {
       res.statusCode = 403;
       res.end("Forbidden");
       return;
@@ -373,7 +382,7 @@ function createStudioServer(options) {
       sendIndex(res);
       return;
     }
-    const ext = path.extname(filePath);
+    const ext = path2.extname(filePath);
     const contentType = MIME_TYPES[ext] || "application/octet-stream";
     fs.readFile(filePath, (err, content) => {
       if (err) {
@@ -389,14 +398,340 @@ function createStudioServer(options) {
 
 // src/codemod/doctor.ts
 import * as fs2 from "fs";
-import * as path2 from "path";
+import * as path3 from "path";
 
 // src/core/validate.ts
 var LOCALE_RE = /^[a-zA-Z]{2,3}(-[a-zA-Z0-9]{2,4})?$/;
+var KEY_RE = /^[a-zA-Z0-9._-]+$/;
+var MAX_LOCALE_LENGTH = 10;
+var MAX_KEY_LENGTH = 200;
+var MAX_VALUE_LENGTH = 1e4;
+var DANGEROUS_KEY_SEGMENTS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+function isSafeKeyPath(key) {
+  if (typeof key !== "string") return false;
+  return !key.split(".").some((segment) => DANGEROUS_KEY_SEGMENTS.has(segment));
+}
+function isValidLocaleFormat(locale) {
+  return typeof locale === "string" && locale.length >= 2 && locale.length <= MAX_LOCALE_LENGTH && LOCALE_RE.test(locale);
+}
+function isValidKeyFormat(key) {
+  return typeof key === "string" && key.length >= 1 && key.length <= MAX_KEY_LENGTH && KEY_RE.test(key);
+}
+function isValidValueFormat(value) {
+  return typeof value === "string" && value.length <= MAX_VALUE_LENGTH;
+}
 function isSafeLocaleSegment(locale) {
   return !(locale.includes("..") || locale.includes("/") || locale.includes("\\") || locale.includes("%") || locale.includes("\0"));
 }
 
+// src/core/flag-script.ts
+var FLAG_SCRIPT_SIGNATURE = "/*! livelocale flag v1 */";
+var FLAG_SCRIPT = `${FLAG_SCRIPT_SIGNATURE}
+(function () {
+  try {
+    var me = document.currentScript;
+    if (!me || !me.src || window.parent === window || window.__LIVELOCALE_FLAG__ !== undefined)
+      return;
+    var studio = new URL('.', me.src);
+    var host = window.parent.location;
+    if (
+      host.origin === 'null' ||
+      host.origin !== window.location.origin ||
+      host.origin !== studio.origin
+    )
+      return;
+    if (host.pathname.indexOf(studio.pathname) !== 0) return;
+    window.__LIVELOCALE_FLAG__ = 'preview';
+  } catch (e) {}
+})();
+`;
+
+// src/core/change-link.ts
+var CHANGE_LINK_PREFIX = "lc1.";
+var CHANGE_BLOCK_OPEN = "```livelocale";
+var CHANGE_BLOCK_CLOSE = "```";
+var ChangeLinkError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "ChangeLinkError";
+    this.code = code;
+  }
+};
+var CORRUPT_MESSAGE = "This change link is damaged or incomplete. Ask the sender to send the file instead.";
+var UNSUPPORTED_VERSION_MESSAGE = "This change link was made by a newer LiveLocale. Update LiveLocale and try again.";
+var BASE64URL_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+function fromBase64Url(text) {
+  if (!/^[A-Za-z0-9_-]*$/.test(text) || text.length % 4 === 1) {
+    throw new ChangeLinkError("CORRUPT", CORRUPT_MESSAGE);
+  }
+  const tail = text.length % 4;
+  if (tail !== 0) {
+    const unusedBits = tail === 2 ? 15 : 3;
+    if ((BASE64URL_ALPHABET.indexOf(text[text.length - 1]) & unusedBits) !== 0) {
+      throw new ChangeLinkError("CORRUPT", CORRUPT_MESSAGE);
+    }
+  }
+  const binary = atob(
+    text.replace(/-/g, "+").replace(/_/g, "/") + "=".repeat(tail === 0 ? 0 : 4 - tail)
+  );
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+  return bytes;
+}
+function fencedBlockContent(text) {
+  const open = new RegExp(`${CHANGE_BLOCK_OPEN}(?:\\r\\n|\\r|\\n)`).exec(text);
+  if (!open) return null;
+  const lines = text.slice(open.index + open[0].length).split(/\r\n|\r|\n/);
+  const close = lines.indexOf(CHANGE_BLOCK_CLOSE);
+  return (close < 0 ? lines : lines.slice(0, close)).join("").replace(/\s+/g, "");
+}
+function findChangeToken(text) {
+  const scope = (fencedBlockContent(text) ?? text).replace(/%23/gi, "#");
+  const tokens = /* @__PURE__ */ new Set();
+  for (const match of scope.matchAll(/(?:^|[^A-Za-z0-9_-])lc1\.([A-Za-z0-9_-]+)/g)) {
+    tokens.add(match[1]);
+  }
+  if (tokens.size === 1) return CHANGE_LINK_PREFIX + [...tokens][0];
+  if (tokens.size > 1) {
+    throw new ChangeLinkError(
+      "AMBIGUOUS",
+      "This text holds more than one change link. Paste one link at a time."
+    );
+  }
+  if (/(?:^|[^A-Za-z0-9_-])lc(?:[2-9]|[1-9]\d+)\.[A-Za-z0-9_-]/.test(scope)) {
+    throw new ChangeLinkError("UNSUPPORTED_VERSION", UNSUPPORTED_VERSION_MESSAGE);
+  }
+  throw new ChangeLinkError(
+    "NOT_FOUND",
+    'This is not a LiveLocale change link. A change link contains "lc1.".'
+  );
+}
+function isValidRepoSlug(slug) {
+  if (!/^[A-Za-z0-9][A-Za-z0-9-]{0,38}\/[A-Za-z0-9._-]{1,100}$/.test(slug)) return false;
+  const repo = slug.slice(slug.indexOf("/") + 1);
+  return repo !== "." && repo !== "..";
+}
+var BRANCH_NAME_RE = /^(?!-)(?!.*\.\.)[^\s\x00-\x1f\x7f]{1,255}$/;
+function isValidBranchName(name) {
+  return BRANCH_NAME_RE.test(name) && !hasLoneSurrogate(name);
+}
+var CHANGE_LINK_VERSION = 1;
+var MAX_CHANGE_EDITS = 500;
+var MAX_BY_CHARS = 100;
+var MAX_NOTE_CHARS = 2e3;
+var BASE_SHA_RE = /^(?:[0-9a-f]{40}|[0-9a-f]{64})?$/;
+var BY_FORBIDDEN_RE = /[\x00-\x1f\x7f]/;
+var NOTE_FORBIDDEN_RE = /[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/;
+var LONE_SURROGATE_RE = /[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:^|[^\uD800-\uDBFF])[\uDC00-\uDFFF]/;
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function own(obj, key) {
+  return Object.prototype.hasOwnProperty.call(obj, key) ? obj[key] : void 0;
+}
+function invalid(message) {
+  return new ChangeLinkError("INVALID", message);
+}
+function hasLoneSurrogate(text) {
+  return typeof text === "string" && LONE_SURROGATE_RE.test(text);
+}
+function parseEdit(entry, n) {
+  const fail = (problem) => invalid(`edit ${n}: ${problem}`);
+  if (!Array.isArray(entry) || entry.length !== 4 && entry.length !== 5) {
+    throw fail("is not a [locale, key, from, to] entry.");
+  }
+  const [locale, key, from, to, force] = entry;
+  if (typeof locale !== "string" || !isValidLocaleFormat(locale)) {
+    throw fail("the locale is not a locale code.");
+  }
+  if (typeof key !== "string" || !isValidKeyFormat(key) || !isSafeKeyPath(key)) {
+    throw fail("the key is not a valid translation key.");
+  }
+  if (from !== null && (typeof from !== "string" || !isValidValueFormat(from))) {
+    throw fail(`the current text is not text of at most ${MAX_VALUE_LENGTH} characters.`);
+  }
+  if (typeof to !== "string" || !isValidValueFormat(to)) {
+    throw fail(`the new text is not text of at most ${MAX_VALUE_LENGTH} characters.`);
+  }
+  if (entry.length === 5 && force !== 1) throw fail("the force flag must be 1.");
+  return { locale, key, from, to, force: entry.length === 5 };
+}
+function checkKeysDistinct(edits) {
+  const keysByLocale = /* @__PURE__ */ new Map();
+  edits.forEach(({ locale, key }, i) => {
+    let keys = keysByLocale.get(locale);
+    if (!keys) keysByLocale.set(locale, keys = /* @__PURE__ */ new Set());
+    if (keys.has(key)) throw invalid(`edit ${i + 1}: an earlier edit changes the same key.`);
+    keys.add(key);
+  });
+  edits.forEach(({ locale, key }, i) => {
+    const keys = keysByLocale.get(locale);
+    for (let dot = key.indexOf("."); dot >= 0; dot = key.indexOf(".", dot + 1)) {
+      if (keys.has(key.slice(0, dot))) {
+        throw invalid(`edit ${i + 1}: another edit changes a key that contains this one.`);
+      }
+    }
+  });
+}
+function parseChangeSet(value) {
+  if (!isPlainObject(value)) throw invalid("This change link does not hold a change set.");
+  if (own(value, "v") !== CHANGE_LINK_VERSION) {
+    throw new ChangeLinkError("UNSUPPORTED_VERSION", UNSUPPORTED_VERSION_MESSAGE);
+  }
+  const repo = own(value, "repo");
+  if (repo !== void 0 && (typeof repo !== "string" || !isValidRepoSlug(repo))) {
+    throw invalid("The repository is not an owner/name slug.");
+  }
+  const branch = own(value, "branch");
+  if (typeof branch !== "string" || branch !== "" && !isValidBranchName(branch)) {
+    throw invalid("The branch is not a valid branch name.");
+  }
+  const base = own(value, "base");
+  if (typeof base !== "string" || !BASE_SHA_RE.test(base)) {
+    throw invalid("The base is not a full commit id.");
+  }
+  const src = own(value, "src");
+  if (typeof src !== "string" || !isValidLocaleFormat(src)) {
+    throw invalid("The source locale is not a locale code.");
+  }
+  const by = own(value, "by");
+  if (typeof by !== "string" || by.length > MAX_BY_CHARS || BY_FORBIDDEN_RE.test(by)) {
+    throw invalid(`The name is not one line of at most ${MAX_BY_CHARS} characters.`);
+  }
+  const note = own(value, "note");
+  if (typeof note !== "string" || note.length > MAX_NOTE_CHARS || NOTE_FORBIDDEN_RE.test(note)) {
+    throw invalid(`The note is not plain text of at most ${MAX_NOTE_CHARS} characters.`);
+  }
+  const entries = own(value, "e");
+  if (!Array.isArray(entries)) throw invalid("This change link holds no list of edits.");
+  if (entries.length > MAX_CHANGE_EDITS) {
+    throw new ChangeLinkError(
+      "TOO_MANY_EDITS",
+      `A change link holds at most ${MAX_CHANGE_EDITS} edits. Send the rest in another link.`
+    );
+  }
+  if (entries.length === 0) throw invalid("This change link holds no edits.");
+  const edits = Array.from(entries, (entry, i) => parseEdit(entry, i + 1));
+  checkKeysDistinct(edits);
+  if ([repo, branch, base, src, by, note].some(hasLoneSurrogate)) {
+    throw invalid("This change link holds broken text.");
+  }
+  edits.forEach(({ locale, key, from, to }, i) => {
+    if ([locale, key, from, to].some(hasLoneSurrogate)) {
+      throw invalid(`edit ${i + 1}: holds broken text.`);
+    }
+  });
+  return { ...repo === void 0 ? {} : { repo }, branch, base, src, by, note, edits };
+}
+var MAX_INFLATED_BYTES = 512 * 1024;
+var MAX_TOKEN_CHARS = 1e6;
+var TOO_LARGE_MESSAGE = `A change link holds at most ${MAX_INFLATED_BYTES / 1024} KB of text. Send the changes in smaller links.`;
+var UNSUPPORTED_ENVIRONMENT_MESSAGE = "This browser cannot create or read change links. Use a current Chrome, Edge or Firefox, or Safari 16.4 or later.";
+var FEED_SLICE_BYTES = 4096;
+async function pipeBytes(stream, bytes, maxOutputLength) {
+  const input = new Uint8Array(bytes);
+  const writer = stream.writable.getWriter();
+  const reader = stream.readable.getReader();
+  let stopped = false;
+  void (async () => {
+    for (let at = 0; at < input.length; at += FEED_SLICE_BYTES) {
+      if (stopped) return;
+      await writer.write(input.subarray(at, at + FEED_SLICE_BYTES));
+    }
+    if (!stopped) await writer.close();
+  })().catch(() => {
+  });
+  const chunks = [];
+  let total = 0;
+  try {
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      total += value.length;
+      if (total > maxOutputLength) throw new ChangeLinkError("TOO_LARGE", TOO_LARGE_MESSAGE);
+      chunks.push(value);
+    }
+  } catch (err) {
+    stopped = true;
+    void writer.abort(err).catch(() => {
+    });
+    await reader.cancel(err).catch(() => {
+    });
+    throw err;
+  }
+  const out = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    out.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return out;
+}
+var streamInflate = async (bytes, maxOutputLength) => {
+  if (typeof globalThis.DecompressionStream !== "function") {
+    throw new ChangeLinkError("UNSUPPORTED_ENVIRONMENT", UNSUPPORTED_ENVIRONMENT_MESSAGE);
+  }
+  try {
+    return await pipeBytes(new DecompressionStream("deflate"), bytes, maxOutputLength);
+  } catch (err) {
+    if (err instanceof ChangeLinkError) throw err;
+    throw new ChangeLinkError("CORRUPT", CORRUPT_MESSAGE);
+  }
+};
+async function decodeChangeLink(text, inflate = streamInflate) {
+  const token = findChangeToken(text);
+  if (token.length > MAX_TOKEN_CHARS) {
+    throw new ChangeLinkError("TOO_LARGE", TOO_LARGE_MESSAGE);
+  }
+  try {
+    const bytes = await inflate(
+      fromBase64Url(token.slice(CHANGE_LINK_PREFIX.length)),
+      MAX_INFLATED_BYTES
+    );
+    const json = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+    return parseChangeSet(JSON.parse(json));
+  } catch (err) {
+    if (err instanceof ChangeLinkError) throw err;
+    throw new ChangeLinkError("CORRUPT", CORRUPT_MESSAGE);
+  }
+}
+
+// src/core/share-manifest.ts
+var SHARE_DIR = "livelocale";
+var SHARE_MANIFEST_FILE = "manifest.json";
+var SHARE_FLAG_FILE = "flag.js";
+var SHARE_LOCALES_DIR = "locales";
+var SHARE_MANIFEST_FORMAT = 1;
+var BASE_SHA_RE2 = /^[0-9a-f]{40}([0-9a-f]{24})?$/;
+function own2(obj, key) {
+  return Object.prototype.hasOwnProperty.call(obj, key) ? obj[key] : void 0;
+}
+function isArrayOf(value, test) {
+  if (!Array.isArray(value)) return false;
+  for (let i = 0; i < value.length; i++) {
+    if (!test(value[i])) return false;
+  }
+  return true;
+}
+function isString(value) {
+  return typeof value === "string";
+}
+function isLocaleCode(value) {
+  return typeof value === "string" && LOCALE_RE.test(value);
+}
+function isNullOr(value, test) {
+  return value === null || typeof value === "string" && test(value);
+}
+function isShareManifest(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+  const repo = own2(value, "repo");
+  const layout = own2(value, "layout");
+  const locales = own2(value, "locales");
+  const sourceLocale = own2(value, "sourceLocale");
+  return own2(value, "format") === SHARE_MANIFEST_FORMAT && (repo === void 0 || typeof repo === "string" && isValidRepoSlug(repo)) && isNullOr(own2(value, "defaultBranch"), isValidBranchName) && isNullOr(own2(value, "branch"), isValidBranchName) && isNullOr(own2(value, "base"), (base) => BASE_SHA_RE2.test(base)) && typeof own2(value, "localesPath") === "string" && (layout === "flat" || layout === "namespaced") && isArrayOf(locales, isLocaleCode) && typeof sourceLocale === "string" && locales.includes(sourceLocale) && isNullOr(own2(value, "basePath"), (path16) => path16.startsWith("/") && path16.endsWith("/")) && isArrayOf(own2(value, "codeKeys"), isString);
+}
+
 // src/codemod/doctor.ts
 var ROUTE_CANDIDATES = [
   "app/api/livelocale/route.ts",
@@ -439,10 +774,32 @@ var NEXT_CONFIG_CANDIDATES = [
   "next.config.ts",
   "next.config.cjs"
 ];
+var VITE_CONFIG_CANDIDATES = [
+  "vite.config.ts",
+  "vite.config.mts",
+  "vite.config.js",
+  "vite.config.mjs",
+  "vite.config.cjs",
+  "vite.config.cts"
+];
+var SERVICE_WORKER_CONFIG_CANDIDATES = [
+  ...VITE_CONFIG_CANDIDATES,
+  "webpack.config.js",
+  "webpack.config.cjs",
+  "webpack.config.mjs",
+  "webpack.config.ts",
+  "craco.config.js",
+  "craco.config.ts",
+  "vue.config.js",
+  "config-overrides.js",
+  ...NEXT_CONFIG_CANDIDATES,
+  "package.json"
+];
 var API_ROUTE = "/api/livelocale";
+var DENYLIST_LINE = "navigateFallbackDenylist: [/^\\/livelocale\\//]";
 function firstExisting(root, candidates) {
   for (const rel of candidates) {
-    if (fs2.existsSync(path2.join(root, rel))) return rel;
+    if (fs2.existsSync(path3.join(root, rel))) return rel;
   }
   return null;
 }
@@ -453,9 +810,31 @@ function readText(file) {
     return "";
   }
 }
+function buildsStaticShare(root) {
+  const vite = firstExisting(root, VITE_CONFIG_CANDIDATES);
+  const viteText = vite ? readText(path3.join(root, vite)) : "";
+  if (/liveLocaleVite\s*\(\s*\{[^)]*\bshare\b(?!\s*:\s*false)/.test(viteText)) return true;
+  let scripts;
+  try {
+    scripts = JSON.parse(readText(path3.join(root, "package.json")) || "{}")?.scripts;
+  } catch {
+    return false;
+  }
+  if (typeof scripts !== "object" || scripts === null) return false;
+  return Object.values(scripts).some(
+    (cmd) => typeof cmd === "string" && /\blivelocale\s+(?:pack|build)\b/.test(cmd)
+  );
+}
 function checkRouteHandler(root) {
   const found = firstExisting(root, ROUTE_CANDIDATES);
   if (found) return { level: "ok", title: "Mutation route handler", detail: found };
+  if (buildsStaticShare(root)) {
+    return {
+      level: "ok",
+      title: "Mutation route handler",
+      detail: "not needed for the share link (static build)"
+    };
+  }
   return {
     level: "fail",
     title: "Mutation route handler",
@@ -463,7 +842,7 @@ function checkRouteHandler(root) {
   };
 }
 function checkProvider(root) {
-  const existing = LAYOUT_CANDIDATES.filter((rel) => fs2.existsSync(path2.join(root, rel)));
+  const existing = LAYOUT_CANDIDATES.filter((rel) => fs2.existsSync(path3.join(root, rel)));
   if (existing.length === 0) {
     return {
       level: "warn",
@@ -471,7 +850,7 @@ function checkProvider(root) {
       detail: "No root layout (app/layout.*) or pages/_app.* found, so the provider could not be verified."
     };
   }
-  const mounted = existing.find((rel) => /LiveLocaleProvider/.test(readText(path2.join(root, rel))));
+  const mounted = existing.find((rel) => /LiveLocaleProvider/.test(readText(path3.join(root, rel))));
   if (mounted) return { level: "ok", title: "LiveLocaleProvider mounted", detail: mounted };
   return {
     level: "warn",
@@ -482,7 +861,7 @@ function checkProvider(root) {
 function checkMiddleware(root) {
   const found = firstExisting(root, MIDDLEWARE_CANDIDATES);
   if (!found) return { level: "ok", title: "Middleware matcher", detail: "no middleware file" };
-  const text = readText(path2.join(root, found));
+  const text = readText(path3.join(root, found));
   if (text.includes("api/livelocale")) {
     return { level: "ok", title: "Middleware matcher", detail: `${found} excludes ${API_ROUTE}` };
   }
@@ -501,7 +880,7 @@ function checkFrameHeaders(root) {
   const found = firstExisting(root, NEXT_CONFIG_CANDIDATES);
   if (!found)
     return { level: "ok", title: "Frame-blocking headers in next.config", detail: "none" };
-  const text = readText(path2.join(root, found));
+  const text = readText(path3.join(root, found));
   if (STUDIO_ORIGIN_RE.test(text)) {
     return {
       level: "ok",
@@ -522,8 +901,8 @@ function checkFrameHeaders(root) {
   };
 }
 function checkLocales(root, localesPath) {
-  const dir = path2.resolve(root, localesPath ?? "locales");
-  const rel = path2.relative(root, dir) || ".";
+  const dir = path3.resolve(root, localesPath ?? "locales");
+  const rel = path3.relative(root, dir) || ".";
   if (!fs2.existsSync(dir) || !fs2.statSync(dir).isDirectory()) {
     return {
       level: "fail",
@@ -534,27 +913,27 @@ function checkLocales(root, localesPath) {
   const entries = fs2.readdirSync(dir, { withFileTypes: true });
   const flat = entries.filter((e) => e.isFile() && e.name.endsWith(".json"));
   const dirs = entries.filter((e) => e.isDirectory() && LOCALE_RE.test(e.name));
-  const invalid = [];
+  const invalid2 = [];
   let fileCount = 0;
   const validate = (file, label) => {
     fileCount++;
     try {
       const parsed = JSON.parse(fs2.readFileSync(file, "utf-8"));
       if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
-        invalid.push(`${label} (root must be an object)`);
+        invalid2.push(`${label} (root must be an object)`);
       }
     } catch (err) {
-      invalid.push(`${label} (${err.message})`);
+      invalid2.push(`${label} (${err.message})`);
     }
   };
-  for (const f of flat) validate(path2.join(dir, f.name), f.name);
+  for (const f of flat) validate(path3.join(dir, f.name), f.name);
   for (const d of dirs) {
-    for (const f of fs2.readdirSync(path2.join(dir, d.name))) {
-      if (f.endsWith(".json")) validate(path2.join(dir, d.name, f), `${d.name}/${f}`);
+    for (const f of fs2.readdirSync(path3.join(dir, d.name))) {
+      if (f.endsWith(".json")) validate(path3.join(dir, d.name, f), `${d.name}/${f}`);
     }
   }
-  if (invalid.length > 0) {
-    return { level: "fail", title: "Locale files", detail: `Invalid JSON: ${invalid.join("; ")}` };
+  if (invalid2.length > 0) {
+    return { level: "fail", title: "Locale files", detail: `Invalid JSON: ${invalid2.join("; ")}` };
   }
   if (fileCount === 0) {
     return {
@@ -577,6 +956,22 @@ function checkLocales(root, localesPath) {
     detail: `${rel}: ${layout}, ${fileCount} file(s) parse`
   };
 }
+function checkServiceWorkerConfig(root) {
+  const files = SERVICE_WORKER_CONFIG_CANDIDATES.filter(
+    (rel) => fs2.existsSync(path3.join(root, rel))
+  ).map((rel) => ({ rel, text: readText(path3.join(root, rel)) }));
+  const pwa = files.find(({ text }) => /VitePWA\s*\(|workbox-webpack-plugin/.test(text));
+  if (!pwa) return null;
+  if (files.some(({ text }) => /navigateFallbackDenylist[\s\S]{0,300}?livelocale/.test(text))) {
+    return null;
+  }
+  const plugin = /VitePWA\s*\(/.test(pwa.text) ? "VitePWA" : "workbox-webpack-plugin";
+  return {
+    level: "warn",
+    title: "Service worker config",
+    detail: `${pwa.rel} uses ${plugin}, and its navigation fallback would answer livelocale/index.html with your app's page. Add to its Workbox options: ${DENYLIST_LINE}`
+  };
+}
 async function probe(fetchImpl, url, token) {
   try {
     const signal = typeof AbortSignal.timeout === "function" ? AbortSignal.timeout(15e3) : void 0;
@@ -709,8 +1104,265 @@ async function checkLive(appOrigin, fetchImpl, token) {
   }
   return findings;
 }
+function shareLinkFor(appBase) {
+  return `${appBase}${SHARE_DIR}/index.html`;
+}
+function normalizeAppUrl(value) {
+  const url = new URL(value);
+  if (url.protocol !== "http:" && url.protocol !== "https:") {
+    throw new Error(`Not an http(s) URL: ${value}`);
+  }
+  let pathname = url.pathname.replace(/index\.html$/, "");
+  if (!pathname.endsWith("/")) pathname += "/";
+  return { origin: url.origin, base: `${url.origin}${pathname}` };
+}
+var STUDIO_TITLE = "LiveLocale \xB7 Studio";
+var UPLOAD_HINT = "Upload the livelocale/ folder from your build output.";
+function isAnswer(page) {
+  return !("error" in page);
+}
+async function fetchPage(fetchImpl, url, origin) {
+  const res = await probe(fetchImpl, url);
+  if (!res.ok) return { url, error: res.error };
+  let body = "";
+  try {
+    body = await res.res.text();
+  } catch {
+  }
+  return {
+    url,
+    status: res.res.status,
+    headers: res.res.headers,
+    body,
+    wall: loginWall(res.res, origin)
+  };
+}
+function answered(title, page) {
+  if (!isAnswer(page)) {
+    return { level: "fail", title, detail: `${page.url} is not reachable (${page.error}).` };
+  }
+  if (page.wall) return { level: "fail", title, detail: page.wall };
+  return page;
+}
+function parseJson(text) {
+  try {
+    return { ok: true, value: JSON.parse(text) };
+  } catch {
+    return { ok: false };
+  }
+}
+function checkStudioPage(studioPage, root) {
+  const title = "Share Studio page";
+  const studio = answered(title, studioPage);
+  if ("level" in studio) return studio;
+  if (studio.status === 200 && isAnswer(root) && root.status === 200 && studio.body === root.body) {
+    return {
+      level: "fail",
+      title,
+      detail: `The host answered livelocale/index.html with your app's page (SPA fallback or service worker). ${UPLOAD_HINT}`
+    };
+  }
+  if (studio.status === 200 && studio.body.includes(STUDIO_TITLE)) {
+    return { level: "ok", title, detail: studio.url };
+  }
+  return {
+    level: "fail",
+    title,
+    detail: `${studio.url} answered HTTP ${studio.status} without the LiveLocale Studio. ${UPLOAD_HINT}`
+  };
+}
+function checkManifest(manifestPage) {
+  const title = "Share manifest";
+  const manifest = answered(title, manifestPage);
+  if ("level" in manifest) return manifest;
+  if (manifest.status === 404) {
+    return {
+      level: "fail",
+      title,
+      detail: `${manifest.url} answered HTTP 404; did the build run with share: true or livelocale pack?`
+    };
+  }
+  const parsed = manifest.status === 200 ? parseJson(manifest.body) : { ok: false };
+  if (parsed.ok && isShareManifest(parsed.value)) {
+    const m = parsed.value;
+    return {
+      level: "ok",
+      title,
+      detail: `${m.locales.length} locale(s), source ${m.sourceLocale}, built from ${m.branch ?? "an unknown branch"} @ ${m.base?.slice(0, 7) ?? "an unknown commit"}`
+    };
+  }
+  return {
+    level: "fail",
+    title,
+    detail: `${manifest.url} answered HTTP ${manifest.status} without a LiveLocale share manifest (format 1). Rebuild with share: true or run livelocale pack.`
+  };
+}
+var HEAD_OPEN = /<head(?=[\s>])[^>]*>/i;
+var HTML_OPEN = /<html(?=[\s>])[^>]*>/i;
+var DOCTYPE = /<!doctype\b[^>]*>/i;
+function firstHeadScript(html) {
+  let start = 0;
+  for (const pattern of [HEAD_OPEN, HTML_OPEN, DOCTYPE]) {
+    const match = pattern.exec(html);
+    if (match) {
+      start = match.index + match[0].length;
+      break;
+    }
+  }
+  const rest = html.slice(start).replace(/^(?:\s|<!--[\s\S]*?-->)*/, "");
+  return /^<script\b([^>]*)>/i.exec(rest)?.[1] ?? null;
+}
+function flagTagProblem(root, base, flagUrl) {
+  const expected = `The first element in <head> of ${base} must be <script src="${flagUrl}"></script> without async. Run livelocale pack on the build output again.`;
+  if (!isAnswer(root) || root.status !== 200) return expected;
+  const attrs = firstHeadScript(root.body);
+  if (attrs === null || /(?:^|\s)async(?=[\s=]|$)/i.test(attrs)) return expected;
+  const src = /(?:^|\s)src\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'>]+))/i.exec(attrs);
+  const value = src ? src[1] ?? src[2] ?? src[3] ?? "" : "";
+  try {
+    if (src && new URL(value, base).href === flagUrl) return null;
+  } catch {
+  }
+  return expected;
+}
+function checkFlagScript(flagPage, root, base) {
+  const title = "Share flag script";
+  const flag = answered(title, flagPage);
+  if ("level" in flag) return flag;
+  const problems = [];
+  const type = flag.headers.get("content-type") || "";
+  if (flag.status !== 200 || !/javascript|ecmascript/i.test(type) || !flag.body.startsWith(FLAG_SCRIPT_SIGNATURE)) {
+    problems.push(
+      `${flag.url} answered HTTP ${flag.status} (${type || "no content type"}) without the LiveLocale flag script. ${UPLOAD_HINT}`
+    );
+  }
+  const tag = flagTagProblem(root, base, flag.url);
+  if (tag) problems.push(tag);
+  if (problems.length > 0) return { level: "fail", title, detail: problems.join(" ") };
+  return { level: "ok", title, detail: `${flag.url} loads first in <head>` };
+}
+function cspSources(csp, directive) {
+  for (const part of csp.split(";")) {
+    const [name, ...sources] = part.trim().split(/\s+/);
+    if (name && name.toLowerCase() === directive) return sources;
+  }
+  return null;
+}
+function allowsSelf(sources, origin) {
+  return sources.some((s) => s === "'self'" || s === "*" || s.replace(/\/+$/, "") === origin);
+}
+function checkShareFrameHeaders(pages, origin) {
+  const title = "Share frame headers";
+  const blockers = [];
+  for (const page of pages) {
+    const answer = answered(title, page);
+    if ("level" in answer) return answer;
+    const xfo = (answer.headers.get("x-frame-options") || "").trim();
+    if (/^deny$/i.test(xfo)) blockers.push(`${page.url} sends X-Frame-Options: ${xfo}`);
+    const ancestors = cspSources(
+      answer.headers.get("content-security-policy") || "",
+      "frame-ancestors"
+    );
+    if (ancestors && (ancestors.includes("'none'") || !allowsSelf(ancestors, origin))) {
+      blockers.push(`${page.url} sends frame-ancestors ${ancestors.join(" ") || "'none'"}`);
+    }
+  }
+  if (blockers.length > 0) {
+    return {
+      level: "fail",
+      title,
+      detail: `${blockers.join("; ")}. The share Studio frames your app from the same origin; use X-Frame-Options: SAMEORIGIN or frame-ancestors 'self'.`
+    };
+  }
+  return { level: "ok", title, detail: "both pages can be framed by the same origin" };
+}
+function checkShareCsp(pages, origin) {
+  const title = "Share CSP";
+  const blocked = [];
+  for (const page of pages) {
+    const answer = answered(title, page);
+    if ("level" in answer) return answer;
+    const csp = answer.headers.get("content-security-policy") || "";
+    const scriptSrc = cspSources(csp, "script-src");
+    const sources = scriptSrc ?? cspSources(csp, "default-src");
+    if (sources && !allowsSelf(sources, origin)) {
+      blocked.push(`${page.url} (${scriptSrc ? "script-src" : "default-src"})`);
+    }
+  }
+  if (blocked.length > 0) {
+    return {
+      level: "warn",
+      title,
+      detail: `${blocked.join(", ")} leaves out 'self', so the browser may block livelocale/flag.js and the Studio's scripts. Add 'self' to script-src.`
+    };
+  }
+  return { level: "ok", title, detail: "scripts from 'self' are allowed" };
+}
+function workerCandidates(root, base) {
+  const urls = [];
+  if (isAnswer(root)) {
+    const registered = /serviceWorker\s*\.\s*register\s*\(\s*["'`]([^"'`]+)["'`]/.exec(root.body);
+    if (registered) {
+      try {
+        urls.push(new URL(registered[1], base).href);
+      } catch {
+      }
+    }
+  }
+  const names = ["sw.js", "service-worker.js"];
+  for (const url of [
+    ...names.map((name) => new URL(name, base).href),
+    ...names.map((name) => new URL(`/${name}`, base).href)
+  ]) {
+    if (!urls.includes(url)) urls.push(url);
+  }
+  return urls;
+}
+async function checkServiceWorker(fetchImpl, root, base, origin) {
+  const title = "Service worker";
+  const found = [];
+  for (const url of workerCandidates(root, base)) {
+    const worker = await fetchPage(fetchImpl, url, origin);
+    if (!isAnswer(worker)) continue;
+    if (worker.wall) return { level: "fail", title, detail: worker.wall };
+    if (worker.status !== 200 || /html/i.test(worker.headers.get("content-type") || "")) continue;
+    found.push(url);
+    if (/createHandlerBoundToURL|navigateFallback/.test(worker.body) && !worker.body.includes("livelocale")) {
+      return {
+        level: "warn",
+        title,
+        detail: `${url} answers navigations with the app shell, so livelocale/index.html would open your app. Add to your Workbox config: ${DENYLIST_LINE}`
+      };
+    }
+  }
+  return {
+    level: "ok",
+    title,
+    detail: found.length > 0 ? `${found.join(", ")} leaves livelocale/ alone` : "none found"
+  };
+}
+async function checkShare(origin, base, fetchImpl, manifest) {
+  const shareUrl = (file) => `${base}${SHARE_DIR}/${file}`;
+  const [root, studio, flag] = await Promise.all([
+    fetchPage(fetchImpl, base, origin),
+    fetchPage(fetchImpl, shareLinkFor(base), origin),
+    fetchPage(fetchImpl, shareUrl(SHARE_FLAG_FILE), origin)
+  ]);
+  return [
+    checkStudioPage(studio, root),
+    checkManifest(manifest),
+    checkFlagScript(flag, root, base),
+    checkShareFrameHeaders([root, studio], origin),
+    checkShareCsp([root, studio], origin),
+    await checkServiceWorker(fetchImpl, root, base, origin),
+    { level: "ok", title: "Share link", detail: shareLinkFor(base) }
+  ];
+}
+function looksLikeShareBuild(manifest) {
+  return isAnswer(manifest) && manifest.status === 200 && parseJson(manifest.body).ok;
+}
 async function runDoctor(options) {
-  const root = path2.resolve(options.projectDir);
+  const root = path3.resolve(options.projectDir);
   const findings = [
     checkRouteHandler(root),
     checkProvider(root),
@@ -718,7 +1370,10 @@ async function runDoctor(options) {
     checkFrameHeaders(root),
     checkLocales(root, options.localesPath)
   ];
-  if (options.appOrigin) {
+  const workerConfig = checkServiceWorkerConfig(root);
+  if (workerConfig) findings.push(workerConfig);
+  const appOrigin = options.appOrigin ?? (options.appBase && new URL(options.appBase).origin);
+  if (appOrigin) {
     const fetchImpl = options.fetchImpl ?? globalThis.fetch;
     if (typeof fetchImpl !== "function") {
       findings.push({
@@ -727,8 +1382,19 @@ async function runDoctor(options) {
         detail: "Live checks need Node 18+ (global fetch)."
       });
     } else {
-      const token = options.token ?? process.env["LIVELOCALE_TOKEN"] ?? void 0;
-      findings.push(...await checkLive(options.appOrigin, fetchImpl, token || void 0));
+      const origin = appOrigin.replace(/\/+$/, "");
+      const base = options.appBase ?? `${origin}/`;
+      const manifest = await fetchPage(
+        fetchImpl,
+        `${base}${SHARE_DIR}/${SHARE_MANIFEST_FILE}`,
+        origin
+      );
+      if (options.share || looksLikeShareBuild(manifest)) {
+        findings.push(...await checkShare(origin, base, fetchImpl, manifest));
+      } else {
+        const token = options.token ?? process.env["LIVELOCALE_TOKEN"] ?? void 0;
+        findings.push(...await checkLive(origin, fetchImpl, token || void 0));
+      }
     }
   }
   return findings;
@@ -748,7 +1414,7 @@ function formatFindings(findings) {
 
 // src/codemod/check.ts
 import * as fs4 from "fs";
-import * as path4 from "path";
+import * as path5 from "path";
 
 // src/core/placeholders.ts
 var PLURAL_TYPES = /* @__PURE__ */ new Set(["plural", "select", "selectordinal"]);
@@ -913,7 +1579,7 @@ function validateMessageSyntax(message) {
 
 // src/server/key-scanner.ts
 import { promises as fs3 } from "fs";
-import * as path3 from "path";
+import * as path4 from "path";
 
 // src/core/env.ts
 var OFF_VALUES = /* @__PURE__ */ new Set(["off", "0", "false"]);
@@ -1194,7 +1860,7 @@ var KeyScanner = class {
     }
   }
   async loadGitignore(projectRoot) {
-    const gitignorePath = path3.join(projectRoot, ".gitignore");
+    const gitignorePath = path4.join(projectRoot, ".gitignore");
     let stat;
     try {
       stat = await fs3.stat(gitignorePath);
@@ -1219,16 +1885,16 @@ var KeyScanner = class {
    * Scans the project (the parent directory of `basePath`) for translation key references.
    */
   async scanCodebaseKeys(basePath) {
-    return this.scanSourceKeys(path3.dirname(path3.resolve(basePath)));
+    return this.scanSourceKeys(path4.dirname(path4.resolve(basePath)));
   }
   /** Scans every source file under `projectRoot` for translation key references. */
   async scanSourceKeys(projectRoot) {
     this.assertEnabled();
-    projectRoot = path3.resolve(projectRoot);
+    projectRoot = path4.resolve(projectRoot);
     const gitignore = await this.loadGitignore(projectRoot);
     const keysSet = /* @__PURE__ */ new Set();
     const seen = /* @__PURE__ */ new Set();
-    const toRel = (fullPath) => path3.relative(projectRoot, fullPath).split(path3.sep).join("/");
+    const toRel = (fullPath) => path4.relative(projectRoot, fullPath).split(path4.sep).join("/");
     const scanDir = async (dir) => {
       let items;
       try {
@@ -1237,7 +1903,7 @@ var KeyScanner = class {
         return;
       }
       for (const item of items) {
-        const fullPath = path3.join(dir, item.name);
+        const fullPath = path4.join(dir, item.name);
         if (item.isDirectory()) {
           if (IGNORE_DIRS.has(item.name)) continue;
           if (gitignore.ignores(toRel(fullPath), true)) continue;
@@ -1245,7 +1911,7 @@ var KeyScanner = class {
           continue;
         }
         if (!item.isFile()) continue;
-        if (!SOURCE_EXTENSIONS.has(path3.extname(item.name))) continue;
+        if (!SOURCE_EXTENSIONS.has(path4.extname(item.name))) continue;
         if (item.name.endsWith(".d.ts")) continue;
         if (gitignore.ignores(toRel(fullPath), false)) continue;
         let stat;
@@ -1285,8 +1951,8 @@ var KeyScanner = class {
     const keysSet = /* @__PURE__ */ new Set();
     for (const locale of locales) {
       try {
-        const resolvedBasePath = path3.resolve(basePath);
-        const localePath = path3.resolve(resolvedBasePath, locale);
+        const resolvedBasePath = path4.resolve(basePath);
+        const localePath = path4.resolve(resolvedBasePath, locale);
         let isDir = false;
         try {
           const stats = await fs3.stat(localePath);
@@ -1298,9 +1964,9 @@ var KeyScanner = class {
           const files = await fs3.readdir(localePath);
           for (const file of files) {
             if (file.endsWith(".json")) {
-              const ns = path3.basename(file, ".json");
+              const ns = path4.basename(file, ".json");
               try {
-                const content = await fs3.readFile(path3.join(localePath, file), "utf-8");
+                const content = await fs3.readFile(path4.join(localePath, file), "utf-8");
                 data[ns] = JSON.parse(content);
               } catch {
               }
@@ -1311,7 +1977,7 @@ var KeyScanner = class {
             if (!isSafeLocaleSegment(locale)) {
               continue;
             }
-            const filePath = path3.resolve(resolvedBasePath, `${locale}.json`);
+            const filePath = path4.resolve(resolvedBasePath, `${locale}.json`);
             if (filePath.startsWith(resolvedBasePath)) {
               const content = await fs3.readFile(filePath, "utf-8");
               data = JSON.parse(content);
@@ -1377,7 +2043,7 @@ function listLocales(localesDir) {
   for (const item of fs4.readdirSync(localesDir, { withFileTypes: true })) {
     if (item.isDirectory() && LOCALE_RE.test(item.name)) locales.add(item.name);
     else if (item.isFile() && item.name.endsWith(".json")) {
-      const name = path4.basename(item.name, ".json");
+      const name = path5.basename(item.name, ".json");
       if (LOCALE_RE.test(name)) locales.add(name);
     }
   }
@@ -1397,7 +2063,7 @@ function flatten(obj, prefix, data) {
 }
 function readLocale(localesDir, locale, projectDir, issues) {
   const data = { leaves: /* @__PURE__ */ new Map(), branches: /* @__PURE__ */ new Set() };
-  const rel = (p) => path4.relative(projectDir, p).split(path4.sep).join("/");
+  const rel = (p) => path5.relative(projectDir, p).split(path5.sep).join("/");
   const parse = (file) => {
     try {
       return JSON.parse(fs4.readFileSync(file, "utf-8"));
@@ -1412,18 +2078,18 @@ function readLocale(localesDir, locale, projectDir, issues) {
       return void 0;
     }
   };
-  const dir = path4.join(localesDir, locale);
+  const dir = path5.join(localesDir, locale);
   if (fs4.existsSync(dir) && fs4.statSync(dir).isDirectory()) {
     for (const file of fs4.readdirSync(dir).sort()) {
       if (!file.endsWith(".json")) continue;
-      const ns = path4.basename(file, ".json");
-      const parsed = parse(path4.join(dir, file));
+      const ns = path5.basename(file, ".json");
+      const parsed = parse(path5.join(dir, file));
       if (parsed === void 0) continue;
       data.branches.add(ns);
       flatten(parsed, ns, data);
     }
   } else {
-    flatten(parse(path4.join(localesDir, `${locale}.json`)), "", data);
+    flatten(parse(path5.join(localesDir, `${locale}.json`)), "", data);
   }
   return data;
 }
@@ -1447,8 +2113,8 @@ function isReferenced(key, codeKeys) {
   return false;
 }
 async function runCheck(options) {
-  const projectDir = path4.resolve(options.projectDir);
-  const localesDir = path4.resolve(projectDir, options.localesPath ?? "locales");
+  const projectDir = path5.resolve(options.projectDir);
+  const localesDir = path5.resolve(projectDir, options.localesPath ?? "locales");
   const issues = [];
   const strict = options.strict ?? false;
   const warn = strict ? "fail" : "warn";
@@ -1565,64 +2231,2208 @@ function formatCheckReport(report, limit = 25) {
   return lines.join("\n");
 }
 
-// src/codemod/index.ts
-var getDirname = () => {
-  if (typeof __dirname !== "undefined") {
-    return __dirname;
-  }
-  return path5.dirname(fileURLToPath(import.meta.url));
-};
-var DEFAULT_STUDIO_PORT = 3010;
-var DEFAULT_APP_ORIGIN = "http://localhost:3000";
-function printHelp() {
-  console.log(`
-LiveLocale (livelocale) CLI
-
-Usage:
-  npx livelocale <command> [options]
-
-Commands:
-  migrate     Bulk migrate existing react-i18next translation usages to wrap them with wrapTranslationEngine automatically.
-  init        Initialize the API route handler inside a Next.js project automatically.
-  studio      Start the visual editing studio local web server.
-  doctor      Check the project for common integration problems (route, provider, middleware, CSP, locales).
-  check       Check translations for missing keys, placeholder drift, broken ICU syntax and unused keys (CI-friendly).
-
-Options for migrate:
-  --dir <path>       Directory to scan (default: current directory)
-  --exclude <list>   Comma-separated list of directories to exclude (default: node_modules,.next,dist,.git)
-  --dry-run          Preview changes without writing them to disk
-
-Options for init:
-  --dir <path>       Target project directory (default: current directory)
-
-Options for studio:
-  --port <number>    Port to run the studio server on (default: ${DEFAULT_STUDIO_PORT})
-  --app <origin>     Origin of the app being edited (default: ${DEFAULT_APP_ORIGIN})
-                     Can also be changed at run time with ?app=<origin> on the Studio URL.
-
-Options for doctor:
-  --dir <path>       Project directory to inspect (default: current directory)
-  --locales <path>   Locales directory relative to the project (default: locales)
-  --app <origin>     Also probe the running app, e.g. http://localhost:3000
-  --token <token>    Access token for a preview deployment (default: LIVELOCALE_TOKEN)
-
-Options for check:
-  --dir <path>       Project directory to scan (default: current directory)
-  --locales <path>   Locales directory relative to the project (default: locales)
-  --source <locale>  Locale the others are compared against (default: en, else the first locale)
-  --no-unused        Do not report keys that code never references
-  --strict           Treat warnings (unused keys, empty values) as failures
-  --json             Print the full report as JSON
+// src/server/pack.ts
+import { spawn } from "child_process";
+import { existsSync as existsSync5, readFileSync as readFileSync5, statSync as statSync4, promises as fs5 } from "fs";
+import * as path8 from "path";
 
-Global Options:
-  -h, --help         Show help information
-`);
-}
-function normalizeOriginArg(value, flag) {
+// src/server/build-info.ts
+import { execFile } from "child_process";
+import { readFileSync as readFileSync3 } from "fs";
+import * as path6 from "path";
+var runGit = (args, cwd) => new Promise((resolve14) => {
   try {
-    const url = new URL(value);
-    if (url.protocol !== "http:" && url.protocol !== "https:") throw new Error("bad protocol");
+    execFile(
+      "git",
+      args,
+      { cwd, windowsHide: true, env: { ...process.env, GIT_TERMINAL_PROMPT: "0" } },
+      (error, stdout) => resolve14(error ? null : String(stdout).trim())
+    );
+  } catch {
+    resolve14(null);
+  }
+});
+var SHA_RE = /^[0-9a-f]{40}([0-9a-f]{24})?$/i;
+async function firstValid(candidates, accept) {
+  for (const candidate of candidates) {
+    const value = typeof candidate === "function" ? await candidate() : candidate;
+    if (typeof value !== "string" || value === "") continue;
+    const accepted = accept(value);
+    if (accepted !== null) return accepted;
+  }
+  return null;
+}
+var asBranch = (value) => isValidBranchName(value) ? value : null;
+var asSha = (value) => SHA_RE.test(value) ? value.toLowerCase() : null;
+var asSlug = (value) => isValidRepoSlug(value) ? value : null;
+function readEvent(eventPath) {
+  if (!eventPath) return {};
+  try {
+    const parsed = JSON.parse(readFileSync3(eventPath, "utf-8"));
+    return isRecord(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function pick(obj, ...keys) {
+  let current = obj;
+  for (const key of keys) {
+    if (!isRecord(current)) return void 0;
+    current = current[key];
+  }
+  return typeof current === "string" ? current : void 0;
+}
+async function resolveBuildInfo(options) {
+  const { cwd, env = process.env, git = runGit, includeRepo = false } = options;
+  const event = readEvent(env.GITHUB_EVENT_PATH);
+  const isPullRequest = env.GITHUB_EVENT_NAME === "pull_request" || env.GITHUB_EVENT_NAME === "pull_request_target";
+  const netlify = env.NETLIFY === "true";
+  const gitlab = env.GITLAB_CI === "true";
+  const branch = await firstValid(
+    [
+      env.GITHUB_HEAD_REF,
+      env.GITHUB_REF_TYPE === "branch" ? env.GITHUB_REF_NAME : null,
+      env.VERCEL_GIT_COMMIT_REF,
+      env.CF_PAGES_BRANCH,
+      netlify ? env.BRANCH : null,
+      gitlab ? env.CI_COMMIT_REF_NAME : null,
+      async () => {
+        const head = await git(["rev-parse", "--abbrev-ref", "HEAD"], cwd);
+        return head === "HEAD" ? null : head;
+      }
+    ],
+    asBranch
+  );
+  const base = await firstValid(
+    [
+      isPullRequest ? pick(event, "pull_request", "head", "sha") : null,
+      env.GITHUB_SHA,
+      env.VERCEL_GIT_COMMIT_SHA,
+      env.CF_PAGES_COMMIT_SHA,
+      netlify ? env.COMMIT_REF : null,
+      gitlab ? env.CI_COMMIT_SHA : null,
+      () => git(["rev-parse", "HEAD"], cwd)
+    ],
+    asSha
+  );
+  const defaultBranch = await firstValid(
+    [
+      pick(event, "repository", "default_branch"),
+      async () => {
+        const ref = await git(["symbolic-ref", "--short", "refs/remotes/origin/HEAD"], cwd);
+        return ref?.startsWith("origin/") ? ref.slice("origin/".length) : null;
+      }
+    ],
+    asBranch
+  );
+  const githubCom = env.GITHUB_SERVER_URL === void 0 || env.GITHUB_SERVER_URL === "" || env.GITHUB_SERVER_URL === "https://github.com";
+  const repo = includeRepo ? await firstValid(
+    [
+      githubCom ? env.GITHUB_REPOSITORY : null,
+      env.VERCEL_GIT_PROVIDER === "github" && env.VERCEL_GIT_REPO_OWNER && env.VERCEL_GIT_REPO_SLUG ? `${env.VERCEL_GIT_REPO_OWNER}/${env.VERCEL_GIT_REPO_SLUG}` : null,
+      netlify && env.REPOSITORY_URL ? parseGitHubSlug(env.REPOSITORY_URL) : null,
+      async () => {
+        const remote = await git(["remote", "get-url", "origin"], cwd);
+        return remote ? parseGitHubSlug(remote) : null;
+      }
+    ],
+    asSlug
+  ) : null;
+  const top = await git(["rev-parse", "--show-toplevel"], cwd);
+  const gitRoot = top ? path6.resolve(top) : null;
+  return { repo, defaultBranch, branch, base, gitRoot };
+}
+function parseGitHubSlug(remote) {
+  const text = remote.trim();
+  let repoPath;
+  const scp = /^[A-Za-z0-9._-]+@github\.com:(.*)$/i.exec(text);
+  if (scp) {
+    repoPath = scp[1] ?? "";
+  } else {
+    let url;
+    try {
+      url = new URL(text);
+    } catch {
+      return null;
+    }
+    if (!["https:", "http:", "ssh:", "git:"].includes(url.protocol)) return null;
+    if (url.hostname.toLowerCase() !== "github.com") return null;
+    repoPath = url.pathname;
+  }
+  const trimmed = repoPath.replace(/^\/+/, "").replace(/\/+$/, "").replace(/\.git$/i, "");
+  return isValidRepoSlug(trimmed) ? trimmed : null;
+}
+
+// src/server/build-target.ts
+import { existsSync as existsSync4, readFileSync as readFileSync4 } from "fs";
+import * as path7 from "path";
+var NEXT_CONFIG_FILES = [
+  "next.config.js",
+  "next.config.mjs",
+  "next.config.cjs",
+  "next.config.ts",
+  "next.config.mts"
+];
+var VITE_CONFIG_FILES = [
+  "vite.config.js",
+  "vite.config.mjs",
+  "vite.config.cjs",
+  "vite.config.ts",
+  "vite.config.mts"
+];
+var OUTPUT_EXPORT = /\boutput\s*:\s*['"`]export['"`]/;
+var BASE_PATH = /\bbasePath\s*:\s*['"`](\/[^'"`]*)['"`]/;
+var VITE_BASE = /\bbase\s*:\s*['"`](\/[^'"`]*|\.\/?|)['"`]/;
+var EXPORTS_POST = /export\s+(?:const|let|var|async\s+function|function)\s+POST\b|export\s*\{[^}]*\bPOST\b[^}]*\}/;
+function readText2(file) {
+  try {
+    return readFileSync4(file, "utf-8");
+  } catch {
+    return null;
+  }
+}
+function readPackageJson(projectDir) {
+  const text = readText2(path7.join(projectDir, "package.json"));
+  if (text === null) return {};
+  try {
+    const parsed = JSON.parse(text);
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function hasDependency(pkg, name) {
+  return Boolean(pkg.dependencies?.[name] ?? pkg.devDependencies?.[name]);
+}
+function firstExisting2(projectDir, names) {
+  for (const name of names) {
+    const file = path7.join(projectDir, name);
+    if (existsSync4(file)) return file;
+  }
+  return null;
+}
+function stripComments(source) {
+  return source.replace(/\/\*[\s\S]*?\*\//g, "").split("\n").filter((line) => !line.trimStart().startsWith("//")).join("\n");
+}
+function craBase(homepage) {
+  if (typeof homepage !== "string") return null;
+  const value = homepage.trim();
+  if (value === "." || value === "./") return "./";
+  if (value.startsWith("/")) return value;
+  try {
+    return new URL(value).pathname;
+  } catch {
+    return null;
+  }
+}
+function detectBuildTarget(projectDir) {
+  const pkg = readPackageJson(projectDir);
+  const nextConfig = firstExisting2(projectDir, NEXT_CONFIG_FILES);
+  if (nextConfig || hasDependency(pkg, "next")) {
+    const source = stripComments((nextConfig && readText2(nextConfig)) ?? "");
+    return {
+      kind: "next",
+      staticExport: OUTPUT_EXPORT.test(source),
+      base: BASE_PATH.exec(source)?.[1] ?? null
+    };
+  }
+  if (hasDependency(pkg, "react-scripts")) return { kind: "cra", base: craBase(pkg.homepage) };
+  if (hasDependency(pkg, "vite") || firstExisting2(projectDir, VITE_CONFIG_FILES)) {
+    const viteConfig = firstExisting2(projectDir, VITE_CONFIG_FILES);
+    const source = stripComments((viteConfig && readText2(viteConfig)) ?? "");
+    return { kind: "vite", base: VITE_BASE.exec(source)?.[1] ?? null };
+  }
+  return { kind: "other", base: null };
+}
+var ROUTE_DIRS = ["app", "src/app"];
+var ROUTE_EXTENSIONS = ["ts", "js", "mjs", "tsx", "jsx"];
+function findExportBlockingRoute(projectDir) {
+  for (const dir of ROUTE_DIRS) {
+    for (const ext of ROUTE_EXTENSIONS) {
+      const rel = `${dir}/api/livelocale/route.${ext}`;
+      const source = readText2(path7.join(projectDir, rel));
+      if (source !== null && EXPORTS_POST.test(source)) return rel;
+    }
+  }
+  return null;
+}
+function outputCandidates(target) {
+  return target.kind === "cra" ? ["build", "dist", "out"] : ["dist", "build", "out"];
+}
+
+// src/server/pack-error.ts
+var PackError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "PackError";
+    this.code = code;
+  }
+};
+
+// src/server/share-html.ts
+var FULL_URL = /^(?:[a-z][a-z0-9+.-]*:|\/\/)/i;
+var WINDOWS_PATH = /^[A-Za-z]:[\\/]/;
+var SEGMENT = /^(?:[A-Za-z0-9._~@+-]|%[0-9A-Fa-f]{2})+$/;
+function normalizeBase(value) {
+  if (value === "" || value === "." || value === "./") return { kind: "relative" };
+  if (WINDOWS_PATH.test(value)) {
+    throw new PackError(
+      "BAD_BASE",
+      `The app base "${value}" is a Windows path. Your shell (Git Bash/MSYS) probably converted a site path such as /repo/ into it. Run the command with MSYS_NO_PATHCONV=1, or from an npm script, and pass the site path, for example --base /app/.`
+    );
+  }
+  if (FULL_URL.test(value)) {
+    throw new PackError(
+      "BAD_BASE",
+      `The app base "${value}" is a full URL. Pass the path your HTML is served from, for example --base /app/ (shareBase in the Vite plugin).`
+    );
+  }
+  const notASitePath = () => new PackError(
+    "BAD_BASE",
+    `The app base "${value}" is not a site path. Use "/", "/app/" or "./".`
+  );
+  if (!value.startsWith("/")) throw notASitePath();
+  const segments = value.slice(1).split("/");
+  if (segments[segments.length - 1] === "") segments.pop();
+  for (const segment of segments) {
+    if (segment === "." || segment === ".." || !SEGMENT.test(segment)) throw notASitePath();
+  }
+  return { kind: "absolute", path: segments.length === 0 ? "/" : `/${segments.join("/")}/` };
+}
+function basePathOf(base) {
+  return base.kind === "absolute" ? base.path : null;
+}
+function flagSrcFor(base, htmlRelPath) {
+  const file = `${SHARE_DIR}/${SHARE_FLAG_FILE}`;
+  if (base.kind === "absolute") return `${base.path}${file}`;
+  const depth = htmlRelPath.split("/").length - 1;
+  return depth === 0 ? `./${file}` : `${"../".repeat(depth)}${file}`;
+}
+function shareUrlPathFor(base) {
+  const page = `${SHARE_DIR}/index.html`;
+  return base.kind === "absolute" ? `${base.path}${page}` : page;
+}
+var EXISTING_FLAG_TAG = /<script\b[^>]*\bsrc="[^"]*livelocale\/flag\.js"[^>]*>\s*<\/script>/gi;
+var HEAD_OPEN2 = /<head(?=[\s>])[^>]*>/i;
+var HTML_OPEN2 = /<html(?=[\s>])[^>]*>/i;
+var DOCTYPE2 = /<!doctype\b[^>]*>/i;
+function escapeAttribute(value) {
+  return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function injectFlagScript(html, src) {
+  const tag = `<script src="${escapeAttribute(src)}"></script>`;
+  const cleaned = html.replace(EXISTING_FLAG_TAG, "");
+  for (const pattern of [HEAD_OPEN2, HTML_OPEN2, DOCTYPE2]) {
+    const match = pattern.exec(cleaned);
+    if (match) {
+      const end = match.index + match[0].length;
+      return cleaned.slice(0, end) + tag + cleaned.slice(end);
+    }
+  }
+  return tag + cleaned;
+}
+
+// src/server/pack.ts
+var NO_REPO_WARNING = "exposeRepo is on but no GitHub repository was found; the manifest has no repo.";
+function isPlainObject2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function toPosix(relative8) {
+  return relative8.split(path8.sep).join("/") || ".";
+}
+function isInside(parent, child) {
+  const rel = path8.relative(parent, child);
+  return rel === "" || !rel.startsWith("..") && !path8.isAbsolute(rel);
+}
+function defineOwn(target, key, value) {
+  Object.defineProperty(target, key, {
+    value,
+    enumerable: true,
+    writable: true,
+    configurable: true
+  });
+}
+async function readJsonObject(file, projectDir) {
+  const shown = toPosix(path8.relative(projectDir, file));
+  let parsed;
+  try {
+    parsed = JSON.parse(await fs5.readFile(file, "utf-8"));
+  } catch (error) {
+    throw new PackError(
+      "INVALID_LOCALE_FILE",
+      `${shown} is not a JSON object: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  if (!isPlainObject2(parsed)) {
+    const kind = Array.isArray(parsed) ? "an array" : parsed === null ? "null" : typeof parsed;
+    throw new PackError(
+      "INVALID_LOCALE_FILE",
+      `${shown} is not a JSON object: the root is ${kind}`
+    );
+  }
+  return parsed;
+}
+async function collectShareData(options) {
+  const projectDir = path8.resolve(options.projectDir);
+  const localesDir = path8.resolve(projectDir, options.localesPath ?? "locales");
+  const warnings = [];
+  let entries;
+  try {
+    if (!(await fs5.stat(localesDir)).isDirectory()) throw new Error("not a directory");
+    entries = await fs5.readdir(localesDir, { withFileTypes: true });
+  } catch {
+    throw new PackError(
+      "LOCALES_NOT_FOUND",
+      `Locales directory not found: ${localesDir}. Pass --locales <path>.`
+    );
+  }
+  const dirLocales = /* @__PURE__ */ new Set();
+  const fileLocales = /* @__PURE__ */ new Set();
+  for (const entry of entries) {
+    if (entry.isDirectory() && LOCALE_RE.test(entry.name)) {
+      dirLocales.add(entry.name);
+    } else if (entry.isFile() && entry.name.endsWith(".json")) {
+      const code = entry.name.slice(0, -".json".length);
+      if (LOCALE_RE.test(code)) fileLocales.add(code);
+    }
+  }
+  const locales = [.../* @__PURE__ */ new Set([...dirLocales, ...fileLocales])].sort();
+  if (locales.length === 0) {
+    throw new PackError(
+      "NO_LOCALES",
+      `No locale files in ${localesDir} (expected en.json or en/*.json).`
+    );
+  }
+  const layout = dirLocales.size > 0 ? "namespaced" : "flat";
+  const sourceLocale = options.sourceLocale ?? (locales.includes("en") ? "en" : locales[0]);
+  if (!locales.includes(sourceLocale)) {
+    throw new PackError(
+      "SOURCE_LOCALE_NOT_FOUND",
+      `Source locale "${sourceLocale}" not found in ${localesDir} (found: ${locales.join(", ")}).`
+    );
+  }
+  const dictionaries = {};
+  for (const locale of locales) {
+    let dictionary;
+    if (dirLocales.has(locale)) {
+      dictionary = {};
+      const folder = path8.join(localesDir, locale);
+      const files = (await fs5.readdir(folder, { withFileTypes: true })).filter((file) => file.isFile() && file.name.endsWith(".json")).map((file) => file.name).sort();
+      for (const file of files) {
+        const namespace = file.slice(0, -".json".length);
+        defineOwn(dictionary, namespace, await readJsonObject(path8.join(folder, file), projectDir));
+      }
+    } else {
+      dictionary = await readJsonObject(path8.join(localesDir, `${locale}.json`), projectDir);
+    }
+    defineOwn(dictionaries, locale, dictionary);
+  }
+  const info = await resolveBuildInfo({
+    cwd: projectDir,
+    env: options.env,
+    git: options.git,
+    includeRepo: options.exposeRepo === true
+  });
+  const root = info.gitRoot !== null && isInside(info.gitRoot, localesDir) ? info.gitRoot : projectDir;
+  const codeKeys = await new KeyScanner({ requireEnabled: false }).scanSourceKeys(projectDir);
+  if (options.exposeRepo === true && info.repo === null) warnings.push(NO_REPO_WARNING);
+  const manifest = {
+    format: SHARE_MANIFEST_FORMAT,
+    ...options.exposeRepo === true && info.repo !== null ? { repo: info.repo } : {},
+    defaultBranch: info.defaultBranch,
+    branch: info.branch,
+    base: info.base,
+    localesPath: toPosix(path8.relative(root, localesDir)),
+    layout,
+    sourceLocale,
+    locales,
+    basePath: options.basePath,
+    codeKeys: [...codeKeys].sort()
+  };
+  return { manifest, dictionaries, warnings };
+}
+var RELATIVE_BASE_WARNING = "The app base is relative (./), so flag.js is linked per HTML file. Pages served by a client-side route fallback cannot load it; build with an absolute base (--base /path/) if the app has such routes.";
+function defaultStudioCandidates() {
+  const here = moduleDir();
+  return [path8.resolve(here, "../studio"), path8.resolve(here, "../../dist/studio")];
+}
+function isDirectory(target) {
+  try {
+    return statSync4(target).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function resolveStudioDir(candidates = defaultStudioCandidates()) {
+  for (const dir of candidates) {
+    if (existsSync5(path8.join(dir, "index.html")) && isDirectory(path8.join(dir, "assets"))) {
+      return dir;
+    }
+  }
+  return null;
+}
+async function ownsShareDir(shareDir) {
+  try {
+    await fs5.lstat(shareDir);
+  } catch {
+    return true;
+  }
+  try {
+    const manifest = JSON.parse(
+      await fs5.readFile(path8.join(shareDir, SHARE_MANIFEST_FILE), "utf-8")
+    );
+    return isPlainObject2(manifest) && typeof manifest["format"] === "number";
+  } catch {
+    return false;
+  }
+}
+async function findHtmlFiles(outDir, shareDir) {
+  const found = [];
+  const walk = async (dir) => {
+    for (const entry of await fs5.readdir(dir, { withFileTypes: true })) {
+      if (entry.isSymbolicLink()) continue;
+      const full = path8.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (full !== shareDir) await walk(full);
+      } else if (entry.isFile() && entry.name.toLowerCase().endsWith(".html")) {
+        found.push(toPosix(path8.relative(outDir, full)));
+      }
+    }
+  };
+  await walk(outDir);
+  return found.sort();
+}
+async function packOutput(options) {
+  const {
+    outDir: outOption,
+    base: baseOption,
+    injectHtml = "auto",
+    studioDir: studioOption,
+    ...shareOptions
+  } = options;
+  const projectDir = path8.resolve(options.projectDir);
+  const outDir = path8.resolve(projectDir, outOption);
+  if (!isDirectory(outDir)) {
+    throw new PackError(
+      "OUT_DIR_NOT_FOUND",
+      `Build output not found: ${outDir}. Run your build first.`
+    );
+  }
+  const target = detectBuildTarget(projectDir);
+  const base = normalizeBase(baseOption ?? target.base ?? "/");
+  const candidates = studioOption !== void 0 ? [path8.resolve(projectDir, studioOption)] : defaultStudioCandidates();
+  const studioDir = resolveStudioDir(candidates);
+  if (studioDir === null) {
+    throw new PackError(
+      "STUDIO_NOT_FOUND",
+      `LiveLocale Studio files are missing from the installed package (looked in ${candidates.join(", ")}). Reinstall livelocale.`
+    );
+  }
+  const data = await collectShareData({ ...shareOptions, projectDir, basePath: basePathOf(base) });
+  const shareDir = path8.join(outDir, SHARE_DIR);
+  if (!await ownsShareDir(shareDir)) {
+    throw new PackError(
+      "SHARE_DIR_TAKEN",
+      `${toPosix(path8.relative(projectDir, outDir))}/${SHARE_DIR}/ already exists and was not written by LiveLocale. Move it away and run again.`
+    );
+  }
+  await fs5.rm(shareDir, { recursive: true, force: true });
+  await fs5.cp(studioDir, shareDir, { recursive: true });
+  await fs5.writeFile(
+    path8.join(shareDir, SHARE_MANIFEST_FILE),
+    JSON.stringify(data.manifest, null, 2) + "\n",
+    "utf-8"
+  );
+  const localesDir = path8.join(shareDir, SHARE_LOCALES_DIR);
+  await fs5.mkdir(localesDir, { recursive: true });
+  for (const locale of data.manifest.locales) {
+    await fs5.writeFile(
+      path8.join(localesDir, `${locale}.json`),
+      JSON.stringify(data.dictionaries[locale]),
+      "utf-8"
+    );
+  }
+  await fs5.writeFile(path8.join(shareDir, SHARE_FLAG_FILE), FLAG_SCRIPT, "utf-8");
+  const inject = injectHtml === "auto" ? target.kind !== "next" && !existsSync5(path8.join(outDir, "_next")) : injectHtml;
+  const htmlInjected = inject ? await findHtmlFiles(outDir, shareDir) : [];
+  for (const rel of htmlInjected) {
+    const file = path8.join(outDir, ...rel.split("/"));
+    const html = await fs5.readFile(file, "utf-8");
+    const injected = injectFlagScript(html, flagSrcFor(base, rel));
+    if (injected !== html) await fs5.writeFile(file, injected, "utf-8");
+  }
+  const warnings = [...data.warnings];
+  if (base.kind === "relative") warnings.push(RELATIVE_BASE_WARNING);
+  return {
+    shareDir,
+    manifest: data.manifest,
+    htmlInjected,
+    shareUrlPath: shareUrlPathFor(base),
+    warnings
+  };
+}
+var VALUE_OPTIONS = {
+  "--dir": "dir",
+  "--locales": "locales",
+  "--source": "source",
+  "--base": "base",
+  "--out": "out"
+};
+function parseShareArgs(argv) {
+  const args = {
+    positional: [],
+    dir: ".",
+    locales: void 0,
+    source: void 0,
+    base: void 0,
+    out: void 0,
+    exposeRepo: false,
+    inject: true,
+    preview: false,
+    command: []
+  };
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--") {
+      args.command = argv.slice(i + 1);
+      break;
+    }
+    if (Object.prototype.hasOwnProperty.call(VALUE_OPTIONS, arg)) {
+      const value = argv[i + 1];
+      if (value === void 0 || value.startsWith("--")) {
+        throw new PackError("USAGE", `${arg} needs a value.`);
+      }
+      args[VALUE_OPTIONS[arg]] = value;
+      i++;
+    } else if (arg === "--expose-repo") {
+      args.exposeRepo = true;
+    } else if (arg === "--no-inject") {
+      args.inject = false;
+    } else if (arg === "--preview") {
+      args.preview = true;
+    } else if (arg.startsWith("-") && arg !== "-") {
+      throw new PackError("USAGE", `Unknown option "${arg}".`);
+    } else {
+      args.positional.push(arg);
+    }
+  }
+  return args;
+}
+var WINDOWS_NEEDS_QUOTES = /[\s"&|<>^()]/;
+function quoteWindowsArg(arg) {
+  if (arg !== "" && !WINDOWS_NEEDS_QUOTES.test(arg)) return arg;
+  let out = '"';
+  let backslashes = 0;
+  for (const ch of arg) {
+    if (ch === "\\") {
+      backslashes++;
+      continue;
+    }
+    if (ch === '"') {
+      out += "\\".repeat(backslashes * 2 + 1) + '"';
+    } else {
+      out += "\\".repeat(backslashes) + ch;
+    }
+    backslashes = 0;
+  }
+  return out + "\\".repeat(backslashes * 2) + '"';
+}
+var spawnInherit = (command, args, { cwd, env }) => new Promise((resolve14, reject2) => {
+  const child = process.platform === "win32" ? spawn([command, ...args].map(quoteWindowsArg).join(" "), {
+    cwd,
+    env,
+    stdio: "inherit",
+    shell: true
+  }) : spawn(command, args, { cwd, env, stdio: "inherit" });
+  child.on("error", (error) => {
+    if (error.code === "ENOENT") resolve14(127);
+    else reject2(error);
+  });
+  child.on("close", (code) => resolve14(code ?? 1));
+});
+var BUILD_USAGE = "Usage: livelocale build [--preview] -- <your build command>";
+var NEXT_PREVIEW_WARNING = "Next.js pages have no watermarks without --preview; the Studio will open but nothing is editable.";
+var NEXT_GITIGNORE_WARNING = "Add public/livelocale/ to .gitignore; it is generated on every build.";
+var FRESH_SLACK_MS = 2e3;
+function gitignoresShareDir(projectDir) {
+  let content;
+  try {
+    content = readFileSync5(path8.join(projectDir, ".gitignore"), "utf-8");
+  } catch {
+    return false;
+  }
+  return parseGitignore(content).ignores(`public/${SHARE_DIR}`, true);
+}
+function freshOutput(projectDir, candidates, startMs) {
+  for (const candidate of candidates) {
+    try {
+      const stat = statSync4(path8.join(projectDir, candidate, "index.html"));
+      if (stat.isFile() && stat.mtimeMs >= startMs - FRESH_SLACK_MS) return candidate;
+    } catch {
+    }
+  }
+  return null;
+}
+async function runBuildCommand(options) {
+  const {
+    command,
+    preview = false,
+    outDir,
+    run: run3 = spawnInherit,
+    now = Date.now,
+    ...packOptions
+  } = options;
+  if (command.length === 0) throw new PackError("USAGE", BUILD_USAGE);
+  const projectDir = path8.resolve(options.projectDir);
+  const target = detectBuildTarget(projectDir);
+  const env = options.env ?? process.env;
+  const childEnv = preview ? { ...env, LIVELOCALE: "preview", NEXT_PUBLIC_LIVELOCALE: "preview" } : env;
+  const runBuild = () => run3(command[0], command.slice(1), { cwd: projectDir, env: childEnv });
+  if (target.kind === "next") {
+    const blocking = target.staticExport ? findExportBlockingRoute(projectDir) : null;
+    if (blocking !== null) {
+      throw new PackError(
+        "NEXT_EXPORT_POST_ROUTE",
+        `Next.js static export (output: 'export') cannot build ${blocking}: it exports POST, and export mode only allows GET route handlers. The share link does not need this route. Delete ${blocking} (or move it out of this build) and run again.`
+      );
+    }
+    await fs5.mkdir(path8.join(projectDir, "public"), { recursive: true });
+    const pack2 = await packOutput({
+      ...packOptions,
+      projectDir,
+      outDir: "public",
+      injectHtml: false
+    });
+    const warnings = [];
+    if (!preview) warnings.push(NEXT_PREVIEW_WARNING);
+    if (!gitignoresShareDir(projectDir)) warnings.push(NEXT_GITIGNORE_WARNING);
+    const exitCode2 = await runBuild();
+    return { exitCode: exitCode2, pack: pack2, warnings: [...warnings, ...pack2.warnings] };
+  }
+  const startMs = now();
+  const exitCode = await runBuild();
+  if (exitCode !== 0) return { exitCode, pack: null, warnings: [] };
+  const candidates = outputCandidates(target);
+  const output = outDir ?? freshOutput(projectDir, candidates, startMs);
+  if (output === null) {
+    throw new PackError(
+      "OUTPUT_NOT_FOUND",
+      `Could not find the build output (looked for a fresh index.html in ${candidates.map((c) => `${c}/`).join(", ")}). Pass --out <dir>.`
+    );
+  }
+  const pack = await packOutput({ ...packOptions, projectDir, outDir: output, injectHtml: "auto" });
+  return { exitCode, pack, warnings: [...pack.warnings] };
+}
+
+// src/codemod/apply/cli.ts
+import * as path14 from "path";
+
+// src/codemod/apply/link-input.ts
+import { execFile as execFile2 } from "child_process";
+import * as fs6 from "fs";
+import * as path9 from "path";
+var MAX_APPLY_INPUT_BYTES = 1048576;
+var TOO_LARGE_MESSAGE2 = "The input is larger than 1 MB.";
+var NO_INPUT_MESSAGE = 'Pass the change link, a file that holds it, "-" to read stdin, or --clipboard. (cmd.exe cuts arguments at 8,191 characters; use --clipboard or a file for long links.)';
+var NO_CLIPBOARD_MESSAGE = "Could not read the clipboard. Save the change link to a file and pass the file instead.";
+var ApplyInputError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ApplyInputError";
+  }
+};
+function checkSize(text) {
+  if (Buffer.byteLength(text, "utf8") > MAX_APPLY_INPUT_BYTES) {
+    throw new ApplyInputError(TOO_LARGE_MESSAGE2);
+  }
+  return text;
+}
+async function readStream(stream) {
+  const chunks = [];
+  let size = 0;
+  for await (const chunk of stream) {
+    const bytes = typeof chunk === "string" ? Buffer.from(chunk, "utf8") : Buffer.from(chunk);
+    size += bytes.length;
+    if (size > MAX_APPLY_INPUT_BYTES) throw new ApplyInputError(TOO_LARGE_MESSAGE2);
+    chunks.push(bytes);
+  }
+  return Buffer.concat(chunks).toString("utf8");
+}
+function existingFile(arg, cwd) {
+  try {
+    const resolved = path9.resolve(cwd, arg);
+    return fs6.statSync(resolved, { throwIfNoEntry: false })?.isFile() ? resolved : null;
+  } catch {
+    return null;
+  }
+}
+async function readApplyInput(arg, options) {
+  if (options.clipboard) return checkSize(await (options.readClipboard ?? readClipboard)());
+  if (arg === void 0 || arg === "") throw new ApplyInputError(NO_INPUT_MESSAGE);
+  if (arg === "-") return readStream(options.stdin ?? process.stdin);
+  const file = existingFile(arg, options.cwd);
+  if (file === null) return checkSize(arg);
+  if (fs6.statSync(file).size > MAX_APPLY_INPUT_BYTES) throw new ApplyInputError(TOO_LARGE_MESSAGE2);
+  return checkSize(fs6.readFileSync(file, "utf8"));
+}
+function clipboardCommands(platform) {
+  if (platform === "win32") {
+    return [
+      ["powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", "Get-Clipboard -Raw"]]
+    ];
+  }
+  if (platform === "darwin") return [["pbpaste", []]];
+  return [
+    ["wl-paste", ["--no-newline"]],
+    ["xclip", ["-selection", "clipboard", "-o"]],
+    ["xsel", ["--clipboard", "--output"]]
+  ];
+}
+var TOO_LARGE = /* @__PURE__ */ Symbol("too large");
+function run(execFileImpl, [command, args]) {
+  return new Promise((resolve14) => {
+    try {
+      execFileImpl(
+        command,
+        args,
+        { encoding: "utf8", windowsHide: true, maxBuffer: MAX_APPLY_INPUT_BYTES + 1 },
+        (error, stdout) => {
+          const code = error?.code;
+          if (code === "ERR_CHILD_PROCESS_STDIO_MAXBUFFER") resolve14(TOO_LARGE);
+          else resolve14(error ? null : String(stdout));
+        }
+      );
+    } catch {
+      resolve14(null);
+    }
+  });
+}
+async function readClipboard(execFileImpl = execFile2, platform = process.platform) {
+  for (const command of clipboardCommands(platform)) {
+    const text = await run(execFileImpl, command);
+    if (text === TOO_LARGE) throw new ApplyInputError(TOO_LARGE_MESSAGE2);
+    if (text !== null) return checkSize(text);
+  }
+  throw new ApplyInputError(NO_CLIPBOARD_MESSAGE);
+}
+
+// src/codemod/apply/local.ts
+import { execFile as execFile4, spawn as spawn2 } from "child_process";
+import * as fs9 from "fs";
+import * as os from "os";
+import * as path13 from "path";
+
+// src/core/change-link-node.ts
+import { inflateSync } from "zlib";
+var CORRUPT_MESSAGE2 = "This change link is damaged or incomplete. Ask the sender to send the file instead.";
+var TOO_LARGE_MESSAGE3 = `A change link holds at most ${MAX_INFLATED_BYTES / 1024} KB of text. Send the changes in smaller links.`;
+var nodeInflate = async (bytes, maxOutputLength) => {
+  let result;
+  try {
+    result = inflateSync(bytes, { maxOutputLength, info: true });
+  } catch (err) {
+    if (err instanceof Error && "code" in err && err.code === "ERR_BUFFER_TOO_LARGE") {
+      throw new ChangeLinkError("TOO_LARGE", TOO_LARGE_MESSAGE3);
+    }
+    throw new ChangeLinkError("CORRUPT", CORRUPT_MESSAGE2);
+  }
+  if (result.engine.bytesWritten !== bytes.length) {
+    throw new ChangeLinkError("CORRUPT", CORRUPT_MESSAGE2);
+  }
+  return result.buffer;
+};
+
+// src/client/watermark.ts
+var WATERMARK_RE = /\u200C(?:[\u200B\u200D]{8})+\u200C/g;
+function containsWatermark(text) {
+  WATERMARK_RE.lastIndex = 0;
+  const found = WATERMARK_RE.test(text);
+  WATERMARK_RE.lastIndex = 0;
+  return found;
+}
+
+// src/core/json-path.ts
+var MAX_KEY_DEPTH = 30;
+function setNestedProperty(obj, keyPath, value) {
+  const keys = keyPath.split(".");
+  if (keys.length > MAX_KEY_DEPTH) {
+    throw new Error(
+      `[livelocale] Key depth limit exceeded. Maximum depth is ${MAX_KEY_DEPTH} levels.`
+    );
+  }
+  if (keys.some((k) => DANGEROUS_KEY_SEGMENTS.has(k))) {
+    throw new Error(
+      `[livelocale] Forbidden key segment in path: "${keyPath}". Segment names like __proto__, constructor, and prototype are not allowed.`
+    );
+  }
+  let current = obj;
+  for (let i = 0; i < keys.length; i++) {
+    const key = keys[i];
+    if (i === keys.length - 1) {
+      current[key] = value;
+      return;
+    }
+    if (!(key in current) || current[key] === null || typeof current[key] !== "object" || Array.isArray(current[key])) {
+      current[key] = {};
+    }
+    current = current[key];
+  }
+}
+function isPlainObject3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function hasOwn(obj, key) {
+  return Object.prototype.hasOwnProperty.call(obj, key);
+}
+function lookupKey(dict, keyPath) {
+  if (!isPlainObject3(dict)) return { state: "missing" };
+  const segments = keyPath.split(".");
+  const leaf = segments.length - 1;
+  let current = dict;
+  for (let i = 0; i < leaf; i++) {
+    if (hasOwn(current, segments.slice(i).join("."))) return { state: "occupied" };
+    const segment = segments[i];
+    if (!hasOwn(current, segment)) return { state: "missing" };
+    const next = current[segment];
+    if (!isPlainObject3(next)) return { state: "occupied" };
+    current = next;
+  }
+  const key = segments[leaf];
+  if (!hasOwn(current, key)) return { state: "missing" };
+  const value = current[key];
+  return typeof value === "string" ? { state: "string", value } : { state: "occupied" };
+}
+function detectJsonIndent(content) {
+  const match = /^([ \t]+)"/m.exec(content);
+  if (!match) return "  ";
+  const ws = match[1];
+  return ws.includes("	") ? "	" : ws;
+}
+
+// src/core/save-rules.ts
+var reject = (status, code, error) => ({
+  ok: false,
+  status,
+  code,
+  error
+});
+function validateWrite(input, options = {}) {
+  const { locale, key, value } = input;
+  if (!isValidLocaleFormat(locale)) {
+    return reject(400, "INVALID_LOCALE_FORMAT", "Invalid locale string parameter.");
+  }
+  if (!isValidKeyFormat(key)) {
+    return reject(
+      400,
+      "INVALID_KEY_FORMAT",
+      "Invalid key path. Must be 1-200 characters containing alphanumeric, dots, underscores, or hyphens."
+    );
+  }
+  if (!isSafeKeyPath(key)) {
+    return reject(
+      400,
+      "INVALID_KEY_FORMAT",
+      "Forbidden key path: segments like __proto__, constructor, or prototype are not allowed."
+    );
+  }
+  if (!isValidValueFormat(value)) {
+    return reject(
+      400,
+      "INVALID_VALUE_FORMAT",
+      "Invalid value. Must be a string less than 10000 characters."
+    );
+  }
+  const accepted = {
+    ok: true,
+    locale,
+    key,
+    value
+  };
+  if (options.force === true) return accepted;
+  const syntaxError = validateMessageSyntax(accepted.value);
+  if (syntaxError) {
+    return reject(422, "MESSAGE_SYNTAX", `Message syntax: ${syntaxError}.`);
+  }
+  const comparison = comparePlaceholders(options.reference, accepted.value);
+  if (!comparison.ok) {
+    const parts = [];
+    if (comparison.missing.length) parts.push(`missing ${comparison.missing.join(", ")}`);
+    if (comparison.extra.length) parts.push(`unexpected ${comparison.extra.join(", ")}`);
+    return {
+      ...reject(
+        422,
+        "PLACEHOLDER_MISMATCH",
+        `Placeholders differ from the reference: ${parts.join("; ")}.`
+      ),
+      details: { missing: comparison.missing, extra: comparison.extra }
+    };
+  }
+  return accepted;
+}
+function sourceReference(key, ctx) {
+  const found = lookupKey(ctx.source, key);
+  return found.state === "string" ? found.value : null;
+}
+function validateEdit(edit, ctx, options) {
+  const { locale, key, value } = edit;
+  const input = { locale, key, value };
+  const format = validateWrite(input, { force: true });
+  if (!format.ok) return format;
+  const dict = locale === ctx.sourceLocale ? ctx.source : ctx.target ?? {};
+  if (lookupKey(dict, key).state === "occupied") {
+    return reject(
+      409,
+      "KEY_NOT_A_STRING",
+      `Cannot save "${key}" in ${locale}: it would replace translations that are not a single text.`
+    );
+  }
+  return validateWrite(input, {
+    reference: sourceReference(key, ctx),
+    force: options?.force === true
+  });
+}
+var RISK_FLAG_MESSAGES = {
+  markup: "Adds markup that the source text does not have.",
+  "javascript-url": "Adds a javascript:, vbscript: or data: link.",
+  "new-url": "Adds a web address that the source text does not have.",
+  "bidi-control": "Contains invisible text-direction control characters."
+};
+var TAG_PATTERN = /<\/?([A-Za-z][\w-]*)\b[^<>]*>/g;
+var SCRIPT_LINK_PATTERNS = [/\b(?:javascript|vbscript)\s*:/i, /\bdata:[a-z]+\/[\w.+-]+/i];
+var URL_PATTERN = /\b(?:https?:\/\/|www\.)[^\s<>"')]+/gi;
+var BIDI_CONTROL_PATTERN = /[\u202A-\u202E\u2066-\u2069]/g;
+var tagNames = (text) => Array.from(text.matchAll(TAG_PATTERN), (m) => m[1].toLowerCase());
+var allMatches = (pattern, text) => text.match(pattern) ?? [];
+var hasNew = (known, found) => {
+  const set = new Set(known);
+  return found.some((item) => !set.has(item));
+};
+function detectRiskFlags(reference, value) {
+  const ref = reference ?? "";
+  const flags = [];
+  if (hasNew(tagNames(ref), tagNames(value))) flags.push("markup");
+  if (SCRIPT_LINK_PATTERNS.some((pattern) => pattern.test(value) && !pattern.test(ref))) {
+    flags.push("javascript-url");
+  }
+  if (hasNew(allMatches(URL_PATTERN, ref), allMatches(URL_PATTERN, value))) flags.push("new-url");
+  if (hasNew(allMatches(BIDI_CONTROL_PATTERN, ref), allMatches(BIDI_CONTROL_PATTERN, value))) {
+    flags.push("bidi-control");
+  }
+  return flags;
+}
+
+// src/core/apply-plan.ts
+var FLAG_MESSAGES = {
+  ...RISK_FLAG_MESSAGES,
+  forced: "Saved with \u201CSave anyway\u201D.",
+  "new-key": "Adds a key the source locale does not have."
+};
+function inExistingNamespace(dict, key) {
+  const dot = key.indexOf(".");
+  if (dot === -1) return false;
+  const namespace = key.slice(0, dot);
+  if (!Object.prototype.hasOwnProperty.call(dict, namespace)) return false;
+  const value = dict[namespace];
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function planEdit(edit, input, source) {
+  const { locale, key, from, to, force } = edit;
+  const base = { locale, key, from, to, force };
+  const invalid2 = (code, message) => ({
+    ...base,
+    status: "invalid",
+    code,
+    message,
+    flags: []
+  });
+  const target = input.targets.get(locale);
+  if (!target) return invalid2("UNKNOWN_LOCALE", `No "${locale}" locale file on the target.`);
+  if (target.layout === "namespaced" && !inExistingNamespace(target.dict, key)) {
+    return invalid2(
+      "UNKNOWN_NAMESPACE",
+      `"${key}" is not in an existing namespace file of ${locale}.`
+    );
+  }
+  if (containsWatermark(to)) {
+    return invalid2("CONTAINS_WATERMARK", "The new text contains LiveLocale watermark characters.");
+  }
+  const ctx = { sourceLocale: input.sourceLocale, source, target: target.dict };
+  const reference = sourceReference(key, ctx);
+  const flags = [];
+  const planned = (outcome) => ({
+    ...base,
+    ...outcome,
+    flags: [...flags, ...detectRiskFlags(reference ?? from ?? void 0, to)]
+  });
+  const found = lookupKey(target.dict, key);
+  if (found.state === "string" && found.value === to) {
+    return planned({ status: "already", current: found.value });
+  }
+  const verdict = validateEdit({ locale, key, value: to }, ctx, { force: false });
+  if (!verdict.ok) {
+    if (verdict.status !== 422 || !force) return invalid2(verdict.code, verdict.error);
+    if (!input.allowForce) {
+      return planned({ status: "needs-force", code: verdict.code, message: verdict.error });
+    }
+    flags.push("forced");
+  }
+  const current = found.state === "string" ? found.value : void 0;
+  if (current === void 0) {
+    if (from !== null) {
+      return planned({
+        status: "conflict",
+        code: "REMOVED_ON_TARGET",
+        message: "Removed on the target since the link was made."
+      });
+    }
+    if (reference === null) flags.push("new-key");
+    return planned({ status: "apply" });
+  }
+  if (current === from) return planned({ status: "apply" });
+  return planned({
+    status: "conflict",
+    code: "CHANGED_ON_TARGET",
+    message: "Changed on the target since the link was made.",
+    current
+  });
+}
+function planApply(input) {
+  const source = input.targets.get(input.sourceLocale);
+  if (!source) {
+    throw new Error(`Source locale "${input.sourceLocale}" has no locale file on the target.`);
+  }
+  const edits = input.edits.map((edit) => planEdit(edit, input, source.dict));
+  const counts = {
+    apply: 0,
+    already: 0,
+    conflict: 0,
+    invalid: 0,
+    "needs-force": 0
+  };
+  for (const edit of edits) counts[edit.status] += 1;
+  return { edits, counts };
+}
+
+// src/server/file-mutator.ts
+import { promises as fs7 } from "fs";
+import * as path11 from "path";
+
+// src/core/safe-path.ts
+import * as path10 from "path";
+function resolveSafeLocalePath(basePath, locale) {
+  if (!isSafeLocaleSegment(locale)) {
+    throw new Error("Path traversal attempt");
+  }
+  const resolvedBasePath = path10.resolve(basePath);
+  const filePath = path10.resolve(resolvedBasePath, `${locale}.json`);
+  if (!filePath.startsWith(resolvedBasePath)) {
+    throw new Error("Path traversal attempt");
+  }
+  return filePath;
+}
+
+// src/server/file-mutator.ts
+var FileMutex = class {
+  queue = Promise.resolve();
+  async acquire(fn) {
+    const next = this.queue.then(fn);
+    this.queue = next.then(
+      () => {
+      },
+      () => {
+      }
+    );
+    return next;
+  }
+};
+var FileMutator = class {
+  fileLocks = /* @__PURE__ */ new Map();
+  requireEnabled;
+  quiet;
+  scanner;
+  constructor(options = {}) {
+    this.requireEnabled = options.requireEnabled ?? true;
+    this.quiet = options.quiet ?? false;
+    this.scanner = new KeyScanner({ requireEnabled: this.requireEnabled });
+  }
+  assertEnabled() {
+    if (!this.requireEnabled) return;
+    const reason = getDisabledReason();
+    if (reason !== null) {
+      throw new Error(
+        `[livelocale] FileMutator can only be executed in development mode (${reason}).`
+      );
+    }
+  }
+  /**
+   * Helper to serialize execution per file path
+   */
+  async withLock(filePath, fn) {
+    let lock = this.fileLocks.get(filePath);
+    if (!lock) {
+      lock = new FileMutex();
+      this.fileLocks.set(filePath, lock);
+    }
+    return lock.acquire(fn);
+  }
+  /**
+   * Updates a locale JSON file on disk atomically and safely.
+   * Enforces development mode checks, path traversal mitigation, key depth restrictions,
+   * structural JSON validation, and concurrency serialization.
+   */
+  async updateLocaleKey(basePath, locale, keyPath, newValue) {
+    this.assertEnabled();
+    if (!isSafeLocaleSegment(locale)) {
+      throw new Error(
+        `[livelocale] Path traversal attempt detected in locale identifier: "${locale}"`
+      );
+    }
+    const resolvedBasePath = path11.resolve(basePath);
+    const localeDir = path11.resolve(resolvedBasePath, locale);
+    let filePath = "";
+    let mutationKeyPath = keyPath;
+    let isNamespaceDir = false;
+    try {
+      const stats = await fs7.stat(localeDir);
+      if (stats.isDirectory()) {
+        isNamespaceDir = true;
+      }
+    } catch {
+    }
+    if (isNamespaceDir) {
+      const firstDot = keyPath.indexOf(".");
+      if (firstDot !== -1) {
+        const namespace = keyPath.substring(0, firstDot);
+        if (DANGEROUS_KEY_SEGMENTS.has(namespace)) {
+          throw new Error(
+            `[livelocale] Forbidden namespace segment in path: "${namespace}". Segment names like __proto__, constructor, and prototype are not allowed.`
+          );
+        }
+        mutationKeyPath = keyPath.substring(firstDot + 1);
+        filePath = path11.resolve(localeDir, `${namespace}.json`);
+      } else {
+        filePath = path11.resolve(localeDir, `${keyPath}.json`);
+        mutationKeyPath = "";
+      }
+    } else {
+      filePath = path11.resolve(resolvedBasePath, `${locale}.json`);
+    }
+    if (!filePath.startsWith(resolvedBasePath)) {
+      throw new Error(
+        `[livelocale] Path traversal attempt: Resolved file path must start with basePath.`
+      );
+    }
+    await this.withLock(filePath, async () => {
+      let currentData = {};
+      let indent = "  ";
+      let trailingNewline = "\n";
+      try {
+        const fileContent = await fs7.readFile(filePath, "utf-8");
+        indent = detectJsonIndent(fileContent);
+        trailingNewline = fileContent.endsWith("\n") ? "\n" : "";
+        try {
+          const parsed = JSON.parse(fileContent);
+          if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+            throw new Error("Root must be an object");
+          }
+          currentData = parsed;
+        } catch (parseError) {
+          throw new Error(
+            `[livelocale] Invalid locale file: root must be an object. Code: INVALID_LOCALE. Original error: ${parseError.message}`
+          );
+        }
+      } catch (err) {
+        if (err.code !== "ENOENT") {
+          throw new Error(
+            `[livelocale] Failed to read locale file at ${filePath}. Operation: read. Original error: ${err.message}`
+          );
+        }
+      }
+      if (mutationKeyPath) {
+        setNestedProperty(currentData, mutationKeyPath, newValue);
+      } else {
+        throw new Error(
+          "[livelocale] Invalid namespace key path: must contain at least one nested key."
+        );
+      }
+      let stringified;
+      try {
+        stringified = JSON.stringify(currentData, null, indent);
+        JSON.parse(stringified);
+        stringified += trailingNewline;
+      } catch (err) {
+        throw new Error(
+          `[livelocale] Produced JSON is invalid or has circular references. Original error: ${err.message}`
+        );
+      }
+      const tempPath = `${filePath}.tmp`;
+      try {
+        await fs7.writeFile(tempPath, stringified, "utf-8");
+      } catch (err) {
+        throw new Error(
+          `[livelocale] Failed to write temp file at ${tempPath}. Operation: write. Original error: ${err.message}`
+        );
+      }
+      try {
+        await fs7.rename(tempPath, filePath);
+      } catch (err) {
+        try {
+          await fs7.unlink(tempPath);
+        } catch {
+        }
+        throw new Error(
+          `[livelocale] Failed to rename temp file to target at ${filePath}. Operation: rename. Original error: ${err.message}`
+        );
+      }
+      if (!this.quiet) {
+        console.log(`[livelocale] Updated key '${keyPath}' in locale '${locale}'`);
+      }
+    });
+  }
+  /**
+   * Returns the full dictionary for a locale: a flat `{locale}.json`, or every
+   * `*.json` inside the `{locale}/` folder merged under its namespace.
+   */
+  async readLocale(basePath, locale) {
+    this.assertEnabled();
+    const localePath = path11.resolve(basePath, locale);
+    let isDir = false;
+    try {
+      isDir = (await fs7.stat(localePath)).isDirectory();
+    } catch {
+    }
+    if (isDir) {
+      const merged = {};
+      for (const file of await fs7.readdir(localePath)) {
+        if (!file.endsWith(".json")) continue;
+        try {
+          merged[path11.basename(file, ".json")] = JSON.parse(
+            await fs7.readFile(path11.join(localePath, file), "utf-8")
+          );
+        } catch {
+        }
+      }
+      return merged;
+    }
+    const filePath = resolveSafeLocalePath(basePath, locale);
+    return JSON.parse(await fs7.readFile(filePath, "utf-8"));
+  }
+  /**
+   * Lists all locale codes dynamically scanned from the locales directory.
+   */
+  async listLocales(basePath) {
+    this.assertEnabled();
+    const resolvedBasePath = path11.resolve(basePath);
+    const items = await fs7.readdir(resolvedBasePath, { withFileTypes: true });
+    const localesSet = /* @__PURE__ */ new Set();
+    for (const item of items) {
+      if (item.isDirectory()) {
+        if (LOCALE_RE.test(item.name)) {
+          localesSet.add(item.name);
+        }
+      } else if (item.isFile() && item.name.endsWith(".json")) {
+        const name = path11.basename(item.name, ".json");
+        if (LOCALE_RE.test(name)) {
+          localesSet.add(name);
+        }
+      }
+    }
+    return Array.from(localesSet).sort();
+  }
+  /**
+   * Adds a new locale directory/file based on current repository structure.
+   */
+  async addLocale(basePath, locale) {
+    this.assertEnabled();
+    if (!isSafeLocaleSegment(locale)) {
+      throw new Error(
+        `[livelocale] Path traversal attempt detected in locale identifier: "${locale}"`
+      );
+    }
+    if (!LOCALE_RE.test(locale)) {
+      throw new Error(`[livelocale] Invalid locale format: "${locale}"`);
+    }
+    const resolvedBasePath = path11.resolve(basePath);
+    const localePath = path11.resolve(resolvedBasePath, locale);
+    if (!localePath.startsWith(resolvedBasePath)) {
+      throw new Error(
+        `[livelocale] Path traversal attempt: Resolved file path must start with basePath.`
+      );
+    }
+    let exists = false;
+    try {
+      await fs7.stat(localePath);
+      exists = true;
+    } catch {
+    }
+    try {
+      await fs7.stat(`${localePath}.json`);
+      exists = true;
+    } catch {
+    }
+    if (exists) {
+      throw new Error(`[livelocale] Locale "${locale}" already exists.`);
+    }
+    const items = await fs7.readdir(resolvedBasePath, { withFileTypes: true });
+    let referenceDir = null;
+    for (const item of items) {
+      if (item.isDirectory() && LOCALE_RE.test(item.name)) {
+        referenceDir = item.name;
+        break;
+      }
+    }
+    if (referenceDir) {
+      await fs7.mkdir(localePath, { recursive: true });
+      const refPath = path11.resolve(resolvedBasePath, referenceDir);
+      const files = await fs7.readdir(refPath);
+      for (const file of files) {
+        if (file.endsWith(".json")) {
+          await fs7.writeFile(path11.join(localePath, file), "{}", "utf-8");
+        }
+      }
+    } else {
+      await fs7.writeFile(`${localePath}.json`, "{}", "utf-8");
+    }
+    console.log(`[livelocale] Added locale '${locale}'`);
+  }
+  /**
+   * Renames an existing locale (directory or file) to a new name.
+   */
+  async renameLocale(basePath, oldLocale, newLocale) {
+    this.assertEnabled();
+    if (!isSafeLocaleSegment(oldLocale) || !isSafeLocaleSegment(newLocale)) {
+      throw new Error("[livelocale] Path traversal attempt detected");
+    }
+    if (!LOCALE_RE.test(oldLocale) || !LOCALE_RE.test(newLocale)) {
+      throw new Error(`[livelocale] Invalid locale format`);
+    }
+    const resolvedBasePath = path11.resolve(basePath);
+    const oldPath = path11.resolve(resolvedBasePath, oldLocale);
+    const newPath = path11.resolve(resolvedBasePath, newLocale);
+    if (!oldPath.startsWith(resolvedBasePath) || !newPath.startsWith(resolvedBasePath)) {
+      throw new Error("[livelocale] Path traversal attempt");
+    }
+    let isDir = false;
+    let exists = false;
+    try {
+      const stats = await fs7.stat(oldPath);
+      isDir = stats.isDirectory();
+      exists = true;
+    } catch {
+    }
+    let isFile = false;
+    if (!exists) {
+      try {
+        await fs7.stat(`${oldPath}.json`);
+        isFile = true;
+        exists = true;
+      } catch {
+      }
+    }
+    if (!exists) {
+      throw new Error(`[livelocale] Locale "${oldLocale}" does not exist.`);
+    }
+    let newExists = false;
+    try {
+      await fs7.stat(newPath);
+      newExists = true;
+    } catch {
+    }
+    try {
+      await fs7.stat(`${newPath}.json`);
+      newExists = true;
+    } catch {
+    }
+    if (newExists) {
+      throw new Error(`[livelocale] Target locale "${newLocale}" already exists.`);
+    }
+    if (isDir) {
+      await fs7.rename(oldPath, newPath);
+    } else if (isFile) {
+      await fs7.rename(`${oldPath}.json`, `${newPath}.json`);
+    }
+    console.log(`[livelocale] Renamed locale '${oldLocale}' to '${newLocale}'`);
+  }
+  /**
+   * Deletes an existing locale (directory or file).
+   */
+  async deleteLocale(basePath, locale) {
+    this.assertEnabled();
+    if (!isSafeLocaleSegment(locale)) {
+      throw new Error("[livelocale] Path traversal attempt detected");
+    }
+    if (!LOCALE_RE.test(locale)) {
+      throw new Error(`[livelocale] Invalid locale format`);
+    }
+    const resolvedBasePath = path11.resolve(basePath);
+    const localePath = path11.resolve(resolvedBasePath, locale);
+    if (!localePath.startsWith(resolvedBasePath)) {
+      throw new Error("[livelocale] Path traversal attempt");
+    }
+    let isDir = false;
+    let exists = false;
+    try {
+      const stats = await fs7.stat(localePath);
+      isDir = stats.isDirectory();
+      exists = true;
+    } catch {
+    }
+    let isFile = false;
+    if (!exists) {
+      try {
+        await fs7.stat(`${localePath}.json`);
+        isFile = true;
+        exists = true;
+      } catch {
+      }
+    }
+    if (!exists) {
+      throw new Error(`[livelocale] Locale "${locale}" does not exist.`);
+    }
+    if (isDir) {
+      await fs7.rm(localePath, { recursive: true, force: true });
+    } else if (isFile) {
+      await fs7.unlink(`${localePath}.json`);
+    }
+    console.log(`[livelocale] Deleted locale '${locale}'`);
+  }
+  /**
+   * Scans codebase directory recursively for references to translation keys.
+   * Delegates to the composed KeyScanner (SRP).
+   */
+  async scanCodebaseKeys(basePath) {
+    return this.scanner.scanCodebaseKeys(basePath);
+  }
+  /**
+   * Scans all locale files/folders to compile the set of all keys currently in locales.
+   */
+  async scanLocalesKeys(basePath) {
+    return this.scanner.scanLocalesKeys(basePath, this.listLocales.bind(this));
+  }
+  /**
+   * Returns merged lists of keys from codebase and existing locale files.
+   */
+  async getKeysMetadata(basePath) {
+    return this.scanner.getKeysMetadata(basePath, this.listLocales.bind(this));
+  }
+};
+
+// src/server/git-client.ts
+import { execFile as execFile3 } from "child_process";
+import { promisify } from "util";
+import * as fs8 from "fs";
+import * as path12 from "path";
+var execFileAsync = promisify(execFile3);
+var MAX_DIFF_BYTES = 2e5;
+function mapStatus(xy) {
+  if (xy === "??") return "added";
+  const code = xy.trim()[0] ?? "";
+  switch (code) {
+    case "M":
+      return "modified";
+    case "A":
+      return "added";
+    case "D":
+      return "deleted";
+    case "R":
+      return "renamed";
+    default:
+      return "modified";
+  }
+}
+var GitClient = class {
+  async git(cwd, args) {
+    const { stdout } = await execFileAsync("git", args, {
+      cwd,
+      maxBuffer: 16 * 1024 * 1024,
+      windowsHide: true,
+      env: { ...process.env, GIT_TERMINAL_PROMPT: "0" }
+    });
+    return stdout;
+  }
+  /** Resolves the repository root and the locales path relative to it (forward slashes). */
+  async locate(localesPath) {
+    const absolute = path12.resolve(localesPath);
+    const cwd = fs8.existsSync(absolute) ? absolute : path12.dirname(absolute);
+    if (!fs8.existsSync(cwd)) return null;
+    try {
+      const root = (await this.git(cwd, ["rev-parse", "--show-toplevel"])).trim();
+      if (!root) return null;
+      const rel = path12.relative(root, absolute).split(path12.sep).join("/");
+      if (rel.startsWith("..")) return null;
+      return { root: path12.resolve(root), rel: rel || ".", absolute };
+    } catch {
+      return null;
+    }
+  }
+  async status(localesPath) {
+    const loc = await this.locate(localesPath);
+    if (!loc) return { isRepo: false, branch: null, changes: [] };
+    let branch = null;
+    try {
+      branch = (await this.git(loc.root, ["rev-parse", "--abbrev-ref", "HEAD"])).trim() || null;
+    } catch {
+      branch = null;
+    }
+    const changes = [];
+    try {
+      const out = await this.git(loc.root, [
+        "status",
+        "--porcelain=v1",
+        "--untracked-files=all",
+        "--",
+        loc.rel
+      ]);
+      for (const line of out.split("\n")) {
+        if (line.length < 4) continue;
+        const xy = line.slice(0, 2);
+        let file = line.slice(3).trim();
+        const arrow = file.indexOf(" -> ");
+        if (arrow !== -1) file = file.slice(arrow + 4);
+        if (file.startsWith('"') && file.endsWith('"')) file = file.slice(1, -1);
+        changes.push({ path: file, status: mapStatus(xy) });
+      }
+    } catch {
+    }
+    return { isRepo: true, branch, changes, mode: "local", pullRequestUrl: null };
+  }
+  async diff(localesPath) {
+    const loc = await this.locate(localesPath);
+    if (!loc) return "";
+    let out = "";
+    try {
+      out = await this.git(loc.root, ["diff", "--no-color", "--", loc.rel]);
+    } catch {
+    }
+    try {
+      const untracked = await this.git(loc.root, [
+        "ls-files",
+        "--others",
+        "--exclude-standard",
+        "--",
+        loc.rel
+      ]);
+      for (const file of untracked.split("\n").map((l) => l.trim()).filter(Boolean)) {
+        const full = path12.join(loc.root, file);
+        let content = "";
+        try {
+          content = fs8.readFileSync(full, "utf-8");
+        } catch {
+          continue;
+        }
+        const lines = content.split("\n");
+        if (lines[lines.length - 1] === "") lines.pop();
+        out += `diff --git a/${file} b/${file}
+new file mode 100644
+--- /dev/null
++++ b/${file}
+@@ -0,0 +1,${lines.length} @@
+` + lines.map((l) => `+${l}`).join("\n") + "\n";
+      }
+    } catch {
+    }
+    if (Buffer.byteLength(out, "utf-8") > MAX_DIFF_BYTES) {
+      out = out.slice(0, MAX_DIFF_BYTES) + "\n\u2026 diff truncated \u2026\n";
+    }
+    return out;
+  }
+  async commit(localesPath, message) {
+    const loc = await this.locate(localesPath);
+    if (!loc) throw new Error("Not a git repository.");
+    const status = await this.status(localesPath);
+    if (status.changes.length === 0) {
+      throw new Error(`No changes to commit under ${loc.rel}.`);
+    }
+    await this.git(loc.root, ["add", "-A", "--", loc.rel]);
+    await this.git(loc.root, ["commit", "-q", "-m", message, "--", loc.rel]);
+    const hash = (await this.git(loc.root, ["rev-parse", "--short", "HEAD"])).trim();
+    return { hash };
+  }
+  async discard(localesPath) {
+    const loc = await this.locate(localesPath);
+    if (!loc) throw new Error("Not a git repository.");
+    try {
+      await this.git(loc.root, ["checkout", "--", loc.rel]);
+    } catch {
+    }
+    await this.git(loc.root, ["clean", "-fd", "--", loc.rel]);
+  }
+};
+
+// src/codemod/apply/report.ts
+var DEFAULT_SPAN_LENGTH = 120;
+var DEFAULT_TABLE_ROWS = 100;
+var MAX_BODY_CHARS = 6e4;
+var MAX_NOTE_CHARS2 = 2e3;
+var MAX_NAME_CHARS = 64;
+var MAX_CHECK_LINES = 50;
+var MAX_CHECK_SUMMARY_CHARS = 1e4;
+var BODY_MARGIN = 200;
+var STATUS_LABELS = {
+  apply: "applied",
+  already: "already done",
+  conflict: "conflict",
+  "needs-force": "needs --force",
+  invalid: "rejected"
+};
+var BIDI_CONTROL_RE = /[‪-‮⁦-⁩]/g;
+var NEWLINE_RE = /\r\n|\r|\n/g;
+var SPAN_CONTROL_RE = /[\u0000-\u0008\u000b-\u001f\u007f-\u009f]/g;
+var CONTROL_RE = /[\u0000-\u001f\u007f-\u009f]/g;
+function cut(text, max) {
+  if (text.length <= max) return text;
+  let out = text.slice(0, max);
+  const last = out.charCodeAt(out.length - 1);
+  if (last >= 55296 && last <= 56319) out = out.slice(0, -1);
+  return out;
+}
+function cutLines(text, max) {
+  if (text.length <= max) return text;
+  const kept = [];
+  let length = 0;
+  for (const line of text.split("\n")) {
+    const added = (kept.length > 0 ? 1 : 0) + line.length;
+    if (length + added + 2 > max) break;
+    kept.push(line);
+    length += added;
+  }
+  return [...kept, "\u2026"].join("\n");
+}
+function longestBacktickRun(text) {
+  let longest = 0;
+  for (const run3 of text.match(/`+/g) ?? []) longest = Math.max(longest, run3.length);
+  return longest;
+}
+function codePointLabel(ch) {
+  return `\u27E8U+${ch.charCodeAt(0).toString(16).toUpperCase().padStart(4, "0")}\u27E9`;
+}
+function codeSpan(text, maxLength = DEFAULT_SPAN_LENGTH) {
+  const truncated = text.length > maxLength ? `${cut(text, maxLength)}\u2026` : text;
+  const content = truncated.replace(NEWLINE_RE, "\u23CE").replace(BIDI_CONTROL_RE, codePointLabel).replace(SPAN_CONTROL_RE, codePointLabel).replace(/\|/g, "\\|");
+  if (content === "") return "` `";
+  const fence = "`".repeat(longestBacktickRun(content) + 1);
+  const pad = /^[` ]|[` ]$/.test(content) ? " " : "";
+  return `${fence}${pad}${content}${pad}${fence}`;
+}
+function sanitizeName(name) {
+  if (name === void 0) return void 0;
+  const cleaned = name.replace(NEWLINE_RE, " ").replace(CONTROL_RE, "").replace(/[@#<>]/g, "").trim();
+  const result = cut(cleaned, MAX_NAME_CHARS).trim();
+  return result === "" ? void 0 : result;
+}
+var NO_CHECK_PROBLEMS = "\u2705 `livelocale check`: no problems in the changed keys.";
+function summarizeCheck(report, edited) {
+  const changed = new Set(edited.map(([locale, key]) => `${locale}\0${key}`));
+  const mine = report.issues.filter(
+    (issue) => issue.locale !== void 0 && issue.key !== void 0 && changed.has(`${issue.locale}\0${issue.key}`)
+  );
+  if (mine.length === 0) return NO_CHECK_PROBLEMS;
+  const lines = [`\u26A0 \`livelocale check\` found ${mine.length} problem(s) in the changed keys:`, ""];
+  for (const issue of mine.slice(0, MAX_CHECK_LINES)) {
+    lines.push(
+      `- ${codeSpan(issue.locale ?? "")} ${codeSpan(issue.key ?? "")}: ${codeSpan(issue.message)}`
+    );
+  }
+  if (mine.length > MAX_CHECK_LINES) lines.push(`- \u2026and ${mine.length - MAX_CHECK_LINES} more`);
+  const others = report.issues.length - mine.length;
+  if (others > 0) {
+    lines.push("", `(${others} other problem(s) already in the repository are not shown.)`);
+  }
+  return lines.join("\n");
+}
+function checksCell(edit) {
+  const parts = edit.flags.map((flag) => FLAG_MESSAGES[flag]);
+  if ((edit.status === "invalid" || edit.status === "needs-force") && edit.message) {
+    parts.push(codeSpan(edit.message));
+  }
+  return parts.join("; ");
+}
+function renderRow(edit) {
+  const before = edit.from === null ? "\u2014" : codeSpan(edit.from);
+  const after = edit.status === "conflict" ? `now: ${edit.current === void 0 ? "(removed)" : codeSpan(edit.current)}` : codeSpan(edit.to);
+  const cells = [
+    STATUS_LABELS[edit.status],
+    codeSpan(edit.locale),
+    codeSpan(edit.key),
+    before,
+    after,
+    checksCell(edit)
+  ];
+  return `| ${cells.join(" | ")} |`;
+}
+function renderTable(plan, limit, maxChars) {
+  const lines = [
+    "| Status | Locale | Key | Before | After | Checks |",
+    "| --- | --- | --- | --- | --- | --- |"
+  ];
+  const moreLine = (n) => `
+
+\u2026and ${n} more`;
+  let length = lines.join("\n").length + moreLine(plan.edits.length).length;
+  let shown = 0;
+  for (const edit of plan.edits) {
+    if (shown >= limit) break;
+    const row = renderRow(edit);
+    if (length + row.length + 1 > maxChars) break;
+    lines.push(row);
+    length += row.length + 1;
+    shown += 1;
+  }
+  const rest = plan.edits.length - shown;
+  return lines.join("\n") + (rest > 0 ? moreLine(rest) : "");
+}
+function fencedNote(note) {
+  const text = cut(note, MAX_NOTE_CHARS2);
+  const fence = "`".repeat(Math.max(3, longestBacktickRun(text) + 1));
+  return `${fence}text
+${text}
+${fence}`;
+}
+function closingLine(ctx) {
+  if (ctx.issueNumber === void 0) return void 0;
+  if (ctx.target.isDefault) return `Closes #${ctx.issueNumber}`;
+  return `Refs #${ctx.issueNumber}. LiveLocale closes the issue when this pull request is merged or closed.`;
+}
+function renderPullRequestBody(ctx) {
+  const head = ["Applies translations sent with a LiveLocale change link."];
+  if (ctx.by?.trim()) head.push(`Translated by ${codeSpan(ctx.by)}`);
+  if (ctx.target.reason === "not-allowed" && ctx.target.requested !== void 0) {
+    head.push(
+      `The link was made from ${codeSpan(ctx.target.requested)}, which is not in the allowed branches, so this targets ${codeSpan(ctx.target.branch)}.`
+    );
+  }
+  if (ctx.note?.trim()) head.push(fencedNote(ctx.note));
+  const tail = [];
+  if (ctx.checkSummary) tail.push(cutLines(ctx.checkSummary, MAX_CHECK_SUMMARY_CHARS));
+  if (ctx.runUrl) tail.push(`Run log: ${ctx.runUrl}`);
+  const closing = closingLine(ctx);
+  if (closing) tail.push(closing);
+  const fixed = [...head, ...tail].join("\n\n").length;
+  const table = renderTable(ctx.plan, DEFAULT_TABLE_ROWS, MAX_BODY_CHARS - BODY_MARGIN - fixed);
+  return [...head, table, ...tail].join("\n\n");
+}
+function renderCommitMessage(input) {
+  let subject = "i18n: apply LiveLocale changes";
+  if (input.issueNumber !== void 0) subject += ` (#${input.issueNumber})`;
+  else if (input.runId !== void 0) subject += ` (run ${input.runId})`;
+  const applied = input.plan.edits.filter((edit) => edit.status === "apply");
+  const locales = [...new Set(applied.map((edit) => edit.locale))].sort();
+  const parts = [subject, `${applied.length} translation(s) in ${locales.join(", ")}.`];
+  const name = sanitizeName(input.by);
+  if (name) parts.push(`Translated-by: ${name}`);
+  return parts.join("\n\n");
+}
+function renderTerminalSummary(plan) {
+  const c = plan.counts;
+  const lines = [
+    `Applied ${c.apply} \xB7 already done ${c.already} \xB7 conflicts ${c.conflict} \xB7 needs --force ${c["needs-force"]} \xB7 rejected ${c.invalid}`
+  ];
+  for (const edit of plan.edits) {
+    lines.push(`${STATUS_LABELS[edit.status]} ${edit.locale} ${edit.key}`);
+  }
+  return lines.join("\n");
+}
+
+// src/codemod/apply/local.ts
+function isPlainObject4(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+async function readTarget(mutator, localesDir, locale) {
+  if (!isValidLocaleFormat(locale)) return null;
+  const dir = path13.join(localesDir, locale);
+  let layout;
+  if (fs9.statSync(dir, { throwIfNoEntry: false })?.isDirectory()) {
+    layout = "namespaced";
+  } else if (fs9.statSync(`${dir}.json`, { throwIfNoEntry: false })?.isFile()) {
+    layout = "flat";
+  } else {
+    return null;
+  }
+  const dict = await mutator.readLocale(localesDir, locale);
+  if (!isPlainObject4(dict)) {
+    throw new Error(`The "${locale}" locale file is not a JSON object.`);
+  }
+  return { layout, dict };
+}
+function fileFor(localesPath, layout, locale, key) {
+  const rel = layout === "flat" ? path13.join(localesPath, `${locale}.json`) : path13.join(localesPath, locale, `${key.slice(0, key.indexOf("."))}.json`);
+  return path13.normalize(rel).split(path13.sep).join("/");
+}
+var PR_TITLE = "i18n: LiveLocale changes";
+var GITHUB_REMOTE_RE = /github\.com[:/]([\w.-]+\/[\w.-]+?)(?:\.git)?$/;
+var defaultGit = (args, cwd, opts) => {
+  const env = { ...process.env, GIT_TERMINAL_PROMPT: "0" };
+  if (opts?.inherit) {
+    return new Promise((resolve14, reject2) => {
+      const child = spawn2("git", args, { cwd, env, stdio: "inherit", windowsHide: true });
+      child.on("error", reject2);
+      child.on(
+        "close",
+        (code) => code === 0 ? resolve14("") : reject2(new Error(`git ${args[0]} failed (exit ${code}).`))
+      );
+    });
+  }
+  return new Promise((resolve14, reject2) => {
+    execFile4(
+      "git",
+      args,
+      { cwd, env, windowsHide: true, maxBuffer: 16 * 1024 * 1024 },
+      (error, stdout) => error ? reject2(error) : resolve14(String(stdout))
+    );
+  });
+};
+var defaultGh = (args, cwd) => new Promise((resolve14, reject2) => {
+  execFile4(
+    "gh",
+    args,
+    { cwd, windowsHide: true },
+    (error, stdout, stderr) => error ? reject2(Object.assign(error, { stderr: String(stderr) })) : resolve14(String(stdout))
+  );
+});
+function utcStamp(date) {
+  const p = (n) => String(n).padStart(2, "0");
+  return `${date.getUTCFullYear()}${p(date.getUTCMonth() + 1)}${p(date.getUTCDate())}-${p(date.getUTCHours())}${p(date.getUTCMinutes())}${p(date.getUTCSeconds())}`;
+}
+async function tryRun(run3) {
+  try {
+    return await run3();
+  } catch {
+    return null;
+  }
+}
+async function pickBranchName(git, root, stamp) {
+  const pushUrl = (await tryRun(() => git(["remote", "get-url", "--push", "origin"], root)))?.trim();
+  const taken = async (name2) => {
+    const local = await tryRun(
+      () => git(["rev-parse", "--verify", "--quiet", `refs/heads/${name2}`], root)
+    );
+    if (local !== null) return true;
+    if (!pushUrl) return false;
+    const remote = await tryRun(
+      () => git(["ls-remote", "--heads", pushUrl, `refs/heads/${name2}`], root)
+    );
+    return remote !== null && remote.trim() !== "";
+  };
+  const base = `livelocale/apply-${stamp}`;
+  let name = base;
+  for (let n = 2; await taken(name); n++) name = `${base}-${n}`;
+  return name;
+}
+function errorMessage(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+async function writeEdits(mutator, plan, targets, localesDir, localesPath) {
+  const written = [];
+  for (const edit of plan.edits) {
+    if (edit.status !== "apply") continue;
+    await mutator.updateLocaleKey(localesDir, edit.locale, edit.key, edit.to);
+    const file = fileFor(localesPath, targets.get(edit.locale).layout, edit.locale, edit.key);
+    if (!written.includes(file)) written.push(file);
+  }
+  return written;
+}
+function exitCodeFor(plan) {
+  const c = plan.counts;
+  return c.conflict + c.invalid + c["needs-force"] > 0 ? 1 : 0;
+}
+async function preparePullRequest(git, projectDir, localesDir) {
+  const top = (await tryRun(() => git(["rev-parse", "--show-toplevel"], projectDir)))?.trim();
+  if (!top) throw new ApplyInputError("apply --pr needs a git repository.");
+  const root = path13.resolve(top);
+  const original = (await tryRun(() => git(["symbolic-ref", "--quiet", "--short", "HEAD"], root)))?.trim();
+  if (!original) throw new ApplyInputError("Check out a branch first.");
+  const status = await new GitClient().status(localesDir);
+  if (status.changes.length > 0) {
+    const rel = path13.relative(root, localesDir).split(path13.sep).join("/") || ".";
+    throw new ApplyInputError(
+      `Commit or stash the changes under ${rel} first; apply --pr commits everything in that folder.`
+    );
+  }
+  return { root, original };
+}
+async function createPullRequest(log, gh, root, base, head, body) {
+  const tmpDir = fs9.mkdtempSync(path13.join(os.tmpdir(), "livelocale-pr-"));
+  const bodyFile = path13.join(tmpDir, "body.md");
+  try {
+    fs9.writeFileSync(bodyFile, body, "utf-8");
+    const out = await gh(
+      [
+        "pr",
+        "create",
+        "--base",
+        base,
+        "--head",
+        head,
+        "--title",
+        PR_TITLE,
+        "--body-file",
+        bodyFile
+      ],
+      root
+    );
+    const lines = out.split("\n").map((line) => line.trim()).filter(Boolean);
+    return lines[lines.length - 1];
+  } catch (err) {
+    if (err?.code !== "ENOENT") {
+      const stderr = err?.stderr;
+      const reason = typeof stderr === "string" && stderr.trim() ? stderr.trim() : errorMessage(err);
+      log(`gh could not open the pull request: ${reason}`);
+    }
+    return void 0;
+  } finally {
+    fs9.rmSync(tmpDir, { recursive: true, force: true });
+  }
+}
+async function runLocalApply(options) {
+  const log = options.log ?? ((line) => console.log(line));
+  const set = await decodeChangeLink(options.input, nodeInflate);
+  const localesPath = options.localesPath ?? "locales";
+  const localesDir = path13.resolve(options.projectDir, localesPath);
+  if (!fs9.statSync(localesDir, { throwIfNoEntry: false })?.isDirectory()) {
+    throw new ApplyInputError(`No locales folder at ${localesPath}.`);
+  }
+  const pr = options.pr === true && options.dryRun !== true;
+  const git = options.exec?.git ?? defaultGit;
+  const repo = pr ? await preparePullRequest(git, options.projectDir, localesDir) : void 0;
+  if (repo && set.branch !== "" && set.branch !== repo.original) {
+    log(
+      `The link was made from the branch \`${set.branch}\`; the pull request targets \`${repo.original}\`.`
+    );
+  }
+  const mutator = new FileMutator({ requireEnabled: false, quiet: true });
+  let sourceLocale = options.sourceLocale;
+  if (sourceLocale === void 0) {
+    const locales = await mutator.listLocales(localesDir);
+    sourceLocale = locales.includes("en") ? "en" : locales[0] ?? "en";
+  }
+  if (set.src !== sourceLocale) {
+    log(
+      `The link says the source locale is \`${set.src}\`; using \`${sourceLocale}\` (pass --source to change).`
+    );
+  }
+  const targets = /* @__PURE__ */ new Map();
+  for (const locale of /* @__PURE__ */ new Set([sourceLocale, ...set.edits.map((e) => e.locale)])) {
+    targets.set(locale, await readTarget(mutator, localesDir, locale));
+  }
+  const plan = planApply({
+    edits: set.edits,
+    sourceLocale,
+    targets,
+    allowForce: options.force === true
+  });
+  const exitCode = exitCodeFor(plan);
+  if (!repo || plan.counts.apply === 0) {
+    const written = repo || options.dryRun ? [] : await writeEdits(mutator, plan, targets, localesDir, localesPath);
+    log(renderTerminalSummary(plan));
+    return { plan, written, exitCode };
+  }
+  const { root, original } = repo;
+  const now = options.now ?? (() => /* @__PURE__ */ new Date());
+  const branch = await pickBranchName(git, root, utcStamp(now()));
+  await git(["switch", "-c", branch], root);
+  try {
+    const written = await writeEdits(mutator, plan, targets, localesDir, localesPath);
+    log(renderTerminalSummary(plan));
+    let checkSummary;
+    try {
+      const report = await runCheck({
+        projectDir: options.projectDir,
+        localesPath: localesDir,
+        sourceLocale,
+        unused: false
+      });
+      const edited = plan.edits.filter((edit) => edit.status === "apply").map((edit) => [edit.locale, edit.key]);
+      checkSummary = summarizeCheck(report, edited);
+    } catch (err) {
+      checkSummary = `Check could not run: ${errorMessage(err)}`;
+    }
+    await new GitClient().commit(localesDir, renderCommitMessage({ plan, by: set.by }));
+    await git(["push", "-u", "origin", branch], root, { inherit: true });
+    const remote = (await tryRun(() => git(["remote", "get-url", "origin"], root)))?.trim();
+    const slug = remote ? GITHUB_REMOTE_RE.exec(remote)?.[1] : void 0;
+    let prUrl;
+    if (slug) {
+      const body = renderPullRequestBody({
+        plan,
+        by: set.by,
+        note: set.note,
+        checkSummary,
+        target: { branch: original, isDefault: false, reason: "local" }
+      });
+      prUrl = await createPullRequest(
+        log,
+        options.exec?.gh ?? defaultGh,
+        root,
+        original,
+        branch,
+        body
+      );
+    }
+    if (prUrl) {
+      log(`Opened ${prUrl}`);
+    } else {
+      log(`Pushed ${branch}. Open a pull/merge request from it into ${original}.`);
+      if (slug) log(`https://github.com/${slug}/compare/${original}...${branch}?expand=1`);
+    }
+    await git(["switch", original], root);
+    return { plan, written, branch, prUrl, exitCode };
+  } catch (err) {
+    log(`You are on ${branch}; your changes are committed there.`);
+    throw err;
+  }
+}
+
+// src/codemod/apply/cli.ts
+var VALUE_OPTIONS2 = { "--dir": "dir", "--locales": "locales", "--source": "source" };
+var FLAG_OPTIONS = {
+  "--clipboard": "clipboard",
+  "--pr": "pr",
+  "--force": "force",
+  "--dry-run": "dryRun"
+};
+function parseApplyArgs(argv) {
+  const args = {
+    input: void 0,
+    clipboard: false,
+    pr: false,
+    force: false,
+    dryRun: false,
+    dir: ".",
+    locales: void 0,
+    source: void 0
+  };
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (Object.prototype.hasOwnProperty.call(VALUE_OPTIONS2, arg)) {
+      const value = argv[i + 1];
+      if (value === void 0 || value.startsWith("--")) {
+        throw new ApplyInputError(`${arg} needs a value.`);
+      }
+      args[VALUE_OPTIONS2[arg]] = value;
+      i++;
+    } else if (Object.prototype.hasOwnProperty.call(FLAG_OPTIONS, arg)) {
+      args[FLAG_OPTIONS[arg]] = true;
+    } else if (arg.startsWith("-") && arg !== "-") {
+      throw new ApplyInputError(`Unknown option "${arg}".`);
+    } else if (args.input !== void 0) {
+      throw new ApplyInputError('Pass one change link, file or "-".');
+    } else {
+      args.input = arg;
+    }
+  }
+  if (args.clipboard && args.input !== void 0) {
+    throw new ApplyInputError("Pass the link or --clipboard, not both.");
+  }
+  return args;
+}
+async function runApplyCommand(argv) {
+  try {
+    const args = parseApplyArgs(argv);
+    const input = await readApplyInput(args.input, {
+      cwd: process.cwd(),
+      clipboard: args.clipboard
+    });
+    const result = await runLocalApply({
+      projectDir: path14.resolve(args.dir),
+      localesPath: args.locales,
+      sourceLocale: args.source,
+      input,
+      force: args.force,
+      dryRun: args.dryRun,
+      pr: args.pr
+    });
+    process.exitCode = result.exitCode;
+  } catch (err) {
+    console.error(`\u274C ${err instanceof Error ? err.message : String(err)}`);
+    process.exitCode = 1;
+  }
+}
+
+// src/codemod/index.ts
+var DEFAULT_STUDIO_PORT = 3010;
+var DEFAULT_APP_ORIGIN = "http://localhost:3000";
+function printHelp() {
+  console.log(`
+LiveLocale (livelocale) CLI
+
+Usage:
+  npx livelocale <command> [options]
+
+Commands:
+  migrate     Bulk migrate existing react-i18next translation usages to wrap them with wrapTranslationEngine automatically.
+  init        Initialize the API route handler inside a Next.js project automatically.
+  studio      Start the visual editing studio local web server.
+  doctor      Check the project for common integration problems (route, provider, middleware, CSP, locales).
+  check       Check translations for missing keys, placeholder drift, broken ICU syntax and unused keys (CI-friendly).
+  pack        Write the share Studio (livelocale/) into a built site folder and link every HTML page to it.
+  build       Run your build command, then pack its output (Next.js: packs into public/livelocale/ first).
+  apply       Apply a LiveLocale change link to your locale files (--pr opens a pull request)
+
+Options for migrate:
+  --dir <path>       Directory to scan (default: current directory)
+  --exclude <list>   Comma-separated list of directories to exclude (default: node_modules,.next,dist,.git)
+  --dry-run          Preview changes without writing them to disk
+
+Options for init:
+  --dir <path>       Target project directory (default: current directory)
+
+Options for studio:
+  --port <number>    Port to run the studio server on (default: ${DEFAULT_STUDIO_PORT})
+  --app <origin>     Origin of the app being edited (default: ${DEFAULT_APP_ORIGIN})
+                     Can also be changed at run time with ?app=<origin> on the Studio URL.
+
+Options for doctor:
+  --dir <path>       Project directory to inspect (default: current directory)
+  --locales <path>   Locales directory relative to the project (default: locales)
+  --app <url>        Also probe the running app or deployed site, e.g. http://localhost:3000
+                     or https://user.github.io/repo/ (a path is the app base)
+  --share            Run the share link probes even when livelocale/manifest.json is missing
+  --token <token>    Access token for a preview deployment (default: LIVELOCALE_TOKEN)
+
+Options for check:
+  --dir <path>       Project directory to scan (default: current directory)
+  --locales <path>   Locales directory relative to the project (default: locales)
+  --source <locale>  Locale the others are compared against (default: en, else the first locale)
+  --no-unused        Do not report keys that code never references
+  --strict           Treat warnings (unused keys, empty values) as failures
+  --json             Print the full report as JSON
+
+Options for pack:
+  pack <outDir>      Built site folder, relative to --dir (e.g. dist, build, out)
+  --dir <path>       Project directory (default: current directory)
+  --locales <path>   Locales directory relative to the project (default: locales)
+  --source <locale>  Source locale (default: en, else the first locale)
+  --base <path>      Site path the app is served from, e.g. /repo/ (default: detected, else /)
+  --expose-repo      Put the GitHub owner/repo into livelocale/manifest.json
+  --no-inject        Do not add the flag.js script to HTML files
+
+Options for build:
+  build [--preview] [--out <dir>] [pack options] -- <command...>
+  --preview          Run the command with LIVELOCALE=preview and NEXT_PUBLIC_LIVELOCALE=preview
+  --out <dir>        Build output folder (default: detected from dist/, build/, out/)
+
+Options for apply:
+  apply <link|file|->  The change link, a file that holds it, or - to read stdin
+  --clipboard        Read the change link from the clipboard instead
+  --pr               Commit the changes on a new branch and open a pull request
+  --dir <path>       Project directory (default: current directory)
+  --locales <path>   Locales directory relative to the project (default: locales)
+  --source <locale>  Source locale (default: en, else the first locale)
+  --force            Apply edits the translator saved with "Save anyway"
+  --dry-run          Show what would change without writing files
+
+Global Options:
+  -h, --help         Show help information
+`);
+}
+function normalizeOriginArg(value, flag) {
+  try {
+    const url = new URL(value);
+    if (url.protocol !== "http:" && url.protocol !== "https:") throw new Error("bad protocol");
     return url.origin;
   } catch {
     console.error(
@@ -1631,12 +4441,22 @@ function normalizeOriginArg(value, flag) {
     process.exit(1);
   }
 }
+function normalizeAppArg(value) {
+  try {
+    return normalizeAppUrl(value);
+  } catch {
+    console.error(
+      `Error: --app must be an http(s) URL such as http://localhost:3000 or https://user.github.io/repo/ (got "${value}").`
+    );
+    process.exit(1);
+  }
+}
 function isPortAnswering(port) {
-  return new Promise((resolve6) => {
+  return new Promise((resolve14) => {
     const socket = net.connect({ host: "localhost", port });
     const done = (answering) => {
       socket.destroy();
-      resolve6(answering);
+      resolve14(answering);
     };
     socket.setTimeout(1e3, () => done(false));
     socket.once("connect", () => done(true));
@@ -1646,8 +4466,8 @@ function isPortAnswering(port) {
 async function runStudio(port, appOrigin) {
   console.log(`
 \u{1F680} Starting LiveLocale Studio...`);
-  const studioDir = path5.resolve(getDirname(), "../studio");
-  if (!fs5.existsSync(path5.join(studioDir, "index.html"))) {
+  const studioDir = path15.resolve(moduleDir(), "../studio");
+  if (!fs10.existsSync(path15.join(studioDir, "index.html"))) {
     console.error(`Error: Studio assets not found at "${studioDir}".`);
     console.error(`Did you build the project? Run "npm run build" first.`);
     process.exit(1);
@@ -1679,48 +4499,48 @@ async function runStudio(port, appOrigin) {
 function runInit(projectDir) {
   console.log(`
 \u{1F680} Initializing LiveLocale API handler...`);
-  const absoluteDir = path5.resolve(projectDir);
-  if (!fs5.existsSync(absoluteDir)) {
+  const absoluteDir = path15.resolve(projectDir);
+  if (!fs10.existsSync(absoluteDir)) {
     console.error(`Error: Directory "${projectDir}" does not exist.`);
     process.exit(1);
   }
-  const isTypeScript = fs5.existsSync(path5.join(absoluteDir, "tsconfig.json"));
+  const isTypeScript = fs10.existsSync(path15.join(absoluteDir, "tsconfig.json"));
   const fileExt = isTypeScript ? "ts" : "js";
   console.log(`\u{1F4C1} Target: ${absoluteDir}`);
   console.log(`\u{1F527} Language detected: ${isTypeScript ? "TypeScript" : "JavaScript"}`);
   let hasNextIntl = false;
   let hasReactI18next = false;
-  const targetPkgPath = path5.join(absoluteDir, "package.json");
-  if (fs5.existsSync(targetPkgPath)) {
+  const targetPkgPath = path15.join(absoluteDir, "package.json");
+  if (fs10.existsSync(targetPkgPath)) {
     try {
-      const pkg = JSON.parse(fs5.readFileSync(targetPkgPath, "utf8"));
+      const pkg = JSON.parse(fs10.readFileSync(targetPkgPath, "utf8"));
       const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
       hasNextIntl = Boolean(allDeps["next-intl"]);
       hasReactI18next = Boolean(allDeps["react-i18next"]);
     } catch {
     }
   }
-  const appDirPath = path5.join(absoluteDir, "app");
-  const pagesDirPath = path5.join(absoluteDir, "pages");
-  const srcAppDirPath = path5.join(absoluteDir, "src", "app");
-  const srcPagesDirPath = path5.join(absoluteDir, "src", "pages");
+  const appDirPath = path15.join(absoluteDir, "app");
+  const pagesDirPath = path15.join(absoluteDir, "pages");
+  const srcAppDirPath = path15.join(absoluteDir, "src", "app");
+  const srcPagesDirPath = path15.join(absoluteDir, "src", "pages");
   let targetPath = "";
   let routerType = "";
   let content = "";
-  if (fs5.existsSync(appDirPath)) {
-    targetPath = path5.join(appDirPath, "api", "livelocale", `route.${fileExt}`);
+  if (fs10.existsSync(appDirPath)) {
+    targetPath = path15.join(appDirPath, "api", "livelocale", `route.${fileExt}`);
     routerType = "Next.js App Router (root)";
-  } else if (fs5.existsSync(srcAppDirPath)) {
-    targetPath = path5.join(srcAppDirPath, "api", "livelocale", `route.${fileExt}`);
+  } else if (fs10.existsSync(srcAppDirPath)) {
+    targetPath = path15.join(srcAppDirPath, "api", "livelocale", `route.${fileExt}`);
     routerType = "Next.js App Router (src/)";
-  } else if (fs5.existsSync(pagesDirPath)) {
-    targetPath = path5.join(pagesDirPath, "api", `livelocale.${fileExt}`);
+  } else if (fs10.existsSync(pagesDirPath)) {
+    targetPath = path15.join(pagesDirPath, "api", `livelocale.${fileExt}`);
     routerType = "Next.js Pages Router (root)";
-  } else if (fs5.existsSync(srcPagesDirPath)) {
-    targetPath = path5.join(srcPagesDirPath, "api", `livelocale.${fileExt}`);
+  } else if (fs10.existsSync(srcPagesDirPath)) {
+    targetPath = path15.join(srcPagesDirPath, "api", `livelocale.${fileExt}`);
     routerType = "Next.js Pages Router (src/)";
   } else {
-    targetPath = path5.join(absoluteDir, "app", "api", "livelocale", `route.${fileExt}`);
+    targetPath = path15.join(absoluteDir, "app", "api", "livelocale", `route.${fileExt}`);
     routerType = "Default App Router (app/ not found)";
   }
   console.log(`\u{1F4CD} Project structure: ${routerType}`);
@@ -1748,14 +4568,14 @@ const handler = createLiveLocaleHandler({
 export default handler;
 `;
   }
-  const targetDir = path5.dirname(targetPath);
-  if (!fs5.existsSync(targetDir)) {
-    fs5.mkdirSync(targetDir, { recursive: true });
+  const targetDir = path15.dirname(targetPath);
+  if (!fs10.existsSync(targetDir)) {
+    fs10.mkdirSync(targetDir, { recursive: true });
   }
   try {
-    fs5.writeFileSync(targetPath, content, "utf8");
+    fs10.writeFileSync(targetPath, content, "utf8");
     console.log(`\u2705 Created API Route Handler successfully at:`);
-    console.log(`   ${path5.relative(absoluteDir, targetPath)}`);
+    console.log(`   ${path15.relative(absoluteDir, targetPath)}`);
     if (hasNextIntl) {
       console.log(`
 \u{1F4A1} Detected 'next-intl' in your project!`);
@@ -1797,8 +4617,8 @@ async function runMigrate(args) {
       }
     }
   }
-  const absoluteDir = path5.resolve(dir);
-  if (!fs5.existsSync(absoluteDir)) {
+  const absoluteDir = path15.resolve(dir);
+  if (!fs10.existsSync(absoluteDir)) {
     console.error(`Error: Directory "${dir}" does not exist.`);
     process.exit(1);
   }
@@ -1822,28 +4642,28 @@ async function runMigrate(args) {
   let scannedCount = 0;
   let migratedCount = 0;
   async function walk(currentDir) {
-    const files = fs5.readdirSync(currentDir, { withFileTypes: true });
+    const files = fs10.readdirSync(currentDir, { withFileTypes: true });
     for (const file of files) {
-      const fullPath = path5.join(currentDir, file.name);
+      const fullPath = path15.join(currentDir, file.name);
       if (file.isDirectory()) {
         if (excludes.includes(file.name)) {
           continue;
         }
         await walk(fullPath);
       } else if (file.isFile()) {
-        const ext = path5.extname(file.name);
+        const ext = path15.extname(file.name);
         if ([".js", ".jsx", ".ts", ".tsx"].includes(ext)) {
           scannedCount++;
           try {
-            const content = fs5.readFileSync(fullPath, "utf8");
+            const content = fs10.readFileSync(fullPath, "utf8");
             const result = await transformReactI18next2(content, fullPath);
             if (result.modified) {
               migratedCount++;
-              const relativePath = path5.relative(absoluteDir, fullPath);
+              const relativePath = path15.relative(absoluteDir, fullPath);
               if (dryRun) {
                 console.log(`[DRY RUN] Would migrate: ${relativePath}`);
               } else {
-                fs5.writeFileSync(fullPath, result.code, "utf8");
+                fs10.writeFileSync(fullPath, result.code, "utf8");
                 console.log(`\u2705 Migrated: ${relativePath}`);
               }
             }
@@ -1873,7 +4693,8 @@ async function runMigrate(args) {
 async function runDoctorCommand(args) {
   let dir = ".";
   let localesPath;
-  let appOrigin;
+  let app;
+  let share = false;
   let token;
   for (let i = 1; i < args.length; i++) {
     const arg = args[i];
@@ -1882,23 +4703,32 @@ async function runDoctorCommand(args) {
     } else if (arg === "--locales") {
       localesPath = args[++i];
     } else if (arg === "--app") {
-      appOrigin = normalizeOriginArg(args[++i] || "", "--app");
+      app = normalizeAppArg(args[++i] || "");
+    } else if (arg === "--share") {
+      share = true;
     } else if (arg === "--token") {
       token = args[++i];
     } else if (arg && !arg.startsWith("--")) {
       dir = arg;
     }
   }
-  const projectDir = path5.resolve(dir);
-  if (!fs5.existsSync(projectDir)) {
+  const projectDir = path15.resolve(dir);
+  if (!fs10.existsSync(projectDir)) {
     console.error(`Error: Directory "${dir}" does not exist.`);
     process.exit(1);
   }
   console.log(`
 \u{1FA7A} LiveLocale doctor \u2014 ${projectDir}`);
-  if (appOrigin) console.log(`\u{1F517} Probing app at ${appOrigin}`);
+  if (app) console.log(`\u{1F517} Probing app at ${app.base}`);
   console.log("--------------------------------------------------");
-  const findings = await runDoctor({ projectDir, localesPath, appOrigin, token });
+  const findings = await runDoctor({
+    projectDir,
+    localesPath,
+    appOrigin: app?.origin,
+    appBase: app?.base,
+    share,
+    token
+  });
   console.log(formatFindings(findings));
   console.log("--------------------------------------------------");
   const fails = findings.filter((f) => f.level === "fail").length;
@@ -1911,7 +4741,9 @@ async function runDoctorCommand(args) {
   console.log(
     warns > 0 ? `\u2705 No blocking problems, ${warns} warning(s) worth a look.` : `\u2705 Everything looks good.`
   );
-  if (!appOrigin) {
+  const shareLink = findings.find((f) => f.title === "Share link")?.detail;
+  if (shareLink) console.log(`\u{1F517} Share link: ${shareLink}`);
+  if (!app) {
     console.log(
       `\u{1F4A1} Start your dev server and re-run with --app http://localhost:3000 for live checks.`
     );
@@ -1942,8 +4774,8 @@ async function runCheckCommand(args) {
       dir = arg;
     }
   }
-  const projectDir = path5.resolve(dir);
-  if (!fs5.existsSync(projectDir)) {
+  const projectDir = path15.resolve(dir);
+  if (!fs10.existsSync(projectDir)) {
     console.error(`Error: Directory "${dir}" does not exist.`);
     process.exit(1);
   }
@@ -1981,13 +4813,74 @@ async function runCheckCommand(args) {
     warns > 0 ? `\u2705 No problems, ${warns} warning(s) worth a look.` : `\u2705 Translations look good.`
   );
 }
-async function run() {
+var PACK_USAGE = "Usage: livelocale pack <outDir> [options]";
+function printPackSummary(result, projectDir, warnings) {
+  for (const warning of warnings) console.log(`\u26A0\uFE0F  ${warning}`);
+  const outRel = path15.relative(projectDir, path15.dirname(result.shareDir)).split(path15.sep).join("/") || ".";
+  console.log(
+    `\u2705 LiveLocale share folder written to ${outRel}/livelocale/ (${result.manifest.locales.length} locales, ${result.manifest.codeKeys.length} code keys, ${result.htmlInjected.length} HTML files linked).`
+  );
+  console.log(`\u{1F517} Open ${result.shareUrlPath} on the deployed site.`);
+}
+async function runPackCommand(args) {
+  try {
+    const options = parseShareArgs(args.slice(1));
+    if (options.positional.length !== 1 || options.out !== void 0 || options.preview || options.command.length > 0) {
+      throw new PackError("USAGE", PACK_USAGE);
+    }
+    const projectDir = path15.resolve(options.dir);
+    const result = await packOutput({
+      projectDir,
+      outDir: options.positional[0],
+      localesPath: options.locales,
+      sourceLocale: options.source,
+      base: options.base,
+      exposeRepo: options.exposeRepo,
+      injectHtml: options.inject ? "auto" : false
+    });
+    printPackSummary(result, projectDir, result.warnings);
+  } catch (err) {
+    if (!(err instanceof PackError)) throw err;
+    console.error(`\u274C ${err.message}`);
+    process.exitCode = 1;
+  }
+}
+async function runBuildCli(args) {
+  try {
+    const options = parseShareArgs(args.slice(1));
+    if (options.positional.length > 0 || !options.inject) {
+      throw new PackError("USAGE", BUILD_USAGE);
+    }
+    const projectDir = path15.resolve(options.dir);
+    const result = await runBuildCommand({
+      projectDir,
+      command: options.command,
+      preview: options.preview,
+      outDir: options.out,
+      localesPath: options.locales,
+      sourceLocale: options.source,
+      base: options.base,
+      exposeRepo: options.exposeRepo
+    });
+    if (result.pack !== null) {
+      printPackSummary(result.pack, projectDir, result.warnings);
+    } else {
+      for (const warning of result.warnings) console.log(`\u26A0\uFE0F  ${warning}`);
+    }
+    process.exitCode = result.exitCode;
+  } catch (err) {
+    if (!(err instanceof PackError)) throw err;
+    console.error(`\u274C ${err.message}`);
+    process.exitCode = 1;
+  }
+}
+async function run2() {
   const args = process.argv.slice(2);
   if (args.includes("--help") || args.includes("-h") || args[0] === "help") {
     printHelp();
     process.exit(0);
   }
-  const COMMANDS = ["migrate", "init", "studio", "doctor", "check"];
+  const COMMANDS = ["migrate", "init", "studio", "doctor", "check", "pack", "build", "apply"];
   if (!args[0] || !COMMANDS.includes(args[0])) {
     console.error(`Unknown command: "${args[0]}". Expected one of: ${COMMANDS.join(", ")}.`);
     printHelp();
@@ -2001,6 +4894,18 @@ async function run() {
     await runCheckCommand(args);
     return;
   }
+  if (args[0] === "pack") {
+    await runPackCommand(args);
+    return;
+  }
+  if (args[0] === "build") {
+    await runBuildCli(args);
+    return;
+  }
+  if (args[0] === "apply") {
+    await runApplyCommand(args.slice(1));
+    return;
+  }
   if (args[0] === "init") {
     let dir = ".";
     for (let i = 1; i < args.length; i++) {
@@ -2031,7 +4936,7 @@ async function run() {
   }
   await runMigrate(args);
 }
-run().catch((err) => {
+run2().catch((err) => {
   console.error(`\u274C ${err?.message || err}`);
   process.exit(1);
 });