joopjs 2.0.0

package/dist/banking/index.mjs

@@ -0,0 +1,4661 @@
+// src/banking/masking.utility.ts
+function maskCard(cardNumber, showLast = 4) {
+  const digits = cardNumber.replace(/\D/g, "");
+  if (digits.length < showLast) return cardNumber;
+  const masked = "*".repeat(digits.length - showLast) + digits.slice(-showLast);
+  return masked.replace(/(.{4})/g, "$1 ").trim();
+}
+function formatCard(cardNumber) {
+  return cardNumber.replace(/\D/g, "").replace(/(.{4})/g, "$1 ").trim();
+}
+function maskIban(iban, showChars = 8) {
+  const clean = iban.replace(/\s/g, "");
+  if (clean.length <= showChars) return iban;
+  return clean.slice(0, 4) + "*".repeat(clean.length - showChars) + clean.slice(-4);
+}
+function maskAccountNumber(account, showLast = 4) {
+  const clean = account.replace(/\D/g, "");
+  if (clean.length <= showLast) return clean;
+  return "*".repeat(clean.length - showLast) + clean.slice(-showLast);
+}
+function maskEmail(email) {
+  const [user, domain] = email.split("@");
+  if (!domain || user.length < 3) return "***@" + (domain ?? "");
+  return user[0] + "*".repeat(user.length - 2) + user[user.length - 1] + "@" + domain;
+}
+function maskPhone(phone, showLast = 4) {
+  const digits = phone.replace(/\D/g, "");
+  if (digits.length <= showLast) return phone;
+  return "*".repeat(digits.length - showLast) + digits.slice(-showLast);
+}
+function maskName(name) {
+  const parts = name.trim().split(/\s+/);
+  return parts.map((p, i) => i === 0 ? p : p[0] + "*".repeat(p.length - 1)).join(" ");
+}
+var NRIC_SG_REGEX = /^[STFGM]\d{7}[A-Z]$/i;
+var NRIC_WEIGHTS = [2, 7, 6, 5, 4, 3, 2];
+var NRIC_SG_ST = ["J", "Z", "I", "H", "G", "F", "E", "D", "C", "B", "A"];
+var NRIC_SG_FG = ["X", "W", "U", "T", "R", "Q", "P", "N", "M", "L", "K"];
+var NRIC_SG_M = ["K", "L", "J", "N", "P", "Q", "R", "T", "U", "W", "X"];
+function validateNric(nric) {
+  const clean = nric.trim().toUpperCase();
+  if (!NRIC_SG_REGEX.test(clean)) return false;
+  const prefix = clean[0];
+  const digits = clean.slice(1, 8).split("").map(Number);
+  const suffix = clean[8];
+  const sum = digits.reduce((acc, d, i) => acc + d * NRIC_WEIGHTS[i], 0);
+  const mod = (sum + (prefix === "G" || prefix === "T" ? 4 : prefix === "M" ? 3 : 0)) % 11;
+  let table;
+  if (prefix === "S" || prefix === "T") table = NRIC_SG_ST;
+  else if (prefix === "F" || prefix === "G") table = NRIC_SG_FG;
+  else table = NRIC_SG_M;
+  return table[mod] === suffix;
+}
+function maskNric(nric) {
+  const clean = nric.trim().toUpperCase();
+  if (clean.length < 5) return nric;
+  return clean[0] + "*".repeat(clean.length - 4) + clean.slice(-3);
+}
+var MYKAD_REGEX = /^\d{12}$|^\d{6}-\d{2}-\d{4}$/;
+function validateMyKad(ic) {
+  return MYKAD_REGEX.test(ic.replace(/\s/g, ""));
+}
+function maskMyKad(ic) {
+  const clean = ic.replace(/[-\s]/g, "");
+  if (clean.length !== 12) return ic;
+  return clean.slice(0, 2) + "****" + clean.slice(6, 8) + "****";
+}
+function formatMyKad(ic) {
+  const clean = ic.replace(/\D/g, "");
+  if (clean.length !== 12) return ic;
+  return `${clean.slice(0, 6)}-${clean.slice(6, 8)}-${clean.slice(8)}`;
+}
+
+// src/banking/custom-mask.utility.ts
+function maskRange(value, firstVisible, lastVisible, maskChar = "*") {
+  const len = value.length;
+  const first = Math.max(0, Math.min(firstVisible, len));
+  const last = Math.max(0, Math.min(lastVisible, len - first));
+  const midLen = Math.max(0, len - first - last);
+  return value.slice(0, first) + maskChar.repeat(midLen) + value.slice(len - last || len);
+}
+function maskShowLast(value, n, maskChar = "*") {
+  return maskRange(value, 0, n, maskChar);
+}
+function maskShowFirst(value, n, maskChar = "*") {
+  return maskRange(value, n, 0, maskChar);
+}
+function maskPattern(value, pattern, maskChar = "*") {
+  let result = "";
+  let vi = 0;
+  for (let i = 0; i < pattern.length; i++) {
+    const pc = pattern[i];
+    if (pc === "#") {
+      result += vi < value.length ? value[vi++] : "";
+    } else if (pc === "*" || pc === "X" || pc === "x") {
+      result += vi < value.length ? maskChar : "";
+      vi++;
+    } else {
+      result += pc;
+    }
+  }
+  return result;
+}
+function maskKeepMiddle(value, visibleCount, maskChar = "*") {
+  const len = value.length;
+  const start = Math.max(0, Math.floor((len - visibleCount) / 2));
+  const end = start + visibleCount;
+  return maskChar.repeat(start) + value.slice(start, end) + maskChar.repeat(Math.max(0, len - end));
+}
+function maskInterleaved(value, maskChar = "*") {
+  return value.split("").map((c, i) => i % 2 === 0 ? c : maskChar).join("");
+}
+function maskKeepSeparators(value, lastVisible, separators = " -", maskChar = "*") {
+  const stripped = value.split("").filter((c) => !separators.includes(c)).join("");
+  const maskedStripped = maskShowLast(stripped, lastVisible, maskChar);
+  let mi = 0;
+  return value.split("").map((c) => separators.includes(c) ? c : maskedStripped[mi++] ?? "").join("");
+}
+
+// src/banking/iban.utility.ts
+var IBAN_LENGTHS = {
+  AL: 28,
+  AD: 24,
+  AE: 23,
+  AT: 20,
+  AZ: 28,
+  BA: 20,
+  BE: 16,
+  BG: 22,
+  BH: 22,
+  BR: 29,
+  BY: 28,
+  CH: 21,
+  CR: 22,
+  CY: 28,
+  CZ: 24,
+  DE: 22,
+  DK: 18,
+  DO: 28,
+  EE: 20,
+  EG: 29,
+  ES: 24,
+  FI: 18,
+  FO: 18,
+  FR: 27,
+  GB: 22,
+  GE: 22,
+  GI: 23,
+  GL: 18,
+  GR: 27,
+  GT: 28,
+  HR: 21,
+  HU: 28,
+  IE: 22,
+  IL: 23,
+  IQ: 23,
+  IS: 26,
+  IT: 27,
+  JO: 30,
+  KW: 30,
+  KZ: 20,
+  LB: 28,
+  LC: 32,
+  LI: 21,
+  LT: 20,
+  LU: 20,
+  LV: 21,
+  LY: 25,
+  MC: 27,
+  MD: 24,
+  ME: 22,
+  MK: 19,
+  MR: 27,
+  MT: 31,
+  MU: 30,
+  NL: 18,
+  NO: 15,
+  PK: 24,
+  PL: 28,
+  PS: 29,
+  PT: 25,
+  QA: 29,
+  RO: 24,
+  RS: 22,
+  SA: 24,
+  SC: 31,
+  SD: 18,
+  SE: 24,
+  SI: 19,
+  SK: 24,
+  SM: 27,
+  ST: 25,
+  SV: 28,
+  TL: 23,
+  TN: 24,
+  TR: 26,
+  UA: 29,
+  VA: 22,
+  VG: 24,
+  XK: 20
+};
+function validateIban(iban) {
+  const clean = iban.replace(/\s/g, "").toUpperCase();
+  const country = clean.slice(0, 2);
+  if (!IBAN_LENGTHS[country] || clean.length !== IBAN_LENGTHS[country]) return false;
+  const numeric = (clean.slice(4) + clean.slice(0, 4)).split("").map((c) => c.charCodeAt(0) >= 65 ? (c.charCodeAt(0) - 55).toString() : c).join("");
+  let remainder = 0;
+  for (const ch of numeric) remainder = (remainder * 10 + parseInt(ch)) % 97;
+  return remainder === 1;
+}
+function formatIban(iban) {
+  return iban.replace(/\s/g, "").toUpperCase().replace(/(.{4})/g, "$1 ").trim();
+}
+function getIbanCountry(iban) {
+  return iban.replace(/\s/g, "").toUpperCase().slice(0, 2);
+}
+function parseIban(iban) {
+  const clean = iban.replace(/\s/g, "").toUpperCase();
+  if (!validateIban(clean)) return null;
+  return { country: clean.slice(0, 2), checkDigits: clean.slice(2, 4), bban: clean.slice(4) };
+}
+function getSupportedIbanCountries() {
+  return Object.keys(IBAN_LENGTHS).sort();
+}
+
+// src/banking/currency.utility.ts
+function formatCurrency(amount, options) {
+  const num = typeof amount === "string" ? parseFloat(amount.replace(/[,\s]/g, "")) : amount;
+  if (!isFinite(num)) return "\u2014";
+  return new Intl.NumberFormat(options.locale ?? "en-US", {
+    style: options.showSymbol === false ? "decimal" : "currency",
+    currency: options.showSymbol === false ? void 0 : options.currency,
+    minimumFractionDigits: options.minimumFractionDigits ?? 2,
+    maximumFractionDigits: options.maximumFractionDigits ?? 2
+  }).format(num);
+}
+function parseCurrencyString(value) {
+  const cleaned = value.replace(/[^0-9.\-]/g, "");
+  const num = parseFloat(cleaned);
+  return isNaN(num) ? 0 : num;
+}
+function convertCurrency(amount, rate, decimals = 2) {
+  return parseFloat((amount * rate).toFixed(decimals));
+}
+function getCurrencySymbol(currency, locale = "en-US") {
+  const formatted = new Intl.NumberFormat(locale, { style: "currency", currency }).format(0);
+  return formatted.replace(/[\d\s.,]/g, "").trim();
+}
+function formatAmount(amount, decimals = 2, locale = "en-US") {
+  return new Intl.NumberFormat(locale, {
+    minimumFractionDigits: decimals,
+    maximumFractionDigits: decimals
+  }).format(amount);
+}
+
+// src/banking/amount.utility.ts
+function safeAdd(a, b, decimals = 2) {
+  const f = Math.pow(10, decimals);
+  return (Math.round(a * f) + Math.round(b * f)) / f;
+}
+function safeSubtract(a, b, decimals = 2) {
+  const f = Math.pow(10, decimals);
+  return (Math.round(a * f) - Math.round(b * f)) / f;
+}
+function safeMultiply(a, b, decimals = 2) {
+  return parseFloat((a * b).toFixed(decimals));
+}
+function safeDivide(a, b, decimals = 2) {
+  if (b === 0) throw new Error("Division by zero");
+  return parseFloat((a / b).toFixed(decimals));
+}
+function roundAmount(amount, decimals = 2) {
+  const f = Math.pow(10, decimals);
+  return Math.round(amount * f) / f;
+}
+function isValidAmount(value) {
+  if (typeof value === "string") {
+    const clean = value.replace(/[,\s]/g, "");
+    return /^-?\d+(\.\d+)?$/.test(clean) && isFinite(parseFloat(clean));
+  }
+  return typeof value === "number" && isFinite(value);
+}
+function clampAmount(amount, min, max) {
+  return Math.min(Math.max(amount, min), max);
+}
+function toMinorUnits(amount, decimalPlaces = 2) {
+  return Math.round(amount * Math.pow(10, decimalPlaces));
+}
+function fromMinorUnits(amount, decimalPlaces = 2) {
+  return amount / Math.pow(10, decimalPlaces);
+}
+function sumAmounts(...amounts) {
+  const f = 100;
+  return amounts.reduce((acc, a) => acc + Math.round(a * f), 0) / f;
+}
+
+// src/banking/transaction.utility.ts
+function generateTransactionId(prefix = "TXN") {
+  const timestamp = Date.now();
+  const randomBytes = new Uint8Array(8);
+  crypto.getRandomValues(randomBytes);
+  const randomHex = Array.from(randomBytes).map((b) => b.toString(16).padStart(2, "0")).join("").toUpperCase();
+  return { id: randomHex, timestamp, prefix, full: `${prefix}-${timestamp}-${randomHex}` };
+}
+function generateReferenceNumber(length = 12) {
+  const chars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+  const arr = new Uint8Array(length);
+  crypto.getRandomValues(arr);
+  return Array.from(arr).map((b) => chars[b % chars.length]).join("");
+}
+function parseTransactionId(id) {
+  const parts = id.split("-");
+  if (parts.length < 3) return null;
+  const timestamp = parseInt(parts[1]);
+  if (isNaN(timestamp)) return null;
+  return { prefix: parts[0], timestamp, random: parts.slice(2).join("-") };
+}
+function isValidTransactionId(id) {
+  return parseTransactionId(id) !== null;
+}
+function generateBatchId() {
+  const arr = new Uint8Array(12);
+  crypto.getRandomValues(arr);
+  return "BATCH-" + Array.from(arr).map((b) => b.toString(16).padStart(2, "0")).join("").toUpperCase();
+}
+
+// src/banking/receipt.service.ts
+var JoopReceiptService = class {
+  build(data) {
+    return data;
+  }
+  toText(data) {
+    const div = "\u2500".repeat(40);
+    return [
+      div,
+      data.title.toUpperCase().padStart(Math.ceil((40 + data.title.length) / 2)),
+      div,
+      `Ref : ${data.referenceNumber}`,
+      `Date: ${data.timestamp}`,
+      div,
+      ...data.lines.map((l) => l.label.padEnd(22) + l.value),
+      div,
+      ...data.footer ? [data.footer] : []
+    ].join("\n");
+  }
+  toJson(data) {
+    return JSON.stringify(data, null, 2);
+  }
+  toHtml(data) {
+    const rows = data.lines.map(
+      (l) => `<tr><td>${l.label}</td><td${l.bold ? ' style="font-weight:bold"' : ""}>${l.value}</td></tr>`
+    ).join("");
+    return `<div class="joop-receipt">
+  <h2>${data.title}</h2>
+  <p>Ref: ${data.referenceNumber} &nbsp;|&nbsp; ${data.timestamp}</p>
+  <table>${rows}</table>${data.footer ? `
+  <p class="footer">${data.footer}</p>` : ""}
+</div>`;
+  }
+};
+
+// src/banking/luhn.utility.ts
+var CARD_PATTERNS = [
+  { network: "amex", pattern: /^3[47]/, lengths: [15], cvvLength: 4 },
+  { network: "diners", pattern: /^3(?:0[0-5]|[68])/, lengths: [14], cvvLength: 3 },
+  { network: "discover", pattern: /^6(?:011|5[0-9]{2})/, lengths: [16], cvvLength: 3 },
+  { network: "jcb", pattern: /^(?:2131|1800|35)/, lengths: [16], cvvLength: 3 },
+  { network: "maestro", pattern: /^(?:5018|5020|5038|6304|6759|676[1-3])/, lengths: [12, 13, 14, 15, 16, 17, 18, 19], cvvLength: 3 },
+  { network: "mastercard", pattern: /^5[1-5]|^2[2-7]/, lengths: [16], cvvLength: 3 },
+  { network: "unionpay", pattern: /^62/, lengths: [16, 17, 18, 19], cvvLength: 3 },
+  { network: "visa", pattern: /^4/, lengths: [13, 16, 19], cvvLength: 3 }
+];
+function validateLuhn(cardNumber) {
+  const digits = cardNumber.replace(/\D/g, "");
+  if (digits.length < 8) return false;
+  let sum = 0;
+  let double = false;
+  for (let i = digits.length - 1; i >= 0; i--) {
+    let d = parseInt(digits[i], 10);
+    if (double) {
+      d *= 2;
+      if (d > 9) d -= 9;
+    }
+    sum += d;
+    double = !double;
+  }
+  return sum % 10 === 0;
+}
+function luhnCheckDigit(partial) {
+  const digits = partial.replace(/\D/g, "");
+  let sum = 0;
+  let double = true;
+  for (let i = digits.length - 1; i >= 0; i--) {
+    let d = parseInt(digits[i], 10);
+    if (double) {
+      d *= 2;
+      if (d > 9) d -= 9;
+    }
+    sum += d;
+    double = !double;
+  }
+  return (10 - sum % 10) % 10;
+}
+function getCardNetwork(cardNumber) {
+  const digits = cardNumber.replace(/\D/g, "");
+  for (const card of CARD_PATTERNS) {
+    if (card.pattern.test(digits)) return card.network;
+  }
+  return "unknown";
+}
+function getCardInfo(cardNumber) {
+  const digits = cardNumber.replace(/\D/g, "");
+  const match = CARD_PATTERNS.find((c) => c.pattern.test(digits));
+  const network = match?.network ?? "unknown";
+  const lengths = match?.lengths ?? [13, 14, 15, 16, 19];
+  const cvvLength = match?.cvvLength ?? 3;
+  const valid = lengths.includes(digits.length) && validateLuhn(digits);
+  const formatted = formatCardNumber(digits);
+  return { network, valid, lengths, cvvLength, formatted };
+}
+function formatCardNumber(cardNumber) {
+  const digits = cardNumber.replace(/\D/g, "");
+  const network = getCardNetwork(digits);
+  if (network === "amex") {
+    return digits.replace(/^(\d{4})(\d{6})(\d{5})$/, "$1 $2 $3");
+  }
+  if (network === "diners") {
+    return digits.replace(/^(\d{4})(\d{6})(\d{4})$/, "$1 $2 $3");
+  }
+  return digits.replace(/(\d{4})(?=\d)/g, "$1 ");
+}
+function isCardExpired(month, year) {
+  const m = parseInt(String(month), 10);
+  let y = parseInt(String(year), 10);
+  if (y < 100) y += 2e3;
+  const now = /* @__PURE__ */ new Date();
+  const expiry = new Date(y, m - 1, 1);
+  expiry.setMonth(expiry.getMonth() + 1);
+  return expiry <= now;
+}
+function validateCvv(cvv, network = "unknown") {
+  const digits = cvv.replace(/\D/g, "");
+  const expectedLength = network === "amex" ? 4 : 3;
+  return digits.length === expectedLength;
+}
+
+// src/events/index.ts
+var JoopSubject = class {
+  _listeners = [];
+  subscribe(listener) {
+    this._listeners.push(listener);
+    return () => {
+      this._listeners = this._listeners.filter((l) => l !== listener);
+    };
+  }
+  next(value) {
+    for (const listener of this._listeners) {
+      listener(value);
+    }
+  }
+  asObservable() {
+    return new JoopObservable((listener) => this.subscribe(listener));
+  }
+};
+var JoopBehaviorSubject = class extends JoopSubject {
+  _value;
+  constructor(initialValue) {
+    super();
+    this._value = initialValue;
+  }
+  getValue() {
+    return this._value;
+  }
+  next(value) {
+    this._value = value;
+    super.next(value);
+  }
+  subscribe(listener) {
+    listener(this._value);
+    return super.subscribe(listener);
+  }
+  asObservable() {
+    return new JoopObservable((listener) => this.subscribe(listener));
+  }
+};
+var JoopObservable = class {
+  constructor(_subscribeFn) {
+    this._subscribeFn = _subscribeFn;
+  }
+  _subscribeFn;
+  subscribe(listener) {
+    return this._subscribeFn(listener);
+  }
+  /** Returns the current value without subscribing (only meaningful for BehaviorSubject-backed observables). */
+  getOnce() {
+    let result;
+    const unsub = this.subscribe((v) => {
+      result = v;
+    });
+    unsub();
+    return result;
+  }
+};
+
+// src/banking/fraud-detection.ts
+function _haversine(lat1, lon1, lat2, lon2) {
+  const R = 6371;
+  const dLat = (lat2 - lat1) * Math.PI / 180;
+  const dLon = (lon2 - lon1) * Math.PI / 180;
+  const a = Math.sin(dLat / 2) ** 2 + Math.cos(lat1 * Math.PI / 180) * Math.cos(lat2 * Math.PI / 180) * Math.sin(dLon / 2) ** 2;
+  return R * 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+}
+function _scoreToLevel(score) {
+  if (score <= 30) return "low";
+  if (score <= 60) return "medium";
+  if (score <= 80) return "high";
+  return "critical";
+}
+function _levelToRecommendation(level) {
+  switch (level) {
+    case "low":
+      return "allow";
+    case "medium":
+      return "review";
+    case "high":
+      return "challenge";
+    case "critical":
+      return "block";
+  }
+}
+var JoopFraudDetection = class {
+  _cfg;
+  _history = [];
+  _alertHandlers = [];
+  // Expose a reactive subject so callers can subscribe to every evaluation result
+  result$;
+  constructor(config = {}) {
+    this._cfg = {
+      velocityWindowMs: config.velocityWindowMs ?? 36e5,
+      velocityCountThreshold: config.velocityCountThreshold ?? 10,
+      velocityAmountThreshold: config.velocityAmountThreshold ?? 5e3,
+      largeAmountThreshold: config.largeAmountThreshold ?? 1e4,
+      geoDistanceThresholdKm: config.geoDistanceThresholdKm ?? 500,
+      alertThreshold: config.alertThreshold ?? 70,
+      maxHistorySize: config.maxHistorySize ?? 1e3
+    };
+    this.result$ = new JoopBehaviorSubject(null);
+  }
+  // -------------------------------------------------------------------------
+  // Public API
+  // -------------------------------------------------------------------------
+  evaluate(signal) {
+    const signals = [
+      this._velocityCount(signal),
+      this._velocityAmount(signal),
+      this._largeAmount(signal),
+      this._geoDistance(signal),
+      this._timeAnomaly(signal)
+    ];
+    const raw = signals.reduce((sum, s) => sum + s.score, 0);
+    const score = Math.min(100, Math.round(raw));
+    const level = _scoreToLevel(score);
+    const result = {
+      transactionId: signal.transactionId,
+      score,
+      level,
+      signals,
+      recommendation: _levelToRecommendation(level),
+      timestamp: Date.now()
+    };
+    this.result$.next(result);
+    return result;
+  }
+  addSignal(signal) {
+    this._history.push(signal);
+    if (this._history.length > this._cfg.maxHistorySize) {
+      this._history.shift();
+    }
+    const result = this.evaluate(signal);
+    if (result.score >= this._cfg.alertThreshold) {
+      for (const handler of this._alertHandlers) {
+        try {
+          handler(result);
+        } catch {
+        }
+      }
+    }
+  }
+  clearHistory(userId) {
+    if (userId === void 0) {
+      this._history = [];
+    } else {
+      this._history = this._history.filter((s) => s.userId !== userId);
+    }
+  }
+  onAlert(handler) {
+    this._alertHandlers.push(handler);
+    return () => {
+      this._alertHandlers = this._alertHandlers.filter((h) => h !== handler);
+    };
+  }
+  // -------------------------------------------------------------------------
+  // Signal evaluators
+  // -------------------------------------------------------------------------
+  /** Velocity: count of transactions by same user/device in window — max 30 pts */
+  _velocityCount(signal) {
+    const windowStart = signal.timestamp - this._cfg.velocityWindowMs;
+    const recent = this._history.filter(
+      (s) => s.timestamp >= windowStart && (signal.userId ? s.userId === signal.userId : s.deviceId === signal.deviceId)
+    );
+    const count = recent.length;
+    const threshold = this._cfg.velocityCountThreshold;
+    if (count === 0) {
+      return { name: "velocity_count", score: 0, triggered: false };
+    }
+    const ratio = Math.min(count / threshold, 1);
+    const score = Math.round(ratio * 30);
+    return {
+      name: "velocity_count",
+      score,
+      triggered: count >= threshold,
+      detail: `${count} transactions in window (threshold ${threshold})`
+    };
+  }
+  /** Velocity: total amount by same user/device in window — max 25 pts */
+  _velocityAmount(signal) {
+    const windowStart = signal.timestamp - this._cfg.velocityWindowMs;
+    const recent = this._history.filter(
+      (s) => s.timestamp >= windowStart && s.currency === signal.currency && (signal.userId ? s.userId === signal.userId : s.deviceId === signal.deviceId)
+    );
+    const total = recent.reduce((sum, s) => sum + s.amount, 0) + signal.amount;
+    const threshold = this._cfg.velocityAmountThreshold;
+    if (total <= 0) {
+      return { name: "velocity_amount", score: 0, triggered: false };
+    }
+    const ratio = Math.min(total / threshold, 1);
+    const score = Math.round(ratio * 25);
+    return {
+      name: "velocity_amount",
+      score,
+      triggered: total >= threshold,
+      detail: `${total.toFixed(2)} ${signal.currency} in window (threshold ${threshold})`
+    };
+  }
+  /** Large single amount — max 20 pts */
+  _largeAmount(signal) {
+    const threshold = this._cfg.largeAmountThreshold;
+    if (signal.amount < threshold) {
+      return { name: "large_amount", score: 0, triggered: false };
+    }
+    const ratio = Math.min(signal.amount / (threshold * 3), 1);
+    const score = Math.round(10 + ratio * 10);
+    return {
+      name: "large_amount",
+      score,
+      triggered: true,
+      detail: `Amount ${signal.amount} ${signal.currency} exceeds threshold ${threshold}`
+    };
+  }
+  /** Geo distance from last transaction by same user — max 15 pts */
+  _geoDistance(signal) {
+    if (signal.latitude === void 0 || signal.longitude === void 0) {
+      return { name: "geo_distance", score: 0, triggered: false };
+    }
+    const previous = [...this._history].reverse().find(
+      (s) => s.latitude !== void 0 && s.longitude !== void 0 && (signal.userId ? s.userId === signal.userId : s.deviceId === signal.deviceId)
+    );
+    if (!previous || previous.latitude === void 0 || previous.longitude === void 0) {
+      return { name: "geo_distance", score: 0, triggered: false };
+    }
+    const km = _haversine(previous.latitude, previous.longitude, signal.latitude, signal.longitude);
+    const threshold = this._cfg.geoDistanceThresholdKm;
+    if (km < threshold) {
+      return { name: "geo_distance", score: 0, triggered: false };
+    }
+    const ratio = Math.min(km / (threshold * 4), 1);
+    const score = Math.round(ratio * 15);
+    return {
+      name: "geo_distance",
+      score,
+      triggered: true,
+      detail: `${km.toFixed(0)} km from last transaction (threshold ${threshold} km)`
+    };
+  }
+  /** Time anomaly: unusual hours 02:00–05:00 local time — max 10 pts */
+  _timeAnomaly(signal) {
+    const hour = new Date(signal.timestamp).getHours();
+    if (hour >= 2 && hour < 5) {
+      return {
+        name: "time_anomaly",
+        score: 10,
+        triggered: true,
+        detail: `Transaction at unusual hour ${hour}:xx (02\u201305 local)`
+      };
+    }
+    return { name: "time_anomaly", score: 0, triggered: false };
+  }
+};
+
+// src/banking/open-banking.ts
+var JoopOpenBankingClient = class {
+  _credentials;
+  _token = null;
+  /** Reactive authentication state — true once a valid token is held */
+  authenticated$;
+  constructor(credentials) {
+    this._credentials = credentials;
+    this.authenticated$ = new JoopBehaviorSubject(false);
+  }
+  // -------------------------------------------------------------------------
+  // Authentication
+  // -------------------------------------------------------------------------
+  async authenticate() {
+    const token = await this._fetchToken();
+    this._token = token;
+    this.authenticated$.next(true);
+  }
+  // -------------------------------------------------------------------------
+  // Accounts & balances
+  // -------------------------------------------------------------------------
+  async getAccounts(consentId) {
+    const raw = await this._request("GET", "/accounts", void 0, consentId);
+    return (raw.Data.Account ?? []).map((a) => ({
+      accountId: a.AccountId,
+      iban: a.Account?.[0]?.Identification,
+      currency: a.Currency,
+      accountType: a.AccountType ?? "Personal",
+      nickname: a.Nickname
+    }));
+  }
+  // -------------------------------------------------------------------------
+  // Transactions
+  // -------------------------------------------------------------------------
+  async getTransactions(accountId, consentId, fromDate, toDate) {
+    const params = new URLSearchParams();
+    if (fromDate) params.set("fromBookingDateTime", fromDate);
+    if (toDate) params.set("toBookingDateTime", toDate);
+    const query = params.toString() ? `?${params.toString()}` : "";
+    const raw = await this._request(
+      "GET",
+      `/accounts/${accountId}/transactions${query}`,
+      void 0,
+      consentId
+    );
+    return (raw.Data.Transaction ?? []).map((t) => ({
+      transactionId: t.TransactionId,
+      accountId: t.AccountId,
+      amount: parseFloat(t.Amount.Amount),
+      currency: t.Amount.Currency,
+      creditDebitIndicator: t.CreditDebitIndicator,
+      status: t.Status,
+      bookingDateTime: t.BookingDateTime,
+      description: t.TransactionInformation,
+      merchantName: t.MerchantDetails?.MerchantName,
+      reference: t.Reference
+    }));
+  }
+  // -------------------------------------------------------------------------
+  // Consents
+  // -------------------------------------------------------------------------
+  async createConsent(request) {
+    const body = {
+      Data: {
+        Permissions: request.scopes,
+        ...request.expirationDateTime ? { ExpirationDateTime: request.expirationDateTime } : {}
+      },
+      Risk: {}
+    };
+    const raw = await this._request("POST", "/account-access-consents", body);
+    const consentId = raw.Data.ConsentId;
+    const authorisationUrl = `${this._credentials.baseUrl.replace(/\/open-banking.*$/, "")}/oauth2/authorize?response_type=code%20id_token&client_id=${encodeURIComponent(this._credentials.clientId)}&request=${encodeURIComponent(consentId)}`;
+    return {
+      consentId,
+      authorisationUrl,
+      status: raw.Data.Status
+    };
+  }
+  async getConsentStatus(consentId) {
+    const raw = await this._request(
+      "GET",
+      `/account-access-consents/${consentId}`
+    );
+    return raw.Data.Status;
+  }
+  async revokeConsent(consentId) {
+    await this._request("DELETE", `/account-access-consents/${consentId}`);
+  }
+  // -------------------------------------------------------------------------
+  // Payments
+  // -------------------------------------------------------------------------
+  async initiatePayment(request) {
+    const consentBody = {
+      Data: {
+        Initiation: _buildInitiation(request)
+      },
+      Risk: { PaymentContextCode: "TransferToThirdParty" }
+    };
+    const consentRaw = await this._request(
+      "POST",
+      "/domestic-payment-consents",
+      consentBody
+    );
+    const consentId = consentRaw.Data.ConsentId;
+    const paymentBody = {
+      Data: {
+        ConsentId: consentId,
+        Initiation: _buildInitiation(request)
+      },
+      Risk: { PaymentContextCode: "TransferToThirdParty" }
+    };
+    const paymentRaw = await this._request(
+      "POST",
+      "/domestic-payments",
+      paymentBody
+    );
+    return {
+      paymentId: paymentRaw.Data.DomesticPaymentId,
+      status: paymentRaw.Data.Status,
+      consentId
+    };
+  }
+  async getPaymentStatus(paymentId) {
+    const raw = await this._request(
+      "GET",
+      `/domestic-payments/${paymentId}`
+    );
+    return raw.Data.Status;
+  }
+  async cancelPayment(paymentId) {
+    await this._request("DELETE", `/domestic-payments/${paymentId}`);
+  }
+  // -------------------------------------------------------------------------
+  // Private helpers
+  // -------------------------------------------------------------------------
+  async _getToken() {
+    if (this._token && Date.now() < this._token.expiresAt - 3e4) {
+      return this._token.accessToken;
+    }
+    const state = await this._fetchToken();
+    this._token = state;
+    this.authenticated$.next(true);
+    return state.accessToken;
+  }
+  async _fetchToken() {
+    const body = new URLSearchParams({
+      grant_type: "client_credentials",
+      client_id: this._credentials.clientId,
+      client_secret: this._credentials.clientSecret,
+      scope: "accounts payments"
+    });
+    const res = await fetch(this._credentials.tokenUrl, {
+      method: "POST",
+      headers: { "Content-Type": "application/x-www-form-urlencoded" },
+      body: body.toString()
+    });
+    if (!res.ok) {
+      throw new Error(`[JoopOpenBankingClient] Token request failed: ${res.status} ${res.statusText}`);
+    }
+    const json = await res.json();
+    return {
+      accessToken: json.access_token,
+      expiresAt: Date.now() + json.expires_in * 1e3
+    };
+  }
+  async _request(method, path, body, consentId) {
+    const token = await this._getToken();
+    const url = `${this._credentials.baseUrl}${path}`;
+    const headers = {
+      "Authorization": `Bearer ${token}`,
+      "Content-Type": "application/json",
+      "x-fapi-interaction-id": _generateInteractionId(),
+      "x-fapi-financial-id": this._credentials.clientId
+    };
+    if (consentId) {
+      headers["x-ob-consent-id"] = consentId;
+    }
+    const res = await fetch(url, {
+      method,
+      headers,
+      ...body !== void 0 ? { body: JSON.stringify(body) } : {}
+    });
+    if (!res.ok) {
+      const errorText = await res.text().catch(() => "");
+      throw new Error(
+        `[JoopOpenBankingClient] ${method} ${path} failed: ${res.status} ${res.statusText} \u2014 ${errorText}`
+      );
+    }
+    if (res.status === 204) return void 0;
+    return res.json();
+  }
+};
+function _buildInitiation(req) {
+  return {
+    InstructionIdentification: req.reference,
+    EndToEndIdentification: req.reference,
+    InstructedAmount: {
+      Amount: req.amount.toFixed(2),
+      Currency: req.currency
+    },
+    CreditorAccount: {
+      SchemeName: "UK.OBIE.IBAN",
+      Identification: req.creditorIban,
+      Name: req.creditorName
+    },
+    ...req.debtorIban ? {
+      DebtorAccount: {
+        SchemeName: "UK.OBIE.IBAN",
+        Identification: req.debtorIban
+      }
+    } : {},
+    ...req.remittanceInfo ? { RemittanceInformation: { Unstructured: req.remittanceInfo } } : {}
+  };
+}
+function _generateInteractionId() {
+  const bytes = new Uint8Array(16);
+  crypto.getRandomValues(bytes);
+  const hex = Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-4${hex.slice(13, 16)}-${hex.slice(16, 20)}-${hex.slice(20, 32)}`;
+}
+
+// src/banking/payment-orchestrator.ts
+var _TERMINAL_STEPS = /* @__PURE__ */ new Set(["authorised", "settled", "failed", "cancelled"]);
+var JoopPaymentOrchestrator = class {
+  _cfg;
+  _sessions = /* @__PURE__ */ new Map();
+  constructor(config) {
+    this._cfg = {
+      gatewayUrl: config.gatewayUrl,
+      merchantId: config.merchantId,
+      apiKey: config.apiKey,
+      timeoutMs: config.timeoutMs ?? 3e4,
+      pollIntervalMs: config.pollIntervalMs ?? 2e3
+    };
+  }
+  // -------------------------------------------------------------------------
+  // Public API
+  // -------------------------------------------------------------------------
+  async initiate(request) {
+    const sessionId = this._generateSessionId();
+    const now = Date.now();
+    const maskedCard = `****${request.cardNumber.replace(/\s/g, "").slice(-4)}`;
+    const session = {
+      sessionId,
+      paymentId: "",
+      amount: request.amount,
+      currency: request.currency,
+      step: "initiating",
+      createdAt: now,
+      updatedAt: now
+    };
+    const subject = new JoopBehaviorSubject(session);
+    this._sessions.set(sessionId, subject);
+    try {
+      const raw = await this._fetch("POST", "/payments", {
+        amount: request.amount,
+        currency: request.currency,
+        cardNumber: maskedCard,
+        // send masked to gateway after capture
+        cardExpiry: request.cardExpiry,
+        cvv: request.cvv,
+        merchantId: request.merchantId,
+        reference: request.reference,
+        returnUrl: request.returnUrl,
+        notifyUrl: request.notifyUrl,
+        metadata: request.metadata
+      });
+      const updated = this._updateSession(subject, {
+        paymentId: raw.paymentId,
+        step: raw.requires3ds ? "awaiting_3ds" : "authorised",
+        threeDsUrl: raw.threeDsUrl,
+        threeDsData: raw.threeDsData,
+        errorCode: raw.errorCode,
+        errorMessage: raw.errorMessage
+      });
+      return updated;
+    } catch (err) {
+      const errMsg = err instanceof Error ? err.message : String(err);
+      return this._updateSession(subject, {
+        step: "failed",
+        errorMessage: errMsg
+      });
+    }
+  }
+  async handle3ds(sessionId, result) {
+    const subject = this._requireSession(sessionId);
+    const current = subject.getValue();
+    if (result.status === "N") {
+      return this._updateSession(subject, {
+        step: "failed",
+        errorCode: "AUTH_FAILED_3DS",
+        errorMessage: "3DS authentication was declined by the card issuer."
+      });
+    }
+    this._updateSession(subject, { step: "processing_3ds" });
+    try {
+      const raw = await this._fetch(
+        "POST",
+        `/payments/${current.paymentId}/3ds`,
+        {
+          transactionId: result.transactionId,
+          status: result.status,
+          eci: result.eci,
+          cavv: result.cavv
+        }
+      );
+      return this._updateSession(subject, {
+        step: _mapGatewayStatus(raw.status),
+        errorCode: raw.errorCode,
+        errorMessage: raw.errorMessage
+      });
+    } catch (err) {
+      const errMsg = err instanceof Error ? err.message : String(err);
+      return this._updateSession(subject, { step: "failed", errorMessage: errMsg });
+    }
+  }
+  async poll(sessionId) {
+    const subject = this._requireSession(sessionId);
+    const current = subject.getValue();
+    if (_TERMINAL_STEPS.has(current.step)) {
+      return current;
+    }
+    try {
+      const raw = await this._fetch(
+        "GET",
+        `/payments/${current.paymentId}`
+      );
+      return this._updateSession(subject, {
+        step: _mapGatewayStatus(raw.status),
+        errorCode: raw.errorCode,
+        errorMessage: raw.errorMessage
+      });
+    } catch (err) {
+      const errMsg = err instanceof Error ? err.message : String(err);
+      return this._updateSession(subject, { step: "failed", errorMessage: errMsg });
+    }
+  }
+  async confirm(sessionId) {
+    const subject = this._requireSession(sessionId);
+    const current = subject.getValue();
+    if (_TERMINAL_STEPS.has(current.step)) {
+      return current;
+    }
+    try {
+      const raw = await this._fetch(
+        "POST",
+        `/payments/${current.paymentId}/confirm`
+      );
+      return this._updateSession(subject, {
+        step: _mapGatewayStatus(raw.status),
+        errorCode: raw.errorCode,
+        errorMessage: raw.errorMessage
+      });
+    } catch (err) {
+      const errMsg = err instanceof Error ? err.message : String(err);
+      return this._updateSession(subject, { step: "failed", errorMessage: errMsg });
+    }
+  }
+  async cancel(sessionId) {
+    const subject = this._requireSession(sessionId);
+    const current = subject.getValue();
+    if (_TERMINAL_STEPS.has(current.step)) {
+      return current;
+    }
+    try {
+      await this._fetch("DELETE", `/payments/${current.paymentId}`);
+      return this._updateSession(subject, { step: "cancelled" });
+    } catch (err) {
+      const errMsg = err instanceof Error ? err.message : String(err);
+      return this._updateSession(subject, { step: "failed", errorMessage: errMsg });
+    }
+  }
+  getSession(sessionId) {
+    return this._sessions.get(sessionId)?.getValue() ?? null;
+  }
+  session$(sessionId) {
+    const existing = this._sessions.get(sessionId);
+    if (existing) return existing.asObservable();
+    return new JoopObservable(() => () => {
+    });
+  }
+  destroy() {
+    this._sessions.clear();
+  }
+  // -------------------------------------------------------------------------
+  // Private helpers
+  // -------------------------------------------------------------------------
+  _requireSession(sessionId) {
+    const subject = this._sessions.get(sessionId);
+    if (!subject) throw new Error(`[JoopPaymentOrchestrator] Unknown sessionId: ${sessionId}`);
+    return subject;
+  }
+  _updateSession(subject, patch) {
+    const next = { ...subject.getValue(), ...patch, updatedAt: Date.now() };
+    subject.next(next);
+    return next;
+  }
+  _generateSessionId() {
+    const bytes = new Uint8Array(18);
+    crypto.getRandomValues(bytes);
+    return btoa(String.fromCharCode(...bytes)).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+  }
+  async _fetch(method, path, body) {
+    const url = `${this._cfg.gatewayUrl}${path}`;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), this._cfg.timeoutMs);
+    try {
+      const res = await fetch(url, {
+        method,
+        headers: {
+          "Authorization": `Bearer ${this._cfg.apiKey}`,
+          "Content-Type": "application/json",
+          "X-Merchant-Id": this._cfg.merchantId
+        },
+        signal: controller.signal,
+        ...body !== void 0 ? { body: JSON.stringify(body) } : {}
+      });
+      if (!res.ok) {
+        const text = await res.text().catch(() => "");
+        throw new Error(`[JoopPaymentOrchestrator] ${method} ${path}: ${res.status} \u2014 ${text}`);
+      }
+      if (res.status === 204) return void 0;
+      return res.json();
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+};
+function _mapGatewayStatus(status) {
+  switch (status?.toLowerCase()) {
+    case "authorised":
+    case "authorized":
+      return "authorised";
+    case "settled":
+    case "captured":
+      return "settled";
+    case "failed":
+    case "declined":
+    case "error":
+      return "failed";
+    case "cancelled":
+    case "canceled":
+    case "voided":
+      return "cancelled";
+    case "pending":
+    case "processing":
+      return "processing_3ds";
+    default:
+      return "processing_3ds";
+  }
+}
+
+// src/banking/statement-parser.ts
+var JoopStatementParser = class _JoopStatementParser {
+  // -------------------------------------------------------------------------
+  // Auto-detect and dispatch
+  // -------------------------------------------------------------------------
+  parse(text, csvConfig) {
+    const format = _JoopStatementParser.detectFormat(text);
+    switch (format) {
+      case "MT940":
+        return this.parseMT940(text);
+      case "OFX":
+        return this.parseOFX(text);
+      case "QIF":
+        return this.parseQIF(text);
+      case "CSV":
+        return this.parseCsv(text, csvConfig);
+      default:
+        return {
+          format: "unknown",
+          transactions: [],
+          parseErrors: ["Unable to detect statement format."]
+        };
+    }
+  }
+  static detectFormat(text) {
+    const trimmed = text.trimStart();
+    if (trimmed.startsWith(":20:") || trimmed.includes("\n:20:")) return "MT940";
+    if (trimmed.includes("OFXHEADER:") || trimmed.includes("<OFX>")) return "OFX";
+    if (/^[DTPMNLC!\^]/m.test(trimmed) && trimmed.includes("^")) return "QIF";
+    const firstLines = trimmed.split("\n").slice(0, 5).join("\n");
+    if (/[,;\t]/.test(firstLines)) return "CSV";
+    return "unknown";
+  }
+  // -------------------------------------------------------------------------
+  // MT940
+  // -------------------------------------------------------------------------
+  parseMT940(text) {
+    const result = {
+      format: "MT940",
+      transactions: [],
+      parseErrors: []
+    };
+    const lines = text.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+    const fieldRegex = /:(\d{2}[A-Z]?):([\s\S]*?)(?=\n:\d{2}[A-Z]?:|$)/g;
+    const fields = /* @__PURE__ */ new Map();
+    let m;
+    while ((m = fieldRegex.exec(lines)) !== null) {
+      const tag = m[1];
+      const value = m[2].trim();
+      const existing = fields.get(tag) ?? [];
+      existing.push(value);
+      fields.set(tag, existing);
+    }
+    const acct = fields.get("25")?.[0];
+    if (acct) {
+      result.accountId = acct.includes("/") ? acct.split("/")[1] : acct;
+    }
+    const ob = fields.get("60F")?.[0] ?? fields.get("60M")?.[0];
+    if (ob) {
+      const parsed = _parseMT940Balance(ob);
+      if (parsed) {
+        result.currency = parsed.currency;
+        result.openingBalance = parsed.amount;
+      }
+    }
+    const cb = fields.get("62F")?.[0] ?? fields.get("62M")?.[0];
+    if (cb) {
+      const parsed = _parseMT940Balance(cb);
+      if (parsed) result.closingBalance = parsed.amount;
+    }
+    const tag61 = fields.get("61") ?? [];
+    const tag86 = fields.get("86") ?? [];
+    tag61.forEach((line61, idx) => {
+      const narrative = tag86[idx] ?? "";
+      try {
+        const txn = _parseMT940Transaction(line61, narrative, result.accountId, result.currency, idx);
+        if (txn) result.transactions.push(txn);
+      } catch (e) {
+        result.parseErrors.push(`MT940 :61: index ${idx}: ${String(e)}`);
+      }
+    });
+    return result;
+  }
+  // -------------------------------------------------------------------------
+  // OFX / QFX (SGML format)
+  // -------------------------------------------------------------------------
+  parseOFX(text) {
+    const result = {
+      format: "OFX",
+      transactions: [],
+      parseErrors: []
+    };
+    const tag = (name) => {
+      const re = new RegExp(`<${name}>([^<\\n\\r]*)`, "i");
+      return re.exec(text)?.[1]?.trim();
+    };
+    result.accountId = tag("ACCTID") ?? tag("BANKID");
+    result.currency = tag("CURDEF") ?? tag("CURRENCY");
+    const ledgerBal = tag("BALAMT");
+    if (ledgerBal !== void 0) result.closingBalance = parseFloat(ledgerBal);
+    const txnBlockRe = /<STMTTRN>([\s\S]*?)<\/STMTTRN>/gi;
+    let blockMatch;
+    let idx = 0;
+    while ((blockMatch = txnBlockRe.exec(text)) !== null) {
+      const block = blockMatch[1];
+      const bTag = (name) => {
+        const re = new RegExp(`<${name}>([^<\\n\\r]*)`, "i");
+        return re.exec(block)?.[1]?.trim();
+      };
+      try {
+        const trnType = bTag("TRNTYPE") ?? "";
+        const dtPosted = bTag("DTPOSTED") ?? "";
+        const dtAvail = bTag("DTAVAIL");
+        const amtStr = bTag("TRNAMT") ?? "0";
+        const fitId = bTag("FITID") ?? String(idx);
+        const name = bTag("NAME");
+        const memo = bTag("MEMO");
+        const refNum = bTag("REFNUM") ?? bTag("CHECKNUM");
+        const rawAmount = parseFloat(amtStr);
+        const amount = Math.abs(rawAmount);
+        const type = _ofxTrnType(trnType, rawAmount);
+        const date = _parseOFXDate(dtPosted);
+        const valueDate = dtAvail ? _parseOFXDate(dtAvail) : void 0;
+        const txn = {
+          id: _stableId(result.accountId, date, amount, idx),
+          date,
+          valueDate,
+          amount,
+          type,
+          currency: result.currency ?? "USD",
+          description: memo ?? name ?? "",
+          reference: refNum,
+          counterpartyName: name,
+          raw: block
+        };
+        result.transactions.push(txn);
+      } catch (e) {
+        result.parseErrors.push(`OFX STMTTRN index ${idx}: ${String(e)}`);
+      }
+      idx++;
+    }
+    return result;
+  }
+  // -------------------------------------------------------------------------
+  // QIF (Quicken Interchange Format)
+  // -------------------------------------------------------------------------
+  parseQIF(text) {
+    const result = {
+      format: "QIF",
+      transactions: [],
+      parseErrors: []
+    };
+    const lines = text.replace(/\r\n/g, "\n").replace(/\r/g, "\n").split("\n");
+    let current = {};
+    let idx = 0;
+    for (const line of lines) {
+      if (line.startsWith("!")) continue;
+      if (line === "^") {
+        if (current.date !== void 0 && current.amount !== void 0) {
+          try {
+            const amount = Math.abs(current.amount);
+            const type = current.amount < 0 ? "debit" : "credit";
+            const txn = {
+              id: _stableId(void 0, current.date, amount, idx),
+              date: current.date,
+              amount,
+              type,
+              currency: "USD",
+              // QIF doesn't carry currency
+              description: current.memo ?? current.payee ?? "",
+              reference: current.ref,
+              counterpartyName: current.payee,
+              raw: void 0
+            };
+            result.transactions.push(txn);
+          } catch (e) {
+            result.parseErrors.push(`QIF record ${idx}: ${String(e)}`);
+          }
+          idx++;
+        }
+        current = {};
+        continue;
+      }
+      const code = line[0];
+      const value = line.slice(1).trim();
+      switch (code) {
+        case "D":
+          current.date = _parseQIFDate(value);
+          break;
+        case "T":
+          current.amount = parseFloat(value.replace(/,/g, ""));
+          break;
+        case "P":
+          current.payee = value;
+          break;
+        case "M":
+          current.memo = value;
+          break;
+        case "N":
+          current.ref = value;
+          break;
+        case "L":
+          break;
+        case "C":
+          current.cleared = value;
+          break;
+      }
+    }
+    return result;
+  }
+  // -------------------------------------------------------------------------
+  // CSV
+  // -------------------------------------------------------------------------
+  parseCsv(text, config = {}) {
+    const result = {
+      format: "CSV",
+      transactions: [],
+      parseErrors: []
+    };
+    const delimiter = config.delimiter ?? _detectDelimiter(text);
+    const hasHeader = config.hasHeader ?? true;
+    const skipRows = config.skipRows ?? 0;
+    const rawRows = text.replace(/\r\n/g, "\n").replace(/\r/g, "\n").split("\n").filter((l) => l.trim().length > 0);
+    const allRows = rawRows.slice(skipRows);
+    if (allRows.length === 0) {
+      result.parseErrors.push("CSV: no data rows found.");
+      return result;
+    }
+    const headerRow = hasHeader ? _splitCsvRow(allRows[0], delimiter) : void 0;
+    const dataRows = hasHeader ? allRows.slice(1) : allRows;
+    const resolve = (col) => {
+      if (col === void 0) return -1;
+      if (typeof col === "number") return col;
+      return headerRow ? headerRow.findIndex((h) => h.toLowerCase() === col.toLowerCase()) : -1;
+    };
+    const dateIdx = resolve(config.dateColumn ?? _guessColumn(headerRow, ["date", "transaction date", "txn date"]));
+    const amtIdx = resolve(config.amountColumn ?? _guessColumn(headerRow, ["amount", "value"]));
+    const crIdx = resolve(config.creditColumn ?? _guessColumn(headerRow, ["credit", "credits"]));
+    const drIdx = resolve(config.debitColumn ?? _guessColumn(headerRow, ["debit", "debits"]));
+    const descIdx = resolve(config.descriptionColumn ?? _guessColumn(headerRow, ["description", "details", "narrative", "memo"]));
+    const refIdx = resolve(config.referenceColumn ?? _guessColumn(headerRow, ["reference", "ref", "cheque no", "check no"]));
+    const balIdx = resolve(config.balanceColumn ?? _guessColumn(headerRow, ["balance", "running balance"]));
+    dataRows.forEach((row, idx) => {
+      if (!row.trim()) return;
+      const cols = _splitCsvRow(row, delimiter);
+      try {
+        const rawDate = dateIdx >= 0 ? cols[dateIdx] ?? "" : "";
+        const rawDesc = descIdx >= 0 ? cols[descIdx] ?? "" : "";
+        const rawRef = refIdx >= 0 ? cols[refIdx] ?? "" : void 0;
+        const rawBal = balIdx >= 0 ? cols[balIdx] ?? "" : void 0;
+        const date = _parseCsvDate(rawDate.trim(), config.dateFormat);
+        let amount;
+        let type;
+        if (crIdx >= 0 || drIdx >= 0) {
+          const crAmt = crIdx >= 0 ? _parseAmount(cols[crIdx] ?? "") : 0;
+          const drAmt = drIdx >= 0 ? _parseAmount(cols[drIdx] ?? "") : 0;
+          if (crAmt > 0) {
+            amount = crAmt;
+            type = "credit";
+          } else if (drAmt > 0) {
+            amount = drAmt;
+            type = "debit";
+          } else {
+            amount = 0;
+            type = "unknown";
+          }
+        } else if (amtIdx >= 0) {
+          const raw = _parseAmount(cols[amtIdx] ?? "");
+          amount = Math.abs(raw);
+          type = raw < 0 ? "debit" : raw > 0 ? "credit" : "unknown";
+        } else {
+          result.parseErrors.push(`CSV row ${idx}: no amount column found.`);
+          return;
+        }
+        const txn = {
+          id: _stableId(void 0, date, amount, idx),
+          date,
+          amount,
+          type,
+          currency: "USD",
+          description: rawDesc.replace(/^"|"$/g, ""),
+          reference: rawRef?.replace(/^"|"$/g, ""),
+          balance: rawBal ? _parseAmount(rawBal) : void 0,
+          raw: row
+        };
+        result.transactions.push(txn);
+      } catch (e) {
+        result.parseErrors.push(`CSV row ${idx}: ${String(e)}`);
+      }
+    });
+    return result;
+  }
+};
+function _parseMT940Balance(value) {
+  const m = /^[CD](\d{6})([A-Z]{3})([\d,]+)/.exec(value.replace(/\s/g, ""));
+  if (!m) return null;
+  const indicator = value[0] === "D" ? -1 : 1;
+  return {
+    currency: m[2],
+    amount: indicator * parseFloat(m[3].replace(",", "."))
+  };
+}
+function _parseMT940Transaction(line61, narrative, accountId, currency, idx) {
+  const re = /^(\d{6})(\d{4})?([CD])(R?)([A-Z]?)(\d[\d,]+)(.*)$/;
+  const m = re.exec(line61.replace(/\s/g, ""));
+  if (!m) return null;
+  const yymmdd = m[1];
+  const mmddOpt = m[2];
+  const cdFlag = m[3];
+  m[4];
+  const amtStr = m[6];
+  const rest = m[7] ?? "";
+  const year = parseInt(yymmdd.slice(0, 2)) + 2e3;
+  const month = yymmdd.slice(2, 4);
+  const day = yymmdd.slice(4, 6);
+  const date = `${year}-${month}-${day}`;
+  let valueDate;
+  if (mmddOpt) {
+    const vmm = mmddOpt.slice(0, 2);
+    const vdd = mmddOpt.slice(2, 4);
+    valueDate = `${year}-${vmm}-${vdd}`;
+  }
+  const amount = parseFloat(amtStr.replace(",", "."));
+  const type = cdFlag === "C" ? "credit" : "debit";
+  const refMatch = /^([^/]{1,16})(?:\/\/(.+))?$/.exec(rest);
+  const reference = refMatch?.[1]?.trim() || void 0;
+  const description = narrative.replace(/\n/g, " ").trim() || reference || "";
+  return {
+    id: _stableId(accountId, date, amount, idx),
+    date,
+    valueDate,
+    amount,
+    type,
+    currency: currency ?? "USD",
+    description,
+    reference,
+    raw: line61 + (narrative ? "\n" + narrative : "")
+  };
+}
+function _ofxTrnType(trnType, rawAmount) {
+  switch (trnType.toUpperCase()) {
+    case "CREDIT":
+      return "credit";
+    case "DEBIT":
+      return "debit";
+    case "FEE":
+      return "fee";
+    case "INT":
+      return "interest";
+    case "XFER":
+      return "transfer";
+    case "DEP":
+      return "credit";
+    case "PAYMENT":
+      return "debit";
+    case "ATM":
+    case "POS":
+      return rawAmount < 0 ? "debit" : "credit";
+    default:
+      return rawAmount < 0 ? "debit" : "credit";
+  }
+}
+function _parseOFXDate(value) {
+  const clean = value.slice(0, 8);
+  if (clean.length < 8) return value;
+  return `${clean.slice(0, 4)}-${clean.slice(4, 6)}-${clean.slice(6, 8)}`;
+}
+function _parseQIFDate(value) {
+  const clean = value.replace(/'/g, "");
+  const parts = clean.split(/[\-\.\/]/);
+  if (parts.length < 3) return clean;
+  let y = parseInt(parts[2]);
+  const a = parseInt(parts[0]);
+  const b = parseInt(parts[1]);
+  if (y < 100) y += y < 30 ? 2e3 : 1900;
+  if (a > 12) {
+    return `${y}-${String(b).padStart(2, "0")}-${String(a).padStart(2, "0")}`;
+  }
+  return `${y}-${String(a).padStart(2, "0")}-${String(b).padStart(2, "0")}`;
+}
+function _detectDelimiter(text) {
+  const sample = text.slice(0, 2e3);
+  const counts = { ",": 0, ";": 0, "	": 0, "|": 0 };
+  for (const ch of sample) {
+    if (ch in counts) counts[ch]++;
+  }
+  return Object.entries(counts).sort((a, b) => b[1] - a[1])[0][0];
+}
+function _splitCsvRow(row, delimiter) {
+  const result = [];
+  let current = "";
+  let inQuotes = false;
+  for (let i = 0; i < row.length; i++) {
+    const ch = row[i];
+    if (ch === '"') {
+      if (inQuotes && row[i + 1] === '"') {
+        current += '"';
+        i++;
+      } else {
+        inQuotes = !inQuotes;
+      }
+    } else if (ch === delimiter && !inQuotes) {
+      result.push(current);
+      current = "";
+    } else {
+      current += ch;
+    }
+  }
+  result.push(current);
+  return result;
+}
+function _guessColumn(header, candidates) {
+  if (!header) return -1;
+  for (const c of candidates) {
+    const idx = header.findIndex((h) => h.toLowerCase().trim() === c.toLowerCase());
+    if (idx >= 0) return idx;
+  }
+  return -1;
+}
+function _parseAmount(raw) {
+  if (!raw || !raw.trim()) return 0;
+  const negative = raw.includes("(") || raw.trimStart().startsWith("-");
+  const clean = raw.replace(/[^0-9.,]/g, "");
+  if (!clean) return 0;
+  const hasEuropean = /\d{1,3}(\.\d{3})+,\d{2}$/.test(clean);
+  const normalised = hasEuropean ? clean.replace(/\./g, "").replace(",", ".") : clean.replace(/,/g, "");
+  const val = parseFloat(normalised);
+  return negative ? -Math.abs(val) : val;
+}
+function _parseCsvDate(raw, fmt) {
+  if (!raw) return "";
+  const format = fmt ?? _detectDateFormat(raw);
+  const clean = raw.replace(/[^\d]/g, "-").replace(/--+/g, "-");
+  const parts = clean.split("-").filter(Boolean);
+  if (parts.length < 3) return raw;
+  let day, month, year;
+  switch (format) {
+    case "DD/MM/YYYY":
+      [day, month, year] = parts;
+      break;
+    case "MM/DD/YYYY":
+      [month, day, year] = parts;
+      break;
+    case "YYYY-MM-DD":
+    default:
+      [year, month, day] = parts;
+  }
+  const y = parseInt(year);
+  const fullYear = y < 100 ? y < 30 ? 2e3 + y : 1900 + y : y;
+  return `${fullYear}-${month.padStart(2, "0")}-${day.padStart(2, "0")}`;
+}
+function _detectDateFormat(sample) {
+  if (/^\d{4}[^\d]\d{2}[^\d]\d{2}$/.test(sample)) return "YYYY-MM-DD";
+  if (/^\d{1,2}\/\d{1,2}\/\d{4}$/.test(sample)) {
+    const parts = sample.split("/");
+    if (parseInt(parts[0]) > 12) return "DD/MM/YYYY";
+    return "MM/DD/YYYY";
+  }
+  if (/^\d{1,2}-\d{1,2}-\d{4}$/.test(sample)) return "DD/MM/YYYY";
+  return "YYYY-MM-DD";
+}
+function _stableId(accountId, date, amount, index) {
+  const key = `${accountId ?? ""}|${date}|${amount.toFixed(2)}|${index}`;
+  let hash = 5381;
+  for (let i = 0; i < key.length; i++) {
+    hash = (hash << 5) + hash ^ key.charCodeAt(i);
+    hash = hash >>> 0;
+  }
+  return `TXN-${hash.toString(16).toUpperCase().padStart(8, "0")}-${index}`;
+}
+
+// src/banking/beneficiary.service.ts
+var JoopBeneficiaryService = class {
+  _beneficiaries = /* @__PURE__ */ new Map();
+  _list$ = new JoopBehaviorSubject([]);
+  // ── CRUD ─────────────────────────────────────────────────────────────────
+  add(data) {
+    const validation = this.validate(data);
+    if (!validation.valid) throw new Error(`Invalid beneficiary: ${validation.errors.join(", ")}`);
+    const b = { ...data, id: _uid(), createdAt: Date.now(), updatedAt: Date.now(), useCount: 0 };
+    this._beneficiaries.set(b.id, b);
+    this._emit();
+    return { ...b };
+  }
+  update(id, patch) {
+    const b = this._get(id);
+    const updated = { ...b, ...patch, id, updatedAt: Date.now() };
+    this._beneficiaries.set(id, updated);
+    this._emit();
+    return { ...updated };
+  }
+  remove(id) {
+    this._beneficiaries.delete(id);
+    this._emit();
+  }
+  get(id) {
+    const b = this._beneficiaries.get(id);
+    return b ? { ...b } : void 0;
+  }
+  getAll() {
+    return Array.from(this._beneficiaries.values()).map((b) => ({ ...b }));
+  }
+  // ── Filtering ────────────────────────────────────────────────────────────
+  getByType(type) {
+    return this.getAll().filter((b) => b.type === type);
+  }
+  getByGroup(group) {
+    return this.getAll().filter((b) => b.group === group);
+  }
+  getFavorites() {
+    return this.getAll().filter((b) => b.isFavorite);
+  }
+  getRecent(limit = 5) {
+    return this.getAll().filter((b) => b.lastUsedAt).sort((a, b) => (b.lastUsedAt ?? 0) - (a.lastUsedAt ?? 0)).slice(0, limit);
+  }
+  getFrequent(limit = 5) {
+    return this.getAll().sort((a, b) => b.useCount - a.useCount).slice(0, limit);
+  }
+  search(query) {
+    const q = query.toLowerCase();
+    return this.getAll().filter(
+      (b) => b.name.toLowerCase().includes(q) || b.nickname?.toLowerCase().includes(q) || b.accountNumber?.includes(q) || b.iban?.toLowerCase().includes(q) || b.upiId?.toLowerCase().includes(q) || b.mobile?.includes(q) || b.bankName?.toLowerCase().includes(q)
+    );
+  }
+  // ── Actions ───────────────────────────────────────────────────────────────
+  toggleFavorite(id) {
+    const b = this._get(id);
+    return this.update(id, { isFavorite: !b.isFavorite });
+  }
+  verify(id) {
+    return this.update(id, { isVerified: true });
+  }
+  markUsed(id) {
+    const b = this._get(id);
+    this.update(id, { lastUsedAt: Date.now(), useCount: b.useCount + 1 });
+  }
+  // ── Meta ──────────────────────────────────────────────────────────────────
+  getGroups() {
+    return [...new Set(this.getAll().map((b) => b.group).filter(Boolean))].sort();
+  }
+  count() {
+    return this._beneficiaries.size;
+  }
+  // ── Validation ────────────────────────────────────────────────────────────
+  validate(b) {
+    const errors = [];
+    if (!b.name?.trim()) errors.push("name is required");
+    if (!b.type) errors.push("type is required");
+    if (b.type === "domestic" || b.type === "international") {
+      if (!b.accountNumber && !b.iban) errors.push("accountNumber or iban required for bank transfers");
+    }
+    if (b.type === "upi") {
+      if (!b.upiId) errors.push("upiId required for UPI beneficiaries");
+      else if (!/^[\w.\-]+@[\w]+$/.test(b.upiId)) errors.push("upiId format invalid (expected user@bank)");
+    }
+    if (b.type === "mobile") {
+      if (!b.mobile) errors.push("mobile required for mobile transfers");
+    }
+    if (b.iban && !/^[A-Z]{2}\d{2}[A-Z0-9]{4,}$/.test(b.iban.replace(/\s/g, ""))) {
+      errors.push("IBAN format invalid");
+    }
+    return { valid: errors.length === 0, errors };
+  }
+  // ── Observable ───────────────────────────────────────────────────────────
+  beneficiaries$() {
+    return this._list$.asObservable();
+  }
+  // ── Internals ─────────────────────────────────────────────────────────────
+  _get(id) {
+    const b = this._beneficiaries.get(id);
+    if (!b) throw new Error(`Beneficiary '${id}' not found`);
+    return b;
+  }
+  _emit() {
+    this._list$.next(this.getAll());
+  }
+};
+function _uid() {
+  return `${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+}
+
+// src/banking/scheduled-payment.service.ts
+var MS = {
+  once: null,
+  daily: 864e5,
+  weekly: 7 * 864e5,
+  biweekly: 14 * 864e5,
+  monthly: null,
+  // computed via Date logic
+  quarterly: null,
+  annually: null
+};
+var JoopScheduledPaymentService = class {
+  _payments = /* @__PURE__ */ new Map();
+  _executions = [];
+  _payments$ = new JoopBehaviorSubject([]);
+  _due$ = new JoopSubject();
+  // ── Schedule ──────────────────────────────────────────────────────────────
+  schedule(data) {
+    const p = {
+      ...data,
+      id: _uid2(),
+      nextExecutionDate: data.startDate,
+      executionCount: 0,
+      status: "active",
+      createdAt: Date.now(),
+      updatedAt: Date.now()
+    };
+    this._payments.set(p.id, p);
+    this._emit();
+    return { ...p };
+  }
+  update(id, patch) {
+    const p = this._get(id);
+    const updated = { ...p, ...patch, updatedAt: Date.now() };
+    this._payments.set(id, updated);
+    this._emit();
+    return { ...updated };
+  }
+  cancel(id) {
+    this.update(id, { status: "cancelled" });
+  }
+  pause(id) {
+    this.update(id, { status: "paused" });
+  }
+  resume(id) {
+    this.update(id, { status: "active" });
+  }
+  // ── Query ─────────────────────────────────────────────────────────────────
+  get(id) {
+    const p = this._payments.get(id);
+    return p ? { ...p } : void 0;
+  }
+  getAll() {
+    return Array.from(this._payments.values()).map((p) => ({ ...p }));
+  }
+  getActive() {
+    return this.getAll().filter((p) => p.status === "active");
+  }
+  getDue(asOf = /* @__PURE__ */ new Date()) {
+    return this.getActive().filter((p) => p.nextExecutionDate <= asOf.getTime());
+  }
+  getUpcoming(days = 30, asOf = /* @__PURE__ */ new Date()) {
+    const cutoff = asOf.getTime() + days * 864e5;
+    return this.getActive().filter((p) => p.nextExecutionDate <= cutoff);
+  }
+  // ── Execution ────────────────────────────────────────────────────────────
+  recordExecution(paymentId, status, error) {
+    const p = this._get(paymentId);
+    const exec = {
+      id: _uid2(),
+      paymentId,
+      executedAt: Date.now(),
+      amount: p.amount,
+      currency: p.currency,
+      status,
+      reference: `REF${Date.now().toString(36).toUpperCase()}`,
+      error
+    };
+    this._executions.push(exec);
+    p.executionCount++;
+    p.lastExecutionDate = exec.executedAt;
+    if (status === "failed") {
+      p.status = "failed";
+    } else if (p.frequency === "once" || p.maxExecutions && p.executionCount >= p.maxExecutions) {
+      p.status = "completed";
+    } else {
+      p.nextExecutionDate = this.computeNextDate(p.nextExecutionDate, p.frequency);
+      if (p.endDate && p.nextExecutionDate > p.endDate) p.status = "completed";
+    }
+    this._payments.set(paymentId, p);
+    this._emit();
+    return exec;
+  }
+  getExecutionHistory(paymentId) {
+    return this._executions.filter((e) => e.paymentId === paymentId);
+  }
+  // ── Date computation ──────────────────────────────────────────────────────
+  computeNextDate(current, frequency) {
+    const ms = MS[frequency];
+    if (ms !== null && ms !== void 0) return current + ms;
+    const d = new Date(current);
+    switch (frequency) {
+      case "monthly":
+        d.setMonth(d.getMonth() + 1);
+        break;
+      case "quarterly":
+        d.setMonth(d.getMonth() + 3);
+        break;
+      case "annually":
+        d.setFullYear(d.getFullYear() + 1);
+        break;
+      case "once":
+        return current;
+    }
+    return d.getTime();
+  }
+  getSchedulePreview(startDate, frequency, count = 5, endDate) {
+    const dates = [];
+    let next = startDate;
+    while (dates.length < count) {
+      if (endDate && next > endDate) break;
+      dates.push(next);
+      if (frequency === "once") break;
+      next = this.computeNextDate(next, frequency);
+    }
+    return dates;
+  }
+  // ── Observables ───────────────────────────────────────────────────────────
+  payments$() {
+    return this._payments$.asObservable();
+  }
+  due$() {
+    return this._due$.asObservable();
+  }
+  // ── Internals ─────────────────────────────────────────────────────────────
+  _get(id) {
+    const p = this._payments.get(id);
+    if (!p) throw new Error(`Scheduled payment '${id}' not found`);
+    return p;
+  }
+  _emit() {
+    this._payments$.next(this.getAll());
+  }
+};
+function _uid2() {
+  return `${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+}
+
+// src/banking/card-management.service.ts
+var DEFAULT_CONTROLS = {
+  onlinePayments: true,
+  internationalPayments: false,
+  contactlessPayments: true,
+  atmWithdrawals: true,
+  ecommercePayments: true
+};
+var JoopCardManagementService = class {
+  _cards = /* @__PURE__ */ new Map();
+  _cards$ = new JoopBehaviorSubject([]);
+  // ── CRUD ─────────────────────────────────────────────────────────────────
+  add(data) {
+    const card = { ...data, id: _uid3(), createdAt: Date.now(), updatedAt: Date.now() };
+    this._cards.set(card.id, card);
+    this._emit();
+    return { ...card };
+  }
+  get(id) {
+    const c = this._cards.get(id);
+    return c ? { ...c } : void 0;
+  }
+  getAll() {
+    return Array.from(this._cards.values()).map((c) => ({ ...c }));
+  }
+  getByAccount(accountId) {
+    return this.getAll().filter((c) => c.accountId === accountId);
+  }
+  getActive() {
+    return this.getAll().filter((c) => c.status === "active");
+  }
+  remove(id) {
+    this._cards.delete(id);
+    this._emit();
+  }
+  // ── Card Controls ──────────────────────────────────────────────────────────
+  freeze(id, reason) {
+    const c = this._require(id);
+    if (c.status === "blocked") throw new Error("Cannot freeze a blocked card");
+    return this._update(id, { status: "frozen", frozenAt: Date.now(), frozenReason: reason });
+  }
+  unfreeze(id) {
+    const c = this._require(id);
+    if (c.status !== "frozen") throw new Error("Card is not frozen");
+    return this._update(id, { status: "active", frozenAt: void 0, frozenReason: void 0 });
+  }
+  block(id) {
+    return this._update(id, { status: "blocked", blockedAt: Date.now() });
+  }
+  // ── Limits & Controls ─────────────────────────────────────────────────────
+  setSpendingLimits(id, limits) {
+    const c = this._require(id);
+    return this._update(id, { spendingLimits: { ...c.spendingLimits, ...limits } });
+  }
+  setControls(id, controls) {
+    const c = this._require(id);
+    return this._update(id, { controls: { ...c.controls, ...controls } });
+  }
+  // ── Virtual Card ──────────────────────────────────────────────────────────
+  generateVirtual(accountId, holderName, options = {}) {
+    const expiryMonths = options.expiryMonths ?? 12;
+    const now = /* @__PURE__ */ new Date();
+    const expiry = new Date(now.getFullYear(), now.getMonth() + expiryMonths, 1);
+    const last4 = String(Math.floor(1e3 + Math.random() * 9e3));
+    "4" + Array.from({ length: 11 }, () => Math.floor(Math.random() * 10)).join("");
+    const cardNumber = `**** **** **** ${last4}`;
+    return this.add({
+      cardNumber,
+      last4,
+      network: "visa",
+      type: "virtual",
+      holderName: holderName.toUpperCase(),
+      expiryMonth: expiry.getMonth() + 1,
+      expiryYear: expiry.getFullYear(),
+      status: "active",
+      accountId,
+      currency: options.currency ?? "USD",
+      spendingLimits: {},
+      controls: { ...DEFAULT_CONTROLS, internationalPayments: true }
+    });
+  }
+  // ── Validation ────────────────────────────────────────────────────────────
+  isExpired(id) {
+    const c = this._require(id);
+    const now = /* @__PURE__ */ new Date();
+    const expiry = new Date(c.expiryYear, c.expiryMonth - 1, 1);
+    return expiry <= new Date(now.getFullYear(), now.getMonth(), 1);
+  }
+  canTransact(id, amount, type) {
+    const c = this._require(id);
+    if (c.status !== "active") return { allowed: false, reason: `Card is ${c.status}` };
+    if (this.isExpired(id)) return { allowed: false, reason: "Card is expired" };
+    const controlMap = {
+      onlinePayments: "onlinePayments",
+      internationalPayments: "internationalPayments",
+      contactlessPayments: "contactlessPayments",
+      atmWithdrawals: "atmWithdrawals",
+      ecommerce: "ecommercePayments"
+    };
+    const controlKey = controlMap[type];
+    if (controlKey && !c.controls[controlKey]) return { allowed: false, reason: `${type} is disabled on this card` };
+    if (c.spendingLimits.perTransaction && amount > c.spendingLimits.perTransaction) {
+      return { allowed: false, reason: `Amount exceeds per-transaction limit of ${c.spendingLimits.perTransaction}` };
+    }
+    return { allowed: true };
+  }
+  validatePin(pin) {
+    return /^\d{4,6}$/.test(pin);
+  }
+  // ── Observables ───────────────────────────────────────────────────────────
+  cards$() {
+    return this._cards$.asObservable();
+  }
+  // ── Internals ─────────────────────────────────────────────────────────────
+  _require(id) {
+    const c = this._cards.get(id);
+    if (!c) throw new Error(`Card '${id}' not found`);
+    return c;
+  }
+  _update(id, patch) {
+    const c = this._require(id);
+    const updated = { ...c, ...patch, updatedAt: Date.now() };
+    this._cards.set(id, updated);
+    this._emit();
+    return { ...updated };
+  }
+  _emit() {
+    this._cards$.next(this.getAll());
+  }
+};
+function _uid3() {
+  return `${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+}
+
+// src/banking/statement-generator.service.ts
+var JoopStatementGeneratorService = class {
+  generate(options) {
+    const sorted = [...options.transactions].filter((t) => t.date >= options.fromDate && t.date <= options.toDate).sort((a, b) => a.date - b.date);
+    let balance = options.openingBalance;
+    let totalCredits = 0;
+    let totalDebits = 0;
+    const entries = sorted.map((tx) => {
+      if (tx.type === "credit") {
+        balance += tx.amount;
+        totalCredits += tx.amount;
+      } else {
+        balance -= tx.amount;
+        totalDebits += tx.amount;
+      }
+      return { ...tx, runningBalance: parseFloat(balance.toFixed(2)) };
+    });
+    return {
+      accountId: options.accountId,
+      accountName: options.accountName ?? "",
+      accountNumber: options.accountNumber ?? "",
+      currency: options.currency,
+      fromDate: options.fromDate,
+      toDate: options.toDate,
+      openingBalance: options.openingBalance,
+      closingBalance: parseFloat(balance.toFixed(2)),
+      totalCredits: parseFloat(totalCredits.toFixed(2)),
+      totalDebits: parseFloat(totalDebits.toFixed(2)),
+      transactionCount: entries.length,
+      entries,
+      generatedAt: Date.now()
+    };
+  }
+  render(statement, format = "text") {
+    switch (format) {
+      case "csv":
+        return this._renderCsv(statement);
+      case "html":
+        return this._renderHtml(statement);
+      default:
+        return this._renderText(statement);
+    }
+  }
+  // ── Summary ────────────────────────────────────────────────────────────────
+  getSummary(statement) {
+    const summary = {};
+    for (const entry of statement.entries) {
+      const cat = entry.category ?? "Uncategorized";
+      summary[cat] = (summary[cat] ?? 0) + entry.amount;
+    }
+    return summary;
+  }
+  getTopCategories(statement, limit = 5) {
+    const summary = this.getSummary(statement);
+    return Object.entries(summary).sort(([, a], [, b]) => b - a).slice(0, limit).map(([category, total]) => ({ category, total: parseFloat(total.toFixed(2)) }));
+  }
+  // ── Renderers ─────────────────────────────────────────────────────────────
+  _renderText(s) {
+    const lines = [];
+    const sep = "\u2500".repeat(70);
+    const fmt = (n) => `${s.currency} ${n.toFixed(2)}`;
+    const fmtDate = (ms) => new Date(ms).toISOString().slice(0, 10);
+    lines.push(sep);
+    lines.push(`ACCOUNT STATEMENT`);
+    lines.push(`Account: ${s.accountName} (${s.accountNumber})`);
+    lines.push(`Period:  ${fmtDate(s.fromDate)} to ${fmtDate(s.toDate)}`);
+    lines.push(`Generated: ${new Date(s.generatedAt).toISOString()}`);
+    lines.push(sep);
+    lines.push(`Opening Balance: ${fmt(s.openingBalance)}`);
+    lines.push("");
+    lines.push(`${"Date".padEnd(12)}${"Description".padEnd(32)}${"Debit".padStart(12)}${"Credit".padStart(12)}${"Balance".padStart(14)}`);
+    lines.push("\u2500".repeat(70));
+    for (const e of s.entries) {
+      const d = e.type === "debit" ? e.amount.toFixed(2) : "";
+      const c = e.type === "credit" ? e.amount.toFixed(2) : "";
+      lines.push(`${fmtDate(e.date).padEnd(12)}${e.description.slice(0, 30).padEnd(32)}${d.padStart(12)}${c.padStart(12)}${e.runningBalance.toFixed(2).padStart(14)}`);
+    }
+    lines.push("\u2500".repeat(70));
+    lines.push(`${"".padEnd(44)}${"Total Debits:".padStart(12)} ${fmt(s.totalDebits)}`);
+    lines.push(`${"".padEnd(44)}${"Total Credits:".padStart(12)} ${fmt(s.totalCredits)}`);
+    lines.push(`${"".padEnd(44)}${"Closing Balance:".padStart(12)} ${fmt(s.closingBalance)}`);
+    lines.push(sep);
+    return lines.join("\n");
+  }
+  _renderCsv(s) {
+    const fmtDate = (ms) => new Date(ms).toISOString().slice(0, 10);
+    const rows = [
+      `Account ID,${s.accountId}`,
+      `Account Name,${s.accountName}`,
+      `Account Number,${s.accountNumber}`,
+      `Currency,${s.currency}`,
+      `Period,${fmtDate(s.fromDate)} to ${fmtDate(s.toDate)}`,
+      `Opening Balance,${s.openingBalance}`,
+      `Closing Balance,${s.closingBalance}`,
+      "",
+      "Date,Description,Type,Amount,Currency,Reference,Category,Running Balance",
+      ...s.entries.map(
+        (e) => [fmtDate(e.date), _csvEscape(e.description), e.type, e.amount, e.currency, e.reference ?? "", e.category ?? "", e.runningBalance].join(",")
+      )
+    ];
+    return rows.join("\n");
+  }
+  _renderHtml(s) {
+    const fmtDate = (ms) => new Date(ms).toISOString().slice(0, 10);
+    const fmt = (n) => `${s.currency} ${n.toFixed(2)}`;
+    const rows = s.entries.map((e) => `
+      <tr>
+        <td>${fmtDate(e.date)}</td>
+        <td>${_htmlEscape(e.description)}</td>
+        <td>${e.type === "debit" ? fmt(e.amount) : ""}</td>
+        <td>${e.type === "credit" ? fmt(e.amount) : ""}</td>
+        <td>${fmt(e.runningBalance)}</td>
+        <td>${e.category ?? ""}</td>
+      </tr>`).join("");
+    return `<!DOCTYPE html>
+<html lang="en">
+<head><meta charset="UTF-8"><title>Account Statement</title>
+<style>
+  body { font-family: Arial, sans-serif; font-size: 13px; margin: 20px; }
+  h2 { margin-bottom: 4px; }
+  .meta { color: #555; margin-bottom: 16px; }
+  table { width: 100%; border-collapse: collapse; }
+  th, td { padding: 6px 10px; border: 1px solid #ddd; text-align: left; }
+  th { background: #f5f5f5; font-weight: 600; }
+  .summary { margin-top: 16px; font-weight: bold; }
+  tr:nth-child(even) { background: #fafafa; }
+</style>
+</head>
+<body>
+<h2>Account Statement</h2>
+<div class="meta">
+  <div>Account: ${_htmlEscape(s.accountName)} (${_htmlEscape(s.accountNumber)})</div>
+  <div>Period: ${fmtDate(s.fromDate)} to ${fmtDate(s.toDate)}</div>
+  <div>Generated: ${new Date(s.generatedAt).toISOString()}</div>
+</div>
+<table>
+  <thead>
+    <tr><th>Date</th><th>Description</th><th>Debit</th><th>Credit</th><th>Balance</th><th>Category</th></tr>
+  </thead>
+  <tbody>
+    <tr><td colspan="4"><strong>Opening Balance</strong></td><td><strong>${fmt(s.openingBalance)}</strong></td><td></td></tr>
+    ${rows}
+    <tr class="summary">
+      <td colspan="2">Totals</td>
+      <td>${fmt(s.totalDebits)}</td>
+      <td>${fmt(s.totalCredits)}</td>
+      <td>${fmt(s.closingBalance)}</td>
+      <td></td>
+    </tr>
+  </tbody>
+</table>
+</body>
+</html>`;
+  }
+};
+function _csvEscape(v) {
+  if (v.includes(",") || v.includes('"') || v.includes("\n")) return `"${v.replace(/"/g, '""')}"`;
+  return v;
+}
+function _htmlEscape(v) {
+  return v.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+
+// src/banking/notification-center.service.ts
+var JoopNotificationCenterService = class {
+  _notifications = [];
+  _notifications$ = new JoopBehaviorSubject([]);
+  _maxItems;
+  constructor(maxItems = 500) {
+    this._maxItems = maxItems;
+  }
+  // ── Add ───────────────────────────────────────────────────────────────────
+  add(data) {
+    const n = {
+      ...data,
+      id: _uid4(),
+      isRead: false,
+      isDismissed: false,
+      createdAt: Date.now()
+    };
+    this._notifications.unshift(n);
+    if (this._notifications.length > this._maxItems) this._notifications.pop();
+    this._emit();
+    return { ...n };
+  }
+  // ── Read ──────────────────────────────────────────────────────────────────
+  get(id) {
+    return this._notifications.find((n) => n.id === id);
+  }
+  getAll(includeExpired = false) {
+    const now = Date.now();
+    return this._notifications.filter((n) => !n.isDismissed && (includeExpired || !n.expiresAt || n.expiresAt > now)).map((n) => ({ ...n }));
+  }
+  getUnread() {
+    return this.getAll().filter((n) => !n.isRead);
+  }
+  getByType(type) {
+    return this.getAll().filter((n) => n.type === type);
+  }
+  getByCategory(category) {
+    return this.getAll().filter((n) => n.category === category);
+  }
+  getByPriority(priority) {
+    return this.getAll().filter((n) => n.priority === priority);
+  }
+  // ── Mark read ─────────────────────────────────────────────────────────────
+  markRead(id) {
+    const n = this._notifications.find((n2) => n2.id === id);
+    if (!n || n.isRead) return;
+    n.isRead = true;
+    n.readAt = Date.now();
+    this._emit();
+  }
+  markAllRead() {
+    const now = Date.now();
+    let changed = false;
+    for (const n of this._notifications) {
+      if (!n.isRead) {
+        n.isRead = true;
+        n.readAt = now;
+        changed = true;
+      }
+    }
+    if (changed) this._emit();
+  }
+  // ── Dismiss ───────────────────────────────────────────────────────────────
+  dismiss(id) {
+    const n = this._notifications.find((n2) => n2.id === id);
+    if (!n || n.isDismissed) return;
+    n.isDismissed = true;
+    this._emit();
+  }
+  dismissAll() {
+    let changed = false;
+    for (const n of this._notifications) {
+      if (!n.isDismissed) {
+        n.isDismissed = true;
+        changed = true;
+      }
+    }
+    if (changed) this._emit();
+  }
+  // ── Counts ────────────────────────────────────────────────────────────────
+  unreadCount() {
+    return this.getUnread().length;
+  }
+  getSummary() {
+    const all = this.getAll();
+    const byType = {};
+    const byPriority = {};
+    for (const n of all) {
+      byType[n.type] = (byType[n.type] ?? 0) + 1;
+      byPriority[n.priority] = (byPriority[n.priority] ?? 0) + 1;
+    }
+    return { total: all.length, unread: this.unreadCount(), byType, byPriority };
+  }
+  // ── Cleanup ───────────────────────────────────────────────────────────────
+  purgeExpired() {
+    const before = this._notifications.length;
+    const now = Date.now();
+    this._notifications = this._notifications.filter((n) => !n.expiresAt || n.expiresAt > now);
+    const removed = before - this._notifications.length;
+    if (removed > 0) this._emit();
+    return removed;
+  }
+  clear() {
+    this._notifications = [];
+    this._emit();
+  }
+  // ── Observable ───────────────────────────────────────────────────────────
+  notifications$() {
+    return this._notifications$.asObservable();
+  }
+  // ── Internals ─────────────────────────────────────────────────────────────
+  _emit() {
+    this._notifications$.next(this.getAll());
+  }
+};
+function _uid4() {
+  return `${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+}
+
+// src/banking/dispute.service.ts
+var JoopDisputeService = class {
+  _disputes = /* @__PURE__ */ new Map();
+  _disputes$ = new JoopBehaviorSubject([]);
+  _counter = 1;
+  // ── CRUD ─────────────────────────────────────────────────────────────────
+  create(data) {
+    const dispute = {
+      ...data,
+      id: _uid5(),
+      referenceNumber: this._generateRef(),
+      status: "open",
+      evidence: [],
+      createdAt: Date.now(),
+      updatedAt: Date.now()
+    };
+    this._disputes.set(dispute.id, dispute);
+    this._emit();
+    return { ...dispute };
+  }
+  update(id, patch) {
+    const d = this._require(id);
+    Object.assign(d, patch, { updatedAt: Date.now() });
+    this._emit();
+    return { ...d };
+  }
+  get(id) {
+    const d = this._disputes.get(id);
+    return d ? { ...d, evidence: [...d.evidence] } : void 0;
+  }
+  getByRef(ref) {
+    const d = Array.from(this._disputes.values()).find((d2) => d2.referenceNumber === ref);
+    return d ? { ...d } : void 0;
+  }
+  getAll() {
+    return Array.from(this._disputes.values()).map((d) => ({ ...d, evidence: [...d.evidence] }));
+  }
+  getByStatus(status) {
+    return this.getAll().filter((d) => d.status === status);
+  }
+  // ── Lifecycle ────────────────────────────────────────────────────────────
+  startReview(id, assignedTo) {
+    return this._transition(id, "under-review", (d) => {
+      if (assignedTo) d.assignedTo = assignedTo;
+    });
+  }
+  resolve(id, resolution) {
+    return this._transition(id, "resolved", (d) => {
+      d.resolution = resolution;
+      d.resolvedAt = Date.now();
+    });
+  }
+  reject(id, reason) {
+    return this._transition(id, "rejected", (d) => {
+      d.rejectionReason = reason;
+      d.resolvedAt = Date.now();
+    });
+  }
+  escalate(id, reason) {
+    return this._transition(id, "escalated", (d) => {
+      d.escalationReason = reason;
+    });
+  }
+  close(id) {
+    return this._transition(id, "closed");
+  }
+  // ── Evidence ─────────────────────────────────────────────────────────────
+  addEvidence(disputeId, evidence) {
+    const d = this._require(disputeId);
+    if (d.status === "resolved" || d.status === "rejected" || d.status === "closed") {
+      throw new Error(`Cannot add evidence to a ${d.status} dispute`);
+    }
+    const e = { ...evidence, id: _uid5(), uploadedAt: Date.now() };
+    d.evidence.push(e);
+    d.updatedAt = Date.now();
+    this._emit();
+    return { ...e };
+  }
+  removeEvidence(disputeId, evidenceId) {
+    const d = this._require(disputeId);
+    const before = d.evidence.length;
+    d.evidence = d.evidence.filter((e) => e.id !== evidenceId);
+    if (d.evidence.length < before) {
+      d.updatedAt = Date.now();
+      this._emit();
+    }
+  }
+  // ── Stats ────────────────────────────────────────────────────────────────
+  getStats() {
+    const all = this.getAll();
+    return {
+      total: all.length,
+      open: all.filter((d) => d.status === "open").length,
+      underReview: all.filter((d) => d.status === "under-review").length,
+      resolved: all.filter((d) => d.status === "resolved").length,
+      rejected: all.filter((d) => d.status === "rejected").length,
+      escalated: all.filter((d) => d.status === "escalated").length,
+      totalAmount: all.reduce((s, d) => s + d.amount, 0)
+    };
+  }
+  // ── Observable ───────────────────────────────────────────────────────────
+  disputes$() {
+    return this._disputes$.asObservable();
+  }
+  // ── Internals ────────────────────────────────────────────────────────────
+  _require(id) {
+    const d = this._disputes.get(id);
+    if (!d) throw new Error(`Dispute '${id}' not found`);
+    return d;
+  }
+  _transition(id, status, mutate) {
+    const d = this._require(id);
+    d.status = status;
+    d.updatedAt = Date.now();
+    if (mutate) mutate(d);
+    this._emit();
+    return { ...d };
+  }
+  _generateRef() {
+    const n = String(this._counter++).padStart(6, "0");
+    return `DSP-${(/* @__PURE__ */ new Date()).getFullYear()}-${n}`;
+  }
+  _emit() {
+    this._disputes$.next(this.getAll());
+  }
+};
+function _uid5() {
+  return `${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+}
+
+// src/banking/bill-payment.service.ts
+var JoopBillPaymentService = class {
+  _billers = /* @__PURE__ */ new Map();
+  _bills = /* @__PURE__ */ new Map();
+  _payments = [];
+  _payments$ = new JoopBehaviorSubject([]);
+  // ── Billers ───────────────────────────────────────────────────────────────
+  addBiller(data) {
+    const biller = { ...data, id: _uid6(), isActive: true, createdAt: Date.now() };
+    this._billers.set(biller.id, biller);
+    return { ...biller };
+  }
+  updateBiller(id, patch) {
+    const b = this._requireBiller(id);
+    Object.assign(b, patch);
+    return { ...b };
+  }
+  removeBiller(id) {
+    this._billers.delete(id);
+  }
+  getBiller(id) {
+    const b = this._billers.get(id);
+    return b ? { ...b } : void 0;
+  }
+  getBillers(category) {
+    const all = Array.from(this._billers.values()).filter((b) => b.isActive).map((b) => ({ ...b }));
+    return category ? all.filter((b) => b.category === category) : all;
+  }
+  // ── Bills ─────────────────────────────────────────────────────────────────
+  addBill(data) {
+    const biller = this._billers.get(data.billerId);
+    const bill = { ...data, id: _uid6(), billerName: biller?.name ?? data.billerName, status: "pending", createdAt: Date.now() };
+    this._bills.set(bill.id, bill);
+    return { ...bill };
+  }
+  getBills(billerId) {
+    const all = Array.from(this._bills.values()).map((b) => ({ ...b }));
+    return billerId ? all.filter((b) => b.billerId === billerId) : all;
+  }
+  getOverdueBills(asOf = Date.now()) {
+    return this.getBills().filter((b) => b.status === "pending" && b.dueDate < asOf);
+  }
+  getUpcomingBills(days = 7, asOf = Date.now()) {
+    const cutoff = asOf + days * 864e5;
+    return this.getBills().filter((b) => b.status === "pending" && b.dueDate >= asOf && b.dueDate <= cutoff);
+  }
+  // ── Payments ─────────────────────────────────────────────────────────────
+  pay(billerId, amount, options = {}) {
+    const biller = this._requireBiller(billerId);
+    const payment = {
+      id: _uid6(),
+      billerId,
+      billId: options.billId,
+      billerName: biller.name,
+      amount,
+      currency: biller.currency,
+      status: "success",
+      reference: options.reference ?? `PAY${Date.now().toString(36).toUpperCase()}`,
+      fromAccount: options.fromAccount,
+      paidAt: Date.now()
+    };
+    this._payments.push(payment);
+    if (options.billId) {
+      const bill = this._bills.get(options.billId);
+      if (bill) bill.status = "paid";
+    }
+    this._payments$.next([...this._payments]);
+    return { ...payment };
+  }
+  getPaymentHistory(billerId) {
+    return billerId ? this._payments.filter((p) => p.billerId === billerId).map((p) => ({ ...p })) : this._payments.map((p) => ({ ...p }));
+  }
+  // ── Summary ───────────────────────────────────────────────────────────────
+  getSummary() {
+    const now = /* @__PURE__ */ new Date();
+    const monthStart = new Date(now.getFullYear(), now.getMonth(), 1).getTime();
+    const yearStart = new Date(now.getFullYear(), 0, 1).getTime();
+    const successful = this._payments.filter((p) => p.status === "success");
+    return {
+      totalPaidThisMonth: successful.filter((p) => p.paidAt >= monthStart).reduce((s, p) => s + p.amount, 0),
+      totalPaidThisYear: successful.filter((p) => p.paidAt >= yearStart).reduce((s, p) => s + p.amount, 0),
+      paymentCount: successful.length,
+      billerCount: this._billers.size,
+      currency: "MIXED"
+    };
+  }
+  // ── Observable ───────────────────────────────────────────────────────────
+  payments$() {
+    return this._payments$.asObservable();
+  }
+  // ── Internals ────────────────────────────────────────────────────────────
+  _requireBiller(id) {
+    const b = this._billers.get(id);
+    if (!b) throw new Error(`Biller '${id}' not found`);
+    return b;
+  }
+};
+function _uid6() {
+  return `${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+}
+
+// src/banking/payment-uri.service.ts
+var JoopPaymentUriService = class {
+  // ── Parse ─────────────────────────────────────────────────────────────────
+  parse(uri) {
+    const raw = uri.trim();
+    if (raw.toLowerCase().startsWith("upi://")) return this._parseUpi(raw);
+    if (raw.toLowerCase().startsWith("bitcoin:")) return this._parseBitcoin(raw);
+    if (raw.toLowerCase().startsWith("ethereum:")) return this._parseEthereum(raw);
+    if (raw.toLowerCase().startsWith("payto:")) return this._parsePayTo(raw);
+    if (raw.toLowerCase().startsWith("sepa:")) return this._parseSepa(raw);
+    return { scheme: "generic", raw, isValid: false, errors: [`Unknown URI scheme: "${raw.split(":")[0]}"`] };
+  }
+  // ── Generate ─────────────────────────────────────────────────────────────
+  generateUpi(params) {
+    if (!params.pa) throw new Error("pa (payee VPA) is required");
+    const q = new URLSearchParams();
+    q.set("pa", params.pa);
+    if (params.pn) q.set("pn", params.pn);
+    if (params.am !== void 0) q.set("am", String(params.am));
+    if (params.cu) q.set("cu", params.cu);
+    if (params.tn) q.set("tn", params.tn);
+    if (params.tr) q.set("tr", params.tr);
+    if (params.mc) q.set("mc", params.mc);
+    return `upi://pay?${q.toString()}`;
+  }
+  generateBitcoin(params) {
+    if (!params.address) throw new Error("address is required");
+    const q = new URLSearchParams();
+    if (params.amount !== void 0) q.set("amount", String(params.amount));
+    if (params.label) q.set("label", params.label);
+    if (params.message) q.set("message", params.message);
+    const qs = q.toString();
+    return `bitcoin:${params.address}${qs ? `?${qs}` : ""}`;
+  }
+  generateEthereum(params) {
+    if (!params.address) throw new Error("address is required");
+    const q = new URLSearchParams();
+    if (params.value !== void 0) q.set("value", String(params.value));
+    if (params.gas !== void 0) q.set("gas", String(params.gas));
+    if (params.data) q.set("data", params.data);
+    const qs = q.toString();
+    return `ethereum:${params.address}${qs ? `?${qs}` : ""}`;
+  }
+  generatePayTo(params) {
+    const q = new URLSearchParams();
+    if (params.amount !== void 0) q.set("amount", `${params.currency ?? "AUD"}:${params.amount}`);
+    if (params.description) q.set("message", params.description);
+    const qs = q.toString();
+    return `payto://${params.payId}${qs ? `?${qs}` : ""}`;
+  }
+  generateSepa(params) {
+    const fields = [
+      "BCD",
+      "002",
+      "1",
+      "SCT",
+      params.bic ?? "",
+      params.name ?? "",
+      params.iban,
+      params.amount ? `${params.currency ?? "EUR"}${params.amount.toFixed(2)}` : "",
+      params.purpose ?? "",
+      params.reference ?? ""
+    ].join("\n");
+    return fields;
+  }
+  // ── Validate ─────────────────────────────────────────────────────────────
+  isValid(uri) {
+    return this.parse(uri).isValid;
+  }
+  getScheme(uri) {
+    const parsed = this.parse(uri);
+    return parsed.isValid ? parsed.scheme : null;
+  }
+  // ── Parsers ──────────────────────────────────────────────────────────────
+  _parseUpi(raw) {
+    const errors = [];
+    try {
+      const url = new URL(raw);
+      if (url.pathname !== "pay" && url.host !== "pay") {
+        const path = (url.pathname || url.host || "").replace(/^\//, "");
+        if (path && path !== "pay") errors.push(`Unknown UPI action: ${path}`);
+      }
+      const pa = url.searchParams.get("pa");
+      if (!pa) errors.push("pa (payee VPA) is required");
+      else if (!/^[\w.\-+]+@[\w]+$/.test(pa)) errors.push("Invalid VPA format");
+      const am = url.searchParams.get("am");
+      if (am && isNaN(Number(am))) errors.push("am (amount) must be a number");
+      const params = {
+        pa: pa ?? "",
+        pn: url.searchParams.get("pn") ?? void 0,
+        am: am ? Number(am) : void 0,
+        cu: url.searchParams.get("cu") ?? "INR",
+        tn: url.searchParams.get("tn") ?? void 0,
+        tr: url.searchParams.get("tr") ?? void 0,
+        mc: url.searchParams.get("mc") ?? void 0
+      };
+      return { scheme: "upi", raw, isValid: errors.length === 0, errors, upi: params };
+    } catch (e) {
+      return { scheme: "upi", raw, isValid: false, errors: ["Invalid UPI URI"] };
+    }
+  }
+  _parseBitcoin(raw) {
+    const errors = [];
+    const [addressPart, queryPart] = raw.slice("bitcoin:".length).split("?");
+    const address = addressPart.trim();
+    if (!address) errors.push("Bitcoin address is required");
+    else if (!/^(bc1|[13])[a-zA-Z0-9]{25,62}$/.test(address)) errors.push("Invalid Bitcoin address format");
+    const q = queryPart ? new URLSearchParams(queryPart) : new URLSearchParams();
+    const amount = q.get("amount") ? Number(q.get("amount")) : void 0;
+    if (amount !== void 0 && isNaN(amount)) errors.push("amount must be a number");
+    const params = { address, amount, label: q.get("label") ?? void 0, message: q.get("message") ?? void 0 };
+    return { scheme: "bitcoin", raw, isValid: errors.length === 0, errors, bitcoin: params };
+  }
+  _parseEthereum(raw) {
+    const errors = [];
+    const [addressPart, queryPart] = raw.slice("ethereum:".length).split("?");
+    const address = addressPart.trim();
+    if (!address) errors.push("Ethereum address is required");
+    else if (!/^0x[0-9a-fA-F]{40}$/.test(address)) errors.push("Invalid Ethereum address (expected 0x + 40 hex chars)");
+    const q = queryPart ? new URLSearchParams(queryPart) : new URLSearchParams();
+    const value = q.get("value") ? Number(q.get("value")) : void 0;
+    const params = { address, value, gas: q.get("gas") ? Number(q.get("gas")) : void 0, data: q.get("data") ?? void 0 };
+    return { scheme: "ethereum", raw, isValid: errors.length === 0, errors, ethereum: params };
+  }
+  _parsePayTo(raw) {
+    const errors = [];
+    try {
+      const url = new URL(raw);
+      const payId = url.hostname + (url.pathname || "");
+      if (!payId) errors.push("PayID is required");
+      const amountParam = url.searchParams.get("amount");
+      let amount;
+      let currency;
+      if (amountParam) {
+        const match = amountParam.match(/^([A-Z]{3}):?([\d.]+)$/);
+        if (match) {
+          currency = match[1];
+          amount = Number(match[2]);
+        } else errors.push("amount format: CCY:amount (e.g. AUD:50.00)");
+      }
+      const params = { payId, amount, currency, description: url.searchParams.get("message") ?? void 0 };
+      return { scheme: "payto", raw, isValid: errors.length === 0, errors, payto: params };
+    } catch {
+      return { scheme: "payto", raw, isValid: false, errors: ["Invalid PayTo URI"] };
+    }
+  }
+  _parseSepa(raw) {
+    const errors = [];
+    const [ibanPart, queryPart] = raw.slice("sepa:".length).split("?");
+    const iban = ibanPart.trim().replace(/\s/g, "");
+    if (!iban) errors.push("IBAN is required");
+    else if (!/^[A-Z]{2}\d{2}[A-Z0-9]{11,30}$/.test(iban)) errors.push("Invalid IBAN format");
+    const q = queryPart ? new URLSearchParams(queryPart) : new URLSearchParams();
+    const amount = q.get("amount") ? Number(q.get("amount")) : void 0;
+    const params = {
+      iban,
+      bic: q.get("bic") ?? void 0,
+      name: q.get("name") ?? void 0,
+      amount,
+      currency: q.get("currency") ?? "EUR",
+      reference: q.get("reference") ?? void 0,
+      purpose: q.get("purpose") ?? void 0
+    };
+    return { scheme: "sepa", raw, isValid: errors.length === 0, errors, sepa: params };
+  }
+};
+
+// src/banking/mandate.service.ts
+var JoopMandateService = class {
+  _mandates = /* @__PURE__ */ new Map();
+  _executions = /* @__PURE__ */ new Map();
+  _counter = 0;
+  _change$ = new JoopSubject();
+  // ── CRUD ─────────────────────────────────────────────────────────────────
+  create(data) {
+    if (data.maxAmount <= 0) throw new Error("maxAmount must be positive");
+    const now = Date.now();
+    const mandate = {
+      id: _uid7(),
+      ref: this._generateRef(),
+      status: "pending",
+      executionCount: 0,
+      createdAt: now,
+      updatedAt: now,
+      nextExecutionAt: this._computeNextDate({ frequency: data.frequency, startDate: data.startDate }, data.startDate),
+      ...data
+    };
+    this._mandates.set(mandate.id, mandate);
+    this._executions.set(mandate.id, []);
+    return { ...mandate };
+  }
+  get(id) {
+    const m = this._mandates.get(id);
+    return m ? { ...m } : void 0;
+  }
+  getAll() {
+    return Array.from(this._mandates.values()).map((m) => ({ ...m }));
+  }
+  // ── State transitions ─────────────────────────────────────────────────────
+  activate(id) {
+    return this._transition(id, "active");
+  }
+  cancel(id) {
+    return this._transition(id, "cancelled");
+  }
+  pause(id) {
+    return this._transition(id, "paused", (m) => {
+      if (m.status !== "active") throw new Error("Only active mandates can be paused");
+    });
+  }
+  resume(id) {
+    return this._transition(id, "active", (m) => {
+      if (m.status !== "paused") throw new Error("Only paused mandates can be resumed");
+    });
+  }
+  fail(id) {
+    return this._transition(id, "failed");
+  }
+  // ── Queries ───────────────────────────────────────────────────────────────
+  getActive() {
+    return this._byStatus("active");
+  }
+  getByAccount(accountId) {
+    return this.getAll().filter((m) => m.accountId === accountId);
+  }
+  getByStatus(status) {
+    return this._byStatus(status);
+  }
+  getDue(asOf = Date.now()) {
+    return this.getActive().filter((m) => m.nextExecutionAt !== void 0 && m.nextExecutionAt <= asOf && !this.isExpired(m));
+  }
+  isExpired(mandate) {
+    return mandate.endDate !== void 0 && Date.now() > mandate.endDate;
+  }
+  // ── Execution ─────────────────────────────────────────────────────────────
+  recordExecution(mandateId, amount, status, failureReason) {
+    const m = this._require(mandateId);
+    if (amount > m.maxAmount) throw new Error(`Execution amount ${amount} exceeds mandate max ${m.maxAmount}`);
+    const exec = { id: _uid7(), mandateId, amount, status, date: Date.now(), failureReason };
+    this._executions.get(mandateId).push(exec);
+    if (status === "success") {
+      m.executionCount++;
+      m.lastExecutedAt = exec.date;
+      m.nextExecutionAt = this.computeNextDate(m, exec.date);
+    }
+    if (status === "failed" && !failureReason) exec.failureReason = "Unknown";
+    m.updatedAt = Date.now();
+    this._change$.next({ ...m });
+    return { ...exec };
+  }
+  getExecutions(mandateId) {
+    return [...this._executions.get(mandateId) ?? []];
+  }
+  // ── Date computation ──────────────────────────────────────────────────────
+  computeNextDate(mandate, fromDate = Date.now()) {
+    return this._computeNextDate(mandate, fromDate);
+  }
+  // ── Observable ────────────────────────────────────────────────────────────
+  change$() {
+    return this._change$.asObservable();
+  }
+  // ── Internals ─────────────────────────────────────────────────────────────
+  _require(id) {
+    const m = this._mandates.get(id);
+    if (!m) throw new Error(`Mandate '${id}' not found`);
+    return m;
+  }
+  _transition(id, status, validate) {
+    const m = this._require(id);
+    if (validate) validate(m);
+    m.status = status;
+    m.updatedAt = Date.now();
+    this._change$.next({ ...m });
+    return { ...m };
+  }
+  _byStatus(status) {
+    return this.getAll().filter((m) => m.status === status);
+  }
+  _computeNextDate(mandate, from) {
+    const d = new Date(from);
+    switch (mandate.frequency) {
+      case "daily":
+        d.setDate(d.getDate() + 1);
+        break;
+      case "weekly":
+        d.setDate(d.getDate() + 7);
+        break;
+      case "biweekly":
+        d.setDate(d.getDate() + 14);
+        break;
+      case "monthly":
+        d.setMonth(d.getMonth() + 1);
+        break;
+      case "quarterly":
+        d.setMonth(d.getMonth() + 3);
+        break;
+      case "half-yearly":
+        d.setMonth(d.getMonth() + 6);
+        break;
+      case "yearly":
+        d.setFullYear(d.getFullYear() + 1);
+        break;
+      case "as-presented":
+        return void 0;
+    }
+    return d.getTime();
+  }
+  _generateRef() {
+    this._counter++;
+    return `MND-${(/* @__PURE__ */ new Date()).getFullYear()}-${String(this._counter).padStart(6, "0")}`;
+  }
+};
+function _uid7() {
+  return `${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+}
+
+// src/banking/split-payment.service.ts
+var JoopSplitPaymentService = class {
+  _expenses = /* @__PURE__ */ new Map();
+  _change$ = new JoopSubject();
+  // ── Create ────────────────────────────────────────────────────────────────
+  create(title, totalAmount, paidBy, participantNames, options = {}) {
+    if (totalAmount <= 0) throw new Error("totalAmount must be positive");
+    if (participantNames.length === 0) throw new Error("At least one participant required");
+    const method = options.method ?? "equal";
+    const shares = this._computeShares(totalAmount, participantNames.length, method, options);
+    const participants = participantNames.map((name, i) => ({
+      id: _uid8(),
+      name,
+      share: shares[i],
+      paid: 0,
+      status: "pending"
+    }));
+    const expense = {
+      id: _uid8(),
+      title,
+      totalAmount,
+      currency: options.currency ?? "USD",
+      paidBy,
+      method,
+      participants,
+      status: "open",
+      notes: options.notes,
+      createdAt: Date.now()
+    };
+    this._expenses.set(expense.id, expense);
+    return this._snapshot(expense);
+  }
+  // ── Payment recording ─────────────────────────────────────────────────────
+  recordPayment(expenseId, participantId, amount) {
+    const e = this._require(expenseId);
+    if (e.status === "settled" || e.status === "cancelled") throw new Error(`Expense is ${e.status}`);
+    const p = e.participants.find((x) => x.id === participantId);
+    if (!p) throw new Error(`Participant '${participantId}' not found`);
+    if (amount <= 0) throw new Error("Payment amount must be positive");
+    p.paid = _round(p.paid + amount);
+    p.paid = Math.min(p.paid, p.share);
+    p.status = p.paid >= p.share ? "paid" : "partial";
+    this._updateStatus(e);
+    this._change$.next(this._snapshot(e));
+    return this._snapshot(e);
+  }
+  // ── Status ────────────────────────────────────────────────────────────────
+  settle(expenseId) {
+    const e = this._require(expenseId);
+    e.status = "settled";
+    e.settledAt = Date.now();
+    this._change$.next(this._snapshot(e));
+  }
+  cancel(expenseId) {
+    const e = this._require(expenseId);
+    e.status = "cancelled";
+    this._change$.next(this._snapshot(e));
+  }
+  // ── Queries ───────────────────────────────────────────────────────────────
+  get(id) {
+    const e = this._expenses.get(id);
+    return e ? this._snapshot(e) : void 0;
+  }
+  getAll() {
+    return Array.from(this._expenses.values()).map((e) => this._snapshot(e));
+  }
+  getOpen() {
+    return this.getAll().filter((e) => e.status === "open" || e.status === "partial");
+  }
+  // ── Settlements ───────────────────────────────────────────────────────────
+  getSettlements(expenseId) {
+    const e = this._require(expenseId);
+    return e.participants.filter((p) => p.paid < p.share && p.name !== e.paidBy).map((p) => ({ from: p.name, to: e.paidBy, amount: _round(p.share - p.paid) }));
+  }
+  getSimplifiedSettlements(expenseId) {
+    return this.getSettlements(expenseId);
+  }
+  // ── Balance ───────────────────────────────────────────────────────────────
+  getBalance(name) {
+    let owes = 0;
+    let owed = 0;
+    for (const e of this.getOpen()) {
+      const p = e.participants.find((x) => x.name === name);
+      if (p && e.paidBy !== name) owes += Math.max(0, p.share - p.paid);
+      if (e.paidBy === name) {
+        for (const other of e.participants) {
+          if (other.name !== name) owed += Math.max(0, other.share - other.paid);
+        }
+      }
+    }
+    return { name, owes: _round(owes), owed: _round(owed), net: _round(owed - owes) };
+  }
+  // ── Summary ───────────────────────────────────────────────────────────────
+  getSummary(expenseId) {
+    const e = this._require(expenseId);
+    const paid = e.participants.reduce((s, p) => s + p.paid, 0);
+    return {
+      total: e.totalAmount,
+      paid: _round(paid),
+      remaining: _round(e.totalAmount - paid),
+      participantCount: e.participants.length,
+      status: e.status
+    };
+  }
+  change$() {
+    return this._change$.asObservable();
+  }
+  // ── Internals ─────────────────────────────────────────────────────────────
+  _computeShares(total, n, method, opts) {
+    switch (method) {
+      case "equal": {
+        const each = _round(total / n);
+        const arr = Array(n).fill(each);
+        const diff = _round(total - arr.reduce((s, x) => s + x, 0));
+        arr[0] = _round(arr[0] + diff);
+        return arr;
+      }
+      case "exact": {
+        const amounts = opts.amounts ?? [];
+        if (amounts.length !== n) throw new Error("amounts length must match participant count");
+        const sum = amounts.reduce((s, x) => s + x, 0);
+        if (Math.abs(sum - total) > 0.01) throw new Error("Exact amounts must sum to totalAmount");
+        return amounts.map((a) => _round(a));
+      }
+      case "percentage": {
+        const pcts = opts.percentages ?? [];
+        if (pcts.length !== n) throw new Error("percentages length must match participant count");
+        const sum = pcts.reduce((s, x) => s + x, 0);
+        if (Math.abs(sum - 100) > 0.01) throw new Error("Percentages must sum to 100");
+        return pcts.map((p) => _round(p / 100 * total));
+      }
+      case "shares": {
+        const sh = opts.shares ?? Array(n).fill(1);
+        if (sh.length !== n) throw new Error("shares length must match participant count");
+        const totalShares = sh.reduce((s, x) => s + x, 0);
+        return sh.map((s) => _round(s / totalShares * total));
+      }
+    }
+  }
+  _updateStatus(e) {
+    const allPaid = e.participants.every((p) => p.status === "paid");
+    const nonePaid = e.participants.every((p) => p.paid === 0);
+    if (allPaid) {
+      e.status = "settled";
+      e.settledAt = Date.now();
+    } else if (nonePaid) e.status = "open";
+    else e.status = "partial";
+  }
+  _require(id) {
+    const e = this._expenses.get(id);
+    if (!e) throw new Error(`Expense '${id}' not found`);
+    return e;
+  }
+  _snapshot(e) {
+    return { ...e, participants: e.participants.map((p) => ({ ...p })) };
+  }
+};
+function _uid8() {
+  return `${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+}
+function _round(n) {
+  return parseFloat(n.toFixed(2));
+}
+
+// src/banking/chequebook.service.ts
+var JoopChequebookService = class {
+  _books = /* @__PURE__ */ new Map();
+  _leafIndex = /* @__PURE__ */ new Map();
+  // chequeNumber → leaf
+  _change$ = new JoopSubject();
+  // ── Chequebook management ─────────────────────────────────────────────────
+  addChequebook(accountId, seriesStart, seriesEnd) {
+    const leaves = this._generateLeaves(accountId, "pending-id", seriesStart, seriesEnd);
+    const book = {
+      id: _uid9(),
+      accountId,
+      seriesStart,
+      seriesEnd,
+      leaves: [],
+      issuedAt: Date.now(),
+      isActive: true
+    };
+    leaves.forEach((l) => {
+      l.chequebookId = book.id;
+      book.leaves.push(l);
+      this._leafIndex.set(l.chequeNumber, l);
+    });
+    this._books.set(book.id, book);
+    return this._snapshotBook(book);
+  }
+  getChequebook(id) {
+    const b = this._books.get(id);
+    return b ? this._snapshotBook(b) : void 0;
+  }
+  getByAccount(accountId) {
+    return Array.from(this._books.values()).filter((b) => b.accountId === accountId).map((b) => this._snapshotBook(b));
+  }
+  deactivateChequebook(id) {
+    const b = this._books.get(id);
+    if (!b) throw new Error(`Chequebook '${id}' not found`);
+    b.isActive = false;
+  }
+  // ── Leaf operations ───────────────────────────────────────────────────────
+  issueCheque(chequeNumber, issuedTo, amount, options = {}) {
+    const leaf = this._requireLeaf(chequeNumber);
+    if (leaf.status !== "available") throw new Error(`Cheque ${chequeNumber} is not available (status: ${leaf.status})`);
+    if (amount <= 0) throw new Error("Amount must be positive");
+    leaf.status = "issued";
+    leaf.issuedTo = issuedTo;
+    leaf.amount = amount;
+    leaf.issuedAt = Date.now();
+    leaf.expiresAt = options.expiresAt;
+    leaf.notes = options.notes;
+    this._change$.next({ ...leaf });
+    return { ...leaf };
+  }
+  stopPayment(chequeNumber, reason) {
+    const leaf = this._requireLeaf(chequeNumber);
+    if (leaf.status === "cleared") throw new Error("Cannot stop a cleared cheque");
+    if (leaf.status === "stopped") throw new Error("Cheque is already stopped");
+    leaf.status = "stopped";
+    leaf.stoppedAt = Date.now();
+    leaf.stopReason = reason;
+    this._change$.next({ ...leaf });
+    return { ...leaf };
+  }
+  markPresented(chequeNumber, presentedAt) {
+    const leaf = this._requireLeaf(chequeNumber);
+    if (leaf.status !== "issued") throw new Error(`Cheque must be in 'issued' status to present (current: ${leaf.status})`);
+    leaf.status = "presented";
+    leaf.presentedAt = presentedAt ?? Date.now();
+    this._change$.next({ ...leaf });
+    return { ...leaf };
+  }
+  markCleared(chequeNumber, clearedAt) {
+    const leaf = this._requireLeaf(chequeNumber);
+    if (leaf.status !== "presented") throw new Error(`Cheque must be in 'presented' status to clear (current: ${leaf.status})`);
+    leaf.status = "cleared";
+    leaf.clearedAt = clearedAt ?? Date.now();
+    this._change$.next({ ...leaf });
+    return { ...leaf };
+  }
+  markBounced(chequeNumber, reason = "Insufficient funds") {
+    const leaf = this._requireLeaf(chequeNumber);
+    if (leaf.status !== "presented" && leaf.status !== "issued") throw new Error(`Cannot bounce cheque in status '${leaf.status}'`);
+    leaf.status = "bounced";
+    leaf.bounceReason = reason;
+    this._change$.next({ ...leaf });
+    return { ...leaf };
+  }
+  cancelCheque(chequeNumber) {
+    const leaf = this._requireLeaf(chequeNumber);
+    if (leaf.status === "cleared") throw new Error("Cannot cancel a cleared cheque");
+    leaf.status = "cancelled";
+    this._change$.next({ ...leaf });
+    return { ...leaf };
+  }
+  // ── Queries ───────────────────────────────────────────────────────────────
+  getLeaf(chequeNumber) {
+    const l = this._leafIndex.get(chequeNumber);
+    return l ? { ...l } : void 0;
+  }
+  getByStatus(status, accountId) {
+    let leaves = Array.from(this._leafIndex.values()).filter((l) => l.status === status);
+    if (accountId) leaves = leaves.filter((l) => l.accountId === accountId);
+    return leaves.map((l) => ({ ...l }));
+  }
+  getAvailableLeaves(accountId) {
+    return this.getByStatus("available", accountId);
+  }
+  isValid(chequeNumber) {
+    const leaf = this._leafIndex.get(chequeNumber);
+    if (!leaf) return false;
+    if (!["available", "issued"].includes(leaf.status)) return false;
+    if (leaf.expiresAt && Date.now() > leaf.expiresAt) return false;
+    return true;
+  }
+  getStats(accountId) {
+    let leaves = Array.from(this._leafIndex.values());
+    if (accountId) leaves = leaves.filter((l) => l.accountId === accountId);
+    const count = (s) => leaves.filter((l) => l.status === s).length;
+    return {
+      total: leaves.length,
+      available: count("available"),
+      issued: count("issued"),
+      presented: count("presented"),
+      cleared: count("cleared"),
+      bounced: count("bounced"),
+      stopped: count("stopped"),
+      cancelled: count("cancelled"),
+      expired: count("expired")
+    };
+  }
+  change$() {
+    return this._change$.asObservable();
+  }
+  // ── Internals ─────────────────────────────────────────────────────────────
+  _requireLeaf(chequeNumber) {
+    const l = this._leafIndex.get(chequeNumber);
+    if (!l) throw new Error(`Cheque '${chequeNumber}' not found`);
+    return l;
+  }
+  _generateLeaves(accountId, chequebookId, start, end) {
+    const startNum = parseInt(start, 10);
+    const endNum = parseInt(end, 10);
+    if (isNaN(startNum) || isNaN(endNum) || endNum < startNum) throw new Error("Invalid cheque series range");
+    const padLen = start.length;
+    const leaves = [];
+    for (let n = startNum; n <= endNum; n++) {
+      leaves.push({ chequeNumber: String(n).padStart(padLen, "0"), chequebookId, accountId, status: "available" });
+    }
+    return leaves;
+  }
+  _snapshotBook(b) {
+    return { ...b, leaves: b.leaves.map((l) => ({ ...l })) };
+  }
+};
+function _uid9() {
+  return `${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+}
+
+// src/banking/insurance.service.ts
+var FREQ_MONTHS = {
+  monthly: 1,
+  quarterly: 3,
+  "half-yearly": 6,
+  yearly: 12
+};
+var JoopInsuranceService = class {
+  _policies = /* @__PURE__ */ new Map();
+  _claims = /* @__PURE__ */ new Map();
+  _payments = /* @__PURE__ */ new Map();
+  // policyId → payments
+  _claimCounter = 0;
+  _change$ = new JoopSubject();
+  // ── Policies ──────────────────────────────────────────────────────────────
+  addPolicy(data) {
+    if (data.coverageAmount <= 0) throw new Error("coverageAmount must be positive");
+    if (data.premiumAmount <= 0) throw new Error("premiumAmount must be positive");
+    if (data.endDate <= data.startDate) throw new Error("endDate must be after startDate");
+    const now = Date.now();
+    const policy = { ...data, id: _uid10(), createdAt: now, updatedAt: now };
+    this._policies.set(policy.id, policy);
+    this._payments.set(policy.id, []);
+    this._change$.next({ ...policy });
+    return { ...policy };
+  }
+  updatePolicy(id, patch) {
+    const p = this._require(id);
+    Object.assign(p, patch, { updatedAt: Date.now() });
+    this._change$.next({ ...p });
+    return { ...p };
+  }
+  cancelPolicy(id, reason) {
+    const p = this._require(id);
+    if (p.status === "cancelled") throw new Error("Policy is already cancelled");
+    p.status = "cancelled";
+    if (reason) p.notes = reason;
+    p.updatedAt = Date.now();
+    this._change$.next({ ...p });
+    return { ...p };
+  }
+  renewPolicy(id, newEndDate) {
+    const p = this._require(id);
+    if (newEndDate <= p.endDate) throw new Error("newEndDate must be after current endDate");
+    p.endDate = newEndDate;
+    p.status = "active";
+    p.updatedAt = Date.now();
+    this._change$.next({ ...p });
+    return { ...p };
+  }
+  getPolicy(id) {
+    const p = this._policies.get(id);
+    return p ? { ...p } : void 0;
+  }
+  getAll() {
+    return Array.from(this._policies.values()).map((p) => ({ ...p }));
+  }
+  getActive() {
+    return this.getAll().filter((p) => p.status === "active");
+  }
+  getByType(type) {
+    return this.getAll().filter((p) => p.type === type);
+  }
+  getExpiring(withinDays, asOf = Date.now()) {
+    const cutoff = asOf + withinDays * 864e5;
+    return this.getActive().filter((p) => p.endDate <= cutoff && p.endDate > asOf);
+  }
+  // ── Claims ────────────────────────────────────────────────────────────────
+  fileClaim(policyId, amount, description, documents = []) {
+    const p = this._require(policyId);
+    if (p.status !== "active") throw new Error(`Cannot file claim on a ${p.status} policy`);
+    if (amount <= 0) throw new Error("Claim amount must be positive");
+    if (amount > p.coverageAmount) throw new Error(`Claim amount exceeds coverage (${p.coverageAmount})`);
+    this._claimCounter++;
+    const claim = {
+      id: _uid10(),
+      claimNumber: `CLM-${(/* @__PURE__ */ new Date()).getFullYear()}-${String(this._claimCounter).padStart(6, "0")}`,
+      policyId,
+      amount,
+      description,
+      documents,
+      status: "submitted",
+      submittedAt: Date.now()
+    };
+    this._claims.set(claim.id, claim);
+    return { ...claim };
+  }
+  updateClaim(id, status, options = {}) {
+    const c = this._requireClaim(id);
+    c.status = status;
+    if (status === "paid" || status === "rejected" || status === "withdrawn") c.resolvedAt = Date.now();
+    if (options.paidAmount !== void 0) c.paidAmount = options.paidAmount;
+    if (options.rejectionReason) c.rejectionReason = options.rejectionReason;
+    return { ...c };
+  }
+  getClaims(policyId) {
+    const all = Array.from(this._claims.values()).map((c) => ({ ...c }));
+    return policyId ? all.filter((c) => c.policyId === policyId) : all;
+  }
+  // ── Premium payments ──────────────────────────────────────────────────────
+  recordPremiumPayment(policyId, amount, method) {
+    this._require(policyId);
+    const payment = { id: _uid10(), policyId, amount, date: Date.now(), method };
+    this._payments.get(policyId).push(payment);
+    const p = this._policies.get(policyId);
+    const base = p.nextPremiumDate ?? Date.now();
+    const d = new Date(base);
+    d.setMonth(d.getMonth() + FREQ_MONTHS[p.premiumFrequency]);
+    p.nextPremiumDate = d.getTime();
+    p.updatedAt = Date.now();
+    return { ...payment };
+  }
+  getPremiumHistory(policyId) {
+    return [...this._payments.get(policyId) ?? []];
+  }
+  // ── Aggregates ────────────────────────────────────────────────────────────
+  getTotalCoverage() {
+    return this.getActive().reduce((s, p) => s + p.coverageAmount, 0);
+  }
+  getTotalAnnualPremium() {
+    const YEARLY_FACTOR = {
+      monthly: 12,
+      quarterly: 4,
+      "half-yearly": 2,
+      yearly: 1
+    };
+    return this.getActive().reduce((s, p) => s + p.premiumAmount * YEARLY_FACTOR[p.premiumFrequency], 0);
+  }
+  change$() {
+    return this._change$.asObservable();
+  }
+  // ── Internals ─────────────────────────────────────────────────────────────
+  _require(id) {
+    const p = this._policies.get(id);
+    if (!p) throw new Error(`Policy '${id}' not found`);
+    return p;
+  }
+  _requireClaim(id) {
+    const c = this._claims.get(id);
+    if (!c) throw new Error(`Claim '${id}' not found`);
+    return c;
+  }
+};
+function _uid10() {
+  return `${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+}
+
+// src/banking/remittance.service.ts
+var DEFAULT_FEES = {
+  swift: 25,
+  sepa: 0.5,
+  ach: 0.25,
+  wire: 20,
+  crypto: 1,
+  "mobile-money": 2,
+  "cash-pickup": 5
+};
+var ARRIVAL_MS = {
+  swift: 3 * 864e5,
+  sepa: 864e5,
+  ach: 2 * 864e5,
+  wire: 864e5,
+  crypto: 30 * 6e4,
+  "mobile-money": 10 * 6e4,
+  "cash-pickup": 2 * 6e4
+};
+var JoopRemittanceService = class {
+  _remittances = /* @__PURE__ */ new Map();
+  _rates = /* @__PURE__ */ new Map();
+  // "USD:EUR" → rate
+  _fees = /* @__PURE__ */ new Map();
+  // channel → flat fee override
+  _counter = 0;
+  _change$ = new JoopSubject();
+  // ── FX rates & fees ───────────────────────────────────────────────────────
+  setExchangeRate(from, to, rate) {
+    this._rates.set(_rateKey(from, to), rate);
+    this._rates.set(_rateKey(to, from), parseFloat((1 / rate).toFixed(6)));
+  }
+  getExchangeRate(from, to) {
+    return this._rates.get(_rateKey(from, to)) ?? null;
+  }
+  setChannelFee(channel, fee) {
+    this._fees.set(channel, fee);
+  }
+  getFee(channel) {
+    return this._fees.get(channel) ?? DEFAULT_FEES[channel];
+  }
+  // ── Quote ─────────────────────────────────────────────────────────────────
+  getQuote(sendAmount, sendCurrency, receiveCurrency, channel = "swift") {
+    if (sendAmount <= 0) throw new Error("sendAmount must be positive");
+    const rate = sendCurrency === receiveCurrency ? 1 : this._rates.get(_rateKey(sendCurrency, receiveCurrency)) ?? null;
+    if (rate === null) throw new Error(`No exchange rate set for ${sendCurrency} \u2192 ${receiveCurrency}`);
+    const fee = this.getFee(channel);
+    const receiveAmount = parseFloat(((sendAmount - fee) * rate).toFixed(2));
+    if (receiveAmount <= 0) throw new Error("Send amount is too small to cover the fee");
+    return {
+      sendAmount,
+      sendCurrency,
+      receiveAmount,
+      receiveCurrency,
+      exchangeRate: rate,
+      fee,
+      totalDebit: parseFloat((sendAmount + fee).toFixed(2)),
+      estimatedArrivalMs: ARRIVAL_MS[channel],
+      channel
+    };
+  }
+  // ── Initiate ──────────────────────────────────────────────────────────────
+  initiate(data) {
+    const quote = this.getQuote(data.sendAmount, data.sendCurrency, data.receiveCurrency, data.channel);
+    const now = Date.now();
+    const remittance = {
+      id: _uid11(),
+      ref: this._generateRef(),
+      status: "initiated",
+      ...quote,
+      senderName: data.senderName,
+      senderAccount: data.senderAccount,
+      recipientName: data.recipientName,
+      recipientAccount: data.recipientAccount,
+      recipientBankCode: data.recipientBankCode,
+      recipientCountry: data.recipientCountry,
+      purposeCode: data.purposeCode,
+      notes: data.notes,
+      initiatedAt: now,
+      estimatedArrival: now + quote.estimatedArrivalMs
+    };
+    this._remittances.set(remittance.id, remittance);
+    this._change$.next({ ...remittance });
+    return { ...remittance };
+  }
+  // ── Status management ─────────────────────────────────────────────────────
+  cancel(id) {
+    return this._transition(id, "cancelled", (r) => {
+      if (!["initiated", "processing"].includes(r.status)) throw new Error(`Cannot cancel remittance in '${r.status}' status`);
+    });
+  }
+  updateStatus(id, status, options = {}) {
+    return this._transition(id, status, (r) => {
+      if (options.notes) r.notes = options.notes;
+      if (status === "completed") r.completedAt = Date.now();
+    });
+  }
+  // ── Queries ───────────────────────────────────────────────────────────────
+  getById(id) {
+    const r = this._remittances.get(id);
+    return r ? { ...r } : void 0;
+  }
+  getByRef(ref) {
+    return Array.from(this._remittances.values()).find((r) => r.ref === ref);
+  }
+  getByStatus(status) {
+    return Array.from(this._remittances.values()).filter((r) => r.status === status).map((r) => ({ ...r }));
+  }
+  getHistory(limit) {
+    const all = Array.from(this._remittances.values()).sort((a, b) => b.initiatedAt - a.initiatedAt);
+    return (limit ? all.slice(0, limit) : all).map((r) => ({ ...r }));
+  }
+  getTotalSent(currency) {
+    return Array.from(this._remittances.values()).filter((r) => r.status === "completed" && (!currency || r.sendCurrency === currency)).reduce((s, r) => s + r.sendAmount, 0);
+  }
+  change$() {
+    return this._change$.asObservable();
+  }
+  // ── Internals ─────────────────────────────────────────────────────────────
+  _transition(id, status, mutate) {
+    const r = this._remittances.get(id);
+    if (!r) throw new Error(`Remittance '${id}' not found`);
+    if (mutate) mutate(r);
+    r.status = status;
+    this._change$.next({ ...r });
+    return { ...r };
+  }
+  _generateRef() {
+    this._counter++;
+    return `RMT-${(/* @__PURE__ */ new Date()).getFullYear()}-${String(this._counter).padStart(6, "0")}`;
+  }
+};
+function _rateKey(from, to) {
+  return `${from.toUpperCase()}:${to.toUpperCase()}`;
+}
+function _uid11() {
+  return `${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+}
+
+// src/banking/virtual-account.service.ts
+var JoopVirtualAccountService = class {
+  _accounts = /* @__PURE__ */ new Map();
+  _credits = /* @__PURE__ */ new Map();
+  // vaId → credits
+  _counter = 0;
+  _change$ = new JoopSubject();
+  // ── Create / manage ───────────────────────────────────────────────────────
+  create(data) {
+    const now = Date.now();
+    const accountNumber = this.generateAccountNumber();
+    const va = {
+      id: _uid12(),
+      accountNumber,
+      iban: data.ibanPrefix ? `${data.ibanPrefix}${accountNumber}` : void 0,
+      parentAccountId: data.parentAccountId,
+      label: data.label,
+      purpose: data.purpose,
+      status: "active",
+      currency: data.currency ?? "USD",
+      collectedAmount: 0,
+      expectedAmount: data.expectedAmount,
+      reference: data.reference,
+      expiresAt: data.expiresAt,
+      metadata: data.metadata,
+      createdAt: now,
+      updatedAt: now
+    };
+    this._accounts.set(va.id, va);
+    this._credits.set(va.id, []);
+    this._change$.next({ ...va });
+    return { ...va };
+  }
+  close(id) {
+    return this._setStatus(id, "closed");
+  }
+  deactivate(id) {
+    return this._setStatus(id, "inactive");
+  }
+  activate(id) {
+    const va = this._require(id);
+    if (va.status === "closed") throw new Error("Cannot activate a closed virtual account");
+    return this._setStatus(id, "active");
+  }
+  update(id, patch) {
+    const va = this._require(id);
+    Object.assign(va, patch, { updatedAt: Date.now() });
+    this._change$.next({ ...va });
+    return { ...va };
+  }
+  // ── Queries ───────────────────────────────────────────────────────────────
+  get(id) {
+    const va = this._accounts.get(id);
+    return va ? { ...va } : void 0;
+  }
+  getAll() {
+    return Array.from(this._accounts.values()).map((va) => ({ ...va }));
+  }
+  getActive(parentAccountId) {
+    let list = this.getAll().filter((va) => va.status === "active");
+    if (parentAccountId) list = list.filter((va) => va.parentAccountId === parentAccountId);
+    return list;
+  }
+  getByReference(reference) {
+    return Array.from(this._accounts.values()).find((va) => va.reference === reference);
+  }
+  getByPurpose(purpose) {
+    return this.getAll().filter((va) => va.purpose === purpose);
+  }
+  getExpiring(withinMs, asOf = Date.now()) {
+    const cutoff = asOf + withinMs;
+    return this.getActive().filter((va) => va.expiresAt !== void 0 && va.expiresAt <= cutoff && va.expiresAt > asOf);
+  }
+  // ── Credits ───────────────────────────────────────────────────────────────
+  recordCredit(virtualAccountId, amount, options = {}) {
+    const va = this._require(virtualAccountId);
+    if (va.status !== "active") throw new Error(`Virtual account is ${va.status}`);
+    if (amount <= 0) throw new Error("Credit amount must be positive");
+    const credit = {
+      id: _uid12(),
+      virtualAccountId,
+      amount,
+      currency: options.currency ?? va.currency,
+      senderName: options.senderName,
+      senderRef: options.senderRef,
+      receivedAt: Date.now(),
+      notes: options.notes
+    };
+    this._credits.get(virtualAccountId).push(credit);
+    va.collectedAmount = parseFloat((va.collectedAmount + amount).toFixed(2));
+    va.updatedAt = Date.now();
+    this._change$.next({ ...va });
+    return { ...credit };
+  }
+  getCredits(virtualAccountId) {
+    return [...this._credits.get(virtualAccountId) ?? []];
+  }
+  getTotalCollected(virtualAccountId) {
+    const va = this._require(virtualAccountId);
+    return va.collectedAmount;
+  }
+  isFullyCollected(virtualAccountId) {
+    const va = this._require(virtualAccountId);
+    return va.expectedAmount !== void 0 && va.collectedAmount >= va.expectedAmount;
+  }
+  // ── Utilities ─────────────────────────────────────────────────────────────
+  generateAccountNumber(prefix = "VA") {
+    this._counter++;
+    return `${prefix}${String(Date.now()).slice(-8)}${String(this._counter).padStart(4, "0")}`;
+  }
+  change$() {
+    return this._change$.asObservable();
+  }
+  // ── Internals ─────────────────────────────────────────────────────────────
+  _require(id) {
+    const va = this._accounts.get(id);
+    if (!va) throw new Error(`Virtual account '${id}' not found`);
+    return va;
+  }
+  _setStatus(id, status) {
+    const va = this._require(id);
+    va.status = status;
+    va.updatedAt = Date.now();
+    this._change$.next({ ...va });
+    return { ...va };
+  }
+};
+function _uid12() {
+  return `${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+}
+
+// src/banking/ledger.service.ts
+function _uid13() {
+  return `${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+}
+function _round2(n, dp = 2) {
+  return Math.round(n * 10 ** dp) / 10 ** dp;
+}
+var DEBIT_NORMAL = /* @__PURE__ */ new Set(["asset", "expense"]);
+var JoopLedgerService = class {
+  _accounts = /* @__PURE__ */ new Map();
+  _entries = [];
+  _seq = 0;
+  _change$ = new JoopSubject();
+  // ── Accounts ─────────────────────────────────────────────────────────────
+  addAccount(code, name, type, description) {
+    if (!code.trim()) throw new Error("Account code required");
+    if (this._accounts.has(code)) throw new Error(`Account ${code} already exists`);
+    const account = { code, name, type, description, createdAt: Date.now() };
+    this._accounts.set(code, account);
+    return account;
+  }
+  getAccount(code) {
+    return this._accounts.get(code);
+  }
+  getAccounts() {
+    return Array.from(this._accounts.values());
+  }
+  removeAccount(code) {
+    if (!this._accounts.has(code)) throw new Error(`Account ${code} not found`);
+    const hasEntries = this._entries.some((e) => e.lines.some((l) => l.accountCode === code));
+    if (hasEntries) throw new Error(`Cannot remove account ${code} \u2014 it has journal entries`);
+    this._accounts.delete(code);
+  }
+  // ── Journal ───────────────────────────────────────────────────────────────
+  postEntry(description, lines, opts = {}) {
+    if (lines.length < 2) throw new Error("A journal entry requires at least 2 lines");
+    for (const l of lines) {
+      if (!this._accounts.has(l.accountCode)) throw new Error(`Unknown account: ${l.accountCode}`);
+      if (l.debit < 0 || l.credit < 0) throw new Error("Debit/credit amounts must be non-negative");
+    }
+    const totalDebits = _round2(lines.reduce((s, l) => s + l.debit, 0));
+    const totalCredits = _round2(lines.reduce((s, l) => s + l.credit, 0));
+    if (totalDebits !== totalCredits) {
+      throw new Error(`Journal entry does not balance \u2014 debits ${totalDebits} \u2260 credits ${totalCredits}`);
+    }
+    this._seq += 1;
+    const year = (/* @__PURE__ */ new Date()).getFullYear();
+    const ref = `JE-${year}-${String(this._seq).padStart(6, "0")}`;
+    const entry = {
+      id: _uid13(),
+      ref,
+      description,
+      date: opts.date ?? Date.now(),
+      lines: lines.map((l) => ({ ...l, debit: _round2(l.debit), credit: _round2(l.credit) })),
+      postedAt: Date.now(),
+      postedBy: opts.postedBy,
+      tags: opts.tags
+    };
+    this._entries.push(entry);
+    this._change$.next(entry);
+    return entry;
+  }
+  getEntry(id) {
+    return this._entries.find((e) => e.id === id);
+  }
+  getJournal(from, to) {
+    return this._entries.filter((e) => (from === void 0 || e.date >= from) && (to === void 0 || e.date <= to)).sort((a, b) => a.date - b.date);
+  }
+  // ── Balances ──────────────────────────────────────────────────────────────
+  getBalance(code) {
+    const acct = this._accounts.get(code);
+    if (!acct) throw new Error(`Account ${code} not found`);
+    let debits = 0;
+    let credits = 0;
+    for (const entry of this._entries) {
+      for (const line of entry.lines) {
+        if (line.accountCode === code) {
+          debits += line.debit;
+          credits += line.credit;
+        }
+      }
+    }
+    return _round2(DEBIT_NORMAL.has(acct.type) ? debits - credits : credits - debits);
+  }
+  getTrialBalance() {
+    const rows = [];
+    let totalDebits = 0;
+    let totalCredits = 0;
+    for (const acct of this._accounts.values()) {
+      let d = 0, c = 0;
+      for (const entry of this._entries) {
+        for (const line of entry.lines) {
+          if (line.accountCode === acct.code) {
+            d += line.debit;
+            c += line.credit;
+          }
+        }
+      }
+      const balance = _round2(DEBIT_NORMAL.has(acct.type) ? d - c : c - d);
+      rows.push({ code: acct.code, name: acct.name, type: acct.type, totalDebits: _round2(d), totalCredits: _round2(c), balance });
+      totalDebits += d;
+      totalCredits += c;
+    }
+    totalDebits = _round2(totalDebits);
+    totalCredits = _round2(totalCredits);
+    return { asOf: Date.now(), rows, totalDebits, totalCredits, isBalanced: totalDebits === totalCredits };
+  }
+  getBalancesByType(type) {
+    const result = {};
+    for (const acct of this._accounts.values()) {
+      if (acct.type === type) result[acct.code] = this.getBalance(acct.code);
+    }
+    return result;
+  }
+  // ── Observable ───────────────────────────────────────────────────────────
+  change$() {
+    return this._change$;
+  }
+};
+
+// src/banking/reconciliation.service.ts
+function _uid14() {
+  return `${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+}
+var JoopReconciliationService = class {
+  _sessions = /* @__PURE__ */ new Map();
+  _change$ = new JoopSubject();
+  // ── Sessions ──────────────────────────────────────────────────────────────
+  createSession(accountId, bankItems, internalItems = []) {
+    const session = {
+      id: _uid14(),
+      accountId,
+      startedAt: Date.now(),
+      internalItems: internalItems.map((i) => ({ ...i, id: _uid14(), source: "internal" })),
+      bankItems: bankItems.map((i) => ({ ...i, id: _uid14(), source: "bank" })),
+      matches: []
+    };
+    this._sessions.set(session.id, session);
+    return session;
+  }
+  getSession(id) {
+    return this._sessions.get(id);
+  }
+  closeSession(id) {
+    const s = this._get(id);
+    s.closedAt = Date.now();
+    this._change$.next(s);
+    return s;
+  }
+  addInternalItems(sessionId, items) {
+    const s = this._get(sessionId);
+    for (const item of items) s.internalItems.push({ ...item, id: _uid14(), source: "internal" });
+    this._change$.next(s);
+    return s;
+  }
+  // ── Matching ──────────────────────────────────────────────────────────────
+  autoMatch(sessionId, toleranceAmount = 0, toleranceDays = 3) {
+    const s = this._get(sessionId);
+    const matchedInternalIds = new Set(s.matches.map((m) => m.internalId));
+    const matchedBankIds = new Set(s.matches.map((m) => m.bankId));
+    const newMatches = [];
+    const dayMs = 864e5;
+    for (const intItem of s.internalItems) {
+      if (matchedInternalIds.has(intItem.id)) continue;
+      for (const bankItem of s.bankItems) {
+        if (matchedBankIds.has(bankItem.id)) continue;
+        const amountDiff = Math.abs(intItem.amount - bankItem.amount);
+        const daysDiff = Math.abs(intItem.date - bankItem.date) / dayMs;
+        if (amountDiff <= toleranceAmount && daysDiff <= toleranceDays) {
+          const match = {
+            id: _uid14(),
+            internalId: intItem.id,
+            bankId: bankItem.id,
+            matchedAt: Date.now(),
+            isManual: false,
+            difference: intItem.amount - bankItem.amount
+          };
+          s.matches.push(match);
+          matchedInternalIds.add(intItem.id);
+          matchedBankIds.add(bankItem.id);
+          newMatches.push(match);
+          break;
+        }
+      }
+    }
+    if (newMatches.length) this._change$.next(s);
+    return newMatches;
+  }
+  manualMatch(sessionId, internalId, bankId) {
+    const s = this._get(sessionId);
+    const intItem = s.internalItems.find((i) => i.id === internalId);
+    const bankItem = s.bankItems.find((i) => i.id === bankId);
+    if (!intItem) throw new Error(`Internal item ${internalId} not found`);
+    if (!bankItem) throw new Error(`Bank item ${bankId} not found`);
+    if (s.matches.some((m) => m.internalId === internalId || m.bankId === bankId)) {
+      throw new Error("One or both items are already matched");
+    }
+    const match = {
+      id: _uid14(),
+      internalId,
+      bankId,
+      matchedAt: Date.now(),
+      isManual: true,
+      difference: intItem.amount - bankItem.amount
+    };
+    s.matches.push(match);
+    this._change$.next(s);
+    return match;
+  }
+  unmatch(sessionId, matchId) {
+    const s = this._get(sessionId);
+    const idx = s.matches.findIndex((m) => m.id === matchId);
+    if (idx === -1) throw new Error(`Match ${matchId} not found`);
+    s.matches.splice(idx, 1);
+    this._change$.next(s);
+  }
+  // ── Queries ───────────────────────────────────────────────────────────────
+  getUnmatched(sessionId) {
+    const s = this._get(sessionId);
+    const matchedInternalIds = new Set(s.matches.map((m) => m.internalId));
+    const matchedBankIds = new Set(s.matches.map((m) => m.bankId));
+    return {
+      internal: s.internalItems.filter((i) => !matchedInternalIds.has(i.id)),
+      bank: s.bankItems.filter((i) => !matchedBankIds.has(i.id))
+    };
+  }
+  getSummary(sessionId) {
+    const s = this._get(sessionId);
+    const unmatched = this.getUnmatched(sessionId);
+    const totalDifference = s.matches.reduce((sum, m) => sum + m.difference, 0);
+    return {
+      sessionId,
+      totalInternal: s.internalItems.length,
+      totalBank: s.bankItems.length,
+      matchedPairs: s.matches.length,
+      unmatchedInternal: unmatched.internal.length,
+      unmatchedBank: unmatched.bank.length,
+      totalDifference: Math.round(totalDifference * 100) / 100,
+      isReconciled: unmatched.internal.length === 0 && unmatched.bank.length === 0
+    };
+  }
+  // ── Observable ───────────────────────────────────────────────────────────
+  change$() {
+    return this._change$;
+  }
+  _get(id) {
+    const s = this._sessions.get(id);
+    if (!s) throw new Error(`Reconciliation session ${id} not found`);
+    return s;
+  }
+};
+
+// src/banking/limit-management.service.ts
+function _uid15() {
+  return `${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+}
+function _periodStart(type, now) {
+  const d = new Date(now);
+  switch (type) {
+    case "per-transaction":
+      return 0;
+    // always fresh
+    case "daily":
+      return new Date(d.getFullYear(), d.getMonth(), d.getDate()).getTime();
+    case "weekly": {
+      const day = d.getDay();
+      const mon = new Date(d.getFullYear(), d.getMonth(), d.getDate() - (day + 6) % 7);
+      return mon.getTime();
+    }
+    case "monthly":
+      return new Date(d.getFullYear(), d.getMonth(), 1).getTime();
+    case "yearly":
+      return new Date(d.getFullYear(), 0, 1).getTime();
+  }
+}
+var JoopLimitManagementService = class {
+  _limits = /* @__PURE__ */ new Map();
+  _usage = [];
+  _change$ = new JoopSubject();
+  // ── Limit CRUD ────────────────────────────────────────────────────────────
+  setLimit(scope, scopeId, type, maxAmount, currency = "USD", notes) {
+    if (maxAmount <= 0) throw new Error("maxAmount must be positive");
+    const existing = this._findLimit(scope, scopeId, type, currency);
+    if (existing) {
+      existing.maxAmount = maxAmount;
+      existing.notes = notes;
+      this._change$.next(existing);
+      return existing;
+    }
+    const limit = {
+      id: _uid15(),
+      scope,
+      scopeId,
+      type,
+      maxAmount,
+      currency,
+      enabled: true,
+      createdAt: Date.now(),
+      notes
+    };
+    this._limits.set(limit.id, limit);
+    this._change$.next(limit);
+    return limit;
+  }
+  getLimit(id) {
+    return this._limits.get(id);
+  }
+  getLimits(scope, scopeId) {
+    return Array.from(this._limits.values()).filter(
+      (l) => (scope === void 0 || l.scope === scope) && (scopeId === void 0 || l.scopeId === scopeId)
+    );
+  }
+  removeLimit(limitId) {
+    if (!this._limits.has(limitId)) throw new Error(`Limit ${limitId} not found`);
+    this._limits.delete(limitId);
+    this._usage = this._usage.filter((u) => u.limitId !== limitId);
+  }
+  enableLimit(limitId) {
+    this._toggle(limitId, true);
+  }
+  disableLimit(limitId) {
+    this._toggle(limitId, false);
+  }
+  // ── Check & Record ────────────────────────────────────────────────────────
+  checkLimit(scope, scopeId, type, amount, currency = "USD") {
+    const limit = this._findLimit(scope, scopeId, type, currency);
+    if (!limit || !limit.enabled) return null;
+    const usage = this._currentUsage(limit, Date.now());
+    const remaining = Math.max(0, limit.maxAmount - usage);
+    const allowed = amount <= remaining;
+    return {
+      allowed,
+      limit,
+      currentUsage: usage,
+      remaining,
+      requestedAmount: amount,
+      reason: allowed ? void 0 : `${type} limit of ${limit.maxAmount} ${currency} exceeded (used: ${usage})`
+    };
+  }
+  checkAllLimits(scope, scopeId, amount, currency = "USD") {
+    const results = [];
+    for (const limit of this._limits.values()) {
+      if (limit.scope === scope && limit.scopeId === scopeId && limit.currency === currency && limit.enabled) {
+        const check = this.checkLimit(scope, scopeId, limit.type, amount, currency);
+        if (check) results.push(check);
+      }
+    }
+    return results;
+  }
+  recordUsage(scope, scopeId, type, amount, currency = "USD", reference) {
+    const limit = this._findLimit(scope, scopeId, type, currency);
+    if (!limit) return;
+    this._usage.push({ limitId: limit.id, amount, recordedAt: Date.now(), reference });
+  }
+  resetUsage(limitId) {
+    this._usage = this._usage.filter((u) => u.limitId !== limitId);
+  }
+  getUsageSummary(scope, scopeId) {
+    const limits = this.getLimits(scope, scopeId);
+    const now = Date.now();
+    return {
+      scope,
+      scopeId,
+      limits: limits.map((l) => {
+        const used = this._currentUsage(l, now);
+        const remaining = Math.max(0, l.maxAmount - used);
+        return {
+          limitId: l.id,
+          type: l.type,
+          maxAmount: l.maxAmount,
+          used,
+          remaining,
+          utilizationPercent: Math.round(used / l.maxAmount * 100 * 100) / 100
+        };
+      })
+    };
+  }
+  // ── Observable ───────────────────────────────────────────────────────────
+  change$() {
+    return this._change$;
+  }
+  _findLimit(scope, scopeId, type, currency) {
+    for (const l of this._limits.values()) {
+      if (l.scope === scope && l.scopeId === scopeId && l.type === type && l.currency === currency) return l;
+    }
+    return void 0;
+  }
+  _currentUsage(limit, now) {
+    if (limit.type === "per-transaction") return 0;
+    const periodStart = _periodStart(limit.type, now);
+    return this._usage.filter((u) => u.limitId === limit.id && u.recordedAt >= periodStart).reduce((s, u) => s + u.amount, 0);
+  }
+  _toggle(limitId, enabled) {
+    const l = this._limits.get(limitId);
+    if (!l) throw new Error(`Limit ${limitId} not found`);
+    l.enabled = enabled;
+    this._change$.next(l);
+  }
+};
+
+// src/banking/standing-order.service.ts
+function _uid16() {
+  return `${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+}
+function _computeNextDate(current, frequency) {
+  const d = new Date(current);
+  switch (frequency) {
+    case "daily":
+      d.setDate(d.getDate() + 1);
+      break;
+    case "weekly":
+      d.setDate(d.getDate() + 7);
+      break;
+    case "biweekly":
+      d.setDate(d.getDate() + 14);
+      break;
+    case "monthly":
+      d.setMonth(d.getMonth() + 1);
+      break;
+    case "quarterly":
+      d.setMonth(d.getMonth() + 3);
+      break;
+    case "half-yearly":
+      d.setMonth(d.getMonth() + 6);
+      break;
+    case "yearly":
+      d.setFullYear(d.getFullYear() + 1);
+      break;
+  }
+  return d.getTime();
+}
+var JoopStandingOrderService = class {
+  _orders = [];
+  _executions = [];
+  _seq = 0;
+  _change$ = new JoopSubject();
+  // ── CRUD ──────────────────────────────────────────────────────────────────
+  create(params) {
+    if (params.amount <= 0) throw new Error("amount must be positive");
+    if (!params.fromAccount.trim()) throw new Error("fromAccount required");
+    if (!params.toAccount.trim()) throw new Error("toAccount required");
+    if (params.endDate !== void 0 && params.endDate <= params.startDate) {
+      throw new Error("endDate must be after startDate");
+    }
+    this._seq += 1;
+    const year = (/* @__PURE__ */ new Date()).getFullYear();
+    const ref = `SO-${year}-${String(this._seq).padStart(6, "0")}`;
+    const order = {
+      id: _uid16(),
+      ref,
+      fromAccount: params.fromAccount,
+      toAccount: params.toAccount,
+      toBeneficiaryName: params.toBeneficiaryName,
+      amount: params.amount,
+      currency: params.currency ?? "USD",
+      frequency: params.frequency,
+      startDate: params.startDate,
+      endDate: params.endDate,
+      status: "active",
+      nextExecutionAt: params.startDate,
+      executionCount: 0,
+      maxExecutions: params.maxExecutions,
+      reference: params.reference,
+      notes: params.notes,
+      createdAt: Date.now()
+    };
+    this._orders.push(order);
+    this._change$.next(order);
+    return order;
+  }
+  update(id, patch) {
+    const o = this._get(id);
+    if (patch.amount !== void 0 && patch.amount <= 0) throw new Error("amount must be positive");
+    Object.assign(o, patch);
+    this._change$.next(o);
+    return o;
+  }
+  // ── Lifecycle ─────────────────────────────────────────────────────────────
+  pause(id) {
+    const o = this._get(id);
+    if (o.status !== "active") throw new Error(`Cannot pause order with status ${o.status}`);
+    o.status = "paused";
+    this._change$.next(o);
+    return o;
+  }
+  resume(id) {
+    const o = this._get(id);
+    if (o.status !== "paused") throw new Error(`Cannot resume order with status ${o.status}`);
+    o.status = "active";
+    this._change$.next(o);
+    return o;
+  }
+  cancel(id) {
+    const o = this._get(id);
+    if (o.status === "cancelled") throw new Error("Order is already cancelled");
+    o.status = "cancelled";
+    this._change$.next(o);
+    return o;
+  }
+  // ── Execution ─────────────────────────────────────────────────────────────
+  execute(id, status = "success", opts = {}) {
+    const o = this._get(id);
+    if (o.status !== "active") throw new Error(`Cannot execute order with status ${o.status}`);
+    const exec = {
+      id: _uid16(),
+      orderId: id,
+      executedAt: Date.now(),
+      amount: o.amount,
+      currency: o.currency,
+      status,
+      failureReason: opts.failureReason,
+      transactionRef: opts.transactionRef
+    };
+    this._executions.push(exec);
+    if (status === "success") {
+      o.executionCount += 1;
+      const next = _computeNextDate(o.nextExecutionAt ?? Date.now(), o.frequency);
+      if (o.endDate && next > o.endDate || o.maxExecutions && o.executionCount >= o.maxExecutions) {
+        o.status = "completed";
+        o.nextExecutionAt = void 0;
+      } else {
+        o.nextExecutionAt = next;
+      }
+    }
+    this._change$.next(o);
+    return exec;
+  }
+  // ── Queries ───────────────────────────────────────────────────────────────
+  get(id) {
+    return this._orders.find((o) => o.id === id);
+  }
+  getAll() {
+    return [...this._orders];
+  }
+  getActive() {
+    return this._orders.filter((o) => o.status === "active");
+  }
+  getByAccount(accountId) {
+    return this._orders.filter((o) => o.fromAccount === accountId || o.toAccount === accountId);
+  }
+  getDue(asOf = Date.now()) {
+    return this._orders.filter((o) => o.status === "active" && o.nextExecutionAt !== void 0 && o.nextExecutionAt <= asOf);
+  }
+  getExecutions(orderId) {
+    return this._executions.filter((e) => e.orderId === orderId);
+  }
+  // ── Observable ───────────────────────────────────────────────────────────
+  change$() {
+    return this._change$;
+  }
+  _get(id) {
+    const o = this._orders.find((x) => x.id === id);
+    if (!o) throw new Error(`Standing order ${id} not found`);
+    return o;
+  }
+};
+
+// src/banking/loan-servicing.service.ts
+function _uid17() {
+  return `${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+}
+function _round3(n, dp = 2) {
+  return Math.round(n * 10 ** dp) / 10 ** dp;
+}
+function _addMonths(ts, months) {
+  const d = new Date(ts);
+  d.setMonth(d.getMonth() + months);
+  return d.getTime();
+}
+function _calcEmi(principal, annualRate, tenureMonths) {
+  if (annualRate === 0) return _round3(principal / tenureMonths);
+  const r = annualRate / 100 / 12;
+  return _round3(principal * r * Math.pow(1 + r, tenureMonths) / (Math.pow(1 + r, tenureMonths) - 1));
+}
+function _buildSchedule(loanId, principal, annualRate, tenureMonths, startDate, emi) {
+  const schedule = [];
+  let outstanding = principal;
+  const r = annualRate / 100 / 12;
+  for (let i = 1; i <= tenureMonths; i++) {
+    const interest = _round3(outstanding * r);
+    const principalC = i < tenureMonths ? _round3(emi - interest) : _round3(outstanding);
+    const total = _round3(interest + principalC);
+    outstanding = _round3(outstanding - principalC);
+    if (outstanding < 0) outstanding = 0;
+    schedule.push({
+      installmentNumber: i,
+      dueDate: _addMonths(startDate, i),
+      principalComponent: principalC,
+      interestComponent: interest,
+      totalDue: total,
+      outstandingAfter: outstanding,
+      status: "pending",
+      paidAmount: 0
+    });
+  }
+  return schedule;
+}
+var JoopLoanServicingService = class {
+  _loans = [];
+  _schedules = /* @__PURE__ */ new Map();
+  _payments = /* @__PURE__ */ new Map();
+  _seq = 0;
+  _change$ = new JoopSubject();
+  // ── Create ────────────────────────────────────────────────────────────────
+  createLoan(params) {
+    if (params.principalAmount <= 0) throw new Error("principalAmount must be positive");
+    if (params.annualInterestRatePercent < 0) throw new Error("annualInterestRatePercent must be non-negative");
+    if (params.tenureMonths <= 0) throw new Error("tenureMonths must be positive");
+    this._seq += 1;
+    const year = (/* @__PURE__ */ new Date()).getFullYear();
+    const ref = `LN-${year}-${String(this._seq).padStart(6, "0")}`;
+    const disbursedAt = params.disbursedAt ?? Date.now();
+    const emi = _calcEmi(params.principalAmount, params.annualInterestRatePercent, params.tenureMonths);
+    const loan = {
+      id: _uid17(),
+      ref,
+      borrowerName: params.borrowerName,
+      borrowerId: params.borrowerId,
+      principalAmount: params.principalAmount,
+      outstandingPrincipal: params.principalAmount,
+      annualInterestRatePercent: params.annualInterestRatePercent,
+      tenureMonths: params.tenureMonths,
+      disbursedAt,
+      status: "active",
+      emiAmount: emi,
+      currency: params.currency ?? "USD",
+      nextDueDate: _addMonths(disbursedAt, 1),
+      totalPaid: 0,
+      penaltyRatePercent: params.penaltyRatePercent ?? 2,
+      notes: params.notes
+    };
+    this._loans.push(loan);
+    this._schedules.set(loan.id, _buildSchedule(loan.id, params.principalAmount, params.annualInterestRatePercent, params.tenureMonths, disbursedAt, emi));
+    this._payments.set(loan.id, []);
+    this._change$.next(loan);
+    return loan;
+  }
+  // ── Payments ──────────────────────────────────────────────────────────────
+  recordPayment(loanId, amount, opts = {}) {
+    const loan = this._get(loanId);
+    if (loan.status !== "active") throw new Error(`Cannot record payment on loan with status ${loan.status}`);
+    if (amount <= 0) throw new Error("amount must be positive");
+    const schedule = this._schedules.get(loanId);
+    const paidAt = opts.paidAt ?? Date.now();
+    let remaining = amount;
+    let interestPaid = 0;
+    let principalPaid = 0;
+    for (const inst of schedule) {
+      if (remaining <= 0) break;
+      if (inst.status === "paid" || inst.status === "waived") continue;
+      const owed = _round3(inst.totalDue - inst.paidAmount);
+      const apply = Math.min(remaining, owed);
+      const instTotal = inst.interestComponent + inst.principalComponent;
+      const intShare = instTotal > 0 ? _round3(apply * (inst.interestComponent / instTotal)) : 0;
+      const priShare = _round3(apply - intShare);
+      interestPaid += intShare;
+      principalPaid += priShare;
+      inst.paidAmount = _round3(inst.paidAmount + apply);
+      remaining = _round3(remaining - apply);
+      if (Math.abs(inst.paidAmount - inst.totalDue) < 0.01) {
+        inst.status = "paid";
+        inst.paidAt = paidAt;
+      } else {
+        inst.status = "partial";
+      }
+    }
+    if (remaining > 0) {
+      principalPaid += remaining;
+      remaining = 0;
+    }
+    interestPaid = _round3(interestPaid);
+    principalPaid = _round3(principalPaid);
+    loan.outstandingPrincipal = _round3(loan.outstandingPrincipal - principalPaid);
+    if (loan.outstandingPrincipal < 0) loan.outstandingPrincipal = 0;
+    loan.totalPaid = _round3(loan.totalPaid + amount);
+    const nextPending = schedule.find((i) => i.status !== "paid" && i.status !== "waived");
+    loan.nextDueDate = nextPending?.dueDate ?? loan.nextDueDate;
+    if (loan.outstandingPrincipal === 0) {
+      loan.status = "closed";
+    }
+    const payment = {
+      id: _uid17(),
+      loanId,
+      amount,
+      paidAt,
+      interestPaid,
+      principalPaid,
+      penaltyPaid: 0,
+      reference: opts.reference
+    };
+    this._payments.get(loanId).push(payment);
+    this._change$.next(loan);
+    return payment;
+  }
+  waveInstallment(loanId, installmentNumber) {
+    const schedule = this._schedules.get(loanId);
+    if (!schedule) throw new Error(`Loan ${loanId} not found`);
+    const inst = schedule.find((i) => i.installmentNumber === installmentNumber);
+    if (!inst) throw new Error(`Installment ${installmentNumber} not found`);
+    inst.status = "waived";
+    inst.paidAt = Date.now();
+  }
+  markDefaulted(loanId) {
+    const loan = this._get(loanId);
+    if (loan.status !== "active") throw new Error(`Loan is not active`);
+    loan.status = "defaulted";
+    this._change$.next(loan);
+    return loan;
+  }
+  // ── Queries ───────────────────────────────────────────────────────────────
+  getLoan(id) {
+    return this._loans.find((l) => l.id === id);
+  }
+  getAll() {
+    return [...this._loans];
+  }
+  getActive() {
+    return this._loans.filter((l) => l.status === "active");
+  }
+  getByBorrower(borrowerId) {
+    return this._loans.filter((l) => l.borrowerId === borrowerId);
+  }
+  getSchedule(loanId) {
+    return this._schedules.get(loanId) ?? [];
+  }
+  getPendingInstallments(loanId) {
+    this._markOverdue(loanId);
+    return (this._schedules.get(loanId) ?? []).filter((i) => i.status !== "paid" && i.status !== "waived");
+  }
+  getOverdueInstallments(loanId) {
+    this._markOverdue(loanId);
+    return (this._schedules.get(loanId) ?? []).filter((i) => i.status === "overdue");
+  }
+  getOutstandingBalance(loanId) {
+    return this._get(loanId).outstandingPrincipal;
+  }
+  getAccruedInterest(loanId, asOf = Date.now()) {
+    const loan = this._get(loanId);
+    const daysSinceDue = Math.max(0, (asOf - loan.nextDueDate) / 864e5);
+    if (daysSinceDue <= 0) return 0;
+    return _round3(loan.outstandingPrincipal * (loan.annualInterestRatePercent / 100 / 365) * daysSinceDue);
+  }
+  getLoanStatement(loanId) {
+    const loan = this._get(loanId);
+    const schedule = this._schedules.get(loanId);
+    const payments = this._payments.get(loanId);
+    this._markOverdue(loanId);
+    const totalOverdue = schedule.filter((i) => i.status === "overdue").reduce((s, i) => s + _round3(i.totalDue - i.paidAmount), 0);
+    return {
+      loan,
+      schedule,
+      payments,
+      outstandingPrincipal: loan.outstandingPrincipal,
+      accruedInterest: this.getAccruedInterest(loanId),
+      totalOverdue: _round3(totalOverdue)
+    };
+  }
+  // ── Observable ───────────────────────────────────────────────────────────
+  change$() {
+    return this._change$;
+  }
+  _get(id) {
+    const l = this._loans.find((x) => x.id === id);
+    if (!l) throw new Error(`Loan ${id} not found`);
+    return l;
+  }
+  _markOverdue(loanId) {
+    const now = Date.now();
+    const schedule = this._schedules.get(loanId);
+    if (!schedule) return;
+    for (const inst of schedule) {
+      if ((inst.status === "pending" || inst.status === "partial") && inst.dueDate < now) {
+        inst.status = "overdue";
+      }
+    }
+  }
+};
+
+// src/banking/digital-wallet.service.ts
+function _uid18() {
+  return `${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+}
+function _round4(n) {
+  return Math.round(n * 100) / 100;
+}
+var JoopDigitalWalletService = class {
+  _wallets = /* @__PURE__ */ new Map();
+  _transactions = [];
+  _balance$ = new JoopBehaviorSubject(null);
+  // ── Wallet lifecycle ──────────────────────────────────────────────────────
+  createWallet(userId, opts = {}) {
+    const wallet = {
+      id: _uid18(),
+      userId,
+      label: opts.label,
+      currency: opts.currency ?? "USD",
+      balance: 0,
+      status: "active",
+      createdAt: Date.now(),
+      dailyLimit: opts.dailyLimit,
+      monthlyLimit: opts.monthlyLimit
+    };
+    this._wallets.set(wallet.id, wallet);
+    return wallet;
+  }
+  freeze(walletId) {
+    const w = this._getActive(walletId);
+    w.status = "frozen";
+    return w;
+  }
+  unfreeze(walletId) {
+    const w = this._get(walletId);
+    if (w.status === "closed") throw new Error("Cannot unfreeze a closed wallet");
+    w.status = "active";
+    return w;
+  }
+  close(walletId) {
+    const w = this._get(walletId);
+    if (w.status === "closed") throw new Error("Wallet already closed");
+    if (w.balance > 0) throw new Error("Cannot close wallet with positive balance \u2014 withdraw funds first");
+    w.status = "closed";
+    return w;
+  }
+  updateLimits(walletId, limits) {
+    const w = this._get(walletId);
+    if (limits.dailyLimit !== void 0) w.dailyLimit = limits.dailyLimit;
+    if (limits.monthlyLimit !== void 0) w.monthlyLimit = limits.monthlyLimit;
+    return w;
+  }
+  // ── Funds ─────────────────────────────────────────────────────────────────
+  topUp(walletId, amount, opts = {}) {
+    if (amount <= 0) throw new Error("amount must be positive");
+    const w = this._getActive(walletId);
+    return this._record(w, "topup", amount, opts.description ?? "Top-up", opts.reference);
+  }
+  withdraw(walletId, amount, opts = {}) {
+    if (amount <= 0) throw new Error("amount must be positive");
+    const w = this._getActive(walletId);
+    this._assertSufficientBalance(w, amount);
+    return this._record(w, "withdrawal", -amount, opts.description ?? "Withdrawal", opts.reference);
+  }
+  pay(walletId, amount, merchantId, merchantName, opts = {}) {
+    if (amount <= 0) throw new Error("amount must be positive");
+    const w = this._getActive(walletId);
+    this._assertSufficientBalance(w, amount);
+    const txn = this._record(w, "payment", -amount, `Payment to ${merchantName}`, opts.reference);
+    txn.counterpartyId = merchantId;
+    txn.counterpartyName = merchantName;
+    if (opts.metadata) txn.metadata = opts.metadata;
+    return txn;
+  }
+  transfer(fromWalletId, toWalletId, amount, opts = {}) {
+    if (amount <= 0) throw new Error("amount must be positive");
+    if (fromWalletId === toWalletId) throw new Error("Cannot transfer to the same wallet");
+    const from = this._getActive(fromWalletId);
+    const to = this._getActive(toWalletId);
+    this._assertSufficientBalance(from, amount);
+    if (from.currency !== to.currency) throw new Error("Cross-currency transfers not supported \u2014 use FX service");
+    const fromTxn = this._record(from, "transfer-out", -amount, opts.note ?? `Transfer to ${to.userId}`, opts.reference);
+    fromTxn.counterpartyId = toWalletId;
+    const toTxn = this._record(to, "transfer-in", amount, opts.note ?? `Transfer from ${from.userId}`, opts.reference);
+    toTxn.counterpartyId = fromWalletId;
+    return { fromTxn, toTxn };
+  }
+  refund(originalTxnId, opts = {}) {
+    const original = this._transactions.find((t) => t.id === originalTxnId);
+    if (!original) throw new Error(`Transaction ${originalTxnId} not found`);
+    if (original.type !== "payment") throw new Error("Can only refund payment transactions");
+    const w = this._getActive(original.walletId);
+    const amount = opts.amount ?? Math.abs(original.amount);
+    if (amount > Math.abs(original.amount)) throw new Error("Refund exceeds original payment amount");
+    return this._record(w, "refund", amount, opts.reason ?? `Refund for ${originalTxnId}`, originalTxnId);
+  }
+  // ── Queries ───────────────────────────────────────────────────────────────
+  getWallet(id) {
+    return this._wallets.get(id);
+  }
+  getWalletsByUser(userId) {
+    return Array.from(this._wallets.values()).filter((w) => w.userId === userId);
+  }
+  getBalance(walletId) {
+    return this._get(walletId).balance;
+  }
+  getTransactions(walletId, limit) {
+    const all = this._transactions.filter((t) => t.walletId === walletId).sort((a, b) => b.createdAt - a.createdAt);
+    return limit ? all.slice(0, limit) : all;
+  }
+  getTotalSpent(walletId, from, to) {
+    return _round4(
+      this._transactions.filter((t) => t.walletId === walletId && t.type === "payment" && (from === void 0 || t.createdAt >= from) && (to === void 0 || t.createdAt <= to)).reduce((s, t) => s + Math.abs(t.amount), 0)
+    );
+  }
+  getTotalTopUp(walletId) {
+    return _round4(
+      this._transactions.filter((t) => t.walletId === walletId && t.type === "topup").reduce((s, t) => s + t.amount, 0)
+    );
+  }
+  // ── Observable ───────────────────────────────────────────────────────────
+  balance$() {
+    return this._balance$;
+  }
+  // ── Private ───────────────────────────────────────────────────────────────
+  _get(id) {
+    const w = this._wallets.get(id);
+    if (!w) throw new Error(`Wallet ${id} not found`);
+    return w;
+  }
+  _getActive(id) {
+    const w = this._get(id);
+    if (w.status !== "active") throw new Error(`Wallet is ${w.status}`);
+    return w;
+  }
+  _assertSufficientBalance(w, amount) {
+    if (w.balance < amount) throw new Error(`Insufficient balance \u2014 available: ${w.balance}, requested: ${amount}`);
+  }
+  _record(w, type, amount, description, reference) {
+    const balanceBefore = w.balance;
+    w.balance = _round4(w.balance + amount);
+    const txn = {
+      id: _uid18(),
+      walletId: w.id,
+      type,
+      amount,
+      balanceBefore,
+      balanceAfter: w.balance,
+      description,
+      reference,
+      createdAt: Date.now()
+    };
+    this._transactions.push(txn);
+    this._balance$.next({ walletId: w.id, balance: w.balance });
+    return txn;
+  }
+};
+
+// src/banking/fx-forward.service.ts
+function _uid19() {
+  return `${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+}
+function _round5(n, dp = 4) {
+  return Math.round(n * 10 ** dp) / 10 ** dp;
+}
+var JoopFxForwardService = class {
+  _forwards = [];
+  _settlements = [];
+  _spotRates = /* @__PURE__ */ new Map();
+  _seq = 0;
+  _change$ = new JoopSubject();
+  // ── Spot rates ────────────────────────────────────────────────────────────
+  setSpotRate(baseCurrency, quoteCurrency, rate) {
+    if (rate <= 0) throw new Error("rate must be positive");
+    this._spotRates.set(`${baseCurrency}:${quoteCurrency}`, rate);
+    this._spotRates.set(`${quoteCurrency}:${baseCurrency}`, _round5(1 / rate));
+  }
+  getSpotRate(baseCurrency, quoteCurrency) {
+    if (baseCurrency === quoteCurrency) return 1;
+    return this._spotRates.get(`${baseCurrency}:${quoteCurrency}`);
+  }
+  // ── Forward contracts ─────────────────────────────────────────────────────
+  createForward(params) {
+    if (params.notionalAmount <= 0) throw new Error("notionalAmount must be positive");
+    if (params.contractRate <= 0) throw new Error("contractRate must be positive");
+    if (params.maturityDate <= Date.now()) throw new Error("maturityDate must be in the future");
+    const spotRate = this.getSpotRate(params.baseCurrency, params.quoteCurrency) ?? params.contractRate;
+    this._seq += 1;
+    const year = (/* @__PURE__ */ new Date()).getFullYear();
+    const ref = `FWD-${year}-${String(this._seq).padStart(6, "0")}`;
+    const forward = {
+      id: _uid19(),
+      ref,
+      type: params.type,
+      baseCurrency: params.baseCurrency,
+      quoteCurrency: params.quoteCurrency,
+      notionalAmount: params.notionalAmount,
+      contractRate: params.contractRate,
+      spotRateAtCreation: spotRate,
+      maturityDate: params.maturityDate,
+      status: "open",
+      counterpartyId: params.counterpartyId,
+      counterpartyName: params.counterpartyName,
+      createdAt: Date.now(),
+      notes: params.notes
+    };
+    this._forwards.push(forward);
+    this._change$.next(forward);
+    return forward;
+  }
+  settleForward(id, spotRate) {
+    const fwd = this._get(id);
+    if (fwd.status !== "open") throw new Error(`Cannot settle forward with status ${fwd.status}`);
+    const rate = spotRate ?? this.getSpotRate(fwd.baseCurrency, fwd.quoteCurrency) ?? fwd.contractRate;
+    const pnl = fwd.type === "sell" ? _round5((fwd.contractRate - rate) * fwd.notionalAmount, 2) : _round5((rate - fwd.contractRate) * fwd.notionalAmount, 2);
+    fwd.status = "settled";
+    fwd.settledAt = Date.now();
+    fwd.settlementSpotRate = rate;
+    fwd.pnl = pnl;
+    const settlement = {
+      forwardId: id,
+      ref: fwd.ref,
+      settledAt: fwd.settledAt,
+      contractRate: fwd.contractRate,
+      spotRate: rate,
+      notionalAmount: fwd.notionalAmount,
+      baseCurrency: fwd.baseCurrency,
+      quoteCurrency: fwd.quoteCurrency,
+      pnl
+    };
+    this._settlements.push(settlement);
+    this._change$.next(fwd);
+    return settlement;
+  }
+  cancelForward(id, notes) {
+    const fwd = this._get(id);
+    if (fwd.status !== "open") throw new Error(`Cannot cancel forward with status ${fwd.status}`);
+    fwd.status = "cancelled";
+    if (notes) fwd.notes = notes;
+    this._change$.next(fwd);
+    return fwd;
+  }
+  expireForward(id) {
+    const fwd = this._get(id);
+    if (fwd.status !== "open") throw new Error(`Cannot expire forward with status ${fwd.status}`);
+    if (fwd.maturityDate > Date.now()) throw new Error("Forward has not yet matured");
+    fwd.status = "expired";
+    this._change$.next(fwd);
+    return fwd;
+  }
+  // ── Queries ───────────────────────────────────────────────────────────────
+  get(id) {
+    return this._forwards.find((f) => f.id === id);
+  }
+  getAll(status) {
+    return status ? this._forwards.filter((f) => f.status === status) : [...this._forwards];
+  }
+  getExpiring(withinMs, asOf = Date.now()) {
+    return this._forwards.filter((f) => f.status === "open" && f.maturityDate <= asOf + withinMs && f.maturityDate > asOf);
+  }
+  getSettlements() {
+    return [...this._settlements];
+  }
+  getSettlement(forwardId) {
+    return this._settlements.find((s) => s.forwardId === forwardId);
+  }
+  getExposure(currency, type) {
+    const open = this._forwards.filter(
+      (f) => f.status === "open" && (f.baseCurrency === currency || f.quoteCurrency === currency) && (type === void 0 || f.type === type)
+    );
+    const map = /* @__PURE__ */ new Map();
+    for (const f of open) {
+      const key = `${currency}:${f.type}`;
+      const cur = map.get(key) ?? { currency, type: f.type, totalNotional: 0, contractCount: 0 };
+      cur.totalNotional += f.notionalAmount;
+      cur.contractCount += 1;
+      map.set(key, cur);
+    }
+    return Array.from(map.values());
+  }
+  getTotalPnL() {
+    return _round5(this._settlements.reduce((s, settlement) => s + settlement.pnl, 0), 2);
+  }
+  getMarkToMarket(id) {
+    const fwd = this._get(id);
+    if (fwd.status !== "open") return fwd.pnl ?? 0;
+    const spot = this.getSpotRate(fwd.baseCurrency, fwd.quoteCurrency) ?? fwd.contractRate;
+    return fwd.type === "sell" ? _round5((fwd.contractRate - spot) * fwd.notionalAmount, 2) : _round5((spot - fwd.contractRate) * fwd.notionalAmount, 2);
+  }
+  // ── Observable ───────────────────────────────────────────────────────────
+  change$() {
+    return this._change$;
+  }
+  _get(id) {
+    const f = this._forwards.find((x) => x.id === id);
+    if (!f) throw new Error(`Forward ${id} not found`);
+    return f;
+  }
+};
+
+export { JoopBeneficiaryService, JoopBillPaymentService, JoopCardManagementService, JoopChequebookService, JoopDigitalWalletService, JoopDisputeService, JoopFraudDetection, JoopFxForwardService, JoopInsuranceService, JoopLedgerService, JoopLimitManagementService, JoopLoanServicingService, JoopMandateService, JoopNotificationCenterService, JoopOpenBankingClient, JoopPaymentOrchestrator, JoopPaymentUriService, JoopReceiptService, JoopReconciliationService, JoopRemittanceService, JoopScheduledPaymentService, JoopSplitPaymentService, JoopStandingOrderService, JoopStatementGeneratorService, JoopStatementParser, JoopVirtualAccountService, clampAmount, convertCurrency, formatAmount, formatCard, formatCardNumber, formatCurrency, formatIban, formatMyKad, fromMinorUnits, generateBatchId, generateReferenceNumber, generateTransactionId, getCardInfo, getCardNetwork, getCurrencySymbol, getIbanCountry, getSupportedIbanCountries, isCardExpired, isValidAmount, isValidTransactionId, luhnCheckDigit, maskAccountNumber, maskCard, maskEmail, maskIban, maskInterleaved, maskKeepMiddle, maskKeepSeparators, maskMyKad, maskName, maskNric, maskPattern, maskPhone, maskRange, maskShowFirst, maskShowLast, parseCurrencyString, parseIban, parseTransactionId, roundAmount, safeAdd, safeDivide, safeMultiply, safeSubtract, sumAmounts, toMinorUnits, validateCvv, validateIban, validateLuhn, validateMyKad, validateNric };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map