isotone 1.1.3 → 1.2.0

package/dist/chunk-L6O4HYGP.js

@@ -0,0 +1,1150 @@
+import {
+  updateNoteText
+} from "./chunk-JCTWHR7U.js";
+import {
+  MAX_FEEDBACK_LENGTH,
+  OVERLAY_GROUP_ID,
+  overlayGroups
+} from "./chunk-BTJHQXF7.js";
+
+// src/store.ts
+import { execFileSync } from "child_process";
+import { createHash, randomUUID as randomUUID2 } from "crypto";
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, realpathSync as realpathSync2, statSync as statSync2, writeFileSync as writeFileSync2 } from "fs";
+import { basename, dirname as dirname3, isAbsolute as isAbsolute2, join as join2, relative as relative2, resolve, sep as sep2 } from "path";
+
+// src/file-store.ts
+import { randomUUID } from "crypto";
+import { closeSync, mkdirSync, openSync, readFileSync, renameSync, rmSync, writeFileSync } from "fs";
+import { dirname } from "path";
+function writeJson(file, value) {
+  mkdirSync(dirname(file), { recursive: true });
+  const temporary = `${file}.${randomUUID()}.tmp`;
+  try {
+    writeFileSync(temporary, `${JSON.stringify(value, null, 2)}
+`, { flag: "wx", mode: 384 });
+    renameSync(temporary, file);
+  } finally {
+    rmSync(temporary, { force: true });
+  }
+}
+function withFileLock(file, work) {
+  mkdirSync(dirname(file), { recursive: true });
+  const lock = `${file}.lock`;
+  const deadline = Date.now() + 2e3;
+  while (true) {
+    try {
+      const fd = openSync(lock, "wx", 384);
+      try {
+        writeFileSync(fd, String(process.pid));
+      } finally {
+        closeSync(fd);
+      }
+      break;
+    } catch (error) {
+      if (error.code !== "EEXIST") throw error;
+      try {
+        const owner = Number(readFileSync(lock, "utf8"));
+        if (Number.isSafeInteger(owner) && owner > 0) {
+          try {
+            process.kill(owner, 0);
+          } catch (cause) {
+            if (cause.code === "ESRCH") {
+              rmSync(lock, { force: true });
+              continue;
+            }
+          }
+        }
+      } catch {
+      }
+      if (Date.now() >= deadline) throw new Error(`Local store is busy: ${file}. Retry after the other writer finishes.`);
+      Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 10);
+    }
+  }
+  try {
+    return work();
+  } finally {
+    rmSync(lock, { force: true });
+  }
+}
+
+// src/update-request.ts
+import { existsSync, realpathSync, statSync } from "fs";
+import { dirname as dirname2, isAbsolute, join, relative, sep } from "path";
+function parseVersion(value) {
+  if (value.length > 256) throw new Error("Invalid version.");
+  const match = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-([\da-zA-Z-]+(?:\.[\da-zA-Z-]+)*))?(?:\+([\da-zA-Z-]+(?:\.[\da-zA-Z-]+)*))?$/.exec(value);
+  if (!match) throw new Error("Invalid version.");
+  const prerelease = match[4]?.split(".") ?? [];
+  if (prerelease.some((part) => /^0\d+$/.test(part))) throw new Error("Invalid version.");
+  return { parts: match.slice(1, 4).map(BigInt), prerelease };
+}
+function compareVersions(a, b) {
+  const left = parseVersion(a), right = parseVersion(b);
+  for (let i = 0; i < 3; i++) {
+    if (left.parts[i] !== right.parts[i]) return left.parts[i] > right.parts[i] ? 1 : -1;
+  }
+  if (!left.prerelease.length || !right.prerelease.length) {
+    return left.prerelease.length === right.prerelease.length ? 0 : left.prerelease.length ? -1 : 1;
+  }
+  for (let i = 0; i < Math.max(left.prerelease.length, right.prerelease.length); i++) {
+    const x = left.prerelease[i], y = right.prerelease[i];
+    if (x === y) continue;
+    if (x === void 0 || y === void 0) return x === void 0 ? -1 : 1;
+    const nx = /^\d+$/.test(x), ny = /^\d+$/.test(y);
+    if (nx && ny) return BigInt(x) > BigInt(y) ? 1 : -1;
+    if (nx !== ny) return nx ? -1 : 1;
+    return x > y ? 1 : -1;
+  }
+  return 0;
+}
+function isVersion(value) {
+  if (typeof value !== "string") return false;
+  try {
+    parseVersion(value);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var plainText = (value, max) => typeof value === "string" && value !== "" && value.length <= max && ![...value].some((char) => {
+  const code = char.charCodeAt(0);
+  return code < 32 || code === 127;
+});
+var PACKAGE_NAME = "isotone";
+var STRICT_VERSION = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-[\da-zA-Z-]+(?:\.[\da-zA-Z-]+)*)?$/;
+function isStrictVersion(value) {
+  return typeof value === "string" && value.length <= 256 && STRICT_VERSION.test(value) && isVersion(value);
+}
+function upgradeCommand(manager, version, flags) {
+  if (!isStrictVersion(version)) throw new Error("Invalid version.");
+  const dev = flags.dev ? " -D" : "";
+  if (manager === "npm") return `npm install${dev} --save-exact ${PACKAGE_NAME}@${version}`;
+  const workspace = flags.workspace ? manager === "pnpm" ? " -w" : " -W" : "";
+  return `${manager} add${dev}${workspace} --exact ${PACKAGE_NAME}@${version}`;
+}
+function canonicalUpgradeCommands(manager, version) {
+  if (!isStrictVersion(version)) return [];
+  const commands = [];
+  for (const dev of [true, false]) {
+    for (const workspace of manager === "npm" ? [false] : [false, true]) commands.push(upgradeCommand(manager, version, { dev, workspace }));
+  }
+  return commands;
+}
+function notesProjectRoot(file) {
+  const start = dirname2(file);
+  for (let directory = start; ; directory = dirname2(directory)) {
+    if (existsSync(join(directory, ".git"))) return directory;
+    if (dirname2(directory) === directory) return start;
+  }
+}
+function isInside(cwd, root) {
+  try {
+    const target = realpathSync(cwd);
+    if (!statSync(target).isDirectory()) return false;
+    const path = relative(realpathSync(root), target);
+    return path === "" || path !== ".." && !path.startsWith(`..${sep}`) && !isAbsolute(path);
+  } catch {
+    return false;
+  }
+}
+function updateRequestOf(value, context = {}) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const v = value;
+  if (!isVersion(v.from) || !isStrictVersion(v.to)) return null;
+  if (v.manager !== "npm" && v.manager !== "pnpm" && v.manager !== "yarn") return null;
+  if (!plainText(v.command, 500) || !plainText(v.cwd, 4096)) return null;
+  if (!canonicalUpgradeCommands(v.manager, v.to).includes(v.command)) return null;
+  if (!isAbsolute(v.cwd)) return null;
+  if (context.root !== void 0 && !isInside(v.cwd, context.root)) return null;
+  if (v.changelog !== void 0 && !(plainText(v.changelog, 500) && v.changelog.startsWith("https://"))) return null;
+  return {
+    from: v.from,
+    to: v.to,
+    command: v.command,
+    cwd: v.cwd,
+    manager: v.manager,
+    ...v.changelog !== void 0 ? { changelog: v.changelog } : {}
+  };
+}
+function changelogUrl(version) {
+  parseVersion(version);
+  return `https://github.com/aaroi/isotone/blob/v${version}/CHANGELOG.md`;
+}
+
+// src/store.ts
+var PAYLOAD_MAX = 65536;
+function readNotes(file) {
+  if (!existsSync2(file)) return [];
+  try {
+    const raw = readFileSync2(file, "utf8").trim();
+    if (!raw) return [];
+    const data = JSON.parse(raw);
+    if (!Array.isArray(data) || !data.every((note) => note && typeof note === "object" && typeof note.id === "string" && typeof note.route === "string" && typeof note.feedback === "string" && typeof note.createdAt === "string")) {
+      throw new Error("expected an array of notes");
+    }
+    return data;
+  } catch (cause) {
+    throw new Error(`Could not read notes from ${file}; the file has been left untouched.`, { cause });
+  }
+}
+function writeNotes(file, notes) {
+  writeJson(file, notes);
+}
+function updateNotes(file, update) {
+  withFileLock(file, () => writeNotes(file, update(readNotes(file))));
+}
+function ensureFileIgnored(file) {
+  try {
+    const dir = realpathSync2(dirname3(resolve(file)));
+    const absolute = join2(dir, basename(file));
+    const gitRoot = execFileSync("git", ["rev-parse", "--show-toplevel"], {
+      cwd: dir,
+      encoding: "utf8",
+      // Outside a repo git writes "fatal: not a git repository" to stderr, and
+      // inheriting it prints that over the server's own startup banner. The
+      // throw is the signal we act on; the message is noise.
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    const pattern = excludePattern(gitRoot, absolute);
+    if (!pattern) return;
+    const infoExclude = excludeFile(dir);
+    const existing = existsSync2(infoExclude) ? readFileSync2(infoExclude, "utf8") : "";
+    if (hasExcludePattern(existing, pattern)) return;
+    const marker = existing && !existing.endsWith("\n") ? "\n" : "";
+    const heading = "# isotone (local dev feedback loop)";
+    const comment = existing.includes(heading) ? "" : `${heading}
+`;
+    mkdirSync2(dirname3(infoExclude), { recursive: true });
+    writeFileSync2(infoExclude, `${existing}${marker}${comment}${pattern}
+`);
+  } catch {
+  }
+}
+function ensureDirIgnored(dir) {
+  try {
+    const absolute = realpathSync2(resolve(dir));
+    const gitRoot = execFileSync("git", ["rev-parse", "--show-toplevel"], {
+      cwd: absolute,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    const base = excludePattern(gitRoot, absolute);
+    if (!base) return;
+    const pattern = `${base}/`;
+    const infoExclude = excludeFile(absolute);
+    const existing = existsSync2(infoExclude) ? readFileSync2(infoExclude, "utf8") : "";
+    if (hasExcludePattern(existing, pattern) || hasExcludePattern(existing, base)) return;
+    const marker = existing && !existing.endsWith("\n") ? "\n" : "";
+    mkdirSync2(dirname3(infoExclude), { recursive: true });
+    writeFileSync2(
+      infoExclude,
+      `${existing}${marker}# isotone (local overlay variants)
+${pattern}
+`
+    );
+  } catch {
+  }
+}
+function excludeFile(cwd) {
+  const reported = execFileSync("git", ["rev-parse", "--git-path", "info/exclude"], {
+    cwd,
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "ignore"]
+  }).trim();
+  return resolve(cwd, reported);
+}
+function excludePattern(gitRoot, absolute) {
+  const rel = relative2(gitRoot, absolute);
+  if (!rel || rel === ".." || rel.startsWith(`..${sep2}`) || isAbsolute2(rel)) {
+    return null;
+  }
+  return `/${rel.split(sep2).join("/")}`;
+}
+function hasExcludePattern(exclude, pattern) {
+  const bare = pattern.replace(/^\//, "");
+  return exclude.split(/\r?\n/).some((line) => line.trim() === pattern || line.trim() === bare);
+}
+function toItem(n, root) {
+  const update = updateRequestOf(n.update, { root });
+  const item = {
+    id: n.id,
+    route: n.route,
+    // An update note says what the server's request says, whatever the file holds.
+    feedback: update ? updateNoteText(update) : n.feedback,
+    element: n.element,
+    done: n.done,
+    createdAt: n.createdAt
+  };
+  if (n.workingAt && !n.done) item.workingAt = n.workingAt;
+  if (n.viewport !== void 0) item.viewport = n.viewport;
+  if (n.payload !== void 0) item.payload = n.payload;
+  return {
+    ...item,
+    ...n.elements !== void 0 ? { elements: n.elements } : {},
+    ...n.variant !== void 0 ? { variant: n.variant } : {},
+    ...n.variantAction !== void 0 ? { variantAction: n.variantAction } : {},
+    // Only the server writes an update request; a malformed one, or one whose
+    // directory is outside the project, is not shown.
+    ...update ? { update } : {},
+    // Only the CLI writes a reply; a hand-edited, malformed one is not shown.
+    ...replyView(n) ? { reply: replyView(n) } : {}
+  };
+}
+function notesResponse(file, req) {
+  if (req.method === "POST" || req.method === "DELETE") {
+    return withFileLock(file, () => handleNotesRequest(file, req));
+  }
+  return handleNotesRequest(file, req);
+}
+function handleNotesRequest(file, req) {
+  const method = req.method ?? "";
+  const query = Object.fromEntries(
+    new URL(req.url ?? "/", "http://localhost").searchParams
+  );
+  const json = (status, body) => ({
+    status,
+    headers: { "content-type": "application/json; charset=utf-8", "cache-control": "no-store" },
+    body
+  });
+  if (method === "GET") {
+    const polled = query.rev !== void 0;
+    const rev = polled ? notesRevision(file) : "";
+    if (polled && rev === String(query.rev)) return json(200, { rev, unchanged: true });
+    const route = String(query.route ?? "");
+    const root = notesProjectRoot(file);
+    const all = query.all !== void 0 && String(query.all) !== "" && String(query.all) !== "0";
+    const notes = polled ? readNotesAt(file, rev) : readNotes(file);
+    const rows = (all ? [...notes] : route ? notes.filter((n) => n.route === route) : notes.filter((n) => !n.done)).sort((a, b) => b.createdAt.localeCompare(a.createdAt)).map((note) => toItem(note, root));
+    return json(200, polled ? { rev, notes: rows } : rows);
+  }
+  if (method === "DELETE") {
+    const id = String(query.id ?? "");
+    if (!id) return json(400, { error: "id is required" });
+    writeNotes(file, readNotes(file).filter((n) => n.id !== id));
+    return json(200, { ok: true });
+  }
+  if (method === "POST") {
+    const body = req.body ?? {};
+    const { id, route, feedback, element, payload, viewport } = body;
+    if (id !== void 0 && id !== null && (typeof id !== "string" || !id || id.length > 200)) {
+      return json(400, { error: "id must be a non-empty string of at most 200 characters" });
+    }
+    if (typeof route !== "string" || route === "") {
+      return json(400, { error: "route is required" });
+    }
+    const cleanFeedback = typeof feedback === "string" ? feedback.trim() : "";
+    if (cleanFeedback === "") {
+      return json(400, { error: "feedback is required" });
+    }
+    if (cleanFeedback.length > MAX_FEEDBACK_LENGTH) return json(400, { error: `feedback must be at most ${MAX_FEEDBACK_LENGTH} characters` });
+    if (payload !== void 0 && !withinPayloadCap(payload)) {
+      return json(400, {
+        error: `payload exceeds ${PAYLOAD_MAX} bytes or is not serializable`
+      });
+    }
+    const cleanViewport = viewportOf(viewport);
+    if (body.elements !== void 0 && (!Array.isArray(body.elements) || body.elements.length > 50)) {
+      return json(400, { error: "elements must be an array of at most 50 elements" });
+    }
+    const elements = body.elements === void 0 ? void 0 : body.elements.map(elementOf).filter((el) => el !== null);
+    const variant = body.variant === void 0 ? void 0 : variantOf(body.variant);
+    const variantAction = removalOf(body.variantAction);
+    if (body.variantAction !== void 0 && !variantAction) return json(400, { error: "Invalid variant action" });
+    let cleanElement = null;
+    if (element && typeof element === "object" && !Array.isArray(element)) {
+      cleanElement = {
+        tag: cap(String(element.tag ?? ""), 30),
+        text: cap(String(element.text ?? ""), 120),
+        selector: cap(String(element.selector ?? ""), MAX_SELECTOR),
+        ...elementContext(element)
+      };
+    }
+    const notes = readNotes(file);
+    const defaultsRequest = cleanFeedback.startsWith("[set-defaults]");
+    const previousDefaults = defaultsRequest && !notes.some((note) => note.id === id) ? notes.filter((n) => !n.done && n.route === route && n.feedback.startsWith("[set-defaults]")).sort((a, b) => b.createdAt.localeCompare(a.createdAt))[0] : void 0;
+    const updateId = previousDefaults?.id ?? id;
+    if (typeof updateId === "string" && updateId !== "") {
+      const existing = notes.find((n) => n.id === updateId && n.route === route);
+      if (existing?.update !== void 0) {
+        return json(409, { error: "An update note is written by Isotone and cannot be edited. Delete it to cancel the update." });
+      }
+      if (existing) {
+        if (previousDefaults) {
+          delete existing.elements;
+          delete existing.variant;
+          delete existing.variantAction;
+          delete existing.payload;
+        }
+        existing.feedback = cleanFeedback;
+        existing.element = cleanElement;
+        if (elements !== void 0) {
+          existing.elements = elements;
+          existing.element = elements[0] ?? null;
+        } else if (existing.elements) existing.element = existing.elements[0] ?? null;
+        if (variant !== void 0) existing.variant = variant;
+        if (variantAction) existing.variantAction = variantAction;
+        if (payload !== void 0) existing.payload = payload;
+        if (defaultsRequest && !existing.done) {
+          existing.createdAt = (/* @__PURE__ */ new Date()).toISOString();
+          if (cleanViewport) existing.viewport = cleanViewport;
+          writeNotes(file, notes.filter((n) => n.id === existing.id || n.done || n.route !== route || !n.feedback.startsWith("[set-defaults]")));
+        } else writeNotes(file, notes);
+        return json(200, { id: existing.id });
+      }
+    }
+    if (typeof id === "string" && notes.some((note) => note.id === id)) {
+      return json(409, { error: "This note belongs to a different route" });
+    }
+    const newId = typeof id === "string" ? id : randomUUID2();
+    const createdAt = typeof body.createdAt === "string" && Number.isFinite(Date.parse(body.createdAt)) ? new Date(body.createdAt).toISOString() : (/* @__PURE__ */ new Date()).toISOString();
+    notes.push({
+      id: newId,
+      route,
+      feedback: cleanFeedback,
+      element: cleanElement,
+      done: false,
+      doneAt: null,
+      createdAt,
+      ...cleanViewport ? { viewport: cleanViewport } : {},
+      ...payload !== void 0 ? { payload } : {},
+      ...elements !== void 0 ? { elements, element: elements[0] ?? null } : {},
+      ...variant !== void 0 ? { variant } : {},
+      ...variantAction ? { variantAction } : {}
+    });
+    writeNotes(file, notes);
+    return json(201, { id: newId });
+  }
+  return json(405, { error: "method not allowed" });
+}
+var parsed = /* @__PURE__ */ new Map();
+function readNotesAt(file, rev) {
+  const cached = parsed.get(file);
+  if (cached && cached.rev === rev && rev !== "none") return cached.notes;
+  const notes = readNotes(file);
+  parsed.set(file, { rev, notes });
+  return notes;
+}
+function notesRevision(file) {
+  try {
+    const stat = statSync2(file, { bigint: true });
+    return `${stat.ino.toString(36)}.${stat.mtimeNs.toString(36)}.${stat.size.toString(36)}`;
+  } catch {
+    return "none";
+  }
+}
+var MAX_REPLY_LENGTH = 2e3;
+function replyOf(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const v = value;
+  if (typeof v.text !== "string" || !v.text.trim() || typeof v.at !== "string" || !Number.isFinite(Date.parse(v.at))) return null;
+  return { text: v.text.slice(0, MAX_REPLY_LENGTH), at: v.at, ...typeof v.about === "string" && v.about.length <= 64 ? { about: v.about } : {} };
+}
+function noteFingerprint(note) {
+  const update = updateRequestOf(note.update);
+  const content = JSON.stringify([
+    note.feedback,
+    note.route,
+    (note.elements ?? (note.element ? [note.element] : [])).map((element) => element.selector),
+    note.variant ?? null,
+    note.variantAction ?? null,
+    update?.to ?? null
+  ]);
+  return createHash("sha256").update(content).digest("base64url").slice(0, 16);
+}
+function replyView(note) {
+  const reply = replyOf(note.reply);
+  if (!reply) return null;
+  return reply.about !== void 0 && reply.about !== noteFingerprint(note) ? { ...reply, answered: true } : reply;
+}
+function cap(v, max) {
+  return v.slice(0, max);
+}
+function elementOf(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const v = value;
+  if (typeof v.selector !== "string" || !v.selector) return null;
+  return {
+    tag: cap(String(v.tag ?? ""), 30),
+    text: cap(String(v.text ?? ""), 120),
+    selector: cap(v.selector, MAX_SELECTOR),
+    ...elementContext(v)
+  };
+}
+var MAX_SELECTOR = 2e3;
+function stringList(value, count, length) {
+  return Array.isArray(value) ? value.filter((item) => typeof item === "string" && item !== "").slice(0, count).map((item) => cap(item, length)) : [];
+}
+function elementContext(value) {
+  const v = value;
+  const out = {};
+  if (v.attributes && typeof v.attributes === "object" && !Array.isArray(v.attributes)) {
+    const entries = Object.entries(v.attributes).filter((entry) => typeof entry[1] === "string" && !UNSAFE_KEYS.has(entry[0])).slice(0, 20).map(([name, text]) => [cap(name, 60), cap(text, 300)]);
+    if (entries.length) out.attributes = Object.fromEntries(entries);
+  }
+  const component = stringList(v.component, 8, 80);
+  if (component.length) out.component = component;
+  const within = stringList(v.within, 6, 120);
+  if (within.length) out.within = within;
+  if (typeof v.source === "string" && v.source) out.source = cap(v.source, 300);
+  if (typeof v.near === "string" && v.near) out.near = cap(v.near, 120);
+  const rect = v.rect;
+  if (rect && typeof rect === "object" && [rect.x, rect.y, rect.w, rect.h].every((n) => typeof n === "number" && Number.isFinite(n))) {
+    out.rect = { x: rect.x, y: rect.y, w: rect.w, h: rect.h };
+  }
+  return out;
+}
+var UNSAFE_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+function variantOf(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const v = value;
+  if (typeof v.axisId !== "string" || typeof v.label !== "string") return null;
+  return {
+    axisId: cap(v.axisId, 200),
+    label: cap(v.label, 200),
+    ...typeof v.optionId === "string" ? { optionId: cap(v.optionId, 200) } : {},
+    ...typeof v.optionLabel === "string" ? { optionLabel: cap(v.optionLabel, 200) } : {},
+    ...typeof v.value === "string" ? { value: cap(v.value, 200) } : {}
+  };
+}
+function viewportOf(v) {
+  if (!v || typeof v !== "object" || Array.isArray(v)) return null;
+  const w = Math.round(Number(v.w));
+  const h = Math.round(Number(v.h));
+  if (!Number.isFinite(w) || !Number.isFinite(h)) return null;
+  if (w <= 0 || h <= 0 || w > 1e5 || h > 1e5) return null;
+  return { w, h };
+}
+function withinPayloadCap(payload) {
+  try {
+    return Buffer.byteLength(JSON.stringify(payload), "utf8") <= PAYLOAD_MAX;
+  } catch {
+    return false;
+  }
+}
+var NOTES_ENDPOINT = "/api/iteration/notes";
+function removalOf(value) {
+  if (!value || typeof value !== "object") return;
+  const v = value;
+  if (typeof v.axisId !== "string" || !v.axisId || v.axisId.length > 200 || !["remove-option", "remove-axis", "keep-default"].includes(v.action ?? "")) return;
+  if (v.action === "remove-option" && (typeof v.optionId !== "string" || !v.optionId || v.optionId.length > 200)) return;
+  return { axisId: v.axisId, action: v.action, ...typeof v.optionId === "string" ? { optionId: v.optionId.slice(0, 200) } : {} };
+}
+
+// src/variants-store.ts
+import { execFileSync as execFileSync2 } from "child_process";
+import { createHash as createHash2, randomUUID as randomUUID3 } from "crypto";
+import {
+  existsSync as existsSync3,
+  mkdirSync as mkdirSync3,
+  lstatSync,
+  readdirSync,
+  readFileSync as readFileSync3,
+  realpathSync as realpathSync3,
+  rmSync as rmSync2,
+  writeFileSync as writeFileSync3
+} from "fs";
+import { tmpdir } from "os";
+import { dirname as dirname4, isAbsolute as isAbsolute3, join as join3, relative as relative3, resolve as resolve2, sep as sep3 } from "path";
+var DEFAULT_VARIANTS_DIR = ".isotone/variants";
+var ACTIVE_FILE = ".isotone/active.json";
+var KNOBS_FILE = ".isotone/knobs.json";
+function mutateVariants(opts, change) {
+  return withFileLock(join3(variantsDir(opts), ".mutation"), change);
+}
+function variantsDir(opts) {
+  const dir = opts.dir ?? DEFAULT_VARIANTS_DIR;
+  return isAbsolute3(dir) ? dir : resolve2(opts.root, dir);
+}
+function variantDir(opts, id) {
+  if (!isValidVariantId(id)) throw new Error(`Invalid variant id "${id}"`);
+  return join3(variantsDir(opts), id);
+}
+function isValidVariantId(id) {
+  return /^[a-z0-9][a-z0-9-]{0,63}$/.test(id);
+}
+function toPosixPath(p) {
+  return p.split(sep3).join("/");
+}
+function isEscaping(rel) {
+  return rel === ".." || rel.startsWith(`..${sep3}`) || isAbsolute3(rel);
+}
+function staysInside(base, file) {
+  const canonical = (path) => {
+    let existing = resolve2(path);
+    while (dirname4(existing) !== existing) {
+      try {
+        lstatSync(existing);
+        break;
+      } catch (error) {
+        if (error.code !== "ENOENT") throw error;
+        existing = dirname4(existing);
+      }
+    }
+    return resolve2(realpathSync3(existing), relative3(existing, resolve2(path)));
+  };
+  return !isEscaping(relative3(canonical(base), canonical(file)));
+}
+function repoRelativeKey(root, file) {
+  const abs = isAbsolute3(file) ? resolve2(file) : resolve2(root, file);
+  const rel = relative3(root, abs);
+  if (!rel || isEscaping(rel) || !isSafeManifestKey(toPosixPath(rel)) || !staysInside(root, abs)) {
+    throw new Error(`"${file}" escapes the project root`);
+  }
+  return { abs, key: toPosixPath(rel) };
+}
+function isSafeManifestKey(key) {
+  if (!key || isAbsolute3(key) || /[\\:\0]/.test(key) || key === "variant.json") return false;
+  return !key.split("/").some((segment) => !segment || segment === "." || segment === ".." || segment === ".git");
+}
+function isPlausibleVariant(v) {
+  if (!v || typeof v !== "object" || Array.isArray(v)) return false;
+  const o = v;
+  return typeof o.id === "string" && typeof o.label === "string" && typeof o.createdAt === "string" && (o.route === void 0 || typeof o.route === "string") && (o.description === void 0 || typeof o.description === "string") && (o.group === void 0 || typeof o.group === "string" && OVERLAY_GROUP_ID.test(o.group)) && (o.groupLabel === void 0 || typeof o.groupLabel === "string") && (o.section === void 0 || typeof o.section === "string") && !!o.files && typeof o.files === "object" && !Array.isArray(o.files) && Object.entries(o.files).every(([key, entry]) => isSafeManifestKey(key) && entry && typeof entry === "object" && "base" in entry && (entry.base === null || typeof entry.base === "string" && /^[a-f0-9]{40}(?:[a-f0-9]{24})?$/.test(entry.base)) && (!("added" in entry) || entry.added === true));
+}
+function readVariant(opts, id) {
+  if (!isValidVariantId(id)) return null;
+  const file = join3(variantDir(opts, id), "variant.json");
+  if (!existsSync3(file)) return null;
+  try {
+    const data = JSON.parse(readFileSync3(file, "utf8"));
+    const dir = variantDir(opts, id);
+    return isPlausibleVariant(data) && data.id === id && staysInside(variantsDir(opts), file) && Object.keys(data.files).every((key) => staysInside(opts.root, join3(opts.root, key)) && staysInside(dir, join3(dir, key))) ? data : null;
+  } catch {
+    return null;
+  }
+}
+function writeVariant(opts, v) {
+  if (!isPlausibleVariant(v)) throw new Error("Invalid variant manifest");
+  const dir = variantDir(opts, v.id);
+  if (!staysInside(variantsDir(opts), dir)) throw new Error("Variant directory escapes the variants tree");
+  mkdirSync3(dir, { recursive: true });
+  writeJson(join3(dir, "variant.json"), v);
+}
+function isStale(base, currentHash) {
+  return base === null || currentHash === null || currentHash !== base;
+}
+function readVariants(opts) {
+  const dir = variantsDir(opts);
+  if (!existsSync3(dir)) return [];
+  return readdirSync(dir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => readVariant(opts, e.name)).filter((v) => v !== null).sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+}
+function listVariants(opts) {
+  const dir = variantsDir(opts);
+  if (!existsSync3(dir)) return [];
+  const root = resolve2(opts.root);
+  const ids = readdirSync(dir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+  const statuses = [];
+  const hashes = /* @__PURE__ */ new Map();
+  for (const id of ids) {
+    const manifest = readVariant(opts, id);
+    if (!manifest) continue;
+    const stale = [];
+    const missing = [];
+    for (const [file, entry] of Object.entries(manifest.files)) {
+      const overrideAbs = join3(dir, id, file);
+      if (!existsSync3(overrideAbs)) {
+        missing.push(file);
+        continue;
+      }
+      if (entry.added) {
+        if (existsSync3(join3(root, file))) stale.push(file);
+        continue;
+      }
+      const hashKey = `${entry.base?.length}:${file}`;
+      if (!hashes.has(hashKey)) hashes.set(hashKey, hashFile(join3(root, file), entry.base));
+      if (isStale(entry.base, hashes.get(hashKey) ?? null)) stale.push(file);
+    }
+    statuses.push({ ...manifest, stale, missing });
+  }
+  statuses.sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+  return statuses;
+}
+function createVariant(opts, input) {
+  return mutateVariants(opts, () => {
+    if (!isValidVariantId(input.id)) {
+      throw new Error(`Invalid variant id "${input.id}"`);
+    }
+    if (input.group !== void 0) assertGroupId(input.group);
+    if (readVariant(opts, input.id)) {
+      throw new Error(`Variant "${input.id}" already exists`);
+    }
+    const variant = {
+      id: input.id,
+      label: input.label || input.id,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      files: {},
+      ...input.route !== void 0 ? { route: input.route } : {},
+      ...input.element !== void 0 ? { element: input.element } : {},
+      ...input.note !== void 0 ? { note: input.note } : {},
+      ...input.description !== void 0 ? { description: input.description } : {},
+      ...input.group !== void 0 ? { group: input.group } : {},
+      ...input.groupLabel !== void 0 ? { groupLabel: input.groupLabel } : {},
+      ...input.section !== void 0 ? { section: input.section } : {}
+    };
+    writeVariant(opts, variant);
+    return variant;
+  });
+}
+function assertGroupId(group) {
+  if (!OVERLAY_GROUP_ID.test(group)) {
+    throw new Error(`Invalid group id "${group}" (lowercase letters, digits and hyphens)`);
+  }
+}
+function setVariantGroup(opts, id, group, groupLabel) {
+  return mutateVariants(opts, () => {
+    const manifest = readVariant(opts, id);
+    if (!manifest) throw new Error(`No variant "${id}"`);
+    assertGroupId(group);
+    manifest.group = group;
+    if (groupLabel !== void 0) manifest.groupLabel = groupLabel;
+    writeVariant(opts, manifest);
+    return manifest;
+  });
+}
+function setVariantSection(opts, id, section) {
+  return mutateVariants(opts, () => {
+    const manifest = readVariant(opts, id);
+    if (!manifest) throw new Error(`No variant "${id}"`);
+    if (section === void 0) delete manifest.section;
+    else manifest.section = section.replace(/\s+/g, " ").trim();
+    writeVariant(opts, manifest);
+    return manifest;
+  });
+}
+function addVariantFile(opts, id, file, { create = false } = {}) {
+  return mutateVariants(opts, () => {
+    const manifest = readVariant(opts, id);
+    if (!manifest) throw new Error(`No variant "${id}"`);
+    const root = resolve2(opts.root);
+    const { abs: sourceAbs, key } = repoRelativeKey(root, file);
+    if (Object.hasOwn(manifest.files, key)) return manifest;
+    const destAbs = join3(variantDir(opts, id), key);
+    if (!staysInside(variantDir(opts, id), destAbs)) throw new Error("Override path escapes the variant directory");
+    if (create) {
+      if (existsSync3(sourceAbs)) throw new Error(`"${file}" already exists; add it without --new`);
+      mkdirSync3(dirname4(destAbs), { recursive: true });
+      if (!existsSync3(destAbs)) writeFileSync3(destAbs, "");
+      manifest.files = { ...manifest.files, [key]: { base: null, added: true } };
+      writeVariant(opts, manifest);
+      return manifest;
+    }
+    if (!existsSync3(sourceAbs)) throw new Error(`"${file}" does not exist. Use --new for a file the variant adds.`);
+    mkdirSync3(dirname4(destAbs), { recursive: true });
+    writeFileSync3(destAbs, readFileSync3(sourceAbs));
+    manifest.files = { ...manifest.files, [key]: { base: blobOf(sourceAbs) } };
+    writeVariant(opts, manifest);
+    return manifest;
+  });
+}
+function removeVariantFile(opts, id, file) {
+  return mutateVariants(opts, () => {
+    const manifest = readVariant(opts, id);
+    if (!manifest) throw new Error(`No variant "${id}"`);
+    const root = resolve2(opts.root);
+    const { key } = repoRelativeKey(root, file);
+    if (Object.hasOwn(manifest.files, key)) {
+      delete manifest.files[key];
+      rmSync2(join3(variantDir(opts, id), key), { force: true });
+      writeVariant(opts, manifest);
+    }
+    return manifest;
+  });
+}
+var CONFLICT_MARKER = "<<<<<<< variant";
+function promoteVariant(opts, id, { force = false } = {}) {
+  return mutateVariants(opts, () => {
+    if (!isValidVariantId(id)) throw new Error(`Invalid variant id "${id}"`);
+    const manifest = readVariant(opts, id);
+    if (!manifest) throw new Error(`No variant "${id}"`);
+    const active = readActive(opts);
+    const root = resolve2(opts.root);
+    const vDir = variantDir(opts, id);
+    const missing = Object.keys(manifest.files).filter((key) => !existsSync3(join3(vDir, key)));
+    if (missing.length) throw new Error(`"${id}" has missing overrides: ${missing.join(", ")}. Restore or remove them before promoting.`);
+    if (!force) {
+      const status = listVariants(opts).find((v) => v.id === id);
+      if (status?.stale.length) {
+        const reasons = status.stale.map(
+          (file) => manifest.files[file]?.base === null ? `no base recorded for ${file} (not a git repo when the override was made)` : `${file} changed since the override was made`
+        );
+        throw new Error(
+          `"${id}" is stale (${reasons.join("; ")}). Run \`variant sync ${id}\` first, or promote with --force.`
+        );
+      }
+      const conflicted = Object.keys(manifest.files).filter((key) => {
+        const overrideAbs = join3(vDir, key);
+        return existsSync3(overrideAbs) && readFileSync3(overrideAbs, "utf8").includes(CONFLICT_MARKER);
+      });
+      if (conflicted.length) {
+        throw new Error(
+          `"${id}" has unresolved conflict markers in ${conflicted.join(", ")}. Resolve them, or promote with --force.`
+        );
+      }
+    }
+    const siblings = overlayGroups(readVariants(opts)).find((g) => g.members.some((m) => m.id === id))?.members.filter((m) => m.id !== id) ?? [];
+    const files = [];
+    const landed = /* @__PURE__ */ new Map();
+    for (const key of Object.keys(manifest.files)) {
+      const overrideAbs = join3(vDir, key);
+      const destAbs = join3(root, key);
+      const before = existsSync3(destAbs) ? currentBlob(destAbs) : null;
+      mkdirSync3(dirname4(destAbs), { recursive: true });
+      writeFileSync3(destAbs, readFileSync3(overrideAbs));
+      landed.set(key, { before, after: blobOf(destAbs) });
+      files.push(key);
+    }
+    rmSync2(vDir, { recursive: true, force: true });
+    if (active.includes(id)) writeActive(opts, active.filter((a) => a !== id));
+    return { files, rebased: rebaseSiblings(opts, siblings, landed) };
+  });
+}
+function rebaseSiblings(opts, siblings, landed) {
+  const rebased = [];
+  for (const sibling of siblings) {
+    let moved = false;
+    for (const [key, entry] of Object.entries(sibling.files)) {
+      const change = landed.get(key);
+      if (!change?.after || !(entry.added || entry.base !== null && entry.base === change.before)) continue;
+      sibling.files[key] = { base: change.after };
+      moved = true;
+    }
+    if (!moved) continue;
+    writeVariant(opts, sibling);
+    rebased.push(sibling.id);
+  }
+  return rebased;
+}
+function dropVariant(opts, id) {
+  mutateVariants(opts, () => {
+    if (!isValidVariantId(id)) throw new Error(`Invalid variant id "${id}"`);
+    const active = readActive(opts);
+    rmSync2(variantDir(opts, id), { recursive: true, force: true });
+    if (active.includes(id)) writeActive(opts, active.filter((a) => a !== id));
+  });
+}
+var GIT_QUIET = ["ignore", "pipe", "ignore"];
+function blobOf(absPath) {
+  try {
+    return execFileSync2("git", ["hash-object", "--no-filters", "-w", absPath], {
+      cwd: dirname4(absPath),
+      encoding: "utf8",
+      stdio: GIT_QUIET
+    }).trim();
+  } catch {
+    return null;
+  }
+}
+function currentBlob(absPath) {
+  try {
+    return execFileSync2("git", ["hash-object", "--no-filters", absPath], {
+      cwd: dirname4(absPath),
+      encoding: "utf8",
+      stdio: GIT_QUIET
+    }).trim();
+  } catch {
+    return null;
+  }
+}
+function hashFile(file, base) {
+  if (base === null) return null;
+  try {
+    const contents = readFileSync3(file);
+    return createHash2(base.length === 64 ? "sha256" : "sha1").update(`blob ${contents.length}\0`).update(contents).digest("hex");
+  } catch {
+    return null;
+  }
+}
+function catFile(cwd, hash) {
+  try {
+    return execFileSync2("git", ["cat-file", "-p", hash], { cwd, encoding: "utf8", stdio: GIT_QUIET });
+  } catch {
+    return null;
+  }
+}
+function mergeFile(overrideAbs, baseAbs, currentAbs) {
+  try {
+    const stdout = execFileSync2(
+      "git",
+      [
+        "merge-file",
+        "-p",
+        "-L",
+        "variant",
+        "-L",
+        "base",
+        "-L",
+        "default",
+        overrideAbs,
+        baseAbs,
+        currentAbs
+      ],
+      { encoding: "utf8", stdio: GIT_QUIET }
+    );
+    return { status: 0, stdout };
+  } catch (err) {
+    const e = err;
+    return { status: e.status ?? null, stdout: e.stdout ?? "" };
+  }
+}
+function isConflictStatus(status) {
+  return status !== null && status >= 1 && status <= 127;
+}
+function recordBase(absPath, hash) {
+  return blobOf(absPath) ?? hash;
+}
+function syncVariant(opts, id) {
+  return mutateVariants(opts, () => {
+    const manifest = readVariant(opts, id);
+    if (!manifest) throw new Error(`No variant "${id}"`);
+    const root = resolve2(opts.root);
+    const vDir = variantDir(opts, id);
+    const merged = [];
+    const conflicts = [];
+    const unchanged = [];
+    let dirty = false;
+    for (const [file, entry] of Object.entries(manifest.files)) {
+      const currentAbs = join3(root, file);
+      const overrideAbs = join3(vDir, file);
+      if (entry.added) {
+        (existsSync3(currentAbs) ? conflicts : unchanged).push(file);
+        continue;
+      }
+      const currentHash = currentBlob(currentAbs);
+      if (!isStale(entry.base, currentHash)) {
+        unchanged.push(file);
+        continue;
+      }
+      const baseContent = entry.base !== null ? catFile(dirname4(currentAbs), entry.base) : null;
+      if (baseContent === null || currentHash === null) {
+        conflicts.push(file);
+        continue;
+      }
+      const baseTmp = join3(tmpdir(), `isotone-base-${randomUUID3()}`);
+      writeFileSync3(baseTmp, baseContent);
+      try {
+        const result = mergeFile(overrideAbs, baseTmp, currentAbs);
+        if (result.status === 0) {
+          writeFileSync3(overrideAbs, result.stdout);
+          entry.base = recordBase(currentAbs, currentHash);
+          dirty = true;
+          merged.push(file);
+        } else if (isConflictStatus(result.status)) {
+          writeFileSync3(overrideAbs, result.stdout);
+          entry.base = recordBase(currentAbs, currentHash);
+          dirty = true;
+          conflicts.push(file);
+        } else {
+          conflicts.push(file);
+        }
+      } finally {
+        rmSync2(baseTmp, { force: true });
+      }
+    }
+    if (dirty) writeVariant(opts, manifest);
+    return { merged, conflicts, unchanged };
+  });
+}
+function resolveOverride(opts, active, absSourcePath) {
+  if (active.length === 0) return null;
+  const root = resolve2(opts.root);
+  const relToRoot = relative3(root, resolve2(absSourcePath));
+  if (isEscaping(relToRoot)) return null;
+  const key = toPosixPath(relToRoot);
+  for (const id of active) {
+    const manifest = readVariant(opts, id);
+    if (!manifest || !Object.hasOwn(manifest.files, key)) continue;
+    const overrideAbs = join3(variantDir(opts, id), key);
+    if (existsSync3(overrideAbs)) return overrideAbs;
+  }
+  return null;
+}
+function overrideSourcePath(opts, absOverridePath) {
+  const rel = relative3(variantsDir(opts), resolve2(absOverridePath));
+  if (!rel || isEscaping(rel)) return null;
+  const [id, ...rest] = toPosixPath(rel).split("/");
+  if (!id || rest.length === 0) return null;
+  return { id, file: rest.join("/") };
+}
+function activeConflict(opts, ids) {
+  const owner = /* @__PURE__ */ new Map();
+  for (const id of ids) {
+    const manifest = readVariant(opts, id);
+    for (const file of Object.keys(manifest?.files ?? {})) {
+      const first = owner.get(file);
+      if (first !== void 0 && first !== id) return [first, id, file];
+      owner.set(file, id);
+    }
+  }
+  return null;
+}
+function crossGroupOverlaps(opts, id) {
+  const variants = readVariants(opts);
+  const self = variants.find((v) => v.id === id);
+  if (!self) return [];
+  const siblings = overlayGroups(variants).find((g) => g.members.some((m) => m.id === id))?.members ?? [];
+  return variants.flatMap((other) => other.id === id || siblings.includes(other) ? [] : Object.keys(other.files).filter((file) => Object.hasOwn(self.files, file)).map((file) => ({ file, other: other.id })));
+}
+function readKnobs(opts) {
+  const file = resolve2(opts.root, KNOBS_FILE);
+  if (!existsSync3(file)) return [];
+  let parsed2;
+  try {
+    parsed2 = JSON.parse(readFileSync3(file, "utf8"));
+  } catch {
+    return [];
+  }
+  if (!Array.isArray(parsed2)) return [];
+  const seen = /* @__PURE__ */ new Set();
+  return parsed2.filter((k) => {
+    if (!k || typeof k !== "object") return false;
+    const a = k;
+    if (typeof a.id !== "string" || !isValidVariantId(a.id) || typeof a.label !== "string") return false;
+    if (a.route !== void 0 && typeof a.route !== "string" && (!Array.isArray(a.route) || !a.route.every((route) => typeof route === "string"))) return false;
+    if (a.showWhen !== void 0 && (!a.showWhen || typeof a.showWhen.axis !== "string" || a.showWhen.equals !== void 0 && typeof a.showWhen.equals !== "string" || a.showWhen.not !== void 0 && typeof a.showWhen.not !== "string")) return false;
+    if (a.section !== void 0 && typeof a.section !== "string") return false;
+    if (a.kind === "range") {
+      const { min, max, step, defaultValue } = a;
+      if (typeof min !== "number" || typeof max !== "number" || typeof step !== "number" || typeof defaultValue !== "number") return false;
+      return [min, max, step, defaultValue, max - min].every(Number.isFinite) && min < max && step > 0 && defaultValue >= min && defaultValue <= max && (a.unit === void 0 || typeof a.unit === "string");
+    }
+    if (a.kind === "color") {
+      const c = a;
+      const hex = (value) => typeof value === "string" && /^#(?:[a-f0-9]{3}|[a-f0-9]{6})$/i.test(value);
+      return hex(c.defaultColor) && Array.isArray(c.swatches) && c.swatches.every((s) => s && typeof s.id === "string" && typeof s.label === "string" && hex(s.value));
+    }
+    if (a.kind === "select") {
+      const s = a;
+      return Array.isArray(s.options) && s.options.length > 0 && s.options.every((o) => o && typeof o.id === "string" && typeof o.label === "string") && s.options.some((o) => o.id === s.defaultOption);
+    }
+    return false;
+  }).filter((axis) => {
+    if (seen.has(axis.id)) return false;
+    seen.add(axis.id);
+    return true;
+  });
+}
+function readActive(opts) {
+  const file = join3(resolve2(opts.root), ACTIVE_FILE);
+  if (!existsSync3(file)) return [];
+  let raw;
+  try {
+    raw = JSON.parse(readFileSync3(file, "utf8")).active;
+  } catch {
+    return [];
+  }
+  const ids = Array.isArray(raw) ? raw : typeof raw === "string" ? [raw] : [];
+  const kept = [];
+  const seen = /* @__PURE__ */ new Set();
+  const owner = /* @__PURE__ */ new Set();
+  for (const id of ids) {
+    if (typeof id !== "string" || seen.has(id)) continue;
+    seen.add(id);
+    const manifest = readVariant(opts, id);
+    if (!manifest) continue;
+    const files = Object.keys(manifest.files);
+    if (files.some((f) => owner.has(f))) continue;
+    for (const f of files) owner.add(f);
+    kept.push(id);
+  }
+  return kept;
+}
+function writeActive(opts, ids) {
+  const file = join3(resolve2(opts.root), ACTIVE_FILE);
+  mkdirSync3(dirname4(file), { recursive: true });
+  const active = Array.from(new Set(ids));
+  writeJson(file, { active });
+  ensureFileIgnored(file);
+}
+function variantsResponse(opts, req) {
+  const method = req.method ?? "";
+  const path = (req.url ?? "/").split("?")[0] || "/";
+  const json = (status, body) => ({
+    status,
+    headers: { "content-type": "application/json; charset=utf-8", "cache-control": "no-store" },
+    body
+  });
+  if (method === "GET" && path === "/") {
+    return json(200, { variants: listVariants(opts), active: readActive(opts), knobs: readKnobs(opts) });
+  }
+  if (method === "POST" && path === "/active") {
+    const body = req.body;
+    if (body === null || typeof body !== "object" || Array.isArray(body)) {
+      return json(400, { error: "body must be a JSON object" });
+    }
+    const raw = body.active;
+    if (!Array.isArray(raw) || !raw.every((id) => typeof id === "string")) {
+      return json(400, { error: "active must be an array of variant ids" });
+    }
+    const active = Array.from(new Set(raw));
+    for (const id of active) {
+      if (!isValidVariantId(id)) return json(400, { error: `invalid variant id "${id}"` });
+    }
+    for (const id of active) {
+      if (!readVariant(opts, id)) return json(404, { error: `unknown variant "${id}"` });
+    }
+    const conflict = activeConflict(opts, active);
+    if (conflict) {
+      const [a, b, file] = conflict;
+      const groups = overlayGroups(readVariants(opts));
+      const named = (id) => {
+        const label = groups.find((group) => group.members.some((member) => member.id === id))?.label;
+        return label ? `"${id}" (${label})` : `"${id}"`;
+      };
+      return json(409, {
+        error: `${named(a)} and ${named(b)} both override ${file}; only one can be active`,
+        conflict
+      });
+    }
+    writeActive(opts, active);
+    return json(200, { active });
+  }
+  return json(405, { error: "method not allowed" });
+}
+
+export {
+  writeJson,
+  withFileLock,
+  parseVersion,
+  compareVersions,
+  upgradeCommand,
+  notesProjectRoot,
+  updateRequestOf,
+  changelogUrl,
+  PAYLOAD_MAX,
+  readNotes,
+  writeNotes,
+  updateNotes,
+  ensureFileIgnored,
+  ensureDirIgnored,
+  notesResponse,
+  notesRevision,
+  MAX_REPLY_LENGTH,
+  noteFingerprint,
+  replyView,
+  NOTES_ENDPOINT,
+  DEFAULT_VARIANTS_DIR,
+  ACTIVE_FILE,
+  KNOBS_FILE,
+  variantsDir,
+  variantDir,
+  readVariant,
+  readVariants,
+  listVariants,
+  createVariant,
+  setVariantGroup,
+  setVariantSection,
+  addVariantFile,
+  removeVariantFile,
+  promoteVariant,
+  dropVariant,
+  syncVariant,
+  resolveOverride,
+  overrideSourcePath,
+  crossGroupOverlaps,
+  readKnobs,
+  readActive,
+  writeActive,
+  variantsResponse
+};
+//# sourceMappingURL=chunk-L6O4HYGP.js.map