@abreen/tada 1.3.2 → 1.4.0

package/README.md

@@ -178,6 +178,7 @@ manually.
 - [MuPDF](https://mupdf.com/) (optional, for PDF text extraction in search)
   - On macOS: `brew install mupdf-tools`
   - On Fedora: `dnf install mupdf`
+  - On Ubuntu: `apt-get install mupdf-tools`
 
 > You may skip MuPDF if you don't need search results to include links to PDF
 > pages. You can also turn off `features.search` in the config to disable

package/bin/tada.ts

@@ -1,7 +1,7 @@
 #!/usr/bin/env bun
 import fs from 'fs';
 import path from 'path';
-import { execSync } from 'child_process';
+import { execFileSync } from 'child_process';
 import { parseArgs } from 'util';
 import packageJson from '../package.json' with { type: 'json' };
 import {
@@ -151,9 +151,9 @@ function printUsage() {
   }
 }
 
-function run(cmd: string): void {
+function run(args: string[]): void {
   try {
-    execSync(cmd, { cwd: process.cwd(), stdio: 'inherit' });
+    execFileSync('bun', args, { cwd: process.cwd(), stdio: 'inherit' });
   } catch (err: unknown) {
     const code = (err as { status?: number }).status;
     if (code != null) {
@@ -506,8 +506,16 @@ function diffCommand(args: string[]): void {
     process.exit(1);
   }
 
-  const oldManifestPath = path.join(prodBase, `v${oldVer}.manifest.json`);
-  const newManifestPath = path.join(prodBase, `v${newVer}.manifest.json`);
+  const oldManifestPath = path.join(
+    prodBase,
+    `v${oldVer}`,
+    'tada.manifest.json',
+  );
+  const newManifestPath = path.join(
+    prodBase,
+    `v${newVer}`,
+    'tada.manifest.json',
+  );
 
   const oldManifest = loadManifest(oldManifestPath);
   if (!oldManifest) {
@@ -572,12 +580,15 @@ function diffCommand(args: string[]): void {
       copyDirRecursive(pagefindSrc, path.join(resolvedOutDir, 'pagefind'));
     }
 
-    const manifestSrc = path.join(prodBase, `v${newVer}.manifest.json`);
-    fs.copyFileSync(manifestSrc, path.join(resolvedOutDir, 'manifest.json'));
+    const manifestSrc = path.join(newDistDir, 'tada.manifest.json');
+    fs.copyFileSync(
+      manifestSrc,
+      path.join(resolvedOutDir, 'tada.manifest.json'),
+    );
 
     const copiedCount = diff.added.length + diff.changed.length;
     console.log(
-      `\nCopied ${copiedCount} ${noun(copiedCount)} + manifest.json to ${outDirArg}`,
+      `\nCopied ${copiedCount} ${noun(copiedCount)} + tada.manifest.json to ${outDirArg}`,
     );
 
     if (diff.removed.length > 0) {
@@ -601,28 +612,22 @@ switch (command) {
 
   case 'dev':
     requireSiteConfig('dev');
-    run(`bun ${path.join(packageDir, 'build/pipeline.ts')} dev`);
+    run([path.join(packageDir, 'build/pipeline.ts'), 'dev']);
     break;
 
   case 'prod':
     requireSiteConfig('prod');
-    run(`bun ${path.join(packageDir, 'build/pipeline.ts')} prod`);
+    run([path.join(packageDir, 'build/pipeline.ts'), 'prod']);
     break;
 
   case 'watch': {
     requireSiteConfig('dev');
-    const watchArgs = process.argv.slice(3).join(' ');
-    run(
-      `bun ${path.join(packageDir, 'build/watch.ts')}${watchArgs ? ' ' + watchArgs : ''}`,
-    );
+    run([path.join(packageDir, 'build/watch.ts'), ...process.argv.slice(3)]);
     break;
   }
 
   case 'serve': {
-    const serveArgs = process.argv.slice(3).join(' ');
-    run(
-      `bun ${path.join(packageDir, 'build/serve.ts')}${serveArgs ? ' ' + serveArgs : ''}`,
-    );
+    run([path.join(packageDir, 'build/serve.ts'), ...process.argv.slice(3)]);
     break;
   }
 

package/build/build-manifest.test.ts

@@ -15,8 +15,11 @@ import {
 } from './build-manifest';
 import type { BuildManifest, ManifestDiff } from './build-manifest';
 
-function makeManifest(files: Record<string, string>): BuildManifest {
-  return { version: 1, buildTime: '2025-01-01T00:00:00.000Z', files };
+function makeManifest(
+  files: Record<string, string>,
+  build: number = 1,
+): BuildManifest {
+  return { schema: 1, build, buildTime: '2025-01-01T00:00:00.000Z', files };
 }
 
 let tmpDir: string;
@@ -149,6 +152,14 @@ describe('walkAndHash', () => {
     expect('pagefind/pagefind.js' in result).toBe(false);
   });
 
+  test('excludes tada.manifest.json', async () => {
+    fs.writeFileSync(path.join(tmpDir, 'index.html'), '<html></html>');
+    fs.writeFileSync(path.join(tmpDir, 'tada.manifest.json'), '{"schema":1}');
+    const result = await walkAndHash(tmpDir);
+    expect(Object.keys(result)).toEqual(['index.html']);
+    expect('tada.manifest.json' in result).toBe(false);
+  });
+
   test('returns empty object for empty directory', async () => {
     const result = await walkAndHash(tmpDir);
     expect(result).toEqual({});
@@ -179,7 +190,7 @@ describe('getVersions', () => {
     fs.mkdirSync(path.join(tmpDir, 'v1'));
     fs.mkdirSync(path.join(tmpDir, 'other'));
     fs.mkdirSync(path.join(tmpDir, 'v2x'));
-    fs.writeFileSync(path.join(tmpDir, 'v3.manifest.json'), '{}');
+    fs.writeFileSync(path.join(tmpDir, 'some-file.json'), '{}');
     expect(getVersions(tmpDir)).toEqual([1]);
   });
 
@@ -209,29 +220,31 @@ describe('getNextVersion', () => {
 });
 
 describe('generateBuildManifest', () => {
-  test('writes valid JSON with version, buildTime, and files', async () => {
+  test('writes valid JSON with schema, build, buildTime, and files', async () => {
     const distDir = path.join(tmpDir, 'dist');
     fs.mkdirSync(distDir);
     fs.writeFileSync(path.join(distDir, 'index.html'), '<html></html>');
 
-    const manifestPath = path.join(tmpDir, 'manifest.json');
-    await generateBuildManifest(distDir, manifestPath);
+    const manifestPath = path.join(distDir, 'tada.manifest.json');
+    await generateBuildManifest(distDir, manifestPath, 3);
 
     const raw = fs.readFileSync(manifestPath, 'utf8');
     const manifest = JSON.parse(raw) as BuildManifest;
 
-    expect(manifest.version).toBe(1);
+    expect(manifest.schema).toBe(1);
+    expect(manifest.build).toBe(3);
     expect(typeof manifest.buildTime).toBe('string');
     expect(manifest.buildTime).toMatch(/^\d{4}-\d{2}-\d{2}T/);
     expect(typeof manifest.files).toBe('object');
     expect('index.html' in manifest.files).toBe(true);
+    expect('tada.manifest.json' in manifest.files).toBe(false);
   });
 });
 
 describe('loadManifest', () => {
   test('loads and parses a manifest from a file', () => {
     const manifest = makeManifest({ 'index.html': 'abc123' });
-    const filePath = path.join(tmpDir, 'manifest.json');
+    const filePath = path.join(tmpDir, 'tada.manifest.json');
     fs.writeFileSync(filePath, JSON.stringify(manifest, null, 2) + '\n');
 
     const loaded = loadManifest(filePath);
@@ -247,10 +260,11 @@ describe('loadManifest', () => {
 describe('pruneOldVersions', () => {
   function setupVersions(versions: number[]) {
     for (const v of versions) {
-      fs.mkdirSync(path.join(tmpDir, `v${v}`));
+      const vDir = path.join(tmpDir, `v${v}`);
+      fs.mkdirSync(vDir);
       fs.writeFileSync(
-        path.join(tmpDir, `v${v}.manifest.json`),
-        JSON.stringify(makeManifest({})),
+        path.join(vDir, 'tada.manifest.json'),
+        JSON.stringify(makeManifest({}, v)),
       );
     }
   }
@@ -263,12 +277,18 @@ describe('pruneOldVersions', () => {
     expect(fs.existsSync(path.join(tmpDir, 'v3'))).toBe(true);
   });
 
-  test('also removes manifest files for pruned versions', () => {
+  test('removes manifests inside pruned version directories', () => {
     setupVersions([1, 2, 3]);
     pruneOldVersions(tmpDir);
-    expect(fs.existsSync(path.join(tmpDir, 'v1.manifest.json'))).toBe(false);
-    expect(fs.existsSync(path.join(tmpDir, 'v2.manifest.json'))).toBe(true);
-    expect(fs.existsSync(path.join(tmpDir, 'v3.manifest.json'))).toBe(true);
+    expect(fs.existsSync(path.join(tmpDir, 'v1', 'tada.manifest.json'))).toBe(
+      false,
+    );
+    expect(fs.existsSync(path.join(tmpDir, 'v2', 'tada.manifest.json'))).toBe(
+      true,
+    );
+    expect(fs.existsSync(path.join(tmpDir, 'v3', 'tada.manifest.json'))).toBe(
+      true,
+    );
   });
 
   test('keeps all versions when there are 2 or fewer', () => {

package/build/build-manifest.ts

@@ -2,9 +2,11 @@ import fs from 'fs';
 import path from 'path';
 
 const EXCLUDED_DIRS = new Set(['pagefind']);
+const EXCLUDED_FILES = new Set(['tada.manifest.json']);
 
 export interface BuildManifest {
-  version: 1;
+  schema: 1;
+  build: number;
   buildTime: string;
   files: Record<string, string>;
 }
@@ -72,6 +74,9 @@ export async function walkAndHash(
     if (EXCLUDED_DIRS.has(topLevel)) {
       continue;
     }
+    if (EXCLUDED_FILES.has(entry.name)) {
+      continue;
+    }
 
     result[rel] = await hashFile(abs);
   }
@@ -112,10 +117,12 @@ export function getNextVersion(prodBaseDir: string): number {
 export async function generateBuildManifest(
   distDir: string,
   manifestPath: string,
+  buildVersion: number,
 ): Promise<void> {
   const files = await walkAndHash(distDir);
   const manifest: BuildManifest = {
-    version: 1,
+    schema: 1,
+    build: buildVersion,
     buildTime: new Date().toISOString(),
     files,
   };
@@ -142,9 +149,6 @@ export function pruneOldVersions(prodBaseDir: string): number[] {
   for (const v of toRemove) {
     const vDir = path.join(prodBaseDir, `v${v}`);
     fs.rmSync(vDir, { recursive: true, force: true });
-
-    const manifestFile = path.join(prodBaseDir, `v${v}.manifest.json`);
-    fs.rmSync(manifestFile, { force: true });
   }
 
   return toRemove;

package/build/generate-content-assets.ts

@@ -2,6 +2,8 @@ import fs from 'fs';
 import path from 'path';
 import { makeLogger } from './log';
 import { isFeatureEnabled } from './features';
+import { validateConfigLinks } from './validate-config-links';
+import { json } from './templates';
 import { initHighlighter } from './utils/shiki-highlighter';
 import {
   getBuildContentFiles,
@@ -257,6 +259,15 @@ export class ContentRenderer {
     );
     const errors: Error[] = [];
 
+    const configLinkErrors = validateConfigLinks(
+      validInternalTargets,
+      json('nav.json'),
+      json('authors.json'),
+    );
+    for (const msg of configLinkErrors) {
+      errors.push(new Error(msg));
+    }
+
     this.pruneRemovedSources(buildFileSet, removedHtmlAssetPaths);
 
     if (dirtySourceFiles.size > 0) {

package/build/{generate-manifest.ts → generate-web-app-manifest.ts}

@@ -95,7 +95,7 @@ function createManifest(siteVariables: SiteVariables): WebAppManifest {
   };
 }
 
-export function generateManifest(
+export function generateWebAppManifest(
   siteVariables: SiteVariables,
   distDir: string,
 ): void {

package/build/pipeline.ts

@@ -13,7 +13,7 @@ import { bundle } from './bundle';
 import { copyFonts } from './generate-fonts';
 import { copyKatexAssets } from './generate-katex-assets';
 import { generateFavicons } from './generate-favicon';
-import { generateManifest } from './generate-manifest';
+import { generateWebAppManifest } from './generate-web-app-manifest';
 import { copyPublicFiles, copyContentAssets } from './copy';
 import { getProcessedExtensions } from './utils/file-types';
 import { ContentRenderer } from './generate-content-assets';
@@ -64,7 +64,7 @@ async function runPipeline(mode: 'development' | 'production'): Promise<void> {
   const assetFiles = results[0] as string[]; // bundle output filenames
 
   if (isFeatureEnabled(siteVariables, 'favicon')) {
-    generateManifest(siteVariables, distDir);
+    generateWebAppManifest(siteVariables, distDir);
   }
 
   const publicRelPaths = copyPublicFiles(publicDir, distDir);
@@ -93,9 +93,8 @@ async function runPipeline(mode: 'development' | 'production'): Promise<void> {
 
   // Phase 5: Build manifest (production only)
   if (!isDev) {
-    const prodBase = getProdDistDir();
-    const manifestPath = path.join(prodBase, `v${prodVersion!}.manifest.json`);
-    await generateBuildManifest(distDir, manifestPath);
+    const manifestPath = path.join(distDir, 'tada.manifest.json');
+    await generateBuildManifest(distDir, manifestPath, prodVersion!);
     log.info`Built dist-prod/v${prodVersion!}/`;
   }
 

package/build/utils/literate-java.ts

@@ -14,6 +14,8 @@ import type {
 
 const log = makeLogger(__filename);
 
+let runnerClassDir: string | null = null;
+
 const MAIN_PATTERN = /\bvoid\s+main\s*\(/m;
 
 export function parseLiterateJava(
@@ -111,33 +113,36 @@ export function compileJavaSource(
   return tempDir;
 }
 
-function ensureRunnerCompiled(runnerDir: string): void {
-  const sourceFile = path.join(runnerDir, 'LiterateRunner.java');
-  const classFile = path.join(runnerDir, 'LiterateRunner.class');
-
-  if (
-    fs.existsSync(classFile) &&
-    fs.statSync(classFile).mtimeMs >= fs.statSync(sourceFile).mtimeMs
-  ) {
-    log.debug`LiterateRunner.class is up to date`;
-    return;
+// Compile LiterateRunner.java into a per-process temp directory so that
+// parallel builds never clobber each other and a stale .class file from a
+// different Java version is never reused.
+function ensureRunnerCompiled(): string {
+  if (runnerClassDir) {
+    return runnerClassDir;
   }
 
-  log.debug`Compiling LiterateRunner.java`;
+  const sourceDir = path.join(__dirname, 'jdi-runner');
+  const sourceFile = path.join(sourceDir, 'LiterateRunner.java');
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'tada-runner-'));
+
+  log.debug`Compiling LiterateRunner.java into ${tempDir}`;
 
   try {
-    execFileSync('javac', ['LiterateRunner.java'], {
-      cwd: runnerDir,
+    execFileSync('javac', ['-d', tempDir, sourceFile], {
       timeout: 30000,
       stdio: ['pipe', 'pipe', 'pipe'],
     });
   } catch (err: unknown) {
     const execErr = err as { stderr?: Buffer; message: string };
     const stderr = execErr.stderr ? execErr.stderr.toString() : execErr.message;
+    fs.rmSync(tempDir, { recursive: true, force: true });
     throw new Error(`Failed to compile LiterateRunner.java:\n${stderr}`, {
       cause: err,
     });
   }
+
+  runnerClassDir = tempDir;
+  return tempDir;
 }
 
 export function executeLiterateJava(
@@ -146,8 +151,7 @@ export function executeLiterateJava(
   codeBlocks: LiterateCodeBlock[],
   stdin?: string,
 ): LiterateRunnerEntry[] {
-  const runnerDir = path.join(__dirname, 'jdi-runner');
-  ensureRunnerCompiled(runnerDir);
+  const runnerDir = ensureRunnerCompiled();
 
   const blockRanges = codeBlocks.map(b => [b.javaStartLine, b.javaEndLine]);
   const rangesJson = JSON.stringify(blockRanges);

package/build/utils/render.ts

@@ -7,6 +7,7 @@ import { makeLogger } from '../log';
 import { B } from '../colors';
 import createGlobals from '../globals';
 import { render, json } from '../templates';
+import { validateParentLink } from '../validate-config-links';
 import {
   extractJavaMethodToc,
   renderCodeSegment,
@@ -348,6 +349,15 @@ function renderPlainTextContent(
 
   resolveAuthor(pageVariablesProcessed, filePath);
 
+  const parentError = validateParentLink(
+    pageVariablesProcessed.parent,
+    filePath,
+    validInternalTargets,
+  );
+  if (parentError) {
+    throw new Error(parentError);
+  }
+
   const strippedContent = stripHtmlComments(content);
 
   const params = createTemplateParameters({

package/build/validate-config-links.test.ts

@@ -0,0 +1,239 @@
+import { describe, expect, test } from 'bun:test';
+import {
+  validateNavLinks,
+  validateAuthorLinks,
+  validateConfigLinks,
+  validateParentLink,
+} from './validate-config-links';
+
+describe('validateNavLinks', () => {
+  test('passes for valid internal links', () => {
+    const validTargets = new Set(['/lectures/index.html', '/labs/index.html']);
+    const navData = [
+      {
+        title: 'Topics',
+        links: [
+          { text: 'Lectures', internal: '/lectures/index.html' },
+          { text: 'Labs', internal: '/labs/index.html' },
+        ],
+      },
+    ];
+    expect(validateNavLinks(navData, validTargets)).toEqual([]);
+  });
+
+  test('reports broken internal links', () => {
+    const validTargets = new Set(['/about.html']);
+    const navData = [
+      {
+        title: 'Menu',
+        links: [{ text: 'Missing', internal: '/missing.html' }],
+      },
+    ];
+    const errors = validateNavLinks(navData, validTargets);
+    expect(errors).toHaveLength(1);
+    expect(errors[0]).toContain('/missing.html');
+    expect(errors[0]).toContain('nav.json');
+  });
+
+  test('reports multiple broken links', () => {
+    const validTargets = new Set<string>();
+    const navData = [
+      {
+        title: 'Menu',
+        links: [
+          { text: 'A', internal: '/a.html' },
+          { text: 'B', internal: '/b.html' },
+        ],
+      },
+    ];
+    const errors = validateNavLinks(navData, validTargets);
+    expect(errors).toHaveLength(2);
+  });
+
+  test('skips disabled links', () => {
+    const validTargets = new Set<string>();
+    const navData = [
+      {
+        title: 'Menu',
+        links: [
+          { text: 'Coming Soon', internal: '/coming.html', disabled: true },
+        ],
+      },
+    ];
+    expect(validateNavLinks(navData, validTargets)).toEqual([]);
+  });
+
+  test('skips external links', () => {
+    const validTargets = new Set<string>();
+    const navData = [
+      {
+        title: 'External',
+        links: [{ text: 'Google', external: 'https://google.com' }],
+      },
+    ];
+    expect(validateNavLinks(navData, validTargets)).toEqual([]);
+  });
+
+  test('normalizes paths before checking', () => {
+    const validTargets = new Set(['/docs/guide.html']);
+    const navData = [
+      {
+        title: 'Menu',
+        links: [{ text: 'Guide', internal: '/docs/../docs/guide.html' }],
+      },
+    ];
+    expect(validateNavLinks(navData, validTargets)).toEqual([]);
+  });
+
+  test('returns empty array for empty nav data', () => {
+    expect(validateNavLinks([], new Set())).toEqual([]);
+  });
+
+  test('returns empty array for null/undefined nav data', () => {
+    expect(validateNavLinks(null, new Set())).toEqual([]);
+    expect(validateNavLinks(undefined, new Set())).toEqual([]);
+  });
+});
+
+describe('validateAuthorLinks', () => {
+  test('passes for valid author url and avatar', () => {
+    const validTargets = new Set(['/about/alex.html', '/avatars/alex.jpg']);
+    const authorsData = {
+      alex: {
+        name: 'Alex',
+        avatar: '/avatars/alex.jpg',
+        url: '/about/alex.html',
+      },
+    };
+    expect(validateAuthorLinks(authorsData, validTargets)).toEqual([]);
+  });
+
+  test('reports broken author url', () => {
+    const validTargets = new Set(['/avatars/alex.jpg']);
+    const authorsData = {
+      alex: { name: 'Alex', avatar: '/avatars/alex.jpg', url: '/missing.html' },
+    };
+    const errors = validateAuthorLinks(authorsData, validTargets);
+    expect(errors).toHaveLength(1);
+    expect(errors[0]).toContain('/missing.html');
+    expect(errors[0]).toContain('authors.json');
+    expect(errors[0]).toContain('alex');
+  });
+
+  test('reports broken avatar path', () => {
+    const validTargets = new Set<string>();
+    const authorsData = {
+      alex: { name: 'Alex', avatar: '/avatars/missing.jpg' },
+    };
+    const errors = validateAuthorLinks(authorsData, validTargets);
+    expect(errors).toHaveLength(1);
+    expect(errors[0]).toContain('/avatars/missing.jpg');
+    expect(errors[0]).toContain('avatar');
+  });
+
+  test('reports both broken url and avatar', () => {
+    const validTargets = new Set<string>();
+    const authorsData = {
+      alex: {
+        name: 'Alex',
+        avatar: '/avatars/missing.jpg',
+        url: '/missing.html',
+      },
+    };
+    const errors = validateAuthorLinks(authorsData, validTargets);
+    expect(errors).toHaveLength(2);
+  });
+
+  test('skips author without url field', () => {
+    const validTargets = new Set(['/avatars/alex.jpg']);
+    const authorsData = { alex: { name: 'Alex', avatar: '/avatars/alex.jpg' } };
+    expect(validateAuthorLinks(authorsData, validTargets)).toEqual([]);
+  });
+
+  test('returns empty array for null/undefined authors data', () => {
+    expect(validateAuthorLinks(null, new Set())).toEqual([]);
+    expect(validateAuthorLinks(undefined, new Set())).toEqual([]);
+  });
+
+  test('validates multiple authors independently', () => {
+    const validTargets = new Set(['/avatars/alex.jpg']);
+    const authorsData = {
+      alex: { name: 'Alex', avatar: '/avatars/alex.jpg' },
+      bob: { name: 'Bob', avatar: '/avatars/bob.jpg' },
+    };
+    const errors = validateAuthorLinks(authorsData, validTargets);
+    expect(errors).toHaveLength(1);
+    expect(errors[0]).toContain('bob');
+  });
+});
+
+describe('validateConfigLinks', () => {
+  test('combines nav and author errors', () => {
+    const validTargets = new Set(['/avatars/alex.jpg']);
+    const navData = [
+      {
+        title: 'Menu',
+        links: [{ text: 'Missing', internal: '/missing.html' }],
+      },
+    ];
+    const authorsData = {
+      alex: {
+        name: 'Alex',
+        avatar: '/avatars/alex.jpg',
+        url: '/also-missing.html',
+      },
+    };
+    const errors = validateConfigLinks(validTargets, navData, authorsData);
+    expect(errors).toHaveLength(2);
+  });
+
+  test('returns empty array when everything is valid', () => {
+    const validTargets = new Set(['/about.html', '/avatars/a.jpg']);
+    const navData = [
+      { title: 'Menu', links: [{ text: 'About', internal: '/about.html' }] },
+    ];
+    const authorsData = { a: { name: 'A', avatar: '/avatars/a.jpg' } };
+    expect(validateConfigLinks(validTargets, navData, authorsData)).toEqual([]);
+  });
+
+  test('handles missing authors.json gracefully', () => {
+    const validTargets = new Set(['/about.html']);
+    const navData = [
+      { title: 'Menu', links: [{ text: 'About', internal: '/about.html' }] },
+    ];
+    expect(validateConfigLinks(validTargets, navData, undefined)).toEqual([]);
+  });
+});
+
+describe('validateParentLink', () => {
+  test('returns null for valid parent link', () => {
+    const validTargets = new Set(['/lectures/index.html']);
+    expect(
+      validateParentLink('/lectures/index.html', 'test.md', validTargets),
+    ).toBeNull();
+  });
+
+  test('returns error for broken parent link', () => {
+    const validTargets = new Set<string>();
+    const error = validateParentLink(
+      '/missing/index.html',
+      'content/page.md',
+      validTargets,
+    );
+    expect(error).not.toBeNull();
+    expect(error).toContain('/missing/index.html');
+    expect(error).toContain('content/page.md');
+    expect(error).toContain('parent');
+  });
+
+  test('returns null when parent is undefined', () => {
+    expect(validateParentLink(undefined, 'test.md', new Set())).toBeNull();
+  });
+
+  test('normalizes parent path before checking', () => {
+    const validTargets = new Set(['/docs/index.html']);
+    expect(
+      validateParentLink('/docs/../docs/index.html', 'test.md', validTargets),
+    ).toBeNull();
+  });
+});

package/build/validate-config-links.ts

@@ -0,0 +1,105 @@
+import { normalizeOutputPath } from './utils/paths';
+
+interface NavLink {
+  text: string;
+  internal?: string;
+  external?: string;
+  disabled?: boolean;
+}
+
+interface NavSection {
+  title: string;
+  links: NavLink[];
+}
+
+export function validateNavLinks(
+  navData: unknown,
+  validTargets: Set<string>,
+): string[] {
+  if (!Array.isArray(navData)) {
+    return [];
+  }
+
+  const errors: string[] = [];
+
+  for (const section of navData as NavSection[]) {
+    for (const link of section.links) {
+      if (link.disabled || !link.internal) {
+        continue;
+      }
+
+      const normalized = normalizeOutputPath(link.internal);
+      if (!validTargets.has(normalized)) {
+        errors.push(
+          `nav.json: broken internal link in section "${section.title}": "${link.internal}"`,
+        );
+      }
+    }
+  }
+
+  return errors;
+}
+
+interface AuthorEntry {
+  name: string;
+  avatar: string;
+  url?: string;
+}
+
+export function validateAuthorLinks(
+  authorsData: unknown,
+  validTargets: Set<string>,
+): string[] {
+  if (!authorsData || typeof authorsData !== 'object') {
+    return [];
+  }
+
+  const errors: string[] = [];
+  const authors = authorsData as Record<string, AuthorEntry>;
+
+  for (const [key, author] of Object.entries(authors)) {
+    const avatarPath = normalizeOutputPath(author.avatar);
+    if (!validTargets.has(avatarPath)) {
+      errors.push(
+        `authors.json: broken avatar path for "${key}": "${author.avatar}"`,
+      );
+    }
+
+    if (author.url) {
+      const urlPath = normalizeOutputPath(author.url);
+      if (!validTargets.has(urlPath)) {
+        errors.push(`authors.json: broken url for "${key}": "${author.url}"`);
+      }
+    }
+  }
+
+  return errors;
+}
+
+export function validateConfigLinks(
+  validTargets: Set<string>,
+  navData: unknown,
+  authorsData: unknown,
+): string[] {
+  return [
+    ...validateNavLinks(navData, validTargets),
+    ...validateAuthorLinks(authorsData, validTargets),
+  ];
+}
+
+export function validateParentLink(
+  parent: unknown,
+  filePath: string,
+  validTargets: Set<string>,
+): string | null {
+  if (!parent || typeof parent !== 'string') {
+    return null;
+  }
+
+  const normalized = normalizeOutputPath(parent);
+  if (!validTargets.has(normalized)) {
+    return `${filePath}: broken parent link: "${parent}"`;
+  }
+
+  return null;
+}

package/build/watch.ts

@@ -20,7 +20,7 @@ import { bundle } from './bundle';
 import { copyFonts } from './generate-fonts';
 import { copyKatexAssets } from './generate-katex-assets';
 import { generateFavicons } from './generate-favicon';
-import { generateManifest } from './generate-manifest';
+import { generateWebAppManifest } from './generate-web-app-manifest';
 import {
   copyPublicFiles,
   copyContentAssets,
@@ -239,7 +239,7 @@ async function initialBuild(): Promise<void> {
 
   if (isFeatureEnabled(siteVariables, 'favicon')) {
     await generateFavicons(siteVariables, distDir);
-    generateManifest(siteVariables, distDir);
+    generateWebAppManifest(siteVariables, distDir);
   }
 
   publicRelPaths = copyPublicFiles(publicDir, distDir);
@@ -341,7 +341,7 @@ async function rebuild(): Promise<void> {
 
       if (isFeatureEnabled(siteVariables, 'favicon')) {
         await generateFavicons(siteVariables, distDir);
-        generateManifest(siteVariables, distDir);
+        generateWebAppManifest(siteVariables, distDir);
       }
 
       const result = contentRenderer.processContent({ distDir, assetFiles });
@@ -524,6 +524,7 @@ initialBuild()
     const configWatcher = chokidar.watch(jsonDataDir, {
       ignoreInitial: true,
       depth: 0,
+      awaitWriteFinish: { stabilityThreshold: 100 },
     });
     const onConfigFileChange = (filePath: string) => {
       if (configFilePaths.has(path.resolve(filePath))) {

package/init/content/labs/00/VowelCounter.java.md

@@ -61,46 +61,45 @@ from the standard in, counting how many characters are vowels. When there are
 no more characters in the stream, the program prints the total number of vowels.
 
 <!---
-Hiding the method signature for main() keeps us focused on the program's logic,
+Hiding the first few lines keeps us focused on the program's logic,
 and avoids discussion of IOException.
 ```
-void main() throws Exception {
+public class VowelCounter {
+    public static void main(String[] args) throws Exception {
 ```
 -->
 
 We'll start the program with a `numVowels` counter initialized to zero,
-the additive identity, and a second integer variable `ch` used to store the
-return value of the `read()` method:
+the additive identity.
 
 ```
-    int numVowels = 0;
-    int ch;
+        int numVowels = 0;
 ```
 
 Using an indefinite loop (since we don't know in advance how many characters
 we'll get), we call the `read()` method and check if it returned the sentinel:
 
 ```
-    while (true) {
-        ch = System.in.read();
-        if (ch == -1) {
-            break;
-        }
+        while (true) {
+            int ch = System.in.read();
+            if (ch == -1) {
+                break;
+            }
 ```
 
 If `read()` returns the sentinel, we stop the loop with `break`. Otherwise,
 we test whether `ch` is a vowel:
 
 ```
-        if ("aeiouAEIOU".indexOf(ch) >= 0) {
-            numVowels++;
-        }
+            if ("aeiouAEIOU".indexOf(ch) >= 0) {
+                numVowels++;
+            }
 ```
 
 <!---
 Hide the closing brace of the `while` loop to avoid indenting the conditional.
 ```
-    }
+        }
 ```
 -->
 
@@ -118,12 +117,13 @@ hello, world!
 Then the last line of the program, which prints the total count, will output 3:
 
 ```
-    IO.println("vowels: " + numVowels);
+        System.out.println("vowels: " + numVowels);
 ```
 
 <!---
-Hiding the closing brace for main().
+Hiding the closing braces.
 ```
+    }
 }
 ```
 -->

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abreen/tada",
-  "version": "1.3.2",
+  "version": "1.4.0",
   "type": "module",
   "description": "A static site generator",
   "license": "MIT",
@@ -40,7 +40,6 @@
     "linux"
   ],
   "dependencies": {
-    "@tsconfig/node23": "^23.0.2",
     "@vscode/markdown-it-katex": "^1.1.2",
     "ajv": "^8.17.1",
     "chokidar": "^4.0.0",
@@ -72,7 +71,6 @@
   },
   "devDependencies": {
     "@eslint/js": "^10.0.1",
-    "@playwright/test": "^1.43.0",
     "@types/bun": "^1.3.10",
     "@types/culori": "^4.0.1",
     "@types/fontkit": "^2.0.8",
@@ -84,7 +82,6 @@
     "lint-staged": "^16.4.0",
     "prettier": "^3.6.2",
     "prettier-plugin-curly": "^0.4.1",
-    "rimraf": "^6.1.3",
     "typescript": "^5.4.5",
     "typescript-eslint": "^8.57.1"
   }