@classytic/payroll 2.7.5 → 2.8.0

package/dist/index.js

@@ -1,15 +1,13 @@
-import mongoose6, { Schema, Types, isValidObjectId as isValidObjectId$1 } from 'mongoose';
+import mongoose5, { Schema, Types, isValidObjectId as isValidObjectId$1 } from 'mongoose';
+import { MongoServerError } from 'mongodb';
 import pLimit from 'p-limit';
 import { LRUCache } from 'lru-cache';
 import crypto from 'crypto';
 import { Repository } from '@classytic/mongokit';
-import { MongoServerError } from 'mongodb';
 import { isTransaction } from '@classytic/shared-types';
 
 var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
@@ -17,15 +15,6 @@ var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/enums.ts
 function isVoidablePayrollStatus(status) {
@@ -204,19 +193,6 @@ var init_enums = __esm({
 });
 
 // src/utils/logger.ts
-var logger_exports = {};
-__export(logger_exports, {
-  createChildLogger: () => createChildLogger,
-  createSilentLogger: () => createSilentLogger,
-  default: () => logger_default,
-  disableLogging: () => disableLogging,
-  enableLogging: () => enableLogging,
-  getLogger: () => getLogger,
-  isLoggingEnabled: () => isLoggingEnabled,
-  logger: () => logger,
-  resetLogger: () => resetLogger,
-  setLogger: () => setLogger
-});
 function getLogger() {
   return {
     info: (message, meta) => {
@@ -236,48 +212,7 @@ function getLogger() {
 function setLogger(logger2) {
   currentLogger = logger2;
 }
-function resetLogger() {
-  currentLogger = createConsoleLogger();
-}
-function createChildLogger(prefix) {
-  const parent = currentLogger;
-  return {
-    info: (message, meta) => {
-      if (loggingEnabled) parent.info(`[${prefix}] ${message}`, meta);
-    },
-    error: (message, meta) => {
-      if (loggingEnabled) parent.error(`[${prefix}] ${message}`, meta);
-    },
-    warn: (message, meta) => {
-      if (loggingEnabled) parent.warn(`[${prefix}] ${message}`, meta);
-    },
-    debug: (message, meta) => {
-      if (loggingEnabled) parent.debug(`[${prefix}] ${message}`, meta);
-    }
-  };
-}
-function createSilentLogger() {
-  return {
-    info: () => {
-    },
-    error: () => {
-    },
-    warn: () => {
-    },
-    debug: () => {
-    }
-  };
-}
-function enableLogging() {
-  loggingEnabled = true;
-}
-function disableLogging() {
-  loggingEnabled = false;
-}
-function isLoggingEnabled() {
-  return loggingEnabled;
-}
-var createConsoleLogger, currentLogger, loggingEnabled, logger, logger_default;
+var createConsoleLogger, currentLogger, loggingEnabled, logger;
 var init_logger = __esm({
   "src/utils/logger.ts"() {
     createConsoleLogger = () => ({
@@ -328,7 +263,6 @@ var init_logger = __esm({
         if (loggingEnabled) currentLogger.debug(message, meta);
       }
     };
-    logger_default = logger;
   }
 });
 
@@ -552,6 +486,11 @@ var init_payroll_states = __esm({
 });
 
 // src/utils/date.ts
+function addDays(date, days) {
+  const result = new Date(date);
+  result.setDate(result.getDate() + days);
+  return result;
+}
 function addMonths(date, months) {
   const result = new Date(date);
   result.setMonth(result.getMonth() + months);
@@ -569,10 +508,26 @@ function endOfMonth(date) {
   result.setHours(23, 59, 59, 999);
   return result;
 }
+function startOfDay(date) {
+  const result = new Date(date);
+  result.setHours(0, 0, 0, 0);
+  return result;
+}
+function toUTCDateString(date) {
+  const d = new Date(date);
+  d.setHours(0, 0, 0, 0);
+  return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(d.getDate()).padStart(2, "0")}`;
+}
 function diffInDays(start, end) {
-  return Math.ceil(
-    (new Date(end).getTime() - new Date(start).getTime()) / (1e3 * 60 * 60 * 24)
-  );
+  const s = new Date(start);
+  const e = new Date(end);
+  s.setHours(0, 0, 0, 0);
+  e.setHours(0, 0, 0, 0);
+  return Math.ceil((e.getTime() - s.getTime()) / (1e3 * 60 * 60 * 24));
+}
+function isWeekday(date) {
+  const day = new Date(date).getDay();
+  return day >= 1 && day <= 5;
 }
 function getPayPeriod(month, year) {
   const startDate = new Date(year, month - 1, 1);
@@ -583,6 +538,59 @@ function getPayPeriod(month, year) {
     endDate: endOfMonth(startDate)
   };
 }
+function getPayPeriodForFrequency(frequency, paymentDate, month, year) {
+  switch (frequency) {
+    case "monthly": {
+      const period = getPayPeriod(month, year);
+      const workingDays = getWorkingDaysInMonth(year, month);
+      return { ...period, workingDays };
+    }
+    case "bi_weekly": {
+      const endDate = startOfDay(paymentDate);
+      const startDate = addDays(endDate, -13);
+      const workingDays = countWeekdaysInRange(startDate, endDate);
+      return { month, year, startDate, endDate, workingDays };
+    }
+    case "weekly": {
+      const endDate = startOfDay(paymentDate);
+      const startDate = addDays(endDate, -6);
+      const workingDays = countWeekdaysInRange(startDate, endDate);
+      return { month, year, startDate, endDate, workingDays };
+    }
+    case "daily":
+    case "hourly": {
+      const date = startOfDay(paymentDate);
+      const workingDays = isWeekday(date) ? 1 : 0;
+      return { month, year, startDate: date, endDate: date, workingDays };
+    }
+    default:
+      return getPayPeriodForFrequency("monthly", paymentDate, month, year);
+  }
+}
+function countWeekdaysInRange(start, end) {
+  let count = 0;
+  const current = new Date(start);
+  while (current <= end) {
+    if (isWeekday(current)) {
+      count++;
+    }
+    current.setDate(current.getDate() + 1);
+  }
+  return count;
+}
+function getWorkingDaysInMonth(year, month) {
+  const start = new Date(year, month - 1, 1);
+  const end = endOfMonth(start);
+  let count = 0;
+  const current = new Date(start);
+  while (current <= end) {
+    if (isWeekday(current)) {
+      count++;
+    }
+    current.setDate(current.getDate() + 1);
+  }
+  return count;
+}
 function calculateProbationEnd(hireDate, probationMonths) {
   if (!probationMonths || probationMonths <= 0) return null;
   return addMonths(hireDate, probationMonths);
@@ -833,11 +841,14 @@ function createError(code, message, context) {
     EMPLOYEE_NOT_FOUND: 404,
     INVALID_EMPLOYEE: 400,
     DUPLICATE_PAYROLL: 409,
+    VOIDED_PAYROLL_REPROCESS: 409,
     VALIDATION_ERROR: 400,
     EMPLOYEE_TERMINATED: 400,
     ALREADY_PROCESSED: 409,
     NOT_ELIGIBLE: 400,
-    SECURITY_ERROR: 403
+    SECURITY_ERROR: 403,
+    EXPORT_NOT_FOUND: 404,
+    EXPORT_ORG_MISMATCH: 403
   };
   return new PayrollError(message, code, statusMap[code] || 500, context ?? {});
 }
@@ -944,12 +955,13 @@ var init_errors = __esm({
       }
     };
     DuplicatePayrollError = class extends PayrollError {
-      constructor(employeeId, month, year, context) {
+      constructor(employeeId, month, year, payrollRunType, context) {
+        const runTypeInfo = payrollRunType ? ` (${payrollRunType})` : "";
         super(
-          `Payroll already processed for employee ${employeeId} in ${month}/${year}`,
+          `Payroll already processed for employee ${employeeId} in ${month}/${year}${runTypeInfo}`,
           "DUPLICATE_PAYROLL",
           409,
-          { employeeId, month, year, ...context }
+          { employeeId, month, year, payrollRunType, ...context }
         );
       }
     };
@@ -993,7 +1005,7 @@ var init_errors = __esm({
 function countWorkingDays(startDate, endDate, options = {}) {
   const workDays = options.workingDays || DEFAULT_WORK_SCHEDULE.workingDays;
   const holidaySet = new Set(
-    (options.holidays || []).map((d) => new Date(d).toDateString())
+    (options.holidays || []).map((d) => toUTCDateString(d))
   );
   let totalDays = 0;
   let workingDays = 0;
@@ -1005,7 +1017,7 @@ function countWorkingDays(startDate, endDate, options = {}) {
   end.setHours(0, 0, 0, 0);
   while (current <= end) {
     totalDays++;
-    const isHoliday = holidaySet.has(current.toDateString());
+    const isHoliday = holidaySet.has(toUTCDateString(current));
     const isWorkDay = workDays.includes(current.getDay());
     if (isHoliday) {
       holidays++;
@@ -1021,6 +1033,7 @@ function countWorkingDays(startDate, endDate, options = {}) {
 var DEFAULT_WORK_SCHEDULE;
 var init_config = __esm({
   "src/core/config.ts"() {
+    init_date();
     DEFAULT_WORK_SCHEDULE = {
       workingDays: [1, 2, 3, 4, 5],
       // Monday to Friday
@@ -1089,7 +1102,7 @@ function calculateProRating(input) {
   };
 }
 function applyProRating(baseAmount, ratio) {
-  return Math.round(baseAmount * ratio);
+  return roundMoney(baseAmount * ratio, 2);
 }
 function shouldProRate(hireDate, terminationDate, periodStart, periodEnd) {
   const hire = new Date(hireDate);
@@ -1101,6 +1114,75 @@ function shouldProRate(hireDate, terminationDate, periodStart, periodEnd) {
 var init_prorating_calculator = __esm({
   "src/calculators/prorating.calculator.ts"() {
     init_config();
+    init_money();
+  }
+});
+function isMongoError(error) {
+  return error instanceof MongoServerError;
+}
+function isDuplicateKeyError(error) {
+  return isMongoError(error) && error.code === 11e3;
+}
+function parseDuplicateKeyError(error) {
+  const message = error.message || "";
+  const match = message.match(/dup key: \{ ([^:]+):/);
+  if (match && match[1]) {
+    return match[1].trim();
+  }
+  const errmsgMatch = message.match(/index: ([^_]+)_/);
+  if (errmsgMatch && errmsgMatch[1]) {
+    return errmsgMatch[1].trim();
+  }
+  return "unknown";
+}
+function isTransactionError(error) {
+  if (!isMongoError(error)) return false;
+  const message = (error.message || "").toLowerCase();
+  return message.includes("transaction") || message.includes("session") || message.includes("replica set") || error.code === 251 || // NoSuchTransaction
+  error.code === 225 || // TransactionTooOld
+  error.code === 244 || // TransactionAborted
+  error.code === 256 || // TransactionCommitted
+  error.code === 257;
+}
+function isTransactionUnsupportedError(error) {
+  if (!isMongoError(error)) return false;
+  const message = (error.message || "").toLowerCase();
+  return message.includes("transaction numbers are only allowed on a replica set member") || message.includes("transactions are only supported on replica sets") || message.includes("mongos") || error.code === 20;
+}
+function isConnectionError(error) {
+  if (!isMongoError(error)) return false;
+  return error.code === 11600 || // InterruptedAtShutdown
+  error.code === 11602 || // InterruptedDueToReplStateChange
+  error.code === 91 || // ShutdownInProgress
+  error.code === 89 || // NetworkTimeout
+  error.code === 6;
+}
+function isGuestEmployee(employee2) {
+  return !employee2.userId;
+}
+function hasUserId(employee2) {
+  return !!employee2.userId;
+}
+function isValidationError(error) {
+  return error instanceof Error && error.name === "ValidationError";
+}
+function isError(error) {
+  return error instanceof Error;
+}
+function getErrorMessage(error) {
+  if (isError(error)) {
+    return error.message;
+  }
+  if (typeof error === "string") {
+    return error;
+  }
+  if (error && typeof error === "object" && "message" in error) {
+    return String(error.message);
+  }
+  return "Unknown error occurred";
+}
+var init_type_guards = __esm({
+  "src/utils/type-guards.ts"() {
   }
 });
 
@@ -1112,7 +1194,7 @@ function calculateLeaveDays(startDate, endDate, options = {}) {
     holidays = [],
     includeEndDate = true
   } = options;
-  const holidaySet = new Set(holidays.map((d) => new Date(d).toDateString()));
+  const holidaySet = new Set(holidays.map((d) => toUTCDateString(d)));
   let count = 0;
   const current = new Date(startDate);
   current.setHours(0, 0, 0, 0);
@@ -1123,7 +1205,7 @@ function calculateLeaveDays(startDate, endDate, options = {}) {
   }
   while (current <= end) {
     const isWorkDay = workingDays.includes(current.getDay());
-    const isHoliday = holidaySet.has(current.toDateString());
+    const isHoliday = holidaySet.has(toUTCDateString(current));
     if (isWorkDay && !isHoliday) {
       count++;
     }
@@ -1194,8 +1276,8 @@ function initializeLeaveBalances(hireDate, config = {}, year = (/* @__PURE__ */
   const fiscalYearEnd = new Date(year + 1, fiscalYearStartMonth - 1, 0);
   let prorationRatio = 1;
   if (proRateNewHires && hireDate > fiscalYearStart) {
-    const totalDays = diffInDays2(fiscalYearStart, fiscalYearEnd);
-    const remainingDays = diffInDays2(hireDate, fiscalYearEnd);
+    const totalDays = diffInDays(fiscalYearStart, fiscalYearEnd);
+    const remainingDays = diffInDays(hireDate, fiscalYearEnd);
     prorationRatio = Math.max(0, Math.min(1, remainingDays / totalDays));
   }
   const balances = [];
@@ -1219,14 +1301,14 @@ function proRateAllocation(fullAllocation, hireDate, fiscalYearStartMonth = 1, y
     return fullAllocation;
   }
   const fiscalYearEnd = new Date(year + 1, fiscalYearStartMonth - 1, 0);
-  const totalDays = diffInDays2(fiscalYearStart, fiscalYearEnd);
-  const remainingDays = Math.max(0, diffInDays2(hireDate, fiscalYearEnd));
+  const totalDays = diffInDays(fiscalYearStart, fiscalYearEnd);
+  const remainingDays = Math.max(0, diffInDays(hireDate, fiscalYearEnd));
   return Math.round(fullAllocation * remainingDays / totalDays);
 }
 function calculateUnpaidLeaveDeduction(baseSalary, unpaidDays, workingDaysInMonth) {
   if (unpaidDays <= 0 || workingDaysInMonth <= 0) return 0;
-  const dailyRate = baseSalary / workingDaysInMonth;
-  return Math.round(dailyRate * unpaidDays);
+  const dailyRate = roundMoney(baseSalary / workingDaysInMonth, 2);
+  return roundMoney(dailyRate * unpaidDays, 2);
 }
 function getUnpaidLeaveDays(leaveRequests, status = "approved") {
   return leaveRequests.filter((r) => r.type === "unpaid" && r.status === status).reduce((sum, r) => sum + r.days, 0);
@@ -1265,16 +1347,11 @@ function accrueLeaveToBalance(balances, type, amount, year = (/* @__PURE__ */ ne
   }
   return balances;
 }
-function diffInDays2(start, end) {
-  const startDate = new Date(start);
-  const endDate = new Date(end);
-  startDate.setHours(0, 0, 0, 0);
-  endDate.setHours(0, 0, 0, 0);
-  return Math.ceil((endDate.getTime() - startDate.getTime()) / (1e3 * 60 * 60 * 24));
-}
 var DEFAULT_LEAVE_ALLOCATIONS, DEFAULT_CARRY_OVER;
 var init_leave = __esm({
   "src/utils/leave.ts"() {
+    init_date();
+    init_money();
     DEFAULT_LEAVE_ALLOCATIONS = {
       annual: 20,
       sick: 10,
@@ -1522,6 +1599,85 @@ var init_employee_identity = __esm({
   }
 });
 
+// src/utils/error-helpers.ts
+function handleTransactionError(error, operationName) {
+  const isUnsupported = isTransactionUnsupportedError(error);
+  const isTxError = isTransactionError(error);
+  const isConnError = isConnectionError(error);
+  const retryable = isTxError && !isUnsupported;
+  const wrappedError = toPayrollError(error);
+  wrappedError.context.operationName = operationName;
+  wrappedError.context.transactionError = true;
+  if (isUnsupported) {
+    wrappedError.context.reason = "transactions_unsupported";
+  } else if (isConnError) {
+    wrappedError.context.reason = "connection_error";
+  } else if (isTxError) {
+    wrappedError.context.reason = "transaction_conflict";
+  }
+  return {
+    isTransactionError: isTxError || isUnsupported,
+    isUnsupported,
+    retryable,
+    error: wrappedError,
+    originalError: error
+  };
+}
+function handleDuplicateKeyError(error, context) {
+  if (!isDuplicateKeyError(error)) {
+    return {
+      isDuplicate: false,
+      field: "",
+      error: toPayrollError(error)
+    };
+  }
+  const field = parseDuplicateKeyError(error);
+  const wrappedError = context?.employeeId && context?.month && context?.year ? new DuplicatePayrollError(context.employeeId, context.month, context.year, void 0, { duplicateField: field }) : toPayrollError(error);
+  return {
+    isDuplicate: true,
+    field,
+    error: wrappedError
+  };
+}
+function handlePayrollError(error, operationName) {
+  const info = extractErrorInfo(error);
+  const retryable = isConnectionError(error) || isTransactionError(error) && !isTransactionUnsupportedError(error);
+  const operational = error instanceof PayrollError ? error.isOperational() : false;
+  return {
+    code: info.code,
+    status: info.status,
+    message: info.message,
+    context: {
+      ...info.context,
+      operationName
+    },
+    operational,
+    retryable
+  };
+}
+function formatUserError(error) {
+  if (error instanceof PayrollError) {
+    return error.message;
+  }
+  if (isDuplicateKeyError(error)) {
+    const field = parseDuplicateKeyError(error);
+    return `A record with this ${field} already exists`;
+  }
+  if (isTransactionUnsupportedError(error)) {
+    return "Database does not support transactions. Please use a replica set.";
+  }
+  if (isConnectionError(error)) {
+    return "Database connection error. Please try again.";
+  }
+  return "An unexpected error occurred";
+}
+var init_error_helpers = __esm({
+  "src/utils/error-helpers.ts"() {
+    init_errors();
+    init_type_guards();
+  }
+});
+
 // src/utils/index.ts
 var init_utils = __esm({
   "src/utils/index.ts"() {
@@ -1562,13 +1718,18 @@ var init_tax_withholding_service = __esm({
       /**
        * Create tax withholding records from payroll breakdown
        *
-       * Extracts tax deductions from the breakdown and creates separate
-       * TaxWithholding records for each tax type
+       * Extracts tax deductions from the breakdown and creates all
+       * TaxWithholding records in a single batch operation (one DB roundtrip).
+       * Events are emitted for each created withholding after the batch insert.
+       *
+       * @param params - Breakdown data, employee info, and session
+       * @returns Array of created TaxWithholdingDocuments (empty if no tax deductions)
        */
       async createFromBreakdown(params) {
         const {
           organizationId,
           employeeId,
+          employeeBusinessId,
           userId,
           payrollRecordId,
           transactionId,
@@ -1616,8 +1777,7 @@ var init_tax_withholding_service = __esm({
               },
               employee: {
                 id: employeeId,
-                employeeId: ""
-                // Will be filled by caller if needed
+                employeeId: employeeBusinessId || employeeId.toString()
               },
               payrollRecord: {
                 id: payrollRecordId
@@ -1698,8 +1858,15 @@ var init_tax_withholding_service = __esm({
       /**
        * Mark tax withholdings as paid
        *
-       * Updates status, optionally creates government payment transaction,
-       * and emits tax:paid event
+       * Updates status using bulkWrite (single DB roundtrip), optionally creates
+       * a government payment transaction, and emits tax:paid event.
+       *
+       * State transitions are pre-validated in memory before the batch update
+       * to ensure all withholdings can transition to 'paid' status.
+       *
+       * @param params - Mark paid parameters (IDs, reference number, notes)
+       * @returns Updated withholdings and optional government transaction
+       * @throws Error if any withholding cannot transition to 'paid' status
        */
       async markPaid(params) {
         const {
@@ -1745,12 +1912,30 @@ var init_tax_withholding_service = __esm({
           });
         }
         for (const withholding of withholdings) {
-          withholding.markAsPaid(
-            governmentTransaction?._id,
-            referenceNumber,
-            paidAt
-          );
-          await withholding.save({ session });
+          const transition = TaxStatusMachine.validateTransition(withholding.status, TAX_STATUS.PAID);
+          if (!transition.success) {
+            throw new Error(`Cannot mark withholding ${withholding._id} as paid: ${transition.error}`);
+          }
+        }
+        const bulkOps = withholdings.map((w) => ({
+          updateOne: {
+            filter: { _id: w._id },
+            update: {
+              $set: {
+                status: TAX_STATUS.PAID,
+                governmentTransactionId: governmentTransaction?._id,
+                referenceNumber,
+                paidAt
+              }
+            }
+          }
+        }));
+        await this.TaxWithholdingModel.bulkWrite(bulkOps, { session });
+        for (const withholding of withholdings) {
+          withholding.status = TAX_STATUS.PAID;
+          withholding.governmentTransactionId = governmentTransaction?._id;
+          withholding.referenceNumber = referenceNumber;
+          withholding.paidAt = paidAt;
         }
         if (this.events) {
           this.events.emitSync("tax:paid", {
@@ -1778,7 +1963,7 @@ var init_tax_withholding_service = __esm({
         });
         return {
           withholdings,
-          transaction: governmentTransaction
+          transaction: governmentTransaction ?? void 0
         };
       }
       /**
@@ -2004,13 +2189,13 @@ var HRM_CONFIG = {
   }
 };
 var TAX_BRACKETS = {
+  // Bangladesh FY 2024-25 rates (after tax-free threshold)
   BDT: [
-    { min: 0, max: 3e5, rate: 0 },
-    { min: 3e5, max: 4e5, rate: 0.05 },
-    { min: 4e5, max: 5e5, rate: 0.1 },
-    { min: 5e5, max: 6e5, rate: 0.15 },
-    { min: 6e5, max: 3e6, rate: 0.2 },
-    { min: 3e6, max: Infinity, rate: 0.25 }
+    { min: 0, max: 1e5, rate: 0.05 },
+    { min: 1e5, max: 4e5, rate: 0.1 },
+    { min: 4e5, max: 7e5, rate: 0.15 },
+    { min: 7e5, max: 11e5, rate: 0.2 },
+    { min: 11e5, max: Infinity, rate: 0.25 }
   ],
   USD: [
     { min: 0, max: 1e4, rate: 0.1 },
@@ -2087,6 +2272,17 @@ function determineOrgRole(employmentData) {
   }
   return ROLE_MAPPING.default;
 }
+function getPayPeriodsPerYear(frequency) {
+  const periodsMap = {
+    monthly: 12,
+    bi_weekly: 26,
+    weekly: 52,
+    daily: 365,
+    hourly: 2080
+    // Assuming 40 hours/week * 52 weeks
+  };
+  return periodsMap[frequency];
+}
 function mergeConfig(customConfig) {
   if (!customConfig) return HRM_CONFIG;
   return {
@@ -2288,6 +2484,7 @@ var Container = class {
 };
 
 // src/core/events.ts
+init_logger();
 var EventBus = class {
   handlers = /* @__PURE__ */ new Map();
   /**
@@ -2333,7 +2530,9 @@ var EventBus = class {
         try {
           await handler(payload);
         } catch (error) {
-          console.error(`Event handler error for ${event}:`, error);
+          getLogger().error(`Event handler error for ${event}`, {
+            error: error instanceof Error ? error.message : String(error)
+          });
         }
       })
     );
@@ -2372,6 +2571,7 @@ function createEventBus() {
 }
 
 // src/core/plugin.ts
+init_logger();
 var PluginManager = class {
   constructor(context) {
     this.context = context;
@@ -2440,8 +2640,7 @@ var PluginManager = class {
             try {
               await errorHandler(error, hookName);
             } catch (handlerError) {
-              const { getLogger: getLogger2 } = (init_logger(), __toCommonJS(logger_exports));
-              getLogger2().debug("Error handler threw an error", {
+              getLogger().debug("Error handler threw an error", {
                 hook: hookName,
                 handlerError: handlerError instanceof Error ? handlerError.message : String(handlerError)
               });
@@ -2464,6 +2663,9 @@ var PluginManager = class {
     return this.plugins.has(name);
   }
 };
+function definePlugin(definition) {
+  return definition;
+}
 
 // src/core/idempotency.ts
 init_logger();
@@ -2544,12 +2746,22 @@ var IdempotencyManager = class _IdempotencyManager {
     };
   }
 };
-function generatePayrollIdempotencyKey(organizationId, employeeId, month, year) {
-  return `payroll:${organizationId}:${employeeId}:${year}-${month}`;
+function generatePayrollIdempotencyKey(organizationId, employeeId, month, year, payrollRunType = "regular", periodStartDate) {
+  if (periodStartDate) {
+    const startDateStr = periodStartDate.toISOString().split("T")[0];
+    return `payroll:${organizationId}:${employeeId}:${year}-${month}:${startDateStr}:${payrollRunType}`;
+  }
+  return `payroll:${organizationId}:${employeeId}:${year}-${month}:${payrollRunType}`;
 }
 var WebhookManager = class {
   webhooks = [];
   deliveryLog = [];
+  maxLogSize;
+  storePayloads;
+  constructor(options) {
+    this.maxLogSize = options?.maxLogSize ?? 1e3;
+    this.storePayloads = options?.storePayloads ?? false;
+  }
   /**
    * Register a webhook
    */
@@ -2585,11 +2797,12 @@ var WebhookManager = class {
       id: deliveryId,
       event,
       url: webhook.url,
-      payload,
+      payload: this.storePayloads ? payload : void 0,
       attempt: 0,
       status: "pending"
     };
     this.deliveryLog.push(delivery);
+    this.pruneLog();
     const maxRetries = webhook.retries || 3;
     for (let attempt = 1; attempt <= maxRetries; attempt++) {
       delivery.attempt = attempt;
@@ -2700,6 +2913,15 @@ var WebhookManager = class {
     const signature = hmac.digest("hex");
     return `t=${timestamp},v1=${signature}`;
   }
+  /**
+   * Prune delivery log to stay within maxLogSize.
+   * Removes oldest entries first.
+   */
+  pruneLog() {
+    if (this.deliveryLog.length > this.maxLogSize) {
+      this.deliveryLog = this.deliveryLog.slice(-this.maxLogSize);
+    }
+  }
   /**
    * Sleep for ms
    */
@@ -3130,6 +3352,7 @@ var TransactionFactory = class {
 // src/payroll.ts
 init_query_builders();
 init_date();
+init_money();
 init_logger();
 init_errors();
 
@@ -3457,6 +3680,7 @@ function createEmployeeService(employeeRepo, config) {
 // src/factories/payroll.factory.ts
 init_date();
 init_calculation();
+init_money();
 var PayrollFactory = class {
   /**
    * Create payroll data object
@@ -3514,7 +3738,7 @@ var PayrollFactory = class {
    */
   static calculateAllowances(baseAmount, allowances) {
     return allowances.map((allowance) => {
-      const amount = allowance.isPercentage && allowance.value !== void 0 ? Math.round(baseAmount * allowance.value / 100) : allowance.amount;
+      const amount = allowance.isPercentage && allowance.value !== void 0 ? roundMoney(baseAmount * allowance.value / 100, 2) : allowance.amount;
       return {
         type: allowance.type,
         amount,
@@ -3527,7 +3751,7 @@ var PayrollFactory = class {
    */
   static calculateDeductions(baseAmount, deductions) {
     return deductions.map((deduction) => {
-      const amount = deduction.isPercentage && deduction.value !== void 0 ? Math.round(baseAmount * deduction.value / 100) : deduction.amount;
+      const amount = deduction.isPercentage && deduction.value !== void 0 ? roundMoney(baseAmount * deduction.value / 100, 2) : deduction.amount;
       return {
         type: deduction.type,
         amount,
@@ -3866,6 +4090,7 @@ function createPayrollService(payrollRepo, employeeService) {
 
 // src/factories/compensation.factory.ts
 init_calculation();
+init_money();
 var CompensationFactory = class {
   /**
    * Create compensation object
@@ -4013,7 +4238,7 @@ var CompensationFactory = class {
     const newBaseAmount = params.amount ? compensation.baseAmount + params.amount : compensation.baseAmount * (1 + (params.percentage || 0) / 100);
     return this.updateBaseAmount(
       compensation,
-      Math.round(newBaseAmount),
+      roundMoney(newBaseAmount, 2),
       params.effectiveFrom
     );
   }
@@ -4114,6 +4339,7 @@ var CompensationPresets = {
 // src/services/compensation.service.ts
 init_query_builders();
 init_logger();
+init_money();
 var CompensationService = class {
   constructor(employeeRepo) {
     this.employeeRepo = employeeRepo;
@@ -4370,12 +4596,12 @@ var CompensationService = class {
     return {
       department,
       employeeCount: stats.employeeCount,
-      totalBase: Math.round(stats.totalBase || 0),
-      totalGross: Math.round(stats.totalGross || 0),
-      totalNet: Math.round(stats.totalNet || 0),
-      averageBase: Math.round(stats.avgBase || 0),
-      averageGross: Math.round(stats.avgGross || 0),
-      averageNet: Math.round(stats.avgNet || 0)
+      totalBase: roundMoney(stats.totalBase || 0, 2),
+      totalGross: roundMoney(stats.totalGross || 0, 2),
+      totalNet: roundMoney(stats.totalNet || 0, 2),
+      averageBase: roundMoney(stats.avgBase || 0, 2),
+      averageGross: roundMoney(stats.avgGross || 0, 2),
+      averageNet: roundMoney(stats.avgNet || 0, 2)
     };
   }
   /**
@@ -4440,17 +4666,17 @@ var CompensationService = class {
     (results[0]?.byDepartment || []).forEach((dept) => {
       byDepartment[dept._id] = {
         count: dept.count,
-        totalNet: Math.round(dept.totalNet || 0)
+        totalNet: roundMoney(dept.totalNet || 0, 2)
       };
     });
     return {
       employeeCount: overallStats.employeeCount,
-      totalBase: Math.round(overallStats.totalBase || 0),
-      totalGross: Math.round(overallStats.totalGross || 0),
-      totalNet: Math.round(overallStats.totalNet || 0),
-      averageBase: Math.round(overallStats.avgBase || 0),
-      averageGross: Math.round(overallStats.avgGross || 0),
-      averageNet: Math.round(overallStats.avgNet || 0),
+      totalBase: roundMoney(overallStats.totalBase || 0, 2),
+      totalGross: roundMoney(overallStats.totalGross || 0, 2),
+      totalNet: roundMoney(overallStats.totalNet || 0, 2),
+      averageBase: roundMoney(overallStats.avgBase || 0, 2),
+      averageGross: roundMoney(overallStats.avgGross || 0, 2),
+      averageNet: roundMoney(overallStats.avgNet || 0, 2),
       byDepartment
     };
   }
@@ -4485,13 +4711,14 @@ init_date();
 init_prorating_calculator();
 
 // src/calculators/attendance.calculator.ts
+init_money();
 function calculateAttendanceDeduction(input) {
   const { expectedWorkingDays, actualWorkingDays, dailyRate } = input;
   const expected = Math.max(0, expectedWorkingDays);
   const actual = Math.max(0, actualWorkingDays);
   const rate = Math.max(0, dailyRate);
   const absentDays = Math.max(0, expected - actual);
-  const deductionAmount = Math.round(absentDays * rate);
+  const deductionAmount = roundMoney(absentDays * rate, 2);
   return {
     absentDays,
     deductionAmount,
@@ -4501,20 +4728,20 @@ function calculateAttendanceDeduction(input) {
 }
 function calculateDailyRate(monthlySalary, workingDays) {
   if (workingDays <= 0) return 0;
-  return Math.round(monthlySalary / workingDays);
+  return roundMoney(monthlySalary / workingDays, 2);
 }
 function calculateHourlyRate(monthlySalary, workingDays, hoursPerDay = 8) {
   const dailyRate = calculateDailyRate(monthlySalary, workingDays);
   if (hoursPerDay <= 0) return 0;
-  return Math.round(dailyRate / hoursPerDay);
+  return roundMoney(dailyRate / hoursPerDay, 2);
 }
 function calculatePartialDayDeduction(dailyRate, fractionAbsent) {
   const fraction = Math.min(1, Math.max(0, fractionAbsent));
-  return Math.round(dailyRate * fraction);
+  return roundMoney(dailyRate * fraction, 2);
 }
 function calculateTotalAttendanceDeduction(input) {
   const { dailyRate, fullDayAbsences = 0, partialDayAbsences = [] } = input;
-  const fullDayDeduction = Math.round(dailyRate * Math.max(0, fullDayAbsences));
+  const fullDayDeduction = roundMoney(dailyRate * Math.max(0, fullDayAbsences), 2);
   const partialDayDeduction = partialDayAbsences.reduce(
     (sum, fraction) => sum + calculatePartialDayDeduction(dailyRate, fraction),
     0
@@ -4528,7 +4755,7 @@ function calculateTotalAttendanceDeduction(input) {
 
 // src/calculators/salary.calculator.ts
 function calculateSalaryBreakdown(input) {
-  const { employee: employee2, period, attendance, options = {}, config, taxBrackets } = input;
+  const { employee: employee2, period, attendance, options = {}, config, taxBrackets, taxOptions, jurisdictionTaxConfig } = input;
   const comp = employee2.compensation;
   const originalBaseAmount = comp.baseAmount;
   const proRating = calculateProRatingForSalary(
@@ -4545,8 +4772,8 @@ function calculateSalaryBreakdown(input) {
   }
   const effectiveAllowances = (comp.allowances || []).filter((a) => isEffectiveForPeriod(a, period.startDate, period.endDate));
   const effectiveDeductions = (comp.deductions || []).filter((d) => isEffectiveForPeriod(d, period.startDate, period.endDate)).filter((d) => d.auto || d.recurring);
-  const allowances = processAllowances(effectiveAllowances, originalBaseAmount, proRating, config);
-  const deductions = processDeductions(effectiveDeductions, originalBaseAmount, proRating, config);
+  const allowances = processAllowances(effectiveAllowances, originalBaseAmount, proRating, config, options.skipProration);
+  const deductions = processDeductions(effectiveDeductions, originalBaseAmount, proRating, config, options.skipProration);
   if (!options.skipAttendance && config.attendanceIntegration && attendance) {
     const attendanceDeductionResult = calculateAttendanceDeductionFromData(
       attendance,
@@ -4563,12 +4790,24 @@ function calculateSalaryBreakdown(input) {
   }
   const grossSalary = calculateGross(baseAmount, allowances);
   const taxableAllowances = allowances.filter((a) => a.taxable);
-  const taxableAmount = baseAmount + sumAllowances(taxableAllowances);
+  let taxableAmount = baseAmount + sumAllowances(taxableAllowances);
+  const preTaxDeductionAmount = calculatePreTaxDeductions(
+    effectiveDeductions,
+    deductions,
+    taxOptions,
+    jurisdictionTaxConfig
+  );
+  taxableAmount = Math.max(0, taxableAmount - preTaxDeductionAmount);
+  const frequency = employee2.compensation?.frequency || "monthly";
   let taxAmount = 0;
   if (!options.skipTax && taxBrackets.length > 0 && config.autoDeductions) {
-    const annualTaxable = taxableAmount * 12;
-    const annualTax = applyTaxBrackets(annualTaxable, taxBrackets);
-    taxAmount = roundMoney(annualTax / 12);
+    taxAmount = calculateEnhancedTax(
+      taxableAmount,
+      taxBrackets,
+      taxOptions,
+      jurisdictionTaxConfig,
+      frequency
+    );
   }
   if (taxAmount > 0) {
     deductions.push({
@@ -4604,11 +4843,11 @@ function calculateProRatingForSalary(hireDate, terminationDate, periodStart, per
     holidays
   });
 }
-function processAllowances(allowances, originalBaseAmount, proRating, config) {
+function processAllowances(allowances, originalBaseAmount, proRating, config, skipProration) {
   return allowances.map((a) => {
     let amount = a.isPercentage && a.value !== void 0 ? percentageOf(originalBaseAmount, a.value) : a.amount;
     const originalAmount = amount;
-    if (proRating.isProRated && config.allowProRating) {
+    if (proRating.isProRated && config.allowProRating && !skipProration) {
       amount = prorateAmount(amount, proRating.ratio);
     }
     return {
@@ -4621,11 +4860,11 @@ function processAllowances(allowances, originalBaseAmount, proRating, config) {
     };
   });
 }
-function processDeductions(deductions, originalBaseAmount, proRating, config) {
+function processDeductions(deductions, originalBaseAmount, proRating, config, skipProration) {
   return deductions.map((d) => {
     let amount = d.isPercentage && d.value !== void 0 ? percentageOf(originalBaseAmount, d.value) : d.amount;
     const originalAmount = amount;
-    if (proRating.isProRated && config.allowProRating) {
+    if (proRating.isProRated && config.allowProRating && !skipProration) {
       amount = prorateAmount(amount, proRating.ratio);
     }
     return {
@@ -4656,6 +4895,78 @@ function calculateAttendanceDeductionFromData(attendance, baseAmount, effectiveW
     absentDays: result.absentDays
   };
 }
+function calculatePreTaxDeductions(effectiveDeductions, processedDeductions, taxOptions, jurisdictionTaxConfig) {
+  let totalPreTax = 0;
+  for (let i = 0; i < effectiveDeductions.length; i++) {
+    const original = effectiveDeductions[i];
+    const processed = processedDeductions[i];
+    if (original.reducesTaxableIncome) {
+      totalPreTax += processed?.amount || 0;
+    }
+  }
+  if (jurisdictionTaxConfig?.preTaxDeductionTypes?.length) {
+    const preTaxTypes = new Set(jurisdictionTaxConfig.preTaxDeductionTypes);
+    for (let i = 0; i < effectiveDeductions.length; i++) {
+      const original = effectiveDeductions[i];
+      const processed = processedDeductions[i];
+      if (original.reducesTaxableIncome) continue;
+      if (preTaxTypes.has(original.type)) {
+        totalPreTax += processed?.amount || 0;
+      }
+    }
+  }
+  if (taxOptions?.preTaxDeductions?.length) {
+    for (const deduction of taxOptions.preTaxDeductions) {
+      totalPreTax += deduction.amount;
+    }
+  }
+  return roundMoney(totalPreTax);
+}
+function calculateEnhancedTax(periodTaxable, taxBrackets, taxOptions, jurisdictionTaxConfig, frequency = "monthly") {
+  const periodsPerYear = getPayPeriodsPerYear(frequency);
+  let annualTaxable = periodTaxable * periodsPerYear;
+  const threshold = getApplicableThreshold(taxOptions, jurisdictionTaxConfig);
+  if (threshold > 0) {
+    annualTaxable = Math.max(0, annualTaxable - threshold);
+  }
+  let annualTax = applyTaxBrackets(annualTaxable, taxBrackets);
+  if (taxOptions?.taxCredits?.length && annualTax > 0) {
+    annualTax = applyTaxCredits(annualTax, taxOptions.taxCredits);
+  }
+  return roundMoney(annualTax / periodsPerYear);
+}
+function getApplicableThreshold(taxOptions, jurisdictionTaxConfig) {
+  if (taxOptions?.standardDeductionOverride !== void 0) {
+    return taxOptions.standardDeductionOverride;
+  }
+  if (taxOptions?.taxpayerCategory) {
+    const category = taxOptions.taxpayerCategory;
+    if (taxOptions.thresholdOverrides?.[category] !== void 0) {
+      return taxOptions.thresholdOverrides[category];
+    }
+    if (jurisdictionTaxConfig?.thresholdsByCategory?.[category] !== void 0) {
+      return jurisdictionTaxConfig.thresholdsByCategory[category];
+    }
+  }
+  if (taxOptions?.applyStandardDeduction && jurisdictionTaxConfig?.standardDeduction) {
+    return jurisdictionTaxConfig.standardDeduction;
+  }
+  return 0;
+}
+function applyTaxCredits(annualTax, taxCredits) {
+  let remainingTax = annualTax;
+  for (const credit of taxCredits) {
+    if (remainingTax <= 0) break;
+    let creditAmount = credit.amount;
+    if (credit.maxPercent !== void 0 && credit.maxPercent > 0) {
+      const maxCredit = annualTax * credit.maxPercent;
+      creditAmount = Math.min(creditAmount, maxCredit);
+    }
+    creditAmount = Math.min(creditAmount, remainingTax);
+    remainingTax -= creditAmount;
+  }
+  return Math.max(0, remainingTax);
+}
 
 // src/core/repository-plugins.ts
 init_query_builders();
@@ -4800,26 +5111,9 @@ function getEmployeeName(employee2) {
   }
   return employee2.employeeId;
 }
-function isMongoError(error) {
-  return error instanceof MongoServerError;
-}
-function isDuplicateKeyError(error) {
-  return isMongoError(error) && error.code === 11e3;
-}
-function parseDuplicateKeyError(error) {
-  const message = error.message || "";
-  const match = message.match(/dup key: \{ ([^:]+):/);
-  if (match && match[1]) {
-    return match[1].trim();
-  }
-  const errmsgMatch = message.match(/index: ([^_]+)_/);
-  if (errmsgMatch && errmsgMatch[1]) {
-    return errmsgMatch[1].trim();
-  }
-  return "unknown";
-}
 
 // src/managers/salary-processing.manager.ts
+init_type_guards();
 var SalaryProcessingManager = class {
   constructor(models, _container, events, idempotency, repositoryManager, calculateSalaryBreakdownFn, resolveOrganizationIdFn, resolveEmployeeIdFn, findEmployeeFn, updatePayrollStatsFn, config) {
     this.models = models;
@@ -4862,32 +5156,65 @@ var SalaryProcessingManager = class {
    * Process salary for a single employee
    */
   async processSalary(params) {
-    const { employeeId, employeeIdMode, organizationId: explicitOrgId, month, year, paymentDate = /* @__PURE__ */ new Date(), paymentMethod = "bank", attendance, options, context, idempotencyKey } = params;
+    const {
+      employeeId,
+      employeeIdMode,
+      organizationId: explicitOrgId,
+      month,
+      year,
+      paymentDate = /* @__PURE__ */ new Date(),
+      paymentMethod = "bank",
+      attendance,
+      options,
+      context,
+      idempotencyKey,
+      payrollRunType = "regular",
+      retroactiveAdjustment,
+      employerContributions
+    } = params;
     const orgId = this.resolveOrganizationIdFn(explicitOrgId || context?.organizationId);
+    const repos = this.repositoryManager.getReposForRequest(orgId);
     const resolvedEmployeeId = await this.resolveEmployeeIdFn(employeeId, employeeIdMode, orgId, context?.session);
-    const idempotentKey = idempotencyKey || generatePayrollIdempotencyKey(orgId, resolvedEmployeeId, month, year);
+    const employee2 = await this.findEmployeeFn({
+      employeeId,
+      employeeIdMode,
+      organizationId: orgId,
+      session: context?.session ?? void 0,
+      populate: "userId"
+    });
+    const employeeFrequency = employee2.compensation?.frequency || "monthly";
+    const frequencyPeriod = getPayPeriodForFrequency(employeeFrequency, paymentDate, month, year);
+    const period = { ...frequencyPeriod, payDate: paymentDate };
+    const idempotentKey = idempotencyKey || generatePayrollIdempotencyKey(
+      orgId,
+      resolvedEmployeeId,
+      month,
+      year,
+      payrollRunType,
+      employeeFrequency !== "monthly" ? period.startDate : void 0
+    );
     const cached = this.idempotency.get(idempotentKey);
     if (cached) {
       getLogger().info("Returning cached payroll result (idempotent)", {
         idempotencyKey: idempotentKey,
-        cachedAt: cached.createdAt
+        cachedAt: cached.createdAt,
+        frequency: employeeFrequency
       });
       return cached.value;
     }
     const providedSession = context?.session;
-    const repos = this.repositoryManager.getReposForRequest(orgId);
     if (providedSession) {
-      return this._processSalaryWithSession(providedSession, repos, params, resolvedEmployeeId, orgId, idempotentKey);
+      return this._processSalaryWithSession(providedSession, repos, params, resolvedEmployeeId, orgId, idempotentKey, employee2, period);
     }
     try {
       return await repos.employee.withTransaction(
-        async (session) => this._processSalaryWithSession(session, repos, params, resolvedEmployeeId, orgId, idempotentKey),
+        async (session) => this._processSalaryWithSession(session, repos, params, resolvedEmployeeId, orgId, idempotentKey, employee2, period),
         { allowFallback: true }
         // Fallback to non-transactional for standalone MongoDB
       );
     } catch (error) {
       if (isDuplicateKeyError(error)) {
-        return this._handleDuplicateKeyError(error, resolvedEmployeeId, orgId, params.month, params.year, idempotentKey);
+        return this._handleDuplicateKeyError(error, resolvedEmployeeId, orgId, params.month, params.year, payrollRunType, idempotentKey, period.startDate, employeeFrequency);
       }
       throw error;
     }
@@ -4896,21 +5223,29 @@ var SalaryProcessingManager = class {
    * Handle duplicate key error by fetching existing payroll record
    * MUST be called OUTSIDE transaction to avoid session state corruption
    */
-  async _handleDuplicateKeyError(error, resolvedEmployeeId, orgId, month, year, idempotentKey) {
+  async _handleDuplicateKeyError(error, resolvedEmployeeId, orgId, month, year, payrollRunType, idempotentKey, periodStartDate, employeeFrequency) {
     const duplicateField = parseDuplicateKeyError(error);
-    getLogger().warn("Duplicate payroll record detected, fetching existing", {
+    getLogger().warn("Duplicate payroll record detected (E11000), fetching existing", {
       employeeId: resolvedEmployeeId.toString(),
       month,
       year,
+      payrollRunType,
       idempotencyKey: idempotentKey,
-      duplicateField
+      duplicateField,
+      periodStartDate: periodStartDate.toISOString(),
+      frequency: employeeFrequency
     });
-    const existingPayroll = await this.models.PayrollRecordModel.findOne({
+    const query = {
       organizationId: orgId,
       employeeId: resolvedEmployeeId,
       "period.month": month,
-      "period.year": year
-    }).populate("transactionId");
+      "period.year": year,
+      payrollRunType
+    };
+    if (employeeFrequency !== "monthly") {
+      query["period.startDate"] = periodStartDate;
+    }
+    const existingPayroll = await this.models.PayrollRecordModel.findOne(query).populate("transactionId");
     if (existingPayroll && existingPayroll.transactionId) {
       const existingEmployee = await this.models.EmployeeModel.findOne({
         _id: resolvedEmployeeId,
@@ -4939,43 +5274,111 @@ var SalaryProcessingManager = class {
       this.idempotency.set(idempotentKey, result);
       return result;
     }
+    if (existingPayroll && !existingPayroll.transactionId) {
+      const status = existingPayroll.status;
+      if (status === "failed") {
+        throw new PayrollError(
+          `Previous payroll attempt failed for employee in ${month}/${year}. Retry to automatically clean up and reprocess.`,
+          "DUPLICATE_PAYROLL",
+          409,
+          {
+            existingRecordId: existingPayroll._id.toString(),
+            status,
+            reason: "orphaned_failed_record",
+            retryable: true
+          }
+        );
+      }
+      if (status === "processing" || status === "pending") {
+        try {
+          await this.models.PayrollRecordModel.updateOne(
+            { _id: existingPayroll._id },
+            { $set: { status: "failed" } }
+          );
+          getLogger().warn("Marked orphaned payroll record as failed", {
+            payrollRecordId: existingPayroll._id.toString(),
+            previousStatus: status
+          });
+        } catch {
+        }
+        throw new PayrollError(
+          `Previous payroll attempt was incomplete for employee in ${month}/${year}. The record has been marked as failed - retry to reprocess.`,
+          "DUPLICATE_PAYROLL",
+          409,
+          {
+            existingRecordId: existingPayroll._id.toString(),
+            status: "failed",
+            reason: "orphaned_record_cleaned",
+            retryable: true
+          }
+        );
+      }
+    }
     throw error;
   }
   /**
    * Internal: Process salary with a specific session
    * Extracted to support both external sessions and withTransaction() pattern
-   */
-  async _processSalaryWithSession(session, repos, params, resolvedEmployeeId, orgId, idempotentKey) {
-    const { employeeId, employeeIdMode, month, year, paymentDate = /* @__PURE__ */ new Date(), paymentMethod = "bank", attendance, options, context } = params;
+   *
+   * @param session - Database session (for transactions)
+   * @param repos - Request-scoped repositories
+   * @param params - Salary processing parameters
+   * @param resolvedEmployeeId - Pre-resolved employee ObjectId
+   * @param orgId - Organization ID
+   * @param idempotentKey - Pre-calculated idempotency key
+   * @param prefetchedEmployee - Pre-fetched employee (to avoid duplicate DB call)
+   * @param prefetchedPeriod - Pre-calculated period (to avoid duplicate calculation)
+   */
+  async _processSalaryWithSession(session, repos, params, resolvedEmployeeId, orgId, idempotentKey, prefetchedEmployee, prefetchedPeriod) {
+    const {
+      month,
+      year,
+      paymentDate = /* @__PURE__ */ new Date(),
+      paymentMethod = "bank",
+      attendance,
+      options,
+      context,
+      payrollRunType = "regular",
+      retroactiveAdjustment,
+      employerContributions
+    } = params;
     const mongooseSession = session ?? void 0;
+    let createdPayrollRecordId = null;
+    let createdTransactionId = null;
     try {
-      const employee2 = await this.findEmployeeFn({
-        employeeId,
-        // Supports both ObjectId and string
-        employeeIdMode,
-        // Explicit disambiguation if needed
-        organizationId: orgId,
-        session: mongooseSession,
-        populate: "userId"
-      });
+      const employee2 = prefetchedEmployee;
       const canReceive = hasPluginMethod(employee2, "canReceiveSalary") ? employee2.canReceiveSalary() : (employee2.status === "active" || employee2.status === "on_leave") && (employee2.compensation?.baseAmount || 0) > 0;
       if (!canReceive) {
         throw new NotEligibleError("Employee is not eligible to receive salary");
       }
-      const existingQuery = payroll().forOrganization(orgId).forEmployee(employee2._id).forPeriod(month, year).build();
+      const period = prefetchedPeriod;
+      const employeeFrequency = employee2.compensation?.frequency || "monthly";
+      const existingQuery = {
+        ...payroll().forOrganization(orgId).forEmployee(employee2._id).forPeriod(month, year).build(),
+        payrollRunType
+        // Only check for same run type
+      };
+      if (employeeFrequency !== "monthly") {
+        existingQuery["period.startDate"] = period.startDate;
+      }
       let existingRecordQuery = this.models.PayrollRecordModel.findOne(existingQuery);
       if (mongooseSession) existingRecordQuery = existingRecordQuery.session(mongooseSession);
       const existingRecord = await existingRecordQuery;
       if (existingRecord) {
         if (existingRecord.status === "paid" || existingRecord.status === "processing") {
-          throw new DuplicatePayrollError(employee2.employeeId, month, year);
+          throw new DuplicatePayrollError(employee2.employeeId, month, year, payrollRunType);
         }
         if (existingRecord.status === "voided") {
           throw new PayrollError(
-            `Cannot retry voided payroll for employee ${employee2.employeeId} in ${month}/${year} - intentionally cancelled`,
-            "DUPLICATE_PAYROLL",
+            `Cannot re-process voided payroll for employee ${employee2.employeeId} in ${month}/${year}. To re-process, first call restorePayroll() to restore the voided record to 'pending' status.`,
+            "VOIDED_PAYROLL_REPROCESS",
             409,
-            { status: existingRecord.status, reason: "intentionally_cancelled" }
+            {
+              status: existingRecord.status,
+              reason: "voided_requires_restore",
+              suggestedAction: "Call restorePayroll({ payrollRecordId }) first",
+              existingRecordId: existingRecord._id.toString()
+            }
           );
         }
         if (existingRecord.status === "reversed") {
@@ -4998,29 +5401,29 @@ var SalaryProcessingManager = class {
               }
             );
           }
-          if (existingRecord.status === "failed") {
-            getLogger().info("Removing failed record without transaction for retry", {
+          if (existingRecord.status === "failed" || existingRecord.status === "pending") {
+            getLogger().info("Removing incomplete record without transaction for retry", {
               recordId: existingRecord._id.toString(),
               status: existingRecord.status,
               employeeId: employee2.employeeId,
               month,
-              year
+              year,
+              payrollRunType
             });
             await this.cascadeDeletePayrollRecord(existingRecord._id, mongooseSession);
           } else {
             throw new PayrollError(
-              `Cannot retry ${existingRecord.status} payroll for employee ${employee2.employeeId} in ${month}/${year} - preserve data integrity`,
+              `Cannot retry ${existingRecord.status} payroll for employee ${employee2.employeeId} in ${month}/${year} - unexpected status`,
               "DUPLICATE_PAYROLL",
               409,
-              { status: existingRecord.status, reason: "data_integrity_preservation" }
+              { status: existingRecord.status, reason: "unexpected_status" }
             );
           }
         }
       }
-      const period = { ...getPayPeriod(month, year), payDate: paymentDate };
       const breakdown = await this.calculateSalaryBreakdownFn(employee2, period, { attendance, options }, mongooseSession);
       const userIdValue = employee2.userId ? typeof employee2.userId === "object" && "_id" in employee2.userId ? employee2.userId._id : employee2.userId : void 0;
-      const [payrollRecord] = await this.models.PayrollRecordModel.create([{
+      const payrollRecord = await repos.payrollRecord.create({
         organizationId: orgId,
         employeeId: employee2._id,
         userId: userIdValue,
@@ -5029,10 +5432,18 @@ var SalaryProcessingManager = class {
         status: "processing",
         paymentMethod,
         processedAt: /* @__PURE__ */ new Date(),
-        processedBy: context?.userId ? toObjectId(context.userId) : void 0
-      }], mongooseSession ? { session: mongooseSession } : {});
+        processedBy: context?.userId ? toObjectId(context.userId) : void 0,
+        // Payroll run type and related fields (v2.8.0+)
+        payrollRunType,
+        // Payment frequency at time of processing (v2.9.0+)
+        // Stored for proper idempotency key reconstruction in void/reverse
+        paymentFrequency: employeeFrequency,
+        retroactiveAdjustment,
+        employerContributions
+      }, mongooseSession ? { session: mongooseSession } : {});
+      createdPayrollRecordId = payrollRecord._id;
       const frequency = employee2.compensation.frequency || "monthly";
-      const [transaction] = await this.models.TransactionModel.create([{
+      const transaction = await repos.transaction.create({
         organizationId: orgId,
         // Classification (shared-types)
         type: "salary",
@@ -5063,7 +5474,7 @@ var SalaryProcessingManager = class {
         customerId: userIdValue,
         // Use normalized value (handles populated docs)
         processedBy: context?.userId ? toObjectId(context.userId) : void 0,
-        // ✅ UNIFIED: Breakdown structure
+        // Breakdown structure
         breakdown: {
           base: breakdown.baseAmount,
           additions: breakdown.allowances.map((a) => ({
@@ -5105,7 +5516,8 @@ var SalaryProcessingManager = class {
           email: getEmployeeEmail(employee2),
           payrollRecordId: payrollRecord._id.toString()
         }
-      }], mongooseSession ? { session: mongooseSession } : {});
+      }, mongooseSession ? { session: mongooseSession } : {});
+      createdTransactionId = transaction._id;
       payrollRecord.transactionId = transaction._id;
       payrollRecord.status = "paid";
       payrollRecord.paidAt = paymentDate;
@@ -5120,6 +5532,7 @@ var SalaryProcessingManager = class {
         await taxService.createFromBreakdown({
           organizationId: orgId,
           employeeId: employee2._id,
+          employeeBusinessId: employee2.employeeId,
           userId: userIdValue,
           payrollRecordId: payrollRecord._id,
           transactionId: transaction._id,
@@ -5168,6 +5581,41 @@ var SalaryProcessingManager = class {
       this.idempotency.set(idempotentKey, result);
       return result;
     } catch (error) {
+      if (!session && createdPayrollRecordId) {
+        try {
+          const existingRecord = await this.models.PayrollRecordModel.findById(createdPayrollRecordId);
+          if (existingRecord?.status === "paid" && existingRecord?.transactionId) {
+            getLogger().warn("Payroll record already paid with transaction - not marking as failed", {
+              payrollRecordId: createdPayrollRecordId.toString(),
+              transactionId: existingRecord.transactionId.toString(),
+              status: existingRecord.status,
+              error: error.message
+            });
+          } else {
+            const updateFields = { status: "failed" };
+            if (createdTransactionId) {
+              updateFields.transactionId = createdTransactionId;
+            }
+            await repos.payrollRecord.update(
+              createdPayrollRecordId,
+              updateFields,
+              { throwOnNotFound: false }
+            );
+            getLogger().warn("Marked payroll record as failed after non-transactional error", {
+              payrollRecordId: createdPayrollRecordId.toString(),
+              transactionId: createdTransactionId?.toString(),
+              error: error.message
+            });
+          }
+        } catch (cleanupError) {
+          getLogger().error("Failed to mark payroll record as failed during cleanup", {
+            payrollRecordId: createdPayrollRecordId.toString(),
+            transactionId: createdTransactionId?.toString(),
+            cleanupError: cleanupError.message,
+            originalError: error.message
+          });
+        }
+      }
       throw error;
     }
   }
@@ -5192,10 +5640,11 @@ function createSalaryProcessingManager(models, container, events, idempotency, r
 init_logger();
 init_query_builders();
 var BulkOperationsManager = class {
-  constructor(models, events, processSalaryFn) {
+  constructor(models, events, processSalaryFn, resolveOrganizationIdFn) {
     this.models = models;
     this.events = events;
     this.processSalaryFn = processSalaryFn;
+    this.resolveOrganizationIdFn = resolveOrganizationIdFn;
   }
   /**
    * Process bulk payroll for multiple employees
@@ -5209,7 +5658,7 @@ var BulkOperationsManager = class {
    */
   async processBulkPayroll(params) {
     const {
-      organizationId,
+      organizationId: explicitOrgId,
       month,
       year,
       employeeIds = [],
@@ -5223,9 +5672,11 @@ var BulkOperationsManager = class {
       batchSize = 10,
       batchDelay = 0,
       concurrency = 1,
-      useStreaming
+      useStreaming,
+      maxResultDetails = Infinity
     } = params;
-    const query = { organizationId: toObjectId(organizationId), status: "active" };
+    const organizationId = this.resolveOrganizationIdFn(explicitOrgId || context?.organizationId);
+    const query = { organizationId, status: { $in: ["active", "on_leave"] } };
     if (employeeIds.length > 0) {
       query._id = { $in: employeeIds.map(toObjectId) };
     }
@@ -5246,7 +5697,8 @@ var BulkOperationsManager = class {
         batchDelay,
         concurrency,
         onProgress,
-        total: employeeCount
+        total: employeeCount,
+        maxResultDetails
       });
     }
     const employees = await this.models.EmployeeModel.find(query);
@@ -5254,16 +5706,19 @@ var BulkOperationsManager = class {
     const results = {
       successful: [],
       failed: [],
-      total
+      total,
+      successCount: 0,
+      failCount: 0,
+      totalAmount: 0
     };
     const reportProgress = async (currentEmployee) => {
       if (onProgress) {
-        const processed = results.successful.length + results.failed.length;
+        const processed = results.successCount + results.failCount;
         await onProgress({
           processed,
           total,
-          successful: results.successful.length,
-          failed: results.failed.length,
+          successful: results.successCount,
+          failed: results.failCount,
           currentEmployee,
           percentage: total > 0 ? Math.round(processed / total * 100) : 0
         });
@@ -5273,7 +5728,7 @@ var BulkOperationsManager = class {
       if (signal?.aborted) {
         getLogger().warn("Bulk payroll cancelled", {
           organizationId: organizationId.toString(),
-          processed: results.successful.length + results.failed.length,
+          processed: results.successCount + results.failCount,
           total
         });
         throw new Error("Payroll processing cancelled by user");
@@ -5293,16 +5748,24 @@ var BulkOperationsManager = class {
               options,
               context: { ...context, session: void 0 }
             });
-            results.successful.push({
-              employeeId: employee2.employeeId,
-              amount: result.payrollRecord.breakdown.netSalary,
-              transactionId: result.transaction._id
-            });
+            const amount = result.payrollRecord.breakdown.netSalary;
+            results.successCount++;
+            results.totalAmount += amount;
+            if (results.successful.length < maxResultDetails) {
+              results.successful.push({
+                employeeId: employee2.employeeId,
+                amount,
+                transactionId: result.transaction._id
+              });
+            }
           } catch (error) {
-            results.failed.push({
-              employeeId: employee2.employeeId,
-              error: error.message
-            });
+            results.failCount++;
+            if (results.failed.length < maxResultDetails) {
+              results.failed.push({
+                employeeId: employee2.employeeId,
+                error: error.message
+              });
+            }
             getLogger().error("Failed to process salary", {
               employeeId: employee2.employeeId,
               error: error.message
@@ -5332,16 +5795,24 @@ var BulkOperationsManager = class {
           const batchResult = batchResults[j];
           const employee2 = batch[j];
           if (batchResult.status === "fulfilled") {
-            results.successful.push({
-              employeeId: batchResult.value.employee.employeeId,
-              amount: batchResult.value.result.payrollRecord.breakdown.netSalary,
-              transactionId: batchResult.value.result.transaction._id
-            });
+            const amount = batchResult.value.result.payrollRecord.breakdown.netSalary;
+            results.successCount++;
+            results.totalAmount += amount;
+            if (results.successful.length < maxResultDetails) {
+              results.successful.push({
+                employeeId: batchResult.value.employee.employeeId,
+                amount,
+                transactionId: batchResult.value.result.transaction._id
+              });
+            }
           } else {
-            results.failed.push({
-              employeeId: employee2.employeeId,
-              error: batchResult.reason.message || "Unknown error"
-            });
+            results.failCount++;
+            if (results.failed.length < maxResultDetails) {
+              results.failed.push({
+                employeeId: employee2.employeeId,
+                error: batchResult.reason.message || "Unknown error"
+              });
+            }
             getLogger().error("Failed to process salary (concurrent)", {
               employeeId: employee2.employeeId,
               error: batchResult.reason.message
@@ -5359,9 +5830,9 @@ var BulkOperationsManager = class {
       period: { month, year },
       summary: {
         total: results.total,
-        successful: results.successful.length,
-        failed: results.failed.length,
-        totalAmount: results.successful.reduce((sum, r) => sum + r.amount, 0)
+        successful: results.successCount,
+        failed: results.failCount,
+        totalAmount: results.totalAmount
       },
       context
     });
@@ -5370,8 +5841,8 @@ var BulkOperationsManager = class {
       month,
       year,
       total: results.total,
-      successful: results.successful.length,
-      failed: results.failed.length,
+      successful: results.successCount,
+      failed: results.failCount,
       concurrency,
       batchSize
     });
@@ -5401,13 +5872,17 @@ var BulkOperationsManager = class {
       batchDelay,
       concurrency,
       onProgress,
-      total
+      total,
+      maxResultDetails
     } = params;
     const startTime = Date.now();
     const results = {
       successful: [],
       failed: [],
-      total
+      total,
+      successCount: 0,
+      failCount: 0,
+      totalAmount: 0
     };
     const cursor = this.models.EmployeeModel.find(query).cursor();
     let processed = 0;
@@ -5418,8 +5893,8 @@ var BulkOperationsManager = class {
         await onProgress({
           processed,
           total,
-          successful: results.successful.length,
-          failed: results.failed.length,
+          successful: results.successCount,
+          failed: results.failCount,
           currentEmployee,
           percentage: total > 0 ? Math.round(processed / total * 100) : 0
         });
@@ -5446,16 +5921,24 @@ var BulkOperationsManager = class {
             options,
             context: { ...context, session: void 0 }
           });
-          results.successful.push({
-            employeeId: employee2.employeeId,
-            amount: result.payrollRecord.breakdown.netSalary,
-            transactionId: result.transaction._id
-          });
+          const amount = result.payrollRecord.breakdown.netSalary;
+          results.successCount++;
+          results.totalAmount += amount;
+          if (results.successful.length < maxResultDetails) {
+            results.successful.push({
+              employeeId: employee2.employeeId,
+              amount,
+              transactionId: result.transaction._id
+            });
+          }
         } catch (error) {
-          results.failed.push({
-            employeeId: employee2.employeeId,
-            error: error.message
-          });
+          results.failCount++;
+          if (results.failed.length < maxResultDetails) {
+            results.failed.push({
+              employeeId: employee2.employeeId,
+              error: error.message
+            });
+          }
           getLogger().error("Failed to process salary (streaming)", {
             employeeId: employee2.employeeId,
             error: error.message
@@ -5482,17 +5965,17 @@ var BulkOperationsManager = class {
       period: { month, year },
       summary: {
         total: results.total,
-        successful: results.successful.length,
-        failed: results.failed.length,
-        totalAmount: results.successful.reduce((sum, r) => sum + r.amount, 0)
+        successful: results.successCount,
+        failed: results.failCount,
+        totalAmount: results.totalAmount
       },
       context
     });
     const duration = Date.now() - startTime;
     getLogger().info("Streaming bulk payroll completed", {
       total: results.total,
-      successful: results.successful.length,
-      failed: results.failed.length,
+      successful: results.successCount,
+      failed: results.failCount,
       duration,
       concurrency,
       batchSize
@@ -5500,8 +5983,8 @@ var BulkOperationsManager = class {
     return results;
   }
 };
-function createBulkOperationsManager(models, events, processSalaryFn) {
-  return new BulkOperationsManager(models, events, processSalaryFn);
+function createBulkOperationsManager(models, events, processSalaryFn, resolveOrganizationIdFn) {
+  return new BulkOperationsManager(models, events, processSalaryFn, resolveOrganizationIdFn);
 }
 
 // src/managers/employee-operations.manager.ts
@@ -5978,9 +6461,6 @@ function createCompensationManager(events, resolveOrganizationIdFn, resolveEmplo
     getServicesForRequestFn
   );
 }
-
-// src/managers/payroll-history.manager.ts
-init_logger();
 init_query_builders();
 var PayrollHistoryManager = class {
   constructor(models, events, resolveOrganizationIdFn, findEmployeeFn) {
@@ -6047,8 +6527,9 @@ var PayrollHistoryManager = class {
    * @returns Aggregated summary statistics
    */
   async payrollSummary(params) {
-    const { organizationId, month, year } = params;
-    const query = { organizationId: toObjectId(organizationId) };
+    const { organizationId: explicitOrgId, month, year } = params;
+    const orgId = this.resolveOrganizationIdFn(explicitOrgId);
+    const query = { organizationId: orgId };
     if (month) query["period.month"] = month;
     if (year) query["period.year"] = year;
     const [summary] = await this.models.PayrollRecordModel.aggregate([
@@ -6076,43 +6557,6 @@ var PayrollHistoryManager = class {
       pendingCount: 0
     };
   }
-  /**
-   * Export payroll data for a date range
-   *
-   * Features:
-   * - Retrieves all payroll records in date range
-   * - Populates employee and transaction details
-   * - Marks records as exported with timestamp
-   * - Emits audit event for compliance
-   *
-   * IMPORTANT: Marks records as exported to prevent duplicate exports
-   *
-   * @param params - Export parameters (organization, date range)
-   * @returns Payroll records with full details
-   */
-  async exportPayroll(params) {
-    const { organizationId, startDate, endDate } = params;
-    const query = {
-      organizationId: toObjectId(organizationId),
-      "period.payDate": { $gte: startDate, $lte: endDate }
-    };
-    const records = await this.models.PayrollRecordModel.find(query).populate("employeeId", "employeeId position department").populate("userId", "name email").populate("transactionId", "amount method status date").sort({ "period.year": -1, "period.month": -1 });
-    await this.models.PayrollRecordModel.updateMany(query, {
-      exported: true,
-      exportedAt: /* @__PURE__ */ new Date()
-    });
-    this.events.emitSync("payroll:exported", {
-      organizationId: toObjectId(organizationId),
-      dateRange: { start: startDate, end: endDate },
-      recordCount: records.length,
-      format: "json"
-    });
-    getLogger().info("Payroll data exported", {
-      organizationId: organizationId.toString(),
-      count: records.length
-    });
-    return records;
-  }
 };
 function createPayrollHistoryManager(models, events, resolveOrganizationIdFn, findEmployeeFn) {
   return new PayrollHistoryManager(models, events, resolveOrganizationIdFn, findEmployeeFn);
@@ -6442,6 +6886,20 @@ var PayrollStateManager = class {
         "Cannot restore a payroll with reversal transaction. The transaction would become orphaned."
       );
     }
+    const existingActive = await this.models.PayrollRecordModel.findOne({
+      organizationId: toObjectId(organizationId),
+      employeeId: payrollRecord.employeeId,
+      "period.month": payrollRecord.period.month,
+      "period.year": payrollRecord.period.year,
+      payrollRunType: payrollRecord.payrollRunType,
+      isVoided: { $ne: true },
+      _id: { $ne: payrollRecord._id }
+    }).session(session || null);
+    if (existingActive) {
+      throw new ValidationError(
+        `Cannot restore: An active payroll record already exists for employee ${payrollRecord.employeeId} in ${payrollRecord.period.month}/${payrollRecord.period.year} with run type '${payrollRecord.payrollRunType}'. Void or reverse the existing record first.`
+      );
+    }
     payrollRecord.status = PAYROLL_STATUS.PENDING;
     payrollRecord.isVoided = false;
     payrollRecord.notes = `${payrollRecord.notes || ""}
@@ -6534,6 +6992,7 @@ var Payroll = class _Payroll {
       singleTenant: singleTenant ?? null,
       logger: customLogger
     });
+    const containerBase = this._container;
     this.repositoryManager = createRepositoryManager(
       {
         EmployeeModel,
@@ -6542,7 +7001,7 @@ var Payroll = class _Payroll {
         LeaveRequestModel: config.LeaveRequestModel ?? null,
         TaxWithholdingModel: config.TaxWithholdingModel ?? null
       },
-      this._container
+      containerBase
     );
     this.salaryProcessingManager = createSalaryProcessingManager(
       {
@@ -6551,7 +7010,6 @@ var Payroll = class _Payroll {
         TransactionModel,
         AttendanceModel: AttendanceModel ?? null,
         LeaveRequestModel: config.LeaveRequestModel ?? null,
-        // Type assertion: The model has custom statics defined in schema but not reflected in config type
         TaxWithholdingModel: config.TaxWithholdingModel ?? null
       },
       this._container,
@@ -6573,7 +7031,8 @@ var Payroll = class _Payroll {
         AttendanceModel: AttendanceModel ?? null
       },
       this._events,
-      this.processSalary.bind(this)
+      this.processSalary.bind(this),
+      this.resolveOrganizationId.bind(this)
     );
     this.employeeOperationsManager = createEmployeeOperationsManager(
       this._events,
@@ -6582,7 +7041,6 @@ var Payroll = class _Payroll {
       this.findEmployee.bind(this),
       (orgId) => this.repositoryManager.getReposForRequest(orgId),
       (repos) => {
-        repos.employee ? repos.employee._organizationId : void 0;
         return this.getServicesForRequest(repos);
       }
     );
@@ -6593,7 +7051,6 @@ var Payroll = class _Payroll {
       this.findEmployee.bind(this),
       (orgId) => this.repositoryManager.getReposForRequest(orgId),
       (repos) => {
-        repos.employee ? repos.employee._organizationId : void 0;
         return this.getServicesForRequest(repos);
       }
     );
@@ -7032,7 +7489,11 @@ var Payroll = class _Payroll {
                 populateUser,
                 session
               });
-            } catch {
+            } catch (modeError) {
+              if (modeError instanceof EmployeeNotFoundError) {
+                continue;
+              }
+              throw modeError;
             }
           }
           break;
@@ -7205,13 +7666,6 @@ var Payroll = class _Payroll {
     this.ensureInitialized();
     return this.payrollHistoryManager.payrollSummary(params);
   }
-  /**
-   * Export payroll data
-   */
-  async exportPayroll(params) {
-    this.ensureInitialized();
-    return this.payrollHistoryManager.exportPayroll(params);
-  }
   // ========================================
   // Void / Reversal Methods (v2.4.0+)
   // ========================================
@@ -7234,12 +7688,15 @@ var Payroll = class _Payroll {
   async voidPayroll(params) {
     this.ensureInitialized();
     const result = await this.payrollStateManager.voidPayroll(params);
-    const { employeeId, period, organizationId } = result.payrollRecord;
+    const { employeeId, period, organizationId, payrollRunType = "regular", paymentFrequency = "monthly" } = result.payrollRecord;
+    const isNonMonthly = paymentFrequency !== "monthly";
     const idempotencyKey = generatePayrollIdempotencyKey(
       organizationId,
       employeeId,
       period.month,
-      period.year
+      period.year,
+      payrollRunType,
+      isNonMonthly ? period.startDate : void 0
     );
     this._idempotency.delete(idempotencyKey);
     return result;
@@ -7263,12 +7720,15 @@ var Payroll = class _Payroll {
   async reversePayroll(params) {
     this.ensureInitialized();
     const result = await this.payrollStateManager.reversePayroll(params);
-    const { employeeId, period, organizationId } = result.payrollRecord;
+    const { employeeId, period, organizationId, payrollRunType = "regular", paymentFrequency = "monthly" } = result.payrollRecord;
+    const isNonMonthly = paymentFrequency !== "monthly";
     const idempotencyKey = generatePayrollIdempotencyKey(
       organizationId,
       employeeId,
       period.month,
-      period.year
+      period.year,
+      payrollRunType,
+      isNonMonthly ? period.startDate : void 0
     );
     this._idempotency.delete(idempotencyKey);
     return result;
@@ -7400,33 +7860,6 @@ var Payroll = class _Payroll {
       taxBrackets
     });
   }
-  /**
-   * Calculate attendance deduction using working days (not calendar days)
-   */
-  async calculateAttendanceDeduction(employeeId, organizationId, period, dailyRate, expectedWorkingDays, session) {
-    try {
-      if (!this.models.AttendanceModel) return 0;
-      let query = this.models.AttendanceModel.findOne({
-        organizationId,
-        targetId: employeeId,
-        targetModel: "Employee",
-        year: period.year,
-        month: period.month
-      });
-      if (session) query = query.session(session);
-      const attendance = await query;
-      if (!attendance) return 0;
-      const workedDays = attendance.totalWorkDays || 0;
-      const absentDays = Math.max(0, expectedWorkingDays - workedDays);
-      return Math.round(absentDays * dailyRate);
-    } catch (error) {
-      getLogger().warn("Failed to calculate attendance deduction", {
-        employeeId: employeeId.toString(),
-        error: error.message
-      });
-      return 0;
-    }
-  }
   async updatePayrollStats(employee2, amount, paymentDate, repos, session) {
     if (!employee2.payrollStats) {
       employee2.payrollStats = {
@@ -7438,10 +7871,27 @@ var Payroll = class _Payroll {
     employee2.payrollStats.totalPaid = (employee2.payrollStats.totalPaid || 0) + amount;
     employee2.payrollStats.lastPaymentDate = paymentDate;
     employee2.payrollStats.paymentsThisYear = (employee2.payrollStats.paymentsThisYear || 0) + 1;
-    employee2.payrollStats.averageMonthly = Math.round(
-      employee2.payrollStats.totalPaid / employee2.payrollStats.paymentsThisYear
+    employee2.payrollStats.averageMonthly = roundMoney(
+      employee2.payrollStats.totalPaid / employee2.payrollStats.paymentsThisYear,
+      2
     );
-    employee2.payrollStats.nextPaymentDate = addMonths(paymentDate, 1);
+    const frequency = employee2.compensation?.frequency || "monthly";
+    switch (frequency) {
+      case "hourly":
+      case "daily":
+        employee2.payrollStats.nextPaymentDate = addDays(paymentDate, 1);
+        break;
+      case "weekly":
+        employee2.payrollStats.nextPaymentDate = addDays(paymentDate, 7);
+        break;
+      case "bi_weekly":
+        employee2.payrollStats.nextPaymentDate = addDays(paymentDate, 14);
+        break;
+      case "monthly":
+      default:
+        employee2.payrollStats.nextPaymentDate = addMonths(paymentDate, 1);
+        break;
+    }
     await repos.employee.update(
       employee2._id,
       { payrollStats: employee2.payrollStats },
@@ -7449,6 +7899,206 @@ var Payroll = class _Payroll {
     );
   }
   // ========================================
+  // Crash Recovery Methods (v2.8.0+)
+  // ========================================
+  /**
+   * Recover stuck payroll records
+   *
+   * Finds payroll records stuck in 'processing' or 'pending' status for longer
+   * than the threshold and handles them appropriately:
+   * - Records WITHOUT transactionId: Marked as 'failed' (safe to retry)
+   * - Records WITH transactionId: Flagged for manual review (orphaned transaction)
+   *
+   * This helps recover from server crashes or partial failures.
+   *
+   * @example
+   * ```typescript
+   * const recovered = await payroll.recoverStuckPayrolls({
+   *   organizationId: org._id,
+   *   staleThresholdMinutes: 30,
+   * });
+   * console.log(`Recovered ${recovered.markedFailed} records`);
+   * if (recovered.requiresManualReview.length > 0) {
+   *   console.warn('Manual review needed:', recovered.requiresManualReview);
+   * }
+   * ```
+   */
+  async recoverStuckPayrolls(params) {
+    this.ensureInitialized();
+    const orgId = this.resolveOrganizationId(params.organizationId);
+    const threshold = params.staleThresholdMinutes ?? 30;
+    const cutoffTime = new Date(Date.now() - threshold * 60 * 1e3);
+    const dryRun = params.dryRun ?? false;
+    const stuckRecords = await this.models.PayrollRecordModel.find({
+      organizationId: orgId,
+      status: { $in: ["processing", "pending"] },
+      processedAt: { $lt: cutoffTime }
+    });
+    const result = {
+      markedFailed: 0,
+      requiresManualReview: [],
+      scanned: stuckRecords.length
+    };
+    for (const record of stuckRecords) {
+      if (record.transactionId) {
+        result.requiresManualReview.push({
+          _id: record._id,
+          status: record.status,
+          transactionId: record.transactionId
+        });
+        getLogger().warn("Stuck payroll record with transaction needs manual review", {
+          payrollRecordId: record._id.toString(),
+          status: record.status,
+          transactionId: record.transactionId.toString(),
+          processedAt: record.processedAt
+        });
+      } else {
+        if (!dryRun) {
+          await this.models.PayrollRecordModel.updateOne(
+            { _id: record._id },
+            { $set: { status: "failed" } }
+          );
+        }
+        result.markedFailed++;
+        getLogger().info("Marked stuck payroll record as failed", {
+          payrollRecordId: record._id.toString(),
+          status: record.status,
+          processedAt: record.processedAt,
+          dryRun
+        });
+      }
+    }
+    getLogger().info("Crash recovery completed", {
+      organizationId: orgId.toString(),
+      scanned: result.scanned,
+      markedFailed: result.markedFailed,
+      requiresManualReview: result.requiresManualReview.length,
+      dryRun
+    });
+    return result;
+  }
+  // ========================================
+  // Two-Phase Export Methods (v2.8.0+)
+  // ========================================
+  /**
+   * Prepare payroll data for export (Phase 1)
+   *
+   * Retrieves records but does NOT mark them as exported yet.
+   * Returns an exportId that must be used to confirm or cancel the export.
+   *
+   * @example
+   * ```typescript
+   * // Phase 1: Prepare
+   * const { records, exportId } = await payroll.prepareExport({
+   *   organizationId: org._id,
+   *   startDate: new Date('2024-01-01'),
+   *   endDate: new Date('2024-01-31'),
+   * });
+   *
+   * // Send records to external system...
+   *
+   * // Phase 2: Confirm (if successful) or Cancel (if failed)
+   * await payroll.confirmExport({ organizationId: org._id, exportId });
+   * ```
+   */
+  async prepareExport(params) {
+    this.ensureInitialized();
+    const orgId = this.resolveOrganizationId(params.organizationId);
+    const { startDate, endDate } = params;
+    const query = {
+      organizationId: toObjectId(orgId),
+      "period.payDate": { $gte: startDate, $lte: endDate }
+    };
+    const records = await this.models.PayrollRecordModel.find(query).populate("employeeId", "employeeId position department").populate("userId", "name email").populate("transactionId", "amount method status date").sort({ "period.year": -1, "period.month": -1 });
+    const exportId = `export-${orgId}-${Date.now()}-${Math.random().toString(36).substring(7)}`;
+    this._idempotency.set(`pending-export:${exportId}`, {
+      organizationId: orgId.toString(),
+      recordIds: records.map((r) => r._id.toString()),
+      createdAt: /* @__PURE__ */ new Date(),
+      startDate,
+      endDate
+    });
+    getLogger().info("Prepared payroll export", {
+      organizationId: orgId.toString(),
+      exportId,
+      recordCount: records.length,
+      dateRange: { start: startDate, end: endDate }
+    });
+    return {
+      records,
+      exportId,
+      total: records.length
+    };
+  }
+  /**
+   * Confirm export success (Phase 2a)
+   *
+   * Marks records as exported after downstream system confirms receipt.
+   */
+  async confirmExport(params) {
+    this.ensureInitialized();
+    const orgId = this.resolveOrganizationId(params.organizationId);
+    const { exportId } = params;
+    const pendingExport = this._idempotency.get(`pending-export:${exportId}`);
+    if (!pendingExport) {
+      throw new PayrollError(
+        `Export ${exportId} not found or already processed`,
+        "EXPORT_NOT_FOUND",
+        404,
+        { exportId }
+      );
+    }
+    if (pendingExport.value.organizationId !== orgId.toString()) {
+      throw new PayrollError(
+        "Organization mismatch for export confirmation",
+        "EXPORT_ORG_MISMATCH",
+        403,
+        { exportId, expectedOrg: pendingExport.value.organizationId }
+      );
+    }
+    const recordIds = pendingExport.value.recordIds.map((id) => toObjectId(id));
+    const result = await this.models.PayrollRecordModel.updateMany(
+      { _id: { $in: recordIds }, organizationId: orgId },
+      { $set: { exported: true, exportedAt: /* @__PURE__ */ new Date() } }
+    );
+    this._idempotency.delete(`pending-export:${exportId}`);
+    this._events.emitSync("payroll:exported", {
+      organizationId: orgId,
+      exportId,
+      recordCount: result.modifiedCount,
+      format: "json"
+    });
+    getLogger().info("Confirmed payroll export", {
+      organizationId: orgId.toString(),
+      exportId,
+      confirmed: result.modifiedCount
+    });
+    return { confirmed: result.modifiedCount ?? 0 };
+  }
+  /**
+   * Cancel export (Phase 2b)
+   *
+   * Called when downstream system fails to process the export.
+   * Records remain unmarked and can be exported again.
+   */
+  async cancelExport(params) {
+    this.ensureInitialized();
+    const orgId = this.resolveOrganizationId(params.organizationId);
+    const { exportId, reason } = params;
+    const pendingExport = this._idempotency.get(`pending-export:${exportId}`);
+    if (!pendingExport) {
+      getLogger().warn("Export cancellation for unknown export", { exportId });
+      return { cancelled: false };
+    }
+    this._idempotency.delete(`pending-export:${exportId}`);
+    getLogger().info("Cancelled payroll export", {
+      organizationId: orgId.toString(),
+      exportId,
+      reason
+    });
+    return { cancelled: true };
+  }
+  // ========================================
   // Static Factory
   // ========================================
   /**
@@ -7986,7 +8636,7 @@ leaveRequestSchema.statics.hasOverlap = async function(employeeId, startDate, en
   const count = await this.countDocuments(query);
   return count > 0;
 };
-function getLeaveRequestModel(connection = mongoose6.connection) {
+function getLeaveRequestModel(connection = mongoose5.connection) {
   const modelName = "LeaveRequest";
   if (connection.models[modelName]) {
     return connection.models[modelName];
@@ -8384,7 +9034,7 @@ taxWithholdingSchema.statics.removeTTLIndex = async function(fieldName) {
     throw error;
   }
 };
-function getTaxWithholdingModel(connection = mongoose6.connection) {
+function getTaxWithholdingModel(connection = mongoose5.connection) {
   const modelName = "TaxWithholding";
   if (connection.models[modelName]) {
     return connection.models[modelName];
@@ -8643,7 +9293,63 @@ function createPayrollRecordFields(options = {}) {
     reversalTransactionId: { type: Schema.Types.ObjectId },
     originalPayrollId: { type: Schema.Types.ObjectId },
     // TTL expiration (per-document)
-    expireAt: { type: Date }
+    expireAt: { type: Date },
+    // Payroll run type (v2.8.0+)
+    payrollRunType: {
+      type: String,
+      enum: ["regular", "off-cycle", "supplemental", "retroactive"],
+      default: "regular"
+    },
+    // Payment frequency at time of processing (v2.9.0+)
+    // Stored for proper idempotency key reconstruction in void/reverse operations
+    paymentFrequency: {
+      type: String,
+      enum: PAYMENT_FREQUENCY_VALUES,
+      default: "monthly"
+    },
+    // Retroactive adjustment details (v2.8.0+)
+    retroactiveAdjustment: {
+      type: new Schema(
+        {
+          originalPeriod: {
+            month: { type: Number, required: true, min: 1, max: 12 },
+            year: { type: Number, required: true }
+          },
+          originalPayrollId: { type: Schema.Types.ObjectId },
+          reason: { type: String, required: true },
+          adjustmentAmount: { type: Number, required: true },
+          approved: { type: Boolean },
+          approvedBy: { type: Schema.Types.ObjectId },
+          approvedAt: { type: Date }
+        },
+        { _id: false }
+      ),
+      required: false
+    },
+    // Employer contributions (v2.8.0+)
+    employerContributions: [
+      {
+        type: {
+          type: String,
+          enum: ["social_security", "pension", "unemployment", "health_insurance", "other"],
+          required: true
+        },
+        amount: { type: Number, required: true },
+        description: { type: String },
+        mandatory: { type: Boolean },
+        referenceNumber: { type: String }
+      }
+    ],
+    // Corrections history (v2.8.0+)
+    corrections: [
+      {
+        previousAmount: { type: Number },
+        newAmount: { type: Number },
+        reason: { type: String },
+        correctedBy: { type: Schema.Types.ObjectId, ref: userRef },
+        correctedAt: { type: Date, default: Date.now }
+      }
+    ]
   };
 }
 var employeeIndexes = [
@@ -8674,17 +9380,51 @@ var employeeIndexes = [
   { fields: { organizationId: 1, "compensation.netSalary": -1 } }
 ];
 var payrollRecordIndexes = [
-  // Composite index for common queries (not unique - app handles duplicates)
+  /**
+   * UNIQUE Compound Index (v2.9.0+) - PRIMARY duplicate protection
+   *
+   * Prevents duplicate payrolls at the database level for the same:
+   * - Organization, Employee, Period (month + year + startDate), Payroll run type
+   *
+   * The period.startDate is critical for non-monthly frequencies (weekly, bi_weekly,
+   * daily, hourly) where multiple payroll runs can occur within the same calendar month.
+   *
+   * Partial filter excludes voided records to allow re-processing.
+   * Duplicate inserts fail with E11000 → converted to DuplicatePayrollError.
+   */
+  {
+    fields: {
+      organizationId: 1,
+      employeeId: 1,
+      "period.month": 1,
+      "period.year": 1,
+      "period.startDate": 1,
+      payrollRunType: 1
+    },
+    options: {
+      unique: true,
+      name: "unique_payroll_per_period_startdate_runtype",
+      // Only enforce for non-voided records (uses $eq which is supported in partial indexes)
+      // When a record is voided, isVoided is set to true, excluding it from unique constraint
+      partialFilterExpression: {
+        isVoided: { $eq: false }
+      }
+    }
+  },
+  // Composite index for common queries
   { fields: { organizationId: 1, employeeId: 1, "period.month": 1, "period.year": 1 } },
   { fields: { organizationId: 1, "period.year": 1, "period.month": 1 } },
   { fields: { employeeId: 1, "period.year": -1, "period.month": -1 } },
   { fields: { status: 1, createdAt: -1 } },
   { fields: { organizationId: 1, status: 1, "period.payDate": 1 } },
+  // Index for payroll run type queries (supplemental, retroactive, etc.)
+  { fields: { organizationId: 1, payrollRunType: 1, "period.year": 1, "period.month": 1 } },
+  // TTL index using expireAt field for per-document retention (jurisdiction-specific)
   {
-    fields: { createdAt: 1 },
+    fields: { expireAt: 1 },
     options: {
-      expireAfterSeconds: HRM_CONFIG.dataRetention.payrollRecordsTTL
-      // TTL applies to ALL records (user handles backups/exports at app level)
+      expireAfterSeconds: 0
+      // Delete immediately when expireAt is reached
     }
   }
 ];
@@ -9165,6 +9905,7 @@ init_utils();
 init_prorating_calculator();
 
 // src/shift-compliance/calculators/late-penalty.ts
+init_money();
 function calculateFlatPenalty(occurrenceCount, flatAmount) {
   return {
     amount: occurrenceCount * flatAmount,
@@ -9173,12 +9914,12 @@ function calculateFlatPenalty(occurrenceCount, flatAmount) {
 }
 function calculatePerMinutePenalty(totalMinutesLate, perMinuteRate) {
   return {
-    amount: Math.round(totalMinutesLate * perMinuteRate),
+    amount: roundMoney(totalMinutesLate * perMinuteRate, 2),
     minutes: totalMinutesLate
   };
 }
 function calculatePercentagePenalty(occurrenceCount, percentageRate, dailyWage) {
-  const penaltyPerOccurrence = Math.round(dailyWage * percentageRate / 100);
+  const penaltyPerOccurrence = roundMoney(dailyWage * percentageRate / 100, 2);
   return {
     amount: occurrenceCount * penaltyPerOccurrence,
     percentage: percentageRate
@@ -9293,26 +10034,27 @@ function calculateLatePenalty(input) {
     return {
       date: occ.date,
       minutesLate: occ.minutesLate,
-      penaltyAmount: Math.round(penaltyPerOccurrence),
+      penaltyAmount: roundMoney(penaltyPerOccurrence, 2),
       tier: tierInfo?.tier,
       waived: false
     };
   });
   return {
-    amount: Math.round(totalPenalty),
+    amount: roundMoney(totalPenalty, 2),
     occurrences: penalizableCount,
     breakdown
   };
 }
 
 // src/shift-compliance/calculators/overtime.ts
+init_money();
 function calculateDailyOvertime(hoursWorked, threshold, multiplier, hourlyRate) {
   const overtimeHours = Math.max(0, hoursWorked - threshold);
   if (overtimeHours === 0) {
     return { amount: 0, overtimeHours: 0 };
   }
   const extraMultiplier = multiplier - 1;
-  const bonus = Math.round(overtimeHours * hourlyRate * extraMultiplier);
+  const bonus = roundMoney(overtimeHours * hourlyRate * extraMultiplier, 2);
   return { amount: bonus, overtimeHours };
 }
 function calculateWeeklyOvertime(hoursWorked, threshold, multiplier, hourlyRate) {
@@ -9323,12 +10065,12 @@ function calculateMonthlyOvertime(hoursWorked, threshold, multiplier, hourlyRate
 }
 function calculateWeekendPremium(hours, multiplier, hourlyRate, day) {
   const extraMultiplier = multiplier - 1;
-  const bonus = Math.round(hours * hourlyRate * extraMultiplier);
+  const bonus = roundMoney(hours * hourlyRate * extraMultiplier, 2);
   return { amount: bonus, hours, day };
 }
 function calculateNightShiftDifferential(hours, multiplier, hourlyRate) {
   const extraMultiplier = multiplier - 1;
-  const bonus = Math.round(hours * hourlyRate * extraMultiplier);
+  const bonus = roundMoney(hours * hourlyRate * extraMultiplier, 2);
   return { amount: bonus, hours };
 }
 function calculateOvertimeBonus(input) {
@@ -9357,14 +10099,14 @@ function calculateOvertimeBonus(input) {
         case "daily":
         case "weekly":
         case "monthly":
-          bonus = Math.round(occ.hours * hourlyRate * extraMultiplier);
+          bonus = roundMoney(occ.hours * hourlyRate * extraMultiplier, 2);
           break;
         case "weekend-saturday":
         case "weekend-sunday":
-          bonus = Math.round(occ.hours * hourlyRate * extraMultiplier);
+          bonus = roundMoney(occ.hours * hourlyRate * extraMultiplier, 2);
           break;
         case "night-shift":
-          bonus = Math.round(occ.hours * hourlyRate * extraMultiplier);
+          bonus = roundMoney(occ.hours * hourlyRate * extraMultiplier, 2);
           break;
       }
       totalBonus += bonus;
@@ -9422,7 +10164,7 @@ function calculateOvertimeBonus(input) {
     }
   }
   return {
-    amount: Math.round(totalBonus),
+    amount: roundMoney(totalBonus, 2),
     hours: totalHours,
     breakdown
   };
@@ -9997,7 +10739,7 @@ var TieredPenaltyBuilder = class {
       this.saveTier();
     }
     if (this.parent instanceof LatePolicyBuilder) {
-      this.parent.policy.tiers = this.tiers;
+      this.parent._getPolicy().tiers = this.tiers;
     }
     return this.parent;
   }
@@ -10642,7 +11384,71 @@ init_enums();
 init_utils();
 init_utils();
 init_utils();
+init_type_guards();
+init_error_helpers();
+
+// src/core/mongokit-plugins/payroll-audit.plugin.ts
+function payrollAuditPlugin(context) {
+  return (repo) => {
+    repo.on("before:create", async (ctx) => {
+      if (context.userId) {
+        ctx.data.createdBy = context.userId;
+      }
+      ctx.data.createdAt = /* @__PURE__ */ new Date();
+      if (context.organizationId && !ctx.data.organizationId) {
+        ctx.data.organizationId = context.organizationId;
+      }
+    });
+    repo.on("before:update", async (ctx) => {
+      if (!ctx.data.$set) {
+        ctx.data.$set = {};
+      }
+      if (context.userId) {
+        ctx.data.$set.updatedBy = context.userId;
+      }
+      ctx.data.$set.updatedAt = /* @__PURE__ */ new Date();
+    });
+  };
+}
+function readAuditPlugin(context, logger2) {
+  return (repo) => {
+    repo.on("after:read", async (ctx) => {
+      const event = {
+        operation: "read",
+        model: repo.model,
+        userId: context.userId,
+        organizationId: context.organizationId,
+        timestamp: /* @__PURE__ */ new Date(),
+        query: ctx.query
+      };
+      if (logger2) {
+        logger2(event);
+      }
+    });
+  };
+}
+function fullAuditPlugin(context, onEvent) {
+  return (repo) => {
+    payrollAuditPlugin(context)(repo);
+    ["after:read", "after:create", "after:update", "after:delete"].forEach(
+      (hookName) => {
+        repo.on(hookName, async (ctx) => {
+          const operation = hookName.split(":")[1];
+          const event = {
+            operation,
+            model: repo.model,
+            userId: context.userId,
+            organizationId: context.organizationId,
+            timestamp: /* @__PURE__ */ new Date(),
+            query: ctx.query || ctx.data
+          };
+          await onEvent(event);
+        });
+      }
+    );
+  };
+}
 
-export { ALLOWANCE_TYPE, AlreadyProcessedError, AttendancePolicyBuilder, AttendancePolicySchema, AttendancePolicySchemaDefinition, ClockRoundingPolicyBuilder, ClockRoundingPolicySchema, ClockRoundingPolicySchemaDefinition, DEDUCTION_TYPE, DEFAULT_ATTENDANCE_POLICY, DEFAULT_CARRY_OVER, DEFAULT_LEAVE_ALLOCATIONS, DEPARTMENT, DuplicatePayrollError, EMPLOYEE_STATUS, EMPLOYEE_TIMELINE_CONFIG, EMPLOYMENT_TYPE, EarlyDeparturePolicySchema, EarlyDeparturePolicySchemaDefinition, EmployeeBuilder, EmployeeFactory, EmployeeNotFoundError, EmployeeStatusMachine, EmployeeTerminatedError, HEALTHCARE_POLICY, HOSPITALITY_POLICY, HRM_CONFIG, IdempotencyManager, InvalidEmployeeError, LEAVE_REQUEST_STATUS, LEAVE_REQUEST_TIMELINE_CONFIG, LEAVE_TYPE, LateArrivalPolicySchema, LateArrivalPolicySchemaDefinition, LatePolicyBuilder, LeaveRequestStatusMachine, MANUFACTURING_POLICY, MaxPenaltiesSchema, MaxPenaltiesSchemaDefinition, NightShiftDifferentialSchema, NightShiftDifferentialSchemaDefinition, NotEligibleError, NotInitializedError, OFFICE_POLICY, OvertimePolicyBuilder, OvertimePolicySchema, OvertimePolicySchemaDefinition, PAYMENT_FREQUENCY, PAYROLL_EVENTS, PAYROLL_RECORD_TIMELINE_CONFIG, PAYROLL_STATUS, Payroll, PayrollBuilder, PayrollError, PayrollStatusMachine, PenaltyTierSchema, PenaltyTierSchemaDefinition, RETAIL_POLICY, SecurityError, StateMachine, TAX_STATUS, TAX_STATUS_VALUES, TAX_TYPE, TAX_TYPE_VALUES, TERMINATION_REASON, TaxStatusMachine, TieredPenaltyBuilder, TransactionFactory, ValidationError, WebhookManager, WeekendPremiumSchema, WeekendPremiumSchemaDefinition, accrueLeaveToBalance, allowanceSchema, applyEmployeeIndexes, applyLeaveRequestIndexes, applyPayrollRecordIndexes, applyProRating, applyTaxWithholdingIndexes, bankDetailsSchema, batchGetAttendance, buildRequestContext, buildTimelineMetadata, calculateAttendanceDeduction, calculateCarryOver, calculateDailyOvertime, calculateDailyRate, calculateFlatPenalty, calculateHourlyRate, calculateLatePenalty, calculateLeaveDays, calculateMonthlyOvertime, calculateNightShiftDifferential, calculateOvertimeBonus, calculatePartialDayDeduction, calculatePerMinutePenalty, calculatePercentagePenalty, calculateProRating, calculateSalaryBreakdown, calculateShiftCompliance, calculateTieredPenalty, calculateTotalAttendanceDeduction, calculateUnpaidLeaveDeduction, calculateWeekendPremium, calculateWeeklyOvertime, compensationSchema, createClockRoundingPolicyBuilder, createEmployee, createEmployeeSchema, createEmploymentFields, createError, createHolidaySchema, createLatePolicyBuilder, createOvertimePolicyBuilder, createPayrollInstance, createPayrollRecordFields, createPayrollRecordSchema, createPayrollTransaction, createPolicyFromPreset, createStateMachine, createTaxPaymentTransaction, deductionSchema, detectEmployeeIdType, determineOrgRole, employeeExistsSecure, employeePlugin, employmentHistorySchema, extractErrorInfo, findEmployeeSecure, findEmployeesSecure, formatEmployeeId, generatePayrollIdempotencyKey, getAttendance, getAvailableDays, getHolidays, getLeaveBalance, getLeaveBalances, getLeaveRequestFields, getLeaveRequestModel, getLeaveSummary, getTaxWithholdingFields, getTaxWithholdingModel, getUnpaidLeaveDays, hasLeaveBalance, initializeLeaveBalances, isApprovedLeaveStatus, isCancelledTaxStatus, isObjectIdEmployeeId, isPaidLeaveType, isPaidTaxStatus, isPayrollError, isPayrollTransaction, isPendingLeaveStatus, isPendingTaxStatus, isStringEmployeeId, isValidLeaveRequestStatus, isValidLeaveType, isValidTaxStatus, isValidTaxType, isVoidablePayrollStatus, isVoidedOrReversedStatus, leaveBalanceFields, leaveBalanceSchema, leaveRequestIndexes, leaveRequestSchema, mergeConfig, multiTenantPlugin, normalizeEmployeeId, payrollStatsSchema, proRateAllocation, requireOrganizationId, requiresReversalPayrollStatus, resolveOrganizationId, shouldProRate, taxWithholdingIndexes, taxWithholdingSchema, toPayrollError, tryResolveOrganizationId, validateOrganizationId, workScheduleSchema };
+export { ALLOWANCE_TYPE, AlreadyProcessedError, AttendancePolicyBuilder, AttendancePolicySchema, AttendancePolicySchemaDefinition, ClockRoundingPolicyBuilder, ClockRoundingPolicySchema, ClockRoundingPolicySchemaDefinition, DEDUCTION_TYPE, DEFAULT_ATTENDANCE_POLICY, DEFAULT_CARRY_OVER, DEFAULT_LEAVE_ALLOCATIONS, DEPARTMENT, DuplicatePayrollError, EMPLOYEE_STATUS, EMPLOYEE_TIMELINE_CONFIG, EMPLOYMENT_TYPE, EarlyDeparturePolicySchema, EarlyDeparturePolicySchemaDefinition, EmployeeBuilder, EmployeeFactory, EmployeeNotFoundError, EmployeeStatusMachine, EmployeeTerminatedError, HEALTHCARE_POLICY, HOSPITALITY_POLICY, HRM_CONFIG, IdempotencyManager, InvalidEmployeeError, LEAVE_REQUEST_STATUS, LEAVE_REQUEST_TIMELINE_CONFIG, LEAVE_TYPE, LateArrivalPolicySchema, LateArrivalPolicySchemaDefinition, LatePolicyBuilder, LeaveRequestStatusMachine, MANUFACTURING_POLICY, MaxPenaltiesSchema, MaxPenaltiesSchemaDefinition, NightShiftDifferentialSchema, NightShiftDifferentialSchemaDefinition, NotEligibleError, NotInitializedError, OFFICE_POLICY, OvertimePolicyBuilder, OvertimePolicySchema, OvertimePolicySchemaDefinition, PAYMENT_FREQUENCY, PAYROLL_EVENTS, PAYROLL_RECORD_TIMELINE_CONFIG, PAYROLL_STATUS, Payroll, PayrollBuilder, PayrollError, PayrollStatusMachine, PenaltyTierSchema, PenaltyTierSchemaDefinition, RETAIL_POLICY, SecurityError, StateMachine, TAX_STATUS, TAX_STATUS_VALUES, TAX_TYPE, TAX_TYPE_VALUES, TERMINATION_REASON, TaxStatusMachine, TieredPenaltyBuilder, TransactionFactory, ValidationError, WebhookManager, WeekendPremiumSchema, WeekendPremiumSchemaDefinition, accrueLeaveToBalance, allowanceSchema, applyEmployeeIndexes, applyLeaveRequestIndexes, applyPayrollRecordIndexes, applyProRating, applyTaxWithholdingIndexes, bankDetailsSchema, batchGetAttendance, buildRequestContext, buildTimelineMetadata, calculateAttendanceDeduction, calculateCarryOver, calculateDailyOvertime, calculateDailyRate, calculateFlatPenalty, calculateHourlyRate, calculateLatePenalty, calculateLeaveDays, calculateMonthlyOvertime, calculateNightShiftDifferential, calculateOvertimeBonus, calculatePartialDayDeduction, calculatePerMinutePenalty, calculatePercentagePenalty, calculateProRating, calculateSalaryBreakdown, calculateShiftCompliance, calculateTieredPenalty, calculateTotalAttendanceDeduction, calculateUnpaidLeaveDeduction, calculateWeekendPremium, calculateWeeklyOvertime, compensationSchema, createClockRoundingPolicyBuilder, createEmployee, createEmployeeSchema, createEmploymentFields, createError, createHolidaySchema, createLatePolicyBuilder, createOvertimePolicyBuilder, createPayrollInstance, createPayrollRecordFields, createPayrollRecordSchema, createPayrollTransaction, createPolicyFromPreset, createStateMachine, createTaxPaymentTransaction, deductionSchema, definePlugin, detectEmployeeIdType, determineOrgRole, employeeExistsSecure, employeeIndexes, employeePlugin, employmentHistorySchema, extractErrorInfo, findEmployeeSecure, findEmployeesSecure, formatEmployeeId, formatUserError, fullAuditPlugin, generatePayrollIdempotencyKey, getAttendance, getAvailableDays, getEmployeeEmail, getEmployeeName, getErrorMessage, getHolidays, getLeaveBalance, getLeaveBalances, getLeaveRequestFields, getLeaveRequestModel, getLeaveSummary, getTaxWithholdingFields, getTaxWithholdingModel, getUnpaidLeaveDays, handleDuplicateKeyError, handlePayrollError, handleTransactionError, hasLeaveBalance, hasUserId, initializeLeaveBalances, isApprovedLeaveStatus, isCancelledTaxStatus, isConnectionError, isDuplicateKeyError, isError, isGuestEmployee, isMongoError, isObjectIdEmployeeId, isPaidLeaveType, isPaidTaxStatus, isPayrollError, isPayrollTransaction, isPendingLeaveStatus, isPendingTaxStatus, isStringEmployeeId, isTransactionError, isTransactionUnsupportedError, isValidLeaveRequestStatus, isValidLeaveType, isValidTaxStatus, isValidTaxType, isValidationError, isVoidablePayrollStatus, isVoidedOrReversedStatus, leaveBalanceFields, leaveBalanceSchema, leaveRequestIndexes, leaveRequestSchema, mergeConfig, multiTenantPlugin, normalizeEmployeeId, parseDuplicateKeyError, payrollAuditPlugin, payrollRecordIndexes, payrollStatsSchema, proRateAllocation, readAuditPlugin, requireOrganizationId, requiresReversalPayrollStatus, resolveOrganizationId, shouldProRate, taxWithholdingIndexes, taxWithholdingSchema, toPayrollError, tryResolveOrganizationId, validateOrganizationId, workScheduleSchema };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map