@classytic/ledger 0.1.3

package/dist/index.mjs

@@ -0,0 +1,171 @@
+import { n as createJournalEntrySchema, r as createAccountSchema, t as createFiscalPeriodSchema } from "./fiscal-period.schema-CbALaaKl.mjs";
+import { a as isValidJournalType, i as getJournalTypeCodes, n as JOURNAL_TYPES, t as JOURNAL_CODES } from "./journals-CI3Wb4EF.mjs";
+import { a as generateIncomeStatement, c as calculateTotal, d as generateTrialBalance, f as buildItemFilters, i as generateGeneralLedger, l as computeEndingBalance, m as getFiscalYearStart, n as reopenFiscalPeriod, o as generateBalanceSheet, p as getDateRange, r as generateCashFlow, s as buildAccountTypeMap, t as closeFiscalPeriod, u as isVirtualTaxAccount } from "./fiscal-close-CNOwv_ud.mjs";
+import { n as Errors, t as AccountingError } from "./errors-CeqRahE-.mjs";
+import { n as finalizeSession, r as defaultLogger, t as acquireSession } from "./session-Dh0s6zG4.mjs";
+import { c as getNormalBalance, d as isValidCategory, l as isBalanceSheet, n as CATEGORY_KEYS, t as CATEGORIES, u as isIncomeStatement } from "./categories-BNJBd4ze.mjs";
+import { Money, add, allocate, format, formatPlain, fromDecimal, multiply, parseCents, percentage, splitTaxExclusive, splitTaxInclusive, subtract, toDecimal } from "./money.mjs";
+import { n as wireJournalEntryMethods, t as wireAccountMethods } from "./account.repository-Crf5DGO4.mjs";
+import { n as fiscalLockPlugin, r as doubleEntryPlugin, t as idempotencyPlugin } from "./idempotency.plugin-C6r8RI8d.mjs";
+import { i as isValidCurrency, n as getCurrency, r as getMinorUnit, t as CURRENCIES } from "./currencies-BBk3NwXn.mjs";
+import { defineCountryPack } from "./country/index.mjs";
+import { a as exportToCsv, n as quickbooksFieldMap, r as flattenJournalEntries, t as universalFieldMap } from "./universal-CMfrZ2hG.mjs";
+
+//#region src/engine.ts
+var AccountingEngine = class {
+	config;
+	country;
+	currency;
+	money = Money;
+	constructor(config) {
+		this.config = config;
+		this.country = config.country;
+		this.currency = config.currency;
+	}
+	createAccountSchema(options) {
+		return createAccountSchema(this.config, options);
+	}
+	createJournalEntrySchema(accountModelName, options) {
+		return createJournalEntrySchema(this.config, accountModelName, options);
+	}
+	createFiscalPeriodSchema(options) {
+		return createFiscalPeriodSchema(this.config, options);
+	}
+	createReports(models) {
+		const { Account: AccountModel, JournalEntry: JournalEntryModel } = models;
+		const { country, config } = this;
+		const orgField = config.multiTenant?.orgField;
+		const fiscalYearStartMonth = config.fiscalYearStartMonth ?? 1;
+		const retainedEarningsCode = config.retainedEarningsCode;
+		const currentYearEarningsCode = config.currentYearEarningsCode;
+		return {
+			trialBalance: (params) => generateTrialBalance({
+				AccountModel,
+				JournalEntryModel,
+				country,
+				orgField,
+				fiscalYearStartMonth
+			}, params),
+			balanceSheet: (params) => generateBalanceSheet({
+				AccountModel,
+				JournalEntryModel,
+				country,
+				orgField,
+				fiscalYearStartMonth,
+				retainedEarningsCode,
+				currentYearEarningsCode
+			}, params),
+			incomeStatement: (params) => generateIncomeStatement({
+				AccountModel,
+				JournalEntryModel,
+				country,
+				orgField
+			}, params),
+			generalLedger: (params) => generateGeneralLedger({
+				AccountModel,
+				JournalEntryModel,
+				country,
+				orgField,
+				fiscalYearStartMonth
+			}, params),
+			cashFlow: (params) => generateCashFlow({
+				AccountModel,
+				JournalEntryModel,
+				country,
+				orgField
+			}, params)
+		};
+	}
+	/** Get all posting account types (accounts you can post transactions to) */
+	getPostingAccountTypes() {
+		return this.country.getPostingAccountTypes();
+	}
+	/** Validate an account type code */
+	isValidAccountType(code) {
+		return this.country.isValidAccountType(code);
+	}
+	/** Get account type definition by code */
+	getAccountType(code) {
+		return this.country.getAccountType(code);
+	}
+	/** Get tax codes for a region */
+	getTaxCodesForRegion(region) {
+		return this.country.getTaxCodesForRegion(region);
+	}
+	/**
+	* Create a fully-configured journal entry repository with secure plugin wiring.
+	* This is the **recommended** way to set up journal entry repositories.
+	*
+	* Includes:
+	* - Double-entry plugin with account existence + tenant integrity validation
+	* - Fiscal lock plugin (when FiscalPeriodModel is provided)
+	* - post(), unpost(), reverse(), and duplicate() domain methods
+	*
+	* @param createRepository - The `createRepository` function from @classytic/mongokit
+	* @param models.JournalEntryModel - Mongoose model for journal entries
+	* @param models.AccountModel - Mongoose model for accounts (required for secure posted-create validation)
+	* @param models.FiscalPeriodModel - Mongoose model for fiscal periods (optional, enables fiscal lock)
+	* @param additionalPlugins - Extra plugins to include (e.g. timestampPlugin)
+	* @returns A wired repository with post(), unpost(), reverse(), duplicate(), and all plugins configured
+	*/
+	createJournalEntryRepository(createRepository, models, additionalPlugins = []) {
+		const orgField = this.config.multiTenant?.orgField;
+		const { JournalEntryModel, AccountModel, FiscalPeriodModel } = models;
+		const plugins = [...additionalPlugins, doubleEntryPlugin({
+			JournalEntryModel,
+			AccountModel,
+			orgField
+		})];
+		if (FiscalPeriodModel) plugins.push(fiscalLockPlugin({
+			FiscalPeriodModel,
+			JournalEntryModel,
+			orgField
+		}));
+		if (this.config.idempotency) plugins.push(idempotencyPlugin({
+			JournalEntryModel,
+			orgField
+		}));
+		const repository = createRepository(JournalEntryModel, plugins);
+		wireJournalEntryMethods(repository, JournalEntryModel, orgField, this.config.strictness);
+		return repository;
+	}
+	/**
+	* Wire post/reverse domain methods onto a mongokit Repository
+	* for journal entries. The repository must already be created via
+	* `createRepository(Model, plugins)` from @classytic/mongokit.
+	*
+	* **Note:** Prefer `createJournalEntryRepository()` which guarantees
+	* secure plugin wiring. This method only adds domain methods and does
+	* not validate plugin configuration.
+	*
+	* @param repository - An existing mongokit Repository instance
+	* @param JournalEntryModel - The Mongoose model for journal entries
+	* @returns The same repository, now with `.post()` and `.reverse()`
+	*/
+	wireJournalEntryRepository(repository, JournalEntryModel) {
+		const orgField = this.config.multiTenant?.orgField;
+		wireJournalEntryMethods(repository, JournalEntryModel, orgField, this.config.strictness);
+		return repository;
+	}
+	/**
+	* Wire seedAccounts/bulkCreate and posting-account validation onto a
+	* mongokit Repository for accounts. The repository must already be
+	* created via `createRepository(Model, plugins)` from @classytic/mongokit.
+	*
+	* @param repository - An existing mongokit Repository instance
+	* @param AccountModel - The Mongoose model for accounts
+	* @returns The same repository, now with `.seedAccounts()` and `.bulkCreate()`
+	*/
+	wireAccountRepository(repository, AccountModel) {
+		const orgField = this.config.multiTenant?.orgField;
+		wireAccountMethods(repository, AccountModel, this.country, orgField);
+		return repository;
+	}
+};
+function createAccountingEngine(config) {
+	return new AccountingEngine(config);
+}
+
+//#endregion
+export { AccountingEngine, AccountingError, CATEGORIES, CATEGORY_KEYS, CURRENCIES, Errors, JOURNAL_CODES, JOURNAL_TYPES, Money, acquireSession, add, allocate, buildAccountTypeMap, buildItemFilters, calculateTotal, closeFiscalPeriod, computeEndingBalance, createAccountSchema, createAccountingEngine, createFiscalPeriodSchema, createJournalEntrySchema, defaultLogger, defineCountryPack, doubleEntryPlugin, exportToCsv, finalizeSession, fiscalLockPlugin, flattenJournalEntries, format, formatPlain, fromDecimal, generateBalanceSheet, generateCashFlow, generateGeneralLedger, generateIncomeStatement, generateTrialBalance, getCurrency, getDateRange, getFiscalYearStart, getJournalTypeCodes, getMinorUnit, getNormalBalance, idempotencyPlugin, isBalanceSheet, isIncomeStatement, isValidCategory, isValidCurrency, isValidJournalType, isVirtualTaxAccount, multiply, parseCents, percentage, quickbooksFieldMap, reopenFiscalPeriod, splitTaxExclusive, splitTaxInclusive, subtract, toDecimal, universalFieldMap, wireAccountMethods, wireJournalEntryMethods };
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../src/engine.ts"],"sourcesContent":["/**\n * AccountingEngine — The main entry point for @classytic/ledger.\n *\n * Usage:\n *   const accounting = createAccountingEngine({\n *     country: canadaPack,\n *     currency: 'CAD',\n *     multiTenant: { orgField: 'business', orgRef: 'Business' },\n *   });\n *\n *   const AccountSchema = accounting.createAccountSchema();\n *   const JournalEntrySchema = accounting.createJournalEntrySchema('Account');\n *   const FiscalPeriodSchema = accounting.createFiscalPeriodSchema();\n *\n *   // Register models\n *   const Account = mongoose.model('Account', AccountSchema);\n *   const JournalEntry = mongoose.model('JournalEntry', JournalEntrySchema);\n *   const FiscalPeriod = mongoose.model('FiscalPeriod', FiscalPeriodSchema);\n *\n *   // Reports\n *   const reports = accounting.createReports({ Account, JournalEntry });\n *   const bs = await reports.balanceSheet({ dateOption: 'year', dateValue: 2025, organizationId: '...' });\n */\n\nimport type { Model } from 'mongoose';\nimport type { AccountingEngineConfig, SchemaOptions, JournalSchemaOptions } from './types/engine.js';\nimport type { CountryPack } from './country/index.js';\nimport { createAccountSchema } from './schemas/account.schema.js';\nimport { createJournalEntrySchema } from './schemas/journal-entry.schema.js';\nimport { createFiscalPeriodSchema } from './schemas/fiscal-period.schema.js';\nimport { generateTrialBalance } from './reports/trial-balance.js';\nimport { generateBalanceSheet } from './reports/balance-sheet.js';\nimport { generateIncomeStatement } from './reports/income-statement.js';\nimport { generateGeneralLedger } from './reports/general-ledger.js';\nimport { generateCashFlow } from './reports/cash-flow.js';\nimport { Money } from './money.js';\nimport { wireJournalEntryMethods } from './repositories/journal-entry.repository.js';\nimport { wireAccountMethods } from './repositories/account.repository.js';\nimport { doubleEntryPlugin } from './plugins/double-entry.plugin.js';\nimport { fiscalLockPlugin } from './plugins/fiscal-lock.plugin.js';\nimport { idempotencyPlugin } from './plugins/idempotency.plugin.js';\n\nexport class AccountingEngine {\n  readonly config: AccountingEngineConfig;\n  readonly country: CountryPack;\n  readonly currency: string;\n  readonly money = Money;\n\n  constructor(config: AccountingEngineConfig) {\n    this.config = config;\n    this.country = config.country;\n    this.currency = config.currency;\n  }\n\n  // ── Schema Factories ───────────────────────────────────────────────────────\n\n  createAccountSchema(options?: SchemaOptions) {\n    return createAccountSchema(this.config, options);\n  }\n\n  createJournalEntrySchema(accountModelName: string, options?: JournalSchemaOptions) {\n    return createJournalEntrySchema(this.config, accountModelName, options);\n  }\n\n  createFiscalPeriodSchema(options?: SchemaOptions) {\n    return createFiscalPeriodSchema(this.config, options);\n  }\n\n  // ── Report Engine ──────────────────────────────────────────────────────────\n\n  createReports(models: {\n    Account: Model<unknown>;\n    JournalEntry: Model<unknown>;\n  }) {\n    const { Account: AccountModel, JournalEntry: JournalEntryModel } = models;\n    const { country, config } = this;\n    const orgField = config.multiTenant?.orgField;\n    const fiscalYearStartMonth = config.fiscalYearStartMonth ?? 1;\n    const retainedEarningsCode = config.retainedEarningsCode;\n    const currentYearEarningsCode = config.currentYearEarningsCode;\n\n    return {\n      trialBalance: (params: {\n        organizationId?: unknown;\n        dateOption: 'month' | 'quarter' | 'year' | 'custom';\n        dateValue: unknown;\n        accountId?: string;\n        filters?: Record<string, unknown>;\n      }) =>\n        generateTrialBalance(\n          { AccountModel, JournalEntryModel, country, orgField, fiscalYearStartMonth },\n          params,\n        ),\n\n      balanceSheet: (params: {\n        organizationId?: unknown;\n        dateOption: 'month' | 'quarter' | 'year' | 'custom';\n        dateValue: unknown;\n        businessName?: string;\n        filters?: Record<string, unknown>;\n      }) =>\n        generateBalanceSheet(\n          { AccountModel, JournalEntryModel, country, orgField, fiscalYearStartMonth, retainedEarningsCode, currentYearEarningsCode },\n          params,\n        ),\n\n      incomeStatement: (params: {\n        organizationId?: unknown;\n        dateOption: 'month' | 'quarter' | 'year' | 'custom';\n        dateValue: unknown;\n        businessName?: string;\n        filters?: Record<string, unknown>;\n      }) =>\n        generateIncomeStatement(\n          { AccountModel, JournalEntryModel, country, orgField },\n          params,\n        ),\n\n      generalLedger: (params: {\n        organizationId?: unknown;\n        dateOption: 'month' | 'quarter' | 'year' | 'custom';\n        dateValue: unknown;\n        accountId?: string;\n        filters?: Record<string, unknown>;\n      }) =>\n        generateGeneralLedger(\n          { AccountModel, JournalEntryModel, country, orgField, fiscalYearStartMonth },\n          params,\n        ),\n\n      cashFlow: (params: {\n        organizationId?: unknown;\n        dateOption: 'month' | 'quarter' | 'year' | 'custom';\n        dateValue: unknown;\n        businessName?: string;\n        filters?: Record<string, unknown>;\n      }) =>\n        generateCashFlow(\n          { AccountModel, JournalEntryModel, country, orgField },\n          params,\n        ),\n    };\n  }\n\n  // ── Account Type Helpers ───────────────────────────────────────────────────\n\n  /** Get all posting account types (accounts you can post transactions to) */\n  getPostingAccountTypes() {\n    return this.country.getPostingAccountTypes();\n  }\n\n  /** Validate an account type code */\n  isValidAccountType(code: string) {\n    return this.country.isValidAccountType(code);\n  }\n\n  /** Get account type definition by code */\n  getAccountType(code: string) {\n    return this.country.getAccountType(code);\n  }\n\n  /** Get tax codes for a region */\n  getTaxCodesForRegion(region: string) {\n    return this.country.getTaxCodesForRegion(region);\n  }\n\n  // ── Repository Factories ─────────────────────────────────────────────────\n\n  /**\n   * Create a fully-configured journal entry repository with secure plugin wiring.\n   * This is the **recommended** way to set up journal entry repositories.\n   *\n   * Includes:\n   * - Double-entry plugin with account existence + tenant integrity validation\n   * - Fiscal lock plugin (when FiscalPeriodModel is provided)\n   * - post(), unpost(), reverse(), and duplicate() domain methods\n   *\n   * @param createRepository - The `createRepository` function from @classytic/mongokit\n   * @param models.JournalEntryModel - Mongoose model for journal entries\n   * @param models.AccountModel - Mongoose model for accounts (required for secure posted-create validation)\n   * @param models.FiscalPeriodModel - Mongoose model for fiscal periods (optional, enables fiscal lock)\n   * @param additionalPlugins - Extra plugins to include (e.g. timestampPlugin)\n   * @returns A wired repository with post(), unpost(), reverse(), duplicate(), and all plugins configured\n   */\n  createJournalEntryRepository(\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    createRepository: (model: Model<unknown>, plugins: any[]) => any,\n    models: {\n      JournalEntryModel: Model<unknown>;\n      AccountModel: Model<unknown>;\n      FiscalPeriodModel?: Model<unknown>;\n    },\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    additionalPlugins: any[] = [],\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  ): any {\n    const orgField = this.config.multiTenant?.orgField;\n    const { JournalEntryModel, AccountModel, FiscalPeriodModel } = models;\n\n    const plugins = [\n      ...additionalPlugins,\n      doubleEntryPlugin({\n        JournalEntryModel,\n        AccountModel,\n        orgField,\n      }),\n    ];\n\n    if (FiscalPeriodModel) {\n      plugins.push(\n        fiscalLockPlugin({\n          FiscalPeriodModel,\n          JournalEntryModel,\n          orgField,\n        }),\n      );\n    }\n\n    if (this.config.idempotency) {\n      plugins.push(\n        idempotencyPlugin({\n          JournalEntryModel,\n          orgField,\n        }),\n      );\n    }\n\n    const repository = createRepository(JournalEntryModel, plugins);\n    wireJournalEntryMethods(repository, JournalEntryModel, orgField, this.config.strictness);\n    return repository;\n  }\n\n  /**\n   * Wire post/reverse domain methods onto a mongokit Repository\n   * for journal entries. The repository must already be created via\n   * `createRepository(Model, plugins)` from @classytic/mongokit.\n   *\n   * **Note:** Prefer `createJournalEntryRepository()` which guarantees\n   * secure plugin wiring. This method only adds domain methods and does\n   * not validate plugin configuration.\n   *\n   * @param repository - An existing mongokit Repository instance\n   * @param JournalEntryModel - The Mongoose model for journal entries\n   * @returns The same repository, now with `.post()` and `.reverse()`\n   */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  wireJournalEntryRepository(repository: any, JournalEntryModel: Model<unknown>): any {\n    const orgField = this.config.multiTenant?.orgField;\n    wireJournalEntryMethods(repository, JournalEntryModel, orgField, this.config.strictness);\n    return repository;\n  }\n\n  /**\n   * Wire seedAccounts/bulkCreate and posting-account validation onto a\n   * mongokit Repository for accounts. The repository must already be\n   * created via `createRepository(Model, plugins)` from @classytic/mongokit.\n   *\n   * @param repository - An existing mongokit Repository instance\n   * @param AccountModel - The Mongoose model for accounts\n   * @returns The same repository, now with `.seedAccounts()` and `.bulkCreate()`\n   */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  wireAccountRepository(repository: any, AccountModel: Model<unknown>): any {\n    const orgField = this.config.multiTenant?.orgField;\n    wireAccountMethods(repository, AccountModel, this.country, orgField);\n    return repository;\n  }\n}\n\n// ── Factory ────────────────────────────────────────────────────────────────\n\nexport function createAccountingEngine(config: AccountingEngineConfig): AccountingEngine {\n  return new AccountingEngine(config);\n}\n"],"mappings":";;;;;;;;;;;;;;AA0CA,IAAa,mBAAb,MAA8B;CAC5B,AAAS;CACT,AAAS;CACT,AAAS;CACT,AAAS,QAAQ;CAEjB,YAAY,QAAgC;AAC1C,OAAK,SAAS;AACd,OAAK,UAAU,OAAO;AACtB,OAAK,WAAW,OAAO;;CAKzB,oBAAoB,SAAyB;AAC3C,SAAO,oBAAoB,KAAK,QAAQ,QAAQ;;CAGlD,yBAAyB,kBAA0B,SAAgC;AACjF,SAAO,yBAAyB,KAAK,QAAQ,kBAAkB,QAAQ;;CAGzE,yBAAyB,SAAyB;AAChD,SAAO,yBAAyB,KAAK,QAAQ,QAAQ;;CAKvD,cAAc,QAGX;EACD,MAAM,EAAE,SAAS,cAAc,cAAc,sBAAsB;EACnE,MAAM,EAAE,SAAS,WAAW;EAC5B,MAAM,WAAW,OAAO,aAAa;EACrC,MAAM,uBAAuB,OAAO,wBAAwB;EAC5D,MAAM,uBAAuB,OAAO;EACpC,MAAM,0BAA0B,OAAO;AAEvC,SAAO;GACL,eAAe,WAOb,qBACE;IAAE;IAAc;IAAmB;IAAS;IAAU;IAAsB,EAC5E,OACD;GAEH,eAAe,WAOb,qBACE;IAAE;IAAc;IAAmB;IAAS;IAAU;IAAsB;IAAsB;IAAyB,EAC3H,OACD;GAEH,kBAAkB,WAOhB,wBACE;IAAE;IAAc;IAAmB;IAAS;IAAU,EACtD,OACD;GAEH,gBAAgB,WAOd,sBACE;IAAE;IAAc;IAAmB;IAAS;IAAU;IAAsB,EAC5E,OACD;GAEH,WAAW,WAOT,iBACE;IAAE;IAAc;IAAmB;IAAS;IAAU,EACtD,OACD;GACJ;;;CAMH,yBAAyB;AACvB,SAAO,KAAK,QAAQ,wBAAwB;;;CAI9C,mBAAmB,MAAc;AAC/B,SAAO,KAAK,QAAQ,mBAAmB,KAAK;;;CAI9C,eAAe,MAAc;AAC3B,SAAO,KAAK,QAAQ,eAAe,KAAK;;;CAI1C,qBAAqB,QAAgB;AACnC,SAAO,KAAK,QAAQ,qBAAqB,OAAO;;;;;;;;;;;;;;;;;;CAqBlD,6BAEE,kBACA,QAMA,oBAA2B,EAAE,EAExB;EACL,MAAM,WAAW,KAAK,OAAO,aAAa;EAC1C,MAAM,EAAE,mBAAmB,cAAc,sBAAsB;EAE/D,MAAM,UAAU,CACd,GAAG,mBACH,kBAAkB;GAChB;GACA;GACA;GACD,CAAC,CACH;AAED,MAAI,kBACF,SAAQ,KACN,iBAAiB;GACf;GACA;GACA;GACD,CAAC,CACH;AAGH,MAAI,KAAK,OAAO,YACd,SAAQ,KACN,kBAAkB;GAChB;GACA;GACD,CAAC,CACH;EAGH,MAAM,aAAa,iBAAiB,mBAAmB,QAAQ;AAC/D,0BAAwB,YAAY,mBAAmB,UAAU,KAAK,OAAO,WAAW;AACxF,SAAO;;;;;;;;;;;;;;;CAiBT,2BAA2B,YAAiB,mBAAwC;EAClF,MAAM,WAAW,KAAK,OAAO,aAAa;AAC1C,0BAAwB,YAAY,mBAAmB,UAAU,KAAK,OAAO,WAAW;AACxF,SAAO;;;;;;;;;;;CAaT,sBAAsB,YAAiB,cAAmC;EACxE,MAAM,WAAW,KAAK,OAAO,aAAa;AAC1C,qBAAmB,YAAY,cAAc,KAAK,SAAS,SAAS;AACpE,SAAO;;;AAMX,SAAgB,uBAAuB,QAAkD;AACvF,QAAO,IAAI,iBAAiB,OAAO"}

package/dist/journals-CI3Wb4EF.mjs

@@ -0,0 +1,92 @@
+//#region src/constants/journals.ts
+const JOURNAL_TYPES = Object.freeze({
+	SALES: {
+		code: "SALES",
+		name: "Sales Journal",
+		description: "Sales transactions and revenue"
+	},
+	PURCHASES: {
+		code: "PURCHASES",
+		name: "Purchases Journal",
+		description: "Purchase transactions and expenses"
+	},
+	CASH_RECEIPTS: {
+		code: "CASH_RECEIPTS",
+		name: "Cash Receipts Journal",
+		description: "Cash and bank deposits received"
+	},
+	CASH_PAYMENTS: {
+		code: "CASH_PAYMENTS",
+		name: "Cash Payments Journal",
+		description: "Cash and bank payments made"
+	},
+	PAYROLL: {
+		code: "PAYROLL",
+		name: "Payroll Journal",
+		description: "Employee wages, salaries, and related expenses"
+	},
+	GENERAL: {
+		code: "GENERAL",
+		name: "General Journal",
+		description: "Adjusting entries, corrections, and misc transactions"
+	},
+	INVENTORY: {
+		code: "INVENTORY",
+		name: "Inventory Journal",
+		description: "Inventory adjustments and movements"
+	},
+	FIXED_ASSETS: {
+		code: "FIXED_ASSETS",
+		name: "Fixed Assets Journal",
+		description: "Asset purchases, disposals, and depreciation"
+	},
+	BANK_RECONCILIATION: {
+		code: "BANK_RECONCILIATION",
+		name: "Bank Reconciliation",
+		description: "Bank reconciliation adjustments"
+	},
+	DEPRECIATION: {
+		code: "DEPRECIATION",
+		name: "Depreciation Journal",
+		description: "Periodic depreciation expenses"
+	},
+	YEAR_END: {
+		code: "YEAR_END",
+		name: "Year-End Adjustments",
+		description: "Year-end closing and adjustment entries"
+	},
+	ACCOUNTS_RECEIVABLE: {
+		code: "ACCOUNTS_RECEIVABLE",
+		name: "Accounts Receivable",
+		description: "Customer invoices and receivable transactions"
+	},
+	ACCOUNTS_PAYABLE: {
+		code: "ACCOUNTS_PAYABLE",
+		name: "Accounts Payable",
+		description: "Vendor bills and payable transactions"
+	},
+	TAX: {
+		code: "TAX",
+		name: "Tax Journal",
+		description: "GST/HST/PST and other tax-related entries"
+	},
+	MISC: {
+		code: "MISC",
+		name: "Miscellaneous",
+		description: "Transactions that don't fit other categories"
+	}
+});
+const JOURNAL_CODES = Object.freeze(Object.fromEntries(Object.keys(JOURNAL_TYPES).map((k) => [k, k])));
+function getJournalTypeCodes() {
+	return Object.keys(JOURNAL_TYPES);
+}
+function isValidJournalType(code) {
+	return code in JOURNAL_TYPES;
+}
+function getJournalType(code) {
+	return JOURNAL_TYPES[code] ?? null;
+}
+
+//#endregion
+export { isValidJournalType as a, getJournalTypeCodes as i, JOURNAL_TYPES as n, getJournalType as r, JOURNAL_CODES as t };
+//# sourceMappingURL=journals-CI3Wb4EF.mjs.map

package/dist/journals-CI3Wb4EF.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"journals-CI3Wb4EF.mjs","names":[],"sources":["../src/constants/journals.ts"],"sourcesContent":["/**\r\n * Journal Types — Standard journal classifications.\r\n * Extensible: country packs can add custom journal types.\r\n */\r\n\r\nimport type { JournalType } from '../types/core.js';\r\n\r\nexport const JOURNAL_TYPES: Readonly<Record<string, JournalType>> = Object.freeze({\r\n  SALES:              { code: 'SALES', name: 'Sales Journal', description: 'Sales transactions and revenue' },\r\n  PURCHASES:          { code: 'PURCHASES', name: 'Purchases Journal', description: 'Purchase transactions and expenses' },\r\n  CASH_RECEIPTS:      { code: 'CASH_RECEIPTS', name: 'Cash Receipts Journal', description: 'Cash and bank deposits received' },\r\n  CASH_PAYMENTS:      { code: 'CASH_PAYMENTS', name: 'Cash Payments Journal', description: 'Cash and bank payments made' },\r\n  PAYROLL:            { code: 'PAYROLL', name: 'Payroll Journal', description: 'Employee wages, salaries, and related expenses' },\r\n  GENERAL:            { code: 'GENERAL', name: 'General Journal', description: 'Adjusting entries, corrections, and misc transactions' },\r\n  INVENTORY:          { code: 'INVENTORY', name: 'Inventory Journal', description: 'Inventory adjustments and movements' },\r\n  FIXED_ASSETS:       { code: 'FIXED_ASSETS', name: 'Fixed Assets Journal', description: 'Asset purchases, disposals, and depreciation' },\r\n  BANK_RECONCILIATION:{ code: 'BANK_RECONCILIATION', name: 'Bank Reconciliation', description: 'Bank reconciliation adjustments' },\r\n  DEPRECIATION:       { code: 'DEPRECIATION', name: 'Depreciation Journal', description: 'Periodic depreciation expenses' },\r\n  YEAR_END:           { code: 'YEAR_END', name: 'Year-End Adjustments', description: 'Year-end closing and adjustment entries' },\r\n  ACCOUNTS_RECEIVABLE:{ code: 'ACCOUNTS_RECEIVABLE', name: 'Accounts Receivable', description: 'Customer invoices and receivable transactions' },\r\n  ACCOUNTS_PAYABLE:   { code: 'ACCOUNTS_PAYABLE', name: 'Accounts Payable', description: 'Vendor bills and payable transactions' },\r\n  TAX:                { code: 'TAX', name: 'Tax Journal', description: 'GST/HST/PST and other tax-related entries' },\r\n  MISC:               { code: 'MISC', name: 'Miscellaneous', description: 'Transactions that don\\'t fit other categories' },\r\n});\r\n\r\nexport const JOURNAL_CODES = Object.freeze(\r\n  Object.fromEntries(Object.keys(JOURNAL_TYPES).map(k => [k, k])) as Record<string, string>,\r\n);\r\n\r\nexport function getJournalTypeCodes(): string[] {\r\n  return Object.keys(JOURNAL_TYPES);\r\n}\r\n\r\nexport function isValidJournalType(code: string): boolean {\r\n  return code in JOURNAL_TYPES;\r\n}\r\n\r\nexport function getJournalType(code: string): JournalType | null {\r\n  return JOURNAL_TYPES[code] ?? null;\r\n}\r\n"],"mappings":";AAOA,MAAa,gBAAuD,OAAO,OAAO;CAChF,OAAoB;EAAE,MAAM;EAAS,MAAM;EAAiB,aAAa;EAAkC;CAC3G,WAAoB;EAAE,MAAM;EAAa,MAAM;EAAqB,aAAa;EAAsC;CACvH,eAAoB;EAAE,MAAM;EAAiB,MAAM;EAAyB,aAAa;EAAmC;CAC5H,eAAoB;EAAE,MAAM;EAAiB,MAAM;EAAyB,aAAa;EAA+B;CACxH,SAAoB;EAAE,MAAM;EAAW,MAAM;EAAmB,aAAa;EAAkD;CAC/H,SAAoB;EAAE,MAAM;EAAW,MAAM;EAAmB,aAAa;EAAyD;CACtI,WAAoB;EAAE,MAAM;EAAa,MAAM;EAAqB,aAAa;EAAuC;CACxH,cAAoB;EAAE,MAAM;EAAgB,MAAM;EAAwB,aAAa;EAAgD;CACvI,qBAAoB;EAAE,MAAM;EAAuB,MAAM;EAAuB,aAAa;EAAmC;CAChI,cAAoB;EAAE,MAAM;EAAgB,MAAM;EAAwB,aAAa;EAAkC;CACzH,UAAoB;EAAE,MAAM;EAAY,MAAM;EAAwB,aAAa;EAA2C;CAC9H,qBAAoB;EAAE,MAAM;EAAuB,MAAM;EAAuB,aAAa;EAAiD;CAC9I,kBAAoB;EAAE,MAAM;EAAoB,MAAM;EAAoB,aAAa;EAAyC;CAChI,KAAoB;EAAE,MAAM;EAAO,MAAM;EAAe,aAAa;EAA6C;CAClH,MAAoB;EAAE,MAAM;EAAQ,MAAM;EAAiB,aAAa;EAAiD;CAC1H,CAAC;AAEF,MAAa,gBAAgB,OAAO,OAClC,OAAO,YAAY,OAAO,KAAK,cAAc,CAAC,KAAI,MAAK,CAAC,GAAG,EAAE,CAAC,CAAC,CAChE;AAED,SAAgB,sBAAgC;AAC9C,QAAO,OAAO,KAAK,cAAc;;AAGnC,SAAgB,mBAAmB,MAAuB;AACxD,QAAO,QAAQ;;AAGjB,SAAgB,eAAe,MAAkC;AAC/D,QAAO,cAAc,SAAS"}

package/dist/logger-Cv6VVc4r.d.mts

@@ -0,0 +1,15 @@
+//#region src/utils/logger.d.ts
+/**
+ * Minimal logger interface for the accounting package.
+ * Defaults to console. App layer can inject a real logger (Winston/Pino).
+ */
+interface Logger {
+  warn(message: string, meta?: Record<string, unknown>): void;
+  error(message: string, meta?: Record<string, unknown>): void;
+  info(message: string, meta?: Record<string, unknown>): void;
+}
+/** Default console-based implementation */
+declare const defaultLogger: Logger;
+//#endregion
+export { defaultLogger as n, Logger as t };
+//# sourceMappingURL=logger-Cv6VVc4r.d.mts.map

package/dist/logger-Cv6VVc4r.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger-Cv6VVc4r.d.mts","names":[],"sources":["../src/utils/logger.ts"],"mappings":";;AAIA;;;UAAiB,MAAA;EACf,IAAA,CAAK,OAAA,UAAiB,IAAA,GAAO,MAAA;EAC7B,KAAA,CAAM,OAAA,UAAiB,IAAA,GAAO,MAAA;EAC9B,IAAA,CAAK,OAAA,UAAiB,IAAA,GAAO,MAAA;AAAA;;cAIlB,aAAA,EAAe,MAAA"}

package/dist/money.d.mts

@@ -0,0 +1,129 @@
+//#region src/money.d.ts
+/**
+ * Money — Integer-cents arithmetic helpers for safe financial computation.
+ *
+ * Provides utilities that operate on **integer minor-unit values** (cents) to
+ * avoid floating-point rounding errors in intermediate calculations.
+ *
+ * **DB storage contract:**
+ * Journal entry `debit` / `credit` / `totalDebit` / `totalCredit` fields are
+ * stored as **integer cents** (e.g. 10050 for $100.50). All report outputs,
+ * aggregation results, and repository methods return integer cents.
+ *
+ * Use `Money.fromDecimal()` to convert user-facing dollar inputs to cents
+ * at the HTTP/API boundary. Use `Money.toDecimal()` or `Money.formatPlain()`
+ * to convert cents back to dollars for display or CSV export.
+ *
+ * Example workflow:
+ *   const cents = Money.fromDecimal(req.body.debit);  // 100.50 → 10050
+ *   const taxCents = Money.percentage(cents, 5);       // 5% → 502 (rounded)
+ *   const display = Money.formatPlain(taxCents);       // 502 → "5.02"
+ *
+ * Inspired by Stripe's money handling — simple, correct, auditable.
+ *
+ * @module @classytic/ledger/money
+ */
+/** Round a floating-point value to the nearest integer cent */
+declare function round(amount: number): number;
+/** Convert a decimal dollar amount to integer cents: 10.50 → 1050 */
+declare function fromDecimal(dollars: number, minorUnit?: number): number;
+/** Convert integer cents to a decimal dollar amount: 1050 → 10.50 */
+declare function toDecimal(cents: number, minorUnit?: number): number;
+/** Add two cent amounts */
+declare function add(a: number, b: number): number;
+/** Subtract b from a in cents */
+declare function subtract(a: number, b: number): number;
+/** Multiply cents by a factor, rounding to nearest cent */
+declare function multiply(cents: number, factor: number): number;
+/**
+ * Calculate a percentage of a cent amount.
+ * percentage(10000, 5) → 500 (5% of $100.00 = $5.00)
+ */
+declare function percentage(cents: number, rate: number): number;
+/**
+ * Calculate tax from a tax-inclusive amount.
+ * splitTaxInclusive(10500, 0.05) → { base: 10000, tax: 500 }
+ */
+declare function splitTaxInclusive(inclusiveAmount: number, taxRate: number): {
+  base: number;
+  tax: number;
+};
+/**
+ * Calculate tax from a tax-exclusive amount.
+ * splitTaxExclusive(10000, 0.05) → { base: 10000, tax: 500, total: 10500 }
+ */
+declare function splitTaxExclusive(exclusiveAmount: number, taxRate: number): {
+  base: number;
+  tax: number;
+  total: number;
+};
+/**
+ * Allocate cents across ratios with zero remainder error.
+ * Uses largest-remainder method (same as parliamentary seat allocation).
+ *
+ * allocate(1000, [1, 1, 1]) → [334, 333, 333]  (sums to 1000 exactly)
+ * allocate(10000, [50, 30, 20]) → [5000, 3000, 2000]
+ */
+declare function allocate(totalCents: number, ratios: number[]): number[];
+/** Are two cent amounts equal? */
+declare function equals(a: number, b: number): boolean;
+/** Is the amount zero? */
+declare function isZero(cents: number): boolean;
+/** Is the amount positive (> 0)? */
+declare function isPositive(cents: number): boolean;
+/** Is the amount negative (< 0)? */
+declare function isNegative(cents: number): boolean;
+/** Absolute value */
+declare function abs(cents: number): number;
+/** Negate */
+declare function negate(cents: number): number;
+/** Min of two amounts */
+declare function min(a: number, b: number): number;
+/** Max of two amounts */
+declare function max(a: number, b: number): number;
+/**
+ * Format cents as a currency string.
+ * format(10550, 'CAD') → "$105.50"
+ * format(10550, 'CAD', 'en-CA') → "$105.50"
+ */
+declare function format(cents: number, currencyCode?: string, locale?: string, minorUnit?: number): string;
+/**
+ * Format cents as a plain decimal string (no currency symbol).
+ * formatPlain(10550) → "105.50"
+ */
+declare function formatPlain(cents: number, minorUnit?: number): string;
+/** Is the value a valid integer cent amount? */
+declare function isValid(value: unknown): value is number;
+/**
+ * Parse a string or number into cents.
+ * parseCents("105.50") → 10550
+ * parseCents(105.50) → 10550
+ */
+declare function parseCents(input: string | number, minorUnit?: number): number;
+declare const Money: {
+  readonly round: typeof round;
+  readonly fromDecimal: typeof fromDecimal;
+  readonly toDecimal: typeof toDecimal;
+  readonly add: typeof add;
+  readonly subtract: typeof subtract;
+  readonly multiply: typeof multiply;
+  readonly percentage: typeof percentage;
+  readonly splitTaxInclusive: typeof splitTaxInclusive;
+  readonly splitTaxExclusive: typeof splitTaxExclusive;
+  readonly allocate: typeof allocate;
+  readonly equals: typeof equals;
+  readonly isZero: typeof isZero;
+  readonly isPositive: typeof isPositive;
+  readonly isNegative: typeof isNegative;
+  readonly abs: typeof abs;
+  readonly negate: typeof negate;
+  readonly min: typeof min;
+  readonly max: typeof max;
+  readonly format: typeof format;
+  readonly formatPlain: typeof formatPlain;
+  readonly isValid: typeof isValid;
+  readonly parseCents: typeof parseCents;
+};
+//#endregion
+export { Money, abs, add, allocate, equals, format, formatPlain, fromDecimal, isNegative, isPositive, isValid, isZero, max, min, multiply, negate, parseCents, percentage, round, splitTaxExclusive, splitTaxInclusive, subtract, toDecimal };
+//# sourceMappingURL=money.d.mts.map

package/dist/money.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"money.d.mts","names":[],"sources":["../src/money.ts"],"mappings":";;AA4BA;;;;;AAKA;;;;;AAMA;;;;;AAMA;;;;;AAKA;;;;iBAtBgB,KAAA,CAAM,MAAA;AA2BtB;AAAA,iBAtBgB,WAAA,CAAY,OAAA,UAAiB,SAAA;;iBAM7B,SAAA,CAAU,KAAA,UAAe,SAAA;;iBAMzB,GAAA,CAAI,CAAA,UAAW,CAAA;;iBAKf,QAAA,CAAS,CAAA,UAAW,CAAA;;iBAKpB,QAAA,CAAS,KAAA,UAAe,MAAA;AAgBxC;;;;AAAA,iBARgB,UAAA,CAAW,KAAA,UAAe,IAAA;;;;;iBAQ1B,iBAAA,CACd,eAAA,UACA,OAAA;EACG,IAAA;EAAc,GAAA;AAAA;;;;;iBAUH,iBAAA,CACd,eAAA,UACA,OAAA;EACG,IAAA;EAAc,GAAA;EAAa,KAAA;AAAA;;;;;AA0ChC;;;iBA5BgB,QAAA,CAAS,UAAA,UAAoB,MAAA;;iBA4B7B,MAAA,CAAO,CAAA,UAAW,CAAA;;iBAKlB,MAAA,CAAO,KAAA;;iBAKP,UAAA,CAAW,KAAA;AAA3B;AAAA,iBAKgB,UAAA,CAAW,KAAA;;iBAKX,GAAA,CAAI,KAAA;;iBAKJ,MAAA,CAAO,KAAA;;iBAKP,GAAA,CAAI,CAAA,UAAW,CAAA;;iBAKf,GAAA,CAAI,CAAA,UAAW,CAAA;AAf/B;;;;;AAAA,iBA0BgB,MAAA,CACd,KAAA,UACA,YAAA,WACA,MAAA,WACA,SAAA;;;;;iBAac,WAAA,CAAY,KAAA,UAAe,SAAA;;iBAO3B,OAAA,CAAQ,KAAA,YAAiB,KAAA;;;AAnCzC;;;iBA4CgB,UAAA,CAAW,KAAA,mBAAwB,SAAA;AAAA,cAWtC,KAAA;EAAA"}

package/dist/money.mjs

@@ -0,0 +1,197 @@
+//#region src/money.ts
+/**
+* Money — Integer-cents arithmetic helpers for safe financial computation.
+*
+* Provides utilities that operate on **integer minor-unit values** (cents) to
+* avoid floating-point rounding errors in intermediate calculations.
+*
+* **DB storage contract:**
+* Journal entry `debit` / `credit` / `totalDebit` / `totalCredit` fields are
+* stored as **integer cents** (e.g. 10050 for $100.50). All report outputs,
+* aggregation results, and repository methods return integer cents.
+*
+* Use `Money.fromDecimal()` to convert user-facing dollar inputs to cents
+* at the HTTP/API boundary. Use `Money.toDecimal()` or `Money.formatPlain()`
+* to convert cents back to dollars for display or CSV export.
+*
+* Example workflow:
+*   const cents = Money.fromDecimal(req.body.debit);  // 100.50 → 10050
+*   const taxCents = Money.percentage(cents, 5);       // 5% → 502 (rounded)
+*   const display = Money.formatPlain(taxCents);       // 502 → "5.02"
+*
+* Inspired by Stripe's money handling — simple, correct, auditable.
+*
+* @module @classytic/ledger/money
+*/
+/** Round a floating-point value to the nearest integer cent */
+function round(amount) {
+	return Math.round(amount);
+}
+/** Convert a decimal dollar amount to integer cents: 10.50 → 1050 */
+function fromDecimal(dollars, minorUnit = 2) {
+	const factor = 10 ** minorUnit;
+	return Math.round(dollars * factor);
+}
+/** Convert integer cents to a decimal dollar amount: 1050 → 10.50 */
+function toDecimal(cents, minorUnit = 2) {
+	return cents / 10 ** minorUnit;
+}
+/** Add two cent amounts */
+function add(a, b) {
+	return a + b;
+}
+/** Subtract b from a in cents */
+function subtract(a, b) {
+	return a - b;
+}
+/** Multiply cents by a factor, rounding to nearest cent */
+function multiply(cents, factor) {
+	return Math.round(cents * factor);
+}
+/**
+* Calculate a percentage of a cent amount.
+* percentage(10000, 5) → 500 (5% of $100.00 = $5.00)
+*/
+function percentage(cents, rate) {
+	return Math.round(cents * rate / 100);
+}
+/**
+* Calculate tax from a tax-inclusive amount.
+* splitTaxInclusive(10500, 0.05) → { base: 10000, tax: 500 }
+*/
+function splitTaxInclusive(inclusiveAmount, taxRate) {
+	const base = Math.round(inclusiveAmount / (1 + taxRate));
+	return {
+		base,
+		tax: inclusiveAmount - base
+	};
+}
+/**
+* Calculate tax from a tax-exclusive amount.
+* splitTaxExclusive(10000, 0.05) → { base: 10000, tax: 500, total: 10500 }
+*/
+function splitTaxExclusive(exclusiveAmount, taxRate) {
+	const tax = Math.round(exclusiveAmount * taxRate);
+	return {
+		base: exclusiveAmount,
+		tax,
+		total: exclusiveAmount + tax
+	};
+}
+/**
+* Allocate cents across ratios with zero remainder error.
+* Uses largest-remainder method (same as parliamentary seat allocation).
+*
+* allocate(1000, [1, 1, 1]) → [334, 333, 333]  (sums to 1000 exactly)
+* allocate(10000, [50, 30, 20]) → [5000, 3000, 2000]
+*/
+function allocate(totalCents, ratios) {
+	if (ratios.length === 0) throw new Error("Ratios must be non-empty");
+	if (ratios.some((r) => r < 0)) throw new Error("Ratios must be non-negative");
+	const ratioSum = ratios.reduce((s, r) => s + r, 0);
+	if (ratioSum === 0) throw new Error("Sum of ratios must be > 0");
+	const allocations = ratios.map((r) => Math.floor(totalCents * r / ratioSum));
+	let remainder = totalCents - allocations.reduce((s, a) => s + a, 0);
+	const fractions = ratios.map((r, i) => ({
+		index: i,
+		frac: totalCents * r / ratioSum - allocations[i]
+	}));
+	fractions.sort((a, b) => b.frac - a.frac);
+	for (let i = 0; i < remainder; i++) allocations[fractions[i].index]++;
+	return allocations;
+}
+/** Are two cent amounts equal? */
+function equals(a, b) {
+	return a === b;
+}
+/** Is the amount zero? */
+function isZero(cents) {
+	return cents === 0;
+}
+/** Is the amount positive (> 0)? */
+function isPositive(cents) {
+	return cents > 0;
+}
+/** Is the amount negative (< 0)? */
+function isNegative(cents) {
+	return cents < 0;
+}
+/** Absolute value */
+function abs(cents) {
+	return Math.abs(cents);
+}
+/** Negate */
+function negate(cents) {
+	return -cents;
+}
+/** Min of two amounts */
+function min(a, b) {
+	return Math.min(a, b);
+}
+/** Max of two amounts */
+function max(a, b) {
+	return Math.max(a, b);
+}
+/**
+* Format cents as a currency string.
+* format(10550, 'CAD') → "$105.50"
+* format(10550, 'CAD', 'en-CA') → "$105.50"
+*/
+function format(cents, currencyCode = "CAD", locale = "en-CA", minorUnit = 2) {
+	const dollars = toDecimal(cents, minorUnit);
+	return new Intl.NumberFormat(locale, {
+		style: "currency",
+		currency: currencyCode
+	}).format(dollars);
+}
+/**
+* Format cents as a plain decimal string (no currency symbol).
+* formatPlain(10550) → "105.50"
+*/
+function formatPlain(cents, minorUnit = 2) {
+	return toDecimal(cents, minorUnit).toFixed(minorUnit);
+}
+/** Is the value a valid integer cent amount? */
+function isValid(value) {
+	return typeof value === "number" && Number.isFinite(value) && Number.isInteger(value);
+}
+/**
+* Parse a string or number into cents.
+* parseCents("105.50") → 10550
+* parseCents(105.50) → 10550
+*/
+function parseCents(input, minorUnit = 2) {
+	if (typeof input === "number") return fromDecimal(input, minorUnit);
+	const cleaned = input.replace(/[$,\s]/g, "");
+	const parsed = parseFloat(cleaned);
+	if (isNaN(parsed)) throw new Error(`Cannot parse "${input}" as money`);
+	return fromDecimal(parsed, minorUnit);
+}
+const Money = {
+	round,
+	fromDecimal,
+	toDecimal,
+	add,
+	subtract,
+	multiply,
+	percentage,
+	splitTaxInclusive,
+	splitTaxExclusive,
+	allocate,
+	equals,
+	isZero,
+	isPositive,
+	isNegative,
+	abs,
+	negate,
+	min,
+	max,
+	format,
+	formatPlain,
+	isValid,
+	parseCents
+};
+
+//#endregion
+export { Money, abs, add, allocate, equals, format, formatPlain, fromDecimal, isNegative, isPositive, isValid, isZero, max, min, multiply, negate, parseCents, percentage, round, splitTaxExclusive, splitTaxInclusive, subtract, toDecimal };
+//# sourceMappingURL=money.mjs.map