@holoscript/plugin-fashion 2.0.1 → 2.0.2

package/package.json

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

@@ -29,20 +29,20 @@ describe('patternGrading', () => {
 
   it('base size measurements equal base values', () => {
     const r = patternGrading(rules, sizes, baseSizeIndex);
-    const base = r.sizes.find(s => s.size === 'M')!;
+    const base = r.sizes.find((s) => s.size === 'M')!;
     expect(base.measurements['chest']).toBe(88);
     expect(base.measurements['waist']).toBe(68);
   });
 
   it('next size up = base + increment', () => {
     const r = patternGrading(rules, sizes, baseSizeIndex);
-    const large = r.sizes.find(s => s.size === 'L')!;
+    const large = r.sizes.find((s) => s.size === 'L')!;
     expect(large.measurements['chest']).toBeCloseTo(88 + 4, 1);
   });
 
   it('next size down = base − increment', () => {
     const r = patternGrading(rules, sizes, baseSizeIndex);
-    const small = r.sizes.find(s => s.size === 'S')!;
+    const small = r.sizes.find((s) => s.size === 'S')!;
     expect(small.measurements['chest']).toBeCloseTo(88 - 4, 1);
   });
 
@@ -70,13 +70,13 @@ describe('patternGrading', () => {
 describe('fabricWasteEstimator', () => {
   const pieces = [
     { name: 'front', widthCm: 60, heightCm: 80, quantity: 2 },
-    { name: 'back',  widthCm: 55, heightCm: 80, quantity: 2 },
-    { name: 'sleeve',widthCm: 40, heightCm: 60, quantity: 2 },
+    { name: 'back', widthCm: 55, heightCm: 80, quantity: 2 },
+    { name: 'sleeve', widthCm: 40, heightCm: 60, quantity: 2 },
   ];
 
   it('nestingEfficiency matches input factor', () => {
-    const r = fabricWasteEstimator(pieces, 150, 0.80);
-    expect(r.nestingEfficiency).toBeCloseTo(0.80, 4);
+    const r = fabricWasteEstimator(pieces, 150, 0.8);
+    expect(r.nestingEfficiency).toBeCloseTo(0.8, 4);
   });
 
   it('wastePct = 1 − nestingEfficiency', () => {
@@ -85,8 +85,8 @@ describe('fabricWasteEstimator', () => {
   });
 
   it('fabricAreaCm2 = totalPieceAreaCm2 / efficiency', () => {
-    const r = fabricWasteEstimator(pieces, 150, 0.80);
-    expect(r.fabricAreaCm2).toBeCloseTo(r.totalPieceAreaCm2 / 0.80, 2);
+    const r = fabricWasteEstimator(pieces, 150, 0.8);
+    expect(r.fabricAreaCm2).toBeCloseTo(r.totalPieceAreaCm2 / 0.8, 2);
   });
 
   it('totalPieceAreaCm2 = sum of width × height × qty', () => {
@@ -168,13 +168,19 @@ describe('trendMomentum', () => {
   });
 
   it('velocity > 0', () => {
-    const periods = [{ period: 'A', unitsSold: 100 }, { period: 'B', unitsSold: 150 }];
+    const periods = [
+      { period: 'A', unitsSold: 100 },
+      { period: 'B', unitsSold: 150 },
+    ];
     const r = trendMomentum(periods);
     expect(r.velocity).toBeGreaterThan(0);
   });
 
   it('projectedNextPeriod ≥ 0', () => {
-    const periods = [{ period: 'A', unitsSold: 50 }, { period: 'B', unitsSold: 60 }];
+    const periods = [
+      { period: 'A', unitsSold: 50 },
+      { period: 'B', unitsSold: 60 },
+    ];
     const r = trendMomentum(periods);
     expect(r.projectedNextPeriod).toBeGreaterThanOrEqual(0);
   });
@@ -215,7 +221,8 @@ describe('buildFashionReceipt', () => {
   it('accepted=true for efficient nesting', () => {
     const fabricWaste = fabricWasteEstimator(
       [{ name: 'front', widthCm: 50, heightCm: 60, quantity: 2 }],
-      150, 0.85, // 15% waste < 25%
+      150,
+      0.85 // 15% waste < 25%
     );
     const receipt = buildFashionReceipt({ fabricWaste, converged: true });
     expect(receipt.acceptance.accepted).toBe(true);
@@ -224,7 +231,8 @@ describe('buildFashionReceipt', () => {
   it('accepted=false for high fabric waste', () => {
     const fabricWaste = fabricWasteEstimator(
       [{ name: 'front', widthCm: 50, heightCm: 60, quantity: 2 }],
-      150, 0.70, // 30% waste > 25%
+      150,
+      0.7 // 30% waste > 25%
     );
     expect(fabricWaste.wastePct).toBeGreaterThan(0.25);
     const receipt = buildFashionReceipt({ fabricWaste, converged: true });
@@ -236,8 +244,8 @@ describe('buildFashionReceipt', () => {
     const trend = trendMomentum([
       { period: 'A', unitsSold: 200 },
       { period: 'B', unitsSold: 100 },
-      { period: 'C', unitsSold: 50  },
-      { period: 'D', unitsSold: 20  },
+      { period: 'C', unitsSold: 50 },
+      { period: 'D', unitsSold: 20 },
     ]);
     expect(trend.trend).toBe('down');
     const receipt = buildFashionReceipt({ trend, converged: true });

package/src/fashionsolver.ts

@@ -57,7 +57,12 @@ export interface FabricWasteResult {
   nestingEfficiency: number;
 }
 
-export type ColorHarmony = 'complementary' | 'analogous' | 'triadic' | 'split-complementary' | 'neutral';
+export type ColorHarmony =
+  | 'complementary'
+  | 'analogous'
+  | 'triadic'
+  | 'split-complementary'
+  | 'neutral';
 
 export interface ColorHarmonyResult {
   harmony: ColorHarmony;
@@ -87,7 +92,9 @@ export interface CostPerWearResult {
   estimatedWears: number;
 }
 
-export interface FashionReceiptOptions { runId?: string; }
+export interface FashionReceiptOptions {
+  runId?: string;
+}
 
 export interface FashionAnalysisResult {
   grading?: PatternGradingResult;
@@ -106,11 +113,12 @@ export interface FashionAnalysisResult {
 export function patternGrading(
   rules: GradingRule[],
   sizes: string[],
-  baseSizeIndex: number,
+  baseSizeIndex: number
 ): PatternGradingResult {
   if (rules.length === 0) throw new Error('No grading rules');
   if (sizes.length === 0) throw new Error('No sizes');
-  if (baseSizeIndex < 0 || baseSizeIndex >= sizes.length) throw new Error('baseSizeIndex out of range');
+  if (baseSizeIndex < 0 || baseSizeIndex >= sizes.length)
+    throw new Error('baseSizeIndex out of range');
 
   const gradedSizes: GradedSize[] = sizes.map((size, idx) => {
     const step = idx - baseSizeIndex;
@@ -139,7 +147,7 @@ export function patternGrading(
 export function fabricWasteEstimator(
   pieces: PatternPiece[],
   fabricWidthCm: number,
-  nestingEfficiencyFactor = 0.82,
+  nestingEfficiencyFactor = 0.82
 ): FabricWasteResult {
   if (pieces.length === 0) throw new Error('No pattern pieces');
   if (fabricWidthCm <= 0) throw new Error('Fabric width must be positive');
@@ -166,8 +174,11 @@ export function fabricWasteEstimator(
  * Analogous:     |Δhue| ≤ 30°  → low contrast, harmonious
  * Triadic:       |Δhue| ≈ 120° → balanced
  */
-export function colorHarmonyScore(primaryHueDeg: number, secondaryHueDeg: number): ColorHarmonyResult {
-  const diff = Math.abs(((primaryHueDeg - secondaryHueDeg) % 360 + 360) % 360);
+export function colorHarmonyScore(
+  primaryHueDeg: number,
+  secondaryHueDeg: number
+): ColorHarmonyResult {
+  const diff = Math.abs((((primaryHueDeg - secondaryHueDeg) % 360) + 360) % 360);
   const norm = diff > 180 ? 360 - diff : diff;
 
   let harmony: ColorHarmony;
@@ -210,7 +221,7 @@ export function trendMomentum(periods: SalesPeriod[]): TrendResult {
 
   const firstHalf = periods.slice(0, Math.floor(n / 2));
   const secondHalf = periods.slice(Math.ceil(n / 2));
-  const avgFirst  = firstHalf.reduce((s, p) => s + p.unitsSold, 0) / firstHalf.length;
+  const avgFirst = firstHalf.reduce((s, p) => s + p.unitsSold, 0) / firstHalf.length;
   const avgSecond = secondHalf.reduce((s, p) => s + p.unitsSold, 0) / secondHalf.length;
 
   const changePct = avgFirst > 0 ? (avgSecond - avgFirst) / avgFirst : 0;
@@ -230,7 +241,7 @@ export function trendMomentum(periods: SalesPeriod[]): TrendResult {
 export function costPerWear(
   purchasePriceUSD: number,
   careCostPerWearUSD: number,
-  estimatedWears: number,
+  estimatedWears: number
 ): CostPerWearResult {
   if (purchasePriceUSD < 0) throw new Error('Purchase price must be ≥ 0');
   if (estimatedWears <= 0) throw new Error('estimatedWears must be positive');
@@ -247,18 +258,27 @@ export function costPerWear(
 
 export function buildFashionReceipt(
   result: FashionAnalysisResult,
-  options?: FashionReceiptOptions,
+  options?: FashionReceiptOptions
 ): DomainSimulationReceipt {
   const violations: Array<{ criterion: string; message: string }> = [];
 
   if (result.fabricWaste && result.fabricWaste.wastePct > 0.25) {
-    violations.push({ criterion: 'fabric_waste', message: `Fabric waste ${(result.fabricWaste.wastePct * 100).toFixed(1)}% exceeds 25% threshold — review nesting` });
+    violations.push({
+      criterion: 'fabric_waste',
+      message: `Fabric waste ${(result.fabricWaste.wastePct * 100).toFixed(1)}% exceeds 25% threshold — review nesting`,
+    });
   }
   if (result.colorHarmony && result.colorHarmony.harmonyScore < 50) {
-    violations.push({ criterion: 'color_harmony', message: `Color harmony score ${result.colorHarmony.harmonyScore} below 50 — consider palette revision` });
+    violations.push({
+      criterion: 'color_harmony',
+      message: `Color harmony score ${result.colorHarmony.harmonyScore} below 50 — consider palette revision`,
+    });
   }
   if (result.trend && result.trend.trend === 'down') {
-    violations.push({ criterion: 'trend', message: `Category showing declining trend (velocity ${result.trend.velocity.toFixed(1)} units/period)` });
+    violations.push({
+      criterion: 'trend',
+      message: `Category showing declining trend (velocity ${result.trend.velocity.toFixed(1)} units/period)`,
+    });
   }
 
   return buildDomainSimulationReceipt({
@@ -272,7 +292,11 @@ export function buildFashionReceipt(
       colorHarmonyScore: result.colorHarmony?.harmonyScore ?? null,
       trendDirection: result.trend?.trend ?? null,
     },
-    cael: { version: 'cael.v1', event: 'fashion.design_analysis', solverType: 'fashion.pattern-grading' },
+    cael: {
+      version: 'cael.v1',
+      event: 'fashion.design_analysis',
+      solverType: 'fashion.pattern-grading',
+    },
     acceptance: { accepted: violations.length === 0, violations },
   });
 }

package/src/index.ts

@@ -1,12 +1,32 @@
 export * from './fashionsolver';
-export { createGarmentHandler, type GarmentConfig, type GarmentCategory } from './traits/GarmentTrait';
-export { createFabricSimulationHandler, type FabricSimulationConfig, type FabricType } from './traits/FabricSimulationTrait';
-export { createRunwayChoreographyHandler, type RunwayChoreographyConfig, type RunwaySegment } from './traits/RunwayChoreographyTrait';
+export {
+  createGarmentHandler,
+  type GarmentConfig,
+  type GarmentCategory,
+} from './traits/GarmentTrait';
+export {
+  createFabricSimulationHandler,
+  type FabricSimulationConfig,
+  type FabricType,
+} from './traits/FabricSimulationTrait';
+export {
+  createRunwayChoreographyHandler,
+  type RunwayChoreographyConfig,
+  type RunwaySegment,
+} from './traits/RunwayChoreographyTrait';
 export * from './traits/types';
 
 import { createGarmentHandler } from './traits/GarmentTrait';
 import { createFabricSimulationHandler } from './traits/FabricSimulationTrait';
 import { createRunwayChoreographyHandler } from './traits/RunwayChoreographyTrait';
 
-export const pluginMeta = { name: '@holoscript/plugin-fashion', version: '1.0.0', traits: ['garment', 'fabric_simulation', 'runway_choreography'] };
-export const traitHandlers = [createGarmentHandler(), createFabricSimulationHandler(), createRunwayChoreographyHandler()];
+export const pluginMeta = {
+  name: '@holoscript/plugin-fashion',
+  version: '1.0.0',
+  traits: ['garment', 'fabric_simulation', 'runway_choreography'],
+};
+export const traitHandlers = [
+  createGarmentHandler(),
+  createFabricSimulationHandler(),
+  createRunwayChoreographyHandler(),
+];

package/src/traits/FabricSimulationTrait.ts

@@ -1,25 +1,71 @@
 /** @fabric_simulation Trait — Cloth physics simulation. @trait fabric_simulation */
 import type { TraitHandler, HSPlusNode, TraitContext, TraitEvent } from './types';
 
-export type FabricType = 'woven' | 'knit' | 'denim' | 'silk' | 'leather' | 'synthetic' | 'lace' | 'tulle';
-export interface FabricSimulationConfig { fabricType: FabricType; stiffness: number; elasticity: number; drapeCoefficient: number; windResistance: number; gravityScale: number; collisionMargin: number; vertexCount: number; }
+export type FabricType =
+  | 'woven'
+  | 'knit'
+  | 'denim'
+  | 'silk'
+  | 'leather'
+  | 'synthetic'
+  | 'lace'
+  | 'tulle';
+export interface FabricSimulationConfig {
+  fabricType: FabricType;
+  stiffness: number;
+  elasticity: number;
+  drapeCoefficient: number;
+  windResistance: number;
+  gravityScale: number;
+  collisionMargin: number;
+  vertexCount: number;
+}
 
-const defaultConfig: FabricSimulationConfig = { fabricType: 'woven', stiffness: 0.5, elasticity: 0.3, drapeCoefficient: 0.7, windResistance: 0.2, gravityScale: 1.0, collisionMargin: 0.01, vertexCount: 1000 };
+const defaultConfig: FabricSimulationConfig = {
+  fabricType: 'woven',
+  stiffness: 0.5,
+  elasticity: 0.3,
+  drapeCoefficient: 0.7,
+  windResistance: 0.2,
+  gravityScale: 1.0,
+  collisionMargin: 0.01,
+  vertexCount: 1000,
+};
 
 export function createFabricSimulationHandler(): TraitHandler<FabricSimulationConfig> {
-  return { name: 'fabric_simulation', defaultConfig,
-    onAttach(n: HSPlusNode, c: FabricSimulationConfig, ctx: TraitContext) { n.__fabricState = { isSimulating: false, frameCount: 0, settledPercent: 0 }; ctx.emit?.('fabric:initialized', { type: c.fabricType, vertices: c.vertexCount }); },
-    onDetach(n: HSPlusNode, _c: FabricSimulationConfig, ctx: TraitContext) { delete n.__fabricState; ctx.emit?.('fabric:destroyed'); },
+  return {
+    name: 'fabric_simulation',
+    defaultConfig,
+    onAttach(n: HSPlusNode, c: FabricSimulationConfig, ctx: TraitContext) {
+      n.__fabricState = { isSimulating: false, frameCount: 0, settledPercent: 0 };
+      ctx.emit?.('fabric:initialized', { type: c.fabricType, vertices: c.vertexCount });
+    },
+    onDetach(n: HSPlusNode, _c: FabricSimulationConfig, ctx: TraitContext) {
+      delete n.__fabricState;
+      ctx.emit?.('fabric:destroyed');
+    },
     onUpdate(n: HSPlusNode, c: FabricSimulationConfig, ctx: TraitContext, _d: number) {
-      const s = n.__fabricState as Record<string, unknown> | undefined; if (!s || !s.isSimulating) return;
+      const s = n.__fabricState as Record<string, unknown> | undefined;
+      if (!s || !s.isSimulating) return;
       (s.frameCount as number)++;
       s.settledPercent = Math.min(100, (s.frameCount as number) * c.drapeCoefficient);
-      if ((s.settledPercent as number) >= 100) { s.isSimulating = false; ctx.emit?.('fabric:settled'); }
+      if ((s.settledPercent as number) >= 100) {
+        s.isSimulating = false;
+        ctx.emit?.('fabric:settled');
+      }
     },
     onEvent(n: HSPlusNode, _c: FabricSimulationConfig, ctx: TraitContext, e: TraitEvent) {
-      const s = n.__fabricState as Record<string, unknown> | undefined; if (!s) return;
-      if (e.type === 'fabric:start') { s.isSimulating = true; s.frameCount = 0; s.settledPercent = 0; ctx.emit?.('fabric:simulating'); }
-      if (e.type === 'fabric:apply_wind') { ctx.emit?.('fabric:wind_applied', { force: e.payload?.force }); }
+      const s = n.__fabricState as Record<string, unknown> | undefined;
+      if (!s) return;
+      if (e.type === 'fabric:start') {
+        s.isSimulating = true;
+        s.frameCount = 0;
+        s.settledPercent = 0;
+        ctx.emit?.('fabric:simulating');
+      }
+      if (e.type === 'fabric:apply_wind') {
+        ctx.emit?.('fabric:wind_applied', { force: e.payload?.force });
+      }
     },
   };
 }

package/src/traits/GarmentTrait.ts

@@ -1,18 +1,56 @@
 /** @garment Trait — Clothing item definition. @trait garment */
 import type { TraitHandler, HSPlusNode, TraitContext, TraitEvent } from './types';
 
-export type GarmentCategory = 'top' | 'bottom' | 'dress' | 'outerwear' | 'footwear' | 'accessory' | 'swimwear' | 'activewear';
-export interface GarmentConfig { name: string; category: GarmentCategory; sizes: string[]; colors: string[]; fabric: string; weight_gsm: number; season: 'spring' | 'summer' | 'fall' | 'winter' | 'all'; price: number; sku: string; }
+export type GarmentCategory =
+  | 'top'
+  | 'bottom'
+  | 'dress'
+  | 'outerwear'
+  | 'footwear'
+  | 'accessory'
+  | 'swimwear'
+  | 'activewear';
+export interface GarmentConfig {
+  name: string;
+  category: GarmentCategory;
+  sizes: string[];
+  colors: string[];
+  fabric: string;
+  weight_gsm: number;
+  season: 'spring' | 'summer' | 'fall' | 'winter' | 'all';
+  price: number;
+  sku: string;
+}
 
-const defaultConfig: GarmentConfig = { name: '', category: 'top', sizes: ['S','M','L'], colors: ['black'], fabric: 'cotton', weight_gsm: 200, season: 'all', price: 0, sku: '' };
+const defaultConfig: GarmentConfig = {
+  name: '',
+  category: 'top',
+  sizes: ['S', 'M', 'L'],
+  colors: ['black'],
+  fabric: 'cotton',
+  weight_gsm: 200,
+  season: 'all',
+  price: 0,
+  sku: '',
+};
 
 export function createGarmentHandler(): TraitHandler<GarmentConfig> {
-  return { name: 'garment', defaultConfig,
-    onAttach(n: HSPlusNode, c: GarmentConfig, ctx: TraitContext) { n.__garmentState = { variants: c.sizes.length * c.colors.length, inStock: true }; ctx.emit?.('garment:created', { name: c.name, category: c.category }); },
-    onDetach(n: HSPlusNode, _c: GarmentConfig, ctx: TraitContext) { delete n.__garmentState; ctx.emit?.('garment:removed'); },
+  return {
+    name: 'garment',
+    defaultConfig,
+    onAttach(n: HSPlusNode, c: GarmentConfig, ctx: TraitContext) {
+      n.__garmentState = { variants: c.sizes.length * c.colors.length, inStock: true };
+      ctx.emit?.('garment:created', { name: c.name, category: c.category });
+    },
+    onDetach(n: HSPlusNode, _c: GarmentConfig, ctx: TraitContext) {
+      delete n.__garmentState;
+      ctx.emit?.('garment:removed');
+    },
     onUpdate() {},
     onEvent(_n: HSPlusNode, c: GarmentConfig, ctx: TraitContext, e: TraitEvent) {
-      if (e.type === 'garment:check_fit') { ctx.emit?.('garment:fit_result', { garment: c.name, sizes: c.sizes }); }
+      if (e.type === 'garment:check_fit') {
+        ctx.emit?.('garment:fit_result', { garment: c.name, sizes: c.sizes });
+      }
     },
   };
 }

package/src/traits/RunwayChoreographyTrait.ts

@@ -1,28 +1,72 @@
 /** @runway_choreography Trait — Fashion show runway planning. @trait runway_choreography */
 import type { TraitHandler, HSPlusNode, TraitContext, TraitEvent } from './types';
 
-export interface RunwaySegment { modelId: string; garmentIds: string[]; walkDurationS: number; pauseAtEndS: number; music: string; lightingCue: string; }
-export interface RunwayChoreographyConfig { segments: RunwaySegment[]; runwayLengthM: number; totalDurationS: number; musicPlaylist: string[]; }
-export interface RunwayChoreographyState { currentSegment: number; isRunning: boolean; elapsedS: number; }
+export interface RunwaySegment {
+  modelId: string;
+  garmentIds: string[];
+  walkDurationS: number;
+  pauseAtEndS: number;
+  music: string;
+  lightingCue: string;
+}
+export interface RunwayChoreographyConfig {
+  segments: RunwaySegment[];
+  runwayLengthM: number;
+  totalDurationS: number;
+  musicPlaylist: string[];
+}
+export interface RunwayChoreographyState {
+  currentSegment: number;
+  isRunning: boolean;
+  elapsedS: number;
+}
 
-const defaultConfig: RunwayChoreographyConfig = { segments: [], runwayLengthM: 20, totalDurationS: 600, musicPlaylist: [] };
+const defaultConfig: RunwayChoreographyConfig = {
+  segments: [],
+  runwayLengthM: 20,
+  totalDurationS: 600,
+  musicPlaylist: [],
+};
 
 export function createRunwayChoreographyHandler(): TraitHandler<RunwayChoreographyConfig> {
-  return { name: 'runway_choreography', defaultConfig,
-    onAttach(n: HSPlusNode, c: RunwayChoreographyConfig, ctx: TraitContext) { n.__runwayState = { currentSegment: 0, isRunning: false, elapsedS: 0 }; ctx.emit?.('runway:ready', { segments: c.segments.length }); },
-    onDetach(n: HSPlusNode, _c: RunwayChoreographyConfig, ctx: TraitContext) { delete n.__runwayState; ctx.emit?.('runway:ended'); },
+  return {
+    name: 'runway_choreography',
+    defaultConfig,
+    onAttach(n: HSPlusNode, c: RunwayChoreographyConfig, ctx: TraitContext) {
+      n.__runwayState = { currentSegment: 0, isRunning: false, elapsedS: 0 };
+      ctx.emit?.('runway:ready', { segments: c.segments.length });
+    },
+    onDetach(n: HSPlusNode, _c: RunwayChoreographyConfig, ctx: TraitContext) {
+      delete n.__runwayState;
+      ctx.emit?.('runway:ended');
+    },
     onUpdate(n: HSPlusNode, c: RunwayChoreographyConfig, ctx: TraitContext, delta: number) {
-      const s = n.__runwayState as RunwayChoreographyState | undefined; if (!s?.isRunning) return;
+      const s = n.__runwayState as RunwayChoreographyState | undefined;
+      if (!s?.isRunning) return;
       s.elapsedS += delta / 1000;
       const seg = c.segments[s.currentSegment];
-      if (seg && s.elapsedS >= seg.walkDurationS + seg.pauseAtEndS) { s.currentSegment++; s.elapsedS = 0;
-        if (s.currentSegment >= c.segments.length) { s.isRunning = false; ctx.emit?.('runway:show_complete'); }
-        else ctx.emit?.('runway:next_model', { segment: s.currentSegment, model: c.segments[s.currentSegment]?.modelId });
+      if (seg && s.elapsedS >= seg.walkDurationS + seg.pauseAtEndS) {
+        s.currentSegment++;
+        s.elapsedS = 0;
+        if (s.currentSegment >= c.segments.length) {
+          s.isRunning = false;
+          ctx.emit?.('runway:show_complete');
+        } else
+          ctx.emit?.('runway:next_model', {
+            segment: s.currentSegment,
+            model: c.segments[s.currentSegment]?.modelId,
+          });
       }
     },
     onEvent(n: HSPlusNode, _c: RunwayChoreographyConfig, ctx: TraitContext, e: TraitEvent) {
-      const s = n.__runwayState as RunwayChoreographyState | undefined; if (!s) return;
-      if (e.type === 'runway:start') { s.isRunning = true; s.currentSegment = 0; s.elapsedS = 0; ctx.emit?.('runway:started'); }
+      const s = n.__runwayState as RunwayChoreographyState | undefined;
+      if (!s) return;
+      if (e.type === 'runway:start') {
+        s.isRunning = true;
+        s.currentSegment = 0;
+        s.elapsedS = 0;
+        ctx.emit?.('runway:started');
+      }
     },
   };
 }

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.