@classytic/ledger 0.9.1 → 0.10.1

package/dist/outbox-store-BbKdQ2eT.mjs

@@ -0,0 +1,253 @@
+import { createEvent, matchEventPattern } from "@classytic/primitives/events";
+import { z } from "zod";
+import { InvalidOutboxEventError, OutboxOwnershipError } from "@classytic/primitives/outbox";
+//#region src/events/event-constants.ts
+/**
+* Ledger domain event names.
+*
+* Convention: `ledger:<resource>.<verb>` — matches the catalog/revenue/flow
+* namespace pattern so hosts can subscribe with a single glob
+* (`ledger:entry.*`, `ledger:*`).
+*/
+const LEDGER_EVENTS = {
+	ENTRY_CREATED: "ledger:entry.created",
+	ENTRY_POSTED: "ledger:entry.posted",
+	ENTRY_UNPOSTED: "ledger:entry.unposted",
+	ENTRY_ARCHIVED: "ledger:entry.archived",
+	ENTRY_DUPLICATED: "ledger:entry.duplicated",
+	ENTRY_REVERSED: "ledger:entry.reversed",
+	ACCOUNT_SEEDED: "ledger:account.seeded",
+	ACCOUNT_BULK_CREATED: "ledger:account.bulk-created",
+	JOURNAL_SEEDED: "ledger:journal.seeded",
+	RECONCILIATION_MATCHED: "ledger:reconciliation.matched",
+	RECONCILIATION_UNMATCHED: "ledger:reconciliation.unmatched"
+};
+//#endregion
+//#region src/events/helpers.ts
+function toIdString(value) {
+	if (value == null) return void 0;
+	if (typeof value === "string") return value;
+	if (typeof value === "number" || typeof value === "bigint") return String(value);
+	const obj = value;
+	if (typeof obj.toHexString === "function") return obj.toHexString();
+	if (typeof obj.toString === "function") {
+		const s = obj.toString();
+		return s === "[object Object]" ? void 0 : s;
+	}
+}
+function createEvent$1(type, payload, ctx, meta) {
+	return createEvent(type, payload, {
+		userId: toIdString(ctx?.actorId),
+		organizationId: toIdString(ctx?.organizationId),
+		correlationId: ctx?.correlationId ?? ctx?.traceId,
+		...meta
+	});
+}
+//#endregion
+//#region src/events/in-process-bus.ts
+var InProcessLedgerBus = class {
+	name = "in-process-ledger";
+	handlers = /* @__PURE__ */ new Map();
+	logger;
+	constructor(options) {
+		this.logger = options?.logger ?? console;
+	}
+	async publish(event) {
+		const matched = /* @__PURE__ */ new Set();
+		for (const [pattern, set] of this.handlers.entries()) if (matchEventPattern(pattern, event.type)) for (const h of set) matched.add(h);
+		for (const handler of matched) try {
+			await handler(event);
+		} catch (err) {
+			this.logger.error(`[InProcessLedgerBus] Handler error for ${event.type}:`, err);
+		}
+	}
+	async publishMany(events) {
+		const results = /* @__PURE__ */ new Map();
+		for (const event of events) try {
+			await this.publish(event);
+			results.set(event.meta.id, null);
+		} catch (err) {
+			results.set(event.meta.id, err instanceof Error ? err : new Error(String(err)));
+		}
+		return results;
+	}
+	async subscribe(pattern, handler) {
+		if (!this.handlers.has(pattern)) this.handlers.set(pattern, /* @__PURE__ */ new Set());
+		this.handlers.get(pattern)?.add(handler);
+		return () => {
+			const set = this.handlers.get(pattern);
+			if (set) {
+				set.delete(handler);
+				if (set.size === 0) this.handlers.delete(pattern);
+			}
+		};
+	}
+	async close() {
+		this.handlers.clear();
+	}
+};
+//#endregion
+//#region src/events/ledger-event-catalog.ts
+function defineLedgerEvent(input) {
+	const { name, version = 1, description, zodSchema } = input;
+	const def = {
+		name,
+		version,
+		schema: z.toJSONSchema(zodSchema),
+		zodSchema,
+		create(payload, meta) {
+			return createEvent(name, payload, {
+				source: "ledger",
+				...meta
+			});
+		}
+	};
+	if (description !== void 0) def.description = description;
+	return def;
+}
+/**
+* Mongo ObjectId or string — repositories pass raw ObjectIds which JSON
+* serialise to hex strings. `passthrough()` via union keeps validation
+* permissive without demanding a cast at the emit site.
+*/
+const objectIdLike = z.union([z.string(), z.any()]);
+const seedCountsSchema = z.object({
+	created: z.number().int().nonnegative(),
+	skipped: z.number().int().nonnegative(),
+	organizationId: objectIdLike.optional()
+});
+const entryCreatedSchema = z.object({
+	entryId: objectIdLike,
+	journalType: z.string().optional(),
+	state: z.string(),
+	referenceNumber: z.string().optional(),
+	idempotencyKey: z.string().optional(),
+	organizationId: objectIdLike.optional()
+});
+const entryPostedSchema = z.object({
+	entryId: objectIdLike,
+	referenceNumber: z.string().optional(),
+	postedBy: objectIdLike.optional(),
+	totalDebit: z.number(),
+	totalCredit: z.number(),
+	organizationId: objectIdLike.optional()
+});
+const entryUnpostedSchema = z.object({
+	entryId: objectIdLike,
+	unpostedBy: objectIdLike.optional(),
+	organizationId: objectIdLike.optional()
+});
+const entryArchivedSchema = z.object({
+	entryId: objectIdLike,
+	archivedBy: objectIdLike.optional(),
+	organizationId: objectIdLike.optional()
+});
+const entryDuplicatedSchema = z.object({
+	sourceEntryId: objectIdLike,
+	duplicateEntryId: objectIdLike,
+	organizationId: objectIdLike.optional()
+});
+const entryReversedSchema = z.object({
+	originalEntryId: objectIdLike,
+	reversalEntryId: objectIdLike,
+	reversalDate: z.iso.datetime(),
+	reversedBy: objectIdLike.optional(),
+	organizationId: objectIdLike.optional()
+});
+const accountBulkCreatedSchema = z.object({
+	created: z.number().int().nonnegative(),
+	skipped: z.number().int().nonnegative(),
+	errors: z.number().int().nonnegative(),
+	organizationId: objectIdLike.optional()
+});
+const reconciliationMatchedSchema = z.object({
+	matchingNumber: z.string(),
+	account: objectIdLike,
+	itemCount: z.number().int().nonnegative(),
+	debitTotal: z.number(),
+	creditTotal: z.number(),
+	isFullReconcile: z.boolean(),
+	currency: z.string().nullable(),
+	organizationId: objectIdLike.optional()
+});
+const reconciliationUnmatchedSchema = z.object({
+	matchingNumber: z.string(),
+	itemCount: z.number().int().nonnegative(),
+	organizationId: objectIdLike.optional()
+});
+const EntryCreated = defineLedgerEvent({
+	name: LEDGER_EVENTS.ENTRY_CREATED,
+	description: "A journal entry was created (may be draft or posted depending on service).",
+	zodSchema: entryCreatedSchema
+});
+const EntryPosted = defineLedgerEvent({
+	name: LEDGER_EVENTS.ENTRY_POSTED,
+	description: "A journal entry was posted — balances are now final.",
+	zodSchema: entryPostedSchema
+});
+const EntryUnposted = defineLedgerEvent({
+	name: LEDGER_EVENTS.ENTRY_UNPOSTED,
+	description: "A previously posted entry was unposted (reverted to draft).",
+	zodSchema: entryUnpostedSchema
+});
+const EntryArchived = defineLedgerEvent({
+	name: LEDGER_EVENTS.ENTRY_ARCHIVED,
+	description: "An entry was archived — hidden from default queries, still on disk.",
+	zodSchema: entryArchivedSchema
+});
+const EntryDuplicated = defineLedgerEvent({
+	name: LEDGER_EVENTS.ENTRY_DUPLICATED,
+	description: "A new draft entry was produced by duplicating an existing one.",
+	zodSchema: entryDuplicatedSchema
+});
+const EntryReversed = defineLedgerEvent({
+	name: LEDGER_EVENTS.ENTRY_REVERSED,
+	description: "A posted entry was reversed — a new offsetting entry was booked.",
+	zodSchema: entryReversedSchema
+});
+const AccountSeeded = defineLedgerEvent({
+	name: LEDGER_EVENTS.ACCOUNT_SEEDED,
+	description: "Chart-of-accounts defaults were seeded for an organization.",
+	zodSchema: seedCountsSchema
+});
+const AccountBulkCreated = defineLedgerEvent({
+	name: LEDGER_EVENTS.ACCOUNT_BULK_CREATED,
+	description: "A bulk import of accounts completed.",
+	zodSchema: accountBulkCreatedSchema
+});
+const JournalSeeded = defineLedgerEvent({
+	name: LEDGER_EVENTS.JOURNAL_SEEDED,
+	description: "Default journals were seeded for an organization.",
+	zodSchema: seedCountsSchema
+});
+const ReconciliationMatched = defineLedgerEvent({
+	name: LEDGER_EVENTS.RECONCILIATION_MATCHED,
+	description: "A set of ledger items was matched under a reconciliation number.",
+	zodSchema: reconciliationMatchedSchema
+});
+const ReconciliationUnmatched = defineLedgerEvent({
+	name: LEDGER_EVENTS.RECONCILIATION_UNMATCHED,
+	description: "A previously matched reconciliation was unmatched.",
+	zodSchema: reconciliationUnmatchedSchema
+});
+/**
+* Every ledger event defined in the package — pass to Arc's
+* `EventRegistry`. Hosts wire ONE array; the whole `ledger:*` namespace
+* becomes introspectable via OpenAPI and auto-validated at publish time
+* when `eventPlugin({ validateMode: 'reject' })` is set.
+*/
+const ledgerEventDefinitions = [
+	EntryCreated,
+	EntryPosted,
+	EntryUnposted,
+	EntryArchived,
+	EntryDuplicated,
+	EntryReversed,
+	AccountSeeded,
+	AccountBulkCreated,
+	JournalSeeded,
+	ReconciliationMatched,
+	ReconciliationUnmatched
+];
+//#endregion
+export { LEDGER_EVENTS as _, EntryArchived as a, EntryPosted as c, JournalSeeded as d, ReconciliationMatched as f, createEvent$1 as g, InProcessLedgerBus as h, AccountSeeded as i, EntryReversed as l, ledgerEventDefinitions as m, OutboxOwnershipError as n, EntryCreated as o, ReconciliationUnmatched as p, AccountBulkCreated as r, EntryDuplicated as s, InvalidOutboxEventError as t, EntryUnposted as u };

package/dist/outbox-store-BcCiHMPw.d.mts

@@ -0,0 +1,305 @@
+import { DomainEvent, EventHandler, EventTransport, PublishManyResult } from "@classytic/primitives/events";
+import { z } from "zod";
+import { InvalidOutboxEventError, OutboxAcknowledgeOptions, OutboxClaimOptions, OutboxErrorInfo, OutboxFailOptions, OutboxFailureContext, OutboxFailureDecision, OutboxFailurePolicy, OutboxOwnershipError, OutboxStore, OutboxWriteOptions } from "@classytic/primitives/outbox";
+
+//#region src/events/event-constants.d.ts
+/**
+ * Ledger domain event names.
+ *
+ * Convention: `ledger:<resource>.<verb>` — matches the catalog/revenue/flow
+ * namespace pattern so hosts can subscribe with a single glob
+ * (`ledger:entry.*`, `ledger:*`).
+ */
+declare const LEDGER_EVENTS: {
+  readonly ENTRY_CREATED: "ledger:entry.created";
+  readonly ENTRY_POSTED: "ledger:entry.posted";
+  readonly ENTRY_UNPOSTED: "ledger:entry.unposted";
+  readonly ENTRY_ARCHIVED: "ledger:entry.archived";
+  readonly ENTRY_DUPLICATED: "ledger:entry.duplicated";
+  readonly ENTRY_REVERSED: "ledger:entry.reversed";
+  readonly ACCOUNT_SEEDED: "ledger:account.seeded";
+  readonly ACCOUNT_BULK_CREATED: "ledger:account.bulk-created";
+  readonly JOURNAL_SEEDED: "ledger:journal.seeded";
+  readonly RECONCILIATION_MATCHED: "ledger:reconciliation.matched";
+  readonly RECONCILIATION_UNMATCHED: "ledger:reconciliation.unmatched";
+};
+type LedgerEventName = (typeof LEDGER_EVENTS)[keyof typeof LEDGER_EVENTS];
+//#endregion
+//#region src/events/event-payloads.d.ts
+/**
+ * Typed payload definitions for ledger domain events.
+ */
+interface EntryCreatedPayload {
+  entryId: unknown;
+  journalType?: string;
+  state: string;
+  referenceNumber?: string;
+  idempotencyKey?: string;
+  organizationId?: unknown;
+}
+interface EntryPostedPayload {
+  entryId: unknown;
+  referenceNumber?: string;
+  postedBy?: unknown;
+  totalDebit: number;
+  totalCredit: number;
+  organizationId?: unknown;
+}
+interface EntryUnpostedPayload {
+  entryId: unknown;
+  unpostedBy?: unknown;
+  organizationId?: unknown;
+}
+interface EntryArchivedPayload {
+  entryId: unknown;
+  archivedBy?: unknown;
+  organizationId?: unknown;
+}
+interface EntryDuplicatedPayload {
+  sourceEntryId: unknown;
+  duplicateEntryId: unknown;
+  organizationId?: unknown;
+}
+interface EntryReversedPayload {
+  originalEntryId: unknown;
+  reversalEntryId: unknown;
+  reversalDate: Date;
+  reversedBy?: unknown;
+  organizationId?: unknown;
+}
+interface AccountSeededPayload {
+  created: number;
+  skipped: number;
+  organizationId?: unknown;
+}
+interface AccountBulkCreatedPayload {
+  created: number;
+  skipped: number;
+  errors: number;
+  organizationId?: unknown;
+}
+interface JournalSeededPayload {
+  created: number;
+  skipped: number;
+  organizationId?: unknown;
+}
+interface ReconciliationMatchedPayload {
+  matchingNumber: string;
+  account: unknown;
+  itemCount: number;
+  debitTotal: number;
+  creditTotal: number;
+  isFullReconcile: boolean;
+  currency: string | null;
+  organizationId?: unknown;
+}
+interface ReconciliationUnmatchedPayload {
+  matchingNumber: string;
+  itemCount: number;
+  organizationId?: unknown;
+}
+//#endregion
+//#region src/events/helpers.d.ts
+/** Minimal context shape for event metadata. */
+interface EventContext {
+  actorId?: unknown;
+  organizationId?: unknown;
+  correlationId?: string;
+  traceId?: string;
+}
+declare function createEvent$1<T>(type: string, payload: T, ctx?: EventContext, meta?: Partial<DomainEvent['meta']>): DomainEvent<T>;
+//#endregion
+//#region src/events/in-process-bus.d.ts
+/** Package-specific logger contract — `console` satisfies it. */
+interface EventLogger {
+  warn(message: string, ...args: unknown[]): void;
+  error(message: string, ...args: unknown[]): void;
+}
+interface InProcessLedgerBusOptions {
+  logger?: EventLogger;
+}
+declare class InProcessLedgerBus implements EventTransport {
+  readonly name = "in-process-ledger";
+  private handlers;
+  private logger;
+  constructor(options?: InProcessLedgerBusOptions);
+  publish(event: DomainEvent): Promise<void>;
+  publishMany(events: readonly DomainEvent[]): Promise<PublishManyResult>;
+  subscribe(pattern: string, handler: EventHandler): Promise<() => void>;
+  close(): Promise<void>;
+}
+//#endregion
+//#region src/events/ledger-event-catalog.d.ts
+interface LedgerEventSchema {
+  type: 'object';
+  properties?: Record<string, {
+    type?: string;
+    format?: string;
+    [key: string]: unknown;
+  }>;
+  required?: string[];
+  [key: string]: unknown;
+}
+interface LedgerEventDefinition<TSchema extends z.ZodType = z.ZodType> {
+  readonly name: string;
+  readonly version: number;
+  readonly description?: string;
+  readonly schema: LedgerEventSchema;
+  readonly zodSchema: TSchema;
+  create(payload: z.infer<TSchema>, meta?: Partial<DomainEvent['meta']>): DomainEvent<z.infer<TSchema>>;
+  readonly __payload?: z.infer<TSchema>;
+}
+type LedgerEventPayloadOf<D> = D extends LedgerEventDefinition<infer S> ? z.infer<S> : never;
+declare const seedCountsSchema: z.ZodObject<{
+  created: z.ZodNumber;
+  skipped: z.ZodNumber;
+  organizationId: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodAny]>>;
+}, z.core.$strip>;
+declare const entryCreatedSchema: z.ZodObject<{
+  entryId: z.ZodUnion<readonly [z.ZodString, z.ZodAny]>;
+  journalType: z.ZodOptional<z.ZodString>;
+  state: z.ZodString;
+  referenceNumber: z.ZodOptional<z.ZodString>;
+  idempotencyKey: z.ZodOptional<z.ZodString>;
+  organizationId: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodAny]>>;
+}, z.core.$strip>;
+declare const entryPostedSchema: z.ZodObject<{
+  entryId: z.ZodUnion<readonly [z.ZodString, z.ZodAny]>;
+  referenceNumber: z.ZodOptional<z.ZodString>;
+  postedBy: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodAny]>>;
+  totalDebit: z.ZodNumber;
+  totalCredit: z.ZodNumber;
+  organizationId: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodAny]>>;
+}, z.core.$strip>;
+declare const entryUnpostedSchema: z.ZodObject<{
+  entryId: z.ZodUnion<readonly [z.ZodString, z.ZodAny]>;
+  unpostedBy: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodAny]>>;
+  organizationId: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodAny]>>;
+}, z.core.$strip>;
+declare const entryArchivedSchema: z.ZodObject<{
+  entryId: z.ZodUnion<readonly [z.ZodString, z.ZodAny]>;
+  archivedBy: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodAny]>>;
+  organizationId: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodAny]>>;
+}, z.core.$strip>;
+declare const entryDuplicatedSchema: z.ZodObject<{
+  sourceEntryId: z.ZodUnion<readonly [z.ZodString, z.ZodAny]>;
+  duplicateEntryId: z.ZodUnion<readonly [z.ZodString, z.ZodAny]>;
+  organizationId: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodAny]>>;
+}, z.core.$strip>;
+declare const entryReversedSchema: z.ZodObject<{
+  originalEntryId: z.ZodUnion<readonly [z.ZodString, z.ZodAny]>;
+  reversalEntryId: z.ZodUnion<readonly [z.ZodString, z.ZodAny]>;
+  reversalDate: z.ZodISODateTime;
+  reversedBy: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodAny]>>;
+  organizationId: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodAny]>>;
+}, z.core.$strip>;
+declare const accountBulkCreatedSchema: z.ZodObject<{
+  created: z.ZodNumber;
+  skipped: z.ZodNumber;
+  errors: z.ZodNumber;
+  organizationId: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodAny]>>;
+}, z.core.$strip>;
+declare const reconciliationMatchedSchema: z.ZodObject<{
+  matchingNumber: z.ZodString;
+  account: z.ZodUnion<readonly [z.ZodString, z.ZodAny]>;
+  itemCount: z.ZodNumber;
+  debitTotal: z.ZodNumber;
+  creditTotal: z.ZodNumber;
+  isFullReconcile: z.ZodBoolean;
+  currency: z.ZodNullable<z.ZodString>;
+  organizationId: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodAny]>>;
+}, z.core.$strip>;
+declare const reconciliationUnmatchedSchema: z.ZodObject<{
+  matchingNumber: z.ZodString;
+  itemCount: z.ZodNumber;
+  organizationId: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodAny]>>;
+}, z.core.$strip>;
+type EntryCreatedPayloadSchema = z.infer<typeof entryCreatedSchema>;
+type EntryPostedPayloadSchema = z.infer<typeof entryPostedSchema>;
+type EntryUnpostedPayloadSchema = z.infer<typeof entryUnpostedSchema>;
+type EntryArchivedPayloadSchema = z.infer<typeof entryArchivedSchema>;
+type EntryDuplicatedPayloadSchema = z.infer<typeof entryDuplicatedSchema>;
+type EntryReversedPayloadSchema = z.infer<typeof entryReversedSchema>;
+type AccountSeededPayloadSchema = z.infer<typeof seedCountsSchema>;
+type AccountBulkCreatedPayloadSchema = z.infer<typeof accountBulkCreatedSchema>;
+type JournalSeededPayloadSchema = z.infer<typeof seedCountsSchema>;
+type ReconciliationMatchedPayloadSchema = z.infer<typeof reconciliationMatchedSchema>;
+type ReconciliationUnmatchedPayloadSchema = z.infer<typeof reconciliationUnmatchedSchema>;
+declare const EntryCreated: LedgerEventDefinition<z.ZodObject<{
+  entryId: z.ZodUnion<readonly [z.ZodString, z.ZodAny]>;
+  journalType: z.ZodOptional<z.ZodString>;
+  state: z.ZodString;
+  referenceNumber: z.ZodOptional<z.ZodString>;
+  idempotencyKey: z.ZodOptional<z.ZodString>;
+  organizationId: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodAny]>>;
+}, z.core.$strip>>;
+declare const EntryPosted: LedgerEventDefinition<z.ZodObject<{
+  entryId: z.ZodUnion<readonly [z.ZodString, z.ZodAny]>;
+  referenceNumber: z.ZodOptional<z.ZodString>;
+  postedBy: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodAny]>>;
+  totalDebit: z.ZodNumber;
+  totalCredit: z.ZodNumber;
+  organizationId: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodAny]>>;
+}, z.core.$strip>>;
+declare const EntryUnposted: LedgerEventDefinition<z.ZodObject<{
+  entryId: z.ZodUnion<readonly [z.ZodString, z.ZodAny]>;
+  unpostedBy: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodAny]>>;
+  organizationId: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodAny]>>;
+}, z.core.$strip>>;
+declare const EntryArchived: LedgerEventDefinition<z.ZodObject<{
+  entryId: z.ZodUnion<readonly [z.ZodString, z.ZodAny]>;
+  archivedBy: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodAny]>>;
+  organizationId: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodAny]>>;
+}, z.core.$strip>>;
+declare const EntryDuplicated: LedgerEventDefinition<z.ZodObject<{
+  sourceEntryId: z.ZodUnion<readonly [z.ZodString, z.ZodAny]>;
+  duplicateEntryId: z.ZodUnion<readonly [z.ZodString, z.ZodAny]>;
+  organizationId: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodAny]>>;
+}, z.core.$strip>>;
+declare const EntryReversed: LedgerEventDefinition<z.ZodObject<{
+  originalEntryId: z.ZodUnion<readonly [z.ZodString, z.ZodAny]>;
+  reversalEntryId: z.ZodUnion<readonly [z.ZodString, z.ZodAny]>;
+  reversalDate: z.ZodISODateTime;
+  reversedBy: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodAny]>>;
+  organizationId: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodAny]>>;
+}, z.core.$strip>>;
+declare const AccountSeeded: LedgerEventDefinition<z.ZodObject<{
+  created: z.ZodNumber;
+  skipped: z.ZodNumber;
+  organizationId: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodAny]>>;
+}, z.core.$strip>>;
+declare const AccountBulkCreated: LedgerEventDefinition<z.ZodObject<{
+  created: z.ZodNumber;
+  skipped: z.ZodNumber;
+  errors: z.ZodNumber;
+  organizationId: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodAny]>>;
+}, z.core.$strip>>;
+declare const JournalSeeded: LedgerEventDefinition<z.ZodObject<{
+  created: z.ZodNumber;
+  skipped: z.ZodNumber;
+  organizationId: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodAny]>>;
+}, z.core.$strip>>;
+declare const ReconciliationMatched: LedgerEventDefinition<z.ZodObject<{
+  matchingNumber: z.ZodString;
+  account: z.ZodUnion<readonly [z.ZodString, z.ZodAny]>;
+  itemCount: z.ZodNumber;
+  debitTotal: z.ZodNumber;
+  creditTotal: z.ZodNumber;
+  isFullReconcile: z.ZodBoolean;
+  currency: z.ZodNullable<z.ZodString>;
+  organizationId: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodAny]>>;
+}, z.core.$strip>>;
+declare const ReconciliationUnmatched: LedgerEventDefinition<z.ZodObject<{
+  matchingNumber: z.ZodString;
+  itemCount: z.ZodNumber;
+  organizationId: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodAny]>>;
+}, z.core.$strip>>;
+/**
+ * Every ledger event defined in the package — pass to Arc's
+ * `EventRegistry`. Hosts wire ONE array; the whole `ledger:*` namespace
+ * becomes introspectable via OpenAPI and auto-validated at publish time
+ * when `eventPlugin({ validateMode: 'reject' })` is set.
+ */
+declare const ledgerEventDefinitions: ReadonlyArray<LedgerEventDefinition>;
+//#endregion
+export { ReconciliationUnmatchedPayload as $, LedgerEventDefinition as A, InProcessLedgerBusOptions as B, EntryPostedPayloadSchema as C, EntryUnpostedPayloadSchema as D, EntryUnposted as E, ReconciliationUnmatched as F, EntryArchivedPayload as G, createEvent$1 as H, ReconciliationUnmatchedPayloadSchema as I, EntryPostedPayload as J, EntryCreatedPayload as K, ledgerEventDefinitions as L, LedgerEventSchema as M, ReconciliationMatched as N, JournalSeeded as O, ReconciliationMatchedPayloadSchema as P, ReconciliationMatchedPayload as Q, EventLogger as R, EntryPosted as S, EntryReversedPayloadSchema as T, AccountBulkCreatedPayload as U, EventContext as V, AccountSeededPayload as W, EntryUnpostedPayload as X, EntryReversedPayload as Y, JournalSeededPayload as Z, EntryArchivedPayloadSchema as _, OutboxFailOptions as a, EntryDuplicated as b, OutboxFailurePolicy as c, OutboxWriteOptions as d, LEDGER_EVENTS as et, AccountBulkCreated as f, EntryArchived as g, AccountSeededPayloadSchema as h, OutboxErrorInfo as i, LedgerEventPayloadOf as j, JournalSeededPayloadSchema as k, OutboxOwnershipError as l, AccountSeeded as m, OutboxAcknowledgeOptions as n, OutboxFailureContext as o, AccountBulkCreatedPayloadSchema as p, EntryDuplicatedPayload as q, OutboxClaimOptions as r, OutboxFailureDecision as s, InvalidOutboxEventError as t, LedgerEventName as tt, OutboxStore as u, EntryCreated as v, EntryReversed as w, EntryDuplicatedPayloadSchema as x, EntryCreatedPayloadSchema as y, InProcessLedgerBus as z };

package/dist/{partner-ledger-BoebloHk.mjs → partner-ledger-CR0geilx.mjs}

@@ -1,4 +1,4 @@
-import { i as Errors } from "./errors-BI5k4iak.mjs";
+import { i as Errors } from "./errors-vXd932rB.mjs";
 import { i as extractMainType } from "./categories-FJlrvzcl.mjs";
 import mongoose from "mongoose";
 //#region src/utils/tenant-guard.ts

package/dist/plugins/index.mjs

@@ -1,2 +1,2 @@
-import { a as watermarkResolver, c as idempotencyPlugin, i as fiscalLockPlugin, l as doubleEntryPlugin, n as creditLimitPlugin, o as periodResolver, r as dailyLockPlugin, s as createLockPlugin, t as fxRealizationPlugin } from "../fx-realization.plugin-Bxlb8cIx.mjs";
+import { a as watermarkResolver, c as idempotencyPlugin, i as fiscalLockPlugin, l as doubleEntryPlugin, n as creditLimitPlugin, o as periodResolver, r as dailyLockPlugin, s as createLockPlugin, t as fxRealizationPlugin } from "../fx-realization.plugin-Dzqzi3u0.mjs";
 export { createLockPlugin, creditLimitPlugin, dailyLockPlugin, doubleEntryPlugin, fiscalLockPlugin, fxRealizationPlugin, idempotencyPlugin, periodResolver, watermarkResolver };

package/dist/reports/index.mjs

@@ -1,2 +1,2 @@
-import { T as generateAgedBalance, c as generateRevaluation, d as generateIncomeStatement, f as generateGeneralLedger, g as generateBalanceSheet, h as generateBudgetVsActual, m as generateCashFlow, n as closeFiscalPeriod, p as generateDimensionBreakdown, r as reopenFiscalPeriod, s as generateTrialBalance, t as generatePartnerLedger, w as DEFAULT_BUCKETS } from "../partner-ledger-BoebloHk.mjs";
+import { T as generateAgedBalance, c as generateRevaluation, d as generateIncomeStatement, f as generateGeneralLedger, g as generateBalanceSheet, h as generateBudgetVsActual, m as generateCashFlow, n as closeFiscalPeriod, p as generateDimensionBreakdown, r as reopenFiscalPeriod, s as generateTrialBalance, t as generatePartnerLedger, w as DEFAULT_BUCKETS } from "../partner-ledger-CR0geilx.mjs";
 export { DEFAULT_BUCKETS, closeFiscalPeriod, generateAgedBalance, generateBalanceSheet, generateBudgetVsActual, generateCashFlow, generateDimensionBreakdown, generateGeneralLedger, generateIncomeStatement, generatePartnerLedger, generateRevaluation, generateTrialBalance, reopenFiscalPeriod };

package/dist/sync/index.d.mts

@@ -166,9 +166,19 @@ interface LedgerPaymentInput {
  */
 interface LedgerBridge {
   createJournalEntry(input: LedgerPostInput): Promise<string>;
-  reverseJournalEntry(journalEntryId: string, reason: string): Promise<string>;
+  reverseJournalEntry(journalEntryId: string, reason: string, ctx: LedgerReverseContext): Promise<string>;
   recordPayment(input: LedgerPaymentInput): Promise<string>;
 }
+/**
+ * Context threaded from the invoice engine into the ledger reversal call.
+ * Required so the ledger can stamp `reversedByUser` and satisfy strict-mode
+ * `requireActor` / multi-tenant guards.
+ */
+interface LedgerReverseContext {
+  organizationId?: string;
+  actorId?: string;
+  session?: unknown;
+}
 interface AdjustmentLine {
   account: string;
   debit?: number;
@@ -200,6 +210,7 @@ interface JournalEntryRepoLike {
   reverse(id: unknown, orgId?: unknown, options?: {
     actorId?: string;
     session?: unknown;
+    reversalDate?: Date;
   }): Promise<{
     original: {
       _id: unknown;
@@ -310,4 +321,4 @@ declare function wireImport<TRaw>(args: WireImportArgs<TRaw>): {
   run(): Promise<ImportReport>;
 };
 //#endregion
-export { type BankStatementMapperConfig, type ExportReport, type ExportSink, type ImportContext, type ImportError, type ImportMapper, type ImportReport, type InvoiceMapperConfig, type JournalEntryInput, type JournalEntryMapperConfig, type JournalItemInput, type LedgerBridge, type LedgerBridgeAccounts, type LedgerBridgeConfig, type LedgerPaymentInput, type LedgerPostInput, type LedgerPostLine, type OpeningBalanceInput, type OpeningBalanceMapperConfig, type OpeningBalanceResult, type TrialBalanceInput, type WireExportArgs, type WireImportArgs, bankStatementMapper, buildOpeningBalanceEntry, createLedgerBridge, invoiceMapper, journalEntryMapper, openingBalanceMapper, wireExport, wireImport };
+export { type BankStatementMapperConfig, type ExportReport, type ExportSink, type ImportContext, type ImportError, type ImportMapper, type ImportReport, type InvoiceMapperConfig, type JournalEntryInput, type JournalEntryMapperConfig, type JournalItemInput, type LedgerBridge, type LedgerBridgeAccounts, type LedgerBridgeConfig, type LedgerPaymentInput, type LedgerPostInput, type LedgerPostLine, type LedgerReverseContext, type OpeningBalanceInput, type OpeningBalanceMapperConfig, type OpeningBalanceResult, type TrialBalanceInput, type WireExportArgs, type WireImportArgs, bankStatementMapper, buildOpeningBalanceEntry, createLedgerBridge, invoiceMapper, journalEntryMapper, openingBalanceMapper, wireExport, wireImport };

package/dist/sync/index.mjs

@@ -102,8 +102,11 @@ function createLedgerBridge(engine, config) {
 			}, input.idempotencyKey ? { idempotencyKey: input.idempotencyKey } : {});
 			return String(result._id);
 		},
-		async reverseJournalEntry(journalEntryId, _reason) {
-			const result = await engine.repositories.journalEntries.reverse(journalEntryId);
+		async reverseJournalEntry(journalEntryId, _reason, ctx) {
+			const options = {};
+			if (ctx.actorId) options.actorId = ctx.actorId;
+			if (ctx.session) options.session = ctx.session;
+			const result = await engine.repositories.journalEntries.reverse(journalEntryId, ctx.organizationId, options);
 			return String(result.reversal._id);
 		},
 		async recordPayment(input) {
@@ -473,7 +476,7 @@ function wireImport(args) {
 				processed: records.length
 			};
 			if (useBulk) try {
-				await args.journalEntries.createMany(pendingDocs.map((p) => p.doc));
+				await args.journalEntries.createMany?.(pendingDocs.map((p) => p.doc));
 				batchInserted += pendingDocs.length;
 			} catch (_err) {
 				for (const { externalId, doc } of pendingDocs) try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@classytic/ledger",
-  "version": "0.9.1",
+  "version": "0.10.1",
   "description": "Production-grade double-entry accounting engine for MongoDB — schemas, reports, tax, multi-tenant",
   "type": "module",
   "sideEffects": false,
@@ -94,8 +94,11 @@
   },
   "peerDependencies": {
     "@classytic/fin-io": ">=0.1.0",
-    "@classytic/mongokit": ">=3.6.4",
-    "mongoose": ">=9.4.1"
+    "@classytic/mongokit": ">=3.11.0",
+    "@classytic/primitives": ">=0.1.0",
+    "@classytic/repo-core": ">=0.2.0",
+    "mongoose": ">=9.4.1",
+    "zod": ">=4.0.0"
   },
   "peerDependenciesMeta": {
     "@classytic/fin-io": {
@@ -104,8 +107,10 @@
   },
   "devDependencies": {
     "@biomejs/biome": "^2.4.12",
-    "@classytic/fin-io": "^0.1.0",
-    "@classytic/mongokit": "^3.6.4",
+    "@classytic/fin-io": ">=0.1.0",
+    "@classytic/mongokit": ">=3.11.0",
+    "@classytic/primitives": ">=0.1.0",
+    "@classytic/repo-core": ">=0.2.0",
     "@types/node": "^25.5.0",
     "@vitest/coverage-v8": "^4.1.4",
     "knip": "^6.4.1",
@@ -113,7 +118,8 @@
     "mongoose": "^9.4.1",
     "tsdown": "^0.21.8",
     "typescript": "^5.7.0",
-    "vitest": "^4.1.4"
+    "vitest": "^4.1.4",
+    "zod": "^4.3.6"
   },
   "engines": {
     "node": ">=22"