@reddoorla/maintenance 0.82.0 → 0.83.0

package/dist/chunk-VNB5XBQ4.js

@@ -0,0 +1,699 @@
+// src/prismic/models/canon.ts
+function canon(v) {
+  if (Array.isArray(v)) return v.map(canon);
+  if (v !== null && typeof v === "object") {
+    return Object.fromEntries(
+      Object.entries(v).filter(([k, x]) => x !== null && x !== void 0 && x !== "" && k !== "imageUrl").sort(([a], [b]) => a < b ? -1 : 1).map(([k, x]) => [k, canon(x)])
+    );
+  }
+  return v;
+}
+function sameModel(a, b) {
+  return JSON.stringify(canon(a)) === JSON.stringify(canon(b));
+}
+
+// src/prismic/models/diff.ts
+var key = (e) => `${e.kind}:${e.id}`;
+function diffModels(local, remote) {
+  const remoteByKey = new Map(remote.map((e) => [key(e), e]));
+  const localKeys = new Set(local.map(key));
+  const diff = { toCreate: [], toUpdate: [], unchanged: [], remoteOnly: [] };
+  for (const l of local) {
+    const r = remoteByKey.get(key(l));
+    if (!r) diff.toCreate.push(l);
+    else if (sameModel(l.model, r.model)) diff.unchanged.push(l);
+    else diff.toUpdate.push({ local: l, remote: r });
+  }
+  for (const r of remote) if (!localKeys.has(key(r))) diff.remoteOnly.push(r);
+  return diff;
+}
+var asZone = (v) => v !== null && typeof v === "object" ? v : {};
+var MAX_FIELD_DEPTH = 20;
+var compareMeta = (a, b, excluded, format) => {
+  const skip = new Set(excluded);
+  const out = [];
+  for (const k of Object.keys(a)) {
+    if (skip.has(k)) continue;
+    if (!Object.hasOwn(b, k)) out.push(format(k, "added"));
+  }
+  for (const k of Object.keys(b)) {
+    if (skip.has(k)) continue;
+    if (!Object.hasOwn(a, k)) out.push(format(k, "removed"));
+  }
+  for (const k of Object.keys(a)) {
+    if (skip.has(k) || !Object.hasOwn(b, k)) continue;
+    if (!sameModel(a[k], b[k])) out.push(format(k, "changed"));
+  }
+  return out;
+};
+var modelMetaLine = (k, verb) => verb === "added" ? `+ (model) ${k}` : verb === "removed" ? `- (model) ${k} (only in Prismic \u2014 pushing DELETES it)` : `~ (model) ${k}`;
+var variationMetaLine = (id, k, verb) => verb === "added" ? `+ variation ${id}: ${k}` : verb === "removed" ? `- variation ${id}: ${k} (only in Prismic \u2014 pushing DELETES it)` : `~ variation ${id}: ${k}`;
+var MODEL_FIELD_KEYS = ["variations", "json"];
+var VARIATION_FIELD_ZONES = ["primary", "items"];
+var VARIATION_META_EXCLUDE = [...VARIATION_FIELD_ZONES, "imageUrl"];
+var containerChildren = (field) => {
+  const f = asZone(field);
+  if (f.type === "Group") return asZone(asZone(f.config).fields);
+  if (f.type === "Slices") return asZone(asZone(f.config).choices);
+  return void 0;
+};
+var withoutChildren = (field, childrenKey) => {
+  const f = asZone(field);
+  const cfg = asZone(f.config);
+  const { [childrenKey]: _children, ...restCfg } = cfg;
+  return { ...f, config: restCfg };
+};
+var compareZone = (label, lz, rz, depth) => {
+  const a = asZone(lz);
+  const b = asZone(rz);
+  const out = [];
+  for (const k of Object.keys(a)) if (!Object.hasOwn(b, k)) out.push(`+ ${label}.${k}`);
+  for (const k of Object.keys(b))
+    if (!Object.hasOwn(a, k)) out.push(`- ${label}.${k} (only in Prismic \u2014 pushing DELETES it)`);
+  for (const k of Object.keys(a)) {
+    if (!Object.hasOwn(b, k) || sameModel(a[k], b[k])) continue;
+    const childPath = `${label}.${k}`;
+    if (depth < MAX_FIELD_DEPTH) {
+      const av = asZone(a[k]);
+      const bv = asZone(b[k]);
+      if (av.type === bv.type && (av.type === "Group" || av.type === "Slices")) {
+        const childrenKey = av.type === "Group" ? "fields" : "choices";
+        const nested = compareZone(
+          childPath,
+          containerChildren(a[k]),
+          containerChildren(b[k]),
+          depth + 1
+        );
+        if (nested.length > 0) {
+          if (!sameModel(withoutChildren(a[k], childrenKey), withoutChildren(b[k], childrenKey)))
+            out.push(`~ ${childPath} (changed)`);
+          out.push(...nested);
+          continue;
+        }
+      }
+    }
+    out.push(`~ ${childPath} (changed)`);
+  }
+  return out;
+};
+function describeDiff(local, remote) {
+  const l = asZone(local);
+  const r = asZone(remote);
+  const lines = [];
+  if (remote !== void 0) lines.push(...compareMeta(l, r, MODEL_FIELD_KEYS, modelMetaLine));
+  if (Array.isArray(l.variations) || Array.isArray(r.variations)) {
+    const variationEntries = (arr) => Array.isArray(arr) ? arr.map((v, i) => {
+      const z = asZone(v);
+      const id = typeof z.id === "string" ? z.id : `variations[${i}]`;
+      return [id, z];
+    }) : [];
+    const lv = new Map(variationEntries(l.variations));
+    const rv = new Map(variationEntries(r.variations));
+    for (const [id, v] of lv) {
+      const rr = rv.get(id);
+      if (!rr) {
+        lines.push(`+ variation ${id} (new)`);
+        continue;
+      }
+      for (const zone of VARIATION_FIELD_ZONES)
+        lines.push(...compareZone(`${id}.${zone}`, v[zone], rr[zone], 0));
+      lines.push(
+        ...compareMeta(v, rr, VARIATION_META_EXCLUDE, (k, verb) => variationMetaLine(id, k, verb))
+      );
+    }
+    for (const id of rv.keys())
+      if (!lv.has(id)) lines.push(`- variation ${id} (only in Prismic \u2014 pushing DELETES it)`);
+  }
+  if (l.json !== void 0 || r.json !== void 0) {
+    const lt = asZone(l.json);
+    const rt = asZone(r.json);
+    for (const tab of Object.keys(lt)) {
+      if (!Object.hasOwn(rt, tab)) {
+        lines.push(`+ tab ${tab} (new)`);
+        continue;
+      }
+      lines.push(...compareZone(tab, lt[tab], rt[tab], 0));
+    }
+    for (const tab of Object.keys(rt))
+      if (!Object.hasOwn(lt, tab))
+        lines.push(`- tab ${tab} (only in Prismic \u2014 pushing DELETES it)`);
+  }
+  if (lines.length === 0 && remote !== void 0 && !sameModel(local, remote))
+    lines.push("~ (model) changed (no field-level detail)");
+  return lines;
+}
+function withRemoteScreenshots(local, remote) {
+  if (!Array.isArray(local.variations)) return local;
+  if (!remote) {
+    return {
+      ...local,
+      variations: local.variations.map((v) => ({ ...asZone(v), imageUrl: "" }))
+    };
+  }
+  const shots = new Map(
+    (Array.isArray(remote.variations) ? remote.variations : []).map((v) => asZone(v)).filter((o) => typeof o.id === "string").map((o) => [o.id, o])
+  );
+  return {
+    ...local,
+    variations: local.variations.map((v) => {
+      const o = asZone(v);
+      if (typeof o.id !== "string") return v;
+      const remoteVariation = shots.get(o.id);
+      if (!remoteVariation || !Object.hasOwn(remoteVariation, "imageUrl")) return v;
+      return { ...o, imageUrl: remoteVariation.imageUrl };
+    })
+  };
+}
+
+// src/prismic/models/config.ts
+import { readFile } from "fs/promises";
+import { join } from "path";
+var CONFIG_FILES = ["slicemachine.config.json", "prismic.config.json"];
+var PLACEHOLDER_REPOSITORY_NAMES = [
+  "your-prismic-repo-name",
+  "reddoor-wireframer"
+];
+async function readPrismicConfig(repoRoot) {
+  for (const name of CONFIG_FILES) {
+    let raw;
+    try {
+      raw = await readFile(join(repoRoot, name), "utf-8");
+    } catch (e) {
+      if (e.code === "ENOENT") continue;
+      throw new Error(`${name}: present but unreadable (${e.message})`, { cause: e });
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch (e) {
+      throw new Error(`${name}: invalid JSON (${e.message})`, { cause: e });
+    }
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+      const got = parsed === null ? "null" : Array.isArray(parsed) ? "an array" : typeof parsed;
+      throw new Error(`${name}: not a JSON object (got ${got})`);
+    }
+    const cfg = parsed;
+    if (typeof cfg.repositoryName !== "string" || cfg.repositoryName.trim() === "") {
+      throw new Error(`${name}: repositoryName is missing or not a string`);
+    }
+    const repositoryName = cfg.repositoryName.trim();
+    if (PLACEHOLDER_REPOSITORY_NAMES.includes(repositoryName)) continue;
+    if (cfg.libraries !== void 0 && !(Array.isArray(cfg.libraries) && cfg.libraries.every((l) => typeof l === "string"))) {
+      const got = Array.isArray(cfg.libraries) ? "an array with a non-string entry" : cfg.libraries === null ? "null" : typeof cfg.libraries;
+      throw new Error(`${name}: libraries is present but is not an array of strings (got ${got})`);
+    }
+    const libraries = cfg.libraries === void 0 ? ["./src/lib/slices"] : cfg.libraries;
+    return { repositoryName, libraries };
+  }
+  return null;
+}
+
+// src/prismic/models/token.ts
+function prismicTokenEnvName(repositoryName) {
+  const slug = repositoryName.toUpperCase().replace(/[^A-Z0-9]+/g, "_").replace(/^_+|_+$/g, "");
+  if (slug === "") {
+    throw new Error(
+      `cannot derive a token env var from repositoryName ${JSON.stringify(repositoryName)}: it has no alphanumeric characters`
+    );
+  }
+  return `PRISMIC_TOKEN_${slug}`;
+}
+function resolvePrismicToken(repositoryName, env, opts) {
+  const canonical = prismicTokenEnvName(repositoryName);
+  const names = opts.allowGeneric ? [canonical, "PRISMIC_WRITE_TOKEN"] : [canonical];
+  for (const name of names) {
+    const value = env[name]?.trim();
+    if (value) return { token: value, source: name };
+  }
+  return null;
+}
+
+// src/prismic/models/local.ts
+import { lstat, readdir, readFile as readFile2, stat } from "fs/promises";
+import { join as join2, posix, relative, sep } from "path";
+var relPath = (repoRoot, full) => relative(repoRoot, full).split(sep).join(posix.sep);
+async function isProvenAbsent(full) {
+  try {
+    await lstat(full);
+    return false;
+  } catch (e) {
+    return e.code === "ENOENT";
+  }
+}
+async function readModel(repoRoot, full, kind) {
+  const rel = relPath(repoRoot, full);
+  let raw;
+  try {
+    raw = await readFile2(full, "utf-8");
+  } catch (e) {
+    throw new Error(`${rel}: cannot read model file (${e.message})`, { cause: e });
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (e) {
+    throw new Error(`${rel}: invalid JSON (${e.message})`, { cause: e });
+  }
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    const got = parsed === null ? "null" : Array.isArray(parsed) ? "an array" : typeof parsed;
+    throw new Error(`${rel}: model is not a JSON object (got ${got})`);
+  }
+  const model = parsed;
+  if (typeof model.id !== "string" || model.id === "") {
+    throw new Error(`${rel}: model has no string "id"`);
+  }
+  return { kind, id: model.id, model, path: rel };
+}
+async function subdirs(repoRoot, dir) {
+  let entries;
+  try {
+    entries = await readdir(dir, { withFileTypes: true });
+  } catch (e) {
+    if (await isProvenAbsent(dir)) return [];
+    throw new Error(`${relPath(repoRoot, dir)}: cannot list directory (${e.message})`, {
+      cause: e
+    });
+  }
+  const names = [];
+  for (const d of entries) {
+    if (d.isDirectory()) {
+      names.push(d.name);
+      continue;
+    }
+    if (!d.isSymbolicLink()) continue;
+    const full = join2(dir, d.name);
+    let target;
+    try {
+      target = await stat(full);
+    } catch (e) {
+      throw new Error(
+        `${relPath(repoRoot, full)}: symlink cannot be resolved (${e.message}). A link we cannot follow may be a model directory \u2014 refusing to guess.`,
+        { cause: e }
+      );
+    }
+    if (target.isDirectory()) names.push(d.name);
+  }
+  return names.sort();
+}
+async function localModels(repoRoot, libraries) {
+  const out = [];
+  const ctRoot = join2(repoRoot, "customtypes");
+  for (const d of await subdirs(repoRoot, ctRoot)) {
+    const full = join2(ctRoot, d, "index.json");
+    if (await isProvenAbsent(full)) continue;
+    out.push(await readModel(repoRoot, full, "customtype"));
+  }
+  for (const libRoot of new Set(libraries.map((lib) => join2(repoRoot, lib)))) {
+    for (const d of await subdirs(repoRoot, libRoot)) {
+      const full = join2(libRoot, d, "model.json");
+      if (await isProvenAbsent(full)) continue;
+      out.push(await readModel(repoRoot, full, "slice"));
+    }
+  }
+  assertNoDuplicateIds(out);
+  assertVariationsHaveIds(out);
+  return out;
+}
+function assertNoDuplicateIds(entries) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const e of entries) {
+    const k = `${e.kind}:${e.id}`;
+    const first = seen.get(k);
+    if (first !== void 0) {
+      throw new Error(
+        `duplicate ${e.kind} id "${e.id}": declared by both ${first} and ${e.path}. Two files cannot own one model \u2014 delete or rename one.`
+      );
+    }
+    seen.set(k, e.path);
+  }
+}
+function assertVariationsHaveIds(entries) {
+  for (const e of entries) {
+    const variations = e.model.variations;
+    if (!Array.isArray(variations)) continue;
+    variations.forEach((v, i) => {
+      const id = v?.id;
+      if (typeof id !== "string" || id === "") {
+        throw new Error(
+          `${e.path}: variation at index ${i} has no string "id". Prismic rejects such a model, and the diff cannot describe it.`
+        );
+      }
+    });
+  }
+}
+
+// src/prismic/models/remote.ts
+var CUSTOM_TYPES_API = "https://customtypes.prismic.io";
+var COLLECTION = { customtype: "customtypes", slice: "slices" };
+var PRISMIC_TIMEOUT_MS = 15e3;
+var authHeaders = (repo, token) => ({
+  repository: repo,
+  Authorization: `Bearer ${token}`
+});
+var jsonTypeOf = (v) => v === null ? "null" : Array.isArray(v) ? "an array" : typeof v;
+var errorBody = async (res, limit) => res.text().then(
+  (t) => t.slice(0, limit),
+  (e) => `<response body unreadable: ${String(e)}>`
+);
+async function request(url, init, repo, fetchImpl, timeoutMs) {
+  try {
+    return await fetchImpl(url, { ...init, signal: AbortSignal.timeout(timeoutMs) });
+  } catch (e) {
+    const what = `${init.method ?? "GET"} ${url} [repository: ${repo}]`;
+    const detail = e?.name === "TimeoutError" ? `timed out after ${timeoutMs}ms` : `failed: ${e instanceof Error ? e.message : String(e)}`;
+    throw new Error(`${what} ${detail}`, { cause: e });
+  }
+}
+async function getCollection(repo, token, kind, fetchImpl, timeoutMs) {
+  const url = `${CUSTOM_TYPES_API}/${COLLECTION[kind]}`;
+  const res = await request(url, { headers: authHeaders(repo, token) }, repo, fetchImpl, timeoutMs);
+  if (!res.ok) {
+    throw Object.assign(
+      new Error(`GET ${url} [repository: ${repo}] -> ${res.status} ${await errorBody(res, 200)}`),
+      { status: res.status }
+    );
+  }
+  const where = `GET ${url} [repository: ${repo}]`;
+  let raw;
+  try {
+    raw = await res.text();
+  } catch (e) {
+    throw new Error(`${where}: ${res.status} but the body could not be read`, { cause: e });
+  }
+  let body;
+  try {
+    body = JSON.parse(raw);
+  } catch (e) {
+    throw new Error(
+      `${where}: ${res.status} but the body did not parse as JSON: ${raw.slice(0, 200)}`,
+      { cause: e }
+    );
+  }
+  if (!Array.isArray(body)) {
+    throw new Error(`${where}: expected an array, got ${jsonTypeOf(body)}`);
+  }
+  return body.map((m, i) => {
+    const id = m?.id;
+    if (typeof id !== "string" || id === "") {
+      throw new Error(`${where}: entry at index ${i} has no string "id"`);
+    }
+    return { kind, id, model: m };
+  });
+}
+async function remoteModels(repo, token, fetchImpl = fetch, timeoutMs = PRISMIC_TIMEOUT_MS) {
+  const customtypes = await getCollection(repo, token, "customtype", fetchImpl, timeoutMs);
+  const slices = await getCollection(repo, token, "slice", fetchImpl, timeoutMs);
+  return [...customtypes, ...slices];
+}
+async function sendModel(repo, token, entry, action, fetchImpl = fetch, timeoutMs = PRISMIC_TIMEOUT_MS) {
+  const bodyId = entry.model.id;
+  if (typeof bodyId !== "string" || bodyId === "" || bodyId !== entry.id) {
+    throw new Error(
+      `refusing to ${action} ${entry.kind} "${entry.id}": the model body's id is ${JSON.stringify(bodyId)}. Prismic writes the body's id, not the reported one, so this would modify the wrong model or none at all.`
+    );
+  }
+  const url = `${CUSTOM_TYPES_API}/${COLLECTION[entry.kind]}/${action}`;
+  const res = await request(
+    url,
+    {
+      method: "POST",
+      headers: { ...authHeaders(repo, token), "Content-Type": "application/json" },
+      body: JSON.stringify(entry.model)
+    },
+    repo,
+    fetchImpl,
+    timeoutMs
+  );
+  if (!res.ok) {
+    throw Object.assign(
+      new Error(
+        `POST ${url} [${entry.kind} ${entry.id}] -> ${res.status} ${await errorBody(res, 300)}`
+      ),
+      { status: res.status }
+    );
+  }
+}
+
+// src/prismic/models/push.ts
+var statusOf = (e) => {
+  try {
+    const s = e?.status;
+    return typeof s === "number" ? s : void 0;
+  } catch {
+    return void 0;
+  }
+};
+var messageOf = (e) => {
+  try {
+    if (e instanceof Error) {
+      const m = e.message;
+      if (typeof m === "string") return m;
+    }
+  } catch {
+  }
+  try {
+    return String(e);
+  } catch {
+    return `<a thrown ${typeof e} that cannot be converted to a string>`;
+  }
+};
+async function pushModels(diff, opts) {
+  const work = [
+    ...diff.toCreate.map((entry) => ({ entry, remote: void 0, action: "insert" })),
+    ...diff.toUpdate.map(({ local, remote }) => ({
+      entry: local,
+      remote: remote.model,
+      action: "update"
+    }))
+  ];
+  work.sort((a, b) => a.entry.kind === b.entry.kind ? 0 : a.entry.kind === "slice" ? -1 : 1);
+  const report = {
+    mode: opts.apply ? "apply" : "dry",
+    sent: [],
+    failed: [],
+    // Filled BEFORE the loop and identically in both modes, because it is a fact
+    // about the COMPARISON rather than about what this run did — and because it
+    // is the only thing that keeps an empty report from being ambiguous between
+    // "in sync" and "this checkout can no longer see its own slices". See
+    // `PushReport.remoteOnlyReported` for the failure it exists to name.
+    remoteOnlyReported: diff.remoteOnly.map((e) => ({ kind: e.kind, id: e.id }))
+  };
+  for (const { entry, remote, action } of work) {
+    if (!opts.apply) {
+      report.sent.push({ kind: entry.kind, id: entry.id, action });
+      continue;
+    }
+    try {
+      await opts.send(
+        { ...entry, model: withRemoteScreenshots(entry.model, remote) },
+        remote,
+        action
+      );
+      report.sent.push({ kind: entry.kind, id: entry.id, action });
+    } catch (e) {
+      const status = statusOf(e);
+      report.failed.push({
+        kind: entry.kind,
+        id: entry.id,
+        error: messageOf(e),
+        // Spread, so the key is ABSENT rather than present-and-undefined when
+        // there was no status (a network failure has none). `PushReport` is
+        // serialised into PR comments and Airtable; a blank `status` key reads
+        // as "there was one and it was empty".
+        ...status === void 0 ? {} : { status }
+      });
+    }
+  }
+  return report;
+}
+
+// src/prismic/models/write.ts
+import { mkdir, readFile as readFile3, realpath, rename, writeFile } from "fs/promises";
+import { dirname, join as join3, posix as posix2, relative as relative2, sep as sep2 } from "path";
+var ID_ALLOWED = /^[A-Za-z0-9_-]+$/;
+var SEGMENT_ALLOWED = /^[A-Za-z0-9_][A-Za-z0-9._-]*$/;
+var pascal = (id) => id.split(/[^A-Za-z0-9]+/).filter(Boolean).map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join("");
+function modelFilePath(entry, library) {
+  if (!ID_ALLOWED.test(entry.id)) {
+    throw new Error(
+      `refusing to derive a file path for ${entry.kind} id ${JSON.stringify(entry.id)}: a model id may contain only letters, digits, "_" and "-". Create the file by hand rather than letting this guess where it goes.`
+    );
+  }
+  let rel;
+  if (entry.kind === "customtype") {
+    rel = posix2.join("customtypes", entry.id, "index.json");
+  } else {
+    const lib = library.replace(/^\.\//, "").split(sep2).join(posix2.sep).trim();
+    if (lib === "") {
+      throw new Error(
+        `refusing to place slice "${entry.id}": no slice library was given. An empty library is not the fleet default \u2014 config.ts treats "libraries: []" as "this site has no slice library" \u2014 so there is nowhere to put this model.`
+      );
+    }
+    const dir = pascal(entry.id);
+    if (dir === "") {
+      throw new Error(
+        `refusing to place slice ${JSON.stringify(entry.id)}: it has no letters or digits, so it yields no directory name.`
+      );
+    }
+    rel = posix2.join(lib, dir, "model.json");
+  }
+  const bad = rel.split(posix2.sep).filter((s) => !SEGMENT_ALLOWED.test(s));
+  if (bad.length > 0) {
+    throw new Error(
+      `refusing to write ${entry.kind} "${entry.id}" to ${JSON.stringify(rel)}: the path segment(s) ${JSON.stringify(bad)} are not a plain relative location inside the repo. Check the "libraries" entry in this site's Prismic config.`
+    );
+  }
+  return rel;
+}
+async function occupantId(rel, full) {
+  let raw;
+  try {
+    raw = await readFile3(full, "utf-8");
+  } catch (e) {
+    if (e.code === "ENOENT") return null;
+    throw new Error(
+      `${rel}: cannot be read, so this pipeline cannot tell whether a model is already there (${e.message}). Refusing to write over what it cannot see.`,
+      { cause: e }
+    );
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (e) {
+    throw new Error(
+      `${rel}: already exists and is not valid JSON (${e.message}). Refusing to overwrite a file this pipeline cannot identify.`,
+      { cause: e }
+    );
+  }
+  const id = parsed?.id;
+  if (typeof id !== "string" || id === "") {
+    throw new Error(
+      `${rel}: already exists but declares no string "id", so there is no way to tell whether it is the model being pulled down. Refusing to overwrite it.`
+    );
+  }
+  return id;
+}
+async function realpathOfNearestExisting(p) {
+  let cur = p;
+  for (; ; ) {
+    try {
+      return await realpath(cur);
+    } catch (e) {
+      if (e.code !== "ENOENT") {
+        throw new Error(`${cur}: cannot be resolved (${e.message})`, { cause: e });
+      }
+      const parent = dirname(cur);
+      if (parent === cur) throw new Error(`${p}: no ancestor of this path exists`, { cause: e });
+      cur = parent;
+    }
+  }
+}
+async function assertResolvesInsideRepo(repoRoot, rel, dir) {
+  const realRoot = await realpathOfNearestExisting(repoRoot);
+  const real = await realpathOfNearestExisting(dir);
+  if (real !== realRoot && !real.startsWith(realRoot + sep2)) {
+    throw new Error(
+      `refusing to write ${rel}: it resolves to ${real}, which is outside this repo (${realRoot}). A symlinked path component redirects the write while every segment of the repo-relative path still looks ordinary \u2014 and every sibling of a repo in this fleet is another live client repo.`
+    );
+  }
+}
+async function targetPrettierBin(repoRoot) {
+  try {
+    return await realpath(join3(repoRoot, "node_modules", ".bin", "prettier"));
+  } catch {
+    return null;
+  }
+}
+var PRETTIER_TIMEOUT_MS = 6e4;
+async function writeModelFile(format, repoRoot, entry, library) {
+  const bodyId = entry.model.id;
+  if (typeof bodyId !== "string" || bodyId === "" || bodyId !== entry.id) {
+    throw new Error(
+      `refusing to write ${entry.kind} "${entry.id}": the model body's id is ${JSON.stringify(bodyId)}. The path is derived from one and every reader of the file keys on the other, so this model would never be found again.`
+    );
+  }
+  const rel = modelFilePath(entry, library);
+  const full = join3(repoRoot, rel);
+  const dir = dirname(full);
+  await assertResolvesInsideRepo(repoRoot, rel, dir);
+  const occupant = await occupantId(rel, full);
+  if (occupant !== null && occupant !== entry.id) {
+    throw new Error(
+      `refusing to pull ${entry.kind} "${entry.id}" into ${rel}: that file already holds "${occupant}". A slice's directory name and its model id are independent \u2014 6 of the fleet's 132 slice directories differ (measured 2026-08-13) \u2014 so the directory this derives can belong to a different model. Move or rename the existing model, or create this one by hand.`
+    );
+  }
+  try {
+    await mkdir(dir, { recursive: true });
+  } catch (e) {
+    throw new Error(
+      `${posix2.dirname(rel)}: cannot create the directory for this model (${e.message})`,
+      { cause: e }
+    );
+  }
+  await assertResolvesInsideRepo(repoRoot, rel, dir);
+  const body = JSON.stringify(entry.model, null, 2) + "\n";
+  if (occupant === null) {
+    try {
+      await writeFile(full, body, { encoding: "utf-8", flag: "wx" });
+    } catch (e) {
+      if (e.code === "EEXIST") {
+        throw new Error(
+          `${rel}: nothing readable was at this path a moment ago and something is there now \u2014 a dangling symlink, or a concurrent write. Refusing to overwrite it.`,
+          { cause: e }
+        );
+      }
+      throw e;
+    }
+  } else {
+    const tmp = `${full}.tmp`;
+    const tmpRel = relative2(repoRoot, tmp);
+    try {
+      await writeFile(tmp, body, { encoding: "utf-8", flag: "w" });
+    } catch (e) {
+      throw new Error(
+        `${rel}: could not stage the replacement model (${e.message}). The model already in the repo is UNTOUCHED. A partial ${tmpRel} may be left behind \u2014 the next pull-down of this model overwrites it, and nothing reads it.`,
+        { cause: e }
+      );
+    }
+    try {
+      await rename(tmp, full);
+    } catch (e) {
+      throw new Error(
+        `${rel}: could not replace the model with the staged copy (${e.message}). The model already in the repo is UNTOUCHED and the staged copy is at ${tmpRel} \u2014 the next pull-down of this model overwrites it, and nothing reads it.`,
+        { cause: e }
+      );
+    }
+  }
+  const bin = await targetPrettierBin(repoRoot);
+  if (bin === null) return { path: rel, formatted: false };
+  try {
+    return {
+      path: rel,
+      formatted: await format(repoRoot, [rel], { bin, timeoutMs: PRETTIER_TIMEOUT_MS })
+    };
+  } catch {
+    return { path: rel, formatted: false };
+  }
+}
+
+// src/util/working-tree.ts
+var NOT_A_WORKING_TREE = /* @__PURE__ */ new Set([".git", ".DS_Store"]);
+function noWorkingTreeFailure(repoRoot, entries, noEffect) {
+  if (!entries.every((e) => NOT_A_WORKING_TREE.has(e))) return null;
+  return `this checkout has no working tree: ${repoRoot} holds ${entries.length === 0 ? "nothing at all" : `only ${entries.join(", ")}`}. ${noEffect} \u2014 this is NOT "no Prismic in this repo"; nothing at all was established about this repo. A git clone killed part-way leaves exactly this (a .git and no files), and a fleet workdir REUSES any non-empty directory as that site's checkout, so it will never re-clone by itself. Delete ${repoRoot} and re-run.`;
+}
+
+export {
+  diffModels,
+  describeDiff,
+  readPrismicConfig,
+  prismicTokenEnvName,
+  resolvePrismicToken,
+  localModels,
+  remoteModels,
+  sendModel,
+  pushModels,
+  writeModelFile,
+  noWorkingTreeFailure
+};
+//# sourceMappingURL=chunk-VNB5XBQ4.js.map