@abreen/tada 1.13.4 → 1.13.9

package/build/bundle.ts

@@ -9,10 +9,20 @@ import {
   getDistDir,
   toPosix,
 } from './utils/paths';
-import { deriveTheme, deriveLinkHue } from './utils/derive-theme';
+import {
+  deriveTheme,
+  deriveLinkHue,
+  deriveTraceLineActiveHue,
+} from './utils/derive-theme';
 import type { PluginBuilder } from 'bun';
 import type { SiteVariables } from './types';
 import timezones from '../src/timezone/timezones.json' with { type: 'json' };
+import pkg from '../package.json' with { type: 'json' };
+
+export function getBundleNaming(): string {
+  const version = pkg.version.replace(/[^a-zA-Z0-9.-]/g, '-');
+  return `[name].bundle.tada-${version}.[ext]`;
+}
 
 function formatCssNumber(value: number, precision = 4): string {
   if (Number.isInteger(value)) {
@@ -40,6 +50,9 @@ function renderThemeScss(siteVariables: SiteVariables): string {
   const linkColorHover = `hsl(${linkHue}deg 34% 60%)`;
   const linkColorDark = `hsl(${linkHue}deg 50% 72%)`;
   const linkColorHoverDark = `hsl(${linkHue}deg 40% 80%)`;
+  const traceLineActiveHue = formatCssNumber(deriveTraceLineActiveHue(tintHue));
+  const bgTraceLineActive = `hsl(${traceLineActiveHue}deg 100% 86%)`;
+  const bgTraceLineActiveDark = `hsl(${traceLineActiveHue}deg 90% 18%)`;
 
   const rendered = _.template(template)({
     ...theme,
@@ -54,6 +67,8 @@ function renderThemeScss(siteVariables: SiteVariables): string {
     linkColorHover,
     linkColorDark,
     linkColorHoverDark,
+    bgTraceLineActive,
+    bgTraceLineActiveDark,
   });
 
   const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'tada-'));
@@ -109,7 +124,7 @@ export async function bundle(
   const result = await Bun.build({
     entrypoints,
     outdir: resolvedDistDir,
-    naming: '[name].bundle.[ext]',
+    naming: getBundleNaming(),
     minify: mode === 'production',
     sourcemap: isDev ? 'inline' : 'none',
     define: createDefine(siteVariables, isDev),

package/build/generate-content-assets.ts

@@ -6,16 +6,14 @@ import { createContentRecord } from './source-records';
 import { validateConfigLinks } from './validate-config-links';
 import { config, getConfigFileName } from './templates';
 import { initHighlighter } from './utils/shiki-highlighter';
-import { checkTraceToolAvailability, isTraceSourceFile } from './utils/trace';
+import { checkTraceToolAvailability } from './utils/trace';
 import type {
   SiteVariables,
   ContentRenderOptions,
   ContentRenderResult,
   HtmlOutputAnalysis,
   TraceToolAvailability,
-  WatchState,
 } from './types';
-import type { TadaSourceRecord } from './watch/snapshot';
 
 const log = makeLogger(import.meta.url);
 
@@ -25,16 +23,25 @@ function cloneHtmlOutputAnalysis(
   return { outgoingTargets: new Set(analysis.outgoingTargets) };
 }
 
+function writeRecordOutputs(
+  distDir: string,
+  outputs: Map<string, string | Buffer>,
+): void {
+  for (const [outputPath, content] of outputs) {
+    const outPath = path.join(distDir, outputPath);
+    fs.mkdirSync(path.dirname(outPath), { recursive: true });
+    fs.writeFileSync(outPath, content);
+  }
+}
+
 export class ContentRenderer {
   private siteVariables: SiteVariables;
-  private sourceFileCache: Map<string, TadaSourceRecord>;
-  private lastBuildFiles: Set<string>;
-  private javacAvailable: boolean | undefined;
   private traceToolAvailability: TraceToolAvailability | undefined;
   private traceCache: Map<
     string,
     {
       manifestUrl: string;
+      artifactId: string;
       highlightedSource: string;
       totalSteps: number;
       mtime: number;
@@ -43,133 +50,23 @@ export class ContentRenderer {
 
   constructor(siteVariables: SiteVariables) {
     this.siteVariables = siteVariables;
-    this.sourceFileCache = new Map();
-    this.lastBuildFiles = new Set();
-  }
-
-  private getCachedRecord(filePath: string): TadaSourceRecord | undefined {
-    return this.sourceFileCache.get(filePath);
   }
 
   async initHighlighter(): Promise<void> {
     await initHighlighter(getRuntimeBundledShikiLanguages(this.siteVariables));
   }
 
-  getDirtySourceFiles(
-    buildContentFiles: string[],
-    { changedContentFiles, jsonDataChanged, partialsChanged }: WatchState = {},
-  ): Set<string> {
-    if (
-      this.lastBuildFiles.size === 0 ||
-      !changedContentFiles ||
-      jsonDataChanged ||
-      partialsChanged
-    ) {
-      return new Set(buildContentFiles);
-    }
-
-    // If any trace source changed, the trace cache will be stale, so rebuild
-    // all content pages to pick up the new trace output.
-    const traceFileChanged = [...changedContentFiles].some(isTraceSourceFile);
-    if (traceFileChanged) {
-      return new Set(buildContentFiles);
-    }
-
-    const buildFileSet = new Set(buildContentFiles);
-    const dirtySourceFiles = new Set<string>();
-    for (const filePath of changedContentFiles) {
-      if (buildFileSet.has(filePath)) {
-        dirtySourceFiles.add(filePath);
-      }
-    }
-    return dirtySourceFiles;
-  }
-
-  updateSourceCache(
-    filePath: string,
-    record: TadaSourceRecord,
-    changedOutputRelPaths: Set<string>,
-    removedOutputRelPaths: Set<string>,
-    changedHtmlAssetPaths: Set<string>,
-    removedHtmlAssetPaths: Set<string>,
-  ): void {
-    const previousRecord = this.getCachedRecord(filePath);
-    const nextOutputPaths = new Set(record.outputs.keys());
-
-    for (const outputPath of previousRecord?.outputs.keys() ?? []) {
-      if (nextOutputPaths.has(outputPath)) {
-        continue;
-      }
-      removedOutputRelPaths.add(outputPath);
-      if (outputPath.endsWith('.html')) {
-        removedHtmlAssetPaths.add(outputPath);
-      }
-    }
-
-    for (const outputPath of record.outputs.keys()) {
-      changedOutputRelPaths.add(outputPath);
-      if (outputPath.endsWith('.html')) {
-        changedHtmlAssetPaths.add(outputPath);
-      }
-    }
-
-    this.sourceFileCache.set(filePath, record);
-  }
-
-  writeCachedAssets(distDir: string, buildContentFiles: string[]): void {
-    for (const filePath of buildContentFiles) {
-      const record = this.getCachedRecord(filePath);
-      if (!record) {
-        continue;
-      }
-      for (const [outputPath, content] of record.outputs) {
-        const outPath = path.join(distDir, outputPath);
-        fs.mkdirSync(path.dirname(outPath), { recursive: true });
-        fs.writeFileSync(outPath, content);
-      }
-    }
-  }
-
-  pruneRemovedSources(
-    buildFileSet: Set<string>,
-    removedOutputRelPaths: Set<string>,
-    removedHtmlAssetPaths: Set<string>,
-  ): void {
-    for (const filePath of [...this.lastBuildFiles]) {
-      if (buildFileSet.has(filePath)) {
-        continue;
-      }
-
-      const previousRecord = this.getCachedRecord(filePath);
-      for (const outputPath of previousRecord?.outputs.keys() ?? []) {
-        removedOutputRelPaths.add(outputPath);
-        if (outputPath.endsWith('.html')) {
-          removedHtmlAssetPaths.add(outputPath);
-        }
-      }
-      this.sourceFileCache.delete(filePath);
-    }
-  }
-
   processContent({
     distDir,
     assetFiles,
     scan,
-    watchState,
   }: ContentRenderOptions): ContentRenderResult {
     const buildContentFiles = [...scan.buildContentFiles];
-    const buildFileSet = new Set<string>(buildContentFiles);
-    const dirtySourceFiles = this.getDirtySourceFiles(
-      buildContentFiles,
-      watchState,
-    );
-    const changedOutputRelPaths = new Set<string>();
-    const removedOutputRelPaths = new Set<string>();
-    const changedHtmlAssetPaths = new Set<string>();
-    const removedHtmlAssetPaths = new Set<string>();
     const validInternalTargets = scan.validTargets;
 
     const errors: Error[] = [];
+    const htmlAssetsByPath = new Map<string, string>();
+    const htmlAnalysisByPath = new Map<string, HtmlOutputAnalysis>();
 
     const configLinkErrors = validateConfigLinks(
       validInternalTargets,
@@ -184,29 +81,21 @@ export class ContentRenderer {
       errors.push(new Error(msg));
     }
 
-    this.pruneRemovedSources(
-      buildFileSet,
-      removedOutputRelPaths,
-      removedHtmlAssetPaths,
-    );
-
-    if (dirtySourceFiles.size > 0) {
-      const noun = dirtySourceFiles.size === 1 ? 'file' : 'files';
-      log.info`Processing ${dirtySourceFiles.size} content ${noun}`;
+    if (buildContentFiles.length > 0) {
+      const noun = buildContentFiles.length === 1 ? 'file' : 'files';
+      log.info`Processing ${buildContentFiles.length} content ${noun}`;
     }
 
-    if (this.javacAvailable === undefined && dirtySourceFiles.size > 0) {
+    if (!this.traceToolAvailability && buildContentFiles.length > 0) {
       this.traceToolAvailability = checkTraceToolAvailability();
-      this.javacAvailable = this.traceToolAvailability.java;
-      if (!this.javacAvailable) {
+      if (!this.traceToolAvailability.java) {
         log.warn`javac was not found; literate Java pages will not include execution output`;
       }
     }
 
-    for (const filePath of dirtySourceFiles) {
-      let record: TadaSourceRecord;
+    for (const filePath of buildContentFiles) {
       try {
-        record = createContentRecord({
+        const record = createContentRecord({
           filePath,
           siteVariables: this.siteVariables,
           scan,
@@ -214,53 +103,27 @@ export class ContentRenderer {
           outputDir: distDir,
           traceCache: this.traceCache,
           traceToolAvailability: this.traceToolAvailability,
-          skipLiterateJavaExecution: !this.javacAvailable,
+          skipLiterateJavaExecution: !this.traceToolAvailability?.java,
         });
+        writeRecordOutputs(distDir, record.outputs);
+        for (const [outputPath, content] of record.outputs) {
+          if (!outputPath.endsWith('.html') || typeof content !== 'string') {
+            continue;
+          }
+          htmlAssetsByPath.set(outputPath, content);
+          const analysis = record.htmlAnalysisByOutputPath?.get(outputPath);
+          if (analysis) {
+            htmlAnalysisByPath.set(
+              outputPath,
+              cloneHtmlOutputAnalysis(analysis),
+            );
+          }
+        }
       } catch (err) {
         errors.push(err as Error);
-        continue;
-      }
-      this.updateSourceCache(
-        filePath,
-        record,
-        changedOutputRelPaths,
-        removedOutputRelPaths,
-        changedHtmlAssetPaths,
-        removedHtmlAssetPaths,
-      );
-    }
-
-    this.writeCachedAssets(distDir, buildContentFiles);
-    this.lastBuildFiles = buildFileSet;
-
-    // Collect HTML asset content and analysis for Pagefind
-    const htmlAssetsByPath = new Map<string, string>();
-    const htmlAnalysisByPath = new Map<string, HtmlOutputAnalysis>();
-    for (const filePath of buildContentFiles) {
-      const record = this.getCachedRecord(filePath);
-      if (!record) {
-        continue;
-      }
-      for (const [outputPath, content] of record.outputs) {
-        if (!outputPath.endsWith('.html') || typeof content !== 'string') {
-          continue;
-        }
-        htmlAssetsByPath.set(outputPath, content);
-        const analysis = record.htmlAnalysisByOutputPath?.get(outputPath);
-        if (analysis) {
-          htmlAnalysisByPath.set(outputPath, cloneHtmlOutputAnalysis(analysis));
-        }
       }
     }
 
-    return {
-      errors,
-      changedHtmlAssetPaths,
-      removedHtmlAssetPaths,
-      removedOutputRelPaths,
-      htmlAssetsByPath,
-      htmlAnalysisByPath,
-      buildContentFiles,
-    };
+    return { errors, htmlAssetsByPath, htmlAnalysisByPath };
   }
 }

package/build/pipeline.ts

@@ -15,7 +15,7 @@ import { makeLogger, printFlair } from './log';
 import { generateBuildManifest, getNextVersion } from './build-manifest';
 import { scanProject } from './source-model';
 import { validateConfig } from './watch/validation';
-import { applyCommitPlan } from '../watch/fs-commit';
+import { applyCommitPlan } from './watch/fs-commit';
 import path from 'path';
 
 const log = makeLogger(import.meta.url);

package/build/source-model.ts

@@ -15,7 +15,7 @@ import {
   normalizeOutputPath,
   toPosix,
 } from './utils/paths';
-import type { ChangeBatch } from '../watch/types';
+import type { ChangeBatch } from './watch/types';
 import type { SiteVariables } from './types';
 
 export interface TadaProjectScan {
@@ -34,18 +34,6 @@ export interface TadaProjectScan {
   sourceTargetPaths: Map<string, Set<string>>;
 }
 
-export interface TadaProjectScanSnapshotLike {
-  processedExts: Set<string>;
-  contentFiles: Set<string>;
-  buildContentFiles: Set<string>;
-  publicFiles: Set<string>;
-  literateJavaOutputPaths: Set<string>;
-  contentOwners: Map<string, string>;
-  publicOwners: Map<string, string>;
-  sourceOutputPaths: Map<string, Set<string>>;
-  sourceTargetPaths: Map<string, Set<string>>;
-}
-
 export function shouldSkipContentFile(filePath: string): boolean {
   const ext = path.extname(filePath).toLowerCase();
   if (!(extensionIsMarkdown(ext) || ext === '.html')) {
@@ -333,7 +321,7 @@ export function scanProject(siteVariables: SiteVariables): TadaProjectScan {
 }
 
 export function updateProjectScan(
-  snapshot: TadaProjectScanSnapshotLike,
+  snapshot: TadaProjectScan,
   batch: ChangeBatch,
 ): TadaProjectScan {
   const scan = createEmptyScan(snapshot.processedExts);

package/build/types.d.ts

@@ -49,25 +49,13 @@ export interface ContentRenderOptions {
   distDir: string;
   assetFiles: string[];
   scan: TadaProjectScan;
-  watchState?: WatchState;
-}
-
-/** State passed from watch mode to control incremental rebuilds */
-export interface WatchState {
-  changedContentFiles?: Set<string>;
-  jsonDataChanged?: boolean;
-  partialsChanged?: boolean;
 }
 
 /** Result from ContentRenderer.processContent() */
 export interface ContentRenderResult {
   errors: Error[];
-  changedHtmlAssetPaths: Set<string>;
-  removedHtmlAssetPaths: Set<string>;
-  removedOutputRelPaths: Set<string>;
   htmlAssetsByPath: Map<string, string>;
   htmlAnalysisByPath: Map<string, HtmlOutputAnalysis>;
-  buildContentFiles: string[];
 }
 
 /** Logger returned by makeLogger() */
@@ -97,6 +85,7 @@ export interface RenderPlainTextOptions {
     string,
     {
       manifestUrl: string;
+      artifactId: string;
       highlightedSource: string;
       totalSteps: number;
       mtime: number;

package/build/utils/derive-theme.ts

@@ -16,6 +16,8 @@ const DARK_TEXT_L_MAX = 0.82;
 
 const LINK_ANCHOR_HUE = 212;
 const LINK_TINT_BLEND = 0.05;
+const TRACE_LINE_ACTIVE_ANCHOR_HUE = 52;
+const TRACE_LINE_ACTIVE_TINT_BLEND = 0.1;
 
 function clamp(v: number, min: number, max: number): number {
   return Math.min(Math.max(v, min), max);
@@ -83,6 +85,14 @@ export function deriveLinkHue(tintHue: number): number {
   return (LINK_ANCHOR_HUE + diff * LINK_TINT_BLEND + 360) % 360;
 }
 
+export function deriveTraceLineActiveHue(tintHue: number): number {
+  const diff = ((tintHue - TRACE_LINE_ACTIVE_ANCHOR_HUE + 540) % 360) - 180;
+  return (
+    (TRACE_LINE_ACTIVE_ANCHOR_HUE + diff * TRACE_LINE_ACTIVE_TINT_BLEND + 360) %
+    360
+  );
+}
+
 export function getTextOnColor(cssColor: string): '#fff' | '#000' {
   const parsed = parse(cssColor);
   if (!parsed) {

package/build/utils/render.ts

@@ -432,6 +432,7 @@ function renderPlainTextContent(
       string,
       {
         manifestUrl: string;
+        artifactId: string;
         highlightedSource: string;
         totalSteps: number;
         mtime: number;

package/build/utils/trace-core.ts

@@ -1,5 +1,6 @@
 import fs from 'fs';
 import path from 'path';
+import { createHash } from 'crypto';
 import { renderCodeSegment } from './code';
 import { splitLines } from './literate-java';
 import { normalizeOutputPath } from './paths';
@@ -14,18 +15,46 @@ export interface ChunkTraceOutputOptions {
   ignoreFields?: Record<string, string[]>;
 }
 
+export interface ChunkTraceOutputResult {
+  manifest: TraceManifest;
+  artifactId: string;
+  outputPaths: string[];
+}
+
+function hashTraceFiles(files: { name: string; content: string }[]): string {
+  const hasher = createHash('sha256');
+  for (const file of files) {
+    hasher.update(file.name, 'utf8');
+    hasher.update('\0', 'utf8');
+    hasher.update(file.content, 'utf8');
+    hasher.update('\0', 'utf8');
+  }
+  return `sha256-${hasher.digest('hex').slice(0, 16)}`;
+}
+
+function buildTraceOutputPath(
+  relDir: string,
+  traceName: string,
+  artifactId: string,
+  fileName: string,
+): string {
+  return [relDir, '_traces', traceName, artifactId, fileName]
+    .filter(Boolean)
+    .join('/');
+}
+
 export function chunkTraceOutput(
   output: string,
   traceOutputDir: string,
+  relDir: string,
+  traceName: string,
   sourceFile: string,
   source: string,
   options: ChunkTraceOutputOptions = {},
-): TraceManifest {
+): ChunkTraceOutputResult {
   const chunkSize = options.chunkSize ?? DEFAULT_CHUNK_SIZE;
   const ignoreFields = options.ignoreFields ?? {};
 
-  fs.mkdirSync(traceOutputDir, { recursive: true });
-
   const lines = output
     .trim()
     .split('\n')
@@ -46,26 +75,27 @@ export function chunkTraceOutput(
 
   let chunkEntries: TraceChunkEntry[] = [];
   let chunkIndex = 0;
+  const chunkFiles: { name: string; content: string }[] = [];
 
   for (const step of allSteps) {
     const svg = generateStepSvg(step, layout);
     chunkEntries.push({ line: step.line, stdout: step.stdout, svg });
 
     if (chunkEntries.length >= chunkSize) {
-      fs.writeFileSync(
-        path.join(traceOutputDir, `chunk-${chunkIndex}.json`),
-        JSON.stringify(chunkEntries),
-      );
+      chunkFiles.push({
+        name: `chunk-${chunkIndex}.json`,
+        content: JSON.stringify(chunkEntries),
+      });
       chunkEntries = [];
       chunkIndex++;
     }
   }
 
   if (chunkEntries.length > 0) {
-    fs.writeFileSync(
-      path.join(traceOutputDir, `chunk-${chunkIndex}.json`),
-      JSON.stringify(chunkEntries),
-    );
+    chunkFiles.push({
+      name: `chunk-${chunkIndex}.json`,
+      content: JSON.stringify(chunkEntries),
+    });
   }
 
   const manifest: TraceManifest = {
@@ -76,12 +106,26 @@ export function chunkTraceOutput(
     lineToSteps,
   };
 
-  fs.writeFileSync(
-    path.join(traceOutputDir, 'manifest.json'),
-    JSON.stringify(manifest),
-  );
+  const manifestFile = {
+    name: 'manifest.json',
+    content: JSON.stringify(manifest),
+  };
+  const files = [manifestFile, ...chunkFiles];
+  const artifactId = hashTraceFiles(files);
+  const artifactDir = path.join(traceOutputDir, artifactId);
 
-  return manifest;
+  fs.mkdirSync(artifactDir, { recursive: true });
+  for (const file of files) {
+    fs.writeFileSync(path.join(artifactDir, file.name), file.content);
+  }
+
+  return {
+    manifest,
+    artifactId,
+    outputPaths: files.map(file =>
+      buildTraceOutputPath(relDir, traceName, artifactId, file.name),
+    ),
+  };
 }
 
 export function highlightTraceSource(
@@ -96,16 +140,25 @@ export function highlightTraceSource(
 export function getTraceOutputPaths(
   relDir: string,
   traceName: string,
+  artifactId: string,
   totalSteps: number,
 ): string[] {
-  const baseDir = [relDir, '_traces', traceName].filter(Boolean).join('/');
-  const outputPaths = [`${baseDir}/manifest.json`];
+  const outputPaths = [
+    buildTraceOutputPath(relDir, traceName, artifactId, 'manifest.json'),
+  ];
   for (
     let chunkIndex = 0;
     chunkIndex * DEFAULT_CHUNK_SIZE < totalSteps;
     chunkIndex++
   ) {
-    outputPaths.push(`${baseDir}/chunk-${chunkIndex}.json`);
+    outputPaths.push(
+      buildTraceOutputPath(
+        relDir,
+        traceName,
+        artifactId,
+        `chunk-${chunkIndex}.json`,
+      ),
+    );
   }
   return outputPaths;
 }
@@ -148,18 +201,18 @@ export function materializeTraceOutputs({
 export function buildManifestUrl({
   relDir,
   traceName,
+  artifactId,
   applyBasePath,
 }: {
   relDir: string;
   traceName: string;
+  artifactId: string;
   applyBasePath: (subPath: string) => string;
 }): string {
   return applyBasePath(
     normalizeOutputPath(
       '/' +
-        [relDir, '_traces', traceName, 'manifest.json']
-          .filter(Boolean)
-          .join('/'),
+        buildTraceOutputPath(relDir, traceName, artifactId, 'manifest.json'),
     ),
   );
 }