@fin.cx/skr 1.3.1 → 2.0.0

package/dist_ts/skr.txview.js

@@ -0,0 +1,235 @@
+/**
+ * Bridges between the legacy v1 shapes (float euros, numeric posting keys,
+ * debit/credit account pairs) and the v2 ledger (cents, string BU keys,
+ * per-line Gegenkonto):
+ *
+ * - input converters: ITransactionData / IJournalEntry  ->  core.IJournalDraft
+ * - output projections: v2 JournalEntry (lines)  ->  transaction-shaped views
+ *
+ * The Transaction collection is FROZEN in v2 — these projections are what
+ * keeps transaction-style reads working.
+ */
+import * as plugins from './plugins.js';
+import * as core from './core/index.js';
+import { getDbSync } from './skr.database.js';
+import { JOURNAL_ENTRY_COLLECTION } from './skr.period.js';
+const { centsFromFloat } = plugins.calculation;
+/** v1 numeric posting keys that map 1:1 onto the v2 string BU keys */
+const NUMERIC_KEY_MAP = {
+    1: '1',
+    2: '2',
+    3: '3',
+    8: '8',
+    9: '9',
+    18: '18',
+    19: '19',
+    40: '40',
+    91: '91',
+    94: '94',
+};
+export function mapNumericPostingKey(postingKey) {
+    if (postingKey === undefined || postingKey === null)
+        return '';
+    return NUMERIC_KEY_MAP[postingKey] ?? '';
+}
+/**
+ * v1 postTransaction input -> two-line v2 draft. The amount is NOT split into
+ * net/VAT (v1 semantics: vatAmount was informational) so ledger figures stay
+ * identical across the migration.
+ */
+export function transactionDataToDraft(data) {
+    const amountCents = centsFromFloat(data.amount);
+    const vatCents = data.vatAmount ? centsFromFloat(data.vatAmount) : 0;
+    const lines = [
+        {
+            accountNumber: data.debitAccount,
+            counterAccount: data.creditAccount,
+            side: 'debit',
+            amountCents,
+            buKey: '',
+            buchungstext: data.description,
+            belegfeld1: data.reference,
+            costCenter1: data.costCenter,
+        },
+        {
+            accountNumber: data.creditAccount,
+            counterAccount: data.debitAccount,
+            side: 'credit',
+            amountCents,
+            buKey: '',
+            buchungstext: data.description,
+            belegfeld1: data.reference,
+            costCenter1: data.costCenter,
+        },
+    ];
+    lines[0].vatAmountCents = vatCents;
+    return {
+        date: data.date,
+        description: data.description,
+        reference: data.reference,
+        skrType: data.skrType,
+        currency: 'EUR',
+        lines,
+    };
+}
+/**
+ * v1 postJournalEntry input -> v2 draft. Gegenkonto derivation: when one side
+ * of the entry has exactly one line, it is the counter account for every line
+ * of the other side (the dominant v1 usage); otherwise the first line of the
+ * opposite side is used (documented heuristic — v1 stored no Gegenkonto).
+ */
+export function journalInputToDraft(entry) {
+    const debitLines = entry.lines.filter((line) => (line.debit ?? 0) > 0);
+    const creditLines = entry.lines.filter((line) => (line.credit ?? 0) > 0);
+    const counterFor = (side) => {
+        const opposite = side === 'debit' ? creditLines : debitLines;
+        return opposite[0]?.accountNumber ?? '';
+    };
+    const lines = entry.lines.map((line) => {
+        const isDebit = (line.debit ?? 0) > 0;
+        return {
+            accountNumber: line.accountNumber,
+            counterAccount: counterFor(isDebit ? 'debit' : 'credit'),
+            side: isDebit ? 'debit' : 'credit',
+            amountCents: centsFromFloat(isDebit ? line.debit : line.credit),
+            buKey: mapNumericPostingKey(line.postingKey),
+            buchungstext: line.description ?? entry.description,
+            costCenter1: line.costCenter,
+        };
+    });
+    return {
+        date: entry.date,
+        description: entry.description,
+        reference: entry.reference,
+        skrType: entry.skrType,
+        currency: 'EUR',
+        lines,
+    };
+}
+/**
+ * Project a two-line v2 entry back into the classic transaction shape.
+ * Returns null for entries with more than two lines (journal-only view).
+ */
+export function entryToTransactionView(entry) {
+    const debitLine = entry.lines.find((line) => line.side === 'debit');
+    const creditLine = entry.lines.find((line) => line.side === 'credit');
+    if (!debitLine || !creditLine || entry.lines.length !== 2)
+        return null;
+    return {
+        id: entry.id,
+        transactionNumber: entry.journalNumber ?? entry.id,
+        date: entry.date,
+        debitAccount: debitLine.accountNumber,
+        creditAccount: creditLine.accountNumber,
+        amount: (debitLine.amountCents ?? 0) / 100,
+        vatAmount: (debitLine.vatAmountCents ?? 0) / 100,
+        description: entry.description,
+        reference: entry.reference ?? '',
+        skrType: entry.skrType,
+        status: entry.status,
+        period: entry.period ?? '',
+        fiscalYear: entry.fiscalYear ?? entry.date.getUTCFullYear(),
+        costCenter: debitLine.costCenter1 ?? creditLine.costCenter1,
+        reversalOf: entry.reversalOf,
+    };
+}
+function dayRange(params) {
+    const from = params?.dateFrom ? new Date(params.dateFrom) : null;
+    const to = params?.dateTo ? new Date(params.dateTo) : null;
+    if (from)
+        from.setHours(0, 0, 0, 0);
+    if (to)
+        to.setHours(23, 59, 59, 999);
+    return { from, to };
+}
+/**
+ * Load v2 entries of a date range as core drafts (for DATEV export).
+ */
+export async function loadDraftsForExport(skrType, dateFrom, dateTo) {
+    const docs = await getDbSync()
+        .mongoDb.collection(JOURNAL_ENTRY_COLLECTION)
+        .find({
+        skrType,
+        schemaVersion: 2,
+        status: { $in: ['posted', 'finalized'] },
+        date: { $gte: dateFrom, $lte: dateTo },
+    })
+        .sort({ sequenceNumber: 1 })
+        .toArray();
+    return docs.map((doc) => {
+        const entry = doc;
+        return {
+            date: entry.date,
+            description: entry.description,
+            reference: entry.reference,
+            skrType: entry.skrType,
+            currency: 'EUR',
+            lines: entry.lines.map((line) => ({
+                accountNumber: line.accountNumber,
+                counterAccount: line.counterAccount ?? '',
+                side: (line.side ?? 'debit'),
+                amountCents: line.amountCents ?? 0,
+                buKey: (line.buKey ?? ''),
+                buchungstext: line.buchungstext ?? entry.description,
+                belegfeld1: line.belegfeld1,
+                costCenter1: line.costCenter1,
+                docLink: line.docLink,
+            })),
+        };
+    });
+}
+/**
+ * Per-account activity as transaction-shaped line views from v2 entries —
+ * the data source for reports (trial balance, general ledger, cash flow).
+ * Each view carries the line's own side and its Gegenkonto.
+ */
+export async function accountLineViews(accountNumber, skrType, params) {
+    const { from, to } = dayRange(params);
+    const match = {
+        skrType,
+        schemaVersion: 2,
+        status: { $in: ['posted', 'finalized'] },
+        'lines.accountNumber': accountNumber,
+    };
+    if (from || to) {
+        const range = {};
+        if (from)
+            range.$gte = from;
+        if (to)
+            range.$lte = to;
+        match.date = range;
+    }
+    const docs = await getDbSync()
+        .mongoDb.collection(JOURNAL_ENTRY_COLLECTION)
+        .find(match)
+        .sort({ date: 1, sequenceNumber: 1 })
+        .toArray();
+    const views = [];
+    for (const doc of docs) {
+        const entry = doc;
+        for (const line of entry.lines) {
+            if (line.accountNumber !== accountNumber)
+                continue;
+            const isDebit = line.side === 'debit';
+            views.push({
+                id: entry.id,
+                transactionNumber: entry.journalNumber ?? entry.id,
+                date: entry.date,
+                debitAccount: isDebit ? accountNumber : line.counterAccount ?? '',
+                creditAccount: isDebit ? line.counterAccount ?? '' : accountNumber,
+                amount: (line.amountCents ?? 0) / 100,
+                vatAmount: (line.vatAmountCents ?? 0) / 100,
+                description: line.buchungstext ?? entry.description,
+                reference: entry.reference ?? '',
+                skrType: entry.skrType,
+                status: entry.status,
+                period: entry.period ?? '',
+                fiscalYear: entry.fiscalYear ?? entry.date.getUTCFullYear(),
+                costCenter: line.costCenter1,
+                reversalOf: entry.reversalOf,
+            });
+        }
+    }
+    return views;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"skr.txview.js","sourceRoot":"","sources":["../ts/skr.txview.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,KAAK,OAAO,MAAM,cAAc,CAAC;AACxC,OAAO,KAAK,IAAI,MAAM,iBAAiB,CAAC;AACxC,OAAO,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAC9C,OAAO,EAAE,wBAAwB,EAAE,MAAM,iBAAiB,CAAC;AAU3D,MAAM,EAAE,cAAc,EAAE,GAAG,OAAO,CAAC,WAAW,CAAC;AAE/C,sEAAsE;AACtE,MAAM,eAAe,GAAgC;IACnD,CAAC,EAAE,GAAG;IACN,CAAC,EAAE,GAAG;IACN,CAAC,EAAE,GAAG;IACN,CAAC,EAAE,GAAG;IACN,CAAC,EAAE,GAAG;IACN,EAAE,EAAE,IAAI;IACR,EAAE,EAAE,IAAI;IACR,EAAE,EAAE,IAAI;IACR,EAAE,EAAE,IAAI;IACR,EAAE,EAAE,IAAI;CACT,CAAC;AAEF,MAAM,UAAU,oBAAoB,CAAC,UAAmB;IACtD,IAAI,UAAU,KAAK,SAAS,IAAI,UAAU,KAAK,IAAI;QAAE,OAAO,EAAE,CAAC;IAC/D,OAAO,eAAe,CAAC,UAAU,CAAC,IAAI,EAAE,CAAC;AAC3C,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,sBAAsB,CAAC,IAAsB;IAC3D,MAAM,WAAW,GAAG,cAAc,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IAChD,MAAM,QAAQ,GAAG,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,cAAc,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IACrE,MAAM,KAAK,GAA6B;QACtC;YACE,aAAa,EAAE,IAAI,CAAC,YAAY;YAChC,cAAc,EAAE,IAAI,CAAC,aAAa;YAClC,IAAI,EAAE,OAAO;YACb,WAAW;YACX,KAAK,EAAE,EAAE;YACT,YAAY,EAAE,IAAI,CAAC,WAAW;YAC9B,UAAU,EAAE,IAAI,CAAC,SAAS;YAC1B,WAAW,EAAE,IAAI,CAAC,UAAU;SAC7B;QACD;YACE,aAAa,EAAE,IAAI,CAAC,aAAa;YACjC,cAAc,EAAE,IAAI,CAAC,YAAY;YACjC,IAAI,EAAE,QAAQ;YACd,WAAW;YACX,KAAK,EAAE,EAAE;YACT,YAAY,EAAE,IAAI,CAAC,WAAW;YAC9B,UAAU,EAAE,IAAI,CAAC,SAAS;YAC1B,WAAW,EAAE,IAAI,CAAC,UAAU;SAC7B;KACF,CAAC;IACF,KAAK,CAAC,CAAC,CAAC,CAAC,cAAc,GAAG,QAAQ,CAAC;IACnC,OAAO;QACL,IAAI,EAAE,IAAI,CAAC,IAAI;QACf,WAAW,EAAE,IAAI,CAAC,WAAW;QAC7B,SAAS,EAAE,IAAI,CAAC,SAAS;QACzB,OAAO,EAAE,IAAI,CAAC,OAAO;QACrB,QAAQ,EAAE,KAAK;QACf,KAAK;KACN,CAAC;AACJ,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,mBAAmB,CAAC,KAAoB;IACtD,MAAM,UAAU,GAAG,KAAK,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,KAAK,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;IACvE,MAAM,WAAW,GAAG,KAAK,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,MAAM,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;IACzE,MAAM,UAAU,GAAG,CAAC,IAAwB,EAAU,EAAE;QACtD,MAAM,QAAQ,GAAG,IAAI,KAAK,OAAO,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,UAAU,CAAC;QAC7D,OAAO,QAAQ,CAAC,CAAC,CAAC,EAAE,aAAa,IAAI,EAAE,CAAC;IAC1C,CAAC,CAAC;IACF,MAAM,KAAK,GAA6B,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE;QAC/D,MAAM,OAAO,GAAG,CAAC,IAAI,CAAC,KAAK,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC;QACtC,OAAO;YACL,aAAa,EAAE,IAAI,CAAC,aAAa;YACjC,cAAc,EAAE,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,QAAQ,CAAC;YACxD,IAAI,EAAE,OAAO,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,QAAQ;YAClC,WAAW,EAAE,cAAc,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,KAAM,CAAC,CAAC,CAAC,IAAI,CAAC,MAAO,CAAC;YACjE,KAAK,EAAE,oBAAoB,CAAC,IAAI,CAAC,UAAU,CAAC;YAC5C,YAAY,EAAE,IAAI,CAAC,WAAW,IAAI,KAAK,CAAC,WAAW;YACnD,WAAW,EAAE,IAAI,CAAC,UAAU;SAC7B,CAAC;IACJ,CAAC,CAAC,CAAC;IACH,OAAO;QACL,IAAI,EAAE,KAAK,CAAC,IAAI;QAChB,WAAW,EAAE,KAAK,CAAC,WAAW;QAC9B,SAAS,EAAE,KAAK,CAAC,SAAS;QAC1B,OAAO,EAAE,KAAK,CAAC,OAAO;QACtB,QAAQ,EAAE,KAAK;QACf,KAAK;KACN,CAAC;AACJ,CAAC;AAiBD;;;GAGG;AACH,MAAM,UAAU,sBAAsB,CAAC,KAAoB;IACzD,MAAM,SAAS,GAAG,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,KAAK,OAAO,CAAC,CAAC;IACpE,MAAM,UAAU,GAAG,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,KAAK,QAAQ,CAAC,CAAC;IACtE,IAAI,CAAC,SAAS,IAAI,CAAC,UAAU,IAAI,KAAK,CAAC,KAAK,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,IAAI,CAAC;IACvE,OAAO;QACL,EAAE,EAAE,KAAK,CAAC,EAAE;QACZ,iBAAiB,EAAE,KAAK,CAAC,aAAa,IAAI,KAAK,CAAC,EAAE;QAClD,IAAI,EAAE,KAAK,CAAC,IAAI;QAChB,YAAY,EAAE,SAAS,CAAC,aAAa;QACrC,aAAa,EAAE,UAAU,CAAC,aAAa;QACvC,MAAM,EAAE,CAAC,SAAS,CAAC,WAAW,IAAI,CAAC,CAAC,GAAG,GAAG;QAC1C,SAAS,EAAE,CAAC,SAAS,CAAC,cAAc,IAAI,CAAC,CAAC,GAAG,GAAG;QAChD,WAAW,EAAE,KAAK,CAAC,WAAW;QAC9B,SAAS,EAAE,KAAK,CAAC,SAAS,IAAI,EAAE;QAChC,OAAO,EAAE,KAAK,CAAC,OAAO;QACtB,MAAM,EAAE,KAAK,CAAC,MAAM;QACpB,MAAM,EAAE,KAAK,CAAC,MAAM,IAAI,EAAE;QAC1B,UAAU,EAAE,KAAK,CAAC,UAAU,IAAI,KAAK,CAAC,IAAI,CAAC,cAAc,EAAE;QAC3D,UAAU,EAAE,SAAS,CAAC,WAAW,IAAI,UAAU,CAAC,WAAW;QAC3D,UAAU,EAAE,KAAK,CAAC,UAAU;KAC7B,CAAC;AACJ,CAAC;AAED,SAAS,QAAQ,CAAC,MAAsB;IACtC,MAAM,IAAI,GAAG,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;IACjE,MAAM,EAAE,GAAG,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;IAC3D,IAAI,IAAI;QAAE,IAAI,CAAC,QAAQ,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;IACpC,IAAI,EAAE;QAAE,EAAE,CAAC,QAAQ,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,GAAG,CAAC,CAAC;IACrC,OAAO,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC;AACtB,CAAC;AAED;;GAEG;AACH,MAAM,CAAC,KAAK,UAAU,mBAAmB,CACvC,OAAiB,EACjB,QAAc,EACd,MAAY;IAEZ,MAAM,IAAI,GAAG,MAAM,SAAS,EAAE;SAC3B,OAAO,CAAC,UAAU,CAAC,wBAAwB,CAAC;SAC5C,IAAI,CAAC;QACJ,OAAO;QACP,aAAa,EAAE,CAAC;QAChB,MAAM,EAAE,EAAE,GAAG,EAAE,CAAC,QAAQ,EAAE,WAAW,CAAC,EAAE;QACxC,IAAI,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,EAAE;KACvC,CAAC;SACD,IAAI,CAAC,EAAE,cAAc,EAAE,CAAC,EAAE,CAAC;SAC3B,OAAO,EAAE,CAAC;IACb,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE;QACtB,MAAM,KAAK,GAAG,GAA+B,CAAC;QAC9C,OAAO;YACL,IAAI,EAAE,KAAK,CAAC,IAAI;YAChB,WAAW,EAAE,KAAK,CAAC,WAAW;YAC9B,SAAS,EAAE,KAAK,CAAC,SAAS;YAC1B,OAAO,EAAE,KAAK,CAAC,OAAO;YACtB,QAAQ,EAAE,KAAc;YACxB,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;gBAChC,aAAa,EAAE,IAAI,CAAC,aAAa;gBACjC,cAAc,EAAE,IAAI,CAAC,cAAc,IAAI,EAAE;gBACzC,IAAI,EAAE,CAAC,IAAI,CAAC,IAAI,IAAI,OAAO,CAAuB;gBAClD,WAAW,EAAE,IAAI,CAAC,WAAW,IAAI,CAAC;gBAClC,KAAK,EAAE,CAAC,IAAI,CAAC,KAAK,IAAI,EAAE,CAAgB;gBACxC,YAAY,EAAE,IAAI,CAAC,YAAY,IAAI,KAAK,CAAC,WAAW;gBACpD,UAAU,EAAE,IAAI,CAAC,UAAU;gBAC3B,WAAW,EAAE,IAAI,CAAC,WAAW;gBAC7B,OAAO,EAAE,IAAI,CAAC,OAAO;aACtB,CAAC,CAAC;SACJ,CAAC;IACJ,CAAC,CAAC,CAAC;AACL,CAAC;AAED;;;;GAIG;AACH,MAAM,CAAC,KAAK,UAAU,gBAAgB,CACpC,aAAqB,EACrB,OAAiB,EACjB,MAAsB;IAEtB,MAAM,EAAE,IAAI,EAAE,EAAE,EAAE,GAAG,QAAQ,CAAC,MAAM,CAAC,CAAC;IACtC,MAAM,KAAK,GAA4B;QACrC,OAAO;QACP,aAAa,EAAE,CAAC;QAChB,MAAM,EAAE,EAAE,GAAG,EAAE,CAAC,QAAQ,EAAE,WAAW,CAAC,EAAE;QACxC,qBAAqB,EAAE,aAAa;KACrC,CAAC;IACF,IAAI,IAAI,IAAI,EAAE,EAAE,CAAC;QACf,MAAM,KAAK,GAAyB,EAAE,CAAC;QACvC,IAAI,IAAI;YAAE,KAAK,CAAC,IAAI,GAAG,IAAI,CAAC;QAC5B,IAAI,EAAE;YAAE,KAAK,CAAC,IAAI,GAAG,EAAE,CAAC;QACxB,KAAK,CAAC,IAAI,GAAG,KAAK,CAAC;IACrB,CAAC;IACD,MAAM,IAAI,GAAG,MAAM,SAAS,EAAE;SAC3B,OAAO,CAAC,UAAU,CAAC,wBAAwB,CAAC;SAC5C,IAAI,CAAC,KAAK,CAAC;SACX,IAAI,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,cAAc,EAAE,CAAC,EAAE,CAAC;SACpC,OAAO,EAAE,CAAC;IAEb,MAAM,KAAK,GAAuB,EAAE,CAAC;IACrC,KAAK,MAAM,GAAG,IAAI,IAAI,EAAE,CAAC;QACvB,MAAM,KAAK,GAAG,GAA+B,CAAC;QAC9C,KAAK,MAAM,IAAI,IAAI,KAAK,CAAC,KAAK,EAAE,CAAC;YAC/B,IAAI,IAAI,CAAC,aAAa,KAAK,aAAa;gBAAE,SAAS;YACnD,MAAM,OAAO,GAAG,IAAI,CAAC,IAAI,KAAK,OAAO,CAAC;YACtC,KAAK,CAAC,IAAI,CAAC;gBACT,EAAE,EAAE,KAAK,CAAC,EAAE;gBACZ,iBAAiB,EAAE,KAAK,CAAC,aAAa,IAAI,KAAK,CAAC,EAAE;gBAClD,IAAI,EAAE,KAAK,CAAC,IAAI;gBAChB,YAAY,EAAE,OAAO,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,cAAc,IAAI,EAAE;gBACjE,aAAa,EAAE,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,cAAc,IAAI,EAAE,CAAC,CAAC,CAAC,aAAa;gBAClE,MAAM,EAAE,CAAC,IAAI,CAAC,WAAW,IAAI,CAAC,CAAC,GAAG,GAAG;gBACrC,SAAS,EAAE,CAAC,IAAI,CAAC,cAAc,IAAI,CAAC,CAAC,GAAG,GAAG;gBAC3C,WAAW,EAAE,IAAI,CAAC,YAAY,IAAI,KAAK,CAAC,WAAW;gBACnD,SAAS,EAAE,KAAK,CAAC,SAAS,IAAI,EAAE;gBAChC,OAAO,EAAE,KAAK,CAAC,OAAO;gBACtB,MAAM,EAAE,KAAK,CAAC,MAAM;gBACpB,MAAM,EAAE,KAAK,CAAC,MAAM,IAAI,EAAE;gBAC1B,UAAU,EAAE,KAAK,CAAC,UAAU,IAAI,KAAK,CAAC,IAAI,CAAC,cAAc,EAAE;gBAC3D,UAAU,EAAE,IAAI,CAAC,WAAW;gBAC5B,UAAU,EAAE,KAAK,CAAC,UAAU;aAC7B,CAAC,CAAC;QACL,CAAC;IACH,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC"}

package/dist_ts/skr.types.d.ts

@@ -53,7 +53,41 @@ export interface IJournalEntryLine {
     credit?: number;
     description?: string;
     costCenter?: string;
-    postingKey: TPostingKey;
+    /** v1 numeric DATEV posting key; optional since schemaVersion 2 (see buKey) */
+    postingKey?: TPostingKey;
+    side?: 'debit' | 'credit';
+    amountCents?: number;
+    counterAccount?: string;
+    /** string-typed DATEV BU-Schlüssel ('' = none) */
+    buKey?: string;
+    buchungstext?: string;
+    belegfeld1?: string;
+    costCenter1?: string;
+    docLink?: string;
+    /** informational VAT share carried on the line (v1 compatibility) */
+    vatAmountCents?: number;
+}
+/**
+ * Transaction-shaped projection of a v2 journal entry (or one of its lines).
+ * The Transaction collection is frozen in v2 — reads go through these views.
+ */
+export interface ITransactionView {
+    id: string;
+    transactionNumber: string;
+    date: Date;
+    debitAccount: string;
+    creditAccount: string;
+    amount: number;
+    vatAmount: number;
+    description: string;
+    reference: string;
+    skrType: TSKRType;
+    status: string;
+    period: string;
+    fiscalYear: number;
+    costCenter?: string;
+    /** id of the entry this one reverses (Storno linkage) */
+    reversalOf?: string;
 }
 export interface ITrialBalanceEntry {
     accountNumber: string;

package/dist_ts/skr.verify.d.ts

@@ -0,0 +1,13 @@
+import type { TSKRType } from './skr.types.js';
+export interface IChainVerificationResult {
+    valid: boolean;
+    entriesChecked: number;
+    issues: string[];
+    headHash: string | null;
+}
+/**
+ * Walk sequence 1..N for (skrType, fiscalYear): check gaplessness, recompute
+ * every entry hash from the persisted payload, verify the chain links, and
+ * compare the final hash against the stored chain head.
+ */
+export declare function verifyHashChain(skrType: TSKRType, fiscalYear: number): Promise<IChainVerificationResult>;

package/dist_ts/skr.verify.js

@@ -0,0 +1,84 @@
+/**
+ * Cryptographic audit-trail verification. Prevention of tampering is
+ * best-effort (doc-level guards); detection is this module: recompute the
+ * whole hash chain from the persisted entries and compare against the stored
+ * chain head.
+ */
+import * as core from './core/index.js';
+import { getDbSync } from './skr.database.js';
+import { JOURNAL_ENTRY_COLLECTION } from './skr.period.js';
+import { getSequenceState } from './skr.sequence.js';
+import { buildHashPayload } from './skr.posting.js';
+/**
+ * Walk sequence 1..N for (skrType, fiscalYear): check gaplessness, recompute
+ * every entry hash from the persisted payload, verify the chain links, and
+ * compare the final hash against the stored chain head.
+ */
+export async function verifyHashChain(skrType, fiscalYear) {
+    const issues = [];
+    const collection = getDbSync().mongoDb.collection(JOURNAL_ENTRY_COLLECTION);
+    const docs = await collection
+        .find({ skrType, fiscalYear, schemaVersion: 2 })
+        .sort({ sequenceNumber: 1 })
+        .toArray();
+    const state = await getSequenceState(skrType, fiscalYear);
+    if (docs.length === 0) {
+        return {
+            valid: !state || state.value === 0,
+            entriesChecked: 0,
+            issues: state && state.value !== 0 ? [`sequence counter is ${state.value} but no entries exist`] : [],
+            headHash: state?.headHash ?? null,
+        };
+    }
+    // gaplessness
+    docs.forEach((doc, index) => {
+        const expected = index + 1;
+        if (doc.sequenceNumber !== expected) {
+            issues.push(`sequence gap: expected ${expected}, found ${doc.sequenceNumber}`);
+        }
+    });
+    // chain
+    const genesis = core.genesisHash(skrType, fiscalYear);
+    const chain = docs.map((doc) => ({
+        sequenceNumber: doc.sequenceNumber,
+        prevHash: doc.prevHash,
+        entryHash: doc.entryHash,
+        payload: buildHashPayload({
+            sequenceNumber: doc.sequenceNumber,
+            skrType: doc.skrType,
+            fiscalYear: doc.fiscalYear,
+            date: doc.date,
+            postedAt: doc.postedAt,
+            description: doc.description,
+            reference: doc.reference,
+            taxScenario: doc.taxScenario,
+            currency: doc.currency,
+            reversalOf: doc.reversalOf,
+            lines: (doc.lines ?? []),
+        }),
+    }));
+    const failure = core.verifyChain(chain, genesis);
+    if (failure) {
+        issues.push(failure.reason);
+    }
+    // head comparison
+    const lastHash = chain[chain.length - 1].entryHash;
+    if (!state) {
+        issues.push('no sequence state document found');
+    }
+    else {
+        if (state.headHash !== lastHash) {
+            issues.push(`stored chain head ${state.headHash} !== last entry hash ${lastHash}`);
+        }
+        if (state.value !== docs.length) {
+            issues.push(`sequence counter ${state.value} !== entry count ${docs.length}`);
+        }
+    }
+    return {
+        valid: issues.length === 0,
+        entriesChecked: docs.length,
+        issues,
+        headHash: state?.headHash ?? null,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fin.cx/skr",
-  "version": "1.3.1",
+  "version": "2.0.0",
   "description": "SKR03 and SKR04 German accounting standards for double-entry bookkeeping",
   "main": "dist_ts/index.js",
   "typings": "dist_ts/index.d.ts",
@@ -20,8 +20,9 @@
   "license": "MIT",
   "dependencies": {
     "@e-invoice-eu/core": "^3.1.1",
+    "@fin.cx/calculation": "^1.1.1",
     "@fin.cx/einvoice": "6.0.0",
-    "@push.rocks/smartdata": "^7.1.7",
+    "@push.rocks/smartdata": "^7.2.1",
     "@push.rocks/smartfile": "^13.1.3",
     "@push.rocks/smartfs": "^1.5.1",
     "@push.rocks/smarthash": "^3.2.7",
@@ -35,10 +36,10 @@
   },
   "devDependencies": {
     "@git.zone/tsbuild": "^4.4.2",
-    "@git.zone/tsrun": "^2.0.4",
+    "@git.zone/tsrun": "^2.0.5",
     "@git.zone/tstest": "^3.6.6",
     "@push.rocks/qenv": "^6.1.4",
-    "@types/node": "^25.9.1",
+    "@types/node": "^26.1.1",
     "@types/node-forge": "^1.3.14"
   },
   "repository": {

package/readme.hints.md

@@ -1,5 +1,42 @@
 # Project Readme Hints
 
+## Dev Environment (2026-07-09)
+
+- Local services are managed by `gitzone services` (@git.zone/cli >= 2.23.0); the old
+  `services.sh` was removed. `gitzone services start` creates MongoDB as a **single-node
+  replica set** (rs0, keyfile auth, mongod on the mapped port inside the container) —
+  required because skr v2 posting uses MongoDB transactions. Verify with
+  `.nogit/debug/check-replicaset.ts` (tsx).
+- Service selection lives in `.smartconfig.json` under `@git.zone/cli.services`;
+  runtime config in `.nogit/env.json`. Old standalone data was backed up to
+  `.nogit/mongodata.pre-replset.bak` (disposable test data).
+- Program plan for the accounting roadmap ("no external tax accountant") is in
+  `readme.plan.md`; M0 = skr v2 core hardening. @fin.cx/calculation ships the cents
+  module (TCents) that skr v2 money handling builds on.
+
+## M0 Phase 2 — stateless core (2026-07-09)
+
+- `ts/core/` is the pure booking core (exported as `core` from the package index):
+  types, BU keys, tax-scenario cascade, account policies, recipes, validation,
+  DATEV EXTF writer, hash chain. Hard rule: core imports only @fin.cx/calculation
+  (+ smarthash for SHA-256) — no smartdata/fs/network.
+- **BU-key corrections vs v1/finance.plus** (cross-checked 2026-07-09): 18/19 =
+  steuerpflichtiger innergemeinschaftlicher Erwerb 7%/19% (§1a UStG); 91/94 =
+  Leistungsempfänger schuldet die Steuer 7%/19% (§13b UStG); 40 = Aufhebung der
+  Automatik. v1's `skr.postingkeys.ts` (numeric keys with partly different meanings)
+  is superseded by `ts/core/core.bukeys.ts`. Official DATEV table (Hilfe-Center doc
+  0904313) is portal-gated — final verification = manual DATEV import per RC.
+- **DATEV EXTF v13 facts** (verified against a DATEV-importable reference file):
+  125 data columns, 31 header fields, field 114 = Festschreibung, decimal-comma
+  amounts, Belegdatum TTMM, text fields quoted, CRLF; file encoding must be CP1252
+  (conversion happens at the IO layer, core emits a JS string).
+  `ts/core/core.datev.captions.ts` is generated from that reference — do not edit.
+- Automatik convention in recipes: a line on an Automatikkonto carries key '' when
+  the entry has no explicit VAT lines, and key '40' when explicit VAT lines exist
+  (automatism must be cancelled so DATEV import doesn't double the tax).
+- PROVISIONAL policy accounts (verify in M-A): reduced-rate Skonto accounts
+  (3731/8731, 5731/4731) and rounding-diff accounts (2700/2300, 4830/6300).
+
 ## Current Status (2025-10-27)
 
 ### Test Results

package/readme.md

@@ -4,6 +4,24 @@
 
 It is built for developers who need a programmable accounting core instead of a pile of CSV glue code: initialize a chart of accounts, post validated transactions and journal entries, generate reports, and archive year-end data in a structured export format.
 
+**Version 2** makes the ledger filing-grade:
+
+- Exact integer-cent amounts internally (no float drift; balance checks are `===`)
+- Atomic posting via MongoDB transactions (replica set required)
+- GoBD audit trail: gapless sequence numbers, SHA-256 hash chain, immutable posted entries, Storno-only corrections
+- Festschreibung: period locking with cryptographic chain verification
+- A pure, stateless booking core (`core` export): BU keys, tax-scenario detection, booking recipes, validation — no database needed
+- DATEV Buchungsstapel export in the real EXTF 700 / Formatversion 13 layout (125 columns)
+
+### Breaking changes in v2
+
+- MongoDB must run as a **replica set** (single-node is fine); `initialize()` fails hard without transaction support. `gitzone services start` creates a suitable MongoDB automatically.
+- `postTransaction()` / `reverseTransaction()` return transaction-shaped views (`ITransactionView`), not `Transaction` documents; the Transaction collection is frozen as a legacy read model.
+- Posted entries are immutable: reversing never mutates the original (`status` stays `posted`; linkage via `reversalOf`).
+- `exportToDATEV()` now emits the EXTF 700 format; persist the string as **CP1252**.
+- `IJournalEntryLine.postingKey` is optional; the v2 line fields (`side`, `amountCents`, `counterAccount`, string `buKey`) are authoritative.
+- Existing v1 data: run `api.migrateToV2()` once (idempotent; keeps all legacy fields; returns a report to archive).
+
 ## Issue Reporting and Security
 
 For reporting bugs, issues, or security vulnerabilities, please visit [community.foss.global/](https://community.foss.global/). This is the central community hub for all issue reporting. Developers who sign and comply with our contribution agreement and go through identification can also get a [code.foss.global/](https://code.foss.global/) account to submit Pull Requests directly.
@@ -29,7 +47,9 @@ For reporting bugs, issues, or security vulnerabilities, please visit [community
 ## Requirements
 
 - Node.js 20+ with ESM support
-- A reachable MongoDB instance
+- A reachable MongoDB instance running as a **replica set** (transactions are
+  mandatory for atomic posting; a single-node replica set is sufficient —
+  `gitzone services start` provides one locally)
 - `pnpm`
 
 The test setup reads MongoDB connection details from `.nogit/` via `@push.rocks/qenv`, but the runtime API only needs a `mongoDbUrl` and an optional `dbName`.
@@ -198,6 +218,54 @@ const imported = await api.importAccountsFromCSV(csvContent);
 const accountCsv = await api.exportAccountsToCSV();
 ```
 
+## v2 Ledger: Recipes, Festschreibung, Audit Chain
+
+The stateless core builds validated drafts; the poster writes them atomically:
+
+```ts
+import { SkrApi, core } from '@fin.cx/skr';
+
+const api = new SkrApi({ mongoDbUrl, dbName });
+await api.initialize('SKR03');
+const policy = api.getDefaultPolicy();
+
+// booking recipes are pure functions — usable without any database
+const draft = core.bookVendorInvoice(
+  {
+    date: new Date(),
+    vendorAccount: '70001',
+    grossCents: 11900,
+    scenario: 'domestic_standard',
+    invoiceNumber: 'RE-1001',
+    description: 'Bürobedarf',
+  },
+  policy,
+);
+
+const entry = await api.postDraft(draft); // gapless sequence + hash chain
+const storno = await api.postStorno(entry); // corrections never mutate
+
+await api.festschreibePeriod('2026-03'); // GoBD period lock
+const audit = await api.verifyAuditChain(2026); // recompute the whole chain
+const balance = await api.getAccountBalanceCents('1200'); // exact cents
+
+const { csv, filename } = await api.exportDatevBuchungsstapel({
+  dateFrom: new Date('2026-03-01'),
+  dateTo: new Date('2026-03-31'),
+  consultantNumber: 1001,
+  clientNumber: 456,
+  fiscalYearStart: new Date('2026-01-01'),
+  festschreibung: true,
+});
+// persist csv as CP1252 — DATEV expects ANSI encoding
+```
+
+Also in `core`: `bookCustomerInvoice` (incl. intra-EU supply, export, §13b),
+`bookBankPayment` (Skonto with VAT correction, tolerance write-offs),
+`bookInternalTransfer` (Geldtransit), `bookToSuspense`/`resolveSuspense`,
+`fxDifferenceLines`, `detectTaxScenario` (confidence-scored cascade), the
+BU-key table (`BU_KEY_RULES`), and `validateJournalDraft`.
+
 ## Reports And Exports
 
 Available reporting methods on `SkrApi`: