svn-visualizer 0.1.0

package/src/gather.ts

@@ -0,0 +1,93 @@
+import {spawn} from 'node:child_process';
+import {access} from 'node:fs/promises';
+import {z} from 'zod';
+import {type Commit, type DataSet} from './model.js';
+import {parseInfoRevision, parseInfoXml, parseLogXml} from './svn-parser.js';
+import {assertSameSource, mergeCommits, readData, revisionCheckpoint, writeData} from './store.js';
+
+const gatherOptionsSchema = z.object({
+	url: z.url(),
+	username: z.string().min(1).optional(),
+	passwordEnv: z.string().regex(/^[a-z_]\w*$/iu),
+	dataFile: z.string().min(1),
+	svnBinary: z.string().min(1),
+});
+
+export type GatherOptions = z.input<typeof gatherOptionsSchema>;
+
+type CommandResult = {readonly stdout: string; readonly stderr: string};
+
+function runSvn(binary: string, arguments_: readonly string[], password?: string): Promise<CommandResult> {
+	return new Promise((resolve, reject) => {
+		const child = spawn(binary, arguments_, {stdio: ['pipe', 'pipe', 'pipe']});
+		let stdout = '';
+		let stderr = '';
+		child.stdout.setEncoding('utf8').on('data', (chunk: string) => {
+			stdout += chunk;
+		});
+		child.stderr.setEncoding('utf8').on('data', (chunk: string) => {
+			stderr += chunk;
+		});
+		child.on('error', (error) => {
+			reject(new Error(`Unable to run ${binary}: ${error.message}`, {cause: error}));
+		});
+		child.on('close', (code) => {
+			if (code === 0) {
+				resolve({stdout, stderr});
+			} else {
+				reject(new Error(`${binary} exited with code ${String(code)}: ${stderr.trim()}`));
+			}
+		});
+		child.stdin.end(password === undefined ? undefined : `${password}\n`);
+	});
+}
+
+function authArguments(username: string | undefined, password: string | undefined): string[] {
+	const result = ['--non-interactive', '--trust-server-cert-failures=unknown-ca,cn-mismatch,expired,not-yet-valid,other'];
+	if (username !== undefined) {
+		result.push('--username', username);
+	}
+	if (password !== undefined) {
+		result.push('--password-from-stdin', '--no-auth-cache');
+	}
+	return result;
+}
+
+async function existingData(filePath: string): Promise<DataSet | undefined> {
+	try {
+		await access(filePath);
+	} catch {
+		return undefined;
+	}
+	return readData(filePath);
+}
+
+export async function gather(rawOptions: GatherOptions): Promise<{readonly added: number; readonly data: DataSet}> {
+	const options = gatherOptionsSchema.parse(rawOptions);
+	const password = process.env[options.passwordEnv];
+	const auth = authArguments(options.username, password);
+	const info = await runSvn(options.svnBinary, ['info', '--xml', ...auth, options.url], password);
+	const source = parseInfoXml(info.stdout, options.url);
+	const headRevision = parseInfoRevision(info.stdout);
+	const previous = await existingData(options.dataFile);
+	if (previous !== undefined) {
+		assertSameSource(previous.source, source);
+	}
+
+	const lastRevision = previous?.lastRevision ?? 0;
+	let incoming: Commit[] = [];
+	if (lastRevision < headRevision) {
+		const log = await runSvn(options.svnBinary, ['log', '--xml', ...auth, '--revision', `${lastRevision + 1}:HEAD`, options.url], password);
+		incoming = parseLogXml(log.stdout);
+	}
+	const commits = mergeCommits(previous?.commits ?? [], incoming);
+	const data = {
+		schemaVersion: 1,
+		source,
+		lastRevision: revisionCheckpoint(lastRevision, headRevision),
+		gatheredAt: new Date().toISOString(),
+		commits,
+	} satisfies DataSet;
+	await writeData(options.dataFile, data);
+	return {added: incoming.length, data};
+}

package/src/index.ts

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+import {createProgram} from './cli.js';
+
+try {
+	await createProgram().parseAsync();
+} catch (error: unknown) {
+	console.error(error instanceof Error ? error.message : String(error));
+	process.exitCode = 1;
+}

package/src/model.ts

@@ -0,0 +1,32 @@
+import {z} from 'zod';
+
+export const commitSchema = z
+	.object({
+		revision: z.number().int().positive(),
+		author: z.string().nullable(),
+		date: z.iso.datetime({offset: true}),
+		message: z.string(),
+	})
+	.strict();
+
+export const sourceSchema = z
+	.object({
+		requestedUrl: z.url(),
+		root: z.url(),
+		uuid: z.string().min(1),
+	})
+	.strict();
+
+export const dataSchema = z
+	.object({
+		schemaVersion: z.literal(1),
+		source: sourceSchema,
+		lastRevision: z.number().int().nonnegative(),
+		gatheredAt: z.iso.datetime({offset: true}),
+		commits: z.array(commitSchema),
+	})
+	.strict();
+
+export type Commit = z.infer<typeof commitSchema>;
+export type DataSet = z.infer<typeof dataSchema>;
+export type Source = z.infer<typeof sourceSchema>;

package/src/report.test.ts

@@ -0,0 +1,91 @@
+import {mkdtemp, readFile} from 'node:fs/promises';
+import {tmpdir} from 'node:os';
+import path from 'node:path';
+import {describe, expect, it} from 'vitest';
+import {type DataSet} from './model.js';
+import {generate, renderHtml, safeJson} from './report.js';
+import {writeData} from './store.js';
+
+describe('HTML rendering', () => {
+	it('escapes markup and script payloads', () => {
+		const page = renderHtml(
+			{
+				title: '<img src=x onerror=alert(1)>',
+				sourceUrl: 'https://example.test/?x=<tag>&y=1',
+				generatedAt: '2026-01-01T00:00:00.000Z',
+				range: {from: '2026-01-01', to: '2026-01-01'},
+				total: 0,
+				users: {labels: ['</script><script>alert(1)</script>'], values: [1]},
+				weekdays: {labels: [], values: []},
+				hours: {labels: [], values: []},
+				days: {labels: [], values: []},
+				daysByUser: {labels: [], datasets: []},
+				months: {labels: [], values: []},
+				recent: [],
+			},
+			'console.log("</script>")',
+		);
+		expect(page).not.toContain('<img src=x');
+		expect(page).not.toContain('</script><script>alert');
+		expect(page).toContain('&lt;img');
+		expect(page).toContain(String.raw`<\/script>`);
+		expect(page).toContain('<tbody id="commits">');
+		expect(safeJson({value: '\u2028<&'})).toBe(String.raw`{"value":"\u2028\u003c\u0026"}`);
+	});
+
+	it('escapes commit messages embedded in the report data', () => {
+		const page = renderHtml(
+			{
+				title: 't',
+				sourceUrl: 'https://example.test/',
+				generatedAt: '2026-01-01T00:00:00.000Z',
+				range: {from: '2026-01-01', to: '2026-01-01'},
+				total: 1,
+				users: {labels: [], values: []},
+				weekdays: {labels: [], values: []},
+				hours: {labels: [], values: []},
+				days: {labels: [], values: []},
+				daysByUser: {labels: [], datasets: []},
+				months: {labels: [], values: []},
+				recent: [{revision: 1, author: 'ada', date: '2026-01-01T00:00:00.000Z', message: '<script>alert(1)</script>'}],
+			},
+			'',
+		);
+		expect(page).not.toContain('<script>alert(1)</script>');
+		expect(page).toContain(String.raw`\u003cscript\u003ealert(1)\u003c/script\u003e`);
+	});
+});
+
+describe('report generation', () => {
+	it('writes a self-contained HTML report from a data file', async () => {
+		const directory = await mkdtemp(path.join(tmpdir(), 'svn-visualizer-'));
+		const dataFile = path.join(directory, 'data.json');
+		const data: DataSet = {
+			schemaVersion: 1,
+			source: {requestedUrl: 'https://example.test/svn/project/trunk', root: 'https://example.test/svn/project', uuid: 'fixture'},
+			lastRevision: 2,
+			gatheredAt: '2026-01-03T00:00:00.000Z',
+			commits: [
+				{revision: 1, author: 'ada', date: '2026-01-01T12:00:00.000Z', message: 'Initial import'},
+				{revision: 2, author: 'lin', date: '2026-01-02T15:30:00.000Z', message: 'Ship report'},
+			],
+		};
+		await writeData(dataFile, data);
+
+		const outputFile = await generate({dataFile, outputDir: path.join(directory, 'output'), title: 'Integration report'}, 'console.log("chart.js")');
+
+		expect(outputFile).toBe(path.join(directory, 'output', 'index.html'));
+		const html = await readFile(outputFile, 'utf8');
+		for (const expected of [
+			'Integration report',
+			'2</strong>',
+			'https://example.test/svn/project/trunk',
+			'console.log("chart.js")',
+			'Recent commits',
+			'Ship report',
+		]) {
+			expect(html).toContain(expected);
+		}
+		expect(/src=["']https?:/u.test(html)).toBe(false);
+	});
+});

package/src/report.ts

@@ -0,0 +1,88 @@
+import {mkdir, readFile, writeFile} from 'node:fs/promises';
+import path from 'node:path';
+import {fileURLToPath} from 'node:url';
+import {z} from 'zod';
+import {aggregate, resolveRange, type ReportData} from './aggregation.js';
+import {readData} from './store.js';
+
+const generateOptionsSchema = z.object({
+	dataFile: z.string().min(1),
+	outputDir: z.string().min(1),
+	from: z.string().optional(),
+	to: z.string().optional(),
+	relativeDays: z.number().int().positive().optional(),
+	title: z.string().min(1).default('Subversion activity'),
+});
+
+export type GenerateOptions = z.input<typeof generateOptionsSchema>;
+
+type PageData = ReportData & {
+	readonly title: string;
+	readonly sourceUrl: string;
+	readonly generatedAt: string;
+};
+
+export function escapeHtml(value: string): string {
+	return value.replaceAll('&', '&amp;').replaceAll('<', '&lt;').replaceAll('>', '&gt;').replaceAll('"', '&quot;').replaceAll("'", '&#39;');
+}
+
+export function safeJson(value: unknown): string {
+	return JSON.stringify(value)
+		.replaceAll('&', String.raw`\u0026`)
+		.replaceAll('<', String.raw`\u003c`)
+		.replaceAll('>', String.raw`\u003e`)
+		.replaceAll('\u2028', String.raw`\u2028`)
+		.replaceAll('\u2029', String.raw`\u2029`);
+}
+
+export function renderHtml(data: PageData, clientScript: string): string {
+	const title = escapeHtml(data.title);
+	const source = escapeHtml(data.sourceUrl);
+	return `<!doctype html>
+<html lang="en">
+<head>
+	<meta charset="utf-8">
+	<meta name="viewport" content="width=device-width,initial-scale=1">
+	<title>${title}</title>
+	<style>
+		:root{color-scheme:dark;--ink:#f4efe4;--muted:#aaa69d;--panel:#18201f;--line:#34413e;--accent:#f3b33d;--cool:#6dc8bf}*{box-sizing:border-box}body{margin:0;background:#0c1110;color:var(--ink);font:16px/1.5 Inter,ui-sans-serif,system-ui,sans-serif}body:before{content:"";position:fixed;inset:0;pointer-events:none;background:radial-gradient(circle at 80% 0,#24423b 0,transparent 38%),linear-gradient(120deg,transparent 0 48%,#ffffff05 48% 49%,transparent 49%);z-index:-1}.wrap{width:min(1180px,calc(100% - 32px));margin:auto;padding:56px 0 72px}header{border-left:5px solid var(--accent);padding-left:24px;margin-bottom:36px}h1{font-family:Georgia,serif;font-size:clamp(2.25rem,6vw,5rem);font-weight:500;line-height:.95;letter-spacing:-.045em;margin:0 0 20px}.eyebrow{color:var(--accent);font-size:.75rem;font-weight:800;letter-spacing:.18em;text-transform:uppercase}.meta{display:flex;flex-wrap:wrap;gap:8px 24px;color:var(--muted);font-size:.875rem}.meta a{color:var(--cool);overflow-wrap:anywhere}.total{display:grid;grid-template-columns:auto 1fr;align-items:end;gap:18px;margin:28px 0}.total strong{font:500 clamp(4rem,14vw,9rem)/.8 Georgia,serif;color:var(--accent)}.total span{max-width:12rem;color:var(--muted);text-transform:uppercase;letter-spacing:.12em;font-weight:700}.grid{display:grid;grid-template-columns:repeat(2,minmax(0,1fr));gap:18px}.card{min-width:0;background:color-mix(in srgb,var(--panel) 94%,transparent);border:1px solid var(--line);border-radius:4px;padding:22px;box-shadow:0 16px 42px #0003}.card.wide{grid-column:1/-1}.card h2{font:500 1.25rem Georgia,serif;margin:0 0 18px}.chart{position:relative;height:280px}.wide .chart{height:330px}table.commits{width:100%;border-collapse:collapse;font-size:.875rem}table.commits th,table.commits td{text-align:left;padding:9px 12px;border-bottom:1px solid var(--line);vertical-align:top}table.commits th{color:var(--muted);font-size:.7rem;font-weight:700;letter-spacing:.08em;text-transform:uppercase}table.commits td.rev{color:var(--accent);font-variant-numeric:tabular-nums;white-space:nowrap}table.commits td.date{white-space:nowrap;color:var(--muted)}table.commits .msg{overflow-wrap:anywhere}table.commits tbody tr:last-child td{border-bottom:none}footer{color:var(--muted);font-size:.75rem;margin-top:24px;text-align:right}@media(max-width:720px){.wrap{padding-top:32px}.grid{grid-template-columns:1fr}.card.wide{grid-column:auto}.chart,.wide .chart{height:260px}}
+	</style>
+</head>
+<body>
+	<main class="wrap">
+		<header><div class="eyebrow">Repository pulse / UTC</div><h1>${title}</h1><div class="meta"><span>${escapeHtml(data.range.from)} to ${escapeHtml(data.range.to)}</span><a href="${source}">${source}</a></div></header>
+		<section class="total" aria-label="Commit total"><strong>${String(data.total)}</strong><span>commits in selected period</span></section>
+		<section class="grid">
+			<article class="card wide"><h2>Last 30 days</h2><div class="chart"><canvas id="days" role="img" aria-label="Commits per day">Chart: commits per day.</canvas></div></article>
+			<article class="card wide"><h2>Commits per day and user</h2><div class="chart"><canvas id="days-by-user" role="img" aria-label="Commits per day and user">Chart: commits per day and user.</canvas></div></article>
+			<article class="card wide"><h2>Current and previous 11 months</h2><div class="chart"><canvas id="months" role="img" aria-label="Commits per month">Chart: commits per month.</canvas></div></article>
+			<article class="card"><h2>Contributors</h2><div class="chart"><canvas id="users" role="img" aria-label="Commits by contributor">Chart: commits by contributor.</canvas></div></article>
+			<article class="card"><h2>Weekday</h2><div class="chart"><canvas id="weekdays" role="img" aria-label="Commits by weekday in UTC">Chart: commits by weekday in UTC.</canvas></div></article>
+			<article class="card wide"><h2>Hour of day (UTC)</h2><div class="chart"><canvas id="hours" role="img" aria-label="Commits by hour in UTC">Chart: commits by hour in UTC.</canvas></div></article>
+			<article class="card wide"><h2>Recent commits</h2><table class="commits"><thead><tr><th>Revision</th><th>Author</th><th>Date (UTC)</th><th>Message</th></tr></thead><tbody id="commits"></tbody></table></article>
+		</section>
+		<footer>Generated ${escapeHtml(data.generatedAt)} · All dates and times UTC</footer>
+	</main>
+	<script id="report-data" type="application/json">${safeJson(data)}</script>
+	<script type="module">${clientScript.replaceAll('</script', String.raw`<\/script`)}</script>
+</body>
+</html>\n`;
+}
+
+export async function generate(rawOptions: GenerateOptions, clientScript?: string): Promise<string> {
+	const options = generateOptionsSchema.parse(rawOptions);
+	const data = await readData(options.dataFile);
+	const range = resolveRange(data.commits, options);
+	const reportData: PageData = {
+		...aggregate(data.commits, range),
+		title: options.title,
+		sourceUrl: data.source.requestedUrl,
+		generatedAt: new Date().toISOString(),
+	};
+	const clientUrl = new URL('client/main.js', import.meta.url);
+	const script = clientScript ?? (await readFile(fileURLToPath(clientUrl), 'utf8'));
+	const outputFile = path.resolve(options.outputDir, 'index.html');
+	await mkdir(path.dirname(outputFile), {recursive: true});
+	await writeFile(outputFile, renderHtml(reportData, script), 'utf8');
+	return outputFile;
+}

package/src/store.test.ts

@@ -0,0 +1,52 @@
+import {mkdtemp, readFile, writeFile} from 'node:fs/promises';
+import {tmpdir} from 'node:os';
+import path from 'node:path';
+import {describe, expect, it} from 'vitest';
+import {type Commit, type DataSet, type Source} from './model.js';
+import {assertSameSource, mergeCommits, readData, revisionCheckpoint, writeData} from './store.js';
+
+const source: Source = {requestedUrl: 'https://example.test/svn/trunk', root: 'https://example.test/svn', uuid: 'uuid'};
+const commits: Commit[] = [
+	{revision: 2, author: 'ada', date: '2026-01-02T00:00:00.000Z', message: 'two'},
+	{revision: 1, author: null, date: '2026-01-01T00:00:00.000Z', message: 'one'},
+];
+
+describe('data store', () => {
+	it('round-trips validated data atomically', async () => {
+		const directory = await mkdtemp(path.join(tmpdir(), 'svn-visualizer-'));
+		const file = path.join(directory, 'nested', 'data.json');
+		const data: DataSet = {schemaVersion: 1, source, lastRevision: 2, gatheredAt: '2026-01-03T00:00:00.000Z', commits};
+		await writeData(file, data);
+		await expect(readData(file)).resolves.toStrictEqual(data);
+		await expect(readFile(file, 'utf8')).resolves.toContain('\n\t"source"');
+	});
+
+	it('rejects invalid external state', async () => {
+		const directory = await mkdtemp(path.join(tmpdir(), 'svn-visualizer-'));
+		const file = path.join(directory, 'data.json');
+		await writeFile(file, '{"schemaVersion":2}', 'utf8');
+		await expect(readData(file)).rejects.toThrow('Invalid data file');
+	});
+
+	it('rejects source mismatches', () => {
+		expect(() => {
+			assertSameSource(source, {...source, uuid: 'other'});
+		}).toThrow('does not match');
+		expect(() => {
+			assertSameSource(source, source);
+		}).not.toThrow();
+	});
+
+	it('sorts, deduplicates, and checkpoints revisions', () => {
+		const [original] = commits;
+		if (original === undefined) {
+			throw new Error('Test fixture is missing a commit');
+		}
+		const replacement = {...original, message: 'updated'};
+		const merged = mergeCommits(commits, [replacement, {revision: 3, author: 'lin', date: '2026-01-03T00:00:00.000Z', message: 'three'}]);
+		expect(merged.map((commit) => commit.revision)).toStrictEqual([1, 2, 3]);
+		expect(merged[1]?.message).toBe('updated');
+		expect(revisionCheckpoint(0, 3)).toBe(3);
+		expect(revisionCheckpoint(9, 0)).toBe(9);
+	});
+});

package/src/store.ts

@@ -0,0 +1,48 @@
+import {mkdir, readFile, rename, rm, writeFile} from 'node:fs/promises';
+import path from 'node:path';
+import {dataSchema, type Commit, type DataSet, type Source} from './model.js';
+
+export async function readData(filePath: string): Promise<DataSet> {
+	let content: string;
+	try {
+		content = await readFile(filePath, 'utf8');
+	} catch (error: unknown) {
+		throw new Error(`Unable to read data file ${filePath}: ${error instanceof Error ? error.message : String(error)}`, {cause: error});
+	}
+	try {
+		return dataSchema.parse(JSON.parse(content) as unknown);
+	} catch (error: unknown) {
+		throw new Error(`Invalid data file ${filePath}: ${error instanceof Error ? error.message : String(error)}`, {cause: error});
+	}
+}
+
+export function assertSameSource(existing: Source, current: Source): void {
+	if (existing.requestedUrl !== current.requestedUrl || existing.root !== current.root || existing.uuid !== current.uuid) {
+		throw new Error('Data file source does not match the requested SVN repository');
+	}
+}
+
+export function mergeCommits(existing: readonly Commit[], incoming: readonly Commit[]): Commit[] {
+	const byRevision = new Map<number, Commit>();
+	for (const commit of [...existing, ...incoming]) {
+		byRevision.set(commit.revision, commit);
+	}
+	return [...byRevision.values()].sort((left, right) => left.revision - right.revision);
+}
+
+export function revisionCheckpoint(previous: number, repositoryHead: number): number {
+	return Math.max(previous, repositoryHead);
+}
+
+export async function writeData(filePath: string, data: DataSet): Promise<void> {
+	const validated = dataSchema.parse(data);
+	const directory = path.dirname(path.resolve(filePath));
+	await mkdir(directory, {recursive: true});
+	const temporary = path.join(directory, `.${path.basename(filePath)}.${process.pid}.${Date.now()}.tmp`);
+	try {
+		await writeFile(temporary, `${JSON.stringify(validated, null, '\t')}\n`, {encoding: 'utf8', mode: 0o600});
+		await rename(temporary, path.resolve(filePath));
+	} finally {
+		await rm(temporary, {force: true});
+	}
+}

package/src/svn-parser.test.ts

@@ -0,0 +1,34 @@
+import {describe, expect, it} from 'vitest';
+import {parseInfoRevision, parseInfoXml, parseLogXml} from './svn-parser.js';
+
+describe('SVN XML parser', () => {
+	it('parses entities and a singleton log entry', () => {
+		const commits = parseLogXml(
+			`<?xml version="1.0"?><log><logentry revision="7"><author>A &amp; B</author><date>2026-02-03T04:05:06.000Z</date><msg>Fix &lt;thing&gt;</msg></logentry></log>`,
+		);
+		expect(commits).toStrictEqual([{revision: 7, author: 'A & B', date: '2026-02-03T04:05:06.000Z', message: 'Fix <thing>'}]);
+	});
+
+	it('handles empty and missing optional text nodes', () => {
+		expect(parseLogXml('<?xml version="1.0"?><log></log>')).toStrictEqual([]);
+		expect(parseLogXml('<log><logentry revision="1"><date>2026-01-01T00:00:00Z</date><msg/></logentry></log>')).toStrictEqual([
+			{revision: 1, author: null, date: '2026-01-01T00:00:00Z', message: ''},
+		]);
+	});
+
+	it('rejects malformed XML', () => {
+		expect(() => parseLogXml('<log>')).toThrow(/Invalid SVN XML:/u);
+	});
+
+	it('parses repository identity', () => {
+		const source = parseInfoXml(
+			'<info><entry revision="0"><repository><root>https://example.test/svn/root</root><uuid>abc-123</uuid></repository></entry></info>',
+			'https://example.test/svn/root/trunk',
+		);
+		expect(source.uuid).toBe('abc-123');
+		expect(source.requestedUrl).toContain('/trunk');
+		expect(
+			parseInfoRevision('<info><entry revision="0"><repository><root>https://example.test/svn/root</root><uuid>abc-123</uuid></repository></entry></info>'),
+		).toBe(0);
+	});
+});

package/src/svn-parser.ts

@@ -0,0 +1,78 @@
+import {XMLParser} from 'fast-xml-parser';
+import {SyntaxValidator} from 'fast-xml-validator';
+import {z} from 'zod';
+import {commitSchema, sourceSchema, type Commit, type Source} from './model.js';
+
+const parser = new XMLParser({
+	ignoreAttributes: false,
+	attributeNamePrefix: '@_',
+	parseTagValue: false,
+	trimValues: false,
+	isArray: (_name, path): boolean => path === 'log.logentry',
+});
+
+const infoXmlSchema = z.object({
+	info: z.object({
+		entry: z.object({
+			'@_revision': z.coerce.number().int().nonnegative(),
+			repository: z.object({root: z.string().min(1), uuid: z.string().min(1)}),
+		}),
+	}),
+});
+
+const logContentsSchema = z.object({
+	logentry: z
+		.array(
+			z.object({
+				'@_revision': z.coerce.number().int().positive(),
+				author: z.union([z.string(), z.record(z.string(), z.never())]).optional(),
+				date: z.string(),
+				msg: z.union([z.string(), z.record(z.string(), z.never())]).optional(),
+			}),
+		)
+		.default([]),
+});
+
+const logXmlSchema = z.object({log: z.union([logContentsSchema, z.literal('')])});
+
+function parseXml(xml: string): unknown {
+	try {
+		SyntaxValidator.validate(xml);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		throw new Error(`Invalid SVN XML: ${message}`, {cause: error});
+	}
+	return parser.parse(xml) as unknown;
+}
+
+function text(value: string | Record<string, never> | undefined): string {
+	return typeof value === 'string' ? value : '';
+}
+
+export function parseInfoXml(xml: string, requestedUrl: string): Source {
+	const parsed = infoXmlSchema.parse(parseXml(xml));
+	return sourceSchema.parse({
+		requestedUrl,
+		root: parsed.info.entry.repository.root,
+		uuid: parsed.info.entry.repository.uuid,
+	});
+}
+
+export function parseInfoRevision(xml: string): number {
+	return infoXmlSchema.parse(parseXml(xml)).info.entry['@_revision'];
+}
+
+export function parseLogXml(xml: string): Commit[] {
+	const parsed = logXmlSchema.parse(parseXml(xml));
+	if (parsed.log === '') {
+		return [];
+	}
+	return parsed.log.logentry.map((entry) =>
+		commitSchema.parse({
+			revision: entry['@_revision'],
+			author: entry.author === undefined ? null : text(entry.author),
+			date: entry.date,
+			message: text(entry.msg),
+		}),
+	);
+}

package/tsconfig.json

@@ -0,0 +1,43 @@
+{
+	"compilerOptions": {
+		/* Language and Environment */
+		"target": "ES2023" /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */,
+		"lib": ["ES2023", "DOM"] /* Specify a set of bundled library declaration files that describe the target runtime environment. */,
+		"module": "ESNext" /* Specify what module code is generated. */,
+		"moduleResolution": "bundler" /* Specify how TypeScript looks up a file from a given module specifier. */,
+		"types": ["node"],
+		"esModuleInterop": true /* Emit additional JavaScript to ease support for importing CommonJS modules. */,
+		"resolveJsonModule": true /* Enable importing .json files. */,
+		"allowImportingTsExtensions": /* Allow imports to include TypeScript file extensions. */ true,
+		"noEmit": true /* Disable emitting files from a compilation. */,
+
+		/* Strict Type-Checking Options */
+		"strict": true /* Enable all strict type-checking options. */,
+		"noImplicitAny": true /* Enable error reporting for expressions and declarations with an implied 'any' type. */,
+		"strictNullChecks": true /* When type checking, take into account 'null' and 'undefined'. */,
+		"strictFunctionTypes": true /* When assigning functions, check to ensure parameters and the return values are subtype-compatible. */,
+		"strictBindCallApply": true /* Check that the arguments for 'bind', 'call', and 'apply' methods match the original function. */,
+		"strictPropertyInitialization": true /* Check for class properties that are declared but not set in the constructor. */,
+		"noImplicitThis": true /* Enable error reporting when 'this' is given the type 'any'. */,
+		"useUnknownInCatchVariables": true /* Default catch clause variables as 'unknown' instead of 'any'. */,
+		"alwaysStrict": true /* Ensure 'use strict' is always emitted. */,
+		"noUnusedLocals": true /* Enable error reporting when local variables aren't read. */,
+		"noUnusedParameters": true /* Raise an error when a function parameter isn't read. */,
+		"exactOptionalPropertyTypes": true /* Interpret optional property types as strictly typed, preventing assignment of 'undefined'. */,
+		"noImplicitReturns": true /* Enable error reporting for codepaths that do not explicitly return in a function. */,
+		"noFallthroughCasesInSwitch": true /* Enable error reporting for fallthrough cases in switch statements. */,
+		"noUncheckedIndexedAccess": true /* Add 'undefined' to a type when accessed using an index. */,
+		"noImplicitOverride": true /* Ensure overriding members in derived classes are marked with an override modifier. */,
+		"noPropertyAccessFromIndexSignature": true /* Enforces using indexed accessors for keys declared using an indexed type. */,
+		"allowUnusedLabels": false /* Disable error reporting for unused labels. */,
+		"allowUnreachableCode": false /* Disable error reporting for unreachable code. */,
+
+		/* Emit */
+		"outDir": "./dist" /* Specify an output folder for all emitted files. */,
+
+		/* Completeness */
+		"skipLibCheck": true /* Skip type checking all .d.ts files. */,
+		"forceConsistentCasingInFileNames": true /* Ensure that casing is correct in imports. */
+	},
+	"include": ["src/**/*"]
+}

package/vite.client.config.ts

@@ -0,0 +1,15 @@
+import path from 'node:path';
+import {defineConfig} from 'vite';
+
+export default defineConfig({
+	build: {
+		lib: {
+			entry: path.resolve(import.meta.dirname, 'src/client/main.ts'),
+			formats: ['es'],
+			fileName: 'main',
+		},
+		outDir: 'dist/client',
+		emptyOutDir: true,
+		target: 'es2022',
+	},
+});

package/vite.config.ts

@@ -0,0 +1,26 @@
+import {defineConfig} from 'vitest/config';
+import path from 'node:path';
+import packageJson from './package.json' with {type: 'json'};
+
+export default defineConfig({
+	define: {
+		APP_VERSION: JSON.stringify(packageJson.version),
+	},
+	build: {
+		ssr: true,
+		lib: {
+			entry: path.resolve(import.meta.dirname, 'src/index.ts'),
+			formats: ['es'],
+			fileName: 'index',
+		},
+		outDir: 'dist',
+		emptyOutDir: false,
+		target: 'node22',
+	},
+	test: {
+		coverage: {
+			provider: 'v8',
+			reporter: ['text', 'json', 'html', 'lcov'],
+		},
+	},
+});