eventToShortText: checkbox time, test-result labels, convertible display

- Checkbox: show date+time (skip time if midnight)
- test-result/scale: Positive/Negative/Indeterminate + percentage (localizable)
- medication/basic: show name + dose + route
- Convertible: source label + localized method name
- Convertible autoConvert: "result (target <- source %)" format
- _raw virtual method auto-generated from dimension stops
- resolveObservationLabel: resolves raw values to localized labels
- HDSSettings._testInject for test-only settings injection
- 296 tests passing

Author: perki

tests/converterEngine.test.js

@@ -274,4 +274,41 @@ describe('[MCVX] HDSModelConverters with loadPack', function () {
       converters.loadPack({ engine: 'neural-network', itemKey: 'test', methods: [] });
     }, /Unknown converter engine/);
   });
+
+  it('[MCVX10] creighton→mira round-trip conversions', async () => {
+    const pairs = [
+      ['0', 'No discharge'], ['6', 'Sticky'], ['8P', 'Creamy'], ['10KL', 'Raw Egg White'],
+    ];
+    const engine = converters.getEngine('cervical-fluid');
+    for (const [cr, mira] of pairs) {
+      const event = await converters.convertMethodToEvent('cervical-fluid', 'creighton', cr);
+      const result = engine.fromVector('mira', event.content.vectors);
+      assert.strictEqual(result.data, mira, `Creighton ${cr} → expected ${mira}, got ${result.data}`);
+    }
+  });
+
+  it('[MCVX11] _raw virtual method is auto-generated', async () => {
+    const moodEngine = converters.getEngine('mood');
+    const cfEngine = converters.getEngine('cervical-fluid');
+    assert.ok(moodEngine.getMethodDef('_raw'), '_raw should exist for mood');
+    assert.ok(cfEngine.getMethodDef('_raw'), '_raw should exist for cervical-fluid');
+    assert.strictEqual(moodEngine.getMethodDef('_raw').name.en, 'Raw dimensions');
+  });
+
+  it('[MCVX12] _raw fromVector returns object with stop labels', async () => {
+    const engine = converters.getEngine('mood');
+    const result = engine.fromVector('_raw', { valence: 0.5, arousal: 0.5, dominance: 0.5, socialOrientation: 0.5, temporalFocus: 0.5 });
+    // Exact stops → distance 0
+    assert.strictEqual(result.matchDistance, 0);
+    assert.strictEqual(typeof result.data, 'object');
+    assert.strictEqual(result.data.valence, 0.5);
+  });
+
+  it('[MCVX13] _raw fromVector with non-exact values has non-zero distance', async () => {
+    const engine = converters.getEngine('mood');
+    const result = engine.fromVector('_raw', { valence: 0.8, arousal: 0.2, dominance: 0.7, socialOrientation: 0.5, temporalFocus: 0.3 });
+    assert.ok(result.matchDistance > 0, `Expected non-zero distance, got ${result.matchDistance}`);
+    const confidence = Math.round((1 - result.matchDistance) * 100);
+    assert.ok(confidence > 80 && confidence < 100, `Expected partial confidence, got ${confidence}%`);
+  });
 });

tests/eventToShortText.test.js

@@ -1,13 +1,16 @@
 import { assert } from './test-utils/deps-node.js';
-import { HDSModel, eventToShortText } from '../ts/index.ts';
+import { eventToShortText } from '../ts/index.ts';
+import { getModel } from '../ts/HDSModel/HDSModelInitAndSingleton.ts';
+import HDSSettings from '../ts/settings/HDSSettings.ts';
 
 const modelURL = 'https://model.datasafe.dev/pack.json';
 
 describe('[ESTX] eventToShortText', () => {
   let model;
   before(async () => {
-    model = new HDSModel(modelURL);
-    await model.load();
+    // Use the singleton so eventToShortText picks up the same model instance
+    model = getModel();
+    await model.load(modelURL);
   });
 
   it('[EST1] returns null for null event', () => {
@@ -48,19 +51,39 @@ describe('[ESTX] eventToShortText', () => {
     assert.equal(result, 'Moderate');
   });
 
-  it('[EST6b] convertible with source block shows source data', () => {
+  it('[EST6b] convertible with source block shows source data (no autoConvert)', async () => {
+    await model.converters.ensureEngine('cervical-fluid');
     const itemDef = model.itemsDefs.forKey('body-vulva-mucus-inspect');
     assert.ok(itemDef, 'itemDef should exist');
     const event = {
       content: {
-        data: { threadiness: 0.4, stretchability: 0.3 },
-        source: { key: 'mira', sourceData: 'Creamy' }
+        vectors: { threadiness: 0.4, stretchability: 0.3 },
+        source: { key: 'mira', sourceData: 'Creamy', engineVersion: 'v0', modelVersion: 'v0' }
       },
       streamIds: [itemDef.data.streamId],
       type: itemDef.eventTypes[0]
     };
     const result = eventToShortText(event);
-    assert.equal(result, 'Creamy (mira)');
+    // Without autoConvert setting, shows sourceData + localized method name
+    assert.equal(result, 'Creamy (Mira)');
+  });
+
+  it('[EST6c] convertible without source shows dimension stop labels', async () => {
+    // Load converter engine to get dimension labels
+    await model.converters.ensureEngine('mood');
+    const event = {
+      content: {
+        vectors: { valence: 0.9, arousal: 0.3, dominance: 0.6, socialOrientation: 0, temporalFocus: 0 }
+      },
+      streamIds: ['wellbeing-mood'],
+      type: 'mood/5d-vectors'
+    };
+    const result = eventToShortText(event);
+    // Top 3 dimensions by weight (valence=0.30, arousal=0.25, dominance=0.20)
+    // nearest stop labels: valence 0.9→"Very pleasant", arousal 0.3→"Calm", dominance 0.6→"Neutral"
+    // _raw method computes confidence from weighted distance to nearest stops
+    assert.ok(result.startsWith('Very pleasant, Calm, Neutral'), `Expected start, got: ${result}`);
+    assert.ok(result.includes('%'), `Expected confidence %, got: ${result}`);
   });
 
   it('[EST7] date item returns ISO date string', () => {
@@ -148,11 +171,21 @@ describe('[ESTX] eventToShortText', () => {
     assert.ok(result.includes('200'), `Expected 200 in: ${result}`);
   });
 
-  it('[EST16a] checkbox with null content returns date', () => {
+  it('[EST16a] checkbox with null content returns date+time', () => {
     const event = { content: null, streamIds: ['fertility-cycles-start'], type: 'activity/plain', time: 1720000000 };
     const result = eventToShortText(event);
+    assert.ok(result, 'Should return a date+time string');
+    assert.ok(/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}$/.test(result), `Expected date+time, got: ${result}`);
+  });
+
+  it('[EST16a2] checkbox at midnight local returns date only', () => {
+    // Midnight local time
+    const d = new Date(2024, 6, 3, 0, 0, 0); // July 3, 2024 00:00 local
+    const midnight = d.getTime() / 1000;
+    const event = { content: null, streamIds: ['fertility-cycles-start'], type: 'activity/plain', time: midnight };
+    const result = eventToShortText(event);
     assert.ok(result, 'Should return a date string');
-    assert.ok(/^\d{4}-\d{2}-\d{2}$/.test(result), `Expected ISO date, got: ${result}`);
+    assert.ok(/^\d{4}-\d{2}-\d{2}$/.test(result), `Expected date only, got: ${result}`);
   });
 
   it('[EST16b] medication with plain string label (not i18n object)', () => {
@@ -232,4 +265,236 @@ describe('[ESTX] eventToShortText', () => {
       assert.ok(result.includes('1/3'), `Expected ratio prefix in: ${result}`);
     }
   });
+
+  it('[EST17a] test-result/scale positive (1)', () => {
+    const event = { content: 1, streamIds: ['fertility-test-opk'], type: 'test-result/scale' };
+    assert.equal(eventToShortText(event), 'Positive');
+  });
+
+  it('[EST17b] test-result/scale negative (-1)', () => {
+    const event = { content: -1, streamIds: ['fertility-test-opk'], type: 'test-result/scale' };
+    assert.equal(eventToShortText(event), 'Negative');
+  });
+
+  it('[EST17c] test-result/scale indeterminate (0)', () => {
+    const event = { content: 0, streamIds: ['fertility-test-pregnancy'], type: 'test-result/scale' };
+    assert.equal(eventToShortText(event), 'Indeterminate');
+  });
+
+  it('[EST17d] test-result/scale partial positive (0.56)', () => {
+    const event = { content: 0.56, streamIds: ['fertility-test-opk'], type: 'test-result/scale' };
+    assert.equal(eventToShortText(event), 'Positive 56%');
+  });
+
+  it('[EST17e] test-result/scale partial negative (-0.3)', () => {
+    const event = { content: -0.3, streamIds: ['fertility-test-opk'], type: 'test-result/scale' };
+    assert.equal(eventToShortText(event), 'Negative 30%');
+  });
+
+  it('[EST18] medication/basic composite shows name + dose', () => {
+    const event = {
+      content: { name: 'Ibuprofen', doseValue: 400, doseUnit: 'mg', route: 'oral' },
+      streamIds: ['medication-intake'],
+      type: 'medication/basic'
+    };
+    const result = eventToShortText(event);
+    assert.equal(result, 'Ibuprofen — 400 mg, oral');
+  });
+
+  // ─── Convertible: mood ───────────────────────────────────────────
+
+  describe('[EST20] convertible mood', () => {
+    before(async () => {
+      await model.converters.ensureEngine('mood');
+    });
+
+    it('[EST20a] mood from mira source — no autoConvert', async () => {
+      const event = await model.converters.convertMethodToEvent('mood', 'mira', 'Happy');
+      event.time = Date.now() / 1000;
+      assert.equal(eventToShortText(event), 'Happy (Mira)');
+    });
+
+    it('[EST20b] mood from mira source — various labels', async () => {
+      const expected = {
+        Sad: 'Sad (Mira)',
+        Excited: 'Excited (Mira)',
+        Normal: 'Normal (Mira)',
+        'Anxiety or panic attacks': 'Anxiety or panic attacks (Mira)',
+      };
+      for (const [label, exp] of Object.entries(expected)) {
+        const event = await model.converters.convertMethodToEvent('mood', 'mira', label);
+        event.time = Date.now() / 1000;
+        assert.equal(eventToShortText(event), exp, `Failed for: ${label}`);
+      }
+    });
+
+    it('[EST20c] mood raw vector — uses stop labels sorted by weight + confidence', () => {
+      const event = {
+        content: { vectors: { valence: 1.0, arousal: 0.9, dominance: 0.8, socialOrientation: 0.7, temporalFocus: 0.6 } },
+        streamIds: ['wellbeing-mood'],
+        type: 'mood/5d-vectors'
+      };
+      const result = eventToShortText(event);
+      // valence(w=0.30)→Very pleasant, arousal(w=0.25)→Very energized, dominance(w=0.20)→In control
+      assert.ok(result.startsWith('Very pleasant, Very energized, In control'), `Expected start, got: ${result}`);
+    });
+
+    it('[EST20d] mood raw vector — neutral baseline is 100% (exact stops)', () => {
+      const event = {
+        content: { vectors: { valence: 0.5, arousal: 0.5, dominance: 0.5, socialOrientation: 0.5, temporalFocus: 0.5 } },
+        streamIds: ['wellbeing-mood'],
+        type: 'mood/5d-vectors'
+      };
+      // All values match exact stops → 100% → no % shown. All 5 dimensions resolved.
+      assert.equal(eventToShortText(event), 'Neutral, Moderate, Neutral, Balanced, Present');
+    });
+
+    it('[EST20e] mood raw vector — depressed shows confidence', () => {
+      const event = {
+        content: { vectors: { valence: 0.1, arousal: 0.1, dominance: 0.1, socialOrientation: 0.2, temporalFocus: 0.1 } },
+        streamIds: ['wellbeing-mood'],
+        type: 'mood/5d-vectors'
+      };
+      const result = eventToShortText(event);
+      assert.ok(result.startsWith('Very unpleasant, Very calm, Powerless'), `Expected start, got: ${result}`);
+      assert.ok(result.includes('%'), `Expected confidence %, got: ${result}`);
+    });
+  });
+
+  // ─── Convertible: cervical fluid ─────────────────────────────────
+
+  describe('[EST21] convertible cervical fluid', () => {
+    before(async () => {
+      await model.converters.ensureEngine('cervical-fluid');
+    });
+
+    it('[EST21a] mucus from mira source — no autoConvert', async () => {
+      const event = await model.converters.convertMethodToEvent('cervical-fluid', 'mira', 'Creamy');
+      event.time = Date.now() / 1000;
+      assert.equal(eventToShortText(event), 'Creamy (Mira)');
+    });
+
+    it('[EST21b] mucus from mira source — various labels', async () => {
+      const labels = ['No discharge', 'Dry', 'Sticky', 'Watery', 'Raw Egg White'];
+      for (const label of labels) {
+        const event = await model.converters.convertMethodToEvent('cervical-fluid', 'mira', label);
+        event.time = Date.now() / 1000;
+        assert.equal(eventToShortText(event), `${label} (Mira)`, `Failed for: ${label}`);
+      }
+    });
+
+    it('[EST21c] mucus from appleHealth source — label localized', async () => {
+      const event = await model.converters.convertMethodToEvent('cervical-fluid', 'appleHealth', 'eggWhite');
+      event.time = Date.now() / 1000;
+      // "eggWhite" value resolves to "Egg White" label
+      assert.equal(eventToShortText(event), 'Egg White (Apple Health)');
+    });
+
+    it('[EST21d] mucus from creighton source — label localized', async () => {
+      const event = await model.converters.convertMethodToEvent('cervical-fluid', 'creighton', '10KL');
+      event.time = Date.now() / 1000;
+      const result = eventToShortText(event);
+      // Creighton 10KL has a descriptive label in its method definition
+      assert.ok(result.includes('Creighton Model'), `Expected method name, got: ${result}`);
+      assert.ok(result.includes('10KL'), `Expected observation value, got: ${result}`);
+    });
+  });
+
+  // ─── Convertible: autoConvert via eventToShortText ──
+
+  describe('[EST22] convertible autoConvert in eventToShortText', () => {
+    before(async () => {
+      await model.converters.ensureEngine('mood');
+      await model.converters.ensureEngine('cervical-fluid');
+    });
+
+    afterEach(() => {
+      HDSSettings.unhook();
+    });
+
+    it('[EST22a] no autoConvert — shows sourceData + method name', async () => {
+      const event = await model.converters.convertMethodToEvent('mood', 'mira', 'Excited');
+      event.time = Date.now() / 1000;
+      assert.equal(eventToShortText(event), 'Excited (Mira)');
+    });
+
+    it('[EST22b] autoConvert same method — shows sourceData + method name (no conversion)', async () => {
+      HDSSettings._testInject('autoConvert-wellbeing-mood', 'mira');
+      const event = await model.converters.convertMethodToEvent('mood', 'mira', 'Happy');
+      event.time = Date.now() / 1000;
+      assert.equal(eventToShortText(event), 'Happy (Mira)');
+    });
+
+    it('[EST22c] autoConvert mood mira→hds — shows stop labels with target <- source', async () => {
+      HDSSettings._testInject('autoConvert-wellbeing-mood', 'hds');
+      const event = await model.converters.convertMethodToEvent('mood', 'mira', 'Happy');
+      event.time = Date.now() / 1000;
+      const result = eventToShortText(event);
+      assert.ok(result.includes('Pleasant'), `Expected stop label, got: ${result}`);
+      assert.ok(result.includes('HDS Native <- Mira'), `Expected target <- source, got: ${result}`);
+      assert.ok(result.includes('%'), `Expected confidence %, got: ${result}`);
+    });
+
+    it('[EST22d] autoConvert cervical fluid mira→appleHealth — localized label + perfect match', async () => {
+      HDSSettings._testInject('autoConvert-body-vulva-mucus-inspect', 'appleHealth');
+      const event = await model.converters.convertMethodToEvent('cervical-fluid', 'mira', 'Creamy');
+      event.time = Date.now() / 1000;
+      // "creamy" value should resolve to "Creamy" label from appleHealth method
+      assert.equal(eventToShortText(event), 'Creamy (Apple Health <- Mira)');
+    });
+
+    it('[EST22e] autoConvert cervical fluid mira→billings — localized label + partial match', async () => {
+      HDSSettings._testInject('autoConvert-body-vulva-mucus-inspect', 'billings');
+      const event = await model.converters.convertMethodToEvent('cervical-fluid', 'mira', 'Watery');
+      event.time = Date.now() / 1000;
+      const result = eventToShortText(event);
+      // billings "wetSlippery" value should have a localized label
+      assert.ok(!result.includes('wetSlippery'), `Should use label not value, got: ${result}`);
+      assert.ok(result.includes('Billings (BOM) <- Mira'), `Expected target <- source, got: ${result}`);
+      assert.ok(result.includes('%'), `Expected confidence %, got: ${result}`);
+    });
+
+    it('[EST22f] autoConvert raw vector (no source) — shows result + target name', async () => {
+      HDSSettings._testInject('autoConvert-wellbeing-mood', 'mira');
+      const event = {
+        content: { vectors: { valence: 0.8, arousal: 0.2, dominance: 0.7, socialOrientation: 0.5, temporalFocus: 0.3 } },
+        streamIds: ['wellbeing-mood'],
+        type: 'mood/5d-vectors',
+        time: Date.now() / 1000
+      };
+      const result = eventToShortText(event);
+      assert.ok(result.includes('Mira'), `Expected target method name, got: ${result}`);
+      assert.ok(result.includes('%'), `Expected confidence %, got: ${result}`);
+    });
+
+    it('[EST22g] all cervical fluid mira→appleHealth labels are capitalized', async () => {
+      HDSSettings._testInject('autoConvert-body-vulva-mucus-inspect', 'appleHealth');
+      const pairs = [
+        ['No discharge', 'Dry'], ['Dry', 'Dry'], ['Sticky', 'Sticky'],
+        ['Creamy', 'Creamy'], ['Watery', 'Watery'], ['Raw Egg White', 'Egg White'],
+      ];
+      for (const [mira, expectedLabel] of pairs) {
+        const event = await model.converters.convertMethodToEvent('cervical-fluid', 'mira', mira);
+        event.time = Date.now() / 1000;
+        const result = eventToShortText(event);
+        assert.ok(result.startsWith(expectedLabel), `${mira} → expected "${expectedLabel}...", got: "${result}"`);
+      }
+    });
+
+    it('[EST22h] cervical fluid source labels are localized from method definition', async () => {
+      // appleHealth source "eggWhite" should show as "Egg White" (label), not "eggWhite" (value)
+      const event = await model.converters.convertMethodToEvent('cervical-fluid', 'appleHealth', 'eggWhite');
+      event.time = Date.now() / 1000;
+      const result = eventToShortText(event);
+      assert.equal(result, 'Egg White (Apple Health)');
+    });
+
+    it('[EST22i] cervical fluid creighton source shows localized label', async () => {
+      const event = await model.converters.convertMethodToEvent('cervical-fluid', 'creighton', '10KL');
+      event.time = Date.now() / 1000;
+      const result = eventToShortText(event);
+      // creighton "10KL" has a label in its method definition
+      assert.ok(result.includes('Creighton Model'), `Expected method name, got: ${result}`);
+    });
+  });
 });