@superheld/summae-core 0.1.0

package/dist/index.js

@@ -0,0 +1,4328 @@
+import Big from 'big.js';
+import { randomBytes, createHash } from 'crypto';
+
+// src/shared/errors.ts
+var InvalidValue = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "InvalidValue";
+  }
+};
+var CurrencyMismatch = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "CurrencyMismatch";
+  }
+};
+
+// src/shared/currency.ts
+var SCALES = {
+  JPY: 0,
+  KRW: 0,
+  BHD: 3,
+  KWD: 3,
+  TND: 3
+};
+var Currency = class _Currency {
+  constructor(code, scale) {
+    this.code = code;
+    this.scale = scale;
+  }
+  code;
+  scale;
+  static of(code) {
+    if (!/^[A-Z]{3}$/.test(code)) {
+      throw new InvalidValue(`Ung\xFCltiger ISO-4217-Code: "${code}"`);
+    }
+    return new _Currency(code, SCALES[code] ?? 2);
+  }
+  equals(other) {
+    return this.code === other.code;
+  }
+  toJSON() {
+    return this.code;
+  }
+  toString() {
+    return this.code;
+  }
+};
+var HALF_UP = Big.roundHalfUp;
+function decimalPlaces(value) {
+  return Math.max(0, value.c.length - value.e - 1);
+}
+var Money = class _Money {
+  constructor(amount, currency) {
+    this.amount = amount;
+    this.currency = currency;
+  }
+  amount;
+  currency;
+  static currencyOf(currency) {
+    return currency instanceof Currency ? currency : Currency.of(currency);
+  }
+  /**
+   * Exakter Betrag auf Währungsskala. Mehr Nachkommastellen als die Währung
+   * erlaubt sind ein Fehler — hier wird nie still gerundet.
+   */
+  static of(amount, currency) {
+    const cur = _Money.currencyOf(currency);
+    let value;
+    try {
+      value = new Big(amount);
+    } catch {
+      throw new InvalidValue(`Ung\xFCltiger Betrag "${amount}" f\xFCr W\xE4hrung ${cur.code} (Skala ${cur.scale})`);
+    }
+    const scaled = value.round(cur.scale, HALF_UP);
+    if (!scaled.eq(value)) {
+      throw new InvalidValue(`Ung\xFCltiger Betrag "${amount}" f\xFCr W\xE4hrung ${cur.code} (Skala ${cur.scale})`);
+    }
+    return new _Money(scaled, cur);
+  }
+  /**
+   * Ergebnis einer Rechnung auf Währungsskala bringen: half-up
+   * (2.225 → 2.23, -2.345 → -2.35). Einziger Weg, auf dem Money rundet.
+   */
+  static fromCalculation(value, currency) {
+    const cur = _Money.currencyOf(currency);
+    let big;
+    try {
+      big = value instanceof Big ? value : new Big(value);
+    } catch {
+      throw new InvalidValue(`Ung\xFCltiger Rechenwert f\xFCr W\xE4hrung ${cur.code}`);
+    }
+    return new _Money(big.round(cur.scale, HALF_UP), cur);
+  }
+  static zero(currency) {
+    return new _Money(new Big(0), _Money.currencyOf(currency));
+  }
+  add(other) {
+    this.assertSameCurrency(other);
+    return new _Money(this.amount.plus(other.amount), this.currency);
+  }
+  subtract(other) {
+    this.assertSameCurrency(other);
+    return new _Money(this.amount.minus(other.amount), this.currency);
+  }
+  negate() {
+    return new _Money(this.amount.times(-1), this.currency);
+  }
+  abs() {
+    return new _Money(this.amount.abs(), this.currency);
+  }
+  /** -1, 0 oder 1 */
+  compareTo(other) {
+    this.assertSameCurrency(other);
+    return this.amount.cmp(other.amount);
+  }
+  equals(other) {
+    return this.currency.equals(other.currency) && this.amount.eq(other.amount);
+  }
+  isZero() {
+    return this.amount.eq(0);
+  }
+  isPositive() {
+    return this.amount.gt(0);
+  }
+  isNegative() {
+    return this.amount.lt(0);
+  }
+  /**
+   * Verteilt den Betrag nach Gewichten (determinismus.md §2): Largest-Remainder,
+   * Gleichstand → erster Teil. Σ Teile = Betrag, immer.
+   *
+   * Gewichte: nicht-negative Dezimalwerte (Zahl oder String), Summe > 0.
+   * Negative Beträge werden als negiertes Spiegelbild verteilt.
+   */
+  allocate(...weights) {
+    if (weights.length === 0) {
+      throw new InvalidValue("allocate braucht mindestens ein Gewicht");
+    }
+    if (this.isNegative()) {
+      return this.negate().allocate(...weights).map((part) => part.negate());
+    }
+    const scale = this.currency.scale;
+    const integerWeights = _Money.normalizeWeights(weights);
+    let weightSum = 0n;
+    for (const weight of integerWeights) {
+      weightSum += weight;
+    }
+    if (weightSum === 0n) {
+      throw new InvalidValue("Gewichtssumme muss > 0 sein");
+    }
+    const factor = new Big(10).pow(scale);
+    const totalMinor = BigInt(this.amount.times(factor).toFixed(0));
+    const parts = integerWeights.map((weight) => {
+      const product = totalMinor * weight;
+      return { base: product / weightSum, remainder: product % weightSum };
+    });
+    let assigned = 0n;
+    for (const part of parts) {
+      assigned += part.base;
+    }
+    const leftover = Number(totalMinor - assigned);
+    const order = parts.map((part, index) => ({ remainder: part.remainder, index }));
+    order.sort(
+      (a, b) => a.remainder > b.remainder ? -1 : a.remainder < b.remainder ? 1 : a.index - b.index
+    );
+    for (let i = 0; i < leftover; i++) {
+      parts[order[i].index].base += 1n;
+    }
+    return parts.map((part) => _Money.fromMinor(part.base, scale, this.currency));
+  }
+  /** Verteilung in n gleiche Teile (Sammelposten-Fünftel, AfA-Monatsraten). */
+  allocateEvenly(parts) {
+    if (parts < 1) {
+      throw new InvalidValue("allocateEvenly braucht mindestens einen Teil");
+    }
+    return this.allocate(...new Array(parts).fill(1));
+  }
+  /** Betrag als String-Dezimal mit fester Skala, z. B. "1234.56" (datenformat.md). */
+  amountAsString() {
+    return this.amount.toFixed(this.currency.scale);
+  }
+  toJSON() {
+    return { amount: this.amountAsString(), currency: this.currency.code };
+  }
+  toString() {
+    return `${this.amountAsString()} ${this.currency.code}`;
+  }
+  static fromMinor(minor, scale, currency) {
+    const value = new Big(minor.toString()).div(new Big(10).pow(scale));
+    return new _Money(value.round(scale, HALF_UP), currency);
+  }
+  /** Dezimalgewichte verlustfrei auf ganzzahlige Gewichte gleicher Skala bringen. */
+  static normalizeWeights(weights) {
+    const decimals = [];
+    let maxScale = 0;
+    for (const weight of weights) {
+      let decimal;
+      try {
+        decimal = new Big(weight);
+      } catch {
+        throw new InvalidValue(`Ung\xFCltiges Gewicht "${weight}"`);
+      }
+      if (decimal.lt(0)) {
+        throw new InvalidValue("Gewichte d\xFCrfen nicht negativ sein");
+      }
+      decimals.push(decimal);
+      maxScale = Math.max(maxScale, decimalPlaces(decimal));
+    }
+    const factor = new Big(10).pow(maxScale);
+    return decimals.map((decimal) => BigInt(decimal.times(factor).toFixed(0)));
+  }
+  assertSameCurrency(other) {
+    if (!this.currency.equals(other.currency)) {
+      throw new CurrencyMismatch(
+        `W\xE4hrungen mischen sich nicht: ${this.currency.code} vs. ${other.currency.code}`
+      );
+    }
+  }
+};
+
+// src/shared/canonical-json.ts
+var MAX_SAFE_INTEGER = 9007199254740991;
+function canonicalJson(value) {
+  return encodeValue(value);
+}
+function encodeValue(value) {
+  if (value === null) {
+    return "null";
+  }
+  if (typeof value === "boolean") {
+    return value ? "true" : "false";
+  }
+  if (typeof value === "number") {
+    if (!Number.isInteger(value)) {
+      throw new InvalidValue(
+        "Floats sind im Datenformat verboten (Betr\xE4ge als String-Dezimal, datenformat.md)"
+      );
+    }
+    if (Math.abs(value) > MAX_SAFE_INTEGER) {
+      throw new InvalidValue(`Ganzzahl au\xDFerhalb des sicheren Bereichs (|x| > 2^53-1): ${value}`);
+    }
+    return String(value);
+  }
+  if (typeof value === "string") {
+    return encodeString(value);
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map(encodeValue).join(",")}]`;
+  }
+  if (typeof value === "object") {
+    const candidate = value;
+    if (typeof candidate.toJSON === "function") {
+      return encodeValue(candidate.toJSON());
+    }
+    return encodeObject(value);
+  }
+  throw new InvalidValue(`Nicht serialisierbarer Typ: ${typeof value}`);
+}
+function encodeObject(object) {
+  const keys = Object.keys(object);
+  if (keys.length === 0) {
+    return "{}";
+  }
+  keys.sort();
+  return `{${keys.map((key) => `${encodeString(key)}:${encodeValue(object[key])}`).join(",")}}`;
+}
+function encodeString(value) {
+  let out = '"';
+  for (let i = 0; i < value.length; i++) {
+    const char = value[i];
+    const code = value.charCodeAt(i);
+    if (char === '"') {
+      out += '\\"';
+    } else if (char === "\\") {
+      out += "\\\\";
+    } else if (code === 8) {
+      out += "\\b";
+    } else if (code === 9) {
+      out += "\\t";
+    } else if (code === 10) {
+      out += "\\n";
+    } else if (code === 12) {
+      out += "\\f";
+    } else if (code === 13) {
+      out += "\\r";
+    } else if (code < 32) {
+      out += `\\u${code.toString(16).padStart(4, "0")}`;
+    } else {
+      out += char;
+    }
+  }
+  return `${out}"`;
+}
+
+// src/shared/clock.ts
+var SystemClock = class {
+  now() {
+    return /* @__PURE__ */ new Date();
+  }
+};
+var FixedClock = class _FixedClock {
+  current;
+  constructor(at) {
+    this.current = at;
+  }
+  static at(iso8601) {
+    return new _FixedClock(new Date(iso8601));
+  }
+  now() {
+    return this.current;
+  }
+  advanceMilliseconds(milliseconds) {
+    this.current = new Date(this.current.getTime() + milliseconds);
+  }
+};
+var PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
+var Uuid = class _Uuid {
+  constructor(value) {
+    this.value = value;
+  }
+  value;
+  static fromString(value) {
+    const normalized = value.toLowerCase();
+    if (!PATTERN.test(normalized)) {
+      throw new InvalidValue(`Keine g\xFCltige UUID: "${value}"`);
+    }
+    return new _Uuid(normalized);
+  }
+  static v7(clock = new SystemClock()) {
+    const time = clock.now().getTime().toString(16).padStart(12, "0");
+    const random = randomBytes(10).toString("hex");
+    const variant = (parseInt(random[3], 16) & 3 | 8).toString(16);
+    return new _Uuid(
+      `${time.slice(0, 8)}-${time.slice(8, 12)}-7${random.slice(0, 3)}-${variant}${random.slice(4, 7)}-${random.slice(7, 19)}`
+    );
+  }
+  equals(other) {
+    return this.value === other.value;
+  }
+  /** Byteweise = zeitliche Ordnung bei v7. */
+  compareTo(other) {
+    return this.value < other.value ? -1 : this.value > other.value ? 1 : 0;
+  }
+  toJSON() {
+    return this.value;
+  }
+  toString() {
+    return this.value;
+  }
+};
+
+// src/shared/id-generator.ts
+var UuidV7IdGenerator = class {
+  constructor(clock = new SystemClock()) {
+    this.clock = clock;
+  }
+  clock;
+  next() {
+    return Uuid.v7(this.clock);
+  }
+};
+var DeterministicIdGenerator = class {
+  constructor(clock) {
+    this.clock = clock;
+  }
+  clock;
+  counter = 0;
+  next() {
+    this.counter++;
+    const time = this.clock.now().getTime().toString(16).padStart(12, "0");
+    const sequence = this.counter.toString(16).padStart(18, "0");
+    return Uuid.fromString(
+      `${time.slice(0, 8)}-${time.slice(8, 12)}-7${sequence.slice(0, 3)}-8${sequence.slice(3, 6)}-${sequence.slice(6, 18)}`
+    );
+  }
+};
+
+// src/shared/calendar-date.ts
+function toIso(year, monthIndex, day) {
+  const date = new Date(Date.UTC(year, monthIndex, day));
+  const y = String(date.getUTCFullYear()).padStart(4, "0");
+  const m = String(date.getUTCMonth() + 1).padStart(2, "0");
+  const d = String(date.getUTCDate()).padStart(2, "0");
+  return `${y}-${m}-${d}`;
+}
+var CalendarDate = class _CalendarDate {
+  constructor(iso) {
+    this.iso = iso;
+  }
+  iso;
+  static of(iso) {
+    if (!/^\d{4}-\d{2}-\d{2}$/.test(iso)) {
+      throw new InvalidValue(`Kein g\xFCltiges Kalenderdatum: "${iso}"`);
+    }
+    const year = Number(iso.slice(0, 4));
+    const month = Number(iso.slice(5, 7));
+    const day = Number(iso.slice(8, 10));
+    if (toIso(year, month - 1, day) !== iso) {
+      throw new InvalidValue(`Kein g\xFCltiges Kalenderdatum: "${iso}"`);
+    }
+    return new _CalendarDate(iso);
+  }
+  compareTo(other) {
+    return this.iso < other.iso ? -1 : this.iso > other.iso ? 1 : 0;
+  }
+  equals(other) {
+    return this.iso === other.iso;
+  }
+  isBefore(other) {
+    return this.compareTo(other) < 0;
+  }
+  isAfter(other) {
+    return this.compareTo(other) > 0;
+  }
+  isBetween(start, end) {
+    return !this.isBefore(start) && !this.isAfter(end);
+  }
+  year() {
+    return Number(this.iso.slice(0, 4));
+  }
+  month() {
+    return Number(this.iso.slice(5, 7));
+  }
+  lastDayOfMonth() {
+    return new _CalendarDate(toIso(this.year(), this.month(), 0));
+  }
+  firstDayOfNextMonth() {
+    return new _CalendarDate(toIso(this.year(), this.month(), 1));
+  }
+  toJSON() {
+    return this.iso;
+  }
+  toString() {
+    return this.iso;
+  }
+};
+
+// src/shared/account-number.ts
+var AccountNumber = class _AccountNumber {
+  constructor(value) {
+    this.value = value;
+  }
+  value;
+  static of(value) {
+    if (value === "" || value.length > 64) {
+      throw new InvalidValue("Kontonummer muss 1-64 Zeichen lang sein");
+    }
+    if (!/^[^\s\p{C}]+$/u.test(value)) {
+      throw new InvalidValue(`Kontonummer enth\xE4lt Whitespace oder Steuerzeichen: "${value}"`);
+    }
+    return new _AccountNumber(value);
+  }
+  compareTo(other) {
+    return this.value < other.value ? -1 : this.value > other.value ? 1 : 0;
+  }
+  equals(other) {
+    return this.value === other.value;
+  }
+  toJSON() {
+    return this.value;
+  }
+  toString() {
+    return this.value;
+  }
+};
+
+// src/shared/period-ref.ts
+var PeriodRef = class {
+  constructor(fiscalYear, period) {
+    this.fiscalYear = fiscalYear;
+    this.period = period;
+    if (fiscalYear < 1 || fiscalYear > 9999) {
+      throw new InvalidValue(`Ung\xFCltiges Gesch\xE4ftsjahr: ${fiscalYear}`);
+    }
+    if (period < 1 || period > 999) {
+      throw new InvalidValue(`Ung\xFCltige Periodennummer: ${period}`);
+    }
+  }
+  fiscalYear;
+  period;
+  /** Chronologisch: erst Jahr, dann Periode. */
+  compareTo(other) {
+    if (this.fiscalYear !== other.fiscalYear) {
+      return this.fiscalYear < other.fiscalYear ? -1 : 1;
+    }
+    return this.period < other.period ? -1 : this.period > other.period ? 1 : 0;
+  }
+  equals(other) {
+    return this.fiscalYear === other.fiscalYear && this.period === other.period;
+  }
+  toJSON() {
+    return { fiscalYear: this.fiscalYear, period: this.period };
+  }
+};
+
+// src/shared/dimension-value.ts
+var DimensionValue = class _DimensionValue {
+  constructor(type, code) {
+    this.type = type;
+    this.code = code;
+  }
+  type;
+  code;
+  static of(type, code) {
+    if (type === "" || code === "") {
+      throw new InvalidValue("Dimensionstyp und -code d\xFCrfen nicht leer sein");
+    }
+    return new _DimensionValue(type, code);
+  }
+  equals(other) {
+    return this.type === other.type && this.code === other.code;
+  }
+  toJSON() {
+    return { type: this.type, code: this.code };
+  }
+};
+
+// src/domain-error.ts
+var DomainError = class extends Error {
+  constructor(errorCode, message = "", details = {}) {
+    super(message !== "" ? message : errorCode);
+    this.errorCode = errorCode;
+    this.details = details;
+    this.name = "DomainError";
+  }
+  errorCode;
+  details;
+};
+
+// src/ledger/types.ts
+var BALANCE_CARRYING = /* @__PURE__ */ new Set([
+  "asset",
+  "liability",
+  "equity"
+]);
+function isBalanceCarrying(type) {
+  return BALANCE_CARRYING.has(type);
+}
+function isAccountType(value) {
+  return value === "asset" || value === "liability" || value === "equity" || value === "expense" || value === "revenue";
+}
+function parseSettlementDifferenceKind(value) {
+  return value === "discount" || value === "bad_debt" || value === "minor" ? value : null;
+}
+function parseOpenItemKind(value) {
+  return value === "receivable" || value === "payable" ? value : null;
+}
+
+// src/ledger/account.ts
+var Account = class {
+  constructor(id, number, name, type, subtype, status = "active") {
+    this.id = id;
+    this.number = number;
+    this.name = name;
+    this.type = type;
+    this.subtype = subtype;
+    this.accountStatus = status;
+  }
+  id;
+  number;
+  name;
+  type;
+  subtype;
+  accountStatus;
+  status() {
+    return this.accountStatus;
+  }
+  isLocked() {
+    return this.accountStatus === "locked";
+  }
+  lock() {
+    this.accountStatus = "locked";
+  }
+  toJSON() {
+    return {
+      id: this.id.value,
+      number: this.number.value,
+      name: this.name,
+      type: this.type,
+      subtype: this.subtype,
+      status: this.accountStatus
+    };
+  }
+};
+
+// src/ledger/entry-line.ts
+var EntryLine = class _EntryLine {
+  constructor(accountId, account, side, money, dimensions = [], taxTag = null) {
+    this.accountId = accountId;
+    this.account = account;
+    this.side = side;
+    this.money = money;
+    this.dimensions = dimensions;
+    this.taxTag = taxTag;
+  }
+  accountId;
+  account;
+  side;
+  money;
+  dimensions;
+  taxTag;
+  negated() {
+    return new _EntryLine(
+      this.accountId,
+      this.account,
+      this.side,
+      this.money.negate(),
+      this.dimensions,
+      this.taxTag
+    );
+  }
+  toJSON() {
+    return {
+      accountId: this.accountId.value,
+      account: this.account.value,
+      side: this.side,
+      money: this.money.toJSON(),
+      dimensions: this.dimensions.map((dimension) => dimension.toJSON()),
+      taxTag: this.taxTag
+    };
+  }
+};
+
+// src/ledger/journal-entry.ts
+var JournalEntry = class {
+  constructor(id, sequenceNumber, entryDate, voucherDate, recordedAt, periodRef, voucherId, text, lines, reverses = null, reversedBy = null, status = "entered") {
+    this.id = id;
+    this.sequenceNumber = sequenceNumber;
+    this.entryDate = entryDate;
+    this.voucherDate = voucherDate;
+    this.recordedAt = recordedAt;
+    this.periodRef = periodRef;
+    this.voucherId = voucherId;
+    this.reverses = reverses;
+    this.entryText = text;
+    this.entryLines = lines;
+    this.entryReversedBy = reversedBy;
+    this.entryStatus = status;
+  }
+  id;
+  sequenceNumber;
+  entryDate;
+  voucherDate;
+  recordedAt;
+  periodRef;
+  voucherId;
+  reverses;
+  entryText;
+  entryLines;
+  entryReversedBy;
+  entryStatus;
+  status() {
+    return this.entryStatus;
+  }
+  isFinalized() {
+    return this.entryStatus === "finalized";
+  }
+  text() {
+    return this.entryText;
+  }
+  lines() {
+    return this.entryLines;
+  }
+  reversedBy() {
+    return this.entryReversedBy;
+  }
+  changeText(text) {
+    this.assertCorrectable();
+    this.entryText = text;
+  }
+  changeLines(lines) {
+    this.assertCorrectable();
+    this.entryLines = lines;
+  }
+  finalize() {
+    this.entryStatus = "finalized";
+  }
+  markReversed(reversalId) {
+    if (this.entryReversedBy !== null) {
+      throw new DomainError(
+        "E_ENTRY_ALREADY_REVERSED",
+        `Buchung ${this.id.value} ist bereits storniert (durch ${this.entryReversedBy.value})`,
+        { entryId: this.id.value, reversedBy: this.entryReversedBy.value }
+      );
+    }
+    this.entryReversedBy = reversalId;
+  }
+  assertCorrectable() {
+    if (this.entryStatus !== "entered") {
+      throw new DomainError(
+        "E_ENTRY_FINALIZED",
+        `Buchung ${this.id.value} ist festgeschrieben \u2014 Korrektur nicht m\xF6glich, nur Storno`,
+        { entryId: this.id.value }
+      );
+    }
+  }
+  toJSON() {
+    return {
+      id: this.id.value,
+      sequenceNumber: this.sequenceNumber,
+      status: this.entryStatus,
+      entryDate: this.entryDate.iso,
+      voucherDate: this.voucherDate?.iso ?? null,
+      recordedAt: this.recordedAt,
+      periodRef: this.periodRef.toJSON(),
+      voucherId: this.voucherId.value,
+      text: this.entryText,
+      lines: this.entryLines.map((line) => line.toJSON()),
+      reverses: this.reverses?.value ?? null,
+      reversedBy: this.entryReversedBy?.value ?? null
+    };
+  }
+};
+
+// src/ledger/voucher.ts
+var Voucher = class {
+  id;
+  voucherNumber;
+  voucherDate;
+  due;
+  recurring;
+  economicYear;
+  supplierTaxationMethod;
+  serviceDate;
+  servicePeriodFrom;
+  servicePeriodTo;
+  kind;
+  partnerId;
+  issuer;
+  constructor(props) {
+    this.id = props.id;
+    this.voucherNumber = props.voucherNumber;
+    this.voucherDate = props.voucherDate;
+    this.due = props.due ?? null;
+    this.recurring = props.recurring ?? false;
+    this.economicYear = props.economicYear ?? null;
+    this.supplierTaxationMethod = props.supplierTaxationMethod ?? null;
+    this.serviceDate = props.serviceDate ?? null;
+    this.servicePeriodFrom = props.servicePeriodFrom ?? null;
+    this.servicePeriodTo = props.servicePeriodTo ?? null;
+    this.kind = props.kind ?? null;
+    this.partnerId = props.partnerId ?? null;
+    this.issuer = props.issuer ?? null;
+  }
+  /** Steuerlich maßgebliches Datum: Leistungsdatum, Fallback Belegdatum. */
+  taxDate() {
+    return this.serviceDate ?? this.servicePeriodTo ?? this.voucherDate;
+  }
+  toJSON() {
+    return {
+      id: this.id.value,
+      voucherNumber: this.voucherNumber,
+      voucherDate: this.voucherDate.iso,
+      due: this.due?.iso ?? null,
+      recurring: this.recurring,
+      economicYear: this.economicYear,
+      supplierTaxationMethod: this.supplierTaxationMethod,
+      serviceDate: this.serviceDate?.iso ?? null,
+      servicePeriod: this.servicePeriodFrom === null ? null : { from: this.servicePeriodFrom.iso, to: this.servicePeriodTo?.iso ?? null },
+      kind: this.kind,
+      partnerId: this.partnerId?.value ?? null,
+      issuer: this.issuer
+    };
+  }
+};
+
+// src/ledger/period.ts
+var Period = class {
+  constructor(number, start, end, status = "open") {
+    this.number = number;
+    this.start = start;
+    this.end = end;
+    this.periodStatus = status;
+  }
+  number;
+  start;
+  end;
+  periodStatus;
+  status() {
+    return this.periodStatus;
+  }
+  isOpen() {
+    return this.periodStatus === "open";
+  }
+  contains(date) {
+    return date.isBetween(this.start, this.end);
+  }
+  /** Nur über FiscalYear aufrufen (Reihenfolgeprüfung dort). */
+  close() {
+    this.periodStatus = "closed";
+  }
+  /** Nur über FiscalYear aufrufen (Jahresstatusprüfung dort). */
+  reopen() {
+    this.periodStatus = "open";
+  }
+};
+
+// src/ledger/fiscal-year.ts
+var FiscalYear = class _FiscalYear {
+  constructor(id, year, start, end, periodList, status = "open") {
+    this.id = id;
+    this.year = year;
+    this.start = start;
+    this.end = end;
+    this.periodList = periodList;
+    this.fiscalStatus = status;
+  }
+  id;
+  year;
+  start;
+  end;
+  periodList;
+  fiscalStatus;
+  static create(id, year, start, end, explicitPeriods = null) {
+    if (!start.isBefore(end)) {
+      throw new InvalidValue("Gesch\xE4ftsjahr: start muss vor end liegen");
+    }
+    const periods = explicitPeriods === null ? _FiscalYear.monthlyPeriods(start, end) : explicitPeriods.map((d) => new Period(d.period, d.start, d.end));
+    return new _FiscalYear(id, year, start, end, periods);
+  }
+  static monthlyPeriods(start, end) {
+    const periods = [];
+    let cursor = start;
+    let number = 1;
+    while (!cursor.isAfter(end)) {
+      const monthEnd = cursor.lastDayOfMonth();
+      const periodEnd = monthEnd.isAfter(end) ? end : monthEnd;
+      periods.push(new Period(number, cursor, periodEnd));
+      cursor = cursor.firstDayOfNextMonth();
+      number++;
+    }
+    return periods;
+  }
+  status() {
+    return this.fiscalStatus;
+  }
+  isClosed() {
+    return this.fiscalStatus === "closed";
+  }
+  periods() {
+    return this.periodList;
+  }
+  period(number) {
+    const found = this.periodList.find((p) => p.number === number);
+    if (found === void 0) {
+      throw new DomainError(
+        "E_PERIOD_UNKNOWN",
+        `Periode ${number} existiert nicht im Gesch\xE4ftsjahr ${this.year}`,
+        { fiscalYear: this.year, period: number }
+      );
+    }
+    return found;
+  }
+  contains(date) {
+    return date.isBetween(this.start, this.end);
+  }
+  periodForDate(date) {
+    const found = this.periodList.find((p) => p.contains(date));
+    if (found === void 0) {
+      throw new DomainError(
+        "E_PERIOD_UNKNOWN",
+        `Kein Periodenzeitraum f\xFCr ${date.iso} im Gesch\xE4ftsjahr ${this.year}`,
+        { date: date.iso, fiscalYear: this.year }
+      );
+    }
+    return found;
+  }
+  closePeriod(number) {
+    this.assertNotClosed();
+    const target = this.period(number);
+    for (const period of this.periodList) {
+      if (period.number < number && period.isOpen()) {
+        throw new DomainError(
+          "E_PERIOD_OUT_OF_ORDER",
+          `Periode ${number} kann nicht geschlossen werden: Periode ${period.number} ist noch offen`,
+          { fiscalYear: this.year, period: number, openPeriod: period.number }
+        );
+      }
+    }
+    target.close();
+    return target;
+  }
+  reopenPeriod(number) {
+    this.assertNotClosed();
+    const target = this.period(number);
+    target.reopen();
+    return target;
+  }
+  /** Reiner Statuswechsel — keine fachliche Buchungswirkung (api.md v0.3). */
+  close() {
+    for (const period of this.periodList) {
+      if (period.isOpen()) {
+        throw new DomainError(
+          "E_PERIOD_OUT_OF_ORDER",
+          `Jahresabschluss ${this.year}: Periode ${period.number} ist noch offen`,
+          { fiscalYear: this.year, openPeriod: period.number }
+        );
+      }
+    }
+    this.fiscalStatus = "closed";
+  }
+  assertNotClosed() {
+    if (this.isClosed()) {
+      throw new DomainError("E_FISCALYEAR_CLOSED", `Gesch\xE4ftsjahr ${this.year} ist abgeschlossen`, {
+        fiscalYear: this.year
+      });
+    }
+  }
+};
+
+// src/ledger/audit-record.ts
+var AuditRecord = class {
+  constructor(id, at, actor, objectType, objectId, action, changes = {}) {
+    this.id = id;
+    this.at = at;
+    this.actor = actor;
+    this.objectType = objectType;
+    this.objectId = objectId;
+    this.action = action;
+    this.changes = changes;
+  }
+  id;
+  at;
+  actor;
+  objectType;
+  objectId;
+  action;
+  changes;
+  toJSON() {
+    return {
+      id: this.id.value,
+      at: this.at,
+      actor: this.actor,
+      objectType: this.objectType,
+      objectId: this.objectId.value,
+      action: this.action,
+      // Leerer Diff → {} (nicht []), damit das Format stabil bleibt.
+      changes: this.changes
+    };
+  }
+};
+
+// src/ledger/open-item.ts
+var OpenItem = class {
+  constructor(id, kind, originEntryId, originLineIndex, money, voucherId, openedAt, partnerId = null) {
+    this.id = id;
+    this.kind = kind;
+    this.originEntryId = originEntryId;
+    this.originLineIndex = originLineIndex;
+    this.money = money;
+    this.voucherId = voucherId;
+    this.openedAt = openedAt;
+    this.partnerId = partnerId;
+  }
+  id;
+  kind;
+  originEntryId;
+  originLineIndex;
+  money;
+  voucherId;
+  openedAt;
+  partnerId;
+  settlementList = [];
+  settlements() {
+    return this.settlementList;
+  }
+  remaining() {
+    return this.remainingAt(null);
+  }
+  /** Restbetrag zum Stichtag (null = heute/alles). */
+  remainingAt(asOf) {
+    let remaining = this.money;
+    for (const settlement of this.settlementList) {
+      if (asOf !== null && settlement.settledAt.isAfter(asOf)) continue;
+      remaining = remaining.subtract(settlement.money);
+    }
+    return remaining;
+  }
+  status() {
+    return this.statusAt(null);
+  }
+  statusAt(asOf) {
+    const remaining = this.remainingAt(asOf);
+    if (remaining.isZero()) return "settled";
+    return remaining.equals(this.money) ? "open" : "partially_settled";
+  }
+  settle(settlement) {
+    if (settlement.money.compareTo(this.remaining()) > 0) {
+      throw new DomainError(
+        "E_SETTLEMENT_EXCEEDS_ITEM",
+        `Zuordnung ${settlement.money.amountAsString()} \xFCbersteigt Restbetrag ${this.remaining().amountAsString()} des Postens ${this.id.value}`,
+        {
+          openItemId: this.id.value,
+          remaining: this.remaining().amountAsString(),
+          allocated: settlement.money.amountAsString()
+        }
+      );
+    }
+    this.settlementList.push(settlement);
+  }
+  toJSON() {
+    return {
+      id: this.id.value,
+      kind: this.kind,
+      originEntryId: this.originEntryId.value,
+      originLineIndex: this.originLineIndex,
+      money: this.money.toJSON(),
+      partnerId: this.partnerId?.value ?? null,
+      remaining: this.remaining().toJSON(),
+      status: this.status(),
+      settlements: this.settlementList.map((settlement) => settlement.toJSON())
+    };
+  }
+};
+
+// src/ledger/settlement.ts
+var Settlement = class {
+  constructor(entryId, money, settledAt, differenceMoney = null, differenceKind = null) {
+    this.entryId = entryId;
+    this.money = money;
+    this.settledAt = settledAt;
+    this.differenceMoney = differenceMoney;
+    this.differenceKind = differenceKind;
+  }
+  entryId;
+  money;
+  settledAt;
+  differenceMoney;
+  differenceKind;
+  toJSON() {
+    return {
+      entryId: this.entryId.value,
+      money: this.money.toJSON(),
+      settledAt: this.settledAt.iso,
+      difference: this.differenceMoney === null ? null : { money: this.differenceMoney.toJSON(), kind: this.differenceKind }
+    };
+  }
+};
+
+// src/ledger/post-result.ts
+var PostResult = class {
+  constructor(entry, openItemsCreated) {
+    this.entry = entry;
+    this.openItemsCreated = openItemsCreated;
+  }
+  entry;
+  openItemsCreated;
+};
+
+// src/ledger/dimension-registry.ts
+var DimensionRegistry = class _DimensionRegistry {
+  constructor(types, values, rules) {
+    this.types = types;
+    this.values = values;
+    this.rules = rules;
+  }
+  types;
+  values;
+  rules;
+  static empty() {
+    return new _DimensionRegistry(/* @__PURE__ */ new Set(), /* @__PURE__ */ new Set(), []);
+  }
+  static fromData(dimensionTypes, dimensionValues, dimensionRules) {
+    const types = new Set(dimensionTypes.map((t) => t.code));
+    const values = new Set(dimensionValues.map((v) => `${v.typeCode}:${v.code}`));
+    const rules = dimensionRules.map((r) => ({
+      from: r.accountRange.from,
+      to: r.accountRange.to,
+      required: r.requiredDimension
+    }));
+    return new _DimensionRegistry(types, values, rules);
+  }
+  validateLine(account, dimensions) {
+    for (const dimension of dimensions) {
+      if (!this.types.has(dimension.type)) {
+        throw new DomainError("E_DIMENSION_INVALID", `Unbekannter Dimensionstyp "${dimension.type}"`, {
+          type: dimension.type
+        });
+      }
+      if (!this.values.has(`${dimension.type}:${dimension.code}`)) {
+        throw new DomainError(
+          "E_DIMENSION_INVALID",
+          `Unbekannter Dimensionswert "${dimension.code}" f\xFCr Typ "${dimension.type}"`,
+          { type: dimension.type, code: dimension.code }
+        );
+      }
+    }
+    for (const rule of this.rules) {
+      const inRange = account.value >= rule.from && account.value <= rule.to;
+      if (!inRange) continue;
+      if (dimensions.some((d) => d.type === rule.required)) continue;
+      throw new DomainError(
+        "E_DIMENSION_INVALID",
+        `Pflichtdimension "${rule.required}" fehlt auf Konto ${account.value}`,
+        { account: account.value, required: rule.required }
+      );
+    }
+  }
+};
+
+// src/ledger/ledger.ts
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function asString(value) {
+  return typeof value === "string" ? value : null;
+}
+var Ledger = class {
+  constructor(baseCurrency, accounts, fiscalYears, vouchers, journal, openItems, audit, dimensions, clock, ids) {
+    this.baseCurrency = baseCurrency;
+    this.accounts = accounts;
+    this.fiscalYears = fiscalYears;
+    this.vouchers = vouchers;
+    this.journal = journal;
+    this.openItems = openItems;
+    this.audit = audit;
+    this.dimensions = dimensions;
+    this.clock = clock;
+    this.ids = ids;
+  }
+  baseCurrency;
+  accounts;
+  fiscalYears;
+  vouchers;
+  journal;
+  openItems;
+  audit;
+  dimensions;
+  clock;
+  ids;
+  post(input) {
+    const actor = this.actor(input);
+    const rawLines = input.lines;
+    if (!Array.isArray(rawLines) || rawLines.length < 2) {
+      throw new DomainError("E_ENTRY_TOO_FEW_LINES", "Eine Buchung braucht mindestens zwei Positionen");
+    }
+    const parsed = rawLines.map((rawLine, index) => {
+      if (!isRecord(rawLine)) {
+        throw new DomainError("E_ENTRY_INVALID_AMOUNT", `Position ${index} ist keine Struktur`);
+      }
+      return this.parseLine(rawLine, index);
+    });
+    const voucher = this.requireVoucher(input.voucherId);
+    const lines = this.resolveLines(parsed);
+    this.assertBalanced(lines);
+    const entryDate = this.parseEntryDate(input.entryDate);
+    const [fiscalYear, period] = this.openPeriodFor(entryDate);
+    const text = asString(input.text) ?? "";
+    const entry = new JournalEntry(
+      this.ids.next(),
+      this.journal.nextSequenceNumber(fiscalYear.year),
+      entryDate,
+      voucher.voucherDate,
+      this.now(),
+      new PeriodRef(fiscalYear.year, period.number),
+      voucher.id,
+      text,
+      lines
+    );
+    this.journal.append(entry);
+    this.recordAudit(actor, "journalEntry", entry.id, "created");
+    return new PostResult(entry, this.createOpenItems(entry));
+  }
+  /**
+   * AR/AP-Automatik: Soll auf Forderungskonto → receivable, Haben auf
+   * Verbindlichkeitskonto → payable. Stornobuchungen erzeugen keine Posten.
+   */
+  createOpenItems(entry) {
+    if (entry.reverses !== null) return [];
+    const created = [];
+    const voucher = this.vouchers.byId(entry.voucherId);
+    entry.lines().forEach((line, index) => {
+      const account = this.accounts.byId(line.accountId);
+      let kind = null;
+      if (account?.subtype === "ar" && line.side === "debit") kind = "receivable";
+      else if (account?.subtype === "ap" && line.side === "credit") kind = "payable";
+      if (kind === null) return;
+      const item = new OpenItem(
+        this.ids.next(),
+        kind,
+        entry.id,
+        index,
+        line.money,
+        entry.voucherId,
+        entry.entryDate,
+        voucher?.partnerId ?? null
+      );
+      this.openItems.add(item);
+      created.push(item);
+    });
+    return created;
+  }
+  /**
+   * Ausgleich: Zuordnung Zahlung → offene(r) Posten, auch teilweise; immer
+   * explizit, kein FIFO (determinismus.md §3). Differenzen (Skonto/Ausfall/
+   * Kleindifferenz) nach api.md G2. Erst vollständig validieren, dann anwenden.
+   */
+  settle(input) {
+    const actor = this.actor(input);
+    const entry = this.requireEntry(input.entryId);
+    const allocations = Array.isArray(input.allocations) ? input.allocations : [];
+    if (allocations.length === 0) {
+      throw new DomainError("E_OPENITEM_UNKNOWN", "settle ohne Zuordnungen");
+    }
+    const plan = [];
+    const planned = /* @__PURE__ */ new Map();
+    for (const allocation of allocations) {
+      if (!isRecord(allocation)) {
+        throw new DomainError("E_OPENITEM_UNKNOWN", "Zuordnung ist keine Struktur");
+      }
+      const openItemId = allocation.openItemId;
+      let item = null;
+      if (typeof openItemId === "string") {
+        try {
+          item = this.openItems.byId(Uuid.fromString(openItemId));
+        } catch (error) {
+          if (!(error instanceof InvalidValue)) throw error;
+        }
+      }
+      if (item === null) {
+        throw new DomainError(
+          "E_OPENITEM_UNKNOWN",
+          `Offener Posten ${typeof openItemId === "string" ? openItemId : "?"} existiert nicht`
+        );
+      }
+      const money = this.parseSettlementMoney(allocation.money, "Zuordnungsbetrag");
+      const [differenceMoney, differenceKind] = this.parseDifference(allocation.difference ?? null, item);
+      const alreadyPlanned = planned.get(item.id.value) ?? Money.zero(this.baseCurrency);
+      if (money.add(alreadyPlanned).compareTo(item.remaining()) > 0) {
+        throw new DomainError(
+          "E_SETTLEMENT_EXCEEDS_ITEM",
+          `Zuordnung ${money.amountAsString()} \xFCbersteigt Restbetrag ${item.remaining().subtract(alreadyPlanned).amountAsString()} des Postens ${item.id.value}`,
+          { openItemId: item.id.value }
+        );
+      }
+      planned.set(item.id.value, money.add(alreadyPlanned));
+      plan.push({
+        item,
+        settlement: new Settlement(entry.id, money, entry.entryDate, differenceMoney, differenceKind)
+      });
+    }
+    const affected = [];
+    for (const step of plan) {
+      const before = step.item.remaining().amountAsString();
+      step.item.settle(step.settlement);
+      this.openItems.save(step.item);
+      this.recordAudit(actor, "openItem", step.item.id, "settled", {
+        remaining: { from: before, to: step.item.remaining().amountAsString() }
+      });
+      affected.push(step.item);
+    }
+    return affected;
+  }
+  parseSettlementMoney(raw, label) {
+    const amount = isRecord(raw) ? asString(raw.amount) : null;
+    const currency = isRecord(raw) ? asString(raw.currency) : null;
+    if (amount === null || currency !== this.baseCurrency.code) {
+      throw new InvalidValue(`${label} fehlt oder falsche W\xE4hrung`);
+    }
+    const money = Money.of(amount, this.baseCurrency);
+    if (!money.isPositive()) {
+      throw new InvalidValue(`${label} muss > 0 sein`);
+    }
+    return money;
+  }
+  parseDifference(raw, item) {
+    if (raw === null) return [null, null];
+    if (!isRecord(raw)) {
+      throw new DomainError("E_SETTLEMENT_DIFFERENCE_INVALID", "difference ist keine Struktur");
+    }
+    const kind = parseSettlementDifferenceKind(raw.kind);
+    if (kind === null) {
+      throw new DomainError(
+        "E_SETTLEMENT_DIFFERENCE_INVALID",
+        `Unbekannte Differenzart "${typeof raw.kind === "string" ? raw.kind : "?"}"`
+      );
+    }
+    let money;
+    try {
+      money = this.parseSettlementMoney(raw.money, "Differenzbetrag");
+    } catch (error) {
+      if (error instanceof InvalidValue) {
+        throw new DomainError("E_SETTLEMENT_DIFFERENCE_INVALID", "Differenzbetrag ung\xFCltig (\u2264 0 oder Format)");
+      }
+      throw error;
+    }
+    if (money.compareTo(item.remaining()) > 0) {
+      throw new DomainError(
+        "E_SETTLEMENT_DIFFERENCE_INVALID",
+        `Differenz ${money.amountAsString()} \xFCbersteigt Restbetrag ${item.remaining().amountAsString()}`
+      );
+    }
+    return [money, kind];
+  }
+  correct(input) {
+    const actor = this.actor(input);
+    const entry = this.requireEntry(input.entryId);
+    const changes = {};
+    const text = asString(input.text);
+    if (text !== null && text !== entry.text()) {
+      changes.text = { from: entry.text(), to: text };
+      entry.changeText(text);
+    }
+    if (Array.isArray(input.lines)) {
+      if (input.lines.length < 2) {
+        throw new DomainError("E_ENTRY_TOO_FEW_LINES", "Eine Buchung braucht mindestens zwei Positionen");
+      }
+      const parsed = input.lines.map((rawLine, index) => {
+        if (!isRecord(rawLine)) {
+          throw new DomainError("E_ENTRY_INVALID_AMOUNT", `Position ${index} ist keine Struktur`);
+        }
+        return this.parseLine(rawLine, index);
+      });
+      const lines = this.resolveLines(parsed);
+      this.assertBalanced(lines);
+      changes.lines = {
+        from: entry.lines().map((line) => line.toJSON()),
+        to: lines.map((line) => line.toJSON())
+      };
+      entry.changeLines(lines);
+    }
+    if (Object.keys(changes).length > 0) {
+      this.journal.save(entry);
+      this.recordAudit(actor, "journalEntry", entry.id, "corrected", changes);
+    } else {
+      entry.changeText(entry.text());
+    }
+    return entry;
+  }
+  finalize(input) {
+    const actor = this.actor(input);
+    if (input.entryId !== void 0) {
+      const entry = this.requireEntry(input.entryId);
+      if (entry.isFinalized()) return 0;
+      entry.finalize();
+      this.journal.save(entry);
+      this.recordAudit(actor, "journalEntry", entry.id, "finalized", {
+        status: { from: "entered", to: "finalized" }
+      });
+      return 1;
+    }
+    const until = input.finalizeUntil;
+    if (typeof until !== "string") {
+      throw new DomainError("E_ENTRY_UNKNOWN", "finalize braucht entryId oder finalizeUntil");
+    }
+    const untilDate = this.parseEntryDate(until);
+    let count = 0;
+    for (const entry of this.journal.all()) {
+      if (entry.isFinalized() || entry.entryDate.isAfter(untilDate)) continue;
+      entry.finalize();
+      this.journal.save(entry);
+      this.recordAudit(actor, "journalEntry", entry.id, "finalized", {
+        status: { from: "entered", to: "finalized" }
+      });
+      count++;
+    }
+    return count;
+  }
+  reverse(input) {
+    const actor = this.actor(input);
+    const original = this.requireEntry(input.entryId);
+    if (original.reversedBy() !== null) {
+      throw new DomainError("E_ENTRY_ALREADY_REVERSED", `Buchung ${original.id.value} ist bereits storniert`, {
+        entryId: original.id.value
+      });
+    }
+    const entryDate = this.parseEntryDate(input.entryDate);
+    const [fiscalYear, period] = this.openPeriodFor(entryDate);
+    const text = asString(input.text) ?? `Storno ${original.sequenceNumber}`;
+    const reversal = new JournalEntry(
+      this.ids.next(),
+      this.journal.nextSequenceNumber(fiscalYear.year),
+      entryDate,
+      original.voucherDate,
+      this.now(),
+      new PeriodRef(fiscalYear.year, period.number),
+      original.voucherId,
+      text,
+      original.lines().map((line) => line.negated()),
+      original.id
+    );
+    original.markReversed(reversal.id);
+    this.journal.append(reversal);
+    this.journal.save(original);
+    this.recordAudit(actor, "journalEntry", reversal.id, "created");
+    this.recordAudit(actor, "journalEntry", original.id, "reversed", {
+      reversedBy: { from: null, to: reversal.id.value }
+    });
+    return reversal;
+  }
+  closePeriod(input) {
+    const fiscalYear = this.requireFiscalYear(input.fiscalYear);
+    const period = fiscalYear.closePeriod(this.periodNumber(input));
+    this.fiscalYears.save(fiscalYear);
+    return { fiscalYear: fiscalYear.year, period: period.number, status: period.status() };
+  }
+  reopenPeriod(input) {
+    const fiscalYear = this.requireFiscalYear(input.fiscalYear);
+    const period = fiscalYear.reopenPeriod(this.periodNumber(input));
+    this.fiscalYears.save(fiscalYear);
+    return { fiscalYear: fiscalYear.year, period: period.number, status: period.status() };
+  }
+  closeFiscalYear(input) {
+    const fiscalYear = this.requireFiscalYear(input.fiscalYear);
+    for (const entry of this.journal.forFiscalYear(fiscalYear.year)) {
+      if (!entry.isFinalized()) {
+        throw new DomainError(
+          "E_FISCALYEAR_UNFINALIZED_ENTRIES",
+          `Jahresabschluss ${fiscalYear.year}: Buchung ${entry.sequenceNumber} ist nicht festgeschrieben`,
+          { fiscalYear: fiscalYear.year, sequenceNumber: entry.sequenceNumber }
+        );
+      }
+    }
+    fiscalYear.close();
+    this.fiscalYears.save(fiscalYear);
+    return fiscalYear;
+  }
+  createFiscalYear(input) {
+    const year = typeof input.year === "number" ? input.year : 0;
+    const start = this.parseEntryDate(input.start);
+    const end = this.parseEntryDate(input.end);
+    for (const existing of this.fiscalYears.all()) {
+      const overlaps = !existing.end.isBefore(start) && !existing.start.isAfter(end);
+      if (overlaps || existing.year === year) {
+        throw new DomainError(
+          "E_FISCALYEAR_OVERLAP",
+          `Gesch\xE4ftsjahr ${year} (${start.iso} bis ${end.iso}) \xFCberschneidet sich mit ${existing.year}`,
+          { year, existing: existing.year }
+        );
+      }
+    }
+    const fiscalYear = FiscalYear.create(this.ids.next(), year, start, end);
+    this.fiscalYears.add(fiscalYear);
+    return fiscalYear;
+  }
+  createAccount(input) {
+    const actor = this.actor(input);
+    const account = this.buildAccount(input);
+    if (this.accounts.byNumber(account.number) !== null) {
+      throw new DomainError("E_ACCOUNT_NUMBER_TAKEN", `Kontonummer ${account.number.value} ist bereits vergeben`, {
+        number: account.number.value
+      });
+    }
+    this.accounts.add(account);
+    this.recordAudit(actor, "account", account.id, "created");
+    return account;
+  }
+  lockAccount(input) {
+    const actor = this.actor(input);
+    const number = asString(input.number) ?? "";
+    const account = this.accounts.byNumber(AccountNumber.of(number));
+    if (account === null) {
+      throw new DomainError("E_ACCOUNT_UNKNOWN", `Konto ${number} existiert nicht`, { number });
+    }
+    const before = account.status();
+    account.lock();
+    this.accounts.save(account);
+    this.recordAudit(actor, "account", account.id, "locked", {
+      status: { from: before, to: account.status() }
+    });
+    return account;
+  }
+  importChartOfAccounts(input) {
+    const actor = this.actor(input);
+    const rows = input.rows;
+    if (!Array.isArray(rows) || rows.length === 0) {
+      throw new DomainError("E_COA_FORMAT_INVALID", "Import ohne Zeilen");
+    }
+    const accounts = [];
+    const numbers = /* @__PURE__ */ new Set();
+    rows.forEach((row, index) => {
+      if (!isRecord(row)) {
+        throw new DomainError("E_COA_FORMAT_INVALID", `Zeile ${index} ist keine Struktur`);
+      }
+      let account;
+      try {
+        account = this.buildAccount(row);
+      } catch (error) {
+        if (error instanceof DomainError) {
+          throw new DomainError("E_COA_FORMAT_INVALID", `Zeile ${index} ist nicht parsebar`, { row: index });
+        }
+        throw error;
+      }
+      if (numbers.has(account.number.value) || this.accounts.byNumber(account.number) !== null) {
+        throw new DomainError("E_ACCOUNT_NUMBER_TAKEN", `Kontonummer ${account.number.value} ist bereits vergeben`, {
+          number: account.number.value
+        });
+      }
+      numbers.add(account.number.value);
+      accounts.push(account);
+    });
+    for (const account of accounts) {
+      this.accounts.add(account);
+      this.recordAudit(actor, "account", account.id, "created");
+    }
+    return accounts.length;
+  }
+  // ---- intern ----------------------------------------------------------
+  actor(input) {
+    const actor = asString(input.actor);
+    return actor !== null && actor !== "" ? actor : "system";
+  }
+  parseLine(rawLine, index) {
+    const money = rawLine.money;
+    const amount = isRecord(money) ? asString(money.amount) : null;
+    const currency = isRecord(money) ? asString(money.currency) : null;
+    if (amount === null || currency === null) {
+      throw new DomainError("E_ENTRY_INVALID_AMOUNT", `Position ${index}: money fehlt oder unvollst\xE4ndig`);
+    }
+    if (currency !== this.baseCurrency.code) {
+      throw new DomainError(
+        "E_ENTRY_INVALID_AMOUNT",
+        `Position ${index}: Fremdw\xE4hrung ${currency} \u2014 v1 bucht nur Mandantenw\xE4hrung ${this.baseCurrency.code}`,
+        { currency }
+      );
+    }
+    let parsedMoney;
+    try {
+      parsedMoney = Money.of(amount, this.baseCurrency);
+    } catch (error) {
+      if (error instanceof InvalidValue) {
+        throw new DomainError(
+          "E_ENTRY_INVALID_AMOUNT",
+          `Position ${index}: Betrag "${amount}" ist kein g\xFCltiger ${this.baseCurrency.code}-Betrag`,
+          { amount }
+        );
+      }
+      throw error;
+    }
+    if (!parsedMoney.isPositive()) {
+      throw new DomainError(
+        "E_ENTRY_INVALID_AMOUNT",
+        `Position ${index}: Betrag muss > 0 sein (negative Betr\xE4ge nur bei Storno)`,
+        { amount }
+      );
+    }
+    const side = rawLine.side;
+    if (side !== "debit" && side !== "credit") {
+      throw new DomainError("E_ENTRY_INVALID_AMOUNT", `Position ${index}: side muss debit oder credit sein`);
+    }
+    const account = asString(rawLine.account);
+    if (account === null || account === "") {
+      throw new DomainError("E_ENTRY_INVALID_AMOUNT", `Position ${index}: account fehlt`);
+    }
+    const dimensions = [];
+    const rawDimensions = Array.isArray(rawLine.dimensions) ? rawLine.dimensions : [];
+    for (const rawDimension of rawDimensions) {
+      if (!isRecord(rawDimension) || typeof rawDimension.type !== "string" || typeof rawDimension.code !== "string") {
+        throw new DomainError("E_DIMENSION_INVALID", `Position ${index}: Dimension unvollst\xE4ndig`);
+      }
+      dimensions.push(DimensionValue.of(rawDimension.type, rawDimension.code));
+    }
+    const taxTag = isRecord(rawLine.taxTag) ? rawLine.taxTag : null;
+    return { account, side, money: parsedMoney, dimensions, taxTag };
+  }
+  requireVoucher(voucherId) {
+    if (typeof voucherId !== "string" || voucherId === "") {
+      throw new DomainError("E_ENTRY_NO_VOUCHER", "Keine Buchung ohne Beleg (F-CORE-003)");
+    }
+    let voucher = null;
+    try {
+      voucher = this.vouchers.byId(Uuid.fromString(voucherId));
+    } catch (error) {
+      if (!(error instanceof InvalidValue)) throw error;
+    }
+    if (voucher === null) {
+      throw new DomainError("E_VOUCHER_UNKNOWN", `Beleg ${voucherId} existiert nicht`, { voucherId });
+    }
+    return voucher;
+  }
+  resolveLines(parsed) {
+    const lines = parsed.map((line) => {
+      const number = AccountNumber.of(line.account);
+      const account = this.accounts.byNumber(number);
+      if (account === null) {
+        throw new DomainError("E_ACCOUNT_UNKNOWN", `Konto ${number.value} existiert nicht`, { number: number.value });
+      }
+      if (account.isLocked()) {
+        throw new DomainError("E_ACCOUNT_LOCKED", `Konto ${number.value} ist gesperrt`, { number: number.value });
+      }
+      return new EntryLine(account.id, account.number, line.side, line.money, line.dimensions, line.taxTag);
+    });
+    for (const line of lines) {
+      this.dimensions.validateLine(line.account, line.dimensions);
+    }
+    return lines;
+  }
+  assertBalanced(lines) {
+    let debit = Money.zero(this.baseCurrency);
+    let credit = Money.zero(this.baseCurrency);
+    for (const line of lines) {
+      if (line.side === "debit") debit = debit.add(line.money);
+      else credit = credit.add(line.money);
+    }
+    if (!debit.equals(credit)) {
+      throw new DomainError(
+        "E_ENTRY_UNBALANCED",
+        `\u03A3 Soll (${debit.amountAsString()}) \u2260 \u03A3 Haben (${credit.amountAsString()})`,
+        { debit: debit.amountAsString(), credit: credit.amountAsString() }
+      );
+    }
+  }
+  parseEntryDate(entryDate) {
+    if (typeof entryDate !== "string") {
+      throw new DomainError("E_PERIOD_UNKNOWN", "entryDate fehlt");
+    }
+    try {
+      return CalendarDate.of(entryDate);
+    } catch (error) {
+      if (error instanceof InvalidValue) {
+        throw new DomainError("E_PERIOD_UNKNOWN", `Ung\xFCltiges Buchungsdatum "${entryDate}"`);
+      }
+      throw error;
+    }
+  }
+  openPeriodFor(entryDate) {
+    const fiscalYear = this.fiscalYears.forDate(entryDate);
+    if (fiscalYear === null) {
+      throw new DomainError(
+        "E_PERIOD_UNKNOWN",
+        `Buchungsdatum ${entryDate.iso} liegt au\xDFerhalb angelegter Gesch\xE4ftsjahre`,
+        { date: entryDate.iso }
+      );
+    }
+    const period = fiscalYear.periodForDate(entryDate);
+    if (fiscalYear.isClosed() || !period.isOpen()) {
+      throw new DomainError("E_PERIOD_CLOSED", `Periode ${fiscalYear.year}/${period.number} ist geschlossen`, {
+        fiscalYear: fiscalYear.year,
+        period: period.number
+      });
+    }
+    return [fiscalYear, period];
+  }
+  requireEntry(entryId) {
+    let entry = null;
+    if (typeof entryId === "string" && entryId !== "") {
+      try {
+        entry = this.journal.byId(Uuid.fromString(entryId));
+      } catch (error) {
+        if (!(error instanceof InvalidValue)) throw error;
+      }
+    }
+    if (entry === null) {
+      throw new DomainError("E_ENTRY_UNKNOWN", `Buchung ${typeof entryId === "string" ? entryId : "?"} existiert nicht`);
+    }
+    return entry;
+  }
+  requireFiscalYear(year) {
+    const fiscalYear = typeof year === "number" ? this.fiscalYears.byYear(year) : null;
+    if (fiscalYear === null) {
+      throw new DomainError("E_PERIOD_UNKNOWN", `Gesch\xE4ftsjahr ${typeof year === "number" ? year : "?"} ist nicht angelegt`);
+    }
+    return fiscalYear;
+  }
+  periodNumber(input) {
+    const period = input.period;
+    if (typeof period !== "number" || !Number.isInteger(period)) {
+      throw new DomainError("E_PERIOD_UNKNOWN", "Periodennummer fehlt");
+    }
+    return period;
+  }
+  buildAccount(input) {
+    const number = asString(input.number);
+    const name = asString(input.name);
+    const type = input.type;
+    if (number === null || number === "" || name === null || name === "" || !isAccountType(type)) {
+      throw new DomainError("E_COA_FORMAT_INVALID", "Konto braucht number, name und g\xFCltigen type");
+    }
+    const subtype = asString(input.subtype);
+    const status = input.status === "locked" ? "locked" : "active";
+    return new Account(this.ids.next(), AccountNumber.of(number), name, type, subtype, status);
+  }
+  recordAudit(actor, objectType, objectId, action, changes = {}) {
+    this.audit.append(new AuditRecord(this.ids.next(), this.now(), actor, objectType, objectId, action, changes));
+  }
+  now() {
+    return this.clock.now().toISOString();
+  }
+};
+
+// src/in-memory.ts
+var InMemoryAccountRepository = class {
+  byNumberMap = /* @__PURE__ */ new Map();
+  byIdMap = /* @__PURE__ */ new Map();
+  add(account) {
+    if (this.byNumberMap.has(account.number.value)) {
+      throw new Error(`Repository-Kontrakt verletzt: Kontonummer ${account.number.value} doppelt`);
+    }
+    this.byNumberMap.set(account.number.value, account);
+    this.byIdMap.set(account.id.value, account);
+  }
+  save(_account) {
+  }
+  byNumber(number) {
+    return this.byNumberMap.get(number.value) ?? null;
+  }
+  byId(id) {
+    return this.byIdMap.get(id.value) ?? null;
+  }
+  all() {
+    return [...this.byNumberMap.values()].sort((a, b) => a.number.compareTo(b.number));
+  }
+};
+var InMemoryFiscalYearRepository = class {
+  byYearMap = /* @__PURE__ */ new Map();
+  add(fiscalYear) {
+    this.byYearMap.set(fiscalYear.year, fiscalYear);
+  }
+  save(_fiscalYear) {
+  }
+  byYear(year) {
+    return this.byYearMap.get(year) ?? null;
+  }
+  forDate(date) {
+    for (const fiscalYear of this.byYearMap.values()) {
+      if (fiscalYear.contains(date)) return fiscalYear;
+    }
+    return null;
+  }
+  all() {
+    return [...this.byYearMap.values()].sort((a, b) => a.year - b.year);
+  }
+};
+var InMemoryJournalRepository = class {
+  entries = [];
+  byIdMap = /* @__PURE__ */ new Map();
+  sequences = /* @__PURE__ */ new Map();
+  append(entry) {
+    this.entries.push(entry);
+    this.byIdMap.set(entry.id.value, entry);
+    this.sequences.set(entry.periodRef.fiscalYear, entry.sequenceNumber);
+  }
+  save(_entry) {
+  }
+  byId(id) {
+    return this.byIdMap.get(id.value) ?? null;
+  }
+  nextSequenceNumber(fiscalYear) {
+    return (this.sequences.get(fiscalYear) ?? 0) + 1;
+  }
+  all() {
+    return [...this.entries].sort(
+      (a, b) => a.periodRef.fiscalYear !== b.periodRef.fiscalYear ? a.periodRef.fiscalYear - b.periodRef.fiscalYear : a.sequenceNumber - b.sequenceNumber
+    );
+  }
+  forFiscalYear(fiscalYear) {
+    return this.entries.filter((entry) => entry.periodRef.fiscalYear === fiscalYear).sort((a, b) => a.sequenceNumber - b.sequenceNumber);
+  }
+};
+var InMemoryVoucherRepository = class {
+  byIdMap = /* @__PURE__ */ new Map();
+  add(voucher) {
+    this.byIdMap.set(voucher.id.value, voucher);
+  }
+  byId(id) {
+    return this.byIdMap.get(id.value) ?? null;
+  }
+  all() {
+    return [...this.byIdMap.values()].sort(
+      (a, b) => a.id.value < b.id.value ? -1 : a.id.value > b.id.value ? 1 : 0
+    );
+  }
+};
+var InMemoryOpenItemRepository = class {
+  items = [];
+  byIdMap = /* @__PURE__ */ new Map();
+  add(item) {
+    this.items.push(item);
+    this.byIdMap.set(item.id.value, item);
+  }
+  save(_item) {
+  }
+  byId(id) {
+    return this.byIdMap.get(id.value) ?? null;
+  }
+  byOriginEntry(entryId) {
+    return this.items.filter((item) => item.originEntryId.equals(entryId));
+  }
+  all() {
+    return [...this.items];
+  }
+};
+var InMemoryAuditTrail = class {
+  records = [];
+  append(record) {
+    this.records.push(record);
+  }
+  all() {
+    return [...this.records];
+  }
+};
+var InMemoryPartnerRepository = class {
+  byIdMap = /* @__PURE__ */ new Map();
+  add(partner) {
+    this.byIdMap.set(partner.id.value, partner);
+  }
+  save(_partner) {
+  }
+  byId(id) {
+    return this.byIdMap.get(id.value) ?? null;
+  }
+  all() {
+    return [...this.byIdMap.values()].sort((a, b) => {
+      const byName = a.name() < b.name() ? -1 : a.name() > b.name() ? 1 : 0;
+      return byName !== 0 ? byName : a.id.value < b.id.value ? -1 : a.id.value > b.id.value ? 1 : 0;
+    });
+  }
+};
+var InMemoryAssetRepository = class {
+  items = [];
+  byIdMap = /* @__PURE__ */ new Map();
+  add(asset) {
+    this.items.push(asset);
+    this.byIdMap.set(asset.id.value, asset);
+  }
+  save(_asset) {
+  }
+  byId(id) {
+    return this.byIdMap.get(id.value) ?? null;
+  }
+  all() {
+    return [...this.items];
+  }
+};
+
+// src/assets/asset.ts
+function lastDayOfMonthAfter(base, monthsToAdd) {
+  const totalMonth0 = base.month() - 1 + monthsToAdd;
+  const year = base.year() + Math.floor(totalMonth0 / 12);
+  const month0 = (totalMonth0 % 12 + 12) % 12;
+  const lastDay = new Date(Date.UTC(year, month0 + 1, 0)).getUTCDate();
+  return CalendarDate.of(
+    `${String(year).padStart(4, "0")}-${String(month0 + 1).padStart(2, "0")}-${String(lastDay).padStart(2, "0")}`
+  );
+}
+var Asset = class {
+  constructor(id, name, assetClass, assetAccount, acquisitionCost, acquiredOn, route, usefulLifeMonths, monthlySchedule, voucherId) {
+    this.id = id;
+    this.name = name;
+    this.assetClass = assetClass;
+    this.assetAccount = assetAccount;
+    this.acquisitionCost = acquisitionCost;
+    this.acquiredOn = acquiredOn;
+    this.route = route;
+    this.usefulLifeMonths = usefulLifeMonths;
+    this.monthlySchedule = monthlySchedule;
+    this.voucherId = voucherId;
+  }
+  id;
+  name;
+  assetClass;
+  assetAccount;
+  acquisitionCost;
+  acquiredOn;
+  route;
+  usefulLifeMonths;
+  monthlySchedule;
+  voucherId;
+  depreciations = [];
+  disposed = false;
+  disposedOn = null;
+  isDisposed() {
+    return this.disposed;
+  }
+  assertActive() {
+    if (this.disposed) {
+      throw new DomainError(
+        "E_ASSET_DISPOSED",
+        `Anlagegut ${this.id.value} ist bereits abgegangen (${this.disposedOn?.iso ?? "?"})`,
+        { assetId: this.id.value }
+      );
+    }
+  }
+  dispose(disposedOn) {
+    this.assertActive();
+    this.disposed = true;
+    this.disposedOn = disposedOn;
+  }
+  planMonthDate(planMonth) {
+    return lastDayOfMonthAfter(this.acquiredOn, planMonth - 1);
+  }
+  isMonthBooked(planMonth) {
+    return this.depreciations.some((booking) => booking.planMonth === planMonth);
+  }
+  recordDepreciation(planMonth, date, amount, entryId) {
+    this.depreciations.push({ planMonth, date, amount, entryId });
+  }
+  accumulatedDepreciationAt(asOf) {
+    let sum = this.acquisitionCost.subtract(this.acquisitionCost);
+    for (const booking of this.depreciations) {
+      if (asOf !== null && booking.date.isAfter(asOf)) continue;
+      sum = sum.add(booking.amount);
+    }
+    return sum;
+  }
+  bookValueAt(asOf) {
+    if (this.route !== "capitalize") return this.acquisitionCost.subtract(this.acquisitionCost);
+    return this.acquisitionCost.subtract(this.accumulatedDepreciationAt(asOf));
+  }
+  scheduleSummary() {
+    if (this.monthlySchedule.length === 0) return {};
+    const summary = {};
+    let total = this.acquisitionCost.subtract(this.acquisitionCost);
+    let runStart = 1;
+    this.monthlySchedule.forEach((amount, index) => {
+      total = total.add(amount);
+      const isLast = index === this.monthlySchedule.length - 1;
+      const next = isLast ? null : this.monthlySchedule[index + 1];
+      if (next !== null && next.equals(amount)) return;
+      summary[`months${runStart}to${index + 1}`] = amount.amountAsString();
+      runStart = index + 2;
+    });
+    summary.total = total.amountAsString();
+    return summary;
+  }
+  toJSON() {
+    return {
+      id: this.id.value,
+      name: this.name,
+      assetClass: this.assetClass,
+      assetAccount: this.assetAccount.value,
+      route: this.route,
+      acquisitionCost: this.acquisitionCost.toJSON(),
+      acquiredOn: this.acquiredOn.iso,
+      usefulLifeMonths: this.usefulLifeMonths,
+      status: this.disposed ? "disposed" : "active",
+      disposedOn: this.disposedOn?.iso ?? null,
+      voucherId: this.voucherId.value
+    };
+  }
+};
+
+// src/assets/asset-route.ts
+function parseAssetRoute(value) {
+  return value === "capitalize" || value === "immediate_expense" || value === "pool" ? value : null;
+}
+
+// src/assets/asset-service.ts
+function isRecord2(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function asString2(value) {
+  return typeof value === "string" ? value : null;
+}
+var AssetService = class {
+  constructor(baseCurrency, assets, fiscalYears, vouchers, ledger, ids) {
+    this.baseCurrency = baseCurrency;
+    this.assets = assets;
+    this.fiscalYears = fiscalYears;
+    this.vouchers = vouchers;
+    this.ledger = ledger;
+    this.ids = ids;
+  }
+  baseCurrency;
+  assets;
+  fiscalYears;
+  vouchers;
+  ledger;
+  ids;
+  ruleModule = {};
+  setRuleModule(ruleModule) {
+    this.ruleModule = ruleModule;
+  }
+  acquire(input) {
+    const name = asString2(input.name) ?? "";
+    const assetClass = asString2(input.assetClass) ?? "";
+    const assetAccount = AccountNumber.of(asString2(input.assetAccount) ?? "0");
+    const cost = this.parseMoney(input.acquisitionCost);
+    const acquiredOn = CalendarDate.of(asString2(input.acquiredOn) ?? "");
+    const voucherIdRaw = asString2(input.voucherId);
+    if (voucherIdRaw === null) throw new InvalidValue("acquireAsset braucht voucherId");
+    const voucherId = Uuid.fromString(voucherIdRaw);
+    const choice = asString2(input.gwgChoice) ?? "auto";
+    const route = this.resolveRoute(choice, cost, acquiredOn);
+    let usefulLifeMonths = null;
+    const schedule = [];
+    if (route === "capitalize") {
+      usefulLifeMonths = this.usefulLifeMonths(assetClass);
+      schedule.push(...cost.allocateEvenly(usefulLifeMonths));
+    } else if (route === "pool") {
+      usefulLifeMonths = 60;
+      for (const yearAmount of cost.allocateEvenly(5)) {
+        schedule.push(...yearAmount.allocateEvenly(12));
+      }
+    }
+    const asset = new Asset(
+      this.ids.next(),
+      name,
+      assetClass,
+      assetAccount,
+      cost,
+      acquiredOn,
+      route,
+      usefulLifeMonths,
+      schedule,
+      voucherId
+    );
+    this.assets.add(asset);
+    const targetAccount = route === "immediate_expense" ? this.gwgExpenseAccount() : assetAccount.value;
+    this.postMachineEntry(acquiredOn, voucherId, `Anlagenzugang ${name}`, [
+      { account: targetAccount, side: "debit", money: cost.toJSON() },
+      { account: this.counterAccount(), side: "credit", money: cost.toJSON() }
+    ]);
+    const result = asset.toJSON();
+    result.route = route;
+    if (route === "immediate_expense") result.expenseAccount = targetAccount;
+    return result;
+  }
+  dispose(input) {
+    const asset = this.requireAsset(input.assetId);
+    asset.assertActive();
+    const disposedOn = CalendarDate.of(asString2(input.disposedOn) ?? "");
+    asset.dispose(disposedOn);
+    this.assets.save(asset);
+    const proceeds = isRecord2(input.proceeds) ? this.parseMoney(input.proceeds) : null;
+    const proceedsAccount = asString2(input.proceedsAccount);
+    const bankAccount = asString2(input.bankAccount) ?? this.counterAccount();
+    if (proceeds !== null && proceedsAccount !== null) {
+      const voucherId = asString2(input.voucherId) ? Uuid.fromString(asString2(input.voucherId)) : asset.voucherId;
+      this.postMachineEntry(disposedOn, voucherId, `Anlagenabgang ${asset.name}`, [
+        { account: bankAccount, side: "debit", money: proceeds.toJSON() },
+        { account: proceedsAccount, side: "credit", money: proceeds.toJSON() }
+      ]);
+    }
+    return asset.toJSON();
+  }
+  runDepreciation(input) {
+    const fiscalYear = typeof input.fiscalYear === "number" ? input.fiscalYear : 0;
+    const period = typeof input.period === "number" ? input.period : null;
+    let entriesCreated = 0;
+    let total = Money.zero(this.baseCurrency);
+    for (const asset of this.assets.all()) {
+      if (asset.route !== "capitalize" && asset.route !== "pool") continue;
+      if (asset.isDisposed()) continue;
+      const [months, amount] = period === null ? this.yearTarget(asset, fiscalYear) : this.monthTarget(asset, fiscalYear, period);
+      if (months.length === 0 || amount.isZero()) continue;
+      const bookingDate = this.bookingDate(asset, fiscalYear, period, months);
+      const periodLabel = period === null ? "" : `/${String(period).padStart(2, "0")}`;
+      const entry = this.postMachineEntry(
+        bookingDate,
+        this.depreciationVoucher(asset, fiscalYear, period),
+        `AfA ${asset.name} ${fiscalYear}${periodLabel}`,
+        [
+          { account: this.depreciationExpenseAccount(), side: "debit", money: amount.toJSON() },
+          { account: asset.assetAccount.value, side: "credit", money: amount.toJSON() }
+        ]
+      );
+      const monthAmounts = months.length === 1 ? [amount] : this.monthAmounts(asset, months, amount);
+      months.forEach((planMonth, index) => {
+        asset.recordDepreciation(planMonth, bookingDate, monthAmounts[index], entry);
+      });
+      this.assets.save(asset);
+      entriesCreated++;
+      total = total.add(amount);
+    }
+    if (entriesCreated === 0) return { alreadyRun: true, entriesCreated: 0 };
+    return { entriesCreated, totalDepreciation: total.toJSON() };
+  }
+  requireAsset(assetId) {
+    let asset = null;
+    if (typeof assetId === "string" && assetId !== "") {
+      try {
+        asset = this.assets.byId(Uuid.fromString(assetId));
+      } catch (error) {
+        if (!(error instanceof InvalidValue)) throw error;
+      }
+    }
+    if (asset === null) {
+      throw new DomainError("E_ASSET_UNKNOWN", `Anlagegut ${typeof assetId === "string" ? assetId : "?"} existiert nicht`);
+    }
+    return asset;
+  }
+  // ---- intern ----------------------------------------------------------
+  yearTarget(asset, fiscalYear) {
+    const zero = Money.zero(this.baseCurrency);
+    const monthsByYear = /* @__PURE__ */ new Map();
+    const life = asset.monthlySchedule.length;
+    for (let planMonth = 1; planMonth <= life; planMonth++) {
+      const year = asset.planMonthDate(planMonth).year();
+      const list = monthsByYear.get(year) ?? [];
+      list.push(planMonth);
+      monthsByYear.set(year, list);
+    }
+    const months = monthsByYear.get(fiscalYear);
+    if (months === void 0) return [[], zero];
+    const years = [...monthsByYear.keys()];
+    const weights = years.map((year) => monthsByYear.get(year).length);
+    const yearAmounts = asset.acquisitionCost.allocate(...weights);
+    const yearIndex = years.indexOf(fiscalYear);
+    if (yearIndex === -1) return [[], zero];
+    const yearAmount = yearAmounts[yearIndex];
+    const openMonths = [];
+    let bookedAmount = zero;
+    for (const planMonth of months) {
+      if (asset.isMonthBooked(planMonth)) {
+        bookedAmount = bookedAmount.add(asset.monthlySchedule[planMonth - 1]);
+        continue;
+      }
+      openMonths.push(planMonth);
+    }
+    const amount = yearAmount.subtract(bookedAmount);
+    if (openMonths.length === 0 || !amount.isPositive()) return [[], zero];
+    return [openMonths, amount];
+  }
+  monthTarget(asset, fiscalYear, period) {
+    const zero = Money.zero(this.baseCurrency);
+    const year = this.fiscalYears.byYear(fiscalYear);
+    if (year === null) {
+      throw new DomainError("E_PERIOD_UNKNOWN", `Gesch\xE4ftsjahr ${fiscalYear} ist nicht angelegt`);
+    }
+    const periodEntity = year.period(period);
+    const life = asset.monthlySchedule.length;
+    for (let planMonth = 1; planMonth <= life; planMonth++) {
+      const date = asset.planMonthDate(planMonth);
+      if (!periodEntity.contains(date)) continue;
+      if (asset.isMonthBooked(planMonth)) return [[], zero];
+      return [[planMonth], asset.monthlySchedule[planMonth - 1]];
+    }
+    return [[], zero];
+  }
+  monthAmounts(asset, months, total) {
+    const planned = months.map((planMonth) => asset.monthlySchedule[planMonth - 1]);
+    let plannedSum = Money.zero(this.baseCurrency);
+    for (const amount of planned) plannedSum = plannedSum.add(amount);
+    if (plannedSum.equals(total)) return planned;
+    return total.allocateEvenly(months.length);
+  }
+  bookingDate(asset, fiscalYear, period, months) {
+    const year = this.fiscalYears.byYear(fiscalYear);
+    if (period !== null && year !== null) return year.period(period).end;
+    if (year !== null) return year.end;
+    return asset.planMonthDate(months[months.length - 1]);
+  }
+  postMachineEntry(date, voucherId, text, lines) {
+    const result = this.ledger.post({ entryDate: date.iso, voucherId: voucherId.value, text, lines });
+    this.ledger.finalize({ entryId: result.entry.id.value });
+    return result.entry.id;
+  }
+  depreciationVoucher(asset, fiscalYear, period) {
+    const periodLabel = period === null ? "" : `-${String(period).padStart(2, "0")}`;
+    const voucher = new Voucher({
+      id: this.ids.next(),
+      voucherNumber: `AFA-${fiscalYear}${periodLabel}-${asset.id.value.slice(-6)}`,
+      voucherDate: CalendarDate.of(`${String(fiscalYear).padStart(4, "0")}-12-31`),
+      kind: "internal"
+    });
+    this.vouchers.add(voucher);
+    return voucher.id;
+  }
+  resolveRoute(choice, cost, acquiredOn) {
+    if (choice !== "auto") return parseAssetRoute(choice) ?? "capitalize";
+    for (const threshold of this.thresholds()) {
+      const validFrom = CalendarDate.of(threshold.validFrom);
+      const validTo = threshold.validTo === null ? null : CalendarDate.of(threshold.validTo);
+      if (acquiredOn.isBefore(validFrom) || validTo !== null && acquiredOn.isAfter(validTo)) continue;
+      if (cost.compareTo(Money.of(threshold.immediateMax, this.baseCurrency)) <= 0) return "immediate_expense";
+      if (threshold.poolMin !== null && threshold.poolMax !== null && cost.compareTo(Money.of(threshold.poolMin, this.baseCurrency)) >= 0 && cost.compareTo(Money.of(threshold.poolMax, this.baseCurrency)) <= 0) {
+        return "pool";
+      }
+    }
+    return "capitalize";
+  }
+  thresholds() {
+    const raw = Array.isArray(this.ruleModule.gwgThresholds) ? this.ruleModule.gwgThresholds : [];
+    const thresholds = [];
+    for (const item of raw) {
+      if (!isRecord2(item) || typeof item.validFrom !== "string" || typeof item.immediateMax !== "string") continue;
+      thresholds.push({
+        validFrom: item.validFrom,
+        validTo: typeof item.validTo === "string" ? item.validTo : null,
+        immediateMax: item.immediateMax,
+        poolMin: typeof item.poolMin === "string" ? item.poolMin : null,
+        poolMax: typeof item.poolMax === "string" ? item.poolMax : null
+      });
+    }
+    return thresholds;
+  }
+  usefulLifeMonths(assetClass) {
+    const raw = Array.isArray(this.ruleModule.usefulLife) ? this.ruleModule.usefulLife : [];
+    for (const item of raw) {
+      if (isRecord2(item) && item.assetClass === assetClass && typeof item.months === "number") {
+        return item.months;
+      }
+    }
+    throw new DomainError(
+      "E_ASSET_UNKNOWN",
+      `Keine Nutzungsdauer f\xFCr Anlagenklasse "${assetClass}" im Regelmodul (siehe SPEC-FINDINGS)`
+    );
+  }
+  counterAccount() {
+    return this.assetAccount("acquisitionCounterAccount");
+  }
+  depreciationExpenseAccount() {
+    return this.assetAccount("depreciationExpenseAccount");
+  }
+  gwgExpenseAccount() {
+    return this.assetAccount("gwgExpenseAccount");
+  }
+  assetAccount(key) {
+    const block = isRecord2(this.ruleModule.assetAccounts) ? this.ruleModule.assetAccounts : {};
+    const value = block[key];
+    if (typeof value === "string" && value !== "") return value;
+    throw new DomainError("E_ACCOUNT_UNKNOWN", `assetAccounts.${key} ist im Regelmodul nicht gesetzt`, { key });
+  }
+  parseMoney(raw) {
+    const amount = isRecord2(raw) ? asString2(raw.amount) : null;
+    if (amount === null) throw new InvalidValue("Betrag fehlt");
+    return Money.of(amount, this.baseCurrency);
+  }
+};
+
+// src/costing/costing-run.ts
+var CostingRun = class {
+  constructor(id, period, version, primary, afterAllocation, grandTotal) {
+    this.id = id;
+    this.period = period;
+    this.version = version;
+    this.primary = primary;
+    this.afterAllocation = afterAllocation;
+    this.grandTotal = grandTotal;
+  }
+  id;
+  period;
+  version;
+  primary;
+  afterAllocation;
+  grandTotal;
+  runStatus = "draft";
+  status() {
+    return this.runStatus;
+  }
+  release() {
+    if (this.runStatus === "released") {
+      throw new DomainError(
+        "E_COSTING_RUN_RELEASED",
+        `Lauf ${this.id.value} ist bereits freigegeben \u2014 \xC4nderungen erzeugen eine neue Version`,
+        { runId: this.id.value }
+      );
+    }
+    this.runStatus = "released";
+  }
+};
+
+// src/costing/costing-service.ts
+function isRecord3(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+var CostingService = class {
+  constructor(baseCurrency, accounts, journal, ids) {
+    this.baseCurrency = baseCurrency;
+    this.accounts = accounts;
+    this.journal = journal;
+    this.ids = ids;
+  }
+  baseCurrency;
+  accounts;
+  journal;
+  ids;
+  schemeSteps = [];
+  runs = /* @__PURE__ */ new Map();
+  versions = /* @__PURE__ */ new Map();
+  setAllocationScheme(input) {
+    const method = typeof input.method === "string" ? input.method : "step_ladder";
+    const steps = [];
+    const edges = /* @__PURE__ */ new Map();
+    for (const rawStep of Array.isArray(input.steps) ? input.steps : []) {
+      if (!isRecord3(rawStep) || typeof rawStep.sender !== "string") {
+        throw new InvalidValue("Umlageschritt braucht sender");
+      }
+      const sender = rawStep.sender;
+      const receivers = [];
+      for (const rawReceiver of Array.isArray(rawStep.receivers) ? rawStep.receivers : []) {
+        if (!isRecord3(rawReceiver) || typeof rawReceiver.code !== "string") continue;
+        receivers.push({ code: rawReceiver.code, share: typeof rawReceiver.share === "string" ? rawReceiver.share : "1" });
+        const list = edges.get(sender) ?? [];
+        list.push(rawReceiver.code);
+        edges.set(sender, list);
+      }
+      steps.push({ sender, receivers });
+    }
+    if (method === "step_ladder") this.assertAcyclic(edges);
+    this.schemeSteps = steps;
+    return { valid: true, method, stepCount: steps.length };
+  }
+  run(input) {
+    const fiscalYear = typeof input.fiscalYear === "number" ? input.fiscalYear : 0;
+    const period = typeof input.period === "number" ? input.period : 0;
+    const periodRef = new PeriodRef(fiscalYear, period);
+    const zero = Money.zero(this.baseCurrency);
+    const primary = /* @__PURE__ */ new Map();
+    for (const entry of this.journal.forFiscalYear(fiscalYear)) {
+      if (entry.periodRef.period !== period) continue;
+      for (const line of entry.lines()) {
+        const account = this.accounts.byId(line.accountId);
+        if (account === null || account.type !== "expense") continue;
+        for (const dimension of line.dimensions) {
+          if (dimension.type !== "costCenter") continue;
+          const signed = line.side === "debit" ? line.money : line.money.negate();
+          primary.set(dimension.code, (primary.get(dimension.code) ?? zero).add(signed));
+        }
+      }
+    }
+    const after = new Map(primary);
+    for (const step of this.schemeSteps) {
+      const senderTotal = after.get(step.sender) ?? zero;
+      if (senderTotal.isZero() || step.receivers.length === 0) continue;
+      const weights = step.receivers.map((receiver) => receiver.share);
+      const parts = senderTotal.allocate(...weights);
+      step.receivers.forEach((receiver, index) => {
+        after.set(receiver.code, (after.get(receiver.code) ?? zero).add(parts[index]));
+      });
+      after.set(step.sender, zero);
+    }
+    let grandTotal = zero;
+    for (const total of after.values()) grandTotal = grandTotal.add(total);
+    const key = `${fiscalYear}-${period}`;
+    const version = (this.versions.get(key) ?? 0) + 1;
+    this.versions.set(key, version);
+    const run = new CostingRun(this.ids.next(), periodRef, version, primary, after, grandTotal);
+    this.runs.set(run.id.value, run);
+    return run;
+  }
+  release(input) {
+    const run = this.requireRun(input.runId);
+    run.release();
+    return run;
+  }
+  costAllocationSheet(params) {
+    const run = this.requireRun(params.runId);
+    return {
+      runId: run.id.value,
+      status: run.status(),
+      version: run.version,
+      primary: this.serializeTotals(run.primary),
+      afterAllocation: this.serializeTotals(run.afterAllocation),
+      grandTotal: run.grandTotal.amountAsString()
+    };
+  }
+  serializeTotals(totals) {
+    const codes = [...totals.keys()].sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+    return codes.map((code) => ({ costCenter: code, total: totals.get(code).amountAsString() }));
+  }
+  requireRun(runId) {
+    let run = null;
+    if (typeof runId === "string" && runId !== "") {
+      try {
+        run = this.runs.get(Uuid.fromString(runId).value) ?? null;
+      } catch (error) {
+        if (!(error instanceof InvalidValue)) throw error;
+      }
+    }
+    if (run === null) {
+      throw new DomainError("E_COSTING_RUN_UNKNOWN", `Abrechnungslauf ${typeof runId === "string" ? runId : "?"} existiert nicht`);
+    }
+    return run;
+  }
+  assertAcyclic(edges) {
+    const visiting = /* @__PURE__ */ new Set();
+    const done = /* @__PURE__ */ new Set();
+    const visit = (node) => {
+      if (done.has(node)) return;
+      if (visiting.has(node)) {
+        throw new DomainError(
+          "E_COSTING_CYCLE",
+          `Umlagezyklus \xFCber Kostenstelle "${node}" \u2014 Stufenleiter verlangt Zyklenfreiheit`,
+          { costCenter: node }
+        );
+      }
+      visiting.add(node);
+      for (const next of edges.get(node) ?? []) visit(next);
+      visiting.delete(node);
+      done.add(node);
+    };
+    for (const node of edges.keys()) visit(node);
+  }
+};
+
+// src/partner/partner.ts
+var Partner = class {
+  constructor(id, name, kind, vatId, paymentTermsDays, accountNumbers = [], address = {}) {
+    this.id = id;
+    this.accountNumbers = accountNumbers;
+    this.address = address;
+    this.partnerName = name;
+    this.partnerKind = kind;
+    this.partnerVatId = vatId;
+    this.partnerPaymentTermsDays = paymentTermsDays;
+  }
+  id;
+  accountNumbers;
+  address;
+  partnerName;
+  partnerKind;
+  partnerVatId;
+  partnerPaymentTermsDays;
+  name() {
+    return this.partnerName;
+  }
+  vatId() {
+    return this.partnerVatId;
+  }
+  update(input) {
+    const changes = {};
+    if (typeof input.name === "string" && input.name !== this.partnerName) {
+      changes.name = { from: this.partnerName, to: input.name };
+      this.partnerName = input.name;
+    }
+    if ("vatId" in input && input.vatId !== this.partnerVatId && (typeof input.vatId === "string" || input.vatId === null)) {
+      changes.vatId = { from: this.partnerVatId, to: input.vatId };
+      this.partnerVatId = input.vatId;
+    }
+    if (typeof input.kind === "string" && input.kind !== this.partnerKind) {
+      changes.kind = { from: this.partnerKind, to: input.kind };
+      this.partnerKind = input.kind;
+    }
+    if (typeof input.paymentTermsDays === "number" && input.paymentTermsDays !== this.partnerPaymentTermsDays) {
+      changes.paymentTermsDays = { from: this.partnerPaymentTermsDays, to: input.paymentTermsDays };
+      this.partnerPaymentTermsDays = input.paymentTermsDays;
+    }
+    return changes;
+  }
+  toJSON() {
+    return {
+      id: this.id.value,
+      name: this.partnerName,
+      kind: this.partnerKind,
+      vatId: this.partnerVatId,
+      paymentTermsDays: this.partnerPaymentTermsDays,
+      accountNumbers: this.accountNumbers,
+      address: Object.keys(this.address).length === 0 ? null : this.address
+    };
+  }
+};
+
+// src/partner/partner-service.ts
+function asString3(value) {
+  return typeof value === "string" ? value : null;
+}
+var PartnerService = class {
+  constructor(partners, audit, clock, ids) {
+    this.partners = partners;
+    this.audit = audit;
+    this.clock = clock;
+    this.ids = ids;
+  }
+  partners;
+  audit;
+  clock;
+  ids;
+  create(input) {
+    const accountNumbers = (Array.isArray(input.accountNumbers) ? input.accountNumbers : []).filter(
+      (value) => typeof value === "string"
+    );
+    const address = input.address !== null && typeof input.address === "object" && !Array.isArray(input.address) ? input.address : {};
+    const partner = new Partner(
+      this.ids.next(),
+      asString3(input.name) ?? "",
+      asString3(input.kind) ?? "both",
+      asString3(input.vatId),
+      typeof input.paymentTermsDays === "number" ? input.paymentTermsDays : null,
+      accountNumbers,
+      address
+    );
+    this.partners.add(partner);
+    this.recordAudit(input, "created", partner.id, {});
+    return partner;
+  }
+  update(input) {
+    const partner = this.require(input.partnerId);
+    const changes = partner.update(input);
+    if (Object.keys(changes).length > 0) {
+      this.partners.save(partner);
+      this.recordAudit(input, "updated", partner.id, changes);
+    }
+    return partner;
+  }
+  require(partnerId) {
+    let partner = null;
+    if (typeof partnerId === "string" && partnerId !== "") {
+      try {
+        partner = this.partners.byId(Uuid.fromString(partnerId));
+      } catch (error) {
+        if (!(error instanceof InvalidValue)) throw error;
+      }
+    }
+    if (partner === null) {
+      throw new DomainError("E_PARTNER_UNKNOWN", `Gesch\xE4ftspartner ${typeof partnerId === "string" ? partnerId : "?"} existiert nicht`);
+    }
+    return partner;
+  }
+  recordAudit(input, action, objectId, changes) {
+    const actor = asString3(input.actor);
+    this.audit.append(
+      new AuditRecord(
+        this.ids.next(),
+        this.clock.now().toISOString(),
+        actor !== null && actor !== "" ? actor : "system",
+        "partner",
+        objectId,
+        action,
+        changes
+      )
+    );
+  }
+};
+
+// src/projection/ec-sales-list.ts
+var EcSalesListProjection = class {
+  constructor(baseCurrency, journal, vouchers, partners, registry) {
+    this.baseCurrency = baseCurrency;
+    this.journal = journal;
+    this.vouchers = vouchers;
+    this.partners = partners;
+    this.registry = registry;
+  }
+  baseCurrency;
+  journal;
+  vouchers;
+  partners;
+  registry;
+  compute(params) {
+    const year = typeof params.year === "number" ? params.year : 0;
+    const quarter = typeof params.quarter === "number" ? params.quarter : 0;
+    const intraCommunityKeys = /* @__PURE__ */ new Set();
+    for (const version of this.registry.allVersions()) {
+      if (version.mechanism === "intra_community_supply" && version.reportingKey !== null) {
+        intraCommunityKeys.add(version.reportingKey);
+      }
+    }
+    const byVatId = /* @__PURE__ */ new Map();
+    for (const entry of this.journal.all()) {
+      const voucher = this.vouchers.byId(entry.voucherId);
+      const taxDate = voucher === null ? entry.entryDate : voucher.taxDate();
+      if (taxDate.year() !== year) continue;
+      if (quarter !== 0 && Math.floor((taxDate.month() - 1) / 3) + 1 !== quarter) continue;
+      const partner = voucher?.partnerId == null ? null : this.partners.byId(voucher.partnerId);
+      const vatId = partner?.vatId() ?? null;
+      if (vatId === null) continue;
+      for (const line of entry.lines()) {
+        const rawKey = line.taxTag?.reportingKey;
+        if (typeof rawKey !== "string" && typeof rawKey !== "number") continue;
+        if (!intraCommunityKeys.has(String(rawKey))) continue;
+        const signed = line.side === "credit" ? line.money : line.money.negate();
+        byVatId.set(vatId, (byVatId.get(vatId) ?? Money.zero(this.baseCurrency)).add(signed));
+      }
+    }
+    const vatIds = [...byVatId.keys()].sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+    const rows = [];
+    for (const vatId of vatIds) {
+      const amount = byVatId.get(vatId);
+      if (amount.isZero()) continue;
+      rows.push({ vatId, amount: amount.amountAsString(), kind: "supply" });
+    }
+    return { rows };
+  }
+};
+
+// src/projection/trial-balance.ts
+var TrialBalanceProjection = class {
+  constructor(baseCurrency, accounts, journal) {
+    this.baseCurrency = baseCurrency;
+    this.accounts = accounts;
+    this.journal = journal;
+  }
+  baseCurrency;
+  accounts;
+  journal;
+  compute(params) {
+    const fiscalYear = typeof params.fiscalYear === "number" ? params.fiscalYear : 0;
+    const throughPeriod = typeof params.throughPeriod === "number" ? params.throughPeriod : Number.MAX_SAFE_INTEGER;
+    const includeZeroBalances = params.includeZeroBalances === true;
+    const zero = Money.zero(this.baseCurrency);
+    const totals = /* @__PURE__ */ new Map();
+    for (const entry of this.journal.all()) {
+      const entryYear = entry.periodRef.fiscalYear;
+      const entryPeriod = entry.periodRef.period;
+      const isPriorYear = entryYear < fiscalYear;
+      const isCurrentScope = entryYear === fiscalYear && entryPeriod <= throughPeriod;
+      if (!isPriorYear && !isCurrentScope) continue;
+      for (const line of entry.lines()) {
+        const account = this.accounts.byId(line.accountId);
+        if (account === null) continue;
+        if (isPriorYear && !isBalanceCarrying(account.type)) continue;
+        const key = account.number.value;
+        let total = totals.get(key);
+        if (total === void 0) {
+          total = { opening: zero, debit: zero, credit: zero, touched: false };
+          totals.set(key, total);
+        }
+        if (isPriorYear) {
+          total.opening = line.side === "debit" ? total.opening.add(line.money) : total.opening.subtract(line.money);
+          continue;
+        }
+        if (line.side === "debit") total.debit = total.debit.add(line.money);
+        else total.credit = total.credit.add(line.money);
+        total.touched = true;
+      }
+    }
+    if (includeZeroBalances) {
+      for (const account of this.accounts.all()) {
+        if (!totals.has(account.number.value)) {
+          totals.set(account.number.value, { opening: zero, debit: zero, credit: zero, touched: false });
+        }
+      }
+    }
+    const numbers = [...totals.keys()].sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+    const rows = [];
+    for (const number of numbers) {
+      const total = totals.get(number);
+      const balance = total.opening.add(total.debit).subtract(total.credit);
+      if (!includeZeroBalances && balance.isZero() && !total.touched) continue;
+      rows.push({
+        account: number,
+        openingBalance: total.opening.amountAsString(),
+        debitTotal: total.debit.amountAsString(),
+        creditTotal: total.credit.amountAsString(),
+        balance: balance.amountAsString()
+      });
+    }
+    return { rows };
+  }
+};
+
+// src/projection/open-items.ts
+var OpenItemsProjection = class {
+  constructor(openItems, vouchers, journal) {
+    this.openItems = openItems;
+    this.vouchers = vouchers;
+    this.journal = journal;
+  }
+  openItems;
+  vouchers;
+  journal;
+  compute(params) {
+    const asOf = typeof params.asOf === "string" ? CalendarDate.of(params.asOf) : null;
+    const kind = parseOpenItemKind(params.kind);
+    const partnerId = typeof params.partnerId === "string" ? params.partnerId : null;
+    const open = this.openItems.all().filter((item) => {
+      if (kind !== null && item.kind !== kind) return false;
+      if (partnerId !== null && (item.partnerId?.value ?? null) !== partnerId) return false;
+      if (asOf !== null && item.openedAt.isAfter(asOf)) return false;
+      if (item.remainingAt(asOf).isZero()) return false;
+      return true;
+    });
+    open.sort((a, b) => {
+      const byDate = this.voucherDate(a).compareTo(this.voucherDate(b));
+      return byDate !== 0 ? byDate : this.sequenceNumber(a) - this.sequenceNumber(b);
+    });
+    return { items: open.map((item) => this.serializeItem(item, asOf)) };
+  }
+  voucherDate(item) {
+    return this.vouchers.byId(item.voucherId)?.voucherDate ?? item.openedAt;
+  }
+  sequenceNumber(item) {
+    return this.journal.byId(item.originEntryId)?.sequenceNumber ?? 0;
+  }
+  serializeItem(item, asOf) {
+    return {
+      id: item.id.value,
+      kind: item.kind,
+      voucherNumber: this.vouchers.byId(item.voucherId)?.voucherNumber ?? null,
+      money: item.money.toJSON(),
+      remaining: item.remainingAt(asOf).toJSON(),
+      status: item.statusAt(asOf)
+    };
+  }
+};
+
+// src/projection/account-sheet.ts
+var AccountSheetProjection = class {
+  constructor(baseCurrency, accounts, journal) {
+    this.baseCurrency = baseCurrency;
+    this.accounts = accounts;
+    this.journal = journal;
+  }
+  baseCurrency;
+  accounts;
+  journal;
+  compute(params) {
+    const number = typeof params.account === "string" ? params.account : "";
+    const fiscalYear = typeof params.fiscalYear === "number" ? params.fiscalYear : 0;
+    const throughPeriod = typeof params.throughPeriod === "number" ? params.throughPeriod : Number.MAX_SAFE_INTEGER;
+    const account = this.accounts.byNumber(AccountNumber.of(number));
+    if (account === null) {
+      throw new DomainError("E_ACCOUNT_UNKNOWN", `Konto ${number} existiert nicht`);
+    }
+    let opening = Money.zero(this.baseCurrency);
+    if (isBalanceCarrying(account.type)) {
+      for (const entry of this.journal.all()) {
+        if (entry.periodRef.fiscalYear >= fiscalYear) continue;
+        for (const line of entry.lines()) {
+          if (!line.accountId.equals(account.id)) continue;
+          opening = line.side === "debit" ? opening.add(line.money) : opening.subtract(line.money);
+        }
+      }
+    }
+    let running = opening;
+    const lines = [];
+    for (const entry of this.journal.forFiscalYear(fiscalYear)) {
+      if (entry.periodRef.period > throughPeriod) continue;
+      for (const line of entry.lines()) {
+        if (!line.accountId.equals(account.id)) continue;
+        running = line.side === "debit" ? running.add(line.money) : running.subtract(line.money);
+        lines.push({
+          sequenceNumber: entry.sequenceNumber,
+          entryDate: entry.entryDate.iso,
+          text: entry.text(),
+          side: line.side,
+          money: line.money.toJSON(),
+          runningBalance: running.amountAsString()
+        });
+      }
+    }
+    return {
+      account: account.number.value,
+      name: account.name,
+      openingBalance: opening.amountAsString(),
+      lines,
+      closingBalance: running.amountAsString()
+    };
+  }
+};
+
+// src/projection/audit-log.ts
+var AuditLogProjection = class {
+  constructor(audit) {
+    this.audit = audit;
+  }
+  audit;
+  compute(params) {
+    const from = typeof params.from === "string" ? CalendarDate.of(params.from) : null;
+    const to = typeof params.to === "string" ? CalendarDate.of(params.to) : null;
+    const records = [];
+    for (const record of this.audit.all()) {
+      const date = CalendarDate.of(record.at.slice(0, 10));
+      if (from !== null && date.isBefore(from)) continue;
+      if (to !== null && date.isAfter(to)) continue;
+      records.push(record.toJSON());
+    }
+    return { records };
+  }
+};
+var VatReturnProjection = class {
+  constructor(baseCurrency, journal, openItems, vouchers, accounts, registry, profile) {
+    this.baseCurrency = baseCurrency;
+    this.journal = journal;
+    this.openItems = openItems;
+    this.vouchers = vouchers;
+    this.accounts = accounts;
+    this.registry = registry;
+    this.profile = profile;
+  }
+  baseCurrency;
+  journal;
+  openItems;
+  vouchers;
+  accounts;
+  registry;
+  profile;
+  compute(params) {
+    const year = typeof params.year === "number" ? params.year : 0;
+    const quarter = typeof params.quarter === "number" ? params.quarter : 0;
+    const asOf = typeof params.asOf === "string" ? CalendarDate.of(params.asOf) : null;
+    const zero = Money.zero(this.baseCurrency);
+    const keys = /* @__PURE__ */ new Map();
+    const directions = this.registryDirections();
+    const add = (key, base, tax) => {
+      const current = keys.get(key) ?? { base: zero, tax: zero };
+      keys.set(key, { base: current.base.add(base), tax: current.tax.add(tax) });
+    };
+    if (this.profile.isCashBasis()) {
+      for (const item of this.openItems.all()) {
+        const origin = this.journal.byId(item.originEntryId);
+        if (origin === null || asOf !== null && origin.entryDate.isAfter(asOf)) continue;
+        const contributions = this.entryContributions(origin, directions);
+        if (contributions.size === 0) continue;
+        for (const share of this.allocateToSettlements(item, contributions)) {
+          if (asOf !== null && share.settledAt.isAfter(asOf)) continue;
+          if (this.inQuarter(share.settledAt, year, quarter)) add(share.key, share.base, share.tax);
+        }
+      }
+      for (const entry of this.journal.all()) {
+        if (!this.inQuarter(entry.entryDate, year, quarter)) continue;
+        if (asOf !== null && entry.entryDate.isAfter(asOf)) continue;
+        if (this.openItems.byOriginEntry(entry.id).length > 0) continue;
+        for (const [key, contribution] of this.entryContributions(entry, directions)) {
+          add(key, contribution.base, contribution.tax);
+        }
+      }
+    } else {
+      for (const entry of this.journal.all()) {
+        let taxDate;
+        if (entry.reverses !== null) {
+          taxDate = entry.entryDate;
+        } else {
+          const voucher = this.vouchers.byId(entry.voucherId);
+          taxDate = voucher === null ? entry.entryDate : voucher.taxDate();
+        }
+        if (!this.inQuarter(taxDate, year, quarter)) continue;
+        if (asOf !== null && entry.entryDate.isAfter(asOf)) continue;
+        for (const [key, contribution] of this.entryContributions(entry, directions)) {
+          add(key, contribution.base, contribution.tax);
+        }
+      }
+    }
+    const sortedKeys = [...keys.keys()].sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+    const result = {};
+    let payload = zero;
+    for (const key of sortedKeys) {
+      const amounts = keys.get(key);
+      const flooredBase = Money.fromCalculation(
+        new Big(amounts.base.amountAsString()).round(0, Big.roundDown),
+        this.baseCurrency
+      );
+      result[key] = { base: flooredBase.amountAsString(), tax: amounts.tax.amountAsString() };
+      const direction = directions.get(key) ?? "output";
+      payload = direction === "input" ? payload.subtract(amounts.tax) : payload.add(amounts.tax);
+    }
+    return { keys: result, payload: payload.toJSON() };
+  }
+  registryDirections() {
+    const directions = /* @__PURE__ */ new Map();
+    for (const version of this.registry.allVersions()) {
+      if (version.reportingKey !== null) {
+        directions.set(version.reportingKey, this.accountDirection(version.taxAccount));
+      }
+      if (version.inputReportingKey !== null) {
+        directions.set(version.inputReportingKey, "input");
+      }
+      if (version.baseReportingKey !== null) {
+        directions.set(
+          version.baseReportingKey,
+          version.mechanism === "reverse_charge" ? "input" : this.accountDirection(version.taxAccount)
+        );
+      }
+    }
+    return directions;
+  }
+  accountDirection(accountNumber) {
+    if (accountNumber === "") return "output";
+    const account = this.accounts.byNumber(AccountNumber.of(accountNumber));
+    return account?.subtype === "tax_in" ? "input" : "output";
+  }
+  entryContributions(entry, directions) {
+    const zero = Money.zero(this.baseCurrency);
+    const collected = /* @__PURE__ */ new Map();
+    for (const line of entry.lines()) {
+      const tag = line.taxTag;
+      if (tag === null) continue;
+      const rawKey = tag.reportingKey;
+      if (typeof rawKey !== "string" && typeof rawKey !== "number") continue;
+      const key = String(rawKey);
+      const account = this.accounts.byId(line.accountId);
+      const subtype = account?.subtype ?? null;
+      const entryFor = collected.get(key) ?? {
+        baseFromTax: zero,
+        hasTaxBase: false,
+        baseFallback: zero,
+        tax: zero
+      };
+      if (subtype === "tax_out" || subtype === "tax_in") {
+        const positiveSide = subtype === "tax_out" ? "credit" : "debit";
+        const signed = line.side === positiveSide ? line.money : line.money.negate();
+        entryFor.tax = entryFor.tax.add(signed);
+        let baseMoney = this.tagBaseMoney(tag);
+        if (baseMoney !== null) {
+          if (line.money.isNegative()) baseMoney = baseMoney.negate();
+          entryFor.baseFromTax = entryFor.baseFromTax.add(baseMoney);
+          entryFor.hasTaxBase = true;
+        }
+      } else {
+        const direction = directions.get(key) ?? "output";
+        const positiveSide = direction === "input" ? "debit" : "credit";
+        const signed = line.side === positiveSide ? line.money : line.money.negate();
+        entryFor.baseFallback = entryFor.baseFallback.add(signed);
+      }
+      collected.set(key, entryFor);
+    }
+    const contributions = /* @__PURE__ */ new Map();
+    for (const [key, parts] of collected) {
+      const base = parts.hasTaxBase ? parts.baseFromTax : parts.baseFallback;
+      if (base.isZero() && parts.tax.isZero()) continue;
+      contributions.set(key, { base, tax: parts.tax });
+    }
+    return contributions;
+  }
+  tagBaseMoney(tag) {
+    const baseMoney = tag.baseMoney;
+    const amount = baseMoney !== null && typeof baseMoney === "object" && typeof baseMoney.amount === "string" ? baseMoney.amount : null;
+    return amount === null ? null : Money.of(amount, this.baseCurrency);
+  }
+  allocateToSettlements(item, contributions) {
+    const shares = [];
+    const allocated = /* @__PURE__ */ new Map();
+    let remaining = item.money;
+    const total = new Big(item.money.amountAsString());
+    for (const settlement of item.settlements()) {
+      remaining = remaining.subtract(settlement.money);
+      const isFinal = remaining.isZero();
+      const ratio = new Big(settlement.money.amountAsString());
+      for (const [key, contribution] of contributions) {
+        const current = allocated.get(key) ?? {
+          base: Money.zero(this.baseCurrency),
+          tax: Money.zero(this.baseCurrency)
+        };
+        let base;
+        let tax;
+        if (isFinal) {
+          base = contribution.base.subtract(current.base);
+          tax = contribution.tax.subtract(current.tax);
+        } else {
+          base = this.proportional(contribution.base, ratio, total);
+          tax = this.proportional(contribution.tax, ratio, total);
+        }
+        allocated.set(key, { base: current.base.add(base), tax: current.tax.add(tax) });
+        shares.push({ key, base, tax, settledAt: settlement.settledAt });
+      }
+    }
+    return shares;
+  }
+  proportional(total, part, whole) {
+    if (whole.eq(0)) return Money.zero(this.baseCurrency);
+    return Money.fromCalculation(
+      new Big(total.amountAsString()).times(part).div(whole),
+      this.baseCurrency
+    );
+  }
+  inQuarter(date, year, quarter) {
+    if (date.year() !== year) return false;
+    return quarter === 0 || Math.floor((date.month() - 1) / 3) + 1 === quarter;
+  }
+};
+
+// src/projection/income-statement.ts
+var IncomeStatementProjection = class {
+  constructor(baseCurrency, accounts, journal, mappings) {
+    this.baseCurrency = baseCurrency;
+    this.accounts = accounts;
+    this.journal = journal;
+    this.mappings = mappings;
+  }
+  baseCurrency;
+  accounts;
+  journal;
+  mappings;
+  compute(params) {
+    const fiscalYear = typeof params.fiscalYear === "number" ? params.fiscalYear : 0;
+    const fromPeriod = typeof params.fromPeriod === "number" ? params.fromPeriod : 1;
+    const throughPeriod = typeof params.throughPeriod === "number" ? params.throughPeriod : Number.MAX_SAFE_INTEGER;
+    const mappingId = typeof params.mapping === "string" ? params.mapping : "";
+    const mapping = this.mappings.byId(mappingId);
+    if (mapping === null) {
+      throw new DomainError("E_MAPPING_OVERLAP", `Mapping "${mappingId}" ist nicht geladen`);
+    }
+    const zero = Money.zero(this.baseCurrency);
+    const amounts = /* @__PURE__ */ new Map();
+    const touched = /* @__PURE__ */ new Set();
+    for (const entry of this.journal.forFiscalYear(fiscalYear)) {
+      const period = entry.periodRef.period;
+      if (period < fromPeriod || period > throughPeriod) continue;
+      for (const line of entry.lines()) {
+        const account = this.accounts.byId(line.accountId);
+        if (account === null || isBalanceCarrying(account.type)) continue;
+        const leaf = mapping.leafFor(account.number.value);
+        if (leaf === null) continue;
+        const signed = line.side === "credit" ? line.money : line.money.negate();
+        amounts.set(leaf.key, (amounts.get(leaf.key) ?? zero).add(signed));
+        touched.add(leaf.key);
+      }
+    }
+    const positions = [];
+    let netIncome = zero;
+    for (const leaf of mapping.leaves) {
+      const amount = amounts.get(leaf.key) ?? zero;
+      netIncome = netIncome.add(amount);
+      if (amount.isZero() && !touched.has(leaf.key)) continue;
+      positions.push({ key: leaf.key, label: leaf.label, amount: amount.amountAsString() });
+    }
+    return { positions, netIncome: netIncome.amountAsString() };
+  }
+};
+
+// src/mapping/mapping.ts
+function isRecord4(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function asString4(value) {
+  return typeof value === "string" ? value : null;
+}
+function leafMatches(leaf, accountNumber) {
+  if (leaf.numbers.includes(accountNumber)) return true;
+  for (const range of leaf.ranges) {
+    if (accountNumber >= range.from && accountNumber <= range.to) return true;
+  }
+  return false;
+}
+var Mapping = class _Mapping {
+  constructor(id, kind, version, leaves) {
+    this.id = id;
+    this.kind = kind;
+    this.version = version;
+    this.leaves = leaves;
+  }
+  id;
+  kind;
+  version;
+  leaves;
+  static fromData(data) {
+    const leaves = [];
+    _Mapping.collectLeaves(Array.isArray(data.positions) ? data.positions : [], [], leaves, null);
+    return new _Mapping(asString4(data.id) ?? "", asString4(data.kind) ?? "", asString4(data.version) ?? "", leaves);
+  }
+  static collectLeaves(positions, parents, leaves, side) {
+    for (const position of positions) {
+      if (!isRecord4(position)) continue;
+      const key = asString4(position.key) ?? "";
+      const nodeSide = asString4(position.side) ?? side;
+      const children = Array.isArray(position.children) ? position.children : [];
+      if (children.length > 0) {
+        _Mapping.collectLeaves(children, [...parents, key], leaves, nodeSide);
+        continue;
+      }
+      const ranges = [];
+      const numbers = [];
+      for (const selector of Array.isArray(position.accounts) ? position.accounts : []) {
+        if (!isRecord4(selector)) continue;
+        if (typeof selector.from === "string" && typeof selector.to === "string") {
+          ranges.push({ from: selector.from, to: selector.to });
+        }
+        for (const number of Array.isArray(selector.numbers) ? selector.numbers : []) {
+          if (typeof number === "string") numbers.push(number);
+        }
+      }
+      leaves.push({
+        key,
+        label: asString4(position.label) ?? key,
+        side: nodeSide,
+        ranges,
+        numbers,
+        includeNonCash: position.includeNonCash === true,
+        includesNetIncome: position.includesNetIncome === true,
+        parents
+      });
+    }
+  }
+  leafFor(accountNumber) {
+    for (const leaf of this.leaves) {
+      if (leafMatches(leaf, accountNumber)) return leaf;
+    }
+    return null;
+  }
+};
+
+// src/projection/balance-sheet.ts
+var BalanceSheetProjection = class {
+  constructor(baseCurrency, accounts, journal, mappings) {
+    this.baseCurrency = baseCurrency;
+    this.accounts = accounts;
+    this.journal = journal;
+    this.mappings = mappings;
+  }
+  baseCurrency;
+  accounts;
+  journal;
+  mappings;
+  compute(params) {
+    const asOf = typeof params.asOf === "string" ? CalendarDate.of(params.asOf) : null;
+    const mappingId = typeof params.mapping === "string" ? params.mapping : "";
+    const mapping = this.mappings.byId(mappingId);
+    if (mapping === null) {
+      throw new DomainError("E_MAPPING_OVERLAP", `Mapping "${mappingId}" ist nicht geladen`);
+    }
+    const zero = Money.zero(this.baseCurrency);
+    const debits = /* @__PURE__ */ new Map();
+    const credits = /* @__PURE__ */ new Map();
+    const touchedAccounts = /* @__PURE__ */ new Set();
+    let netIncome = zero;
+    for (const entry of this.journal.all()) {
+      if (asOf !== null && entry.entryDate.isAfter(asOf)) continue;
+      for (const line of entry.lines()) {
+        const account = this.accounts.byId(line.accountId);
+        if (account === null) continue;
+        if (!isBalanceCarrying(account.type)) {
+          netIncome = line.side === "credit" ? netIncome.add(line.money) : netIncome.subtract(line.money);
+          continue;
+        }
+        const key = account.number.value;
+        if (line.side === "debit") debits.set(key, (debits.get(key) ?? zero).add(line.money));
+        else credits.set(key, (credits.get(key) ?? zero).add(line.money));
+        touchedAccounts.add(key);
+      }
+    }
+    const allNumbers = /* @__PURE__ */ new Set([...debits.keys(), ...credits.keys()]);
+    const sections = { assets: [], liabilitiesAndEquity: [] };
+    const totals = { assets: zero, liabilitiesAndEquity: zero };
+    for (const leaf of mapping.leaves) {
+      const section = leaf.side === "liabilitiesAndEquity" ? "liabilitiesAndEquity" : "assets";
+      let amount = zero;
+      let touched = false;
+      for (const number of allNumbers) {
+        if (!leafMatches(leaf, number)) continue;
+        const debit = debits.get(number) ?? zero;
+        const credit = credits.get(number) ?? zero;
+        amount = section === "assets" ? amount.add(debit).subtract(credit) : amount.add(credit).subtract(debit);
+        touched = touched || touchedAccounts.has(number);
+      }
+      if (leaf.includesNetIncome) {
+        amount = amount.add(netIncome);
+        touched = touched || !netIncome.isZero();
+      }
+      if (amount.isZero() && !touched) continue;
+      sections[section].push({ key: leaf.key, label: leaf.label, amount: amount.amountAsString() });
+      totals[section] = totals[section].add(amount);
+    }
+    return {
+      assets: sections.assets,
+      assetsTotal: totals.assets.amountAsString(),
+      liabilitiesAndEquity: sections.liabilitiesAndEquity,
+      liabilitiesAndEquityTotal: totals.liabilitiesAndEquity.amountAsString()
+    };
+  }
+};
+var NON_PROFIT_SUBTYPES = /* @__PURE__ */ new Set(["bank", "cash", "transit", "ar", "ap"]);
+var CashBasisProjection = class {
+  constructor(baseCurrency, accounts, journal, openItems, vouchers, fiscalYears, mappings) {
+    this.baseCurrency = baseCurrency;
+    this.accounts = accounts;
+    this.journal = journal;
+    this.openItems = openItems;
+    this.vouchers = vouchers;
+    this.fiscalYears = fiscalYears;
+    this.mappings = mappings;
+  }
+  baseCurrency;
+  accounts;
+  journal;
+  openItems;
+  vouchers;
+  fiscalYears;
+  mappings;
+  compute(params) {
+    const year = typeof params.year === "number" ? params.year : 0;
+    const asOf = typeof params.asOf === "string" ? CalendarDate.of(params.asOf) : null;
+    const mapping = typeof params.mapping === "string" ? this.mappings.byId(params.mapping) : null;
+    this.assertCalendarYearFiscalYears(year);
+    const income = /* @__PURE__ */ new Map();
+    const expenses = /* @__PURE__ */ new Map();
+    const addTo = (bucket, label, amount) => {
+      bucket.set(label, (bucket.get(label) ?? Money.zero(this.baseCurrency)).add(amount));
+    };
+    for (const entry of this.journal.all()) {
+      if (asOf !== null && entry.entryDate.isAfter(asOf)) continue;
+      const bankFlow = this.bankFlow(entry);
+      if (bankFlow.isZero()) {
+        if (mapping === null || entry.entryDate.year() !== year) continue;
+        for (const line of entry.lines()) {
+          const account = this.accounts.byId(line.accountId);
+          if (account === null) continue;
+          const leaf = mapping.leafFor(account.number.value);
+          if (leaf === null || !leaf.includeNonCash) continue;
+          if (account.type === "revenue" || account.subtype === "tax_out") {
+            const signed = line.side === "credit" ? line.money : line.money.negate();
+            addTo(income, leaf.label, signed);
+          } else if (account.type === "expense" || account.subtype === "tax_in") {
+            const signed = line.side === "debit" ? line.money : line.money.negate();
+            addTo(expenses, leaf.label, signed);
+          }
+        }
+        continue;
+      }
+      if (this.assignYear(entry) !== year) continue;
+      const inflow = bankFlow.isPositive();
+      for (const sourced of this.sourceLines(entry)) {
+        const account = this.accounts.byId(sourced.line.accountId);
+        if (account === null || account.subtype !== null && NON_PROFIT_SUBTYPES.has(account.subtype)) {
+          continue;
+        }
+        const amount = this.proportional(sourced.line.money, sourced.ratio);
+        if (account.subtype === "tax_out") {
+          addTo(inflow ? income : expenses, inflow ? "Vereinnahmte USt" : "USt-Zahlung an FA", amount);
+        } else if (account.subtype === "tax_in") {
+          addTo(expenses, "Gezahlte Vorsteuer", amount);
+        } else if (account.type === "revenue") {
+          addTo(income, this.label(mapping, account), amount);
+        } else if (account.type === "expense") {
+          addTo(expenses, this.label(mapping, account), amount);
+        }
+      }
+    }
+    return { income: this.serializeBucket(income), expenses: this.serializeBucket(expenses) };
+  }
+  assertCalendarYearFiscalYears(year) {
+    const y = String(year).padStart(4, "0");
+    const start = CalendarDate.of(`${y}-01-01`);
+    const end = CalendarDate.of(`${y}-12-31`);
+    for (const fiscalYear of this.fiscalYears.all()) {
+      const overlaps = !fiscalYear.end.isBefore(start) && !fiscalYear.start.isAfter(end);
+      if (!overlaps) continue;
+      const isCalendarYear = fiscalYear.start.iso.slice(5) === "01-01" && fiscalYear.end.iso.slice(5) === "12-31";
+      if (!isCalendarYear) {
+        throw new DomainError(
+          "E_CASHBASIS_DEVIATING_FISCAL_YEAR",
+          `Gesch\xE4ftsjahr ${fiscalYear.year} (${fiscalYear.start.iso} bis ${fiscalYear.end.iso}) weicht vom Kalenderjahr ab \u2014 E\xDCR ist kalenderjahrgebunden`,
+          { fiscalYear: fiscalYear.year }
+        );
+      }
+    }
+  }
+  bankFlow(entry) {
+    let flow = Money.zero(this.baseCurrency);
+    for (const line of entry.lines()) {
+      const account = this.accounts.byId(line.accountId);
+      const subtype = account?.subtype ?? null;
+      if (subtype !== "bank" && subtype !== "cash") continue;
+      flow = line.side === "debit" ? flow.add(line.money) : flow.subtract(line.money);
+    }
+    return flow;
+  }
+  assignYear(entry) {
+    const voucher = this.vouchers.byId(entry.voucherId);
+    if (voucher !== null && voucher.recurring && voucher.economicYear !== null && voucher.due !== null && this.inTenDayWindow(entry.entryDate) && this.inTenDayWindow(voucher.due)) {
+      return voucher.economicYear;
+    }
+    return entry.entryDate.year();
+  }
+  inTenDayWindow(date) {
+    const month = date.month();
+    const day = Number(date.iso.slice(8, 10));
+    return month === 12 && day >= 22 || month === 1 && day <= 10;
+  }
+  sourceLines(entry) {
+    const sourced = [];
+    for (const item of this.openItems.all()) {
+      for (const settlement of item.settlements()) {
+        if (!settlement.entryId.equals(entry.id)) continue;
+        const origin = this.journal.byId(item.originEntryId);
+        if (origin === null || item.money.isZero()) continue;
+        const ratio = new Big(settlement.money.amountAsString()).div(new Big(item.money.amountAsString()));
+        for (const line of origin.lines()) sourced.push({ line, ratio });
+      }
+    }
+    if (sourced.length > 0) return sourced;
+    const one = new Big(1);
+    for (const line of entry.lines()) sourced.push({ line, ratio: one });
+    return sourced;
+  }
+  proportional(amount, ratio) {
+    if (ratio.eq(1)) return amount.abs();
+    return Money.fromCalculation(new Big(amount.abs().amountAsString()).times(ratio), this.baseCurrency);
+  }
+  label(mapping, account) {
+    if (mapping !== null) {
+      const leaf = mapping.leafFor(account.number.value);
+      if (leaf !== null) return leaf.label;
+    }
+    return account.name;
+  }
+  serializeBucket(bucket) {
+    const labels = [...bucket.keys()].sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+    const rows = [];
+    for (const label of labels) {
+      const amount = bucket.get(label);
+      if (amount.isZero()) continue;
+      rows.push({ category: label, amount: amount.amountAsString() });
+    }
+    return rows;
+  }
+};
+
+// src/projection/asset-register.ts
+var AssetRegisterProjection = class {
+  constructor(assets) {
+    this.assets = assets;
+  }
+  assets;
+  compute(params) {
+    const asOf = typeof params.asOf === "string" ? CalendarDate.of(params.asOf) : null;
+    const sorted = [...this.assets.all()].sort((a, b) => {
+      const byDate = a.acquiredOn.compareTo(b.acquiredOn);
+      return byDate !== 0 ? byDate : a.id.compareTo(b.id);
+    });
+    const rows = [];
+    for (const asset of sorted) {
+      if (asOf !== null && asset.acquiredOn.isAfter(asOf)) continue;
+      const row = asset.toJSON();
+      row.accumulatedDepreciation = asset.accumulatedDepreciationAt(asOf).toJSON();
+      row.bookValue = asset.bookValueAt(asOf).toJSON();
+      if (asset.route === "capitalize") row.depreciationSchedule = asset.scheduleSummary();
+      rows.push(row);
+    }
+    return { assets: rows };
+  }
+};
+var FORMAT_VERSION = "0.4";
+var LINE_FIELDS = ["accountId", "side", "money", "dimensions", "taxTag"];
+function withoutNulls(row) {
+  return Object.fromEntries(Object.entries(row).filter(([, value]) => value !== null));
+}
+var JournalExportProjection = class _JournalExportProjection {
+  constructor(tenantId, tenantName, baseCurrency, journal, accounts, vouchers, partners, audit, clock) {
+    this.tenantId = tenantId;
+    this.tenantName = tenantName;
+    this.baseCurrency = baseCurrency;
+    this.journal = journal;
+    this.accounts = accounts;
+    this.vouchers = vouchers;
+    this.partners = partners;
+    this.audit = audit;
+    this.clock = clock;
+  }
+  tenantId;
+  tenantName;
+  baseCurrency;
+  journal;
+  accounts;
+  vouchers;
+  partners;
+  audit;
+  clock;
+  compute(params) {
+    const fiscalYear = typeof params.fiscalYear === "number" ? params.fiscalYear : null;
+    const entries = fiscalYear === null ? this.journal.all() : this.journal.forFiscalYear(fiscalYear);
+    const streams = {
+      journal: entries.map((entry) => _JournalExportProjection.formatEntry(entry)),
+      accounts: this.accounts.all().map((account) => withoutNulls(account.toJSON())),
+      vouchers: this.vouchers.all().map((voucher) => withoutNulls(voucher.toJSON()))
+    };
+    if (this.partners.all().length > 0) {
+      streams.partners = this.partners.all().map((partner) => partner.toJSON());
+    }
+    streams.auditLog = this.audit.all().map((record) => record.toJSON());
+    const contentHashes = {};
+    for (const [name, rows] of Object.entries(streams)) {
+      const lines = rows.map((row) => canonicalJson(row));
+      contentHashes[name] = createHash("sha256").update(lines.join("\n")).digest("hex");
+    }
+    const allFinalized = entries.every((entry) => entry.isFinalized());
+    return {
+      manifest: {
+        formatVersion: FORMAT_VERSION,
+        tenantId: this.tenantId.value,
+        tenantName: this.tenantName,
+        baseCurrency: this.baseCurrency.code,
+        exportedAt: this.clock.now().toISOString(),
+        hashAlgorithm: "sha256",
+        streams: Object.keys(streams),
+        contentHashes
+      },
+      fieldCatalogIncluded: true,
+      fieldCatalog: this.fieldCatalog(),
+      journal: { entryCount: entries.length, ordering: "sequenceNumber", allFinalized },
+      data: streams
+    };
+  }
+  static formatEntry(entry) {
+    const data = entry.toJSON();
+    const lines = Array.isArray(data.lines) ? data.lines : [];
+    data.lines = lines.map((line) => {
+      const source = line;
+      const stripped = {};
+      for (const field of LINE_FIELDS) stripped[field] = source[field];
+      return stripped;
+    });
+    return data;
+  }
+  fieldCatalog() {
+    return {
+      journal: [
+        { name: "id", type: "uuid", meaning: "Eindeutige Buchungs-ID (UUIDv7)" },
+        { name: "sequenceNumber", type: "integer", meaning: "L\xFCckenlose Journalnummer je Gesch\xE4ftsjahr" },
+        { name: "status", type: "string", meaning: "entered|finalized (Festschreibung)" },
+        { name: "entryDate", type: "date", meaning: "Buchungsdatum (zonenlos)" },
+        { name: "recordedAt", type: "timestamp", meaning: "Erfassungszeitpunkt" },
+        { name: "periodRef", type: "object", meaning: "Gesch\xE4ftsjahr + Periode" },
+        { name: "voucherId", type: "uuid", meaning: "Belegreferenz (Pflicht)" },
+        { name: "text", type: "string", meaning: "Buchungstext" },
+        { name: "lines", type: "array", meaning: "Positionen: Konto, Seite, Betrag, Dimensionen, Steuer-Tag" },
+        { name: "reverses", type: "uuid|null", meaning: "R\xFCckverweis bei Storno (Generalumkehr)" },
+        { name: "reversedBy", type: "uuid|null", meaning: "Verweis auf die Stornobuchung" }
+      ],
+      accounts: [
+        { name: "number", type: "string", meaning: "Kontonummer (f\xFChrende Nullen signifikant)" },
+        { name: "name", type: "string", meaning: "Kontobezeichnung" },
+        { name: "type", type: "string", meaning: "asset|liability|equity|expense|revenue" },
+        { name: "subtype", type: "string|null", meaning: "Kanonischer Subtyp (bank, ar, ap, \u2026)" }
+      ],
+      vouchers: [
+        { name: "voucherNumber", type: "string", meaning: "Belegnummer" },
+        { name: "voucherDate", type: "date", meaning: "Belegdatum" }
+      ],
+      auditLog: [
+        { name: "at", type: "timestamp", meaning: "\xC4nderungszeitpunkt" },
+        { name: "actor", type: "string", meaning: "Audit-Identit\xE4t" },
+        { name: "action", type: "string", meaning: "created|corrected|finalized|locked|\u2026" },
+        { name: "changes", type: "object", meaning: "Vorher/Nachher-Diff der ge\xE4nderten Felder" }
+      ]
+    };
+  }
+};
+
+// src/projection/datev-export.ts
+var TAX_SUBTYPES = /* @__PURE__ */ new Set(["tax_in", "tax_out"]);
+function pad2(value) {
+  return String(value).padStart(2, "0");
+}
+function tagCode(line) {
+  const code = line.taxTag?.code;
+  return typeof code === "string" ? code : null;
+}
+var DatevExportProjection = class {
+  constructor(journal, accounts, vouchers, partners, registry) {
+    this.journal = journal;
+    this.accounts = accounts;
+    this.vouchers = vouchers;
+    this.partners = partners;
+    this.registry = registry;
+  }
+  journal;
+  accounts;
+  vouchers;
+  partners;
+  registry;
+  compute(params) {
+    const kind = typeof params.kind === "string" ? params.kind : "entries";
+    const rows = kind === "accounts" ? this.accountRows() : kind === "partners" ? this.partnerRows() : this.entryRows(params);
+    return { kind, rows, rowCount: rows.length };
+  }
+  entryRows(params) {
+    const fiscalYear = typeof params.fiscalYear === "number" ? params.fiscalYear : null;
+    const fromPeriod = typeof params.fromPeriod === "number" ? params.fromPeriod : 1;
+    const throughPeriod = typeof params.throughPeriod === "number" ? params.throughPeriod : Number.MAX_SAFE_INTEGER;
+    const entries = fiscalYear === null ? this.journal.all() : this.journal.forFiscalYear(fiscalYear);
+    const rows = [];
+    for (const entry of entries) {
+      const period = entry.periodRef.period;
+      if (period < fromPeriod || period > throughPeriod) continue;
+      rows.push(...this.splitEntry(entry));
+    }
+    return rows;
+  }
+  splitEntry(entry) {
+    let lead = null;
+    const contraLines = [];
+    const taxLines = [];
+    for (const line of entry.lines()) {
+      const account = this.accounts.byId(line.accountId);
+      const isTaxLine = account?.subtype != null && TAX_SUBTYPES.has(account.subtype) && line.taxTag !== null;
+      if (isTaxLine) {
+        taxLines.push(line);
+        continue;
+      }
+      if (lead === null && line.taxTag === null) {
+        lead = line;
+        continue;
+      }
+      contraLines.push(line);
+    }
+    if (lead === null || contraLines.length === 0) return [];
+    const voucher = this.vouchers.byId(entry.voucherId);
+    const rows = [];
+    for (const contra of contraLines) {
+      let gross = contra.money;
+      let buKey = null;
+      const contraCode = tagCode(contra);
+      if (contraCode !== null) {
+        buKey = this.registry.datevBuFor(contraCode);
+        for (const taxLine of taxLines) {
+          if (tagCode(taxLine) === contraCode) gross = gross.add(taxLine.money);
+        }
+      }
+      rows.push({
+        amount: gross.abs().amountAsString(),
+        debitCredit: lead.side === "debit" ? "S" : "H",
+        account: lead.account.value,
+        contraAccount: contra.account.value,
+        buKey,
+        documentField1: voucher === null ? "" : voucher.voucherNumber,
+        date: `${pad2(entry.entryDate.month())}${pad2(Number(entry.entryDate.iso.slice(8, 10)))}`,
+        text: entry.text(),
+        finalized: entry.isFinalized()
+      });
+    }
+    return rows;
+  }
+  accountRows() {
+    return this.accounts.all().map((account) => ({
+      number: account.number.value,
+      name: account.name,
+      type: account.type
+    }));
+  }
+  partnerRows() {
+    return this.partners.all().map((partner) => partner.toJSON());
+  }
+};
+
+// src/mapping/mapping-registry.ts
+function isRecord5(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+var MappingRegistry = class _MappingRegistry {
+  byIdMap = /* @__PURE__ */ new Map();
+  static empty() {
+    return new _MappingRegistry();
+  }
+  static fromRuleModules(raw) {
+    const registry = new _MappingRegistry();
+    for (const mappingData of raw) {
+      if (isRecord5(mappingData)) registry.add(Mapping.fromData(mappingData));
+    }
+    return registry;
+  }
+  add(mapping) {
+    this.byIdMap.set(mapping.id, mapping);
+  }
+  byId(id) {
+    return this.byIdMap.get(id) ?? null;
+  }
+};
+
+// src/mapping/mapping-importer.ts
+function isRecord6(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+var MappingImporter = class {
+  constructor(accounts, registry) {
+    this.accounts = accounts;
+    this.registry = registry;
+  }
+  accounts;
+  registry;
+  import(input) {
+    const data = isRecord6(input.mapping) ? input.mapping : {};
+    const mapping = Mapping.fromData(data);
+    const gapWarnings = [];
+    for (const account of this.relevantAccounts(mapping.kind)) {
+      const matches = mapping.leaves.filter((leaf) => leafMatches(leaf, account.number.value)).map((leaf) => leaf.key);
+      if (matches.length > 1) {
+        throw new DomainError(
+          "E_MAPPING_OVERLAP",
+          `Konto ${account.number.value} f\xE4llt in mehrere Positionen: ${matches.join(", ")}`,
+          { account: account.number.value, positions: matches }
+        );
+      }
+      if (matches.length === 0) {
+        gapWarnings.push({ account: account.number.value, assignedTo: "_unassigned" });
+      }
+    }
+    this.registry.add(mapping);
+    return { imported: true, id: mapping.id, kind: mapping.kind, gapWarnings };
+  }
+  relevantAccounts(kind) {
+    return this.accounts.all().filter((account) => {
+      if (kind === "balance-sheet") return isBalanceCarrying(account.type);
+      if (kind === "income-statement") return !isBalanceCarrying(account.type);
+      return false;
+    });
+  }
+};
+
+// src/tax/tax-code.ts
+var TaxCode = class {
+  constructor(code, versions, datevBu = null) {
+    this.code = code;
+    this.versions = versions;
+    this.datevBu = datevBu;
+  }
+  code;
+  versions;
+  datevBu;
+  versionFor(date) {
+    for (const version of this.versions) {
+      if (version.coversDate(date)) return version;
+    }
+    throw new DomainError(
+      "E_TAXCODE_NO_VALID_VERSION",
+      `Steuerschl\xFCssel ${this.code} hat keine zum ${date.iso} g\xFCltige Regelversion`,
+      { code: this.code, date: date.iso }
+    );
+  }
+};
+
+// src/tax/tax-code-version.ts
+var TaxCodeVersion = class {
+  constructor(validFrom, validTo, rate, taxAccount, reportingKey, mechanism = "standard", inputTaxAccount = null, inputReportingKey = null, baseReportingKey = null) {
+    this.validFrom = validFrom;
+    this.validTo = validTo;
+    this.rate = rate;
+    this.taxAccount = taxAccount;
+    this.reportingKey = reportingKey;
+    this.mechanism = mechanism;
+    this.inputTaxAccount = inputTaxAccount;
+    this.inputReportingKey = inputReportingKey;
+    this.baseReportingKey = baseReportingKey;
+  }
+  validFrom;
+  validTo;
+  rate;
+  taxAccount;
+  reportingKey;
+  mechanism;
+  inputTaxAccount;
+  inputReportingKey;
+  baseReportingKey;
+  coversDate(date) {
+    if (date.isBefore(this.validFrom)) return false;
+    return this.validTo === null || !date.isAfter(this.validTo);
+  }
+};
+
+// src/tax/tax-code-registry.ts
+function asString5(value) {
+  return typeof value === "string" ? value : null;
+}
+var TaxCodeRegistry = class _TaxCodeRegistry {
+  constructor(codes) {
+    this.codes = codes;
+  }
+  codes;
+  static empty() {
+    return new _TaxCodeRegistry(/* @__PURE__ */ new Map());
+  }
+  static fromData(data) {
+    const codes = /* @__PURE__ */ new Map();
+    for (const codeData of data) {
+      const code = asString5(codeData.code) ?? "";
+      const rawVersions = Array.isArray(codeData.versions) ? codeData.versions : [];
+      const versions = [];
+      for (const versionData of rawVersions) {
+        if (versionData === null || typeof versionData !== "object") continue;
+        const v = versionData;
+        versions.push(
+          new TaxCodeVersion(
+            CalendarDate.of(asString5(v.validFrom) ?? ""),
+            typeof v.validTo === "string" ? CalendarDate.of(v.validTo) : null,
+            asString5(v.rate) ?? "0",
+            asString5(v.taxAccount) ?? "",
+            asString5(v.reportingKey),
+            asString5(v.mechanism) ?? "standard",
+            asString5(v.inputTaxAccount),
+            asString5(v.inputReportingKey),
+            asString5(v.baseReportingKey)
+          )
+        );
+      }
+      codes.set(code, new TaxCode(code, versions, asString5(codeData.datevBu)));
+    }
+    return new _TaxCodeRegistry(codes);
+  }
+  allVersions() {
+    const versions = [];
+    for (const code of this.codes.values()) versions.push(...code.versions);
+    return versions;
+  }
+  datevBuFor(code) {
+    return this.codes.get(code)?.datevBu ?? null;
+  }
+  get(code) {
+    const found = this.codes.get(code);
+    if (found === void 0) {
+      throw new DomainError("E_TAXCODE_UNKNOWN", `Steuerschl\xFCssel "${code}" ist nicht definiert`, { code });
+    }
+    return found;
+  }
+  versionFor(code, date) {
+    return this.get(code).versionFor(date);
+  }
+};
+
+// src/tax/tax-profile.ts
+var TaxProfile = class _TaxProfile {
+  constructor(method, smallBusiness, period) {
+    this.method = method;
+    this.smallBusiness = smallBusiness;
+    this.period = period;
+  }
+  method;
+  smallBusiness;
+  period;
+  static fromData(data) {
+    const method = data.taxationMethod === "cash" ? "cash" : "accrual";
+    const period = data.vatPeriod === "monthly" ? "monthly" : "quarterly";
+    const segments = [];
+    const smallBusiness = data.smallBusiness ?? false;
+    if (typeof smallBusiness === "boolean") {
+      if (smallBusiness) segments.push({ validFrom: CalendarDate.of("0001-01-01"), value: true });
+    } else if (Array.isArray(smallBusiness)) {
+      for (const segment of smallBusiness) {
+        if (segment === null || typeof segment !== "object") continue;
+        const s = segment;
+        if (typeof s.validFrom !== "string") continue;
+        segments.push({ validFrom: CalendarDate.of(s.validFrom), value: s.value === true });
+      }
+    }
+    return new _TaxProfile(method, _TaxProfile.sorted(segments), period);
+  }
+  static default() {
+    return new _TaxProfile("accrual", [], "quarterly");
+  }
+  taxationMethod() {
+    return this.method;
+  }
+  isCashBasis() {
+    return this.method === "cash";
+  }
+  vatPeriod() {
+    return this.period;
+  }
+  smallBusinessAt(date) {
+    let value = false;
+    for (const segment of this.smallBusiness) {
+      if (segment.validFrom.isAfter(date)) break;
+      value = segment.value;
+    }
+    return value;
+  }
+  setSmallBusiness(validFrom, value) {
+    const segments = this.smallBusiness.filter((segment) => !segment.validFrom.equals(validFrom));
+    segments.push({ validFrom, value });
+    this.smallBusiness = _TaxProfile.sorted(segments);
+  }
+  static sorted(segments) {
+    return [...segments].sort((a, b) => a.validFrom.compareTo(b.validFrom));
+  }
+  toJSON() {
+    return {
+      taxationMethod: this.method,
+      vatPeriod: this.period,
+      smallBusiness: this.smallBusiness.map((segment) => ({
+        validFrom: segment.validFrom.iso,
+        value: segment.value
+      }))
+    };
+  }
+};
+function isRecord7(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function asString6(value) {
+  return typeof value === "string" ? value : null;
+}
+var TaxService = class {
+  constructor(baseCurrency, registry, profileValue, journal) {
+    this.baseCurrency = baseCurrency;
+    this.registry = registry;
+    this.profileValue = profileValue;
+    this.journal = journal;
+  }
+  baseCurrency;
+  registry;
+  profileValue;
+  journal;
+  profile() {
+    return this.profileValue;
+  }
+  registryHandle() {
+    return this.registry;
+  }
+  expand(input) {
+    const date = typeof input.serviceDate === "string" ? this.parseDate(input.serviceDate) : this.parseDate(input.date);
+    const direction = input.direction === "input" ? "input" : "output";
+    const defaultCode = asString6(input.taxCode);
+    const rawLines = Array.isArray(input.netLines) ? input.netLines : [];
+    if (rawLines.length === 0) {
+      throw new DomainError("E_ENTRY_TOO_FEW_LINES", "expandTax ohne Netto-Positionen");
+    }
+    const netLines = rawLines.map((rawLine) => {
+      if (!isRecord7(rawLine)) {
+        throw new DomainError("E_ENTRY_INVALID_AMOUNT", "Netto-Position ist keine Struktur");
+      }
+      const code = asString6(rawLine.taxCode) ?? defaultCode;
+      if (code === null) {
+        throw new DomainError("E_TAXCODE_UNKNOWN", "Position ohne Steuerschl\xFCssel (kein Default gesetzt)");
+      }
+      return { account: asString6(rawLine.account) ?? "", money: this.parseMoney(rawLine.money), code };
+    });
+    for (const line of netLines) this.registry.get(line.code);
+    const versions = /* @__PURE__ */ new Map();
+    const bases = /* @__PURE__ */ new Map();
+    for (const line of netLines) {
+      if (!versions.has(line.code)) versions.set(line.code, this.registry.versionFor(line.code, date));
+      bases.set(line.code, (bases.get(line.code) ?? Money.zero(this.baseCurrency)).add(line.money));
+    }
+    let netTotal = Money.zero(this.baseCurrency);
+    for (const line of netLines) netTotal = netTotal.add(line.money);
+    const sideFor = direction === "output" ? "credit" : "debit";
+    if (this.profileValue.smallBusinessAt(date)) {
+      return {
+        netLines: netLines.map((line) => ({
+          account: line.account,
+          side: sideFor,
+          money: line.money.toJSON(),
+          taxTag: null
+        })),
+        taxLines: [],
+        grossTotal: netTotal.toJSON()
+      };
+    }
+    const codes = [...bases.keys()].sort((a, b) => {
+      const aa = versions.get(a).taxAccount;
+      const bb = versions.get(b).taxAccount;
+      return aa < bb ? -1 : aa > bb ? 1 : 0;
+    });
+    const taxLines = [];
+    let grossTotal = netTotal;
+    const baseTags = /* @__PURE__ */ new Map();
+    for (const code of codes) {
+      const version = versions.get(code);
+      const base = bases.get(code);
+      const tax = Money.fromCalculation(
+        new Big(base.amountAsString()).times(version.rate).div(100),
+        this.baseCurrency
+      );
+      if (version.mechanism === "intra_community_supply") {
+        baseTags.set(code, this.tag(code, version, version.reportingKey, base));
+        continue;
+      }
+      if (version.mechanism === "reverse_charge") {
+        taxLines.push({
+          account: version.taxAccount,
+          side: "credit",
+          money: tax.toJSON(),
+          taxTag: this.tag(code, version, version.reportingKey, base)
+        });
+        taxLines.push({
+          account: version.inputTaxAccount ?? version.taxAccount,
+          side: "debit",
+          money: tax.toJSON(),
+          taxTag: this.tag(code, version, version.inputReportingKey, base)
+        });
+        baseTags.set(code, this.tag(code, version, version.baseReportingKey ?? version.reportingKey, base));
+      } else {
+        taxLines.push({
+          account: version.taxAccount,
+          side: sideFor,
+          money: tax.toJSON(),
+          taxTag: this.tag(code, version, version.reportingKey, base)
+        });
+        baseTags.set(code, this.tag(code, version, version.reportingKey, base));
+        grossTotal = grossTotal.add(tax);
+      }
+    }
+    return {
+      netLines: netLines.map((line) => ({
+        account: line.account,
+        side: sideFor,
+        money: line.money.toJSON(),
+        taxTag: baseTags.get(line.code) ?? null
+      })),
+      taxLines,
+      grossTotal: grossTotal.toJSON()
+    };
+  }
+  setProfile(input) {
+    const smallBusiness = input.smallBusiness;
+    if (!isRecord7(smallBusiness) || typeof smallBusiness.validFrom !== "string") {
+      throw new DomainError("E_PROFILE_RETROACTIVE_CONFLICT", "setTaxProfile braucht smallBusiness.validFrom");
+    }
+    const validFrom = this.parseDate(smallBusiness.validFrom);
+    for (const entry of this.journal.all()) {
+      if (entry.isFinalized() && !entry.entryDate.isBefore(validFrom)) {
+        throw new DomainError(
+          "E_PROFILE_RETROACTIVE_CONFLICT",
+          `Zeitraum ab ${validFrom.iso} enth\xE4lt festgeschriebene Buchungen (z. B. Nr. ${entry.sequenceNumber})`,
+          { validFrom: validFrom.iso, sequenceNumber: entry.sequenceNumber }
+        );
+      }
+    }
+    this.profileValue.setSmallBusiness(validFrom, smallBusiness.value === true);
+    return this.profileValue;
+  }
+  tag(code, version, reportingKey, base) {
+    return {
+      code,
+      appliedVersion: version.validFrom.iso,
+      reportingKey,
+      baseMoney: base.toJSON()
+    };
+  }
+  parseDate(date) {
+    try {
+      return CalendarDate.of(typeof date === "string" ? date : "");
+    } catch (error) {
+      if (error instanceof InvalidValue) {
+        throw new DomainError("E_TAXCODE_NO_VALID_VERSION", "Belegdatum fehlt oder ung\xFCltig");
+      }
+      throw error;
+    }
+  }
+  parseMoney(raw) {
+    const amount = isRecord7(raw) ? asString6(raw.amount) : null;
+    if (amount === null) {
+      throw new DomainError("E_ENTRY_INVALID_AMOUNT", "Netto-Position ohne Betrag");
+    }
+    try {
+      return Money.of(amount, this.baseCurrency);
+    } catch (error) {
+      if (error instanceof InvalidValue) {
+        throw new DomainError("E_ENTRY_INVALID_AMOUNT", `Ung\xFCltiger Betrag "${amount}"`);
+      }
+      throw error;
+    }
+  }
+};
+
+// src/composition/tenant.ts
+var Tenant = class _Tenant {
+  constructor(id, name, baseCurrency, accounts, fiscalYears, vouchers, journal, openItems, assets, partners, audit, ledger, tax, assetService, costing, partnerService, mappings, clock, ids) {
+    this.id = id;
+    this.name = name;
+    this.baseCurrency = baseCurrency;
+    this.accounts = accounts;
+    this.fiscalYears = fiscalYears;
+    this.vouchers = vouchers;
+    this.journal = journal;
+    this.openItems = openItems;
+    this.assets = assets;
+    this.partners = partners;
+    this.audit = audit;
+    this.ledger = ledger;
+    this.tax = tax;
+    this.assetService = assetService;
+    this.costing = costing;
+    this.partnerService = partnerService;
+    this.mappings = mappings;
+    this.clock = clock;
+    this.ids = ids;
+  }
+  id;
+  name;
+  baseCurrency;
+  accounts;
+  fiscalYears;
+  vouchers;
+  journal;
+  openItems;
+  assets;
+  partners;
+  audit;
+  ledger;
+  tax;
+  assetService;
+  costing;
+  partnerService;
+  mappings;
+  clock;
+  ids;
+  static inMemory(name, baseCurrency, clock = new SystemClock(), ids, dimensions = DimensionRegistry.empty(), taxCodes = TaxCodeRegistry.empty(), taxProfile = TaxProfile.default(), mappings = MappingRegistry.empty()) {
+    const idGen = ids ?? new UuidV7IdGenerator(clock);
+    const accounts = new InMemoryAccountRepository();
+    const fiscalYears = new InMemoryFiscalYearRepository();
+    const vouchers = new InMemoryVoucherRepository();
+    const journal = new InMemoryJournalRepository();
+    const openItems = new InMemoryOpenItemRepository();
+    const assets = new InMemoryAssetRepository();
+    const partners = new InMemoryPartnerRepository();
+    const audit = new InMemoryAuditTrail();
+    const ledger = new Ledger(
+      baseCurrency,
+      accounts,
+      fiscalYears,
+      vouchers,
+      journal,
+      openItems,
+      audit,
+      dimensions,
+      clock,
+      idGen
+    );
+    const tax = new TaxService(baseCurrency, taxCodes, taxProfile, journal);
+    const assetService = new AssetService(baseCurrency, assets, fiscalYears, vouchers, ledger, idGen);
+    const costing = new CostingService(baseCurrency, accounts, journal, idGen);
+    const partnerService = new PartnerService(partners, audit, clock, idGen);
+    return new _Tenant(
+      idGen.next(),
+      name,
+      baseCurrency,
+      accounts,
+      fiscalYears,
+      vouchers,
+      journal,
+      openItems,
+      assets,
+      partners,
+      audit,
+      ledger,
+      tax,
+      assetService,
+      costing,
+      partnerService,
+      mappings,
+      clock,
+      idGen
+    );
+  }
+};
+
+// src/composition/post-voucher-service.ts
+function isRecord8(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function asString7(value) {
+  return typeof value === "string" ? value : null;
+}
+var PostVoucherService = class {
+  constructor(tenant) {
+    this.tenant = tenant;
+  }
+  tenant;
+  post(input) {
+    const voucherData = isRecord8(input.voucher) ? input.voucher : {};
+    const voucherNumber = asString7(voucherData.voucherNumber) ?? "";
+    let voucherDate;
+    try {
+      voucherDate = CalendarDate.of(asString7(voucherData.voucherDate) ?? "");
+    } catch (error) {
+      if (error instanceof InvalidValue) {
+        throw new DomainError("E_ENTRY_NO_VOUCHER", "postVoucher braucht voucher.voucherDate");
+      }
+      throw error;
+    }
+    let partnerId = null;
+    if (voucherData.partnerId !== void 0 && voucherData.partnerId !== null) {
+      partnerId = this.tenant.partnerService.require(voucherData.partnerId).id;
+    }
+    const date = (value) => typeof value === "string" ? CalendarDate.of(value) : null;
+    const servicePeriod = isRecord8(voucherData.servicePeriod) ? voucherData.servicePeriod : {};
+    const voucher = new Voucher({
+      id: this.tenant.ids.next(),
+      voucherNumber,
+      voucherDate,
+      due: date(voucherData.due),
+      recurring: voucherData.recurring === true,
+      economicYear: typeof voucherData.economicYear === "number" ? voucherData.economicYear : null,
+      serviceDate: date(voucherData.serviceDate),
+      servicePeriodFrom: date(servicePeriod.from),
+      servicePeriodTo: date(servicePeriod.to),
+      kind: asString7(voucherData.kind),
+      partnerId,
+      issuer: asString7(voucherData.issuer)
+    });
+    this.tenant.vouchers.add(voucher);
+    const expansion = this.tenant.tax.expand({
+      date: voucherDate.iso,
+      serviceDate: voucher.taxDate().iso,
+      taxCode: input.taxCode ?? null,
+      direction: input.direction ?? "output",
+      netLines: input.netLines ?? []
+    });
+    const direction = input.direction === "input" ? "input" : "output";
+    const counterAccount = asString7(input.counterAccount) ?? "";
+    const netLines = Array.isArray(expansion.netLines) ? expansion.netLines : [];
+    const taxLines = Array.isArray(expansion.taxLines) ? expansion.taxLines : [];
+    const lines = [
+      {
+        account: counterAccount,
+        side: direction === "output" ? "debit" : "credit",
+        money: expansion.grossTotal
+      },
+      ...netLines,
+      ...taxLines
+    ];
+    const result = this.tenant.ledger.post({
+      actor: input.actor ?? null,
+      entryDate: input.entryDate ?? voucherDate.iso,
+      voucherId: voucher.id.value,
+      text: input.text ?? "",
+      lines
+    });
+    return {
+      entry: JSON.parse(JSON.stringify(result.entry)),
+      openItemsCreated: result.openItemsCreated.map((item) => JSON.parse(JSON.stringify(item))),
+      grossTotal: expansion.grossTotal,
+      taxLines: expansion.taxLines,
+      voucherId: voucher.id.value
+    };
+  }
+};
+
+// src/composition/tenant-operations.ts
+function serialize(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+var TenantOperations = class {
+  constructor(tenant) {
+    this.tenant = tenant;
+  }
+  tenant;
+  execute(op, input) {
+    const ledger = this.tenant.ledger;
+    switch (op) {
+      case "expandTax":
+        return this.tenant.tax.expand(input);
+      case "setTaxProfile":
+        return serialize(this.tenant.tax.setProfile(input));
+      case "postVoucher":
+        return new PostVoucherService(this.tenant).post(input);
+      case "post": {
+        const result = ledger.post(input);
+        return {
+          ...serialize(result.entry),
+          openItemsCreated: result.openItemsCreated.map((item) => serialize(item))
+        };
+      }
+      case "correct":
+        return serialize(ledger.correct(input));
+      case "settle":
+        return { openItems: ledger.settle(input).map((item) => serialize(item)) };
+      case "finalize":
+        return { finalizedCount: ledger.finalize(input) };
+      case "reverse":
+        return serialize(ledger.reverse(input));
+      case "closePeriod":
+        return ledger.closePeriod(input);
+      case "reopenPeriod":
+        return ledger.reopenPeriod(input);
+      case "closeFiscalYear":
+        return { fiscalYear: ledger.closeFiscalYear(input).year, status: "closed" };
+      case "createAccount":
+        return serialize(ledger.createAccount(input));
+      case "createFiscalYear": {
+        const fiscalYear = ledger.createFiscalYear(input);
+        return { year: fiscalYear.year, periodCount: fiscalYear.periods().length };
+      }
+      case "lockAccount":
+        return serialize(ledger.lockAccount(input));
+      case "importChartOfAccounts":
+        return { importedCount: ledger.importChartOfAccounts(input) };
+      case "importMapping":
+        return new MappingImporter(this.tenant.accounts, this.tenant.mappings).import(input);
+      case "createPartner":
+        return serialize(this.tenant.partnerService.create(input));
+      case "updatePartner":
+        return serialize(this.tenant.partnerService.update(input));
+      case "acquireAsset":
+        return this.tenant.assetService.acquire(input);
+      case "disposeAsset":
+        return this.tenant.assetService.dispose(input);
+      case "runDepreciation":
+        return this.tenant.assetService.runDepreciation(input);
+      case "setAllocationScheme":
+        return this.tenant.costing.setAllocationScheme(input);
+      case "runCosting": {
+        const run = this.tenant.costing.run(input);
+        return { runId: run.id.value, status: run.status(), version: run.version };
+      }
+      case "releaseCosting": {
+        const released = this.tenant.costing.release(input);
+        return { runId: released.id.value, status: released.status() };
+      }
+      default:
+        throw new DomainError("E_NOT_IMPLEMENTED", `Operation "${op}" ist nicht definiert`);
+    }
+  }
+  project(name, params) {
+    const tenant = this.tenant;
+    switch (name) {
+      case "trialBalance":
+        return new TrialBalanceProjection(tenant.baseCurrency, tenant.accounts, tenant.journal).compute(params);
+      case "openItems":
+        return new OpenItemsProjection(tenant.openItems, tenant.vouchers, tenant.journal).compute(params);
+      case "accountSheet":
+        return new AccountSheetProjection(tenant.baseCurrency, tenant.accounts, tenant.journal).compute(params);
+      case "auditLog":
+        return new AuditLogProjection(tenant.audit).compute(params);
+      case "assetRegister":
+        return new AssetRegisterProjection(tenant.assets).compute(params);
+      case "costAllocationSheet":
+        return tenant.costing.costAllocationSheet(params);
+      case "ecSalesList":
+        return new EcSalesListProjection(
+          tenant.baseCurrency,
+          tenant.journal,
+          tenant.vouchers,
+          tenant.partners,
+          tenant.tax.registryHandle()
+        ).compute(params);
+      case "incomeStatement":
+        return new IncomeStatementProjection(
+          tenant.baseCurrency,
+          tenant.accounts,
+          tenant.journal,
+          tenant.mappings
+        ).compute(params);
+      case "balanceSheet":
+        return new BalanceSheetProjection(
+          tenant.baseCurrency,
+          tenant.accounts,
+          tenant.journal,
+          tenant.mappings
+        ).compute(params);
+      case "vatReturn":
+        return new VatReturnProjection(
+          tenant.baseCurrency,
+          tenant.journal,
+          tenant.openItems,
+          tenant.vouchers,
+          tenant.accounts,
+          tenant.tax.registryHandle(),
+          tenant.tax.profile()
+        ).compute(params);
+      case "cashBasisReport":
+        return new CashBasisProjection(
+          tenant.baseCurrency,
+          tenant.accounts,
+          tenant.journal,
+          tenant.openItems,
+          tenant.vouchers,
+          tenant.fiscalYears,
+          tenant.mappings
+        ).compute(params);
+      case "journalExport":
+        return new JournalExportProjection(
+          tenant.id,
+          tenant.name,
+          tenant.baseCurrency,
+          tenant.journal,
+          tenant.accounts,
+          tenant.vouchers,
+          tenant.partners,
+          tenant.audit,
+          tenant.clock
+        ).compute(params);
+      case "datevExport":
+        return new DatevExportProjection(
+          tenant.journal,
+          tenant.accounts,
+          tenant.vouchers,
+          tenant.partners,
+          tenant.tax.registryHandle()
+        ).compute(params);
+      default:
+        throw new DomainError("E_NOT_IMPLEMENTED", `Projektion "${name}" ist nicht definiert`);
+    }
+  }
+};
+
+// src/composition/tenant-factory.ts
+function isRecord9(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function asString8(value) {
+  return typeof value === "string" ? value : null;
+}
+var TenantFactory = class {
+  constructor(ruleModules, clock, ids) {
+    this.ruleModules = ruleModules;
+    this.clock = clock;
+    this.ids = ids;
+  }
+  ruleModules;
+  clock;
+  ids;
+  create(input) {
+    const profileId = asString8(input.profile) ?? "";
+    const profile = this.findById("profiles", profileId);
+    if (profile === null) {
+      throw new DomainError("E_PROFILE_UNKNOWN", `Profil "${profileId}" ist nicht vorhanden`);
+    }
+    const coaId = asString8(profile.chartOfAccounts) ?? "";
+    const coa = this.findById("chartsOfAccounts", coaId);
+    if (coa === null) {
+      throw new DomainError("E_PROFILE_UNKNOWN", `Kontenrahmen "${coaId}" des Profils fehlt`);
+    }
+    const wantedCodes = Array.isArray(profile.taxCodes) ? profile.taxCodes : [];
+    const allTaxCodes = Array.isArray(this.ruleModules.taxCodes) ? this.ruleModules.taxCodes : [];
+    const taxCodeData = allTaxCodes.filter(
+      (code) => isRecord9(code) && wantedCodes.includes(code.code)
+    );
+    const defaults = isRecord9(profile.defaults) ? profile.defaults : {};
+    const taxProfile = TaxProfile.fromData(defaults);
+    const tenant = Tenant.inMemory(
+      asString8(input.name) ?? "Tenant",
+      Currency.of(asString8(input.baseCurrency) ?? "EUR"),
+      this.clock,
+      this.ids,
+      void 0,
+      TaxCodeRegistry.fromData(taxCodeData),
+      taxProfile
+    );
+    let accountCount = 0;
+    for (const accountData of Array.isArray(coa.accounts) ? coa.accounts : []) {
+      if (!isRecord9(accountData)) continue;
+      const type = accountData.type;
+      if (!isAccountType(type)) continue;
+      tenant.accounts.add(
+        new Account(
+          tenant.ids.next(),
+          AccountNumber.of(asString8(accountData.number) ?? ""),
+          asString8(accountData.name) ?? "",
+          type,
+          asString8(accountData.subtype),
+          "active"
+        )
+      );
+      accountCount++;
+    }
+    const year = typeof input.firstFiscalYear === "number" ? input.firstFiscalYear : 0;
+    if (year > 0) {
+      const y = String(year).padStart(4, "0");
+      tenant.fiscalYears.add(
+        FiscalYear.create(tenant.ids.next(), year, CalendarDate.of(`${y}-01-01`), CalendarDate.of(`${y}-12-31`))
+      );
+    }
+    return {
+      tenant,
+      result: {
+        id: tenant.id.value,
+        name: tenant.name,
+        profile: { id: profileId, version: asString8(profile.version) ?? "" },
+        accountCount,
+        taxationMethod: taxProfile.taxationMethod()
+      }
+    };
+  }
+  findById(module, id) {
+    const list = Array.isArray(this.ruleModules[module]) ? this.ruleModules[module] : [];
+    for (const candidate of list) {
+      if (isRecord9(candidate) && candidate.id === id) return candidate;
+    }
+    return null;
+  }
+};
+
+export { Account, AccountNumber, AccountSheetProjection, Asset, AssetRegisterProjection, AssetService, AuditLogProjection, AuditRecord, BalanceSheetProjection, CalendarDate, CashBasisProjection, CostingRun, CostingService, Currency, CurrencyMismatch, DatevExportProjection, DeterministicIdGenerator, DimensionRegistry, DimensionValue, DomainError, EcSalesListProjection, EntryLine, FiscalYear, FixedClock, InMemoryAccountRepository, InMemoryAssetRepository, InMemoryAuditTrail, InMemoryFiscalYearRepository, InMemoryJournalRepository, InMemoryOpenItemRepository, InMemoryPartnerRepository, InMemoryVoucherRepository, IncomeStatementProjection, InvalidValue, JournalEntry, JournalExportProjection, Ledger, Mapping, MappingImporter, MappingRegistry, Money, OpenItem, OpenItemsProjection, Partner, PartnerService, Period, PeriodRef, PostResult, PostVoucherService, Settlement, SystemClock, TaxCode, TaxCodeRegistry, TaxCodeVersion, TaxProfile, TaxService, Tenant, TenantFactory, TenantOperations, TrialBalanceProjection, Uuid, UuidV7IdGenerator, VatReturnProjection, Voucher, canonicalJson, isAccountType, isBalanceCarrying, leafMatches, parseAssetRoute, parseOpenItemKind, parseSettlementDifferenceKind };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map