@mulmoclaude/accounting-plugin 2.0.0 → 2.2.0

package/dist/server.cjs

@@ -16,12 +16,12 @@ var __copyProps = (to, from, except, desc) => {
 	}
 	return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
 	value: mod,
 	enumerable: true
 }) : target, mod));
 //#endregion
-const require_shared = require("./shared-BpFVwa6Y.cjs");
+const require_shared = require("./shared-Dgt-i23T.cjs");
 let express = require("express");
 let node_crypto = require("node:crypto");
 let node_fs = require("node:fs");
@@ -84,11 +84,41 @@ function configureAccountingServer(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). */
+*  (unit tests always pass an explicit root, so they never hit this) —
+*  and also under STRICT mode (`workspaceRoot: null`), where there is no
+*  ambient root to fall back to and a missing option is a bug rather
+*  than a default. */
 function defaultWorkspaceRoot() {
 	if (!deps) throw new Error("@mulmoclaude/accounting-plugin: configureAccountingServer() must be called before serving accounting requests");
+	if (deps.workspaceRoot === null) throw new Error("@mulmoclaude/accounting-plugin: this host is configured with workspaceRoot: null (explicit-root mode), so every call must pass a workspaceRoot. A call reached the engine without one.");
 	return deps.workspaceRoot;
 }
+/** The opaque channel scope for a root, or `null` when the host declared
+*  none (single-root hosts, and a multi-root host's default root). Used
+*  by the event publisher; never contains a path.
+*
+*  A missing root throws under explicit-root mode, exactly as
+*  `defaultWorkspaceRoot()` does. Returning `null` there would be worse
+*  than the io-path bug it mirrors: the event would go out on the
+*  UNSCOPED channel name, which every project's default-scope
+*  subscriber receives. The publisher catches it and logs, so a dropped
+*  root costs one event and a warning rather than a silent cross-project
+*  notification. */
+function channelScopeFor(workspaceRoot) {
+	if (!deps?.channelScopeForRoot) return null;
+	return deps.channelScopeForRoot(workspaceRoot ?? defaultWorkspaceRoot());
+}
+/** Whether the host declared project scoping at all.
+*
+*  The difference matters where a card records the project it belongs
+*  to: on a scoped host, "no scope" is a REAL answer (the default root)
+*  and must be recorded as `null`, not left out — an omitted field means
+*  "ask the host what is active now", which is precisely the drift a
+*  pinned card exists to prevent. On an unscoped host the field is left
+*  out entirely and every payload stays byte-identical to today's. */
+function isProjectScopedHost() {
+	return Boolean(deps?.channelScopeForRoot);
+}
 var consoleLogger = {
 	error: (namespace, msg, data) => console.error(`[${namespace}] ${msg}`, data ?? ""),
 	warn: (namespace, msg, data) => console.warn(`[${namespace}] ${msg}`, data ?? ""),
@@ -1165,9 +1195,16 @@ var pubsub = null;
 function initAccountingEventPublisher(instance) {
 	pubsub = instance;
 }
-function safePublish(channel, payload) {
+/** `channelFor` is called INSIDE the guard, not before it: resolving the
+*  scope can throw (a write that reached the publisher with no root
+*  under explicit-root mode), and a lost event with a warning beats
+*  either crashing the write or publishing to the unscoped channel that
+*  every project can hear. */
+function safePublish(channelFor, payload) {
 	if (!pubsub) return;
+	let channel = "(unresolved)";
 	try {
+		channel = channelFor();
 		pubsub.publish(channel, payload);
 	} catch (err) {
 		log.warn("accounting", "publish failed; subscribers will miss this event", {
@@ -1178,15 +1215,20 @@ function safePublish(channel, payload) {
 }
 /** 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(require_shared.bookChannel(bookId), payload);
+*  events).
+*
+*  `workspaceRoot` is the root the write happened under; the channel
+*  name is namespaced by the host's opaque scope for it (see
+*  `channelScopeFor`). Omit it — as a single-root host's service calls
+*  do — and the name is what it has always been. */
+function publishBookChange(bookId, payload, workspaceRoot) {
+	safePublish(() => require_shared.bookChannel(bookId, channelScopeFor(workspaceRoot)), payload);
 }
 /** Fired when the *list* of books changes (createBook, deleteBook).
 *  Payload is intentionally empty — subscribers refetch from
-*  /api/accounting. */
-function publishBooksChanged() {
-	safePublish(require_shared.ACCOUNTING_BOOKS_CHANNEL, {});
+*  /api/accounting. Scoped by root like `publishBookChange`. */
+function publishBooksChanged(workspaceRoot) {
+	safePublish(() => require_shared.booksChannel(channelScopeFor(workspaceRoot)), {});
 }
 //#endregion
 //#region src/server/snapshotCache.ts
@@ -1255,18 +1297,39 @@ async function rebuildAllSnapshots(bookId, workspaceRoot) {
 	return { rebuilt: periods };
 }
 var rebuildQueues = /* @__PURE__ */ new Map();
+/** Canonical key for the root a rebuild belongs to. An absent root
+*  resolves to the host's configured one, so a call that passes it
+*  explicitly and one that relies on the default share a queue. Under
+*  explicit-root mode there is no default and `defaultWorkspaceRoot()`
+*  throws — deliberately loud: a `cancelRebuild` / `awaitRebuildIdle`
+*  that quietly keyed a queue nobody scheduled would return while the
+*  real rebuild is still writing, which is how `deleteBook` races a
+*  `writeSnapshot` back into existence.
+*
+*  Lexical resolution only — symlinks are deliberately NOT resolved,
+*  matching `canonicalRoot` in `@mulmoclaude/core`'s collection engine,
+*  so one project has one identity across both packages. A host that
+*  hands the engine a real path in one call and a symlink alias in the
+*  next would split the queue; the fix belongs in the host's own root
+*  resolution, which is where the two packages agree it lives. */
+function rootKey(workspaceRoot) {
+	return node_path.default.resolve(workspaceRoot ?? defaultWorkspaceRoot());
+}
+function queueKey(bookId, workspaceRoot) {
+	return `${rootKey(workspaceRoot)}\u0000${bookId}`;
+}
 function minPeriod(lhs, rhs) {
 	if (lhs === null) return rhs;
 	return lhs < rhs ? lhs : rhs;
 }
-function isInvalidatedDuringRebuild(bookId, period) {
-	const queue = rebuildQueues.get(bookId);
+function isInvalidatedDuringRebuild(key, period) {
+	const queue = rebuildQueues.get(key);
 	return queue !== void 0 && queue.pendingFromPeriod !== null && period >= queue.pendingFromPeriod;
 }
-function isCancelled(bookId) {
-	return rebuildQueues.get(bookId)?.cancelled === true;
+function isCancelled(key) {
+	return rebuildQueues.get(key)?.cancelled === true;
 }
-async function runRebuild(bookId, fromPeriod, workspaceRoot) {
+async function runRebuild(key, bookId, fromPeriod, workspaceRoot) {
 	const startedAt = Date.now();
 	log.info("accounting", "snapshot rebuild started", {
 		bookId,
@@ -1275,25 +1338,25 @@ async function runRebuild(bookId, fromPeriod, workspaceRoot) {
 	publishBookChange(bookId, {
 		kind: require_shared.BOOK_EVENT_KINDS.snapshotsRebuilding,
 		period: fromPeriod
-	});
+	}, workspaceRoot);
 	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;
+		if (isCancelled(key)) break;
+		if (isInvalidatedDuringRebuild(key, monthKey)) break;
 		const balances = await balancesAtEndOf(bookId, monthKey, workspaceRoot);
-		if (isCancelled(bookId)) break;
-		if (isInvalidatedDuringRebuild(bookId, monthKey)) break;
+		if (isCancelled(key)) break;
+		if (isInvalidatedDuringRebuild(key, monthKey)) break;
 		await writeSnapshot(bookId, {
 			period: monthKey,
 			balances,
 			builtAt: (/* @__PURE__ */ new Date()).toISOString()
 		}, workspaceRoot);
-		if (isCancelled(bookId)) {
+		if (isCancelled(key)) {
 			await invalidateSnapshotsFrom(bookId, monthKey, workspaceRoot);
 			break;
 		}
-		if (isInvalidatedDuringRebuild(bookId, monthKey)) {
+		if (isInvalidatedDuringRebuild(key, monthKey)) {
 			await invalidateSnapshotsFrom(bookId, monthKey, workspaceRoot);
 			break;
 		}
@@ -1301,7 +1364,7 @@ async function runRebuild(bookId, fromPeriod, workspaceRoot) {
 		publishBookChange(bookId, {
 			kind: require_shared.BOOK_EVENT_KINDS.snapshotsReady,
 			period: monthKey
-		});
+		}, workspaceRoot);
 	}
 	log.info("accounting", "snapshot rebuild done", {
 		bookId,
@@ -1309,7 +1372,7 @@ async function runRebuild(bookId, fromPeriod, workspaceRoot) {
 		durationMs: Date.now() - startedAt
 	});
 }
-function startRebuild(bookId, fromPeriod, workspaceRoot) {
+function startRebuild(key, bookId, fromPeriod, workspaceRoot) {
 	const entry = {
 		running: Promise.resolve(),
 		pendingFromPeriod: null,
@@ -1318,27 +1381,27 @@ function startRebuild(bookId, fromPeriod, workspaceRoot) {
 		runningFromPeriod: fromPeriod,
 		cancelled: false
 	};
-	entry.running = runRebuild(bookId, fromPeriod, workspaceRoot).catch((err) => {
+	entry.running = runRebuild(key, bookId, fromPeriod, workspaceRoot).catch((err) => {
 		log.error("accounting", "snapshot rebuild failed", {
 			bookId,
 			fromPeriod,
 			error: require_shared.errorMessage(err)
 		});
 	}).then(() => {
-		const current = rebuildQueues.get(bookId);
+		const current = rebuildQueues.get(key);
 		if (!current) return;
 		if (current.cancelled) {
-			rebuildQueues.delete(bookId);
+			rebuildQueues.delete(key);
 			return;
 		}
 		if (current.pendingFromPeriod !== null) {
 			const nextFrom = current.pendingFromPeriod;
 			const nextRoot = current.pendingWorkspaceRoot;
 			const carriedCount = current.coalescedWriteCount;
-			const successor = startRebuild(bookId, nextFrom, nextRoot);
+			const successor = startRebuild(key, bookId, nextFrom, nextRoot);
 			successor.coalescedWriteCount += carriedCount;
-			rebuildQueues.set(bookId, successor);
-		} else rebuildQueues.delete(bookId);
+			rebuildQueues.set(key, successor);
+		} else rebuildQueues.delete(key);
 	});
 	return entry;
 }
@@ -1347,9 +1410,10 @@ function startRebuild(bookId, fromPeriod, workspaceRoot) {
 *  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);
+	const key = queueKey(bookId, workspaceRoot);
+	const existing = rebuildQueues.get(key);
 	if (!existing) {
-		rebuildQueues.set(bookId, startRebuild(bookId, fromPeriod, workspaceRoot));
+		rebuildQueues.set(key, startRebuild(key, bookId, fromPeriod, workspaceRoot));
 		return;
 	}
 	existing.pendingFromPeriod = minPeriod(existing.pendingFromPeriod, fromPeriod);
@@ -1360,9 +1424,10 @@ function scheduleRebuild(bookId, fromPeriod, workspaceRoot) {
 *  `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);
+async function awaitRebuildIdle(bookId, workspaceRoot) {
+	const key = queueKey(bookId, workspaceRoot);
+	while (rebuildQueues.has(key)) {
+		const entry = rebuildQueues.get(key);
 		if (!entry) return;
 		await entry.running;
 	}
@@ -1372,8 +1437,8 @@ async function awaitRebuildIdle(bookId) {
 *  `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);
+function cancelRebuild(bookId, workspaceRoot) {
+	const entry = rebuildQueues.get(queueKey(bookId, workspaceRoot));
 	if (!entry) return;
 	entry.cancelled = true;
 	entry.pendingFromPeriod = null;
@@ -1727,7 +1792,7 @@ async function createBook(input, workspaceRoot) {
 	await ensureBookDir(bookId, workspaceRoot);
 	await writeAccounts(bookId, [...DEFAULT_ACCOUNTS], workspaceRoot);
 	await writeConfig({ books: [...config.books, book] }, workspaceRoot);
-	publishBooksChanged();
+	publishBooksChanged(workspaceRoot);
 	return { book };
 }
 async function updateBook(input, workspaceRoot) {
@@ -1744,7 +1809,7 @@ async function updateBook(input, workspaceRoot) {
 	};
 	if (country === "") delete next.country;
 	await writeConfig({ books: config.books.map((book) => book.id === input.bookId ? next : book) }, workspaceRoot);
-	publishBooksChanged();
+	publishBooksChanged(workspaceRoot);
 	return { book: next };
 }
 async function deleteBook(input, workspaceRoot) {
@@ -1752,11 +1817,11 @@ async function deleteBook(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`);
-	cancelRebuild(input.bookId);
-	await awaitRebuildIdle(input.bookId);
+	cancelRebuild(input.bookId, workspaceRoot);
+	await awaitRebuildIdle(input.bookId, workspaceRoot);
 	await removeBookDir(input.bookId, workspaceRoot);
 	await writeConfig({ books: config.books.filter((book) => book.id !== input.bookId) }, workspaceRoot);
-	publishBooksChanged();
+	publishBooksChanged(workspaceRoot);
 	return {
 		deletedBookId: input.bookId,
 		deletedBookName: target.name
@@ -1806,7 +1871,7 @@ async function upsertAccount(input, workspaceRoot) {
 		scheduleRebuild(bookId, "0000-00", workspaceRoot);
 		await invalidateAllSnapshots(bookId, workspaceRoot);
 	}
-	publishBookChange(bookId, { kind: require_shared.BOOK_EVENT_KINDS.accounts });
+	publishBookChange(bookId, { kind: require_shared.BOOK_EVENT_KINDS.accounts }, workspaceRoot);
 	return {
 		bookId,
 		account,
@@ -1855,7 +1920,7 @@ async function addEntries(input, workspaceRoot) {
 	publishBookChange(bookId, {
 		kind: require_shared.BOOK_EVENT_KINDS.journal,
 		period: earliestPeriod
-	});
+	}, workspaceRoot);
 	return {
 		bookId,
 		entries: built
@@ -1884,7 +1949,7 @@ async function voidEntry(input, workspaceRoot) {
 	publishBookChange(bookId, {
 		kind: require_shared.BOOK_EVENT_KINDS.journal,
 		period: fromPeriod
-	});
+	}, workspaceRoot);
 	return {
 		bookId,
 		reverseEntry: reverse,
@@ -1948,7 +2013,7 @@ async function setOpeningBalances(input, workspaceRoot) {
 	await appendJournal(bookId, opening, workspaceRoot);
 	scheduleRebuild(bookId, "0000-00", workspaceRoot);
 	await invalidateAllSnapshots(bookId, workspaceRoot);
-	publishBookChange(bookId, { kind: require_shared.BOOK_EVENT_KINDS.opening });
+	publishBookChange(bookId, { kind: require_shared.BOOK_EVENT_KINDS.opening }, workspaceRoot);
 	return {
 		bookId,
 		openingEntry: opening,
@@ -2046,9 +2111,10 @@ function validateTimeSeriesInput(input) {
 async function loadTimeSeriesBookContext(requestedBookId, workspaceRoot) {
 	const config = await loadOrInitConfig(workspaceRoot);
 	const bookId = resolveBookId(config, requestedBookId);
+	const book = findBook(config, bookId);
 	return {
 		bookId,
-		fiscalYearEnd: require_shared.resolveFiscalYearEnd(findBook(config, bookId)?.fiscalYearEnd),
+		fiscalYearEnd: require_shared.resolveFiscalYearEnd(book?.fiscalYearEnd),
 		accounts: await readAccounts(bookId, workspaceRoot)
 	};
 }
@@ -2082,7 +2148,7 @@ async function getTimeSeriesReport(input, workspaceRoot) {
 async function rebuildSnapshots(input, workspaceRoot) {
 	const bookId = resolveBookId(await loadOrInitConfig(workspaceRoot), input.bookId);
 	const result = await rebuildAllSnapshots(bookId, workspaceRoot);
-	publishBookChange(bookId, { kind: require_shared.BOOK_EVENT_KINDS.snapshotsReady });
+	publishBookChange(bookId, { kind: require_shared.BOOK_EVENT_KINDS.snapshotsReady }, workspaceRoot);
 	return {
 		bookId,
 		rebuilt: result.rebuilt
@@ -2109,19 +2175,21 @@ function asyncHandler(namespace, fallbackMessage, handler) {
 }
 //#endregion
 //#region src/server/router.ts
-async function handleOpenBook(rest) {
+async function handleOpenBook(rest, root) {
 	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();
+	const list = await listBooks(root);
 	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;
+	const scopeField = isProjectScopedHost() ? { scope: channelScopeFor(root) } : {};
 	return {
 		kind: "accounting-app",
 		bookId: rest.bookId,
 		initialTab,
-		books: list.books
+		books: list.books,
+		...scopeField
 	};
 }
-async function handleGetReport(rest) {
+async function handleGetReport(rest, root) {
 	const kind = typeof rest.kind === "string" ? rest.kind : "";
 	const periodInput = optionalReportPeriod(rest.period);
 	const bookId = optionalString(rest.bookId);
@@ -2132,14 +2200,14 @@ async function handleGetReport(rest) {
 		return getBalanceSheetReport({
 			bookId,
 			period: periodInput
-		});
+		}, root);
 	}
 	if (kind === "pl") {
 		if (!periodInput) throw periodRequired("getReport pl");
 		return getProfitLossReport({
 			bookId,
 			period: periodInput
-		});
+		}, root);
 	}
 	if (kind === "ledger") {
 		if (typeof rest.accountCode !== "string" || rest.accountCode === "") throw new AccountingError(400, "getReport ledger: accountCode is required");
@@ -2147,79 +2215,79 @@ async function handleGetReport(rest) {
 			bookId,
 			accountCode: rest.accountCode,
 			period: periodInput
-		});
+		}, root);
 	}
 	throw new AccountingError(400, `getReport: unknown kind ${JSON.stringify(kind)}`);
 }
 var ACTION_HANDLERS = {
 	[require_shared.ACCOUNTING_ACTIONS.openBook]: handleOpenBook,
-	[require_shared.ACCOUNTING_ACTIONS.getBooks]: () => listBooks(),
-	[require_shared.ACCOUNTING_ACTIONS.createBook]: async (rest) => {
+	[require_shared.ACCOUNTING_ACTIONS.getBooks]: (_rest, root) => listBooks(root),
+	[require_shared.ACCOUNTING_ACTIONS.createBook]: async (rest, root) => {
 		const result = await createBook({
 			name: typeof rest.name === "string" ? rest.name : "",
 			currency: typeof rest.currency === "string" ? rest.currency : void 0,
 			country: typeof rest.country === "string" ? rest.country : void 0,
 			fiscalYearEnd: rest.fiscalYearEnd
-		});
+		}, root);
 		return {
 			bookId: result.book.id,
 			...result
 		};
 	},
-	[require_shared.ACCOUNTING_ACTIONS.updateBook]: async (rest) => {
+	[require_shared.ACCOUNTING_ACTIONS.updateBook]: async (rest, root) => {
 		const result = await updateBook({
 			bookId: typeof rest.bookId === "string" ? rest.bookId : "",
 			name: typeof rest.name === "string" ? rest.name : void 0,
 			country: typeof rest.country === "string" ? rest.country : void 0,
 			fiscalYearEnd: rest.fiscalYearEnd
-		});
+		}, root);
 		return {
 			bookId: result.book.id,
 			...result
 		};
 	},
-	[require_shared.ACCOUNTING_ACTIONS.deleteBook]: (rest) => deleteBook({
+	[require_shared.ACCOUNTING_ACTIONS.deleteBook]: (rest, root) => deleteBook({
 		bookId: typeof rest.bookId === "string" ? rest.bookId : "",
 		confirm: rest.confirm === true
-	}),
-	[require_shared.ACCOUNTING_ACTIONS.getAccounts]: (rest) => listAccounts({ bookId: optionalString(rest.bookId) }),
-	[require_shared.ACCOUNTING_ACTIONS.upsertAccount]: (rest) => upsertAccount({
+	}, root),
+	[require_shared.ACCOUNTING_ACTIONS.getAccounts]: (rest, root) => listAccounts({ bookId: optionalString(rest.bookId) }, root),
+	[require_shared.ACCOUNTING_ACTIONS.upsertAccount]: (rest, root) => upsertAccount({
 		bookId: optionalString(rest.bookId),
 		account: rest.account
-	}),
-	[require_shared.ACCOUNTING_ACTIONS.addEntries]: (rest) => addEntries({
+	}, root),
+	[require_shared.ACCOUNTING_ACTIONS.addEntries]: (rest, root) => addEntries({
 		bookId: optionalString(rest.bookId),
 		entries: rest.entries
-	}),
-	[require_shared.ACCOUNTING_ACTIONS.voidEntry]: (rest) => voidEntry({
+	}, root),
+	[require_shared.ACCOUNTING_ACTIONS.voidEntry]: (rest, root) => voidEntry({
 		bookId: optionalString(rest.bookId),
 		entryId: typeof rest.entryId === "string" ? rest.entryId : "",
 		reason: optionalString(rest.reason),
 		voidDate: optionalString(rest.voidDate)
-	}),
-	[require_shared.ACCOUNTING_ACTIONS.getJournalEntries]: (rest) => listEntries({
+	}, root),
+	[require_shared.ACCOUNTING_ACTIONS.getJournalEntries]: (rest, root) => listEntries({
 		bookId: optionalString(rest.bookId),
 		from: optionalString(rest.from),
 		to: optionalString(rest.to),
 		accountCode: optionalString(rest.accountCode)
-	}),
-	[require_shared.ACCOUNTING_ACTIONS.getOpeningBalances]: (rest) => getOpeningBalances({ bookId: optionalString(rest.bookId) }),
-	[require_shared.ACCOUNTING_ACTIONS.setOpeningBalances]: (rest) => setOpeningBalances({
+	}, root),
+	[require_shared.ACCOUNTING_ACTIONS.getOpeningBalances]: (rest, root) => getOpeningBalances({ bookId: optionalString(rest.bookId) }, root),
+	[require_shared.ACCOUNTING_ACTIONS.setOpeningBalances]: (rest, root) => setOpeningBalances({
 		bookId: optionalString(rest.bookId),
 		asOfDate: typeof rest.asOfDate === "string" ? rest.asOfDate : "",
 		lines: rest.lines ?? [],
 		memo: optionalString(rest.memo)
-	}),
+	}, root),
 	[require_shared.ACCOUNTING_ACTIONS.getReport]: handleGetReport,
-	[require_shared.ACCOUNTING_ACTIONS.getTimeSeries]: (rest) => getTimeSeriesReport({
+	[require_shared.ACCOUNTING_ACTIONS.getTimeSeries]: (rest, root) => getTimeSeriesReport({
 		bookId: optionalString(rest.bookId),
 		metric: rest.metric,
 		granularity: rest.granularity,
 		from: rest.from,
 		to: rest.to,
 		accountCode: rest.accountCode
-	}),
-	[require_shared.ACCOUNTING_ACTIONS.rebuildSnapshots]: (rest) => rebuildSnapshots({ bookId: optionalString(rest.bookId) })
+	}, root),
+	[require_shared.ACCOUNTING_ACTIONS.rebuildSnapshots]: (rest, root) => rebuildSnapshots({ bookId: optionalString(rest.bookId) }, root)
 };
 var PREVIEW_ACTIONS = /* @__PURE__ */ new Set([
 	require_shared.ACCOUNTING_ACTIONS.openBook,
@@ -2296,11 +2364,11 @@ function previewMessage(action, fields) {
 	const head = ownEntry(MESSAGE_BUILDERS, action)?.(fields);
 	return head ? `${head} ${VIEW_VISIBLE_TRAILER}` : VIEW_VISIBLE_TRAILER;
 }
-async function dispatch(body) {
+async function dispatch(body, root) {
 	const { action, ...rest } = body;
 	const handler = ownEntry(ACTION_HANDLERS, action);
 	if (!handler) throw new AccountingError(400, `unknown action ${JSON.stringify(action)}`);
-	const result = await handler(rest);
+	const result = await handler(rest, root);
 	const handlerFields = require_shared.isRecord(result) ? result : { value: result };
 	const dataField = PREVIEW_ACTIONS.has(action) ? { data: {
 		action,
@@ -2317,8 +2385,9 @@ async function dispatch(body) {
 /** 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() {
+*  with `app.use(...)`. Pass `resolveWorkspaceRoot` to serve more than
+*  one root; omit it and every request uses the configured one. */
+function createAccountingRouter(options = {}) {
 	const router = (0, express.Router)();
 	router.post(require_shared.ACCOUNTING_API.dispatch.path, asyncHandler("accounting", "accounting dispatch failed", async (req, res) => {
 		const { body } = req;
@@ -2330,7 +2399,8 @@ function createAccountingRouter() {
 		const { action } = body;
 		log.info("accounting", "POST dispatch: start", { action });
 		try {
-			const result = await dispatch(body);
+			const root = options.resolveWorkspaceRoot?.(req);
+			const result = await dispatch(body, root);
 			log.info("accounting", "POST dispatch: ok", { action });
 			res.json(result);
 		} catch (err) {