livelocale 0.8.0 → 0.9.0

package/dist/vite/index.cjs

@@ -33,8 +33,8 @@ __export(vite_plugin_exports, {
   liveLocaleVite: () => liveLocaleVite
 });
 module.exports = __toCommonJS(vite_plugin_exports);
-var path5 = __toESM(require("path"), 1);
-var fs4 = __toESM(require("fs"), 1);
+var path9 = __toESM(require("path"), 1);
+var fs5 = __toESM(require("fs"), 1);
 
 // src/server/file-mutator.ts
 var import_fs2 = require("fs");
@@ -560,14 +560,6 @@ var KeyScanner = class {
 };
 
 // src/server/file-mutator.ts
-function assertEnabled(component) {
-  const reason = getDisabledReason();
-  if (reason !== null) {
-    throw new Error(
-      `[livelocale] ${component} can only be executed in development mode (${reason}).`
-    );
-  }
-}
 var FileMutex = class {
   queue = Promise.resolve();
   async acquire(fn) {
@@ -583,7 +575,23 @@ var FileMutex = class {
 };
 var FileMutator = class {
   fileLocks = /* @__PURE__ */ new Map();
-  scanner = new KeyScanner();
+  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
    */
@@ -601,7 +609,7 @@ var FileMutator = class {
    * structural JSON validation, and concurrency serialization.
    */
   async updateLocaleKey(basePath, locale, keyPath, newValue) {
-    assertEnabled("FileMutator");
+    this.assertEnabled();
     if (!isSafeLocaleSegment(locale)) {
       throw new Error(
         `[livelocale] Path traversal attempt detected in locale identifier: "${locale}"`
@@ -704,7 +712,9 @@ var FileMutator = class {
           `[livelocale] Failed to rename temp file to target at ${filePath}. Operation: rename. Original error: ${err.message}`
         );
       }
-      console.log(`[livelocale] Updated key '${keyPath}' in locale '${locale}'`);
+      if (!this.quiet) {
+        console.log(`[livelocale] Updated key '${keyPath}' in locale '${locale}'`);
+      }
     });
   }
   /**
@@ -712,7 +722,7 @@ var FileMutator = class {
    * `*.json` inside the `{locale}/` folder merged under its namespace.
    */
   async readLocale(basePath, locale) {
-    assertEnabled("FileMutator");
+    this.assertEnabled();
     const localePath = path3.resolve(basePath, locale);
     let isDir = false;
     try {
@@ -739,7 +749,7 @@ var FileMutator = class {
    * Lists all locale codes dynamically scanned from the locales directory.
    */
   async listLocales(basePath) {
-    assertEnabled("FileMutator");
+    this.assertEnabled();
     const resolvedBasePath = path3.resolve(basePath);
     const items = await import_fs2.promises.readdir(resolvedBasePath, { withFileTypes: true });
     const localesSet = /* @__PURE__ */ new Set();
@@ -761,7 +771,7 @@ var FileMutator = class {
    * Adds a new locale directory/file based on current repository structure.
    */
   async addLocale(basePath, locale) {
-    assertEnabled("FileMutator");
+    this.assertEnabled();
     if (!isSafeLocaleSegment(locale)) {
       throw new Error(
         `[livelocale] Path traversal attempt detected in locale identifier: "${locale}"`
@@ -817,7 +827,7 @@ var FileMutator = class {
    * Renames an existing locale (directory or file) to a new name.
    */
   async renameLocale(basePath, oldLocale, newLocale) {
-    assertEnabled("FileMutator");
+    this.assertEnabled();
     if (!isSafeLocaleSegment(oldLocale) || !isSafeLocaleSegment(newLocale)) {
       throw new Error("[livelocale] Path traversal attempt detected");
     }
@@ -875,7 +885,7 @@ var FileMutator = class {
    * Deletes an existing locale (directory or file).
    */
   async deleteLocale(basePath, locale) {
-    assertEnabled("FileMutator");
+    this.assertEnabled();
     if (!isSafeLocaleSegment(locale)) {
       throw new Error("[livelocale] Path traversal attempt detected");
     }
@@ -1238,6 +1248,67 @@ function validateMessageSyntax(message) {
   return parseIcu(prepared).error;
 }
 
+// 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;
+}
+
 // src/server/router.ts
 var DEFAULT_ALLOWED_ORIGINS = ["http://localhost:3010", "http://127.0.0.1:3010"];
 var MAX_BODY_BYTES = 1e6;
@@ -1425,53 +1496,18 @@ function createMutationRouter(mutator, options) {
       await mutator.deleteLocale(basePath, locale);
       return json(200, headers, { success: true, locale });
     }
-    if (!isValidLocaleFormat(locale)) {
-      return json(400, headers, {
-        error: "Invalid locale string parameter.",
-        code: "INVALID_LOCALE_FORMAT"
-      });
-    }
-    if (!isValidKeyFormat(key)) {
-      return json(400, headers, {
-        error: "Invalid key path. Must be 1-200 characters containing alphanumeric, dots, underscores, or hyphens.",
-        code: "INVALID_KEY_FORMAT"
-      });
-    }
-    if (!isSafeKeyPath(key)) {
-      return json(400, headers, {
-        error: "Forbidden key path: segments like __proto__, constructor, or prototype are not allowed.",
-        code: "INVALID_KEY_FORMAT"
-      });
-    }
-    if (!isValidValueFormat(value)) {
-      return json(400, headers, {
-        error: "Invalid value. Must be a string less than 10000 characters.",
-        code: "INVALID_VALUE_FORMAT"
+    const verdict = validateWrite(
+      { locale, key, value },
+      { reference: typeof reference === "string" ? reference : null, force: force === true }
+    );
+    if (!verdict.ok) {
+      return json(verdict.status, headers, {
+        error: verdict.error,
+        code: verdict.code,
+        details: verdict.details
       });
     }
-    if (force !== true) {
-      const syntaxError = validateMessageSyntax(value);
-      if (syntaxError) {
-        return json(422, headers, {
-          error: `Message syntax: ${syntaxError}.`,
-          code: "MESSAGE_SYNTAX"
-        });
-      }
-      if (typeof reference === "string") {
-        const comparison = comparePlaceholders(reference, 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 json(422, headers, {
-            error: `Placeholders differ from the reference: ${parts.join("; ")}.`,
-            code: "PLACEHOLDER_MISMATCH",
-            details: { missing: comparison.missing, extra: comparison.extra }
-          });
-        }
-      }
-    }
-    await mutator.updateLocaleKey(basePath, locale, key, value);
+    await mutator.updateLocaleKey(basePath, verdict.locale, verdict.key, verdict.value);
     return json(200, headers, { success: true, key, locale });
   }
   return {
@@ -1545,7 +1581,7 @@ var BodyTooLargeError = class extends Error {
   }
 };
 function readNodeBody(req, maxBytes) {
-  return new Promise((resolve6, reject) => {
+  return new Promise((resolve8, reject2) => {
     let bodyText = "";
     let settled = false;
     req.on("data", (chunk) => {
@@ -1553,19 +1589,19 @@ function readNodeBody(req, maxBytes) {
       bodyText += chunk.toString();
       if (Buffer.byteLength(bodyText, "utf-8") > maxBytes) {
         settled = true;
-        reject(new BodyTooLargeError());
+        reject2(new BodyTooLargeError());
         req.destroy?.();
       }
     });
     req.on("end", () => {
       if (settled) return;
       settled = true;
-      resolve6(bodyText);
+      resolve8(bodyText);
     });
     req.on("error", (err) => {
       if (settled) return;
       settled = true;
-      reject(err);
+      reject2(err);
     });
   });
 }
@@ -1585,6 +1621,591 @@ function deepMerge(target, source) {
   return result;
 }
 
+// src/server/pack.ts
+var import_fs5 = require("fs");
+var path8 = __toESM(require("path"), 1);
+
+// 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
+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 LONE_SURROGATE_RE = /[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:^|[^\uD800-\uDBFF])[\uDC00-\uDFFF]/;
+function hasLoneSurrogate(text) {
+  return typeof text === "string" && LONE_SURROGATE_RE.test(text);
+}
+var MAX_INFLATED_BYTES = 512 * 1024;
+var TOO_LARGE_MESSAGE = `A change link holds at most ${MAX_INFLATED_BYTES / 1024} KB of text. Send the changes in smaller links.`;
+
+// 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;
+
+// src/server/build-info.ts
+var import_child_process2 = require("child_process");
+var import_fs3 = require("fs");
+var path5 = __toESM(require("path"), 1);
+var runGit = (args, cwd) => new Promise((resolve8) => {
+  try {
+    (0, import_child_process2.execFile)(
+      "git",
+      args,
+      { cwd, windowsHide: true, env: { ...process.env, GIT_TERMINAL_PROMPT: "0" } },
+      (error, stdout) => resolve8(error ? null : String(stdout).trim())
+    );
+  } catch {
+    resolve8(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((0, import_fs3.readFileSync)(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 ? path5.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
+var import_fs4 = require("fs");
+var path6 = __toESM(require("path"), 1);
+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*['"`](\/[^'"`]*|\.\/?|)['"`]/;
+function readText(file) {
+  try {
+    return (0, import_fs4.readFileSync)(file, "utf-8");
+  } catch {
+    return null;
+  }
+}
+function readPackageJson(projectDir) {
+  const text = readText(path6.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 firstExisting(projectDir, names) {
+  for (const name of names) {
+    const file = path6.join(projectDir, name);
+    if ((0, import_fs4.existsSync)(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 = firstExisting(projectDir, NEXT_CONFIG_FILES);
+  if (nextConfig || hasDependency(pkg, "next")) {
+    const source = stripComments((nextConfig && readText(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") || firstExisting(projectDir, VITE_CONFIG_FILES)) {
+    const viteConfig = firstExisting(projectDir, VITE_CONFIG_FILES);
+    const source = stripComments((viteConfig && readText(viteConfig)) ?? "");
+    return { kind: "vite", base: VITE_BASE.exec(source)?.[1] ?? null };
+  }
+  return { kind: "other", base: null };
+}
+
+// src/server/module-dir.ts
+var path7 = __toESM(require("path"), 1);
+var import_url = require("url");
+var import_meta = {};
+function moduleDir() {
+  if (typeof __dirname !== "undefined") {
+    return __dirname;
+  }
+  return path7.dirname((0, import_url.fileURLToPath)(import_meta.url));
+}
+
+// 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_OPEN = /<head(?=[\s>])[^>]*>/i;
+var HTML_OPEN = /<html(?=[\s>])[^>]*>/i;
+var DOCTYPE = /<!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_OPEN, HTML_OPEN, DOCTYPE]) {
+    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 isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function toPosix(relative4) {
+  return relative4.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 import_fs5.promises.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 (!isPlainObject(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 import_fs5.promises.stat(localesDir)).isDirectory()) throw new Error("not a directory");
+    entries = await import_fs5.promises.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 import_fs5.promises.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 (0, import_fs5.statSync)(target).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function resolveStudioDir(candidates = defaultStudioCandidates()) {
+  for (const dir of candidates) {
+    if ((0, import_fs5.existsSync)(path8.join(dir, "index.html")) && isDirectory(path8.join(dir, "assets"))) {
+      return dir;
+    }
+  }
+  return null;
+}
+async function ownsShareDir(shareDir) {
+  try {
+    await import_fs5.promises.lstat(shareDir);
+  } catch {
+    return true;
+  }
+  try {
+    const manifest = JSON.parse(
+      await import_fs5.promises.readFile(path8.join(shareDir, SHARE_MANIFEST_FILE), "utf-8")
+    );
+    return isPlainObject(manifest) && typeof manifest["format"] === "number";
+  } catch {
+    return false;
+  }
+}
+async function findHtmlFiles(outDir, shareDir) {
+  const found = [];
+  const walk = async (dir) => {
+    for (const entry of await import_fs5.promises.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 import_fs5.promises.rm(shareDir, { recursive: true, force: true });
+  await import_fs5.promises.cp(studioDir, shareDir, { recursive: true });
+  await import_fs5.promises.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 import_fs5.promises.mkdir(localesDir, { recursive: true });
+  for (const locale of data.manifest.locales) {
+    await import_fs5.promises.writeFile(
+      path8.join(localesDir, `${locale}.json`),
+      JSON.stringify(data.dictionaries[locale]),
+      "utf-8"
+    );
+  }
+  await import_fs5.promises.writeFile(path8.join(shareDir, SHARE_FLAG_FILE), FLAG_SCRIPT, "utf-8");
+  const inject = injectHtml === "auto" ? target.kind !== "next" && !(0, import_fs5.existsSync)(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 import_fs5.promises.readFile(file, "utf-8");
+    const injected = injectFlagScript(html, flagSrcFor(base, rel));
+    if (injected !== html) await import_fs5.promises.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
+  };
+}
+
 // src/server/vite-plugin.ts
 var ROUTE = "/api/livelocale";
 function liveLocaleVite(config) {
@@ -1594,10 +2215,47 @@ function liveLocaleVite(config) {
     git: config.git === false ? void 0 : new GitClient(),
     authToken: config.authToken ?? process.env["LIVELOCALE_TOKEN"]
   });
+  let shareBuild = null;
+  let packed = false;
   return {
     name: "livelocale",
-    // Only active during dev server mode; the plugin is a no-op during builds.
-    apply: "serve",
+    // Always active in dev; in builds only with `share: true`, and never for the SSR build.
+    apply(_userConfig, env) {
+      if (env.command === "serve") return true;
+      return config.share === true && !env.isSsrBuild && !env.ssrBuild;
+    },
+    configResolved(resolved) {
+      shareBuild = null;
+      if (resolved.command !== "build" || config.share !== true) return;
+      if (resolved.build?.ssr || resolved.build?.lib) return;
+      const base = config.shareBase ?? resolved.base;
+      shareBuild = {
+        root: resolved.root,
+        outDir: path9.resolve(resolved.root, resolved.build.outDir),
+        base,
+        appBase: normalizeBase(base),
+        logger: resolved.logger
+      };
+    },
+    buildStart() {
+      packed = false;
+    },
+    async writeBundle() {
+      if (shareBuild === null || packed) return;
+      packed = true;
+      const result = await packOutput({
+        outDir: shareBuild.outDir,
+        projectDir: shareBuild.root,
+        // Resolved against the working directory, as the serve half does.
+        localesPath: path9.resolve(config.localesPath),
+        sourceLocale: config.sourceLocale,
+        exposeRepo: config.exposeRepo ?? false,
+        base: shareBuild.base,
+        // transformIndexHtml already linked flag.js in every HTML file Vite wrote.
+        injectHtml: false
+      });
+      for (const warning of result.warnings) shareBuild.logger.warn(warning);
+    },
     configureServer(server) {
       server.middlewares.use(async (req, res, next) => {
         const url = req.url ?? "";
@@ -1634,7 +2292,11 @@ function liveLocaleVite(config) {
         }
       });
     },
-    transformIndexHtml(html) {
+    transformIndexHtml(html, ctx) {
+      if (shareBuild !== null) {
+        const htmlRelPath = (ctx?.path ?? "/index.html").replace(/^\/+/, "");
+        return injectFlagScript(html, flagSrcFor(shareBuild.appBase, htmlRelPath));
+      }
       const flag = process.env["LIVELOCALE"];
       const flagScript = flag ? `<script>window.${BROWSER_FLAG_GLOBAL} = ${JSON.stringify(flag)};</script>
 ` : "";
@@ -1642,24 +2304,24 @@ function liveLocaleVite(config) {
         return flagScript ? html.replace("</head>", `${flagScript}</head>`) : html;
       }
       try {
-        const resolvedLocalesPath = path5.resolve(config.localesPath);
-        const entries = fs4.readdirSync(resolvedLocalesPath);
+        const resolvedLocalesPath = path9.resolve(config.localesPath);
+        const entries = fs5.readdirSync(resolvedLocalesPath);
         let fallbackData = {};
         for (const entry of entries) {
           if (entry.startsWith(".")) continue;
-          const entryPath = path5.join(resolvedLocalesPath, entry);
+          const entryPath = path9.join(resolvedLocalesPath, entry);
           let entryIsDir = false;
           try {
-            entryIsDir = fs4.statSync(entryPath).isDirectory();
+            entryIsDir = fs5.statSync(entryPath).isDirectory();
           } catch {
           }
           if (entryIsDir) {
             try {
-              const files = fs4.readdirSync(entryPath);
+              const files = fs5.readdirSync(entryPath);
               for (const file of files) {
                 if (file.endsWith(".json")) {
                   const ns = file.slice(0, -5);
-                  const raw = fs4.readFileSync(path5.join(entryPath, file), "utf-8");
+                  const raw = fs5.readFileSync(path9.join(entryPath, file), "utf-8");
                   try {
                     const parsed = JSON.parse(raw);
                     fallbackData[ns] = deepMerge(fallbackData[ns] || {}, parsed);
@@ -1670,7 +2332,7 @@ function liveLocaleVite(config) {
             } catch {
             }
           } else if (entry.endsWith(".json")) {
-            const raw = fs4.readFileSync(entryPath, "utf-8");
+            const raw = fs5.readFileSync(entryPath, "utf-8");
             try {
               const parsed = JSON.parse(raw);
               fallbackData = deepMerge(fallbackData, parsed);