@zalkera/cli 0.20.2

package/dist/main.js

@@ -0,0 +1,3128 @@
+#!/usr/bin/env node
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+
+// ../core/dist/notice.js
+function defang(text) {
+  let out = text;
+  for (let pass = 0; pass < DEFANG_PASSES; pass += 1) {
+    const next = out.replace(LINK_SHAPE, (_m, inner) => `\uFF3D\uFF08${inner}\uFF09`).replace(AUTOLINK_SHAPE, (_m, inner) => `\uFF1C${inner}\uFF1E`);
+    if (next === out)
+      return out;
+    out = next;
+  }
+  return out.replace(/[\]()<>]/g, " ");
+}
+function plainNotice(text, limit = 300) {
+  if (typeof text !== "string")
+    return "";
+  const cap = Math.min(limit, MAX_CAP);
+  const head = text.length > cap * 4 ? text.slice(0, cap * 4) : text;
+  const stripped = head.replace(/[\u0000-\u001f\u007f-\u009f\u200b-\u200f\u202a-\u202e\u2066-\u2069\u2028\u2029]+/g, " ");
+  const tidy = defang(stripped).replace(/\s+/g, " ").trim();
+  return tidy.length > cap ? `${tidy.slice(0, cap)}\u2026` : tidy;
+}
+var INNER_BOUND, MAX_CAP, LINK_SHAPE, AUTOLINK_SHAPE, DEFANG_PASSES;
+var init_notice = __esm({
+  "../core/dist/notice.js"() {
+    "use strict";
+    INNER_BOUND = 2048;
+    MAX_CAP = 512;
+    LINK_SHAPE = new RegExp(`\\]\\s*\\(\\s*([A-Za-z][A-Za-z0-9+.-]*:[^)]{0,${INNER_BOUND}})\\)`, "g");
+    AUTOLINK_SHAPE = new RegExp(`<\\s*([A-Za-z][A-Za-z0-9+.-]*:[^>\\s]{0,${INNER_BOUND}})\\s*>`, "g");
+    DEFANG_PASSES = 4;
+  }
+});
+
+// ../core/dist/errors.js
+var DevtoolsError;
+var init_errors = __esm({
+  "../core/dist/errors.js"() {
+    "use strict";
+    init_notice();
+    DevtoolsError = class extends Error {
+      code;
+      hint;
+      /**
+       * 서버가 보낸 `errorCode` 원문. **분기용이지 표시용이 아니다** — 보여 줄 때는 [humanMessage] 를 쓴다.
+       *
+       * 이것이 없으면 「동의하면 계속할 수 있다」는 거절과 「어떻게 해도 안 된다」는 거절을 호출부가
+       * 구분하지 못한다. 서버가 "계속하려면 확인해 주세요"라고 적어 보내는데 확인할 자리가 없으면
+       * 그 문장이 곧 막다른 길이 된다.
+       */
+      serverCode;
+      /**
+       * 서버가 **어느 항목이 걸렸는지** 짚어 준 목록(응답의 `errors[].field`). 대개 소스 경로다.
+       *
+       * ■ 왜 문면이 아니라 목록인가
+       *
+       * 배치 요청 하나가 여러 항목을 담으면 「무엇이 걸렸는가」는 문장이 아니라 목록이다. 문면을
+       * 뜯어 쓰면 서버의 **한국어 문구가 계약이 된다** — 백엔드의 `ErrorResponse.errorCode` KDoc 이
+       * 이미 「문자열 매칭을 유도하면 계약이 깨진다」고 못박은 자리다.
+       *
+       * ⚠ **서버가 정하는 값이다.** 표시에 쓸 때는 [humanMessage] 와 같은 소독을 지나야 한다 —
+       *   알림 본문은 링크를 렌더하고 그 링크는 명령을 실행할 수 있다(형제 `api.ts` 의 실측).
+       */
+      paths;
+      // 파라미터 프로퍼티(`constructor(readonly x)`)를 쓰지 않는다 — Node 의 타입 스트립 실행이 그 문법을
+      // 받지 않아서, 쓰는 순간 테스트가 빌드 산출물을 거쳐야 한다(소스를 그대로 돌리는 이점이 사라진다).
+      constructor(code2, message, hint, cause, serverCode, paths) {
+        super(message, cause === void 0 ? void 0 : { cause });
+        this.name = "DevtoolsError";
+        this.code = code2;
+        this.hint = hint;
+        this.serverCode = serverCode;
+        this.paths = paths ?? [];
+      }
+      /**
+       * 사람에게 보여 줄 전체 문장(메시지 + 다음 할 일). **여기서 소독한다.**
+       *
+       * ⚠ 이 접근자의 이름이 곧 경계다 — 나가는 자리가 알림창인지 출력 채널인지는 이 클래스가
+       *   모른다. 그래서 「알림에 닿기 전에 어딘가에서 소독됐겠지」에 기대지 않는다.
+       *
+       * 실제로 그 기대가 틀렸다(3회전 심의 실증): `safeWrite.ts`·`untar.ts` 는 **서버가 정한 zip·tar
+       * 항목 이름**을 그대로 메시지에 보간하는데(`받은 파일이 폴더 밖을 가리킵니다: ${name}`),
+       * 소독은 `api.ts` 의 응답 파싱 경로에만 있었다. 항목 이름이
+       * `../[열기](command:workbench.action.terminal.new)` 이면 그 문장이 비-모달 알림에서
+       * **누르면 명령이 도는 링크**가 됐다.
+       *
+       * 보간하는 자리를 열거해 고치면 다음에 생기는 자리가 또 샌다 — 이 레포가 두 번 겪은 형상이다.
+       * 그래서 자리가 아니라 **나가는 문 하나**에서 한다. [message]·[hint] 원문은 그대로 남으므로
+       * 로그·시험은 영향받지 않는다.
+       */
+      get humanMessage() {
+        const body = plainNotice(this.message);
+        return this.hint ? `${body}
+${plainNotice(this.hint)}` : body;
+      }
+    };
+  }
+});
+
+// ../core/dist/nodeOnPath.js
+var init_nodeOnPath = __esm({
+  "../core/dist/nodeOnPath.js"() {
+    "use strict";
+  }
+});
+
+// ../core/dist/dev.js
+var init_dev = __esm({
+  "../core/dist/dev.js"() {
+    "use strict";
+    init_errors();
+    init_nodeOnPath();
+  }
+});
+
+// ../core/dist/index.js
+init_errors();
+
+// ../core/dist/handshake.js
+init_errors();
+init_notice();
+
+// ../core/dist/serverUrl.js
+function httpUrl(value) {
+  if (typeof value !== "string" || value.trim() === "")
+    return null;
+  let parsed;
+  try {
+    parsed = new URL(value);
+  } catch {
+    return null;
+  }
+  return parsed.protocol === "https:" || parsed.protocol === "http:" ? parsed : null;
+}
+function isLoopback(url) {
+  return url.hostname === "127.0.0.1" || url.hostname === "localhost" || url.hostname === "[::1]" || url.hostname === "::1";
+}
+function apiBaseUrl(value) {
+  const url = httpUrl(value);
+  if (!url)
+    return null;
+  return url.protocol === "https:" || isLoopback(url) ? url : null;
+}
+function mcpServerName(value) {
+  return typeof value === "string" && /^[a-z0-9][a-z0-9-]{0,62}$/.test(value) ? value : null;
+}
+
+// ../core/dist/handshake.js
+var HANDSHAKE_TIMEOUT_MS = 15 * 1e3;
+var MAX_VERSION_SHOWN = 40;
+async function fetchHandshake(apiBase, extensionVersion, fetchImpl = fetch, upgradeHow) {
+  const url = new URL("/api/devtools/handshake", withTrailingSlash(apiBase));
+  url.searchParams.set("extensionVersion", extensionVersion);
+  let response;
+  try {
+    response = await fetchImpl(url, {
+      headers: { accept: "application/json" },
+      signal: AbortSignal.timeout(HANDSHAKE_TIMEOUT_MS)
+    });
+  } catch (cause) {
+    throw new DevtoolsError("SERVER_UNREACHABLE", "\uC798\uCEE4\uB77C \uC11C\uBC84\uC5D0 \uC5F0\uACB0\uD558\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4.", `\uC8FC\uC18C\uAC00 \uB9DE\uB294\uC9C0(${apiBase}), \uC778\uD130\uB137\xB7\uC0AC\uB0B4\uB9DD \uD504\uB85D\uC2DC\uAC00 \uB9C9\uACE0 \uC788\uC9C0 \uC54A\uC740\uC9C0 \uD655\uC778\uD574 \uC8FC\uC138\uC694.`, cause);
+  }
+  if (!response.ok) {
+    throw new DevtoolsError("SERVER_REJECTED", `\uC11C\uBC84\uAC00 \uC751\uB2F5\uD558\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4(HTTP ${response.status}).`, "\uC7A0\uC2DC \uB4A4 \uB2E4\uC2DC \uC2DC\uB3C4\uD574 \uC8FC\uC138\uC694. \uACC4\uC18D\uB418\uBA74 \uC798\uCEE4\uB77C\uC5D0 \uBB38\uC758\uD574 \uC8FC\uC138\uC694.");
+  }
+  let body;
+  try {
+    body = await response.json();
+  } catch (cause) {
+    throw new DevtoolsError("SERVER_UNREACHABLE", "\uC11C\uBC84 \uC751\uB2F5\uC744 \uC774\uD574\uD558\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4.", `${apiBase} \uAC00 \uC798\uCEE4\uB77C \uC11C\uBC84\uAC00 \uB9DE\uB294\uC9C0, \uC0AC\uB0B4\uB9DD \uD504\uB85D\uC2DC\uAC00 \uC751\uB2F5\uC744 \uBC14\uAFB8\uACE0 \uC788\uC9C0 \uC54A\uC740\uC9C0 \uD655\uC778\uD574 \uC8FC\uC138\uC694.`, cause);
+  }
+  const handshake = body?.data;
+  if (!handshake || typeof handshake.verdict !== "string") {
+    throw new DevtoolsError("SERVER_UNREACHABLE", "\uC11C\uBC84 \uC751\uB2F5\uC5D0 \uD544\uC694\uD55C \uC815\uBCF4\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4.", "\uC8FC\uC18C\uAC00 \uC798\uCEE4\uB77C \uC11C\uBC84\uAC00 \uB9DE\uB294\uC9C0 \uD655\uC778\uD574 \uC8FC\uC138\uC694.");
+  }
+  if (!handshake.auth || !apiBaseUrl(handshake.auth.issuer)) {
+    throw new DevtoolsError("SERVER_REJECTED", "\uC11C\uBC84\uAC00 \uBCF4\uB0B8 \uB85C\uADF8\uC778 \uC8FC\uC18C\uB97C \uC4F8 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.", "\uC798\uCEE4\uB77C\uC5D0 \uBB38\uC758\uD574 \uC8FC\uC138\uC694.");
+  }
+  if (handshake.mcp && (!apiBaseUrl(handshake.mcp.authServerMetadataUrl) || !apiBaseUrl(handshake.mcp.sourceUrlTemplate?.replace("{tenantCode}", "probe")) || !mcpServerName(handshake.mcp.serverName))) {
+    handshake.mcp = null;
+  }
+  handshake.message = handshake.message == null ? null : plainNotice(handshake.message);
+  handshake.minExtensionVersion = plainNotice(handshake.minExtensionVersion, MAX_VERSION_SHOWN);
+  handshake.recommendedExtensionVersion = plainNotice(handshake.recommendedExtensionVersion, MAX_VERSION_SHOWN);
+  if (handshake.verdict === "UPGRADE_REQUIRED") {
+    throw new DevtoolsError(
+      "EXTENSION_OUTDATED",
+      handshake.message ?? "\uC774 \uBC84\uC804\uC740 \uB354 \uC774\uC0C1 \uC11C\uBC84\uC640 \uB9DE\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4.",
+      // 🔴 **나가는 길을 맨 앞에 둔다.** `humanMessage` 가 다시 300자로 죄므로, 서버가 정하는
+      //    글자가 앞에 오면 **긴 값 하나로 우리 안내를 통째로 밀어낼 수** 있다(심의 실측:
+      //    191자면 `npx zalkera@latest` 가 사라진다). 그러면 「업데이트하세요」만 남고
+      //    방법이 없는, 이 인자가 막으려던 그 교착이 서버 문자열 하나로 되살아난다.
+      (upgradeHow === void 0 ? "" : `${upgradeHow} `) + `\uC11C\uBC84\uAC00 \uC694\uAD6C\uD558\uB294 \uCD5C\uC18C \uBC84\uC804\uC740 ${handshake.minExtensionVersion} \uC785\uB2C8\uB2E4.`
+    );
+  }
+  return handshake;
+}
+function withTrailingSlash(base) {
+  return base.endsWith("/") ? base : `${base}/`;
+}
+
+// ../core/dist/auth/pkce.js
+import { createHash, randomBytes } from "node:crypto";
+function createPkce() {
+  const verifier = base64Url(randomBytes(96));
+  const challenge = base64Url(createHash("sha256").update(verifier).digest());
+  return { verifier, challenge, method: "S256" };
+}
+function createState() {
+  return base64Url(randomBytes(32));
+}
+function base64Url(buffer) {
+  return buffer.toString("base64url");
+}
+
+// ../core/dist/auth/loopback.js
+init_errors();
+import { createServer } from "node:http";
+var DEFAULT_TIMEOUT_MS = 5 * 60 * 1e3;
+var CANCEL_ERRORS = /* @__PURE__ */ new Set(["access_denied", "consent_required", "login_required", "interaction_required"]);
+var DEFAULT_SUCCESS_HTML = `<!doctype html>
+<html lang="ko"><head><meta charset="utf-8"><title>\uB85C\uADF8\uC778 \uC644\uB8CC</title></head>
+<body style="font-family:system-ui,sans-serif;padding:3rem;text-align:center">
+<h1 style="font-size:1.25rem">\uB85C\uADF8\uC778\uC774 \uB05D\uB0AC\uC2B5\uB2C8\uB2E4</h1>
+<p style="color:#555">\uC774 \uCC3D\uC744 \uB2EB\uACE0 \uD3B8\uC9D1\uAE30\uB85C \uB3CC\uC544\uAC00\uC138\uC694.</p>
+</body></html>`;
+async function startLoopbackReceiver(options = {}) {
+  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const successHtml = options.successHtml ?? DEFAULT_SUCCESS_HTML;
+  let resolveCode;
+  let rejectCode;
+  let settled = false;
+  const codePromise = new Promise((resolve9, reject) => {
+    resolveCode = (result) => {
+      settled = true;
+      resolve9(result);
+    };
+    rejectCode = (error) => {
+      settled = true;
+      reject(error);
+    };
+  });
+  codePromise.catch(() => {
+  });
+  const server = createServer((request, response) => {
+    const url = new URL(request.url ?? "/", "http://127.0.0.1");
+    const error = url.searchParams.get("error");
+    const code2 = url.searchParams.get("code");
+    const state = url.searchParams.get("state");
+    if (error) {
+      const cancelled = CANCEL_ERRORS.has(error);
+      respond(response, cancelled ? 200 : 400, cancelled ? "<p>\uB85C\uADF8\uC778\uC744 \uCDE8\uC18C\uD588\uC2B5\uB2C8\uB2E4. \uC774 \uCC3D\uC740 \uB2EB\uC73C\uC154\uB3C4 \uB429\uB2C8\uB2E4.</p>" : `<p>\uB85C\uADF8\uC778\uC774 \uAC70\uC808\uB418\uC5C8\uC2B5\uB2C8\uB2E4: ${escapeHtml(error)}</p>`);
+      rejectCode(cancelled ? new DevtoolsError("CANCELLED", "\uB85C\uADF8\uC778\uC744 \uCDE8\uC18C\uD588\uC2B5\uB2C8\uB2E4.") : new Error(url.searchParams.get("error_description") ?? error));
+      return;
+    }
+    if (!code2 || !state) {
+      respond(response, 400, "<p>\uC798\uBABB\uB41C \uC694\uCCAD\uC785\uB2C8\uB2E4.</p>");
+      return;
+    }
+    respond(response, 200, successHtml);
+    resolveCode({ code: code2, state });
+  });
+  await new Promise((resolve9, reject) => {
+    server.once("error", reject);
+    server.listen(0, "127.0.0.1", resolve9);
+  });
+  const port = server.address().port;
+  const timer = setTimeout(() => {
+    rejectCode(new Error("\uB85C\uADF8\uC778\uC774 \uC2DC\uAC04 \uC548\uC5D0 \uB05D\uB098\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4."));
+  }, timeoutMs);
+  timer.unref?.();
+  const close = () => {
+    clearTimeout(timer);
+    server.close();
+    if (!settled)
+      rejectCode(new DevtoolsError("CANCELLED", "\uB85C\uADF8\uC778\uC744 \uCDE8\uC18C\uD588\uC2B5\uB2C8\uB2E4."));
+  };
+  if (options.signal) {
+    if (options.signal.aborted)
+      close();
+    else
+      options.signal.addEventListener("abort", close, { once: true });
+  }
+  return {
+    redirectUri: `http://127.0.0.1:${port}/callback`,
+    waitForCode: () => codePromise,
+    close
+  };
+}
+function respond(response, status, html) {
+  response.writeHead(status, { "content-type": "text/html; charset=utf-8" });
+  response.end(html);
+}
+function escapeHtml(value) {
+  return value.replace(/[&<>"']/g, (c) => `&#${c.charCodeAt(0)};`);
+}
+
+// ../core/dist/auth/oauth.js
+init_errors();
+var REFRESH_SKEW_MS = 2e4;
+async function login(config, store, options) {
+  const pkce = createPkce();
+  const state = createState();
+  const receiver = await startLoopbackReceiver({
+    ...options.timeoutMs === void 0 ? {} : { timeoutMs: options.timeoutMs },
+    ...options.signal === void 0 ? {} : { signal: options.signal }
+  });
+  try {
+    const issuer = httpUrl(trimSlash(config.issuer));
+    if (!issuer) {
+      throw new DevtoolsError("SERVER_REJECTED", "\uC11C\uBC84\uAC00 \uBCF4\uB0B8 \uB85C\uADF8\uC778 \uC8FC\uC18C\uB97C \uC4F8 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.", "\uBE0C\uB77C\uC6B0\uC800\uB97C \uC5F4\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4. \uC798\uCEE4\uB77C\uC5D0 \uBB38\uC758\uD574 \uC8FC\uC138\uC694.");
+    }
+    const authorizeUrl = new URL(`${trimSlash(issuer.toString())}/protocol/openid-connect/auth`);
+    authorizeUrl.searchParams.set("client_id", config.clientId);
+    authorizeUrl.searchParams.set("response_type", "code");
+    authorizeUrl.searchParams.set("redirect_uri", receiver.redirectUri);
+    authorizeUrl.searchParams.set("scope", config.scopes.join(" "));
+    authorizeUrl.searchParams.set("state", state);
+    authorizeUrl.searchParams.set("code_challenge", pkce.challenge);
+    authorizeUrl.searchParams.set("code_challenge_method", pkce.method);
+    if (options.signal?.aborted)
+      throw new DevtoolsError("CANCELLED", "\uB85C\uADF8\uC778\uC744 \uCDE8\uC18C\uD588\uC2B5\uB2C8\uB2E4.");
+    await options.openBrowser(authorizeUrl.toString());
+    const result = await receiver.waitForCode();
+    if (result.state !== state) {
+      throw new DevtoolsError("NOT_AUTHENTICATED", "\uB85C\uADF8\uC778 \uC751\uB2F5\uC774 \uC774 \uC694\uCCAD\uC758 \uAC83\uC774 \uC544\uB2D9\uB2C8\uB2E4.", "\uBE0C\uB77C\uC6B0\uC800 \uCC3D\uC744 \uBAA8\uB450 \uB2EB\uACE0 \uB2E4\uC2DC \uB85C\uADF8\uC778\uD574 \uC8FC\uC138\uC694.");
+    }
+    const tokens = await exchange(config, {
+      grant_type: "authorization_code",
+      code: result.code,
+      redirect_uri: receiver.redirectUri,
+      code_verifier: pkce.verifier
+    });
+    await store.write(tokens);
+    return tokens;
+  } finally {
+    receiver.close();
+  }
+}
+var refreshing = /* @__PURE__ */ new WeakMap();
+var logoutEpoch = /* @__PURE__ */ new WeakMap();
+var epochOf = (store) => logoutEpoch.get(store) ?? 0;
+async function getAccessToken(config, store) {
+  const inFlight = refreshing.get(store);
+  if (inFlight)
+    return inFlight;
+  const run = refreshToken(config, store);
+  refreshing.set(store, run);
+  try {
+    return await run;
+  } finally {
+    refreshing.delete(store);
+  }
+}
+async function refreshToken(config, store) {
+  const epoch = epochOf(store);
+  const current = await store.read();
+  if (!current) {
+    throw new DevtoolsError("NOT_AUTHENTICATED", "\uB85C\uADF8\uC778\uC774 \uD544\uC694\uD569\uB2C8\uB2E4.", "\uBA3C\uC800 \uC798\uCEE4\uB77C\uC5D0 \uB85C\uADF8\uC778\uD574 \uC8FC\uC138\uC694.");
+  }
+  if (current.issuer !== config.issuer) {
+    await store.clear();
+    throw new DevtoolsError("NOT_AUTHENTICATED", "\uC11C\uBC84\uAC00 \uBC14\uB00C\uC5B4 \uB2E4\uC2DC \uB85C\uADF8\uC778\uD574\uC57C \uD569\uB2C8\uB2E4.");
+  }
+  if (current.expiresAt - REFRESH_SKEW_MS > Date.now())
+    return current.accessToken;
+  let refreshed;
+  try {
+    refreshed = await exchange(config, { grant_type: "refresh_token", refresh_token: current.refreshToken });
+  } catch (cause) {
+    await store.clear();
+    throw new DevtoolsError("NOT_AUTHENTICATED", "\uB85C\uADF8\uC778\uC774 \uB9CC\uB8CC\uB418\uC5C8\uC2B5\uB2C8\uB2E4.", "\uB2E4\uC2DC \uB85C\uADF8\uC778\uD574 \uC8FC\uC138\uC694.", cause);
+  }
+  if (epochOf(store) !== epoch) {
+    throw new DevtoolsError("NOT_AUTHENTICATED", "\uB85C\uADF8\uC544\uC6C3\uB418\uC5C8\uC2B5\uB2C8\uB2E4.", "\uB2E4\uC2DC \uB85C\uADF8\uC778\uD574 \uC8FC\uC138\uC694.");
+  }
+  await store.write(refreshed);
+  return refreshed.accessToken;
+}
+async function logout(store) {
+  logoutEpoch.set(store, epochOf(store) + 1);
+  await store.clear();
+}
+async function exchange(config, params) {
+  const body = new URLSearchParams({ client_id: config.clientId, ...params });
+  const response = await fetch(`${trimSlash(config.issuer)}/protocol/openid-connect/token`, {
+    method: "POST",
+    headers: { "content-type": "application/x-www-form-urlencoded" },
+    body
+  });
+  if (!response.ok) {
+    const detail = await safeText(response);
+    throw new DevtoolsError("NOT_AUTHENTICATED", "\uD1A0\uD070 \uBC1C\uAE09\uC5D0 \uC2E4\uD328\uD588\uC2B5\uB2C8\uB2E4.", detail || void 0);
+  }
+  const token = await response.json();
+  if (!token.refresh_token) {
+    throw new DevtoolsError("NOT_AUTHENTICATED", "\uC11C\uBC84\uAC00 \uAC31\uC2E0 \uD1A0\uD070\uC744 \uC8FC\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4.", "\uC798\uCEE4\uB77C\uC5D0 \uBB38\uC758\uD574 \uC8FC\uC138\uC694(\uD655\uC7A5 \uD074\uB77C\uC774\uC5B8\uD2B8 \uC124\uC815 \uBB38\uC81C\uC77C \uC218 \uC788\uC2B5\uB2C8\uB2E4).");
+  }
+  return {
+    accessToken: token.access_token,
+    refreshToken: token.refresh_token,
+    expiresAt: Date.now() + token.expires_in * 1e3,
+    issuer: config.issuer
+  };
+}
+async function safeText(response) {
+  try {
+    return (await response.text()).slice(0, 200);
+  } catch {
+    return "";
+  }
+}
+function trimSlash(value) {
+  return value.replace(/\/+$/, "");
+}
+
+// ../core/dist/api.js
+init_errors();
+init_notice();
+var ZalkeraApi = class _ZalkeraApi {
+  fetchImpl;
+  options;
+  constructor(options) {
+    this.options = options;
+    this.fetchImpl = options.fetchImpl ?? fetch;
+  }
+  /**
+   * 내 소속 테넌트 — 테넌트 선택(A3)에 쓴다. 이 경로만 `X-Tenant` 를 요구하지 않는다(닭과 달걀).
+   *
+   * 내가 고를 수 있는 사이트. **`isSuperAdmin` 을 함께 돌려준다** — 목록이 비었다고 해서
+   * "사이트가 없다"가 아니기 때문이다.
+   *
+   * 서버는 `admin_user_tenant` **소속만** 열거한다. SUPER_ADMIN 은 소속과 무관하게 전 테넌트에
+   * 접근하므로(`AdminUserAuth.canAccessTenant`), 소속 행이 없는 순수 super-admin 은 **목록이 빈 채로
+   * 모든 사이트를 다룰 수 있다.** 그 둘을 구분하지 않으면 사용자에게 거짓을 말하게 된다.
+   */
+  async whoAmI() {
+    const me = await this.request("GET", "/api/me", { withTenant: false });
+    return { tenants: me.tenants ?? [], isSuperAdmin: me.isSuperAdmin === true };
+  }
+  async listMyTenants() {
+    return (await this.whoAmI()).tenants;
+  }
+  /**
+   * 미리보기 키 발급(memo146 §3.4). **재발급하면 이 테넌트의 이전 미리보기 키는 즉시 끊긴다** —
+   * `revokedPrevious` 가 0 이 아니면 호출부는 그 사실을 사람에게 말해야 한다(말 없이 끊기면 고장으로 읽힌다).
+   */
+  issuePreviewKey(label) {
+    return this.request("POST", "/api/partner/storefront-keys/preview", {
+      body: label ? { label } : {}
+    });
+  }
+  /**
+   * 스토어프론트 키 폐기 — **로그아웃이 진짜 로그아웃이 되게 하는 조각**(심의 경고).
+   *
+   * 이것이 없으면 로그아웃해도 이미 발급된 미리보기 키가 TTL(기본 12시간)까지 살아 있고, 그 키를 들고 있는
+   * dev 서버는 계속 상용 데이터를 읽는다. "로그아웃했다"는 화면과 실제가 어긋나는 자리다.
+   */
+  revokeStorefrontKey(keyId) {
+    return this.request("DELETE", `/api/partner/storefront-keys/${keyId}`);
+  }
+  /** 시작 소스 팩 목록(B1). 공개된 것만 온다 — 고를 수 없는 것은 안 보이는 편이 정직하다. */
+  listPresets() {
+    return this.request("GET", "/api/partner/site-preset/presets");
+  }
+  /** 팩 소스 zip 의 단기 URL + **sha256**(받는 쪽이 대조한다 — 그래야 "배달했으면 끝"이 검증 가능한 약속이 된다). */
+  presetSourceUrl(code2) {
+    return this.request("GET", `/api/partner/site-preset/presets/${encodeURIComponent(code2)}/source-url`);
+  }
+  /**
+   * 버전 이력(최신순). B2「현재 사이트 내려받기」와 롤백이 여기서 대상을 고른다.
+   *
+   * @param limit **최근 몇 개만** 받을지. 없으면 전량이다.
+   *
+   * ⚠ **판은 발행할 때마다 늘고 줄지 않는다.** 몇 개면 되는 소비자가 전량을 받으면 그 비용이 원장
+   *   크기에 비례해 영원히 자란다 — 반영 확인 폴링이 그 자리다(판 1,000개 테넌트에서 매 폴마다
+   *   전량). 구 서버는 이 파라미터를 **조용히 무시**하고 전량을 준다 — 동작은 종전과 같다.
+   */
+  listRevisions(limit) {
+    const path = "/api/partner/site-upload/revisions";
+    return this.request("GET", limit == null ? path : `${path}?limit=${limit}`);
+  }
+  /** 소스 tar.gz 다운로드 URL **+ sha256**(TENANT_ADMIN+). 소스 소유의 실물이고, 해시가 그 약속의 검산이다. */
+  sourceUrl(revisionNo) {
+    return this.request("GET", `/api/partner/site-upload/revisions/${revisionNo}/source-url`);
+  }
+  /**
+   * 버전 전환(롤백 포함). READY 인 버전만 받는다.
+   *
+   * ⚠ **소비하는 필드만 형에 둔다.** `pointerMoved` 는 「판을 옮겼다」와 「아무것도 안 옮겼다」를
+   *   가른다 — 종전에는 둘 다 성공이라 화면이 무동작을 「바꿨습니다」로 말했다.
+   *   **결여는 `true` 방향**이다(서버 기본값이 그렇고, 구서버는 이 필드를 안 보낸다).
+   */
+  activateRevision(revisionNo, discardPendingChanges = false) {
+    return this.request("POST", `/api/partner/site-upload/revisions/${revisionNo}/activate`, { body: { discardPendingChanges } });
+  }
+  /**
+   * 「지금 편집 중인 것이 있는가」 — 우리는 **`revertTargetRevisionNo` 하나만** 본다.
+   *
+   * ⚠ **못 읽어도 막지 않는다.** 구서버·권한 부족·망 단절이면 부르는 쪽이 `null` 로 강하하고,
+   *   그때 동작은 종전과 같다(`switchCandidates` 의 KDoc). 「모르는 것으로는 막지 않는다」.
+   */
+  draftState() {
+    return this.request("GET", "/api/partner/site-upload/draft");
+  }
+  /**
+   * 편집 중인 것을 **판 N+1 로 올린다**(memo184 §2.4 · `POST /draft/publish`).
+   *
+   * ⚠ **새 문을 내지 않는다** — 콘솔이 쓰는 그 문을 그대로 쓴다. 문이 둘이 되면 「발행했는가」를
+   *   두 곳에 물어야 하고, 한쪽만 고쳐지는 병이 시작된다.
+   * ⚠ **`actor` 를 본문에 안 싣는다.** 서버가 인증에서 만든다 — 실으면 아무 이름이나 박힌다.
+   *
+   * @param discardPendingChanges 게시 대기 AI 변경을 함께 버릴지. **명시 동의가 있을 때만** 참이다.
+   */
+  publishDraft(label, discardPendingChanges = false) {
+    return this.request("POST", "/api/partner/site-upload/draft/publish", {
+      body: { ...label === void 0 ? {} : { label }, discardPendingChanges }
+    });
+  }
+  /** 이 클라이언트가 어느 사이트를 가리키는가. 장부(`sync.json`)가 소속을 적을 때 쓴다. */
+  tenantCode() {
+    return this.options.tenantCode();
+  }
+  /**
+   * 소스 여러 파일을 **한 번에** 고친다(memo184 T0-① · `POST /draft/edits`).
+   *
+   * ⚠ **한 요청이 계약이다.** 파일마다 따로 부르면 드래프트 세대가 N 개 생기고, 그 중간 세대가
+   *   다른 문(발행·되돌리기)의 대상이 될 수 있다 — 의도한 변경의 **반쪽이 원장에 영구히 서는**
+   *   형상이다. 나눠 보내지 마라.
+   *
+   * ⚠ 거절은 **어느 경로가** 걸렸는지를 `errors[].field` 로 준다([DevtoolsError.paths]).
+   *   문면을 뜯지 마라 — 서버의 한국어 문구가 계약이 된다.
+   */
+  editDraft(edits) {
+    return this.request("POST", "/api/partner/site-upload/draft/edits", {
+      body: { edits }
+    });
+  }
+  /**
+   * 지금 편집 중인 것이 **무엇을 바꿔 놓았는가**(memo184 T0-② · `GET /draft/files`).
+   *
+   * ⚠ **선행조건의 정본이 이 문이다.** 로컬 도구는 다음 편집의 base sha 를 자기 장부가 아니라
+   *   여기서 받는다. 장부로 폴백하면 memo184 🔴1(남이 되돌린 뒤에도 「이미 반영됨」이라 말하는
+   *   거짓 성공)이 그대로 되살아난다.
+   * ⚠ `generation` 은 **불투명**하다. 값을 해석하거나 순서를 매기지 않는다 — 서버 내부 토큰이
+   *   클라이언트로 새지 않게 그렇게 정했다.
+   *
+   * 편집이 없으면 **빈 목록**이다(404 가 아니다 — 「없다」와 「못 물어봤다」를 가른다).
+   */
+  draftFiles() {
+    return this.request("GET", "/api/partner/site-upload/draft/files");
+  }
+  /** 업로드 presign — zip 을 S3 로 **직접** 올린다(백엔드 미경유). */
+  presignArchive(fileName, byteSize) {
+    return this.request("POST", "/api/partner/site-archive/presign", {
+      body: { fileName, contentType: "application/zip", byteSize }
+    });
+  }
+  /**
+   * 업로드 확정 — 서버가 언팩·검사하고 새 버전을 만든다.
+   *
+   * @param baseRevisionNo 이 올리기가 **딛는다고 선언하는 판**(동시 업로드 최소 방어). 서버가 판을
+   *   만들기 전에 원장 꼬리와 대조하고 다르면 `UPLOAD_BASE_MOVED` 409 로 멈춘다.
+   *   `null` 은 **무선언 — 현행 그대로 통과**다(모르는 것으로 막지 않는다).
+   *
+   * ⚠ **동의 재시도에서도 같은 값을 실어야 한다.** 백엔드는 `BaselineShiftGuard`(동의)를 기반
+   *   대조보다 **먼저** 지나므로, 동의 409 를 받고 재호출할 때 이 값을 빠뜨리면 **그 경로만 조용히
+   *   무선언**이 된다 — 방어가 있는 줄 알았는데 하필 편집이 있는 사이트에서만 없다.
+   */
+  confirmArchive(storageKey, discardPendingChanges = false, baseRevisionNo = null) {
+    return this.request("POST", "/api/partner/site-archive/confirm", {
+      // 선언이 없으면 **필드 자체를 안 보낸다** — `null` 을 보내도 서버는 같게 다루지만, 안 보내는
+      // 쪽이 「주장하지 않는다」는 뜻에 정확하고 구 서버와도 같은 와이어다.
+      body: baseRevisionNo == null ? { storageKey, discardPendingChanges } : { storageKey, discardPendingChanges, baseRevisionNo }
+    });
+  }
+  /**
+   * 요청 상한. **Node 의 `fetch` 는 기본 타임아웃이 없다** — 서버가 연결만 붙들고 응답을 안 주면
+   * 호출자가 영원히 매달린다. 로그아웃의 키 폐기는 진행 표시조차 없어 화면이 그냥 멈춘 것처럼 보인다.
+   *
+   * 이 값은 **제어 평면 호출**(수 KB JSON)의 상한이다. 대용량 업로드는 이 클래스를 통과하지 않는다
+   * (presign 으로 받은 URL 에 직접 올린다) — 그래서 짧게 잡아도 큰 전송을 끊지 않는다.
+   */
+  static REQUEST_TIMEOUT_MS = 3e4;
+  async request(method, path, init = {}) {
+    const headers = {
+      accept: "application/json",
+      authorization: `Bearer ${await this.options.accessToken()}`
+    };
+    if (init.withTenant !== false)
+      headers["x-tenant"] = this.options.tenantCode();
+    if (init.body !== void 0)
+      headers["content-type"] = "application/json";
+    let response;
+    try {
+      response = await this.fetchImpl(new URL(path, withTrailingSlash2(this.options.apiBase)), {
+        method,
+        headers,
+        signal: AbortSignal.timeout(_ZalkeraApi.REQUEST_TIMEOUT_MS),
+        ...init.body === void 0 ? {} : { body: JSON.stringify(init.body) }
+      });
+    } catch (cause) {
+      const timedOut = cause instanceof Error && (cause.name === "TimeoutError" || cause.name === "AbortError");
+      throw new DevtoolsError("SERVER_UNREACHABLE", timedOut ? "\uC798\uCEE4\uB77C \uC11C\uBC84\uAC00 \uC81C\uB54C \uC751\uB2F5\uD558\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4." : "\uC798\uCEE4\uB77C \uC11C\uBC84\uC5D0 \uC5F0\uACB0\uD558\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4.", timedOut ? "\uC7A0\uC2DC \uB4A4 \uB2E4\uC2DC \uC2DC\uB3C4\uD574 \uC8FC\uC138\uC694." : "\uC778\uD130\uB137\xB7\uC0AC\uB0B4\uB9DD \uD504\uB85D\uC2DC\uB97C \uD655\uC778\uD574 \uC8FC\uC138\uC694.", cause);
+    }
+    if (!response.ok)
+      throw await toError(response);
+    let envelope;
+    try {
+      envelope = await response.json();
+    } catch (cause) {
+      throw new DevtoolsError("SERVER_UNREACHABLE", "\uC11C\uBC84 \uC751\uB2F5\uC744 \uC774\uD574\uD558\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4.", `${this.options.apiBase} \uAC00 \uC798\uCEE4\uB77C \uC11C\uBC84\uAC00 \uB9DE\uB294\uC9C0, \uC0AC\uB0B4\uB9DD \uD504\uB85D\uC2DC\uAC00 \uC751\uB2F5\uC744 \uBC14\uAFB8\uACE0 \uC788\uC9C0 \uC54A\uC740\uC9C0 \uD655\uC778\uD574 \uC8FC\uC138\uC694.`, cause);
+    }
+    if (envelope === null || typeof envelope !== "object" || !("data" in envelope)) {
+      throw new DevtoolsError("SERVER_UNREACHABLE", "\uC11C\uBC84 \uC751\uB2F5\uC5D0 \uD544\uC694\uD55C \uC815\uBCF4\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4.", `${this.options.apiBase} \uAC00 \uC798\uCEE4\uB77C \uC11C\uBC84\uAC00 \uB9DE\uB294\uC9C0 \uD655\uC778\uD574 \uC8FC\uC138\uC694.`);
+    }
+    return envelope.data;
+  }
+};
+async function toError(response) {
+  let serverMessage = "";
+  let errorCode = "";
+  let paths = [];
+  try {
+    const body = await response.json();
+    serverMessage = plainNotice(body.message, MAX_SERVER_MESSAGE);
+    errorCode = plainNotice(body.errorCode ?? "", MAX_ERROR_CODE);
+    paths = (Array.isArray(body.errors) ? body.errors : []).map((row) => typeof row?.field === "string" ? plainNotice(row.field, MAX_PATH) : "").filter((path) => path !== "").slice(0, MAX_REJECTED_PATHS);
+  } catch {
+  }
+  if (response.status === 401) {
+    return new DevtoolsError("NOT_AUTHENTICATED", "\uB85C\uADF8\uC778\uC774 \uB9CC\uB8CC\uB418\uC5C8\uC2B5\uB2C8\uB2E4.", "\uB2E4\uC2DC \uB85C\uADF8\uC778\uD574 \uC8FC\uC138\uC694.");
+  }
+  if (response.status === 403) {
+    return new DevtoolsError("FORBIDDEN", serverMessage || "\uC774 \uC791\uC5C5\uC744 \uD560 \uAD8C\uD55C\uC774 \uC5C6\uC2B5\uB2C8\uB2E4.", "\uC0AC\uC774\uD2B8 \uC18C\uC2A4\uB97C \uB2E4\uB8E8\uB824\uBA74 \uAD00\uB9AC\uC790 \uAD8C\uD55C\uC774 \uD544\uC694\uD569\uB2C8\uB2E4. \uACC4\uC815 \uAD8C\uD55C\uC744 \uD655\uC778\uD574 \uC8FC\uC138\uC694.");
+  }
+  return new DevtoolsError("SERVER_REJECTED", serverMessage || `\uC11C\uBC84\uAC00 \uC694\uCCAD\uC744 \uAC70\uC808\uD588\uC2B5\uB2C8\uB2E4(HTTP ${response.status}).`, errorCode ? `\uC624\uB958 \uCF54\uB4DC: ${errorCode}` : void 0, void 0, errorCode || void 0, paths);
+}
+var DISCARD_CONSENT_CODES = /* @__PURE__ */ new Set([
+  // 판이 옮겨진다 — 전환은 진행되고, 게시 안 한 AI 변경이 함께 사라진다(`BaselineShiftGuard`).
+  "PENDING_AI_CHANGES_CONFIRM_REQUIRED",
+  // **판은 그대로다** — 이미 켜진 판을 다시 고른 것이라 「지금으로 되돌리기」로 갈리고,
+  // 편집과 게시 대기 AI 변경만 버린다(`discardToCurrent`). 잃는 것이 더 크므로 문면이 다르다.
+  "DRAFT_DISCARD_CONFIRM_REQUIRED"
+]);
+function needsDiscardConsent(error) {
+  return error instanceof DevtoolsError && DISCARD_CONSENT_CODES.has(error.serverCode ?? "");
+}
+var DRAFT_IN_PROGRESS = "DRAFT_IN_PROGRESS";
+function isDraftInProgress(error) {
+  return error instanceof DevtoolsError && error.serverCode === DRAFT_IN_PROGRESS;
+}
+var MAX_SERVER_MESSAGE = 300;
+var MAX_ERROR_CODE = 64;
+var MAX_PATH = 1024;
+var MAX_REJECTED_PATHS = 500;
+function withTrailingSlash2(base) {
+  return base.endsWith("/") ? base : `${base}/`;
+}
+
+// ../core/dist/safeWrite.js
+init_errors();
+import { lstat, mkdir, rename, rm, writeFile } from "node:fs/promises";
+import { randomBytes as randomBytes2 } from "node:crypto";
+import { basename, join, normalize, relative, resolve, sep } from "node:path";
+async function lstatOrAbsent(path, name) {
+  try {
+    return await lstat(path);
+  } catch (cause) {
+    const code2 = cause.code;
+    if (code2 === "ENOENT" || code2 === "ENOTDIR")
+      return null;
+    throw new DevtoolsError("SERVER_REJECTED", `${name} \uC744 \uD655\uC778\uD558\uC9C0 \uBABB\uD574 \uC4F0\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4(${code2 ?? "UNKNOWN"}).`, "\uD3F4\uB354 \uAD8C\uD55C\uC744 \uD655\uC778\uD558\uC2DC\uAC70\uB098, \uB2E4\uB978 \uBE48 \uD3F4\uB354\uB85C \uB2E4\uC2DC \uC2DC\uB3C4\uD574 \uC8FC\uC138\uC694.", cause);
+  }
+}
+function safeSegments(root, name) {
+  const cleaned = name.replace(/^(\.\/)+/, "");
+  if (cleaned.startsWith("/") || /^[A-Za-z]:/.test(cleaned) || cleaned.includes("\0")) {
+    throw new DevtoolsError("SERVER_REJECTED", `\uBC1B\uC740 \uD30C\uC77C\uC5D0 \uC774\uC0C1\uD55C \uACBD\uB85C\uAC00 \uC788\uC2B5\uB2C8\uB2E4: ${name}`);
+  }
+  const path = resolve(root, normalize(cleaned));
+  if (path !== root && !path.startsWith(root + sep)) {
+    throw new DevtoolsError("SERVER_REJECTED", `\uBC1B\uC740 \uD30C\uC77C\uC774 \uD3F4\uB354 \uBC16\uC744 \uAC00\uB9AC\uD0B5\uB2C8\uB2E4: ${name}`);
+  }
+  const segments = relative(root, path).split(sep).filter((part) => part.length > 0);
+  return segments;
+}
+async function descend(root, segments, verified) {
+  let current = root;
+  for (const part of segments) {
+    const next = join(current, part);
+    if (verified.has(next)) {
+      current = next;
+      continue;
+    }
+    const info = await lstatOrAbsent(next, part);
+    if (info?.isSymbolicLink()) {
+      throw new DevtoolsError("SERVER_REJECTED", `\uBC1B\uC740 \uAFB8\uB7EC\uBBF8\uAC00 \uB9C1\uD06C\uB97C \uAC70\uCCD0 \uD3F4\uB354 \uBC16\uC5D0 \uC4F0\uB824\uACE0 \uD569\uB2C8\uB2E4: ${part}`, "\uC798\uBABB \uBC1B\uC740 \uC0C1\uD0DC\uB85C \uC9C4\uD589\uD558\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4. \uC798\uCEE4\uB77C\uC5D0 \uBB38\uC758\uD574 \uC8FC\uC138\uC694.");
+    }
+    if (!info) {
+      await mkdir(next).catch((error) => {
+        if (error?.code !== "EEXIST")
+          throw error;
+      });
+    } else if (!info.isDirectory()) {
+      throw new DevtoolsError("SERVER_REJECTED", `\uBC1B\uC740 \uAFB8\uB7EC\uBBF8\uC758 \uACBD\uB85C\uAC00 \uD30C\uC77C\uACFC \uACB9\uCE69\uB2C8\uB2E4: ${part}`);
+    }
+    verified.add(next);
+    current = next;
+  }
+  return current;
+}
+async function assertNotSymlink(path, name) {
+  const info = await lstatOrAbsent(path, name);
+  if (info?.isSymbolicLink()) {
+    throw new DevtoolsError("SERVER_REJECTED", `\uBC1B\uC740 \uAFB8\uB7EC\uBBF8\uAC00 \uAE30\uC874 \uB9C1\uD06C\uB97C \uB36E\uC5B4\uC4F0\uB824\uACE0 \uD569\uB2C8\uB2E4: ${name}`);
+  }
+}
+async function writeOwnFile(path, data, mode = 420) {
+  const info = await lstat(path).catch(() => null);
+  if (info?.isSymbolicLink()) {
+    throw new DevtoolsError("NOT_A_SITE", `${basename(path)} \uC774 \uB9C1\uD06C\uB77C \uC4F0\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4.`, "\uC774 \uD30C\uC77C\uC740 \uD655\uC7A5\uC774 \uB9CC\uB4E4\uC5B4 \uC8FC\uB294 \uC790\uB9AC\uC785\uB2C8\uB2E4. \uB9C1\uD06C\uB97C \uC9C0\uC6B0\uACE0 \uB2E4\uC2DC \uC2DC\uB3C4\uD574 \uC8FC\uC138\uC694.");
+  }
+  await writeViaRename(path, data, mode);
+}
+async function writeViaRename(path, data, mode = 420) {
+  const tmp = `${path}.zalkera-${randomBytes2(6).toString("hex")}.tmp`;
+  try {
+    await writeFile(tmp, data, typeof data === "string" ? { encoding: "utf8", mode, flag: "wx" } : { mode, flag: "wx" });
+    await rename(tmp, path);
+  } catch (error) {
+    await rm(tmp, { force: true }).catch(() => void 0);
+    throw error;
+  }
+}
+async function ensureOwnDir(root, ...segments) {
+  let current = root;
+  for (const part of segments) {
+    const next = join(current, part);
+    const info = await lstat(next).catch(() => null);
+    if (info?.isSymbolicLink()) {
+      throw new DevtoolsError("NOT_A_SITE", `${part} \uC774 \uB9C1\uD06C\uB77C \uC4F0\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4.`, "\uC774 \uD3F4\uB354\uB294 \uD655\uC7A5\uC774 \uB9CC\uB4E4\uC5B4 \uC8FC\uB294 \uC790\uB9AC\uC785\uB2C8\uB2E4. \uB9C1\uD06C\uB97C \uC9C0\uC6B0\uACE0 \uB2E4\uC2DC \uC2DC\uB3C4\uD574 \uC8FC\uC138\uC694.");
+    }
+    if (!info) {
+      await mkdir(next).catch((error) => {
+        if (error?.code !== "EEXIST")
+          throw error;
+      });
+    } else if (!info.isDirectory()) {
+      throw new DevtoolsError("NOT_A_SITE", `${part} \uC774 \uD3F4\uB354\uAC00 \uC544\uB2C8\uB77C \uC4F0\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4.`);
+    }
+    current = next;
+  }
+  return current;
+}
+function assertNotVendored(segments, name) {
+  if (!segments.includes("node_modules"))
+    return;
+  throw new DevtoolsError("SERVER_REJECTED", `\uBC1B\uC740 \uD30C\uC77C\uC5D0 node_modules \uAC00 \uB4E4\uC5B4 \uC788\uC2B5\uB2C8\uB2E4: ${name}`, "\uBC1B\uC740 \uAFB8\uB7EC\uBBF8\uAC00 \uC815\uC0C1\uC774 \uC544\uB2D9\uB2C8\uB2E4. \uC798\uCEE4\uB77C\uC5D0 \uBB38\uC758\uD574 \uC8FC\uC138\uC694.");
+}
+async function writeExclusive(path, data, entryName, written) {
+  try {
+    await writeFile(path, data, { flag: "wx" });
+    written?.add(path);
+  } catch (error) {
+    if (error.code !== "EEXIST")
+      throw error;
+    assertNotWrittenTwice(path, entryName, written);
+    throw new DevtoolsError("SERVER_REJECTED", `\uBC1B\uC740 \uAFB8\uB7EC\uBBF8\uAC00 \uC774\uBBF8 \uC788\uB294 \uD30C\uC77C\uC744 \uB36E\uC73C\uB824 \uD569\uB2C8\uB2E4: ${entryName}`, "\uADF8 \uD30C\uC77C\uC740 \uC774 \uD3F4\uB354\uC5D0 \uC6D0\uB798 \uC788\uB358 \uAC83\uC785\uB2C8\uB2E4. \uBE48 \uD3F4\uB354\uB97C \uC0C8\uB85C \uB9CC\uB4E4\uC5B4 \uB2E4\uC2DC \uBC1B\uC544 \uC8FC\uC138\uC694.");
+  }
+}
+function assertNotWrittenTwice(path, entryName, written) {
+  if (!written?.has(path))
+    return;
+  throw new DevtoolsError("SERVER_REJECTED", `\uBC1B\uC740 \uAFB8\uB7EC\uBBF8\uAC00 \uAC19\uC740 \uD30C\uC77C\uC744 \uB450 \uBC88 \uB2F4\uACE0 \uC788\uC2B5\uB2C8\uB2E4: ${entryName}`, "\uBC1B\uC740 \uAC83\uC774 \uC798\uBABB\uB410\uC2B5\uB2C8\uB2E4 \u2014 \uBE48 \uD3F4\uB354\uB85C \uB2E4\uC2DC \uBC1B\uC544\uB3C4 \uAC19\uC740 \uC790\uB9AC\uC5D0\uC11C \uBA48\uCDA5\uB2C8\uB2E4. \uC798\uCEE4\uB77C\uC5D0 \uC54C\uB824 \uC8FC\uC138\uC694.");
+}
+
+// ../core/dist/project.js
+init_errors();
+import { existsSync } from "node:fs";
+import { readFile, writeFile as writeFile2 } from "node:fs/promises";
+import { join as join2 } from "node:path";
+async function inspectProject(dir) {
+  const packagePath = join2(dir, "package.json");
+  if (!existsSync(packagePath)) {
+    throw new DevtoolsError("NOT_A_SITE", "\uC774 \uD3F4\uB354\uC5D0\uC11C \uC0AC\uC774\uD2B8 \uC18C\uC2A4\uB97C \uCC3E\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4.", "\uC0AC\uC774\uD2B8 \uC18C\uC2A4 \uD3F4\uB354(package.json \uC774 \uC788\uB294 \uACF3)\uB97C \uACE8\uB77C \uC8FC\uC138\uC694.");
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(await readFile(packagePath, "utf8"));
+  } catch (cause) {
+    throw new DevtoolsError("NOT_A_SITE", "package.json \uC744 \uC77D\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4(\uD615\uC2DD \uC624\uB958).", "\uD30C\uC77C\uC774 \uD3B8\uC9D1 \uC911 \uAE68\uC84C\uB294\uC9C0 \uD655\uC778\uD574 \uC8FC\uC138\uC694.", cause);
+  }
+  const deps = { ...parsed.dependencies, ...parsed.devDependencies };
+  return {
+    dir,
+    name: parsed.name ?? dir.split("/").filter(Boolean).pop() ?? dir,
+    hasNext: "next" in deps,
+    clientVersion: deps["@zalkera/client"] ?? null,
+    toolInDeps: TOOL_PACKAGES.filter((name) => name in deps),
+    hasNodeModules: existsSync(join2(dir, "node_modules"))
+  };
+}
+var TOOL_PACKAGES = ["@zalkera/cli", "@zalkera/devtools", "zalkera", "zalkera-cli"];
+
+// ../core/dist/deps.js
+init_errors();
+
+// ../core/dist/untar.js
+import { createHash as createHash2 } from "node:crypto";
+import { chmod, lstat as lstat2, mkdir as mkdir2, open, realpath, rm as rm2, symlink, writeFile as writeFile3 } from "node:fs/promises";
+import { isAbsolute, join as join3, normalize as normalize2, relative as relative2, resolve as resolve2, sep as sep2 } from "node:path";
+
+// ../core/dist/limits.js
+var MAX_DOWNLOAD_BYTES = 150 * 1024 * 1024;
+var SOURCE_EXPANSION = 3;
+var MAX_EXTRACT_BYTES = MAX_DOWNLOAD_BYTES * SOURCE_EXPANSION;
+var MAX_ENTRY_BYTES = 200 * 1024 * 1024;
+var MAX_ENTRIES = 2e5;
+var MAX_NAME_BYTES = 8 * 1024 * 1024;
+
+// ../core/dist/untar.js
+init_errors();
+async function extractTar(tar, targetDir, options = {}) {
+  const sink = await createSink(targetDir, options);
+  await forEachBufferedEntry(tar, (meta, data) => sink.consume(meta, data));
+  return sink.fileCount();
+}
+async function forEachBufferedEntry(tar, consume) {
+  let offset = 0;
+  while (offset + BLOCK <= tar.length) {
+    const header = tar.subarray(offset, offset + BLOCK);
+    if (isEndOfArchive(header))
+      break;
+    const meta = parseHeader(header);
+    offset += BLOCK;
+    if (offset + meta.size > tar.length) {
+      throw new DevtoolsError("SERVER_REJECTED", "\uBC1B\uC740 \uD30C\uC77C\uC774 \uC911\uAC04\uC5D0 \uB04A\uACBC\uC2B5\uB2C8\uB2E4.");
+    }
+    const data = tar.subarray(offset, offset + meta.size);
+    offset += Math.ceil(meta.size / BLOCK) * BLOCK;
+    await consume(meta, data);
+  }
+}
+async function readTarGzManifest(gzipped, options = {}) {
+  return readTarManifest(await gunzipBuffer(gzipped, options.maxBytes), options);
+}
+async function readTarManifest(tar, options = {}) {
+  const manifest = {};
+  const root = resolve2(sep2, "zalkera-manifest-root");
+  let entries = 0;
+  const entryCap = Math.min(options.maxEntries ?? MAX_ENTRIES, MAX_ENTRIES);
+  const names = createNameResolver();
+  await forEachBufferedEntry(tar, async (meta, data) => {
+    entries += 1;
+    if (entries > entryCap) {
+      throw new DevtoolsError("SERVER_REJECTED", `\uBC1B\uC740 \uD30C\uC77C\uC758 \uD56D\uBAA9\uC774 \uB108\uBB34 \uB9CE\uC2B5\uB2C8\uB2E4(${entryCap}\uAC1C \uCD08\uACFC).`, "\uC798\uBABB \uBC1B\uC740 \uC0C1\uD0DC\uB85C \uC9C4\uD589\uD558\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4. \uC798\uCEE4\uB77C\uC5D0 \uBB38\uC758\uD574 \uC8FC\uC138\uC694.");
+    }
+    const resolved = names.resolve(meta, data);
+    if (!resolved)
+      return;
+    const { name } = resolved;
+    assertKnownEntryType(meta.type, name);
+    if (meta.type !== "0" && meta.type !== "\0")
+      return;
+    const segments = safeSegments(root, name);
+    if (options.rejectVendored === true)
+      assertNotVendored(segments, name);
+    const path = segments.join("/");
+    if (path === "")
+      return;
+    manifest[path] = { sha256: createHash2("sha256").update(data).digest("hex"), bytes: meta.size };
+  });
+  return manifest;
+}
+var BLOCK = 512;
+function isEndOfArchive(header) {
+  return header.every((byte) => byte === 0);
+}
+function parseHeader(header) {
+  const size = parseOctal(header.subarray(124, 136));
+  if (!Number.isFinite(size) || size < 0) {
+    throw new DevtoolsError("SERVER_REJECTED", "\uBC1B\uC740 \uD30C\uC77C\uC774 \uC190\uC0C1\uB418\uC5C8\uC2B5\uB2C8\uB2E4(\uAE38\uC774 \uD544\uB4DC \uC624\uB958).");
+  }
+  if (size > MAX_ENTRY_BYTES) {
+    throw new DevtoolsError("SERVER_REJECTED", `\uBC1B\uC740 \uD30C\uC77C\uC5D0 \uBE44\uC815\uC0C1\uC801\uC73C\uB85C \uD070 \uD56D\uBAA9\uC774 \uC788\uC2B5\uB2C8\uB2E4(${size}B).`, "\uC798\uBABB \uBC1B\uC740 \uC0C1\uD0DC\uB85C \uC9C4\uD589\uD558\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4. \uC798\uCEE4\uB77C\uC5D0 \uBB38\uC758\uD574 \uC8FC\uC138\uC694.");
+  }
+  const rawName = cstring(header.subarray(0, 100));
+  const prefix = cstring(header.subarray(345, 500));
+  return {
+    name: prefix ? `${prefix}/${rawName}` : rawName,
+    size,
+    type: String.fromCharCode(header[156] ?? 0),
+    mode: parseOctal(header.subarray(100, 108)) || 420,
+    linkTarget: cstring(header.subarray(157, 257))
+  };
+}
+function createNameResolver() {
+  let pendingName = null;
+  let pendingLink = null;
+  return {
+    resolve(entry, data) {
+      if (entry.type === "L") {
+        pendingName = cstring(data);
+        return null;
+      }
+      if (entry.type === "x" || entry.type === "g") {
+        const path = parsePaxPath(data);
+        if (path)
+          pendingName = path;
+        return null;
+      }
+      if (entry.type === "K") {
+        pendingLink = cstring(data);
+        return null;
+      }
+      const name = pendingName ?? entry.name;
+      pendingName = null;
+      const linkTarget = pendingLink ?? entry.linkTarget;
+      pendingLink = null;
+      return { name, linkTarget };
+    }
+  };
+}
+function assertKnownEntryType(type, name) {
+  if (type === "0" || type === "\0" || type === "5" || type === "2" || type === "1")
+    return;
+  throw new DevtoolsError("SERVER_REJECTED", `\uBC1B\uC740 \uD30C\uC77C\uC5D0 \uB2E4\uB8F0 \uC218 \uC5C6\uB294 \uD56D\uBAA9\uC774 \uC788\uC2B5\uB2C8\uB2E4(\uD615\uC2DD ${type}): ${name}`, "\uC798\uCEE4\uB77C\uC5D0 \uBB38\uC758\uD574 \uC8FC\uC138\uC694. \uC798\uBABB \uBC1B\uC740 \uC0C1\uD0DC\uB85C \uC9C4\uD589\uD558\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4.");
+}
+async function createSink(targetDir, options) {
+  await mkdir2(targetDir, { recursive: true });
+  const root = await realpath(targetDir);
+  const verified = /* @__PURE__ */ new Set([root]);
+  let entries = 0;
+  const entryCap = Math.min(options.maxEntries ?? MAX_ENTRIES, MAX_ENTRIES);
+  const materializeLinks = options.symlinks === "materialize";
+  const preserveMode = options.preserveMode === true;
+  let count2 = 0;
+  const writtenPaths = /* @__PURE__ */ new Set();
+  const foldedPaths = /* @__PURE__ */ new Set();
+  const names = createNameResolver();
+  return {
+    fileCount: () => count2,
+    async consume(entry, data) {
+      entries += 1;
+      if (entries > entryCap) {
+        throw new DevtoolsError("SERVER_REJECTED", `\uBC1B\uC740 \uD30C\uC77C\uC5D0 \uD56D\uBAA9\uC774 \uB108\uBB34 \uB9CE\uC2B5\uB2C8\uB2E4(\uC0C1\uD55C ${entryCap.toLocaleString()}\uAC1C).`);
+      }
+      const resolved = names.resolve(entry, data);
+      if (!resolved)
+        return;
+      const { name, linkTarget } = resolved;
+      const segments = safeSegments(root, name);
+      if (options.rejectVendored === true)
+        assertNotVendored(segments, name);
+      if (entry.type === "5") {
+        if (options.decide)
+          return;
+        await descend(root, segments, verified);
+        return;
+      }
+      if (entry.type === "2") {
+        if (!materializeLinks)
+          return;
+        await writeSymlink(root, segments, name, linkTarget, verified);
+        return;
+      }
+      if (entry.type === "1")
+        return;
+      assertKnownEntryType(entry.type, name);
+      const leaf = segments[segments.length - 1];
+      if (!leaf)
+        throw new DevtoolsError("SERVER_REJECTED", `\uBC1B\uC740 \uD30C\uC77C\uC5D0 \uC774\uC0C1\uD55C \uACBD\uB85C\uAC00 \uC788\uC2B5\uB2C8\uB2E4: ${name}`);
+      const verdict = options.decide?.(segments.join("/")) ?? "create";
+      if (verdict === "skip")
+        return;
+      const parent = await descend(root, segments.slice(0, -1), verified);
+      const path = join3(parent, leaf);
+      await assertNotSymlink(path, name);
+      if (verdict === "replace") {
+        assertNotWrittenTwice(path, name, writtenPaths);
+        assertNotWrittenTwice(path.toLowerCase(), name, foldedPaths);
+        await writeViaRename(path, data, preserveMode && (entry.mode & 73) !== 0 ? 493 : 420);
+        writtenPaths.add(path);
+        foldedPaths.add(path.toLowerCase());
+      } else {
+        await writeExclusive(path, data, name, writtenPaths);
+      }
+      if (preserveMode && (entry.mode & 73) !== 0) {
+        await chmod(path, 493).catch(() => {
+        });
+      }
+      count2 += 1;
+    }
+  };
+}
+async function writeSymlink(root, segments, name, target, verified) {
+  if (!target)
+    return;
+  if (isAbsolute(target) || /^[A-Za-z]:/.test(target)) {
+    throw new DevtoolsError("SERVER_REJECTED", `\uBC1B\uC740 \uAFB8\uB7EC\uBBF8\uC5D0 \uC808\uB300\uACBD\uB85C \uB9C1\uD06C\uAC00 \uC788\uC2B5\uB2C8\uB2E4: ${name}`);
+  }
+  const leaf = segments[segments.length - 1];
+  if (!leaf)
+    throw new DevtoolsError("SERVER_REJECTED", `\uBC1B\uC740 \uAFB8\uB7EC\uBBF8\uC5D0 \uC774\uC0C1\uD55C \uB9C1\uD06C \uC774\uB984\uC774 \uC788\uC2B5\uB2C8\uB2E4: ${name}`);
+  const parent = await descend(root, segments.slice(0, -1), verified);
+  const resolved = resolve2(parent, target);
+  if (resolved !== root && !resolved.startsWith(root + sep2)) {
+    throw new DevtoolsError("SERVER_REJECTED", `\uBC1B\uC740 \uAFB8\uB7EC\uBBF8\uC758 \uB9C1\uD06C\uAC00 \uD3F4\uB354 \uBC16\uC744 \uAC00\uB9AC\uD0B5\uB2C8\uB2E4: ${name}`);
+  }
+  const linkPath = join3(parent, leaf);
+  await assertNotSymlink(linkPath, name);
+  await symlink(relative2(parent, resolved) || ".", linkPath).catch((error) => {
+    throw new DevtoolsError("SERVER_REJECTED", `\uB9C1\uD06C\uB97C \uB9CC\uB4E4\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4: ${name}`, "\uBC1B\uB294 \uD3F4\uB354\uB97C \uBE44\uC6B0\uACE0 \uB2E4\uC2DC \uC2DC\uB3C4\uD574 \uC8FC\uC138\uC694.", error);
+  });
+}
+function cstring(buffer) {
+  const end = buffer.indexOf(0);
+  return buffer.subarray(0, end === -1 ? buffer.length : end).toString("utf8");
+}
+function parsePaxPath(data) {
+  const text = data.toString("utf8");
+  const match = /(?:^|\n)\d+ path=([^\n]*)\n/.exec(text);
+  return match?.[1] ?? null;
+}
+function parseOctal(buffer) {
+  const text = cstring(buffer).trim();
+  return text.length === 0 ? 0 : Number.parseInt(text, 8);
+}
+function resolveCap(maxBytes) {
+  return maxBytes ?? MAX_EXTRACT_BYTES;
+}
+async function gunzipTar(input, maxBytes) {
+  return gunzipBuffer(input, maxBytes);
+}
+async function gunzipBuffer(input, maxBytes) {
+  const { gunzip: gunzipCb } = await import("node:zlib");
+  const { promisify: promisify3 } = await import("node:util");
+  const cap = resolveCap(maxBytes);
+  try {
+    return await promisify3(gunzipCb)(input, { maxOutputLength: cap });
+  } catch (cause) {
+    throw new DevtoolsError("SERVER_REJECTED", "\uBC1B\uC740 \uD30C\uC77C\uC774 \uB108\uBB34 \uD06C\uAC70\uB098 \uC190\uC0C1\uB418\uC5C8\uC2B5\uB2C8\uB2E4.", "\uB2E4\uC2DC \uC2DC\uB3C4\uD574\uB3C4 \uAC19\uC73C\uBA74 \uC798\uCEE4\uB77C\uC5D0 \uBB38\uC758\uD574 \uC8FC\uC138\uC694.", cause);
+  }
+}
+
+// ../core/dist/payload.js
+var EXTRACT_RATIO_CAP = 8;
+var DISK_HEADROOM = 1 + 2 * EXTRACT_RATIO_CAP;
+var MIN_EXTRACT_CAP = 32 * 1024 * 1024;
+
+// ../core/dist/index.js
+init_dev();
+
+// ../core/dist/syncLedger.js
+var SYNC_LEDGER_PATH = ".zalkera/sync.json";
+var SYNC_LEDGER_FORMAT = 1;
+function parseSyncLedger(text) {
+  let raw;
+  try {
+    raw = JSON.parse(text);
+  } catch {
+    return null;
+  }
+  if (typeof raw !== "object" || raw === null)
+    return null;
+  const o = raw;
+  if (o.format !== SYNC_LEDGER_FORMAT)
+    return null;
+  if (typeof o.tenant !== "string" || o.tenant === "")
+    return null;
+  const base = o.base;
+  if (!base || typeof base.revisionNo !== "number" || typeof base.tarSha256 !== "string")
+    return null;
+  const files = {};
+  const rawFiles = o.files;
+  if (typeof rawFiles !== "object" || rawFiles === null)
+    return null;
+  for (const [path, value] of Object.entries(rawFiles)) {
+    const f = value;
+    if (typeof f?.sha256 !== "string" || typeof f?.bytes !== "number")
+      return null;
+    files[path] = { sha256: f.sha256, bytes: f.bytes };
+  }
+  const server = o.server;
+  if (server !== null && server !== void 0 && typeof server.generation !== "string")
+    return null;
+  const mine = {};
+  const rawMine = o.mine;
+  if (rawMine !== void 0) {
+    if (typeof rawMine !== "object" || rawMine === null)
+      return null;
+    for (const [path, value] of Object.entries(rawMine)) {
+      if (value !== null && typeof value !== "string")
+        return null;
+      mine[path] = value;
+    }
+  }
+  return {
+    format: SYNC_LEDGER_FORMAT,
+    tenant: o.tenant,
+    base: { revisionNo: base.revisionNo, tarSha256: base.tarSha256 },
+    files,
+    server: server == null ? null : { generation: server.generation },
+    mine,
+    pulledAt: typeof o.pulledAt === "string" ? o.pulledAt : "",
+    pushedAt: typeof o.pushedAt === "string" ? o.pushedAt : null
+  };
+}
+function serializeSyncLedger(ledger) {
+  return `${JSON.stringify(ledger, null, 2)}
+`;
+}
+
+// ../core/dist/localMark.js
+import { join as join4 } from "node:path";
+var SOURCE_MARK_PATH = ".zalkera/source.json";
+var TENANT_CODE = /^[a-z0-9][a-z0-9-]{0,62}$/;
+var MAX_REVISION_NO = 2147483647;
+function plausibleRevisionNo(no) {
+  return typeof no === "number" && Number.isSafeInteger(no) && no > 0 && no <= MAX_REVISION_NO ? no : null;
+}
+function buildSourceMark(input) {
+  const mark = { format: 1, ...input };
+  return `${JSON.stringify(mark, null, 2)}
+`;
+}
+function parseSourceMark(text) {
+  if (text === null)
+    return null;
+  let raw;
+  try {
+    raw = JSON.parse(text);
+  } catch {
+    return null;
+  }
+  if (typeof raw !== "object" || raw === null)
+    return null;
+  const o = raw;
+  if (typeof o.tenant !== "string" || !TENANT_CODE.test(o.tenant))
+    return null;
+  if (o.format === 1) {
+    if (typeof o.revisionNo !== "number" || !Number.isInteger(o.revisionNo))
+      return null;
+    if (typeof o.sha256 !== "string" || o.sha256.length === 0)
+      return null;
+    if (typeof o.fetchedAt !== "string")
+      return null;
+    return { format: 1, tenant: o.tenant, revisionNo: o.revisionNo, sha256: o.sha256, fetchedAt: o.fetchedAt };
+  }
+  if (o.format === 2 && o.origin === "published") {
+    if (typeof o.revisionNo !== "number" || !Number.isInteger(o.revisionNo))
+      return null;
+    if (typeof o.publishedAt !== "string")
+      return null;
+    return {
+      format: 2,
+      origin: "published",
+      tenant: o.tenant,
+      revisionNo: o.revisionNo,
+      publishedAt: o.publishedAt
+    };
+  }
+  if (o.format === 2 && o.origin === "linked") {
+    if (typeof o.linkedAt !== "string")
+      return null;
+    return { format: 2, origin: "linked", tenant: o.tenant, linkedAt: o.linkedAt };
+  }
+  return null;
+}
+async function writeSourceMarkTo(root, mark) {
+  return writeMarkText(root, buildSourceMark(mark));
+}
+async function writeMarkText(root, text) {
+  try {
+    await ensureOwnDir(root, ".zalkera");
+    await writeOwnFile(join4(root, SOURCE_MARK_PATH), text);
+    return { ok: true, text: "" };
+  } catch (error) {
+    return { ok: false, reason: error instanceof Error ? error.message : String(error) };
+  }
+}
+
+// ../core/dist/provenance.js
+var PROVENANCE_PATH = ".zalkera/provenance.json";
+
+// ../core/dist/zip.js
+init_errors();
+import { join as join5, relative as relative3, sep as sep3 } from "node:path";
+import { deflateRaw } from "node:zlib";
+import { promisify } from "node:util";
+var deflate = promisify(deflateRaw);
+var ALWAYS_EXCLUDED = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  // macOS 기본 압축이 만드는 부스러기. 발행에도 들여오기에도 실릴 이유가 없다.
+  // ⚠ 조회가 소문자라 **항목도 소문자여야 한다**(위 .ds_store 와 같은 함정).
+  "__macosx",
+  ".next",
+  "dist",
+  "out",
+  ".ds_store",
+  // ⚠ 조회가 소문자라 **항목도 소문자여야 한다**(아래 참조)
+  ".turbo",
+  ".vercel",
+  ".claude",
+  // ── 아래 넷은 심의 실측으로 추가됐다(2026-08-10) ──────────────────────────
+  // 이 목록이 옛 배치 기준으로 쓰인 뒤 **우리가 파일을 늘렸는데** 목록을 안 늘렸다.
+  //
+  // `.mcp.json` 은 **우리가 만든다**(「에이전트 연결」). 그리고 그 파일은 남의 MCP 서버 항목을
+  // 일부러 보존하는데(mcp.ts), stdio 형 서버는 관례적으로 `env: { GITHUB_TOKEN: … }` 를 들고 다닌다.
+  // 우리가 만든 파일이 정본 소스가 되어 그 버전을 받는 **모두에게** 배포되는 자리였다.
+  ".mcp.json",
+  // `.vscode/settings.json` 에는 **우리가 적은 `zalkera.tenant`** 가 들어 있다(`configTarget()`).
+  // 그것이 zip 에 실려 유통되면, 그 소스를 받아 연 사람의 확장이 조용히 그 테넌트를 가리킨다.
+  // 편집기 설정은 **배포되는 사이트의 내용이 아니다** — 빠져도 잃는 것이 없다.
+  ".vscode",
+  ".idea",
+  // 홈 디렉터리 자격증명이 프로젝트 안에 복사돼 있는 경우가 실제로 있다.
+  ".ssh",
+  ".aws"
+]);
+function isValueLessTemplate(lower) {
+  return lower.startsWith(".env") && /\.(example|sample|template)$/.test(lower);
+}
+var LIVE_SECRET = [
+  ["\uC798\uCEE4\uB77C \uC2A4\uD1A0\uC5B4\uD504\uB860\uD2B8 \uD0A4", /\boqsk_[0-9A-Za-z_-]{8,}/],
+  ["AWS \uC561\uC138\uC2A4\uD0A4", /\bAKIA[0-9A-Z]{16}\b/],
+  ["\uAC1C\uC778\uD0A4 \uBE14\uB85D", /-----BEGIN [A-Z ]{0,20}PRIVATE KEY-----/],
+  ["\uACB0\uC81C \uB77C\uC774\uBE0C \uC2DC\uD06C\uB9BF", /\b(?:sk_live_|live_sk_)[0-9A-Za-z]{8,}/],
+  ["GitHub \uD1A0\uD070", /\b(?:gh[pousr]_[0-9A-Za-z]{20,}|github_pat_[0-9A-Za-z_]{20,})\b/],
+  ["Slack \uD1A0\uD070", /\bxox[abprs]-[0-9A-Za-z-]{10,}\b/],
+  ["Google API \uD0A4", /\bAIza[0-9A-Za-z_-]{35}\b/],
+  ["npm \uD1A0\uD070", /\bnpm_[0-9A-Za-z]{36}\b/]
+];
+var AWS_DOC_PLACEHOLDER = /\bAKIA[0-9A-Z]{9}EXAMPLE\b/;
+var AWS_LIVE_KEY = /\bAKIA(?![0-9A-Z]{9}EXAMPLE\b)[0-9A-Z]{16}\b/;
+var URL_CREDENTIAL = /\b[a-z][a-z0-9+.-]*:\/\/[^\s/:@]+:[^\s/@]{3,}@([^\s/?#]+)/;
+var UNREACHABLE_HOST = /^(?:localhost|0\.0\.0\.0|::1|127\.\d+\.\d+\.\d+|10\.\d+\.\d+\.\d+|192\.168\.\d+\.\d+|172\.(?:1[6-9]|2\d|3[01])\.\d+\.\d+)$/i;
+var UNREACHABLE_SUFFIX = /\.(?:local|localhost|internal|test|invalid)$/i;
+function reachableHost(raw) {
+  const host = raw.replace(/:\d+$/, "").replace(/^\[|\]$/g, "");
+  if (UNREACHABLE_HOST.test(host) || UNREACHABLE_SUFFIX.test(host))
+    return false;
+  return host.includes(".");
+}
+var TEMPLATE_SCAN_BYTES = 256 * 1024;
+function decodeTemplate(data) {
+  if (data.length >= 4 && data[0] === 255 && data[1] === 254 && data[2] === 0 && data[3] === 0)
+    return null;
+  if (data.length >= 4 && data[0] === 0 && data[1] === 0 && data[2] === 254 && data[3] === 255)
+    return null;
+  if (data.length >= 2 && data[0] === 255 && data[1] === 254) {
+    return data.subarray(2).toString("utf16le");
+  }
+  if (data.length >= 2 && data[0] === 254 && data[1] === 255) {
+    const swapped = Buffer.from(data.subarray(2));
+    swapped.swap16();
+    return swapped.toString("utf16le");
+  }
+  if (data.includes(0))
+    return null;
+  return data.toString("utf8");
+}
+function templateHoldsSecret(text) {
+  if (/-----BEGIN [A-Z ]{0,20}PRIVATE KEY-----/.test(text))
+    return "\uAC1C\uC778\uD0A4 \uBE14\uB85D";
+  for (const raw of text.split(/\r?\n/)) {
+    const line = raw.trim();
+    if (line === "")
+      continue;
+    const eq = line.replace(/^#+\s*/, "").indexOf("=");
+    if (eq < 0)
+      continue;
+    const value = line.replace(/^#+\s*/, "").slice(eq + 1).trim().replace(/^(["'])(.*)\1$/, "$2");
+    if (value === "")
+      continue;
+    for (const [what, pattern] of LIVE_SECRET) {
+      if (!pattern.test(value))
+        continue;
+      if (what === "AWS \uC561\uC138\uC2A4\uD0A4" && AWS_DOC_PLACEHOLDER.test(value) && !AWS_LIVE_KEY.test(value)) {
+        continue;
+      }
+      return what;
+    }
+    const url = URL_CREDENTIAL.exec(value);
+    if (url !== null && reachableHost(url[1] ?? ""))
+      return "URL \uB0B4\uC7A5 \uC790\uACA9\uC99D\uBA85";
+  }
+  return null;
+}
+function isSecretFile(name, isDirectory = false) {
+  const lower = name.toLowerCase();
+  if (!isDirectory && isValueLessTemplate(lower))
+    return false;
+  if (lower.startsWith(".env"))
+    return true;
+  if (SECRET_NAMES.has(lower))
+    return true;
+  if (SECRET_SUFFIXES.some((suffix) => lower.endsWith(suffix)))
+    return true;
+  if (lower.endsWith(".json") && (lower.startsWith("service-account") || lower.includes("firebase-adminsdk"))) {
+    return true;
+  }
+  return lower.endsWith(".env");
+}
+var SECRET_NAMES = /* @__PURE__ */ new Set([
+  "id_rsa",
+  "id_dsa",
+  "id_ecdsa",
+  "id_ed25519",
+  "credentials.json",
+  ".npmrc",
+  // 심의 추가(2026-08-10) — 셋 다 **평문 자격증명**을 담는 표준 파일명이다.
+  ".netrc",
+  "_netrc",
+  // 윈도 변형 — 같은 파일이다
+  ".git-credentials",
+  ".yarnrc.yml",
+  // 도구별 자격증명 파일. 전부 **평문**이고, 홈이 아니라 프로젝트 루트에 놓이는 일이 흔하다.
+  ".dockercfg",
+  ".pgpass",
+  // libpq — `host:port:db:user:password`
+  ".pypirc",
+  // twine 업로드 토큰
+  "kubeconfig",
+  // 클러스터 자격증명(이름 그대로 두는 관례)
+  "secrets.json"
+  // .NET user-secrets 등의 관례명
+]);
+var SECRET_SUFFIXES = [".pem", ".key", ".p12", ".pfx", ".p8"];
+var EXCLUDED_PATHS = /* @__PURE__ */ new Set([".zalkera/source.json", SYNC_LEDGER_PATH, PROVENANCE_PATH]);
+var EXCLUDED_PREFIXES = [".zalkera/saved/"];
+function isExcludedPath(path) {
+  return EXCLUDED_PATHS.has(path) || EXCLUDED_PREFIXES.some((prefix) => path.startsWith(prefix));
+}
+function isExcludedEntry(entryPath) {
+  const path = entryPath.split(sep3).join("/").toLowerCase();
+  if (isExcludedPath(path))
+    return true;
+  const segments = path.split("/").filter((s) => s !== "");
+  if (segments.some((segment) => ALWAYS_EXCLUDED.has(segment)))
+    return true;
+  return segments.some((segment, at) => isSecretFile(segment, at < segments.length - 1));
+}
+function templateBreach(name, data) {
+  if (!isValueLessTemplate(name.toLowerCase()))
+    return null;
+  if (data.byteLength > TEMPLATE_SCAN_BYTES)
+    return "\uC11C\uC2DD\uCE58\uACE0 \uB108\uBB34 \uD07D\uB2C8\uB2E4";
+  const text = decodeTemplate(data);
+  if (text === null)
+    return "\uAE00\uC790\uB85C \uC77D\uD788\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4";
+  return templateHoldsSecret(text);
+}
+var MAX_FILE_BYTES = 100 * 1024 * 1024;
+var MAX_RAW_BYTES = 300 * 1024 * 1024;
+
+// ../core/dist/publish.js
+init_errors();
+var MAX_ARCHIVE_BYTES = 100 * 1024 * 1024;
+var TRANSFER_TIMEOUT_MS = 15 * 60 * 1e3;
+
+// ../core/dist/preview.js
+init_dev();
+init_errors();
+
+// ../core/dist/fetchSource.js
+import { createHash as createHash3 } from "node:crypto";
+init_errors();
+
+// ../core/dist/fetchTarget.js
+init_errors();
+function pickRevision(revisions) {
+  const active = revisions.find((r) => r.isActive && r.status === "READY");
+  if (active)
+    return { revisionNo: active.revisionNo, why: "active" };
+  let best = null;
+  for (const r of revisions) {
+    if (r.status !== "READY")
+      continue;
+    if (best === null || r.revisionNo > best.revisionNo)
+      best = r;
+  }
+  return best === null ? null : { revisionNo: best.revisionNo, why: "latest-ready" };
+}
+function noRevisionError(revisions) {
+  if (revisions.length === 0) {
+    return new DevtoolsError("NOT_A_SITE", "\uC544\uC9C1 \uC62C\uB9B0 \uC0AC\uC774\uD2B8 \uC18C\uC2A4\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4.", "\u300C\uC608\uC81C zip \uB2E4\uC6B4\uB85C\uB4DC\u300D\uB85C \uC608\uC81C\uB97C \uBC1B\uC544 \u300Czip \uC73C\uB85C \uC2DC\uC791\u300D\uC73C\uB85C \uD478\uC2DC\uAC70\uB098, \uC798\uCEE4\uB77C \uCF58\uC194\uC5D0\uC11C \uC18C\uC2A4\uB97C \uBA3C\uC800 \uC62C\uB824 \uC8FC\uC138\uC694.");
+  }
+  return new DevtoolsError("NOT_A_SITE", "\uBC1B\uC744 \uC218 \uC788\uB294 \uD310\uC774 \uC5C6\uC2B5\uB2C8\uB2E4.", "\uC62C\uB9B0 \uD310\uC774 \uC544\uC9C1 \uB9CC\uB4E4\uC5B4\uC9C0\uB294 \uC911\uC774\uAC70\uB098 \uC2E4\uD328\uD588\uC2B5\uB2C8\uB2E4. \u300C\uBC84\uC804 \uC774\uB825\u300D\uC5D0\uC11C \uD655\uC778\uD574 \uC8FC\uC138\uC694.");
+}
+
+// ../core/dist/download.js
+init_errors();
+async function openBounded(url, options) {
+  if (apiBaseUrl(url) === null) {
+    throw new DevtoolsError("SERVER_REJECTED", `${options.what} \uC8FC\uC18C\uB97C \uC2E0\uB8B0\uD560 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.`, "\uC798\uCEE4\uB77C\uC5D0 \uBB38\uC758\uD574 \uC8FC\uC138\uC694. \uBC1B\uC9C0 \uC54A\uACE0 \uBA48\uCDC4\uC2B5\uB2C8\uB2E4.");
+  }
+  const response = await options.fetchImpl(url, { signal: AbortSignal.timeout(options.timeoutMs) });
+  if (!response.ok || !response.body) {
+    throw new DevtoolsError("SERVER_REJECTED", `${options.what}\uB97C \uB0B4\uB824\uBC1B\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4(HTTP ${response.status}).`, "\uC7A0\uC2DC \uB4A4 \uB2E4\uC2DC \uC2DC\uB3C4\uD574 \uC8FC\uC138\uC694.");
+  }
+  return response.body;
+}
+function tooBig(what, limit) {
+  return new DevtoolsError("SERVER_REJECTED", `${what}\uAC00 \uB108\uBB34 \uD07D\uB2C8\uB2E4(\uC0C1\uD55C ${Math.round(limit / 1024 / 1024)}MB).`, "\uBC1B\uC740 \uAC83\uC774 \uC815\uC0C1\uC774 \uC544\uB2D9\uB2C8\uB2E4. \uC798\uCEE4\uB77C\uC5D0 \uBB38\uC758\uD574 \uC8FC\uC138\uC694.");
+}
+async function downloadBounded(url, options) {
+  const body = await openBounded(url, options);
+  const limit = options.maxBytes ?? MAX_DOWNLOAD_BYTES;
+  const chunks = [];
+  let total = 0;
+  for await (const chunk of body) {
+    total += chunk.byteLength;
+    if (total > limit) {
+      await body.cancel().catch(() => {
+      });
+      throw tooBig(options.what, limit);
+    }
+    chunks.push(Buffer.from(chunk));
+  }
+  return Buffer.concat(chunks, total);
+}
+
+// ../core/dist/fetchSource.js
+var TRANSFER_TIMEOUT_MS2 = 15 * 60 * 1e3;
+async function fetchVerifiedSourceTar(options) {
+  const report = options.onProgress ?? (() => {
+  });
+  const fetchImpl = options.fetchImpl ?? fetch;
+  let revisionNo = options.revisionNo;
+  if (revisionNo === void 0) {
+    const revisions = await options.api.listRevisions();
+    const choice = pickRevision(revisions);
+    if (!choice)
+      throw noRevisionError(revisions);
+    revisionNo = choice.revisionNo;
+  }
+  report(`\uBC84\uC804 ${revisionNo} \uC18C\uC2A4\uB97C \uBC1B\uB294 \uC911\u2026`);
+  const source = await options.api.sourceUrl(revisionNo);
+  const buffer = await downloadBounded(source.url, {
+    fetchImpl,
+    timeoutMs: TRANSFER_TIMEOUT_MS2,
+    what: "\uC18C\uC2A4"
+  });
+  if (!source.sha256) {
+    throw new DevtoolsError("SERVER_REJECTED", "\uC11C\uBC84\uAC00 \uBB34\uACB0\uC131 \uD574\uC2DC\uB97C \uC8FC\uC9C0 \uC54A\uC544 \uC18C\uC2A4\uB97C \uAC80\uC99D\uD560 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.", "\uC798\uCEE4\uB77C\uC5D0 \uBB38\uC758\uD574 \uC8FC\uC138\uC694. \uAC80\uC99D \uC5C6\uC774 \uC9C4\uD589\uD558\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4.");
+  }
+  const actual = createHash3("sha256").update(buffer).digest("hex");
+  if (actual !== source.sha256) {
+    throw new DevtoolsError("SERVER_REJECTED", "\uBC1B\uC740 \uC18C\uC2A4\uAC00 \uC6D0\uBCF8\uACFC \uB2E4\uB985\uB2C8\uB2E4(\uBB34\uACB0\uC131 \uD655\uC778 \uC2E4\uD328).", "\uB124\uD2B8\uC6CC\uD06C \uBB38\uC81C\uC77C \uC218 \uC788\uC2B5\uB2C8\uB2E4. \uB2E4\uC2DC \uC2DC\uB3C4\uD574 \uC8FC\uC138\uC694.");
+  }
+  return { revisionNo, buffer, sha256: source.sha256 };
+}
+
+// ../core/dist/unzip.js
+init_errors();
+import { inflateRaw } from "node:zlib";
+import { promisify as promisify2 } from "node:util";
+var inflate = promisify2(inflateRaw);
+
+// ../core/dist/importZip.js
+init_errors();
+
+// ../core/dist/build.js
+init_errors();
+var DEFAULT_TIMEOUT_MS2 = 10 * 60 * 1e3;
+
+// ../core/dist/tenantScope.js
+init_notice();
+
+// ../core/dist/upgradeNotice.js
+var UPGRADE_NOTICE_INTERVAL_MS = 24 * 60 * 60 * 1e3;
+
+// ../core/dist/index.js
+init_notice();
+
+// ../core/dist/presets.js
+init_errors();
+var TRANSFER_TIMEOUT_MS3 = 15 * 60 * 1e3;
+
+// ../core/dist/precheck.js
+var HEAVY_BYTES = 5 * 1024 * 1024;
+
+// ../core/dist/mcp.js
+init_errors();
+
+// ../core/dist/agents.js
+var MARKER = "<!-- zalkera-devtools \uAC00 \uB9CC\uB4E0 \uC2A4\uD141\uC785\uB2C8\uB2E4. \uB0B4\uC6A9\uC744 \uC5EC\uAE30 \uC4F0\uC9C0 \uB9D0\uACE0 \uC815\uBCF8\uC744 \uACE0\uCE58\uC138\uC694. -->";
+var AGENTS_STUB = `${MARKER}
+# \uC774 \uC0AC\uC774\uD2B8 \uC18C\uC2A4\uC758 \uADDC\uC57D
+
+\uADDC\uC57D\uC758 \uC815\uBCF8\uC740 \uC774 \uD30C\uC77C\uC774 \uC544\uB2C8\uB77C **\`@zalkera/client\` \uC5D0 \uB3D9\uBD09\uB41C \`llms.txt\`** \uC785\uB2C8\uB2E4.
+
+- \uC124\uCE58\uB3FC \uC788\uC73C\uBA74: \`node_modules/@zalkera/client/llms.txt\`
+- \uB370\uC774\uD130\uB294 \uC11C\uBC84\uAC00 \uC815\uBCF8\uC785\uB2C8\uB2E4 \u2014 \uC0C1\uD488\xB7\uAE00\xB7\uC124\uC815 \uAC12\uC744 \uC18C\uC2A4\uC5D0 \uBCF5\uC0AC\uD558\uC9C0 \uB9C8\uC138\uC694.
+- \`.env.local\` \uC740 \uC790\uACA9\uC99D\uBA85\uC774 \uB4E4\uC5B4 \uC788\uC5B4 **\uCEE4\uBC0B\uD558\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4.**
+`;
+var CLAUDE_POINTER = `${MARKER}
+@AGENTS.md
+`;
+
+// ../core/dist/reentrancy.js
+var BUSY = Symbol("busy");
+
+// ../core/dist/errorNotice.js
+init_errors();
+init_notice();
+
+// ../core/dist/whyBlocked.js
+init_notice();
+
+// ../core/dist/sidebarPlan.js
+init_notice();
+
+// ../core/dist/pullPlan.js
+function planPull(input) {
+  const { incoming, ledger, local } = input;
+  const plan = { deletes: [], writes: [], unchanged: [], untracked: [], conflicts: [] };
+  for (const [path, known] of Object.entries(ledger)) {
+    const here = local[path];
+    const next = incoming[path];
+    const clean = here !== void 0 && here.sha256 === known.sha256;
+    if (next === void 0) {
+      if (here === void 0)
+        continue;
+      if (clean)
+        plan.deletes.push(path);
+      else
+        plan.conflicts.push({ path, reason: "modified" });
+      continue;
+    }
+    if (here === void 0) {
+      plan.conflicts.push({ path, reason: "deleted-locally" });
+      continue;
+    }
+    if (next.sha256 === known.sha256) {
+      if (clean)
+        plan.unchanged.push(path);
+      else
+        plan.conflicts.push({ path, reason: "modified" });
+      continue;
+    }
+    if (clean || here.sha256 === next.sha256)
+      plan.writes.push(path);
+    else
+      plan.conflicts.push({ path, reason: "modified" });
+  }
+  for (const [path, next] of Object.entries(incoming)) {
+    if (ledger[path] !== void 0)
+      continue;
+    const here = local[path];
+    if (here === void 0) {
+      plan.writes.push(path);
+      continue;
+    }
+    if (here.sha256 === next.sha256)
+      plan.unchanged.push(path);
+    else
+      plan.conflicts.push({ path, reason: "added-locally" });
+  }
+  for (const path of Object.keys(local)) {
+    if (ledger[path] === void 0 && incoming[path] === void 0)
+      plan.untracked.push(path);
+  }
+  plan.deletes.sort();
+  plan.writes.sort();
+  plan.unchanged.sort();
+  plan.untracked.sort();
+  plan.conflicts.sort((a, b) => a.path.localeCompare(b.path));
+  return plan;
+}
+function applyAfterDiscard(plan, incoming) {
+  const writes = [...plan.writes];
+  const deletes = [...plan.deletes];
+  for (const conflict of plan.conflicts) {
+    if (incoming[conflict.path] !== void 0)
+      writes.push(conflict.path);
+    else
+      deletes.push(conflict.path);
+  }
+  return { writes: writes.sort(), deletes: deletes.sort() };
+}
+var PATH_LIST_CAP = 10;
+function trimPaths(paths, cap = PATH_LIST_CAP, all = false) {
+  if (all || paths.length <= cap)
+    return [...paths];
+  return [...paths.slice(0, cap), `\uC678 ${paths.length - cap}\uAC1C`];
+}
+
+// ../core/dist/pull.js
+import { lstat as lstat4, mkdir as mkdir3, readFile as readFile2, realpath as realpath2, rename as rename2, rmdir, stat, unlink, writeFile as writeFile4 } from "node:fs/promises";
+init_errors();
+import { basename as basename2, dirname, join as join7, relative as relative4, resolve as resolve3, sep as sep5 } from "node:path";
+
+// ../core/dist/workdir.js
+init_errors();
+import { createReadStream } from "node:fs";
+import { createHash as createHash4 } from "node:crypto";
+import { lstat as lstat3, readdir } from "node:fs/promises";
+import { join as join6, sep as sep4 } from "node:path";
+async function hashWorkdir(root, options = {}) {
+  const manifest = {};
+  const cap = Math.min(options.maxEntries ?? MAX_ENTRIES, MAX_ENTRIES);
+  let seen = 0;
+  async function walk(dir, prefix) {
+    const entries = await readdir(dir, { withFileTypes: true }).catch((error) => {
+      if (error?.code === "ENOENT")
+        return [];
+      throw error;
+    });
+    for (const item of entries) {
+      const relative5 = prefix === "" ? item.name : `${prefix}/${item.name}`;
+      if (isExcludedEntry(relative5))
+        continue;
+      if (item.isSymbolicLink())
+        continue;
+      if (item.isDirectory()) {
+        await walk(join6(dir, item.name), relative5);
+        continue;
+      }
+      if (!item.isFile())
+        continue;
+      seen += 1;
+      if (seen > cap) {
+        throw new DevtoolsError("LOCAL_TOO_LARGE", `\uC774 \uD3F4\uB354\uC758 \uD30C\uC77C\uC774 \uB108\uBB34 \uB9CE\uC2B5\uB2C8\uB2E4(${cap}\uAC1C \uCD08\uACFC).`, "\uC0AC\uC774\uD2B8 \uD3F4\uB354\uAC00 \uC544\uB2CC \uACF3\uC744 \uAC00\uB9AC\uD0A4\uACE0 \uC788\uC9C0 \uC54A\uC740\uC9C0 \uD655\uC778\uD574 \uC8FC\uC138\uC694.");
+      }
+      manifest[relative5] = { sha256: await hashFile(join6(dir, item.name)) };
+    }
+  }
+  await walk(root, "");
+  return manifest;
+}
+async function hashFile(path) {
+  const hash = createHash4("sha256");
+  for await (const chunk of createReadStream(path))
+    hash.update(chunk);
+  return hash.digest("hex");
+}
+async function resolveExisting(root, path) {
+  if (path === "" || path.includes("\0"))
+    return null;
+  const segments = path.split("/").filter((s) => s !== "");
+  if (segments.length === 0)
+    return null;
+  if (segments.some((s) => s === "." || s === ".." || s.includes(sep4)))
+    return null;
+  let current = root;
+  for (const part of segments) {
+    const next = join6(current, part);
+    const info = await lstat3(next).catch(() => null);
+    if (!info || info.isSymbolicLink())
+      return null;
+    current = next;
+  }
+  return current;
+}
+
+// ../core/dist/pull.js
+var SAVED_SUFFIX = ".zalkera-saved";
+async function pullSiteSource(options) {
+  const report = options.onProgress ?? (() => {
+  });
+  const root = resolve3(options.folder);
+  const found = await readLedger(root);
+  const foreignLedger2 = found !== null && found.tenant !== options.api.tenantCode();
+  const ledger = foreignLedger2 ? null : found;
+  report("\uC0AC\uC774\uD2B8 \uC18C\uC2A4\uB97C \uBC1B\uB294 \uC911\uC785\uB2C8\uB2E4\u2026");
+  const tar = await fetchVerifiedSourceTar({
+    api: options.api,
+    revisionNo: options.revisionNo,
+    onProgress: report,
+    fetchImpl: options.fetchImpl
+  });
+  report("\uBB34\uC5C7\uC774 \uB2EC\uB77C\uC84C\uB294\uC9C0 \uACAC\uC8FC\uB294 \uC911\uC785\uB2C8\uB2E4\u2026");
+  const untarred = await gunzipTar(tar.buffer, MAX_EXTRACT_BYTES);
+  const declared = await readTarManifest(untarred, { rejectVendored: true });
+  const { incoming, dropped } = withoutExcluded(declared);
+  const local = await hashWorkdir(root);
+  requireNoFoldedCollision(incoming, local);
+  const deletionsUnknown = ledger === null && Object.keys(local).length > 0;
+  const plan = planPull({ incoming, ledger: ledger?.files ?? {}, local });
+  let savedTo = null;
+  let movedAway = [];
+  if (plan.conflicts.length > 0) {
+    if (!options.discardLocal)
+      throw conflictRefusal(plan, options.listAll === true);
+    const aside = await setAside(root, plan);
+    savedTo = aside.folder;
+    movedAway = aside.moved;
+    report(`\uACE0\uCE5C \uB0B4\uC6A9\uC744 ${basename2(savedTo)} \uC5D0 \uC62E\uACA8 \uB450\uC5C8\uC2B5\uB2C8\uB2E4.`);
+  }
+  const todo = savedTo ? applyAfterDiscard(plan, incoming) : { writes: plan.writes, deletes: plan.deletes };
+  await requireNoLinkedTargets(root, todo.writes);
+  const moved = new Set(movedAway);
+  const deleted = await applyDeletes(root, todo.deletes) + todo.deletes.filter((path) => moved.has(path)).length;
+  const writes = new Set(todo.writes);
+  await extractTar(untarred, root, {
+    // 여기도 켠다 — 읽기 훑기가 이미 걸렀지만, 이 함수는 공개 API 라 두 경로가 같은 판정을
+    // 지나야 한다. 실제로 걸리는 자리는 위쪽이다.
+    rejectVendored: true,
+    decide: (path) => writes.has(path) ? "replace" : "skip"
+  });
+  const generation = await currentGeneration(options.api);
+  const next = {
+    format: SYNC_LEDGER_FORMAT,
+    tenant: options.api.tenantCode(),
+    base: { revisionNo: tar.revisionNo, tarSha256: tar.sha256 },
+    files: Object.fromEntries(Object.entries(incoming).map(([path, entry]) => [path, { sha256: entry.sha256, bytes: entry.bytes }])),
+    server: generation === null ? null : { generation },
+    mine: {},
+    pulledAt: (/* @__PURE__ */ new Date()).toISOString(),
+    pushedAt: ledger?.pushedAt ?? null
+  };
+  const ledgerWritten = await writeLedger(root, next);
+  await writeSourceMarkTo(root, {
+    tenant: options.api.tenantCode(),
+    revisionNo: tar.revisionNo,
+    sha256: tar.sha256,
+    fetchedAt: next.pulledAt
+  }).catch(() => void 0);
+  return {
+    revisionNo: tar.revisionNo,
+    written: todo.writes.length,
+    deleted,
+    unchanged: plan.unchanged.length,
+    untracked: plan.untracked.length,
+    savedTo,
+    serverExcluded: dropped,
+    foreignLedger: foreignLedger2,
+    deletionsUnknown,
+    ledgerWritten
+  };
+}
+function requireNoFoldedCollision(incoming, local) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const path of Object.keys(incoming)) {
+    const folded = path.toLowerCase();
+    const first = seen.get(folded);
+    if (first !== void 0) {
+      throw new DevtoolsError("SERVER_REJECTED", `\uC0AC\uC774\uD2B8\uAC00 \uBCF4\uB0B8 \uD30C\uC77C \uC911 \uC774\uB984\uC774 \uB300\uC18C\uBB38\uC790\uB9CC \uB2E4\uB978 \uAC83\uC774 \uC788\uC2B5\uB2C8\uB2E4: ${first} \xB7 ${path}`, "\uCEF4\uD4E8\uD130\uC5D0 \uB530\uB77C \uAC19\uC740 \uD30C\uC77C\uB85C \uCDE8\uAE09\uB3FC \uD55C\uCABD\uC774 \uC0AC\uB77C\uC9D1\uB2C8\uB2E4. \uC544\uBB34\uAC83\uB3C4 \uBC1B\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4 \u2014 \uC798\uCEE4\uB77C\uC5D0 \uC54C\uB824 \uC8FC\uC138\uC694.");
+    }
+    seen.set(folded, path);
+  }
+  for (const path of Object.keys(local)) {
+    const other = seen.get(path.toLowerCase());
+    if (other === void 0 || other === path)
+      continue;
+    throw new DevtoolsError("PULL_WOULD_OVERWRITE", `\uC774 \uD3F4\uB354\uC758 ${path} \uC640 \uC0AC\uC774\uD2B8\uC758 ${other} \uB294 \uC774\uB984\uC774 \uB300\uC18C\uBB38\uC790\uB9CC \uB2E4\uB985\uB2C8\uB2E4. \uC544\uBB34\uAC83\uB3C4 \uBC1B\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4.`, "\uCEF4\uD4E8\uD130\uC5D0 \uB530\uB77C \uAC19\uC740 \uD30C\uC77C\uB85C \uCDE8\uAE09\uB3FC \uD55C\uCABD\uC774 \uC0AC\uB77C\uC9D1\uB2C8\uB2E4. \uC774 \uD3F4\uB354\uC758 \uD30C\uC77C \uC774\uB984\uC744 \uBC14\uAFB8\uAC70\uB098 \uC62E\uACA8 \uB450\uACE0 \uB2E4\uC2DC \uC2E4\uD589\uD574 \uC8FC\uC138\uC694.");
+  }
+}
+async function requireNoLinkedTargets(root, paths) {
+  const checked = /* @__PURE__ */ new Set();
+  for (const path of paths) {
+    const segments = path.split("/").filter((s) => s !== "");
+    let current = root;
+    for (const part of segments) {
+      current = join7(current, part);
+      if (checked.has(current))
+        continue;
+      checked.add(current);
+      const info = await lstat4(current).catch(() => null);
+      if (!info?.isSymbolicLink())
+        continue;
+      throw new DevtoolsError("PULL_WOULD_OVERWRITE", `\uC774 \uD3F4\uB354\uC758 ${relative4(root, current).split(sep5).join("/")} \uAC00 \uB2E4\uB978 \uACF3\uC744 \uAC00\uB9AC\uD0A4\uB294 \uBC14\uB85C\uAC00\uAE30\uC785\uB2C8\uB2E4. \uC544\uBB34\uAC83\uB3C4 \uBC1B\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4.`, "\uADF8 \uBC14\uB85C\uAC00\uAE30\uB97C \uC9C0\uC6B0\uACE0 \uB2E4\uC2DC \uC2E4\uD589\uD574 \uC8FC\uC138\uC694. \uADF8\uB300\uB85C \uB450\uBA74 \uC774 \uD3F4\uB354 \uBC16\uC758 \uAC83\uC744 \uB36E\uC5B4\uC4F0\uAC8C \uB429\uB2C8\uB2E4.");
+    }
+  }
+}
+function withoutExcluded(declared) {
+  const incoming = {};
+  const dropped = [];
+  for (const [path, entry] of Object.entries(declared)) {
+    if (isExcludedEntry(path))
+      dropped.push(path);
+    else
+      incoming[path] = entry;
+  }
+  return { incoming, dropped: dropped.sort() };
+}
+async function readLedger(root) {
+  const text = await readFile2(join7(root, SYNC_LEDGER_PATH), "utf8").catch(() => null);
+  return text === null ? null : parseSyncLedger(text);
+}
+async function writeLedger(root, ledger) {
+  try {
+    const dir = await ensureOwnDir(root, ...SYNC_LEDGER_PATH.split("/").slice(0, -1));
+    await writeOwnFile(join7(dir, basename2(SYNC_LEDGER_PATH)), serializeSyncLedger(ledger));
+  } catch {
+    return false;
+  }
+  await ignoreLedger(root).catch(() => {
+  });
+  return true;
+}
+async function ignoreLedger(root) {
+  const info = join7(root, ".git", "info");
+  const exists = await stat(join7(root, ".git")).then((s) => s.isDirectory()).catch(() => false);
+  if (!exists)
+    return;
+  const path = join7(info, "exclude");
+  const current = await readFile2(path, "utf8").catch(() => "");
+  if (current.split(/\r?\n/).some((line) => line.trim() === SYNC_LEDGER_PATH))
+    return;
+  await mkdir3(info, { recursive: true });
+  const prefix = current === "" || current.endsWith("\n") ? "" : "\n";
+  await writeFile4(path, `${current}${prefix}${SYNC_LEDGER_PATH}
+`);
+}
+async function currentGeneration(api) {
+  return await api.draftFiles().then((state) => state.generation ?? null).catch(() => null);
+}
+async function applyDeletes(root, paths) {
+  let count2 = 0;
+  const parents = /* @__PURE__ */ new Set();
+  for (const path of paths) {
+    const target = await resolveExisting(root, path);
+    if (!target)
+      continue;
+    await unlink(target).catch(() => {
+    });
+    count2 += 1;
+    let dir = dirname(target);
+    while (dir.length > root.length && dir.startsWith(root)) {
+      parents.add(dir);
+      dir = dirname(dir);
+    }
+  }
+  for (const dir of [...parents].sort((a, b) => b.length - a.length)) {
+    await rmdir(dir).catch(() => {
+    });
+  }
+  return count2;
+}
+async function setAside(root, plan) {
+  const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  const real = await realpath2(root).catch(() => root);
+  const saved = join7(dirname(real), `${basename2(real)}${SAVED_SUFFIX}`, stamp);
+  const moved = [];
+  for (const conflict of plan.conflicts) {
+    const from = await resolveExisting(root, conflict.path);
+    if (!from)
+      continue;
+    const to = join7(saved, conflict.path);
+    await mkdir3(dirname(to), { recursive: true });
+    await rename2(from, to);
+    moved.push(conflict.path);
+  }
+  return { folder: saved, moved };
+}
+function conflictRefusal(plan, all) {
+  const paths = plan.conflicts.map((c) => c.path);
+  const list = trimPaths(paths, PATH_LIST_CAP, all).map((p) => `  \xB7 ${p}`).join("\n");
+  return new DevtoolsError(
+    "PULL_WOULD_OVERWRITE",
+    `\uC774 \uD3F4\uB354\uC5D0\uC11C \uACE0\uCE5C \uAC83\uC774 ${paths.length}\uAC1C \uC788\uC5B4 \uC544\uBB34\uAC83\uB3C4 \uBC1B\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4.
+${list}`,
+    // ⚠ **없는 명령을 대지 않는다.** 여기 적힌 둘은 실제로 있는 동사다 — 없는 것을 대면 작업을
+    //   지키는 쪽이 죽은 문이 되고, 남는 유일한 길이 「내 작업을 밖으로 옮기는 것」이 된다.
+    "\uACE0\uCE5C \uB0B4\uC6A9\uC744 \uBA3C\uC800 \uC0AC\uC774\uD2B8 \uCABD\uC5D0 \uC62C\uB9AC\uB824\uBA74 `zalkera push`, \uBC84\uB9AC\uACE0 \uC0AC\uC774\uD2B8 \uAC83\uC73C\uB85C \uBC1B\uC73C\uB824\uBA74 `zalkera pull --discard-local` \uC744 \uC2E4\uD589\uD558\uC138\uC694. \uBC84\uB9AC\uB294 \uCABD\uC744 \uACE8\uB77C\uB3C4 \uACE0\uCE5C \uD30C\uC77C\uC740 \uC606 \uD3F4\uB354\uC5D0 \uC62E\uACA8 \uB461\uB2C8\uB2E4."
+  );
+}
+
+// ../core/dist/baseline.js
+init_errors();
+import { readFile as readFile3 } from "node:fs/promises";
+import { join as join8, resolve as resolve4 } from "node:path";
+async function rebuildBaseline(options) {
+  const report = options.onProgress ?? (() => {
+  });
+  const root = resolve4(options.folder);
+  const previousText = await readFile3(join8(root, SYNC_LEDGER_PATH), "utf8").catch(() => null);
+  const previous = previousText === null ? null : parseSyncLedger(previousText);
+  report("\uD310\uC758 \uD30C\uC77C \uBAA9\uB85D\uC744 \uB2E4\uC2DC \uC77D\uB294 \uC911\uC785\uB2C8\uB2E4\u2026");
+  const tar = await fetchVerifiedSourceTar({
+    api: options.api,
+    revisionNo: options.revisionNo,
+    onProgress: report,
+    fetchImpl: options.fetchImpl
+  });
+  const { incoming: manifest, dropped } = withoutExcluded(await readTarGzManifest(tar.buffer, { maxBytes: MAX_EXTRACT_BYTES }));
+  const generation = await options.api.draftFiles().then((state) => state.generation ?? null).catch(() => null);
+  const ledger = {
+    format: SYNC_LEDGER_FORMAT,
+    tenant: options.api.tenantCode(),
+    base: { revisionNo: tar.revisionNo, tarSha256: tar.sha256 },
+    files: Object.fromEntries(Object.entries(manifest).map(([path, entry]) => [path, { sha256: entry.sha256, bytes: entry.bytes }])),
+    server: generation === null ? null : { generation },
+    // ⚠ **`mine` 은 비운다.** 옛 장부의 `mine` 을 살리면 「내가 올린 것」이라는 주장이 근거 없이
+    //   되살아난다 — 그 주장이 좌초 안내와 응답 유실 화해의 입력이다.
+    mine: {},
+    pulledAt: previous?.pulledAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+    pushedAt: previous?.pushedAt ?? null
+  };
+  await writeSourceMarkTo(root, {
+    tenant: options.api.tenantCode(),
+    revisionNo: tar.revisionNo,
+    sha256: tar.sha256,
+    fetchedAt: ledger.pulledAt
+  }).catch(() => void 0);
+  const written = await writeLedger(root, ledger);
+  if (!written) {
+    throw new DevtoolsError("LEDGER_UNKNOWN", "\uAE30\uC900 \uAE30\uB85D\uC744 \uC4F0\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4.", "\uD3F4\uB354\uC758 `.zalkera` \uC790\uB9AC\uAC00 \uB9C1\uD06C\uC774\uAC70\uB098 \uC4F8 \uC218 \uC5C6\uB294 \uC0C1\uD0DC\uC778\uC9C0 \uD655\uC778\uD574 \uC8FC\uC138\uC694.");
+  }
+  const local = await hashWorkdir(root);
+  const differing = Object.keys(manifest).filter((path) => local[path]?.sha256 !== manifest[path]?.sha256).concat(Object.keys(local).filter((path) => manifest[path] === void 0)).sort();
+  return {
+    revisionNo: tar.revisionNo,
+    files: Object.keys(manifest).length,
+    replaced: previous !== null,
+    differing,
+    serverExcluded: dropped
+  };
+}
+
+// ../core/dist/syncStatus.js
+function syncStatus(input) {
+  const { ledger, local, draft, activeRevisionNo: activeRevisionNo2 } = input;
+  const blockers = [];
+  if (!ledger)
+    blockers.push("LEDGER_UNKNOWN");
+  if (!draft)
+    blockers.push("SERVER_UNREADABLE");
+  if (draft?.strandedOnOldRevision)
+    blockers.push("STRANDED");
+  const base = ledger?.files ?? {};
+  const changed = [];
+  const removed = [];
+  const added = [];
+  for (const [path, known] of Object.entries(base)) {
+    const here = local[path];
+    if (here === void 0)
+      removed.push(path);
+    else if (here.sha256 !== known.sha256)
+      changed.push(path);
+  }
+  for (const path of Object.keys(local)) {
+    if (base[path] === void 0)
+      added.push(path);
+  }
+  const seen = ledger?.server?.generation ?? null;
+  const now = draft?.generation ?? null;
+  const mineValid = draft !== null && seen !== null && seen === now;
+  const baseRevisionNo = ledger?.base.revisionNo ?? null;
+  return {
+    tenant: ledger?.tenant ?? null,
+    baseRevisionNo,
+    activeRevisionNo: activeRevisionNo2,
+    behind: baseRevisionNo !== null && activeRevisionNo2 !== null && activeRevisionNo2 > baseRevisionNo,
+    changed: changed.sort(),
+    removed: removed.sort(),
+    added: added.sort(),
+    draftPaths: (draft?.changed.length ?? 0) + (draft?.deleted.length ?? 0),
+    mineValid,
+    blockers
+  };
+}
+function ledgerCorrection(ledger, draft) {
+  if (!ledger || !draft)
+    return null;
+  const seen = ledger.server?.generation ?? null;
+  if (seen === (draft.generation ?? null))
+    return null;
+  if (seen === null && Object.keys(ledger.mine).length === 0)
+    return null;
+  return { ...ledger, server: null, mine: {} };
+}
+
+// ../core/dist/push.js
+init_errors();
+init_notice();
+import { readFile as readFile4, stat as stat2 } from "node:fs/promises";
+import { basename as basename3, join as join9, resolve as resolve5 } from "node:path";
+
+// ../core/dist/pushPlan.js
+function effectiveSha(base, draft, path) {
+  if (draft.deleted.includes(path))
+    return null;
+  const written = draft.changed.find((row) => row.path === path);
+  if (written)
+    return written.sha256;
+  return base[path]?.sha256 ?? null;
+}
+function planPush(input) {
+  const { base, draft, local } = input;
+  const mine = input.mine ?? {};
+  const edits = [];
+  const unseen = [];
+  const paths = /* @__PURE__ */ new Set([
+    ...Object.keys(base),
+    ...draft.changed.map((row) => row.path),
+    ...draft.deleted,
+    ...Object.keys(local)
+  ]);
+  for (const path of [...paths].sort()) {
+    const now = effectiveSha(base, draft, path);
+    const here = local[path]?.sha256 ?? null;
+    if (here === now)
+      continue;
+    if (here === null) {
+      edits.push({ path, sha256: null, baseSha256: now });
+      continue;
+    }
+    edits.push({ path, sha256: here, baseSha256: now });
+  }
+  for (const path of paths) {
+    const touched = draft.changed.some((row) => row.path === path) || draft.deleted.includes(path);
+    if (!touched)
+      continue;
+    const now = effectiveSha(base, draft, path);
+    const here = local[path]?.sha256 ?? null;
+    if (here === now)
+      continue;
+    if (Object.hasOwn(mine, path) && mine[path] === now)
+      continue;
+    unseen.push(path);
+  }
+  return { edits, unseen: unseen.sort() };
+}
+
+// ../core/dist/push.js
+var MAX_PUSH_ENTRIES = 500;
+var MAX_PUSH_ATTEMPTS = 3;
+var PATH_NOT_ACCEPTED = "SOURCE_PATH_NOT_ACCEPTED";
+var SHAPE_STALE = "SOURCE_EDIT_SHAPE_STALE";
+var MAX_PREVIEW_URL = 2048;
+var MAX_WARNING = 300;
+var MAX_PUSH_FILE_BYTES = 1024 * 1024;
+var MAX_PUSH_BYTES = 3.5 * 1024 * 1024;
+async function pushSiteSource(options) {
+  const report = options.onProgress ?? (() => {
+  });
+  const root = resolve5(options.folder);
+  const ledger = await readLedger(root);
+  if (!ledger)
+    throw ledgerUnknown();
+  if (ledger.tenant !== options.api.tenantCode())
+    throw foreignLedger(ledger.tenant);
+  report("\uC0AC\uC774\uD2B8 \uCABD \uC0C1\uD0DC\uB97C \uD655\uC778\uD558\uB294 \uC911\uC785\uB2C8\uB2E4\u2026");
+  let draft = await readDraft(options.api);
+  const rows = await revisionRows(options.api);
+  const active = activeOf(rows);
+  const reconciled = reconcile(ledger, draft);
+  const local = await hashWorkdir(root);
+  const owned = ownedBy(ledger, draft);
+  if (active !== ledger.base.revisionNo) {
+    const notYetLive = active < ledger.base.revisionNo;
+    const mineRow = notYetLive ? rows.find((row) => row.revisionNo === ledger.base.revisionNo) : void 0;
+    if (mineRow?.status === "BUILDING") {
+      throw new DevtoolsError("PUSH_BASE_BUILDING", `${ledger.base.revisionNo}\uD310\uC744 \uC9D3\uB294 \uC911\uC774\uB77C \uC544\uC9C1 \uC62C\uB9B4 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.`, "\uBE4C\uB4DC\uAC00 \uB05D\uB098\uBA74 \uADF8 \uBC84\uC804\uC774 \uCF1C\uC9D1\uB2C8\uB2E4 \u2014 `zalkera status` \uB85C \uD655\uC778\uD55C \uB4A4 \uB2E4\uC2DC \uC62C\uB824 \uC8FC\uC138\uC694. \uC774 \uD3F4\uB354\uB294 \uADF8\uB300\uB85C \uB450\uC154\uB3C4 \uB429\uB2C8\uB2E4.");
+    }
+    if (mineRow?.status === "FAILED") {
+      throw new DevtoolsError("PUSH_BASE_BUILD_FAILED", `${ledger.base.revisionNo}\uD310\uC740 \uC9D3\uB2E4\uAC00 \uC2E4\uD328\uD574 \uCF1C\uC9C0\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4 \u2014 \uC9C0\uAE08 \uCF1C\uC838 \uC788\uB294 \uAC83\uC740 ${active}\uD310\uC785\uB2C8\uB2E4.`, "`zalkera status` \uB85C \uC2E4\uD328 \uC0AC\uC720\uB97C \uD655\uC778\uD574 \uC8FC\uC138\uC694. \uACE0\uCCD0\uC11C \uB2E4\uC2DC \uC62C\uB9AC\uB824\uBA74 `zalkera baseline` \uC73C\uB85C \uAE30\uC900\uC744 \uC9C0\uAE08 \uCF1C\uC9C4 \uBC84\uC804\uC73C\uB85C \uB9DE\uCD98 \uB4A4 \uC791\uC5C5\uD574 \uC8FC\uC138\uC694.");
+    }
+    const dirty = Object.keys(ledger.files).filter((path) => local[path]?.sha256 !== ledger.files[path]?.sha256).length;
+    throw baseMoved(ledger.base.revisionNo, active, dirty);
+  }
+  let plan = planPush({ base: ledger.files, draft: viewOf(draft), local, mine: owned });
+  requireSeen(plan, options);
+  if (plan.edits.length === 0) {
+    const written2 = await writeLedger(root, {
+      ...ledger,
+      server: draft.generation === null ? null : { generation: draft.generation },
+      mine: {}
+    });
+    return {
+      sent: 0,
+      removed: 0,
+      generation: draft.generation,
+      droppedByServer: [],
+      retriedAfterConflict: false,
+      reconciled,
+      previewUrl: null,
+      warning: written2 ? null : ledgerWriteFailed(0)
+    };
+  }
+  requireWithinLimits(plan.edits);
+  report(`${plan.edits.length}\uAC1C\uB97C \uC62C\uB9AC\uB294 \uC911\uC785\uB2C8\uB2E4\u2026`);
+  const dropped = [];
+  let retried = false;
+  let sent = null;
+  for (let round = 0; round < MAX_PUSH_ATTEMPTS; round += 1) {
+    requireWithinLimits(plan.edits);
+    sent = await attempt(options.api, root, plan.edits, report);
+    if (sent.kind === "ok")
+      break;
+    if (sent.kind === "lost") {
+      const attempted = {};
+      for (const edit of plan.edits)
+        attempted[edit.path] = edit.sha256;
+      const noted = await writeLedger(root, { ...ledger, server: null, mine: attempted });
+      throw responseLost(sent.error, noted);
+    }
+    if (round === MAX_PUSH_ATTEMPTS - 1)
+      throw sent.error;
+    if (sent.kind === "excluded") {
+      const named = sent.rejectedPaths.filter((path) => plan.edits.some((edit) => edit.path === path));
+      if (named.length === 0)
+        throw sent.error;
+      dropped.push(...named);
+      const kept = plan.edits.filter((edit) => !named.includes(edit.path));
+      if (kept.length === 0)
+        throw sent.error;
+      report(`\uC0AC\uC774\uD2B8\uAC00 \uBC1B\uC9C0 \uC54A\uB294 \uACBD\uB85C ${named.length}\uAC1C\uB97C \uBE7C\uACE0 \uB2E4\uC2DC \uBCF4\uB0C5\uB2C8\uB2E4\u2026`);
+      plan = { ...plan, edits: kept };
+      continue;
+    }
+    if (sent.kind === "conflict") {
+      report("\uC0AC\uC774\uD2B8 \uCABD\uC774 \uADF8 \uC0AC\uC774 \uB2EC\uB77C\uC838 \uB2E4\uC2DC \uC77D\uC2B5\uB2C8\uB2E4\u2026");
+      draft = await readDraft(options.api);
+      const fresh = await hashWorkdir(root);
+      plan = planPush({ base: ledger.files, draft: viewOf(draft), local: fresh, mine: ownedBy(ledger, draft) });
+      requireSeen(plan, options);
+      plan = { ...plan, edits: plan.edits.filter((edit) => !dropped.includes(edit.path)) };
+      if (plan.edits.length === 0) {
+        const written2 = await writeLedger(root, {
+          ...ledger,
+          server: draft.generation === null ? null : { generation: draft.generation },
+          mine: {}
+        });
+        return {
+          sent: 0,
+          removed: 0,
+          generation: draft.generation,
+          droppedByServer: dropped,
+          // 두 번째 요청이 안 나갔다 — 재계산은 했지만 **다시 보내지는 않았다.**
+          retriedAfterConflict: false,
+          reconciled,
+          previewUrl: null,
+          warning: written2 ? null : ledgerWriteFailed(0)
+        };
+      }
+      retried = true;
+      continue;
+    }
+    throw sent.error;
+  }
+  if (sent === null || sent.kind !== "ok")
+    throw sent?.error ?? unreachable();
+  const mine = {};
+  for (const edit of plan.edits)
+    mine[edit.path] = edit.sha256;
+  const written = await writeLedger(root, {
+    ...ledger,
+    server: sent.generation === null ? null : { generation: sent.generation },
+    mine,
+    pushedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  return {
+    sent: plan.edits.length,
+    removed: plan.edits.filter((edit) => edit.sha256 === null).length,
+    generation: sent.generation,
+    droppedByServer: dropped,
+    retriedAfterConflict: retried,
+    reconciled,
+    previewUrl: sent.previewUrl,
+    warning: written ? sent.warning : ledgerWriteFailed(plan.edits.length)
+  };
+}
+var ledgerWriteFailed = (sent) => sent > 0 ? "\uC62C\uB9B0 \uAC83\uC740 \uC0AC\uC774\uD2B8 \uCABD\uC5D0 \uBC18\uC601\uB410\uC9C0\uB9CC \uC774 \uD3F4\uB354\uC758 \uAE30\uC900 \uAE30\uB85D\uC744 \uC4F0\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4. `zalkera baseline` \uC744 \uD55C \uBC88 \uC2E4\uD589\uD574 \uC8FC\uC138\uC694." : "\uC774 \uD3F4\uB354\uC758 \uAE30\uC900 \uAE30\uB85D\uC744 \uC4F0\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4. `zalkera baseline` \uC744 \uD55C \uBC88 \uC2E4\uD589\uD574 \uC8FC\uC138\uC694.";
+async function readDraft(api) {
+  const draft = await api.draftFiles().catch(() => null);
+  if (!draft) {
+    throw new DevtoolsError("SERVER_UNREADABLE_DRAFT", "\uC9C0\uAE08 \uC0AC\uC774\uD2B8 \uCABD \uC0C1\uD0DC\uB97C \uD655\uC778\uD558\uC9C0 \uBABB\uD574 \uC544\uBB34\uAC83\uB3C4 \uC62C\uB9AC\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4.", "\uC7A0\uC2DC \uB4A4 \uB2E4\uC2DC \uC2DC\uB3C4\uD574 \uC8FC\uC138\uC694.");
+  }
+  if (draft.strandedOnOldRevision) {
+    throw new DevtoolsError("STRANDED_DRAFT", "\uC0AC\uC774\uD2B8 \uCABD\uC5D0\uC11C \uD3B8\uC9D1 \uC911\uC774\uB358 \uAC83\uC774 \uC9C0\uAE08 \uBC84\uC804 \uC704\uAC00 \uC544\uB2C8\uB77C \uC5EC\uAE30\uC5D0 \uC5B9\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.", "\uCF58\uC194\uC5D0\uC11C \uADF8 \uD3B8\uC9D1\uC744 \uB418\uB3CC\uB9B0 \uB4A4 \uB2E4\uC2DC \uC2DC\uB3C4\uD574 \uC8FC\uC138\uC694. \uB418\uB3CC\uB9AC\uAE30 \uC804\uC5D0 \uBB34\uC5C7\uC774 \uB4E4\uC5B4 \uC788\uC5C8\uB294\uC9C0\uB294 \uCF58\uC194\uC5D0\uC11C \uBCFC \uC218 \uC788\uC2B5\uB2C8\uB2E4.");
+  }
+  return draft;
+}
+var viewOf = (draft) => ({ changed: draft.changed, deleted: draft.deleted });
+function ownedBy(ledger, draft) {
+  const seen = ledger.server?.generation ?? null;
+  return seen !== null && seen === (draft.generation ?? null) ? ledger.mine : {};
+}
+async function revisionRows(api) {
+  const rows = await api.listRevisions().catch(() => null);
+  if (rows === null) {
+    throw new DevtoolsError("SERVER_UNREADABLE_DRAFT", "\uC9C0\uAE08 \uC0AC\uC774\uD2B8\uC5D0 \uCF1C\uC838 \uC788\uB294 \uBC84\uC804\uC744 \uD655\uC778\uD558\uC9C0 \uBABB\uD574 \uC544\uBB34\uAC83\uB3C4 \uC62C\uB9AC\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4.", "\uC7A0\uC2DC \uB4A4 \uB2E4\uC2DC \uC2DC\uB3C4\uD574 \uC8FC\uC138\uC694. \uACC4\uC18D \uADF8\uB7EC\uBA74 \uC774 \uACC4\uC815\uC5D0 \uBC84\uC804 \uBAA9\uB85D\uC744 \uBCFC \uAD8C\uD55C\uC774 \uC788\uB294\uC9C0 \uD655\uC778\uD574 \uC8FC\uC138\uC694.");
+  }
+  return rows;
+}
+function activeOf(rows) {
+  const active = rows.find((row) => row.isActive)?.revisionNo;
+  if (active === void 0) {
+    throw new DevtoolsError("SERVER_UNREADABLE_DRAFT", "\uC774 \uC0AC\uC774\uD2B8\uC5D0 \uCF1C\uC838 \uC788\uB294 \uBC84\uC804\uC774 \uC5C6\uC2B5\uB2C8\uB2E4.", "\uCF58\uC194\uC5D0\uC11C \uC5B4\uB5A4 \uBC84\uC804\uC744 \uCF24\uC9C0 \uBA3C\uC800 \uC815\uD574 \uC8FC\uC138\uC694. \uADF8 \uC804\uC5D0\uB294 \uBB34\uC5C7 \uC704\uC5D0 \uC5B9\uB294 \uAC83\uC778\uC9C0 \uC54C \uC218 \uC5C6\uC5B4 \uC62C\uB9AC\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4.");
+  }
+  return active;
+}
+function reconcile(ledger, draft) {
+  const paths = Object.keys(ledger.mine);
+  if (ledger.server !== null || paths.length === 0)
+    return null;
+  const applied = paths.every((path) => {
+    const expected = ledger.mine[path] ?? null;
+    if (expected === null)
+      return draft.deleted.includes(path);
+    return draft.changed.some((row) => row.path === path && row.sha256 === expected);
+  });
+  return applied ? "applied" : "not-applied";
+}
+function requireSeen(plan, options) {
+  if (plan.unseen.length === 0 || options.overwriteUnseen === true)
+    return;
+  const list = trimPaths(plan.unseen, PATH_LIST_CAP, options.listAll === true).map((path) => `  \xB7 ${path}`).join("\n");
+  throw new DevtoolsError("PUSH_WOULD_REVERT", `\uC0AC\uC774\uD2B8 \uCABD\uC5D0 \uC774 \uD3F4\uB354\uAC00 \uC544\uC9C1 \uBABB \uBC1B\uC740 \uD3B8\uC9D1\uC774 ${plan.unseen.length}\uAC1C \uC788\uC5B4 \uC544\uBB34\uAC83\uB3C4 \uC62C\uB9AC\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4.
+${list}`, "`zalkera pull` \uB85C \uC9C0\uAE08 \uBC84\uC804\uC744 \uBC1B\uC740 \uB4A4 \uB2E4\uC2DC \uC62C\uB9AC\uAC70\uB098, \uADF8 \uD3B8\uC9D1\uC744 \uCF58\uC194\uC5D0\uC11C \uD655\uC778\uD574 \uC8FC\uC138\uC694. \uADF8\uB300\uB85C \uC62C\uB9AC\uBA74 \uADF8 \uD3B8\uC9D1\uC774 \uC0AC\uB77C\uC9D1\uB2C8\uB2E4.");
+}
+function requireWithinLimits(edits) {
+  if (edits.length > MAX_PUSH_ENTRIES) {
+    throw new DevtoolsError("PUSH_TOO_LARGE", `\uD55C \uBC88\uC5D0 \uC62C\uB9B4 \uC218 \uC788\uB294 \uD30C\uC77C\uC740 ${MAX_PUSH_ENTRIES}\uAC1C\uC778\uB370 ${edits.length}\uAC1C\uC785\uB2C8\uB2E4.`, "\uACE0\uCE5C \uAC83\uC774 \uC774\uB9CC\uD07C \uB9CE\uC73C\uBA74 \uD3B8\uC9D1\uC774 \uC544\uB2C8\uB77C \uC0C8 \uC18C\uC2A4\uC785\uB2C8\uB2E4 \u2014 \uCF58\uC194\uC5D0\uC11C \uC18C\uC2A4\uB97C \uD1B5\uC9F8\uB85C \uC62C\uB9AC\uB294 \uCABD\uC774 \uB9DE\uC2B5\uB2C8\uB2E4.");
+  }
+}
+async function attempt(api, root, edits, report) {
+  const body = await bodyOf(root, edits);
+  try {
+    const result = await api.editDraft(body);
+    return {
+      kind: "ok",
+      generation: result.generation,
+      // 🔴 **서버가 정한 문자열은 소독을 지난다.** 같은 응답의 오류 갈래는 이미 지나는데
+      //    성공 갈래의 이 둘만 안 지났다 — 그리고 이 둘은 `stdout` 으로 나간다. 제어문자가
+      //    살아 있으면 서버가 **커서를 올려 방금 찍은 줄을 지우고** 다른 문장을 앉힐 수 있다
+      //    (심의 실측). `plainNotice` 가 제어문자를 걷는다.
+      previewUrl: plainNotice(result.previewUrl ?? "", MAX_PREVIEW_URL) || null,
+      warning: plainNotice(result.warning ?? "", MAX_WARNING) || null,
+      rejectedPaths: []
+    };
+  } catch (error) {
+    if (!(error instanceof DevtoolsError))
+      throw error;
+    if (error.code === "SERVER_UNREACHABLE") {
+      return { kind: "lost", error, rejectedPaths: [], generation: null, previewUrl: null, warning: null };
+    }
+    const kind = error.serverCode === "DRAFT_PRECONDITION_FAILED" || error.serverCode === SHAPE_STALE ? "conflict" : error.serverCode === PATH_NOT_ACCEPTED && error.paths.length > 0 ? "excluded" : "other";
+    if (kind === "conflict" && error.paths.length > 0) {
+      report(`\uC0AC\uC774\uD2B8 \uCABD\uC774 \uB2EC\uB77C\uC9C4 \uD30C\uC77C ${error.paths.length}\uAC1C: ${trimPaths([...error.paths], 5).join(" \xB7 ")}`);
+    }
+    return { kind, error, rejectedPaths: [...error.paths], generation: null, previewUrl: null, warning: null };
+  }
+}
+async function bodyOf(root, edits) {
+  const body = [];
+  let total = 0;
+  for (const edit of edits) {
+    if (edit.sha256 === null) {
+      body.push({ path: edit.path, remove: true, ...edit.baseSha256 === null ? {} : { baseSha256: edit.baseSha256 } });
+      continue;
+    }
+    const size = (await stat2(join9(root, edit.path))).size;
+    if (size > MAX_PUSH_FILE_BYTES) {
+      throw new DevtoolsError("PUSH_TOO_LARGE", `\uD30C\uC77C \uD558\uB098\uAC00 \uB108\uBB34 \uD07D\uB2C8\uB2E4: ${edit.path} (${Math.round(size / 1024)}KB \xB7 \uC0C1\uD55C ${MAX_PUSH_FILE_BYTES / 1024}KB).`, "\uB3D9\uC601\uC0C1\xB7\uC6D0\uBCF8 \uC774\uBBF8\uC9C0\xB7\uBE4C\uB4DC \uC0B0\uCD9C\uBB3C\uC774 \uC18C\uC2A4 \uD3F4\uB354\uC5D0 \uB4E4\uC5B4 \uC788\uC9C0 \uC54A\uC740\uC9C0 \uD655\uC778\uD574 \uC8FC\uC138\uC694.");
+    }
+    if (total + size > MAX_PUSH_BYTES)
+      throw tooLarge();
+    const raw = await readFile4(join9(root, edit.path));
+    const breach = templateBreach(basename3(edit.path), raw);
+    if (breach !== null) {
+      throw new DevtoolsError("PUSH_SECRET_TEMPLATE", `${edit.path} \uC5D0 \uC2E4\uC81C \uAC12\uC774 \uB4E4\uC5B4 \uC788\uC5B4 \uC62C\uB9AC\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4(${breach}).`, "`.env.example` \uAC19\uC740 \uC11C\uC2DD \uD30C\uC77C\uC740 \uAC12\uC744 \uBE44\uC6CC \uB450\uC5B4\uC57C \uC62C\uB77C\uAC11\uB2C8\uB2E4. \uC2E4\uC81C \uAC12\uC740 \uCF58\uC194\uC758 \uD658\uACBD\uBCC0\uC218 \uD654\uBA74\uC5D0\uC11C \uAD00\uB9AC\uD574 \uC8FC\uC138\uC694.");
+    }
+    if (!Buffer.from(raw.toString("utf8"), "utf8").equals(raw)) {
+      throw new DevtoolsError("PUSH_NOT_TEXT", `\uAE00\uC790 \uD30C\uC77C\uC774 \uC544\uB2C8\uB77C \uC62C\uB9B4 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4: ${edit.path}`, "\uC774 \uBC29\uBC95\uC740 \uAE00\uC790\uB85C \uB41C \uD30C\uC77C\uB9CC \uB2E4\uB8F9\uB2C8\uB2E4. \uADF8\uB9BC\xB7\uAE00\uAF34\xB7\uC555\uCD95 \uD30C\uC77C\uC774 \uBC14\uB00C\uC5C8\uC73C\uBA74 \uCF58\uC194\uC5D0\uC11C \uC18C\uC2A4\uB97C \uD1B5\uC9F8\uB85C \uC62C\uB824 \uC8FC\uC138\uC694 \u2014 \uADF8\uB7EC\uBA74 \uADF8 \uD30C\uC77C\uB4E4\uB3C4 \uADF8\uB300\uB85C \uAC11\uB2C8\uB2E4.");
+    }
+    total += size;
+    body.push({
+      path: edit.path,
+      content: raw.toString("utf8"),
+      ...edit.baseSha256 === null ? {} : { baseSha256: edit.baseSha256 }
+    });
+  }
+  if (Buffer.byteLength(JSON.stringify({ edits: body }), "utf8") > MAX_PUSH_BYTES)
+    throw tooLarge();
+  return body;
+}
+function tooLarge() {
+  return new DevtoolsError("PUSH_TOO_LARGE", `\uD55C \uBC88\uC5D0 \uC62C\uB9B4 \uC218 \uC788\uB294 \uCD1D\uB7C9(${Math.round(MAX_PUSH_BYTES / 1024 / 1024 * 10) / 10}MB)\uC744 \uB118\uC5C8\uC2B5\uB2C8\uB2E4.`, "\uB098\uB220 \uBCF4\uB0B4\uBA74 \uC0AC\uC774\uD2B8 \uCABD\uC5D0 \uBC18\uCABD\uB9CC \uC11C\uB294 \uC0C1\uD0DC\uAC00 \uC0DD\uAE41\uB2C8\uB2E4 \u2014 \uCF58\uC194\uC5D0\uC11C \uC18C\uC2A4\uB97C \uD1B5\uC9F8\uB85C \uC62C\uB824 \uC8FC\uC138\uC694.");
+}
+function responseLost(cause, noted) {
+  return new DevtoolsError("PUSH_RESPONSE_LOST", "\uC62C\uB838\uB294\uC9C0 \uD655\uC778\uD558\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4.", noted ? "\uCF58\uC194\uC758 \u300C\uD3B8\uC9D1 \uC911\u300D\uC5D0\uC11C \uC9C0\uAE08 \uAC78\uB824 \uC788\uB294 \uB0B4\uC6A9\uC744 \uBA3C\uC800 \uBD10 \uC8FC\uC138\uC694. \uB2E4\uC74C\uC5D0 \uB2E4\uC2DC \uC2E4\uD589\uD558\uBA74 \uC774 \uB3C4\uAD6C\uAC00 \uC0AC\uC774\uD2B8 \uCABD\uACFC \uB300\uC870\uD574 \uC815\uB9AC\uD569\uB2C8\uB2E4." : "\uCF58\uC194\uC758 \u300C\uD3B8\uC9D1 \uC911\u300D\uC5D0\uC11C \uC9C0\uAE08 \uAC78\uB824 \uC788\uB294 \uB0B4\uC6A9\uC744 \uBD10 \uC8FC\uC138\uC694. \uC774 \uD3F4\uB354\uC758 \uAE30\uC900 \uAE30\uB85D\uC744 \uC4F0\uC9C0 \uBABB\uD574 \uB2E4\uC74C \uC2E4\uD589\uC774 \uC790\uB3D9\uC73C\uB85C \uC815\uB9AC\uD558\uC9C0\uB294 \uBABB\uD569\uB2C8\uB2E4.", cause);
+}
+var ledgerUnknown = () => new DevtoolsError("LEDGER_UNKNOWN", "\uC774 \uD3F4\uB354\uC5D0 \uAE30\uC900 \uAE30\uB85D\uC774 \uC5C6\uC5B4 \uBB34\uC5C7\uC774 \uB2EC\uB77C\uC84C\uB294\uC9C0 \uC140 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.", "`zalkera baseline` \uC744 \uC2E4\uD589\uD558\uBA74 \uC9C0\uAE08 \uBC84\uC804\uC744 \uAE30\uC900\uC73C\uB85C \uB2E4\uC2DC \uC138\uC6C1\uB2C8\uB2E4. \uD3F4\uB354\uC758 \uD30C\uC77C\uC740 \uAC74\uB4DC\uB9AC\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4.");
+var foreignLedger = (tenant) => new DevtoolsError("LEDGER_UNKNOWN", `\uC774 \uD3F4\uB354\uC758 \uAE30\uC900 \uAE30\uB85D\uC740 \uB2E4\uB978 \uC0AC\uC774\uD2B8(${tenant})\uC758 \uAC83\uC785\uB2C8\uB2E4.`, "`zalkera pull` \uB85C \uC774 \uC0AC\uC774\uD2B8\uC758 \uC18C\uC2A4\uB97C \uBC1B\uAC70\uB098, `zalkera baseline` \uC73C\uB85C \uAE30\uC900\uC744 \uB2E4\uC2DC \uC138\uC6CC \uC8FC\uC138\uC694.");
+function unreachable() {
+  return new DevtoolsError("SERVER_REJECTED", "\uC62C\uB9AC\uAE30\uAC00 \uB05D\uB098\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4.", "\uB2E4\uC2DC \uC2DC\uB3C4\uD574 \uC8FC\uC138\uC694.");
+}
+function baseMoved(mine, now, dirty) {
+  const way = dirty === 0 ? `\uC774 \uD3F4\uB354\uB97C ${now}\uD310\uC5D0 \uB9DE\uCD94\uB824\uBA74 \`zalkera pull\` \uC744 \uC2E4\uD589\uD558\uC138\uC694.` : `\uC774 \uD3F4\uB354\uC5D0\uC11C \uACE0\uCE5C \uAC83\uC774 ${dirty}\uAC1C \uC788\uC5B4 \`zalkera pull\` \uB3C4 \uADF8\uB300\uB85C\uB294 \uB9C9\uD799\uB2C8\uB2E4. \`zalkera pull --discard-local\` \uC744 \uC2E4\uD589\uD558\uBA74 \uACE0\uCE5C \uD30C\uC77C\uC744 \uC606 \uD3F4\uB354\uC5D0 \uC62E\uACA8 \uB450\uACE0 \uC0C8 \uD310\uC744 \uBC1B\uC2B5\uB2C8\uB2E4 \u2014 \uADF8 \uB4A4 \uC62E\uACA8 \uB454 \uD30C\uC77C\uC744 \uBCF4\uACE0 \uB2E4\uC2DC \uACE0\uCCD0 \uC62C\uB9AC\uC2DC\uBA74 \uB429\uB2C8\uB2E4.`;
+  return new DevtoolsError("PUSH_BASE_MOVED", `\uAE30\uC900\uC774 ${mine}\uD310\uC5D0\uC11C ${now}\uD310\uC73C\uB85C \uC6C0\uC9C1\uC5EC \uC544\uBB34\uAC83\uB3C4 \uC62C\uB9AC\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4.`, `${way} \uC9C0\uAE08 \uC62C\uB9AC\uBA74 ${mine}\uD310\uC744 \uBCF4\uACE0 \uACE0\uCE5C \uB0B4\uC6A9\uC774 ${now}\uD310 \uC704\uC5D0 \uC5B9\uD799\uB2C8\uB2E4.`);
+}
+
+// ../core/dist/draftLifecycle.js
+import { resolve as resolve6 } from "node:path";
+init_errors();
+import { rm as rm3 } from "node:fs/promises";
+async function publishDraft(options) {
+  const report = options.onProgress ?? (() => {
+  });
+  const root = resolve6(options.folder);
+  report("\uD3B8\uC9D1\uC744 \uC0C8 \uBC84\uC804\uC73C\uB85C \uC62C\uB9AC\uB294 \uC911\uC785\uB2C8\uB2E4\u2026");
+  const published = await requireConsent(() => options.api.publishDraft(options.label, options.discardPendingChanges === true)).catch((error) => {
+    if (error instanceof DevtoolsError && error.serverCode === "DRAFT_BASE_MOVED") {
+      throw new DevtoolsError("PUBLISH_BASE_MOVED", "\uD3B8\uC9D1\uC744 \uC2DC\uC791\uD55C \uB4A4 \uC0AC\uC774\uD2B8 \uBC84\uC804\uC774 \uBC14\uB00C\uC5B4 \uC774 \uD3B8\uC9D1\uC744 \uC62C\uB9B4 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.", "`zalkera discard` \uB85C \uADF8 \uD3B8\uC9D1\uC744 \uBC84\uB9B0 \uB4A4, `zalkera pull` \uB85C \uC9C0\uAE08 \uBC84\uC804\uC744 \uBC1B\uC544 \uB2E4\uC2DC \uACE0\uCCD0 \uC8FC\uC138\uC694. \uBC84\uB9AC\uAE30\uB294 \uBB34\uC5C7\uC774 \uAC78\uB824 \uC788\uB294\uC9C0 \uBA3C\uC800 \uBCF4\uC5EC \uC90D\uB2C8\uB2E4.", error);
+    }
+    throw error;
+  });
+  report("\uC0C8 \uBC84\uC804\uC758 \uD30C\uC77C \uBAA9\uB85D\uC744 \uC77D\uB294 \uC911\uC785\uB2C8\uB2E4\u2026");
+  const rebuilt = await rebuildBaseline({
+    api: options.api,
+    folder: root,
+    revisionNo: published.revisionNo,
+    onProgress: report,
+    fetchImpl: options.fetchImpl
+  }).catch(() => null);
+  if (rebuilt === null) {
+    await forgetLedger(root);
+    return { ...published, ledgerRebuilt: false, files: null };
+  }
+  return { ...published, ledgerRebuilt: true, files: rebuilt.files };
+}
+async function rollbackRevision(options) {
+  const report = options.onProgress ?? (() => {
+  });
+  const root = resolve6(options.folder);
+  const active = await activeRevisionNo(options.api);
+  if (options.revisionNo === active) {
+    throw new DevtoolsError("ROLLBACK_IS_DISCARD", `${options.revisionNo}\uD310\uC740 \uC9C0\uAE08 \uCF1C\uC838 \uC788\uB294 \uBC84\uC804\uC785\uB2C8\uB2E4 \u2014 \uB418\uB3CC\uB9B4 \uAC83\uC774 \uC5C6\uC2B5\uB2C8\uB2E4.`, "\uD3B8\uC9D1 \uC911\uC778 \uAC83\uC744 \uBC84\uB9AC\uB824\uB294 \uAC83\uC774\uB77C\uBA74 `zalkera discard` \uB97C \uC4F0\uC138\uC694. \uADF8\uCABD\uC740 \uD310\uC744 \uC62E\uAE30\uC9C0 \uC54A\uACE0 \uD3B8\uC9D1\uB9CC \uBC84\uB9BD\uB2C8\uB2E4.");
+  }
+  report(`${options.revisionNo}\uD310\uC73C\uB85C \uB418\uB3CC\uB9AC\uB294 \uC911\uC785\uB2C8\uB2E4\u2026`);
+  const result = await requireConsent(() => options.api.activateRevision(options.revisionNo, options.discardPending === true)).catch((error) => {
+    if (isDraftInProgress(error)) {
+      throw new DevtoolsError("ROLLBACK_BLOCKED_BY_DRAFT", "\uC0AC\uC774\uD2B8 \uCABD\uC5D0 \uD3B8\uC9D1 \uC911\uC778 \uAC83\uC774 \uC788\uC5B4 \uBC84\uC804\uC744 \uB418\uB3CC\uB9B4 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.", "`zalkera publish` \uB85C \uADF8 \uD3B8\uC9D1\uC744 \uC0C8 \uBC84\uC804\uC73C\uB85C \uB9CC\uB4E4\uAC70\uB098, `zalkera discard` \uB85C \uBC84\uB9B0 \uB4A4 \uB2E4\uC2DC \uC2DC\uB3C4\uD574 \uC8FC\uC138\uC694. \uBC84\uB9AC\uAE30\uB294 \uBB34\uC5C7\uC774 \uAC78\uB824 \uC788\uB294\uC9C0 \uBA3C\uC800 \uBCF4\uC5EC \uC90D\uB2C8\uB2E4.", error);
+    }
+    throw error;
+  });
+  const landed = plausibleRevisionNo(result.revisionNo) ?? await activeRevisionNo(options.api).catch(() => null);
+  if (landed === null) {
+    await forgetLedger(root);
+    return {
+      revisionNo: null,
+      requested: options.revisionNo,
+      pointerMoved: result.pointerMoved ?? true,
+      discardedDraft: result.discardedDraft ?? false,
+      discardedPendingChanges: result.discardedPendingChanges ?? 0,
+      ledgerRebuilt: false,
+      differing: []
+    };
+  }
+  const rebuilt = await rebuildBaseline({
+    api: options.api,
+    folder: root,
+    revisionNo: landed,
+    onProgress: report,
+    fetchImpl: options.fetchImpl
+  }).catch(() => null);
+  if (rebuilt === null)
+    await forgetLedger(root);
+  return {
+    revisionNo: landed,
+    requested: options.revisionNo,
+    pointerMoved: result.pointerMoved ?? true,
+    discardedDraft: result.discardedDraft ?? false,
+    discardedPendingChanges: result.discardedPendingChanges ?? 0,
+    ledgerRebuilt: rebuilt !== null,
+    differing: rebuilt?.differing ?? []
+  };
+}
+async function discardDraft(options) {
+  const report = options.onProgress ?? (() => {
+  });
+  const root = resolve6(options.folder);
+  const active = await activeRevisionNo(options.api);
+  const now = await options.api.draftFiles().catch(() => null);
+  if (now === null || (now.generation ?? null) !== options.plan.generation) {
+    throw new DevtoolsError("DRAFT_MOVED_WHILE_CONFIRMING", "\uD655\uC778\uD558\uC2DC\uB294 \uC0AC\uC774 \uC0AC\uC774\uD2B8 \uCABD \uD3B8\uC9D1\uC774 \uB2EC\uB77C\uC838 \uC544\uBB34\uAC83\uB3C4 \uBC84\uB9AC\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4.", "`zalkera discard` \uB97C \uB2E4\uC2DC \uC2E4\uD589\uD558\uBA74 \uC9C0\uAE08 \uAC78\uB824 \uC788\uB294 \uAC83\uC744 \uBCF4\uC5EC \uB4DC\uB9BD\uB2C8\uB2E4.");
+  }
+  report("\uD3B8\uC9D1 \uC911\uC778 \uAC83\uC744 \uBC84\uB9AC\uB294 \uC911\uC785\uB2C8\uB2E4\u2026");
+  const result = await options.api.activateRevision(active, options.discardPending === true).catch(async (error) => {
+    if (!needsDiscardConsent(error) || !(error instanceof DevtoolsError))
+      throw error;
+    if (creditsAtStake(error))
+      throw asConsentRequired(error);
+    report("\uC11C\uBC84\uAC00 \uD655\uC778\uC744 \uD55C \uBC88 \uB354 \uC694\uAD6C\uD574 \uBC29\uAE08 \uC8FC\uC2E0 \uB3D9\uC758\uB97C \uADF8\uB300\uB85C \uC787\uC2B5\uB2C8\uB2E4\u2026");
+    return options.api.activateRevision(active, true);
+  });
+  const ledger = await readLedger(root);
+  if (ledger)
+    await writeLedger(root, { ...ledger, server: null, mine: {} });
+  return {
+    plan: options.plan,
+    discardedPendingChanges: result.discardedPendingChanges ?? 0,
+    hadDraft: result.discardedDraft ?? options.plan.paths.length > 0,
+    // 🔴 **라이브가 움직였는지 싣는다.** 갈래는 서버가 정한다 — 우리가 읽은 활성 판이 그 사이
+    //    낡았으면 서버는 이 호출을 **되돌리기로 처리해 포인터를 옮긴다.** 그 사실을 안 실으면
+    //    배포 사건이 일어났는데 「아무 일도 없었다」로 읽힌다.
+    pointerMoved: result.pointerMoved ?? false
+  };
+}
+async function forgetLedger(root) {
+  const target = await resolveExisting(root, SYNC_LEDGER_PATH);
+  if (target === null)
+    return;
+  await rm3(target, { force: true }).catch(() => void 0);
+}
+async function activeRevisionNo(api) {
+  const rows = await api.listRevisions().catch(() => null);
+  if (rows === null) {
+    throw new DevtoolsError("SERVER_UNREADABLE_DRAFT", "\uC9C0\uAE08 \uC0AC\uC774\uD2B8\uC5D0 \uCF1C\uC838 \uC788\uB294 \uBC84\uC804\uC744 \uD655\uC778\uD558\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4.", "\uC7A0\uC2DC \uB4A4 \uB2E4\uC2DC \uC2DC\uB3C4\uD574 \uC8FC\uC138\uC694. \uACC4\uC18D \uADF8\uB7EC\uBA74 \uC774 \uACC4\uC815\uC5D0 \uBC84\uC804 \uBAA9\uB85D\uC744 \uBCFC \uAD8C\uD55C\uC774 \uC788\uB294\uC9C0 \uD655\uC778\uD574 \uC8FC\uC138\uC694.");
+  }
+  const active = rows.find((row) => row.isActive)?.revisionNo;
+  if (active !== void 0)
+    return active;
+  const fallback = await api.draftState().then((state) => state.revertTargetRevisionNo ?? null).catch(() => null);
+  if (fallback !== null)
+    return fallback;
+  throw new DevtoolsError("SERVER_UNREADABLE_DRAFT", "\uC774 \uC0AC\uC774\uD2B8\uC5D0 \uCF1C\uC838 \uC788\uB294 \uBC84\uC804\uC774 \uC5C6\uC2B5\uB2C8\uB2E4.", "\uCF58\uC194\uC5D0\uC11C \uC5B4\uB5A4 \uBC84\uC804\uC744 \uCF24\uC9C0 \uBA3C\uC800 \uC815\uD574 \uC8FC\uC138\uC694. \uADF8 \uC804\uC5D0\uB294 \uBB34\uC5C7 \uC704\uC5D0 \uC5B9\uB294 \uAC83\uC778\uC9C0 \uC54C \uC218 \uC5C6\uC5B4 \uC6D0\uC7A5\uC744 \uAC74\uB4DC\uB9AC\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4.");
+}
+async function requireConsent(call) {
+  try {
+    return await call();
+  } catch (error) {
+    if (needsDiscardConsent(error) && error instanceof DevtoolsError)
+      throw asConsentRequired(error);
+    throw error;
+  }
+}
+function asConsentRequired(error) {
+  return new DevtoolsError("DISCARD_CONSENT_REQUIRED", error.message, creditsAtStake(error) ? "\uADF8\uB798\uB3C4 \uACC4\uC18D\uD558\uB824\uBA74 `--discard-pending` \uC744 \uBD99\uC5EC \uC8FC\uC138\uC694. \uC4F4 \uD06C\uB808\uB527\uC740 \uB3CC\uC544\uC624\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4." : "\uADF8\uB798\uB3C4 \uACC4\uC18D\uD558\uB824\uBA74 `--discard-pending` \uC744 \uBD99\uC5EC \uC8FC\uC138\uC694.", error);
+}
+var PENDING_MARK = "pendingAiChanges";
+function creditsAtStake(error) {
+  return error.paths.length === 0 || error.paths.includes(PENDING_MARK);
+}
+
+// ../core/dist/strandedPlan.js
+function planStranded(input) {
+  const { ledger, draft } = input;
+  if (!draft)
+    return { verdict: "elsewhere", empty: false, paths: [], generation: null, reason: "server-unreadable" };
+  const paths = [...draft.changed.map((row) => row.path), ...draft.deleted].sort();
+  const generation = draft.generation ?? null;
+  const empty = paths.length === 0;
+  if (!ledger)
+    return { verdict: "elsewhere", empty, paths, generation, reason: "no-ledger" };
+  const seen = ledger.server?.generation ?? null;
+  if (seen === null)
+    return { verdict: "elsewhere", empty, paths, generation, reason: "generation-unknown" };
+  if (seen !== (draft.generation ?? null)) {
+    return { verdict: "elsewhere", empty, paths, generation, reason: "generation-differs" };
+  }
+  for (const path of draft.deleted) {
+    if (!Object.hasOwn(ledger.mine, path))
+      return { verdict: "elsewhere", empty, paths, generation, reason: "path-not-mine" };
+    if (ledger.mine[path] !== null)
+      return { verdict: "elsewhere", empty, paths, generation, reason: "sha-differs" };
+  }
+  for (const row of draft.changed) {
+    if (!Object.hasOwn(ledger.mine, row.path)) {
+      return { verdict: "elsewhere", empty, paths, generation, reason: "path-not-mine" };
+    }
+    if (ledger.mine[row.path] !== row.sha256) {
+      return { verdict: "elsewhere", empty, paths, generation, reason: "sha-differs" };
+    }
+  }
+  return { verdict: "mine", empty, paths, generation, reason: "ledger-matches" };
+}
+
+// src/main.ts
+import { spawn } from "node:child_process";
+
+// src/args.ts
+function parseArgs(argv) {
+  const positional = [];
+  const flags = {};
+  let literal = false;
+  for (let i = 0; i < argv.length; i += 1) {
+    const token = argv[i];
+    if (literal) {
+      positional.push(token);
+      continue;
+    }
+    if (token === "--") {
+      literal = true;
+      continue;
+    }
+    if (!token.startsWith("--")) {
+      positional.push(token);
+      continue;
+    }
+    const body = token.slice(2);
+    const eq = body.indexOf("=");
+    if (eq >= 0) {
+      flags[body.slice(0, eq)] = body.slice(eq + 1);
+      continue;
+    }
+    const next = argv[i + 1];
+    if (next !== void 0 && !next.startsWith("--")) {
+      flags[body] = next;
+      i += 1;
+      continue;
+    }
+    flags[body] = true;
+  }
+  return { command: positional.shift() ?? null, positional, flags };
+}
+function flagOn(flags, name) {
+  const value = flags[name];
+  if (value === void 0) return false;
+  if (value === true) return true;
+  return !["false", "0", "no", ""].includes(value.toLowerCase());
+}
+function flagValue(flags, name) {
+  const value = flags[name];
+  return typeof value === "string" && value !== "" ? value : null;
+}
+
+// src/context.ts
+import { readFileSync } from "node:fs";
+import { readFile as readFile6 } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+import { join as join11, resolve as resolve8 } from "node:path";
+
+// src/tokenStore.ts
+import { chmod as chmod2, readFile as readFile5, rm as rm4 } from "node:fs/promises";
+import { homedir } from "node:os";
+import { basename as basename4, dirname as dirname2, isAbsolute as isAbsolute2, join as join10, resolve as resolve7, sep as sep6 } from "node:path";
+function tokenPath(env = process.env, home = homedir()) {
+  const fallback = join10(home, ".config");
+  const base = env.XDG_CONFIG_HOME;
+  const inside = base !== void 0 && isAbsolute2(base) && (resolve7(base) === resolve7(home) || resolve7(base).startsWith(resolve7(home) + sep6));
+  return join10(inside ? resolve7(base) : fallback, "zalkera", "auth.json");
+}
+var FileTokenStore = class {
+  // ⚠ 매개변수 프로퍼티(`constructor(private path)`)를 안 쓴다 — Node 의 타입 제거 실행기가
+  //   그 문법을 거절해 **시험이 아예 안 돈다.** 이 레포의 시험은 전부 그 실행기로 돈다.
+  path;
+  constructor(path = tokenPath()) {
+    this.path = path;
+  }
+  async read() {
+    const text = await readFile5(this.path, "utf8").catch(() => null);
+    if (text === null) return null;
+    try {
+      const raw = JSON.parse(text);
+      if (typeof raw !== "object" || raw === null) return null;
+      const t = raw;
+      if (typeof t.accessToken !== "string" || typeof t.refreshToken !== "string" || typeof t.expiresAt !== "number" || typeof t.issuer !== "string") {
+        return null;
+      }
+      return {
+        accessToken: t.accessToken,
+        refreshToken: t.refreshToken,
+        expiresAt: t.expiresAt,
+        issuer: t.issuer
+      };
+    } catch {
+      return null;
+    }
+  }
+  async write(tokens) {
+    const dir = await ensureOwnDir(dirname2(dirname2(this.path)), basename4(dirname2(this.path)));
+    await chmod2(dir, 448).catch(() => {
+    });
+    await writeOwnFile(this.path, JSON.stringify(tokens), 384);
+    await chmod2(this.path, 384);
+  }
+  async clear() {
+    await rm4(this.path, { force: true });
+  }
+};
+
+// src/context.ts
+var DEFAULT_SERVER = "https://api.zalkera.com";
+function serverUrlOf(env = process.env) {
+  const raw = env.ZALKERA_SERVER ?? DEFAULT_SERVER;
+  const url = apiBaseUrl(raw);
+  if (!url) {
+    throw new DevtoolsError(
+      "SERVER_UNREACHABLE",
+      `\uC11C\uBC84 \uC8FC\uC18C\uAC00 \uC62C\uBC14\uB974\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4: ${raw}`,
+      "`ZALKERA_SERVER` \uB97C \uD655\uC778\uD574 \uC8FC\uC138\uC694."
+    );
+  }
+  return url.toString().replace(/\/$/, "");
+}
+async function tenantOf(folder, explicit) {
+  if (explicit) return TENANT_CODE.test(explicit) ? explicit : null;
+  const mark = parseSourceMark(await readFile6(join11(folder, SOURCE_MARK_PATH), "utf8").catch(() => null));
+  if (mark) return mark.tenant;
+  const text = await readFile6(join11(folder, SYNC_LEDGER_PATH), "utf8").catch(() => null);
+  return text === null ? null : parseSyncLedger(text)?.tenant ?? null;
+}
+async function openAuth(options = {}) {
+  const handshake = await fetchHandshake(serverUrlOf(options.env ?? process.env), version(), fetch, UPGRADE_HOW);
+  return { auth: handshake.auth, store: options.store ?? new FileTokenStore() };
+}
+async function openContext(options = {}) {
+  const env = options.env ?? process.env;
+  const folder = resolve8(options.folder ?? process.cwd());
+  const serverUrl = serverUrlOf(env);
+  const tenant = await tenantOf(folder, options.tenant);
+  if (!tenant) {
+    throw new DevtoolsError(
+      "NOT_A_SITE",
+      "\uC774 \uD3F4\uB354\uAC00 \uC5B4\uB290 \uC0AC\uC774\uD2B8\uC758 \uAC83\uC778\uC9C0 \uC54C \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.",
+      "\uC0AC\uC774\uD2B8 \uD3F4\uB354 \uC548\uC5D0\uC11C \uC2E4\uD589\uD558\uAC70\uB098 `--site <\uC0AC\uC774\uD2B8\uCF54\uB4DC>` \uB97C \uBD99\uC5EC \uC8FC\uC138\uC694."
+    );
+  }
+  for (const line of await misplacedToolLines(folder)) process.stderr.write(`${line}
+`);
+  const handshake = await fetchHandshake(serverUrl, version(), fetch, UPGRADE_HOW);
+  const store = options.store ?? new FileTokenStore();
+  const auth = handshake.auth;
+  const api = new ZalkeraApi({
+    apiBase: serverUrl,
+    accessToken: () => getAccessToken(auth, store),
+    tenantCode: () => tenant
+  });
+  return { api, auth, store, folder, tenant, serverUrl };
+}
+async function misplacedToolLines(folder) {
+  const found = await inspectProject(folder).then((p) => p.toolInDeps).catch(() => []);
+  if (found.length === 0) return [];
+  return [
+    `\u26A0 ${found.join(" \xB7 ")} \uAC00 \uC774 \uC0AC\uC774\uD2B8\uC758 \uC758\uC874\uC73C\uB85C \uB4E4\uC5B4 \uC788\uC2B5\uB2C8\uB2E4.`,
+    "  \uC774\uAC83\uC740 \uC18C\uC2A4\uAC00 `import` \uD558\uB294 \uD328\uD0A4\uC9C0\uAC00 \uC544\uB2C8\uB77C \uD130\uBBF8\uB110\uC5D0\uC11C \uCE58\uB294 \uBA85\uB839\uC785\uB2C8\uB2E4.",
+    "  `package.json` \uC5D0\uC11C \uBE7C \uC8FC\uC138\uC694 \u2014 \uADF8\uB300\uB85C \uB450\uBA74 \uC0AC\uC774\uD2B8\uB97C \uC9C0\uC744 \uB54C \uD568\uAED8 \uC124\uCE58\uB429\uB2C8\uB2E4."
+  ];
+}
+var UPGRADE_HOW = "`npx @zalkera/cli@latest <\uBA85\uB839>` \uC73C\uB85C \uBD80\uB974\uAC70\uB098, \uC804\uC5ED \uC124\uCE58\uB97C \uC4F0\uC2E0\uB2E4\uBA74 `npm i -g @zalkera/cli@latest` \uB97C \uC2E4\uD589\uD574 \uC8FC\uC138\uC694.";
+function version() {
+  let raw;
+  try {
+    raw = JSON.parse(readFileSync(fileURLToPath(new URL("../package.json", import.meta.url)), "utf8"));
+  } catch (error) {
+    throw new DevtoolsError(
+      "INSTALL_BROKEN",
+      "\uC774 \uB3C4\uAD6C\uC758 \uC124\uCE58\uAC00 \uC628\uC804\uD558\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4 \u2014 \uC790\uAE30 \uBC84\uC804\uC744 \uC77D\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4.",
+      "`npm i -g @zalkera/cli@latest` \uB85C \uB2E4\uC2DC \uC124\uCE58\uD558\uAC70\uB098, `npx @zalkera/cli@latest <\uBA85\uB839>` \uC73C\uB85C \uC2E4\uD589\uD574 \uC8FC\uC138\uC694.",
+      error
+    );
+  }
+  const declared = raw.version;
+  if (typeof declared !== "string" || declared === "") {
+    throw new DevtoolsError(
+      "INSTALL_BROKEN",
+      "\uC774 \uB3C4\uAD6C\uC758 \uC124\uCE58\uAC00 \uC628\uC804\uD558\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4 \u2014 \uBC84\uC804 \uD45C\uAE30\uAC00 \uBE44\uC5B4 \uC788\uC2B5\uB2C8\uB2E4.",
+      "`npm i -g @zalkera/cli@latest` \uB85C \uB2E4\uC2DC \uC124\uCE58\uD558\uAC70\uB098, `npx @zalkera/cli@latest <\uBA85\uB839>` \uC73C\uB85C \uC2E4\uD589\uD574 \uC8FC\uC138\uC694."
+    );
+  }
+  return declared;
+}
+
+// src/confirm.ts
+import { createInterface } from "node:readline/promises";
+async function confirm(options) {
+  if (options.given === true) return true;
+  const input = options.input ?? process.stdin;
+  const output = options.output ?? process.stderr;
+  if (input.isTTY !== true) {
+    output.write(
+      `${options.question}
+\uD130\uBBF8\uB110\uC774 \uC544\uB2C8\uB77C \uBB3C\uC5B4\uBCFC \uC218 \uC5C6\uC2B5\uB2C8\uB2E4. \uACC4\uC18D\uD558\uB824\uBA74 \`${options.flag}\` \uB97C \uBD99\uC5EC \uC8FC\uC138\uC694.
+`
+    );
+    return false;
+  }
+  const rl = createInterface({ input, output });
+  try {
+    const answer = (await rl.question(`${options.question}
+> `)).trim();
+    if (options.phrase !== void 0) return answer === options.phrase;
+    return ["y", "yes", "\uC608"].includes(answer.toLowerCase());
+  } finally {
+    rl.close();
+  }
+}
+
+// src/report.ts
+var PATH_SHOW = 200;
+function bullets(paths, verbose) {
+  return trimPaths(paths, PATH_LIST_CAP, verbose).map((p) => `  \xB7 ${plainNotice(p, PATH_SHOW)}`);
+}
+function block(title, paths, verbose) {
+  if (paths.length === 0) return [];
+  return [`${title} ${paths.length}\uAC1C`, ...bullets(paths, verbose)];
+}
+function pathLines(paths, verbose = false) {
+  return bullets(paths, verbose);
+}
+function describeStatus(status, verbose = false) {
+  const lines = [];
+  lines.push(`\uC0AC\uC774\uD2B8: ${status.tenant ?? "(\uBAA8\uB984)"}`);
+  lines.push(
+    status.baseRevisionNo === null ? "\uC774 \uD3F4\uB354\uAC00 \uC120 \uD310: \uBAA8\uB984" : `\uC774 \uD3F4\uB354\uAC00 \uC120 \uD310: ${status.baseRevisionNo}\uD310`
+  );
+  if (status.activeRevisionNo !== null) lines.push(`\uC9C0\uAE08 \uC0AC\uC774\uD2B8\uC5D0 \uCF1C\uC9C4 \uD310: ${status.activeRevisionNo}\uD310`);
+  if (status.behind) {
+    lines.push("");
+    lines.push(`\uAE30\uC900\uC774 ${status.baseRevisionNo}\uD310\uC5D0\uC11C ${status.activeRevisionNo}\uD310\uC73C\uB85C \uC6C0\uC9C1\uC600\uC2B5\uB2C8\uB2E4.`);
+    const dirty = status.changed.length + status.removed.length;
+    lines.push(
+      dirty === 0 ? `\uC774 \uD3F4\uB354\uB97C ${status.activeRevisionNo}\uD310\uC5D0 \uB9DE\uCD94\uB824\uBA74 \`zalkera pull\` \uC744 \uC2E4\uD589\uD558\uC138\uC694.` : `\uC774 \uD3F4\uB354\uC5D0\uC11C \uACE0\uCE5C \uAC83\uC774 ${dirty}\uAC1C \uC788\uC5B4 \`zalkera pull\` \uC740 \uADF8\uB300\uB85C\uB294 \uB9C9\uD799\uB2C8\uB2E4. \`zalkera pull --discard-local\` \uC744 \uC2E4\uD589\uD558\uBA74 \uACE0\uCE5C \uD30C\uC77C\uC744 \uC606 \uD3F4\uB354\uC5D0 \uC62E\uACA8 \uB450\uACE0 \uC0C8 \uD310\uC744 \uBC1B\uC2B5\uB2C8\uB2E4.`
+    );
+    lines.push(
+      `\uC9C0\uAE08 \uC62C\uB9AC\uBA74 ${status.baseRevisionNo}\uD310\uC744 \uBCF4\uACE0 \uACE0\uCE5C \uB0B4\uC6A9\uC774 ${status.activeRevisionNo}\uD310 \uC704\uC5D0 \uC5B9\uD799\uB2C8\uB2E4.`
+    );
+  }
+  const changes = [
+    ...block("\uACE0\uCE5C \uAC83", status.changed, verbose),
+    ...block("\uC9C0\uC6B4 \uAC83", status.removed, verbose),
+    ...block("\uC0C8\uB85C \uB9CC\uB4E0 \uAC83", status.added, verbose)
+  ];
+  lines.push("");
+  if (changes.length === 0) lines.push("\uC774 \uD3F4\uB354\uC5D0\uC11C \uACE0\uCE5C \uAC83\uC774 \uC5C6\uC2B5\uB2C8\uB2E4.");
+  else lines.push(...changes);
+  if (status.draftPaths > 0) {
+    lines.push("");
+    lines.push(`\uC0AC\uC774\uD2B8 \uCABD\uC5D0 \uC544\uC9C1 \uC548 \uCF20 \uD3B8\uC9D1\uC774 ${status.draftPaths}\uAC1C \uACBD\uB85C\uC5D0 \uC788\uC2B5\uB2C8\uB2E4.`);
+    lines.push(
+      status.mineValid ? "\uC774 \uD3F4\uB354\uC5D0\uC11C \uC62C\uB9B0 \uAC83\uC785\uB2C8\uB2E4. `zalkera publish` \uB85C \uCF1C\uAC70\uB098 `zalkera discard` \uB85C \uBC84\uB9B4 \uC218 \uC788\uC2B5\uB2C8\uB2E4." : "\uC774 \uD3F4\uB354\uC5D0\uC11C \uC62C\uB9B0 \uAC83\uC778\uC9C0\uB294 \uC54C \uC218 \uC5C6\uC2B5\uB2C8\uB2E4 \u2014 \uADF8 \uC0AC\uC774 \uC0AC\uC774\uD2B8 \uCABD\uC774 \uB2EC\uB77C\uC84C\uC2B5\uB2C8\uB2E4. \uCF58\uC194\uC5D0\uC11C \uBB34\uC5C7\uC774 \uB4E4\uC5B4 \uC788\uB294\uC9C0 \uD655\uC778\uD574 \uC8FC\uC138\uC694."
+    );
+  }
+  for (const blocker of status.blockers) {
+    lines.push("");
+    lines.push(BLOCKER_TEXT[blocker]);
+  }
+  return lines.join("\n");
+}
+var BLOCKER_TEXT = {
+  LEDGER_UNKNOWN: "\uC774 \uD3F4\uB354\uC5D0 \uAE30\uC900 \uAE30\uB85D\uC774 \uC5C6\uC5B4 \uC62C\uB9AC\uAE30\uB294 \uB9C9\uD600 \uC788\uC2B5\uB2C8\uB2E4.\n`zalkera baseline` \uC744 \uC2E4\uD589\uD558\uBA74 \uC9C0\uAE08 \uD310\uC744 \uAE30\uC900\uC73C\uB85C \uB2E4\uC2DC \uC138\uC6C1\uB2C8\uB2E4. \uD3F4\uB354\uC758 \uD30C\uC77C\uC740 \uAC74\uB4DC\uB9AC\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4.",
+  SERVER_UNREADABLE: "\uC9C0\uAE08 \uC0AC\uC774\uD2B8 \uCABD \uC0C1\uD0DC\uB97C \uD655\uC778\uD558\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4. \uADF8\uB798\uC11C \uC62C\uB9AC\uAE30\uB294 \uB9C9\uC544 \uB450\uC5C8\uC2B5\uB2C8\uB2E4.\n\uC7A0\uC2DC \uB4A4 \uB2E4\uC2DC \uC2DC\uB3C4\uD574 \uC8FC\uC138\uC694.",
+  // ⚠ **있는 명령만 댄다.** 좌초는 사람이 막혀서 다음 걸음을 찾는 자리다 — 없는 동사를 대면
+  //   「모르는 명령입니다」로 끝난다. `discard` 는 T3 에서 실제로 생겼다.
+  STRANDED: "\uC0AC\uC774\uD2B8 \uCABD\uC5D0\uC11C \uD3B8\uC9D1 \uC911\uC774\uB358 \uAC83\uC774 \uC9C0\uAE08 \uBC84\uC804 \uC704\uAC00 \uC544\uB2D9\uB2C8\uB2E4. \uADF8\uB300\uB85C\uB294 \uCF24 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.\n`zalkera discard` \uB85C \uADF8 \uD3B8\uC9D1\uC744 \uBC84\uB9B4 \uC218 \uC788\uC2B5\uB2C8\uB2E4 \u2014 \uBC84\uB9AC\uAE30 \uC804\uC5D0 \uBB34\uC5C7\uC774 \uAC78\uB824 \uC788\uB294\uC9C0 \uBCF4\uC5EC \uC90D\uB2C8\uB2E4."
+};
+function describePush(result, verbose = false) {
+  const lines = [];
+  if (result.reconciled === "applied") {
+    lines.push("\uC9C0\uB09C\uBC88\uC5D0 \uC62C\uB9B0 \uAC83\uC774 \uC0AC\uC774\uD2B8 \uCABD\uC5D0 \uB4E4\uC5B4\uAC00 \uC788\uC5C8\uC2B5\uB2C8\uB2E4. \uADF8\uAC83\uC73C\uB85C \uC815\uB9AC\uD588\uC2B5\uB2C8\uB2E4.");
+  } else if (result.reconciled === "not-applied") {
+    lines.push("\uC9C0\uB09C\uBC88\uC5D0 \uC62C\uB9B0 \uAC83\uC774 \uC0AC\uC774\uD2B8 \uCABD\uC5D0 \uC5C6\uC5C8\uC2B5\uB2C8\uB2E4.");
+  }
+  lines.push(
+    result.sent > 0 ? `${result.sent}\uAC1C\uB97C \uC62C\uB838\uC2B5\uB2C8\uB2E4(\uADF8\uC911 \uC9C0\uC6B4 \uAC83 ${result.removed}\uAC1C).` : result.droppedByServer.length > 0 ? "\uC62C\uB9B0 \uAC83\uC774 \uC5C6\uC2B5\uB2C8\uB2E4 \u2014 \uB2EC\uB77C\uC9C4 \uAC83\uC774 \uBAA8\uB450 \uC0AC\uC774\uD2B8\uAC00 \uBC1B\uC9C0 \uC54A\uB294 \uACBD\uB85C\uC600\uC2B5\uB2C8\uB2E4." : "\uC62C\uB9B4 \uAC83\uC774 \uC5C6\uC2B5\uB2C8\uB2E4 \u2014 \uC774 \uD3F4\uB354\uC758 \uB0B4\uC6A9\uC774 \uC0AC\uC774\uD2B8 \uCABD\uACFC \uAC19\uC2B5\uB2C8\uB2E4."
+  );
+  if (result.retriedAfterConflict) {
+    lines.push("\uC62C\uB9AC\uB294 \uC0AC\uC774\uC5D0 \uC0AC\uC774\uD2B8 \uCABD\uC774 \uB2EC\uB77C\uC838 \uB2E4\uC2DC \uC77D\uACE0 \uD55C \uBC88 \uB354 \uBCF4\uB0C8\uC2B5\uB2C8\uB2E4.");
+  }
+  if (result.droppedByServer.length > 0) {
+    lines.push(
+      `\uC0AC\uC774\uD2B8\uAC00 \uBC1B\uC9C0 \uC54A\uB294 \uACBD\uB85C ${result.droppedByServer.length}\uAC1C\uB294 \uBE7C\uACE0 \uBCF4\uB0C8\uC2B5\uB2C8\uB2E4.`,
+      ...bullets(result.droppedByServer, verbose)
+    );
+  }
+  if (result.previewUrl) lines.push(`\uBBF8\uB9AC\uBCF4\uAE30: ${result.previewUrl}`);
+  if (result.warning) lines.push(result.warning);
+  if (result.sent > 0) lines.push("\uC544\uC9C1 \uC0AC\uC774\uD2B8\uC5D0 \uCF1C\uC9C0\uC9C0\uB294 \uC54A\uC558\uC2B5\uB2C8\uB2E4 \u2014 \uCF1C\uB824\uBA74 `zalkera publish` \uB97C \uC2E4\uD589\uD558\uC138\uC694.");
+  return lines;
+}
+function describeStranded(plan, verbose = false) {
+  const list = bullets(plan.paths, verbose);
+  if (plan.verdict === "mine") {
+    return [
+      "\uC9C0\uAE08 \uC0AC\uC774\uD2B8 \uCABD\uC5D0 \uAC78\uB824 \uC788\uB294 \uD3B8\uC9D1\uC740 \uC774 \uD3F4\uB354\uC5D0\uC11C \uC62C\uB9B0 \uAC83\uACFC \uAC19\uC2B5\uB2C8\uB2E4.",
+      ...list,
+      "\uBC84\uB9AC\uACE0 \uB2E4\uC2DC \uC62C\uB824\uB3C4 \uC774 \uD3F4\uB354\uC758 \uB0B4\uC6A9\uC740 \uADF8\uB300\uB85C\uC785\uB2C8\uB2E4."
+    ];
+  }
+  if (plan.paths.length === 0) {
+    return [
+      "\u26A0 \uC9C0\uAE08 \uC0AC\uC774\uD2B8 \uCABD\uC5D0 \uBB34\uC5C7\uC774 \uAC78\uB824 \uC788\uB294\uC9C0 \uD655\uC778\uD558\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4.",
+      "\uBC84\uB9AC\uBA74 \uB418\uCC3E\uC744 \uBC29\uBC95\uC774 \uC5C6\uC73C\uB2C8, \uCF58\uC194\uC758 \u300C\uD3B8\uC9D1 \uC911\u300D\uC5D0\uC11C \uBA3C\uC800 \uD655\uC778\uD574 \uC8FC\uC138\uC694."
+    ];
+  }
+  return [
+    "\u26A0 \uC9C0\uAE08 \uC0AC\uC774\uD2B8 \uCABD\uC5D0 **\uC774 \uD3F4\uB354\uC5D0 \uC5C6\uB294 \uD3B8\uC9D1**\uC774 \uAC78\uB824 \uC788\uC2B5\uB2C8\uB2E4.",
+    ...list,
+    "\uCF58\uC194\uC774\uB098 AI \uB85C \uACE0\uCE5C \uB0B4\uC6A9\uC77C \uC218 \uC788\uACE0, \uBC84\uB9AC\uBA74 \uB418\uCC3E\uC744 \uBC29\uBC95\uC774 \uC5C6\uC2B5\uB2C8\uB2E4.",
+    "\uBB34\uC5C7\uC774 \uAC78\uB824 \uC788\uB294\uC9C0 \uCF58\uC194\uC758 \u300C\uD3B8\uC9D1 \uC911\u300D\uC5D0\uC11C \uBA3C\uC800 \uD655\uC778\uD574 \uC8FC\uC138\uC694."
+  ];
+}
+var DISCARD_PHRASE = "\uBC84\uB9BD\uB2C8\uB2E4";
+
+// src/main.ts
+function help() {
+  return `\uC798\uCEE4\uB77C \u2014 \uC0AC\uC774\uD2B8 \uC18C\uC2A4\uB97C \uB85C\uCEEC\uC5D0\uC11C \uB2E4\uB8E8\uB294 \uB3C4\uAD6C (v${version()})
+
+  zalkera login                 \uBE0C\uB77C\uC6B0\uC800\uB85C \uB85C\uADF8\uC778
+  zalkera logout                \uB85C\uADF8\uC778 \uC815\uBCF4\uB97C \uC9C0\uC6B4\uB2E4
+  zalkera status                \uC774 \uD3F4\uB354\uC640 \uC0AC\uC774\uD2B8\uAC00 \uC5B4\uB5BB\uAC8C \uB2E4\uB978\uC9C0 \uBCF8\uB2E4
+  zalkera pull                  \uC0AC\uC774\uD2B8\uC758 \uC9C0\uAE08 \uD310\uC744 \uC774 \uD3F4\uB354\uC5D0 \uBC1B\uB294\uB2E4
+  zalkera push                  \uC774 \uD3F4\uB354\uC5D0\uC11C \uACE0\uCE5C \uAC83\uC744 \uC0AC\uC774\uD2B8 \uCABD\uC5D0 \uC62C\uB9B0\uB2E4(\uCF1C\uC9C0\uC9C0\uB294 \uC54A\uB294\uB2E4)
+  zalkera publish               \uC62C\uB9B0 \uAC83\uC744 \uC0C8 \uBC84\uC804\uC73C\uB85C \uB9CC\uB4E0\uB2E4(\uADF8\uB798\uC57C \uC190\uB2D8\uC5D0\uAC8C \uBCF4\uC778\uB2E4)
+  zalkera rollback <\uD310\uBC88\uD638>      \uB77C\uC774\uBE0C\uB97C \uADF8 \uBC84\uC804\uC73C\uB85C \uB418\uB3CC\uB9B0\uB2E4
+  zalkera discard               \uC0AC\uC774\uD2B8 \uCABD\uC5D0\uC11C \uD3B8\uC9D1 \uC911\uC778 \uAC83\uC744 \uBC84\uB9B0\uB2E4(\uD310\uC740 \uC548 \uC62E\uAE34\uB2E4)
+  zalkera baseline              \uAE30\uC900 \uAE30\uB85D\uB9CC \uC9C0\uAE08 \uD310\uC73C\uB85C \uB2E4\uC2DC \uC138\uC6B4\uB2E4(\uD30C\uC77C\uC740 \uC548 \uAC74\uB4DC\uB9B0\uB2E4)
+
+\uC635\uC158
+  --site <\uC0AC\uC774\uD2B8\uCF54\uB4DC>            \uD3F4\uB354\uAC00 \uC18C\uC18D\uC744 \uBAA8\uB97C \uB54C \uC9C0\uC815\uD55C\uB2E4
+  --folder <\uACBD\uB85C>                \uC774 \uD3F4\uB354 \uB300\uC2E0 \uB2E4\uB978 \uD3F4\uB354\uB97C \uB2E4\uB8EC\uB2E4
+  --revision <\uD310\uBC88\uD638>            \uBC1B\uC744 \uD310\uC744 \uC9C0\uC815\uD55C\uB2E4(pull \xB7 baseline)
+  --discard-local                pull \uC774 \uB9C9\uD790 \uB54C \uACE0\uCE5C \uAC83\uC744 \uC606 \uD3F4\uB354\uB85C \uC62E\uAE30\uACE0 \uC9C4\uD589\uD55C\uB2E4
+  --overwrite-unseen             push \uAC00 \uB9C9\uD790 \uB54C \uC0AC\uC774\uD2B8 \uCABD \uD3B8\uC9D1\uC744 \uB36E\uC5B4\uC4F0\uACE0 \uC9C4\uD589\uD55C\uB2E4(\uADF8 \uD3B8\uC9D1\uC740 \uC0AC\uB77C\uC9C4\uB2E4)
+  --label <\uC774\uB984>                 publish \uAC00 \uBD99\uC77C \uBC84\uC804 \uC774\uB984
+  --discard-pending              \uAC8C\uC2DC \uB300\uAE30 AI \uBCC0\uACBD\uC744 \uD568\uAED8 \uBC84\uB9B0\uB2E4(publish\xB7rollback\xB7discard)
+                                 \u26A0 \uC4F4 \uD06C\uB808\uB527\uC740 \uB3CC\uC544\uC624\uC9C0 \uC54A\uB294\uB2E4 \u2014 \uD3B8\uC9D1\uB9CC \uBC84\uB9B4 \uB54C\uB294 \uD544\uC694 \uC5C6\uB2E4
+  --yes                          discard \uD655\uC778\uC744 \uBBF8\uB9AC \uC900\uB2E4 \u2014 **\uB0B4\uAC00 \uC62C\uB9B0 \uAC83\uACFC \uAC19\uC744 \uB54C\uB9CC** \uBA39\uB294\uB2E4
+  --confirm \uBC84\uB9BD\uB2C8\uB2E4               \uC5EC\uAE30 \uC5C6\uB294 \uD3B8\uC9D1\uC744 \uBC84\uB9B4 \uB54C \uD544\uC694\uD55C \uBB38\uAD6C(\uD130\uBBF8\uB110\uC774 \uC544\uB2D0 \uB54C)
+  --verbose                      \uACBD\uB85C\uB97C \uC804\uBD80 \uBCF4\uC5EC \uC900\uB2E4
+
+\uB85C\uADF8\uC778 \uC815\uBCF4\uB294 ${tokenPath()} \uC5D0 **\uD3C9\uBB38**\uC73C\uB85C \uC800\uC7A5\uB429\uB2C8\uB2E4.
+\uADF8 \uCEF4\uD4E8\uD130\uB97C \uC4F8 \uC218 \uC788\uB294 \uC0AC\uB78C\uC740 \uC774 \uC0AC\uC774\uD2B8\uB97C \uACE0\uCE58\uACE0 \uBC30\uD3EC\uD560 \uC218 \uC788\uC2B5\uB2C8\uB2E4.`;
+}
+async function main(argv) {
+  const { command, positional, flags } = parseArgs(argv);
+  if (command === "version" || flagOn(flags, "version")) {
+    process.stdout.write(`${version()}
+`);
+    return 0;
+  }
+  if (command === null || command === "help" || flagOn(flags, "help")) {
+    process.stdout.write(`${help()}
+`);
+    return 0;
+  }
+  const verbose = flagOn(flags, "verbose");
+  const common = {
+    folder: flagValue(flags, "folder") ?? void 0,
+    tenant: flagValue(flags, "site") ?? void 0
+  };
+  const revisionNo = revisionOf(flags);
+  switch (command) {
+    case "login": {
+      const auth = await openAuth(common);
+      await login(auth.auth, auth.store, { openBrowser });
+      process.stdout.write(`\uB85C\uADF8\uC778\uD588\uC2B5\uB2C8\uB2E4. \uB85C\uADF8\uC778 \uC815\uBCF4\uB294 ${tokenPath()} \uC5D0 \uC788\uC2B5\uB2C8\uB2E4.
+`);
+      return 0;
+    }
+    case "logout": {
+      await logout(new FileTokenStore());
+      process.stdout.write("\uB85C\uADF8\uC778 \uC815\uBCF4\uB97C \uC9C0\uC6E0\uC2B5\uB2C8\uB2E4.\n");
+      return 0;
+    }
+    case "status": {
+      const context = await openContext(common);
+      const draft = await context.api.draftFiles().catch(() => null);
+      const active = await context.api.listRevisions(20).then((rows) => rows.find((r) => r.isActive)?.revisionNo ?? null).catch(() => null);
+      const ledger = await readLedger(context.folder);
+      const status = syncStatus({
+        ledger,
+        local: await hashWorkdir(context.folder),
+        draft,
+        activeRevisionNo: active
+      });
+      process.stdout.write(`${describeStatus(status, verbose)}
+`);
+      const corrected = ledgerCorrection(ledger, draft);
+      if (corrected) await writeLedger(context.folder, corrected);
+      return status.blockers.length > 0 ? 1 : 0;
+    }
+    case "pull": {
+      const context = await openContext(common);
+      const result = await pullSiteSource({
+        api: context.api,
+        folder: context.folder,
+        revisionNo,
+        discardLocal: flagOn(flags, "discard-local"),
+        listAll: verbose,
+        onProgress: (message) => process.stderr.write(`${message}
+`)
+      });
+      const parts = [
+        `${result.revisionNo}\uD310\uC744 \uBC1B\uC558\uC2B5\uB2C8\uB2E4.`,
+        `\uC0C8\uB85C \uC4F4 \uAC83 ${result.written}\uAC1C \xB7 \uC9C0\uC6B4 \uAC83 ${result.deleted}\uAC1C \xB7 \uADF8\uB300\uB85C \uB454 \uAC83 ${result.unchanged}\uAC1C`
+      ];
+      if (result.untracked > 0) parts.push(`\uC774 \uD3F4\uB354\uC5D0\uB9CC \uC788\uB294 \uD30C\uC77C ${result.untracked}\uAC1C\uB294 \uAC74\uB4DC\uB9AC\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4.`);
+      if (result.savedTo) parts.push(`\uACE0\uCCD0 \uB450\uC5C8\uB358 \uAC83\uC740 ${result.savedTo} \uC5D0 \uC62E\uACA8 \uB450\uC5C8\uC2B5\uB2C8\uB2E4.`);
+      if (result.foreignLedger) {
+        parts.push("\uC774 \uD3F4\uB354\uC5D0 \uB2E4\uB978 \uC0AC\uC774\uD2B8\uC758 \uAE30\uC900 \uAE30\uB85D\uC774 \uC788\uC5B4 \uC4F0\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4. \uC9C0\uAE08\uC740 \uC774 \uC0AC\uC774\uD2B8 \uAC83\uC73C\uB85C \uB418\uC5B4 \uC788\uC2B5\uB2C8\uB2E4.");
+      }
+      if (result.deletionsUnknown) {
+        parts.push(
+          "\uC774 \uD3F4\uB354\uC5D0\uB294 \uAE30\uC900 \uAE30\uB85D\uC774 \uC5C6\uC5C8\uC2B5\uB2C8\uB2E4. \uADF8\uB798\uC11C \uC0AC\uC774\uD2B8\uC5D0\uC11C \uC9C0\uC6CC\uC9C4 \uD30C\uC77C\uC774 \uC5EC\uAE30 \uB0A8\uC544 \uC788\uC5B4\uB3C4 \uC774\uBC88\uC5D0\uB294 \uC9C0\uC6B0\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4.",
+          "\uC9C0\uAE08 \uB0A8\uC544 \uC788\uB294 \uAC83 \uC911 \uC0AC\uC774\uD2B8\uC5D0 \uC5C6\uB294 \uD30C\uC77C\uC774 \uC788\uB294\uC9C0 `zalkera status` \uB85C \uD655\uC778\uD574 \uC8FC\uC138\uC694."
+        );
+      }
+      if (result.serverExcluded.length > 0) {
+        parts.push(
+          `\uC0AC\uC774\uD2B8\uAC00 \uBCF4\uB0B8 \uAC83 \uC911 ${result.serverExcluded.length}\uAC1C\uB294 \uC774 \uB3C4\uAD6C\uAC00 \uB2E4\uB8E8\uC9C0 \uC54A\uB294 \uD30C\uC77C\uC774\uB77C \uBC1B\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4.`,
+          ...pathLines(result.serverExcluded, verbose)
+        );
+      }
+      if (!result.ledgerWritten) {
+        parts.push(
+          "\uB2E4\uB9CC \uAE30\uC900 \uAE30\uB85D\uC744 \uC4F0\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4. \uD30C\uC77C\uC740 \uC0C8 \uD310\uC785\uB2C8\uB2E4.",
+          "`zalkera baseline` \uC744 \uD55C \uBC88 \uC2E4\uD589\uD574 \uC8FC\uC138\uC694 \u2014 \uD3F4\uB354\uC758 \uD30C\uC77C\uC740 \uAC74\uB4DC\uB9AC\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4."
+        );
+      }
+      process.stdout.write(`${parts.join("\n")}
+`);
+      return result.ledgerWritten ? 0 : 1;
+    }
+    case "push": {
+      const context = await openContext(common);
+      const result = await pushSiteSource({
+        api: context.api,
+        folder: context.folder,
+        // ⚠ **명시 동의다.** 이 손잡이가 없으면 사이트 쪽에 걸려 있던 남의 편집이 조용히
+        //    사라진다 — 선행조건은 그것을 못 막는다.
+        overwriteUnseen: flagOn(flags, "overwrite-unseen"),
+        listAll: verbose,
+        onProgress: (message) => process.stderr.write(`${message}
+`)
+      });
+      const parts = describePush(result, verbose);
+      process.stdout.write(`${parts.join("\n")}
+`);
+      return 0;
+    }
+    case "publish": {
+      const context = await openContext(common);
+      const result = await publishDraft({
+        api: context.api,
+        folder: context.folder,
+        label: flagValue(flags, "label") ?? void 0,
+        // ⚠ **명시 동의다.** 게시 대기 AI 변경이 함께 사라진다.
+        discardPendingChanges: flagOn(flags, "discard-pending"),
+        onProgress: (message) => process.stderr.write(`${message}
+`)
+      });
+      const lines = [
+        `${result.revisionNo}\uD310\uC73C\uB85C \uC62C\uB838\uC2B5\uB2C8\uB2E4.`,
+        result.siteType === "STATIC" ? "\uC9C0\uAE08 \uBC14\uB85C \uC190\uB2D8\uC5D0\uAC8C \uBCF4\uC785\uB2C8\uB2E4." : "\uC0AC\uC774\uD2B8\uB97C \uB2E4\uC2DC \uC9D3\uB294 \uC911\uC785\uB2C8\uB2E4 \u2014 \uB2E4 \uC9C0\uC5B4\uC9C0\uBA74 \uC790\uB3D9\uC73C\uB85C \uC190\uB2D8\uC5D0\uAC8C \uBCF4\uC785\uB2C8\uB2E4."
+      ];
+      if (result.capabilityNote) lines.push(result.capabilityNote);
+      if (!result.ledgerRebuilt) {
+        lines.push(
+          "",
+          "\uB2E4\uB9CC \uC0C8 \uBC84\uC804\uC758 \uD30C\uC77C \uBAA9\uB85D\uC744 \uC77D\uC9C0 \uBABB\uD574 \uC774 \uD3F4\uB354\uC758 \uAE30\uC900 \uAE30\uB85D\uC744 \uC9C0\uC6E0\uC2B5\uB2C8\uB2E4.",
+          "`zalkera baseline` \uC744 \uD55C \uBC88 \uC2E4\uD589\uD574 \uC8FC\uC138\uC694 \u2014 \uD3F4\uB354\uC758 \uD30C\uC77C\uC740 \uAC74\uB4DC\uB9AC\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4."
+        );
+      }
+      process.stdout.write(`${lines.join("\n")}
+`);
+      return 0;
+    }
+    case "rollback": {
+      const target = revisionArg(positional);
+      const context = await openContext(common);
+      const result = await rollbackRevision({
+        api: context.api,
+        folder: context.folder,
+        revisionNo: target,
+        // ⚠ 이 손잡이는 **게시 대기 AI 변경** 폐기 동의다 — 「편집 중인 것」이 아니다.
+        //    편집이 있으면 서버가 플래그와 무관하게 되돌리기를 거절한다(가드 5층).
+        discardPending: flagOn(flags, "discard-pending"),
+        onProgress: (message) => process.stderr.write(`${message}
+`)
+      });
+      const lines = [
+        result.revisionNo === null ? "\uB418\uB3CC\uB838\uC2B5\uB2C8\uB2E4 \u2014 \uB2E4\uB9CC \uC9C0\uAE08 \uCF1C\uC9C4 \uBC84\uC804\uC758 \uBC88\uD638\uB97C \uD655\uC778\uD558\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4." : result.pointerMoved ? `${result.revisionNo}\uD310\uC73C\uB85C \uB418\uB3CC\uB838\uC2B5\uB2C8\uB2E4.` : `\uC774\uBBF8 ${result.revisionNo}\uD310\uC774\uC5C8\uC2B5\uB2C8\uB2E4.`
+      ];
+      if (result.revisionNo === null) {
+        lines.push("`zalkera status` \uB85C \uD655\uC778\uD574 \uC8FC\uC138\uC694. **\uB2E4\uC2DC \uB418\uB3CC\uB9AC\uC9C0 \uB9C8\uC138\uC694** \u2014 \uAC19\uC740 \uB0B4\uC6A9\uC758 \uBC84\uC804\uC774 \uD558\uB098 \uB354 \uC0DD\uAE41\uB2C8\uB2E4.");
+      }
+      if (result.revisionNo !== null && result.revisionNo !== result.requested) {
+        lines.push(
+          `(${result.requested}\uD310\uC758 \uB0B4\uC6A9\uC73C\uB85C **\uC0C8 ${result.revisionNo}\uD310**\uC744 \uC138\uC6CC \uCF30\uC2B5\uB2C8\uB2E4 \u2014 \uC6D0\uC7A5\uC740 \uB418\uAC10\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4.)`
+        );
+      }
+      if (result.discardedPendingChanges > 0) {
+        lines.push(`\uAC8C\uC2DC \uB300\uAE30 \uBCC0\uACBD ${result.discardedPendingChanges}\uAC74\uB3C4 \uD568\uAED8 \uBC84\uB838\uC2B5\uB2C8\uB2E4.`);
+      }
+      lines.push("", "\uC774 \uD3F4\uB354\uC758 \uD30C\uC77C\uC740 \uAC74\uB4DC\uB9AC\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4 \u2014 \uB9DE\uCD94\uB824\uBA74 `zalkera pull` \uC744 \uC2E4\uD589\uD558\uC138\uC694.");
+      if (result.differing.length > 0) {
+        lines.push(
+          `\u26A0 \uC774 \uD3F4\uB354\uC758 ${result.differing.length}\uAC1C \uD30C\uC77C\uC774 ${result.revisionNo}\uD310\uACFC \uB2E4\uB985\uB2C8\uB2E4.`,
+          ...pathLines(result.differing, verbose),
+          `\uC9C0\uAE08 \`zalkera push\` \uB97C \uD558\uBA74 \uC774 ${result.differing.length}\uAC1C\uAC00 **\uC804\uBD80** \uC62C\uB77C\uAC00 ${result.revisionNo}\uD310\uC758 \uB0B4\uC6A9\uC744 \uB36E\uC2B5\uB2C8\uB2E4.`
+        );
+      }
+      if (!result.ledgerRebuilt) {
+        lines.push("", "\uC0C8 \uAE30\uC900\uC758 \uD30C\uC77C \uBAA9\uB85D\uC744 \uC77D\uC9C0 \uBABB\uD574 \uAE30\uC900 \uAE30\uB85D\uC744 \uC9C0\uC6E0\uC2B5\uB2C8\uB2E4. `zalkera baseline` \uC744 \uC2E4\uD589\uD574 \uC8FC\uC138\uC694.");
+      }
+      process.stdout.write(`${lines.join("\n")}
+`);
+      return 0;
+    }
+    case "discard": {
+      const context = await openContext(common);
+      const draft = await context.api.draftFiles().catch(() => null);
+      const plan = planStranded({ ledger: await readLedger(context.folder), draft });
+      if (plan.empty) {
+        process.stdout.write("\uC0AC\uC774\uD2B8 \uCABD\uC5D0 \uD3B8\uC9D1 \uC911\uC778 \uAC83\uC774 \uC5C6\uC2B5\uB2C8\uB2E4 \u2014 \uBC84\uB9B4 \uAC83\uC774 \uC5C6\uC2B5\uB2C8\uB2E4.\n");
+        return 0;
+      }
+      process.stderr.write(`${describeStranded(plan, verbose).join("\n")}
+`);
+      const agreed = plan.verdict === "mine" ? await confirm({
+        question: "\uBC84\uB9B4\uAE4C\uC694? (y/n)",
+        given: flagOn(flags, "yes"),
+        flag: "--yes"
+      }) : await confirm({
+        question: `\uADF8\uB798\uB3C4 \uBC84\uB9AC\uB824\uBA74 \uC544\uB798\uB97C \uADF8\uB300\uB85C \uC785\uB825\uD574 \uC8FC\uC138\uC694: \`${DISCARD_PHRASE}\``,
+        phrase: DISCARD_PHRASE,
+        given: flagValue(flags, "confirm") === DISCARD_PHRASE,
+        flag: `--confirm ${DISCARD_PHRASE}`
+      });
+      if (!agreed) {
+        process.stdout.write("\uC544\uBB34\uAC83\uB3C4 \uBC84\uB9AC\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4.\n");
+        return 1;
+      }
+      const result = await discardDraft({
+        api: context.api,
+        folder: context.folder,
+        discardPending: flagOn(flags, "discard-pending"),
+        // 사람에게 보여 준 **그 판정**을 넘긴다 — 다시 조회하면 확인한 것과 버리는 것이 갈린다.
+        plan,
+        onProgress: (message) => process.stderr.write(`${message}
+`)
+      });
+      const lines = [result.hadDraft ? "\uD3B8\uC9D1 \uC911\uC774\uB358 \uAC83\uC744 \uBC84\uB838\uC2B5\uB2C8\uB2E4." : "\uBC84\uB9B4 \uD3B8\uC9D1\uC774 \uC5C6\uC5C8\uC2B5\uB2C8\uB2E4."];
+      if (result.discardedPendingChanges > 0) {
+        lines.push(`\uAC8C\uC2DC \uB300\uAE30 \uBCC0\uACBD ${result.discardedPendingChanges}\uAC74\uB3C4 \uD568\uAED8 \uBC84\uB838\uC2B5\uB2C8\uB2E4.`);
+      }
+      if (result.pointerMoved) {
+        lines.push("\u26A0 \uADF8 \uC0AC\uC774 \uC0AC\uC774\uD2B8 \uCABD\uC774 \uB2EC\uB77C\uC838 **\uB77C\uC774\uBE0C \uBC84\uC804\uB3C4 \uD568\uAED8 \uC6C0\uC9C1\uC600\uC2B5\uB2C8\uB2E4** \u2014 `zalkera status` \uB85C \uD655\uC778\uD574 \uC8FC\uC138\uC694.");
+      }
+      lines.push("\uC774 \uD3F4\uB354\uC758 \uD30C\uC77C\uC740 \uAC74\uB4DC\uB9AC\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4.");
+      process.stdout.write(`${lines.join("\n")}
+`);
+      return 0;
+    }
+    case "baseline": {
+      const context = await openContext(common);
+      const result = await rebuildBaseline({
+        api: context.api,
+        folder: context.folder,
+        revisionNo,
+        onProgress: (message) => process.stderr.write(`${message}
+`)
+      });
+      const lines = [
+        `${result.revisionNo}\uD310(\uD30C\uC77C ${result.files}\uAC1C)\uC744 \uAE30\uC900\uC73C\uB85C ${result.replaced ? "\uB2E4\uC2DC " : ""}\uC138\uC6E0\uC2B5\uB2C8\uB2E4.`,
+        "\uD3F4\uB354\uC758 \uD30C\uC77C\uC740 \uAC74\uB4DC\uB9AC\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4."
+      ];
+      if (result.differing.length > 0) {
+        lines.push(
+          "",
+          `\u26A0 \uC774 \uD3F4\uB354\uC758 ${result.differing.length}\uAC1C \uD30C\uC77C\uC774 ${result.revisionNo}\uD310\uACFC \uB2E4\uB985\uB2C8\uB2E4.`,
+          ...pathLines(result.differing, verbose),
+          `\uC9C0\uAE08 \`zalkera push\` \uB97C \uD558\uBA74 \uC774 ${result.differing.length}\uAC1C\uAC00 **\uC804\uBD80** \uC62C\uB77C\uAC00 ${result.revisionNo}\uD310\uC758 \uB0B4\uC6A9\uC744 \uB36E\uC2B5\uB2C8\uB2E4.`,
+          "\uACE0\uCE5C \uAC83\uC774 \uADF8\uC911 \uC77C\uBD80\uBFD0\uC774\uB77C\uBA74 `zalkera pull` \uB85C \uBC1B\uB294 \uCABD\uC774 \uB9DE\uC2B5\uB2C8\uB2E4."
+        );
+      } else {
+        lines.push("\uC9C0\uAE08 \uC0C1\uD0DC\uB294 `zalkera status` \uB85C \uBCFC \uC218 \uC788\uC2B5\uB2C8\uB2E4.");
+      }
+      if (result.serverExcluded.length > 0) {
+        lines.push(
+          "",
+          `\uC0AC\uC774\uD2B8\uAC00 \uBCF4\uB0B8 \uAC83 \uC911 ${result.serverExcluded.length}\uAC1C\uB294 \uC774 \uB3C4\uAD6C\uAC00 \uB2E4\uB8E8\uC9C0 \uC54A\uB294 \uD30C\uC77C\uC774\uB77C \uAE30\uC900\uC5D0 \uB123\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4.`,
+          ...pathLines(result.serverExcluded, verbose)
+        );
+      }
+      process.stdout.write(`${lines.join("\n")}
+`);
+      return 0;
+    }
+    default:
+      process.stderr.write(`\uBAA8\uB974\uB294 \uBA85\uB839\uC785\uB2C8\uB2E4: ${command}
+
+${help()}
+`);
+      return 2;
+  }
+}
+function revisionArg(positional) {
+  const raw = positional[0];
+  const value = Number(raw);
+  if (raw === void 0 || !Number.isInteger(value) || value <= 0) {
+    throw new DevtoolsError(
+      "SERVER_REJECTED",
+      `\uB418\uB3CC\uB9B4 \uBC84\uC804 \uBC88\uD638\uB97C \uC8FC\uC138\uC694(\uC608: \`zalkera rollback 5\`).${raw === void 0 ? "" : ` \uBC1B\uC740 \uAC12: ${raw}`}`,
+      "`zalkera status` \uB85C \uC9C0\uAE08 \uCF1C\uC9C4 \uBC84\uC804\uC744 \uBCFC \uC218 \uC788\uC2B5\uB2C8\uB2E4."
+    );
+  }
+  return value;
+}
+function revisionOf(flags) {
+  const raw = flagValue(flags, "revision");
+  if (raw === null) return void 0;
+  const value = Number(raw);
+  if (!Number.isInteger(value) || value <= 0) {
+    throw new DevtoolsError("SERVER_REJECTED", `\uD310 \uBC88\uD638\uAC00 \uC62C\uBC14\uB974\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4: ${raw}`);
+  }
+  return value;
+}
+async function openBrowser(url) {
+  const [command, args] = process.platform === "darwin" ? ["open", [url]] : process.platform === "win32" ? ["cmd", ["/c", "start", "", url]] : ["xdg-open", [url]];
+  await new Promise((resolve9, reject) => {
+    const child = spawn(command, args, { stdio: "ignore", detached: true });
+    child.on("error", reject);
+    child.on("spawn", () => {
+      child.unref();
+      resolve9();
+    });
+  }).catch(() => {
+    process.stderr.write(`\uBE0C\uB77C\uC6B0\uC800\uB97C \uC5F4\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4. \uC774 \uC8FC\uC18C\uB97C \uC9C1\uC811 \uC5F4\uC5B4 \uC8FC\uC138\uC694:
+${url}
+`);
+  });
+}
+var code = await main(process.argv.slice(2)).catch((error) => {
+  if (error instanceof DevtoolsError) {
+    process.stderr.write(`${error.humanMessage}
+`);
+    return 1;
+  }
+  process.stderr.write(`${error instanceof Error ? error.message : String(error)}
+`);
+  return 1;
+});
+process.exit(code);