@holoscript/plugin-travel-hospitality 2.0.1 → 2.0.2

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@holoscript/plugin-travel-hospitality",
-  "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__/revenuemanagement.test.ts

@@ -66,9 +66,9 @@ describe('emsrYieldManagement', () => {
 
   it('3-class EMSR returns correct array lengths', () => {
     const threeClass: RateClass[] = [
-      { id: 'Suite',   adr: 400, expectedDemand: 20, demandStdDev: 8 },
+      { id: 'Suite', adr: 400, expectedDemand: 20, demandStdDev: 8 },
       { id: 'Standard', adr: 200, expectedDemand: 60, demandStdDev: 15 },
-      { id: 'Budget',   adr: 100, expectedDemand: 100, demandStdDev: 25 },
+      { id: 'Budget', adr: 100, expectedDemand: 100, demandStdDev: 25 },
     ];
     const r = emsrYieldManagement(200, threeClass);
     expect(r.protectionLevels).toHaveLength(3);
@@ -93,7 +93,7 @@ describe('revparAnalysis', () => {
    */
   it('occupancy = occupied / available', () => {
     const r = revparAnalysis(200, 160, 24_000);
-    expect(r.occupancyRate).toBeCloseTo(0.80, 5);
+    expect(r.occupancyRate).toBeCloseTo(0.8, 5);
   });
 
   it('ADR = revenue / occupied rooms', () => {
@@ -134,23 +134,23 @@ describe('overbookingOptimization', () => {
    * Critical ratio = 150/(150+300) = 1/3 — expect some overbooking to be optimal
    */
   it('overbooking level ≥ 0', () => {
-    const r = overbookingOptimization(100, 0.10, 150, 300, 95);
+    const r = overbookingOptimization(100, 0.1, 150, 300, 95);
     expect(r.overbook).toBeGreaterThanOrEqual(0);
   });
 
   it('authorized bookings = capacity + overbook', () => {
-    const r = overbookingOptimization(100, 0.10, 150, 300, 95);
+    const r = overbookingOptimization(100, 0.1, 150, 300, 95);
     expect(r.authorizedBookings).toBe(r.capacity + r.overbook);
   });
 
   it('higher walk cost → lower overbooking', () => {
-    const r1 = overbookingOptimization(100, 0.10, 150, 100, 90);  // low walk cost
-    const r2 = overbookingOptimization(100, 0.10, 150, 1000, 90); // high walk cost
+    const r1 = overbookingOptimization(100, 0.1, 150, 100, 90); // low walk cost
+    const r2 = overbookingOptimization(100, 0.1, 150, 1000, 90); // high walk cost
     expect(r2.overbook).toBeLessThanOrEqual(r1.overbook);
   });
 
   it('expectedWalkCost ≥ 0', () => {
-    const r = overbookingOptimization(100, 0.10, 150, 300, 95);
+    const r = overbookingOptimization(100, 0.1, 150, 300, 95);
     expect(r.expectedWalkCost).toBeGreaterThanOrEqual(0);
   });
 
@@ -231,8 +231,13 @@ describe('hotelDemandForecast', () => {
 
   it('weekend indices > weekday indices (reflects weekend demand spike)', () => {
     const r = hotelDemandForecast(historical, 7);
-    const weekdayAvg = (r.seasonalIndices[0] + r.seasonalIndices[1] + r.seasonalIndices[2] +
-                        r.seasonalIndices[3] + r.seasonalIndices[4]) / 5;
+    const weekdayAvg =
+      (r.seasonalIndices[0] +
+        r.seasonalIndices[1] +
+        r.seasonalIndices[2] +
+        r.seasonalIndices[3] +
+        r.seasonalIndices[4]) /
+      5;
     const weekendAvg = (r.seasonalIndices[5] + r.seasonalIndices[6]) / 2;
     expect(weekendAvg).toBeGreaterThan(weekdayAvg);
   });

package/src/__tests__/runtime-integration.test.ts

@@ -0,0 +1,137 @@
+/**
+ * Integration proof: the travel-hospitality `revpar` trait, once registered via
+ * the runtime's real `registerTrait` seam, is dispatched BY THE RUNTIME and runs
+ * the deterministic RevPAR analytic solver — NOT called directly as a handler
+ * object.
+ *
+ * Mirrors government-civic-plugin's runtime-integration reference
+ * (civic_decision). Drives the real path: executeNode(orb) -> orb-executor ->
+ * applyDirectives -> traitHandlers.get('revpar').onAttach -> revparAnalysis.
+ * The negative control proves the registration is load-bearing (without it, the
+ * trait is a dead no-op — which is exactly the tier's status quo).
+ *
+ * HAND-DERIVED RevPAR (real formula, NOT solver output):
+ *   availableRooms=200, occupiedRooms=150, totalRevenue=$30,000
+ *   occupancyRate = occupied/available   = 150/200      = 0.75
+ *   adr           = revenue/occupied     = 30000/150    = 200
+ *   RevPAR        = ADR × occupancy       = 200 × 0.75   = 150.00
+ *   cross-check   = revenue/available     = 30000/200    = 150.00  (agrees)
+ */
+import { describe, it, expect } from 'vitest';
+import { HoloScriptRuntime } from '@holoscript/core/runtime';
+import { registerTravelHospitalityTraitHandlers } from '../runtime';
+
+// Hand-derived expectations (see header arithmetic).
+const AVAILABLE_ROOMS = 200;
+const OCCUPIED_ROOMS = 150;
+const TOTAL_REVENUE = 30_000;
+const EXPECTED_OCCUPANCY = 0.75; // 150 / 200
+const EXPECTED_ADR = 200; // 30000 / 150
+const EXPECTED_REVPAR = 150; // 200 × 0.75  (=== 30000 / 200)
+
+function revparOrb(config: Record<string, unknown>): unknown {
+  return {
+    type: 'orb',
+    name: 'revpar-orb',
+    properties: {},
+    methods: [],
+    position: [0, 0, 0],
+    hologram: { shape: 'orb', color: '#fff', size: 1, glow: false, interactive: false },
+    directives: [{ type: 'trait', name: 'revpar', config }],
+  };
+}
+
+/** Flush the runtime's async emit dispatch so `on` listeners have fired. */
+const flush = (): Promise<void> => new Promise((resolve) => setTimeout(resolve, 0));
+
+describe('travel-hospitality -> HoloScript runtime integration (revpar)', () => {
+  it('runtime dispatch runs the RevPAR solver for a registered @revpar orb', async () => {
+    const runtime = new HoloScriptRuntime();
+    registerTravelHospitalityTraitHandlers(runtime);
+
+    const solved: Array<Record<string, unknown>> = [];
+    runtime.on('revpar_solved', (e: unknown) => {
+      solved.push(e as Record<string, unknown>);
+    });
+
+    await runtime.executeNode(
+      revparOrb({
+        availableRooms: AVAILABLE_ROOMS,
+        occupiedRooms: OCCUPIED_ROOMS,
+        totalRevenue: TOTAL_REVENUE,
+      }) as never
+    );
+    await flush();
+
+    expect(solved).toHaveLength(1);
+    const summary = solved[0];
+    // Asserted against the HAND derivation above, NOT against solver output:
+    //   RevPAR = ADR × occupancy = 200 × 0.75 = 150.00
+    expect(summary.revpar as number).toBeCloseTo(EXPECTED_REVPAR, 6);
+    expect(summary.adr as number).toBeCloseTo(EXPECTED_ADR, 6);
+    expect(summary.occupancyRate as number).toBeCloseTo(EXPECTED_OCCUPANCY, 6);
+    expect(summary.availableRooms).toBe(AVAILABLE_ROOMS);
+    expect(summary.occupiedRooms).toBe(OCCUPIED_ROOMS);
+  });
+
+  it('NEGATIVE CONTROL: without registration the @revpar trait is a dead no-op', async () => {
+    const runtime = new HoloScriptRuntime(); // intentionally NOT registered
+    const solved: unknown[] = [];
+    runtime.on('revpar_solved', (e: unknown) => solved.push(e));
+
+    await runtime.executeNode(
+      revparOrb({
+        availableRooms: AVAILABLE_ROOMS,
+        occupiedRooms: OCCUPIED_ROOMS,
+        totalRevenue: TOTAL_REVENUE,
+      }) as never
+    );
+    await flush();
+
+    expect(solved).toHaveLength(0);
+  });
+
+  it('persists the solver result into durable runtime state on ATTACH', async () => {
+    const runtime = new HoloScriptRuntime();
+    registerTravelHospitalityTraitHandlers(runtime);
+
+    await runtime.executeNode(
+      revparOrb({
+        availableRooms: AVAILABLE_ROOMS,
+        occupiedRooms: OCCUPIED_ROOMS,
+        totalRevenue: TOTAL_REVENUE,
+      }) as never
+    );
+    await flush();
+
+    const state = runtime.getState() as Record<string, unknown>;
+    const persisted = state['revpar:revpar-orb'] as
+      | { revpar?: number; occupancyRate?: number }
+      | undefined;
+    expect(persisted).toBeDefined();
+    // Same hand-derived RevPAR = 150.00.
+    expect(persisted?.revpar).toBeCloseTo(EXPECTED_REVPAR, 6);
+    expect(persisted?.occupancyRate).toBeCloseTo(EXPECTED_OCCUPANCY, 6);
+  });
+
+  it('emits revpar_error (does not throw through the runtime) for invalid config', async () => {
+    const runtime = new HoloScriptRuntime();
+    registerTravelHospitalityTraitHandlers(runtime);
+
+    const errors: Array<Record<string, unknown>> = [];
+    runtime.on('revpar_error', (e: unknown) => {
+      errors.push(e as Record<string, unknown>);
+    });
+
+    // Zero available rooms + negative revenue: the real solver validates
+    // `availableRooms <= 0` first and throws "availableRooms must be positive",
+    // which the handler's try/catch turns into a revpar_error rather than a throw.
+    await runtime.executeNode(
+      revparOrb({ availableRooms: 0, occupiedRooms: 0, totalRevenue: -5_000 }) as never
+    );
+    await flush();
+
+    expect(errors).toHaveLength(1);
+    expect(String(errors[0].error)).toContain('availableRooms');
+  });
+});

package/src/index.ts

@@ -1,6 +1,18 @@
-export { createReservationHandler, type ReservationConfig, type ReservationStatus } from './traits/ReservationTrait';
-export { createItineraryHandler, type ItineraryConfig, type ItineraryItem } from './traits/ItineraryTrait';
-export { createRateManagementHandler, type RateManagementConfig, type RatePeriod } from './traits/RateManagementTrait';
+export {
+  createReservationHandler,
+  type ReservationConfig,
+  type ReservationStatus,
+} from './traits/ReservationTrait';
+export {
+  createItineraryHandler,
+  type ItineraryConfig,
+  type ItineraryItem,
+} from './traits/ItineraryTrait';
+export {
+  createRateManagementHandler,
+  type RateManagementConfig,
+  type RatePeriod,
+} from './traits/RateManagementTrait';
 export * from './traits/types';
 
 import { createReservationHandler } from './traits/ReservationTrait';
@@ -9,5 +21,36 @@ import { createRateManagementHandler } from './traits/RateManagementTrait';
 
 export * from './revenuemanagement';
 
-export const pluginMeta = { name: '@holoscript/plugin-travel-hospitality', version: '1.0.0', traits: ['reservation', 'itinerary', 'rate_management', 'emsr_yield', 'revpar', 'overbooking', 'group_displacement', 'demand_forecast'] };
-export const traitHandlers = [createReservationHandler(), createItineraryHandler(), createRateManagementHandler()];
+// Runtime integration — behavioral trait handler + registrar that wire the
+// deterministic RevPAR analytic solver into HoloScriptRuntime's dispatch. Closes
+// the built-but-dead-wired gap for `revpar`, mirroring government-civic's
+// `civic_decision` reference integration.
+export {
+  TRAVEL_HOSPITALITY_PLUGIN_ID,
+  revparHandler,
+  registerTravelHospitalityTraitHandlers,
+  type RevparTraitConfig,
+  type RevparSolvedEvent,
+  type RuntimeTraitHandler,
+  type TraitRegistrar,
+} from './runtime';
+
+export const pluginMeta = {
+  name: '@holoscript/plugin-travel-hospitality',
+  version: '1.0.0',
+  traits: [
+    'reservation',
+    'itinerary',
+    'rate_management',
+    'emsr_yield',
+    'revpar',
+    'overbooking',
+    'group_displacement',
+    'demand_forecast',
+  ],
+};
+export const traitHandlers = [
+  createReservationHandler(),
+  createItineraryHandler(),
+  createRateManagementHandler(),
+];

package/src/revenuemanagement.ts

@@ -106,23 +106,22 @@ export interface RevenueReceiptOptions {
 function normalCDF(x: number): number {
   if (x < -6) return 0;
   if (x > 6) return 1;
-  const a1 = 0.254829592, a2 = -0.284496736, a3 = 1.421413741;
-  const a4 = -1.453152027, a5 = 1.061405429, p = 0.3275911;
+  const a1 = 0.254829592,
+    a2 = -0.284496736,
+    a3 = 1.421413741;
+  const a4 = -1.453152027,
+    a5 = 1.061405429,
+    p = 0.3275911;
   const sign = x >= 0 ? 1 : -1;
   const absX = Math.abs(x);
   const t = 1 / (1 + p * absX);
-  const poly = ((((a5 * t + a4) * t) + a3) * t + a2) * t + a1;
+  const poly = (((a5 * t + a4) * t + a3) * t + a2) * t + a1;
   const erfVal = 1 - poly * t * Math.exp(-absX * absX);
   return 0.5 * (1 + sign * erfVal);
 }
 
 /** Littlewood's rule: P(demand ≥ x) ≥ r_low/r_high → protect x seats for high class */
-function littlewoodProtection(
-  rLow: number,
-  rHigh: number,
-  mu: number,
-  sigma: number,
-): number {
+function littlewoodProtection(rLow: number, rHigh: number, mu: number, sigma: number): number {
   // Find x such that P(D_high ≥ x) = r_low / r_high
   const threshold = rLow / rHigh;
   // P(D ≥ x) = 1 - Φ((x - μ)/σ)
@@ -137,28 +136,42 @@ function littlewoodProtection(
 function normInvApprox(p: number): number {
   if (p <= 0) return -6;
   if (p >= 1) return 6;
-  const a = [-3.969683028665376e+01, 2.209460984245205e+02, -2.759285104469687e+02,
-              1.383577518672690e+02, -3.066479806614716e+01, 2.506628277459239e+00];
-  const b = [-5.447609879822406e+01, 1.615858368580409e+02, -1.556989798598866e+02,
-              6.680131188771972e+01, -1.328068155288572e+01];
-  const c = [-7.784894002430293e-03, -3.223964580411365e-01, -2.400758277161838e+00,
-              -2.549732539343734e+00, 4.374664141464968e+00, 2.938163982698783e+00];
-  const d = [7.784695709041462e-03, 3.224671290700398e-01, 2.445134137142996e+00, 3.754408661907416e+00];
-  const pLow = 0.02425, pHigh = 1 - pLow;
+  const a = [
+    -3.969683028665376e1, 2.209460984245205e2, -2.759285104469687e2, 1.38357751867269e2,
+    -3.066479806614716e1, 2.506628277459239,
+  ];
+  const b = [
+    -5.447609879822406e1, 1.615858368580409e2, -1.556989798598866e2, 6.680131188771972e1,
+    -1.328068155288572e1,
+  ];
+  const c = [
+    -7.784894002430293e-3, -3.223964580411365e-1, -2.400758277161838, -2.549732539343734,
+    4.374664141464968, 2.938163982698783,
+  ];
+  const d = [7.784695709041462e-3, 3.224671290700398e-1, 2.445134137142996, 3.754408661907416];
+  const pLow = 0.02425,
+    pHigh = 1 - pLow;
 
   let q: number, r: number;
   if (p < pLow) {
     q = Math.sqrt(-2 * Math.log(p));
-    return (((((c[0]*q+c[1])*q+c[2])*q+c[3])*q+c[4])*q+c[5]) /
-           ((((d[0]*q+d[1])*q+d[2])*q+d[3])*q+1);
+    return (
+      (((((c[0] * q + c[1]) * q + c[2]) * q + c[3]) * q + c[4]) * q + c[5]) /
+      ((((d[0] * q + d[1]) * q + d[2]) * q + d[3]) * q + 1)
+    );
   } else if (p <= pHigh) {
-    q = p - 0.5; r = q * q;
-    return (((((a[0]*r+a[1])*r+a[2])*r+a[3])*r+a[4])*r+a[5])*q /
-           (((((b[0]*r+b[1])*r+b[2])*r+b[3])*r+b[4])*r+1);
+    q = p - 0.5;
+    r = q * q;
+    return (
+      ((((((a[0] * r + a[1]) * r + a[2]) * r + a[3]) * r + a[4]) * r + a[5]) * q) /
+      (((((b[0] * r + b[1]) * r + b[2]) * r + b[3]) * r + b[4]) * r + 1)
+    );
   } else {
     q = Math.sqrt(-2 * Math.log(1 - p));
-    return -(((((c[0]*q+c[1])*q+c[2])*q+c[3])*q+c[4])*q+c[5]) /
-             ((((d[0]*q+d[1])*q+d[2])*q+d[3])*q+1);
+    return (
+      -(((((c[0] * q + c[1]) * q + c[2]) * q + c[3]) * q + c[4]) * q + c[5]) /
+      ((((d[0] * q + d[1]) * q + d[2]) * q + d[3]) * q + 1)
+    );
   }
 }
 
@@ -167,10 +180,7 @@ function normInvApprox(p: number): number {
  * Rate classes must be provided in any order; sorted high→low ADR internally.
  * capacity: total rooms available.
  */
-export function emsrYieldManagement(
-  capacity: number,
-  rateClasses: RateClass[],
-): EMSRResult {
+export function emsrYieldManagement(capacity: number, rateClasses: RateClass[]): EMSRResult {
   if (capacity <= 0) throw new Error('capacity must be positive');
   if (rateClasses.length === 0) throw new Error('At least one rate class required');
 
@@ -182,13 +192,14 @@ export function emsrYieldManagement(
 
   // EMSR-b: aggregate demand from classes j+1..n and find protection for class j
   for (let j = 0; j < sorted.length - 1; j++) {
-    const r_j   = sorted[j].adr;       // higher class fare
-    const r_j1  = sorted[j + 1].adr;   // lower class fare
+    const r_j = sorted[j].adr; // higher class fare
+    const r_j1 = sorted[j + 1].adr; // lower class fare
 
     // Aggregate demand for classes 0..j (high-value classes)
-    let aggMu = 0, aggVar = 0;
+    let aggMu = 0,
+      aggVar = 0;
     for (let k = 0; k <= j; k++) {
-      aggMu  += sorted[k].expectedDemand;
+      aggMu += sorted[k].expectedDemand;
       aggVar += sorted[k].demandStdDev ** 2;
     }
     const aggSigma = Math.sqrt(aggVar);
@@ -222,7 +233,7 @@ export function emsrYieldManagement(
 export function revparAnalysis(
   availableRooms: number,
   occupiedRooms: number,
-  totalRevenue: number,
+  totalRevenue: number
 ): RevPARResult {
   if (availableRooms <= 0) throw new Error('availableRooms must be positive');
   if (occupiedRooms < 0) throw new Error('occupiedRooms must be non-negative');
@@ -249,7 +260,7 @@ export function overbookingOptimization(
   noShowRate: number,
   adr: number,
   walkCostPerGuest: number,
-  expectedBookings: number,
+  expectedBookings: number
 ): OverbookingResult {
   if (capacity <= 0) throw new Error('capacity must be positive');
   if (noShowRate < 0 || noShowRate > 1) throw new Error('noShowRate must be in [0, 1]');
@@ -282,7 +293,8 @@ export function overbookingOptimization(
   // Expected walks = E[max(0, shows - capacity)] where shows = bookings - noShows
   let expectedWalks = 0;
   for (let w = 1; w <= optOverbook + 5; w++) {
-    const pWalk = 1 - normalCDF((w - 0.5 - (authorizedBookings - mu - capacity)) / Math.max(sigma, 0.1));
+    const pWalk =
+      1 - normalCDF((w - 0.5 - (authorizedBookings - mu - capacity)) / Math.max(sigma, 0.1));
     expectedWalks += pWalk;
     if (pWalk < 1e-6) break;
   }
@@ -292,7 +304,15 @@ export function overbookingOptimization(
   // Revenue gain vs no-overbooking: each additional booking accepted at ADR, less expected walk cost
   const expectedRevenueGain = Math.max(0, optOverbook * adr * noShowRate - expectedWalkCost);
 
-  return { capacity, overbook: optOverbook, authorizedBookings, noShowRate, walkCostPerGuest, expectedWalkCost, expectedRevenueGain };
+  return {
+    capacity,
+    overbook: optOverbook,
+    authorizedBookings,
+    noShowRate,
+    walkCostPerGuest,
+    expectedWalkCost,
+    expectedRevenueGain,
+  };
 }
 
 // ─── Group displacement ───────────────────────────────────────────────────────
@@ -304,14 +324,15 @@ export function groupDisplacementAnalysis(
   groupAdr: number,
   groupRoomNights: number,
   transientAdr: number,
-  transientDemandProbability = 1.0,
+  transientDemandProbability = 1.0
 ): GroupDisplacementResult {
   if (groupAdr <= 0) throw new Error('groupAdr must be positive');
   if (groupRoomNights <= 0) throw new Error('groupRoomNights must be positive');
   if (transientAdr <= 0) throw new Error('transientAdr must be positive');
 
   const displacementCost = (transientAdr - groupAdr) * groupRoomNights * transientDemandProbability;
-  const netValue = groupAdr * groupRoomNights - (transientAdr * groupRoomNights * transientDemandProbability);
+  const netValue =
+    groupAdr * groupRoomNights - transientAdr * groupRoomNights * transientDemandProbability;
   const profitable = netValue > 0;
 
   return { groupAdr, groupRoomNights, transientAdr, displacementCost, netValue, profitable };
@@ -325,9 +346,10 @@ export function groupDisplacementAnalysis(
  */
 export function hotelDemandForecast(
   historical: number[],
-  forecastDays: number,
+  forecastDays: number
 ): HotelForecastResult {
-  if (historical.length < 14) throw new Error('At least 14 days of history required for seasonal estimation');
+  if (historical.length < 14)
+    throw new Error('At least 14 days of history required for seasonal estimation');
   if (forecastDays < 1) throw new Error('forecastDays must be ≥ 1');
 
   // Estimate weekly seasonal indices (7 days)
@@ -341,7 +363,7 @@ export function hotelDemandForecast(
     dayCounts[dow]++;
   });
   seasonalIndices.forEach((s, i) => {
-    seasonalIndices[i] = overallMean > 0 ? (s / dayCounts[i]) / overallMean : 1;
+    seasonalIndices[i] = overallMean > 0 ? s / dayCounts[i] / overallMean : 1;
   });
 
   // Deseasonalise
@@ -385,11 +407,11 @@ export interface TravelAnalysisResult {
 
 export function buildTravelReceipt(
   result: TravelAnalysisResult,
-  options?: RevenueReceiptOptions,
+  options?: RevenueReceiptOptions
 ): DomainSimulationReceipt {
   const violations: Array<{ criterion: string; message: string }> = [];
 
-  if (result.revpar && result.revpar.occupancyRate < 0.40) {
+  if (result.revpar && result.revpar.occupancyRate < 0.4) {
     violations.push({
       criterion: 'occupancy',
       message: `Occupancy ${(result.revpar.occupancyRate * 100).toFixed(1)}% is critically low (<40%)`,
@@ -413,7 +435,11 @@ export function buildTravelReceipt(
       emsrExpectedRevenue: result.emsr?.expectedRevenue ?? null,
       overbookLevel: result.overbooking?.overbook ?? null,
     },
-    cael: { version: 'cael.v1', event: 'travel_hospitality.revenue_management', solverType: 'travel-hospitality.emsr-b' },
+    cael: {
+      version: 'cael.v1',
+      event: 'travel_hospitality.revenue_management',
+      solverType: 'travel-hospitality.emsr-b',
+    },
     acceptance: { accepted: violations.length === 0, violations },
   });
 }

package/src/runtime.ts

@@ -0,0 +1,162 @@
+/**
+ * Runtime integration for @holoscript/plugin-travel-hospitality.
+ *
+ * Bridges the previously dead-wired `revpar` trait into a behavioral
+ * TraitHandler that the HoloScript runtime actually dispatches
+ * (HoloScriptRuntime.registerTrait -> applyDirectives / updateTraits).
+ *
+ * Before this module the plugin declared trait NAMES only (pluginMeta.traits)
+ * and exported the revenue-management solvers (revparAnalysis,
+ * emsrYieldManagement, …), but nothing invoked a solver THROUGH the runtime —
+ * the whole domain-plugin tier was built-but-dead-wired. This mirrors
+ * government-civic-plugin's reference integration (civic_decision): it wires the
+ * deterministic RevPAR analytic solver (`revparAnalysis`) behind the `revpar`
+ * trait so the runtime's directive dispatch can run it. The remaining
+ * travel-hospitality traits follow the same registrar shape.
+ *
+ * RevPAR (Revenue Per Available Room) = Room Revenue / Available Room-nights,
+ * equivalently ADR × Occupancy (revparAnalysis computes both and they agree).
+ */
+import { registerPluginTraits } from '@holoscript/core/runtime';
+import { revparAnalysis, type RevPARResult } from './revenuemanagement';
+
+/** Stable id for this plugin's trait ownership tagging. */
+export const TRAVEL_HOSPITALITY_PLUGIN_ID = 'travel-hospitality' as const;
+
+/** Config carried by an orb's `@revpar` trait directive. */
+export interface RevparTraitConfig {
+  /** Rooms available for the period. Required; absence/invalid emits `revpar_error`. */
+  availableRooms?: number;
+  /** Rooms occupied for the period. Required. */
+  occupiedRooms?: number;
+  /** Total room revenue for the period ($). Required. */
+  totalRevenue?: number;
+}
+
+/** Summary payload emitted on `revpar_solved`. */
+export interface RevparSolvedEvent {
+  nodeId: string;
+  /** Revenue Per Available Room = ADR × occupancy ($). */
+  revpar: number;
+  /** Average Daily Rate ($). */
+  adr: number;
+  /** Occupancy rate [0,1]. */
+  occupancyRate: number;
+  /** Rooms available evaluated. */
+  availableRooms: number;
+  /** Rooms occupied evaluated. */
+  occupiedRooms: number;
+  /** Total room revenue evaluated ($). */
+  totalRevenue: number;
+}
+
+/**
+ * Structural view of the runtime trait-handler contract. Matches
+ * `@holoscript/core` TraitTypes.TraitHandler at the call sites the runtime
+ * actually uses (onAttach / onUpdate receive the node, the directive config,
+ * and a context exposing `emit`). Declared locally so the plugin stays
+ * decoupled from core's full trait surface.
+ */
+export interface TraitDispatchContext {
+  emit: (event: string, payload?: unknown) => void;
+  setState?: (updates: Record<string, unknown>) => void;
+}
+
+export interface RuntimeTraitHandler {
+  name: string;
+  onAttach?: (node: unknown, config: RevparTraitConfig, context: TraitDispatchContext) => void;
+  onUpdate?: (
+    node: unknown,
+    config: RevparTraitConfig,
+    context: TraitDispatchContext,
+    delta: number
+  ) => void;
+}
+
+interface RevparNode {
+  id?: string;
+  name?: string;
+  properties?: Record<string, unknown>;
+  __revparResult?: RevPARResult;
+}
+
+/** Run the RevPAR solver on the directive config, write the result onto the node, and emit. */
+function solveOntoNode(
+  node: unknown,
+  config: RevparTraitConfig | undefined,
+  context: TraitDispatchContext
+): void {
+  const carrier = node as RevparNode;
+  const nodeId = carrier.id ?? carrier.name ?? 'unknown';
+  const availableRooms = config?.availableRooms;
+  const occupiedRooms = config?.occupiedRooms;
+  const totalRevenue = config?.totalRevenue;
+
+  if (
+    typeof availableRooms !== 'number' ||
+    typeof occupiedRooms !== 'number' ||
+    typeof totalRevenue !== 'number'
+  ) {
+    context.emit('revpar_error', {
+      nodeId,
+      error:
+        'revpar trait requires numeric config.availableRooms, config.occupiedRooms, and config.totalRevenue',
+    });
+    return;
+  }
+
+  try {
+    const result = revparAnalysis(availableRooms, occupiedRooms, totalRevenue);
+    carrier.__revparResult = result;
+    carrier.properties = {
+      ...(carrier.properties ?? {}),
+      revpar: result.revpar,
+      revparAdr: result.adr,
+      revparOccupancyRate: result.occupancyRate,
+    };
+    const summary: RevparSolvedEvent = {
+      nodeId,
+      revpar: result.revpar,
+      adr: result.adr,
+      occupancyRate: result.occupancyRate,
+      availableRooms: result.availableRooms,
+      occupiedRooms: result.occupiedRooms,
+      totalRevenue: result.totalRevenue,
+    };
+    context.setState?.({ [`revpar:${nodeId}`]: summary });
+    context.emit('revpar_solved', summary);
+  } catch (error) {
+    context.emit('revpar_error', {
+      nodeId,
+      error: error instanceof Error ? error.message : String(error),
+    });
+  }
+}
+
+/**
+ * Behavioral handler for the travel-hospitality `revpar` trait. Runs the
+ * deterministic RevPAR analytic solver whenever an orb carrying the trait is
+ * attached (and on each per-frame update), writing the result onto the node and
+ * emitting `revpar_solved` / `revpar_error`.
+ */
+export const revparHandler: RuntimeTraitHandler = {
+  name: 'revpar',
+  onAttach: (node, config, context) => solveOntoNode(node, config, context),
+  onUpdate: (node, config, context) => solveOntoNode(node, config, context),
+};
+
+/** A runtime that can register behavioral trait handlers. */
+export interface TraitRegistrar {
+  registerTrait(name: string, handler: unknown): void;
+}
+
+/**
+ * Register travel-hospitality behavioral trait handlers into a runtime that
+ * exposes `registerTrait(name, handler)` — e.g. `@holoscript/core`
+ * HoloScriptRuntime. This is the consumption path the dead-wired tier was
+ * missing: after this call the runtime's directive dispatch (applyDirectives /
+ * updateTraits) will invoke the RevPAR solver for `@revpar` orbs.
+ */
+export function registerTravelHospitalityTraitHandlers(registrar: TraitRegistrar): void {
+  registerPluginTraits(registrar, TRAVEL_HOSPITALITY_PLUGIN_ID, [revparHandler]);
+}

package/src/traits/ItineraryTrait.ts

@@ -1,25 +1,73 @@
 /** @itinerary Trait — Trip itinerary planning. @trait itinerary */
 import type { TraitHandler, HSPlusNode, TraitContext, TraitEvent } from './types';
 
-export interface ItineraryItem { id: string; day: number; time: string; activity: string; location: string; durationMin: number; bookingRef?: string; notes?: string; }
-export interface ItineraryConfig { tripName: string; startDate: string; endDate: string; travelers: number; items: ItineraryItem[]; }
-export interface ItineraryState { currentDay: number; completedItems: string[]; totalDays: number; }
+export interface ItineraryItem {
+  id: string;
+  day: number;
+  time: string;
+  activity: string;
+  location: string;
+  durationMin: number;
+  bookingRef?: string;
+  notes?: string;
+}
+export interface ItineraryConfig {
+  tripName: string;
+  startDate: string;
+  endDate: string;
+  travelers: number;
+  items: ItineraryItem[];
+}
+export interface ItineraryState {
+  currentDay: number;
+  completedItems: string[];
+  totalDays: number;
+}
 
-const defaultConfig: ItineraryConfig = { tripName: '', startDate: '', endDate: '', travelers: 1, items: [] };
+const defaultConfig: ItineraryConfig = {
+  tripName: '',
+  startDate: '',
+  endDate: '',
+  travelers: 1,
+  items: [],
+};
 
 export function createItineraryHandler(): TraitHandler<ItineraryConfig> {
-  return { name: 'itinerary', defaultConfig,
+  return {
+    name: 'itinerary',
+    defaultConfig,
     onAttach(n: HSPlusNode, c: ItineraryConfig, ctx: TraitContext) {
-      const days = c.startDate && c.endDate ? Math.max(1, Math.ceil((new Date(c.endDate).getTime() - new Date(c.startDate).getTime()) / 86400000)) : 1;
+      const days =
+        c.startDate && c.endDate
+          ? Math.max(
+              1,
+              Math.ceil(
+                (new Date(c.endDate).getTime() - new Date(c.startDate).getTime()) / 86400000
+              )
+            )
+          : 1;
       n.__itinState = { currentDay: 1, completedItems: [], totalDays: days };
       ctx.emit?.('itinerary:planned', { days, items: c.items.length });
     },
-    onDetach(n: HSPlusNode, _c: ItineraryConfig, ctx: TraitContext) { delete n.__itinState; ctx.emit?.('itinerary:removed'); },
+    onDetach(n: HSPlusNode, _c: ItineraryConfig, ctx: TraitContext) {
+      delete n.__itinState;
+      ctx.emit?.('itinerary:removed');
+    },
     onUpdate() {},
     onEvent(n: HSPlusNode, _c: ItineraryConfig, ctx: TraitContext, e: TraitEvent) {
-      const s = n.__itinState as ItineraryState | undefined; if (!s) return;
-      if (e.type === 'itinerary:complete_item') { const id = e.payload?.itemId as string; if (!s.completedItems.includes(id)) { s.completedItems.push(id); ctx.emit?.('itinerary:item_done', { id, completed: s.completedItems.length }); } }
-      if (e.type === 'itinerary:next_day') { s.currentDay = Math.min(s.totalDays, s.currentDay + 1); ctx.emit?.('itinerary:day_changed', { day: s.currentDay }); }
+      const s = n.__itinState as ItineraryState | undefined;
+      if (!s) return;
+      if (e.type === 'itinerary:complete_item') {
+        const id = e.payload?.itemId as string;
+        if (!s.completedItems.includes(id)) {
+          s.completedItems.push(id);
+          ctx.emit?.('itinerary:item_done', { id, completed: s.completedItems.length });
+        }
+      }
+      if (e.type === 'itinerary:next_day') {
+        s.currentDay = Math.min(s.totalDays, s.currentDay + 1);
+        ctx.emit?.('itinerary:day_changed', { day: s.currentDay });
+      }
     },
   };
 }

package/src/traits/RateManagementTrait.ts

@@ -1,24 +1,67 @@
 /** @rate_management Trait — Dynamic pricing and rate control. @trait rate_management */
 import type { TraitHandler, HSPlusNode, TraitContext, TraitEvent } from './types';
 
-export interface RatePeriod { startDate: string; endDate: string; rate: number; minStay: number; }
-export interface RateManagementConfig { baseRate: number; currency: string; seasons: RatePeriod[]; weekendMultiplier: number; dynamicPricingEnabled: boolean; minRate: number; maxRate: number; }
-export interface RateManagementState { currentRate: number; occupancyPercent: number; revenueToday: number; }
+export interface RatePeriod {
+  startDate: string;
+  endDate: string;
+  rate: number;
+  minStay: number;
+}
+export interface RateManagementConfig {
+  baseRate: number;
+  currency: string;
+  seasons: RatePeriod[];
+  weekendMultiplier: number;
+  dynamicPricingEnabled: boolean;
+  minRate: number;
+  maxRate: number;
+}
+export interface RateManagementState {
+  currentRate: number;
+  occupancyPercent: number;
+  revenueToday: number;
+}
 
-const defaultConfig: RateManagementConfig = { baseRate: 100, currency: 'USD', seasons: [], weekendMultiplier: 1.2, dynamicPricingEnabled: false, minRate: 50, maxRate: 500 };
+const defaultConfig: RateManagementConfig = {
+  baseRate: 100,
+  currency: 'USD',
+  seasons: [],
+  weekendMultiplier: 1.2,
+  dynamicPricingEnabled: false,
+  minRate: 50,
+  maxRate: 500,
+};
 
 export function createRateManagementHandler(): TraitHandler<RateManagementConfig> {
-  return { name: 'rate_management', defaultConfig,
-    onAttach(n: HSPlusNode, c: RateManagementConfig, ctx: TraitContext) { n.__rateState = { currentRate: c.baseRate, occupancyPercent: 0, revenueToday: 0 }; ctx.emit?.('rate:configured', { base: c.baseRate }); },
-    onDetach(n: HSPlusNode, _c: RateManagementConfig, ctx: TraitContext) { delete n.__rateState; ctx.emit?.('rate:removed'); },
+  return {
+    name: 'rate_management',
+    defaultConfig,
+    onAttach(n: HSPlusNode, c: RateManagementConfig, ctx: TraitContext) {
+      n.__rateState = { currentRate: c.baseRate, occupancyPercent: 0, revenueToday: 0 };
+      ctx.emit?.('rate:configured', { base: c.baseRate });
+    },
+    onDetach(n: HSPlusNode, _c: RateManagementConfig, ctx: TraitContext) {
+      delete n.__rateState;
+      ctx.emit?.('rate:removed');
+    },
     onUpdate() {},
     onEvent(n: HSPlusNode, c: RateManagementConfig, ctx: TraitContext, e: TraitEvent) {
-      const s = n.__rateState as RateManagementState | undefined; if (!s) return;
+      const s = n.__rateState as RateManagementState | undefined;
+      if (!s) return;
       if (e.type === 'rate:update_occupancy') {
         s.occupancyPercent = (e.payload?.occupancy as number) ?? 0;
-        if (c.dynamicPricingEnabled) { s.currentRate = Math.min(c.maxRate, Math.max(c.minRate, c.baseRate * (1 + s.occupancyPercent / 100))); ctx.emit?.('rate:adjusted', { rate: s.currentRate, occupancy: s.occupancyPercent }); }
+        if (c.dynamicPricingEnabled) {
+          s.currentRate = Math.min(
+            c.maxRate,
+            Math.max(c.minRate, c.baseRate * (1 + s.occupancyPercent / 100))
+          );
+          ctx.emit?.('rate:adjusted', { rate: s.currentRate, occupancy: s.occupancyPercent });
+        }
+      }
+      if (e.type === 'rate:record_sale') {
+        s.revenueToday += s.currentRate;
+        ctx.emit?.('rate:sale_recorded', { revenue: s.revenueToday });
       }
-      if (e.type === 'rate:record_sale') { s.revenueToday += s.currentRate; ctx.emit?.('rate:sale_recorded', { revenue: s.revenueToday }); }
     },
   };
 }

package/src/traits/ReservationTrait.ts

@@ -1,27 +1,84 @@
 /** @reservation Trait — Booking and reservation management. @trait reservation */
 import type { TraitHandler, HSPlusNode, TraitContext, TraitEvent } from './types';
 
-export type ReservationStatus = 'pending' | 'confirmed' | 'checked_in' | 'checked_out' | 'cancelled' | 'no_show';
-export interface ReservationConfig { confirmationNumber: string; guestName: string; roomType: string; checkIn: string; checkOut: string; guests: number; ratePerNight: number; currency: string; specialRequests?: string; }
-export interface ReservationState { status: ReservationStatus; totalNights: number; totalCost: number; }
+export type ReservationStatus =
+  | 'pending'
+  | 'confirmed'
+  | 'checked_in'
+  | 'checked_out'
+  | 'cancelled'
+  | 'no_show';
+export interface ReservationConfig {
+  confirmationNumber: string;
+  guestName: string;
+  roomType: string;
+  checkIn: string;
+  checkOut: string;
+  guests: number;
+  ratePerNight: number;
+  currency: string;
+  specialRequests?: string;
+}
+export interface ReservationState {
+  status: ReservationStatus;
+  totalNights: number;
+  totalCost: number;
+}
 
-const defaultConfig: ReservationConfig = { confirmationNumber: '', guestName: '', roomType: 'standard', checkIn: '', checkOut: '', guests: 1, ratePerNight: 0, currency: 'USD' };
+const defaultConfig: ReservationConfig = {
+  confirmationNumber: '',
+  guestName: '',
+  roomType: 'standard',
+  checkIn: '',
+  checkOut: '',
+  guests: 1,
+  ratePerNight: 0,
+  currency: 'USD',
+};
 
 export function createReservationHandler(): TraitHandler<ReservationConfig> {
-  return { name: 'reservation', defaultConfig,
+  return {
+    name: 'reservation',
+    defaultConfig,
     onAttach(n: HSPlusNode, c: ReservationConfig, ctx: TraitContext) {
-      const nights = c.checkIn && c.checkOut ? Math.max(1, Math.ceil((new Date(c.checkOut).getTime() - new Date(c.checkIn).getTime()) / 86400000)) : 1;
-      n.__resState = { status: 'pending' as ReservationStatus, totalNights: nights, totalCost: nights * c.ratePerNight };
+      const nights =
+        c.checkIn && c.checkOut
+          ? Math.max(
+              1,
+              Math.ceil((new Date(c.checkOut).getTime() - new Date(c.checkIn).getTime()) / 86400000)
+            )
+          : 1;
+      n.__resState = {
+        status: 'pending' as ReservationStatus,
+        totalNights: nights,
+        totalCost: nights * c.ratePerNight,
+      };
       ctx.emit?.('reservation:created', { confirmation: c.confirmationNumber, nights });
     },
-    onDetach(n: HSPlusNode, _c: ReservationConfig, ctx: TraitContext) { delete n.__resState; ctx.emit?.('reservation:removed'); },
+    onDetach(n: HSPlusNode, _c: ReservationConfig, ctx: TraitContext) {
+      delete n.__resState;
+      ctx.emit?.('reservation:removed');
+    },
     onUpdate() {},
     onEvent(n: HSPlusNode, _c: ReservationConfig, ctx: TraitContext, e: TraitEvent) {
-      const s = n.__resState as ReservationState | undefined; if (!s) return;
-      if (e.type === 'reservation:confirm') { s.status = 'confirmed'; ctx.emit?.('reservation:confirmed'); }
-      if (e.type === 'reservation:check_in') { s.status = 'checked_in'; ctx.emit?.('reservation:checked_in'); }
-      if (e.type === 'reservation:check_out') { s.status = 'checked_out'; ctx.emit?.('reservation:checked_out', { total: s.totalCost }); }
-      if (e.type === 'reservation:cancel') { s.status = 'cancelled'; ctx.emit?.('reservation:cancelled'); }
+      const s = n.__resState as ReservationState | undefined;
+      if (!s) return;
+      if (e.type === 'reservation:confirm') {
+        s.status = 'confirmed';
+        ctx.emit?.('reservation:confirmed');
+      }
+      if (e.type === 'reservation:check_in') {
+        s.status = 'checked_in';
+        ctx.emit?.('reservation:checked_in');
+      }
+      if (e.type === 'reservation:check_out') {
+        s.status = 'checked_out';
+        ctx.emit?.('reservation:checked_out', { total: s.totalCost });
+      }
+      if (e.type === 'reservation:cancel') {
+        s.status = 'cancelled';
+        ctx.emit?.('reservation:cancelled');
+      }
     },
   };
 }

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/vitest.config.ts

@@ -1,6 +1,18 @@
 import { defineConfig } from 'vitest/config';
+import { resolve } from 'path';
 
+// resolve.alias is REQUIRED: without it, `@holoscript/core/runtime` resolves to
+// the STALE built dist and registerPluginTraits is missing ("not a function").
+// Point the subpath imports at core/engine source so the runtime barrel
+// (core/src/runtime.ts) and shared registrar resolve from source. Mirrors
+// government-civic-plugin/vitest.config.ts.
 export default defineConfig({
+  resolve: {
+    alias: {
+      '@holoscript/engine': resolve(__dirname, '../../engine/src'),
+      '@holoscript/core': resolve(__dirname, '../../core/src'),
+    },
+  },
   test: {
     globals: true,
     environment: 'node',

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.