npm - @emeryld/rrroutes-export - Versions diffs - 1.0.3 → 1.0.5 - Mend

@emeryld/rrroutes-export 1.0.3 → 1.0.5

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (18) hide show

package/README.md +132 -3
package/bin/rrroutes-export-changelog.mjs +16 -0
package/dist/defaultViewerTemplate.d.ts +1 -0
package/dist/exportFinalizedLeaves.changelog.cli.d.ts +15 -0
package/dist/exportFinalizedLeaves.changelog.d.ts +145 -0
package/dist/exportFinalizedLeaves.cli.d.ts +14 -0
package/dist/exportFinalizedLeaves.d.ts +61 -0
package/dist/extractLeafSourceByAst.d.ts +38 -0
package/dist/flattenSchema.d.ts +12 -0
package/dist/index.cjs +882 -14
package/dist/index.cjs.map +1 -1
package/dist/index.d.ts +9 -0
package/dist/index.mjs +877 -14
package/dist/index.mjs.map +1 -1
package/dist/schemaIntrospection.d.ts +47 -0
package/dist/serializeLeafContract.d.ts +31 -0
package/package.json +10 -5
package/tools/finalized-leaves-viewer.html +129 -1

package/dist/index.cjs CHANGED Viewed

@@ -31,20 +31,25 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   DEFAULT_VIEWER_TEMPLATE: () => DEFAULT_VIEWER_TEMPLATE,
+  __private: () => __private,
   clearSchemaIntrospectionHandlers: () => clearSchemaIntrospectionHandlers,
   createSchemaIntrospector: () => createSchemaIntrospector,
   exportFinalizedLeaves: () => exportFinalizedLeaves,
+  exportFinalizedLeavesChangelog: () => exportFinalizedLeavesChangelog,
   extractLeafSourceByAst: () => extractLeafSourceByAst,
   flattenLeafSchemas: () => flattenLeafSchemas,
   flattenSerializableSchema: () => flattenSerializableSchema,
   introspectSchema: () => introspectSchema,
   loadFinalizedLeavesInput: () => loadFinalizedLeavesInput,
+  parseFinalizedLeavesChangelogCliArgs: () => parseFinalizedLeavesChangelogCliArgs,
   parseFinalizedLeavesCliArgs: () => parseFinalizedLeavesCliArgs,
   registerSchemaIntrospectionHandler: () => registerSchemaIntrospectionHandler,
+  runExportFinalizedLeavesChangelogCli: () => runExportFinalizedLeavesChangelogCli,
   runExportFinalizedLeavesCli: () => runExportFinalizedLeavesCli,
   serializableSchemaKinds: () => serializableSchemaKinds,
   serializeLeafContract: () => serializeLeafContract,
   serializeLeavesContract: () => serializeLeavesContract,
+  writeFinalizedLeavesChangelogExport: () => writeFinalizedLeavesChangelogExport,
   writeFinalizedLeavesExport: () => writeFinalizedLeavesExport
 });
 module.exports = __toCommonJS(index_exports);
@@ -345,46 +350,46 @@ function normalizeType(schema) {
       return "unknown";
   }
 }
-function isNonEmptyPath(path4) {
-  return typeof path4 === "string" && path4.length > 0;
+function isNonEmptyPath(path6) {
+  return typeof path6 === "string" && path6.length > 0;
 }
-function setNode(out, path4, schema, inherited) {
-  if (!isNonEmptyPath(path4)) return;
-  out[path4] = {
+function setNode(out, path6, schema, inherited) {
+  if (!isNonEmptyPath(path6)) return;
+  out[path6] = {
     type: normalizeType(schema),
     nullable: inherited.nullable || Boolean(schema.nullable),
     optional: inherited.optional || Boolean(schema.optional),
     literal: schema.kind === "literal" ? schema.literal : void 0
   };
 }
-function flattenInto(out, schema, path4, inherited) {
-  if (!schema || !isNonEmptyPath(path4)) return;
+function flattenInto(out, schema, path6, inherited) {
+  if (!schema || !isNonEmptyPath(path6)) return;
   const nextInherited = {
     optional: inherited.optional || Boolean(schema.optional),
     nullable: inherited.nullable || Boolean(schema.nullable)
   };
   if (schema.kind === "union" && Array.isArray(schema.union) && schema.union.length > 0) {
     schema.union.forEach((option, index) => {
-      const optionPath = `${path4}-${index + 1}`;
+      const optionPath = `${path6}-${index + 1}`;
       flattenInto(out, option, optionPath, inherited);
     });
     return;
   }
-  setNode(out, path4, schema, inherited);
+  setNode(out, path6, schema, inherited);
   if (schema.kind === "object" && schema.properties) {
     for (const [key, child] of Object.entries(schema.properties)) {
-      const childPath = `${path4}.${key}`;
+      const childPath = `${path6}.${key}`;
       flattenInto(out, child, childPath, nextInherited);
     }
     return;
   }
   if (schema.kind === "array" && schema.element) {
-    flattenInto(out, schema.element, `${path4}[]`, nextInherited);
+    flattenInto(out, schema.element, `${path6}[]`, nextInherited);
   }
 }
-function flattenSerializableSchema(schema, path4) {
+function flattenSerializableSchema(schema, path6) {
   const out = {};
-  flattenInto(out, schema, path4, { optional: false, nullable: false });
+  flattenInto(out, schema, path6, { optional: false, nullable: false });
   return out;
 }
 function isSerializedLeaf(value) {
@@ -457,7 +462,27 @@ var DEFAULT_VIEWER_TEMPLATE = `<!doctype html>
       const resultsEl = document.getElementById('results')
       const payload = window.__FINALIZED_LEAVES_PAYLOAD
-      if (!payload || !Array.isArray(payload.leaves)) {
+      if (payload && payload.kind === 'finalized-leaves-changelog') {
+        statusEl.textContent =
+          'Loaded changelog payload with ' + (payload.commits?.length || 0) + ' commits.'
+        const wrapSection = (title, value) => {
+          const card = document.createElement('details')
+          const summary = document.createElement('summary')
+          summary.textContent = title
+          const pre = document.createElement('pre')
+          pre.textContent = JSON.stringify(value, null, 2)
+          card.appendChild(summary)
+          card.appendChild(pre)
+          return card
+        }
+        resultsEl.appendChild(wrapSection('Commits', payload.commits || []))
+        resultsEl.appendChild(wrapSection('By Route', payload.byRoute || {}))
+        resultsEl.appendChild(
+          wrapSection('By Source Object', payload.bySourceObject || {}),
+        )
+      } else if (!payload || !Array.isArray(payload.leaves)) {
         statusEl.textContent = 'No baked payload found in this HTML file.'
       } else {
         statusEl.textContent =           'Loaded baked payload with ' + payload.leaves.length + ' routes.'
@@ -1364,23 +1389,866 @@ async function runExportFinalizedLeavesCli(argv) {
     outFile: import_node_path3.default.resolve(args.outFile)
   };
 }
+// src/exportFinalizedLeaves.changelog.ts
+var import_promises2 = __toESM(require("fs/promises"), 1);
+var import_node_os = __toESM(require("os"), 1);
+var import_node_path4 = __toESM(require("path"), 1);
+var import_node_child_process2 = require("child_process");
+var import_node_util = require("util");
+var import_node_url2 = require("url");
+var execFile = (0, import_node_util.promisify)(import_node_child_process2.execFile);
+var CHANGESET_CFG_FIELDS = [
+  "summary",
+  "description",
+  "tags",
+  "deprecated",
+  "stability",
+  "docsGroup",
+  "docsHidden",
+  "feed"
+];
+var SCHEMA_SECTIONS = ["params", "query", "body", "output"];
+var SOURCE_KEY_BY_SECTION = {
+  params: "paramsSchema",
+  query: "querySchema",
+  body: "bodySchema",
+  output: "outputSchema"
+};
+function normalizePath(p) {
+  return p.replace(/\\/g, "/");
+}
+function stableStringify(value) {
+  return JSON.stringify(value, (_key, v) => {
+    if (v && typeof v === "object" && !Array.isArray(v)) {
+      const sorted = Object.entries(v).sort(([a], [b]) => a.localeCompare(b)).reduce((acc, [k, inner]) => {
+        acc[k] = inner;
+        return acc;
+      }, {});
+      return sorted;
+    }
+    return v;
+  });
+}
+function sanitizeCfgValue(value) {
+  if (Array.isArray(value)) {
+    return value.slice().sort((a, b) => String(a).localeCompare(String(b)));
+  }
+  return value;
+}
+function toCfgSubset(cfg) {
+  const out = {};
+  for (const field of CHANGESET_CFG_FIELDS) {
+    const value = sanitizeCfgValue(cfg[field]);
+    if (value !== void 0) {
+      out[field] = value;
+    }
+  }
+  return out;
+}
+function entrySignature(entry) {
+  return stableStringify({
+    type: entry.type,
+    nullable: Boolean(entry.nullable),
+    optional: Boolean(entry.optional),
+    literal: entry.literal
+  });
+}
+function semverToTuple(tag) {
+  const match = tag.match(/^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/);
+  if (!match) return null;
+  return {
+    major: Number(match[1]),
+    minor: Number(match[2]),
+    patch: Number(match[3]),
+    prerelease: match[4] ?? ""
+  };
+}
+function compareSemverTags(a, b) {
+  const av = semverToTuple(a);
+  const bv = semverToTuple(b);
+  if (!av && !bv) return 0;
+  if (!av) return -1;
+  if (!bv) return 1;
+  if (av.major !== bv.major) return av.major - bv.major;
+  if (av.minor !== bv.minor) return av.minor - bv.minor;
+  if (av.patch !== bv.patch) return av.patch - bv.patch;
+  if (!av.prerelease && bv.prerelease) return 1;
+  if (av.prerelease && !bv.prerelease) return -1;
+  return av.prerelease.localeCompare(bv.prerelease);
+}
+async function runGit(cwd, args) {
+  const { stdout } = await execFile("git", args, { cwd });
+  return stdout.trim();
+}
+async function resolveCommit(cwd, rev) {
+  return runGit(cwd, ["rev-parse", "--verify", `${rev}^{commit}`]);
+}
+async function findLastReachableSemverTag(cwd, to) {
+  const tagsRaw = await runGit(cwd, ["tag", "--merged", to]);
+  const tags = tagsRaw.split("\n").map((item) => item.trim()).filter(Boolean).filter((tag) => semverToTuple(tag) !== null);
+  if (tags.length === 0) {
+    return void 0;
+  }
+  tags.sort(compareSemverTags);
+  return tags[tags.length - 1];
+}
+async function findDefaultFromCommit(cwd, toCommit) {
+  const tag = await findLastReachableSemverTag(cwd, toCommit);
+  if (tag) {
+    return resolveCommit(cwd, tag);
+  }
+  const root = await runGit(cwd, ["rev-list", "--max-parents=0", toCommit]);
+  const rootCommit = root.split("\n").map((item) => item.trim()).filter(Boolean)[0];
+  if (!rootCommit) {
+    throw new Error("Failed to resolve a baseline commit for changelog generation.");
+  }
+  return rootCommit;
+}
+async function resolveCommitWindow(cwd, from, to) {
+  const toCommit = await resolveCommit(cwd, to ?? "HEAD");
+  const fromCommit = from ? await resolveCommit(cwd, from) : await findDefaultFromCommit(cwd, toCommit);
+  return { from: fromCommit, to: toCommit };
+}
+async function resolveCommitPath(cwd, fromCommit, toCommit) {
+  if (fromCommit === toCommit) {
+    return [toCommit];
+  }
+  const pathRaw = await runGit(cwd, [
+    "rev-list",
+    "--reverse",
+    "--ancestry-path",
+    `${fromCommit}..${toCommit}`
+  ]);
+  const commits = pathRaw.split("\n").map((item) => item.trim()).filter(Boolean);
+  return [fromCommit, ...commits];
+}
+function parentDirectories(relativePath) {
+  const clean = normalizePath(relativePath).replace(/^\/+/, "");
+  const dir = import_node_path4.default.posix.dirname(clean);
+  if (!dir || dir === ".") return [];
+  const parts = dir.split("/");
+  const out = [];
+  for (let i = parts.length; i > 0; i -= 1) {
+    out.push(parts.slice(0, i).join("/"));
+  }
+  return out;
+}
+function buildRelevantConfigFiles(moduleRel, tsconfigRel) {
+  const dirs = new Set(parentDirectories(moduleRel));
+  if (tsconfigRel) {
+    parentDirectories(tsconfigRel).forEach((item) => dirs.add(item));
+    dirs.add(import_node_path4.default.posix.dirname(normalizePath(tsconfigRel)));
+  }
+  const files = /* @__PURE__ */ new Set(["pnpm-workspace.yaml"]);
+  for (const dir of dirs) {
+    if (!dir || dir === ".") continue;
+    files.add(`${dir}/package.json`);
+    files.add(`${dir}/tsconfig.json`);
+  }
+  return files;
+}
+async function commitTouchedRelevantPaths(cwd, commit, moduleRel, tsconfigRel) {
+  const changed = await runGit(cwd, [
+    "show",
+    "--pretty=format:",
+    "--name-only",
+    "--diff-filter=ACMRTUXB",
+    commit
+  ]);
+  const changedFiles = changed.split("\n").map((item) => normalizePath(item.trim()).replace(/^\/+/, "")).filter(Boolean);
+  const moduleFile = normalizePath(moduleRel).replace(/^\/+/, "");
+  const moduleDir = normalizePath(import_node_path4.default.posix.dirname(moduleFile)).replace(/^\/+/, "");
+  const tsconfigFile = tsconfigRel ? normalizePath(tsconfigRel).replace(/^\/+/, "") : void 0;
+  const configFiles = buildRelevantConfigFiles(moduleFile, tsconfigFile);
+  return changedFiles.some((file) => {
+    if (file === moduleFile) return true;
+    if (moduleDir && moduleDir !== "." && (file === moduleDir || file.startsWith(`${moduleDir}/`))) {
+      return true;
+    }
+    if (tsconfigFile && file === tsconfigFile) return true;
+    return configFiles.has(file);
+  });
+}
+async function filterCommits(cwd, commits, moduleRel, tsconfigRel) {
+  if (commits.length <= 1) {
+    return commits;
+  }
+  const keep = [commits[0]];
+  for (let i = 1; i < commits.length; i += 1) {
+    const commit = commits[i];
+    if (await commitTouchedRelevantPaths(cwd, commit, moduleRel, tsconfigRel)) {
+      keep.push(commit);
+    }
+  }
+  const tip = commits[commits.length - 1];
+  if (!keep.includes(tip)) {
+    keep.push(tip);
+  }
+  return keep;
+}
+async function getCommitMetadata(cwd, commit) {
+  const out = await runGit(cwd, ["show", "-s", "--format=%H%x1f%aI%x1f%s", commit]);
+  const [sha, authorDate, subject] = out.split("");
+  if (!sha || !authorDate) {
+    throw new Error(`Unable to read commit metadata for ${commit}`);
+  }
+  return {
+    sha,
+    authorDate,
+    subject: subject ?? ""
+  };
+}
+function buildSourceIdentity(section, value) {
+  const sourceName = typeof value.sourceName === "string" ? value.sourceName : void 0;
+  const tag = typeof value.tag === "string" ? value.tag : void 0;
+  const file = typeof value.file === "string" ? value.file : void 0;
+  const line = typeof value.line === "number" ? value.line : void 0;
+  const column = typeof value.column === "number" ? value.column : void 0;
+  const fallbackName = sourceName ?? tag ?? section;
+  const suffix = file ? `${file}:${line ?? 1}:${column ?? 1}` : `${section}:unknown`;
+  return {
+    id: sourceName ?? `${fallbackName}@${suffix}`,
+    displayName: sourceName ?? `${fallbackName} (${suffix})`,
+    sourceName,
+    tag,
+    file,
+    line,
+    column
+  };
+}
+function asRecord(value) {
+  return value && typeof value === "object" ? value : {};
+}
+function toRouteSnapshots(payload) {
+  const routes = {};
+  for (const leaf of payload.leaves) {
+    const flatSchema = payload.schemaFlatByLeaf[leaf.key] ?? {};
+    const cfg = toCfgSubset(asRecord(leaf.cfg));
+    const sourceLeaf = payload.sourceByLeaf?.[leaf.key];
+    const sourceSchemas = sourceLeaf?.schemas;
+    const sourceBySection = {};
+    for (const section of SCHEMA_SECTIONS) {
+      const schemaKey = SOURCE_KEY_BY_SECTION[section];
+      const sectionSource = sourceSchemas?.[schemaKey];
+      if (!sectionSource || typeof sectionSource !== "object") continue;
+      sourceBySection[section] = buildSourceIdentity(
+        section,
+        sectionSource
+      );
+    }
+    routes[leaf.key] = {
+      key: leaf.key,
+      method: String(leaf.method).toUpperCase(),
+      path: leaf.path,
+      cfg,
+      flatSchema,
+      sourceBySection
+    };
+  }
+  return routes;
+}
+function sectionPathEntries(flatSchema, section) {
+  return Object.entries(flatSchema).filter(
+    ([schemaPath]) => schemaPath === section || schemaPath.startsWith(`${section}.`) || schemaPath.startsWith(`${section}[]`)
+  );
+}
+function toSourceObjectSnapshots(routesByKey) {
+  const working = /* @__PURE__ */ new Map();
+  for (const route of Object.values(routesByKey)) {
+    for (const section of SCHEMA_SECTIONS) {
+      const sourceIdentity = route.sourceBySection[section];
+      if (!sourceIdentity) continue;
+      const entries = sectionPathEntries(route.flatSchema, section);
+      if (entries.length === 0) continue;
+      const existing = working.get(sourceIdentity.id) ?? {
+        id: sourceIdentity.id,
+        displayName: sourceIdentity.displayName,
+        routeKeys: /* @__PURE__ */ new Set(),
+        sections: {
+          params: /* @__PURE__ */ new Map(),
+          query: /* @__PURE__ */ new Map(),
+          body: /* @__PURE__ */ new Map(),
+          output: /* @__PURE__ */ new Map()
+        }
+      };
+      existing.routeKeys.add(route.key);
+      for (const [schemaPath, schemaEntry] of entries) {
+        const sectionMap = existing.sections[section];
+        const signatures = sectionMap.get(schemaPath) ?? /* @__PURE__ */ new Set();
+        signatures.add(entrySignature(schemaEntry));
+        sectionMap.set(schemaPath, signatures);
+      }
+      working.set(sourceIdentity.id, existing);
+    }
+  }
+  const out = {};
+  for (const [id, item] of working.entries()) {
+    const sections = {
+      params: {},
+      query: {},
+      body: {},
+      output: {}
+    };
+    for (const section of SCHEMA_SECTIONS) {
+      for (const [schemaPath, signatures] of item.sections[section].entries()) {
+        sections[section][schemaPath] = Array.from(signatures).sort();
+      }
+    }
+    out[id] = {
+      id,
+      displayName: item.displayName,
+      routeKeys: Array.from(item.routeKeys).sort(),
+      sections
+    };
+  }
+  return out;
+}
+function diffRouteSchemas(before, after) {
+  const paths = /* @__PURE__ */ new Set([...Object.keys(before), ...Object.keys(after)]);
+  const out = [];
+  for (const schemaPath of Array.from(paths).sort()) {
+    const prev = before[schemaPath];
+    const next = after[schemaPath];
+    if (!prev && next) {
+      out.push({ path: schemaPath, op: "added", after: next });
+      continue;
+    }
+    if (prev && !next) {
+      out.push({ path: schemaPath, op: "removed", before: prev });
+      continue;
+    }
+    if (!prev || !next) continue;
+    if (entrySignature(prev) !== entrySignature(next)) {
+      out.push({ path: schemaPath, op: "changed", before: prev, after: next });
+    }
+  }
+  return out;
+}
+function diffRouteCfg(before, after) {
+  const out = [];
+  for (const field of CHANGESET_CFG_FIELDS) {
+    const prev = before[field];
+    const next = after[field];
+    if (stableStringify(prev) !== stableStringify(next)) {
+      out.push({
+        field,
+        before: prev,
+        after: next
+      });
+    }
+  }
+  return out;
+}
+function flattenSourceSections(snapshot) {
+  const map = /* @__PURE__ */ new Map();
+  for (const section of SCHEMA_SECTIONS) {
+    const entries = snapshot.sections[section];
+    for (const [schemaPath, signatures] of Object.entries(entries)) {
+      map.set(`${section}:${schemaPath}`, signatures);
+    }
+  }
+  return map;
+}
+function diffSourceSchemas(before, after) {
+  const prev = flattenSourceSections(before);
+  const next = flattenSourceSections(after);
+  const keys = /* @__PURE__ */ new Set([...prev.keys(), ...next.keys()]);
+  const out = [];
+  for (const key of Array.from(keys).sort()) {
+    const prevSignatures = prev.get(key);
+    const nextSignatures = next.get(key);
+    const [section, ...rest] = key.split(":");
+    const schemaPath = rest.join(":");
+    if (!prevSignatures && nextSignatures) {
+      out.push({
+        section,
+        path: schemaPath,
+        op: "added",
+        after: nextSignatures
+      });
+      continue;
+    }
+    if (prevSignatures && !nextSignatures) {
+      out.push({
+        section,
+        path: schemaPath,
+        op: "removed",
+        before: prevSignatures
+      });
+      continue;
+    }
+    if (!prevSignatures || !nextSignatures) continue;
+    if (stableStringify(prevSignatures) !== stableStringify(nextSignatures)) {
+      out.push({
+        section,
+        path: schemaPath,
+        op: "changed",
+        before: prevSignatures,
+        after: nextSignatures
+      });
+    }
+  }
+  return out;
+}
+function routeRecordByKey(events) {
+  var _a;
+  const out = {};
+  for (const event of events) {
+    out[_a = event.routeKey] ?? (out[_a] = []);
+    out[event.routeKey].push(event);
+  }
+  return out;
+}
+function sourceRecordById(events) {
+  var _a;
+  const out = {};
+  for (const event of events) {
+    out[_a = event.sourceObjectId] ?? (out[_a] = []);
+    out[event.sourceObjectId].push(event);
+  }
+  return out;
+}
+function buildRollups(routeEvents, sourceEvents, commits) {
+  var _a, _b;
+  const route = {
+    route_added: 0,
+    route_removed: 0,
+    schema_changed: 0,
+    cfg_changed: 0
+  };
+  const sourceObject = {
+    source_object_added: 0,
+    source_object_removed: 0,
+    source_schema_changed: 0
+  };
+  for (const event of routeEvents) {
+    route[event.type] += 1;
+  }
+  for (const event of sourceEvents) {
+    sourceObject[event.type] += 1;
+  }
+  const byCommit = {};
+  for (const commit of commits) {
+    byCommit[commit.sha] = { routeEvents: 0, sourceEvents: 0 };
+  }
+  for (const event of routeEvents) {
+    byCommit[_a = event.commitSha] ?? (byCommit[_a] = { routeEvents: 0, sourceEvents: 0 });
+    byCommit[event.commitSha].routeEvents += 1;
+  }
+  for (const event of sourceEvents) {
+    byCommit[_b = event.commitSha] ?? (byCommit[_b] = { routeEvents: 0, sourceEvents: 0 });
+    byCommit[event.commitSha].sourceEvents += 1;
+  }
+  return {
+    route,
+    sourceObject,
+    byCommit
+  };
+}
+async function loadChangelogInput(modulePath, exportName) {
+  const mod = await import(`${(0, import_node_url2.pathToFileURL)(modulePath).href}?v=${Date.now()}`);
+  const value = mod[exportName] ?? (mod.default && mod.default[exportName]);
+  if (!value) {
+    throw new Error(`Export "${exportName}" not found in module: ${modulePath}`);
+  }
+  return value;
+}
+async function createSnapshot(repoRoot, moduleRel, exportName, commit, tempRoot, tsconfigRel, exportOptions) {
+  const worktreeDir = import_node_path4.default.join(tempRoot, `wt-${commit.sha.slice(0, 12)}`);
+  await runGit(repoRoot, ["worktree", "add", "--detach", worktreeDir, commit.sha]);
+  try {
+    const modulePath = import_node_path4.default.resolve(worktreeDir, moduleRel);
+    const tsconfigPath = tsconfigRel ? import_node_path4.default.resolve(worktreeDir, tsconfigRel) : void 0;
+    const input = await loadChangelogInput(modulePath, exportName);
+    const payload = await exportFinalizedLeaves(input, {
+      includeSource: true,
+      sourceModulePath: modulePath,
+      sourceExportName: exportName,
+      tsconfigPath,
+      ...exportOptions
+    });
+    const routesByKey = toRouteSnapshots(payload);
+    const sourceObjectsById = toSourceObjectSnapshots(routesByKey);
+    return {
+      commit,
+      routesByKey,
+      sourceObjectsById
+    };
+  } finally {
+    await runGit(repoRoot, ["worktree", "remove", "--force", worktreeDir]).catch(() => void 0);
+    await import_promises2.default.rm(worktreeDir, { recursive: true, force: true }).catch(() => void 0);
+  }
+}
+function diffSnapshots(previous, current) {
+  const routeEvents = [];
+  const sourceEvents = [];
+  const routeKeys = /* @__PURE__ */ new Set([
+    ...Object.keys(previous.routesByKey),
+    ...Object.keys(current.routesByKey)
+  ]);
+  for (const routeKey of Array.from(routeKeys).sort()) {
+    const prevRoute = previous.routesByKey[routeKey];
+    const nextRoute = current.routesByKey[routeKey];
+    if (!prevRoute && nextRoute) {
+      routeEvents.push({
+        type: "route_added",
+        commitSha: current.commit.sha,
+        routeKey,
+        method: nextRoute.method,
+        path: nextRoute.path
+      });
+      continue;
+    }
+    if (prevRoute && !nextRoute) {
+      routeEvents.push({
+        type: "route_removed",
+        commitSha: current.commit.sha,
+        routeKey,
+        method: prevRoute.method,
+        path: prevRoute.path
+      });
+      continue;
+    }
+    if (!prevRoute || !nextRoute) continue;
+    const schemaDiff = diffRouteSchemas(prevRoute.flatSchema, nextRoute.flatSchema);
+    if (schemaDiff.length > 0) {
+      routeEvents.push({
+        type: "schema_changed",
+        commitSha: current.commit.sha,
+        routeKey,
+        method: nextRoute.method,
+        path: nextRoute.path,
+        schemaDiff
+      });
+    }
+    const cfgDiff = diffRouteCfg(prevRoute.cfg, nextRoute.cfg);
+    if (cfgDiff.length > 0) {
+      routeEvents.push({
+        type: "cfg_changed",
+        commitSha: current.commit.sha,
+        routeKey,
+        method: nextRoute.method,
+        path: nextRoute.path,
+        cfgDiff
+      });
+    }
+  }
+  const sourceKeys = /* @__PURE__ */ new Set([
+    ...Object.keys(previous.sourceObjectsById),
+    ...Object.keys(current.sourceObjectsById)
+  ]);
+  for (const sourceObjectId of Array.from(sourceKeys).sort()) {
+    const prevSource = previous.sourceObjectsById[sourceObjectId];
+    const nextSource = current.sourceObjectsById[sourceObjectId];
+    if (!prevSource && nextSource) {
+      sourceEvents.push({
+        type: "source_object_added",
+        commitSha: current.commit.sha,
+        sourceObjectId,
+        displayName: nextSource.displayName,
+        impactedRoutes: nextSource.routeKeys
+      });
+      continue;
+    }
+    if (prevSource && !nextSource) {
+      sourceEvents.push({
+        type: "source_object_removed",
+        commitSha: current.commit.sha,
+        sourceObjectId,
+        displayName: prevSource.displayName,
+        impactedRoutes: prevSource.routeKeys
+      });
+      continue;
+    }
+    if (!prevSource || !nextSource) continue;
+    const schemaDiff = diffSourceSchemas(prevSource, nextSource);
+    const prevRoutes = new Set(prevSource.routeKeys);
+    const nextRoutes = new Set(nextSource.routeKeys);
+    const routeAdded = Array.from(nextRoutes).filter((routeKey) => !prevRoutes.has(routeKey));
+    const routeRemoved = Array.from(prevRoutes).filter((routeKey) => !nextRoutes.has(routeKey));
+    if (schemaDiff.length > 0 || routeAdded.length > 0 || routeRemoved.length > 0) {
+      sourceEvents.push({
+        type: "source_schema_changed",
+        commitSha: current.commit.sha,
+        sourceObjectId,
+        displayName: nextSource.displayName,
+        impactedRoutes: nextSource.routeKeys,
+        schemaDiff: schemaDiff.length > 0 ? schemaDiff : void 0,
+        routeAdded: routeAdded.length > 0 ? routeAdded : void 0,
+        routeRemoved: routeRemoved.length > 0 ? routeRemoved : void 0
+      });
+    }
+  }
+  return {
+    routeEvents,
+    sourceEvents
+  };
+}
+var BAKED_PAYLOAD_MARKER2 = "<!--__FINALIZED_LEAVES_BAKED_PAYLOAD__-->";
+function escapePayloadForInlineScript2(payload) {
+  return JSON.stringify(payload).replace(/<\//g, "<\\/").replace(/<!--/g, "<\\!--");
+}
+function injectPayloadIntoViewerHtml2(htmlTemplate, payload) {
+  const payloadScript = `${BAKED_PAYLOAD_MARKER2}
+<script id="finalized-leaves-baked-payload">window.__FINALIZED_LEAVES_PAYLOAD = ${escapePayloadForInlineScript2(
+    payload
+  )};</script>`;
+  if (htmlTemplate.includes(BAKED_PAYLOAD_MARKER2)) {
+    return htmlTemplate.replace(BAKED_PAYLOAD_MARKER2, payloadScript);
+  }
+  if (htmlTemplate.includes("</body>")) {
+    return htmlTemplate.replace("</body>", `${payloadScript}
+</body>`);
+  }
+  return `${payloadScript}
+${htmlTemplate}`;
+}
+async function resolveViewerTemplatePath2(viewerTemplateFile) {
+  if (viewerTemplateFile) {
+    const resolved = import_node_path4.default.resolve(viewerTemplateFile);
+    await import_promises2.default.access(resolved);
+    return resolved;
+  }
+  const candidates = [
+    import_node_path4.default.resolve(
+      process.cwd(),
+      "node_modules/@emeryld/rrroutes-export/tools/finalized-leaves-viewer.html"
+    ),
+    import_node_path4.default.resolve(process.cwd(), "tools/finalized-leaves-viewer.html"),
+    import_node_path4.default.resolve(process.cwd(), "packages/export/tools/finalized-leaves-viewer.html")
+  ];
+  for (const candidate of candidates) {
+    try {
+      await import_promises2.default.access(candidate);
+      return candidate;
+    } catch {
+    }
+  }
+  return void 0;
+}
+async function writeJsonExport2(payload, outFile) {
+  const resolved = import_node_path4.default.resolve(outFile);
+  await import_promises2.default.mkdir(import_node_path4.default.dirname(resolved), { recursive: true });
+  await import_promises2.default.writeFile(resolved, `${JSON.stringify(payload, null, 2)}
+`, "utf8");
+  return resolved;
+}
+async function writeBakedHtmlExport2(payload, htmlFile, viewerTemplateFile) {
+  const templatePath = await resolveViewerTemplatePath2(viewerTemplateFile);
+  const template = templatePath ? await import_promises2.default.readFile(templatePath, "utf8") : DEFAULT_VIEWER_TEMPLATE;
+  const baked = injectPayloadIntoViewerHtml2(template, payload);
+  const resolved = import_node_path4.default.resolve(htmlFile);
+  await import_promises2.default.mkdir(import_node_path4.default.dirname(resolved), { recursive: true });
+  await import_promises2.default.writeFile(resolved, baked, "utf8");
+  return resolved;
+}
+async function openHtmlInBrowser2(filePath) {
+  const resolved = import_node_path4.default.resolve(filePath);
+  const platform = process.platform;
+  if (platform === "darwin") {
+    (0, import_node_child_process2.spawn)("open", [resolved], { detached: true, stdio: "ignore" }).unref();
+    return;
+  }
+  if (platform === "win32") {
+    (0, import_node_child_process2.spawn)("cmd", ["/c", "start", "", resolved], {
+      detached: true,
+      stdio: "ignore"
+    }).unref();
+    return;
+  }
+  (0, import_node_child_process2.spawn)("xdg-open", [resolved], { detached: true, stdio: "ignore" }).unref();
+}
+async function writeFinalizedLeavesChangelogExport(payload, outFileOrOptions) {
+  const options = typeof outFileOrOptions === "string" ? { outFile: outFileOrOptions } : outFileOrOptions;
+  const written = {};
+  if (options.outFile) {
+    written.outFile = await writeJsonExport2(payload, options.outFile);
+  }
+  if (options.htmlFile) {
+    written.htmlFile = await writeBakedHtmlExport2(
+      payload,
+      options.htmlFile,
+      options.viewerTemplateFile
+    );
+  }
+  if (options.openOnFinish) {
+    if (!written.htmlFile) {
+      throw new Error(
+        "openOnFinish requires htmlFile. Provide htmlFile to open the baked viewer."
+      );
+    }
+    await openHtmlInBrowser2(written.htmlFile);
+  }
+  return written;
+}
+async function exportFinalizedLeavesChangelog(options) {
+  const cwd = process.cwd();
+  const repoRoot = await runGit(cwd, ["rev-parse", "--show-toplevel"]);
+  const modulePathAbsolute = import_node_path4.default.resolve(cwd, options.modulePath);
+  const modulePathRelative = normalizePath(import_node_path4.default.relative(repoRoot, modulePathAbsolute));
+  if (modulePathRelative.startsWith("..")) {
+    throw new Error("modulePath must resolve inside the git repository root.");
+  }
+  const tsconfigAbsolute = options.tsconfigPath ? import_node_path4.default.resolve(cwd, options.tsconfigPath) : void 0;
+  const tsconfigRelative = tsconfigAbsolute ? normalizePath(import_node_path4.default.relative(repoRoot, tsconfigAbsolute)) : void 0;
+  if (tsconfigRelative && tsconfigRelative.startsWith("..")) {
+    throw new Error("tsconfigPath must resolve inside the git repository root.");
+  }
+  const exportName = options.exportName ?? "leaves";
+  const window = await resolveCommitWindow(repoRoot, options.from, options.to);
+  const allCommits = await resolveCommitPath(repoRoot, window.from, window.to);
+  const selectedCommitShas = await filterCommits(
+    repoRoot,
+    allCommits,
+    modulePathRelative,
+    tsconfigRelative
+  );
+  if (selectedCommitShas.length === 0) {
+    selectedCommitShas.push(window.to);
+  }
+  const commits = [];
+  for (const commit of selectedCommitShas) {
+    commits.push(await getCommitMetadata(repoRoot, commit));
+  }
+  const tempRoot = await import_promises2.default.mkdtemp(import_node_path4.default.join(import_node_os.default.tmpdir(), "rrroutes-export-changelog-"));
+  try {
+    const snapshots = [];
+    for (const commit of commits) {
+      snapshots.push(
+        await createSnapshot(
+          repoRoot,
+          modulePathRelative,
+          exportName,
+          commit,
+          tempRoot,
+          tsconfigRelative,
+          options
+        )
+      );
+    }
+    const routeEvents = [];
+    const sourceEvents = [];
+    for (let i = 1; i < snapshots.length; i += 1) {
+      const { routeEvents: nextRouteEvents, sourceEvents: nextSourceEvents } = diffSnapshots(
+        snapshots[i - 1],
+        snapshots[i]
+      );
+      routeEvents.push(...nextRouteEvents);
+      sourceEvents.push(...nextSourceEvents);
+    }
+    const payload = {
+      kind: "finalized-leaves-changelog",
+      _meta: {
+        generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        description: "Git-history changelog for RRRoutes finalized leaves with route-level and source-object schema diffs.",
+        modulePath: options.modulePath,
+        exportName,
+        from: window.from,
+        to: window.to,
+        selectedCommitCount: commits.length
+      },
+      commits,
+      byRoute: routeRecordByKey(routeEvents),
+      bySourceObject: sourceRecordById(sourceEvents),
+      rollups: buildRollups(routeEvents, sourceEvents, commits)
+    };
+    if (options.outFile || options.htmlFile) {
+      await writeFinalizedLeavesChangelogExport(payload, {
+        outFile: options.outFile,
+        htmlFile: options.htmlFile,
+        viewerTemplateFile: options.viewerTemplateFile,
+        openOnFinish: options.openOnFinish
+      });
+    }
+    return payload;
+  } finally {
+    await import_promises2.default.rm(tempRoot, { recursive: true, force: true }).catch(() => void 0);
+  }
+}
+var __private = {
+  resolveCommitWindow,
+  resolveCommitPath,
+  filterCommits,
+  toRouteSnapshots,
+  toSourceObjectSnapshots,
+  diffSnapshots,
+  buildSourceIdentity
+};
+// src/exportFinalizedLeaves.changelog.cli.ts
+var import_node_path5 = __toESM(require("path"), 1);
+function parseFinalizedLeavesChangelogCliArgs(argv) {
+  const args = /* @__PURE__ */ new Map();
+  for (let i = 0; i < argv.length; i += 1) {
+    const key = argv[i];
+    if (key === "--") continue;
+    if (!key.startsWith("--")) continue;
+    if (key === "--with-source") {
+      continue;
+    }
+    const value = argv[i + 1];
+    if (!value || value.startsWith("--")) {
+      throw new Error(`Missing value for ${key}`);
+    }
+    args.set(key, value);
+    i += 1;
+  }
+  const modulePath = args.get("--module");
+  if (!modulePath) {
+    throw new Error("Missing required --module argument");
+  }
+  return {
+    modulePath,
+    exportName: args.get("--export") ?? "leaves",
+    outFile: args.get("--out") ?? "finalized-leaves.changelog.json",
+    htmlFile: args.get("--html") ?? void 0,
+    tsconfigPath: args.get("--tsconfig") ?? void 0,
+    from: args.get("--from") ?? void 0,
+    to: args.get("--to") ?? void 0
+  };
+}
+async function runExportFinalizedLeavesChangelogCli(argv) {
+  const args = parseFinalizedLeavesChangelogCliArgs(argv);
+  const options = {
+    modulePath: args.modulePath,
+    exportName: args.exportName,
+    outFile: args.outFile,
+    htmlFile: args.htmlFile,
+    tsconfigPath: args.tsconfigPath,
+    from: args.from,
+    to: args.to,
+    includeSource: true
+  };
+  const payload = await exportFinalizedLeavesChangelog(options);
+  return {
+    payload,
+    outFile: import_node_path5.default.resolve(args.outFile),
+    htmlFile: args.htmlFile ? import_node_path5.default.resolve(args.htmlFile) : void 0
+  };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   DEFAULT_VIEWER_TEMPLATE,
+  __private,
   clearSchemaIntrospectionHandlers,
   createSchemaIntrospector,
   exportFinalizedLeaves,
+  exportFinalizedLeavesChangelog,
   extractLeafSourceByAst,
   flattenLeafSchemas,
   flattenSerializableSchema,
   introspectSchema,
   loadFinalizedLeavesInput,
+  parseFinalizedLeavesChangelogCliArgs,
   parseFinalizedLeavesCliArgs,
   registerSchemaIntrospectionHandler,
+  runExportFinalizedLeavesChangelogCli,
   runExportFinalizedLeavesCli,
   serializableSchemaKinds,
   serializeLeafContract,
   serializeLeavesContract,
+  writeFinalizedLeavesChangelogExport,
   writeFinalizedLeavesExport
 });
 //# sourceMappingURL=index.cjs.map