@abreen/tada 1.17.0 → 1.17.1

package/README.md

@@ -135,6 +135,9 @@ files in the `dist/` directory.
 ### `tada watch`
 
 Start a development web server, watch for changes and rebuild automatically.
+Exactly one `site.dev.yaml`, `site.dev.yml`, or `site.dev.json` must exist
+before starting; otherwise, correct the configuration files and restart the
+command. Once watching, build errors can be fixed without restarting.
 
 ### `tada clean`
 
@@ -267,7 +270,7 @@ vars:
 | `symbol` | Text (1-5 chars) displayed in header (also used as the favicon symbol) |
 | `themeColor` | Theme color for the site (e.g., `"tomato"`, `"#c04040"`, `"hsl(195 70% 40%)"`) |
 | `tintHue` | *Optional*, hue (0-360) for background and foreground tinting (default `20`) |
-| `tintAmount` | *Optional*, percentage (0-100) of tint to apply (default `100`) |
+| `tintAmount` | *Optional*, percentage (0-100) of tint to apply to the neutral palette (default `100`); link saturation stays fixed |
 | `defaultFont` | *Optional*, initial font pairing: `sans` or `serif` (default `sans`) |
 | `defaultContrast` | *Optional*, initial neutral-palette contrast: `standard` or `high` (default `standard`) |
 | `fontOverrides` | *Optional*, custom serif and serif-monospace WOFF2 faces from `public/`; each configured family requires `regular` and may include styled faces, OpenType `features`, and font-specific `tuning` |

package/bin/tada.ts

@@ -536,7 +536,9 @@ function diffCommand(args: string[]): void {
 
   if (totalChanges === 0) {
     console.log('\nNo changes between builds.');
-    return;
+    if (copyIdx === -1) {
+      return;
+    }
   }
 
   if (diff.added.length > 0) {
@@ -559,7 +561,9 @@ function diffCommand(args: string[]): void {
   }
 
   const noun = (n: number) => (n === 1 ? 'file' : 'files');
-  console.log(`\nTotal: ${totalChanges} ${noun(totalChanges)} differ`);
+  if (totalChanges > 0) {
+    console.log(`\nTotal: ${totalChanges} ${noun(totalChanges)} differ`);
+  }
 
   if (copyIdx !== -1) {
     const outDirArg = args[copyIdx + 1];
@@ -570,6 +574,7 @@ function diffCommand(args: string[]): void {
 
     const newDistDir = path.join(prodBase, `v${newVer}`);
     const resolvedOutDir = path.resolve(projectDir, outDirArg);
+    fs.mkdirSync(resolvedOutDir, { recursive: true });
     copyChangedFiles(diff, newDistDir, resolvedOutDir);
 
     // Always include pagefind/ (excluded from manifest but needed for search)

package/bin/validators.ts

@@ -83,7 +83,7 @@ export function createSiteConfig({
     extensionToShikiLanguage,
     shikiLanguages,
     themeColor,
-    tintHue: Number(tintHue),
+    tintHue: Number(String(tintHue).replace(/deg$/, '')),
     tintAmount: Number(tintAmount),
     vars: { foobar: 123 },
   };

package/build/build-manifest.ts

@@ -85,7 +85,7 @@ export async function walkAndHash(
     if (EXCLUDED_DIRS.has(topLevel)) {
       continue;
     }
-    if (EXCLUDED_FILES.has(entry.name)) {
+    if (EXCLUDED_FILES.has(rel)) {
       continue;
     }
 

package/build/columns-plugin.ts

@@ -1,9 +1,14 @@
-import type MarkdownIt from 'markdown-it';
+import MarkdownIt from 'markdown-it';
+import type Token from 'markdown-it/lib/token.mjs';
 import type StateBlock from 'markdown-it/lib/rules_block/state_block.mjs';
 
 const MARKER_CHAR = 0x2b; // '+'
 const MIN_MARKERS = 3;
 
+// A separate block parser avoids invoking column rules recursively or mutating
+// the document's tokens and plugin environment while locating literal code.
+const codeContextParser = new MarkdownIt('commonmark');
+
 function isColumnsFence(state: StateBlock, line: number): boolean {
   const start = state.bMarks[line] + state.tShift[line];
   const max = state.eMarks[line];
@@ -46,7 +51,28 @@ function columnsRule(
   let separatorLine = -1;
   let closeLine = -1;
 
+  // Parse block context, including lists and blockquotes, before looking for
+  // delimiters. Token maps keep code fences and their contents literal.
+  const contextTokens: Token[] = [];
+  codeContextParser.block.parse(
+    state.getLines(startLine + 1, endLine, state.blkIndent, false),
+    codeContextParser,
+    {},
+    contextTokens,
+  );
+  const codeLines = new Set<number>();
+  for (const token of contextTokens) {
+    if ((token.type === 'fence' || token.type === 'code_block') && token.map) {
+      for (let line = token.map[0]; line < token.map[1]; line++) {
+        codeLines.add(startLine + 1 + line);
+      }
+    }
+  }
+
   for (let line = startLine + 1; line < endLine; line++) {
+    if (codeLines.has(line)) {
+      continue;
+    }
     if (!isColumnsFence(state, line)) {
       continue;
     }

package/build/deflist-id-plugin.ts

@@ -24,11 +24,11 @@ export default function deflistIdPlugin(md: MarkdownIt): void {
           break;
         }
 
-        if (t.type === 'text') {
+        if (t.type === 'text' || t.type === 'code_inline') {
           termText += t.content;
         } else if (t.type === 'inline' && t.children) {
           for (const child of t.children) {
-            if (child.type === 'text') {
+            if (child.type === 'text' || child.type === 'code_inline') {
               termText += child.content;
             }
           }

package/build/source-model.ts

@@ -376,13 +376,28 @@ export function updateProjectScan(
     addPublicSourceToScan({ scan, filePath: sourcePath });
   }
 
+  // Rebuild the selected owners from the complete source inventory. Removing
+  // either producer of a formerly conflicting output must retain its survivor.
+  scan.contentOwners.clear();
+  for (const sourcePath of scan.contentFiles) {
+    for (const outputPath of scan.sourceOutputPaths.get(sourcePath) || []) {
+      scan.contentOwners.set(outputPath, sourcePath);
+    }
+  }
   scan.validTargets = collectValidTargets(scan.sourceTargetPaths);
   return scan;
 }
 
 export function assertNoOutputPathConflicts(scan: TadaProjectScan): string[] {
-  const conflicts = [...scan.contentOwners.keys()].filter(relPath =>
-    scan.publicOwners.has(relPath),
-  );
-  return conflicts.sort();
+  const owners = new Set<string>();
+  const conflicts = new Set<string>();
+  for (const outputs of scan.sourceOutputPaths.values()) {
+    for (const outputPath of outputs) {
+      if (owners.has(outputPath)) {
+        conflicts.add(outputPath);
+      }
+      owners.add(outputPath);
+    }
+  }
+  return [...conflicts].sort();
 }

package/build/templates.ts

@@ -53,7 +53,7 @@ export function getConfigFileName(name: ProjectConfigName): string | undefined {
 export function render(
   fileName: string,
   params?: Record<string, unknown> | null,
-): string | undefined {
+): string {
   if (params != null) {
     // Allow the template to call render(), it will use our params
     params.render = (otherFileName: string) => render(otherFileName, params);
@@ -68,16 +68,17 @@ export function render(
   } catch (err) {
     if (errorStack == null) {
       errorStack = renderStack.slice();
-
-      if (renderStack.length > 1) {
-        throw err;
-      }
-    } else if (renderStack.length === 1) {
+    }
+    if (renderStack.length === 1) {
       const topItem = errorStack[errorStack.length - 1];
       throw new Error(`Render error in ${topItem}: ${err}`, { cause: err });
     }
+    throw err;
   } finally {
     renderStack.pop();
+    if (renderStack.length === 0) {
+      errorStack = null;
+    }
   }
 }
 

package/build/utils/code.ts

@@ -122,16 +122,7 @@ const JAVA_TYPE_DECLARATION_NODES = new Set([
   'recordDeclaration',
 ]);
 
-function extractJavaMethodMeta(
-  methodNode: CstNode,
-  requireBody = true,
-): MethodMeta | null {
-  const methodBody = methodNode.children?.methodBody?.[0];
-  const hasBody = Boolean(methodBody?.children?.block?.length);
-  if (requireBody && !hasBody) {
-    return null;
-  }
-
+function extractJavaMethodMeta(methodNode: CstNode): MethodMeta | null {
   const methodHeader = methodNode.children?.methodHeader?.[0];
   const methodDeclarator = methodHeader?.children?.methodDeclarator?.[0];
   const identifier = methodDeclarator?.children?.Identifier?.[0];
@@ -293,16 +284,15 @@ export function extractJavaMethodToc(sourceCode: string): JavaTocEntry[] {
       return;
     }
 
-    if (node.name === 'methodDeclaration' && typeDepth <= 1) {
+    if (
+      (node.name === 'methodDeclaration' ||
+        node.name === 'interfaceMethodDeclaration') &&
+      typeDepth <= 1
+    ) {
       const method = extractJavaMethodMeta(node);
       if (method) {
         callables.push({ ...method, kind: 'method' });
       }
-    } else if (node.name === 'interfaceMethodDeclaration' && typeDepth <= 1) {
-      const method = extractJavaMethodMeta(node, false);
-      if (method) {
-        callables.push({ ...method, kind: 'method' });
-      }
     } else if (node.name === 'constructorDeclaration' && typeDepth === 1) {
       const constructor = extractJavaConstructorMeta(node);
       if (constructor) {
@@ -325,6 +315,13 @@ export function extractJavaMethodToc(sourceCode: string): JavaTocEntry[] {
     for (const value of Object.values(children)) {
       for (const child of value) {
         if (child && child.name) {
+          // Anonymous classes have a classBody without a type declaration.
+          if (
+            node.name === 'unqualifiedClassInstanceCreationExpression' &&
+            child.name === 'classBody'
+          ) {
+            continue;
+          }
           visit(child, nextTypeDepth);
         }
       }

package/build/utils/jdi-runner/LiterateRunner.java

@@ -244,7 +244,15 @@ public class LiterateRunner {
                 case '\n' -> sb.append("\\n");
                 case '\r' -> sb.append("\\r");
                 case '\t' -> sb.append("\\t");
-                default -> sb.append(c);
+                default -> {
+                    if (c < 0x20) {
+                        sb.append("\\u00");
+                        sb.append(Character.forDigit(c >> 4, 16));
+                        sb.append(Character.forDigit(c & 0xf, 16));
+                    } else {
+                        sb.append(c);
+                    }
+                }
             }
         }
         sb.append('"');

package/build/validate-config-links.ts

@@ -70,6 +70,21 @@ function getInternalHrefTarget(href: string): string {
   }
 }
 
+function validateDirectoryLink(
+  href: string,
+  resolvedTarget: string,
+  validTargets: Set<string>,
+  context: string,
+): string | null {
+  const indexPath = normalizeOutputPath(
+    path.posix.join(resolvedTarget, 'index.html'),
+  );
+  if (validTargets.has(indexPath)) {
+    return `${context}: directory link must reference index.html explicitly: "${href}" (resolved to "${resolvedTarget}", expected "${indexPath}")`;
+  }
+  return null;
+}
+
 export function validateNavLinks(
   navData: unknown,
   validTargets: Set<string>,
@@ -96,8 +111,16 @@ export function validateNavLinks(
         continue;
       }
 
-      const normalized = normalizeOutputPath(link.internal);
-      if (!validTargets.has(normalized)) {
+      const normalized = getInternalHrefTarget(link.internal);
+      const directoryError = validateDirectoryLink(
+        link.internal,
+        normalized,
+        validTargets,
+        `${fileName}: internal link in section "${section.title}"`,
+      );
+      if (directoryError) {
+        errors.push(directoryError);
+      } else if (!validTargets.has(normalized)) {
         errors.push(
           `${fileName}: broken internal link in section "${section.title}": "${link.internal}"`,
         );
@@ -200,6 +223,16 @@ export function validateParentLink(
     return null;
   }
 
+  const directoryError = validateDirectoryLink(
+    parent as string,
+    resolvedTarget,
+    validTargets,
+    `${filePath}: parent link`,
+  );
+  if (directoryError) {
+    return directoryError;
+  }
+
   if (!validTargets.has(resolvedTarget)) {
     return `${filePath}: broken parent link: "${parent}"`;
   }

package/build/watch/engine.ts

@@ -52,6 +52,7 @@ function toDiagnostics(error: unknown): { message: string }[] {
 
 export async function runWatchEngine(
   options: WatchEngineOptions,
+  dependencies = { watch: chokidar.watch, applyCommitPlan },
 ): Promise<void> {
   const debounceMs = options.debounceMs ?? 300;
   let snapshot: TadaSnapshot | undefined;
@@ -71,7 +72,24 @@ export async function runWatchEngine(
   async function runBuild(batch?: ChangeBatch): Promise<CompilerBuildResult> {
     await emit({ kind: 'build-started', batch });
     try {
-      return await options.compiler.build(snapshot, batch);
+      const outcome = await options.compiler.build(snapshot, batch);
+      if (outcome.ok) {
+        try {
+          dependencies.applyCommitPlan(outcome.commit);
+        } catch (error) {
+          // The compiler may have mutated cached state before publication failed.
+          // Rebuild from sources on the next change instead of reusing that state.
+          snapshot = undefined;
+          return {
+            ok: false,
+            diagnostics: toDiagnostics(error).map(diagnostic => ({
+              message: `Failed to publish build output: ${diagnostic.message}`,
+            })),
+          };
+        }
+        snapshot = outcome.snapshot;
+      }
+      return outcome;
     } catch (error) {
       return { ok: false, diagnostics: toDiagnostics(error) };
     }
@@ -110,8 +128,6 @@ export async function runWatchEngine(
           return;
         }
 
-        applyCommitPlan(outcome.commit);
-        snapshot = outcome.snapshot;
         uncommitted = new Map();
         finalSuccess = { batch, result: outcome };
 
@@ -157,8 +173,6 @@ export async function runWatchEngine(
       diagnostics: startupOutcome.diagnostics,
     });
   } else {
-    applyCommitPlan(startupOutcome.commit);
-    snapshot = startupOutcome.snapshot;
     await emit({ kind: 'build-succeeded', meta: startupOutcome.meta });
   }
 
@@ -166,7 +180,7 @@ export async function runWatchEngine(
     .getWatchTargets()
     .map(target => ({
       target,
-      watcher: chokidar.watch(target.path, {
+      watcher: dependencies.watch(target.path, {
         ignoreInitial: true,
         atomic: true,
         awaitWriteFinish: { stabilityThreshold: 100 },

package/build/watch/fs-commit.ts

@@ -4,7 +4,6 @@ import { globals, type Globals } from '../globals';
 import type {
   ApplyMutationsCommitPlan,
   CommitPlan,
-  FileMutation,
   ReplaceRootCommitPlan,
 } from './types';
 
@@ -77,45 +76,111 @@ function pruneEmptyDirs(rootDir: string, filePath: string): void {
   }
 }
 
-function applyFileMutation(
-  rootDir: string,
-  mutation: FileMutation,
-  stagedRoot: string,
-  globals: CommitPlanGlobals,
-): void {
-  const targetPath = path.join(rootDir, mutation.path);
-  const stagedPath = path.join(stagedRoot, mutation.path);
-
-  if (mutation.kind === 'write') {
-    ensureParentDir(targetPath);
-    renameWithRetry(stagedPath, targetPath, globals);
-    return;
-  }
-
-  fs.rmSync(targetPath, { force: true });
-  pruneEmptyDirs(rootDir, targetPath);
+interface MutationJournalEntry {
+  targetPath: string;
+  backupPath?: string;
 }
 
 function applyMutations(
   plan: ApplyMutationsCommitPlan,
   globals: CommitPlanGlobals,
 ): void {
-  const stagedRoot = fs.mkdtempSync(path.join(plan.rootDir, '.watch-stage-'));
+  const transactionRoot = fs.mkdtempSync(
+    path.join(plan.rootDir, '.watch-stage-'),
+  );
+  const journal: MutationJournalEntry[] = [];
+  const createdDirs: string[] = [];
   try {
-    for (const mutation of plan.mutations) {
+    // Index staging paths so file/directory transitions cannot collide in staging.
+    for (const [index, mutation] of plan.mutations.entries()) {
       if (mutation.kind === 'write') {
-        const stagedPath = path.join(stagedRoot, mutation.path);
-        ensureParentDir(stagedPath);
-        fs.writeFileSync(stagedPath, mutation.content);
+        fs.writeFileSync(
+          path.join(transactionRoot, `write-${index}`),
+          mutation.content,
+        );
       }
     }
 
+    for (const [index, mutation] of plan.mutations.entries()) {
+      const targetPath = path.resolve(plan.rootDir, mutation.path);
+      const existing = fs.lstatSync(targetPath, { throwIfNoEntry: false });
+      if (existing?.isDirectory()) {
+        throw new Error(
+          `Cannot publish file mutation over directory: ${targetPath}`,
+        );
+      }
+      const backupPath = existing
+        ? path.join(transactionRoot, `backup-${index}`)
+        : undefined;
+      if (backupPath) {
+        renameWithRetry(targetPath, backupPath, globals);
+      }
+      journal.push({ targetPath, backupPath });
+      if (mutation.kind === 'write') {
+        // Track missing parents without relying on mkdir's returned path spelling.
+        let dir = path.dirname(targetPath);
+        while (!fs.existsSync(dir)) {
+          createdDirs.push(dir);
+          const parent = path.dirname(dir);
+          if (parent === dir) {
+            break;
+          }
+          dir = parent;
+        }
+        fs.mkdirSync(path.dirname(targetPath), { recursive: true });
+        renameWithRetry(
+          path.join(transactionRoot, `write-${index}`),
+          targetPath,
+          globals,
+        );
+      }
+    }
     for (const mutation of plan.mutations) {
-      applyFileMutation(plan.rootDir, mutation, stagedRoot, globals);
+      if (mutation.kind === 'delete') {
+        pruneEmptyDirs(plan.rootDir, path.resolve(plan.rootDir, mutation.path));
+      }
+    }
+  } catch (publicationError) {
+    const rollbackErrors: unknown[] = [];
+    const removeCreatedDirs = () => {
+      for (const dir of [...new Set(createdDirs)].sort(
+        (a, b) => b.length - a.length,
+      )) {
+        try {
+          fs.rmdirSync(dir);
+        } catch (error) {
+          const code = (error as NodeJS.ErrnoException).code;
+          if (code !== 'ENOENT' && code !== 'ENOTEMPTY' && code !== 'ENOTDIR') {
+            rollbackErrors.push(error);
+          }
+        }
+      }
+    };
+    for (const entry of journal.toReversed()) {
+      try {
+        removeCreatedDirs();
+        fs.rmSync(entry.targetPath, { force: true });
+        if (entry.backupPath) {
+          ensureParentDir(entry.targetPath);
+          renameWithRetry(entry.backupPath, entry.targetPath, globals);
+        }
+      } catch (error) {
+        rollbackErrors.push(error);
+      }
+    }
+    removeCreatedDirs();
+    if (rollbackErrors.length > 0) {
+      // Keep any unrestored originals available for manual recovery.
+      throw new AggregateError(
+        [publicationError, ...rollbackErrors],
+        `Failed to publish and restore output; recovery files remain in ${transactionRoot}`,
+        { cause: publicationError },
+      );
     }
-  } finally {
-    removeDirIfExists(stagedRoot);
+    removeDirIfExists(transactionRoot);
+    throw publicationError;
   }
+  removeDirIfExists(transactionRoot);
 }
 
 function replaceRoot(

package/build/watch/validation.ts

@@ -1,3 +1,4 @@
+import path from 'path';
 import { B } from '../colors';
 import { makeLogger } from '../log';
 import { config, getConfigFileName } from '../templates';
@@ -29,11 +30,17 @@ export function validateConfig(
     return diagnostics;
   }
   for (const relPath of conflicts) {
-    log.error`content/${B`${relPath}`} conflicts with public/${B`${relPath}`}`;
+    const sources = [...scan.sourceOutputPaths]
+      .filter(([, outputs]) => outputs.has(relPath))
+      .map(([sourcePath]) =>
+        path.relative(path.dirname(scan.contentDir), sourcePath),
+      )
+      .sort();
+    log.error`${sources.join(' conflicts with ')}: same output path ${B`${relPath}`}`;
   }
   const noun = conflicts.length === 1 ? 'file' : 'files';
   diagnostics.push({
-    message: `${conflicts.length} ${noun} in content/ and public/ have the same path`,
+    message: `${conflicts.length} output ${noun} ${conflicts.length === 1 ? 'has' : 'have'} multiple sources with the same path`,
   });
   return diagnostics;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abreen/tada",
-  "version": "1.17.0",
+  "version": "1.17.1",
   "type": "module",
   "description": "A static site generator",
   "license": "MIT",
@@ -100,7 +100,6 @@
   "devDependencies": {
     "@eslint/js": "^10.0.1",
     "@playwright/test": "^1.59.1",
-    "@saintedlama/lcov-parse": "^1.0.1",
     "@types/bun": "^1.3.12",
     "@types/culori": "^4.0.1",
     "@types/d3-flextree": "^2.1.4",

package/src/navigate/index.ts

@@ -28,7 +28,7 @@ function shouldIgnoreClick(
     return true;
   }
 
-  if (anchor.target) {
+  if (anchor.target || anchor.hasAttribute('download')) {
     return true;
   }
 
@@ -68,7 +68,7 @@ export default function mountNavigate(window: Window): () => void {
       return;
     }
 
-    // Same-page hash links: handle locally so we can clear search and
+    // Same-page links: handle locally so we can clear search and
     // close the header without a full SPA fetch.
     const url = new URL(anchor.href);
     if (
@@ -84,6 +84,17 @@ export default function mountNavigate(window: Window): () => void {
         } else {
           globals.setLocationHash(window, url.hash);
         }
+      } else {
+        saveScrollPosition(window);
+        if (window.location.hash) {
+          const state = window.history.state;
+          globals.setLocationHash(window, '');
+          // Native fragment clearing leaves a trailing #. Keep the authored
+          // URL and the current SPA history state on the new entry.
+          window.history.replaceState(state, '', url.href);
+        }
+        window.scrollTo({ top: 0 });
+        saveScrollPosition(window);
       }
       return;
     }

package/src/search/index.ts

@@ -281,6 +281,7 @@ export default (window: Window) => {
 
   let pagefindLoadPromise: Promise<boolean> | null = null;
   let pagefindLoadGeneration = 0;
+  let disposed = false;
 
   function pagefindModulePath(generation: number) {
     const path = applyBasePath('/pagefind/pagefind.js');
@@ -291,6 +292,9 @@ export default (window: Window) => {
   }
 
   async function loadPagefind(): Promise<boolean> {
+    if (disposed) {
+      return false;
+    }
     if (pagefind) {
       return true;
     }
@@ -317,7 +321,18 @@ export default (window: Window) => {
       }
       pagefind = loadedPagefind;
       return true;
-    })();
+    })().catch(err => {
+      if (generation === pagefindLoadGeneration) {
+        // Failed dynamic imports are cached by URL. Retry only on a later
+        // interaction, with a fresh URL, sharing one pending load.
+        pagefindLoadGeneration += 1;
+        console.log(`failed to load Pagefind: ${err}`);
+        if (state.showResults) {
+          render(input!, resultsContainer, state, false);
+        }
+      }
+      return false;
+    });
 
     const promise = pagefindLoadPromise;
     try {
@@ -343,6 +358,9 @@ export default (window: Window) => {
       render(input!, resultsContainer, state, true);
     }
     const query = state.value;
+    if (!(await loadPagefind()) || updateId !== latestUpdateId) {
+      return;
+    }
     const nextState = await doSearch(query, window);
     if (updateId !== latestUpdateId) {
       return;
@@ -370,7 +388,7 @@ export default (window: Window) => {
   function loadPagefindAndUpdate() {
     loadPagefind()
       .then(loadedCurrentPagefind => {
-        if (loadedCurrentPagefind && state.showResults) {
+        if (loadedCurrentPagefind && !disposed && state.showResults) {
           queueUpdate();
         }
       })
@@ -601,6 +619,9 @@ export default (window: Window) => {
   input.disabled = false;
 
   return () => {
+    disposed = true;
+    pagefindLoadGeneration += 1;
+    invalidateUpdates();
     window.removeEventListener(
       PAGE_UPDATE_REFRESH_EVENT,
       handlePageUpdateRefresh,

package/src/timezone/index.ts

@@ -4,6 +4,7 @@ import {
   normalizeHM,
   to12Hour,
   to12HourMarkup,
+  to24Hour,
   type PeriodStyle,
 } from './time-format';
 
@@ -149,6 +150,23 @@ export default (window: Window) => {
     periodStyles.set(el, detectPeriodStyle(el.textContent ?? ''));
   });
   const pagePeriodStyle = dominantPeriodStyle(periodStyles);
+  const twentyFourHourTimes = new Set<HTMLTimeElement>();
+  for (const [el, style] of periodStyles) {
+    const rangeEnd = getRangeEnd(el);
+    const inheritsPeriod =
+      rangeEnd !== null && periodStyles.get(rangeEnd) != null;
+    const authoredTime = (el.textContent ?? '').trim();
+    // A periodless 12-hour prefix may inherit its range's final AM/PM.
+    // Otherwise text matching datetime is an authored 24-hour time.
+    if (
+      style === null &&
+      !inheritsPeriod &&
+      /^\d{1,2}:\d{2}$/.test(authoredTime) &&
+      parseHHMM(authoredTime) === parseHHMM(el.getAttribute('datetime') ?? '')
+    ) {
+      twentyFourHourTimes.add(el);
+    }
+  }
 
   function updateTimes(targetTz: string) {
     const target = timezones.find(t => t.value === targetTz) || defaultTz;
@@ -187,11 +205,12 @@ export default (window: Window) => {
         }
       }
 
+      const is24Hour = twentyFourHourTimes.has(el);
       const originalStyle = periodStyles.get(el) ?? null;
       const originalIsPm = Math.floor(baseMinutes / 60) >= 12;
       const periodChanged = originalIsPm !== h >= 12 || dayShift !== 0;
       let style =
-        originalStyle === null && periodChanged
+        !is24Hour && originalStyle === null && periodChanged
           ? pagePeriodStyle
           : originalStyle;
 
@@ -201,6 +220,7 @@ export default (window: Window) => {
         ? parseHHMM(rangeEndDatetime)
         : NaN;
       if (
+        !is24Hour &&
         originalStyle === null &&
         rangeEnd !== null &&
         !isNaN(rangeEndMinutes)
@@ -216,14 +236,20 @@ export default (window: Window) => {
         isDefault || style === null || rangeEnd !== null
           ? ''
           : ` <span class="small-caps">${target.abbreviation}</span>`;
-      el.innerHTML = to12HourMarkup(h, m, style) + timeZone + suffix;
+      el.innerHTML =
+        (is24Hour ? to24Hour(h, m) : to12HourMarkup(h, m, style)) +
+        timeZone +
+        suffix;
 
       if (isDefault) {
         el.classList.remove('is-modified');
         el.title = '';
       } else {
         el.classList.add('is-modified');
-        el.title = `${to12Hour(...normalizeHM(baseMinutes), style ?? pagePeriodStyle)} ${defaultTz.abbreviation}`;
+        const originalTime = is24Hour
+          ? to24Hour(...normalizeHM(baseMinutes))
+          : to12Hour(...normalizeHM(baseMinutes), style ?? pagePeriodStyle);
+        el.title = `${originalTime} ${defaultTz.abbreviation}`;
       }
     });
   }

package/src/timezone/time-format.ts

@@ -22,6 +22,10 @@ function pad(n: number | string) {
   return String(n).padStart(2, '0');
 }
 
+export function to24Hour(h: number, m: number) {
+  return `${pad(h)}:${pad(m)}`;
+}
+
 export function to12Hour(
   h: number,
   m: number,

package/src/toc/index.ts

@@ -123,11 +123,12 @@ export default (window: Window) => {
       }
 
       let best = 0;
+      let bestLine = -1;
+      // TOC display groups (such as fields and methods) are not source order.
       for (let i = 0; i < codeLines.length; i++) {
-        if (codeLines[i] <= line) {
+        if (codeLines[i] <= line && codeLines[i] >= bestLine) {
           best = i;
-        } else {
-          break;
+          bestLine = codeLines[i];
         }
       }
 

package/src/trace/index.ts

@@ -5,6 +5,7 @@ interface WidgetState {
   manifest: TraceManifest;
   chunks: Map<number, TraceChunkEntry[]>;
   currentStep: number;
+  navigationRequest: number;
 }
 
 interface TraceResizeState {
@@ -54,6 +55,7 @@ async function goToStep(
   stepIndex: number,
   doc: Document,
 ): Promise<void> {
+  const request = ++state.navigationRequest;
   stepIndex = Math.max(0, Math.min(stepIndex, state.manifest.totalSteps - 1));
   const lastChunk = Math.floor(stepIndex / state.manifest.chunkSize);
   const loads: Promise<void>[] = [];
@@ -61,6 +63,9 @@ async function goToStep(
     loads.push(loadChunk(state, manifestUrl, i));
   }
   await Promise.all(loads);
+  if (request !== state.navigationRequest) {
+    return;
+  }
   state.currentStep = stepIndex;
   renderWidgetState(state, elements, doc);
 }
@@ -492,7 +497,12 @@ async function initWidget(root: HTMLElement, doc: Document): Promise<void> {
   }
   const manifest: TraceManifest = await res.json();
 
-  const state: WidgetState = { manifest, chunks: new Map(), currentStep: 0 };
+  const state: WidgetState = {
+    manifest,
+    chunks: new Map(),
+    currentStep: 0,
+    navigationRequest: 0,
+  };
 
   await loadChunk(state, manifestUrl, 0);