@elench/testkit 0.1.85 → 0.1.86

package/README.md

@@ -423,15 +423,49 @@ const suite = defineHttpSuite({ profile: "defaultAuth" }, ({ actor, actors, req
 DAL suites:
 
 ```ts
-import { defineDalSuite } from "@elench/testkit";
+import { defineDalFixtures, defineDalSuite } from "@elench/testkit";
+
+const fixtures = defineDalFixtures(({ db, fixtureScope }) => ({
+  widget() {
+    return fixtureScope.seed("widget", "primary", { name: "Primary Widget" }, () => {
+      const widgetId = fixtureScope.id("widget");
+      db.exec(`
+        INSERT INTO widgets (id, name)
+        VALUES ('${widgetId}', 'Primary Widget')
+      `);
+      return { widgetId };
+    });
+  },
+}));
 
-const suite = defineDalSuite(({ db }) => {
-  db.query("select 1");
+const suite = defineDalSuite({ fixtures }, ({ db, fixtureScope, fixtures }) => {
+  const widget = fixtures.widget();
+  db.query(`select id from widgets where id = '${widget.widgetId}'`);
+  fixtureScope.records();
 });
 
 export default suite;
 ```
 
+`defineDalFixtures(...)` is the package-owned DAL seeding model. It gives every
+suite a deterministic `fixtureScope` with:
+
+- `fixtureScope.id(label)` / `uuid(label)`
+- `fixtureScope.slug(label)`
+- `fixtureScope.email(label)`
+- `fixtureScope.string(label, options)`
+- `fixtureScope.token(label)`
+- `fixtureScope.seed(kind, key, signature, create)`
+- `fixtureScope.records()`
+
+`testkit` enforces strict fixture behavior:
+
+- one logical fixture per `kind + key`
+- identical reseeds reuse the same seeded value
+- conflicting reseeds fail immediately
+- dependency cycles fail immediately
+- seeded fixture records are persisted as a `testkit.dal-fixtures` artifact
+
 Scenario suites:
 
 ```ts

package/lib/index.d.ts

@@ -1,11 +1,13 @@
 import type {
   ActorRequestClient,
+  DalFixtureDefinition,
   HttpClient,
   HttpClientConfig,
   RawRequestClient,
   RuntimeDb,
   RuntimeDalContext,
   RuntimeEnv,
+  RuntimeFixtureScope,
   RuntimeHeaders,
   RuntimeOptions,
   RuntimeResponse,
@@ -120,16 +122,24 @@ export interface HttpSuiteConfig<TSession = unknown> {
   options?: RuntimeOptions;
 }
 
-export interface DalSuiteContext<TSetup = unknown> {
+export interface DalSuiteContext<TSetup = unknown, TFixtures = Record<string, unknown>> {
   db: RuntimeDb;
   dal: RuntimeDalContext;
+  fixtureScope: RuntimeFixtureScope;
+  fixtures: TFixtures;
   setupData: TSetup | null;
 }
 
-export interface DalSuiteConfig<TSetup = unknown> {
+export interface DalSuiteConfig<TSetup = unknown, TFixtures = Record<string, unknown>> {
   db?: RuntimeDb;
+  fixtures?: DalFixtureDefinition<TFixtures> | null;
   options?: RuntimeOptions;
-  setup?: (context: { db: RuntimeDb; dal: RuntimeDalContext }) => TSetup;
+  setup?: (context: {
+    db: RuntimeDb;
+    dal: RuntimeDalContext;
+    fixtureScope: RuntimeFixtureScope;
+    fixtures: TFixtures;
+  }) => TSetup;
 }
 
 export declare function defineHttpSuite<TSetup = unknown>(
@@ -150,13 +160,23 @@ export declare function defineScenarioSuite<TSetup = unknown>(
   run: (context: ScenarioSuiteContext<TSetup>) => unknown
 ): TestkitSuite<TSetup>;
 
-export declare function defineDalSuite<TSetup = unknown>(
-  run: (context: DalSuiteContext<TSetup>) => unknown
+export declare function defineDalFixtures<TFixtures = Record<string, unknown>>(
+  factory: (context: {
+    db: RuntimeDb;
+    dal: RuntimeDalContext;
+    fixtureScope: RuntimeFixtureScope;
+    seed: RuntimeFixtureScope["seed"];
+    values: RuntimeFixtureScope["values"];
+  }) => TFixtures
+): DalFixtureDefinition<TFixtures>;
+
+export declare function defineDalSuite<TSetup = unknown, TFixtures = Record<string, unknown>>(
+  run: (context: DalSuiteContext<TSetup, TFixtures>) => unknown
 ): TestkitSuite<TSetup>;
 
-export declare function defineDalSuite<TSetup = unknown>(
-  config: DalSuiteConfig<TSetup>,
-  run: (context: DalSuiteContext<TSetup>) => unknown
+export declare function defineDalSuite<TSetup = unknown, TFixtures = Record<string, unknown>>(
+  config: DalSuiteConfig<TSetup, TFixtures>,
+  run: (context: DalSuiteContext<TSetup, TFixtures>) => unknown
 ): TestkitSuite<TSetup>;
 
 export declare function createAuthAdapter<TSetup = unknown>(
@@ -164,11 +184,13 @@ export declare function createAuthAdapter<TSetup = unknown>(
 ): AuthAdapter<TSetup>;
 
 export type {
+  DalFixtureDefinition,
   HttpClient,
   HttpClientConfig,
   RuntimeDb,
   RuntimeDalContext,
   RuntimeEnv,
+  RuntimeFixtureScope,
   RuntimeHeaders,
   RuntimeOptions,
   RuntimeResponse,

package/lib/index.mjs

@@ -1,6 +1,9 @@
 export {
   defineDalSuite,
 } from "./runtime-src/k6/dal-suite.js";
+export {
+  defineDalFixtures,
+} from "./runtime-src/k6/dal-fixtures.js";
 export {
   defineHttpSuite,
 } from "./runtime-src/k6/suite.js";

package/lib/runtime/index.d.ts

@@ -82,6 +82,83 @@ export interface RuntimeDalContext {
   truncate(...tables: string[]): void;
 }
 
+export interface RuntimeFixtureLocation {
+  column: number;
+  line: number;
+  path: string;
+}
+
+export interface RuntimeFixtureReference {
+  key: string;
+  kind: string;
+}
+
+export interface RuntimeFixtureRecord {
+  dependencies: RuntimeFixtureReference[];
+  key: string;
+  kind: string;
+  location?: RuntimeFixtureLocation;
+  order: number;
+  reuseCount: number;
+  signature: unknown;
+}
+
+export interface RuntimeFixtureStringOptions {
+  fallback?: string;
+  maxLength?: number;
+  prefix?: string;
+  suffixLength?: number;
+}
+
+export interface RuntimeFixtureEmailOptions {
+  domain?: string;
+  fallback?: string;
+  suffixLength?: number;
+}
+
+export interface RuntimeFixtureSlugOptions {
+  fallback?: string;
+  maxLength?: number;
+}
+
+export interface RuntimeFixtureValueHelpers {
+  email(label: string, options?: RuntimeFixtureEmailOptions): string;
+  slug(label: string, options?: RuntimeFixtureSlugOptions): string;
+  string(label: string, options?: RuntimeFixtureStringOptions): string;
+  token(label: string, options?: RuntimeFixtureStringOptions): string;
+  uuid(label: string): string;
+}
+
+export interface RuntimeFixtureScope {
+  email(label: string, options?: RuntimeFixtureEmailOptions): string;
+  id(label: string): string;
+  namespace: string;
+  records(): RuntimeFixtureRecord[];
+  seed<TResult>(
+    kind: string,
+    key: string,
+    signature: unknown,
+    create: () => TResult
+  ): TResult;
+  slug(label: string, options?: RuntimeFixtureSlugOptions): string;
+  string(label: string, options?: RuntimeFixtureStringOptions): string;
+  token(label: string, options?: RuntimeFixtureStringOptions): string;
+  uuid(label: string): string;
+  values: RuntimeFixtureValueHelpers;
+}
+
+export interface DalFixtureDefinitionContext {
+  dal: RuntimeDalContext;
+  db: RuntimeDb;
+  fixtureScope: RuntimeFixtureScope;
+  seed: RuntimeFixtureScope["seed"];
+  values: RuntimeFixtureValueHelpers;
+}
+
+export interface DalFixtureDefinition<TFixtures = Record<string, unknown>> {
+  create(context: DalFixtureDefinitionContext): TFixtures;
+}
+
 export interface HttpRequestParams {
   headers?: RuntimeHeaders;
   redirects?: number;

package/lib/runtime-src/k6/dal-fixtures.js

@@ -0,0 +1,66 @@
+import { emitArtifact } from "./artifacts.js";
+import { createFixtureScope } from "../shared/fixture-engine.mjs";
+import { readTestkitContext } from "../../shared/test-context.mjs";
+
+export function defineDalFixtures(factory) {
+  if (typeof factory !== "function") {
+    throw new Error("defineDalFixtures(factory) requires a fixture factory function.");
+  }
+
+  return {
+    create: factory,
+  };
+}
+
+export function createDalFixtureRuntime({ db, dal, definition = null, env = __ENV } = {}) {
+  const runtimeContext = readTestkitContext(env);
+  const fixtureScope = createFixtureScope({
+    namespace: `dal-${runtimeContext.namespace}`,
+  });
+
+  const fixtureDefinition = normalizeFixtureDefinition(definition);
+  const fixtures = fixtureDefinition
+    ? fixtureDefinition.create({
+        db,
+        dal,
+        fixtureScope,
+        seed: fixtureScope.seed,
+        values: fixtureScope.values,
+      }) || {}
+    : {};
+
+  let artifactEmitted = false;
+
+  function emitArtifactOnce() {
+    if (artifactEmitted) return;
+    const records = fixtureScope.records();
+    if (records.length === 0) return;
+
+    emitArtifact(
+      "dal-fixtures",
+      {
+        namespace: fixtureScope.namespace,
+        fixtures: records,
+      },
+      {
+        kind: "testkit.dal-fixtures",
+        summary: `${records.length} DAL fixture(s)`,
+      }
+    );
+    artifactEmitted = true;
+  }
+
+  return {
+    fixtures,
+    fixtureScope,
+    emitArtifactOnce,
+  };
+}
+
+function normalizeFixtureDefinition(definition) {
+  if (!definition) return null;
+  if (typeof definition.create !== "function") {
+    throw new Error("DAL fixture definitions must be created with defineDalFixtures(...).");
+  }
+  return definition;
+}

package/lib/runtime-src/k6/dal-suite.js

@@ -6,23 +6,40 @@ import {
   startFailureCollection,
 } from "./checks.js";
 import { createDalContext, openDb } from "./dal.js";
+import { createDalFixtureRuntime } from "./dal-fixtures.js";
 
 export function defineDalSuite(configOrRun, maybeRun) {
   const { config, run } = normalizeSuiteArgs(configOrRun, maybeRun);
   const db = config.db || openDb();
   const dal = createDalContext(db);
+  const fixtureRuntime = createDalFixtureRuntime({
+    db,
+    dal,
+    definition: config.fixtures || null,
+  });
 
   return {
     options: config.options || defaultOptions,
     setup() {
       if (typeof config.setup !== "function") return null;
       startFailureCollection("setup");
+      let setupCompleted = false;
       try {
-        return config.setup({ db, dal });
+        const result = config.setup({
+          db,
+          dal,
+          fixtures: fixtureRuntime.fixtures,
+          fixtureScope: fixtureRuntime.fixtureScope,
+        });
+        setupCompleted = true;
+        return result;
       } catch (error) {
         recordRuntimeFailure();
         fail(formatFatalSuiteError("setup", error));
       } finally {
+        if (!setupCompleted) {
+          fixtureRuntime.emitArtifactOnce();
+        }
         emitFailureCollectionArtifact();
       }
     },
@@ -32,12 +49,15 @@ export function defineDalSuite(configOrRun, maybeRun) {
         return run({
           db,
           dal,
+          fixtures: fixtureRuntime.fixtures,
+          fixtureScope: fixtureRuntime.fixtureScope,
           setupData,
         });
       } catch (error) {
         recordRuntimeFailure();
         fail(formatFatalSuiteError("exec", error));
       } finally {
+        fixtureRuntime.emitArtifactOnce();
         emitFailureCollectionArtifact();
       }
     },

package/lib/runtime-src/shared/fixture-engine.mjs

@@ -0,0 +1,320 @@
+const DEFAULT_SLUG_MAX_LENGTH = 63;
+const DEFAULT_STRING_SUFFIX_LENGTH = 12;
+const DEFAULT_TOKEN_SUFFIX_LENGTH = 16;
+const DEFAULT_EMAIL_DOMAIN = "example.test";
+const STACK_LOCATION_PATTERN = /(file:\/\/[^\s)]+|\/[^\s):]+):(\d+):(\d+)/;
+
+export function createFixtureScope({ namespace, locationSkips = [] } = {}) {
+  const normalizedNamespace = normalizeNamespace(namespace);
+  const entries = new Map();
+  const creationOrder = [];
+  const activeEntries = [];
+  const values = createFixtureValues(normalizedNamespace);
+  const skipMatchers = [
+    "/runtime-src/shared/fixture-engine.mjs",
+    "/runtime-src/k6/dal-fixtures.js",
+    ...locationSkips,
+  ].filter(Boolean);
+
+  function seed(kind, key, signature, create) {
+    const normalizedKind = normalizeRequiredString(kind, "fixture kind");
+    const normalizedKey = normalizeRequiredString(key, "fixture key");
+    if (typeof create !== "function") {
+      throw new Error(
+        `Fixture ${formatFixtureRef(normalizedKind, normalizedKey)} requires a synchronous create callback.`
+      );
+    }
+
+    const entryId = buildEntryId(normalizedKind, normalizedKey);
+    const parentEntry = activeEntries[activeEntries.length - 1] || null;
+    if (parentEntry) {
+      parentEntry.dependencies.add(entryId);
+    }
+
+    const normalizedSignature = normalizeJsonValue(signature);
+    const signatureJson = stableJsonStringify(normalizedSignature);
+    const existing = entries.get(entryId);
+    if (existing) {
+      if (existing.state === "creating") {
+        throw new Error(formatFixtureCycleError(existing, activeEntries, normalizedKind, normalizedKey));
+      }
+
+      if (existing.signatureJson !== signatureJson) {
+        throw new Error(
+          formatFixtureConflictError(existing, normalizedSignature, signatureJson)
+        );
+      }
+
+      existing.reuseCount += 1;
+      return existing.result;
+    }
+
+    const entry = {
+      entryId,
+      kind: normalizedKind,
+      key: normalizedKey,
+      state: "creating",
+      signature: normalizedSignature,
+      signatureJson,
+      location: captureCallsite(skipMatchers),
+      dependencies: new Set(),
+      reuseCount: 0,
+      order: creationOrder.length + 1,
+      result: undefined,
+    };
+
+    entries.set(entryId, entry);
+    creationOrder.push(entryId);
+    activeEntries.push(entry);
+
+    try {
+      const result = create();
+      if (result && typeof result.then === "function") {
+        throw new Error(
+          `Fixture ${formatFixtureRef(normalizedKind, normalizedKey)} returned a Promise. DAL fixtures must be synchronous.`
+        );
+      }
+      entry.state = "ready";
+      entry.result = result;
+      return result;
+    } catch (error) {
+      entries.delete(entryId);
+      creationOrder.pop();
+      throw error;
+    } finally {
+      activeEntries.pop();
+    }
+  }
+
+  function records() {
+    return creationOrder
+      .map((entryId) => entries.get(entryId))
+      .filter(Boolean)
+      .map((entry) => ({
+        kind: entry.kind,
+        key: entry.key,
+        signature: cloneJsonValue(entry.signature),
+        reuseCount: entry.reuseCount,
+        order: entry.order,
+        dependencies: [...entry.dependencies]
+          .map((dependencyId) => entries.get(dependencyId))
+          .filter(Boolean)
+          .map((dependency) => ({
+            kind: dependency.kind,
+            key: dependency.key,
+          })),
+        ...(entry.location ? { location: { ...entry.location } } : {}),
+      }));
+  }
+
+  return {
+    namespace: normalizedNamespace,
+    values,
+    id: values.uuid,
+    uuid: values.uuid,
+    slug: values.slug,
+    email: values.email,
+    string: values.string,
+    token: values.token,
+    seed,
+    records,
+  };
+}
+
+export function createFixtureValues(namespace) {
+  const normalizedNamespace = normalizeNamespace(namespace);
+
+  function uuid(label) {
+    const hex = namespacedHex(normalizedNamespace, label).slice(0, 32).split("");
+    hex[12] = "4";
+    hex[16] = ((Number.parseInt(hex[16] || "0", 16) & 0x3) | 0x8).toString(16);
+    return `${hex.slice(0, 8).join("")}-${hex.slice(8, 12).join("")}-${hex.slice(12, 16).join("")}-${hex.slice(16, 20).join("")}-${hex.slice(20, 32).join("")}`;
+  }
+
+  function slug(label, options = {}) {
+    const fallback = normalizeToken(options.fallback) || "resource";
+    const base = normalizeToken(label) || fallback;
+    const maxLength = normalizePositiveInteger(options.maxLength) || DEFAULT_SLUG_MAX_LENGTH;
+    return `${base}-${namespacedSuffix(normalizedNamespace, `slug:${label}`, DEFAULT_STRING_SUFFIX_LENGTH)}`.slice(
+      0,
+      maxLength
+    );
+  }
+
+  function email(label, options = {}) {
+    const fallback = normalizeToken(options.fallback) || "user";
+    const base = normalizeToken(label) || fallback;
+    const domain = normalizeEmailDomain(options.domain) || DEFAULT_EMAIL_DOMAIN;
+    const suffixLength =
+      normalizePositiveInteger(options.suffixLength) || DEFAULT_STRING_SUFFIX_LENGTH;
+    return `${base}-${namespacedSuffix(normalizedNamespace, `email:${label}`, suffixLength)}@${domain}`;
+  }
+
+  function string(label, options = {}) {
+    const fallback = normalizeToken(options.fallback) || "value";
+    const prefix = normalizeToken(options.prefix) || normalizeToken(label) || fallback;
+    const suffixLength =
+      normalizePositiveInteger(options.suffixLength) || DEFAULT_STRING_SUFFIX_LENGTH;
+    const maxLength = normalizePositiveInteger(options.maxLength) || null;
+    const value = `${prefix}-${namespacedSuffix(normalizedNamespace, `string:${label}:${prefix}`, suffixLength)}`;
+    return maxLength ? value.slice(0, maxLength) : value;
+  }
+
+  function token(label, options = {}) {
+    return string(label, {
+      ...options,
+      fallback: options.fallback || "token",
+      suffixLength: normalizePositiveInteger(options.suffixLength) || DEFAULT_TOKEN_SUFFIX_LENGTH,
+    });
+  }
+
+  return {
+    uuid,
+    slug,
+    email,
+    string,
+    token,
+  };
+}
+
+function formatFixtureConflictError(existing, nextSignature, nextSignatureJson) {
+  const location = existing.location ? ` First declared at ${formatLocation(existing.location)}.` : "";
+  return [
+    `Fixture ${formatFixtureRef(existing.kind, existing.key)} was seeded twice with conflicting signatures.`,
+    location,
+    ` Existing: ${existing.signatureJson}`,
+    ` New: ${nextSignatureJson || stableJsonStringify(normalizeJsonValue(nextSignature))}`,
+  ].join("");
+}
+
+function formatFixtureCycleError(existing, activeEntries, kind, key) {
+  const cycleStartIndex = activeEntries.findIndex((entry) => entry.entryId === existing.entryId);
+  const cycleEntries = cycleStartIndex >= 0 ? activeEntries.slice(cycleStartIndex) : activeEntries;
+  const chain = [...cycleEntries.map((entry) => formatFixtureRef(entry.kind, entry.key)), formatFixtureRef(kind, key)];
+  return `Fixture dependency cycle detected: ${chain.join(" -> ")}.`;
+}
+
+function formatFixtureRef(kind, key) {
+  return `${kind}:${key}`;
+}
+
+function formatLocation(location) {
+  return `${location.path}:${location.line}:${location.column}`;
+}
+
+function buildEntryId(kind, key) {
+  return `${kind}::${key}`;
+}
+
+function normalizeNamespace(namespace) {
+  return normalizeToken(namespace) || "standalone";
+}
+
+function normalizeRequiredString(value, label) {
+  const normalized = String(value || "").trim();
+  if (normalized.length === 0) {
+    throw new Error(`Fixture ${label} must be a non-empty string.`);
+  }
+  return normalized;
+}
+
+function normalizePositiveInteger(value) {
+  if (!Number.isInteger(value) || value <= 0) return null;
+  return value;
+}
+
+function normalizeEmailDomain(value) {
+  const normalized = String(value || "").trim().toLowerCase();
+  return normalized.length > 0 ? normalized : null;
+}
+
+function normalizeToken(value) {
+  return String(value || "")
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "");
+}
+
+function hash32(input) {
+  let hash = 0x811c9dc5;
+  for (let index = 0; index < input.length; index += 1) {
+    hash ^= input.charCodeAt(index);
+    hash = Math.imul(hash, 0x01000193) >>> 0;
+  }
+  return hash.toString(16).padStart(8, "0");
+}
+
+function namespacedHex(namespace, label) {
+  return [0, 1, 2, 3].map((part) => hash32(`${namespace}:${label}:${part}`)).join("");
+}
+
+function namespacedSuffix(namespace, label, length) {
+  return namespacedHex(namespace, label).slice(0, length);
+}
+
+function captureCallsite(skipMatchers) {
+  const stack = new Error().stack;
+  if (!stack) return null;
+
+  for (const line of stack.split("\n").slice(1)) {
+    const match = line.match(STACK_LOCATION_PATTERN);
+    if (!match) continue;
+    const [rawPath, rawLine, rawColumn] = match.slice(1);
+    if (!rawPath || !rawLine || !rawColumn) continue;
+    const path = normalizeStackPath(rawPath);
+    if (skipMatchers.some((matcher) => path.endsWith(matcher) || path.includes(matcher))) {
+      continue;
+    }
+    return {
+      path,
+      line: Number(rawLine),
+      column: Number(rawColumn),
+    };
+  }
+
+  return null;
+}
+
+function normalizeStackPath(rawPath) {
+  return String(rawPath || "").replace(/^file:\/\//, "");
+}
+
+function stableJsonStringify(value) {
+  return JSON.stringify(normalizeJsonValue(value));
+}
+
+function cloneJsonValue(value) {
+  return normalizeJsonValue(value);
+}
+
+function normalizeJsonValue(value) {
+  if (
+    value === null ||
+    value === undefined ||
+    typeof value === "boolean" ||
+    typeof value === "number" ||
+    typeof value === "string"
+  ) {
+    return value;
+  }
+
+  if (typeof value === "bigint") {
+    return value.toString();
+  }
+
+  if (Array.isArray(value)) {
+    return value.map((entry) => normalizeJsonValue(entry));
+  }
+
+  if (typeof value === "object") {
+    return Object.keys(value)
+      .sort()
+      .reduce((result, key) => {
+        result[key] = normalizeJsonValue(value[key]);
+        return result;
+      }, {});
+  }
+
+  return String(value);
+}

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

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

package/node_modules/@elench/testkit-bridge/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elench/testkit-bridge",
-  "version": "0.1.85",
+  "version": "0.1.86",
   "description": "Browser bridge helpers for testkit",
   "type": "module",
   "main": "./dist/index.js",
@@ -22,7 +22,7 @@
     "typecheck": "tsc -p tsconfig.json --noEmit"
   },
   "dependencies": {
-    "@elench/testkit-protocol": "0.1.85"
+    "@elench/testkit-protocol": "0.1.86"
   },
   "private": false
 }

package/node_modules/@elench/testkit-protocol/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elench/testkit-protocol",
-  "version": "0.1.85",
+  "version": "0.1.86",
   "description": "Shared browser protocol for testkit bridge and extension consumers",
   "type": "module",
   "main": "./dist/index.js",

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

@@ -1,6 +1,6 @@
 {
   "name": "@elench/ts-analysis",
-  "version": "0.1.85",
+  "version": "0.1.86",
   "description": "TypeScript compiler-backed source analysis primitives for Erench tools",
   "type": "module",
   "exports": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elench/testkit",
-  "version": "0.1.85",
+  "version": "0.1.86",
   "description": "CLI for discovering and running local HTTP, DAL, and Playwright test suites",
   "type": "module",
   "workspaces": [
@@ -82,10 +82,10 @@
   },
   "dependencies": {
     "@babel/code-frame": "^7.29.0",
-    "@elench/next-analysis": "0.1.85",
-    "@elench/testkit-bridge": "0.1.85",
-    "@elench/testkit-protocol": "0.1.85",
-    "@elench/ts-analysis": "0.1.85",
+    "@elench/next-analysis": "0.1.86",
+    "@elench/testkit-bridge": "0.1.86",
+    "@elench/testkit-protocol": "0.1.86",
+    "@elench/ts-analysis": "0.1.86",
     "@oclif/core": "^4.10.6",
     "esbuild": "^0.25.11",
     "execa": "^9.5.0",