@holoscript/plugin-manufacturing-qc 2.0.1 → 2.0.2

package/package.json

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

@@ -80,7 +80,7 @@ describe('manufacturing-qc -> HoloScript runtime integration (spc)', () => {
         subgroups: HAND_SUBGROUPS,
         lsl: HAND_LSL,
         usl: HAND_USL,
-      }) as never,
+      }) as never
     );
     await flush();
 
@@ -107,7 +107,7 @@ describe('manufacturing-qc -> HoloScript runtime integration (spc)', () => {
         subgroups: HAND_SUBGROUPS,
         lsl: HAND_LSL,
         usl: HAND_USL,
-      }) as never,
+      }) as never
     );
     await flush();
 
@@ -124,7 +124,7 @@ describe('manufacturing-qc -> HoloScript runtime integration (spc)', () => {
         subgroups: HAND_SUBGROUPS,
         lsl: HAND_LSL,
         usl: HAND_USL,
-      }) as never,
+      }) as never
     );
     await flush();
 
@@ -155,7 +155,7 @@ describe('manufacturing-qc -> HoloScript runtime integration (spc)', () => {
         subgroups: HAND_SUBGROUPS,
         lsl: 10,
         usl: 4,
-      }) as never,
+      }) as never
     );
     await flush();
 

package/src/__tests__/spc.test.ts

@@ -7,12 +7,7 @@
  */
 
 import { describe, it, expect } from 'vitest';
-import {
-  buildSPCChart,
-  computeCapability,
-  buildSPCReceipt,
-  type Subgroup,
-} from '../spc';
+import { buildSPCChart, computeCapability, buildSPCReceipt, type Subgroup } from '../spc';
 
 // ─── Helpers ──────────────────────────────────────────────────────────────────
 
@@ -87,8 +82,7 @@ describe('buildSPCChart — xbar_r', () => {
     expect(result.primaryChart.ucl).toBeGreaterThan(result.primaryChart.centerLine);
     expect(result.primaryChart.lcl).toBeLessThan(result.primaryChart.centerLine);
     // At least 80% of subgroups should be in control for a stable reference process
-    const inControlFraction =
-      1 - result.outOfControlCount / result.subgroupCount;
+    const inControlFraction = 1 - result.outOfControlCount / result.subgroupCount;
     expect(inControlFraction).toBeGreaterThanOrEqual(0.8);
   });
 
@@ -158,7 +152,7 @@ describe('buildSPCChart — p', () => {
       buildSPCChart('p', [
         { index: 1, values: [1, 2, 3] },
         { index: 2, values: [1, 2, 3] },
-      ]),
+      ])
     ).toThrow();
   });
 });
@@ -191,11 +185,12 @@ describe('buildSPCChart — c', () => {
 
 describe('computeCapability', () => {
   // Centred process: mean=50, σ≈1, LSL=44, USL=56 → Cpk≈2.0
-  const centredValues: number[] = Array.from({ length: 100 }, (_, i) =>
-    50 + Math.sin(i * 0.7) * 0.8,
+  const centredValues: number[] = Array.from(
+    { length: 100 },
+    (_, i) => 50 + Math.sin(i * 0.7) * 0.8
   );
   const centredSubgroups = makeSubgroups(
-    Array.from({ length: 20 }, (_, i) => centredValues.slice(i * 5, i * 5 + 5)),
+    Array.from({ length: 20 }, (_, i) => centredValues.slice(i * 5, i * 5 + 5))
   );
 
   it('computes Cp, Cpk, Pp, Ppk with correct ordering (Cpk ≤ Cp)', () => {

package/src/index.ts

@@ -1,7 +1,20 @@
 export * from './spc';
-export { createProductionLineHandler, type ProductionLineConfig, type Station } from './traits/ProductionLineTrait';
-export { createQualityGateHandler, type QualityGateConfig, type InspectionCriteria } from './traits/QualityGateTrait';
-export { createDefectTrackingHandler, type DefectTrackingConfig, type Defect, type DefectSeverity } from './traits/DefectTrackingTrait';
+export {
+  createProductionLineHandler,
+  type ProductionLineConfig,
+  type Station,
+} from './traits/ProductionLineTrait';
+export {
+  createQualityGateHandler,
+  type QualityGateConfig,
+  type InspectionCriteria,
+} from './traits/QualityGateTrait';
+export {
+  createDefectTrackingHandler,
+  type DefectTrackingConfig,
+  type Defect,
+  type DefectSeverity,
+} from './traits/DefectTrackingTrait';
 export { createBOMHandler, type BOMConfig, type BOMItem } from './traits/BOMTrait';
 export * from './traits/types';
 
@@ -26,5 +39,14 @@ export {
   type TraitRegistrar,
 } from './runtime';
 
-export const pluginMeta = { name: '@holoscript/plugin-manufacturing-qc', version: '1.0.0', traits: ['production_line', 'quality_gate', 'defect_tracking', 'bom', 'spc'] };
-export const traitHandlers = [createProductionLineHandler(), createQualityGateHandler(), createDefectTrackingHandler(), createBOMHandler()];
+export const pluginMeta = {
+  name: '@holoscript/plugin-manufacturing-qc',
+  version: '1.0.0',
+  traits: ['production_line', 'quality_gate', 'defect_tracking', 'bom', 'spc'],
+};
+export const traitHandlers = [
+  createProductionLineHandler(),
+  createQualityGateHandler(),
+  createDefectTrackingHandler(),
+  createBOMHandler(),
+];

package/src/runtime.ts

@@ -15,11 +15,7 @@
  * traits follow the same registrar shape.
  */
 import { registerPluginTraits } from '@holoscript/core/runtime';
-import {
-  computeCapability,
-  type Subgroup,
-  type ProcessCapability,
-} from './spc';
+import { computeCapability, type Subgroup, type ProcessCapability } from './spc';
 
 /** Stable id for this plugin's trait ownership tagging. */
 export const MANUFACTURING_QC_PLUGIN_ID = 'manufacturing-qc' as const;
@@ -76,7 +72,7 @@ export interface RuntimeTraitHandler {
     node: unknown,
     config: SpcTraitConfig,
     context: TraitDispatchContext,
-    delta: number,
+    delta: number
   ) => void;
 }
 
@@ -91,7 +87,7 @@ interface SpcNode {
 function solveOntoNode(
   node: unknown,
   config: SpcTraitConfig | undefined,
-  context: TraitDispatchContext,
+  context: TraitDispatchContext
 ): void {
   const carrier = node as SpcNode;
   const nodeId = carrier.id ?? carrier.name ?? 'unknown';

package/src/spc.ts

@@ -58,8 +58,8 @@ export interface SPCChartResult {
   chartType: ChartType;
   subgroupCount: number;
   totalObservations: number;
-  primaryChart: ControlLimits;      // X̅ or p or c/u
-  secondaryChart?: ControlLimits;   // R or s (only for variables charts)
+  primaryChart: ControlLimits; // X̅ or p or c/u
+  secondaryChart?: ControlLimits; // R or s (only for variables charts)
   subgroupStats: SubgroupStat[];
   outOfControlCount: number;
   processInControl: boolean;
@@ -131,48 +131,104 @@ export interface SPCReceipt {
 
 /** d2 unbiasing constants for range → σ̂ */
 const D2: Record<number, number> = {
-  2: 1.128, 3: 1.693, 4: 2.059, 5: 2.326,
-  6: 2.534, 7: 2.704, 8: 2.847, 9: 2.970, 10: 3.078,
+  2: 1.128,
+  3: 1.693,
+  4: 2.059,
+  5: 2.326,
+  6: 2.534,
+  7: 2.704,
+  8: 2.847,
+  9: 2.97,
+  10: 3.078,
 };
 
 /** d3 for range chart LCL */
 const D3: Record<number, number> = {
-  2: 0,     3: 0,     4: 0,     5: 0,
-  6: 0,     7: 0.076, 8: 0.136, 9: 0.184, 10: 0.223,
+  2: 0,
+  3: 0,
+  4: 0,
+  5: 0,
+  6: 0,
+  7: 0.076,
+  8: 0.136,
+  9: 0.184,
+  10: 0.223,
 };
 
 /** d4 for range chart UCL */
 const D4: Record<number, number> = {
-  2: 3.267, 3: 2.575, 4: 2.282, 5: 2.115,
-  6: 2.004, 7: 1.924, 8: 1.864, 9: 1.816, 10: 1.777,
+  2: 3.267,
+  3: 2.575,
+  4: 2.282,
+  5: 2.115,
+  6: 2.004,
+  7: 1.924,
+  8: 1.864,
+  9: 1.816,
+  10: 1.777,
 };
 
 /** c4 unbiasing constants for s → σ̂ */
 const C4: Record<number, number> = {
-  2: 0.7979, 3: 0.8862, 4: 0.9213, 5: 0.9400,
-  6: 0.9515, 7: 0.9594, 8: 0.9650, 9: 0.9693, 10: 0.9727,
+  2: 0.7979,
+  3: 0.8862,
+  4: 0.9213,
+  5: 0.94,
+  6: 0.9515,
+  7: 0.9594,
+  8: 0.965,
+  9: 0.9693,
+  10: 0.9727,
 };
 
 /** A2 constants for X̅-R chart (3σ limits via R̅) */
 const A2: Record<number, number> = {
-  2: 1.880, 3: 1.023, 4: 0.729, 5: 0.577,
-  6: 0.483, 7: 0.419, 8: 0.373, 9: 0.337, 10: 0.308,
+  2: 1.88,
+  3: 1.023,
+  4: 0.729,
+  5: 0.577,
+  6: 0.483,
+  7: 0.419,
+  8: 0.373,
+  9: 0.337,
+  10: 0.308,
 };
 
 /** A3 constants for X̅-s chart (3σ limits via s̅) */
 const A3: Record<number, number> = {
-  2: 2.659, 3: 1.954, 4: 1.628, 5: 1.427,
-  6: 1.287, 7: 1.182, 8: 1.099, 9: 1.032, 10: 0.975,
+  2: 2.659,
+  3: 1.954,
+  4: 1.628,
+  5: 1.427,
+  6: 1.287,
+  7: 1.182,
+  8: 1.099,
+  9: 1.032,
+  10: 0.975,
 };
 
 /** B3 / B4 for s-chart limits */
 const B3: Record<number, number> = {
-  2: 0,     3: 0,     4: 0,     5: 0,
-  6: 0.030, 7: 0.118, 8: 0.185, 9: 0.239, 10: 0.284,
+  2: 0,
+  3: 0,
+  4: 0,
+  5: 0,
+  6: 0.03,
+  7: 0.118,
+  8: 0.185,
+  9: 0.239,
+  10: 0.284,
 };
 const B4: Record<number, number> = {
-  2: 3.267, 3: 2.568, 4: 2.266, 5: 2.089,
-  6: 1.970, 7: 1.882, 8: 1.815, 9: 1.761, 10: 1.716,
+  2: 3.267,
+  3: 2.568,
+  4: 2.266,
+  5: 2.089,
+  6: 1.97,
+  7: 1.882,
+  8: 1.815,
+  9: 1.761,
+  10: 1.716,
 };
 
 // ─── Statistics helpers ────────────────────────────────────────────────────────────────────
@@ -266,7 +322,8 @@ function westernElectricViolations(zScores: number[]): string[][] {
     // Rule 5: 6 consecutive monotone
     if (i >= 5) {
       const window = zScores.slice(i - 5, i + 1);
-      let inc = true; let dec = true;
+      let inc = true;
+      let dec = true;
       for (let j = 1; j < window.length; j++) {
         if (window[j] <= window[j - 1]) inc = false;
         if (window[j] >= window[j - 1]) dec = false;
@@ -291,7 +348,10 @@ function westernElectricViolations(zScores: number[]): string[][] {
       for (let j = 2; j < window.length; j++) {
         const prevDir = window[j - 1] > window[j - 2];
         const currDir = window[j] > window[j - 1];
-        if (currDir === prevDir) { alternating = false; break; }
+        if (currDir === prevDir) {
+          alternating = false;
+          break;
+        }
       }
       if (alternating) violations[i].push('WE7:alternating14');
     }
@@ -396,14 +456,15 @@ function buildXbarSChart(subgroups: Subgroup[]): SPCChartResult {
     lclFloor: 0,
   };
 
-  const c4val = C4[n] ?? 0.9400;
+  const c4val = C4[n] ?? 0.94;
   const sigma = sBar / c4val;
   const primaryZ = means.map((m) => (sigma > 0 ? (m - xbarBar) / sigma : 0));
   const primaryViolations = westernElectricViolations(primaryZ);
 
   const subgroupStats: SubgroupStat[] = subgroups.map((sg, i) => {
     const violations = [...primaryViolations[i]];
-    if (stds[i] > secondaryLimits.ucl || stds[i] < secondaryLimits.lcl) violations.push('s:outOfControl');
+    if (stds[i] > secondaryLimits.ucl || stds[i] < secondaryLimits.lcl)
+      violations.push('s:outOfControl');
     return {
       index: sg.index,
       n,
@@ -485,7 +546,8 @@ function buildPChart(subgroups: Subgroup[]): SPCChartResult {
 function buildCChart(subgroups: Subgroup[]): SPCChartResult {
   if (subgroups.length < 2) throw new Error('[spc] c-chart requires ≥ 2 subgroups');
   for (const sg of subgroups) {
-    if (sg.defects === undefined) throw new Error('[spc] c-chart requires .defects on every subgroup');
+    if (sg.defects === undefined)
+      throw new Error('[spc] c-chart requires .defects on every subgroup');
   }
 
   const counts = subgroups.map((sg) => sg.defects ?? 0);
@@ -537,9 +599,12 @@ function buildCChart(subgroups: Subgroup[]): SPCChartResult {
  */
 export function buildSPCChart(type: ChartType, subgroups: Subgroup[]): SPCChartResult {
   switch (type) {
-    case 'xbar_r':  return buildXbarRChart(subgroups);
-    case 'xbar_s':  return buildXbarSChart(subgroups);
-    case 'p':       return buildPChart(subgroups);
+    case 'xbar_r':
+      return buildXbarRChart(subgroups);
+    case 'xbar_s':
+      return buildXbarSChart(subgroups);
+    case 'p':
+      return buildPChart(subgroups);
     case 'np': {
       // np-chart: same as p-chart but plot count instead of proportion
       const result = buildPChart(subgroups);
@@ -555,7 +620,8 @@ export function buildSPCChart(type: ChartType, subgroups: Subgroup[]): SPCChartR
         },
       };
     }
-    case 'c':       return buildCChart(subgroups);
+    case 'c':
+      return buildCChart(subgroups);
     case 'u': {
       // u-chart: defects per unit (c-chart normalised by n)
       for (const sg of subgroups) {
@@ -612,7 +678,7 @@ export function computeCapability(
   subgroups: Subgroup[],
   lsl: number,
   usl: number,
-  target?: number,
+  target?: number
 ): ProcessCapability {
   if (usl <= lsl) throw new Error('[spc] usl must be > lsl');
   if (allValues.length < 2) throw new Error('[spc] need ≥ 2 values for capability');
@@ -633,11 +699,11 @@ export function computeCapability(
   }
 
   const specWidth = usl - lsl;
-  const Cp  = withinSigma  > 0 ? specWidth / (6 * withinSigma)  : Infinity;
-  const Pp  = overallSigma > 0 ? specWidth / (6 * overallSigma) : Infinity;
+  const Cp = withinSigma > 0 ? specWidth / (6 * withinSigma) : Infinity;
+  const Pp = overallSigma > 0 ? specWidth / (6 * overallSigma) : Infinity;
 
-  const CpkUpper = withinSigma  > 0 ? (usl - processMean) / (3 * withinSigma)  : Infinity;
-  const CpkLower = withinSigma  > 0 ? (processMean - lsl) / (3 * withinSigma)  : Infinity;
+  const CpkUpper = withinSigma > 0 ? (usl - processMean) / (3 * withinSigma) : Infinity;
+  const CpkLower = withinSigma > 0 ? (processMean - lsl) / (3 * withinSigma) : Infinity;
   const Cpk = Math.min(CpkUpper, CpkLower);
 
   const PpkUpper = overallSigma > 0 ? (usl - processMean) / (3 * overallSigma) : Infinity;
@@ -656,11 +722,17 @@ export function computeCapability(
   const ppmBelowLSL = ppm(zBelowLSL);
 
   return {
-    lsl, usl, target,
+    lsl,
+    usl,
+    target,
     processMean,
     processStdDev: overallSigma,
-    Cp, Cpk, CpkLower, CpkUpper,
-    Pp, Ppk,
+    Cp,
+    Cpk,
+    CpkLower,
+    CpkUpper,
+    Pp,
+    Ppk,
     Cpm,
     ppmAboveUSL,
     ppmBelowLSL,
@@ -676,7 +748,7 @@ export function buildSPCReceipt(
   modelId: string,
   chartResult: SPCChartResult,
   capability?: ProcessCapability,
-  options: SPCReceiptOptions = {},
+  options: SPCReceiptOptions = {}
 ): SPCReceipt {
   const violations: Array<{ criterion: string; message: string }> = [];
 

package/src/traits/BOMTrait.ts

@@ -1,22 +1,50 @@
 /** @bom Trait — Bill of Materials management. @trait bom */
 import type { TraitHandler, HSPlusNode, TraitContext, TraitEvent } from './types';
 
-export interface BOMItem { partNumber: string; name: string; quantity: number; unit: string; supplier?: string; leadTimeDays: number; costPerUnit: number; }
-export interface BOMConfig { items: BOMItem[]; revision: string; product: string; approvedBy?: string; }
+export interface BOMItem {
+  partNumber: string;
+  name: string;
+  quantity: number;
+  unit: string;
+  supplier?: string;
+  leadTimeDays: number;
+  costPerUnit: number;
+}
+export interface BOMConfig {
+  items: BOMItem[];
+  revision: string;
+  product: string;
+  approvedBy?: string;
+}
 
 const defaultConfig: BOMConfig = { items: [], revision: '1.0', product: '' };
 
 export function createBOMHandler(): TraitHandler<BOMConfig> {
-  return { name: 'bom', defaultConfig,
+  return {
+    name: 'bom',
+    defaultConfig,
     onAttach(n: HSPlusNode, c: BOMConfig, ctx: TraitContext) {
       const totalCost = c.items.reduce((sum, i) => sum + i.costPerUnit * i.quantity, 0);
-      n.__bomState = { totalCost, itemCount: c.items.length, longestLeadTime: Math.max(0, ...c.items.map(i => i.leadTimeDays)) };
+      n.__bomState = {
+        totalCost,
+        itemCount: c.items.length,
+        longestLeadTime: Math.max(0, ...c.items.map((i) => i.leadTimeDays)),
+      };
       ctx.emit?.('bom:loaded', { items: c.items.length, totalCost });
     },
-    onDetach(n: HSPlusNode, _c: BOMConfig, ctx: TraitContext) { delete n.__bomState; ctx.emit?.('bom:unloaded'); },
+    onDetach(n: HSPlusNode, _c: BOMConfig, ctx: TraitContext) {
+      delete n.__bomState;
+      ctx.emit?.('bom:unloaded');
+    },
     onUpdate() {},
     onEvent(_n: HSPlusNode, c: BOMConfig, ctx: TraitContext, e: TraitEvent) {
-      if (e.type === 'bom:check_availability') { const missing = c.items.filter(i => i.leadTimeDays > 14); ctx.emit?.('bom:availability', { available: c.items.length - missing.length, delayed: missing.length }); }
+      if (e.type === 'bom:check_availability') {
+        const missing = c.items.filter((i) => i.leadTimeDays > 14);
+        ctx.emit?.('bom:availability', {
+          available: c.items.length - missing.length,
+          delayed: missing.length,
+        });
+      }
     },
   };
 }

package/src/traits/DefectTrackingTrait.ts

@@ -2,25 +2,65 @@
 import type { TraitHandler, HSPlusNode, TraitContext, TraitEvent } from './types';
 
 export type DefectSeverity = 'critical' | 'major' | 'minor' | 'cosmetic';
-export interface Defect { id: string; severity: DefectSeverity; description: string; stationId: string; timestamp: number; resolved: boolean; }
-export interface DefectTrackingConfig { categories: string[]; autoEscalateCritical: boolean; maxOpenDefects: number; }
+export interface Defect {
+  id: string;
+  severity: DefectSeverity;
+  description: string;
+  stationId: string;
+  timestamp: number;
+  resolved: boolean;
+}
+export interface DefectTrackingConfig {
+  categories: string[];
+  autoEscalateCritical: boolean;
+  maxOpenDefects: number;
+}
 
-const defaultConfig: DefectTrackingConfig = { categories: ['dimensional', 'surface', 'functional', 'material'], autoEscalateCritical: true, maxOpenDefects: 50 };
+const defaultConfig: DefectTrackingConfig = {
+  categories: ['dimensional', 'surface', 'functional', 'material'],
+  autoEscalateCritical: true,
+  maxOpenDefects: 50,
+};
 
 export function createDefectTrackingHandler(): TraitHandler<DefectTrackingConfig> {
-  return { name: 'defect_tracking', defaultConfig,
-    onAttach(n: HSPlusNode, _c: DefectTrackingConfig, ctx: TraitContext) { n.__defectState = { defects: [], openCount: 0 }; ctx.emit?.('defect:tracker_ready'); },
-    onDetach(n: HSPlusNode, _c: DefectTrackingConfig, ctx: TraitContext) { delete n.__defectState; ctx.emit?.('defect:tracker_removed'); },
+  return {
+    name: 'defect_tracking',
+    defaultConfig,
+    onAttach(n: HSPlusNode, _c: DefectTrackingConfig, ctx: TraitContext) {
+      n.__defectState = { defects: [], openCount: 0 };
+      ctx.emit?.('defect:tracker_ready');
+    },
+    onDetach(n: HSPlusNode, _c: DefectTrackingConfig, ctx: TraitContext) {
+      delete n.__defectState;
+      ctx.emit?.('defect:tracker_removed');
+    },
     onUpdate() {},
     onEvent(n: HSPlusNode, c: DefectTrackingConfig, ctx: TraitContext, e: TraitEvent) {
-      const s = n.__defectState as { defects: Defect[]; openCount: number } | undefined; if (!s) return;
+      const s = n.__defectState as { defects: Defect[]; openCount: number } | undefined;
+      if (!s) return;
       if (e.type === 'defect:log') {
-        const defect: Defect = { id: `DEF-${s.defects.length + 1}`, severity: (e.payload?.severity as DefectSeverity) || 'minor', description: (e.payload?.description as string) || '', stationId: (e.payload?.stationId as string) || '', timestamp: Date.now(), resolved: false };
-        s.defects.push(defect); s.openCount++;
+        const defect: Defect = {
+          id: `DEF-${s.defects.length + 1}`,
+          severity: (e.payload?.severity as DefectSeverity) || 'minor',
+          description: (e.payload?.description as string) || '',
+          stationId: (e.payload?.stationId as string) || '',
+          timestamp: Date.now(),
+          resolved: false,
+        };
+        s.defects.push(defect);
+        s.openCount++;
         ctx.emit?.('defect:logged', { id: defect.id, severity: defect.severity });
-        if (defect.severity === 'critical' && c.autoEscalateCritical) ctx.emit?.('defect:escalated', { id: defect.id });
+        if (defect.severity === 'critical' && c.autoEscalateCritical)
+          ctx.emit?.('defect:escalated', { id: defect.id });
+      }
+      if (e.type === 'defect:resolve') {
+        const d = s.defects.find((d) => d.id === e.payload?.id);
+        if (d && !d.resolved) {
+          d.resolved = true;
+          s.openCount--;
+          ctx.emit?.('defect:resolved', { id: d.id });
+        }
       }
-      if (e.type === 'defect:resolve') { const d = s.defects.find(d => d.id === e.payload?.id); if (d && !d.resolved) { d.resolved = true; s.openCount--; ctx.emit?.('defect:resolved', { id: d.id }); } }
     },
   };
 }

package/src/traits/ProductionLineTrait.ts

@@ -1,26 +1,70 @@
 /** @production_line Trait — Assembly line management. @trait production_line */
 import type { TraitHandler, HSPlusNode, TraitContext, TraitEvent } from './types';
 
-export interface Station { id: string; name: string; cycleTimeS: number; status: 'running' | 'idle' | 'maintenance' | 'error'; }
-export interface ProductionLineConfig { stations: Station[]; targetUnitsPerHour: number; shiftDurationH: number; product: string; }
-export interface ProductionLineState { unitsProduced: number; currentThroughput: number; bottleneckStation: string | null; isRunning: boolean; }
+export interface Station {
+  id: string;
+  name: string;
+  cycleTimeS: number;
+  status: 'running' | 'idle' | 'maintenance' | 'error';
+}
+export interface ProductionLineConfig {
+  stations: Station[];
+  targetUnitsPerHour: number;
+  shiftDurationH: number;
+  product: string;
+}
+export interface ProductionLineState {
+  unitsProduced: number;
+  currentThroughput: number;
+  bottleneckStation: string | null;
+  isRunning: boolean;
+}
 
-const defaultConfig: ProductionLineConfig = { stations: [], targetUnitsPerHour: 60, shiftDurationH: 8, product: '' };
+const defaultConfig: ProductionLineConfig = {
+  stations: [],
+  targetUnitsPerHour: 60,
+  shiftDurationH: 8,
+  product: '',
+};
 
 export function createProductionLineHandler(): TraitHandler<ProductionLineConfig> {
-  return { name: 'production_line', defaultConfig,
-    onAttach(n: HSPlusNode, c: ProductionLineConfig, ctx: TraitContext) { n.__lineState = { unitsProduced: 0, currentThroughput: 0, bottleneckStation: null, isRunning: false }; ctx.emit?.('line:created', { stations: c.stations.length }); },
-    onDetach(n: HSPlusNode, _c: ProductionLineConfig, ctx: TraitContext) { delete n.__lineState; ctx.emit?.('line:shutdown'); },
+  return {
+    name: 'production_line',
+    defaultConfig,
+    onAttach(n: HSPlusNode, c: ProductionLineConfig, ctx: TraitContext) {
+      n.__lineState = {
+        unitsProduced: 0,
+        currentThroughput: 0,
+        bottleneckStation: null,
+        isRunning: false,
+      };
+      ctx.emit?.('line:created', { stations: c.stations.length });
+    },
+    onDetach(n: HSPlusNode, _c: ProductionLineConfig, ctx: TraitContext) {
+      delete n.__lineState;
+      ctx.emit?.('line:shutdown');
+    },
     onUpdate(n: HSPlusNode, c: ProductionLineConfig, ctx: TraitContext, delta: number) {
-      const s = n.__lineState as ProductionLineState | undefined; if (!s?.isRunning) return;
+      const s = n.__lineState as ProductionLineState | undefined;
+      if (!s?.isRunning) return;
       s.unitsProduced += (c.targetUnitsPerHour / 3600) * (delta / 1000);
-      const slowest = c.stations.reduce((a, b) => a.cycleTimeS > b.cycleTimeS ? a : b, c.stations[0]);
+      const slowest = c.stations.reduce(
+        (a, b) => (a.cycleTimeS > b.cycleTimeS ? a : b),
+        c.stations[0]
+      );
       s.bottleneckStation = slowest?.id ?? null;
     },
     onEvent(n: HSPlusNode, _c: ProductionLineConfig, ctx: TraitContext, e: TraitEvent) {
-      const s = n.__lineState as ProductionLineState | undefined; if (!s) return;
-      if (e.type === 'line:start') { s.isRunning = true; ctx.emit?.('line:started'); }
-      if (e.type === 'line:stop') { s.isRunning = false; ctx.emit?.('line:stopped', { produced: s.unitsProduced }); }
+      const s = n.__lineState as ProductionLineState | undefined;
+      if (!s) return;
+      if (e.type === 'line:start') {
+        s.isRunning = true;
+        ctx.emit?.('line:started');
+      }
+      if (e.type === 'line:stop') {
+        s.isRunning = false;
+        ctx.emit?.('line:stopped', { produced: s.unitsProduced });
+      }
     },
   };
 }

package/src/traits/QualityGateTrait.ts

@@ -1,26 +1,58 @@
 /** @quality_gate Trait — Inspection checkpoint. @trait quality_gate */
 import type { TraitHandler, HSPlusNode, TraitContext, TraitEvent } from './types';
 
-export interface InspectionCriteria { id: string; name: string; type: 'visual' | 'dimensional' | 'functional' | 'electrical'; tolerance: number; unit: string; }
-export interface QualityGateConfig { criteria: InspectionCriteria[]; passThreshold: number; autoReject: boolean; stationId: string; }
-export interface QualityGateState { inspected: number; passed: number; failed: number; passRate: number; }
+export interface InspectionCriteria {
+  id: string;
+  name: string;
+  type: 'visual' | 'dimensional' | 'functional' | 'electrical';
+  tolerance: number;
+  unit: string;
+}
+export interface QualityGateConfig {
+  criteria: InspectionCriteria[];
+  passThreshold: number;
+  autoReject: boolean;
+  stationId: string;
+}
+export interface QualityGateState {
+  inspected: number;
+  passed: number;
+  failed: number;
+  passRate: number;
+}
 
-const defaultConfig: QualityGateConfig = { criteria: [], passThreshold: 95, autoReject: true, stationId: '' };
+const defaultConfig: QualityGateConfig = {
+  criteria: [],
+  passThreshold: 95,
+  autoReject: true,
+  stationId: '',
+};
 
 export function createQualityGateHandler(): TraitHandler<QualityGateConfig> {
-  return { name: 'quality_gate', defaultConfig,
-    onAttach(n: HSPlusNode, _c: QualityGateConfig, ctx: TraitContext) { n.__qcState = { inspected: 0, passed: 0, failed: 0, passRate: 100 }; ctx.emit?.('qc:ready'); },
-    onDetach(n: HSPlusNode, _c: QualityGateConfig, ctx: TraitContext) { delete n.__qcState; ctx.emit?.('qc:removed'); },
+  return {
+    name: 'quality_gate',
+    defaultConfig,
+    onAttach(n: HSPlusNode, _c: QualityGateConfig, ctx: TraitContext) {
+      n.__qcState = { inspected: 0, passed: 0, failed: 0, passRate: 100 };
+      ctx.emit?.('qc:ready');
+    },
+    onDetach(n: HSPlusNode, _c: QualityGateConfig, ctx: TraitContext) {
+      delete n.__qcState;
+      ctx.emit?.('qc:removed');
+    },
     onUpdate() {},
     onEvent(n: HSPlusNode, c: QualityGateConfig, ctx: TraitContext, e: TraitEvent) {
-      const s = n.__qcState as QualityGateState | undefined; if (!s) return;
+      const s = n.__qcState as QualityGateState | undefined;
+      if (!s) return;
       if (e.type === 'qc:inspect') {
         s.inspected++;
         const pass = (e.payload?.pass as boolean) ?? true;
-        if (pass) s.passed++; else s.failed++;
+        if (pass) s.passed++;
+        else s.failed++;
         s.passRate = s.inspected > 0 ? (s.passed / s.inspected) * 100 : 100;
         ctx.emit?.('qc:inspected', { pass, passRate: s.passRate });
-        if (s.passRate < c.passThreshold) ctx.emit?.('qc:threshold_breach', { passRate: s.passRate, threshold: c.passThreshold });
+        if (s.passRate < c.passThreshold)
+          ctx.emit?.('qc:threshold_breach', { passRate: s.passRate, threshold: c.passThreshold });
       }
     },
   };

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.