@elench/testkit 0.1.100 → 0.1.101

package/lib/runner/planning.mjs

@@ -1,4 +1,3 @@
-import { buildTimingKey, estimateTaskDuration } from "../timing/index.mjs";
 import {
   matchesSelectedTypes,
   matchesSuiteSelectors,
@@ -86,11 +85,6 @@ export function collectSuites(config, typeValues, suiteSelectors, fileNames = []
   return suites;
 }
 
-export function applyShard(suites, shard) {
-  if (!shard) return suites;
-  return suites.filter((_unused, index) => index % shard.total === shard.index - 1);
-}
-
 export function orderedTypes(types) {
   const ordered = [];
   for (const known of TYPE_ORDER) {
@@ -143,52 +137,6 @@ export function buildRuntimeGraphs(servicePlans) {
   }));
 }
 
-export function buildTaskQueue(servicePlans, graphs, timings) {
-  const graphByKey = new Map(graphs.map((graph) => [graph.key, graph]));
-  const tasks = [];
-  let nextId = 1;
-
-  for (const plan of servicePlans) {
-    if (plan.skipped) continue;
-
-    const graph = graphByKey.get(plan.assignedGraphKey);
-    if (!graph) {
-      throw new Error(`Assigned graph "${plan.assignedGraphKey}" not found for ${plan.config.name}`);
-    }
-
-    for (const suite of plan.suites) {
-      for (const file of suite.files) {
-        const timingKey = buildTimingKey(plan.config.name, suite, file);
-        tasks.push({
-          id: nextId,
-          graphKey: graph.key,
-          targetName: plan.config.name,
-          serviceName: plan.config.name,
-          suiteKey: `${suite.type}:${suite.name}`,
-          suiteName: suite.name,
-          type: suite.type,
-          framework: suite.framework,
-          orderIndex: suite.orderIndex,
-          file,
-          locks: resolveTaskLocks(plan.config, suite, file),
-          resourceCost: 1,
-          timingKey,
-          estimatedDurationMs: estimateTaskDuration(timings, timingKey, suite),
-        });
-        nextId += 1;
-      }
-    }
-  }
-
-  return tasks.sort(
-    (a, b) =>
-      b.estimatedDurationMs - a.estimatedDurationMs ||
-      a.serviceName.localeCompare(b.serviceName) ||
-      a.suiteKey.localeCompare(b.suiteKey) ||
-      a.file.localeCompare(b.file)
-  );
-}
-
 export function claimNextTask(queue, preferredGraphKey, isRunnable = () => true) {
   if (queue.length === 0) return null;
 
@@ -259,29 +207,6 @@ function applySkipRules(config, displayType, suiteName, files, opts = {}) {
   };
 }
 
-function resolveTaskLocks(config, suite, file) {
-  const locks = new Set();
-  const matchedSuiteRules = config.testkit.requirements?.suites || [];
-  for (const rule of matchedSuiteRules) {
-    if (matchesSuiteSelectors(suite.displayType, suite.name, [rule.selector])) {
-      for (const lockName of rule.locks || []) {
-        locks.add(lockName);
-      }
-    }
-  }
-
-  const normalizedFile = normalizePathSeparators(file);
-  const fileMetadata = config.testkit.fileMetadataByPath?.get(normalizedFile) || null;
-  for (const lockName of config.testkit.requirements?.fileLocksByPath?.get(normalizedFile) || []) {
-    locks.add(lockName);
-  }
-  for (const lockName of fileMetadata?.locks || []) {
-    locks.add(lockName);
-  }
-
-  return [...locks].sort();
-}
-
 function normalizePathSeparators(filePath) {
   return String(filePath).split("\\").join("/");
 }

package/lib/runner/provenance.mjs

@@ -0,0 +1,20 @@
+const ASSISTANT_SESSION_ENV = "TESTKIT_ASSISTANT_SESSION_ID";
+const ASSISTANT_COMMAND_ID_ENV = "TESTKIT_ASSISTANT_COMMAND_ID";
+
+export function buildRunProvenance(env = process.env) {
+  const sessionId = normalizeOptionalString(env?.[ASSISTANT_SESSION_ENV]);
+  const commandId = normalizeOptionalString(env?.[ASSISTANT_COMMAND_ID_ENV]);
+  if (!sessionId && !commandId) return null;
+  return {
+    assistant: {
+      sessionId,
+      commandId,
+    },
+  };
+}
+
+function normalizeOptionalString(value) {
+  if (value == null) return null;
+  const stringValue = String(value).trim();
+  return stringValue || null;
+}

package/lib/runner/reporting.mjs

@@ -6,7 +6,6 @@ export function buildStatusArtifact({
   typeValues,
   suiteSelectors,
   fileNames,
-  shard,
   serviceFilter,
   scenarioSeed,
   metadata,
@@ -67,7 +66,6 @@ export function buildStatusArtifact({
     types: [...(typeValues || ["all"])].sort(),
     suiteSelectors: [...(suiteSelectors || [])].map((selector) => selector.raw).sort(),
     fileNames: [...(fileNames || [])].sort(),
-    shard: shard || null,
     serviceFilter: serviceFilter || null,
     scenarioSeed: scenarioSeed || null,
   };
@@ -76,11 +74,10 @@ export function buildStatusArtifact({
     scope.types[0] === "all" &&
     scope.suiteSelectors.length === 0 &&
     scope.fileNames.length === 0 &&
-    scope.shard === null &&
     scope.serviceFilter === null;
 
   return {
-    schemaVersion: 7,
+    schemaVersion: 8,
     source: "testkit",
     notice: "Generated file. Do not edit manually.",
     product: {
@@ -99,6 +96,7 @@ export function buildStatusArtifact({
 
 export function buildRunArtifact({
   productDir,
+  runId = null,
   results,
   startedAt,
   finishedAt,
@@ -109,9 +107,10 @@ export function buildRunArtifact({
   typeValues,
   suiteSelectors,
   fileNames,
-  shard,
   serviceFilter,
   scenarioSeed,
+  planning = null,
+  provenance = null,
   metadata,
   summarizeDbBackend,
   serviceLogs = [],
@@ -134,7 +133,7 @@ export function buildRunArtifact({
   const dbBackend = summarizeDbBackend(results);
 
   return {
-    schemaVersion: 9,
+    schemaVersion: 10,
     source: "testkit",
     generatedAt: new Date(finishedAt).toISOString(),
     product: {
@@ -144,6 +143,7 @@ export function buildRunArtifact({
     git: metadata.git,
     host: metadata.host,
     run: {
+      id: runId,
       status: runStatus || (failedServices.length > 0 ? "failed" : "passed"),
       startedAt: new Date(startedAt).toISOString(),
       finishedAt: new Date(finishedAt).toISOString(),
@@ -157,11 +157,12 @@ export function buildRunArtifact({
       types: typeValues,
       suiteSelectors: suiteSelectors.map((selector) => selector.raw),
       fileNames,
-      shard,
       serviceFilter,
       scenarioSeed: scenarioSeed || null,
       testkitVersion: metadata.testkitVersion,
     },
+    ...(provenance ? { provenance } : {}),
+    ...(planning ? { planning } : {}),
     summary: {
       services: {
         total: executed.length,
@@ -216,6 +217,7 @@ export function buildRunArtifact({
 
 export function buildLiveRunArtifact({
   productDir,
+  runId = null,
   results,
   startedAt,
   updatedAt,
@@ -226,9 +228,10 @@ export function buildLiveRunArtifact({
   typeValues,
   suiteSelectors,
   fileNames,
-  shard,
   serviceFilter,
   scenarioSeed,
+  planning = null,
+  provenance = null,
   metadata,
   summarizeDbBackend,
   serviceLogs = [],
@@ -237,6 +240,7 @@ export function buildLiveRunArtifact({
 }) {
   return buildRunArtifact({
     productDir,
+    runId,
     results,
     startedAt,
     finishedAt: updatedAt,
@@ -247,9 +251,10 @@ export function buildLiveRunArtifact({
     typeValues,
     suiteSelectors,
     fileNames,
-    shard,
     serviceFilter,
     scenarioSeed,
+    planning,
+    provenance,
     metadata,
     summarizeDbBackend,
     serviceLogs,

package/lib/runner/run-finalization.mjs

@@ -9,6 +9,7 @@ import { shouldFailRegressionSync, validateRegressionIssues } from "../regressio
 
 export async function finalizeRunArtifacts({
   productDir,
+  runId,
   results,
   startedAt,
   finishedAt,
@@ -17,6 +18,7 @@ export async function finalizeRunArtifacts({
   runtimeInstanceCount,
   runtimeStats,
   selection,
+  provenance = null,
   metadata,
   logRegistry,
   setupRegistry,
@@ -28,6 +30,7 @@ export async function finalizeRunArtifacts({
 }) {
   const runArtifact = buildRunArtifact({
     productDir,
+    runId,
     results,
     startedAt,
     finishedAt,
@@ -38,9 +41,10 @@ export async function finalizeRunArtifacts({
     typeValues: selection.typeValues,
     suiteSelectors: selection.suiteSelectors,
     fileNames: selection.fileNames,
-    shard: selection.shard,
     serviceFilter: selection.serviceFilter,
     scenarioSeed: selection.scenarioSeed,
+    planning: selection.planning || null,
+    provenance,
     metadata,
     summarizeDbBackend,
     serviceLogs: logRegistry.listServiceLogs(),
@@ -54,7 +58,6 @@ export async function finalizeRunArtifacts({
         typeValues: selection.typeValues,
         suiteSelectors: selection.suiteSelectors,
         fileNames: selection.fileNames,
-        shard: selection.shard,
         serviceFilter: selection.serviceFilter,
         scenarioSeed: selection.scenarioSeed,
         metadata,

package/lib/runner/run-guards.mjs

@@ -27,7 +27,6 @@ export function ensureStatusWriteAllowed(opts, typeValues, suiteSelectors, reque
       typeValues,
       suiteSelectors,
       requestedFiles,
-      opts.shard || null,
       opts.serviceFilter || null
     )
   ) {

package/lib/runner/scheduler/estimates.mjs

@@ -0,0 +1,61 @@
+export const DEFAULT_ESTIMATE_SOURCE = "default";
+
+export function estimateTask({ task, suite, timings, history } = {}) {
+  const timingEstimate = estimateFromTimings(timings, task);
+  if (timingEstimate) return timingEstimate;
+
+  const historyEstimate = estimateFromHistory(history, task);
+  if (historyEstimate) return historyEstimate;
+
+  return {
+    durationMs: estimateDefaultDuration(task, suite),
+    source: DEFAULT_ESTIMATE_SOURCE,
+    confidence: "low",
+    runs: 0,
+    key: null,
+  };
+}
+
+export function estimateDefaultDuration(task = {}, suite = {}) {
+  const base =
+    task.framework === "playwright" || suite.framework === "playwright"
+      ? 20_000
+      : task.type === "dal" || suite.type === "dal"
+        ? 4_000
+        : 8_000;
+  const suiteWeight = Number(suite.weight || 1);
+  const suiteFileCount = Math.max(1, Number(suite.files?.length || 1));
+  return Math.max(1_000, Math.round((base * suiteWeight) / suiteFileCount));
+}
+
+function estimateFromTimings(timings, task = {}) {
+  const candidates = [task.timingKey, ...(task.legacyTimingKeys || [])].filter(Boolean);
+  for (const key of candidates) {
+    const entry = timings?.files?.[key];
+    const durationMs = Number(entry?.durationMs || entry?.avgDurationMs || 0);
+    if (durationMs <= 0) continue;
+    const runs = Number(entry.runs || 0);
+    return {
+      durationMs: Math.max(1, Math.round(durationMs)),
+      source: "timings",
+      confidence: runs >= 3 ? "high" : "medium",
+      runs,
+      key,
+    };
+  }
+  return null;
+}
+
+function estimateFromHistory(history, task = {}) {
+  const entry = history?.tests?.[task.historyKey];
+  const durationMs = Number(entry?.avgDurationMs || 0);
+  if (durationMs <= 0) return null;
+  const runs = Number(entry.durationCount || entry.runCount || 0);
+  return {
+    durationMs: Math.max(1, Math.round(durationMs)),
+    source: "history",
+    confidence: runs >= 3 ? "medium" : "low",
+    runs,
+    key: task.historyKey,
+  };
+}

package/lib/runner/scheduler/identity.mjs

@@ -0,0 +1,31 @@
+import path from "path";
+
+export function normalizeTaskPath(filePath) {
+  return String(filePath || "").split(path.sep).join("/").replace(/^\.\/+/, "");
+}
+
+export function buildSchedulerTaskKey({ serviceName, displayType, type, framework, file } = {}) {
+  return [
+    serviceName || "service",
+    displayType || type || "unknown",
+    framework || "k6",
+    normalizeTaskPath(file),
+  ].join("|");
+}
+
+export function buildLegacyTimingKey({ serviceName, type, framework, file } = {}) {
+  return [
+    serviceName || "service",
+    framework || "k6",
+    type || "unknown",
+    normalizeTaskPath(file),
+  ].join("|");
+}
+
+export function buildSchedulerHistoryKey({ serviceName, displayType, type, file } = {}) {
+  return [
+    serviceName || "service",
+    displayType || type || "unknown",
+    normalizeTaskPath(file),
+  ].join("|");
+}

package/lib/runner/scheduler/index.mjs

@@ -0,0 +1,126 @@
+import {
+  buildLegacyTimingKey,
+  buildSchedulerHistoryKey,
+  buildSchedulerTaskKey,
+} from "./identity.mjs";
+import { estimateTask } from "./estimates.mjs";
+import { matchesSuiteSelectors } from "../suite-selection.mjs";
+
+export const SCHEDULER_POLICY = "longest-estimated-duration-first";
+export const SCHEDULER_VERSION = 1;
+
+export function buildScheduledQueue(servicePlans, graphs, { timings, history } = {}) {
+  const graphByKey = new Map(graphs.map((graph) => [graph.key, graph]));
+  const tasks = [];
+  let nextId = 1;
+
+  for (const plan of servicePlans) {
+    if (plan.skipped) continue;
+
+    const graph = graphByKey.get(plan.assignedGraphKey);
+    if (!graph) {
+      throw new Error(`Assigned graph "${plan.assignedGraphKey}" not found for ${plan.config.name}`);
+    }
+
+    for (const suite of plan.suites) {
+      for (const file of suite.files) {
+        const baseTask = {
+          id: nextId,
+          graphKey: graph.key,
+          targetName: plan.config.name,
+          serviceName: plan.config.name,
+          suiteKey: `${suite.type}:${suite.name}`,
+          suiteName: suite.name,
+          type: suite.type,
+          displayType: suite.displayType || suite.type,
+          framework: suite.framework,
+          orderIndex: suite.orderIndex,
+          file,
+          locks: resolveTaskLocks(plan.config, suite, file),
+          resourceCost: 1,
+        };
+        const timingKey = buildSchedulerTaskKey(baseTask);
+        const task = {
+          ...baseTask,
+          timingKey,
+          legacyTimingKeys: [buildLegacyTimingKey(baseTask)].filter((key) => key !== timingKey),
+          historyKey: buildSchedulerHistoryKey(baseTask),
+        };
+        const estimate = estimateTask({ task, suite, timings, history });
+        tasks.push({
+          ...task,
+          estimatedDurationMs: estimate.durationMs,
+          estimateSource: estimate.source,
+          estimateConfidence: estimate.confidence,
+          estimateRuns: estimate.runs,
+          estimateKey: estimate.key,
+        });
+        nextId += 1;
+      }
+    }
+  }
+
+  return tasks
+    .sort(compareScheduledTasks)
+    .map((task, index) => ({
+      ...task,
+      schedulerRank: index + 1,
+      schedulerPolicy: SCHEDULER_POLICY,
+    }));
+}
+
+export function buildRunPlanningMetadata(queue) {
+  return {
+    scheduler: {
+      policy: SCHEDULER_POLICY,
+      version: SCHEDULER_VERSION,
+    },
+    tasks: (queue || []).map((task) => ({
+      rank: task.schedulerRank || null,
+      id: task.id,
+      service: task.serviceName,
+      suite: task.suiteName,
+      type: task.displayType || task.type,
+      framework: task.framework,
+      file: task.file,
+      graphKey: task.graphKey,
+      estimatedDurationMs: task.estimatedDurationMs,
+      estimateSource: task.estimateSource,
+      estimateConfidence: task.estimateConfidence,
+      estimateRuns: task.estimateRuns || 0,
+      timingKey: task.timingKey,
+      historyKey: task.historyKey,
+    })),
+  };
+}
+
+export function compareScheduledTasks(a, b) {
+  return (
+    b.estimatedDurationMs - a.estimatedDurationMs ||
+    a.serviceName.localeCompare(b.serviceName) ||
+    a.suiteKey.localeCompare(b.suiteKey) ||
+    a.file.localeCompare(b.file)
+  );
+}
+
+function resolveTaskLocks(config, suite, file) {
+  const locks = new Set();
+  const matchedSuiteRules = config.testkit.requirements?.suites || [];
+  for (const rule of matchedSuiteRules) {
+    if (matchesSuiteSelectors(suite.displayType, suite.name, [rule.selector])) {
+      for (const lockName of rule.locks || []) {
+        locks.add(lockName);
+      }
+    }
+  }
+
+  const normalizedFile = String(file).split("\\").join("/");
+  const fileMetadata = config.testkit.fileMetadataByPath?.get(normalizedFile) || null;
+  for (const lockName of config.testkit.requirements?.fileLocksByPath?.get(normalizedFile) || []) {
+    locks.add(lockName);
+  }
+  for (const lockName of fileMetadata?.locks || []) {
+    locks.add(lockName);
+  }
+  return [...locks].sort();
+}

package/lib/runner/scheduler/observations.mjs

@@ -0,0 +1,27 @@
+export function buildTimingObservation(task, outcome = {}) {
+  const status = normalizeOutcomeStatus(outcome);
+  if (status === "skipped" || status === "not_run") return null;
+
+  const durationMs = Number(outcome.durationMs || 0);
+  if (durationMs <= 0) return null;
+
+  return {
+    key: task.timingKey,
+    legacyKeys: task.legacyTimingKeys || [],
+    durationMs,
+    status,
+    startedAt: outcome.startedAt || null,
+    finishedAt: outcome.finishedAt || null,
+    estimate: {
+      durationMs: task.estimatedDurationMs || null,
+      source: task.estimateSource || null,
+      confidence: task.estimateConfidence || null,
+    },
+  };
+}
+
+function normalizeOutcomeStatus(outcome = {}) {
+  if (outcome.status === "skipped") return "skipped";
+  if (outcome.status === "not_run") return "not_run";
+  return outcome.failed ? "failed" : "passed";
+}

package/lib/runner/selection.mjs

@@ -23,13 +23,12 @@ export function findUnmatchedRequestedFiles(
   );
 }
 
-export function isFullRunSelection(typeValues, suiteSelectors, fileNames, shard, serviceFilter) {
+export function isFullRunSelection(typeValues, suiteSelectors, fileNames, serviceFilter) {
   return (
     (typeValues || []).length === 1 &&
     typeValues[0] === "all" &&
     (suiteSelectors || []).length === 0 &&
     (fileNames || []).length === 0 &&
-    (shard || null) === null &&
     (serviceFilter || null) === null
   );
 }

package/lib/runner/worker-loop.mjs

@@ -1,6 +1,7 @@
 import { formatError } from "./formatting.mjs";
 import { runDalTask, runHttpK6Task } from "./default-runtime-runner.mjs";
 import { runPlaywrightTask } from "./playwright-runner.mjs";
+import { buildTimingObservation } from "./scheduler/observations.mjs";
 
 const HTTP_K6_TYPES = new Set(["integration", "e2e", "scenario", "load"]);
 
@@ -72,10 +73,8 @@ export async function runWorker(
         const outcome = await runTask(lease.context, task, lifecycle, lease, reporter);
         recordTaskOutcome(trackers, outcome.task, outcome);
         reporter?.taskFinished?.(outcome.task, outcome);
-        timingUpdates.push({
-          key: outcome.task.timingKey,
-          durationMs: outcome.durationMs,
-        });
+        const timingObservation = buildTimingObservation(outcome.task, outcome);
+        if (timingObservation) timingUpdates.push(timingObservation);
         worker.taskCount += 1;
         await runtimeManager.release(lease);
       } catch (error) {

package/lib/timing/index.mjs

@@ -1,5 +1,3 @@
-import path from "path";
-
 export function createEmptyTimings() {
   return {
     version: 1,
@@ -8,9 +6,24 @@ export function createEmptyTimings() {
 }
 
 export function normalizeTimings(parsed) {
+  const files = {};
+  const parsedFiles = parsed?.files && typeof parsed.files === "object" ? parsed.files : {};
+  for (const [key, entry] of Object.entries(parsedFiles)) {
+    const durationMs = Math.max(0, Math.round(Number(entry?.durationMs || entry?.avgDurationMs || 0)));
+    files[key] = {
+      durationMs,
+      avgDurationMs: Math.max(0, Math.round(Number(entry?.avgDurationMs || durationMs || 0))),
+      lastDurationMs: Math.max(0, Math.round(Number(entry?.lastDurationMs || durationMs || 0))),
+      minDurationMs: Math.max(0, Math.round(Number(entry?.minDurationMs || durationMs || 0))),
+      maxDurationMs: Math.max(0, Math.round(Number(entry?.maxDurationMs || durationMs || 0))),
+      runs: Number(entry?.runs || 0),
+      lastStatus: entry?.lastStatus || null,
+      updatedAt: entry?.updatedAt || null,
+    };
+  }
   return {
     version: 1,
-    files: parsed?.files && typeof parsed.files === "object" ? parsed.files : {},
+    files,
   };
 }
 
@@ -21,53 +34,40 @@ export function applyTimingUpdates(timings, updates, updatedAt = new Date().toIS
   };
 
   for (const update of updates) {
+    if (!update?.key) continue;
+    const updateDurationMs = Math.max(1, Math.round(Number(update.durationMs || 0)));
+    if (!Number.isFinite(updateDurationMs)) continue;
     const existing = next.files[update.key];
     if (!existing) {
       next.files[update.key] = {
-        durationMs: Math.max(1, Math.round(update.durationMs)),
+        durationMs: updateDurationMs,
+        avgDurationMs: updateDurationMs,
+        lastDurationMs: updateDurationMs,
+        minDurationMs: updateDurationMs,
+        maxDurationMs: updateDurationMs,
         runs: 1,
+        lastStatus: update.status || null,
         updatedAt,
       };
       continue;
     }
 
     const runs = Number(existing.runs || 0) + 1;
-    const durationMs = Math.max(
+    const avgDurationMs = Math.max(
       1,
-      Math.round(((existing.durationMs || update.durationMs) * (runs - 1) + update.durationMs) / runs)
+      Math.round(((existing.avgDurationMs || existing.durationMs || updateDurationMs) * (runs - 1) + updateDurationMs) / runs)
     );
     next.files[update.key] = {
-      durationMs,
+      durationMs: avgDurationMs,
+      avgDurationMs,
+      lastDurationMs: updateDurationMs,
+      minDurationMs: Math.min(Number(existing.minDurationMs || updateDurationMs), updateDurationMs),
+      maxDurationMs: Math.max(Number(existing.maxDurationMs || updateDurationMs), updateDurationMs),
       runs,
+      lastStatus: update.status || existing.lastStatus || null,
       updatedAt,
     };
   }
 
   return next;
 }
-
-export function estimateTaskDuration(timings, timingKey, suite) {
-  const cached = timings.files[timingKey];
-  if (cached?.durationMs) return cached.durationMs;
-
-  const base =
-    suite.framework === "playwright"
-      ? 20_000
-      : suite.type === "dal"
-        ? 4_000
-        : 8_000;
-  return Math.max(1_000, Math.round((base * suite.weight) / Math.max(1, suite.files.length)));
-}
-
-export function buildTimingKey(serviceName, suite, file) {
-  return [
-    serviceName,
-    suite.framework,
-    suite.type,
-    normalizePathSeparators(file),
-  ].join("|");
-}
-
-function normalizePathSeparators(filePath) {
-  return filePath.split(path.sep).join("/");
-}

package/node_modules/@elench/next-analysis/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elench/next-analysis",
-  "version": "0.1.100",
+  "version": "0.1.101",
   "description": "SWC-backed Next.js source analysis primitives for Erench tools",
   "type": "module",
   "exports": {