@emeryld/rrroutes-export 1.0.11 → 1.0.12

package/README.md

@@ -79,15 +79,18 @@ Behavior summary:
 - For TypeScript module entries, compiles the commit snapshot to JS and imports emitted output.
 - For JavaScript module entries, imports directly from worktree.
 - If module entrypoint cannot be resolved for a commit, changelog uses an empty snapshot for that commit (timeline continuity).
+- If a commit snapshot fails to compile/load, changelog also uses an empty snapshot for that commit and continues.
 - Exports snapshots, then computes adjacent diffs:
   - route events (`route_added`, `route_removed`, `schema_changed`, `cfg_changed`)
   - source-object events (`source_object_added`, `source_object_removed`, `source_schema_changed`)
+  - metadata includes fallback details in `_meta.unresolvedModuleCommits` and `_meta.snapshotFallbacks`
 
 Runtime progress logs:
 
 - `rrroutes-export-changelog` now prints step-by-step progress (window resolution, commit filtering, per-commit snapshot progress, diff totals, output writing, cleanup).
 - Changelog logs include compile lifecycle details: selected tsconfig, cache hit/miss, emitted entry path.
 - Changelog logs include per-commit module resolution and unresolved-entry fallback messages.
+- Changelog logs include snapshot compile/load fallback messages when a commit cannot be materialized.
 - Bundle script prints stage logs for snapshot export + changelog export.
 
 Troubleshooting historical TS imports:

package/dist/exportFinalizedLeaves.changelog.d.ts

@@ -33,6 +33,8 @@ type CommitSnapshot = {
     routesByKey: Record<string, RouteSnapshot>;
     sourceObjectsById: Record<string, SourceObjectSnapshot>;
     unresolvedModule?: boolean;
+    fallbackReason?: 'module_unresolved' | 'snapshot_error';
+    fallbackError?: string;
 };
 type DiffOp = 'added' | 'removed' | 'changed';
 export type SchemaPathDelta = {
@@ -98,6 +100,11 @@ export type FinalizedLeavesChangelogExport = {
         to: string;
         selectedCommitCount: number;
         unresolvedModuleCommits?: string[];
+        snapshotFallbacks?: Array<{
+            sha: string;
+            reason: 'module_unresolved' | 'snapshot_error';
+            error?: string;
+        }>;
     };
     commits: ChangelogCommit[];
     byRoute: Record<string, RouteChangeEvent[]>;

package/dist/index.cjs

@@ -2121,72 +2121,87 @@ async function createSnapshot(repoRoot, moduleCandidates, exportName, commit, te
   const worktreeDir = import_node_path4.default.join(tempRoot, `wt-${commit.sha.slice(0, 12)}`);
   await runGit(repoRoot, ["worktree", "add", "--detach", worktreeDir, commit.sha]);
   try {
-    await ensureWorktreeDependencies(repoRoot, worktreeDir);
-    const resolvedModuleRel = await resolveModulePathForCommit(
-      repoRoot,
-      commit.sha,
-      moduleCandidates
-    );
-    if (!resolvedModuleRel) {
+    try {
+      await ensureWorktreeDependencies(repoRoot, worktreeDir);
+      const resolvedModuleRel = await resolveModulePathForCommit(
+        repoRoot,
+        commit.sha,
+        moduleCandidates
+      );
+      if (!resolvedModuleRel) {
+        log?.(
+          `[changelog] unresolved module for commit ${commit.sha.slice(0, 12)}; using empty snapshot`
+        );
+        return {
+          commit,
+          routesByKey: {},
+          sourceObjectsById: {},
+          unresolvedModule: true,
+          fallbackReason: "module_unresolved"
+        };
+      }
+      log?.(
+        `[changelog] resolved module for commit ${commit.sha.slice(0, 12)}: ${resolvedModuleRel}`
+      );
+      const modulePath = import_node_path4.default.resolve(worktreeDir, resolvedModuleRel);
+      let snapshotRuntimePath = modulePath;
+      let resolvedTsconfigPath;
+      if (isTypeScriptModule(modulePath)) {
+        resolvedTsconfigPath = await resolveSnapshotTsconfig(
+          worktreeDir,
+          modulePath,
+          tsconfigRel
+        );
+        log?.(`[changelog] using tsconfig: ${resolvedTsconfigPath}`);
+        const compileCacheRoot = import_node_path4.default.resolve(
+          exportOptions?.cacheDir ?? import_node_path4.default.join(import_node_os.default.tmpdir(), "rrroutes-export-changelog-cache")
+        );
+        snapshotRuntimePath = await compileSnapshotEntry({
+          worktreeDir,
+          moduleRel: resolvedModuleRel,
+          modulePath,
+          tsconfigPath: resolvedTsconfigPath,
+          commitSha: commit.sha,
+          cacheRoot: compileCacheRoot,
+          noCache: exportOptions?.noCache,
+          log
+        });
+      } else if (!isJavaScriptModule(modulePath)) {
+        throw new Error(
+          `Unsupported module extension for changelog snapshots: ${modulePath}`
+        );
+      }
+      const input = await loadSnapshotExport({
+        entryPath: snapshotRuntimePath,
+        exportName
+      });
+      const payload = await exportFinalizedLeaves(input, {
+        includeSource: true,
+        sourceModulePath: modulePath,
+        sourceExportName: exportName,
+        tsconfigPath: resolvedTsconfigPath ?? (tsconfigRel ? import_node_path4.default.resolve(worktreeDir, tsconfigRel) : void 0),
+        handlers: exportOptions?.handlers
+      });
+      const routesByKey = toRouteSnapshots(payload);
+      const sourceObjectsById = toSourceObjectSnapshots(routesByKey);
+      return {
+        commit,
+        routesByKey,
+        sourceObjectsById
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
       log?.(
-        `[changelog] unresolved module for commit ${commit.sha.slice(0, 12)}; using empty snapshot`
+        `[changelog] snapshot failed for ${commit.sha.slice(0, 12)}; using empty snapshot. ${message}`
       );
       return {
         commit,
         routesByKey: {},
         sourceObjectsById: {},
-        unresolvedModule: true
+        fallbackReason: "snapshot_error",
+        fallbackError: message
       };
     }
-    log?.(
-      `[changelog] resolved module for commit ${commit.sha.slice(0, 12)}: ${resolvedModuleRel}`
-    );
-    const modulePath = import_node_path4.default.resolve(worktreeDir, resolvedModuleRel);
-    let snapshotRuntimePath = modulePath;
-    let resolvedTsconfigPath;
-    if (isTypeScriptModule(modulePath)) {
-      resolvedTsconfigPath = await resolveSnapshotTsconfig(
-        worktreeDir,
-        modulePath,
-        tsconfigRel
-      );
-      log?.(`[changelog] using tsconfig: ${resolvedTsconfigPath}`);
-      const compileCacheRoot = import_node_path4.default.resolve(
-        exportOptions?.cacheDir ?? import_node_path4.default.join(import_node_os.default.tmpdir(), "rrroutes-export-changelog-cache")
-      );
-      snapshotRuntimePath = await compileSnapshotEntry({
-        worktreeDir,
-        moduleRel: resolvedModuleRel,
-        modulePath,
-        tsconfigPath: resolvedTsconfigPath,
-        commitSha: commit.sha,
-        cacheRoot: compileCacheRoot,
-        noCache: exportOptions?.noCache,
-        log
-      });
-    } else if (!isJavaScriptModule(modulePath)) {
-      throw new Error(
-        `Unsupported module extension for changelog snapshots: ${modulePath}`
-      );
-    }
-    const input = await loadSnapshotExport({
-      entryPath: snapshotRuntimePath,
-      exportName
-    });
-    const payload = await exportFinalizedLeaves(input, {
-      includeSource: true,
-      sourceModulePath: modulePath,
-      sourceExportName: exportName,
-      tsconfigPath: resolvedTsconfigPath ?? (tsconfigRel ? import_node_path4.default.resolve(worktreeDir, tsconfigRel) : void 0),
-      handlers: exportOptions?.handlers
-    });
-    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);
@@ -2442,6 +2457,7 @@ async function exportFinalizedLeavesChangelog(options) {
   try {
     const snapshots = [];
     const unresolvedModuleCommits = [];
+    const snapshotFallbacks = [];
     for (let index = 0; index < commits.length; index += 1) {
       const commit = commits[index];
       log(
@@ -2459,9 +2475,17 @@ async function exportFinalizedLeavesChangelog(options) {
           log
         )
       );
-      if (snapshots[snapshots.length - 1]?.unresolvedModule) {
+      const lastSnapshot = snapshots[snapshots.length - 1];
+      if (lastSnapshot?.unresolvedModule) {
         unresolvedModuleCommits.push(commit.sha);
       }
+      if (lastSnapshot?.fallbackReason) {
+        snapshotFallbacks.push({
+          sha: commit.sha,
+          reason: lastSnapshot.fallbackReason,
+          error: lastSnapshot.fallbackError
+        });
+      }
     }
     const routeEvents = [];
     const sourceEvents = [];
@@ -2487,7 +2511,8 @@ async function exportFinalizedLeavesChangelog(options) {
         from: window.from,
         to: window.to,
         selectedCommitCount: commits.length,
-        unresolvedModuleCommits: unresolvedModuleCommits.length > 0 ? unresolvedModuleCommits : void 0
+        unresolvedModuleCommits: unresolvedModuleCommits.length > 0 ? unresolvedModuleCommits : void 0,
+        snapshotFallbacks: snapshotFallbacks.length > 0 ? snapshotFallbacks : void 0
       },
       commits,
       byRoute: routeRecordByKey(routeEvents),