@holoscript/plugin-education-lms 2.0.1 → 2.0.2

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@holoscript/plugin-education-lms",
-  "version": "2.0.1",
+  "version": "2.0.2",
   "description": "HoloScript domain plugin for education-lms",
   "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__/educationsolver.test.ts

@@ -28,8 +28,8 @@ describe('irtAbilityEstimate', () => {
   it('all correct → high positive ability estimate', () => {
     const items = [
       { id: 'i1', b: -1 },
-      { id: 'i2', b:  0 },
-      { id: 'i3', b:  1 },
+      { id: 'i2', b: 0 },
+      { id: 'i3', b: 1 },
     ];
     const responses = [
       { itemId: 'i1', correct: true },
@@ -43,8 +43,8 @@ describe('irtAbilityEstimate', () => {
   it('all incorrect → low negative ability estimate', () => {
     const items = [
       { id: 'i1', b: -1 },
-      { id: 'i2', b:  0 },
-      { id: 'i3', b:  1 },
+      { id: 'i2', b: 0 },
+      { id: 'i3', b: 1 },
     ];
     const responses = [
       { itemId: 'i1', correct: false },
@@ -57,8 +57,14 @@ describe('irtAbilityEstimate', () => {
 
   it('ability near item difficulty for 50/50 pattern', () => {
     // Items with difficulties -1, +1; student gets easy correct, hard wrong
-    const items = [{ id: 'easy', b: -2 }, { id: 'hard', b: 2 }];
-    const responses = [{ itemId: 'easy', correct: true }, { itemId: 'hard', correct: false }];
+    const items = [
+      { id: 'easy', b: -2 },
+      { id: 'hard', b: 2 },
+    ];
+    const responses = [
+      { itemId: 'easy', correct: true },
+      { itemId: 'hard', correct: false },
+    ];
     const r = irtAbilityEstimate(items, responses);
     // Ability should be in middle range
     expect(r.abilityTheta).toBeGreaterThan(-2);
@@ -66,23 +72,39 @@ describe('irtAbilityEstimate', () => {
   });
 
   it('testInformation = sum of itemInformation', () => {
-    const items = [{ id: 'i1', b: 0 }, { id: 'i2', b: 1 }];
-    const responses = [{ itemId: 'i1', correct: true }, { itemId: 'i2', correct: false }];
+    const items = [
+      { id: 'i1', b: 0 },
+      { id: 'i2', b: 1 },
+    ];
+    const responses = [
+      { itemId: 'i1', correct: true },
+      { itemId: 'i2', correct: false },
+    ];
     const r = irtAbilityEstimate(items, responses);
     const manualSum = r.itemInformation.reduce((s, x) => s + x.information, 0);
     expect(r.testInformation).toBeCloseTo(manualSum, 6);
   });
 
   it('standardError = 1/sqrt(testInformation)', () => {
-    const items = [{ id: 'i1', b: 0 }, { id: 'i2', b: 0.5 }];
-    const responses = [{ itemId: 'i1', correct: true }, { itemId: 'i2', correct: true }];
+    const items = [
+      { id: 'i1', b: 0 },
+      { id: 'i2', b: 0.5 },
+    ];
+    const responses = [
+      { itemId: 'i1', correct: true },
+      { itemId: 'i2', correct: true },
+    ];
     const r = irtAbilityEstimate(items, responses);
     expect(r.standardError).toBeCloseTo(1 / Math.sqrt(r.testInformation), 4);
   });
 
   it('itemFit length matches items length', () => {
-    const items = [{ id: 'i1', b: 0 }, { id: 'i2', b: 1 }, { id: 'i3', b: -1 }];
-    const responses = items.map(it => ({ itemId: it.id, correct: true }));
+    const items = [
+      { id: 'i1', b: 0 },
+      { id: 'i2', b: 1 },
+      { id: 'i3', b: -1 },
+    ];
+    const responses = items.map((it) => ({ itemId: it.id, correct: true }));
     const r = irtAbilityEstimate(items, responses);
     expect(r.itemFit).toHaveLength(3);
   });
@@ -90,11 +112,23 @@ describe('irtAbilityEstimate', () => {
   it('higher discrimination a → more information near item difficulty', () => {
     // Use mixed responses: easy item correct, hard item wrong → theta stays near 0
     // where discrimination parameter a is most influential
-    const itemsLow  = [{ id: 'easy', a: 0.5, b: -2 }, { id: 'hard', a: 0.5, b: 2 }];
-    const itemsHigh = [{ id: 'easy', a: 2.0, b: -2 }, { id: 'hard', a: 2.0, b: 2 }];
-    const responsesLow  = [{ itemId: 'easy', correct: true }, { itemId: 'hard', correct: false }];
-    const responsesHigh = [{ itemId: 'easy', correct: true }, { itemId: 'hard', correct: false }];
-    const rLow  = irtAbilityEstimate(itemsLow,  responsesLow);
+    const itemsLow = [
+      { id: 'easy', a: 0.5, b: -2 },
+      { id: 'hard', a: 0.5, b: 2 },
+    ];
+    const itemsHigh = [
+      { id: 'easy', a: 2.0, b: -2 },
+      { id: 'hard', a: 2.0, b: 2 },
+    ];
+    const responsesLow = [
+      { itemId: 'easy', correct: true },
+      { itemId: 'hard', correct: false },
+    ];
+    const responsesHigh = [
+      { itemId: 'easy', correct: true },
+      { itemId: 'hard', correct: false },
+    ];
+    const rLow = irtAbilityEstimate(itemsLow, responsesLow);
     const rHigh = irtAbilityEstimate(itemsHigh, responsesHigh);
     // Higher discrimination → higher test information at estimated theta
     expect(rHigh.testInformation).toBeGreaterThan(rLow.testInformation);
@@ -176,10 +210,10 @@ describe('sm2Review', () => {
 
 describe('learningPathOptimizer', () => {
   const nodes = [
-    { id: 'A', label: 'Algebra',      prerequisites: [],      estimatedMinutes: 60 },
-    { id: 'B', label: 'Calculus',     prerequisites: ['A'],   estimatedMinutes: 90 },
-    { id: 'C', label: 'Statistics',   prerequisites: ['A'],   estimatedMinutes: 45 },
-    { id: 'D', label: 'ML Basics',    prerequisites: ['B','C'], estimatedMinutes: 120 },
+    { id: 'A', label: 'Algebra', prerequisites: [], estimatedMinutes: 60 },
+    { id: 'B', label: 'Calculus', prerequisites: ['A'], estimatedMinutes: 90 },
+    { id: 'C', label: 'Statistics', prerequisites: ['A'], estimatedMinutes: 45 },
+    { id: 'D', label: 'ML Basics', prerequisites: ['B', 'C'], estimatedMinutes: 120 },
   ];
 
   it('path is in topological order (prerequisites before dependents)', () => {
@@ -201,7 +235,7 @@ describe('learningPathOptimizer', () => {
     const mastery: { nodeId: string; masteryScore: number }[] = [];
     const r = learningPathOptimizer(nodes, mastery);
     const expected = r.path.reduce((acc, id) => {
-      const n = nodes.find(x => x.id === id);
+      const n = nodes.find((x) => x.id === id);
       return acc + (n?.estimatedMinutes ?? 30);
     }, 0);
     expect(r.totalMinutes).toBe(expected);
@@ -213,9 +247,7 @@ describe('learningPathOptimizer', () => {
   });
 
   it('throws if prerequisite node not found', () => {
-    const badNodes = [
-      { id: 'X', label: 'X', prerequisites: ['MISSING'], estimatedMinutes: 30 },
-    ];
+    const badNodes = [{ id: 'X', label: 'X', prerequisites: ['MISSING'], estimatedMinutes: 30 }];
     expect(() => learningPathOptimizer(badNodes, [])).toThrow();
   });
 
@@ -239,12 +271,12 @@ describe('gradePredictor', () => {
 
   it('recent grades weighted more heavily with decay < 1', () => {
     const grades = [
-      { weight: 1, score: 0.50, recencyIndex: 1 }, // old, low
+      { weight: 1, score: 0.5, recencyIndex: 1 }, // old, low
       { weight: 1, score: 0.95, recencyIndex: 5 }, // recent, high
     ];
     const r = gradePredictor(grades, 0.5);
     // Should be closer to 0.95 than to plain average
-    expect(r.predictedGrade).toBeGreaterThan(0.70);
+    expect(r.predictedGrade).toBeGreaterThan(0.7);
   });
 
   it('predictedGrade 0.93+ → letter A, gpa=4.0', () => {
@@ -255,7 +287,7 @@ describe('gradePredictor', () => {
   });
 
   it('predictedGrade below 0.60 → letter F, gpa=0.0', () => {
-    const grades = [{ weight: 1, score: 0.50, recencyIndex: 1 }];
+    const grades = [{ weight: 1, score: 0.5, recencyIndex: 1 }];
     const r = gradePredictor(grades);
     expect(r.letterGrade).toBe('F');
     expect(r.gpa).toBe(0.0);
@@ -406,8 +438,8 @@ describe('buildEducationReceipt', () => {
       itemCount: 3,
       n: 10,
       pValues: [0.5, 0.5, 0.5],
-      discriminationIndices: [0.05, 0.05, 0.05],  // all poor → > 50% poor items
-      cronbachAlpha: 0.30,  // below 0.70 threshold
+      discriminationIndices: [0.05, 0.05, 0.05], // all poor → > 50% poor items
+      cronbachAlpha: 0.3, // below 0.70 threshold
       meanScore: 1.5,
       stdDevScore: 0.5,
       poorItems: ['i1', 'i2', 'i3'],

package/src/educationsolver.ts

@@ -144,28 +144,28 @@ function itemInfo(theta: number, a: number, b: number, c: number): number {
  * Estimate student ability θ via Newton-Raphson MLE.
  * Iterates until convergence or max 50 steps.
  */
-export function irtAbilityEstimate(
-  items: IRTItem[],
-  responses: IRTResponse[],
-): IRTResult {
+export function irtAbilityEstimate(items: IRTItem[], responses: IRTResponse[]): IRTResult {
   if (items.length === 0) throw new Error('No items provided');
   if (responses.length !== items.length) throw new Error('responses must match items length');
 
-  const itemMap = new Map(items.map(it => [it.id, it]));
-  const responseMap = new Map(responses.map(r => [r.itemId, r.correct ? 1 : 0]));
+  const itemMap = new Map(items.map((it) => [it.id, it]));
+  const responseMap = new Map(responses.map((r) => [r.itemId, r.correct ? 1 : 0]));
 
   // Newton-Raphson MLE
   let theta = 0.0;
   for (let iter = 0; iter < 50; iter++) {
-    let firstDeriv = 0, secondDeriv = 0;
+    let firstDeriv = 0,
+      secondDeriv = 0;
     for (const item of items) {
-      const a = item.a ?? 1.0, b = item.b, c = item.c ?? 0;
+      const a = item.a ?? 1.0,
+        b = item.b,
+        c = item.c ?? 0;
       const P = irt3PL(theta, a, b, c);
       const u = responseMap.get(item.id) ?? 0;
       const W = (P - c) / ((1 - c) * P * (1 - P) + 1e-15);
-      const dP = a * (P - c) * (1 - P) / (1 - c + 1e-15);
-      firstDeriv  += (u - P) * dP / (P * (1 - P) + 1e-15);
-      secondDeriv -= dP * dP / (P * (1 - P) + 1e-15);
+      const dP = (a * (P - c) * (1 - P)) / (1 - c + 1e-15);
+      firstDeriv += ((u - P) * dP) / (P * (1 - P) + 1e-15);
+      secondDeriv -= (dP * dP) / (P * (1 - P) + 1e-15);
     }
     if (Math.abs(secondDeriv) < 1e-12) break;
     const step = firstDeriv / secondDeriv;
@@ -175,16 +175,20 @@ export function irtAbilityEstimate(
   }
 
   // Standard error = 1 / sqrt(test information)
-  const infoArr = items.map(item => {
-    const a = item.a ?? 1.0, b = item.b, c = item.c ?? 0;
+  const infoArr = items.map((item) => {
+    const a = item.a ?? 1.0,
+      b = item.b,
+      c = item.c ?? 0;
     return { itemId: item.id, information: itemInfo(theta, a, b, c) };
   });
   const testInformation = infoArr.reduce((s, x) => s + x.information, 0);
   const standardError = testInformation > 0 ? 1 / Math.sqrt(testInformation) : Infinity;
 
   // Item fit residuals
-  const itemFit = items.map(item => {
-    const a = item.a ?? 1.0, b = item.b, c = item.c ?? 0;
+  const itemFit = items.map((item) => {
+    const a = item.a ?? 1.0,
+      b = item.b,
+      c = item.c ?? 0;
     const P = irt3PL(theta, a, b, c);
     const u = responseMap.get(item.id) ?? 0;
     const residual = (u - P) / Math.sqrt(P * (1 - P) + 1e-15);
@@ -205,7 +209,7 @@ export function irtAbilityEstimate(
 export function sm2Review(card: SM2Card, quality: 0 | 1 | 2 | 3 | 4 | 5): SM2Result {
   if (quality < 0 || quality > 5) throw new Error('quality must be 0-5');
 
-  let ef  = card.ef ?? 2.5;
+  let ef = card.ef ?? 2.5;
   let rep = card.repetitions ?? 0;
   let interval = card.interval ?? 1;
 
@@ -235,29 +239,30 @@ export function sm2Review(card: SM2Card, quality: 0 | 1 | 2 | 3 | 4 | 5): SM2Res
 export function learningPathOptimizer(
   nodes: KnowledgeNode[],
   masteryStates: MasteryState[],
-  masteryThreshold = 0.80,
+  masteryThreshold = 0.8
 ): LearningPathResult {
   if (nodes.length === 0) throw new Error('No knowledge nodes provided');
 
-  const masteryMap = new Map(masteryStates.map(m => [m.nodeId, m.masteryScore]));
-  const nodeMap = new Map(nodes.map(n => [n.id, n]));
+  const masteryMap = new Map(masteryStates.map((m) => [m.nodeId, m.masteryScore]));
+  const nodeMap = new Map(nodes.map((n) => [n.id, n]));
 
   // Validate prerequisites exist
   for (const node of nodes) {
     for (const prereq of node.prerequisites) {
-      if (!nodeMap.has(prereq)) throw new Error(`Prerequisite ${prereq} not found for node ${node.id}`);
+      if (!nodeMap.has(prereq))
+        throw new Error(`Prerequisite ${prereq} not found for node ${node.id}`);
     }
   }
 
   // Kahn's topological sort
-  const inDegree = new Map(nodes.map(n => [n.id, 0]));
+  const inDegree = new Map(nodes.map((n) => [n.id, 0]));
   for (const node of nodes) {
     for (const prereq of node.prerequisites) {
       inDegree.set(node.id, (inDegree.get(node.id) ?? 0) + 1);
     }
   }
 
-  const queue: string[] = nodes.filter(n => (inDegree.get(n.id) ?? 0) === 0).map(n => n.id);
+  const queue: string[] = nodes.filter((n) => (inDegree.get(n.id) ?? 0) === 0).map((n) => n.id);
   const topoOrder: string[] = [];
   const adj = new Map<string, string[]>();
   for (const node of nodes) {
@@ -270,7 +275,7 @@ export function learningPathOptimizer(
   while (queue.length > 0) {
     const cur = queue.shift()!;
     topoOrder.push(cur);
-    for (const child of (adj.get(cur) ?? [])) {
+    for (const child of adj.get(cur) ?? []) {
       const newDeg = (inDegree.get(child) ?? 0) - 1;
       inDegree.set(child, newDeg);
       if (newDeg === 0) queue.push(child);
@@ -280,7 +285,7 @@ export function learningPathOptimizer(
   const feasible = topoOrder.length === nodes.length;
 
   // Filter to nodes that need study (mastery < threshold)
-  const path = topoOrder.filter(id => (masteryMap.get(id) ?? 0) < masteryThreshold);
+  const path = topoOrder.filter((id) => (masteryMap.get(id) ?? 0) < masteryThreshold);
   const totalMinutes = path.reduce((acc, id) => acc + (nodeMap.get(id)?.estimatedMinutes ?? 30), 0);
 
   return { path, totalMinutes, feasible };
@@ -303,13 +308,14 @@ export interface GradeEntry {
  */
 export function gradePredictor(
   grades: GradeEntry[],
-  decay = 0.85,
+  decay = 0.85
 ): { predictedGrade: number; letterGrade: string; gpa: number } {
   if (grades.length === 0) throw new Error('No grade entries provided');
   if (decay <= 0 || decay > 1) throw new Error('decay must be in (0, 1]');
 
-  const maxRecency = Math.max(...grades.map(g => g.recencyIndex));
-  let weightedSum = 0, totalWeight = 0;
+  const maxRecency = Math.max(...grades.map((g) => g.recencyIndex));
+  let weightedSum = 0,
+    totalWeight = 0;
   for (const g of grades) {
     const recencyWeight = Math.pow(decay, maxRecency - g.recencyIndex);
     const w = g.weight * recencyWeight;
@@ -320,19 +326,40 @@ export function gradePredictor(
 
   // Letter grade (US standard)
   const letter =
-    predictedGrade >= 0.93 ? 'A'  :
-    predictedGrade >= 0.90 ? 'A-' :
-    predictedGrade >= 0.87 ? 'B+' :
-    predictedGrade >= 0.83 ? 'B'  :
-    predictedGrade >= 0.80 ? 'B-' :
-    predictedGrade >= 0.77 ? 'C+' :
-    predictedGrade >= 0.73 ? 'C'  :
-    predictedGrade >= 0.70 ? 'C-' :
-    predictedGrade >= 0.67 ? 'D+' :
-    predictedGrade >= 0.60 ? 'D'  : 'F';
+    predictedGrade >= 0.93
+      ? 'A'
+      : predictedGrade >= 0.9
+        ? 'A-'
+        : predictedGrade >= 0.87
+          ? 'B+'
+          : predictedGrade >= 0.83
+            ? 'B'
+            : predictedGrade >= 0.8
+              ? 'B-'
+              : predictedGrade >= 0.77
+                ? 'C+'
+                : predictedGrade >= 0.73
+                  ? 'C'
+                  : predictedGrade >= 0.7
+                    ? 'C-'
+                    : predictedGrade >= 0.67
+                      ? 'D+'
+                      : predictedGrade >= 0.6
+                        ? 'D'
+                        : 'F';
 
   const gpaMap: Record<string, number> = {
-    'A':4.0,'A-':3.7,'B+':3.3,'B':3.0,'B-':2.7,'C+':2.3,'C':2.0,'C-':1.7,'D+':1.3,'D':1.0,'F':0.0,
+    A: 4.0,
+    'A-': 3.7,
+    'B+': 3.3,
+    B: 3.0,
+    'B-': 2.7,
+    'C+': 2.3,
+    C: 2.0,
+    'C-': 1.7,
+    'D+': 1.3,
+    D: 1.0,
+    F: 0.0,
   };
 
   return { predictedGrade, letterGrade: letter, gpa: gpaMap[letter] };
@@ -342,38 +369,98 @@ export function gradePredictor(
 
 const BLOOM_VERBS: Record<string, number> = {
   // L1 Remember
-  define:1, list:1, recall:1, recognize:1, identify:1, name:1, state:1, describe:1, memorize:1,
+  define: 1,
+  list: 1,
+  recall: 1,
+  recognize: 1,
+  identify: 1,
+  name: 1,
+  state: 1,
+  describe: 1,
+  memorize: 1,
   // L2 Understand
-  explain:2, summarize:2, paraphrase:2, classify:2, compare:2, interpret:2, discuss:2, review:2,
+  explain: 2,
+  summarize: 2,
+  paraphrase: 2,
+  classify: 2,
+  compare: 2,
+  interpret: 2,
+  discuss: 2,
+  review: 2,
   // L3 Apply
-  apply:3, use:3, demonstrate:3, solve:3, implement:3, compute:3, execute:3, calculate:3, practice:3,
+  apply: 3,
+  use: 3,
+  demonstrate: 3,
+  solve: 3,
+  implement: 3,
+  compute: 3,
+  execute: 3,
+  calculate: 3,
+  practice: 3,
   // L4 Analyze
-  analyze:4, differentiate:4, examine:4, distinguish:4, break:4, deconstruct:4, investigate:4, inspect:4,
+  analyze: 4,
+  differentiate: 4,
+  examine: 4,
+  distinguish: 4,
+  break: 4,
+  deconstruct: 4,
+  investigate: 4,
+  inspect: 4,
   // L5 Evaluate
-  evaluate:5, judge:5, critique:5, justify:5, assess:5, argue:5, defend:5, prioritize:5, rank:5,
+  evaluate: 5,
+  judge: 5,
+  critique: 5,
+  justify: 5,
+  assess: 5,
+  argue: 5,
+  defend: 5,
+  prioritize: 5,
+  rank: 5,
   // L6 Create
-  create:6, design:6, construct:6, develop:6, formulate:6, compose:6, plan:6, produce:6, generate:6,
+  create: 6,
+  design: 6,
+  construct: 6,
+  develop: 6,
+  formulate: 6,
+  compose: 6,
+  plan: 6,
+  produce: 6,
+  generate: 6,
 };
 
-const BLOOM_LABELS = ['','Remember','Understand','Apply','Analyze','Evaluate','Create'] as const;
+const BLOOM_LABELS = [
+  '',
+  'Remember',
+  'Understand',
+  'Apply',
+  'Analyze',
+  'Evaluate',
+  'Create',
+] as const;
 
 /**
  * Classify learning objective text into Bloom's taxonomy level.
  */
 export function bloomClassifier(objectiveText: string): BloomLevel {
-  const words = objectiveText.toLowerCase().replace(/[^a-z\s]/g, '').split(/\s+/);
-  const levelCounts = [0,0,0,0,0,0,0];
+  const words = objectiveText
+    .toLowerCase()
+    .replace(/[^a-z\s]/g, '')
+    .split(/\s+/);
+  const levelCounts = [0, 0, 0, 0, 0, 0, 0];
   let matched = 0;
   for (const word of words) {
     const lvl = BLOOM_VERBS[word];
-    if (lvl) { levelCounts[lvl]++; matched++; }
+    if (lvl) {
+      levelCounts[lvl]++;
+      matched++;
+    }
   }
   if (matched === 0) {
     return { level: 1, label: 'Remember', confidence: 0 };
   }
   let bestLevel = 1;
   for (let l = 2; l <= 6; l++) if (levelCounts[l] > levelCounts[bestLevel]) bestLevel = l;
-  const level = bestLevel as 1|2|3|4|5|6;
+  const level = bestLevel as 1 | 2 | 3 | 4 | 5 | 6;
   return { level, label: BLOOM_LABELS[level], confidence: levelCounts[level] / words.length };
 }
 
@@ -384,25 +471,23 @@ export function bloomClassifier(objectiveText: string): BloomLevel {
  * responses: matrix [student][item] = 0/1
  * itemIds: label per item
  */
-export function quizPsychometrics(
-  responses: number[][],
-  itemIds: string[],
-): QuizPsychometrics {
+export function quizPsychometrics(responses: number[][], itemIds: string[]): QuizPsychometrics {
   const n = responses.length;
   if (n < 2) throw new Error('At least 2 respondents required');
   const k = itemIds.length;
-  if (responses.some(row => row.length !== k)) throw new Error('All response rows must match itemIds length');
+  if (responses.some((row) => row.length !== k))
+    throw new Error('All response rows must match itemIds length');
 
   // P-values
   const pValues = itemIds.map((_, j) => {
-    const correct = responses.filter(r => r[j] === 1).length;
+    const correct = responses.filter((r) => r[j] === 1).length;
     return correct / n;
   });
 
   // Total scores
-  const scores = responses.map(row => row.reduce((a, b) => a + b, 0));
+  const scores = responses.map((row) => row.reduce((a, b) => a + b, 0));
   const meanScore = scores.reduce((a, b) => a + b, 0) / n;
-  const variance  = scores.reduce((acc, s) => acc + (s - meanScore) ** 2, 0) / (n - 1);
+  const variance = scores.reduce((acc, s) => acc + (s - meanScore) ** 2, 0) / (n - 1);
   const stdDevScore = Math.sqrt(variance);
 
   // Discrimination indices (upper/lower 27%)
@@ -412,8 +497,8 @@ export function quizPsychometrics(
   const lower = sortedIndices.slice(n - k27);
 
   const discriminationIndices = itemIds.map((_, j) => {
-    const pU = upper.filter(i => responses[i][j] === 1).length / k27;
-    const pL = lower.filter(i => responses[i][j] === 1).length / k27;
+    const pU = upper.filter((i) => responses[i][j] === 1).length / k27;
+    const pL = lower.filter((i) => responses[i][j] === 1).length / k27;
     return pU - pL;
   });
 
@@ -423,13 +508,20 @@ export function quizPsychometrics(
     return p * (1 - p);
   });
   const sumItemVar = itemVariances.reduce((a, b) => a + b, 0);
-  const cronbachAlpha = k > 1 && variance > 0
-    ? (k / (k - 1)) * (1 - sumItemVar / variance)
-    : 0;
+  const cronbachAlpha = k > 1 && variance > 0 ? (k / (k - 1)) * (1 - sumItemVar / variance) : 0;
 
   const poorItems = itemIds.filter((_, j) => discriminationIndices[j] < 0.2);
 
-  return { itemCount: k, n, pValues, discriminationIndices, cronbachAlpha, meanScore, stdDevScore, poorItems };
+  return {
+    itemCount: k,
+    n,
+    pValues,
+    discriminationIndices,
+    cronbachAlpha,
+    meanScore,
+    stdDevScore,
+    poorItems,
+  };
 }
 
 // ─── Receipt ──────────────────────────────────────────────────────────────────
@@ -446,21 +538,30 @@ export interface EducationAnalysisResult {
 
 export function buildEducationReceipt(
   result: EducationAnalysisResult,
-  options?: EducationReceiptOptions,
+  options?: EducationReceiptOptions
 ): DomainSimulationReceipt {
   const violations: Array<{ criterion: string; message: string }> = [];
 
   if (result.psychometrics) {
     const { cronbachAlpha, poorItems } = result.psychometrics;
-    if (cronbachAlpha < 0.70) {
-      violations.push({ criterion: 'reliability', message: `Cronbach's α ${cronbachAlpha.toFixed(3)} < 0.70 — quiz reliability is poor` });
+    if (cronbachAlpha < 0.7) {
+      violations.push({
+        criterion: 'reliability',
+        message: `Cronbach's α ${cronbachAlpha.toFixed(3)} < 0.70 — quiz reliability is poor`,
+      });
     }
     if (poorItems.length > result.psychometrics.itemCount / 2) {
-      violations.push({ criterion: 'discrimination', message: `${poorItems.length}/${result.psychometrics.itemCount} items have poor discrimination (D < 0.2)` });
+      violations.push({
+        criterion: 'discrimination',
+        message: `${poorItems.length}/${result.psychometrics.itemCount} items have poor discrimination (D < 0.2)`,
+      });
     }
   }
   if (result.learningPath && !result.learningPath.feasible) {
-    violations.push({ criterion: 'prerequisite_cycle', message: 'Prerequisite graph contains a cycle — learning path is infeasible' });
+    violations.push({
+      criterion: 'prerequisite_cycle',
+      message: 'Prerequisite graph contains a cycle — learning path is infeasible',
+    });
   }
 
   return buildDomainSimulationReceipt({
@@ -475,7 +576,11 @@ export function buildEducationReceipt(
       learningPathNodes: result.learningPath?.path.length ?? null,
       bloomLevel: result.bloom?.level ?? null,
     },
-    cael: { version: 'cael.v1', event: 'education_lms.learning_analysis', solverType: 'education-lms.irt-3pl' },
+    cael: {
+      version: 'cael.v1',
+      event: 'education_lms.learning_analysis',
+      solverType: 'education-lms.irt-3pl',
+    },
     acceptance: { accepted: violations.length === 0, violations },
   });
 }

package/src/index.ts

@@ -1,9 +1,23 @@
 export * from './educationsolver';
-export { createCourseHandler, type CourseConfig, type CourseState, type Difficulty } from './traits/CourseTrait';
+export {
+  createCourseHandler,
+  type CourseConfig,
+  type CourseState,
+  type Difficulty,
+} from './traits/CourseTrait';
 export { createLessonHandler, type LessonConfig, type ContentType } from './traits/LessonTrait';
 export { createGradeHandler, type GradeConfig, type GradingScale } from './traits/GradeTrait';
-export { createEnrollmentHandler, type EnrollmentConfig, type EnrollmentStatus } from './traits/EnrollmentTrait';
-export { createQuizHandler, type QuizConfig, type QuizQuestion, type QuestionType } from './traits/QuizTrait';
+export {
+  createEnrollmentHandler,
+  type EnrollmentConfig,
+  type EnrollmentStatus,
+} from './traits/EnrollmentTrait';
+export {
+  createQuizHandler,
+  type QuizConfig,
+  type QuizQuestion,
+  type QuestionType,
+} from './traits/QuizTrait';
 export * from './traits/types';
 
 import { createCourseHandler } from './traits/CourseTrait';
@@ -12,5 +26,15 @@ import { createGradeHandler } from './traits/GradeTrait';
 import { createEnrollmentHandler } from './traits/EnrollmentTrait';
 import { createQuizHandler } from './traits/QuizTrait';
 
-export const pluginMeta = { name: '@holoscript/plugin-education-lms', version: '1.0.0', traits: ['course', 'lesson', 'grade', 'enrollment', 'quiz'] };
-export const traitHandlers = [createCourseHandler(), createLessonHandler(), createGradeHandler(), createEnrollmentHandler(), createQuizHandler()];
+export const pluginMeta = {
+  name: '@holoscript/plugin-education-lms',
+  version: '1.0.0',
+  traits: ['course', 'lesson', 'grade', 'enrollment', 'quiz'],
+};
+export const traitHandlers = [
+  createCourseHandler(),
+  createLessonHandler(),
+  createGradeHandler(),
+  createEnrollmentHandler(),
+  createQuizHandler(),
+];

package/src/traits/CourseTrait.ts

@@ -2,21 +2,63 @@
 import type { TraitHandler, HSPlusNode, TraitContext, TraitEvent } from './types';
 
 export type Difficulty = 'beginner' | 'intermediate' | 'advanced' | 'expert';
-export interface CourseConfig { title: string; description: string; instructor: string; durationHours: number; difficulty: Difficulty; prerequisites: string[]; modules: string[]; maxEnrollment: number; }
-export interface CourseState { enrolledCount: number; completionRate: number; averageScore: number; isPublished: boolean; }
+export interface CourseConfig {
+  title: string;
+  description: string;
+  instructor: string;
+  durationHours: number;
+  difficulty: Difficulty;
+  prerequisites: string[];
+  modules: string[];
+  maxEnrollment: number;
+}
+export interface CourseState {
+  enrolledCount: number;
+  completionRate: number;
+  averageScore: number;
+  isPublished: boolean;
+}
 
-const defaultConfig: CourseConfig = { title: '', description: '', instructor: '', durationHours: 1, difficulty: 'beginner', prerequisites: [], modules: [], maxEnrollment: 100 };
+const defaultConfig: CourseConfig = {
+  title: '',
+  description: '',
+  instructor: '',
+  durationHours: 1,
+  difficulty: 'beginner',
+  prerequisites: [],
+  modules: [],
+  maxEnrollment: 100,
+};
 
 export function createCourseHandler(): TraitHandler<CourseConfig> {
   return {
-    name: 'course', defaultConfig,
-    onAttach(node: HSPlusNode, config: CourseConfig, ctx: TraitContext) { node.__courseState = { enrolledCount: 0, completionRate: 0, averageScore: 0, isPublished: false }; ctx.emit?.('course:created', { title: config.title }); },
-    onDetach(node: HSPlusNode, _c: CourseConfig, ctx: TraitContext) { delete node.__courseState; ctx.emit?.('course:removed'); },
+    name: 'course',
+    defaultConfig,
+    onAttach(node: HSPlusNode, config: CourseConfig, ctx: TraitContext) {
+      node.__courseState = {
+        enrolledCount: 0,
+        completionRate: 0,
+        averageScore: 0,
+        isPublished: false,
+      };
+      ctx.emit?.('course:created', { title: config.title });
+    },
+    onDetach(node: HSPlusNode, _c: CourseConfig, ctx: TraitContext) {
+      delete node.__courseState;
+      ctx.emit?.('course:removed');
+    },
     onUpdate() {},
     onEvent(node: HSPlusNode, _c: CourseConfig, ctx: TraitContext, event: TraitEvent) {
-      const s = node.__courseState as CourseState | undefined; if (!s) return;
-      if (event.type === 'course:publish') { s.isPublished = true; ctx.emit?.('course:published'); }
-      if (event.type === 'course:enroll') { s.enrolledCount++; ctx.emit?.('course:enrollment_updated', { count: s.enrolledCount }); }
+      const s = node.__courseState as CourseState | undefined;
+      if (!s) return;
+      if (event.type === 'course:publish') {
+        s.isPublished = true;
+        ctx.emit?.('course:published');
+      }
+      if (event.type === 'course:enroll') {
+        s.enrolledCount++;
+        ctx.emit?.('course:enrollment_updated', { count: s.enrolledCount });
+      }
     },
   };
 }

package/src/traits/EnrollmentTrait.ts

@@ -2,21 +2,51 @@
 import type { TraitHandler, HSPlusNode, TraitContext, TraitEvent } from './types';
 
 export type EnrollmentStatus = 'enrolled' | 'completed' | 'dropped' | 'waitlisted' | 'suspended';
-export interface EnrollmentConfig { studentId: string; courseId: string; status: EnrollmentStatus; enrolledDate: string; progressPercent: number; }
+export interface EnrollmentConfig {
+  studentId: string;
+  courseId: string;
+  status: EnrollmentStatus;
+  enrolledDate: string;
+  progressPercent: number;
+}
 
-const defaultConfig: EnrollmentConfig = { studentId: '', courseId: '', status: 'enrolled', enrolledDate: '', progressPercent: 0 };
+const defaultConfig: EnrollmentConfig = {
+  studentId: '',
+  courseId: '',
+  status: 'enrolled',
+  enrolledDate: '',
+  progressPercent: 0,
+};
 
 export function createEnrollmentHandler(): TraitHandler<EnrollmentConfig> {
   return {
-    name: 'enrollment', defaultConfig,
-    onAttach(node: HSPlusNode, config: EnrollmentConfig, ctx: TraitContext) { node.__enrollState = { ...config }; ctx.emit?.('enrollment:created', { studentId: config.studentId, courseId: config.courseId }); },
-    onDetach(node: HSPlusNode, _c: EnrollmentConfig, ctx: TraitContext) { delete node.__enrollState; ctx.emit?.('enrollment:removed'); },
+    name: 'enrollment',
+    defaultConfig,
+    onAttach(node: HSPlusNode, config: EnrollmentConfig, ctx: TraitContext) {
+      node.__enrollState = { ...config };
+      ctx.emit?.('enrollment:created', { studentId: config.studentId, courseId: config.courseId });
+    },
+    onDetach(node: HSPlusNode, _c: EnrollmentConfig, ctx: TraitContext) {
+      delete node.__enrollState;
+      ctx.emit?.('enrollment:removed');
+    },
     onUpdate() {},
     onEvent(node: HSPlusNode, _c: EnrollmentConfig, ctx: TraitContext, event: TraitEvent) {
-      const s = node.__enrollState as EnrollmentConfig | undefined; if (!s) return;
-      if (event.type === 'enrollment:update_progress') { s.progressPercent = event.payload?.progress as number; ctx.emit?.('enrollment:progress', { progress: s.progressPercent }); }
-      if (event.type === 'enrollment:complete') { s.status = 'completed'; s.progressPercent = 100; ctx.emit?.('enrollment:completed'); }
-      if (event.type === 'enrollment:drop') { s.status = 'dropped'; ctx.emit?.('enrollment:dropped'); }
+      const s = node.__enrollState as EnrollmentConfig | undefined;
+      if (!s) return;
+      if (event.type === 'enrollment:update_progress') {
+        s.progressPercent = event.payload?.progress as number;
+        ctx.emit?.('enrollment:progress', { progress: s.progressPercent });
+      }
+      if (event.type === 'enrollment:complete') {
+        s.status = 'completed';
+        s.progressPercent = 100;
+        ctx.emit?.('enrollment:completed');
+      }
+      if (event.type === 'enrollment:drop') {
+        s.status = 'dropped';
+        ctx.emit?.('enrollment:dropped');
+      }
     },
   };
 }

package/src/traits/GradeTrait.ts

@@ -2,26 +2,56 @@
 import type { TraitHandler, HSPlusNode, TraitContext, TraitEvent } from './types';
 
 export type GradingScale = 'letter' | 'percentage' | 'pass_fail' | 'points' | 'gpa';
-export interface GradeConfig { score: number; maxScore: number; weight: number; gradingScale: GradingScale; rubric?: string; }
+export interface GradeConfig {
+  score: number;
+  maxScore: number;
+  weight: number;
+  gradingScale: GradingScale;
+  rubric?: string;
+}
 
-const defaultConfig: GradeConfig = { score: 0, maxScore: 100, weight: 1, gradingScale: 'percentage' };
+const defaultConfig: GradeConfig = {
+  score: 0,
+  maxScore: 100,
+  weight: 1,
+  gradingScale: 'percentage',
+};
 
 export function createGradeHandler(): TraitHandler<GradeConfig> {
   return {
-    name: 'grade', defaultConfig,
-    onAttach(node: HSPlusNode, config: GradeConfig, ctx: TraitContext) { node.__gradeState = { ...config, letterGrade: computeLetter(config.score, config.maxScore) }; ctx.emit?.('grade:assigned'); },
-    onDetach(node: HSPlusNode, _c: GradeConfig, ctx: TraitContext) { delete node.__gradeState; ctx.emit?.('grade:removed'); },
+    name: 'grade',
+    defaultConfig,
+    onAttach(node: HSPlusNode, config: GradeConfig, ctx: TraitContext) {
+      node.__gradeState = { ...config, letterGrade: computeLetter(config.score, config.maxScore) };
+      ctx.emit?.('grade:assigned');
+    },
+    onDetach(node: HSPlusNode, _c: GradeConfig, ctx: TraitContext) {
+      delete node.__gradeState;
+      ctx.emit?.('grade:removed');
+    },
     onUpdate() {},
     onEvent(node: HSPlusNode, _c: GradeConfig, ctx: TraitContext, event: TraitEvent) {
-      const s = node.__gradeState as Record<string, unknown> | undefined; if (!s) return;
-      if (event.type === 'grade:update') { s.score = event.payload?.score as number; s.letterGrade = computeLetter(s.score as number, s.maxScore as number); ctx.emit?.('grade:updated', { score: s.score }); }
+      const s = node.__gradeState as Record<string, unknown> | undefined;
+      if (!s) return;
+      if (event.type === 'grade:update') {
+        s.score = event.payload?.score as number;
+        s.letterGrade = computeLetter(s.score as number, s.maxScore as number);
+        ctx.emit?.('grade:updated', { score: s.score });
+      }
     },
   };
 }
 
 function computeLetter(score: number, max: number): string {
   const pct = max > 0 ? (score / max) * 100 : 0;
-  if (pct >= 93) return 'A'; if (pct >= 90) return 'A-'; if (pct >= 87) return 'B+'; if (pct >= 83) return 'B';
-  if (pct >= 80) return 'B-'; if (pct >= 77) return 'C+'; if (pct >= 73) return 'C'; if (pct >= 70) return 'C-';
-  if (pct >= 60) return 'D'; return 'F';
+  if (pct >= 93) return 'A';
+  if (pct >= 90) return 'A-';
+  if (pct >= 87) return 'B+';
+  if (pct >= 83) return 'B';
+  if (pct >= 80) return 'B-';
+  if (pct >= 77) return 'C+';
+  if (pct >= 73) return 'C';
+  if (pct >= 70) return 'C-';
+  if (pct >= 60) return 'D';
+  return 'F';
 }

package/src/traits/LessonTrait.ts

@@ -2,19 +2,46 @@
 import type { TraitHandler, HSPlusNode, TraitContext, TraitEvent } from './types';
 
 export type ContentType = 'video' | 'text' | 'interactive' | 'quiz' | 'assignment' | 'discussion';
-export interface LessonConfig { title: string; contentType: ContentType; durationMinutes: number; order: number; completionCriteria: 'view' | 'score' | 'submit'; passingScore?: number; }
+export interface LessonConfig {
+  title: string;
+  contentType: ContentType;
+  durationMinutes: number;
+  order: number;
+  completionCriteria: 'view' | 'score' | 'submit';
+  passingScore?: number;
+}
 
-const defaultConfig: LessonConfig = { title: '', contentType: 'text', durationMinutes: 15, order: 0, completionCriteria: 'view' };
+const defaultConfig: LessonConfig = {
+  title: '',
+  contentType: 'text',
+  durationMinutes: 15,
+  order: 0,
+  completionCriteria: 'view',
+};
 
 export function createLessonHandler(): TraitHandler<LessonConfig> {
   return {
-    name: 'lesson', defaultConfig,
-    onAttach(node: HSPlusNode, config: LessonConfig, ctx: TraitContext) { node.__lessonState = { isComplete: false, timeSpentMs: 0, score: null }; ctx.emit?.('lesson:attached', { title: config.title }); },
-    onDetach(node: HSPlusNode, _c: LessonConfig, ctx: TraitContext) { delete node.__lessonState; ctx.emit?.('lesson:detached'); },
-    onUpdate(node: HSPlusNode, _c: LessonConfig, _ctx: TraitContext, delta: number) { const s = node.__lessonState as Record<string, unknown> | undefined; if (s) s.timeSpentMs = ((s.timeSpentMs as number) || 0) + delta; },
+    name: 'lesson',
+    defaultConfig,
+    onAttach(node: HSPlusNode, config: LessonConfig, ctx: TraitContext) {
+      node.__lessonState = { isComplete: false, timeSpentMs: 0, score: null };
+      ctx.emit?.('lesson:attached', { title: config.title });
+    },
+    onDetach(node: HSPlusNode, _c: LessonConfig, ctx: TraitContext) {
+      delete node.__lessonState;
+      ctx.emit?.('lesson:detached');
+    },
+    onUpdate(node: HSPlusNode, _c: LessonConfig, _ctx: TraitContext, delta: number) {
+      const s = node.__lessonState as Record<string, unknown> | undefined;
+      if (s) s.timeSpentMs = ((s.timeSpentMs as number) || 0) + delta;
+    },
     onEvent(node: HSPlusNode, config: LessonConfig, ctx: TraitContext, event: TraitEvent) {
-      const s = node.__lessonState as Record<string, unknown> | undefined; if (!s) return;
-      if (event.type === 'lesson:complete') { s.isComplete = true; ctx.emit?.('lesson:completed', { title: config.title, timeSpent: s.timeSpentMs }); }
+      const s = node.__lessonState as Record<string, unknown> | undefined;
+      if (!s) return;
+      if (event.type === 'lesson:complete') {
+        s.isComplete = true;
+        ctx.emit?.('lesson:completed', { title: config.title, timeSpent: s.timeSpentMs });
+      }
     },
   };
 }

package/src/traits/QuizTrait.ts

@@ -1,28 +1,87 @@
 /** @quiz Trait — Assessment with multiple question types. @trait quiz */
 import type { TraitHandler, HSPlusNode, TraitContext, TraitEvent } from './types';
 
-export type QuestionType = 'multiple_choice' | 'true_false' | 'short_answer' | 'matching' | 'fill_blank';
-export interface QuizQuestion { id: string; type: QuestionType; text: string; options?: string[]; correctAnswer: string | string[]; points: number; }
-export interface QuizConfig { questions: QuizQuestion[]; timeLimitMinutes: number | null; attemptsAllowed: number; passingScore: number; shuffle: boolean; showCorrectAnswers: boolean; }
-export interface QuizState { currentQuestion: number; answers: Record<string, string>; score: number; attemptsUsed: number; isComplete: boolean; startedAt: number | null; }
+export type QuestionType =
+  | 'multiple_choice'
+  | 'true_false'
+  | 'short_answer'
+  | 'matching'
+  | 'fill_blank';
+export interface QuizQuestion {
+  id: string;
+  type: QuestionType;
+  text: string;
+  options?: string[];
+  correctAnswer: string | string[];
+  points: number;
+}
+export interface QuizConfig {
+  questions: QuizQuestion[];
+  timeLimitMinutes: number | null;
+  attemptsAllowed: number;
+  passingScore: number;
+  shuffle: boolean;
+  showCorrectAnswers: boolean;
+}
+export interface QuizState {
+  currentQuestion: number;
+  answers: Record<string, string>;
+  score: number;
+  attemptsUsed: number;
+  isComplete: boolean;
+  startedAt: number | null;
+}
 
-const defaultConfig: QuizConfig = { questions: [], timeLimitMinutes: null, attemptsAllowed: 3, passingScore: 70, shuffle: false, showCorrectAnswers: true };
+const defaultConfig: QuizConfig = {
+  questions: [],
+  timeLimitMinutes: null,
+  attemptsAllowed: 3,
+  passingScore: 70,
+  shuffle: false,
+  showCorrectAnswers: true,
+};
 
 export function createQuizHandler(): TraitHandler<QuizConfig> {
   return {
-    name: 'quiz', defaultConfig,
-    onAttach(node: HSPlusNode, config: QuizConfig, ctx: TraitContext) { node.__quizState = { currentQuestion: 0, answers: {}, score: 0, attemptsUsed: 0, isComplete: false, startedAt: null }; ctx.emit?.('quiz:ready', { questionCount: config.questions.length }); },
-    onDetach(node: HSPlusNode, _c: QuizConfig, ctx: TraitContext) { delete node.__quizState; ctx.emit?.('quiz:detached'); },
+    name: 'quiz',
+    defaultConfig,
+    onAttach(node: HSPlusNode, config: QuizConfig, ctx: TraitContext) {
+      node.__quizState = {
+        currentQuestion: 0,
+        answers: {},
+        score: 0,
+        attemptsUsed: 0,
+        isComplete: false,
+        startedAt: null,
+      };
+      ctx.emit?.('quiz:ready', { questionCount: config.questions.length });
+    },
+    onDetach(node: HSPlusNode, _c: QuizConfig, ctx: TraitContext) {
+      delete node.__quizState;
+      ctx.emit?.('quiz:detached');
+    },
     onUpdate() {},
     onEvent(node: HSPlusNode, config: QuizConfig, ctx: TraitContext, event: TraitEvent) {
-      const s = node.__quizState as QuizState | undefined; if (!s) return;
-      if (event.type === 'quiz:start') { s.startedAt = Date.now(); s.attemptsUsed++; ctx.emit?.('quiz:started', { attempt: s.attemptsUsed }); }
-      if (event.type === 'quiz:answer') { const qId = event.payload?.questionId as string; const ans = event.payload?.answer as string; s.answers[qId] = ans; }
+      const s = node.__quizState as QuizState | undefined;
+      if (!s) return;
+      if (event.type === 'quiz:start') {
+        s.startedAt = Date.now();
+        s.attemptsUsed++;
+        ctx.emit?.('quiz:started', { attempt: s.attemptsUsed });
+      }
+      if (event.type === 'quiz:answer') {
+        const qId = event.payload?.questionId as string;
+        const ans = event.payload?.answer as string;
+        s.answers[qId] = ans;
+      }
       if (event.type === 'quiz:submit') {
         let correct = 0;
-        for (const q of config.questions) { if (s.answers[q.id] === q.correctAnswer) correct += q.points; }
+        for (const q of config.questions) {
+          if (s.answers[q.id] === q.correctAnswer) correct += q.points;
+        }
         const total = config.questions.reduce((sum, q) => sum + q.points, 0);
-        s.score = total > 0 ? (correct / total) * 100 : 0; s.isComplete = true;
+        s.score = total > 0 ? (correct / total) * 100 : 0;
+        s.isComplete = true;
         ctx.emit?.('quiz:submitted', { score: s.score, passed: s.score >= config.passingScore });
       }
     },

package/src/traits/types.ts

@@ -1,4 +1,25 @@
-export interface HSPlusNode { id?: string; properties?: Record<string, unknown>; [key: string]: unknown; }
-export interface TraitContext { emit?: (event: string, payload?: unknown) => void; getState?: () => Record<string, unknown>; setState?: (updates: Record<string, unknown>) => void; [key: string]: unknown; }
-export interface TraitEvent { type: string; source?: string; payload?: Record<string, unknown>; [key: string]: unknown; }
-export interface TraitHandler<TConfig = unknown> { name: string; defaultConfig: TConfig; onAttach(node: HSPlusNode, config: TConfig, ctx: TraitContext): void; onDetach(node: HSPlusNode, config: TConfig, ctx: TraitContext): void; onUpdate(node: HSPlusNode, config: TConfig, ctx: TraitContext, delta: number): void; onEvent(node: HSPlusNode, config: TConfig, ctx: TraitContext, event: TraitEvent): void; }
+export interface HSPlusNode {
+  id?: string;
+  properties?: Record<string, unknown>;
+  [key: string]: unknown;
+}
+export interface TraitContext {
+  emit?: (event: string, payload?: unknown) => void;
+  getState?: () => Record<string, unknown>;
+  setState?: (updates: Record<string, unknown>) => void;
+  [key: string]: unknown;
+}
+export interface TraitEvent {
+  type: string;
+  source?: string;
+  payload?: Record<string, unknown>;
+  [key: string]: unknown;
+}
+export interface TraitHandler<TConfig = unknown> {
+  name: string;
+  defaultConfig: TConfig;
+  onAttach(node: HSPlusNode, config: TConfig, ctx: TraitContext): void;
+  onDetach(node: HSPlusNode, config: TConfig, ctx: TraitContext): void;
+  onUpdate(node: HSPlusNode, config: TConfig, ctx: TraitContext, delta: number): void;
+  onEvent(node: HSPlusNode, config: TConfig, ctx: TraitContext, event: TraitEvent): void;
+}

package/tsconfig.json

@@ -1 +1,10 @@
-{ "extends": "../../../tsconfig.json", "compilerOptions": { "outDir": "dist", "rootDir": "src", "declaration": true, "declarationMap": true }, "include": ["src"] }
+{
+  "extends": "../../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "dist",
+    "rootDir": "src",
+    "declaration": true,
+    "declarationMap": 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.