@emeryld/rrroutes-export 1.0.8 → 1.0.10

package/README.md

@@ -66,13 +66,19 @@ Settings:
 - `--html <path>`: optional. Baked HTML viewer for changelog payload.
 - `--tsconfig <path>`: optional. TS config used for source extraction in snapshots.
 - `--with-source`: accepted for parity; changelog mode always enables source extraction.
+- `--cache-dir <path>`: optional. Directory for per-commit compile cache artifacts.
+- `--no-cache`: optional flag. Disable compile cache and force recompilation.
 
 Behavior summary:
 
 - Resolves commit path from `from..to` (chronological).
+- Builds commit-aware module path candidates (current path + extension variants + rename history).
 - Filters commits to those touching module tree/relevant config files.
 - Ensures tip commit is always included.
 - Creates a temp git worktree per selected commit.
+- 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).
 - 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`)
@@ -80,8 +86,17 @@ Behavior summary:
 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.
 - Bundle script prints stage logs for snapshot export + changelog export.
 
+Troubleshooting historical TS imports:
+
+- Changelog execution no longer relies on direct Node runtime loading of TS sources.
+- Historical imports like `./x.js` pointing to `x.ts` are handled by snapshot compilation.
+- If tsconfig auto-discovery fails, pass `--tsconfig`.
+- If entrypoint path moved across history, changelog resolves rename history automatically.
+
 ## Recommended end-to-end script
 
 Use this when you want one command to produce everything (snapshot + changelog + HTML + summary + timestamped storage).
@@ -95,6 +110,7 @@ pnpm --filter @emeryld/rrroutes-export run export:bundle -- \
   --tsconfig ./tsconfig.json \
   --from v1.4.0 \
   --to HEAD \
+  --cache-dir ./.rroutes-exports/.cache \
   --dir ./.rrroutes-exports
 ```
 
@@ -105,6 +121,8 @@ Bundle script settings (`scripts/export-release-bundle.ts`):
 - `--tsconfig <path>`: optional.
 - `--from <rev>`: optional.
 - `--to <rev>`: optional.
+- `--cache-dir <path>`: optional.
+- `--no-cache`: optional flag.
 - `--dir <path>`: optional base directory for stored bundles. Default: `.rrroutes-exports`.
 
 Per run, it writes a timestamped directory:
@@ -138,6 +156,8 @@ const changelog = await exportFinalizedLeavesChangelog({
   exportName: 'leaves',
   from: 'v1.4.0',
   to: 'HEAD',
+  cacheDir: './.cache/rrroutes-export',
+  noCache: false,
   outFile: './finalized-leaves.changelog.json',
   htmlFile: './finalized-leaves.changelog.viewer.html',
   log: (message) => console.log(message),

package/dist/exportFinalizedLeaves.changelog.cli.d.ts

@@ -6,6 +6,8 @@ export type FinalizedLeavesChangelogCliArgs = {
     tsconfigPath?: string;
     from?: string;
     to?: string;
+    cacheDir?: string;
+    noCache: boolean;
 };
 export declare function parseFinalizedLeavesChangelogCliArgs(argv: string[]): FinalizedLeavesChangelogCliArgs;
 export declare function runExportFinalizedLeavesChangelogCli(argv: string[]): Promise<{

package/dist/exportFinalizedLeaves.changelog.d.ts

@@ -32,6 +32,7 @@ type CommitSnapshot = {
     commit: ChangelogCommit;
     routesByKey: Record<string, RouteSnapshot>;
     sourceObjectsById: Record<string, SourceObjectSnapshot>;
+    unresolvedModule?: boolean;
 };
 type DiffOp = 'added' | 'removed' | 'changed';
 export type SchemaPathDelta = {
@@ -96,6 +97,7 @@ export type FinalizedLeavesChangelogExport = {
         from: string;
         to: string;
         selectedCommitCount: number;
+        unresolvedModuleCommits?: string[];
     };
     commits: ChangelogCommit[];
     byRoute: Record<string, RouteChangeEvent[]>;
@@ -115,16 +117,40 @@ export type ExportFinalizedLeavesChangelogOptions = {
     includeSource?: boolean;
     handlers?: ExportFinalizedLeavesOptions['handlers'];
     log?: (message: string) => void;
+    cacheDir?: string;
+    noCache?: boolean;
 };
 declare function resolveCommitWindow(cwd: string, from?: string, to?: string): Promise<{
     from: string;
     to: string;
 }>;
 declare function resolveCommitPath(cwd: string, fromCommit: string, toCommit: string): Promise<string[]>;
-declare function filterCommits(cwd: string, commits: string[], moduleRel: string, tsconfigRel?: string): Promise<string[]>;
+declare function buildModulePathCandidates(repoRoot: string, toCommit: string, requestedModuleRel: string): Promise<string[]>;
+declare function resolveModulePathForCommit(repoRoot: string, commitSha: string, candidates: readonly string[]): Promise<string | undefined>;
+declare function filterCommits(cwd: string, commits: string[], moduleCandidates: readonly string[], tsconfigRel?: string): Promise<string[]>;
 declare function buildSourceIdentity(section: ChangelogSchemaSection, value: Record<string, unknown>): SourceIdentity;
 declare function toRouteSnapshots(payload: FinalizedLeavesExport): Record<string, RouteSnapshot>;
 declare function toSourceObjectSnapshots(routesByKey: Record<string, RouteSnapshot>): Record<string, SourceObjectSnapshot>;
+declare function resolveSnapshotTsconfig(worktreeDir: string, modulePath: string, tsconfigOverride?: string): Promise<string>;
+declare function toEmittedModulePath(moduleRel: string): string;
+declare function buildCompileCacheKey(commitSha: string, moduleRel: string, tsconfigPath: string, tsconfigStat: {
+    mtimeMs: number;
+    size: number;
+}): string;
+declare function compileSnapshotEntry(options: {
+    worktreeDir: string;
+    moduleRel: string;
+    modulePath: string;
+    tsconfigPath: string;
+    commitSha: string;
+    cacheRoot: string;
+    noCache?: boolean;
+    log?: (message: string) => void;
+}): Promise<string>;
+declare function loadSnapshotExport(options: {
+    entryPath: string;
+    exportName: string;
+}): Promise<{}>;
 declare function diffSnapshots(previous: CommitSnapshot, current: CommitSnapshot): {
     routeEvents: RouteChangeEvent[];
     sourceEvents: SourceObjectChangeEvent[];
@@ -138,6 +164,13 @@ export declare const __private: {
     resolveCommitWindow: typeof resolveCommitWindow;
     resolveCommitPath: typeof resolveCommitPath;
     filterCommits: typeof filterCommits;
+    buildModulePathCandidates: typeof buildModulePathCandidates;
+    resolveModulePathForCommit: typeof resolveModulePathForCommit;
+    resolveSnapshotTsconfig: typeof resolveSnapshotTsconfig;
+    toEmittedModulePath: typeof toEmittedModulePath;
+    buildCompileCacheKey: typeof buildCompileCacheKey;
+    compileSnapshotEntry: typeof compileSnapshotEntry;
+    loadSnapshotExport: typeof loadSnapshotExport;
     toRouteSnapshots: typeof toRouteSnapshots;
     toSourceObjectSnapshots: typeof toSourceObjectSnapshots;
     diffSnapshots: typeof diffSnapshots;