@holoscript/plugin-manufacturing-qc 2.0.1

package/src/traits/BOMTrait.ts

@@ -0,0 +1,22 @@
+/** @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; }
+
+const defaultConfig: BOMConfig = { items: [], revision: '1.0', product: '' };
+
+export function createBOMHandler(): TraitHandler<BOMConfig> {
+  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)) };
+      ctx.emit?.('bom:loaded', { items: c.items.length, totalCost });
+    },
+    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 }); }
+    },
+  };
+}

package/src/traits/DefectTrackingTrait.ts

@@ -0,0 +1,26 @@
+/** @defect_tracking Trait — Defect logging and classification. @trait defect_tracking */
+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; }
+
+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'); },
+    onUpdate() {},
+    onEvent(n: HSPlusNode, c: DefectTrackingConfig, ctx: TraitContext, e: TraitEvent) {
+      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++;
+        ctx.emit?.('defect:logged', { id: defect.id, severity: defect.severity });
+        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 }); } }
+    },
+  };
+}

package/src/traits/ProductionLineTrait.ts

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

package/src/traits/QualityGateTrait.ts

@@ -0,0 +1,27 @@
+/** @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; }
+
+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'); },
+    onUpdate() {},
+    onEvent(n: HSPlusNode, c: QualityGateConfig, ctx: TraitContext, e: TraitEvent) {
+      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++;
+        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 });
+      }
+    },
+  };
+}

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,22 @@
+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',
+    include: ['src/**/*.test.ts'],
+    passWithNoTests: true,
+  },
+});