mulmoclaude 0.5.2 → 0.6.0

package/src/plugins/accounting/components/OpeningBalancesForm.vue

@@ -0,0 +1,271 @@
+<template>
+  <form class="flex flex-col gap-3" data-testid="accounting-opening-form" @submit.prevent="onSubmit">
+    <div class="flex items-center justify-between gap-2">
+      <h3 class="text-base font-semibold">{{ t("pluginAccounting.openingForm.title") }}</h3>
+      <button
+        type="button"
+        class="h-8 px-2.5 flex items-center gap-1 rounded border border-gray-300 text-sm text-gray-600 hover:bg-gray-50"
+        data-testid="accounting-opening-manage-accounts"
+        @click="showAccountsModal = true"
+      >
+        <span class="material-icons text-base">tune</span>
+        <span>{{ t("pluginAccounting.accounts.manageButton") }}</span>
+      </button>
+    </div>
+    <p class="text-xs text-gray-500">{{ t("pluginAccounting.openingForm.explainer") }}</p>
+    <p class="text-xs text-blue-600" data-testid="accounting-opening-empty-hint">{{ t("pluginAccounting.openingForm.emptyHint") }}</p>
+    <div v-if="existing" class="text-xs text-gray-500" data-testid="accounting-opening-existing">
+      {{ t("pluginAccounting.openingForm.setBy", { date: existing.date }) }}
+      <span v-if="existing" class="text-amber-600 ml-2">{{ t("pluginAccounting.openingForm.replaceWarning") }}</span>
+    </div>
+    <p v-else class="text-xs text-gray-400" data-testid="accounting-opening-none">{{ t("pluginAccounting.openingForm.none") }}</p>
+    <label class="text-xs text-gray-500 flex flex-col gap-1 w-fit">
+      {{ t("pluginAccounting.openingForm.asOfLabel") }}
+      <input v-model="asOfDate" type="date" required class="h-8 px-2 rounded border border-gray-300 text-sm" data-testid="accounting-opening-asof" />
+    </label>
+    <table class="w-full text-sm">
+      <thead>
+        <tr class="text-xs text-gray-500 border-b border-gray-200">
+          <th class="text-left py-1 px-2">{{ t("pluginAccounting.entryForm.accountLabel") }}</th>
+          <th class="text-right py-1 px-2 w-32">{{ t("pluginAccounting.entryForm.debitLabel") }}</th>
+          <th class="text-right py-1 px-2 w-32">{{ t("pluginAccounting.entryForm.creditLabel") }}</th>
+        </tr>
+      </thead>
+      <tbody>
+        <tr v-for="account in bsAccounts" :key="account.code" class="border-b border-gray-100">
+          <td class="py-1 px-2">
+            <span class="font-mono text-[10px] text-gray-400 mr-2">{{ account.code }}</span>
+            <span>{{ account.name }}</span>
+            <span class="ml-2 text-xs text-gray-400">{{ account.type }}</span>
+          </td>
+          <td class="py-1 px-2">
+            <input
+              v-model.number="rows[account.code].debit"
+              type="number"
+              :step="step"
+              min="0"
+              class="h-8 px-2 w-full rounded border border-gray-300 text-sm text-right"
+              :data-testid="`accounting-opening-debit-${account.code}`"
+              @input="onDebitInput(account.code)"
+            />
+          </td>
+          <td class="py-1 px-2">
+            <input
+              v-model.number="rows[account.code].credit"
+              type="number"
+              :step="step"
+              min="0"
+              class="h-8 px-2 w-full rounded border border-gray-300 text-sm text-right"
+              :data-testid="`accounting-opening-credit-${account.code}`"
+              @input="onCreditInput(account.code)"
+            />
+          </td>
+        </tr>
+      </tbody>
+    </table>
+    <div class="flex items-center justify-between">
+      <span class="text-xs text-gray-400">{{ t("pluginAccounting.openingForm.explainer2") }}</span>
+      <span :class="balanced ? 'text-green-600' : 'text-red-500'" class="text-xs" data-testid="accounting-opening-balance">
+        {{ balanced ? t("pluginAccounting.entryForm.balanced") : t("pluginAccounting.entryForm.imbalance", { amount: imbalanceText }) }}
+      </span>
+    </div>
+    <p v-if="error" class="text-xs text-red-500" data-testid="accounting-opening-error">{{ error }}</p>
+    <p v-if="successMessage" class="text-xs text-green-600" data-testid="accounting-opening-success">{{ successMessage }}</p>
+    <div class="flex justify-end">
+      <button
+        type="submit"
+        class="h-8 px-3 rounded bg-blue-600 hover:bg-blue-700 text-white text-sm disabled:opacity-50"
+        :disabled="!balanced || submitting"
+        data-testid="accounting-opening-submit"
+      >
+        {{ submitting ? t("pluginAccounting.entryForm.submitting") : t("pluginAccounting.openingForm.submit") }}
+      </button>
+    </div>
+  </form>
+  <!-- Sibling of the parent <form> on purpose: the modal renders
+       its own <form @submit.prevent> for the inline editor, and
+       nesting <form>s is invalid HTML that breaks Enter-key submit
+       routing in some browsers. Vue 3 multi-root templates let us
+       keep the markup flat with no wrapper div. -->
+  <AccountsModal v-if="showAccountsModal" :book-id="bookId" :accounts="accounts" @close="showAccountsModal = false" />
+</template>
+
+<script setup lang="ts">
+import { computed, ref, watch } from "vue";
+import { useI18n } from "vue-i18n";
+import { getOpeningBalances, setOpeningBalances, type Account, type JournalEntry, type JournalLine } from "../api";
+import { formatAmount, inputStepFor } from "../currencies";
+import { localDateString } from "../dates";
+import { useLatestRequest } from "./useLatestRequest";
+import AccountsModal from "./AccountsModal.vue";
+
+const { t } = useI18n();
+
+const props = defineProps<{ bookId: string; accounts: Account[]; currency: string; version: number }>();
+const emit = defineEmits<{ submitted: [] }>();
+
+const showAccountsModal = ref(false);
+
+interface OpeningRow {
+  debit: number | null;
+  credit: number | null;
+}
+
+const asOfDate = ref(localDateString());
+const rows = ref<Record<string, OpeningRow>>({});
+const existing = ref<JournalEntry | null>(null);
+const submitting = ref(false);
+const error = ref<string | null>(null);
+const successMessage = ref<string | null>(null);
+const { begin: beginLoad, isCurrent: isCurrentLoad } = useLatestRequest();
+
+const bsAccounts = computed(() =>
+  props.accounts.filter((account) => (account.type === "asset" || account.type === "liability" || account.type === "equity") && account.active !== false),
+);
+
+function ensureRows(): void {
+  for (const account of bsAccounts.value) {
+    if (!rows.value[account.code]) rows.value[account.code] = { debit: null, credit: null };
+  }
+}
+
+function onDebitInput(code: string): void {
+  const row = rows.value[code];
+  if (row.debit !== null && row.debit !== 0) row.credit = null;
+}
+function onCreditInput(code: string): void {
+  const row = rows.value[code];
+  if (row.credit !== null && row.credit !== 0) row.debit = null;
+}
+
+const imbalance = computed<number>(() => {
+  // Iterate the live bsAccounts (already active-filtered) rather
+  // than rows.value keys so a row for a now-inactive account
+  // doesn't tilt `balanced` against what `toApiLines` will
+  // actually post.
+  let sum = 0;
+  for (const account of bsAccounts.value) {
+    const row = rows.value[account.code];
+    if (!row) continue;
+    if (typeof row.debit === "number") sum += row.debit;
+    if (typeof row.credit === "number") sum -= row.credit;
+  }
+  return sum;
+});
+// An all-empty form is valid: it submits as a zero-line opening
+// marker so the user can unlock the rest of the UI without
+// committing to specific balances on day one.
+const balanced = computed(() => Math.abs(imbalance.value) <= 0.005);
+const imbalanceText = computed(() => formatAmount(imbalance.value, props.currency));
+const step = computed(() => inputStepFor(props.currency));
+
+function isPositiveAmount(value: unknown): value is number {
+  // Robust against the empty string `v-model.number` produces when
+  // the user clears a previously-typed field — without this, the
+  // skip condition `value === 0` was false for `""` and the form
+  // emitted ghost lines like `{accountCode: "3000"}` with no
+  // amount on either side.
+  return typeof value === "number" && Number.isFinite(value) && value > 0;
+}
+
+function toApiLines(): JournalLine[] {
+  const out: JournalLine[] = [];
+  // Iterate the visible bsAccounts list (which already filters
+  // out inactive accounts) rather than `rows.value` keys. A row
+  // for an account that was active when the user typed amounts
+  // and then got deactivated mid-edit would otherwise still post —
+  // the row stays in the map even after the v-for stops rendering
+  // it, so iterating keys would silently land entries on a
+  // soft-deleted account.
+  for (const account of bsAccounts.value) {
+    const row = rows.value[account.code];
+    if (!row) continue;
+    const debitOk = isPositiveAmount(row.debit);
+    const creditOk = isPositiveAmount(row.credit);
+    if (!debitOk && !creditOk) continue;
+    const line: JournalLine = { accountCode: account.code };
+    if (debitOk) line.debit = row.debit as number;
+    if (creditOk) line.credit = row.credit as number;
+    out.push(line);
+  }
+  return out;
+}
+
+function freshRows(): Record<string, OpeningRow> {
+  const out: Record<string, OpeningRow> = {};
+  for (const account of bsAccounts.value) out[account.code] = { debit: null, credit: null };
+  return out;
+}
+
+async function loadExisting(): Promise<void> {
+  // Always start from a fresh row map so a book without an
+  // opening doesn't inherit the previous book's draft values.
+  const token = beginLoad();
+  const next = freshRows();
+  const result = await getOpeningBalances(props.bookId);
+  // Drop the result if the user has switched books since this
+  // call started — otherwise stale rows would land on the new
+  // book's form.
+  if (!isCurrentLoad(token)) return;
+  if (!result.ok) {
+    existing.value = null;
+    rows.value = next;
+    return;
+  }
+  existing.value = result.data.opening;
+  if (result.data.opening) {
+    asOfDate.value = result.data.opening.date;
+    for (const line of result.data.opening.lines) {
+      next[line.accountCode] = { debit: line.debit ?? null, credit: line.credit ?? null };
+    }
+  } else {
+    asOfDate.value = localDateString();
+  }
+  rows.value = next;
+}
+
+async function onSubmit(): Promise<void> {
+  if (submitting.value || !balanced.value) return;
+  submitting.value = true;
+  error.value = null;
+  successMessage.value = null;
+  try {
+    const result = await setOpeningBalances({ bookId: props.bookId, asOfDate: asOfDate.value, lines: toApiLines() });
+    if (!result.ok) {
+      error.value = result.error;
+      return;
+    }
+    successMessage.value = t("pluginAccounting.openingForm.success");
+    emit("submitted");
+  } catch (err) {
+    error.value = err instanceof Error ? err.message : String(err);
+  } finally {
+    submitting.value = false;
+  }
+}
+
+watch(
+  () => [props.bookId, props.version, props.accounts.length],
+  () => {
+    ensureRows();
+    void loadExisting();
+  },
+  { immediate: true },
+);
+</script>
+
+<style scoped>
+/* Hide the WebKit / Firefox spin buttons on amount inputs. The
+   step attribute still controls validation; this is purely UI.
+   Accounting amount fields don't benefit from a spinner — users
+   type the number and the up/down arrows just clutter the row. */
+input[type="number"]::-webkit-outer-spin-button,
+input[type="number"]::-webkit-inner-spin-button {
+  -webkit-appearance: none;
+  margin: 0;
+}
+input[type="number"] {
+  -moz-appearance: textfield;
+  appearance: textfield;
+}
+</style>

package/src/plugins/accounting/components/ProfitLoss.vue

@@ -0,0 +1,160 @@
+<template>
+  <div class="flex flex-col gap-3" data-testid="accounting-profit-loss">
+    <div class="flex flex-wrap items-end gap-3">
+      <DateRangePicker v-model="range" :fiscal-year-end="resolvedFiscalYearEnd" :opening-date="openingDate" />
+      <button class="h-8 px-2.5 rounded border border-gray-300 text-sm text-gray-600 hover:bg-gray-50" @click="refresh">
+        <span class="material-icons text-base align-middle">refresh</span>
+      </button>
+    </div>
+    <p v-if="loading" class="text-xs text-gray-400">{{ t("pluginAccounting.common.loading") }}</p>
+    <p v-else-if="error" class="text-xs text-red-500">{{ t("pluginAccounting.common.error", { error }) }}</p>
+    <template v-else-if="profitLoss">
+      <section class="border border-gray-200 rounded p-3">
+        <h4 class="text-sm font-semibold mb-2">{{ t("pluginAccounting.profitLoss.income") }}</h4>
+        <table class="w-full text-sm">
+          <tbody>
+            <tr
+              v-for="row in profitLoss.income.rows"
+              :key="row.accountCode"
+              class="border-b border-gray-100 hover:bg-blue-50 cursor-pointer focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-blue-400"
+              tabindex="0"
+              role="button"
+              :aria-label="t('pluginAccounting.accounts.openLedgerAria', { code: row.accountCode, name: row.accountName })"
+              :data-testid="`accounting-pl-row-${row.accountCode}`"
+              @click="onRowClick(row.accountCode)"
+              @keydown.enter.prevent.self="onKeyActivate($event, row.accountCode)"
+              @keydown.space.prevent.self="onKeyActivate($event, row.accountCode)"
+            >
+              <td class="py-1 px-1">
+                <span class="font-mono text-[10px] text-gray-400 mr-2">{{ row.accountCode }}</span
+                >{{ row.accountName }}
+              </td>
+              <td class="py-1 px-1 text-right font-mono">{{ formatAmount(row.amount) }}</td>
+            </tr>
+          </tbody>
+          <tfoot>
+            <tr class="font-semibold border-t border-gray-300">
+              <td class="py-1 px-1">{{ t("pluginAccounting.balanceSheet.total") }}</td>
+              <td class="py-1 px-1 text-right">{{ formatAmount(profitLoss.income.total) }}</td>
+            </tr>
+          </tfoot>
+        </table>
+      </section>
+      <section class="border border-gray-200 rounded p-3">
+        <h4 class="text-sm font-semibold mb-2">{{ t("pluginAccounting.profitLoss.expense") }}</h4>
+        <table class="w-full text-sm">
+          <tbody>
+            <tr
+              v-for="row in profitLoss.expense.rows"
+              :key="row.accountCode"
+              class="border-b border-gray-100 hover:bg-blue-50 cursor-pointer focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-blue-400"
+              tabindex="0"
+              role="button"
+              :aria-label="t('pluginAccounting.accounts.openLedgerAria', { code: row.accountCode, name: row.accountName })"
+              :data-testid="`accounting-pl-row-${row.accountCode}`"
+              @click="onRowClick(row.accountCode)"
+              @keydown.enter.prevent.self="onKeyActivate($event, row.accountCode)"
+              @keydown.space.prevent.self="onKeyActivate($event, row.accountCode)"
+            >
+              <td class="py-1 px-1">
+                <span class="font-mono text-[10px] text-gray-400 mr-2">{{ row.accountCode }}</span
+                >{{ row.accountName }}
+              </td>
+              <td class="py-1 px-1 text-right font-mono">{{ formatAmount(row.amount) }}</td>
+            </tr>
+          </tbody>
+          <tfoot>
+            <tr class="font-semibold border-t border-gray-300">
+              <td class="py-1 px-1">{{ t("pluginAccounting.balanceSheet.total") }}</td>
+              <td class="py-1 px-1 text-right">{{ formatAmount(profitLoss.expense.total) }}</td>
+            </tr>
+          </tfoot>
+        </table>
+      </section>
+      <div class="flex justify-end items-center gap-2 text-sm font-semibold" data-testid="accounting-pl-net">
+        <span>{{ t("pluginAccounting.profitLoss.netIncome") }}</span>
+        <span :class="profitLoss.netIncome >= 0 ? 'text-green-600' : 'text-red-500'">{{ formatAmount(profitLoss.netIncome) }}</span>
+      </div>
+    </template>
+  </div>
+</template>
+
+<script setup lang="ts">
+import { computed, ref, watch } from "vue";
+import { useI18n } from "vue-i18n";
+import { getProfitLoss, type ProfitLoss } from "../api";
+import { formatAmount as formatAmountWithCurrency } from "../currencies";
+import { currentFiscalYearRange, resolveFiscalYearEnd, type DateRange, type FiscalYearEnd } from "../fiscalYear";
+import { useLatestRequest } from "./useLatestRequest";
+import DateRangePicker from "./DateRangePicker.vue";
+
+const { t } = useI18n();
+
+const props = defineProps<{
+  bookId: string;
+  currency: string;
+  version: number;
+  fiscalYearEnd?: FiscalYearEnd;
+  /** Opening-balance date for the active book — drives the "Lifetime"
+   *  shortcut in the date picker (from = openingDate, to = today).
+   *  When absent, the picker hides Lifetime; "All" still works. */
+  openingDate?: string;
+}>();
+
+const emit = defineEmits<{ selectAccount: [code: string] }>();
+
+const resolvedFiscalYearEnd = computed<FiscalYearEnd>(() => resolveFiscalYearEnd(props.fiscalYearEnd));
+
+function onRowClick(code: string): void {
+  emit("selectAccount", code);
+}
+
+function onKeyActivate(event: KeyboardEvent, code: string): void {
+  if (event.repeat) return;
+  emit("selectAccount", code);
+}
+
+// Default = current fiscal year. Reset by the bookId/fiscalYearEnd
+// watcher below so switching books or changing the FY-end in
+// settings drops a stale custom range from the prior book.
+const range = ref<DateRange>(currentFiscalYearRange(resolvedFiscalYearEnd.value));
+const profitLoss = ref<ProfitLoss | null>(null);
+const loading = ref(false);
+const error = ref<string | null>(null);
+const { begin: beginRequest, isCurrent } = useLatestRequest();
+
+function formatAmount(value: number): string {
+  return formatAmountWithCurrency(value, props.currency);
+}
+
+async function refresh(): Promise<void> {
+  const token = beginRequest();
+  loading.value = true;
+  error.value = null;
+  try {
+    // P&L always sends a range. Empty-side gets a sentinel so "All"
+    // (both empty) means "every entry" rather than an empty window.
+    const fromBound = range.value.from || "0000-01-01";
+    const toBound = range.value.to || "9999-12-31";
+    const result = await getProfitLoss({ kind: "range", from: fromBound, to: toBound }, props.bookId);
+    if (!isCurrent(token)) return;
+    if (!result.ok) {
+      error.value = result.error;
+      profitLoss.value = null;
+      return;
+    }
+    profitLoss.value = result.data.profitLoss;
+  } finally {
+    if (isCurrent(token)) loading.value = false;
+  }
+}
+
+watch(
+  () => [props.bookId, resolvedFiscalYearEnd.value],
+  () => {
+    range.value = currentFiscalYearRange(resolvedFiscalYearEnd.value);
+  },
+);
+
+watch(() => [props.bookId, props.version, range.value.from, range.value.to], refresh, { immediate: true });
+</script>

package/src/plugins/accounting/components/accountDraft.ts

@@ -0,0 +1,13 @@
+// Shared draft shape for the AccountsModal editor row. Lives in
+// its own module so AccountsModal.vue and AccountEditor.vue can
+// both type the prop / emit without one importing the other —
+// they form a parent / child pair, not a re-export chain.
+
+import type { AccountType } from "../api";
+
+export interface AccountDraft {
+  code: string;
+  name: string;
+  type: AccountType;
+  note: string;
+}

package/src/plugins/accounting/components/accountNumbering.ts

@@ -0,0 +1,103 @@
+// Account-code numbering convention. The chart of accounts uses
+// 4-digit codes whose leading digit identifies the type:
+//
+//   1xxx → asset
+//   2xxx → liability
+//   3xxx → equity
+//   4xxx → income
+//   5xxx → expense
+//
+// Within those bands, the second digit `4` is reserved for tax-
+// related accounts on both sides of the balance sheet:
+//
+//   14xx → tax-related current assets
+//          (1400 Input Tax Receivable / 仮払消費税, plus future
+//           withholding-tax-receivable / etc. siblings)
+//   24xx → tax-related current liabilities
+//          (2400 Sales Tax Payable / 仮受消費税, plus future
+//           withholding-tax-payable / etc. siblings)
+//
+// Special-case UI (Ledger T-number column, JournalEntryForm
+// per-line tax-registration ID input) is **input-tax-only** — it
+// keys off `isTaxAccountCode`, which matches 14xx (purchase side)
+// only. Output-tax / sales-side lines (24xx) intentionally don't
+// surface a counterparty registration field: the seller's
+// obligation is to put their *own* registration number on the
+// invoice they issue, not to capture the customer's. So a custom
+// suspense account added in the 14xx band participates without
+// any opt-in step; 24xx accounts book the liability without the
+// extra column.
+//
+// Lives in its own module so AccountsModal, AccountEditor, and the
+// validation helper can share the same constants without circular
+// imports between Vue components.
+
+import type { Account, AccountType } from "../api";
+
+export const ACCOUNT_TYPE_PREFIX: Record<AccountType, number> = {
+  asset: 1,
+  liability: 2,
+  equity: 3,
+  income: 4,
+  expense: 5,
+};
+
+const TAX_ACCOUNT_PREFIXES: readonly string[] = ["14"];
+
+/** Returns `true` for codes whose first two digits identify a
+ *  tax-related current asset (`14xx`) — i.e. the input-tax /
+ *  purchase side of consumption / sales / VAT bookkeeping. Drives
+ *  Ledger column visibility and the JournalEntryForm per-line
+ *  tax-registration ID input. Output-tax (24xx) is intentionally
+ *  excluded: the counterparty's registration ID is only
+ *  load-bearing for input-tax-credit eligibility on purchases. */
+export function isTaxAccountCode(code: string): boolean {
+  return TAX_ACCOUNT_PREFIXES.some((prefix) => code.startsWith(prefix));
+}
+
+const ACCOUNT_CODE_RE = /^\d{4}$/;
+const SUGGESTED_GAP = 10;
+
+export function isValidAccountCode(code: string): boolean {
+  return ACCOUNT_CODE_RE.test(code);
+}
+
+export function typeForCode(code: string): AccountType | null {
+  if (!isValidAccountCode(code)) return null;
+  const leading = Number.parseInt(code[0], 10);
+  for (const [type, prefix] of Object.entries(ACCOUNT_TYPE_PREFIX) as [AccountType, number][]) {
+    if (prefix === leading) return type;
+  }
+  return null;
+}
+
+export function codeMatchesType(code: string, type: AccountType): boolean {
+  return typeForCode(code) === type;
+}
+
+/** Suggest the next free 4-digit code for `type`. Picks max-in-range
+ *  + SUGGESTED_GAP so users keep room to insert sibling accounts
+ *  later (the standard accounting convention). Falls back to the
+ *  prefix base when the range is empty, and to max+1 when +gap would
+ *  spill out of the 4-digit prefix window. */
+export function suggestNextCode(type: AccountType, accounts: readonly Account[]): string {
+  const prefix = ACCOUNT_TYPE_PREFIX[type];
+  const inRange: number[] = [];
+  for (const account of accounts) {
+    if (!isValidAccountCode(account.code)) continue;
+    const value = Number.parseInt(account.code, 10);
+    if (Math.floor(value / 1000) !== prefix) continue;
+    inRange.push(value);
+  }
+  if (inRange.length === 0) return `${prefix}000`;
+  const max = Math.max(...inRange);
+  const candidate = max + SUGGESTED_GAP;
+  if (Math.floor(candidate / 1000) === prefix && candidate <= 9999) return String(candidate);
+  // Range is dense at the top — fall back to a unit step. If even
+  // that overflows the prefix window the chart is essentially full
+  // for that type; surface the overflow rather than silently
+  // suggesting a code in the next type's range.
+  const fallback = max + 1;
+  if (Math.floor(fallback / 1000) === prefix && fallback <= 9999) return String(fallback);
+  return `${prefix}999`;
+}

package/src/plugins/accounting/components/accountValidation.ts

@@ -0,0 +1,75 @@
+// Pure validation for the AccountsModal editor draft. Lives in its
+// own module so unit tests can exercise the boundary cases (reserved
+// `_` prefix, duplicate code, empty fields) without spinning up Vue
+// or i18n. The component maps the returned error code to a
+// localized message.
+//
+// The `_`-prefix rule mirrors the server's check in
+// server/accounting/service.ts:upsertAccount — codes starting with
+// `_` are reserved for synthetic report rows. Catching it client-
+// side avoids a round-trip and surfaces the localized message
+// instead of the raw server error.
+
+import type { Account } from "../api";
+import type { AccountDraft } from "./accountDraft";
+import { codeMatchesType, isValidAccountCode } from "./accountNumbering";
+
+export const RESERVED_PREFIX = "_";
+
+export type CodeValidationError = "emptyCode" | "reservedCode" | "invalidCodeFormat" | "codeTypeMismatch" | "duplicateCode";
+export type NameValidationError = "emptyName" | "duplicateName";
+export type AccountValidationError = CodeValidationError | NameValidationError;
+
+/**
+ * Validate just the code field. Split out from the full draft
+ * validator so AccountEditor can paint a per-field red border in
+ * realtime without re-running the name check on every keystroke.
+ */
+export function validateCodeField(draft: AccountDraft, existing: readonly Account[], isNew: boolean): CodeValidationError | null {
+  const trimmedCode = draft.code.trim();
+  if (trimmedCode.length === 0) return "emptyCode";
+  if (trimmedCode.startsWith(RESERVED_PREFIX)) return "reservedCode";
+  // 4-digit numbering is enforced for new accounts only: pre-existing
+  // books may already hold legacy codes the user added before the
+  // rule landed, and changing the code would orphan their journal
+  // lines (codes are immutable once created — see codeReadOnlyHint).
+  if (isNew && !isValidAccountCode(trimmedCode)) return "invalidCodeFormat";
+  if (isNew && !codeMatchesType(trimmedCode, draft.type)) return "codeTypeMismatch";
+  if (isNew && existing.some((account) => account.code === trimmedCode)) return "duplicateCode";
+  return null;
+}
+
+/**
+ * Validate just the name field. Empty + duplicate (case-insensitive,
+ * trimmed) against other accounts. On edit, the account being edited
+ * is excluded from the duplicate check via `draft.code` — otherwise
+ * every save would flag the user's own row as a collision.
+ */
+export function validateNameField(draft: AccountDraft, existing: readonly Account[], isNew: boolean): NameValidationError | null {
+  const trimmedName = draft.name.trim();
+  if (trimmedName.length === 0) return "emptyName";
+  const folded = trimmedName.toLowerCase();
+  const collides = existing.some((account) => {
+    if (!isNew && account.code === draft.code.trim()) return false;
+    return account.name.trim().toLowerCase() === folded;
+  });
+  if (collides) return "duplicateName";
+  return null;
+}
+
+/**
+ * Validate a draft about to be sent to `upsertAccount`. Returns
+ * `null` on success or an error code on failure. Caller maps the
+ * code to a localized message.
+ *
+ * `existing` is the current chart of accounts — used to detect a
+ * duplicate code on a brand-new entry (otherwise the server would
+ * silently overwrite the existing account, which is rarely what
+ * the user typing into the "Add account" form intended).
+ *
+ * Code errors take precedence over name errors so the user fixes
+ * one stable issue at a time as they type.
+ */
+export function validateAccountDraft(draft: AccountDraft, existing: readonly Account[], isNew: boolean): AccountValidationError | null {
+  return validateCodeField(draft, existing, isNew) ?? validateNameField(draft, existing, isNew);
+}

package/src/plugins/accounting/components/useLatestRequest.ts

@@ -0,0 +1,44 @@
+// Stale-response guard for watcher-driven async fetches.
+//
+// Pattern: a watcher fires on bookId / filter / version changes
+// and kicks off `apiPost(...)`. Without coordination, a slower
+// earlier request can resolve after a newer one and overwrite the
+// fresh state with stale data. This composable hands out a
+// monotonic token before each await; the caller checks that the
+// token is still current after the await before mutating state.
+//
+// Usage:
+//
+//   const { begin, isCurrent } = useLatestRequest();
+//   async function refresh() {
+//     const token = begin();
+//     const result = await api.fetch(...);
+//     if (!isCurrent(token)) return;          // a newer refresh started
+//     applyState(result);
+//   }
+//
+// Cheap and dependency-free. Each component holds its own
+// `useLatestRequest()` instance — there's no shared state across
+// components.
+
+export interface LatestRequestApi {
+  /** Returns the token of the new request. Increments the
+   *  internal counter; older outstanding requests will fail
+   *  `isCurrent`. */
+  begin: () => number;
+  /** True if `token` is still the most recently issued one. */
+  isCurrent: (token: number) => boolean;
+}
+
+export function useLatestRequest(): LatestRequestApi {
+  let counter = 0;
+  return {
+    begin(): number {
+      counter += 1;
+      return counter;
+    },
+    isCurrent(token: number): boolean {
+      return token === counter;
+    },
+  };
+}