@mulmoclaude/accounting-plugin 0.1.0

package/dist/server.js

@@ -0,0 +1,2074 @@
+import { ACCOUNTING_ACTIONS, ACCOUNTING_BOOKS_CHANNEL, BOOK_EVENT_KINDS, FISCAL_YEAR_ENDS, SUPPORTED_COUNTRY_CODES, TIME_SERIES_GRANULARITIES, TIME_SERIES_METRICS, bookChannel, errorMessage, fiscalYearEndMonth, isFiscalYearEnd, isSupportedCountryCode } from "./shared.js";
+import { Router } from "express";
+import { randomUUID } from "node:crypto";
+import { promises } from "node:fs";
+import path from "node:path";
+//#region src/server/context.ts
+var deps = null;
+/** Called once by the host before the accounting router is mounted. */
+function configureAccountingServer(context) {
+	deps = context;
+}
+/** Default workspace root for io calls that don't pass one explicitly.
+*  Throws if the host never configured the server — a real wiring bug
+*  (unit tests always pass an explicit root, so they never hit this). */
+function defaultWorkspaceRoot() {
+	if (!deps) throw new Error("@mulmoclaude/accounting-plugin: configureAccountingServer() must be called before serving accounting requests");
+	return deps.workspaceRoot;
+}
+var consoleLogger = {
+	error: (namespace, msg, data) => console.error(`[${namespace}] ${msg}`, data ?? ""),
+	warn: (namespace, msg, data) => console.warn(`[${namespace}] ${msg}`, data ?? ""),
+	info: () => {},
+	debug: () => {}
+};
+/** Logger proxy — forwards to the injected logger, console fallback
+*  before configuration. Lets call sites keep `log.warn("accounting", …)`. */
+var log = {
+	error: (namespace, msg, data) => (deps?.logger ?? consoleLogger).error(namespace, msg, data),
+	warn: (namespace, msg, data) => (deps?.logger ?? consoleLogger).warn(namespace, msg, data),
+	info: (namespace, msg, data) => (deps?.logger ?? consoleLogger).info(namespace, msg, data),
+	debug: (namespace, msg, data) => (deps?.logger ?? consoleLogger).debug(namespace, msg, data)
+};
+/** Workspace-relative directories this plugin owns. Mirrors the host
+*  META's `workspaceDirs` (kept in sync by value; the host META stays
+*  the codegen-discoverable source for the aggregator merge). */
+var ACCOUNTING_DIRS = {
+	accounting: "data/accounting",
+	accountingBooks: "data/accounting/books"
+};
+//#endregion
+//#region src/server/atomic.ts
+/** True for a `not found` filesystem error. */
+function isEnoent(err) {
+	return typeof err === "object" && err !== null && "code" in err && err.code === "ENOENT";
+}
+/** Atomic write: tmp alongside destination, then rename. */
+async function writeFileAtomic(filePath, content, opts = {}) {
+	const tmp = opts.uniqueTmp ? `${filePath}.${randomUUID()}.tmp` : `${filePath}.tmp`;
+	await promises.mkdir(path.dirname(filePath), { recursive: true });
+	try {
+		await promises.writeFile(tmp, content, { encoding: "utf-8" });
+		await promises.rename(tmp, filePath);
+	} catch (err) {
+		await promises.unlink(tmp).catch(() => {});
+		throw err;
+	}
+}
+/** Atomic JSON write (2-space indent), the only serialization shape the
+*  accounting io layer needs. */
+async function writeJsonAtomic(filePath, data, opts = {}) {
+	await writeFileAtomic(filePath, JSON.stringify(data, null, 2), opts);
+}
+//#endregion
+//#region src/server/io.ts
+var root = (workspaceRoot) => workspaceRoot ?? defaultWorkspaceRoot();
+function accountingRoot(workspaceRoot) {
+	return path.join(root(workspaceRoot), ACCOUNTING_DIRS.accounting);
+}
+function configPath(workspaceRoot) {
+	return path.join(accountingRoot(workspaceRoot), "config.json");
+}
+/** Allowed shape for a book id used as a directory name. Defense
+*  against path traversal: a crafted id like "../../config" or
+*  "/tmp/x" would otherwise let `bookRoot` escape the
+*  `data/accounting/books/` tree, since every write path joins
+*  `bookId` directly into the filesystem. The first character is
+*  alphanumeric to forbid leading dashes / underscores that some
+*  shells / docs render confusingly; `_` and `-` are allowed inside.
+*  64 chars is plenty for any reasonable book name. */
+var SAFE_BOOK_ID_RE = /^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$/;
+function isSafeBookId(bookId) {
+	return typeof bookId === "string" && SAFE_BOOK_ID_RE.test(bookId);
+}
+function assertSafeBookId(bookId) {
+	if (!isSafeBookId(bookId)) throw new Error(`accounting: invalid bookId ${JSON.stringify(bookId)} (allowed: alphanumeric / _ / -; 1-64 chars; cannot start with _ or -)`);
+}
+function bookRoot(bookId, workspaceRoot) {
+	assertSafeBookId(bookId);
+	return path.join(root(workspaceRoot), ACCOUNTING_DIRS.accountingBooks, bookId);
+}
+function accountsPath(bookId, workspaceRoot) {
+	return path.join(bookRoot(bookId, workspaceRoot), "accounts.json");
+}
+function journalDir(bookId, workspaceRoot) {
+	return path.join(bookRoot(bookId, workspaceRoot), "journal");
+}
+function journalFileFor(bookId, period, workspaceRoot) {
+	return path.join(journalDir(bookId, workspaceRoot), `${period}.jsonl`);
+}
+function snapshotsDir(bookId, workspaceRoot) {
+	return path.join(bookRoot(bookId, workspaceRoot), "snapshots");
+}
+function snapshotFileFor(bookId, period, workspaceRoot) {
+	return path.join(snapshotsDir(bookId, workspaceRoot), `${period}.json`);
+}
+async function fileExists(filePath) {
+	try {
+		await promises.access(filePath);
+		return true;
+	} catch {
+		return false;
+	}
+}
+/** Strict variant of `readJsonOrNull` from `./json.ts`: returns null
+*  on ENOENT but RETHROWS other read errors and parse failures so a
+*  corrupted accounting journal surfaces rather than silently
+*  collapsing to "no data". `./json.ts` keeps the permissive
+*  variant for user-config files where a single bad keystroke
+*  shouldn't 500 the server. */
+async function readJsonStrict(filePath) {
+	try {
+		const raw = await promises.readFile(filePath, "utf-8");
+		return JSON.parse(raw);
+	} catch (err) {
+		if (isEnoent(err)) return null;
+		throw err;
+	}
+}
+async function readConfig(workspaceRoot) {
+	return readJsonStrict(configPath(workspaceRoot));
+}
+async function writeConfig(config, workspaceRoot) {
+	await writeJsonAtomic(configPath(workspaceRoot), config);
+}
+async function readAccounts(bookId, workspaceRoot) {
+	return await readJsonStrict(accountsPath(bookId, workspaceRoot)) ?? [];
+}
+async function writeAccounts(bookId, accounts, workspaceRoot) {
+	await writeJsonAtomic(accountsPath(bookId, workspaceRoot), accounts);
+}
+/** Convert a YYYY-MM-DD date string to its YYYY-MM month bucket. The
+*  month bucket dictates which JSONL file the entry lives in. */
+function periodFromDate(date) {
+	if (!/^\d{4}-\d{2}-\d{2}$/.test(date)) throw new Error(`accounting: invalid date format ${JSON.stringify(date)} (expected YYYY-MM-DD)`);
+	return date.slice(0, 7);
+}
+/** Append one entry to the appropriate month's JSONL.
+*
+*  Uses POSIX append-only semantics (`fs.appendFile` → `O_APPEND`).
+*  Two concurrent callers landing in the same month file are
+*  serialised by the kernel — neither overwrites the other, which
+*  is the bug the previous read-modify-write implementation had.
+*
+*  Crash mid-write: an entry shorter than `PIPE_BUF` (≥ 512 bytes
+*  on every supported platform) writes atomically; a single
+*  serialised `JournalEntry` is comfortably under that. If the
+*  process is killed during the syscall the worst case is a torn
+*  trailing line, which `readJournalMonth` already tolerates by
+*  skipping unparseable lines and surfacing a `skipped` count to
+*  the caller. */
+async function appendJournal(bookId, entry, workspaceRoot) {
+	const file = journalFileFor(bookId, periodFromDate(entry.date), workspaceRoot);
+	await promises.mkdir(path.dirname(file), { recursive: true });
+	await promises.appendFile(file, `${JSON.stringify(entry)}\n`, { encoding: "utf-8" });
+}
+function groupEntriesByPeriod(entries) {
+	const byPeriod = /* @__PURE__ */ new Map();
+	for (const entry of entries) {
+		const period = periodFromDate(entry.date);
+		const list = byPeriod.get(period) ?? [];
+		list.push(entry);
+		byPeriod.set(period, list);
+	}
+	return byPeriod;
+}
+/** Append a batch of entries: same-period entries are concatenated
+*  into one `appendFile` call so the whole same-period chunk hits
+*  the kernel as a single `O_APPEND` write — small chunks (under
+*  `PIPE_BUF`, ≥ 512 bytes on every supported platform) are
+*  guaranteed atomic by POSIX, and `O_APPEND` serialises with any
+*  concurrent appender (a parallel `appendJournal` / `addEntries`
+*  call can never overwrite our write or vice versa). Cross-period
+*  batches loop one append per period; each is independently
+*  concurrency-safe but their union is not transactional across
+*  files (out of scope for the append-only JSONL design). */
+async function appendJournalBatch(bookId, entries, workspaceRoot) {
+	if (entries.length === 0) return;
+	const byPeriod = groupEntriesByPeriod(entries);
+	for (const [period, items] of byPeriod) {
+		const file = journalFileFor(bookId, period, workspaceRoot);
+		await promises.mkdir(path.dirname(file), { recursive: true });
+		const chunk = items.map((entry) => `${JSON.stringify(entry)}\n`).join("");
+		await promises.appendFile(file, chunk, { encoding: "utf-8" });
+	}
+}
+/** Read a single month's JSONL. Malformed lines are skipped (logged
+*  by the caller; this layer just returns the parseable subset) so
+*  one bad line doesn't lock the user out of their book. */
+async function readJournalMonth(bookId, period, workspaceRoot) {
+	const file = journalFileFor(bookId, period, workspaceRoot);
+	let raw;
+	try {
+		raw = await promises.readFile(file, "utf-8");
+	} catch (err) {
+		if (isEnoent(err)) return {
+			entries: [],
+			skipped: 0
+		};
+		throw err;
+	}
+	const entries = [];
+	let skipped = 0;
+	for (const line of raw.split("\n")) {
+		if (line.trim() === "") continue;
+		try {
+			entries.push(JSON.parse(line));
+		} catch {
+			skipped += 1;
+		}
+	}
+	return {
+		entries,
+		skipped
+	};
+}
+/** List the YYYY-MM periods that have a journal file on disk, sorted
+*  ascending. Useful for full-history scans (rebuilding snapshots
+*  from scratch). */
+async function listJournalPeriods(bookId, workspaceRoot) {
+	let names;
+	try {
+		names = await promises.readdir(journalDir(bookId, workspaceRoot));
+	} catch (err) {
+		if (isEnoent(err)) return [];
+		throw err;
+	}
+	return names.filter((name) => /^\d{4}-\d{2}\.jsonl$/.test(name)).map((name) => name.slice(0, 7)).sort();
+}
+async function readSnapshot(bookId, period, workspaceRoot) {
+	return readJsonStrict(snapshotFileFor(bookId, period, workspaceRoot));
+}
+async function writeSnapshot(bookId, snapshot, workspaceRoot) {
+	const file = snapshotFileFor(bookId, snapshot.period, workspaceRoot);
+	await promises.mkdir(path.dirname(file), { recursive: true });
+	await writeJsonAtomic(file, snapshot, { uniqueTmp: true });
+}
+/** Drop snapshot files for all periods >= `fromPeriod`. The next
+*  read regenerates them. Idempotent: missing files are silently
+*  ignored. */
+async function invalidateSnapshotsFrom(bookId, fromPeriod, workspaceRoot) {
+	let names;
+	try {
+		names = await promises.readdir(snapshotsDir(bookId, workspaceRoot));
+	} catch (err) {
+		if (isEnoent(err)) return { removed: [] };
+		throw err;
+	}
+	const removed = [];
+	for (const name of names) {
+		const match = /^(\d{4}-\d{2})\.json$/.exec(name);
+		if (!match) continue;
+		const [, period] = match;
+		if (period >= fromPeriod) {
+			await promises.rm(path.join(snapshotsDir(bookId, workspaceRoot), name), { force: true });
+			removed.push(period);
+		}
+	}
+	return { removed: removed.sort() };
+}
+/** Drop ALL snapshots for a book — used by `rebuildSnapshots()`
+*  with no `from`. Equivalent to `invalidateSnapshotsFrom("0000-00")`
+*  but reads more clearly at call sites. */
+async function invalidateAllSnapshots(bookId, workspaceRoot) {
+	return invalidateSnapshotsFrom(bookId, "0000-00", workspaceRoot);
+}
+async function bookExists(bookId, workspaceRoot) {
+	return fileExists(bookRoot(bookId, workspaceRoot));
+}
+async function ensureBookDir(bookId, workspaceRoot) {
+	await promises.mkdir(bookRoot(bookId, workspaceRoot), { recursive: true });
+	await promises.mkdir(journalDir(bookId, workspaceRoot), { recursive: true });
+	await promises.mkdir(snapshotsDir(bookId, workspaceRoot), { recursive: true });
+}
+/** Recursively delete a book's directory. Used by `deleteBook` after
+*  the config has been updated to drop the entry. */
+async function removeBookDir(bookId, workspaceRoot) {
+	await promises.rm(bookRoot(bookId, workspaceRoot), {
+		recursive: true,
+		force: true
+	});
+}
+//#endregion
+//#region src/server/types.ts
+/** B/S accounts (assets / liabilities / equity). Used by opening
+*  balance validation: opening entries reference balance-sheet
+*  accounts only. */
+var BALANCE_SHEET_ACCOUNT_TYPES = [
+	"asset",
+	"liability",
+	"equity"
+];
+//#endregion
+//#region src/server/journal.ts
+/** Floating-point tolerance for the debit = credit check. Currency
+*  amounts arrive as JavaScript numbers (the on-wire format is JSON,
+*  so amounts are doubles). 0.005 keeps two-decimal currency math
+*  honest while accepting the floating-point noise of summing
+*  many lines. */
+var EQUALITY_TOLERANCE$1 = .005;
+function lineHasExactlyOneSide(line) {
+	return (typeof line.debit === "number" && line.debit !== 0) !== (typeof line.credit === "number" && line.credit !== 0);
+}
+function isNonNegativeNumber(value) {
+	return typeof value === "number" && Number.isFinite(value) && value >= 0;
+}
+/** Build today's `YYYY-MM-DD` from the host's local timezone.
+*  Centralised here so server-side defaults (the void-date on
+*  `voidEntry`, the today() stamp on opening replacements, etc.)
+*  agree with the client-side `localDateString()` from
+*  `src/plugins/accounting/dates.ts`. `toISOString().slice(0, 10)`
+*  would emit a UTC date instead — which silently flips into
+*  tomorrow / yesterday in negative-offset timezones. */
+function localDateString(now = /* @__PURE__ */ new Date()) {
+	return `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, "0")}-${String(now.getDate()).padStart(2, "0")}`;
+}
+/** Validate that `date` is both shaped as YYYY-MM-DD AND represents
+*  a real calendar day. The bare regex accepts impossible values
+*  like 2026-02-31 or 2026-13-01 which would then poison
+*  `periodFromDate`, sort orders, and snapshot keys. We reparse
+*  through the Date constructor and roundtrip-format to catch
+*  silent normalisation (e.g. "2026-02-30" → Mar 02). */
+function isValidCalendarDate(date) {
+	if (!/^\d{4}-\d{2}-\d{2}$/.test(date)) return false;
+	const [year, month, day] = date.split("-").map((segment) => parseInt(segment, 10));
+	const parsed = new Date(Date.UTC(year, month - 1, day));
+	return parsed.getUTCFullYear() === year && parsed.getUTCMonth() === month - 1 && parsed.getUTCDate() === day;
+}
+/** Returns Σ debit − Σ credit. Used by callers that need the actual
+*  imbalance value (e.g. the OpeningBalancesForm shows live diff). */
+function netBalance(lines) {
+	let net = 0;
+	for (const line of lines) {
+		if (typeof line.debit === "number") net += line.debit;
+		if (typeof line.credit === "number") net -= line.credit;
+	}
+	return net;
+}
+/** Pure validation. Does not throw; returns a list of issues so the
+*  REST handler can return a structured 400 instead of an opaque
+*  500. */
+function validateLine(line, idx, accountCodes, errors) {
+	if (!line.accountCode || !accountCodes.has(line.accountCode)) errors.push({
+		field: `lines[${idx}].accountCode`,
+		message: `unknown account code ${JSON.stringify(line.accountCode)}`
+	});
+	if (line.debit !== void 0 && !isNonNegativeNumber(line.debit)) errors.push({
+		field: `lines[${idx}].debit`,
+		message: "debit must be a non-negative finite number"
+	});
+	if (line.credit !== void 0 && !isNonNegativeNumber(line.credit)) errors.push({
+		field: `lines[${idx}].credit`,
+		message: "credit must be a non-negative finite number"
+	});
+	if (!lineHasExactlyOneSide(line)) errors.push({
+		field: `lines[${idx}]`,
+		message: "each line must set exactly one of debit or credit (and to a non-zero amount)"
+	});
+	if (line.taxRegistrationId !== void 0) {
+		if (typeof line.taxRegistrationId !== "string") errors.push({
+			field: `lines[${idx}].taxRegistrationId`,
+			message: "must be a string"
+		});
+		else if (line.taxRegistrationId.trim().length > 32) errors.push({
+			field: `lines[${idx}].taxRegistrationId`,
+			message: `must be at most 32 characters (got ${line.taxRegistrationId.trim().length})`
+		});
+	}
+}
+/** Normalize a journal line before persistence: trim string fields
+*  and drop empty-string optionals so the JSONL doesn't accumulate
+*  noise like `"taxRegistrationId":""`. Pure — does not mutate
+*  `line`. */
+function normalizeLine(line) {
+	const out = { ...line };
+	if (typeof out.taxRegistrationId === "string") {
+		const trimmed = out.taxRegistrationId.trim();
+		if (trimmed === "") delete out.taxRegistrationId;
+		else out.taxRegistrationId = trimmed;
+	}
+	return out;
+}
+function validateEntry(input) {
+	const errors = [];
+	if (!isValidCalendarDate(input.date)) errors.push({
+		field: "date",
+		message: `expected YYYY-MM-DD calendar date, got ${JSON.stringify(input.date)}`
+	});
+	if (!Array.isArray(input.lines) || input.lines.length < 2) {
+		errors.push({
+			field: "lines",
+			message: "an entry needs at least two lines (one debit, one credit)"
+		});
+		return {
+			ok: false,
+			errors
+		};
+	}
+	const accountCodes = new Set(input.accounts.map((account) => account.code));
+	input.lines.forEach((line, idx) => validateLine(line, idx, accountCodes, errors));
+	const net = netBalance(input.lines);
+	if (Math.abs(net) > EQUALITY_TOLERANCE$1) errors.push({
+		field: "lines",
+		message: `Σ debit − Σ credit = ${net.toFixed(4)}; entry must balance`
+	});
+	return {
+		ok: errors.length === 0,
+		errors
+	};
+}
+/** Build a JournalEntry — validation is the caller's responsibility
+*  (it should have called `validateEntry` first). The id is a fresh
+*  UUID; createdAt is the wall clock at the moment of creation.
+*  Lines are normalized so optional string fields don't persist as
+*  empty strings. */
+function makeEntry(input) {
+	const entry = {
+		id: randomUUID(),
+		date: input.date,
+		kind: input.kind ?? "normal",
+		lines: input.lines.map(normalizeLine),
+		memo: input.memo,
+		createdAt: (/* @__PURE__ */ new Date()).toISOString()
+	};
+	if (input.replacesEntryId) entry.replacesEntryId = input.replacesEntryId;
+	return entry;
+}
+/** Pick the most descriptive memo from the original entry to quote
+*  in the voiding entry's memo. Precedence: entry-level memo →
+*  first non-empty line memo → null (caller falls back to a
+*  date-only template). */
+function originalMemoToQuote(target) {
+	if (target.memo && target.memo.trim() !== "") return target.memo;
+	for (const line of target.lines) if (line.memo && line.memo.trim() !== "") return line.memo;
+	return null;
+}
+/** Build the human-readable memo that goes on the voiding entry.
+*  Format: `void of '<original memo>' on <original date>` (or the
+*  no-memo fallback when the original carried no memo). The reason
+*  the user typed is appended after a colon when present. */
+function voidMemo(target, reason) {
+	const quoted = originalMemoToQuote(target);
+	const base = quoted !== null ? `void of '${quoted}' on ${target.date}` : `void of entry on ${target.date}`;
+	return reason && reason.trim() !== "" ? `${base}: ${reason}` : base;
+}
+/** Build the reversing pair for a voided entry. The `void` entry
+*  swaps debit / credit on every line so the net effect is zero;
+*  the `void-marker` is a zero-line entry that exists purely to
+*  carry the `voidedEntryId` reference and the user's reason. The
+*  marker keeps `listEntries` queries simple — filtering by
+*  `kind: "void-marker"` surfaces every voided id without scanning
+*  for matching pairs. */
+function makeVoidEntries(target, reason, voidDate) {
+	const swappedLines = target.lines.map((line) => {
+		const swapped = {
+			accountCode: line.accountCode,
+			debit: line.credit,
+			credit: line.debit,
+			memo: line.memo
+		};
+		if (line.taxRegistrationId !== void 0) swapped.taxRegistrationId = line.taxRegistrationId;
+		return swapped;
+	});
+	return {
+		reverse: {
+			id: randomUUID(),
+			date: voidDate,
+			kind: "void",
+			lines: swappedLines,
+			memo: voidMemo(target, reason),
+			voidedEntryId: target.id,
+			voidReason: reason,
+			createdAt: (/* @__PURE__ */ new Date()).toISOString()
+		},
+		marker: {
+			id: randomUUID(),
+			date: voidDate,
+			kind: "void-marker",
+			lines: [],
+			voidedEntryId: target.id,
+			voidReason: reason,
+			createdAt: (/* @__PURE__ */ new Date()).toISOString()
+		}
+	};
+}
+/** Returns the set of entry ids that have been voided — built from
+*  every `void-marker` entry's `voidedEntryId`. Reports use this to
+*  exclude original-and-reverse pairs from the activity listing
+*  (the netting is automatic in B/S aggregates because the reverse
+*  entry has equal-and-opposite lines). */
+function voidedIdSet(entries) {
+	const set = /* @__PURE__ */ new Set();
+	for (const entry of entries) if (entry.kind === "void-marker" && entry.voidedEntryId) set.add(entry.voidedEntryId);
+	return set;
+}
+//#endregion
+//#region src/server/openingBalances.ts
+var EQUALITY_TOLERANCE = .005;
+/** Find the existing opening entry for a book, if any. Multiple
+*  openings shouldn't coexist (the route enforces void-then-append),
+*  but if they do the most recent by `createdAt` wins so callers
+*  always see one canonical opening. */
+function findActiveOpening(entries) {
+	const voided = voidedIdSet(entries);
+	let active = null;
+	for (const entry of entries) {
+		if (entry.kind !== "opening") continue;
+		if (voided.has(entry.id)) continue;
+		if (!active || entry.createdAt > active.createdAt) active = entry;
+	}
+	return active;
+}
+function validateLineAccountTypes(input, errors) {
+	const accountByCode = new Map(input.accounts.map((account) => [account.code, account]));
+	input.lines.forEach((line, idx) => {
+		const acct = accountByCode.get(line.accountCode);
+		if (!acct) {
+			errors.push({
+				field: `lines[${idx}].accountCode`,
+				message: `unknown account code ${JSON.stringify(line.accountCode)}`
+			});
+			return;
+		}
+		if (!BALANCE_SHEET_ACCOUNT_TYPES.includes(acct.type)) errors.push({
+			field: `lines[${idx}].accountCode`,
+			message: `account ${acct.code} is type ${acct.type}; opening balances may only reference balance-sheet accounts (asset / liability / equity)`
+		});
+	});
+}
+function validateAsOfPredatesEverything(input, errors) {
+	const voided = voidedIdSet(input.existingEntries);
+	for (const entry of input.existingEntries) {
+		if (entry.kind === "opening") continue;
+		if (entry.kind === "void-marker") continue;
+		if (voided.has(entry.id)) continue;
+		if (entry.date < input.asOfDate) {
+			errors.push({
+				field: "asOfDate",
+				message: `cannot set opening as of ${input.asOfDate}: existing entry ${entry.id} dated ${entry.date} is older. Void it first or pick an earlier asOfDate.`
+			});
+			break;
+		}
+	}
+}
+/** Validate inputs for `setOpeningBalances`. Caller passes the full
+*  list of journal entries in the book so we can check the
+*  "asOfDate must precede every other entry" rule. An opening with
+*  zero lines is accepted as a no-op marker — it satisfies the
+*  "book has an opening" gate the UI uses without committing the
+*  user to specific balances on day one (they can replace it
+*  later). */
+function validateOpening(input) {
+	const errors = [];
+	if (!isValidCalendarDate(input.asOfDate)) errors.push({
+		field: "asOfDate",
+		message: `expected YYYY-MM-DD calendar date, got ${JSON.stringify(input.asOfDate)}`
+	});
+	if (!Array.isArray(input.lines)) {
+		errors.push({
+			field: "lines",
+			message: "lines must be an array"
+		});
+		return {
+			ok: false,
+			errors
+		};
+	}
+	validateLineAccountTypes(input, errors);
+	const net = netBalance(input.lines);
+	if (Math.abs(net) > EQUALITY_TOLERANCE) errors.push({
+		field: "lines",
+		message: `Σ debit − Σ credit = ${net.toFixed(4)}; opening must balance`
+	});
+	validateAsOfPredatesEverything(input, errors);
+	return {
+		ok: errors.length === 0,
+		errors
+	};
+}
+//#endregion
+//#region src/server/accountNormalize.ts
+function normalizeStoredAccount(input, existing) {
+	const stored = {
+		code: input.code,
+		name: input.name,
+		type: input.type
+	};
+	if (typeof input.note === "string" && input.note.length > 0) stored.note = input.note;
+	const inheritInactive = input.active === void 0 && existing?.active === false;
+	if (input.active === false || inheritInactive) stored.active = false;
+	return stored;
+}
+//#endregion
+//#region src/server/report.ts
+var ZERO_TOLERANCE = .0049;
+/** Returns net (debit − credit) per account across the supplied
+*  entries. Voids work by having an original + reverse pair that
+*  cancel mathematically — both are included in aggregation (their
+*  contributions sum to zero). The `void-marker` entries carry no
+*  lines, so excluding them is just a formality.
+*
+*  Why not "exclude original via voidedIdSet"? Because then the
+*  reverse half would remain unmatched, and the net would be the
+*  original's amount with the wrong sign. Letting the math cancel
+*  naturally is simpler and impossible to get wrong. */
+function aggregateBalances(entries) {
+	const map = /* @__PURE__ */ new Map();
+	for (const entry of entries) {
+		if (entry.kind === "void-marker") continue;
+		for (const line of entry.lines) {
+			const cur = map.get(line.accountCode) ?? 0;
+			const debit = line.debit ?? 0;
+			const credit = line.credit ?? 0;
+			map.set(line.accountCode, cur + debit - credit);
+		}
+	}
+	return Array.from(map.entries()).map(([accountCode, netDebit]) => ({
+		accountCode,
+		netDebit
+	})).sort((lhs, rhs) => lhs.accountCode.localeCompare(rhs.accountCode));
+}
+function naturalSign$1(type, netDebit) {
+	if (type === "asset" || type === "expense") return netDebit;
+	return -netDebit;
+}
+/** Sentinel `accountCode` for the synthetic "Current period
+*  earnings" row added to the Equity section by `buildBalanceSheet`.
+*  The View detects this code and substitutes a localised label
+*  for the fixed English fallback. */
+var CURRENT_EARNINGS_ACCOUNT_CODE = "_currentEarnings";
+function computeCurrentEarnings(accounts, balanceByCode) {
+	let earnings = 0;
+	for (const account of accounts) {
+		if (account.type !== "income" && account.type !== "expense") continue;
+		const presented = naturalSign$1(account.type, balanceByCode.get(account.code) ?? 0);
+		earnings += account.type === "income" ? presented : -presented;
+	}
+	return earnings;
+}
+function buildBalanceSheet(input) {
+	const balanceByCode = new Map(input.balances.map((row) => [row.accountCode, row.netDebit]));
+	const currentEarnings = computeCurrentEarnings(input.accounts, balanceByCode);
+	const sections = [];
+	for (const type of [
+		"asset",
+		"liability",
+		"equity"
+	]) {
+		const rows = [];
+		let total = 0;
+		for (const account of input.accounts) {
+			if (account.type !== type) continue;
+			const presented = naturalSign$1(type, balanceByCode.get(account.code) ?? 0);
+			if (Math.abs(presented) <= ZERO_TOLERANCE) continue;
+			rows.push({
+				accountCode: account.code,
+				accountName: account.name,
+				balance: presented
+			});
+			total += presented;
+		}
+		if (type === "equity" && Math.abs(currentEarnings) > ZERO_TOLERANCE) {
+			rows.push({
+				accountCode: CURRENT_EARNINGS_ACCOUNT_CODE,
+				accountName: "Current period earnings",
+				balance: currentEarnings
+			});
+			total += currentEarnings;
+		}
+		sections.push({
+			type,
+			rows,
+			total
+		});
+	}
+	const assetTotal = sections[0].total;
+	const liabEquityTotal = sections[1].total + sections[2].total;
+	return {
+		asOf: input.asOf,
+		sections,
+		imbalance: assetTotal - liabEquityTotal
+	};
+}
+function buildProfitLoss(input) {
+	const balances = aggregateBalances(input.entries.filter((entry) => entry.date >= input.from && entry.date <= input.to));
+	const balanceByCode = new Map(balances.map((row) => [row.accountCode, row.netDebit]));
+	const incomeRows = [];
+	const expenseRows = [];
+	let incomeTotal = 0;
+	let expenseTotal = 0;
+	for (const account of input.accounts) {
+		const netDebit = balanceByCode.get(account.code) ?? 0;
+		const presented = naturalSign$1(account.type, netDebit);
+		if (Math.abs(presented) <= ZERO_TOLERANCE) continue;
+		if (account.type === "income") {
+			incomeRows.push({
+				accountCode: account.code,
+				accountName: account.name,
+				amount: presented
+			});
+			incomeTotal += presented;
+		} else if (account.type === "expense") {
+			expenseRows.push({
+				accountCode: account.code,
+				accountName: account.name,
+				amount: presented
+			});
+			expenseTotal += presented;
+		}
+	}
+	return {
+		from: input.from,
+		to: input.to,
+		income: {
+			rows: incomeRows,
+			total: incomeTotal
+		},
+		expense: {
+			rows: expenseRows,
+			total: expenseTotal
+		},
+		netIncome: incomeTotal - expenseTotal
+	};
+}
+/** Concatenate the entry-level memo (the *what-happened*) with the
+*  line-level memo (the *why-this-account*) so a per-account ledger
+*  view shows both. Without this combine, a Sales Tax Receivable
+*  ledger row would show "仮払消費税 10%" but lose the originating
+*  "Starbucks Tokyo — coffee" — and the user can't tell which
+*  transaction the row came from. Identity-collapse handles the
+*  case where someone set both fields to the same string. */
+function combineMemo(entryMemo, lineMemo) {
+	if (!entryMemo) return lineMemo;
+	if (!lineMemo) return entryMemo;
+	if (entryMemo === lineMemo) return entryMemo;
+	return `${entryMemo} · ${lineMemo}`;
+}
+function accumulateLedgerEntry(entry, accountCode, fromDate, toDate, acc) {
+	if (entry.kind === "void-marker") return;
+	for (const line of entry.lines) {
+		if (line.accountCode !== accountCode) continue;
+		const debit = line.debit ?? 0;
+		const credit = line.credit ?? 0;
+		acc.running += debit - credit;
+		if (fromDate && entry.date < fromDate) continue;
+		if (toDate && entry.date > toDate) continue;
+		const row = {
+			entryId: entry.id,
+			date: entry.date,
+			kind: entry.kind,
+			memo: combineMemo(entry.memo, line.memo),
+			debit,
+			credit,
+			runningBalance: acc.running
+		};
+		if (line.taxRegistrationId !== void 0) row.taxRegistrationId = line.taxRegistrationId;
+		acc.rows.push(row);
+	}
+}
+function buildLedger(input) {
+	const sorted = [...input.entries].sort((lhs, rhs) => lhs.date === rhs.date ? lhs.createdAt.localeCompare(rhs.createdAt) : lhs.date.localeCompare(rhs.date));
+	const acc = {
+		rows: [],
+		running: 0
+	};
+	for (const entry of sorted) accumulateLedgerEntry(entry, input.account.code, input.from, input.to, acc);
+	return {
+		accountCode: input.account.code,
+		accountName: input.account.name,
+		rows: acc.rows,
+		closingBalance: acc.running
+	};
+}
+//#endregion
+//#region src/server/timeSeries.ts
+function pad2(num) {
+	return String(num).padStart(2, "0");
+}
+function fmtYmd(year, month, day) {
+	return `${year}-${pad2(month)}-${pad2(day)}`;
+}
+function parseYmd(value) {
+	const [year, month, day] = value.split("-").map((segment) => parseInt(segment, 10));
+	return {
+		year,
+		month,
+		day
+	};
+}
+function lastDayOf(year, month) {
+	return new Date(Date.UTC(year, month, 0)).getUTCDate();
+}
+function addDay(date) {
+	const stepped = new Date(Date.UTC(date.year, date.month - 1, date.day + 1));
+	return {
+		year: stepped.getUTCFullYear(),
+		month: stepped.getUTCMonth() + 1,
+		day: stepped.getUTCDate()
+	};
+}
+function fyAnchorFor(date, end) {
+	const closingMonth = fiscalYearEndMonth(end);
+	const startMonth = closingMonth % 12 + 1;
+	const fyStartYear = date.month >= startMonth ? date.year : date.year - 1;
+	return {
+		fyStartYear,
+		fyEndYear: closingMonth === 12 ? fyStartYear : fyStartYear + 1,
+		startMonth
+	};
+}
+function monthBucketContaining(date) {
+	return {
+		from: fmtYmd(date.year, date.month, 1),
+		to: fmtYmd(date.year, date.month, lastDayOf(date.year, date.month)),
+		label: `${date.year}-${pad2(date.month)}`
+	};
+}
+function quarterBucketContaining(date, end) {
+	const anchor = fyAnchorFor(date, end);
+	const offset = (date.month - anchor.startMonth + 12) % 12;
+	const qIdx = Math.floor(offset / 3);
+	const startFlat = anchor.fyStartYear * 12 + (anchor.startMonth - 1) + qIdx * 3;
+	const endFlat = startFlat + 2;
+	const qStartYear = Math.floor(startFlat / 12);
+	const qStartMonth = startFlat % 12 + 1;
+	const qEndYear = Math.floor(endFlat / 12);
+	const qEndMonth = endFlat % 12 + 1;
+	return {
+		from: fmtYmd(qStartYear, qStartMonth, 1),
+		to: fmtYmd(qEndYear, qEndMonth, lastDayOf(qEndYear, qEndMonth)),
+		label: `FY${anchor.fyEndYear}-Q${qIdx + 1}`
+	};
+}
+function yearBucketContaining(date, end) {
+	const anchor = fyAnchorFor(date, end);
+	const startFlat = anchor.fyStartYear * 12 + (anchor.startMonth - 1);
+	const endFlat = startFlat + 11;
+	const yStartYear = Math.floor(startFlat / 12);
+	const yStartMonth = startFlat % 12 + 1;
+	const yEndYear = Math.floor(endFlat / 12);
+	const yEndMonth = endFlat % 12 + 1;
+	return {
+		from: fmtYmd(yStartYear, yStartMonth, 1),
+		to: fmtYmd(yEndYear, yEndMonth, lastDayOf(yEndYear, yEndMonth)),
+		label: `FY${anchor.fyEndYear}`
+	};
+}
+function bucketContaining(date, granularity, end) {
+	if (granularity === "month") return monthBucketContaining(date);
+	if (granularity === "quarter") return quarterBucketContaining(date, end);
+	return yearBucketContaining(date, end);
+}
+/** Walk inclusive `[from, to]` and return every bucket that overlaps
+*  it, ordered ascending by `from`. The first bucket is the one
+*  CONTAINING `from` — it can extend earlier than `from`; the last
+*  bucket is the one CONTAINING `to` — it can extend past `to`. The
+*  caller's response echoes the input range so the LLM can label the
+*  chart truthfully ("Revenue Apr 2025 – Sep 2026" even though the
+*  outermost buckets cover Apr-Jun 2025 and Jul-Sep 2026). */
+function bucketize(input) {
+	if (input.from > input.to) return [];
+	const start = parseYmd(input.from);
+	const result = [];
+	let bucket = bucketContaining(start, input.granularity, input.fiscalYearEnd);
+	while (bucket.from <= input.to) {
+		result.push(bucket);
+		bucket = bucketContaining(addDay(parseYmd(bucket.to)), input.granularity, input.fiscalYearEnd);
+	}
+	return result;
+}
+/** Convert raw netDebit to natural-sign presentation per account
+*  type. Mirrors the helper in `report.ts` (kept private there). */
+function naturalSign(type, netDebit) {
+	if (type === "asset" || type === "expense") return netDebit;
+	return -netDebit;
+}
+/** Sum presented income and expense values across the supplied
+*  entries. Used for window-based metrics (revenue / expense /
+*  netIncome). Opening entries reference B/S accounts only and so
+*  contribute zero to either total — including them is harmless. */
+function presentedPlTotals(entries, accountTypeByCode) {
+	const balances = aggregateBalances(entries);
+	let income = 0;
+	let expense = 0;
+	for (const row of balances) {
+		const type = accountTypeByCode.get(row.accountCode);
+		if (!type) continue;
+		if (type === "income") income += naturalSign(type, row.netDebit);
+		else if (type === "expense") expense += naturalSign(type, row.netDebit);
+	}
+	return {
+		income,
+		expense
+	};
+}
+function entriesInWindow(entries, from, toDate) {
+	return entries.filter((entry) => entry.date >= from && entry.date <= toDate);
+}
+function entriesUpTo(entries, toDate) {
+	return entries.filter((entry) => entry.date <= toDate);
+}
+function valueForBucket(input) {
+	const accountTypeByCode = new Map(input.accounts.map((acct) => [acct.code, acct.type]));
+	if (input.metric === "accountBalance") {
+		const code = input.accountCode;
+		if (!code) return 0;
+		const type = accountTypeByCode.get(code);
+		if (!type) return 0;
+		const row = aggregateBalances(entriesUpTo(input.entries, input.bucket.to)).find((balance) => balance.accountCode === code);
+		return row ? naturalSign(type, row.netDebit) : 0;
+	}
+	const totals = presentedPlTotals(entriesInWindow(input.entries, input.bucket.from, input.bucket.to), accountTypeByCode);
+	if (input.metric === "revenue") return totals.income;
+	if (input.metric === "expense") return totals.expense;
+	return totals.income - totals.expense;
+}
+function buildTimeSeries(input) {
+	return input.buckets.map((bucket) => ({
+		label: bucket.label,
+		from: bucket.from,
+		to: bucket.to,
+		value: valueForBucket({
+			bucket,
+			entries: input.entries,
+			accounts: input.accounts,
+			metric: input.metric,
+			accountCode: input.accountCode
+		})
+	}));
+}
+//#endregion
+//#region src/server/eventPublisher.ts
+var pubsub = null;
+function initAccountingEventPublisher(instance) {
+	pubsub = instance;
+}
+function safePublish(channel, payload) {
+	if (!pubsub) return;
+	try {
+		pubsub.publish(channel, payload);
+	} catch (err) {
+		log.warn("accounting", "publish failed; subscribers will miss this event", {
+			channel,
+			error: errorMessage(err)
+		});
+	}
+}
+/** Per-book change notification. `period` should be the entry's
+*  YYYY-MM bucket (or the earliest invalidated month for snapshot
+*  events). */
+function publishBookChange(bookId, payload) {
+	safePublish(bookChannel(bookId), payload);
+}
+/** Fired when the *list* of books changes (createBook, deleteBook).
+*  Payload is intentionally empty — subscribers refetch from
+*  /api/accounting. */
+function publishBooksChanged() {
+	safePublish(ACCOUNTING_BOOKS_CHANNEL, {});
+}
+//#endregion
+//#region src/server/snapshotCache.ts
+function previousPeriod(period) {
+	const [year, month] = period.split("-").map((segment) => parseInt(segment, 10));
+	if (month === 1) return `${(year - 1).toString().padStart(4, "0")}-12`;
+	return `${year.toString().padStart(4, "0")}-${(month - 1).toString().padStart(2, "0")}`;
+}
+function mergeBalances(base, delta) {
+	const map = /* @__PURE__ */ new Map();
+	for (const row of base) map.set(row.accountCode, row.netDebit);
+	for (const row of delta) map.set(row.accountCode, (map.get(row.accountCode) ?? 0) + row.netDebit);
+	return Array.from(map.entries()).map(([accountCode, netDebit]) => ({
+		accountCode,
+		netDebit
+	})).sort((lhs, rhs) => lhs.accountCode.localeCompare(rhs.accountCode));
+}
+async function buildEmptySnapshot(bookId, period, workspaceRoot) {
+	const empty = {
+		period,
+		balances: [],
+		builtAt: (/* @__PURE__ */ new Date()).toISOString()
+	};
+	await writeSnapshot(bookId, empty, workspaceRoot);
+	return empty;
+}
+/** Build a snapshot at end-of-`period` for one book, lazily relying
+*  on the previous month's snapshot if it exists. Falls all the way
+*  back to the earliest journal month if no upstream snapshot is
+*  available. Always writes the result to disk before returning. */
+async function getOrBuildSnapshot(bookId, period, workspaceRoot) {
+	const cached = await readSnapshot(bookId, period, workspaceRoot);
+	if (cached) return cached;
+	const periods = await listJournalPeriods(bookId, workspaceRoot);
+	if (periods.length === 0 || period < periods[0]) return buildEmptySnapshot(bookId, period, workspaceRoot);
+	const { entries } = await readJournalMonth(bookId, period, workspaceRoot);
+	const monthDelta = aggregateBalances(entries);
+	let priorBalances = [];
+	if (period > periods[0]) priorBalances = (await getOrBuildSnapshot(bookId, previousPeriod(period), workspaceRoot)).balances;
+	const snap = {
+		period,
+		balances: mergeBalances(priorBalances, monthDelta),
+		builtAt: (/* @__PURE__ */ new Date()).toISOString()
+	};
+	await writeSnapshot(bookId, snap, workspaceRoot);
+	return snap;
+}
+/** Compute closing balances at end-of-`period` from journal alone,
+*  bypassing the snapshot cache. Used by the byte-equality
+*  invariant test, and as a safety net for "compute without
+*  trusting cache" paths. */
+async function balancesAtEndOf(bookId, period, workspaceRoot) {
+	const periods = await listJournalPeriods(bookId, workspaceRoot);
+	const all = [];
+	for (const monthKey of periods) {
+		if (period < monthKey) break;
+		const { entries } = await readJournalMonth(bookId, monthKey, workspaceRoot);
+		for (const entry of entries) all.push(entry);
+	}
+	return aggregateBalances(all);
+}
+/** Drop all snapshots and rebuild from scratch. Used by the
+*  `rebuildSnapshots` admin action. Returns the periods that were
+*  rebuilt. */
+async function rebuildAllSnapshots(bookId, workspaceRoot) {
+	await invalidateAllSnapshots(bookId, workspaceRoot);
+	const periods = await listJournalPeriods(bookId, workspaceRoot);
+	for (const monthKey of periods) await getOrBuildSnapshot(bookId, monthKey, workspaceRoot);
+	return { rebuilt: periods };
+}
+var rebuildQueues = /* @__PURE__ */ new Map();
+function minPeriod(lhs, rhs) {
+	if (lhs === null) return rhs;
+	return lhs < rhs ? lhs : rhs;
+}
+function isInvalidatedDuringRebuild(bookId, period) {
+	const queue = rebuildQueues.get(bookId);
+	return queue !== void 0 && queue.pendingFromPeriod !== null && period >= queue.pendingFromPeriod;
+}
+function isCancelled(bookId) {
+	return rebuildQueues.get(bookId)?.cancelled === true;
+}
+async function runRebuild(bookId, fromPeriod, workspaceRoot) {
+	const startedAt = Date.now();
+	log.info("accounting", "snapshot rebuild started", {
+		bookId,
+		fromPeriod
+	});
+	publishBookChange(bookId, {
+		kind: BOOK_EVENT_KINDS.snapshotsRebuilding,
+		period: fromPeriod
+	});
+	const targets = (await listJournalPeriods(bookId, workspaceRoot)).filter((monthKey) => monthKey >= fromPeriod);
+	let written = 0;
+	for (const monthKey of targets) {
+		if (isCancelled(bookId)) break;
+		if (isInvalidatedDuringRebuild(bookId, monthKey)) break;
+		const balances = await balancesAtEndOf(bookId, monthKey, workspaceRoot);
+		if (isCancelled(bookId)) break;
+		if (isInvalidatedDuringRebuild(bookId, monthKey)) break;
+		await writeSnapshot(bookId, {
+			period: monthKey,
+			balances,
+			builtAt: (/* @__PURE__ */ new Date()).toISOString()
+		}, workspaceRoot);
+		if (isCancelled(bookId)) {
+			await invalidateSnapshotsFrom(bookId, monthKey, workspaceRoot);
+			break;
+		}
+		if (isInvalidatedDuringRebuild(bookId, monthKey)) {
+			await invalidateSnapshotsFrom(bookId, monthKey, workspaceRoot);
+			break;
+		}
+		written += 1;
+		publishBookChange(bookId, {
+			kind: BOOK_EVENT_KINDS.snapshotsReady,
+			period: monthKey
+		});
+	}
+	log.info("accounting", "snapshot rebuild done", {
+		bookId,
+		periods: written,
+		durationMs: Date.now() - startedAt
+	});
+}
+function startRebuild(bookId, fromPeriod, workspaceRoot) {
+	const entry = {
+		running: Promise.resolve(),
+		pendingFromPeriod: null,
+		pendingWorkspaceRoot: void 0,
+		coalescedWriteCount: 1,
+		runningFromPeriod: fromPeriod,
+		cancelled: false
+	};
+	entry.running = runRebuild(bookId, fromPeriod, workspaceRoot).catch((err) => {
+		log.error("accounting", "snapshot rebuild failed", {
+			bookId,
+			fromPeriod,
+			error: errorMessage(err)
+		});
+	}).then(() => {
+		const current = rebuildQueues.get(bookId);
+		if (!current) return;
+		if (current.cancelled) {
+			rebuildQueues.delete(bookId);
+			return;
+		}
+		if (current.pendingFromPeriod !== null) {
+			const nextFrom = current.pendingFromPeriod;
+			const nextRoot = current.pendingWorkspaceRoot;
+			const carriedCount = current.coalescedWriteCount;
+			const successor = startRebuild(bookId, nextFrom, nextRoot);
+			successor.coalescedWriteCount += carriedCount;
+			rebuildQueues.set(bookId, successor);
+		} else rebuildQueues.delete(bookId);
+	});
+	return entry;
+}
+/** Schedule a background rebuild for `bookId` starting at `fromPeriod`.
+*  Multiple calls during an in-flight rebuild coalesce into a single
+*  follow-up rebuild that covers the minimum `fromPeriod` seen.
+*  Returns immediately — the rebuild runs on its own promise chain. */
+function scheduleRebuild(bookId, fromPeriod, workspaceRoot) {
+	const existing = rebuildQueues.get(bookId);
+	if (!existing) {
+		rebuildQueues.set(bookId, startRebuild(bookId, fromPeriod, workspaceRoot));
+		return;
+	}
+	existing.pendingFromPeriod = minPeriod(existing.pendingFromPeriod, fromPeriod);
+	existing.pendingWorkspaceRoot = workspaceRoot;
+	existing.coalescedWriteCount += 1;
+}
+/** Test/diagnostic: resolves when no rebuild is running or queued for
+*  `bookId`. Also called by `deleteBook` after `cancelRebuild` to
+*  ensure a previously running rebuild has fully stopped before the
+*  caller removes the book's directory on disk. */
+async function awaitRebuildIdle(bookId) {
+	while (rebuildQueues.has(bookId)) {
+		const entry = rebuildQueues.get(bookId);
+		if (!entry) return;
+		await entry.running;
+	}
+}
+/** Mark the book's in-flight rebuild as cancelled. The runRebuild
+*  loop checks before each write and bails out, so a subsequent
+*  `removeBookDir` cannot race with a `writeSnapshot` that would
+*  re-create the directory tree. Pair with `awaitRebuildIdle(bookId)`
+*  to wait for the in-flight rebuild to finish bailing. */
+function cancelRebuild(bookId) {
+	const entry = rebuildQueues.get(bookId);
+	if (!entry) return;
+	entry.cancelled = true;
+	entry.pendingFromPeriod = null;
+}
+//#endregion
+//#region src/server/defaultAccounts.ts
+var DEFAULT_ACCOUNTS = [
+	{
+		code: "1000",
+		name: "Cash",
+		type: "asset"
+	},
+	{
+		code: "1001",
+		name: "Petty Cash",
+		type: "asset",
+		active: false
+	},
+	{
+		code: "1010",
+		name: "Bank — Checking",
+		type: "asset"
+	},
+	{
+		code: "1020",
+		name: "Bank — Savings",
+		type: "asset"
+	},
+	{
+		code: "1100",
+		name: "Accounts Receivable",
+		type: "asset"
+	},
+	{
+		code: "1200",
+		name: "Inventory",
+		type: "asset",
+		active: false
+	},
+	{
+		code: "1300",
+		name: "Prepaid Expenses",
+		type: "asset",
+		active: false
+	},
+	{
+		code: "1400",
+		name: "Input Tax Receivable",
+		type: "asset"
+	},
+	{
+		code: "1500",
+		name: "Equipment",
+		type: "asset"
+	},
+	{
+		code: "1510",
+		name: "Furniture & Fixtures",
+		type: "asset",
+		active: false
+	},
+	{
+		code: "1520",
+		name: "Vehicles",
+		type: "asset",
+		active: false
+	},
+	{
+		code: "1590",
+		name: "Accumulated Depreciation",
+		type: "asset",
+		active: false
+	},
+	{
+		code: "2000",
+		name: "Accounts Payable",
+		type: "liability"
+	},
+	{
+		code: "2100",
+		name: "Credit Card",
+		type: "liability"
+	},
+	{
+		code: "2200",
+		name: "Loans Payable",
+		type: "liability"
+	},
+	{
+		code: "2300",
+		name: "Accrued Expenses",
+		type: "liability",
+		active: false
+	},
+	{
+		code: "2400",
+		name: "Sales Tax Payable",
+		type: "liability"
+	},
+	{
+		code: "2500",
+		name: "Payroll Liabilities",
+		type: "liability",
+		active: false
+	},
+	{
+		code: "3000",
+		name: "Owner's Equity",
+		type: "equity"
+	},
+	{
+		code: "3100",
+		name: "Retained Earnings",
+		type: "equity"
+	},
+	{
+		code: "3200",
+		name: "Owner's Draws",
+		type: "equity",
+		active: false
+	},
+	{
+		code: "4000",
+		name: "Sales",
+		type: "income"
+	},
+	{
+		code: "4010",
+		name: "Service Revenue",
+		type: "income",
+		active: false
+	},
+	{
+		code: "4100",
+		name: "Other Income",
+		type: "income"
+	},
+	{
+		code: "4200",
+		name: "Interest Income",
+		type: "income",
+		active: false
+	},
+	{
+		code: "4300",
+		name: "Sales Returns & Discounts",
+		type: "income",
+		active: false
+	},
+	{
+		code: "5000",
+		name: "Cost of Goods Sold",
+		type: "expense"
+	},
+	{
+		code: "5100",
+		name: "Rent",
+		type: "expense"
+	},
+	{
+		code: "5200",
+		name: "Utilities",
+		type: "expense"
+	},
+	{
+		code: "5300",
+		name: "Salaries",
+		type: "expense"
+	},
+	{
+		code: "5400",
+		name: "Office Supplies",
+		type: "expense"
+	},
+	{
+		code: "5500",
+		name: "Advertising & Marketing",
+		type: "expense",
+		active: false
+	},
+	{
+		code: "5600",
+		name: "Travel",
+		type: "expense",
+		active: false
+	},
+	{
+		code: "5610",
+		name: "Meals & Entertainment",
+		type: "expense",
+		active: false
+	},
+	{
+		code: "5700",
+		name: "Professional Fees",
+		type: "expense",
+		active: false
+	},
+	{
+		code: "5710",
+		name: "Insurance",
+		type: "expense",
+		active: false
+	},
+	{
+		code: "5720",
+		name: "Software & Subscriptions",
+		type: "expense",
+		active: false
+	},
+	{
+		code: "5730",
+		name: "Bank Fees",
+		type: "expense",
+		active: false
+	},
+	{
+		code: "5800",
+		name: "Depreciation Expense",
+		type: "expense",
+		active: false
+	},
+	{
+		code: "5810",
+		name: "Taxes",
+		type: "expense",
+		active: false
+	},
+	{
+		code: "5900",
+		name: "Miscellaneous Expense",
+		type: "expense"
+	}
+];
+//#endregion
+//#region src/server/service.ts
+var AccountingError = class extends Error {
+	status;
+	details;
+	constructor(status, message, details) {
+		super(message);
+		this.status = status;
+		this.details = details;
+		this.name = "AccountingError";
+	}
+};
+var DEFAULT_CURRENCY = "USD";
+var GENERATED_ID_RETRIES = 8;
+function emptyConfig() {
+	return { books: [] };
+}
+async function loadOrInitConfig(workspaceRoot) {
+	return await readConfig(workspaceRoot) ?? emptyConfig();
+}
+function findBook(config, bookId) {
+	return config.books.find((book) => book.id === bookId) ?? null;
+}
+function resolveBookId(config, requested) {
+	if (!requested) throw new AccountingError(400, "bookId is required");
+	if (!findBook(config, requested)) throw new AccountingError(404, `book ${JSON.stringify(requested)} not found`);
+	return requested;
+}
+async function generateBookId(config, workspaceRoot) {
+	for (let attempt = 0; attempt < GENERATED_ID_RETRIES; attempt += 1) {
+		const candidate = `book-${randomUUID().slice(0, 8)}`;
+		if (!findBook(config, candidate) && !await bookExists(candidate, workspaceRoot)) return candidate;
+	}
+	throw new AccountingError(500, "could not generate a unique book id after several attempts");
+}
+/** Read every journal entry across every month, in period-sorted
+*  order. Used by paths that need a full-history view (opening
+*  balance lookups, P/L date filtering). */
+async function readAllEntries(bookId, workspaceRoot) {
+	const periods = await listJournalPeriods(bookId, workspaceRoot);
+	const all = [];
+	for (const monthKey of periods) {
+		const { entries, skipped } = await readJournalMonth(bookId, monthKey, workspaceRoot);
+		for (const entry of entries) all.push(entry);
+		if (skipped > 0) log.warn("accounting", "journal month had unparseable lines", {
+			bookId,
+			period: monthKey,
+			skipped
+		});
+	}
+	return all;
+}
+async function listBooks(workspaceRoot) {
+	return { books: (await loadOrInitConfig(workspaceRoot)).books };
+}
+function unsupportedCountryError(received) {
+	return new AccountingError(400, `unsupported country code ${JSON.stringify(received)} — must be one of: ${SUPPORTED_COUNTRY_CODES.join(", ")}`);
+}
+function unsupportedFiscalYearEndError(received) {
+	return new AccountingError(400, `unsupported fiscalYearEnd ${JSON.stringify(received)} — must be one of: ${FISCAL_YEAR_ENDS.join(", ")}`);
+}
+/** Narrow a free-form `fiscalYearEnd` input. Empty / absent → default
+*  (back-compat with old callers and pre-field on-disk books); any
+*  other value must match the enum or 400. */
+function narrowFiscalYearEnd(raw) {
+	if (raw === void 0 || raw === "") return "Q4";
+	if (!isFiscalYearEnd(raw)) throw unsupportedFiscalYearEndError(raw);
+	return raw;
+}
+/** Boundary checks shared by updateBook. Throws on the first failure
+*  so the surrounding function stays under the cognitive-complexity
+*  threshold; each rule is also unit-testable independently via the
+*  service entry point. */
+function validateUpdateBookInput(input) {
+	if (input.name !== void 0 && (typeof input.name !== "string" || input.name.trim() === "")) throw new AccountingError(400, "name must be a non-empty string when supplied");
+	if (input.country !== void 0 && input.country !== "" && !isSupportedCountryCode(input.country)) throw unsupportedCountryError(input.country);
+	if (input.fiscalYearEnd !== void 0 && input.fiscalYearEnd !== "" && !isFiscalYearEnd(input.fiscalYearEnd)) throw unsupportedFiscalYearEndError(input.fiscalYearEnd);
+}
+async function createBook(input, workspaceRoot) {
+	if (typeof input.name !== "string" || input.name.trim() === "") throw new AccountingError(400, "name is required");
+	if (input.country !== void 0 && !isSupportedCountryCode(input.country)) throw unsupportedCountryError(input.country);
+	const fiscalYearEnd = narrowFiscalYearEnd(input.fiscalYearEnd);
+	const config = await loadOrInitConfig(workspaceRoot);
+	const bookId = input.id ?? await generateBookId(config, workspaceRoot);
+	if (!isSafeBookId(bookId)) throw new AccountingError(400, `invalid book id ${JSON.stringify(bookId)} — allowed characters are A-Z a-z 0-9 _ - (1-64 chars; cannot start with _ or -)`);
+	if (findBook(config, bookId)) throw new AccountingError(409, `book ${JSON.stringify(bookId)} already exists`);
+	if (await bookExists(bookId, workspaceRoot)) throw new AccountingError(409, `book directory ${JSON.stringify(bookId)} already exists on disk`);
+	const book = {
+		id: bookId,
+		name: input.name,
+		currency: input.currency ?? DEFAULT_CURRENCY,
+		...input.country ? { country: input.country } : {},
+		fiscalYearEnd,
+		createdAt: (/* @__PURE__ */ new Date()).toISOString()
+	};
+	await ensureBookDir(bookId, workspaceRoot);
+	await writeAccounts(bookId, [...DEFAULT_ACCOUNTS], workspaceRoot);
+	await writeConfig({ books: [...config.books, book] }, workspaceRoot);
+	publishBooksChanged();
+	return { book };
+}
+async function updateBook(input, workspaceRoot) {
+	const config = await loadOrInitConfig(workspaceRoot);
+	const target = findBook(config, input.bookId);
+	if (!target) throw new AccountingError(404, `book ${JSON.stringify(input.bookId)} not found`);
+	validateUpdateBookInput(input);
+	const next = {
+		...target,
+		...input.name !== void 0 ? { name: input.name } : {},
+		...input.country !== void 0 && input.country !== "" ? { country: input.country } : {},
+		...input.fiscalYearEnd !== void 0 && input.fiscalYearEnd !== "" ? { fiscalYearEnd: input.fiscalYearEnd } : {}
+	};
+	if (input.country === "") delete next.country;
+	await writeConfig({ books: config.books.map((book) => book.id === input.bookId ? next : book) }, workspaceRoot);
+	publishBooksChanged();
+	return { book: next };
+}
+async function deleteBook(input, workspaceRoot) {
+	if (!input.confirm) throw new AccountingError(400, "deleteBook requires confirm: true");
+	const config = await loadOrInitConfig(workspaceRoot);
+	const target = findBook(config, input.bookId);
+	if (!target) throw new AccountingError(404, `book ${JSON.stringify(input.bookId)} not found`);
+	cancelRebuild(input.bookId);
+	await awaitRebuildIdle(input.bookId);
+	await removeBookDir(input.bookId, workspaceRoot);
+	await writeConfig({ books: config.books.filter((book) => book.id !== input.bookId) }, workspaceRoot);
+	publishBooksChanged();
+	return {
+		deletedBookId: input.bookId,
+		deletedBookName: target.name
+	};
+}
+async function listAccounts(input, workspaceRoot) {
+	const bookId = resolveBookId(await loadOrInitConfig(workspaceRoot), input.bookId);
+	return {
+		bookId,
+		accounts: await readAccounts(bookId, workspaceRoot)
+	};
+}
+async function upsertAccount(input, workspaceRoot) {
+	const bookId = resolveBookId(await loadOrInitConfig(workspaceRoot), input.bookId);
+	if (typeof input.account?.code !== "string" || input.account.code.length === 0) throw new AccountingError(400, "account code is required");
+	if (input.account.code.startsWith("_")) throw new AccountingError(400, `account code ${JSON.stringify(input.account.code)} is reserved (codes starting with _ are used for synthetic report rows)`);
+	const accounts = await readAccounts(bookId, workspaceRoot);
+	const existingIdx = accounts.findIndex((account) => account.code === input.account.code);
+	const next = [...accounts];
+	const oldType = existingIdx >= 0 ? accounts[existingIdx].type : null;
+	const stored = normalizeStoredAccount(input.account, existingIdx >= 0 ? accounts[existingIdx] : void 0);
+	if (existingIdx >= 0) next[existingIdx] = stored;
+	else next.push(stored);
+	await writeAccounts(bookId, next, workspaceRoot);
+	if (oldType !== null && oldType !== input.account.type) {
+		scheduleRebuild(bookId, "0000-00", workspaceRoot);
+		await invalidateAllSnapshots(bookId, workspaceRoot);
+	}
+	publishBookChange(bookId, { kind: BOOK_EVENT_KINDS.accounts });
+	return {
+		bookId,
+		account: { ...input.account },
+		accounts: next
+	};
+}
+function collectBatchValidationFailures(items, accounts) {
+	const failures = [];
+	for (let idx = 0; idx < items.length; idx++) {
+		const item = items[idx];
+		const validation = validateEntry({
+			date: item.date,
+			lines: item.lines,
+			accounts
+		});
+		if (!validation.ok) failures.push({
+			index: idx,
+			errors: validation.errors
+		});
+	}
+	return failures;
+}
+function buildBatchEntries(items) {
+	return items.map((item) => makeEntry({
+		date: item.date,
+		lines: item.lines,
+		memo: item.memo,
+		kind: "normal",
+		replacesEntryId: item.replacesEntryId
+	}));
+}
+function earliestPeriodOf(entries) {
+	return entries.map((entry) => periodFromDate(entry.date)).reduce((min, period) => period < min ? period : min);
+}
+async function addEntries(input, workspaceRoot) {
+	const bookId = resolveBookId(await loadOrInitConfig(workspaceRoot), input.bookId);
+	if (!Array.isArray(input.entries) || input.entries.length === 0) throw new AccountingError(400, "addEntries: entries must be a non-empty array");
+	const accounts = await readAccounts(bookId, workspaceRoot);
+	const failures = collectBatchValidationFailures(input.entries, accounts);
+	if (failures.length > 0) throw new AccountingError(400, "invalid journal entries", failures);
+	const built = buildBatchEntries(input.entries);
+	await appendJournalBatch(bookId, built, workspaceRoot);
+	const earliestPeriod = earliestPeriodOf(built);
+	scheduleRebuild(bookId, earliestPeriod, workspaceRoot);
+	await invalidateSnapshotsFrom(bookId, earliestPeriod, workspaceRoot);
+	publishBookChange(bookId, {
+		kind: BOOK_EVENT_KINDS.journal,
+		period: earliestPeriod
+	});
+	return {
+		bookId,
+		entries: built
+	};
+}
+async function findEntryById(bookId, entryId, workspaceRoot) {
+	const periods = await listJournalPeriods(bookId, workspaceRoot);
+	for (const monthKey of periods) {
+		const { entries } = await readJournalMonth(bookId, monthKey, workspaceRoot);
+		const hit = entries.find((entry) => entry.id === entryId);
+		if (hit) return hit;
+	}
+	return null;
+}
+async function voidEntry(input, workspaceRoot) {
+	const bookId = resolveBookId(await loadOrInitConfig(workspaceRoot), input.bookId);
+	const target = await findEntryById(bookId, input.entryId, workspaceRoot);
+	if (!target) throw new AccountingError(404, `entry ${JSON.stringify(input.entryId)} not found`);
+	const voidDate = input.voidDate ?? localDateString();
+	const { reverse, marker } = makeVoidEntries(target, input.reason, voidDate);
+	await appendJournal(bookId, reverse, workspaceRoot);
+	await appendJournal(bookId, marker, workspaceRoot);
+	const fromPeriod = target.date < voidDate ? periodFromDate(target.date) : periodFromDate(voidDate);
+	scheduleRebuild(bookId, fromPeriod, workspaceRoot);
+	await invalidateSnapshotsFrom(bookId, fromPeriod, workspaceRoot);
+	publishBookChange(bookId, {
+		kind: BOOK_EVENT_KINDS.journal,
+		period: fromPeriod
+	});
+	return {
+		bookId,
+		reverseEntry: reverse,
+		markerEntry: marker
+	};
+}
+function entryMatchesFilters(entry, input) {
+	if (input.from && entry.date < input.from) return false;
+	if (input.to && entry.date > input.to) return false;
+	if (input.accountCode && !entry.lines.some((line) => line.accountCode === input.accountCode)) return false;
+	return true;
+}
+async function listEntries(input, workspaceRoot) {
+	const bookId = resolveBookId(await loadOrInitConfig(workspaceRoot), input.bookId);
+	const periods = await listJournalPeriods(bookId, workspaceRoot);
+	const entries = [];
+	const allVoidedIds = /* @__PURE__ */ new Set();
+	for (const monthKey of periods) {
+		const { entries: monthEntries } = await readJournalMonth(bookId, monthKey, workspaceRoot);
+		for (const voidedId of voidedIdSet(monthEntries)) allVoidedIds.add(voidedId);
+		if (input.from && monthKey < input.from.slice(0, 7)) continue;
+		if (input.to && monthKey > input.to.slice(0, 7)) continue;
+		for (const entry of monthEntries) if (entryMatchesFilters(entry, input)) entries.push(entry);
+	}
+	return {
+		bookId,
+		entries,
+		voidedEntryIds: Array.from(allVoidedIds).sort()
+	};
+}
+async function getOpeningBalances(input, workspaceRoot) {
+	const bookId = resolveBookId(await loadOrInitConfig(workspaceRoot), input.bookId);
+	return {
+		bookId,
+		opening: findActiveOpening(await readAllEntries(bookId, workspaceRoot))
+	};
+}
+async function setOpeningBalances(input, workspaceRoot) {
+	const bookId = resolveBookId(await loadOrInitConfig(workspaceRoot), input.bookId);
+	const accounts = await readAccounts(bookId, workspaceRoot);
+	const all = await readAllEntries(bookId, workspaceRoot);
+	const validation = validateOpening({
+		asOfDate: input.asOfDate,
+		lines: input.lines,
+		accounts,
+		existingEntries: all
+	});
+	if (!validation.ok) throw new AccountingError(400, "invalid opening balances", validation.errors);
+	const existing = findActiveOpening(all);
+	if (existing) {
+		const { reverse, marker } = makeVoidEntries(existing, "replaced via setOpeningBalances", localDateString());
+		await appendJournal(bookId, reverse, workspaceRoot);
+		await appendJournal(bookId, marker, workspaceRoot);
+	}
+	const opening = makeEntry({
+		date: input.asOfDate,
+		lines: input.lines,
+		memo: input.memo ?? "Opening balances",
+		kind: "opening"
+	});
+	await appendJournal(bookId, opening, workspaceRoot);
+	scheduleRebuild(bookId, "0000-00", workspaceRoot);
+	await invalidateAllSnapshots(bookId, workspaceRoot);
+	publishBookChange(bookId, { kind: BOOK_EVENT_KINDS.opening });
+	return {
+		bookId,
+		openingEntry: opening,
+		replacedExisting: existing !== null
+	};
+}
+function endDateOfPeriod(period) {
+	if (period.kind === "month") {
+		const [year, month] = period.period.split("-").map((segment) => parseInt(segment, 10));
+		const last = new Date(Date.UTC(year, month, 0)).getUTCDate();
+		return `${period.period}-${String(last).padStart(2, "0")}`;
+	}
+	return period.to;
+}
+async function getBalanceSheetReport(input, workspaceRoot) {
+	const bookId = resolveBookId(await loadOrInitConfig(workspaceRoot), input.bookId);
+	return {
+		bookId,
+		balanceSheet: buildBalanceSheet({
+			accounts: await readAccounts(bookId, workspaceRoot),
+			balances: await balancesAsOf(bookId, input.period, workspaceRoot),
+			asOf: endDateOfPeriod(input.period)
+		})
+	};
+}
+/** Resolve closing balances at the end of a `ReportPeriod`. Month
+*  periods hit the snapshot cache; range periods with a mid-month
+*  `to` date have to filter the journal directly because the
+*  end-of-month snapshot would include activity past `to`. */
+async function balancesAsOf(bookId, period, workspaceRoot) {
+	if (period.kind === "month") return [...(await getOrBuildSnapshot(bookId, period.period, workspaceRoot)).balances];
+	return aggregateBalances((await readAllEntries(bookId, workspaceRoot)).filter((entry) => entry.date <= period.to));
+}
+async function getProfitLossReport(input, workspaceRoot) {
+	const bookId = resolveBookId(await loadOrInitConfig(workspaceRoot), input.bookId);
+	return {
+		bookId,
+		profitLoss: buildProfitLoss({
+			accounts: await readAccounts(bookId, workspaceRoot),
+			entries: await readAllEntries(bookId, workspaceRoot),
+			from: input.period.kind === "month" ? `${input.period.period}-01` : input.period.from,
+			to: endDateOfPeriod(input.period)
+		})
+	};
+}
+async function getLedgerReport(input, workspaceRoot) {
+	const bookId = resolveBookId(await loadOrInitConfig(workspaceRoot), input.bookId);
+	const account = (await readAccounts(bookId, workspaceRoot)).find((acct) => acct.code === input.accountCode);
+	if (!account) throw new AccountingError(404, `account ${JSON.stringify(input.accountCode)} not found`);
+	return {
+		bookId,
+		ledger: buildLedger({
+			account,
+			entries: await readAllEntries(bookId, workspaceRoot),
+			from: input.period?.kind === "month" ? `${input.period.period}-01` : input.period?.from,
+			to: input.period ? endDateOfPeriod(input.period) : void 0
+		})
+	};
+}
+function ensureValidYmd(label, value) {
+	if (typeof value !== "string" || !isValidCalendarDate(value)) throw new AccountingError(400, `getTimeSeries: ${label} must be a valid YYYY-MM-DD calendar date`);
+	return value;
+}
+function ensureMetric(value) {
+	if (typeof value !== "string" || !TIME_SERIES_METRICS.includes(value)) throw new AccountingError(400, `getTimeSeries: metric must be one of ${TIME_SERIES_METRICS.join(", ")}`);
+	return value;
+}
+function ensureGranularity(value) {
+	if (typeof value !== "string" || !TIME_SERIES_GRANULARITIES.includes(value)) throw new AccountingError(400, `getTimeSeries: granularity must be one of ${TIME_SERIES_GRANULARITIES.join(", ")}`);
+	return value;
+}
+function resolveAccountCode(metric, raw) {
+	if (metric === "accountBalance") {
+		if (typeof raw !== "string" || raw === "") throw new AccountingError(400, "getTimeSeries: accountCode is required when metric is accountBalance");
+		return raw;
+	}
+	if (raw !== void 0 && raw !== "") throw new AccountingError(400, "getTimeSeries: accountCode is only allowed when metric is accountBalance");
+}
+function validateTimeSeriesInput(input) {
+	const metric = ensureMetric(input.metric);
+	const granularity = ensureGranularity(input.granularity);
+	const from = ensureValidYmd("from", input.from);
+	const toDate = ensureValidYmd("to", input.to);
+	if (from > toDate) throw new AccountingError(400, "getTimeSeries: from must be on or before to");
+	return {
+		metric,
+		granularity,
+		from,
+		toDate,
+		accountCode: resolveAccountCode(metric, input.accountCode)
+	};
+}
+async function loadTimeSeriesBookContext(requestedBookId, workspaceRoot) {
+	const config = await loadOrInitConfig(workspaceRoot);
+	const bookId = resolveBookId(config, requestedBookId);
+	return {
+		bookId,
+		fiscalYearEnd: findBook(config, bookId)?.fiscalYearEnd ?? "Q4",
+		accounts: await readAccounts(bookId, workspaceRoot)
+	};
+}
+async function getTimeSeriesReport(input, workspaceRoot) {
+	const { metric, granularity, from, toDate, accountCode } = validateTimeSeriesInput(input);
+	const { bookId, fiscalYearEnd, accounts } = await loadTimeSeriesBookContext(input.bookId, workspaceRoot);
+	if (accountCode && !accounts.some((acct) => acct.code === accountCode)) throw new AccountingError(404, `getTimeSeries: account ${JSON.stringify(accountCode)} not found`);
+	const entries = await readAllEntries(bookId, workspaceRoot);
+	const report = {
+		bookId,
+		metric,
+		granularity,
+		from,
+		to: toDate,
+		points: buildTimeSeries({
+			buckets: bucketize({
+				from,
+				to: toDate,
+				granularity,
+				fiscalYearEnd
+			}),
+			entries,
+			accounts,
+			metric,
+			accountCode
+		})
+	};
+	if (accountCode) report.accountCode = accountCode;
+	return report;
+}
+async function rebuildSnapshots(input, workspaceRoot) {
+	const bookId = resolveBookId(await loadOrInitConfig(workspaceRoot), input.bookId);
+	const result = await rebuildAllSnapshots(bookId, workspaceRoot);
+	publishBookChange(bookId, { kind: BOOK_EVENT_KINDS.snapshotsReady });
+	return {
+		bookId,
+		rebuilt: result.rebuilt
+	};
+}
+//#endregion
+//#region src/server/http.ts
+function asyncHandler(namespace, fallbackMessage, handler) {
+	return async (req, res) => {
+		try {
+			await handler(req, res);
+		} catch (err) {
+			const expressReq = req;
+			const expressRes = res;
+			log.error(namespace, "handler threw", {
+				route: expressReq.path,
+				error: errorMessage(err)
+			});
+			if (!expressRes.headersSent) expressRes.status(500).json({ error: fallbackMessage });
+		}
+	};
+}
+//#endregion
+//#region src/server/router.ts
+async function handleOpenBook(rest) {
+	if (typeof rest.bookId !== "string" || rest.bookId === "") throw new AccountingError(400, "openBook: bookId is required. Call 'getBooks' to enumerate, or 'createBook' first on a fresh workspace.");
+	const list = await listBooks();
+	if (!list.books.some((book) => book.id === rest.bookId)) throw new AccountingError(404, `openBook: book ${JSON.stringify(rest.bookId)} not found`);
+	const initialTab = typeof rest.initialTab === "string" ? rest.initialTab : void 0;
+	return {
+		kind: "accounting-app",
+		bookId: rest.bookId,
+		initialTab,
+		books: list.books
+	};
+}
+async function handleGetReport(rest) {
+	const kind = String(rest.kind ?? "");
+	const periodInput = rest.period;
+	const bookId = rest.bookId;
+	if (kind === "balance") {
+		if (!periodInput) throw new AccountingError(400, "getReport balance: period is required");
+		return getBalanceSheetReport({
+			bookId,
+			period: periodInput
+		});
+	}
+	if (kind === "pl") {
+		if (!periodInput) throw new AccountingError(400, "getReport pl: period is required");
+		return getProfitLossReport({
+			bookId,
+			period: periodInput
+		});
+	}
+	if (kind === "ledger") {
+		if (typeof rest.accountCode !== "string" || rest.accountCode === "") throw new AccountingError(400, "getReport ledger: accountCode is required");
+		return getLedgerReport({
+			bookId,
+			accountCode: rest.accountCode,
+			period: periodInput
+		});
+	}
+	throw new AccountingError(400, `getReport: unknown kind ${JSON.stringify(kind)}`);
+}
+var ACTION_HANDLERS = {
+	[ACCOUNTING_ACTIONS.openBook]: handleOpenBook,
+	[ACCOUNTING_ACTIONS.getBooks]: () => listBooks(),
+	[ACCOUNTING_ACTIONS.createBook]: async (rest) => {
+		const result = await createBook({
+			name: String(rest.name ?? ""),
+			currency: typeof rest.currency === "string" ? rest.currency : void 0,
+			country: typeof rest.country === "string" ? rest.country : void 0,
+			fiscalYearEnd: typeof rest.fiscalYearEnd === "string" ? rest.fiscalYearEnd : void 0
+		});
+		return {
+			bookId: result.book.id,
+			...result
+		};
+	},
+	[ACCOUNTING_ACTIONS.updateBook]: async (rest) => {
+		const result = await updateBook({
+			bookId: String(rest.bookId ?? ""),
+			name: typeof rest.name === "string" ? rest.name : void 0,
+			country: typeof rest.country === "string" ? rest.country : void 0,
+			fiscalYearEnd: typeof rest.fiscalYearEnd === "string" ? rest.fiscalYearEnd : void 0
+		});
+		return {
+			bookId: result.book.id,
+			...result
+		};
+	},
+	[ACCOUNTING_ACTIONS.deleteBook]: (rest) => deleteBook({
+		bookId: String(rest.bookId ?? ""),
+		confirm: rest.confirm === true
+	}),
+	[ACCOUNTING_ACTIONS.getAccounts]: (rest) => listAccounts({ bookId: rest.bookId }),
+	[ACCOUNTING_ACTIONS.upsertAccount]: (rest) => upsertAccount({
+		bookId: rest.bookId,
+		account: rest.account
+	}),
+	[ACCOUNTING_ACTIONS.addEntries]: (rest) => addEntries({
+		bookId: rest.bookId,
+		entries: rest.entries ?? []
+	}),
+	[ACCOUNTING_ACTIONS.voidEntry]: (rest) => voidEntry({
+		bookId: rest.bookId,
+		entryId: String(rest.entryId ?? ""),
+		reason: rest.reason,
+		voidDate: rest.voidDate
+	}),
+	[ACCOUNTING_ACTIONS.getJournalEntries]: (rest) => listEntries({
+		bookId: rest.bookId,
+		from: rest.from,
+		to: rest.to,
+		accountCode: rest.accountCode
+	}),
+	[ACCOUNTING_ACTIONS.getOpeningBalances]: (rest) => getOpeningBalances({ bookId: rest.bookId }),
+	[ACCOUNTING_ACTIONS.setOpeningBalances]: (rest) => setOpeningBalances({
+		bookId: rest.bookId,
+		asOfDate: String(rest.asOfDate ?? ""),
+		lines: rest.lines ?? [],
+		memo: rest.memo
+	}),
+	[ACCOUNTING_ACTIONS.getReport]: handleGetReport,
+	[ACCOUNTING_ACTIONS.getTimeSeries]: (rest) => getTimeSeriesReport({
+		bookId: rest.bookId,
+		metric: rest.metric,
+		granularity: rest.granularity,
+		from: rest.from,
+		to: rest.to,
+		accountCode: rest.accountCode
+	}),
+	[ACCOUNTING_ACTIONS.rebuildSnapshots]: (rest) => rebuildSnapshots({ bookId: rest.bookId })
+};
+var PREVIEW_ACTIONS = /* @__PURE__ */ new Set([
+	ACCOUNTING_ACTIONS.openBook,
+	ACCOUNTING_ACTIONS.createBook,
+	ACCOUNTING_ACTIONS.updateBook,
+	ACCOUNTING_ACTIONS.upsertAccount,
+	ACCOUNTING_ACTIONS.addEntries,
+	ACCOUNTING_ACTIONS.voidEntry,
+	ACCOUNTING_ACTIONS.setOpeningBalances
+]);
+var VIEW_VISIBLE_TRAILER = "The accounting view is shown to the user.";
+var MESSAGE_BUILDERS = {
+	[ACCOUNTING_ACTIONS.openBook]: (fields) => {
+		const { books, bookId } = fields;
+		const booksFragment = Array.isArray(books) ? ` Books available: ${JSON.stringify(books)}.` : "";
+		return `Mounted the accounting app in the canvas${typeof bookId === "string" ? ` (book id: ${bookId})` : ""}.${booksFragment}`;
+	},
+	[ACCOUNTING_ACTIONS.createBook]: (fields) => {
+		const book = fields.book;
+		return `${book?.name ? `A new book named ${JSON.stringify(book.name)}` : "A new book"} has been created${book?.id ? ` (id: ${book.id})` : ""}. Next required step: set opening balances via setOpeningBalances — the journal-entry, ledger, and report tabs are locked until an opening (even an empty one) is saved.`;
+	},
+	[ACCOUNTING_ACTIONS.upsertAccount]: (fields) => {
+		const account = fields.account;
+		if (account?.code && account?.name) return `Upserted account ${account.code} ${JSON.stringify(account.name)}.`;
+		return "Updated the chart of accounts.";
+	},
+	[ACCOUNTING_ACTIONS.addEntries]: (fields) => {
+		const entries = Array.isArray(fields.entries) ? fields.entries : [];
+		if (entries.length === 0) return "Posted 0 journal entries.";
+		if (entries.length === 1) {
+			const [entry] = entries;
+			const idFragment = entry?.id ? ` (id: ${entry.id})` : "";
+			return `Posted a journal entry on ${entry?.date ?? "the requested date"}${idFragment}.`;
+		}
+		const summary = entries.map((entry) => `${entry?.date ?? "?"} (id: ${entry?.id ?? "?"})`).join(", ");
+		return `Posted ${entries.length} journal entries: ${summary}.`;
+	},
+	[ACCOUNTING_ACTIONS.voidEntry]: (fields) => {
+		return `Voided the entry; a reversing pair was posted on ${fields.reverseEntry?.date ?? "today"}.`;
+	},
+	[ACCOUNTING_ACTIONS.setOpeningBalances]: (fields) => {
+		const opening = fields.openingEntry;
+		const verb = fields.replacedExisting === true ? "replaced" : "set";
+		const date = opening?.date ?? "the requested date";
+		const lines = Array.isArray(opening?.lines) ? opening.lines : [];
+		return `Opening balances were ${verb} as of ${date}.${lines.length > 0 ? ` Lines: ${JSON.stringify(lines)}.` : ""}`;
+	},
+	[ACCOUNTING_ACTIONS.deleteBook]: (fields) => {
+		const bookId = fields.deletedBookId;
+		const name = fields.deletedBookName;
+		return `Deleted ${name ? `the book ${JSON.stringify(name)}` : "the book"}${bookId ? ` (id: ${bookId})` : ""}.`;
+	},
+	[ACCOUNTING_ACTIONS.updateBook]: (fields) => {
+		const book = fields.book;
+		return `Updated ${book?.name ? JSON.stringify(book.name) : "the book"}${book?.country ? ` (country: ${book.country})` : ""}.`;
+	}
+};
+function previewMessage(action, fields) {
+	const head = Object.hasOwn(MESSAGE_BUILDERS, action) ? MESSAGE_BUILDERS[action](fields) : void 0;
+	return head ? `${head} ${VIEW_VISIBLE_TRAILER}` : VIEW_VISIBLE_TRAILER;
+}
+async function dispatch(body) {
+	const { action, ...rest } = body;
+	if (!Object.hasOwn(ACTION_HANDLERS, action)) throw new AccountingError(400, `unknown action ${JSON.stringify(action)}`);
+	const handler = ACTION_HANDLERS[action];
+	const result = await handler(rest);
+	const handlerFields = result && typeof result === "object" ? result : { value: result };
+	const dataField = PREVIEW_ACTIONS.has(action) ? { data: {
+		action,
+		...handlerFields
+	} } : {};
+	const messageField = (typeof handlerFields.message === "string" ? handlerFields.message : void 0) ? {} : MESSAGE_BUILDERS[action] ? { message: previewMessage(action, handlerFields) } : { message: JSON.stringify(handlerFields) };
+	return {
+		action,
+		...handlerFields,
+		...messageField,
+		...dataField
+	};
+}
+/** Build the accounting Express router. The host injects its workspace
+*  root + logger via `configureAccountingServer(...)` and pub/sub via
+*  `initAccountingEventPublisher(...)`, then mounts the returned router
+*  with `app.use(...)`. */
+function createAccountingRouter() {
+	const router = Router();
+	router.post("/api/accounting", asyncHandler("accounting", "accounting dispatch failed", async (req, res) => {
+		const { body } = req;
+		if (!body || typeof body !== "object" || typeof body.action !== "string") {
+			log.warn("accounting", "POST dispatch: invalid body");
+			res.status(400).json({ error: "request body must be an object with a string `action` field" });
+			return;
+		}
+		const { action } = body;
+		log.info("accounting", "POST dispatch: start", { action });
+		try {
+			const result = await dispatch(body);
+			log.info("accounting", "POST dispatch: ok", { action });
+			res.json(result);
+		} catch (err) {
+			if (err instanceof AccountingError) {
+				log.warn("accounting", "POST dispatch: error", {
+					action,
+					status: err.status,
+					message: err.message
+				});
+				res.status(err.status).json({
+					error: err.message,
+					details: err.details
+				});
+				return;
+			}
+			throw err;
+		}
+	}));
+	return router;
+}
+//#endregion
+export { configureAccountingServer, createAccountingRouter, initAccountingEventPublisher, isValidCalendarDate };
+
+//# sourceMappingURL=server.js.map