@holoscript/plugin-banking-finance 2.0.1 → 2.0.2

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@holoscript/plugin-banking-finance",
-  "version": "2.0.1",
+  "version": "2.0.2",
   "main": "src/index.ts",
   "peerDependencies": {
-    "@holoscript/core": "8.0.6"
+    "@holoscript/core": ">=8.0.0"
   },
   "license": "MIT",
   "scripts": {
     "test": "vitest run --passWithNoTests",
     "test:coverage": "vitest run --coverage --passWithNoTests"
   }
-}
+}

package/src/__tests__/fixedincome.test.ts

@@ -26,9 +26,9 @@ describe('analyzeBond', () => {
    * When coupon rate = yield, price = par: $1000.
    */
   const parBond: BondSpec = {
-    faceValue:     1_000,
-    couponRate:    0.05,
-    periods:       20,   // 10 years × 2
+    faceValue: 1_000,
+    couponRate: 0.05,
+    periods: 20, // 10 years × 2
     periodsPerYear: 2,
   };
 
@@ -62,8 +62,8 @@ describe('analyzeBond', () => {
 
   it('price is inverse function of yield (higher yield → lower price)', () => {
     const bond: BondSpec = { faceValue: 1000, couponRate: 0.05, periods: 20, periodsPerYear: 2 };
-    const r4  = analyzeBond(bond, 0.04);
-    const r6  = analyzeBond(bond, 0.06);
+    const r4 = analyzeBond(bond, 0.04);
+    const r6 = analyzeBond(bond, 0.06);
     expect(r4.price).toBeGreaterThan(r6.price);
   });
 
@@ -105,7 +105,11 @@ describe('analyzeBond', () => {
 
   it('YTM > coupon rate for discount bond', () => {
     const bond: BondSpec = {
-      faceValue: 1000, couponRate: 0.04, periods: 20, periodsPerYear: 2, marketPrice: 922.78,
+      faceValue: 1000,
+      couponRate: 0.04,
+      periods: 20,
+      periodsPerYear: 2,
+      marketPrice: 922.78,
     };
     const r = analyzeBond(bond, 0.05);
     expect(r.ytm).not.toBeNull();
@@ -193,15 +197,13 @@ describe('analyzePortfolio', () => {
   it('throws for mismatched return series lengths', () => {
     const bad: PortfolioHolding[] = [
       { id: 'A', returns: [0.01, 0.02, 0.03], weight: 0.5 },
-      { id: 'B', returns: [0.01, 0.02],       weight: 0.5 },
+      { id: 'B', returns: [0.01, 0.02], weight: 0.5 },
     ];
     expect(() => analyzePortfolio(bad)).toThrow();
   });
 
   it('throws for fewer than 2 observations', () => {
-    expect(() =>
-      analyzePortfolio([{ id: 'A', returns: [0.01], weight: 1.0 }]),
-    ).toThrow();
+    expect(() => analyzePortfolio([{ id: 'A', returns: [0.01], weight: 1.0 }])).toThrow();
   });
 });
 
@@ -213,7 +215,7 @@ describe('blackScholes', () => {
    *  S=40, K=40 (ATM), T=0.5yr, r=0.10, σ=0.40
    *  call ≈ $4.76, put ≈ $2.82 (from original paper, approximate)
    */
-  const atm = () => blackScholes(40, 40, 0.5, 0.10, 0.40);
+  const atm = () => blackScholes(40, 40, 0.5, 0.1, 0.4);
 
   it('ATM call price is positive and reasonable (0–10 for S=40)', () => {
     const r = atm();
@@ -229,8 +231,11 @@ describe('blackScholes', () => {
    * Put-call parity: C − P = S − K × e^(−rT)
    */
   it('put-call parity holds', () => {
-    const r  = atm();
-    const S  = 40, K = 40, T = 0.5, rr = 0.10;
+    const r = atm();
+    const S = 40,
+      K = 40,
+      T = 0.5,
+      rr = 0.1;
     const parity = S - K * Math.exp(-rr * T);
     expect(r.callPrice - r.putPrice).toBeCloseTo(parity, 3);
   });
@@ -259,25 +264,25 @@ describe('blackScholes', () => {
   });
 
   it('deep ITM call price approaches intrinsic value (S - K × e^{-rT})', () => {
-    const r    = blackScholes(100, 50, 0.5, 0.05, 0.10); // deep ITM
+    const r = blackScholes(100, 50, 0.5, 0.05, 0.1); // deep ITM
     const intrinsic = 100 - 50 * Math.exp(-0.05 * 0.5);
     expect(r.callPrice).toBeCloseTo(intrinsic, 0);
   });
 
   it('deep OTM call price approaches 0', () => {
-    const r = blackScholes(40, 200, 0.5, 0.05, 0.20); // deep OTM
+    const r = blackScholes(40, 200, 0.5, 0.05, 0.2); // deep OTM
     expect(r.callPrice).toBeCloseTo(0, 3);
   });
 
   it('higher volatility increases both call and put price', () => {
-    const lo = blackScholes(40, 40, 0.5, 0.05, 0.20);
-    const hi = blackScholes(40, 40, 0.5, 0.05, 0.40);
+    const lo = blackScholes(40, 40, 0.5, 0.05, 0.2);
+    const hi = blackScholes(40, 40, 0.5, 0.05, 0.4);
     expect(hi.callPrice).toBeGreaterThan(lo.callPrice);
     expect(hi.putPrice).toBeGreaterThan(lo.putPrice);
   });
 
   it('throws for zero spot price', () => {
-    expect(() => blackScholes(0, 40, 0.5, 0.05, 0.20)).toThrow();
+    expect(() => blackScholes(0, 40, 0.5, 0.05, 0.2)).toThrow();
   });
 
   it('throws for zero volatility', () => {
@@ -290,13 +295,24 @@ describe('blackScholes', () => {
 describe('analyzeFinance', () => {
   it('computes all three analyses when all inputs provided', () => {
     const holdings: PortfolioHolding[] = [
-      { id: 'A', returns: Array.from({length:24},(_,i)=>0.005+0.01*Math.cos(i)), weight: 0.6 },
-      { id: 'B', returns: Array.from({length:24},(_,i)=>0.006+0.01*Math.sin(i)), weight: 0.4 },
+      {
+        id: 'A',
+        returns: Array.from({ length: 24 }, (_, i) => 0.005 + 0.01 * Math.cos(i)),
+        weight: 0.6,
+      },
+      {
+        id: 'B',
+        returns: Array.from({ length: 24 }, (_, i) => 0.006 + 0.01 * Math.sin(i)),
+        weight: 0.4,
+      },
     ];
     const r = analyzeFinance({
-      bond:      { spec: { faceValue: 1000, couponRate: 0.05, periods: 20, periodsPerYear: 2 }, annualYield: 0.05 },
+      bond: {
+        spec: { faceValue: 1000, couponRate: 0.05, periods: 20, periodsPerYear: 2 },
+        annualYield: 0.05,
+      },
       portfolio: { holdings },
-      options:   { S: 40, K: 40, T: 0.5, r: 0.05, sigma: 0.30 },
+      options: { S: 40, K: 40, T: 0.5, r: 0.05, sigma: 0.3 },
     });
     expect(r.bond).toBeDefined();
     expect(r.portfolio).toBeDefined();
@@ -309,7 +325,10 @@ describe('analyzeFinance', () => {
 
 describe('buildFinanceReceipt', () => {
   const bondResult = analyzeFinance({
-    bond: { spec: { faceValue: 1000, couponRate: 0.05, periods: 20, periodsPerYear: 2 }, annualYield: 0.05 },
+    bond: {
+      spec: { faceValue: 1000, couponRate: 0.05, periods: 20, periodsPerYear: 2 },
+      annualYield: 0.05,
+    },
   });
 
   it('produces receipt with plugin=banking-finance and CAEL event', () => {

package/src/fixedincome.ts

@@ -15,95 +15,92 @@
  *   Black & Scholes (1973) "The Pricing of Options..." J. Political Economy.
  */
 
-import {
-  DOMAIN_SIMULATION_RECEIPT_SCHEMA,
-  buildDomainSimulationReceipt,
-} from '@holoscript/core';
+import { DOMAIN_SIMULATION_RECEIPT_SCHEMA, buildDomainSimulationReceipt } from '@holoscript/core';
 
 // ─── Types ────────────────────────────────────────────────────────────────────
 
 export interface BondSpec {
   /** Face (par) value */
-  faceValue:     number;
+  faceValue: number;
   /** Annual coupon rate (e.g. 0.05 = 5%) */
-  couponRate:    number;
+  couponRate: number;
   /** Periods to maturity (coupon payments; typically semi-annual = years × 2) */
-  periods:       number;
+  periods: number;
   /** Periods per year (2 = semi-annual, 1 = annual) */
   periodsPerYear: number;
   /** Market price (for YTM calculation; optional) */
-  marketPrice?:  number;
+  marketPrice?: number;
 }
 
 export interface BondResult {
   /** Clean price (sum of discounted cash flows) at given yield */
-  price:             number;
+  price: number;
   /** Yield to maturity (annual, bond-equivalent) */
-  ytm:               number | null;
+  ytm: number | null;
   /** Macaulay duration (years) */
-  macaulayDuration:  number;
+  macaulayDuration: number;
   /** Modified duration (% price change per 1% yield change) */
-  modifiedDuration:  number;
+  modifiedDuration: number;
   /** Dollar duration (DV01): price change for 1 bp yield change */
-  dv01:              number;
+  dv01: number;
   /** Convexity */
-  convexity:         number;
+  convexity: number;
 }
 
 export interface PortfolioHolding {
-  id:          string;
+  id: string;
   /** Historical returns (one per period) */
-  returns:     number[];
+  returns: number[];
   /** Portfolio weight (0–1, must sum to 1 across holdings) */
-  weight:      number;
+  weight: number;
 }
 
 export interface PortfolioResult {
-  expectedReturn:  number;
-  variance:        number;
-  stdDev:          number;
-  sharpeRatio:     number | null; // null if riskFreeRate not provided
-  beta:            number | null; // null if benchmark returns not provided
+  expectedReturn: number;
+  variance: number;
+  stdDev: number;
+  sharpeRatio: number | null; // null if riskFreeRate not provided
+  beta: number | null; // null if benchmark returns not provided
   /** Historical VaR at 95% confidence */
-  var95:           number;
+  var95: number;
   /** Historical CVaR (expected shortfall) at 95% */
-  cvar95:          number;
+  cvar95: number;
 }
 
 export interface BlackScholesResult {
   callPrice: number;
-  putPrice:  number;
+  putPrice: number;
   /** Greeks */
   callDelta: number;
-  putDelta:  number;
-  gamma:     number;
-  vega:      number;
+  putDelta: number;
+  gamma: number;
+  vega: number;
   callTheta: number;
-  putTheta:  number;
-  callRho:   number;
-  putRho:    number;
+  putTheta: number;
+  callRho: number;
+  putRho: number;
 }
 
 export interface FinanceAnalysisResult {
-  bond?:      BondResult;
+  bond?: BondResult;
   portfolio?: PortfolioResult;
-  options?:   BlackScholesResult;
-  converged:  boolean;
+  options?: BlackScholesResult;
+  converged: boolean;
 }
 
 export interface FinanceReceipt {
-  plugin:        string;
-  runId:         string;
-  payloadHash:   string;
+  plugin: string;
+  runId: string;
+  payloadHash: string;
   hashAlgorithm: string;
-  cael:          { event: string; solverType: string; version: string };
-  acceptance:    { accepted: boolean; violations: Array<{ criterion: string; message: string }> };
+  cael: { event: string; solverType: string; version: string };
+  acceptance: { accepted: boolean; violations: Array<{ criterion: string; message: string }> };
   resultSummary: {
-    bondYTM?:          number;
-    bondDuration?:     number;
-    portfolioReturn?:  number;
-    portfolioSharpe?:  number;
-    optionCallPrice?:  number;
+    bondYTM?: number;
+    bondDuration?: number;
+    portfolioReturn?: number;
+    portfolioSharpe?: number;
+    optionCallPrice?: number;
   };
 }
 
@@ -112,12 +109,12 @@ export interface FinanceReceipt {
 /** Standard normal CDF via Abramowitz & Stegun (7-term; error < 3e-7) */
 function normalCDF(x: number): number {
   if (x < -8) return 0;
-  if (x >  8) return 1;
+  if (x > 8) return 1;
   const k = 1 / (1 + 0.2316419 * Math.abs(x));
-  const poly = ((((1.330274429 * k - 1.821255978) * k + 1.781477937) * k
-               - 0.356563782) * k + 0.319381530) * k;
-  const pdf  = Math.exp(-0.5 * x * x) / Math.sqrt(2 * Math.PI);
-  const cdf  = 1 - pdf * poly;
+  const poly =
+    ((((1.330274429 * k - 1.821255978) * k + 1.781477937) * k - 0.356563782) * k + 0.31938153) * k;
+  const pdf = Math.exp(-0.5 * x * x) / Math.sqrt(2 * Math.PI);
+  const cdf = 1 - pdf * poly;
   return x >= 0 ? cdf : 1 - cdf;
 }
 
@@ -148,43 +145,50 @@ function bondPrice(spec: BondSpec, yieldPerPeriod: number): number {
  */
 export function analyzeBond(spec: BondSpec, annualYield: number): BondResult {
   const { faceValue, couponRate, periods, periodsPerYear } = spec;
-  if (periods <= 0)         throw new Error('[finance] periods must be > 0');
-  if (faceValue <= 0)       throw new Error('[finance] faceValue must be > 0');
-  if (periodsPerYear <= 0)  throw new Error('[finance] periodsPerYear must be > 0');
-  if (annualYield < 0)      throw new Error('[finance] annualYield must be ≥ 0');
+  if (periods <= 0) throw new Error('[finance] periods must be > 0');
+  if (faceValue <= 0) throw new Error('[finance] faceValue must be > 0');
+  if (periodsPerYear <= 0) throw new Error('[finance] periodsPerYear must be > 0');
+  if (annualYield < 0) throw new Error('[finance] annualYield must be ≥ 0');
 
-  const r   = annualYield / periodsPerYear; // yield per period
-  const C   = faceValue * (couponRate / periodsPerYear);
+  const r = annualYield / periodsPerYear; // yield per period
+  const C = faceValue * (couponRate / periodsPerYear);
   const price = bondPrice(spec, r);
 
   // Macaulay duration: Σ t × PV(CF_t) / price
   let durationWeightedSum = 0;
-  let convexitySum        = 0;
+  let convexitySum = 0;
   for (let t = 1; t <= periods; t++) {
-    const cf   = t < periods ? C : C + faceValue;
-    const pv   = cf / Math.pow(1 + r, t);
+    const cf = t < periods ? C : C + faceValue;
+    const pv = cf / Math.pow(1 + r, t);
     durationWeightedSum += (t / periodsPerYear) * pv;
-    convexitySum        += (t * (t + 1)) * pv / Math.pow(1 + r, 2);
+    convexitySum += (t * (t + 1) * pv) / Math.pow(1 + r, 2);
   }
-  const macaulayDuration  = durationWeightedSum / price;
-  const modifiedDuration  = macaulayDuration / (1 + r);
-  const dv01              = modifiedDuration * price * 0.0001; // per 1 bp
-  const convexity         = convexitySum / (price * Math.pow(periodsPerYear, 2));
+  const macaulayDuration = durationWeightedSum / price;
+  const modifiedDuration = macaulayDuration / (1 + r);
+  const dv01 = modifiedDuration * price * 0.0001; // per 1 bp
+  const convexity = convexitySum / (price * Math.pow(periodsPerYear, 2));
 
   // YTM from market price (if provided)
   let ytm: number | null = null;
   if (spec.marketPrice !== undefined && spec.marketPrice > 0) {
     const mktPrice = spec.marketPrice;
     // Bisect on annual yield: find y s.t. bondPrice(y/periodsPerYear) = mktPrice
-    let lo = 0, hi = 2.0;
-    if (Math.sign(bondPrice(spec, lo / periodsPerYear) - mktPrice) !==
-        Math.sign(bondPrice(spec, hi / periodsPerYear) - mktPrice)) {
+    let lo = 0,
+      hi = 2.0;
+    if (
+      Math.sign(bondPrice(spec, lo / periodsPerYear) - mktPrice) !==
+      Math.sign(bondPrice(spec, hi / periodsPerYear) - mktPrice)
+    ) {
       for (let i = 0; i < 100; i++) {
-        const mid   = (lo + hi) / 2;
+        const mid = (lo + hi) / 2;
         const delta = bondPrice(spec, mid / periodsPerYear) - mktPrice;
-        if (Math.abs(delta) < 0.0001 || (hi - lo) < 1e-10) { ytm = mid; break; }
+        if (Math.abs(delta) < 0.0001 || hi - lo < 1e-10) {
+          ytm = mid;
+          break;
+        }
         Math.sign(delta) === Math.sign(bondPrice(spec, lo / periodsPerYear) - mktPrice)
-          ? (lo = mid) : (hi = mid);
+          ? (lo = mid)
+          : (hi = mid);
         ytm = (lo + hi) / 2;
       }
     }
@@ -203,32 +207,34 @@ export function analyzeBond(spec: BondSpec, annualYield: number): BondResult {
  * @param benchmarkReturns Benchmark return series; optional — required for beta
  */
 export function analyzePortfolio(
-  holdings:         PortfolioHolding[],
-  riskFreeRate?:    number,
-  benchmarkReturns?: number[],
+  holdings: PortfolioHolding[],
+  riskFreeRate?: number,
+  benchmarkReturns?: number[]
 ): PortfolioResult {
   if (holdings.length === 0) throw new Error('[finance] at least one holding required');
   const n = holdings[0].returns.length;
   if (n < 2) throw new Error('[finance] at least 2 return observations required');
-  if (holdings.some((h) => h.returns.length !== n)) throw new Error('[finance] all return series must have same length');
+  if (holdings.some((h) => h.returns.length !== n))
+    throw new Error('[finance] all return series must have same length');
 
   const totalWeight = holdings.reduce((s, h) => s + h.weight, 0);
-  if (Math.abs(totalWeight - 1) > 1e-6) throw new Error(`[finance] weights must sum to 1 (got ${totalWeight.toFixed(6)})`);
+  if (Math.abs(totalWeight - 1) > 1e-6)
+    throw new Error(`[finance] weights must sum to 1 (got ${totalWeight.toFixed(6)})`);
 
   // Portfolio returns (weighted sum each period)
   const portReturns = Array.from({ length: n }, (_, t) =>
-    holdings.reduce((s, h) => s + h.weight * h.returns[t], 0),
+    holdings.reduce((s, h) => s + h.weight * h.returns[t], 0)
   );
 
   const expectedReturn = portReturns.reduce((s, r) => s + r, 0) / n;
-  const variance       = portReturns.reduce((s, r) => s + (r - expectedReturn) ** 2, 0) / (n - 1);
-  const stdDev         = Math.sqrt(variance);
+  const variance = portReturns.reduce((s, r) => s + (r - expectedReturn) ** 2, 0) / (n - 1);
+  const stdDev = Math.sqrt(variance);
 
   // Sharpe ratio (annualised using period count as proxy)
   let sharpeRatio: number | null = null;
   if (riskFreeRate !== undefined) {
-    const periodsPerYear  = n; // single-period approximation
-    const excessReturn    = expectedReturn - riskFreeRate / periodsPerYear;
+    const periodsPerYear = n; // single-period approximation
+    const excessReturn = expectedReturn - riskFreeRate / periodsPerYear;
     sharpeRatio = stdDev > 0 ? (excessReturn / stdDev) * Math.sqrt(n) : null;
   }
 
@@ -236,16 +242,21 @@ export function analyzePortfolio(
   let beta: number | null = null;
   if (benchmarkReturns && benchmarkReturns.length === n) {
     const benchMean = benchmarkReturns.reduce((s, r) => s + r, 0) / n;
-    const cov       = portReturns.reduce((s, r, i) => s + (r - expectedReturn) * (benchmarkReturns[i] - benchMean), 0) / (n - 1);
-    const benchVar  = benchmarkReturns.reduce((s, r) => s + (r - benchMean) ** 2, 0) / (n - 1);
+    const cov =
+      portReturns.reduce(
+        (s, r, i) => s + (r - expectedReturn) * (benchmarkReturns[i] - benchMean),
+        0
+      ) /
+      (n - 1);
+    const benchVar = benchmarkReturns.reduce((s, r) => s + (r - benchMean) ** 2, 0) / (n - 1);
     beta = benchVar > 0 ? cov / benchVar : null;
   }
 
   // Historical VaR and CVaR at 95%
   const sorted = [...portReturns].sort((a, b) => a - b);
-  const idx    = Math.ceil(0.05 * n) - 1;
-  const var95  = -sorted[Math.max(0, idx)];   // convert return to loss
-  const tail   = sorted.slice(0, idx + 1);
+  const idx = Math.ceil(0.05 * n) - 1;
+  const var95 = -sorted[Math.max(0, idx)]; // convert return to loss
+  const tail = sorted.slice(0, idx + 1);
   const cvar95 = -(tail.reduce((s, v) => s + v, 0) / tail.length);
 
   return { expectedReturn, variance, stdDev, sharpeRatio, beta, var95, cvar95 };
@@ -262,50 +273,70 @@ export function analyzePortfolio(
  * @param r  Risk-free rate (annual, continuously compounded)
  * @param σ  Volatility (annual)
  */
-export function blackScholes(S: number, K: number, T: number, r: number, sigma: number): BlackScholesResult {
-  if (S <= 0)     throw new Error('[finance] spot price must be > 0');
-  if (K <= 0)     throw new Error('[finance] strike must be > 0');
-  if (T <= 0)     throw new Error('[finance] time to expiry must be > 0');
+export function blackScholes(
+  S: number,
+  K: number,
+  T: number,
+  r: number,
+  sigma: number
+): BlackScholesResult {
+  if (S <= 0) throw new Error('[finance] spot price must be > 0');
+  if (K <= 0) throw new Error('[finance] strike must be > 0');
+  if (T <= 0) throw new Error('[finance] time to expiry must be > 0');
   if (sigma <= 0) throw new Error('[finance] volatility must be > 0');
 
   const sqrtT = Math.sqrt(T);
-  const d1    = (Math.log(S / K) + (r + 0.5 * sigma * sigma) * T) / (sigma * sqrtT);
-  const d2    = d1 - sigma * sqrtT;
+  const d1 = (Math.log(S / K) + (r + 0.5 * sigma * sigma) * T) / (sigma * sqrtT);
+  const d2 = d1 - sigma * sqrtT;
 
-  const Nd1   = normalCDF(d1);
-  const Nd2   = normalCDF(d2);
-  const Nnd1  = normalCDF(-d1);
-  const Nnd2  = normalCDF(-d2);
-  const nd1   = normalPDF(d1);
-  const disc  = Math.exp(-r * T);
+  const Nd1 = normalCDF(d1);
+  const Nd2 = normalCDF(d2);
+  const Nnd1 = normalCDF(-d1);
+  const Nnd2 = normalCDF(-d2);
+  const nd1 = normalPDF(d1);
+  const disc = Math.exp(-r * T);
 
-  const callPrice = S * Nd1  - K * disc * Nd2;
-  const putPrice  = K * disc * Nnd2 - S * Nnd1;
+  const callPrice = S * Nd1 - K * disc * Nd2;
+  const putPrice = K * disc * Nnd2 - S * Nnd1;
 
   const callDelta = Nd1;
-  const putDelta  = Nd1 - 1;
-  const gamma     = nd1 / (S * sigma * sqrtT);
-  const vega      = S * nd1 * sqrtT / 100;               // per 1% vol move
+  const putDelta = Nd1 - 1;
+  const gamma = nd1 / (S * sigma * sqrtT);
+  const vega = (S * nd1 * sqrtT) / 100; // per 1% vol move
   const callTheta = (-(S * nd1 * sigma) / (2 * sqrtT) - r * K * disc * Nd2) / 365;
-  const putTheta  = (-(S * nd1 * sigma) / (2 * sqrtT) + r * K * disc * Nnd2) / 365;
-  const callRho   = K * T * disc * Nd2  / 100;
-  const putRho    = -K * T * disc * Nnd2 / 100;
-
-  return { callPrice, putPrice, callDelta, putDelta, gamma, vega, callTheta, putTheta, callRho, putRho };
+  const putTheta = (-(S * nd1 * sigma) / (2 * sqrtT) + r * K * disc * Nnd2) / 365;
+  const callRho = (K * T * disc * Nd2) / 100;
+  const putRho = (-K * T * disc * Nnd2) / 100;
+
+  return {
+    callPrice,
+    putPrice,
+    callDelta,
+    putDelta,
+    gamma,
+    vega,
+    callTheta,
+    putTheta,
+    callRho,
+    putRho,
+  };
 }
 
 // ─── Combined analysis ────────────────────────────────────────────────────────
 
 export function analyzeFinance(params: {
-  bond?:      { spec: BondSpec; annualYield: number };
+  bond?: { spec: BondSpec; annualYield: number };
   portfolio?: { holdings: PortfolioHolding[]; riskFreeRate?: number; benchmarkReturns?: number[] };
-  options?:   { S: number; K: number; T: number; r: number; sigma: number };
+  options?: { S: number; K: number; T: number; r: number; sigma: number };
 }): FinanceAnalysisResult {
   const result: FinanceAnalysisResult = { converged: true };
-  if (params.bond)      result.bond      = analyzeBond(params.bond.spec, params.bond.annualYield);
-  if (params.portfolio) result.portfolio = analyzePortfolio(
-    params.portfolio.holdings, params.portfolio.riskFreeRate, params.portfolio.benchmarkReturns,
-  );
+  if (params.bond) result.bond = analyzeBond(params.bond.spec, params.bond.annualYield);
+  if (params.portfolio)
+    result.portfolio = analyzePortfolio(
+      params.portfolio.holdings,
+      params.portfolio.riskFreeRate,
+      params.portfolio.benchmarkReturns
+    );
   if (params.options) {
     const { S, K, T, r, sigma } = params.options;
     result.options = blackScholes(S, K, T, r, sigma);
@@ -316,8 +347,8 @@ export function analyzeFinance(params: {
 // ─── Receipt ─────────────────────────────────────────────────────────────────
 
 export function buildFinanceReceipt(
-  result:  FinanceAnalysisResult,
-  options?: { runId?: string },
+  result: FinanceAnalysisResult,
+  options?: { runId?: string }
 ): FinanceReceipt {
   const violations: Array<{ criterion: string; message: string }> = [];
   if (result.bond?.price !== undefined && result.bond.price <= 0)
@@ -325,7 +356,7 @@ export function buildFinanceReceipt(
 
   const summary: Record<string, number | null | undefined> = {};
   if (result.bond) {
-    summary.bondYTM      = result.bond.ytm;
+    summary.bondYTM = result.bond.ytm;
     summary.bondDuration = result.bond.modifiedDuration;
   }
   if (result.portfolio) {
@@ -337,22 +368,22 @@ export function buildFinanceReceipt(
   }
 
   const raw = buildDomainSimulationReceipt({
-    plugin:        'banking-finance',
+    plugin: 'banking-finance',
     pluginVersion: '1.0.0',
-    runId:         options?.runId ?? `fin-${Date.now().toString(36)}`,
+    runId: options?.runId ?? `fin-${Date.now().toString(36)}`,
     solverConfig: {
       solverType: 'fixed-income-portfolio',
-      scale:      'instrument',
-      hasBond:      result.bond      !== undefined,
+      scale: 'instrument',
+      hasBond: result.bond !== undefined,
       hasPortfolio: result.portfolio !== undefined,
-      hasOptions:   result.options   !== undefined,
+      hasOptions: result.options !== undefined,
     },
     resultSummary: Object.fromEntries(
-      Object.entries(summary).filter(([, v]) => v !== undefined && v !== null),
+      Object.entries(summary).filter(([, v]) => v !== undefined && v !== null)
     ) as Record<string, number>,
     cael: {
-      version:    'cael.v1',
-      event:      'banking_finance.fixed_income',
+      version: 'cael.v1',
+      event: 'banking_finance.fixed_income',
       solverType: 'banking-finance.fixed-income-portfolio',
     },
     acceptance: { accepted: violations.length === 0, violations },

package/src/index.ts

@@ -1,8 +1,21 @@
 export { createAccountHandler, type AccountConfig, type AccountType } from './traits/AccountTrait';
-export { createTransactionHandler, type TransactionConfig, type TransactionType, type TransactionStatus } from './traits/TransactionTrait';
+export {
+  createTransactionHandler,
+  type TransactionConfig,
+  type TransactionType,
+  type TransactionStatus,
+} from './traits/TransactionTrait';
 export { createKYCHandler, type KYCConfig, type KYCLevel, type KYCStatus } from './traits/KYCTrait';
-export { createPortfolioHandler, type PortfolioConfig, type Holding } from './traits/PortfolioTrait';
-export { createRiskModelHandler, type RiskModelConfig, type RiskCategory } from './traits/RiskModelTrait';
+export {
+  createPortfolioHandler,
+  type PortfolioConfig,
+  type Holding,
+} from './traits/PortfolioTrait';
+export {
+  createRiskModelHandler,
+  type RiskModelConfig,
+  type RiskCategory,
+} from './traits/RiskModelTrait';
 export * from './traits/types';
 
 import { createAccountHandler } from './traits/AccountTrait';
@@ -13,8 +26,18 @@ import { createRiskModelHandler } from './traits/RiskModelTrait';
 
 export * from './fixedincome';
 
-export const pluginMeta = { name: '@holoscript/plugin-banking-finance', version: '1.0.0', traits: ['account', 'transaction', 'kyc', 'portfolio', 'risk_model', 'fixed_income_solver'] };
-export const traitHandlers = [createAccountHandler(), createTransactionHandler(), createKYCHandler(), createPortfolioHandler(), createRiskModelHandler()];
+export const pluginMeta = {
+  name: '@holoscript/plugin-banking-finance',
+  version: '1.0.0',
+  traits: ['account', 'transaction', 'kyc', 'portfolio', 'risk_model', 'fixed_income_solver'],
+};
+export const traitHandlers = [
+  createAccountHandler(),
+  createTransactionHandler(),
+  createKYCHandler(),
+  createPortfolioHandler(),
+  createRiskModelHandler(),
+];
 
 // Runtime integration — behavioral trait handler + registrar that wire the
 // deterministic bond-pricing solver into HoloScriptRuntime's dispatch. Closes

package/src/runtime.ts

@@ -72,12 +72,16 @@ export interface TraitDispatchContext {
 
 export interface RuntimeTraitHandler {
   name: string;
-  onAttach?: (node: unknown, config: FixedIncomeSolverTraitConfig, context: TraitDispatchContext) => void;
+  onAttach?: (
+    node: unknown,
+    config: FixedIncomeSolverTraitConfig,
+    context: TraitDispatchContext
+  ) => void;
   onUpdate?: (
     node: unknown,
     config: FixedIncomeSolverTraitConfig,
     context: TraitDispatchContext,
-    delta: number,
+    delta: number
   ) => void;
 }
 
@@ -92,7 +96,7 @@ interface FixedIncomeSolverNode {
 function solveOntoNode(
   node: unknown,
   config: FixedIncomeSolverTraitConfig | undefined,
-  context: TraitDispatchContext,
+  context: TraitDispatchContext
 ): void {
   const carrier = node as FixedIncomeSolverNode;
   const nodeId = carrier.id ?? carrier.name ?? 'unknown';

package/src/traits/AccountTrait.ts

@@ -2,22 +2,78 @@
 import type { TraitHandler, HSPlusNode, TraitContext, TraitEvent } from './types';
 
 export type AccountType = 'checking' | 'savings' | 'credit' | 'investment' | 'loan' | 'escrow';
-export interface AccountConfig { accountNumber: string; accountType: AccountType; currency: string; balance: number; interestRate: number; ownerKycId: string; }
-export interface AccountState { currentBalance: number; availableBalance: number; pendingTransactions: number; isFrozen: boolean; }
+export interface AccountConfig {
+  accountNumber: string;
+  accountType: AccountType;
+  currency: string;
+  balance: number;
+  interestRate: number;
+  ownerKycId: string;
+}
+export interface AccountState {
+  currentBalance: number;
+  availableBalance: number;
+  pendingTransactions: number;
+  isFrozen: boolean;
+}
 
-const defaultConfig: AccountConfig = { accountNumber: '', accountType: 'checking', currency: 'USD', balance: 0, interestRate: 0, ownerKycId: '' };
+const defaultConfig: AccountConfig = {
+  accountNumber: '',
+  accountType: 'checking',
+  currency: 'USD',
+  balance: 0,
+  interestRate: 0,
+  ownerKycId: '',
+};
 
 export function createAccountHandler(): TraitHandler<AccountConfig> {
-  return { name: 'account', defaultConfig,
-    onAttach(n: HSPlusNode, c: AccountConfig, ctx: TraitContext) { n.__acctState = { currentBalance: c.balance, availableBalance: c.balance, pendingTransactions: 0, isFrozen: false }; ctx.emit?.('account:opened', { type: c.accountType }); },
-    onDetach(n: HSPlusNode, _c: AccountConfig, ctx: TraitContext) { delete n.__acctState; ctx.emit?.('account:closed'); },
+  return {
+    name: 'account',
+    defaultConfig,
+    onAttach(n: HSPlusNode, c: AccountConfig, ctx: TraitContext) {
+      n.__acctState = {
+        currentBalance: c.balance,
+        availableBalance: c.balance,
+        pendingTransactions: 0,
+        isFrozen: false,
+      };
+      ctx.emit?.('account:opened', { type: c.accountType });
+    },
+    onDetach(n: HSPlusNode, _c: AccountConfig, ctx: TraitContext) {
+      delete n.__acctState;
+      ctx.emit?.('account:closed');
+    },
     onUpdate() {},
     onEvent(n: HSPlusNode, _c: AccountConfig, ctx: TraitContext, e: TraitEvent) {
-      const s = n.__acctState as AccountState | undefined; if (!s) return;
-      if (s.isFrozen) { ctx.emit?.('account:frozen_rejection'); return; }
-      if (e.type === 'account:credit') { const amt = e.payload?.amount as number; s.currentBalance += amt; s.availableBalance += amt; ctx.emit?.('account:credited', { amount: amt, balance: s.currentBalance }); }
-      if (e.type === 'account:debit') { const amt = e.payload?.amount as number; if (s.availableBalance >= amt) { s.currentBalance -= amt; s.availableBalance -= amt; ctx.emit?.('account:debited', { amount: amt, balance: s.currentBalance }); } else { ctx.emit?.('account:insufficient_funds', { requested: amt, available: s.availableBalance }); } }
-      if (e.type === 'account:freeze') { s.isFrozen = true; ctx.emit?.('account:frozen'); }
+      const s = n.__acctState as AccountState | undefined;
+      if (!s) return;
+      if (s.isFrozen) {
+        ctx.emit?.('account:frozen_rejection');
+        return;
+      }
+      if (e.type === 'account:credit') {
+        const amt = e.payload?.amount as number;
+        s.currentBalance += amt;
+        s.availableBalance += amt;
+        ctx.emit?.('account:credited', { amount: amt, balance: s.currentBalance });
+      }
+      if (e.type === 'account:debit') {
+        const amt = e.payload?.amount as number;
+        if (s.availableBalance >= amt) {
+          s.currentBalance -= amt;
+          s.availableBalance -= amt;
+          ctx.emit?.('account:debited', { amount: amt, balance: s.currentBalance });
+        } else {
+          ctx.emit?.('account:insufficient_funds', {
+            requested: amt,
+            available: s.availableBalance,
+          });
+        }
+      }
+      if (e.type === 'account:freeze') {
+        s.isFrozen = true;
+        ctx.emit?.('account:frozen');
+      }
     },
   };
 }

package/src/traits/KYCTrait.ts

@@ -3,20 +3,62 @@ import type { TraitHandler, HSPlusNode, TraitContext, TraitEvent } from './types
 
 export type KYCLevel = 'none' | 'basic' | 'enhanced' | 'full';
 export type KYCStatus = 'pending' | 'verified' | 'rejected' | 'expired' | 'under_review';
-export interface KYCConfig { level: KYCLevel; requiredDocuments: string[]; expiryDays: number; amlCheck: boolean; pepCheck: boolean; }
+export interface KYCConfig {
+  level: KYCLevel;
+  requiredDocuments: string[];
+  expiryDays: number;
+  amlCheck: boolean;
+  pepCheck: boolean;
+}
 
-const defaultConfig: KYCConfig = { level: 'basic', requiredDocuments: ['government_id', 'proof_of_address'], expiryDays: 365, amlCheck: true, pepCheck: true };
+const defaultConfig: KYCConfig = {
+  level: 'basic',
+  requiredDocuments: ['government_id', 'proof_of_address'],
+  expiryDays: 365,
+  amlCheck: true,
+  pepCheck: true,
+};
 
 export function createKYCHandler(): TraitHandler<KYCConfig> {
-  return { name: 'kyc', defaultConfig,
-    onAttach(n: HSPlusNode, _c: KYCConfig, ctx: TraitContext) { n.__kycState = { status: 'pending' as KYCStatus, documentsSubmitted: [] as string[], verifiedAt: null, riskScore: 0 }; ctx.emit?.('kyc:initiated'); },
-    onDetach(n: HSPlusNode, _c: KYCConfig, ctx: TraitContext) { delete n.__kycState; ctx.emit?.('kyc:removed'); },
+  return {
+    name: 'kyc',
+    defaultConfig,
+    onAttach(n: HSPlusNode, _c: KYCConfig, ctx: TraitContext) {
+      n.__kycState = {
+        status: 'pending' as KYCStatus,
+        documentsSubmitted: [] as string[],
+        verifiedAt: null,
+        riskScore: 0,
+      };
+      ctx.emit?.('kyc:initiated');
+    },
+    onDetach(n: HSPlusNode, _c: KYCConfig, ctx: TraitContext) {
+      delete n.__kycState;
+      ctx.emit?.('kyc:removed');
+    },
     onUpdate() {},
     onEvent(n: HSPlusNode, c: KYCConfig, ctx: TraitContext, e: TraitEvent) {
-      const s = n.__kycState as Record<string, unknown> | undefined; if (!s) return;
-      if (e.type === 'kyc:submit_document') { (s.documentsSubmitted as string[]).push(e.payload?.documentType as string); const allSubmitted = c.requiredDocuments.every(d => (s.documentsSubmitted as string[]).includes(d)); if (allSubmitted) { s.status = 'under_review'; ctx.emit?.('kyc:review_started'); } }
-      if (e.type === 'kyc:approve') { s.status = 'verified'; s.verifiedAt = Date.now(); ctx.emit?.('kyc:verified', { level: c.level }); }
-      if (e.type === 'kyc:reject') { s.status = 'rejected'; ctx.emit?.('kyc:rejected', { reason: e.payload?.reason }); }
+      const s = n.__kycState as Record<string, unknown> | undefined;
+      if (!s) return;
+      if (e.type === 'kyc:submit_document') {
+        (s.documentsSubmitted as string[]).push(e.payload?.documentType as string);
+        const allSubmitted = c.requiredDocuments.every((d) =>
+          (s.documentsSubmitted as string[]).includes(d)
+        );
+        if (allSubmitted) {
+          s.status = 'under_review';
+          ctx.emit?.('kyc:review_started');
+        }
+      }
+      if (e.type === 'kyc:approve') {
+        s.status = 'verified';
+        s.verifiedAt = Date.now();
+        ctx.emit?.('kyc:verified', { level: c.level });
+      }
+      if (e.type === 'kyc:reject') {
+        s.status = 'rejected';
+        ctx.emit?.('kyc:rejected', { reason: e.payload?.reason });
+      }
     },
   };
 }

package/src/traits/PortfolioTrait.ts

@@ -1,28 +1,66 @@
 /** @portfolio Trait — Investment portfolio management. @trait portfolio */
 import type { TraitHandler, HSPlusNode, TraitContext, TraitEvent } from './types';
 
-export interface Holding { symbol: string; quantity: number; avgCostBasis: number; currentPrice: number; assetClass: 'equity' | 'bond' | 'crypto' | 'commodity' | 'real_estate' | 'cash'; }
-export interface PortfolioConfig { holdings: Holding[]; benchmarkIndex: string; riskTolerance: 'conservative' | 'moderate' | 'aggressive'; rebalanceThreshold: number; }
-export interface PortfolioState { totalValue: number; totalCost: number; unrealizedPnL: number; dayChange: number; }
+export interface Holding {
+  symbol: string;
+  quantity: number;
+  avgCostBasis: number;
+  currentPrice: number;
+  assetClass: 'equity' | 'bond' | 'crypto' | 'commodity' | 'real_estate' | 'cash';
+}
+export interface PortfolioConfig {
+  holdings: Holding[];
+  benchmarkIndex: string;
+  riskTolerance: 'conservative' | 'moderate' | 'aggressive';
+  rebalanceThreshold: number;
+}
+export interface PortfolioState {
+  totalValue: number;
+  totalCost: number;
+  unrealizedPnL: number;
+  dayChange: number;
+}
 
-const defaultConfig: PortfolioConfig = { holdings: [], benchmarkIndex: 'SPY', riskTolerance: 'moderate', rebalanceThreshold: 5 };
+const defaultConfig: PortfolioConfig = {
+  holdings: [],
+  benchmarkIndex: 'SPY',
+  riskTolerance: 'moderate',
+  rebalanceThreshold: 5,
+};
 
 export function createPortfolioHandler(): TraitHandler<PortfolioConfig> {
-  return { name: 'portfolio', defaultConfig,
+  return {
+    name: 'portfolio',
+    defaultConfig,
     onAttach(n: HSPlusNode, c: PortfolioConfig, ctx: TraitContext) {
       const totalValue = c.holdings.reduce((s, h) => s + h.currentPrice * h.quantity, 0);
       const totalCost = c.holdings.reduce((s, h) => s + h.avgCostBasis * h.quantity, 0);
-      n.__portfolioState = { totalValue, totalCost, unrealizedPnL: totalValue - totalCost, dayChange: 0 };
+      n.__portfolioState = {
+        totalValue,
+        totalCost,
+        unrealizedPnL: totalValue - totalCost,
+        dayChange: 0,
+      };
       ctx.emit?.('portfolio:loaded', { holdings: c.holdings.length, totalValue });
     },
-    onDetach(n: HSPlusNode, _c: PortfolioConfig, ctx: TraitContext) { delete n.__portfolioState; ctx.emit?.('portfolio:closed'); },
+    onDetach(n: HSPlusNode, _c: PortfolioConfig, ctx: TraitContext) {
+      delete n.__portfolioState;
+      ctx.emit?.('portfolio:closed');
+    },
     onUpdate() {},
     onEvent(n: HSPlusNode, c: PortfolioConfig, ctx: TraitContext, e: TraitEvent) {
-      const s = n.__portfolioState as PortfolioState | undefined; if (!s) return;
+      const s = n.__portfolioState as PortfolioState | undefined;
+      if (!s) return;
       if (e.type === 'portfolio:price_update') {
-        const sym = e.payload?.symbol as string; const price = e.payload?.price as number;
-        const holding = c.holdings.find(h => h.symbol === sym);
-        if (holding) { holding.currentPrice = price; s.totalValue = c.holdings.reduce((sum, h) => sum + h.currentPrice * h.quantity, 0); s.unrealizedPnL = s.totalValue - s.totalCost; ctx.emit?.('portfolio:updated', { totalValue: s.totalValue, pnl: s.unrealizedPnL }); }
+        const sym = e.payload?.symbol as string;
+        const price = e.payload?.price as number;
+        const holding = c.holdings.find((h) => h.symbol === sym);
+        if (holding) {
+          holding.currentPrice = price;
+          s.totalValue = c.holdings.reduce((sum, h) => sum + h.currentPrice * h.quantity, 0);
+          s.unrealizedPnL = s.totalValue - s.totalCost;
+          ctx.emit?.('portfolio:updated', { totalValue: s.totalValue, pnl: s.unrealizedPnL });
+        }
       }
     },
   };

package/src/traits/RiskModelTrait.ts

@@ -2,20 +2,61 @@
 import type { TraitHandler, HSPlusNode, TraitContext, TraitEvent } from './types';
 
 export type RiskCategory = 'market' | 'credit' | 'operational' | 'liquidity' | 'regulatory';
-export interface RiskModelConfig { category: RiskCategory; varConfidenceLevel: number; timeHorizonDays: number; stressScenarios: string[]; maxExposure: number; }
-export interface RiskModelState { currentVaR: number; stressTestResults: Record<string, number>; riskScore: number; breachCount: number; }
+export interface RiskModelConfig {
+  category: RiskCategory;
+  varConfidenceLevel: number;
+  timeHorizonDays: number;
+  stressScenarios: string[];
+  maxExposure: number;
+}
+export interface RiskModelState {
+  currentVaR: number;
+  stressTestResults: Record<string, number>;
+  riskScore: number;
+  breachCount: number;
+}
 
-const defaultConfig: RiskModelConfig = { category: 'market', varConfidenceLevel: 0.99, timeHorizonDays: 1, stressScenarios: ['crash_2008', 'covid_2020', 'rate_hike'], maxExposure: 1000000 };
+const defaultConfig: RiskModelConfig = {
+  category: 'market',
+  varConfidenceLevel: 0.99,
+  timeHorizonDays: 1,
+  stressScenarios: ['crash_2008', 'covid_2020', 'rate_hike'],
+  maxExposure: 1000000,
+};
 
 export function createRiskModelHandler(): TraitHandler<RiskModelConfig> {
-  return { name: 'risk_model', defaultConfig,
-    onAttach(n: HSPlusNode, _c: RiskModelConfig, ctx: TraitContext) { n.__riskState = { currentVaR: 0, stressTestResults: {}, riskScore: 0, breachCount: 0 }; ctx.emit?.('risk:model_loaded'); },
-    onDetach(n: HSPlusNode, _c: RiskModelConfig, ctx: TraitContext) { delete n.__riskState; ctx.emit?.('risk:model_removed'); },
+  return {
+    name: 'risk_model',
+    defaultConfig,
+    onAttach(n: HSPlusNode, _c: RiskModelConfig, ctx: TraitContext) {
+      n.__riskState = { currentVaR: 0, stressTestResults: {}, riskScore: 0, breachCount: 0 };
+      ctx.emit?.('risk:model_loaded');
+    },
+    onDetach(n: HSPlusNode, _c: RiskModelConfig, ctx: TraitContext) {
+      delete n.__riskState;
+      ctx.emit?.('risk:model_removed');
+    },
     onUpdate() {},
     onEvent(n: HSPlusNode, c: RiskModelConfig, ctx: TraitContext, e: TraitEvent) {
-      const s = n.__riskState as RiskModelState | undefined; if (!s) return;
-      if (e.type === 'risk:calculate_var') { s.currentVaR = (e.payload?.portfolioValue as number ?? 0) * (1 - c.varConfidenceLevel) * Math.sqrt(c.timeHorizonDays); ctx.emit?.('risk:var_calculated', { var: s.currentVaR }); if (s.currentVaR > c.maxExposure) { s.breachCount++; ctx.emit?.('risk:breach', { var: s.currentVaR, limit: c.maxExposure }); } }
-      if (e.type === 'risk:stress_test') { for (const scenario of c.stressScenarios) { s.stressTestResults[scenario] = Math.random() * c.maxExposure * 0.3; } ctx.emit?.('risk:stress_complete', { results: s.stressTestResults }); }
+      const s = n.__riskState as RiskModelState | undefined;
+      if (!s) return;
+      if (e.type === 'risk:calculate_var') {
+        s.currentVaR =
+          ((e.payload?.portfolioValue as number) ?? 0) *
+          (1 - c.varConfidenceLevel) *
+          Math.sqrt(c.timeHorizonDays);
+        ctx.emit?.('risk:var_calculated', { var: s.currentVaR });
+        if (s.currentVaR > c.maxExposure) {
+          s.breachCount++;
+          ctx.emit?.('risk:breach', { var: s.currentVaR, limit: c.maxExposure });
+        }
+      }
+      if (e.type === 'risk:stress_test') {
+        for (const scenario of c.stressScenarios) {
+          s.stressTestResults[scenario] = Math.random() * c.maxExposure * 0.3;
+        }
+        ctx.emit?.('risk:stress_complete', { results: s.stressTestResults });
+      }
     },
   };
 }

package/src/traits/TransactionTrait.ts

@@ -1,23 +1,73 @@
 /** @transaction Trait — Financial transaction record. @trait transaction */
 import type { TraitHandler, HSPlusNode, TraitContext, TraitEvent } from './types';
 
-export type TransactionType = 'deposit' | 'withdrawal' | 'transfer' | 'payment' | 'fee' | 'interest' | 'refund';
+export type TransactionType =
+  | 'deposit'
+  | 'withdrawal'
+  | 'transfer'
+  | 'payment'
+  | 'fee'
+  | 'interest'
+  | 'refund';
 export type TransactionStatus = 'pending' | 'completed' | 'failed' | 'reversed' | 'held';
-export interface TransactionConfig { type: TransactionType; amount: number; currency: string; fromAccount: string; toAccount: string; description: string; reference: string; }
-export interface TransactionState { status: TransactionStatus; timestamp: number; settledAt: number | null; }
+export interface TransactionConfig {
+  type: TransactionType;
+  amount: number;
+  currency: string;
+  fromAccount: string;
+  toAccount: string;
+  description: string;
+  reference: string;
+}
+export interface TransactionState {
+  status: TransactionStatus;
+  timestamp: number;
+  settledAt: number | null;
+}
 
-const defaultConfig: TransactionConfig = { type: 'transfer', amount: 0, currency: 'USD', fromAccount: '', toAccount: '', description: '', reference: '' };
+const defaultConfig: TransactionConfig = {
+  type: 'transfer',
+  amount: 0,
+  currency: 'USD',
+  fromAccount: '',
+  toAccount: '',
+  description: '',
+  reference: '',
+};
 
 export function createTransactionHandler(): TraitHandler<TransactionConfig> {
-  return { name: 'transaction', defaultConfig,
-    onAttach(n: HSPlusNode, c: TransactionConfig, ctx: TraitContext) { n.__txnState = { status: 'pending' as TransactionStatus, timestamp: Date.now(), settledAt: null }; ctx.emit?.('transaction:created', { type: c.type, amount: c.amount }); },
-    onDetach(n: HSPlusNode, _c: TransactionConfig, ctx: TraitContext) { delete n.__txnState; ctx.emit?.('transaction:removed'); },
+  return {
+    name: 'transaction',
+    defaultConfig,
+    onAttach(n: HSPlusNode, c: TransactionConfig, ctx: TraitContext) {
+      n.__txnState = {
+        status: 'pending' as TransactionStatus,
+        timestamp: Date.now(),
+        settledAt: null,
+      };
+      ctx.emit?.('transaction:created', { type: c.type, amount: c.amount });
+    },
+    onDetach(n: HSPlusNode, _c: TransactionConfig, ctx: TraitContext) {
+      delete n.__txnState;
+      ctx.emit?.('transaction:removed');
+    },
     onUpdate() {},
     onEvent(n: HSPlusNode, c: TransactionConfig, ctx: TraitContext, e: TraitEvent) {
-      const s = n.__txnState as TransactionState | undefined; if (!s) return;
-      if (e.type === 'transaction:settle') { s.status = 'completed'; s.settledAt = Date.now(); ctx.emit?.('transaction:settled', { amount: c.amount, reference: c.reference }); }
-      if (e.type === 'transaction:fail') { s.status = 'failed'; ctx.emit?.('transaction:failed', { reason: e.payload?.reason }); }
-      if (e.type === 'transaction:reverse') { s.status = 'reversed'; ctx.emit?.('transaction:reversed', { amount: c.amount }); }
+      const s = n.__txnState as TransactionState | undefined;
+      if (!s) return;
+      if (e.type === 'transaction:settle') {
+        s.status = 'completed';
+        s.settledAt = Date.now();
+        ctx.emit?.('transaction:settled', { amount: c.amount, reference: c.reference });
+      }
+      if (e.type === 'transaction:fail') {
+        s.status = 'failed';
+        ctx.emit?.('transaction:failed', { reason: e.payload?.reason });
+      }
+      if (e.type === 'transaction:reverse') {
+        s.status = 'reversed';
+        ctx.emit?.('transaction:reversed', { amount: c.amount });
+      }
     },
   };
 }

package/src/traits/types.ts

@@ -1,4 +1,22 @@
-export interface HSPlusNode { id?: string; properties?: Record<string, unknown>; [key: string]: unknown; }
-export interface TraitContext { emit?: (event: string, payload?: unknown) => void; [key: string]: unknown; }
-export interface TraitEvent { type: string; payload?: Record<string, unknown>; [key: string]: unknown; }
-export interface TraitHandler<T = unknown> { name: string; defaultConfig: T; onAttach(n: HSPlusNode, c: T, ctx: TraitContext): void; onDetach(n: HSPlusNode, c: T, ctx: TraitContext): void; onUpdate(n: HSPlusNode, c: T, ctx: TraitContext, d: number): void; onEvent(n: HSPlusNode, c: T, ctx: TraitContext, e: TraitEvent): void; }
+export interface HSPlusNode {
+  id?: string;
+  properties?: Record<string, unknown>;
+  [key: string]: unknown;
+}
+export interface TraitContext {
+  emit?: (event: string, payload?: unknown) => void;
+  [key: string]: unknown;
+}
+export interface TraitEvent {
+  type: string;
+  payload?: Record<string, unknown>;
+  [key: string]: unknown;
+}
+export interface TraitHandler<T = unknown> {
+  name: string;
+  defaultConfig: T;
+  onAttach(n: HSPlusNode, c: T, ctx: TraitContext): void;
+  onDetach(n: HSPlusNode, c: T, ctx: TraitContext): void;
+  onUpdate(n: HSPlusNode, c: T, ctx: TraitContext, d: number): void;
+  onEvent(n: HSPlusNode, c: T, ctx: TraitContext, e: TraitEvent): void;
+}

package/tsconfig.json

@@ -1 +1,5 @@
-{ "extends": "../../../tsconfig.json", "compilerOptions": { "outDir": "dist", "rootDir": "src", "declaration": true }, "include": ["src"] }
+{
+  "extends": "../../../tsconfig.json",
+  "compilerOptions": { "outDir": "dist", "rootDir": "src", "declaration": true },
+  "include": ["src"]
+}

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2025-2026 HoloScript Contributors
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.