@holoscript/plugin-insurance 2.0.1 → 2.0.2

package/src/actuarial.ts

@@ -15,28 +15,25 @@
  *   London, D. "Survival Models and Their Estimation" (3rd ed., 1997).
  */
 
-import {
-  DOMAIN_SIMULATION_RECEIPT_SCHEMA,
-  buildDomainSimulationReceipt,
-} from '@holoscript/core';
+import { DOMAIN_SIMULATION_RECEIPT_SCHEMA, buildDomainSimulationReceipt } from '@holoscript/core';
 
 // ─── Types ────────────────────────────────────────────────────────────────────
 
 /** One row of a standard life table (age x). */
 export interface LifeTableRow {
-  age:    number; // x  — integer age
-  qx:     number; // probability of death between age x and x+1
-  lx:     number; // number of survivors at age x (radix l₀ = 100 000)
-  dx:     number; // deaths between x and x+1
-  Lx:     number; // person-years lived between x and x+1
-  Tx:     number; // total person-years lived above age x
-  ex:     number; // curtate life expectancy at age x
+  age: number; // x  — integer age
+  qx: number; // probability of death between age x and x+1
+  lx: number; // number of survivors at age x (radix l₀ = 100 000)
+  dx: number; // deaths between x and x+1
+  Lx: number; // person-years lived between x and x+1
+  Tx: number; // total person-years lived above age x
+  ex: number; // curtate life expectancy at age x
 }
 
 /** Abridged model life table — minimum required: age 0 through at least age 100. */
 export interface LifeTable {
-  id:    string;
-  rows:  LifeTableRow[];
+  id: string;
+  rows: LifeTableRow[];
   /** Annual effective interest rate (e.g. 0.05 = 5%) */
   interestRate: number;
 }
@@ -44,63 +41,63 @@ export interface LifeTable {
 export type PolicyType = 'whole_life' | 'term_life' | 'endowment' | 'annuity_due';
 
 export interface PolicySpec {
-  type:          PolicyType;
-  issueAge:      number;  // age at policy issue
-  termYears?:    number;  // required for term_life and endowment
-  benefitAmount: number;  // face amount (currency units)
+  type: PolicyType;
+  issueAge: number; // age at policy issue
+  termYears?: number; // required for term_life and endowment
+  benefitAmount: number; // face amount (currency units)
   /** Annual effective interest rate override; falls back to table default */
   interestRate?: number;
 }
 
 export interface ActuarialResult {
   /** Net Single Premium — expected present value of benefits */
-  nsp:           number;
+  nsp: number;
   /** Level annual premium (equivalence principle) */
   annualPremium: number;
   /** Curtate life expectancy at issue age */
   lifeExpectancy: number;
   /** Present value of an annuity-due of 1 per year at issue age */
-  annuityDue:    number;
+  annuityDue: number;
   /** Policy type */
-  policyType:    PolicyType;
-  issueAge:      number;
-  termYears:     number | null;
+  policyType: PolicyType;
+  issueAge: number;
+  termYears: number | null;
 }
 
 export interface CashFlow {
   /** Period index (0-based; typically year number) */
-  period:    number;
+  period: number;
   /** Cash inflow (+) or outflow (−) */
-  amount:    number;
+  amount: number;
 }
 
 export interface NPVResult {
-  npv:          number;
-  irr:          number | null; // null if no real IRR found in 0–200% range
+  npv: number;
+  irr: number | null; // null if no real IRR found in 0–200% range
   paybackPeriod: number | null; // period where cumulative CF first ≥ 0
 }
 
 export interface VaRResult {
-  confidenceLevel: number;  // e.g. 0.95
-  var95:           number;  // VaR at 95%
-  var99:           number;  // VaR at 99%
-  cvar95:          number;  // CVaR (expected shortfall) at 95%
-  cvar99:          number;  // CVaR at 99%
-  expectedLoss:    number;
-  maxLoss:         number;
-  sampleSize:      number;
+  confidenceLevel: number; // e.g. 0.95
+  var95: number; // VaR at 95%
+  var99: number; // VaR at 99%
+  cvar95: number; // CVaR (expected shortfall) at 95%
+  cvar99: number; // CVaR at 99%
+  expectedLoss: number;
+  maxLoss: number;
+  sampleSize: number;
 }
 
 export interface ActuarialReceipt {
-  plugin:        string;
-  runId:         string;
-  payloadHash:   string;
+  plugin: string;
+  runId: string;
+  payloadHash: string;
   hashAlgorithm: string;
-  cael:          { event: string; schemaVersion: string; ts: string };
-  acceptance:    { accepted: boolean; violations: string[] };
+  cael: { event: string; schemaVersion: string; ts: string };
+  acceptance: { accepted: boolean; violations: string[] };
   resultSummary: {
-    nsp:            number;
-    annualPremium:  number;
+    nsp: number;
+    annualPremium: number;
     lifeExpectancy: number;
   };
 }
@@ -115,7 +112,8 @@ const RADIX = 100_000;
  */
 export function buildLifeTable(id: string, qxByAge: number[], interestRate: number): LifeTable {
   if (qxByAge.length < 2) throw new Error('[actuarial] qxByAge must have at least 2 entries');
-  if (qxByAge.some((q) => q < 0 || q > 1)) throw new Error('[actuarial] all qx values must be in [0,1]');
+  if (qxByAge.some((q) => q < 0 || q > 1))
+    throw new Error('[actuarial] all qx values must be in [0,1]');
   if (interestRate < 0) throw new Error('[actuarial] interestRate must be ≥ 0');
 
   const rows: LifeTableRow[] = [];
@@ -154,12 +152,12 @@ export function buildLifeTable(id: string, qxByAge: number[], interestRate: numb
   for (let x = 0; x < n; x++) {
     rows.push({
       age: x,
-      qx:  qxByAge[x],
-      lx:  lx_arr[x],
-      dx:  dx_arr[x],
-      Lx:  Lx_arr[x],
-      Tx:  Tx_arr[x],
-      ex:  ex_arr[x],
+      qx: qxByAge[x],
+      lx: lx_arr[x],
+      dx: dx_arr[x],
+      Lx: Lx_arr[x],
+      Tx: Tx_arr[x],
+      ex: ex_arr[x],
     });
   }
 
@@ -177,13 +175,19 @@ export function buildLifeTable(id: string, qxByAge: number[], interestRate: numb
  *   Cx = v^(x+1) · dx   (discounted deaths)
  *   Mx = Σ(x to ω) Cx   (accumulated Cx)
  */
-function commutationColumns(table: LifeTable, iRate: number): {
-  Dx: number[]; Nx: number[]; Cx: number[]; Mx: number[];
+function commutationColumns(
+  table: LifeTable,
+  iRate: number
+): {
+  Dx: number[];
+  Nx: number[];
+  Cx: number[];
+  Mx: number[];
 } {
-  const v   = 1 / (1 + iRate);
-  const n   = table.rows.length;
-  const Dx  = table.rows.map((r) => Math.pow(v, r.age) * r.lx);
-  const Cx  = table.rows.map((r) => Math.pow(v, r.age + 1) * r.dx);
+  const v = 1 / (1 + iRate);
+  const n = table.rows.length;
+  const Dx = table.rows.map((r) => Math.pow(v, r.age) * r.lx);
+  const Cx = table.rows.map((r) => Math.pow(v, r.age + 1) * r.dx);
 
   const Nx: number[] = new Array(n).fill(0);
   const Mx: number[] = new Array(n).fill(0);
@@ -209,90 +213,91 @@ function commutationColumns(table: LifeTable, iRate: number): {
  *   annuity_due  — benefit B paid at START of each year while alive (no death benefit)
  */
 export function computeActuarialValues(spec: PolicySpec, table: LifeTable): ActuarialResult {
-  const n       = table.rows.length;
-  const iRate   = spec.interestRate ?? table.interestRate;
-  const x       = spec.issueAge;
-  const B       = spec.benefitAmount;
+  const n = table.rows.length;
+  const iRate = spec.interestRate ?? table.interestRate;
+  const x = spec.issueAge;
+  const B = spec.benefitAmount;
 
-  if (x < 0 || x >= n) throw new Error(`[actuarial] issueAge ${x} out of table range [0, ${n - 1}]`);
-  if (iRate < 0)        throw new Error('[actuarial] interestRate must be ≥ 0');
+  if (x < 0 || x >= n)
+    throw new Error(`[actuarial] issueAge ${x} out of table range [0, ${n - 1}]`);
+  if (iRate < 0) throw new Error('[actuarial] interestRate must be ≥ 0');
 
   const { Dx, Nx, Mx } = commutationColumns(table, iRate);
 
-  const row      = table.rows[x];
-  const lifeExp  = row.ex;
+  const row = table.rows[x];
+  const lifeExp = row.ex;
 
   // ── Whole life ──────────────────────────────────────────────────────────────
   if (spec.type === 'whole_life') {
-    const Ax       = Mx[x] / Dx[x];           // net single premium per unit benefit
-    const annuity  = Nx[x] / Dx[x];           // ä_x (annuity-due of 1)
-    const nsp      = B * Ax;
-    const Px       = Ax / annuity;            // level premium per unit benefit per year
+    const Ax = Mx[x] / Dx[x]; // net single premium per unit benefit
+    const annuity = Nx[x] / Dx[x]; // ä_x (annuity-due of 1)
+    const nsp = B * Ax;
+    const Px = Ax / annuity; // level premium per unit benefit per year
     return {
       nsp,
       annualPremium: B * Px,
       lifeExpectancy: lifeExp,
-      annuityDue:    annuity,
-      policyType:    'whole_life',
-      issueAge:      x,
-      termYears:     null,
+      annuityDue: annuity,
+      policyType: 'whole_life',
+      issueAge: x,
+      termYears: null,
     };
   }
 
   // ── Term life ───────────────────────────────────────────────────────────────
   if (spec.type === 'term_life') {
     const term = spec.termYears ?? 20;
-    const xn   = Math.min(x + term, n - 1);
-    const A1xn = (Mx[x] - Mx[xn]) / Dx[x];  // A^1_{x:n} term insurance per unit
-    const axn  = (Nx[x] - Nx[xn]) / Dx[x];  // ä_{x:n} term annuity-due per unit
-    const nsp  = B * A1xn;
+    const xn = Math.min(x + term, n - 1);
+    const A1xn = (Mx[x] - Mx[xn]) / Dx[x]; // A^1_{x:n} term insurance per unit
+    const axn = (Nx[x] - Nx[xn]) / Dx[x]; // ä_{x:n} term annuity-due per unit
+    const nsp = B * A1xn;
     return {
       nsp,
       annualPremium: axn > 0 ? nsp / axn : 0,
       lifeExpectancy: lifeExp,
-      annuityDue:    axn,
-      policyType:    'term_life',
-      issueAge:      x,
-      termYears:     term,
+      annuityDue: axn,
+      policyType: 'term_life',
+      issueAge: x,
+      termYears: term,
     };
   }
 
   // ── Endowment ───────────────────────────────────────────────────────────────
   if (spec.type === 'endowment') {
     const term = spec.termYears ?? 20;
-    const xn   = Math.min(x + term, n - 1);
+    const xn = Math.min(x + term, n - 1);
     // Endowment = term life + pure endowment (survival to n)
-    const A1xn = (Mx[x] - Mx[xn]) / Dx[x];  // insurance component
-    const Exn  = Dx[xn] / Dx[x];             // pure endowment (n Ex)
-    const Axn  = A1xn + Exn;                 // endowment NSP per unit
-    const axn  = (Nx[x] - Nx[xn]) / Dx[x];
-    const nsp  = B * Axn;
+    const A1xn = (Mx[x] - Mx[xn]) / Dx[x]; // insurance component
+    const Exn = Dx[xn] / Dx[x]; // pure endowment (n Ex)
+    const Axn = A1xn + Exn; // endowment NSP per unit
+    const axn = (Nx[x] - Nx[xn]) / Dx[x];
+    const nsp = B * Axn;
     return {
       nsp,
       annualPremium: axn > 0 ? nsp / axn : 0,
       lifeExpectancy: lifeExp,
-      annuityDue:    axn,
-      policyType:    'endowment',
-      issueAge:      x,
-      termYears:     term,
+      annuityDue: axn,
+      policyType: 'endowment',
+      issueAge: x,
+      termYears: term,
     };
   }
 
   // ── Life annuity-due ────────────────────────────────────────────────────────
   if (spec.type === 'annuity_due') {
-    const term     = spec.termYears;
+    const term = spec.termYears;
     let annuityDue: number;
     let termYears: number | null;
 
     if (term != null) {
       // Temporary life annuity-due ä_{x:n}
-      const xn   = Math.min(x + term, n - 1);
+      const xn = Math.min(x + term, n - 1);
       annuityDue = (Nx[x] - Nx[xn]) / Dx[x];
-      termYears  = term;
+      termYears = term;
     } else {
       // Whole life annuity-due ä_x
       annuityDue = Nx[x] / Dx[x];
-      termYears  = null;
+      termYears = null;
     }
 
     const nsp = B * annuityDue;
@@ -301,8 +306,8 @@ export function computeActuarialValues(spec: PolicySpec, table: LifeTable): Actu
       annualPremium: 0, // annuities don't have a separately stated premium
       lifeExpectancy: lifeExp,
       annuityDue,
-      policyType:    'annuity_due',
-      issueAge:      x,
+      policyType: 'annuity_due',
+      issueAge: x,
       termYears,
     };
   }
@@ -318,7 +323,7 @@ export function computeActuarialValues(spec: PolicySpec, table: LifeTable): Actu
  */
 export function computeNPV(cashFlows: CashFlow[], discountRate: number): NPVResult {
   if (cashFlows.length === 0) throw new Error('[actuarial] cashFlows must not be empty');
-  if (discountRate < 0)       throw new Error('[actuarial] discountRate must be ≥ 0');
+  if (discountRate < 0) throw new Error('[actuarial] discountRate must be ≥ 0');
 
   const sorted = [...cashFlows].sort((a, b) => a.period - b.period);
 
@@ -329,18 +334,25 @@ export function computeNPV(cashFlows: CashFlow[], discountRate: number): NPVResu
   let paybackPeriod: number | null = null;
   for (const cf of sorted) {
     cum += cf.amount;
-    if (cum >= 0 && paybackPeriod === null) { paybackPeriod = cf.period; }
+    if (cum >= 0 && paybackPeriod === null) {
+      paybackPeriod = cf.period;
+    }
   }
 
   // IRR via bisection (finds rate where NPV = 0)
   let irr: number | null = null;
   const npvAt = (r: number) => sorted.reduce((s, cf) => s + cf.amount / (1 + r) ** cf.period, 0);
-  const lo = 0, hi = 2.0; // 0% to 200%
+  const lo = 0,
+    hi = 2.0; // 0% to 200%
   if (Math.sign(npvAt(lo)) !== Math.sign(npvAt(hi))) {
-    let a = lo, b = hi;
+    let a = lo,
+      b = hi;
     for (let i = 0; i < 100; i++) {
       const mid = (a + b) / 2;
-      if (Math.abs(b - a) < 1e-10) { irr = mid; break; }
+      if (Math.abs(b - a) < 1e-10) {
+        irr = mid;
+        break;
+      }
       Math.sign(npvAt(mid)) === Math.sign(npvAt(a)) ? (a = mid) : (b = mid);
       irr = (a + b) / 2;
     }
@@ -359,7 +371,7 @@ export function computeVaR(losses: number[]): VaRResult {
   if (losses.length < 2) throw new Error('[actuarial] VaR requires at least 2 loss observations');
 
   const sorted = [...losses].sort((a, b) => a - b);
-  const n      = sorted.length;
+  const n = sorted.length;
 
   const idx95 = Math.ceil(0.95 * n) - 1;
   const idx99 = Math.ceil(0.99 * n) - 1;
@@ -374,7 +386,7 @@ export function computeVaR(losses: number[]): VaRResult {
   const cvar99 = tail99.reduce((s, v) => s + v, 0) / tail99.length;
 
   const expectedLoss = sorted.reduce((s, v) => s + v, 0) / n;
-  const maxLoss      = sorted[n - 1];
+  const maxLoss = sorted[n - 1];
 
   return {
     confidenceLevel: 0.95,
@@ -400,13 +412,16 @@ export function computeVaR(losses: number[]): VaRResult {
  *
  * Returns qx values for ages 0 .. maxAge.
  */
-export function gompertzMakehamQx(params: { A: number; B: number; c: number }, maxAge: number): number[] {
+export function gompertzMakehamQx(
+  params: { A: number; B: number; c: number },
+  maxAge: number
+): number[] {
   const { A, B, c } = params;
   if (B <= 0 || c <= 1) throw new Error('[actuarial] Gompertz params require B>0 and c>1');
   const lnC = Math.log(c);
   return Array.from({ length: maxAge + 1 }, (_, x) => {
     // qx ≈ 1 − exp(−∫ₓˣ⁺¹ μ(t) dt) = 1 − exp(−A − B(cˣ)(c−1)/ln(c))
-    const integral = A + B * Math.pow(c, x) * (c - 1) / lnC;
+    const integral = A + (B * Math.pow(c, x) * (c - 1)) / lnC;
     return Math.min(1, 1 - Math.exp(-integral));
   });
 }
@@ -414,34 +429,37 @@ export function gompertzMakehamQx(params: { A: number; B: number; c: number }, m
 // ─── Receipt ─────────────────────────────────────────────────────────────────
 
 export function buildActuarialReceipt(
-  result:  ActuarialResult,
-  options?: { runId?: string },
+  result: ActuarialResult,
+  options?: { runId?: string }
 ): ActuarialReceipt {
   const violations: Array<{ criterion: string; message: string }> = [];
   if (result.nsp < 0)
     violations.push({ criterion: 'nsp', message: `negative NSP: ${result.nsp.toFixed(4)}` });
   if (result.annualPremium < 0)
-    violations.push({ criterion: 'premium', message: `negative annual premium: ${result.annualPremium.toFixed(4)}` });
+    violations.push({
+      criterion: 'premium',
+      message: `negative annual premium: ${result.annualPremium.toFixed(4)}`,
+    });
 
   const raw = buildDomainSimulationReceipt({
-    plugin:        'insurance',
+    plugin: 'insurance',
     pluginVersion: '1.0.0',
-    runId:         options?.runId ?? `act-${Date.now().toString(36)}`,
-    modelId:       `${result.policyType}-age${result.issueAge}`,
+    runId: options?.runId ?? `act-${Date.now().toString(36)}`,
+    modelId: `${result.policyType}-age${result.issueAge}`,
     solverConfig: {
-      solverType:  'commutation-columns',
-      scale:       'individual-policy',
-      policyType:  result.policyType,
-      issueAge:    result.issueAge,
+      solverType: 'commutation-columns',
+      scale: 'individual-policy',
+      policyType: result.policyType,
+      issueAge: result.issueAge,
     },
     resultSummary: {
-      nsp:            +result.nsp.toFixed(4),
-      annualPremium:  +result.annualPremium.toFixed(4),
+      nsp: +result.nsp.toFixed(4),
+      annualPremium: +result.annualPremium.toFixed(4),
       lifeExpectancy: +result.lifeExpectancy.toFixed(2),
     },
     cael: {
-      version:    'cael.v1',
-      event:      'insurance.actuarial',
+      version: 'cael.v1',
+      event: 'insurance.actuarial',
       solverType: 'insurance.commutation-columns',
     },
     acceptance: { accepted: violations.length === 0, violations },

package/src/fairness-underwriting.ts

@@ -100,7 +100,7 @@ export interface HomeownersModelWeights {
  */
 export function createHomeownersModel(
   weights: HomeownersModelWeights,
-  modelId = 'homeowners-underwriting-scorer',
+  modelId = 'homeowners-underwriting-scorer'
 ): FairnessModel {
   return {
     id: modelId,
@@ -129,10 +129,10 @@ export function createHomeownersModel(
 export const BIASED_WEIGHTS: HomeownersModelWeights = {
   prior_claims: 0.45,
   credit_tier: 0.55,
-  zip_risk: 0.60, // over-penalises high-decile (the bias lever)
-  age_band: 0.10,
-  bias: 0.70,
-  threshold: 0.50,
+  zip_risk: 0.6, // over-penalises high-decile (the bias lever)
+  age_band: 0.1,
+  bias: 0.7,
+  threshold: 0.5,
 };
 
 /**
@@ -147,12 +147,12 @@ export const BIASED_WEIGHTS: HomeownersModelWeights = {
  * constraint; the higher bias provides the margin).
  */
 export const REMEDIATED_WEIGHTS: HomeownersModelWeights = {
-  prior_claims: 0.40,
+  prior_claims: 0.4,
   credit_tier: 0.55,
-  zip_risk: 0.00, // zeroed out — D.057 remediation
+  zip_risk: 0.0, // zeroed out — D.057 remediation
   age_band: 0.08,
   bias: 0.55,
-  threshold: 0.50,
+  threshold: 0.5,
 };
 
 // ── Synthetic cohort generator ───────────────────────────────────────────────
@@ -185,18 +185,18 @@ export function makeInsuranceCohort(seed: number, n = 400): FairnessRecord[] {
     // ZIP-risk proxy: the bias trap — high-decile draws from higher range
     const zip_risk =
       group === 'high-decile'
-        ? clamp01(0.55 + 0.40 * rng()) // [0.55, 0.95]
+        ? clamp01(0.55 + 0.4 * rng()) // [0.55, 0.95]
         : clamp01(0.05 + 0.45 * rng()); // [0.05, 0.50]
 
     // Credit tier: slightly lower for high-decile (systemic disparity)
     const credit_tier =
       group === 'high-decile'
-        ? clamp01(0.30 + 0.55 * rng()) // mean ~0.575
-        : clamp01(0.40 + 0.55 * rng()); // mean ~0.675
+        ? clamp01(0.3 + 0.55 * rng()) // mean ~0.575
+        : clamp01(0.4 + 0.55 * rng()); // mean ~0.675
 
     // Prior claims and age band: comparable across groups
     const prior_claims = clamp01(0.05 + 0.45 * rng()); // [0.05, 0.50]
-    const age_band = clamp01(0.20 + 0.60 * rng()); // [0.20, 0.80]
+    const age_band = clamp01(0.2 + 0.6 * rng()); // [0.20, 0.80]
 
     rows.push({
       group,
@@ -227,7 +227,7 @@ export function makeInsuranceCohort(seed: number, n = 400): FairnessRecord[] {
  */
 export const insuranceUnderwritingPerturber: CohortPerturber = (
   cohort: readonly FairnessRecord[],
-  { driftShift, noiseScale, rng }: FairnessPerturbation,
+  { driftShift, noiseScale, rng }: FairnessPerturbation
 ): FairnessRecord[] => {
   const n = cohort.length;
   const clamp01 = (x: number) => Math.max(0, Math.min(1, x));
@@ -242,16 +242,12 @@ export const insuranceUnderwritingPerturber: CohortPerturber = (
         zip_risk: clamp01(
           src.features.zip_risk +
             (isHighDecile ? driftShift : 0) + // directed drift for high-decile
-            (rng() - 0.5) * 0.5 * noiseScale, // symmetric noise for both
+            (rng() - 0.5) * 0.5 * noiseScale // symmetric noise for both
         ),
         // Credit bureau measurement noise (both groups)
-        credit_tier: clamp01(
-          src.features.credit_tier + (rng() - 0.5) * 2 * noiseScale,
-        ),
+        credit_tier: clamp01(src.features.credit_tier + (rng() - 0.5) * 2 * noiseScale),
         // Prior claims: low noise (claim history is more stable)
-        prior_claims: clamp01(
-          src.features.prior_claims + (rng() - 0.5) * noiseScale,
-        ),
+        prior_claims: clamp01(src.features.prior_claims + (rng() - 0.5) * noiseScale),
         // Age band: stable (no drift)
         age_band: src.features.age_band,
       },

package/src/index.ts

@@ -1,7 +1,20 @@
-export { createPolicyHandler, type PolicyConfig, type PolicyType, type PolicyStatus } from './traits/PolicyTrait';
+export {
+  createPolicyHandler,
+  type PolicyConfig,
+  type PolicyType,
+  type PolicyStatus,
+} from './traits/PolicyTrait';
 export { createClaimHandler, type ClaimConfig, type ClaimStatus } from './traits/ClaimTrait';
-export { createRiskAssessmentHandler, type RiskAssessmentConfig, type RiskFactor } from './traits/RiskAssessmentTrait';
-export { createUnderwritingHandler, type UnderwritingConfig, type UnderwritingDecision } from './traits/UnderwritingTrait';
+export {
+  createRiskAssessmentHandler,
+  type RiskAssessmentConfig,
+  type RiskFactor,
+} from './traits/RiskAssessmentTrait';
+export {
+  createUnderwritingHandler,
+  type UnderwritingConfig,
+  type UnderwritingDecision,
+} from './traits/UnderwritingTrait';
 export * from './traits/types';
 
 import { createPolicyHandler } from './traits/PolicyTrait';
@@ -12,5 +25,14 @@ import { createUnderwritingHandler } from './traits/UnderwritingTrait';
 export * from './actuarial';
 export * from './fairness-underwriting';
 
-export const pluginMeta = { name: '@holoscript/plugin-insurance', version: '1.0.0', traits: ['policy', 'claim', 'risk_assessment', 'underwriting', 'actuarial_math'] };
-export const traitHandlers = [createPolicyHandler(), createClaimHandler(), createRiskAssessmentHandler(), createUnderwritingHandler()];
+export const pluginMeta = {
+  name: '@holoscript/plugin-insurance',
+  version: '1.0.0',
+  traits: ['policy', 'claim', 'risk_assessment', 'underwriting', 'actuarial_math'],
+};
+export const traitHandlers = [
+  createPolicyHandler(),
+  createClaimHandler(),
+  createRiskAssessmentHandler(),
+  createUnderwritingHandler(),
+];