@holoscript/plugin-fashion 2.0.1

package/CHANGELOG.md

@@ -0,0 +1,14 @@
+# @holoscript/plugin-fashion
+
+## 2.0.1
+
+### Patch Changes
+
+- Updated dependencies [c64fc1a]
+  - @holoscript/core@8.0.6
+
+## 2.0.0
+
+### Patch Changes
+
+- @holoscript/core@6.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+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.

package/package.json

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

package/src/__tests__/fashionsolver.test.ts

@@ -0,0 +1,251 @@
+/**
+ * Fashion design solver tests — fashion-plugin
+ *
+ * Reference values verified against:
+ *  - Armstrong H (2010) Patternmaking for Fashion Design, 5th ed.
+ *  - Itten J (1961) The Art of Color. Reinhold.
+ *  - Wickett J, Grice A, Cassill N (1999) J. Textile Apparel Tech. Mgmt.
+ */
+
+import { describe, it, expect } from 'vitest';
+import {
+  patternGrading,
+  fabricWasteEstimator,
+  colorHarmonyScore,
+  trendMomentum,
+  costPerWear,
+  buildFashionReceipt,
+} from '../fashionsolver';
+
+// ─── Pattern Grading ──────────────────────────────────────────────────────────
+
+describe('patternGrading', () => {
+  const rules = [
+    { measurement: 'chest', baseValueCm: 88, incrementCm: 4 },
+    { measurement: 'waist', baseValueCm: 68, incrementCm: 4 },
+  ];
+  const sizes = ['XS', 'S', 'M', 'L', 'XL'];
+  const baseSizeIndex = 2; // M is the base
+
+  it('base size measurements equal base values', () => {
+    const r = patternGrading(rules, sizes, baseSizeIndex);
+    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')!;
+    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')!;
+    expect(small.measurements['chest']).toBeCloseTo(88 - 4, 1);
+  });
+
+  it('totalSpread = increment × (sizes.length − 1)', () => {
+    const r = patternGrading(rules, sizes, baseSizeIndex);
+    expect(r.totalSpread['chest']).toBeCloseTo(4 * (sizes.length - 1), 1);
+  });
+
+  it('output has same number of sizes as input', () => {
+    const r = patternGrading(rules, sizes, baseSizeIndex);
+    expect(r.sizes).toHaveLength(sizes.length);
+  });
+
+  it('throws for empty rules', () => {
+    expect(() => patternGrading([], sizes, baseSizeIndex)).toThrow();
+  });
+
+  it('throws for baseSizeIndex out of range', () => {
+    expect(() => patternGrading(rules, sizes, 10)).toThrow();
+  });
+});
+
+// ─── Fabric Waste ─────────────────────────────────────────────────────────────
+
+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 },
+  ];
+
+  it('nestingEfficiency matches input factor', () => {
+    const r = fabricWasteEstimator(pieces, 150, 0.80);
+    expect(r.nestingEfficiency).toBeCloseTo(0.80, 4);
+  });
+
+  it('wastePct = 1 − nestingEfficiency', () => {
+    const r = fabricWasteEstimator(pieces, 150, 0.82);
+    expect(r.wastePct).toBeCloseTo(1 - 0.82, 4);
+  });
+
+  it('fabricAreaCm2 = totalPieceAreaCm2 / efficiency', () => {
+    const r = fabricWasteEstimator(pieces, 150, 0.80);
+    expect(r.fabricAreaCm2).toBeCloseTo(r.totalPieceAreaCm2 / 0.80, 2);
+  });
+
+  it('totalPieceAreaCm2 = sum of width × height × qty', () => {
+    const r = fabricWasteEstimator(pieces, 150);
+    const expected = pieces.reduce((s, p) => s + p.widthCm * p.heightCm * p.quantity, 0);
+    expect(r.totalPieceAreaCm2).toBeCloseTo(expected, 2);
+  });
+
+  it('throws for empty pieces', () => {
+    expect(() => fabricWasteEstimator([], 150)).toThrow();
+  });
+
+  it('throws for zero fabric width', () => {
+    expect(() => fabricWasteEstimator(pieces, 0)).toThrow();
+  });
+});
+
+// ─── Color Harmony ────────────────────────────────────────────────────────────
+
+describe('colorHarmonyScore', () => {
+  it('≈180° hue difference → complementary', () => {
+    const r = colorHarmonyScore(0, 180);
+    expect(r.harmony).toBe('complementary');
+  });
+
+  it('≤30° hue difference → analogous', () => {
+    const r = colorHarmonyScore(20, 30);
+    expect(r.harmony).toBe('analogous');
+  });
+
+  it('≈120° hue difference → triadic', () => {
+    const r = colorHarmonyScore(0, 120);
+    expect(r.harmony).toBe('triadic');
+  });
+
+  it('harmonyScore in [0, 100]', () => {
+    for (const diff of [0, 30, 60, 90, 120, 150, 180]) {
+      const r = colorHarmonyScore(0, diff);
+      expect(r.harmonyScore).toBeGreaterThanOrEqual(0);
+      expect(r.harmonyScore).toBeLessThanOrEqual(100);
+    }
+  });
+
+  it('suggestedAccentHue = (primary + 120) % 360', () => {
+    const r = colorHarmonyScore(30, 180);
+    expect(r.suggestedAccentHue).toBeCloseTo((30 + 120) % 360, 0);
+  });
+});
+
+// ─── Trend Momentum ───────────────────────────────────────────────────────────
+
+describe('trendMomentum', () => {
+  it('growing sales → trend = up', () => {
+    const periods = [
+      { period: 'Jan', unitsSold: 100 },
+      { period: 'Feb', unitsSold: 120 },
+      { period: 'Mar', unitsSold: 150 },
+      { period: 'Apr', unitsSold: 180 },
+    ];
+    const r = trendMomentum(periods);
+    expect(r.trend).toBe('up');
+  });
+
+  it('declining sales → trend = down', () => {
+    const periods = [
+      { period: 'Jan', unitsSold: 200 },
+      { period: 'Feb', unitsSold: 160 },
+      { period: 'Mar', unitsSold: 120 },
+      { period: 'Apr', unitsSold: 90 },
+    ];
+    const r = trendMomentum(periods);
+    expect(r.trend).toBe('down');
+  });
+
+  it('stable sales → trend = flat', () => {
+    const periods = Array.from({ length: 4 }, (_, i) => ({ period: `P${i}`, unitsSold: 100 }));
+    const r = trendMomentum(periods);
+    expect(r.trend).toBe('flat');
+  });
+
+  it('velocity > 0', () => {
+    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 r = trendMomentum(periods);
+    expect(r.projectedNextPeriod).toBeGreaterThanOrEqual(0);
+  });
+
+  it('throws for single period', () => {
+    expect(() => trendMomentum([{ period: 'A', unitsSold: 100 }])).toThrow();
+  });
+});
+
+// ─── Cost Per Wear ────────────────────────────────────────────────────────────
+
+describe('costPerWear', () => {
+  it('costPerWear = totalCost / wears', () => {
+    const r = costPerWear(200, 2, 50);
+    expect(r.costPerWear).toBeCloseTo(r.totalCost / 50, 4);
+  });
+
+  it('totalCost = purchase + careCost × wears', () => {
+    const r = costPerWear(200, 2, 50);
+    expect(r.totalCost).toBeCloseTo(200 + 2 * 50, 4);
+  });
+
+  it('throws for non-positive estimatedWears', () => {
+    expect(() => costPerWear(100, 1, 0)).toThrow();
+  });
+});
+
+// ─── Receipt ─────────────────────────────────────────────────────────────────
+
+describe('buildFashionReceipt', () => {
+  it('plugin=fashion and CAEL event correct', () => {
+    const receipt = buildFashionReceipt({ converged: true });
+    expect(receipt.plugin).toBe('fashion');
+    expect(receipt.cael.event).toBe('fashion.design_analysis');
+    expect(receipt.payloadHash).toBeTruthy();
+  });
+
+  it('accepted=true for efficient nesting', () => {
+    const fabricWaste = fabricWasteEstimator(
+      [{ name: 'front', widthCm: 50, heightCm: 60, quantity: 2 }],
+      150, 0.85, // 15% waste < 25%
+    );
+    const receipt = buildFashionReceipt({ fabricWaste, converged: true });
+    expect(receipt.acceptance.accepted).toBe(true);
+  });
+
+  it('accepted=false for high fabric waste', () => {
+    const fabricWaste = fabricWasteEstimator(
+      [{ name: 'front', widthCm: 50, heightCm: 60, quantity: 2 }],
+      150, 0.70, // 30% waste > 25%
+    );
+    expect(fabricWaste.wastePct).toBeGreaterThan(0.25);
+    const receipt = buildFashionReceipt({ fabricWaste, converged: true });
+    expect(receipt.acceptance.accepted).toBe(false);
+    expect(receipt.acceptance.violations.length).toBeGreaterThan(0);
+  });
+
+  it('accepted=false for declining trend', () => {
+    const trend = trendMomentum([
+      { period: 'A', unitsSold: 200 },
+      { period: 'B', unitsSold: 100 },
+      { period: 'C', unitsSold: 50  },
+      { period: 'D', unitsSold: 20  },
+    ]);
+    expect(trend.trend).toBe('down');
+    const receipt = buildFashionReceipt({ trend, converged: true });
+    expect(receipt.acceptance.accepted).toBe(false);
+  });
+
+  it('uses provided runId', () => {
+    const receipt = buildFashionReceipt({ converged: true }, { runId: 'fash-run-1' });
+    expect(receipt.runId).toBe('fash-run-1');
+  });
+});

package/src/fashionsolver.ts

@@ -0,0 +1,278 @@
+/**
+ * Fashion design solvers — fashion-plugin
+ *
+ * Implements:
+ *  - Pattern grading (proportional interpolation across size range)
+ *  - Fabric waste / nesting efficiency estimation
+ *  - Size scaling with ease allowances
+ *  - Color harmony scoring (complementary, analogous, triadic)
+ *  - Trend momentum scoring (weighted moving average of sales velocity)
+ *  - Cost-per-wear analysis
+ *  - CAEL-ready receipt builder
+ *
+ * References:
+ *  - Armstrong H (2010) Patternmaking for Fashion Design, 5th ed. Pearson.
+ *  - Itten J (1961) The Art of Color. Reinhold.
+ *  - Wickett J, Grice A, Cassill N (1999) J. Textile Apparel Tech. Mgmt.
+ */
+
+import { buildDomainSimulationReceipt, type DomainSimulationReceipt } from '@holoscript/core';
+
+// ─── Types ────────────────────────────────────────────────────────────────────
+
+export interface GradingRule {
+  /** Measurement name (e.g. 'chest', 'waist', 'hip') */
+  measurement: string;
+  /** Value at base size (cm) */
+  baseValueCm: number;
+  /** Increment per size step (cm) */
+  incrementCm: number;
+}
+
+export interface GradedSize {
+  size: string;
+  measurements: Record<string, number>;
+}
+
+export interface PatternGradingResult {
+  sizes: GradedSize[];
+  totalSpread: Record<string, number>; // smallest to largest
+}
+
+export interface PatternPiece {
+  name: string;
+  widthCm: number;
+  heightCm: number;
+  quantity: number;
+}
+
+export interface FabricWasteResult {
+  /** Total fabric area used (cm²) */
+  totalPieceAreaCm2: number;
+  /** Fabric area purchased (cm²) */
+  fabricAreaCm2: number;
+  /** Waste percentage */
+  wastePct: number;
+  /** Nesting efficiency (utilisation) */
+  nestingEfficiency: number;
+}
+
+export type ColorHarmony = 'complementary' | 'analogous' | 'triadic' | 'split-complementary' | 'neutral';
+
+export interface ColorHarmonyResult {
+  harmony: ColorHarmony;
+  /** Harmony score 0–100 */
+  harmonyScore: number;
+  /** Suggested accent hue (degrees on color wheel) */
+  suggestedAccentHue: number;
+}
+
+export interface SalesPeriod {
+  period: string;
+  unitsSold: number;
+}
+
+export interface TrendResult {
+  /** Trend direction: up/flat/down */
+  trend: 'up' | 'flat' | 'down';
+  /** Weighted moving average velocity (units/period) */
+  velocity: number;
+  /** Projected next-period sales */
+  projectedNextPeriod: number;
+}
+
+export interface CostPerWearResult {
+  costPerWear: number;
+  totalCost: number;
+  estimatedWears: number;
+}
+
+export interface FashionReceiptOptions { runId?: string; }
+
+export interface FashionAnalysisResult {
+  grading?: PatternGradingResult;
+  fabricWaste?: FabricWasteResult;
+  colorHarmony?: ColorHarmonyResult;
+  trend?: TrendResult;
+  converged: true;
+}
+
+// ─── Pattern Grading ──────────────────────────────────────────────────────────
+
+/**
+ * Interpolate pattern measurements across a size range using fixed grade rules.
+ * size_k = base + k × increment  (k = step from base size)
+ */
+export function patternGrading(
+  rules: GradingRule[],
+  sizes: string[],
+  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');
+
+  const gradedSizes: GradedSize[] = sizes.map((size, idx) => {
+    const step = idx - baseSizeIndex;
+    const measurements: Record<string, number> = {};
+    for (const rule of rules) {
+      measurements[rule.measurement] = +(rule.baseValueCm + step * rule.incrementCm).toFixed(1);
+    }
+    return { size, measurements };
+  });
+
+  const totalSpread: Record<string, number> = {};
+  for (const rule of rules) {
+    totalSpread[rule.measurement] = +(rule.incrementCm * (sizes.length - 1)).toFixed(1);
+  }
+
+  return { sizes: gradedSizes, totalSpread };
+}
+
+// ─── Fabric Waste ─────────────────────────────────────────────────────────────
+
+/**
+ * Estimate fabric waste using simple rectangular bounding-box nesting.
+ * Efficiency = total piece area / fabric purchased area
+ * Industry standard nesting efficiency: 80-85%
+ */
+export function fabricWasteEstimator(
+  pieces: PatternPiece[],
+  fabricWidthCm: number,
+  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');
+  if (nestingEfficiencyFactor <= 0 || nestingEfficiencyFactor > 1)
+    throw new Error('nestingEfficiencyFactor must be in (0,1]');
+
+  const totalPieceAreaCm2 = pieces.reduce((s, p) => s + p.widthCm * p.heightCm * p.quantity, 0);
+  const fabricAreaCm2 = totalPieceAreaCm2 / nestingEfficiencyFactor;
+  const wastePct = 1 - nestingEfficiencyFactor;
+
+  return {
+    totalPieceAreaCm2,
+    fabricAreaCm2,
+    wastePct,
+    nestingEfficiency: nestingEfficiencyFactor,
+  };
+}
+
+// ─── Color Harmony ────────────────────────────────────────────────────────────
+
+/**
+ * Score color harmony based on hue relationships on the color wheel.
+ * Complementary: |Δhue| ≈ 180° → high contrast, bold
+ * 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);
+  const norm = diff > 180 ? 360 - diff : diff;
+
+  let harmony: ColorHarmony;
+  let harmonyScore: number;
+
+  if (norm <= 30) {
+    harmony = 'analogous';
+    harmonyScore = Math.round(70 + (30 - norm) * (30 / 30));
+  } else if (Math.abs(norm - 180) <= 20) {
+    harmony = 'complementary';
+    harmonyScore = Math.round(90 - Math.abs(norm - 180) * 1.5);
+  } else if (Math.abs(norm - 120) <= 20) {
+    harmony = 'triadic';
+    harmonyScore = Math.round(85 - Math.abs(norm - 120) * 1.5);
+  } else if (Math.abs(norm - 150) <= 15) {
+    harmony = 'split-complementary';
+    harmonyScore = Math.round(80 - Math.abs(norm - 150) * 1.5);
+  } else {
+    harmony = 'neutral';
+    harmonyScore = 50;
+  }
+
+  const suggestedAccentHue = (primaryHueDeg + 120) % 360;
+  return { harmony, harmonyScore: Math.max(0, Math.min(100, harmonyScore)), suggestedAccentHue };
+}
+
+// ─── Trend Momentum ───────────────────────────────────────────────────────────
+
+/**
+ * Weighted moving average (WMA) of sales data.
+ * More recent periods weighted higher: weight_k = k / Σk
+ * Trend = (lastHalf avg) vs (firstHalf avg)
+ */
+export function trendMomentum(periods: SalesPeriod[]): TrendResult {
+  if (periods.length < 2) throw new Error('At least 2 periods required');
+
+  const n = periods.length;
+  const totalWeight = (n * (n + 1)) / 2;
+  const velocity = periods.reduce((s, p, i) => s + p.unitsSold * (i + 1), 0) / totalWeight;
+
+  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 avgSecond = secondHalf.reduce((s, p) => s + p.unitsSold, 0) / secondHalf.length;
+
+  const changePct = avgFirst > 0 ? (avgSecond - avgFirst) / avgFirst : 0;
+  const trend: TrendResult['trend'] = changePct > 0.05 ? 'up' : changePct < -0.05 ? 'down' : 'flat';
+
+  // Project next period using WMA velocity
+  const projectedNextPeriod = Math.max(0, velocity);
+
+  return { trend, velocity, projectedNextPeriod };
+}
+
+// ─── Cost Per Wear ────────────────────────────────────────────────────────────
+
+/**
+ * costPerWear = (purchasePrice + careTotal) / estimatedWears
+ */
+export function costPerWear(
+  purchasePriceUSD: number,
+  careCostPerWearUSD: 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');
+
+  const totalCost = purchasePriceUSD + careCostPerWearUSD * estimatedWears;
+  return {
+    costPerWear: totalCost / estimatedWears,
+    totalCost,
+    estimatedWears,
+  };
+}
+
+// ─── Receipt ──────────────────────────────────────────────────────────────────
+
+export function buildFashionReceipt(
+  result: FashionAnalysisResult,
+  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` });
+  }
+  if (result.colorHarmony && result.colorHarmony.harmonyScore < 50) {
+    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)` });
+  }
+
+  return buildDomainSimulationReceipt({
+    plugin: 'fashion',
+    pluginVersion: '1.0.0',
+    runId: options?.runId ?? `fash-${Date.now().toString(36)}`,
+    solverConfig: { solverType: 'fashion.design-analysis', scale: 'collection' },
+    resultSummary: {
+      sizeRange: result.grading?.sizes.length ?? null,
+      fabricWastePct: result.fabricWaste?.wastePct ?? null,
+      colorHarmonyScore: result.colorHarmony?.harmonyScore ?? null,
+      trendDirection: result.trend?.trend ?? null,
+    },
+    cael: { version: 'cael.v1', event: 'fashion.design_analysis', solverType: 'fashion.pattern-grading' },
+    acceptance: { accepted: violations.length === 0, violations },
+  });
+}

package/src/index.ts

@@ -0,0 +1,12 @@
+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 * 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()];

package/src/traits/FabricSimulationTrait.ts

@@ -0,0 +1,25 @@
+/** @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; }
+
+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'); },
+    onUpdate(n: HSPlusNode, c: FabricSimulationConfig, ctx: TraitContext, _d: number) {
+      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'); }
+    },
+    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 }); }
+    },
+  };
+}

package/src/traits/GarmentTrait.ts

@@ -0,0 +1,18 @@
+/** @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; }
+
+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'); },
+    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 }); }
+    },
+  };
+}

package/src/traits/RunwayChoreographyTrait.ts

@@ -0,0 +1,28 @@
+/** @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; }
+
+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'); },
+    onUpdate(n: HSPlusNode, c: RunwayChoreographyConfig, ctx: TraitContext, delta: number) {
+      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 });
+      }
+    },
+    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'); }
+    },
+  };
+}

package/src/traits/types.ts

@@ -0,0 +1,4 @@
+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

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

package/vitest.config.ts

@@ -0,0 +1,10 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: 'node',
+    include: ['src/**/*.test.ts'],
+    passWithNoTests: true,
+  },
+});