cachelint 0.1.0

package/dist/chunk-2JSY5BQA.js

@@ -0,0 +1,340 @@
+import {
+  PRICING_AS_OF,
+  PRICING_TABLE_VERSION,
+  REFERENCE_MODEL,
+  referencePricing,
+  wastePerTokenUsd
+} from "./chunk-O7ZE6CFI.js";
+import {
+  requirePro
+} from "./chunk-GXASKZ4Z.js";
+import {
+  runRules
+} from "./chunk-WKFGRNYK.js";
+import {
+  COST_LINE_OVERLAPPED,
+  costLabel,
+  costLineAtRisk,
+  costLineInvalidates,
+  costLineWasted,
+  costSummary,
+  formatUsdPer1k
+} from "./chunk-VWE5TDL5.js";
+import {
+  resolveConfigArg,
+  resolveSources,
+  toPosixRelative
+} from "./chunk-MW7BXKPR.js";
+import {
+  DEFAULT_RULE_VOLATILITY,
+  isRuleId
+} from "./chunk-4GHSUBAY.js";
+import {
+  CACHELINT_VERSION,
+  COST_MODEL_VERSION
+} from "./chunk-WPJYUQMU.js";
+import {
+  ConfigError,
+  SourceError,
+  costUnavailableWarning,
+  diagnosticsExitCode,
+  redactSecrets
+} from "./chunk-XKRPGMZT.js";
+
+// src/commands/lint.ts
+import { extname, resolve as pathResolve } from "path";
+
+// src/rules/packs.ts
+var KNOWN_PACK_IDS = /* @__PURE__ */ new Set(["anthropic-2026-q1"]);
+
+// src/cost/estimate.ts
+var CHARS_PER_TOKEN = 4;
+function usdPer1kCalls(tokens, pricing) {
+  return tokens * wastePerTokenUsd(pricing) * 1e3;
+}
+function heuristicTokens(chars) {
+  return Math.ceil(chars / CHARS_PER_TOKEN);
+}
+function metricsOf(normalized) {
+  const lines = normalized === "" ? [] : normalized.slice(0, -1).split("\n");
+  const lineLengths = lines.map((l) => l.length);
+  const lineStarts = new Array(lineLengths.length);
+  let at = 0;
+  for (let i = 0; i < lineLengths.length; i++) {
+    lineStarts[i] = at;
+    at += lineLengths[i] + 1;
+  }
+  return { totalLength: normalized.length, lineLengths, lineStarts };
+}
+function normalizedOffsetFor(m, line, column) {
+  if (m.lineLengths.length === 0) return 0;
+  const idx = line - 1;
+  if (idx < 0) return 0;
+  if (idx >= m.lineLengths.length) return m.totalLength;
+  return m.lineStarts[idx] + Math.min(Math.max(column - 1, 0), m.lineLengths[idx]);
+}
+function volatilityOf(d) {
+  if (d.volatility !== void 0) return d.volatility;
+  return isRuleId(d.rule) ? DEFAULT_RULE_VOLATILITY[d.rule] : "regeneration";
+}
+function estimateCosts(diagnostics, normalizedTextByFile, pricing = referencePricing()) {
+  const metricsByFile = /* @__PURE__ */ new Map();
+  const metricsFor = (file) => {
+    const cached = metricsByFile.get(file);
+    if (cached !== void 0) return cached;
+    const text = normalizedTextByFile.get(file);
+    if (text === void 0) return null;
+    const m = metricsOf(text);
+    metricsByFile.set(file, m);
+    return m;
+  };
+  const computed = diagnostics.map((d) => {
+    const m = metricsFor(d.file);
+    if (m === null) return null;
+    const offset = normalizedOffsetFor(m, d.line, d.column);
+    const remainingChars = Math.max(0, m.totalLength - offset);
+    return {
+      file: d.file,
+      volatility: volatilityOf(d),
+      offset,
+      fromHereTokens: heuristicTokens(remainingChars)
+    };
+  });
+  const earliest = /* @__PURE__ */ new Map();
+  for (let i = 0; i < computed.length; i++) {
+    const c = computed[i];
+    if (c === null || c === void 0) continue;
+    const key = `${c.file}\0${c.volatility}`;
+    const prev = earliest.get(key);
+    if (prev === void 0 || c.offset < computed[prev].offset) earliest.set(key, i);
+  }
+  const perDiagnostic = computed.map((c, i) => {
+    if (c === null) return null;
+    const counts = earliest.get(`${c.file}\0${c.volatility}`) === i;
+    return {
+      fromHereTokens: c.fromHereTokens,
+      volatility: c.volatility,
+      countsTowardTotal: counts,
+      ...c.volatility === "per-call" ? { wastedUsdPer1kCalls: usdPer1kCalls(c.fromHereTokens, pricing) } : {}
+    };
+  });
+  const perFileTokens = /* @__PURE__ */ new Map();
+  for (const i of earliest.values()) {
+    const c = computed[i];
+    const agg = perFileTokens.get(c.file) ?? { wasted: 0, atRisk: 0 };
+    if (c.volatility === "per-call") agg.wasted = c.fromHereTokens;
+    else agg.atRisk = c.fromHereTokens;
+    perFileTokens.set(c.file, agg);
+  }
+  const perFile = /* @__PURE__ */ new Map();
+  let totalWasted = 0;
+  let totalAtRisk = 0;
+  for (const file of [...perFileTokens.keys()].sort()) {
+    const { wasted, atRisk } = perFileTokens.get(file);
+    perFile.set(file, {
+      wastedTokens: wasted,
+      wastedUsdPer1kCalls: usdPer1kCalls(wasted, pricing),
+      atRiskTokens: atRisk
+    });
+    totalWasted += wasted;
+    totalAtRisk += atRisk;
+  }
+  return {
+    perDiagnostic,
+    perFile,
+    totals: {
+      wastedTokens: totalWasted,
+      wastedUsdPer1kCalls: usdPer1kCalls(totalWasted, pricing),
+      atRiskTokens: totalAtRisk
+    }
+  };
+}
+
+// src/commands/lint.ts
+var GLOB_CHARS = /[*?[\]{}]/;
+function lint(args = {}) {
+  const root = pathResolve(args.projectRoot ?? process.cwd());
+  const { config, configPath } = resolveConfigArg(args.config, root);
+  const packLoaded = resolvePack(args.pack);
+  const cliPaths = args.paths ?? [];
+  const scanPaths = cliPaths.length > 0 ? [...cliPaths] : config.prompt_globs ?? [];
+  if (scanPaths.length === 0) {
+    throw new SourceError({
+      code: "SRC_NO_PATHS",
+      message: "no paths to lint: pass file/glob arguments, or set `prompt_globs` in cachelint.config",
+      hint: 'e.g. `cachelint lint prompts/system.md` or add `prompt_globs: ["prompts/**/*"]` to your config.'
+    });
+  }
+  const promptScoped = computePromptScopedSet(cliPaths, config, root);
+  const resolution = resolveSources({
+    paths: scanPaths,
+    projectRoot: root,
+    required: false,
+    ...config.exclude !== void 0 ? { exclude: config.exclude } : {},
+    ...config.max_file_bytes !== void 0 ? { maxFileBytes: config.max_file_bytes } : {},
+    ...config.max_total_bytes !== void 0 ? { maxTotalBytes: config.max_total_bytes } : {}
+  });
+  const inputs = resolution.sources.map((s) => ({
+    file: s.path,
+    raw: s.raw,
+    ext: extname(s.path).toLowerCase(),
+    bomByte: s.bomByte,
+    mixedLineEndings: s.mixedLineEndings,
+    promptScoped: promptScoped.has(s.path)
+  }));
+  const diagnostics = runRules(inputs, {
+    settings: {
+      ...config.disable !== void 0 ? { disable: config.disable } : {},
+      ...config.rules !== void 0 ? { rules: config.rules } : {}
+    }
+  });
+  const exitCode = diagnosticsExitCode(diagnostics, { strict: args.strict === true });
+  let cost;
+  if (args.cost !== false) {
+    try {
+      const normalizedTextByFile = new Map(resolution.sources.map((s) => [s.path, s.normalized]));
+      const estimate = estimateCosts(diagnostics, normalizedTextByFile);
+      if (estimate.perDiagnostic.length !== diagnostics.length) {
+        throw new Error(
+          `cost estimate misaligned: ${estimate.perDiagnostic.length} per-diagnostic entries for ${diagnostics.length} diagnostics`
+        );
+      }
+      const normalizedCharsByFile = {};
+      for (const path of [...normalizedTextByFile.keys()].sort()) {
+        normalizedCharsByFile[path] = (normalizedTextByFile.get(path) ?? "").length;
+      }
+      cost = {
+        costModelVersion: COST_MODEL_VERSION,
+        pricing: { tableVersion: PRICING_TABLE_VERSION, asOf: PRICING_AS_OF, referenceModel: REFERENCE_MODEL },
+        perDiagnostic: estimate.perDiagnostic,
+        totals: estimate.totals,
+        normalizedCharsByFile
+      };
+    } catch (err) {
+      resolution.warnings.push(costUnavailableWarning(err));
+    }
+  }
+  return {
+    version: CACHELINT_VERSION,
+    configPath,
+    packLoaded,
+    diagnostics,
+    warnings: resolution.warnings,
+    exitCode,
+    ...cost !== void 0 ? { cost } : {}
+  };
+}
+function resolvePack(pack) {
+  if (pack === void 0) return null;
+  requirePro("pack", `the --pack ${pack} bug-pattern pack`);
+  if (!KNOWN_PACK_IDS.has(pack)) {
+    throw new ConfigError({
+      code: "PRO_UNKNOWN_PACK",
+      message: `unknown pack "${pack}"`,
+      hint: `Known packs: ${[...KNOWN_PACK_IDS].join(", ")}.`
+    });
+  }
+  return pack;
+}
+function computePromptScopedSet(cliPaths, config, root) {
+  const set = /* @__PURE__ */ new Set();
+  for (const p of cliPaths) {
+    if (!GLOB_CHARS.test(p)) {
+      set.add(toPosixRelative(pathResolve(root, p), root));
+    }
+  }
+  if (config.prompt_globs && config.prompt_globs.length > 0) {
+    const r = resolveSources({ paths: config.prompt_globs, projectRoot: root, required: false });
+    for (const s of r.sources) set.add(s.path);
+  }
+  return set;
+}
+var COLORS = {
+  red: "\x1B[31m",
+  yellow: "\x1B[33m",
+  dim: "\x1B[2m",
+  bold: "\x1B[1m",
+  reset: "\x1B[0m"
+};
+function renderLintHuman(result, opts = {}) {
+  const color = opts.color === true;
+  const c = (code, s) => color ? code + s + COLORS.reset : s;
+  const lines = [];
+  if (result.packLoaded !== null) {
+    lines.push(c(COLORS.dim, `note  pack "${result.packLoaded}" loaded (no additional rules in this build yet)`));
+  }
+  for (const w of result.warnings) {
+    const where = w.path ? `${w.path}: ` : "";
+    lines.push(`${c(COLORS.dim, "note")}  ${where}${w.message}`);
+  }
+  if ((result.warnings.length > 0 || result.packLoaded !== null) && result.diagnostics.length > 0) lines.push("");
+  const label = result.cost !== void 0 ? costLabel({ model: result.cost.pricing.referenceModel }, result.cost.pricing.asOf) : "";
+  let errors = 0;
+  let warns = 0;
+  for (let i = 0; i < result.diagnostics.length; i++) {
+    const d = result.diagnostics[i];
+    if (d.severity === "error") errors++;
+    else warns++;
+    const level = d.severity === "error" ? c(COLORS.red, "error  ") : c(COLORS.yellow, "warning");
+    lines.push(`${c(COLORS.bold, `${d.file}:${d.line}:${d.column}`)}  ${level}  ${d.rule}  ${d.message}`);
+    if (d.snippet) lines.push(`  ${c(COLORS.dim, "\u203A " + d.snippet)}`);
+    if (d.fixHint) lines.push(`  ${c(COLORS.dim, "fix:")} ${d.fixHint}`);
+    if (d.whyUrl) lines.push(`  ${c(COLORS.dim, "why:")} ${d.whyUrl}`);
+    const dc = result.cost?.perDiagnostic[i] ?? null;
+    if (dc !== null) {
+      if (!dc.countsTowardTotal) {
+        lines.push(`  ${c(COLORS.dim, COST_LINE_OVERLAPPED)}`);
+      } else if (dc.volatility === "per-call") {
+        lines.push(`  ${c(COLORS.dim, costLineInvalidates(dc.fromHereTokens))}`);
+        const usd = dc.wastedUsdPer1kCalls !== void 0 ? formatUsdPer1k(dc.wastedUsdPer1kCalls) : null;
+        if (usd !== null) lines.push(`  ${c(COLORS.dim, costLineWasted(usd, label))}`);
+      } else {
+        lines.push(`  ${c(COLORS.dim, costLineAtRisk(dc.fromHereTokens))}`);
+      }
+    }
+  }
+  if (result.diagnostics.length === 0) {
+    lines.push(c(COLORS.dim, "cachelint: no problems found."));
+  } else {
+    lines.push("");
+    const parts = [];
+    if (errors > 0) parts.push(`${errors} error${errors === 1 ? "" : "s"}`);
+    if (warns > 0) parts.push(`${warns} warning${warns === 1 ? "" : "s"}`);
+    const total = result.diagnostics.length;
+    lines.push(`cachelint: ${total} problem${total === 1 ? "" : "s"} (${parts.join(", ")})`);
+    if (result.cost !== void 0) {
+      const summary = costSummary(result.cost.totals, label);
+      if (summary !== null) lines.push(`cachelint: ${summary}`);
+    }
+  }
+  return redactSecrets(lines.join("\n"));
+}
+function renderLintJson(result) {
+  return redactSecrets(
+    JSON.stringify(
+      {
+        version: result.version,
+        configPath: result.configPath,
+        packLoaded: result.packLoaded,
+        exitCode: result.exitCode,
+        diagnostics: result.diagnostics,
+        warnings: result.warnings,
+        // R4: present only when cost was computed — `--no-cost` omits the
+        // block by construction (it's absent from the result itself).
+        ...result.cost !== void 0 ? { cost: result.cost } : {}
+      },
+      null,
+      2
+    )
+  ) + "\n";
+}
+
+export {
+  KNOWN_PACK_IDS,
+  usdPer1kCalls,
+  heuristicTokens,
+  estimateCosts,
+  lint,
+  renderLintHuman,
+  renderLintJson
+};

package/dist/chunk-4GHSUBAY.js

@@ -0,0 +1,28 @@
+// src/rules/ids.ts
+var RULE_IDS = ["R001", "R002", "R003", "R004", "R005"];
+var DEFAULT_RULE_SEVERITY = {
+  R001: "warn",
+  R002: "warn",
+  R003: "warn",
+  R004: "error",
+  R005: "error"
+};
+var DEFAULT_RULE_VOLATILITY = {
+  R001: "per-call",
+  R002: "per-call",
+  R003: "regeneration",
+  R004: "regeneration",
+  R005: "regeneration"
+};
+var RULE_SEVERITY_VALUES = ["off", "warn", "error"];
+function isRuleId(s) {
+  return RULE_IDS.includes(s);
+}
+
+export {
+  RULE_IDS,
+  DEFAULT_RULE_SEVERITY,
+  DEFAULT_RULE_VOLATILITY,
+  RULE_SEVERITY_VALUES,
+  isRuleId
+};

package/dist/chunk-4LB5LF2P.js

@@ -0,0 +1,51 @@
+// src/license/store.ts
+import { homedir } from "os";
+import { join } from "path";
+import { readFileSync, writeFileSync, mkdirSync, rmSync, existsSync } from "fs";
+var ENV_VAR = "CACHELINT_LICENSE_KEY";
+function licenseFilePath() {
+  if (process.platform === "win32") {
+    const appData = process.env["APPDATA"] ?? join(homedir(), "AppData", "Roaming");
+    return join(appData, "cachelint", "license");
+  }
+  const xdg = process.env["XDG_CONFIG_HOME"];
+  const base = xdg !== void 0 && xdg.trim() !== "" ? xdg : join(homedir(), ".config");
+  return join(base, "cachelint", "license");
+}
+function readStoredLicense() {
+  const env = process.env[ENV_VAR];
+  if (env !== void 0 && env.trim() !== "") return { token: env.trim(), source: `env ${ENV_VAR}` };
+  const path = licenseFilePath();
+  if (!existsSync(path)) return null;
+  try {
+    const token = readFileSync(path, "utf8").trim();
+    if (token === "") return null;
+    return { token, source: path };
+  } catch {
+    return null;
+  }
+}
+function writeStoredLicense(token) {
+  const path = licenseFilePath();
+  mkdirSync(join(path, ".."), { recursive: true });
+  writeFileSync(path, token.trim() + "\n", { encoding: "utf8", mode: 384 });
+  return path;
+}
+function clearStoredLicense() {
+  const path = licenseFilePath();
+  if (!existsSync(path)) return false;
+  rmSync(path, { force: true });
+  return true;
+}
+function hasEnvLicense() {
+  const env = process.env[ENV_VAR];
+  return env !== void 0 && env.trim() !== "";
+}
+
+export {
+  licenseFilePath,
+  readStoredLicense,
+  writeStoredLicense,
+  clearStoredLicense,
+  hasEnvLicense
+};

package/dist/chunk-BUZCVKMZ.js

@@ -0,0 +1,246 @@
+import {
+  bundleHash,
+  resolveSources
+} from "./chunk-MW7BXKPR.js";
+import {
+  CACHELINT_VERSION,
+  NORMALIZATION_POLICY_VERSION,
+  RULE_TABLE_VERSION
+} from "./chunk-WPJYUQMU.js";
+import {
+  LockCorruptError,
+  SourceError
+} from "./chunk-XKRPGMZT.js";
+
+// src/commands/bundles.ts
+import { resolve as pathResolve } from "path";
+function computeBundles(args) {
+  const root = pathResolve(args.projectRoot);
+  const cfg = args.config;
+  const warnings = [];
+  const byName = /* @__PURE__ */ new Map();
+  const add = (b) => {
+    if (byName.has(b.name)) {
+      throw new SourceError({
+        code: "BUNDLE_NAME_COLLISION",
+        message: `two bundles resolve to the same name "${b.name}"`,
+        hint: "Rename a config bundle, or don't list a file path that collides with a config bundle name."
+      });
+    }
+    byName.set(b.name, b);
+  };
+  const cliPaths = args.paths ?? [];
+  const oneFilePaths = cliPaths.length > 0 ? [...cliPaths] : cfg.prompt_globs ?? [];
+  if (oneFilePaths.length > 0) {
+    const r = resolveSources({
+      paths: oneFilePaths,
+      projectRoot: root,
+      required: false,
+      ...cfg.exclude !== void 0 ? { exclude: cfg.exclude } : {},
+      ...cfg.max_file_bytes !== void 0 ? { maxFileBytes: cfg.max_file_bytes } : {},
+      ...cfg.max_total_bytes !== void 0 ? { maxTotalBytes: cfg.max_total_bytes } : {}
+    });
+    warnings.push(...r.warnings);
+    for (const s of r.sources) {
+      add({ name: s.path, files: [{ path: s.path, sha256: s.sha256 }], stablePrefixHash: bundleHash([s.sha256]) });
+    }
+  }
+  for (const b of cfg.bundles ?? []) {
+    const files = [];
+    for (const entry of b.files) {
+      const r = resolveSources({
+        paths: [entry],
+        projectRoot: root,
+        required: true,
+        name: b.name,
+        ...cfg.exclude !== void 0 ? { exclude: cfg.exclude } : {},
+        ...cfg.max_file_bytes !== void 0 ? { maxFileBytes: cfg.max_file_bytes } : {},
+        ...cfg.max_total_bytes !== void 0 ? { maxTotalBytes: cfg.max_total_bytes } : {}
+      });
+      warnings.push(...r.warnings);
+      if (r.sources.length === 0) {
+        throw new SourceError({
+          code: "BUNDLE_ENTRY_EMPTY",
+          message: `bundle "${b.name}": entry "${entry}" matched no readable text files`,
+          hint: "Fix the path/glob, or remove it from the bundle."
+        });
+      }
+      for (const s of r.sources) files.push({ path: s.path, sha256: s.sha256 });
+    }
+    add({ name: b.name, files, stablePrefixHash: bundleHash(files.map((f) => f.sha256)) });
+  }
+  if (byName.size === 0) {
+    throw new SourceError({
+      code: "NO_BUNDLES",
+      message: "nothing to hash: pass file/glob arguments, or set `prompt_globs` / `bundles` in cachelint.config",
+      hint: 'e.g. `cachelint hash prompts/system.md`, or add `bundles: [{ name: "system", files: [...] }]`.'
+    });
+  }
+  return { bundles: [...byName.values()].sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0), warnings };
+}
+
+// src/lockfile/format.ts
+import { writeFileSync, renameSync, rmSync, readFileSync, mkdirSync, existsSync } from "fs";
+import { dirname, basename, join } from "path";
+var LOCKFILE_FORMAT_VERSION = 1;
+var DEFAULT_LOCKFILE_NAME = "cachelint.lock";
+function makeLockfile(bundles) {
+  const sorted = [...bundles].sort((a, b) => cmpCodepoint(a.name, b.name));
+  return {
+    version: LOCKFILE_FORMAT_VERSION,
+    cachelintVersion: CACHELINT_VERSION,
+    normalizationPolicyVersion: NORMALIZATION_POLICY_VERSION,
+    ruleTableVersion: RULE_TABLE_VERSION,
+    bundles: sorted
+  };
+}
+function canonicalJsonStringify(value) {
+  const json = JSON.stringify(sortKeysDeep(value), jsonReplacerForNumbers, 2);
+  let out = "";
+  for (let i = 0; i < json.length; i++) {
+    const code = json.charCodeAt(i);
+    out += code <= 127 ? json.charAt(i) : "\\u" + code.toString(16).padStart(4, "0");
+  }
+  return out;
+}
+function serializeLockfile(lock) {
+  return canonicalJsonStringify(lock);
+}
+function jsonReplacerForNumbers(_key, val) {
+  if (typeof val === "number" && !Number.isInteger(val)) {
+    throw new LockCorruptError(`refusing to serialize a non-integer number (${val}) into the lockfile`);
+  }
+  return val;
+}
+function sortKeysDeep(v) {
+  if (Array.isArray(v)) return v.map(sortKeysDeep);
+  if (v !== null && typeof v === "object") {
+    const src = v;
+    const out = {};
+    for (const k of Object.keys(src).sort(cmpCodepoint)) out[k] = sortKeysDeep(src[k]);
+    return out;
+  }
+  return v;
+}
+function cmpCodepoint(a, b) {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+function parseLockfile(text, label = DEFAULT_LOCKFILE_NAME) {
+  let data;
+  try {
+    data = JSON.parse(text);
+  } catch (err) {
+    throw new LockCorruptError(
+      `${label} is not valid JSON: ${err instanceof Error ? err.message : String(err)}`,
+      "Re-generate it with `cachelint hash \u2026` and commit the result."
+    );
+  }
+  if (typeof data !== "object" || data === null || Array.isArray(data)) {
+    throw new LockCorruptError(`${label} is not an object`);
+  }
+  const o = data;
+  const version = o["version"];
+  if (typeof version !== "number") throw new LockCorruptError(`${label}: missing/invalid "version"`);
+  if (version !== LOCKFILE_FORMAT_VERSION) {
+    throw new LockCorruptError(
+      `${label}: lockfile format version ${version} is not supported by this cachelint (expects ${LOCKFILE_FORMAT_VERSION})`,
+      "Upgrade or downgrade cachelint, or re-run `cachelint hash` with this version and commit."
+    );
+  }
+  const cachelintVersion = typeof o["cachelintVersion"] === "string" ? o["cachelintVersion"] : "";
+  const npv = o["normalizationPolicyVersion"];
+  const rtv = o["ruleTableVersion"];
+  if (typeof npv !== "number" || typeof rtv !== "number") {
+    throw new LockCorruptError(`${label}: missing/invalid policy version fields`);
+  }
+  const bundlesRaw = o["bundles"];
+  if (!Array.isArray(bundlesRaw)) throw new LockCorruptError(`${label}: "bundles" must be an array`);
+  const bundles = bundlesRaw.map((b, i) => parseBundle(b, `${label}: bundles[${i}]`));
+  return {
+    version,
+    cachelintVersion,
+    normalizationPolicyVersion: npv,
+    ruleTableVersion: rtv,
+    bundles
+  };
+}
+function parseBundle(b, where) {
+  if (typeof b !== "object" || b === null || Array.isArray(b)) throw new LockCorruptError(`${where}: not an object`);
+  const o = b;
+  const name = o["name"];
+  const stablePrefixHash = o["stablePrefixHash"];
+  const filesRaw = o["files"];
+  if (typeof name !== "string" || name.length === 0) throw new LockCorruptError(`${where}: missing "name"`);
+  if (!isSha256Hex(stablePrefixHash)) throw new LockCorruptError(`${where}: missing/invalid "stablePrefixHash"`);
+  if (!Array.isArray(filesRaw)) throw new LockCorruptError(`${where}: "files" must be an array`);
+  const files = filesRaw.map((f, i) => {
+    if (typeof f !== "object" || f === null) throw new LockCorruptError(`${where}.files[${i}]: not an object`);
+    const fo = f;
+    const p = fo["path"];
+    const h = fo["sha256"];
+    if (typeof p !== "string" || p.length === 0) throw new LockCorruptError(`${where}.files[${i}]: missing "path"`);
+    if (!isSha256Hex(h)) throw new LockCorruptError(`${where}.files[${i}]: missing/invalid "sha256"`);
+    return { path: p, sha256: h };
+  });
+  return { name, files, stablePrefixHash };
+}
+function isSha256Hex(v) {
+  return typeof v === "string" && /^[0-9a-f]{64}$/.test(v);
+}
+function readLockfileIfExists(path) {
+  let text;
+  try {
+    text = readFileSync(path, "utf8");
+  } catch (err) {
+    if (err?.code === "ENOENT") return null;
+    throw new LockCorruptError(`cannot read ${basename(path)}: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  return parseLockfile(text, basename(path));
+}
+function writeLockfileAtomic(path, lock) {
+  const text = serializeLockfile(lock);
+  const dir = dirname(path);
+  mkdirSync(dir, { recursive: true });
+  const tmp = join(dir, `.${basename(path)}.${process.pid}.tmp`);
+  const bak = join(dir, `.${basename(path)}.${process.pid}.bak`);
+  writeFileSync(tmp, text, { encoding: "utf8" });
+  try {
+    renameSync(tmp, path);
+    return text;
+  } catch {
+  }
+  let movedAside = false;
+  try {
+    if (existsSync(path)) {
+      renameSync(path, bak);
+      movedAside = true;
+    }
+    renameSync(tmp, path);
+    if (movedAside) rmSync(bak, { force: true });
+    return text;
+  } catch (err) {
+    if (movedAside && existsSync(bak) && !existsSync(path)) {
+      try {
+        renameSync(bak, path);
+      } catch {
+      }
+    }
+    rmSync(tmp, { force: true });
+    throw new LockCorruptError(
+      `could not write ${basename(path)} atomically: ${err instanceof Error ? err.message : String(err)}`,
+      "Check write permissions on the directory; the previous cachelint.lock (if any) was preserved."
+    );
+  }
+}
+
+export {
+  computeBundles,
+  LOCKFILE_FORMAT_VERSION,
+  DEFAULT_LOCKFILE_NAME,
+  makeLockfile,
+  canonicalJsonStringify,
+  serializeLockfile,
+  parseLockfile,
+  readLockfileIfExists,
+  writeLockfileAtomic
+};