@koda-sl/baker-cli 0.385.0-dev.ec7b0e42b → 0.385.0-dev.f7ef4c7e1

package/dist/chunk-D5FY4FAK.js

@@ -0,0 +1,24 @@
+// src/commands/ads/hints.ts
+function backendHints(envelope) {
+  const hints = envelope.hints;
+  return Array.isArray(hints) ? hints.filter((hint) => typeof hint === "string") : [];
+}
+function withHints(envelope, extra) {
+  const hints = [...backendHints(envelope), ...extra];
+  return hints.length > 0 ? { ...envelope, hints } : envelope;
+}
+function hintLines(envelope) {
+  return backendHints(envelope).map((hint) => `
+> ${hint}`).join("");
+}
+function splitHints(response) {
+  const { hints, ...data } = response;
+  return { data, hints: hints ?? [] };
+}
+
+export {
+  withHints,
+  hintLines,
+  splitHints
+};
+//# sourceMappingURL=chunk-D5FY4FAK.js.map

package/dist/chunk-D5FY4FAK.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/commands/ads/hints.ts"],"sourcesContent":["/**\n * The `hints[]` of an ads envelope. The backend sends its own (another chat's\n * overlapping changes, say) and the CLI adds what only it can see (copy tells,\n * batching nudges) — neither may overwrite the other.\n */\n\nfunction backendHints(envelope: Record<string, unknown>): string[] {\n  const hints = envelope.hints;\n  return Array.isArray(hints) ? hints.filter((hint): hint is string => typeof hint === \"string\") : [];\n}\n\n/** The envelope with the backend's hints first, then `extra`; untouched when there are none. */\nexport function withHints<T extends Record<string, unknown>>(envelope: T, extra: readonly string[]): T {\n  const hints = [...backendHints(envelope), ...extra];\n  return hints.length > 0 ? { ...envelope, hints } : envelope;\n}\n\n/** The backend's hints as lines under a rendered (non-JSON) view; empty when there are none. */\nexport function hintLines(envelope: Record<string, unknown>): string {\n  return backendHints(envelope)\n    .map((hint) => `\\n> ${hint}`)\n    .join(\"\");\n}\n\n/**\n * A response that carries the backend's `hints` inside its data (Tag Manager,\n * Google Analytics) split into the data and those hints, so they reach the\n * envelope's `hints[]` where the agent reads them — never buried in `data`.\n */\nexport function splitHints<T extends { hints?: string[] }>(response: T): { data: Omit<T, \"hints\">; hints: string[] } {\n  const { hints, ...data } = response;\n  return { data, hints: hints ?? [] };\n}\n"],"mappings":";AAMA,SAAS,aAAa,UAA6C;AACjE,QAAM,QAAQ,SAAS;AACvB,SAAO,MAAM,QAAQ,KAAK,IAAI,MAAM,OAAO,CAAC,SAAyB,OAAO,SAAS,QAAQ,IAAI,CAAC;AACpG;AAGO,SAAS,UAA6C,UAAa,OAA6B;AACrG,QAAM,QAAQ,CAAC,GAAG,aAAa,QAAQ,GAAG,GAAG,KAAK;AAClD,SAAO,MAAM,SAAS,IAAI,EAAE,GAAG,UAAU,MAAM,IAAI;AACrD;AAGO,SAAS,UAAU,UAA2C;AACnE,SAAO,aAAa,QAAQ,EACzB,IAAI,CAAC,SAAS;AAAA,IAAO,IAAI,EAAE,EAC3B,KAAK,EAAE;AACZ;AAOO,SAAS,WAA2C,UAA0D;AACnH,QAAM,EAAE,OAAO,GAAG,KAAK,IAAI;AAC3B,SAAO,EAAE,MAAM,OAAO,SAAS,CAAC,EAAE;AACpC;","names":[]}

package/dist/chunk-DGCUPJZD.js

@@ -0,0 +1,39 @@
+// src/engine/landing-library/visualHash.ts
+import sharp from "sharp";
+var HASH_WIDTH = 9;
+var HASH_HEIGHT = 8;
+async function perceptualHash(image) {
+  try {
+    const raw = await sharp(image).greyscale().resize(HASH_WIDTH, HASH_HEIGHT, { fit: "fill" }).raw().toBuffer();
+    return bitsToHex(rowGradientBits(new Uint8Array(raw)));
+  } catch {
+    return null;
+  }
+}
+function rowGradientBits(pixels) {
+  const bits = [];
+  for (let y = 0; y < HASH_HEIGHT; y++) {
+    for (let x = 0; x < HASH_WIDTH - 1; x++) {
+      const left = pixels[y * HASH_WIDTH + x] ?? 0;
+      const right = pixels[y * HASH_WIDTH + x + 1] ?? 0;
+      bits.push(left > right);
+    }
+  }
+  return bits;
+}
+function bitsToHex(bits) {
+  let hex = "";
+  for (let index = 0; index < bits.length; index += 4) {
+    let nibble = 0;
+    for (let offset = 0; offset < 4; offset++) {
+      if (bits[index + offset]) nibble |= 1 << 3 - offset;
+    }
+    hex += nibble.toString(16);
+  }
+  return hex;
+}
+
+export {
+  perceptualHash
+};
+//# sourceMappingURL=chunk-DGCUPJZD.js.map

package/dist/chunk-DGCUPJZD.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/engine/landing-library/visualHash.ts"],"sourcesContent":["import sharp from \"sharp\";\n\n/**\n * A perceptual fingerprint of what a section actually looks like.\n *\n * The corpus stores many pages per site, and a site puts the same navbar,\n * footer and closing CTA on all of them. Those repeats are byte-different in\n * markup — different nav item is active, different year in the copyright — so\n * neither the HTML nor the structural fingerprint catches them. Pixels do.\n *\n * dHash rather than a mean-brightness hash: it encodes the *gradient* between\n * neighbouring pixels, so it survives the small exposure and anti-aliasing\n * differences between two screenshots of the same element, while still\n * separating two sections that merely share an overall tone. A section is\n * mostly whitespace often enough that average-brightness hashing collapses\n * unrelated sections onto the same value.\n */\n\n/** 9 wide because each row yields 8 comparisons — 8 rows x 8 bits = 64. */\nconst HASH_WIDTH = 9;\nconst HASH_HEIGHT = 8;\n\nexport async function perceptualHash(image: Buffer): Promise<string | null> {\n  try {\n    const raw = await sharp(image).greyscale().resize(HASH_WIDTH, HASH_HEIGHT, { fit: \"fill\" }).raw().toBuffer();\n    return bitsToHex(rowGradientBits(new Uint8Array(raw)));\n  } catch {\n    // A hash we couldn't compute must not fail the capture. Downstream treats a\n    // missing hash as \"unknown\", which keeps the section rather than guessing.\n    return null;\n  }\n}\n\n/**\n * Is each pixel brighter than the one to its right?\n *\n * Exported for testing: this is the whole of the algorithm, and it is far\n * easier to reason about against a hand-built grid than through sharp.\n */\nexport function rowGradientBits(pixels: Uint8Array): boolean[] {\n  const bits: boolean[] = [];\n  for (let y = 0; y < HASH_HEIGHT; y++) {\n    for (let x = 0; x < HASH_WIDTH - 1; x++) {\n      const left = pixels[y * HASH_WIDTH + x] ?? 0;\n      const right = pixels[y * HASH_WIDTH + x + 1] ?? 0;\n      bits.push(left > right);\n    }\n  }\n  return bits;\n}\n\nfunction bitsToHex(bits: readonly boolean[]): string {\n  let hex = \"\";\n  for (let index = 0; index < bits.length; index += 4) {\n    let nibble = 0;\n    for (let offset = 0; offset < 4; offset++) {\n      if (bits[index + offset]) nibble |= 1 << (3 - offset);\n    }\n    hex += nibble.toString(16);\n  }\n  return hex;\n}\n"],"mappings":";AAAA,OAAO,WAAW;AAmBlB,IAAM,aAAa;AACnB,IAAM,cAAc;AAEpB,eAAsB,eAAe,OAAuC;AAC1E,MAAI;AACF,UAAM,MAAM,MAAM,MAAM,KAAK,EAAE,UAAU,EAAE,OAAO,YAAY,aAAa,EAAE,KAAK,OAAO,CAAC,EAAE,IAAI,EAAE,SAAS;AAC3G,WAAO,UAAU,gBAAgB,IAAI,WAAW,GAAG,CAAC,CAAC;AAAA,EACvD,QAAQ;AAGN,WAAO;AAAA,EACT;AACF;AAQO,SAAS,gBAAgB,QAA+B;AAC7D,QAAM,OAAkB,CAAC;AACzB,WAAS,IAAI,GAAG,IAAI,aAAa,KAAK;AACpC,aAAS,IAAI,GAAG,IAAI,aAAa,GAAG,KAAK;AACvC,YAAM,OAAO,OAAO,IAAI,aAAa,CAAC,KAAK;AAC3C,YAAM,QAAQ,OAAO,IAAI,aAAa,IAAI,CAAC,KAAK;AAChD,WAAK,KAAK,OAAO,KAAK;AAAA,IACxB;AAAA,EACF;AACA,SAAO;AACT;AAEA,SAAS,UAAU,MAAkC;AACnD,MAAI,MAAM;AACV,WAAS,QAAQ,GAAG,QAAQ,KAAK,QAAQ,SAAS,GAAG;AACnD,QAAI,SAAS;AACb,aAAS,SAAS,GAAG,SAAS,GAAG,UAAU;AACzC,UAAI,KAAK,QAAQ,MAAM,EAAG,WAAU,KAAM,IAAI;AAAA,IAChD;AACA,WAAO,OAAO,SAAS,EAAE;AAAA,EAC3B;AACA,SAAO;AACT;","names":[]}

package/dist/chunk-DNCLWSHO.js

@@ -0,0 +1,41 @@
+// src/commands/landing/inspiration/shot.ts
+import { mkdir, writeFile } from "fs/promises";
+import path from "path";
+import sharp from "sharp";
+var READABLE_SHOT = {
+  maxWidth: 1440,
+  maxHeight: 4e3,
+  quality: 82,
+  extension: "webp"
+};
+async function toReadableShot(original) {
+  try {
+    return await sharp(original).resize({
+      width: READABLE_SHOT.maxWidth,
+      height: READABLE_SHOT.maxHeight,
+      fit: "inside",
+      withoutEnlargement: true
+    }).webp({ quality: READABLE_SHOT.quality }).toBuffer();
+  } catch {
+    return original;
+  }
+}
+async function downloadReadableShot(url, file) {
+  if (!url) return null;
+  try {
+    const response = await fetch(url);
+    if (!response.ok) return null;
+    const shot = await toReadableShot(Buffer.from(await response.arrayBuffer()));
+    await mkdir(path.dirname(file), { recursive: true });
+    await writeFile(file, shot);
+    return path.relative(process.cwd(), file);
+  } catch {
+    return null;
+  }
+}
+
+export {
+  READABLE_SHOT,
+  downloadReadableShot
+};
+//# sourceMappingURL=chunk-DNCLWSHO.js.map

package/dist/chunk-DNCLWSHO.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/commands/landing/inspiration/shot.ts"],"sourcesContent":["import { mkdir, writeFile } from \"node:fs/promises\";\nimport path from \"node:path\";\nimport sharp from \"sharp\";\n\n/**\n * The size a section screenshot is worth reading at.\n *\n * Sections are captured at a 1440px viewport with `deviceScaleFactor: 2`, so\n * what R2 holds is a ~2880px-wide lossless PNG — the right archive, the wrong\n * thing to hand an agent. A vision model bills by pixel area and downsamples\n * anything past its own long-edge cap, so the extra resolution buys no legibility\n * and costs context on every hit; a default `search` writes eight of these, and\n * `view` three more per section.\n *\n * 1440 is the width the page was designed at, so halving the 2x capture back to\n * it is the same picture a human sees, not a lossy compromise — and the height\n * bound is what stops a 20,000px scrolling hero from being resized into an\n * unreadable ribbon.\n */\nexport const READABLE_SHOT = {\n  maxWidth: 1440,\n  maxHeight: 4000,\n  quality: 82,\n  extension: \"webp\",\n} as const;\n\n/**\n * Downscale a captured shot to the rendition an agent reads.\n *\n * Never enlarges, and never fails the caller: a shot that sharp cannot decode\n * (an HTML login wall saved as `.png` is the recurring case) is passed through\n * untouched, because a slightly-too-large image beats no image at all in a\n * library whose whole value is visual.\n */\nexport async function toReadableShot(original: Buffer): Promise<Buffer> {\n  try {\n    return await sharp(original)\n      .resize({\n        width: READABLE_SHOT.maxWidth,\n        height: READABLE_SHOT.maxHeight,\n        fit: \"inside\",\n        withoutEnlargement: true,\n      })\n      .webp({ quality: READABLE_SHOT.quality })\n      .toBuffer();\n  } catch {\n    return original;\n  }\n}\n\n/**\n * Fetch a shot and put the readable rendition on disk.\n *\n * Returns the repo-relative path to `Read`, or null when there was nothing to\n * download — a missing screenshot is never worth failing a search or a view over.\n */\nexport async function downloadReadableShot(url: string | null | undefined, file: string): Promise<string | null> {\n  if (!url) return null;\n  try {\n    const response = await fetch(url);\n    if (!response.ok) return null;\n    const shot = await toReadableShot(Buffer.from(await response.arrayBuffer()));\n    await mkdir(path.dirname(file), { recursive: true });\n    await writeFile(file, shot);\n    return path.relative(process.cwd(), file);\n  } catch {\n    return null;\n  }\n}\n"],"mappings":";AAAA,SAAS,OAAO,iBAAiB;AACjC,OAAO,UAAU;AACjB,OAAO,WAAW;AAiBX,IAAM,gBAAgB;AAAA,EAC3B,UAAU;AAAA,EACV,WAAW;AAAA,EACX,SAAS;AAAA,EACT,WAAW;AACb;AAUA,eAAsB,eAAe,UAAmC;AACtE,MAAI;AACF,WAAO,MAAM,MAAM,QAAQ,EACxB,OAAO;AAAA,MACN,OAAO,cAAc;AAAA,MACrB,QAAQ,cAAc;AAAA,MACtB,KAAK;AAAA,MACL,oBAAoB;AAAA,IACtB,CAAC,EACA,KAAK,EAAE,SAAS,cAAc,QAAQ,CAAC,EACvC,SAAS;AAAA,EACd,QAAQ;AACN,WAAO;AAAA,EACT;AACF;AAQA,eAAsB,qBAAqB,KAAgC,MAAsC;AAC/G,MAAI,CAAC,IAAK,QAAO;AACjB,MAAI;AACF,UAAM,WAAW,MAAM,MAAM,GAAG;AAChC,QAAI,CAAC,SAAS,GAAI,QAAO;AACzB,UAAM,OAAO,MAAM,eAAe,OAAO,KAAK,MAAM,SAAS,YAAY,CAAC,CAAC;AAC3E,UAAM,MAAM,KAAK,QAAQ,IAAI,GAAG,EAAE,WAAW,KAAK,CAAC;AACnD,UAAM,UAAU,MAAM,IAAI;AAC1B,WAAO,KAAK,SAAS,QAAQ,IAAI,GAAG,IAAI;AAAA,EAC1C,QAAQ;AACN,WAAO;AAAA,EACT;AACF;","names":[]}

package/dist/chunk-DUPURL26.js

@@ -0,0 +1,97 @@
+import {
+  JEV_MODEL,
+  askJev
+} from "./chunk-AIRIT4GF.js";
+
+// src/engine/lib/remembered-nouls.ts
+import { createHash } from "crypto";
+import { readFile } from "fs/promises";
+
+// src/engine/lib/file-lock.ts
+import { randomUUID } from "crypto";
+import { mkdir, rename, rm, stat, writeFile } from "fs/promises";
+import path from "path";
+var LOCK_STALE_MS = 1e4;
+var LOCK_WAIT_MS = 20;
+async function updateLockedFile(file, change) {
+  await mkdir(path.dirname(file), { recursive: true });
+  const lock = `${file}.lock`;
+  await acquireLock(lock);
+  try {
+    const temp = `${file}.${process.pid}.${randomUUID()}.tmp`;
+    await writeFile(temp, await change(), "utf8");
+    await rename(temp, file);
+  } finally {
+    await rm(lock, { force: true });
+  }
+}
+async function acquireLock(lock) {
+  for (; ; ) {
+    try {
+      await writeFile(lock, String(process.pid), { flag: "wx" });
+      return;
+    } catch (e) {
+      if (e.code !== "EEXIST") throw e;
+    }
+    const held = await stat(lock).catch(() => null);
+    if (held && Date.now() - held.mtimeMs > LOCK_STALE_MS) await rm(lock, { force: true });
+    await new Promise((resolve) => setTimeout(resolve, LOCK_WAIT_MS));
+  }
+}
+
+// src/engine/lib/remembered-nouls.ts
+var PER_REQUEST = 200;
+var MAX_REMEMBERED = 2e4;
+function keyOf(question) {
+  return createHash("sha256").update(JSON.stringify([JEV_MODEL, question.instructions])).digest("hex").slice(0, 32);
+}
+async function remembered(file) {
+  const parsed = await readFile(file, "utf8").then(JSON.parse, () => ({}));
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return {};
+  return Object.fromEntries(
+    Object.entries(parsed).filter((e) => typeof e[1] === "number")
+  );
+}
+async function rememberedNouls(questions, opts) {
+  if (questions.length === 0) return [];
+  const keys = questions.map(keyOf);
+  const known = opts.file ? await remembered(opts.file) : {};
+  const missing = [...new Set(keys.filter((k) => known[k] === void 0))];
+  const byKey = new Map(questions.map((q, i) => [keys[i], q]));
+  const batches = [];
+  for (let i = 0; i < missing.length; i += PER_REQUEST) batches.push(missing.slice(i, i + PER_REQUEST));
+  const answered = await Promise.all(
+    batches.map((batch) => opts.ask(batch.flatMap((k) => byKey.get(k) ?? [])).catch(() => null))
+  );
+  if (answered.some((a) => a === null || a.length === 0)) return null;
+  const fresh = {};
+  batches.forEach((batch, b) => {
+    batch.forEach((k, i) => {
+      const answer = answered[b]?.[i];
+      if (answer !== void 0) fresh[k] = answer;
+    });
+  });
+  const all = { ...known, ...fresh };
+  const file = opts.file;
+  if (file && missing.length > 0) {
+    await updateLockedFile(file, async () => {
+      const kept = Object.entries({ ...await remembered(file), ...fresh }).slice(-MAX_REMEMBERED);
+      return JSON.stringify(Object.fromEntries(kept));
+    }).catch(() => void 0);
+  }
+  const answers = keys.map((k) => all[k]);
+  return answers.every((a) => a !== void 0) ? answers : null;
+}
+function jevAsker(onSpend) {
+  return (questions) => askJev(questions, onSpend);
+}
+function rememberedJev(file, onSpend) {
+  const ask = jevAsker(onSpend);
+  return (questions) => rememberedNouls(questions, { ask, file });
+}
+
+export {
+  updateLockedFile,
+  rememberedJev
+};
+//# sourceMappingURL=chunk-DUPURL26.js.map

package/dist/chunk-DUPURL26.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/engine/lib/remembered-nouls.ts","../src/engine/lib/file-lock.ts"],"sourcesContent":["/**\n * Yes/no answers from the decision model (Jev, `askJev`), asked in batches and remembered by\n * question, so the same text asked the same question gets the same answer on every run. A gate\n * that counts findings (the landing critique's block count, an idea's warnings) must not flip\n * because Jev answered 0.69 one run and 0.71 the next.\n */\nimport { createHash } from \"node:crypto\";\nimport { readFile } from \"node:fs/promises\";\nimport { askJev, JEV_MODEL } from \"../nodes/local/lib/jev.ts\";\nimport type { ReviewUsage } from \"../nodes/local/lib/render-review.ts\";\nimport { updateLockedFile } from \"./file-lock.ts\";\n\nexport type NoulQuestion = { instructions: Record<string, string> };\n/** Each question's probability, in order, or null when no answer came back. */\nexport type AskNouls = (questions: readonly NoulQuestion[]) => Promise<number[] | null>;\n\n/** Several hundred fit in one request at the same latency; this keeps each well inside Jev's context. */\nconst PER_REQUEST = 200;\n/** The file never grows past this many answers; the oldest are dropped first. */\nconst MAX_REMEMBERED = 20_000;\n\nfunction keyOf(question: NoulQuestion): string {\n  return createHash(\"sha256\")\n    .update(JSON.stringify([JEV_MODEL, question.instructions]))\n    .digest(\"hex\")\n    .slice(0, 32);\n}\n\nasync function remembered(file: string): Promise<Record<string, number>> {\n  const parsed: unknown = await readFile(file, \"utf8\").then(JSON.parse, () => ({}));\n  if (!parsed || typeof parsed !== \"object\" || Array.isArray(parsed)) return {};\n  return Object.fromEntries(\n    Object.entries(parsed as Record<string, unknown>).filter((e): e is [string, number] => typeof e[1] === \"number\"),\n  );\n}\n\n/**\n * The probability each statement is true, in order: from `file` when asked before, else from\n * `ask`, in requests of `PER_REQUEST` sent at once. Null when any request failed, so the caller\n * takes its fallback for the whole decision rather than half of it. Never throws.\n */\nexport async function rememberedNouls(\n  questions: readonly NoulQuestion[],\n  opts: { ask: AskNouls; file?: string },\n): Promise<number[] | null> {\n  if (questions.length === 0) return [];\n  const keys = questions.map(keyOf);\n  const known = opts.file ? await remembered(opts.file) : {};\n  const missing = [...new Set(keys.filter((k) => known[k] === undefined))];\n  const byKey = new Map(questions.map((q, i) => [keys[i], q]));\n  const batches: string[][] = [];\n  for (let i = 0; i < missing.length; i += PER_REQUEST) batches.push(missing.slice(i, i + PER_REQUEST));\n  const answered = await Promise.all(\n    batches.map((batch) => opts.ask(batch.flatMap((k) => byKey.get(k) ?? [])).catch(() => null)),\n  );\n  if (answered.some((a) => a === null || a.length === 0)) return null;\n  const fresh: Record<string, number> = {};\n  batches.forEach((batch, b) => {\n    batch.forEach((k, i) => {\n      const answer = answered[b]?.[i];\n      if (answer !== undefined) fresh[k] = answer;\n    });\n  });\n  const all = { ...known, ...fresh };\n  const file = opts.file;\n  if (file && missing.length > 0) {\n    // Read again under the lock: another caller sharing the file may have written its answers since.\n    await updateLockedFile(file, async () => {\n      const kept = Object.entries({ ...(await remembered(file)), ...fresh }).slice(-MAX_REMEMBERED);\n      return JSON.stringify(Object.fromEntries(kept));\n    }).catch(() => undefined);\n  }\n  const answers = keys.map((k) => all[k]);\n  return answers.every((a): a is number => a !== undefined) ? answers : null;\n}\n\n/** The real decision model, its spend reported to `onSpend`. */\nexport function jevAsker(onSpend?: (usage: ReviewUsage) => void): AskNouls {\n  return (questions) => askJev(questions, onSpend);\n}\n\n/** The real decision model behind the answers kept in `file`: what every CLI caller asks through. */\nexport function rememberedJev(file: string, onSpend?: (usage: ReviewUsage) => void): AskNouls {\n  const ask = jevAsker(onSpend);\n  return (questions) => rememberedNouls(questions, { ask, file });\n}\n","/**\n * Change a JSON file that several processes (or several calls in one) update at once: read,\n * change and write it whole under a lock file, through a temp file renamed into place, so no\n * writer erases another's entries and no reader sees half a file.\n */\nimport { randomUUID } from \"node:crypto\";\nimport { mkdir, rename, rm, stat, writeFile } from \"node:fs/promises\";\nimport path from \"node:path\";\n\nconst LOCK_STALE_MS = 10_000;\nconst LOCK_WAIT_MS = 20;\n\n/** Run `change` with `file` locked, and write what it returns as the file's whole new content. */\nexport async function updateLockedFile(file: string, change: () => Promise<string>): Promise<void> {\n  await mkdir(path.dirname(file), { recursive: true });\n  const lock = `${file}.lock`;\n  await acquireLock(lock);\n  try {\n    const temp = `${file}.${process.pid}.${randomUUID()}.tmp`;\n    await writeFile(temp, await change(), \"utf8\");\n    await rename(temp, file);\n  } finally {\n    await rm(lock, { force: true });\n  }\n}\n\nasync function acquireLock(lock: string): Promise<void> {\n  for (;;) {\n    try {\n      await writeFile(lock, String(process.pid), { flag: \"wx\" });\n      return;\n    } catch (e) {\n      if ((e as NodeJS.ErrnoException).code !== \"EEXIST\") throw e;\n    }\n    // A process that died holding the lock leaves it behind: a lock this old is no one's.\n    const held = await stat(lock).catch(() => null);\n    if (held && Date.now() - held.mtimeMs > LOCK_STALE_MS) await rm(lock, { force: true });\n    await new Promise((resolve) => setTimeout(resolve, LOCK_WAIT_MS));\n  }\n}\n"],"mappings":"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","names":[]}