@actual-app/api 26.5.0 → 26.6.0-nightly.20260504

package/dist/index.js

@@ -109162,12 +109162,22 @@ function getStatus(nextDate, completed, hasTrans, upcomingLength = "7") {
 	else if (nextDate < today) return "missed";
 	else return "scheduled";
 }
+/**
+* Builds a query to check if each schedule already has a matching transaction.
+*
+* The date lower-bound varies:
+* - `dateCond.op === 'is'` (one-time): exact `next_date`, no lookback.
+* - `posts_transaction` (auto-posted recurring): exact `next_date`, since
+*   auto-posted dates are always precise. A lookback here would cause
+*   yesterday's transaction to falsely match today's occurrence.
+* - Otherwise (manual recurring): 2-day lookback to catch early payments.
+*/
 function getHasTransactionsQuery(schedules) {
 	const filters = schedules.map((schedule) => {
 		const dateCond = schedule._conditions?.find((c) => c.field === "date");
 		return { $and: {
 			schedule: schedule.id,
-			date: { $gte: dateCond && dateCond.op === "is" ? schedule.next_date : subDays(schedule.next_date, 2) }
+			date: { $gte: dateCond && dateCond.op === "is" ? schedule.next_date : schedule.posts_transaction ? schedule.next_date : subDays(schedule.next_date, 2) }
 		} };
 	});
 	return q$1("transactions").options({ splits: "all" }).filter({ $or: filters }).orderBy({ date: "desc" }).select(["schedule", "date"]);
@@ -115080,8 +115090,9 @@ function getPayMonthOfTotal(t) {
 	for (const schedule of schedules) total += schedule.target;
 	return total;
 }
-async function getSinkingContributionTotal(t, remainder, last_month_balance) {
+function getSinkingContributionBreakdown(t, remainder, last_month_balance) {
 	let total = 0;
+	const perSchedule = /* @__PURE__ */ new Map();
 	for (const [index, schedule] of t.entries()) {
 		remainder = index === 0 ? schedule.target - last_month_balance : schedule.target - remainder;
 		let tg = 0;
@@ -115092,41 +115103,37 @@ async function getSinkingContributionTotal(t, remainder, last_month_balance) {
 			tg = 0;
 			remainder = Math.abs(remainder);
 		}
-		total += tg / (schedule.num_months + 1);
+		const contribution = tg / (schedule.num_months + 1);
+		total += contribution;
+		perSchedule.set(schedule.name.trim(), (perSchedule.get(schedule.name.trim()) ?? 0) + contribution);
+	}
+	return {
+		total,
+		perSchedule
+	};
+}
+function getMonthlyBaseContribution(schedule) {
+	let prevDate;
+	let intervalMonths;
+	switch (schedule.target_frequency) {
+		case "yearly": return schedule.target / schedule.target_interval / 12;
+		case "monthly": return schedule.target / schedule.target_interval;
+		case "weekly":
+			prevDate = subWeeks(schedule.next_date_string, schedule.target_interval);
+			intervalMonths = differenceInCalendarMonths(schedule.next_date_string, prevDate);
+			if (intervalMonths === 0) intervalMonths = 1;
+			return schedule.target / intervalMonths;
+		case "daily":
+			prevDate = subDays(schedule.next_date_string, schedule.target_interval);
+			intervalMonths = differenceInCalendarMonths(schedule.next_date_string, prevDate);
+			if (intervalMonths === 0) intervalMonths = 1;
+			return schedule.target / intervalMonths;
+		default: return schedule.target / schedule.target_interval;
 	}
-	return total;
 }
 function getSinkingBaseContributionTotal(t) {
 	let total = 0;
-	for (const schedule of t) {
-		let monthlyAmount = 0;
-		let prevDate;
-		let intervalMonths;
-		switch (schedule.target_frequency) {
-			case "yearly":
-				monthlyAmount = schedule.target / schedule.target_interval / 12;
-				break;
-			case "monthly":
-				monthlyAmount = schedule.target / schedule.target_interval;
-				break;
-			case "weekly":
-				prevDate = subWeeks(schedule.next_date_string, schedule.target_interval);
-				intervalMonths = differenceInCalendarMonths(schedule.next_date_string, prevDate);
-				if (intervalMonths === 0) intervalMonths = 1;
-				monthlyAmount = schedule.target / intervalMonths;
-				break;
-			case "daily":
-				prevDate = subDays(schedule.next_date_string, schedule.target_interval);
-				intervalMonths = differenceInCalendarMonths(schedule.next_date_string, prevDate);
-				if (intervalMonths === 0) intervalMonths = 1;
-				monthlyAmount = schedule.target / intervalMonths;
-				break;
-			default:
-				monthlyAmount = schedule.target / schedule.target_interval;
-				break;
-		}
-		total += monthlyAmount;
-	}
+	for (const schedule of t) total += getMonthlyBaseContribution(schedule);
 	return total;
 }
 function getSinkingTotal(t) {
@@ -115146,16 +115153,26 @@ async function runSchedule(template_lines, current_month, balance, remainder, la
 	const totalSinking = getSinkingTotal(t_sinking);
 	const totalSinkingBaseContribution = getSinkingBaseContributionTotal(t_sinking);
 	const lastMonthGoal = await getSheetValue(sheetForMonth(subMonths(current_month, 1)), `goal-${category.id}`);
-	if (balance >= totalSinking + totalPayMonthOf || lastMonthGoal < totalSinking + totalPayMonthOf && lastMonthGoal !== 0 && balance >= lastMonthGoal && numSubMonthly > 0) to_budget += Math.round(totalPayMonthOf + totalSinkingBaseContribution);
-	else {
-		const totalSinkingContribution = await getSinkingContributionTotal(t_sinking, remainder, last_month_balance);
+	const perScheduleMonthly = /* @__PURE__ */ new Map();
+	const addContribution = (name, amount) => {
+		perScheduleMonthly.set(name.trim(), (perScheduleMonthly.get(name.trim()) ?? 0) + amount);
+	};
+	if (balance >= totalSinking + totalPayMonthOf || lastMonthGoal < totalSinking + totalPayMonthOf && lastMonthGoal !== 0 && balance >= lastMonthGoal && numSubMonthly > 0) {
+		to_budget += Math.round(totalPayMonthOf + totalSinkingBaseContribution);
+		for (const c of t_payMonthOf) addContribution(c.name, c.target);
+		for (const c of t_sinking) addContribution(c.name, getMonthlyBaseContribution(c));
+	} else {
+		const { total: totalSinkingContribution, perSchedule: sinkingPerSchedule } = getSinkingContributionBreakdown(t_sinking, remainder, last_month_balance);
 		if (t_sinking.length === 0) to_budget += Math.round(totalPayMonthOf + totalSinkingContribution) - last_month_balance;
 		else to_budget += Math.round(totalPayMonthOf + totalSinkingContribution);
+		for (const c of t_payMonthOf) addContribution(c.name, c.target);
+		for (const [name, amount] of sinkingPerSchedule) addContribution(name, amount);
 	}
 	return {
 		to_budget,
 		errors,
-		remainder
+		remainder,
+		perScheduleMonthly
 	};
 }
 //#endregion
@@ -117670,7 +117687,7 @@ async function getCategoriesWithTemplates() {
 	return templatesForCategory;
 }
 function prefixFromPriority(priority) {
-	return priority === null ? TEMPLATE_PREFIX : `${TEMPLATE_PREFIX}-${priority}`;
+	return priority === null || priority === 0 ? TEMPLATE_PREFIX : `${TEMPLATE_PREFIX}-${priority}`;
 }
 async function unparse(templates) {
 	const refill = templates.find((t) => t.type === "refill");
@@ -117760,9 +117777,7 @@ function limitToString(limit) {
 	}
 }
 function periodToString(p) {
-	const { period, amount } = p;
-	if (amount === 1) return period;
-	return `${amount} ${period}s`;
+	return `${p.amount} ${p.period}s`;
 }
 function repeatToString(annual, repeat) {
 	if (annual === void 0) return null;
@@ -117851,9 +117866,12 @@ var CategoryTemplateContext = class CategoryTemplateContext {
 		const t = this.templates.filter((t) => t.directive === "template" && t.priority === priority);
 		let available = budgetAvail || 0;
 		let toBudget = 0;
+		const perTemplateLocal = /* @__PURE__ */ new Map();
 		let byFlag = false;
 		let remainder = 0;
 		let scheduleFlag = false;
+		let schedulePerTemplate = null;
+		let byPerTemplate = null;
 		for (const template of t) {
 			let newBudget = 0;
 			switch (template.type) {
@@ -117876,8 +117894,11 @@ var CategoryTemplateContext = class CategoryTemplateContext {
 					newBudget = await CategoryTemplateContext.runPercentage(template, availStart, this);
 					break;
 				case "by":
-					if (!byFlag) newBudget = CategoryTemplateContext.runBy(this);
-					else newBudget = 0;
+					if (!byFlag) {
+						const ret = CategoryTemplateContext.runBy(this);
+						newBudget = ret.toBudget;
+						byPerTemplate = ret.perTemplateNeed;
+					} else newBudget = 0;
 					byFlag = true;
 					break;
 				case "schedule":
@@ -117886,6 +117907,7 @@ var CategoryTemplateContext = class CategoryTemplateContext {
 						const ret = await runSchedule(t, this.month, budgeted, remainder, this.fromLastMonth, toBudget, [], this.category, this.currency);
 						newBudget = ret.to_budget - toBudget;
 						remainder = ret.remainder;
+						schedulePerTemplate = ret.perScheduleMonthly;
 						scheduleFlag = true;
 					}
 					break;
@@ -117896,24 +117918,51 @@ var CategoryTemplateContext = class CategoryTemplateContext {
 			}
 			available = available - newBudget;
 			toBudget += newBudget;
+			perTemplateLocal.set(template, (perTemplateLocal.get(template) ?? 0) + newBudget);
 		}
+		redistributeBatch(perTemplateLocal, t, "by", (template) => {
+			if (template.type !== "by") return 0;
+			return Math.max(0, byPerTemplate?.get(template) ?? 0);
+		});
+		redistributeBatch(perTemplateLocal, t, "schedule", (template) => {
+			if (template.type !== "schedule") return 0;
+			const monthly = schedulePerTemplate?.get(template.name.trim()) ?? 0;
+			return Math.max(0, monthly);
+		});
+		let scale = 1;
 		if (this.limitCheck) {
 			if (toBudget + this.toBudgetAmount + this.fromLastMonth >= this.limitAmount) {
 				const orig = toBudget;
 				toBudget = this.limitAmount - this.toBudgetAmount - this.fromLastMonth;
 				this.limitMet = true;
 				available = available + orig - toBudget;
+				if (orig > 0) scale *= toBudget / orig;
 			}
 		}
-		if (this.hideDecimal) toBudget = this.removeFraction(toBudget);
+		if (this.hideDecimal) {
+			const preRound = toBudget;
+			toBudget = this.removeFraction(toBudget);
+			if (preRound !== 0) scale *= toBudget / preRound;
+		}
 		if (priority > 0 && available < 0 && !this.category.is_income) {
 			this.fullAmount = (this.fullAmount || 0) + toBudget;
-			toBudget = Math.max(0, toBudget + available);
+			const adjusted = Math.max(0, toBudget + available);
+			if (toBudget > 0) scale *= adjusted / toBudget;
+			toBudget = adjusted;
 			this.toBudgetAmount += toBudget;
 		} else {
 			this.fullAmount = (this.fullAmount || 0) + toBudget;
 			this.toBudgetAmount += toBudget;
 		}
+		const perRowScale = Math.max(0, scale);
+		const items = Array.from(perTemplateLocal);
+		let remaining = Math.max(0, toBudget);
+		items.forEach(([template, value], i) => {
+			const share = i === items.length - 1 ? remaining : Math.max(0, Math.min(remaining, Math.round(value * perRowScale)));
+			const existing = this.perTemplateContribution.get(template) ?? 0;
+			this.perTemplateContribution.set(template, existing + share);
+			remaining -= share;
+		});
 		return this.category.is_income ? -toBudget : toBudget;
 	}
 	runRemainder(budgetAvail, perWeight) {
@@ -117931,6 +117980,17 @@ var CategoryTemplateContext = class CategoryTemplateContext {
 				this.limitMet = true;
 			}
 		}
+		if (toBudget > 0 && this.remainderWeight > 0) {
+			let remaining = toBudget;
+			for (let i = 0; i < this.remainder.length; i++) {
+				const template = this.remainder[i];
+				const share = i === this.remainder.length - 1 ? remaining : Math.round(toBudget * (template.weight / this.remainderWeight));
+				const allocated = Math.max(0, Math.min(share, remaining));
+				const existing = this.perTemplateContribution.get(template) ?? 0;
+				this.perTemplateContribution.set(template, existing + allocated);
+				remaining -= allocated;
+			}
+		}
 		this.toBudgetAmount += toBudget;
 		return toBudget;
 	}
@@ -117939,7 +117999,8 @@ var CategoryTemplateContext = class CategoryTemplateContext {
 		return {
 			budgeted: this.toBudgetAmount,
 			goal: this.goalAmount,
-			longGoal: this.isLongGoal
+			longGoal: this.isLongGoal,
+			perTemplateContribution: this.perTemplateContribution
 		};
 	}
 	category;
@@ -117951,6 +118012,7 @@ var CategoryTemplateContext = class CategoryTemplateContext {
 	hideDecimal = false;
 	remainderWeight = 0;
 	toBudgetAmount = 0;
+	perTemplateContribution = /* @__PURE__ */ new Map();
 	fullAmount = null;
 	isLongGoal = null;
 	goalAmount = null;
@@ -118008,10 +118070,15 @@ var CategoryTemplateContext = class CategoryTemplateContext {
 	static async checkPercentage(templates) {
 		const pt = templates.filter((t) => t.type === "percentage");
 		if (pt.length === 0) return;
-		const reqCategories = pt.map((t) => t.category.toLowerCase());
-		const availNames = (await getCategories$3()).filter((c) => c.is_income).map((c) => c.name.toLocaleLowerCase());
-		reqCategories.forEach((n) => {
-			if (n === "available funds" || n === "all income") {} else if (!availNames.includes(n)) throw new Error(`Category \x22${n}\x22 is not found in available income categories`);
+		const incomeCategories = (await getCategories$3()).filter((c) => c.is_income);
+		const availNames = new Set(incomeCategories.map((c) => c.name.toLocaleLowerCase()));
+		const availIds = new Set(incomeCategories.map((c) => c.id));
+		const specialSources = new Set(["all income", "available funds"]);
+		pt.forEach((t) => {
+			const raw = t.category;
+			const lowered = raw.toLocaleLowerCase();
+			if (specialSources.has(lowered) || availNames.has(lowered) || availIds.has(raw)) return;
+			throw new Error(`Category \x22${raw}\x22 is not found in available income categories`);
 		});
 	}
 	checkLimit(templates) {
@@ -118075,7 +118142,7 @@ var CategoryTemplateContext = class CategoryTemplateContext {
 		const amount = amountToInteger$1(template.amount, templateContext.currency.decimalPlaces);
 		const period = template.period.period;
 		const numPeriods = template.period.amount;
-		let date = template.starting ?? firstDayOfMonth(templateContext.month);
+		let date = template.starting && template.starting.length > 0 ? template.starting : firstDayOfMonth(templateContext.month);
 		let dateShiftFunction;
 		switch (period) {
 			case "day":
@@ -118128,7 +118195,7 @@ var CategoryTemplateContext = class CategoryTemplateContext {
 	}
 	static async runPercentage(template, availableFunds, templateContext) {
 		const percent = template.percent;
-		const cat = template.category.toLowerCase();
+		const cat = template.category.toLocaleLowerCase();
 		const prev = template.previous;
 		let sheetName;
 		let monthlyIncome;
@@ -118137,7 +118204,7 @@ var CategoryTemplateContext = class CategoryTemplateContext {
 		if (cat === "all income") monthlyIncome = await getSheetValue(sheetName, `total-income`);
 		else if (cat === "available funds") monthlyIncome = availableFunds;
 		else {
-			const incomeCat = (await getCategories$3()).find((c) => c.is_income && c.name.toLowerCase() === cat);
+			const incomeCat = (await getCategories$3()).find((c) => c.is_income && (c.id === template.category || c.name.toLocaleLowerCase() === cat));
 			if (!incomeCat) throw new Error(`Income category "${template.category}" not found for percentage template`);
 			monthlyIncome = await getSheetValue(sheetName, `sum-amount-${incomeCat.id}`);
 		}
@@ -118182,6 +118249,7 @@ var CategoryTemplateContext = class CategoryTemplateContext {
 			if (workingShortNumMonths === void 0 || numMonths < workingShortNumMonths) workingShortNumMonths = numMonths;
 		}
 		const shortNumMonths = workingShortNumMonths || 0;
+		const perTemplateNeed = /* @__PURE__ */ new Map();
 		for (let i = 0; i < byTemplates.length; i++) {
 			const template = byTemplates[i];
 			const numMonths = savedInfo[i].numMonths;
@@ -118190,11 +118258,43 @@ var CategoryTemplateContext = class CategoryTemplateContext {
 			if (numMonths > shortNumMonths && period) amount = Math.round(amountToInteger$1(template.amount, templateContext.currency.decimalPlaces) / period * (period - numMonths + shortNumMonths));
 			else if (numMonths > shortNumMonths) amount = Math.round(amountToInteger$1(template.amount, templateContext.currency.decimalPlaces) / (numMonths + 1) * (shortNumMonths + 1));
 			else amount = amountToInteger$1(template.amount, templateContext.currency.decimalPlaces);
+			perTemplateNeed.set(template, amount);
 			totalNeeded += amount;
 		}
-		return Math.round((totalNeeded - templateContext.fromLastMonth) / (shortNumMonths + 1));
+		return {
+			toBudget: Math.round((totalNeeded - templateContext.fromLastMonth) / (shortNumMonths + 1)),
+			perTemplateNeed
+		};
 	}
 };
+function redistributeBatch(perTemplateLocal, templates, type, weightOf) {
+	const siblings = templates.filter((template) => template.type === type);
+	if (siblings.length < 2) return;
+	let total = 0;
+	for (const sibling of siblings) {
+		total += perTemplateLocal.get(sibling) ?? 0;
+		perTemplateLocal.set(sibling, 0);
+	}
+	if (total === 0) return;
+	const totalWeight = siblings.reduce((sum, s) => sum + weightOf(s), 0);
+	if (totalWeight <= 0) {
+		let remaining = total;
+		siblings.forEach((sibling, i) => {
+			const share = i === siblings.length - 1 ? remaining : Math.round(total / siblings.length);
+			const allocated = Math.max(0, Math.min(share, remaining));
+			perTemplateLocal.set(sibling, (perTemplateLocal.get(sibling) ?? 0) + allocated);
+			remaining -= allocated;
+		});
+		return;
+	}
+	let remaining = total;
+	siblings.forEach((sibling, i) => {
+		const share = i === siblings.length - 1 ? remaining : Math.round(total * weightOf(sibling) / totalWeight);
+		const allocated = Math.max(0, Math.min(share, remaining));
+		perTemplateLocal.set(sibling, (perTemplateLocal.get(sibling) ?? 0) + allocated);
+		remaining -= allocated;
+	});
+}
 //#endregion
 //#region ../loot-core/src/server/budget/goal-template.ts
 function distributeRemainder(templateContexts, availBudget) {
@@ -118216,7 +118316,7 @@ async function storeTemplates({ categoriesWithTemplates, source }) {
 	await batchMessages(async () => {
 		for (const { id, templates } of categoriesWithTemplates) await updateWithSchema("categories", {
 			id,
-			goal_def: JSON.stringify(templates),
+			goal_def: templates.length > 0 ? JSON.stringify(templates) : null,
 			template_settings: { source }
 		});
 	});
@@ -118249,7 +118349,10 @@ async function getCategories$2() {
 async function getTemplates(filter = () => true) {
 	const { data: categoriesWithGoalDef } = await aqlQuery$1(q$1("categories").filter({ goal_def: { $ne: null } }).select("*"));
 	const categoryTemplates = {};
-	for (const categoryWithGoalDef of categoriesWithGoalDef.filter(filter)) categoryTemplates[categoryWithGoalDef.id] = JSON.parse(categoryWithGoalDef.goal_def);
+	for (const categoryWithGoalDef of categoriesWithGoalDef.filter(filter)) {
+		if (!categoryWithGoalDef.goal_def) continue;
+		categoryTemplates[categoryWithGoalDef.id] = JSON.parse(categoryWithGoalDef.goal_def);
+	}
 	return categoryTemplates;
 }
 async function getTemplatesForCategory(categoryId) {
@@ -118278,15 +118381,14 @@ async function setGoals(month, templateGoal) {
 		});
 	});
 }
-async function processTemplate(month, force, categoryTemplates, categories = []) {
+async function computeTemplates(month, force, categoryTemplates, categories = []) {
 	const isTracking = isTrackingBudget();
 	if (!categories.length) categories = (await getCategories$2()).filter((c) => isTracking || !c.is_income);
 	const templateContexts = [];
 	let availBudget = await getSheetValue(sheetForMonth(month), `to-budget`);
 	const prioritiesSet = /* @__PURE__ */ new Set();
 	const errors = [];
-	const budgetList = [];
-	const goalList = [];
+	const orphanGoals = [];
 	for (const category of categories) {
 		const { id } = category;
 		const sheetName = sheetForMonth(month);
@@ -118302,23 +118404,16 @@ async function processTemplate(month, force, categoryTemplates, categories = [])
 		} catch (e) {
 			errors.push(`${category.name}: ${e.message}`);
 		}
-		else if (existingGoal !== null && !templates) goalList.push({
+		else if (existingGoal !== null && !templates) orphanGoals.push({
 			category: id,
 			goal: null,
 			longGoal: null
 		});
 	}
-	if (templateContexts.length === 0 && errors.length === 0) {
-		if (goalList.length > 0) setGoals(month, goalList);
-		return {
-			type: "message",
-			message: "Everything is up to date"
-		};
-	}
 	if (errors.length > 0) return {
-		sticky: true,
-		message: "There were errors interpreting some templates:",
-		pre: errors.join(`\n\n`)
+		contexts: templateContexts,
+		errors,
+		orphanGoals
 	};
 	const priorities = new Int32Array([...prioritiesSet]).sort((a, b) => a - b);
 	for (const priority of priorities) {
@@ -118328,8 +118423,30 @@ async function processTemplate(month, force, categoryTemplates, categories = [])
 			availBudget -= budget;
 		}
 	}
-	availBudget = distributeRemainder(templateContexts, availBudget);
-	templateContexts.forEach((context) => {
+	distributeRemainder(templateContexts, availBudget);
+	return {
+		contexts: templateContexts,
+		errors,
+		orphanGoals
+	};
+}
+async function processTemplate(month, force, categoryTemplates, categories = []) {
+	const { contexts, errors, orphanGoals } = await computeTemplates(month, force, categoryTemplates, categories);
+	if (contexts.length === 0 && errors.length === 0) {
+		if (orphanGoals.length > 0) await setGoals(month, orphanGoals);
+		return {
+			type: "message",
+			message: "Everything is up to date"
+		};
+	}
+	if (errors.length > 0) return {
+		sticky: true,
+		message: "There were errors interpreting some templates:",
+		pre: errors.join(`\n\n`)
+	};
+	const budgetList = [];
+	const goalList = [...orphanGoals];
+	contexts.forEach((context) => {
 		const values = context.getValues();
 		budgetList.push({
 			category: context.category.id,
@@ -118345,7 +118462,22 @@ async function processTemplate(month, force, categoryTemplates, categories = [])
 	await setGoals(month, goalList);
 	return {
 		type: "message",
-		message: `Successfully applied templates to ${templateContexts.length} categories`
+		message: `Successfully applied templates to ${contexts.length} categories`
+	};
+}
+async function dryRunCategoryTemplate({ month, categoryId, templates }) {
+	const allCategoryTemplates = await getTemplates();
+	allCategoryTemplates[categoryId] = templates;
+	const { contexts } = await computeTemplates(month, true, allCategoryTemplates, []);
+	const ctx = contexts.find((c) => c.category.id === categoryId);
+	if (!ctx) return {
+		budgeted: 0,
+		perTemplate: templates.map(() => 0)
+	};
+	const values = ctx.getValues();
+	return {
+		budgeted: values.budgeted,
+		perTemplate: templates.map((t) => values.perTemplateContribution.get(t) ?? 0)
 	};
 }
 //#endregion
@@ -118389,6 +118521,7 @@ app$14.method("category-group-delete", mutator(undoable(deleteCategoryGroup$1)))
 app$14.method("must-category-transfer", isCategoryTransferRequired);
 app$14.method("budget/get-category-automations", getTemplatesForCategory);
 app$14.method("budget/set-category-automations", mutator(undoable(storeTemplates)));
+app$14.method("budget/dry-run-category-template", dryRunCategoryTemplate);
 app$14.method("budget/store-note-templates", mutator(storeNoteTemplates));
 app$14.method("budget/render-note-templates", unparse);
 async function getCategories$1() {