livelocale 0.9.0 → 0.10.0

package/dist/codemod/index.js

@@ -292,11 +292,12 @@ var init_transform = __esm({
 });
 
 // src/codemod/index.ts
-import * as fs10 from "fs";
-import * as path15 from "path";
+import * as fs12 from "fs";
+import * as path18 from "path";
 import * as net from "net";
 
 // src/server/module-dir.ts
+import { readFileSync } from "fs";
 import * as path from "path";
 import { fileURLToPath } from "url";
 function moduleDir() {
@@ -305,6 +306,15 @@ function moduleDir() {
   }
   return path.dirname(fileURLToPath(import.meta.url));
 }
+function readOwnVersion() {
+  const file = path.resolve(moduleDir(), "../../package.json");
+  const pkg = JSON.parse(readFileSync(file, "utf-8"));
+  const version = pkg?.version;
+  if (typeof version !== "string" || version === "") {
+    throw new Error(`No version in ${file}.`);
+  }
+  return version;
+}
 
 // src/codemod/studio-server.ts
 import * as fs from "fs";
@@ -729,7 +739,7 @@ function isShareManifest(value) {
   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);
+  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"), (path19) => path19.startsWith("/") && path19.endsWith("/")) && isArrayOf(own2(value, "codeKeys"), isString);
 }
 
 // src/codemod/doctor.ts
@@ -2233,23 +2243,23 @@ function formatCheckReport(report, limit = 25) {
 
 // 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 { existsSync as existsSync5, readFileSync as readFileSync6, statSync as statSync4, promises as fs5 } from "fs";
 import * as path8 from "path";
 
 // src/server/build-info.ts
 import { execFile } from "child_process";
-import { readFileSync as readFileSync3 } from "fs";
+import { readFileSync as readFileSync4 } from "fs";
 import * as path6 from "path";
-var runGit = (args, cwd) => new Promise((resolve14) => {
+var runGit = (args, cwd) => new Promise((resolve16) => {
   try {
     execFile(
       "git",
       args,
       { cwd, windowsHide: true, env: { ...process.env, GIT_TERMINAL_PROMPT: "0" } },
-      (error, stdout) => resolve14(error ? null : String(stdout).trim())
+      (error, stdout) => resolve16(error ? null : String(stdout).trim())
     );
   } catch {
-    resolve14(null);
+    resolve16(null);
   }
 });
 var SHA_RE = /^[0-9a-f]{40}([0-9a-f]{24})?$/i;
@@ -2268,7 +2278,7 @@ var asSlug = (value) => isValidRepoSlug(value) ? value : null;
 function readEvent(eventPath) {
   if (!eventPath) return {};
   try {
-    const parsed = JSON.parse(readFileSync3(eventPath, "utf-8"));
+    const parsed = JSON.parse(readFileSync4(eventPath, "utf-8"));
     return isRecord(parsed) ? parsed : {};
   } catch {
     return {};
@@ -2367,7 +2377,7 @@ function parseGitHubSlug(remote) {
 }
 
 // src/server/build-target.ts
-import { existsSync as existsSync4, readFileSync as readFileSync4 } from "fs";
+import { existsSync as existsSync4, readFileSync as readFileSync5 } from "fs";
 import * as path7 from "path";
 var NEXT_CONFIG_FILES = [
   "next.config.js",
@@ -2389,7 +2399,7 @@ 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");
+    return readFileSync5(file, "utf-8");
   } catch {
     return null;
   }
@@ -2541,8 +2551,8 @@ var NO_REPO_WARNING = "exposeRepo is on but no GitHub repository was found; the
 function isPlainObject2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function toPosix(relative8) {
-  return relative8.split(path8.sep).join("/") || ".";
+function toPosix(relative9) {
+  return relative9.split(path8.sep).join("/") || ".";
 }
 function isInside(parent, child) {
   const rel = path8.relative(parent, child);
@@ -2841,7 +2851,7 @@ function quoteWindowsArg(arg) {
   }
   return out + "\\".repeat(backslashes * 2) + '"';
 }
-var spawnInherit = (command, args, { cwd, env }) => new Promise((resolve14, reject2) => {
+var spawnInherit = (command, args, { cwd, env }) => new Promise((resolve16, reject2) => {
   const child = process.platform === "win32" ? spawn([command, ...args].map(quoteWindowsArg).join(" "), {
     cwd,
     env,
@@ -2849,10 +2859,10 @@ var spawnInherit = (command, args, { cwd, env }) => new Promise((resolve14, reje
     shell: true
   }) : spawn(command, args, { cwd, env, stdio: "inherit" });
   child.on("error", (error) => {
-    if (error.code === "ENOENT") resolve14(127);
+    if (error.code === "ENOENT") resolve16(127);
     else reject2(error);
   });
-  child.on("close", (code) => resolve14(code ?? 1));
+  child.on("close", (code) => resolve16(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.";
@@ -2861,7 +2871,7 @@ var FRESH_SLACK_MS = 2e3;
 function gitignoresShareDir(projectDir) {
   let content;
   try {
-    content = readFileSync5(path8.join(projectDir, ".gitignore"), "utf-8");
+    content = readFileSync6(path8.join(projectDir, ".gitignore"), "utf-8");
   } catch {
     return false;
   }
@@ -2929,122 +2939,12 @@ async function runBuildCommand(options) {
 }
 
 // src/codemod/apply/cli.ts
-import * as path14 from "path";
+import * as path16 from "path";
 
-// src/codemod/apply/link-input.ts
-import { execFile as execFile2 } from "child_process";
+// src/codemod/apply/github-event.ts
 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;
-};
+import * as path10 from "path";
 
 // src/client/watermark.ts
 var WATERMARK_RE = /\u200C(?:[\u200B\u200D]{8})+\u200C/g;
@@ -3112,6 +3012,11 @@ function detectJsonIndent(content) {
   const ws = match[1];
   return ws.includes("	") ? "	" : ws;
 }
+function stringifyLike(data, content) {
+  const indent = content === null ? "  " : detectJsonIndent(content);
+  const trailing = content === null || content.endsWith("\n") ? "\n" : "";
+  return JSON.stringify(data, null, indent) + trailing;
+}
 
 // src/core/save-rules.ts
 var reject = (status, code, error) => ({
@@ -3317,113 +3222,1064 @@ function planApply(input) {
   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");
+// 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_MESSAGE2 = `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_MESSAGE2);
+    }
+    throw new ChangeLinkError("CORRUPT", CORRUPT_MESSAGE2);
   }
-  const resolvedBasePath = path10.resolve(basePath);
-  const filePath = path10.resolve(resolvedBasePath, `${locale}.json`);
-  if (!filePath.startsWith(resolvedBasePath)) {
-    throw new Error("Path traversal attempt");
+  if (result.engine.bytesWritten !== bytes.length) {
+    throw new ChangeLinkError("CORRUPT", CORRUPT_MESSAGE2);
   }
-  return filePath;
-}
+  return result.buffer;
+};
 
-// 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;
+// src/server/github-rest.ts
+var GitHubApiError = class extends Error {
+  constructor(message, status) {
+    super(message);
+    this.status = status;
+    this.name = "GitHubApiError";
   }
+  status;
 };
-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}).`
-      );
-    }
+var CHUNK_BYTES = 32768;
+function encodeBase64Utf8(text) {
+  const bytes = new TextEncoder().encode(text);
+  let binary = "";
+  for (let i = 0; i < bytes.length; i += CHUNK_BYTES) {
+    binary += String.fromCharCode(...bytes.subarray(i, i + CHUNK_BYTES));
   }
-  /**
-   * 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 btoa(binary);
+}
+function decodeBase64Utf8(base64) {
+  const binary = atob(base64.replace(/\s/g, ""));
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+  return new TextDecoder().decode(bytes);
+}
+function isPullRequestCreationForbidden(err) {
+  return err instanceof GitHubApiError && err.status === 403 && /not permitted to create or approve pull requests/i.test(err.message);
+}
+function encodeRefPath(ref) {
+  return ref.split("/").map(encodeURIComponent).join("/");
+}
+function createGitHubRest(config) {
+  const repo = config.repo;
+  const apiBase = (config.apiBase ?? "https://api.github.com").replace(/\/+$/, "");
+  const fetchImpl = config.fetchImpl ?? globalThis.fetch;
+  const owner = repo.split("/")[0] ?? "";
+  if (!/^[\w.-]+\/[\w.-]+$/.test(repo)) {
+    throw new Error(`[livelocale] github.repo must be "owner/name", got "${repo}".`);
+  }
+  if (typeof fetchImpl !== "function") {
+    throw new Error("[livelocale] The GitHub gateway needs a global fetch (Node 18+).");
+  }
+  const headers = (hasBody) => ({
+    Authorization: `Bearer ${config.token}`,
+    Accept: "application/vnd.github+json",
+    "X-GitHub-Api-Version": "2022-11-28",
+    ...hasBody ? { "Content-Type": "application/json" } : {}
+  });
+  async function api(method, path19, options = {}) {
+    const url = new URL(`${apiBase}/repos/${repo}${path19}`);
+    for (const [k, v] of Object.entries(options.query ?? {})) url.searchParams.set(k, v);
+    const response = await fetchImpl(url.toString(), {
+      method,
+      headers: headers(options.body !== void 0),
+      body: options.body !== void 0 ? JSON.stringify(options.body) : void 0
+    });
+    let data = null;
+    try {
+      data = await response.json();
+    } catch {
     }
-    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}"`
+    if (response.status === 404 && options.allow404) return { status: 404, data: null };
+    if (!response.ok) {
+      const detail = data?.message || "request failed";
+      const hint = /not accessible by/i.test(detail) ? ' The token lacks a permission: give it "Contents" and "Pull requests" with "Read and write" on this repository.' : "";
+      throw new GitHubApiError(
+        `GitHub API ${response.status} on ${method} ${path19}: ${detail}.${hint}`,
+        response.status
       );
     }
-    const resolvedBasePath = path11.resolve(basePath);
-    const localeDir = path11.resolve(resolvedBasePath, locale);
-    let filePath = "";
-    let mutationKeyPath = keyPath;
-    let isNamespaceDir = false;
+    return { status: response.status, data };
+  }
+  async function probeStatus(method, path19, body) {
+    const response = await fetchImpl(`${apiBase}/repos/${repo}${path19}`, {
+      method,
+      headers: headers(body !== void 0),
+      body: body !== void 0 ? JSON.stringify(body) : void 0
+    });
     try {
-      const stats = await fs7.stat(localeDir);
-      if (stats.isDirectory()) {
-        isNamespaceDir = true;
-      }
+      await response.arrayBuffer();
     } 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 = "";
+    return response.status;
+  }
+  async function refSha(branch) {
+    const res = await api(
+      "GET",
+      `/git/ref/heads/${encodeRefPath(branch)}`,
+      { allow404: true }
+    );
+    return res.data?.object?.sha ?? null;
+  }
+  async function findOpenPullRequest(head, base) {
+    const res = await api("GET", "/pulls", {
+      query: { head: `${owner}:${head}`, base, state: "open" }
+    });
+    const pull = res.data?.[0];
+    return pull ? { number: pull.number, url: pull.html_url } : null;
+  }
+  async function openOrReusePullRequest(input) {
+    const existing = await findOpenPullRequest(input.head, input.base);
+    if (existing) {
+      if (input.updateBodyIfReused) {
+        await api("PATCH", `/pulls/${existing.number}`, { body: { body: input.body } });
       }
-    } else {
-      filePath = path11.resolve(resolvedBasePath, `${locale}.json`);
+      return { ...existing, reused: true };
     }
-    if (!filePath.startsWith(resolvedBasePath)) {
+    const res = await api("POST", "/pulls", {
+      body: { title: input.title, head: input.head, base: input.base, body: input.body }
+    });
+    return { number: res.data.number, url: res.data.html_url, reused: false };
+  }
+  return { repo, api, probeStatus, refSha, findOpenPullRequest, openOrReusePullRequest };
+}
+
+// src/codemod/apply/github-commit.ts
+import * as path9 from "path";
+var BRANCH_PREFIX = "livelocale/";
+function normalizeRepoDir(p) {
+  const posix2 = p.replace(/\\/g, "/");
+  if (posix2.startsWith("/") || /^[A-Za-z]:/.test(posix2)) {
+    throw new Error(`[livelocale] The locales path must be relative to the repository: "${p}".`);
+  }
+  const segments = posix2.split("/").filter((s) => s !== "" && s !== ".");
+  if (segments.includes("..")) {
+    throw new Error(`[livelocale] The locales path must stay inside the repository: "${p}".`);
+  }
+  return segments.join("/");
+}
+function joinRepoPath(dir, rest) {
+  return dir === "" ? rest : `${dir}/${rest}`;
+}
+function localeFileFor(localesDir, layout, locale, key) {
+  const dir = normalizeRepoDir(localesDir);
+  if (layout === "flat") return { file: joinRepoPath(dir, `${locale}.json`), innerKey: key };
+  const dot = key.indexOf(".");
+  if (dot <= 0 || dot === key.length - 1) {
+    throw new Error(`[livelocale] "${key}" names no key inside a namespace file.`);
+  }
+  return {
+    file: joinRepoPath(dir, `${locale}/${key.slice(0, dot)}.json`),
+    innerKey: key.slice(dot + 1)
+  };
+}
+function isPlainObject4(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function applyEditsToText(text, edits) {
+  const data = JSON.parse(text);
+  if (!isPlainObject4(data)) throw new Error("[livelocale] A locale file is not a JSON object.");
+  for (const edit of edits) setNestedProperty(data, edit.innerKey, edit.value);
+  return stringifyLike(data, text);
+}
+async function listDir(rest, dir, ref) {
+  const res = await rest.api("GET", `/contents/${encodeRefPath(dir)}`, {
+    query: { ref },
+    allow404: true
+  });
+  return Array.isArray(res.data) ? res.data : null;
+}
+async function readBlob(rest, sha) {
+  const res = await rest.api(
+    "GET",
+    `/git/blobs/${encodeURIComponent(sha)}`
+  );
+  return decodeBase64Utf8(res.data?.content ?? "");
+}
+function parseLocaleFile(text, file) {
+  let data;
+  try {
+    data = JSON.parse(text);
+  } catch {
+    throw new Error(`[livelocale] ${file} is not valid JSON.`);
+  }
+  if (!isPlainObject4(data)) throw new Error(`[livelocale] ${file} is not a JSON object.`);
+  return data;
+}
+async function readRemoteLocales(rest, commitSha, localesDir, locales) {
+  const dir = normalizeRepoDir(localesDir);
+  const entries = await listDir(rest, dir, commitSha);
+  if (entries === null) {
+    throw new Error(`[livelocale] No locales folder at ${dir || "."} on the target.`);
+  }
+  const targets = /* @__PURE__ */ new Map();
+  const files = /* @__PURE__ */ new Map();
+  for (const locale of locales) {
+    if (targets.has(locale)) continue;
+    const flat = entries.find((e) => e.type === "file" && e.name === `${locale}.json`);
+    const folder = entries.find((e) => e.type === "dir" && e.name === locale);
+    if (!isValidLocaleFormat(locale) || !flat && !folder) {
+      targets.set(locale, null);
+      continue;
+    }
+    if (flat) {
+      const file = joinRepoPath(dir, flat.name);
+      const text = await readBlob(rest, flat.sha);
+      files.set(file, text);
+      targets.set(locale, { layout: "flat", dict: parseLocaleFile(text, file) });
+      continue;
+    }
+    const dict = {};
+    for (const entry of await listDir(rest, joinRepoPath(dir, locale), commitSha) ?? []) {
+      if (entry.type !== "file" || !entry.name.endsWith(".json")) continue;
+      const file = joinRepoPath(dir, `${locale}/${entry.name}`);
+      const text = await readBlob(rest, entry.sha);
+      files.set(file, text);
+      dict[entry.name.slice(0, -".json".length)] = parseLocaleFile(text, file);
+    }
+    targets.set(locale, { layout: "namespaced", dict });
+  }
+  return { sha: commitSha, targets, files };
+}
+function buildFileChanges(localesDir, plan, remote, baseFiles) {
+  const dir = normalizeRepoDir(localesDir);
+  const prefix = dir === "" ? "" : `${dir}/`;
+  const byFile = /* @__PURE__ */ new Map();
+  for (const edit of plan.edits) {
+    if (edit.status !== "apply") continue;
+    const layout = remote.targets.get(edit.locale)?.layout ?? "flat";
+    const { file, innerKey } = localeFileFor(dir, layout, edit.locale, edit.key);
+    const normalized = path9.posix.normalize(file);
+    if (normalized !== file || normalized.startsWith("../") || normalized.startsWith("/") || !normalized.startsWith(prefix)) {
       throw new Error(
-        `[livelocale] Path traversal attempt: Resolved file path must start with basePath.`
+        `[livelocale] Refusing to write ${file}: it is outside the locales folder ${dir || "."}.`
+      );
+    }
+    const list = byFile.get(file) ?? [];
+    list.push({ innerKey, value: edit.to });
+    byFile.set(file, list);
+  }
+  const changes = /* @__PURE__ */ new Map();
+  for (const [file, edits] of byFile) {
+    const text = baseFiles?.get(file) ?? remote.files.get(file);
+    if (text === void 0) {
+      throw new Error(`[livelocale] ${file} was not read from the target.`);
+    }
+    const next = applyEditsToText(text, edits);
+    if (next !== text) changes.set(file, next);
+  }
+  return changes;
+}
+async function prepareBranch(rest, baseName, base, targetSha, runId) {
+  const head = await rest.refSha(baseName);
+  if (head === null) return { branch: baseName, parentSha: targetSha, mode: "new" };
+  if (await rest.findOpenPullRequest(baseName, base)) {
+    return { branch: baseName, parentSha: head, mode: "append" };
+  }
+  return { branch: `${baseName}-${runId}`, parentSha: targetSha, mode: "new" };
+}
+async function commitFiles(rest, input) {
+  const { branch, parentSha, mode } = input.branchPlan;
+  if (!branch.startsWith(BRANCH_PREFIX)) {
+    throw new Error(`[livelocale] Refusing to write "${branch}": only ${BRANCH_PREFIX}* branches.`);
+  }
+  if (input.files.size === 0) return { sha: null, unchanged: true };
+  const parent = await rest.api(
+    "GET",
+    `/git/commits/${encodeURIComponent(parentSha)}`
+  );
+  const baseTree = parent.data.tree.sha;
+  const entries = [];
+  for (const [file, text] of input.files) {
+    const blob = await rest.api("POST", "/git/blobs", {
+      body: { content: encodeBase64Utf8(text), encoding: "base64" }
+    });
+    entries.push({ path: file, mode: "100644", type: "blob", sha: blob.data.sha });
+  }
+  const tree = await rest.api("POST", "/git/trees", {
+    body: { base_tree: baseTree, tree: entries }
+  });
+  const treeSha = tree.data.sha;
+  if (treeSha === baseTree) return { sha: null, unchanged: true };
+  const commit = await rest.api("POST", "/git/commits", {
+    body: { message: input.message, tree: treeSha, parents: [parentSha], author: input.author }
+  });
+  const sha = commit.data.sha;
+  if (mode === "new") {
+    await rest.api("POST", "/git/refs", { body: { ref: `refs/heads/${branch}`, sha } });
+  } else {
+    await rest.api("PATCH", `/git/refs/heads/${encodeRefPath(branch)}`, {
+      body: { sha, force: false }
+    });
+  }
+  return { sha };
+}
+function noreplyAuthor(actor) {
+  return { name: actor.login, email: `${actor.id}+${actor.login}@users.noreply.github.com` };
+}
+
+// src/codemod/apply/github-trigger.ts
+var APPLY_COMMAND_RE = /^\/livelocale\s+apply(\s+--force)?\s*$/;
+var COMMAND_PREFIX = "/livelocale";
+var ISSUE_BRANCH_RE = /^livelocale\/issue-(\d+)(?:-\d+)?$/;
+var TRUSTED_ASSOCIATIONS = /* @__PURE__ */ new Set(["OWNER", "MEMBER", "COLLABORATOR"]);
+var TRUSTED_PERMISSIONS = /* @__PURE__ */ new Set(["admin", "write"]);
+var TRUSTED_ROLES = /* @__PURE__ */ new Set(["admin", "maintain", "write"]);
+var ignore = (reason) => ({ kind: "ignore", reason });
+function actorOf(user) {
+  return { login: String(user?.login ?? ""), id: Number(user?.id ?? 0) };
+}
+function textOf(value) {
+  return typeof value === "string" ? value : "";
+}
+function holdsChangeToken(text) {
+  try {
+    findChangeToken(text);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function parseTrigger(eventName, event) {
+  const repo = textOf(event?.repository?.full_name);
+  const defaultBranch = textOf(event?.repository?.default_branch);
+  switch (eventName) {
+    case "issues": {
+      if (event?.action !== "opened") return ignore("issue not opened");
+      const issue = event.issue;
+      const body = textOf(issue?.body);
+      if (!body.includes(CHANGE_BLOCK_OPEN)) return ignore("no change block");
+      return {
+        kind: "apply",
+        via: "issue",
+        issueNumber: Number(issue.number),
+        actor: actorOf(issue.user),
+        association: issue.author_association ?? null,
+        text: body,
+        force: false,
+        repo,
+        defaultBranch
+      };
+    }
+    case "issue_comment": {
+      if (event?.action !== "created") return ignore("comment not created");
+      const issue = event.issue;
+      const comment = event.comment;
+      if (issue?.pull_request) return ignore("comment on a pull request");
+      if (comment?.user?.type === "Bot") return ignore("comment by a bot");
+      const body = textOf(comment?.body);
+      const firstLine = body.split(/\r\n|\r|\n/)[0] ?? "";
+      if (!firstLine.startsWith(COMMAND_PREFIX)) return ignore("not a livelocale command");
+      const command = APPLY_COMMAND_RE.exec(firstLine);
+      if (!command) return ignore("unknown command");
+      return {
+        kind: "apply",
+        via: "comment",
+        issueNumber: Number(issue.number),
+        // The gate checks the commenter, never the issue author.
+        actor: actorOf(comment.user),
+        association: comment.author_association ?? null,
+        text: holdsChangeToken(body) ? body : textOf(issue?.body),
+        force: command[1] !== void 0,
+        repo,
+        defaultBranch
+      };
+    }
+    case "workflow_dispatch":
+      return {
+        kind: "apply",
+        via: "dispatch",
+        issueNumber: null,
+        actor: actorOf(event?.sender),
+        association: null,
+        text: textOf(event?.inputs?.link),
+        force: false,
+        repo,
+        defaultBranch
+      };
+    case "pull_request": {
+      if (event?.action !== "closed") return ignore("pull request not closed");
+      const pull = event.pull_request;
+      const branch = ISSUE_BRANCH_RE.exec(textOf(pull?.head?.ref));
+      if (!branch) return ignore("not a livelocale issue branch");
+      if (textOf(pull?.head?.repo?.full_name) !== repo || repo === "") {
+        return ignore("pull request from another repository");
+      }
+      return {
+        kind: "close-issue",
+        issueNumber: Number(branch[1]),
+        prUrl: textOf(pull.html_url),
+        merged: pull.merged === true,
+        repo
+      };
+    }
+    default:
+      return ignore(`unsupported event ${eventName}`);
+  }
+}
+async function isTrustedActor(rest, login, association) {
+  if (association !== null && TRUSTED_ASSOCIATIONS.has(association)) return true;
+  try {
+    const res = await rest.api(
+      "GET",
+      `/collaborators/${encodeURIComponent(login)}/permission`
+    );
+    const permission = res.data?.permission ?? "";
+    const role = res.data?.role_name ?? "";
+    return TRUSTED_PERMISSIONS.has(permission) || TRUSTED_ROLES.has(role);
+  } catch (err) {
+    if (err instanceof GitHubApiError && (err.status === 403 || err.status === 404)) return false;
+    throw err;
+  }
+}
+function chooseTargetBranch(requested, allowList, defaultBranch) {
+  if (!requested) return { branch: defaultBranch, reason: "default" };
+  const allowed = allowList.length > 0 ? allowList : [defaultBranch];
+  if (allowed.includes(requested)) return { branch: requested, reason: "link" };
+  return { branch: defaultBranch, reason: "not-allowed" };
+}
+function branchBaseName(t, runId) {
+  return t.issueNumber !== null ? `livelocale/issue-${t.issueNumber}` : `livelocale/run-${runId}`;
+}
+
+// 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 targetNote(target) {
+  if (target?.reason !== "not-allowed" || target.requested === void 0) return void 0;
+  return `The link was made from ${codeSpan(target.requested)}, which is not in the allowed branches, so this targets ${codeSpan(target.branch)}.`;
+}
+function creditLines(ctx, withTarget) {
+  const lines = [];
+  if (ctx.by?.trim()) lines.push(`Translated by ${codeSpan(ctx.by)}`);
+  const target = withTarget ? targetNote(ctx.target) : void 0;
+  if (target) lines.push(target);
+  if (ctx.note?.trim()) lines.push(fencedNote(ctx.note));
+  return lines;
+}
+function renderPullRequestBody(ctx) {
+  const head = [
+    "Applies translations sent with a LiveLocale change link.",
+    ...creditLines(ctx, true)
+  ];
+  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");
+}
+var MAX_ERROR_MESSAGE_CHARS = 2e3;
+function needsForceHint(plan) {
+  const n = plan?.counts["needs-force"] ?? 0;
+  if (n === 0) return void 0;
+  return `${n} change(s) were saved with "Save anyway". A maintainer can apply them with \`/livelocale apply --force\`.`;
+}
+function withTable(head, plan, tail) {
+  if (!plan) return [...head, ...tail].join("\n\n");
+  const fixed = [...head, ...tail].join("\n\n").length;
+  const table = renderTable(plan, DEFAULT_TABLE_ROWS, MAX_BODY_CHARS - BODY_MARGIN - fixed);
+  return [...head, table, ...tail].join("\n\n");
+}
+function checkTail(checkSummary) {
+  return checkSummary ? [cutLines(checkSummary, MAX_CHECK_SUMMARY_CHARS)] : [];
+}
+function renderIssueComment(ctx) {
+  const { outcome } = ctx;
+  switch (outcome.kind) {
+    case "waiting-for-maintainer":
+      return "Waiting for a maintainer: comment `/livelocale apply`";
+    case "wrong-repo":
+      return `This change link was made for ${codeSpan(outcome.linkRepo)}, not ${codeSpan(outcome.repo)}. Nothing was applied.`;
+    case "error": {
+      const message = cut(outcome.message, MAX_ERROR_MESSAGE_CHARS).replace(/\.$/, "");
+      const runLog = ctx.runUrl ? ` Run log: ${ctx.runUrl}` : "";
+      return `LiveLocale could not apply this link: ${message}.${runLog}`;
+    }
+    case "nothing-to-apply": {
+      const hint = needsForceHint(ctx.plan);
+      return withTable(
+        ["Nothing to apply.", ...creditLines(ctx, false)],
+        ctx.plan,
+        hint ? [hint] : []
+      );
+    }
+    case "pr": {
+      const headline = `${outcome.reused ? "Updated pull request" : "Pull request"}: ${outcome.url}`;
+      return withTable(
+        [headline, ...creditLines(ctx, true)],
+        ctx.plan,
+        checkTail(ctx.checkSummary)
+      );
+    }
+    case "compare": {
+      const headline = [
+        `This repository does not let GitHub Actions open pull requests, so the branch ${codeSpan(outcome.branch)} was pushed instead. Create the pull request with one click: ${outcome.url}`,
+        '(Or allow it once: Settings \u2192 Actions \u2192 General \u2192 "Allow GitHub Actions to create and approve pull requests".)'
+      ];
+      return withTable(
+        [...headline, ...creditLines(ctx, true)],
+        ctx.plan,
+        checkTail(ctx.checkSummary)
+      );
+    }
+  }
+}
+
+// src/codemod/apply/github-event.ts
+var PR_TITLE = "i18n: LiveLocale changes";
+var NOT_FOUND_MESSAGE = "No LiveLocale change link (lc1.\u2026) found.";
+var ExpectedFailure = class extends Error {
+};
+function errorMessage(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function required(env, name) {
+  const value = env[name];
+  if (!value) throw new Error(`[livelocale] ${name} is not set; run this inside GitHub Actions.`);
+  return value;
+}
+async function closeIssue(rest, trigger, log) {
+  const n = trigger.issueNumber;
+  const issue = await rest.api("GET", `/issues/${n}`, {
+    allow404: true
+  });
+  const body = typeof issue.data?.body === "string" ? issue.data.body : "";
+  if (issue.data?.state !== "open" || !body.includes(CHANGE_BLOCK_OPEN)) {
+    log(`Issue #${n} is not an open LiveLocale issue; nothing to close.`);
+    return "ignored";
+  }
+  await rest.api("PATCH", `/issues/${n}`, {
+    body: { state: "closed", state_reason: trigger.merged ? "completed" : "not_planned" }
+  });
+  await rest.api("POST", `/issues/${n}/comments`, {
+    body: { body: `Closed because ${trigger.prUrl} was ${trigger.merged ? "merged" : "closed"}.` }
+  });
+  log(`Closed issue #${n}.`);
+  return "closed-issue";
+}
+async function checkChanges(options, workspace, remote, changes, plan) {
+  const dir = normalizeRepoDir(options.localesPath);
+  const prefix = dir === "" ? "" : `${dir}/`;
+  const tmp = fs6.mkdtempSync(path10.join(os.tmpdir(), "livelocale-check-"));
+  try {
+    for (const [file, text] of new Map([...remote.files, ...changes])) {
+      const target = path10.join(tmp, ...file.slice(prefix.length).split("/"));
+      fs6.mkdirSync(path10.dirname(target), { recursive: true });
+      fs6.writeFileSync(target, text, "utf-8");
+    }
+    const report = await runCheck({
+      projectDir: path10.join(workspace, options.dir ?? "."),
+      localesPath: tmp,
+      sourceLocale: options.sourceLocale,
+      unused: false
+    });
+    const edited = plan.edits.filter((edit) => edit.status === "apply").map((edit) => [edit.locale, edit.key]);
+    return summarizeCheck(report, edited);
+  } catch (err) {
+    return `Check could not run: ${errorMessage(err)}`;
+  } finally {
+    fs6.rmSync(tmp, { recursive: true, force: true });
+  }
+}
+async function runGitHubEventApply(options) {
+  const { env } = options;
+  const log = options.log ?? ((line) => console.log(line));
+  const token = required(env, "GITHUB_TOKEN");
+  const eventPath = required(env, "GITHUB_EVENT_PATH");
+  const event = JSON.parse(fs6.readFileSync(eventPath, "utf-8"));
+  const trigger = parseTrigger(env.GITHUB_EVENT_NAME ?? "", event);
+  if (trigger.kind === "ignore") {
+    log(`Nothing to do: ${trigger.reason}.`);
+    return "ignored";
+  }
+  const repo = env.GITHUB_REPOSITORY || trigger.repo;
+  const rest = createGitHubRest({
+    repo,
+    token,
+    apiBase: env.GITHUB_API_URL || void 0,
+    fetchImpl: options.fetchImpl
+  });
+  if (trigger.kind === "close-issue") return closeIssue(rest, trigger, log);
+  const server = (env.GITHUB_SERVER_URL || "https://github.com").replace(/\/+$/, "");
+  const runId = env.GITHUB_RUN_ID ?? "0";
+  const runUrl = `${server}/${repo}/actions/runs/${runId}`;
+  const issueNumber = trigger.issueNumber ?? void 0;
+  const report = async (outcome, ctx = {}) => {
+    const text = renderIssueComment({ ...ctx, runUrl, outcome });
+    if (issueNumber !== void 0) {
+      await rest.api("POST", `/issues/${issueNumber}/comments`, { body: { body: text } });
+    } else if (env.GITHUB_STEP_SUMMARY) {
+      fs6.appendFileSync(env.GITHUB_STEP_SUMMARY, `${text}
+`, "utf-8");
+    }
+    log(`Result: ${outcome.kind}`);
+    return outcome.kind;
+  };
+  if (trigger.via !== "dispatch") {
+    if (!await isTrustedActor(rest, trigger.actor.login, trigger.association)) {
+      return report({ kind: "waiting-for-maintainer" });
+    }
+  }
+  try {
+    return await applyLink(options, rest, trigger, { repo, runId, runUrl, server, log, report });
+  } catch (err) {
+    if (err instanceof ExpectedFailure) return report({ kind: "error", message: err.message });
+    await report({ kind: "error", message: errorMessage(err) });
+    throw err;
+  }
+}
+async function applyLink(options, rest, trigger, run3) {
+  const { repo, runId, runUrl, log, report } = run3;
+  const issueNumber = trigger.issueNumber ?? void 0;
+  let set;
+  try {
+    set = await decodeChangeLink(trigger.text, nodeInflate);
+  } catch (err) {
+    if (!(err instanceof ChangeLinkError)) throw err;
+    throw new ExpectedFailure(err.code === "NOT_FOUND" ? NOT_FOUND_MESSAGE : err.message);
+  }
+  if (set.repo !== void 0 && set.repo.toLowerCase() !== repo.toLowerCase()) {
+    return report({ kind: "wrong-repo", linkRepo: set.repo, repo });
+  }
+  const defaultBranch = trigger.defaultBranch;
+  const chosen = chooseTargetBranch(set.branch, options.branches ?? [defaultBranch], defaultBranch);
+  const target = {
+    branch: chosen.branch,
+    isDefault: chosen.branch === defaultBranch,
+    ...set.branch ? { requested: set.branch } : {},
+    reason: chosen.reason
+  };
+  const targetSha = await rest.refSha(target.branch);
+  if (targetSha === null) {
+    throw new Error(`[livelocale] The target branch ${target.branch} does not exist.`);
+  }
+  const locales = [.../* @__PURE__ */ new Set([...set.edits.map((e) => e.locale), options.sourceLocale])];
+  const remote = await readRemoteLocales(rest, targetSha, options.localesPath, locales);
+  if (!remote.targets.get(options.sourceLocale)) {
+    throw new ExpectedFailure(
+      `Source locale \`${options.sourceLocale}\` has no locale file on \`${target.branch}\`.`
+    );
+  }
+  const plan = planApply({
+    edits: set.edits,
+    sourceLocale: options.sourceLocale,
+    targets: remote.targets,
+    allowForce: trigger.force
+  });
+  log(renderTerminalSummary(plan));
+  const credits = { plan, by: set.by, note: set.note, target };
+  if (plan.counts.apply === 0) return report({ kind: "nothing-to-apply" }, credits);
+  const branchPlan = await prepareBranch(
+    rest,
+    branchBaseName(trigger, runId),
+    target.branch,
+    targetSha,
+    runId
+  );
+  const base = branchPlan.mode === "append" ? await readRemoteLocales(rest, branchPlan.parentSha, options.localesPath, locales) : remote;
+  const changes = buildFileChanges(options.localesPath, plan, remote, base.files);
+  const commit = await commitFiles(rest, {
+    branchPlan,
+    files: changes,
+    message: renderCommitMessage({ plan, by: set.by, issueNumber, runId }),
+    author: noreplyAuthor(trigger.actor)
+  });
+  log(
+    commit.sha === null ? `${branchPlan.branch} already holds these changes.` : `Committed to ${branchPlan.branch}.`
+  );
+  const workspace = options.env.GITHUB_WORKSPACE || process.cwd();
+  const checkSummary = await checkChanges(options, workspace, base, changes, plan);
+  const title = issueNumber !== void 0 ? `${PR_TITLE} (#${issueNumber})` : `${PR_TITLE} (run ${runId})`;
+  const body = renderPullRequestBody({ ...credits, issueNumber, checkSummary, runUrl });
+  let outcome;
+  try {
+    const pull = await rest.openOrReusePullRequest({
+      head: branchPlan.branch,
+      base: target.branch,
+      title,
+      body,
+      updateBodyIfReused: true
+    });
+    outcome = { kind: "pr", url: pull.url, reused: pull.reused };
+  } catch (err) {
+    if (!isPullRequestCreationForbidden(err)) throw err;
+    const closing = closingLine({ target, issueNumber });
+    const url = `${run3.server}/${repo}/compare/${encodeRefPath(target.branch)}...${encodeRefPath(branchPlan.branch)}?quick_pull=1&title=${encodeURIComponent(title)}` + (closing ? `&body=${encodeURIComponent(closing)}` : "");
+    outcome = { kind: "compare", url, branch: branchPlan.branch };
+  }
+  log(`Pull request: ${outcome.url}`);
+  return report(outcome, { ...credits, checkSummary });
+}
+
+// src/codemod/apply/link-input.ts
+import { execFile as execFile2 } from "child_process";
+import * as fs7 from "fs";
+import * as path11 from "path";
+var MAX_APPLY_INPUT_BYTES = 1048576;
+var TOO_LARGE_MESSAGE3 = "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_MESSAGE3);
+  }
+  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_MESSAGE3);
+    chunks.push(bytes);
+  }
+  return Buffer.concat(chunks).toString("utf8");
+}
+function existingFile(arg, cwd) {
+  try {
+    const resolved = path11.resolve(cwd, arg);
+    return fs7.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 (fs7.statSync(file).size > MAX_APPLY_INPUT_BYTES) throw new ApplyInputError(TOO_LARGE_MESSAGE3);
+  return checkSize(fs7.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((resolve16) => {
+    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") resolve16(TOO_LARGE);
+          else resolve16(error ? null : String(stdout));
+        }
+      );
+    } catch {
+      resolve16(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_MESSAGE3);
+    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 fs10 from "fs";
+import * as os2 from "os";
+import * as path15 from "path";
+
+// src/server/file-mutator.ts
+import { promises as fs8 } from "fs";
+import * as path13 from "path";
+
+// src/core/safe-path.ts
+import * as path12 from "path";
+function resolveSafeLocalePath(basePath, locale) {
+  if (!isSafeLocaleSegment(locale)) {
+    throw new Error("Path traversal attempt");
+  }
+  const resolvedBasePath = path12.resolve(basePath);
+  const filePath = path12.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 = path13.resolve(basePath);
+    const localeDir = path13.resolve(resolvedBasePath, locale);
+    let filePath = "";
+    let mutationKeyPath = keyPath;
+    let isNamespaceDir = false;
+    try {
+      const stats = await fs8.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 = path13.resolve(localeDir, `${namespace}.json`);
+      } else {
+        filePath = path13.resolve(localeDir, `${keyPath}.json`);
+        mutationKeyPath = "";
+      }
+    } else {
+      filePath = path13.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 () => {
@@ -3431,7 +4287,7 @@ var FileMutator = class {
       let indent = "  ";
       let trailingNewline = "\n";
       try {
-        const fileContent = await fs7.readFile(filePath, "utf-8");
+        const fileContent = await fs8.readFile(filePath, "utf-8");
         indent = detectJsonIndent(fileContent);
         trailingNewline = fileContent.endsWith("\n") ? "\n" : "";
         try {
@@ -3471,17 +4327,17 @@ var FileMutator = class {
       }
       const tempPath = `${filePath}.tmp`;
       try {
-        await fs7.writeFile(tempPath, stringified, "utf-8");
+        await fs8.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);
+        await fs8.rename(tempPath, filePath);
       } catch (err) {
         try {
-          await fs7.unlink(tempPath);
+          await fs8.unlink(tempPath);
         } catch {
         }
         throw new Error(
@@ -3499,19 +4355,19 @@ var FileMutator = class {
    */
   async readLocale(basePath, locale) {
     this.assertEnabled();
-    const localePath = path11.resolve(basePath, locale);
+    const localePath = path13.resolve(basePath, locale);
     let isDir = false;
     try {
-      isDir = (await fs7.stat(localePath)).isDirectory();
+      isDir = (await fs8.stat(localePath)).isDirectory();
     } catch {
     }
     if (isDir) {
       const merged = {};
-      for (const file of await fs7.readdir(localePath)) {
+      for (const file of await fs8.readdir(localePath)) {
         if (!file.endsWith(".json")) continue;
         try {
-          merged[path11.basename(file, ".json")] = JSON.parse(
-            await fs7.readFile(path11.join(localePath, file), "utf-8")
+          merged[path13.basename(file, ".json")] = JSON.parse(
+            await fs8.readFile(path13.join(localePath, file), "utf-8")
           );
         } catch {
         }
@@ -3519,15 +4375,15 @@ var FileMutator = class {
       return merged;
     }
     const filePath = resolveSafeLocalePath(basePath, locale);
-    return JSON.parse(await fs7.readFile(filePath, "utf-8"));
+    return JSON.parse(await fs8.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 resolvedBasePath = path13.resolve(basePath);
+    const items = await fs8.readdir(resolvedBasePath, { withFileTypes: true });
     const localesSet = /* @__PURE__ */ new Set();
     for (const item of items) {
       if (item.isDirectory()) {
@@ -3535,7 +4391,7 @@ var FileMutator = class {
           localesSet.add(item.name);
         }
       } else if (item.isFile() && item.name.endsWith(".json")) {
-        const name = path11.basename(item.name, ".json");
+        const name = path13.basename(item.name, ".json");
         if (LOCALE_RE.test(name)) {
           localesSet.add(name);
         }
@@ -3556,8 +4412,8 @@ var FileMutator = class {
     if (!LOCALE_RE.test(locale)) {
       throw new Error(`[livelocale] Invalid locale format: "${locale}"`);
     }
-    const resolvedBasePath = path11.resolve(basePath);
-    const localePath = path11.resolve(resolvedBasePath, locale);
+    const resolvedBasePath = path13.resolve(basePath);
+    const localePath = path13.resolve(resolvedBasePath, locale);
     if (!localePath.startsWith(resolvedBasePath)) {
       throw new Error(
         `[livelocale] Path traversal attempt: Resolved file path must start with basePath.`
@@ -3565,19 +4421,19 @@ var FileMutator = class {
     }
     let exists = false;
     try {
-      await fs7.stat(localePath);
+      await fs8.stat(localePath);
       exists = true;
     } catch {
     }
     try {
-      await fs7.stat(`${localePath}.json`);
+      await fs8.stat(`${localePath}.json`);
       exists = true;
     } catch {
     }
     if (exists) {
       throw new Error(`[livelocale] Locale "${locale}" already exists.`);
     }
-    const items = await fs7.readdir(resolvedBasePath, { withFileTypes: true });
+    const items = await fs8.readdir(resolvedBasePath, { withFileTypes: true });
     let referenceDir = null;
     for (const item of items) {
       if (item.isDirectory() && LOCALE_RE.test(item.name)) {
@@ -3586,16 +4442,16 @@ var FileMutator = class {
       }
     }
     if (referenceDir) {
-      await fs7.mkdir(localePath, { recursive: true });
-      const refPath = path11.resolve(resolvedBasePath, referenceDir);
-      const files = await fs7.readdir(refPath);
+      await fs8.mkdir(localePath, { recursive: true });
+      const refPath = path13.resolve(resolvedBasePath, referenceDir);
+      const files = await fs8.readdir(refPath);
       for (const file of files) {
         if (file.endsWith(".json")) {
-          await fs7.writeFile(path11.join(localePath, file), "{}", "utf-8");
+          await fs8.writeFile(path13.join(localePath, file), "{}", "utf-8");
         }
       }
     } else {
-      await fs7.writeFile(`${localePath}.json`, "{}", "utf-8");
+      await fs8.writeFile(`${localePath}.json`, "{}", "utf-8");
     }
     console.log(`[livelocale] Added locale '${locale}'`);
   }
@@ -3610,16 +4466,16 @@ var FileMutator = class {
     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);
+    const resolvedBasePath = path13.resolve(basePath);
+    const oldPath = path13.resolve(resolvedBasePath, oldLocale);
+    const newPath = path13.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);
+      const stats = await fs8.stat(oldPath);
       isDir = stats.isDirectory();
       exists = true;
     } catch {
@@ -3627,7 +4483,7 @@ var FileMutator = class {
     let isFile = false;
     if (!exists) {
       try {
-        await fs7.stat(`${oldPath}.json`);
+        await fs8.stat(`${oldPath}.json`);
         isFile = true;
         exists = true;
       } catch {
@@ -3638,12 +4494,12 @@ var FileMutator = class {
     }
     let newExists = false;
     try {
-      await fs7.stat(newPath);
+      await fs8.stat(newPath);
       newExists = true;
     } catch {
     }
     try {
-      await fs7.stat(`${newPath}.json`);
+      await fs8.stat(`${newPath}.json`);
       newExists = true;
     } catch {
     }
@@ -3651,9 +4507,9 @@ var FileMutator = class {
       throw new Error(`[livelocale] Target locale "${newLocale}" already exists.`);
     }
     if (isDir) {
-      await fs7.rename(oldPath, newPath);
+      await fs8.rename(oldPath, newPath);
     } else if (isFile) {
-      await fs7.rename(`${oldPath}.json`, `${newPath}.json`);
+      await fs8.rename(`${oldPath}.json`, `${newPath}.json`);
     }
     console.log(`[livelocale] Renamed locale '${oldLocale}' to '${newLocale}'`);
   }
@@ -3668,15 +4524,15 @@ var FileMutator = class {
     if (!LOCALE_RE.test(locale)) {
       throw new Error(`[livelocale] Invalid locale format`);
     }
-    const resolvedBasePath = path11.resolve(basePath);
-    const localePath = path11.resolve(resolvedBasePath, locale);
+    const resolvedBasePath = path13.resolve(basePath);
+    const localePath = path13.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);
+      const stats = await fs8.stat(localePath);
       isDir = stats.isDirectory();
       exists = true;
     } catch {
@@ -3684,7 +4540,7 @@ var FileMutator = class {
     let isFile = false;
     if (!exists) {
       try {
-        await fs7.stat(`${localePath}.json`);
+        await fs8.stat(`${localePath}.json`);
         isFile = true;
         exists = true;
       } catch {
@@ -3694,9 +4550,9 @@ var FileMutator = class {
       throw new Error(`[livelocale] Locale "${locale}" does not exist.`);
     }
     if (isDir) {
-      await fs7.rm(localePath, { recursive: true, force: true });
+      await fs8.rm(localePath, { recursive: true, force: true });
     } else if (isFile) {
-      await fs7.unlink(`${localePath}.json`);
+      await fs8.unlink(`${localePath}.json`);
     }
     console.log(`[livelocale] Deleted locale '${locale}'`);
   }
@@ -3724,8 +4580,8 @@ var FileMutator = class {
 // 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";
+import * as fs9 from "fs";
+import * as path14 from "path";
 var execFileAsync = promisify(execFile3);
 var MAX_DIFF_BYTES = 2e5;
 function mapStatus(xy) {
@@ -3756,15 +4612,15 @@ var GitClient = class {
   }
   /** 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;
+    const absolute = path14.resolve(localesPath);
+    const cwd = fs9.existsSync(absolute) ? absolute : path14.dirname(absolute);
+    if (!fs9.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("/");
+      const rel = path14.relative(root, absolute).split(path14.sep).join("/");
       if (rel.startsWith("..")) return null;
-      return { root: path12.resolve(root), rel: rel || ".", absolute };
+      return { root: path14.resolve(root), rel: rel || ".", absolute };
     } catch {
       return null;
     }
@@ -3796,301 +4652,127 @@ var GitClient = class {
         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));
+    } catch {
+    }
+    return { isRepo: true, branch, changes, mode: "local", pullRequestUrl: null };
   }
-  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;
+  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 = path14.join(loc.root, file);
+        let content = "";
+        try {
+          content = fs9.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;
   }
-  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)}.`
-    );
+  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 };
   }
-  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}`);
+  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]);
   }
-  return lines.join("\n");
-}
+};
 
 // src/codemod/apply/local.ts
-function isPlainObject4(value) {
+function isPlainObject5(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);
+  const dir = path15.join(localesDir, locale);
   let layout;
-  if (fs9.statSync(dir, { throwIfNoEntry: false })?.isDirectory()) {
+  if (fs10.statSync(dir, { throwIfNoEntry: false })?.isDirectory()) {
     layout = "namespaced";
-  } else if (fs9.statSync(`${dir}.json`, { throwIfNoEntry: false })?.isFile()) {
+  } else if (fs10.statSync(`${dir}.json`, { throwIfNoEntry: false })?.isFile()) {
     layout = "flat";
   } else {
     return null;
   }
   const dict = await mutator.readLocale(localesDir, locale);
-  if (!isPlainObject4(dict)) {
+  if (!isPlainObject5(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("/");
+  const rel = layout === "flat" ? path15.join(localesPath, `${locale}.json`) : path15.join(localesPath, locale, `${key.slice(0, key.indexOf("."))}.json`);
+  return path15.normalize(rel).split(path15.sep).join("/");
 }
-var PR_TITLE = "i18n: LiveLocale changes";
+var PR_TITLE2 = "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) => {
+    return new Promise((resolve16, 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}).`))
+        (code) => code === 0 ? resolve16("") : reject2(new Error(`git ${args[0]} failed (exit ${code}).`))
       );
     });
   }
-  return new Promise((resolve14, reject2) => {
+  return new Promise((resolve16, reject2) => {
     execFile4(
       "git",
       args,
       { cwd, env, windowsHide: true, maxBuffer: 16 * 1024 * 1024 },
-      (error, stdout) => error ? reject2(error) : resolve14(String(stdout))
+      (error, stdout) => error ? reject2(error) : resolve16(String(stdout))
     );
   });
 };
-var defaultGh = (args, cwd) => new Promise((resolve14, reject2) => {
+var defaultGh = (args, cwd) => new Promise((resolve16, reject2) => {
   execFile4(
     "gh",
     args,
     { cwd, windowsHide: true },
-    (error, stdout, stderr) => error ? reject2(Object.assign(error, { stderr: String(stderr) })) : resolve14(String(stdout))
+    (error, stdout, stderr) => error ? reject2(Object.assign(error, { stderr: String(stderr) })) : resolve16(String(stdout))
   );
 });
 function utcStamp(date) {
@@ -4122,7 +4804,7 @@ async function pickBranchName(git, root, stamp) {
   for (let n = 2; await taken(name); n++) name = `${base}-${n}`;
   return name;
 }
-function errorMessage(err) {
+function errorMessage2(err) {
   return err instanceof Error ? err.message : String(err);
 }
 async function writeEdits(mutator, plan, targets, localesDir, localesPath) {
@@ -4142,12 +4824,12 @@ function exitCodeFor(plan) {
 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 root = path15.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("/") || ".";
+    const rel = path15.relative(root, localesDir).split(path15.sep).join("/") || ".";
     throw new ApplyInputError(
       `Commit or stash the changes under ${rel} first; apply --pr commits everything in that folder.`
     );
@@ -4155,10 +4837,10 @@ async function preparePullRequest(git, projectDir, localesDir) {
   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");
+  const tmpDir = fs10.mkdtempSync(path15.join(os2.tmpdir(), "livelocale-pr-"));
+  const bodyFile = path15.join(tmpDir, "body.md");
   try {
-    fs9.writeFileSync(bodyFile, body, "utf-8");
+    fs10.writeFileSync(bodyFile, body, "utf-8");
     const out = await gh(
       [
         "pr",
@@ -4168,7 +4850,7 @@ async function createPullRequest(log, gh, root, base, head, body) {
         "--head",
         head,
         "--title",
-        PR_TITLE,
+        PR_TITLE2,
         "--body-file",
         bodyFile
       ],
@@ -4179,20 +4861,20 @@ async function createPullRequest(log, gh, root, base, head, body) {
   } catch (err) {
     if (err?.code !== "ENOENT") {
       const stderr = err?.stderr;
-      const reason = typeof stderr === "string" && stderr.trim() ? stderr.trim() : errorMessage(err);
+      const reason = typeof stderr === "string" && stderr.trim() ? stderr.trim() : errorMessage2(err);
       log(`gh could not open the pull request: ${reason}`);
     }
     return void 0;
   } finally {
-    fs9.rmSync(tmpDir, { recursive: true, force: true });
+    fs10.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()) {
+  const localesDir = path15.resolve(options.projectDir, localesPath);
+  if (!fs10.statSync(localesDir, { throwIfNoEntry: false })?.isDirectory()) {
     throw new ApplyInputError(`No locales folder at ${localesPath}.`);
   }
   const pr = options.pr === true && options.dryRun !== true;
@@ -4248,7 +4930,7 @@ async function runLocalApply(options) {
       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)}`;
+      checkSummary = `Check could not run: ${errorMessage2(err)}`;
     }
     await new GitClient().commit(localesDir, renderCommitMessage({ plan, by: set.by }));
     await git(["push", "-u", "origin", branch], root, { inherit: true });
@@ -4292,7 +4974,8 @@ var FLAG_OPTIONS = {
   "--clipboard": "clipboard",
   "--pr": "pr",
   "--force": "force",
-  "--dry-run": "dryRun"
+  "--dry-run": "dryRun",
+  "--github-event": "githubEvent"
 };
 function parseApplyArgs(argv) {
   const args = {
@@ -4303,11 +4986,20 @@ function parseApplyArgs(argv) {
     dryRun: false,
     dir: ".",
     locales: void 0,
-    source: void 0
+    source: void 0,
+    githubEvent: false,
+    branches: void 0
   };
   for (let i = 0; i < argv.length; i++) {
     const arg = argv[i];
-    if (Object.prototype.hasOwnProperty.call(VALUE_OPTIONS2, arg)) {
+    if (arg === "--branches") {
+      const value = argv[i + 1];
+      if (value === void 0 || value.startsWith("--")) {
+        throw new ApplyInputError(`${arg} needs a value.`);
+      }
+      args.branches = value.split(",").map((branch) => branch.trim()).filter(Boolean);
+      i++;
+    } else 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.`);
@@ -4327,17 +5019,43 @@ function parseApplyArgs(argv) {
   if (args.clipboard && args.input !== void 0) {
     throw new ApplyInputError("Pass the link or --clipboard, not both.");
   }
+  if (args.githubEvent) {
+    if (args.force) {
+      throw new ApplyInputError(
+        "--force is not allowed with --github-event; a maintainer comments `/livelocale apply --force`."
+      );
+    }
+    if (args.input !== void 0) {
+      throw new ApplyInputError(
+        "--github-event reads the link from the event file; do not pass one."
+      );
+    }
+    if (args.locales === void 0 || args.source === void 0) {
+      throw new ApplyInputError("--github-event needs --locales and --source.");
+    }
+  }
   return args;
 }
 async function runApplyCommand(argv) {
   try {
     const args = parseApplyArgs(argv);
+    if (args.githubEvent) {
+      const result2 = await runGitHubEventApply({
+        env: process.env,
+        localesPath: args.locales,
+        sourceLocale: args.source,
+        branches: args.branches,
+        dir: args.dir
+      });
+      process.exitCode = result2 === "error" || result2 === "wrong-repo" ? 1 : 0;
+      return;
+    }
     const input = await readApplyInput(args.input, {
       cwd: process.cwd(),
       clipboard: args.clipboard
     });
     const result = await runLocalApply({
-      projectDir: path14.resolve(args.dir),
+      projectDir: path16.resolve(args.dir),
       localesPath: args.locales,
       sourceLocale: args.source,
       input,
@@ -4352,6 +5070,327 @@ async function runApplyCommand(argv) {
   }
 }
 
+// src/codemod/init-share.ts
+import * as fs11 from "fs";
+import * as path17 from "path";
+var CHECKOUT_ACTION = "actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2";
+var WORKFLOW_PATH = ".github/workflows/livelocale.yml";
+var LOCALES_CANDIDATES = [
+  "locales",
+  "src/locales",
+  "public/locales",
+  "src/i18n/locales",
+  "messages"
+];
+var SAFE_ARG = /^[A-Za-z0-9_./-]+$/;
+var VERSION_RE = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/;
+var MAX_BRANCHES = 10;
+var SHARE_GITIGNORE = "public/livelocale/";
+function readText3(file) {
+  try {
+    return fs11.readFileSync(file, "utf-8");
+  } catch {
+    return null;
+  }
+}
+function parsePackageJson(text) {
+  if (text === null) return null;
+  try {
+    const parsed = JSON.parse(text);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function hasDependency2(pkg, name) {
+  return Boolean(pkg?.dependencies?.[name] ?? pkg?.devDependencies?.[name]);
+}
+function detectShareStack(projectDir) {
+  const target = detectBuildTarget(projectDir);
+  if (target.kind === "next") {
+    return target.staticExport ? { stack: "next-export", evidence: "Next.js with output: 'export'" } : { stack: "next-server", evidence: "Next.js without output: 'export'" };
+  }
+  if (target.kind === "vite") return { stack: "vite", evidence: "Vite" };
+  if (target.kind === "cra") return { stack: "cra", evidence: "react-scripts" };
+  const pkg = parsePackageJson(readText3(path17.join(projectDir, "package.json")));
+  for (const name of ["webpack", "@rsbuild/core"]) {
+    if (hasDependency2(pkg, name)) return { stack: "webpack", evidence: `${name} dependency` };
+  }
+  const config = fs11.readdirSync(projectDir).find((name) => /^webpack\.config\.[A-Za-z]+$/.test(name));
+  if (config) return { stack: "webpack", evidence: config };
+  return { stack: "unknown", evidence: "no Vite, Next.js, CRA, webpack or Rsbuild setup found" };
+}
+function checkSafePath(name, value) {
+  const segments = value.split("/");
+  if (!SAFE_ARG.test(value) || value.startsWith("/") || segments.includes("..")) {
+    throw new Error(`\`${name}\` may only contain letters, digits, ".", "_", "-" and "/".`);
+  }
+}
+function validateShareArgs(o) {
+  checkSafePath("--locales", o.localesPath);
+  if (o.dir !== void 0) checkSafePath("--dir", o.dir);
+  if (!LOCALE_RE.test(o.sourceLocale)) {
+    throw new Error("`--source` must be a locale code such as en or pt-BR.");
+  }
+  if (o.branches.length === 0) throw new Error("`--branches` needs at least one branch.");
+  if (o.branches.length > MAX_BRANCHES) {
+    throw new Error(`\`--branches\` takes at most ${MAX_BRANCHES} branches.`);
+  }
+  for (const branch of o.branches) checkSafePath("--branches", branch);
+}
+function renderWorkflow(o) {
+  validateShareArgs(o);
+  if (!VERSION_RE.test(o.version)) throw new Error(`Not a livelocale version: ${o.version}`);
+  const dirArg = o.dir === void 0 ? "" : ` --dir ${o.dir}`;
+  return [
+    "# Written by `npx livelocale init --share`. Turns LiveLocale change links into pull requests.",
+    "# livelocale reads the link from the event file; it never reaches a shell command.",
+    "name: LiveLocale",
+    "on:",
+    "  issues: { types: [opened] }",
+    "  issue_comment: { types: [created] }",
+    "  pull_request: { types: [closed] }",
+    "  workflow_dispatch: { inputs: { link: { description: 'LiveLocale change link', required: true } } }",
+    "permissions: { contents: write, pull-requests: write, issues: write }",
+    "concurrency: { group: 'livelocale-${{ github.event.issue.number || github.run_id }}', queue: max }",
+    "jobs:",
+    "  apply:",
+    "    if: >-",
+    "      github.event_name == 'workflow_dispatch' ||",
+    "      (github.event_name == 'issues' && contains(github.event.issue.body, '```livelocale')) ||",
+    "      (github.event_name == 'issue_comment' && !github.event.issue.pull_request &&",
+    "       startsWith(github.event.comment.body, '/livelocale')) ||",
+    "      (github.event_name == 'pull_request' && startsWith(github.event.pull_request.head.ref, 'livelocale/issue-') &&",
+    "       github.event.pull_request.base.ref != github.event.repository.default_branch)",
+    "    runs-on: ubuntu-latest",
+    "    steps:",
+    `      - uses: ${CHECKOUT_ACTION}`,
+    "        with: { persist-credentials: false }",
+    `      - run: npx --yes livelocale@${o.version} apply --github-event --locales ${o.localesPath} --source ${o.sourceLocale} --branches ${o.branches.join(",")}${dirArg}`,
+    "        env: { GITHUB_TOKEN: '${{ github.token }}' }",
+    ""
+  ].join("\n");
+}
+function toPosix2(p) {
+  return p.split(path17.sep).join("/");
+}
+function normalizeArgPath(p) {
+  return p.replace(/\\/g, "/").replace(/^(?:\.\/)+/, "").replace(/\/+$/, "");
+}
+function realDir(dir) {
+  try {
+    return fs11.realpathSync(dir);
+  } catch {
+    return path17.resolve(dir);
+  }
+}
+function holdsLocaleJson(dir) {
+  let entries;
+  try {
+    entries = fs11.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return false;
+  }
+  return entries.some((entry) => {
+    if (entry.isFile())
+      return entry.name.endsWith(".json") && LOCALE_RE.test(entry.name.slice(0, -5));
+    if (!entry.isDirectory() || !LOCALE_RE.test(entry.name)) return false;
+    try {
+      return fs11.readdirSync(path17.join(dir, entry.name)).some((name) => name.endsWith(".json"));
+    } catch {
+      return false;
+    }
+  });
+}
+function findLocalesPath(projectDir) {
+  const found = LOCALES_CANDIDATES.find((rel) => holdsLocaleJson(path17.join(projectDir, rel)));
+  if (!found) throw new Error("Pass --locales <path>.");
+  return found;
+}
+async function defaultBranchOf(git, cwd) {
+  const ref = await git(["symbolic-ref", "--short", "refs/remotes/origin/HEAD"], cwd);
+  if (ref?.startsWith("origin/") && ref.length > "origin/".length) {
+    return ref.slice("origin/".length);
+  }
+  const head = await git(["rev-parse", "--abbrev-ref", "HEAD"], cwd);
+  if (head && head !== "HEAD") return head;
+  return "main";
+}
+function planWrite(projectDir, rel, content) {
+  const current = readText3(path17.join(projectDir, rel));
+  if (current === null) return { path: rel, action: "create", content };
+  return current === content ? { path: rel, action: "unchanged" } : { path: rel, action: "update", content };
+}
+function planViteConfig(c) {
+  const addNote = `Add liveLocaleVite({ localesPath: '${c.localesPath}', share: true }) to the plugins array in vite.config.`;
+  const config = VITE_CONFIG_FILES.find((name) => fs11.existsSync(path17.join(c.projectDir, name)));
+  if (!config) {
+    c.notes.push(addNote);
+    return [];
+  }
+  const source = readText3(path17.join(c.projectDir, config)) ?? "";
+  if (!source.includes("liveLocaleVite(")) {
+    c.notes.push(addNote);
+    return [{ path: config, action: "skipped", reason: "no liveLocaleVite(...) call" }];
+  }
+  if (/\bshare\s*:/.test(source)) return [{ path: config, action: "unchanged" }];
+  const call = /liveLocaleVite\(\{\s*/;
+  if (!call.test(source)) {
+    c.notes.push(addNote);
+    return [{ path: config, action: "skipped", reason: "liveLocaleVite(...) has no { options }" }];
+  }
+  const source2 = c.sourceLocale === "en" ? "" : `sourceLocale: '${c.sourceLocale}', `;
+  const next = source.replace(call, () => `liveLocaleVite({ share: true, ${source2}`);
+  return [{ path: config, action: "update", content: next }];
+}
+function planPackageScripts(c) {
+  const text = readText3(path17.join(c.projectDir, "package.json"));
+  const pkg = parsePackageJson(text);
+  const args = `--locales ${c.localesPath} --source ${c.sourceLocale}`;
+  const isNext = c.stack === "next-export" || c.stack === "next-server";
+  const outDir = c.stack === "cra" ? "build" : "dist";
+  const packCommand = `livelocale pack ${outDir} ${args}`;
+  if (!pkg) {
+    c.notes.push(
+      isNext ? `Add "build:preview": "livelocale build --preview ${args} -- next build" to package.json.` : `Run "${packCommand}" after your build.`
+    );
+    return [{ path: "package.json", action: "skipped", reason: "no readable package.json" }];
+  }
+  const scripts = { ...pkg.scripts ?? {} };
+  if (isNext) {
+    const wanted = `livelocale build --preview ${args} -- next build`;
+    const current = scripts["build:preview"];
+    if (current === wanted || typeof current === "string" && current.includes("livelocale build")) {
+      return [{ path: "package.json", action: "unchanged" }];
+    }
+    if (current !== void 0) {
+      c.notes.push(`Set "build:preview" to "${wanted}" in package.json.`);
+      return [
+        {
+          path: "package.json",
+          action: "skipped",
+          reason: 'scripts["build:preview"] already exists'
+        }
+      ];
+    }
+    scripts["build:preview"] = wanted;
+  } else {
+    const build = scripts.build;
+    if (typeof build !== "string" || build.trim() === "") {
+      c.notes.push(`Run "${packCommand}" after your build.`);
+      return [{ path: "package.json", action: "skipped", reason: "no scripts.build" }];
+    }
+    if (build.includes("livelocale pack")) return [{ path: "package.json", action: "unchanged" }];
+    scripts.build = `${build} && ${packCommand}`;
+  }
+  return [
+    {
+      path: "package.json",
+      action: "update",
+      content: stringifyLike({ ...pkg, scripts }, text)
+    }
+  ];
+}
+function planGitignore(projectDir) {
+  const current = readText3(path17.join(projectDir, ".gitignore"));
+  if (current === null) {
+    return { path: ".gitignore", action: "create", content: `${SHARE_GITIGNORE}
+` };
+  }
+  if (parseGitignore(current).ignores("public/livelocale", true)) {
+    return { path: ".gitignore", action: "unchanged" };
+  }
+  const sep9 = current === "" || current.endsWith("\n") ? "" : "\n";
+  return { path: ".gitignore", action: "update", content: `${current}${sep9}${SHARE_GITIGNORE}
+` };
+}
+function planBuild(c) {
+  switch (c.stack) {
+    case "vite":
+      return planViteConfig(c);
+    case "cra":
+    case "webpack":
+      return planPackageScripts(c);
+    case "next-export":
+    case "next-server": {
+      const files = [...planPackageScripts(c), planGitignore(c.projectDir)];
+      if (c.stack === "next-export") {
+        const route = findExportBlockingRoute(c.projectDir);
+        if (route) {
+          c.notes.push(
+            `Delete ${route}: static export rejects POST routes, and livelocale build stops while it exists.`
+          );
+        }
+      } else {
+        c.notes.push(
+          'Use "npm run build:preview" as the build command of your preview deployments.'
+        );
+      }
+      return files;
+    }
+    case "unknown":
+      c.notes.push(
+        `No supported build setup found. In custom CI, run LIVELOCALE=preview <your build> (only for SSR/SSG), then npx livelocale pack <outDir> --locales ${c.localesPath} --source ${c.sourceLocale}.`
+      );
+      return [];
+  }
+}
+async function planInitShare(o) {
+  const projectDir = realDir(o.projectDir);
+  const git = o.git ?? runGit;
+  const sourceLocale = o.sourceLocale ?? "en";
+  const localesPath = o.localesPath !== void 0 ? normalizeArgPath(o.localesPath) : findLocalesPath(projectDir);
+  validateShareArgs({ localesPath, sourceLocale, branches: o.branches ?? ["main"] });
+  const { stack } = detectShareStack(projectDir);
+  const notes = [];
+  const files = planBuild({ projectDir, stack, localesPath, sourceLocale, notes });
+  const remote = await git(["remote", "get-url", "origin"], projectDir);
+  if (!remote || parseGitHubSlug(remote) === null) {
+    notes.push('One-click pull requests need GitHub. Use: npx livelocale apply "<link>" --pr');
+    return { stack, files, notes };
+  }
+  const top = await git(["rev-parse", "--show-toplevel"], projectDir);
+  const repoRoot = top ? realDir(top) : projectDir;
+  const appRel = toPosix2(path17.relative(repoRoot, projectDir));
+  const dir = appRel === "" ? void 0 : appRel;
+  const repoLocales = dir === void 0 ? localesPath : `${dir}/${localesPath}`;
+  const defaultBranch = await defaultBranchOf(git, projectDir);
+  const branches = o.branches ?? [defaultBranch];
+  const workflow = renderWorkflow({
+    version: o.version,
+    localesPath: repoLocales,
+    sourceLocale,
+    branches,
+    dir
+  });
+  const workflowRel = toPosix2(path17.relative(projectDir, path17.join(repoRoot, WORKFLOW_PATH)));
+  const planned = planWrite(projectDir, workflowRel, workflow);
+  files.push(
+    planned.action === "update" && !o.overwrite ? {
+      path: workflowRel,
+      action: "skipped",
+      reason: "it exists with different content; pass --overwrite to replace it"
+    } : planned
+  );
+  for (const branch of branches) {
+    if (branch === defaultBranch) continue;
+    notes.push(
+      `Also merge ${WORKFLOW_PATH} into \`${branch}\`; pull requests into it run workflows from that branch, so LiveLocale cannot close their issues otherwise.`
+    );
+  }
+  return { stack, files, notes };
+}
+function writePlannedFiles(projectDir, files) {
+  for (const file of files) {
+    if (file.action !== "create" && file.action !== "update" || file.content === void 0) {
+      continue;
+    }
+    const target = path17.resolve(projectDir, file.path);
+    fs11.mkdirSync(path17.dirname(target), { recursive: true });
+    fs11.writeFileSync(target, file.content, "utf-8");
+  }
+}
+
 // src/codemod/index.ts
 var DEFAULT_STUDIO_PORT = 3010;
 var DEFAULT_APP_ORIGIN = "http://localhost:3000";
@@ -4379,6 +5418,11 @@ Options for migrate:
 
 Options for init:
   --dir <path>       Target project directory (default: current directory)
+  --share            Set up the share link build and the GitHub workflow instead of the API route
+  --locales <path>   (--share) Locales directory relative to the project (default: detected)
+  --source <locale>  (--share) Source locale (default: en)
+  --branches <a,b>   (--share) Branches a change link may target (default: the default branch)
+  --overwrite        (--share) Replace an existing .github/workflows/livelocale.yml
 
 Options for studio:
   --port <number>    Port to run the studio server on (default: ${DEFAULT_STUDIO_PORT})
@@ -4424,6 +5468,8 @@ Options for apply:
   --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
+  --github-event      Run inside the generated GitHub workflow; reads the link from the event file
+  --branches <a,b>    Branches a link may target (default: the repository's default branch)
 
 Global Options:
   -h, --help         Show help information
@@ -4452,11 +5498,11 @@ function normalizeAppArg(value) {
   }
 }
 function isPortAnswering(port) {
-  return new Promise((resolve14) => {
+  return new Promise((resolve16) => {
     const socket = net.connect({ host: "localhost", port });
     const done = (answering) => {
       socket.destroy();
-      resolve14(answering);
+      resolve16(answering);
     };
     socket.setTimeout(1e3, () => done(false));
     socket.once("connect", () => done(true));
@@ -4466,8 +5512,8 @@ function isPortAnswering(port) {
 async function runStudio(port, appOrigin) {
   console.log(`
 \u{1F680} Starting LiveLocale Studio...`);
-  const studioDir = path15.resolve(moduleDir(), "../studio");
-  if (!fs10.existsSync(path15.join(studioDir, "index.html"))) {
+  const studioDir = path18.resolve(moduleDir(), "../studio");
+  if (!fs12.existsSync(path18.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);
@@ -4499,48 +5545,48 @@ async function runStudio(port, appOrigin) {
 function runInit(projectDir) {
   console.log(`
 \u{1F680} Initializing LiveLocale API handler...`);
-  const absoluteDir = path15.resolve(projectDir);
-  if (!fs10.existsSync(absoluteDir)) {
+  const absoluteDir = path18.resolve(projectDir);
+  if (!fs12.existsSync(absoluteDir)) {
     console.error(`Error: Directory "${projectDir}" does not exist.`);
     process.exit(1);
   }
-  const isTypeScript = fs10.existsSync(path15.join(absoluteDir, "tsconfig.json"));
+  const isTypeScript = fs12.existsSync(path18.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 = path15.join(absoluteDir, "package.json");
-  if (fs10.existsSync(targetPkgPath)) {
+  const targetPkgPath = path18.join(absoluteDir, "package.json");
+  if (fs12.existsSync(targetPkgPath)) {
     try {
-      const pkg = JSON.parse(fs10.readFileSync(targetPkgPath, "utf8"));
+      const pkg = JSON.parse(fs12.readFileSync(targetPkgPath, "utf8"));
       const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
       hasNextIntl = Boolean(allDeps["next-intl"]);
       hasReactI18next = Boolean(allDeps["react-i18next"]);
     } catch {
     }
   }
-  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");
+  const appDirPath = path18.join(absoluteDir, "app");
+  const pagesDirPath = path18.join(absoluteDir, "pages");
+  const srcAppDirPath = path18.join(absoluteDir, "src", "app");
+  const srcPagesDirPath = path18.join(absoluteDir, "src", "pages");
   let targetPath = "";
   let routerType = "";
   let content = "";
-  if (fs10.existsSync(appDirPath)) {
-    targetPath = path15.join(appDirPath, "api", "livelocale", `route.${fileExt}`);
+  if (fs12.existsSync(appDirPath)) {
+    targetPath = path18.join(appDirPath, "api", "livelocale", `route.${fileExt}`);
     routerType = "Next.js App Router (root)";
-  } else if (fs10.existsSync(srcAppDirPath)) {
-    targetPath = path15.join(srcAppDirPath, "api", "livelocale", `route.${fileExt}`);
+  } else if (fs12.existsSync(srcAppDirPath)) {
+    targetPath = path18.join(srcAppDirPath, "api", "livelocale", `route.${fileExt}`);
     routerType = "Next.js App Router (src/)";
-  } else if (fs10.existsSync(pagesDirPath)) {
-    targetPath = path15.join(pagesDirPath, "api", `livelocale.${fileExt}`);
+  } else if (fs12.existsSync(pagesDirPath)) {
+    targetPath = path18.join(pagesDirPath, "api", `livelocale.${fileExt}`);
     routerType = "Next.js Pages Router (root)";
-  } else if (fs10.existsSync(srcPagesDirPath)) {
-    targetPath = path15.join(srcPagesDirPath, "api", `livelocale.${fileExt}`);
+  } else if (fs12.existsSync(srcPagesDirPath)) {
+    targetPath = path18.join(srcPagesDirPath, "api", `livelocale.${fileExt}`);
     routerType = "Next.js Pages Router (src/)";
   } else {
-    targetPath = path15.join(absoluteDir, "app", "api", "livelocale", `route.${fileExt}`);
+    targetPath = path18.join(absoluteDir, "app", "api", "livelocale", `route.${fileExt}`);
     routerType = "Default App Router (app/ not found)";
   }
   console.log(`\u{1F4CD} Project structure: ${routerType}`);
@@ -4568,14 +5614,14 @@ const handler = createLiveLocaleHandler({
 export default handler;
 `;
   }
-  const targetDir = path15.dirname(targetPath);
-  if (!fs10.existsSync(targetDir)) {
-    fs10.mkdirSync(targetDir, { recursive: true });
+  const targetDir = path18.dirname(targetPath);
+  if (!fs12.existsSync(targetDir)) {
+    fs12.mkdirSync(targetDir, { recursive: true });
   }
   try {
-    fs10.writeFileSync(targetPath, content, "utf8");
+    fs12.writeFileSync(targetPath, content, "utf8");
     console.log(`\u2705 Created API Route Handler successfully at:`);
-    console.log(`   ${path15.relative(absoluteDir, targetPath)}`);
+    console.log(`   ${path18.relative(absoluteDir, targetPath)}`);
     if (hasNextIntl) {
       console.log(`
 \u{1F4A1} Detected 'next-intl' in your project!`);
@@ -4617,8 +5663,8 @@ async function runMigrate(args) {
       }
     }
   }
-  const absoluteDir = path15.resolve(dir);
-  if (!fs10.existsSync(absoluteDir)) {
+  const absoluteDir = path18.resolve(dir);
+  if (!fs12.existsSync(absoluteDir)) {
     console.error(`Error: Directory "${dir}" does not exist.`);
     process.exit(1);
   }
@@ -4642,28 +5688,28 @@ async function runMigrate(args) {
   let scannedCount = 0;
   let migratedCount = 0;
   async function walk(currentDir) {
-    const files = fs10.readdirSync(currentDir, { withFileTypes: true });
+    const files = fs12.readdirSync(currentDir, { withFileTypes: true });
     for (const file of files) {
-      const fullPath = path15.join(currentDir, file.name);
+      const fullPath = path18.join(currentDir, file.name);
       if (file.isDirectory()) {
         if (excludes.includes(file.name)) {
           continue;
         }
         await walk(fullPath);
       } else if (file.isFile()) {
-        const ext = path15.extname(file.name);
+        const ext = path18.extname(file.name);
         if ([".js", ".jsx", ".ts", ".tsx"].includes(ext)) {
           scannedCount++;
           try {
-            const content = fs10.readFileSync(fullPath, "utf8");
+            const content = fs12.readFileSync(fullPath, "utf8");
             const result = await transformReactI18next2(content, fullPath);
             if (result.modified) {
               migratedCount++;
-              const relativePath = path15.relative(absoluteDir, fullPath);
+              const relativePath = path18.relative(absoluteDir, fullPath);
               if (dryRun) {
                 console.log(`[DRY RUN] Would migrate: ${relativePath}`);
               } else {
-                fs10.writeFileSync(fullPath, result.code, "utf8");
+                fs12.writeFileSync(fullPath, result.code, "utf8");
                 console.log(`\u2705 Migrated: ${relativePath}`);
               }
             }
@@ -4712,8 +5758,8 @@ async function runDoctorCommand(args) {
       dir = arg;
     }
   }
-  const projectDir = path15.resolve(dir);
-  if (!fs10.existsSync(projectDir)) {
+  const projectDir = path18.resolve(dir);
+  if (!fs12.existsSync(projectDir)) {
     console.error(`Error: Directory "${dir}" does not exist.`);
     process.exit(1);
   }
@@ -4774,8 +5820,8 @@ async function runCheckCommand(args) {
       dir = arg;
     }
   }
-  const projectDir = path15.resolve(dir);
-  if (!fs10.existsSync(projectDir)) {
+  const projectDir = path18.resolve(dir);
+  if (!fs12.existsSync(projectDir)) {
     console.error(`Error: Directory "${dir}" does not exist.`);
     process.exit(1);
   }
@@ -4816,7 +5862,7 @@ async function runCheckCommand(args) {
 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("/") || ".";
+  const outRel = path18.relative(projectDir, path18.dirname(result.shareDir)).split(path18.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).`
   );
@@ -4828,7 +5874,7 @@ async function runPackCommand(args) {
     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 projectDir = path18.resolve(options.dir);
     const result = await packOutput({
       projectDir,
       outDir: options.positional[0],
@@ -4851,7 +5897,7 @@ async function runBuildCli(args) {
     if (options.positional.length > 0 || !options.inject) {
       throw new PackError("USAGE", BUILD_USAGE);
     }
-    const projectDir = path15.resolve(options.dir);
+    const projectDir = path18.resolve(options.dir);
     const result = await runBuildCommand({
       projectDir,
       command: options.command,
@@ -4874,6 +5920,55 @@ async function runBuildCli(args) {
     process.exitCode = 1;
   }
 }
+async function runInitShareCommand(args) {
+  let dir = ".";
+  let localesPath;
+  let sourceLocale;
+  let branches;
+  let overwrite = false;
+  for (let i = 1; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--dir") {
+      dir = args[++i] || ".";
+    } else if (arg === "--locales") {
+      localesPath = args[++i];
+    } else if (arg === "--source") {
+      sourceLocale = args[++i];
+    } else if (arg === "--branches") {
+      branches = (args[++i] ?? "").split(",").map((b) => b.trim()).filter(Boolean);
+    } else if (arg === "--overwrite") {
+      overwrite = true;
+    }
+  }
+  const projectDir = path18.resolve(dir);
+  if (!fs12.existsSync(projectDir)) {
+    console.error(`Error: Directory "${dir}" does not exist.`);
+    process.exit(1);
+  }
+  try {
+    const plan = await planInitShare({
+      projectDir,
+      localesPath,
+      sourceLocale,
+      branches,
+      version: readOwnVersion(),
+      overwrite
+    });
+    writePlannedFiles(projectDir, plan.files);
+    console.log(`
+\u{1F680} LiveLocale share link setup (${plan.stack})`);
+    for (const file of plan.files) {
+      console.log(
+        `  ${file.action.padEnd(9)} ${file.path}${file.reason ? ` (${file.reason})` : ""}`
+      );
+    }
+    for (const note of plan.notes) console.log(`\u{1F4A1} ${note}`);
+    console.log("Commit and push: the workflow must be on the default branch.");
+  } catch (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") {
@@ -4906,6 +6001,10 @@ async function run2() {
     await runApplyCommand(args.slice(1));
     return;
   }
+  if (args[0] === "init" && args.includes("--share")) {
+    await runInitShareCommand(args);
+    return;
+  }
   if (args[0] === "init") {
     let dir = ".";
     for (let i = 1; i < args.length; i++) {