@tradejs/node 3.1.29-beta.261 → 3.1.29-beta.262

package/dist/{chunk-ZZQLTUTP.mjs → chunk-GHSLOJLE.mjs}

@@ -1,10 +1,19 @@
 // src/jevTraining.ts
-import { JEV_DIMENSIONS as JEV_DIMENSIONS2, decideJev, predictJevTree } from "@tradejs/core/jev";
-import { jevHash, validateJevResponse } from "@tradejs/infra/jev";
+import {
+  JEV_DIMENSIONS as JEV_DIMENSIONS2,
+  JEV_QUESTION_SET as JEV_QUESTION_SET2,
+  decideJev,
+  predictJevTree
+} from "@tradejs/core/jev";
+import {
+  jevScoreMaximum,
+  jevHash,
+  validateJevResponse
+} from "@tradejs/infra/jev";
 
 // src/jevInput.ts
 import { intervalToMs } from "@tradejs/core/data";
-import { JEV_DIMENSIONS } from "@tradejs/core/jev";
+import { JEV_DIMENSIONS, JEV_QUESTION_SET } from "@tradejs/core/jev";
 var object = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : {};
 var at = (value, ...path) => path.reduce((current, key) => object(current)[key], value);
 var finite = (value) => typeof value === "number" && Number.isFinite(value) ? value : null;
@@ -83,6 +92,35 @@ var buildJevInput = (signal) => {
   const stop = finite(signal.prices.stopLossPrice);
   const target = finite(signal.prices.takeProfitPrice);
   const atr = baseProblem ? null : finite(at(base, "raw", "volatility", "atr"));
+  if (!baseProblem) {
+    const open = finite(at(base, "candle", "open"));
+    const close = finite(at(base, "candle", "close"));
+    const high = finite(at(base, "candle", "high"));
+    const low = finite(at(base, "candle", "low"));
+    const sign = signal.direction === "LONG" ? 1 : -1;
+    const candleFact = {
+      knownAt: baseKnownAt,
+      scope: "target",
+      source: "baseContext.candle"
+    };
+    if (open != null && close != null && atr != null && atr > 0)
+      put("entry.directionalBodyAtr", sign * (close - open) / atr, {
+        ...candleFact,
+        unit: "ATR"
+      });
+    if (high != null && low != null && close != null && high > low && close >= low && close <= high) {
+      put(
+        "entry.directionalCloseLocation",
+        signal.direction === "LONG" ? (close - low) / (high - low) : (high - close) / (high - low),
+        { ...candleFact, unit: "ratio" }
+      );
+      if (atr != null && atr > 0)
+        put("entry.rangeAtr", (high - low) / atr, {
+          ...candleFact,
+          unit: "ATR"
+        });
+    }
+  }
   if (price == null || stop == null || target == null)
     throw new Error("Invalid Jev signal prices");
   put(
@@ -169,33 +207,30 @@ var buildJevInput = (signal) => {
   );
   const questions = JEV_DIMENSIONS.filter((dimension) => {
     switch (dimension) {
+      case "signalStrength":
+        return has("signal.validLevels");
       case "trend":
         return has("market.trendBias");
       case "swing":
-        return has("market.swingBias");
+        return has("setup.retracementRatio");
       case "participation":
-        return has("market.volumeRel20") || has("market.deltaPct");
+        return has("market.volumeRel20");
       case "setupParticipation":
         return setupKeys.some(
           (key) => /volume|delta|flow|liquidity|turnover/i.test(key)
         );
       case "extension":
-        return has("market.fastMaDistanceAtr") || has("setup.breakoutDistanceAtr") || has("signal.stopDistanceAtr");
+        return has("setup.breakoutDistanceAtr");
       case "confirmation":
-        return setupKeys.some(
-          (key) => /stage|confirm|retest|accept/i.test(key)
-        );
+        return has("entry.directionalBodyAtr") && has("entry.directionalCloseLocation");
       case "setupStrength":
-        return setupKeys.some(
-          (key) => key !== "setup.version" && !/volume|delta|flow|liquidity|turnover|stage|confirm|retest|accept|breakoutDistance/i.test(
-            key
-          )
-        );
+        return setupKeys.some((key) => /efficiencyRatio$/i.test(key));
       case "geometry":
         return geometryStatus !== "invalid" && Object.keys(features).some((key) => key.startsWith("geometry."));
     }
   });
   return {
+    questionSet: JEV_QUESTION_SET,
     schema: "tradejs-jev-input/v4",
     strategy: signal.strategy,
     symbol: signal.symbol,
@@ -209,68 +244,155 @@ var buildJevInput = (signal) => {
     geometryStatus
   };
 };
-var criteria = (subject) => [
-  `${subject} is clearly contradicted by the supplied facts.`,
-  `${subject} has a material conflict.`,
-  `${subject} is uncertain from the supplied facts.`,
-  `${subject} has adequate support.`,
-  `${subject} has strong support without a material conflict.`
-];
-var JEV_QUESTIONS = {
+var JEV_COMPONENT_QUESTIONS = {
   trend: {
     type: "score",
-    instructions: "Does market.trendBias support signal.direction? Judge only the target-asset trend, not swings or setup quality.",
-    criteria: criteria("Target-asset trend alignment")
+    instructions: "Rate agreement of market.trendBias and market.swingBias with signal.direction: bull supports LONG, bear supports SHORT; neutral/unknown is inconclusive. No profit prediction.",
+    criteria: [
+      "Both oppose.",
+      "One opposes; other inconclusive.",
+      "Biases conflict, or both inconclusive.",
+      "One supports; other inconclusive.",
+      "Both support."
+    ]
   },
   swing: {
     type: "score",
-    instructions: "Does market.swingBias support signal.direction? Judge only the target-asset swing structure, not the broader trend.",
-    criteria: criteria("Target-asset swing alignment")
+    instructions: "Rate shallow correction using only setup.retracementRatio (correction / preceding impulse). Missing is inconclusive, not favorable.",
+    criteria: [
+      "Exceeds impulse (>1).",
+      "Deep (>0.65 to 1).",
+      "Moderate (>0.4 to 0.65), or missing.",
+      "Contained (>0.2 to 0.4).",
+      "Shallow (0 to 0.2)."
+    ]
   },
   participation: {
     type: "score",
-    instructions: "Does the supplied market.volumeRel20 or market.deltaPct show target-asset participation supportive of this direction? Ignore strategy setup volume and do not infer missing flow.",
-    criteria: criteria("Current target-asset participation")
+    instructions: "Rate activity using only market.volumeRel20 (candle volume / trailing 20-candle mean). Not directional flow; ignore setup volume.",
+    criteria: [
+      "Very low (<0.5).",
+      "Below ordinary (0.5 to <0.8).",
+      "Ordinary (0.8 to <1.2), or missing.",
+      "Elevated (1.2 to <2).",
+      "Strong expansion (>=2)."
+    ]
   },
   setupParticipation: {
     type: "score",
-    instructions: "Do the strategy-defined setup volume, flow or liquidity facts support the named setup? Use only relevant setup.* facts, not market.volumeRel20; do not infer missing data.",
-    criteria: criteria("Participation within the setup")
+    instructions: "Rate consolidation volume contraction using a supplied setup consolidation / preceding impulse volume ratio, e.g. setup.flagToPoleVolumeRatio. Smaller means stronger contraction. Ignore current volume and directional flow; unrelated setup semantics are inconclusive.",
+    criteria: [
+      "Exceeds impulse (>1.2).",
+      "No contraction (>0.9 to 1.2).",
+      "Mild (>0.7 to 0.9), or inconclusive.",
+      "Clear (>0.4 to 0.7).",
+      "Strong (0 to 0.4)."
+    ]
   },
   extension: {
     type: "score",
-    instructions: "Do the supplied ATR-normalized entry-distance facts suggest the entry is not excessively extended? Use only distance facts; do not calculate new ratios or judge confirmation.",
-    criteria: criteria("Entry location without excessive extension")
+    instructions: "Rate absence of entry extension using only setup.breakoutDistanceAtr (distance past setup boundary in ATR). Stop/target distances are not extension.",
+    criteria: [
+      "Extreme (>2 ATR).",
+      "Large (>1 to 2 ATR).",
+      "Moderate (>0.5 to 1 ATR), or missing.",
+      "Small (>0.2 to 0.5 ATR).",
+      "Near boundary (0 to 0.2 ATR)."
+    ]
   },
   confirmation: {
     type: "score",
-    instructions: "Do the supplied setup stage and confirmation facts indicate a confirmed rather than premature entry? Do not judge distance or predict the outcome.",
-    criteria: criteria("Setup confirmation at entry")
+    instructions: "Rate closed entry candle conviction using entry.directionalBodyAtr (signed toward signal.direction) and entry.directionalCloseLocation (1=favorable extreme). Stage names alone prove neither conviction nor breakout retention.",
+    criteria: [
+      "Opposing body AND unfavorable-quarter close.",
+      "Opposing body OR unfavorable-half close.",
+      "Small body (<0.2 ATR), mixed or missing evidence.",
+      "Supporting body (>=0.2 ATR) AND favorable-half close.",
+      "Strong supporting body (>=0.5 ATR) AND favorable-quarter close."
+    ]
   },
   setupStrength: {
     type: "score",
-    instructions: "Do the strategy-defined setup strength and quality facts support this candidate? Exclude volume, confirmation, entry distance and geometry; do not assume missing facts.",
-    criteria: criteria("Non-geometric setup strength")
+    instructions: "Rate impulse persistence using only supplied setup efficiency (absolute net move / sum of absolute bar moves), e.g. setup.poleEfficiencyRatio. Exclude size, volume, correction and geometry.",
+    criteria: [
+      "Highly choppy (<0.2).",
+      "Weak (0.2 to <0.4).",
+      "Mixed (0.4 to <0.6), or missing.",
+      "Clear (0.6 to <0.8).",
+      "Highly persistent (0.8 to 1)."
+    ]
   },
   geometry: {
     type: "score",
-    instructions: "Do the supplied geometry.* facts support the named setup? Do not infer unseen figure points or certify mathematical validity.",
-    criteria: criteria("Setup geometry")
+    instructions: "Rate fitted consolidation boundaries jointly: geometry.upperR2 and lowerR2 (1=best fit), slopeDivergenceRatio (0=parallel). Use the weaker fit; exclude depth, width, volume and profit. Missing equivalent geometry is inconclusive.",
+    criteria: [
+      "Fit <0.5 OR divergence >0.5.",
+      "Fit <0.7 OR divergence >0.3.",
+      "Fit <0.85 OR divergence >0.15, or missing.",
+      "Both fits >=0.85 AND divergence <=0.15.",
+      "Both fits >=0.95 AND divergence <=0.05."
+    ]
   }
 };
-var questionsForJevInput = (input) => Object.fromEntries(input.questions.map((key) => [key, JEV_QUESTIONS[key]]));
+var JEV_SIGNAL_STRENGTH_QUESTION = {
+  type: "score",
+  instructions: "Rate overall support for entry now from signal-time facts: direction, market, setup, candle, placement, relevant geometry and stop/target plan. No other Jev answers, future prices or outcomes. Essential missing facts and conflicts weaken support; optional missing geometry alone does not disqualify. Invalid signal.validLevels cannot rate strong. Not win probability or execution permission. Criteria 1\u201310 map to API indices 0\u20139.",
+  criteria: [
+    "1: Invalid levels or decisive contrary evidence.",
+    "2: Severe directional/setup conflicts; poor support.",
+    "3: Substantial weaknesses outweigh support.",
+    "4: Some support; material weakness makes entry unattractive.",
+    "5: Balanced conflicts or essential evidence missing.",
+    "6: Modest coherent support; reasonable but limited evidence.",
+    "7: Convincing support from several facts; remaining weakness.",
+    "8: Strong coherent support, suitable placement/plan; no material conflict.",
+    "9: Very strong independent support; well-defined entry/stop/target plan.",
+    "10: Exceptional coherent support and plan; no visible material weakness, profit uncertain."
+  ]
+};
+var JEV_QUESTIONS = {
+  ...JEV_COMPONENT_QUESTIONS,
+  signalStrength: JEV_SIGNAL_STRENGTH_QUESTION
+};
+var questionsForJevInput = (input) => {
+  if (input.questionSet !== JEV_QUESTION_SET)
+    throw new Error(
+      "Unsupported Jev recording question set; rerun the backtest with --jev"
+    );
+  return Object.fromEntries(
+    input.questions.map((key) => {
+      const question = JEV_QUESTIONS[key];
+      if (!question) throw new Error("Unknown Jev question");
+      return [key, question];
+    })
+  );
+};
+var groupJevFields = (entries) => {
+  const groups = /* @__PURE__ */ new Map();
+  const flat = [];
+  for (const [key, value] of entries) {
+    const separator = key.indexOf(".");
+    if (separator < 0) {
+      flat.push([key, value]);
+      continue;
+    }
+    const namespace = key.slice(0, separator);
+    const group = groups.get(namespace) ?? [];
+    group.push([key.slice(separator + 1), value]);
+    groups.set(namespace, group);
+  }
+  return Object.fromEntries([
+    ...flat,
+    ...Array.from(groups, ([key, fields]) => [key, Object.fromEntries(fields)])
+  ]);
+};
 var stateForJevInput = (input) => ({
-  schema: input.schema,
   strategy: input.strategy,
-  direction: input.direction,
-  facts: input.features,
-  missing: input.missing,
+  facts: groupJevFields(Object.entries(input.features)),
+  missing: groupJevFields(Object.entries(input.missing)),
   geometryStatus: input.geometryStatus,
-  units: Object.fromEntries(
+  units: groupJevFields(
     Object.entries(input.provenance).filter(([, detail]) => detail.unit != null).map(([key, detail]) => [key, detail.unit])
-  ),
-  sources: Object.fromEntries(
-    Object.entries(input.provenance).filter(([, detail]) => detail.source != null).map(([key, detail]) => [key, detail.source])
   )
 });
 
@@ -288,7 +410,7 @@ var validateJevStudy = (rows) => {
     );
   for (const row of rows) {
     const record = row?.record;
-    if (row?.schema !== "tradejs-jev-study/v4" || !row.signalId || record?.schema !== "tradejs-jev-record/v4" || record.input?.schema !== "tradejs-jev-input/v4" || !Number.isFinite(record.input.timestamp) || record.inputHash !== jevHash(record.input) || record.questionsHash !== jevHash(questionsForJevInput(record.input)) || record.id !== jevHash({
+    if (row?.schema !== "tradejs-jev-study/v4" || !row.signalId || record?.schema !== "tradejs-jev-record/v4" || record.input?.schema !== "tradejs-jev-input/v4" || record.input.questionSet !== JEV_QUESTION_SET2 || !Number.isFinite(record.input.timestamp) || record.inputHash !== jevHash(record.input) || record.questionsHash !== jevHash(questionsForJevInput(record.input)) || record.id !== jevHash({
       inputHash: record.inputHash,
       questionsHash: record.questionsHash,
       provider: record.provider
@@ -296,7 +418,7 @@ var validateJevStudy = (rows) => {
       throw new Error("Invalid Jev study provenance");
     validateJevResponse(record.response, record.input.questions);
     for (const dimension of JEV_DIMENSIONS2) {
-      const expected = record.input.questions.includes(dimension) ? record.response.answers[dimension].score / 4 : null;
+      const expected = record.input.questions.includes(dimension) ? record.response.answers[dimension].score / jevScoreMaximum(dimension) : null;
       if (record.scores[dimension] !== expected)
         throw new Error("Jev study scores do not match the teacher response");
     }
@@ -379,10 +501,12 @@ var trainTree = (rows, dimension, depth, minLeaf) => {
 };
 var validateJevGateModel = (value) => {
   const model = value;
-  if (model?.schema !== "tradejs-jev-gate/v2" || model.inputSchema !== "tradejs-jev-input/v4" || typeof model.strategy !== "string" || !model.strategy || !model.teacherModel || !model.trees || model.questionsHash !== jevHash(JEV_QUESTIONS) || !model.training || !/^[a-f0-9]{64}$/.test(model.training.datasetHash))
+  if (model?.schema !== "tradejs-jev-gate/v2" || model.inputSchema !== "tradejs-jev-input/v4" || typeof model.strategy !== "string" || !model.strategy || !model.teacherModel || !model.trees || model.questionSet !== JEV_QUESTION_SET2 || JEV_DIMENSIONS2.some((dimension) => !(dimension in model.trees)) || Object.keys(model.trees).some(
+    (dimension) => !JEV_DIMENSIONS2.includes(dimension)
+  ) || model.questionsHash !== jevHash(JEV_QUESTIONS) || !model.training || !/^[a-f0-9]{64}$/.test(model.training.datasetHash))
     throw new Error("Invalid local Jev gate");
   const { trainEnd, validationEnd, testEnd } = model.training;
-  if (![trainEnd, validationEnd, testEnd].every(Number.isFinite) || !(trainEnd < validationEnd && validationEnd < testEnd))
+  if (![trainEnd, validationEnd, testEnd].every(Number.isFinite) || model.training.split !== "outer-60-40" || !(trainEnd === validationEnd && trainEnd < testEnd))
     throw new Error("Invalid local Jev gate partitions");
   const check = (tree, depth) => {
     if (!tree || depth > 8) throw new Error("Invalid local Jev tree");
@@ -518,13 +642,10 @@ var trainJevGate = (input, options = {}) => {
   ];
   if (rows.length < 30 || timestamps.length < 10)
     throw new Error("Need at least 30 distinct samples across 10 signal times");
-  const trainEnd = timestamps[Math.floor(timestamps.length * 0.6) - 1];
-  const validationEnd = timestamps[Math.floor(timestamps.length * 0.8) - 1];
+  const trainEnd = timestamps[timestamps.length - Math.max(1, Math.floor(timestamps.length * 0.4)) - 1];
+  const validationEnd = trainEnd;
   const train = rows.filter((row) => row.record.input.timestamp <= trainEnd);
-  const validation = rows.filter(
-    (row) => row.record.input.timestamp > trainEnd && row.record.input.timestamp <= validationEnd
-  );
-  const test = rows.filter((row) => row.record.input.timestamp > validationEnd);
+  const test = rows.filter((row) => row.record.input.timestamp > trainEnd);
   const fit = (samples) => Object.fromEntries(
     JEV_DIMENSIONS2.map((key) => {
       const eligible = samples.filter(
@@ -541,10 +662,12 @@ var trainJevGate = (input, options = {}) => {
     schema: "tradejs-jev-gate/v2",
     inputSchema: "tradejs-jev-input/v4",
     strategy: first.input.strategy,
+    questionSet: JEV_QUESTION_SET2,
     questionsHash: jevHash(JEV_QUESTIONS),
     teacherModel: first.response.model,
     trees: fit(train),
     training: {
+      split: "outer-60-40",
       datasetHash: jevHash(
         rows.map((row) => ({
           id: row.record.id,
@@ -559,18 +682,20 @@ var trainJevGate = (input, options = {}) => {
     }
   };
   validateJevGateModel(model);
-  const walkForward = [0.4, 0.6, 0.8].map((fraction) => {
-    const trainThrough = timestamps[Math.max(0, Math.floor(timestamps.length * (fraction - 0.1)) - 1)];
-    const validationThrough = timestamps[Math.floor(timestamps.length * fraction) - 1];
-    const testThrough = timestamps[Math.min(
-      timestamps.length - 1,
-      Math.round(timestamps.length * (fraction + 0.2)) - 1
+  const developmentTimes = timestamps.filter(
+    (timestamp) => timestamp <= trainEnd
+  );
+  const walkForward = [0.25, 0.5, 0.75].map((fraction) => {
+    const trainThrough = developmentTimes[Math.max(0, Math.floor(developmentTimes.length * fraction) - 1)];
+    const testThrough = developmentTimes[Math.min(
+      developmentTimes.length - 1,
+      Math.floor(developmentTimes.length * (fraction + 0.25)) - 1
     )];
-    const fitting = rows.filter(
+    const fitting = train.filter(
       (row) => row.record.input.timestamp <= trainThrough
     );
-    const evaluation = rows.filter(
-      (row) => row.record.input.timestamp > validationThrough && row.record.input.timestamp <= testThrough
+    const evaluation = train.filter(
+      (row) => row.record.input.timestamp > trainThrough && row.record.input.timestamp <= testThrough
     );
     const fold = {
       ...model,
@@ -578,13 +703,13 @@ var trainJevGate = (input, options = {}) => {
       training: {
         ...model.training,
         trainEnd: trainThrough,
-        validationEnd: validationThrough,
+        validationEnd: trainThrough,
         testEnd: testThrough
       }
     };
     return {
       trainThrough,
-      validationThrough,
+      validationThrough: trainThrough,
       testThrough,
       trainRows: fitting.length,
       test: compareJevGate(fold, evaluation)
@@ -594,7 +719,8 @@ var trainJevGate = (input, options = {}) => {
     model,
     report: {
       train: compareJevGate(model, train),
-      validation: compareJevGate(model, validation),
+      partitionScheme: "outer-60-40",
+      stabilityRole: "independently fitted folds inside development only",
       test: compareJevGate(model, test),
       walkForward,
       promotion: "research-only; validate a sequential backtest and prospective signals before runtime admission"

package/dist/{chunk-WGL7XJ3W.mjs → chunk-SKY2HNZU.mjs}

@@ -12,7 +12,7 @@ import {
 } from "./chunk-LZDXRXIU.mjs";
 import {
   assessSignalWithJev
-} from "./chunk-3BBXGZ7M.mjs";
+} from "./chunk-YR55Q355.mjs";
 
 // src/binanceBreadthUniverses.ts
 import { createHash } from "crypto";

package/dist/{chunk-3BBXGZ7M.mjs → chunk-YR55Q355.mjs}

@@ -3,18 +3,21 @@ import {
   buildJevInput,
   questionsForJevInput,
   stateForJevInput
-} from "./chunk-ZZQLTUTP.mjs";
+} from "./chunk-GHSLOJLE.mjs";
 
 // src/jev.ts
 import fs from "fs/promises";
 import path from "path";
 import {
   JEV_DIMENSIONS,
+  JEV_QUESTION_SET,
   JEV_PROVIDERS,
   parseJevConfig,
-  predictJevTree
+  predictJevTree,
+  jevAssessmentFeatures
 } from "@tradejs/core/jev";
 import {
+  jevScoreMaximum,
   jevHash,
   jevFileHash,
   readJevArtifact,
@@ -48,6 +51,7 @@ var evaluateJevInput = async ({
   const questions = questionsForJevInput(input);
   const questionsHash = jevHash(questions);
   const base = {
+    questionSet: JEV_QUESTION_SET,
     schema: "tradejs-signal-assessment/v5",
     source: config.source,
     mode: config.mode,
@@ -73,7 +77,7 @@ var evaluateJevInput = async ({
     );
     if (jevFileHash(contents) !== config.modelSha256)
       throw new Error("Local Jev gate checksum mismatch");
-    const { validateJevGateModel: validateJevGateModel2 } = await import("./jevTraining-JYXUVAZG.mjs");
+    const { validateJevGateModel: validateJevGateModel2 } = await import("./jevTraining-J4Y4VCM4.mjs");
     const model = validateJevGateModel2(JSON.parse(contents));
     if (model.strategy !== input.strategy || model.questionsHash !== jevHash(JEV_QUESTIONS))
       throw new Error("Local Jev gate strategy or question version mismatch");
@@ -104,7 +108,7 @@ var evaluateJevInput = async ({
         throw new Error("Jev recording identity mismatch");
       validateJevResponse(existing.response, input.questions);
       for (const key of JEV_DIMENSIONS) {
-        const expected = input.questions.includes(key) ? existing.response.answers[key].score / 4 : null;
+        const expected = input.questions.includes(key) ? existing.response.answers[key].score / jevScoreMaximum(key) : null;
         if (existing.scores[key] !== expected)
           throw new Error("Jev recording scores do not match the response");
       }
@@ -152,7 +156,7 @@ var evaluateJevInput = async ({
     const scores = Object.fromEntries(
       JEV_DIMENSIONS.map((key) => [
         key,
-        input.questions.includes(key) ? response.answers[key].score / 4 : null
+        input.questions.includes(key) ? response.answers[key].score / jevScoreMaximum(key) : null
       ])
     );
     const value = {
@@ -219,6 +223,7 @@ var assessSignalWithJev = async ({
   } catch (error) {
     if (strict) throw error;
     assessment = {
+      questionSet: JEV_QUESTION_SET,
       schema: "tradejs-signal-assessment/v5",
       source: config.source,
       mode: config.mode,
@@ -235,12 +240,7 @@ var assessSignalWithJev = async ({
   signal.assessment = assessment;
   signal.additionalIndicators = {
     ...signal.additionalIndicators,
-    jev: {
-      schema: "tradejs-jev-features/v2",
-      status: assessment.status,
-      scores: assessment.scores,
-      confidence: assessment.confidence
-    }
+    jev: jevAssessmentFeatures(assessment)
   };
   const identity = {
     signalId: signal.signalId,