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

package/dist/runtimeStrategies.js

@@ -36,7 +36,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/jevInput.ts
-var import_data, import_jev, object, at, finite, fact, buildJevInput, criteria, JEV_QUESTIONS, questionsForJevInput, stateForJevInput;
+var import_data, import_jev, object, at, finite, fact, buildJevInput, JEV_COMPONENT_QUESTIONS, JEV_SIGNAL_STRENGTH_QUESTION, JEV_QUESTIONS, questionsForJevInput, groupJevFields, stateForJevInput;
 var init_jevInput = __esm({
   "src/jevInput.ts"() {
     "use strict";
@@ -120,6 +120,35 @@ var init_jevInput = __esm({
       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(
@@ -206,33 +235,30 @@ var init_jevInput = __esm({
       );
       const questions = import_jev.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: import_jev.JEV_QUESTION_SET,
         schema: "tradejs-jev-input/v4",
         strategy: signal.strategy,
         symbol: signal.symbol,
@@ -246,68 +272,155 @@ var init_jevInput = __esm({
         geometryStatus
       };
     };
-    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.`
-    ];
-    JEV_QUESTIONS = {
+    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."
+        ]
       }
     };
-    questionsForJevInput = (input) => Object.fromEntries(input.questions.map((key) => [key, JEV_QUESTIONS[key]]));
+    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."
+      ]
+    };
+    JEV_QUESTIONS = {
+      ...JEV_COMPONENT_QUESTIONS,
+      signalStrength: JEV_SIGNAL_STRENGTH_QUESTION
+    };
+    questionsForJevInput = (input) => {
+      if (input.questionSet !== import_jev.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];
+        })
+      );
+    };
+    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)])
+      ]);
+    };
     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])
       )
     });
   }
@@ -341,7 +454,7 @@ var init_jevTraining = __esm({
         );
       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 !== (0, import_jev3.jevHash)(record.input) || record.questionsHash !== (0, import_jev3.jevHash)(questionsForJevInput(record.input)) || record.id !== (0, import_jev3.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 !== import_jev2.JEV_QUESTION_SET || !Number.isFinite(record.input.timestamp) || record.inputHash !== (0, import_jev3.jevHash)(record.input) || record.questionsHash !== (0, import_jev3.jevHash)(questionsForJevInput(record.input)) || record.id !== (0, import_jev3.jevHash)({
           inputHash: record.inputHash,
           questionsHash: record.questionsHash,
           provider: record.provider
@@ -349,7 +462,7 @@ var init_jevTraining = __esm({
           throw new Error("Invalid Jev study provenance");
         (0, import_jev3.validateJevResponse)(record.response, record.input.questions);
         for (const dimension of import_jev2.JEV_DIMENSIONS) {
-          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 / (0, import_jev3.jevScoreMaximum)(dimension) : null;
           if (record.scores[dimension] !== expected)
             throw new Error("Jev study scores do not match the teacher response");
         }
@@ -432,10 +545,12 @@ var init_jevTraining = __esm({
     };
     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 !== (0, import_jev3.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 !== import_jev2.JEV_QUESTION_SET || import_jev2.JEV_DIMENSIONS.some((dimension) => !(dimension in model.trees)) || Object.keys(model.trees).some(
+        (dimension) => !import_jev2.JEV_DIMENSIONS.includes(dimension)
+      ) || model.questionsHash !== (0, import_jev3.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");
@@ -571,13 +686,10 @@ var init_jevTraining = __esm({
       ];
       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(
         import_jev2.JEV_DIMENSIONS.map((key) => {
           const eligible = samples.filter(
@@ -594,10 +706,12 @@ var init_jevTraining = __esm({
         schema: "tradejs-jev-gate/v2",
         inputSchema: "tradejs-jev-input/v4",
         strategy: first.input.strategy,
+        questionSet: import_jev2.JEV_QUESTION_SET,
         questionsHash: (0, import_jev3.jevHash)(JEV_QUESTIONS),
         teacherModel: first.response.model,
         trees: fit(train),
         training: {
+          split: "outer-60-40",
           datasetHash: (0, import_jev3.jevHash)(
             rows.map((row) => ({
               id: row.record.id,
@@ -612,18 +726,20 @@ var init_jevTraining = __esm({
         }
       };
       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,
@@ -631,13 +747,13 @@ var init_jevTraining = __esm({
           training: {
             ...model.training,
             trainEnd: trainThrough,
-            validationEnd: validationThrough,
+            validationEnd: trainThrough,
             testEnd: testThrough
           }
         };
         return {
           trainThrough,
-          validationThrough,
+          validationThrough: trainThrough,
           testThrough,
           trainRows: fitting.length,
           test: compareJevGate(fold, evaluation)
@@ -647,7 +763,8 @@ var init_jevTraining = __esm({
         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"
@@ -715,6 +832,7 @@ var evaluateJevInput = async ({
   const questions = questionsForJevInput(input);
   const questionsHash = (0, import_jev5.jevHash)(questions);
   const base = {
+    questionSet: import_jev4.JEV_QUESTION_SET,
     schema: "tradejs-signal-assessment/v5",
     source: config.source,
     mode: config.mode,
@@ -771,7 +889,7 @@ var evaluateJevInput = async ({
         throw new Error("Jev recording identity mismatch");
       (0, import_jev5.validateJevResponse)(existing.response, input.questions);
       for (const key of import_jev4.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 / (0, import_jev5.jevScoreMaximum)(key) : null;
         if (existing.scores[key] !== expected)
           throw new Error("Jev recording scores do not match the response");
       }
@@ -819,7 +937,7 @@ var evaluateJevInput = async ({
     const scores = Object.fromEntries(
       import_jev4.JEV_DIMENSIONS.map((key) => [
         key,
-        input.questions.includes(key) ? response.answers[key].score / 4 : null
+        input.questions.includes(key) ? response.answers[key].score / (0, import_jev5.jevScoreMaximum)(key) : null
       ])
     );
     const value = {
@@ -886,6 +1004,7 @@ var assessSignalWithJev = async ({
   } catch (error) {
     if (strict) throw error;
     assessment = {
+      questionSet: import_jev4.JEV_QUESTION_SET,
       schema: "tradejs-signal-assessment/v5",
       source: config.source,
       mode: config.mode,
@@ -902,12 +1021,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: (0, import_jev4.jevAssessmentFeatures)(assessment)
   };
   const identity = {
     signalId: signal.signalId,

package/dist/runtimeStrategies.mjs

@@ -9,11 +9,11 @@ import {
   resolveRuntimeComposition,
   verifyRuntimeDeclaration
 } from "./chunk-BO42QWAB.mjs";
-import "./chunk-WGL7XJ3W.mjs";
+import "./chunk-SKY2HNZU.mjs";
 import "./chunk-UL5Z46JL.mjs";
 import "./chunk-LZDXRXIU.mjs";
-import "./chunk-3BBXGZ7M.mjs";
-import "./chunk-ZZQLTUTP.mjs";
+import "./chunk-YR55Q355.mjs";
+import "./chunk-GHSLOJLE.mjs";
 import "./chunk-Y6FXYEAI.mjs";
 export {
   RUNTIME_PACKAGE_MANIFEST_SCHEMA,