@elench/testkit 0.1.137 → 0.1.139

package/lib/config/index.mjs

@@ -236,11 +236,33 @@ function normalizeEnvironmentConfig(name, environment) {
     data,
     portOffset,
     env: normalizeEnvironmentEnv(environment.env),
+    resources: normalizeEnvironmentResources(name, environment.resources),
+    productionLike: Boolean(environment.productionLike),
     ...(environment.publicHost ? { publicHost: String(environment.publicHost) } : {}),
     ...(kiln ? { kiln } : {}),
   };
 }
 
+function normalizeEnvironmentResources(environmentName, resources = {}) {
+  if (resources == null) return {};
+  if (typeof resources !== "object" || Array.isArray(resources)) {
+    throw new Error(`Environment "${environmentName}" resources must be an object`);
+  }
+  return Object.fromEntries(
+    Object.entries(resources).map(([name, resource]) => {
+      const normalizedName = normalizeDatabaseEnvToken(name, `Environment "${environmentName}" resource name`, false);
+      if (!resource || typeof resource !== "object" || Array.isArray(resource)) {
+        throw new Error(`Environment "${environmentName}" resource "${name}" must be an object`);
+      }
+      const kind = String(resource.kind || "").trim();
+      if (!["postgres", "server"].includes(kind)) {
+        throw new Error(`Environment "${environmentName}" resource "${name}" kind must be "postgres" or "server"`);
+      }
+      return [normalizedName, { ...resource, kind }];
+    })
+  );
+}
+
 function normalizeKilnEnvironmentConfig(name, kiln) {
   if (!kiln) return null;
   if (typeof kiln !== "object" || Array.isArray(kiln)) {
@@ -277,13 +299,14 @@ function normalizeEnvironmentEnv(env) {
   }
   const hasPresetShape =
     Object.prototype.hasOwnProperty.call(env, "values") ||
-    Object.prototype.hasOwnProperty.call(env, "databases");
+    Object.prototype.hasOwnProperty.call(env, "databases") ||
+    Object.prototype.hasOwnProperty.call(env, "resources");
   if (!hasPresetShape) {
     return Object.fromEntries(
       Object.entries(env).map(([key, value]) => [key, String(value)])
     );
   }
-  const allowedKeys = new Set(["values", "databases"]);
+  const allowedKeys = new Set(["values", "databases", "resources"]);
   const unexpectedKeys = Object.keys(env).filter((key) => !allowedKeys.has(key));
   if (unexpectedKeys.length > 0) {
     throw new Error(
@@ -293,8 +316,11 @@ function normalizeEnvironmentEnv(env) {
   const values = env.values && typeof env.values === "object" && !Array.isArray(env.values) ? env.values : {};
   const databases =
     env.databases && typeof env.databases === "object" && !Array.isArray(env.databases) ? env.databases : {};
+  const resources =
+    env.resources && typeof env.resources === "object" && !Array.isArray(env.resources) ? env.resources : {};
   return {
     ...expandDatabaseBindings(databases),
+    ...expandResourceBindings(resources),
     ...Object.fromEntries(Object.entries(values).map(([key, value]) => [key, String(value)])),
   };
 }
@@ -317,6 +343,22 @@ function expandDatabaseBindings(bindings) {
   return env;
 }
 
+function expandResourceBindings(bindings) {
+  const env = {};
+  for (const [envName, binding] of Object.entries(bindings || {})) {
+    if (typeof binding === "string") {
+      const [resourceName, field = "url"] = binding.split(".");
+      env[envName] = `{resource:${normalizeDatabaseEnvToken(resourceName, `env.resources.${envName}`, false)}:${normalizeDatabaseEnvToken(field, `env.resources.${envName} field`, false)}}`;
+      continue;
+    }
+    if (!binding || typeof binding !== "object" || Array.isArray(binding)) {
+      throw new Error(`env.resources.${envName} must be a string or object`);
+    }
+    env[envName] = `{resource:${normalizeDatabaseEnvToken(binding.resource, `env.resources.${envName}.resource`, false)}:${normalizeDatabaseEnvToken(binding.field || "url", `env.resources.${envName}.field`, false)}}`;
+  }
+  return env;
+}
+
 function normalizeDatabaseEnvToken(value, label, sanitize = true) {
   const raw = String(value || "").trim();
   const normalized = sanitize

package/lib/config-api/index.d.ts

@@ -280,8 +280,40 @@ export interface DatabaseBindingEnvConfig {
 export interface PresetEnvConfig {
   values?: Record<string, string>;
   databases?: Record<string, DatabaseBindingEnvConfig>;
+  resources?: Record<string, string | { resource: string; field?: string }>;
 }
 
+export interface KilnVMResourceConfig {
+  autostart?: boolean;
+  disk?: string;
+  diskSize?: string | number;
+  diskSizeMB?: number;
+  memoryMB?: number;
+  name?: string;
+  networkId?: string;
+  profile?: string;
+  vcpus?: number;
+}
+
+export interface PostgresResourceConfig {
+  kind: "postgres";
+  data?: "reuse" | "reset" | "rebuild";
+  database?: string;
+  extensions?: string[];
+  password?: string;
+  port?: number;
+  user?: string;
+  version?: string;
+  vm?: KilnVMResourceConfig;
+}
+
+export interface ServerResourceConfig {
+  kind: "server";
+  vm?: KilnVMResourceConfig;
+}
+
+export type ResourceConfig = PostgresResourceConfig | ServerResourceConfig;
+
 export interface LocalEnvironmentConfig {
   kind: "local";
   data?: "reuse" | "reset" | "rebuild";
@@ -289,7 +321,9 @@ export interface LocalEnvironmentConfig {
   env?: Record<string, string>;
   kiln?: KilnLocalEnvironmentConfig;
   portOffset?: number;
+  productionLike?: boolean;
   publicHost?: string;
+  resources?: Record<string, ResourceConfig>;
   target: string;
 }
 
@@ -599,6 +633,17 @@ export declare const database: {
     }
   ): ServiceConfig;
 };
+export declare const resource: {
+  postgres(options?: Omit<PostgresResourceConfig, "kind">): PostgresResourceConfig;
+  server(options?: Omit<ServerResourceConfig, "kind">): ServerResourceConfig;
+  field(resourceName: string, field?: string): string;
+  url(resourceName: string): string;
+  host(resourceName: string): string;
+  port(resourceName: string): string;
+  database(resourceName: string): string;
+  user(resourceName: string): string;
+  password(resourceName: string): string;
+};
 export declare const step: {
   command(run: string, options?: TemplateLifecycleStepOptions): TemplateCommandStepConfig;
   module(target: string, options?: TemplateLifecycleStepOptions): TemplateModuleStepConfig;
@@ -615,6 +660,7 @@ export declare const ui: {
 };
 export declare const environment: {
   local(options: LocalEnvironmentOptions): LocalEnvironmentConfig;
+  productionLike(options: LocalEnvironmentOptions): LocalEnvironmentConfig;
 };
 export declare const auth: {
   fixture(options: { contract: JsonSessionContract; topology: AuthTopology }): AuthFixture;

package/lib/config-api/index.mjs

@@ -33,6 +33,33 @@ function postgresDatabase(options = {}) {
   };
 }
 
+function postgresResource(options = {}) {
+  return {
+    kind: "postgres",
+    version: options.version || "16",
+    database: options.database || options.name || "app",
+    user: options.user || "app",
+    ...(options.password ? { password: options.password } : {}),
+    ...(options.port ? { port: options.port } : {}),
+    ...(options.vm ? { vm: { ...options.vm } } : {}),
+    ...(options.data ? { data: options.data } : {}),
+    ...(options.extensions ? { extensions: [...options.extensions] } : {}),
+  };
+}
+
+function serverResource(options = {}) {
+  return {
+    kind: "server",
+    ...(options.vm ? { vm: { ...options.vm } } : {}),
+  };
+}
+
+function resourceField(resourceName, field = "url") {
+  const normalizedResourceName = normalizeDatabaseEnvToken(resourceName, "resource name", false);
+  const normalizedField = normalizeDatabaseEnvToken(field, "resource field", false);
+  return `{resource:${normalizedResourceName}:${normalizedField}}`;
+}
+
 function buildDatabaseTemplateConfig(options = {}) {
   for (const legacyKey of ["schema"]) {
     if (Object.prototype.hasOwnProperty.call(options, legacyKey)) {
@@ -412,6 +439,30 @@ export const database = {
   fixture: postgresFixture,
 };
 
+export const resource = {
+  postgres: postgresResource,
+  server: serverResource,
+  field: resourceField,
+  url(resourceName) {
+    return resourceField(resourceName, "url");
+  },
+  host(resourceName) {
+    return resourceField(resourceName, "host");
+  },
+  port(resourceName) {
+    return resourceField(resourceName, "port");
+  },
+  database(resourceName) {
+    return resourceField(resourceName, "database");
+  },
+  user(resourceName) {
+    return resourceField(resourceName, "user");
+  },
+  password(resourceName) {
+    return resourceField(resourceName, "password");
+  },
+};
+
 export const step = {
   command: commandStep,
   module: moduleStep,
@@ -456,6 +507,13 @@ function localEnvironment(options = {}) {
 
 export const environment = {
   local: localEnvironment,
+  productionLike(options = {}) {
+    return localEnvironment({
+      driver: "kiln",
+      ...options,
+      productionLike: true,
+    });
+  },
 };
 
 export const auth = {
@@ -497,7 +555,7 @@ function normalizePresetEnv(env) {
   if (typeof env !== "object" || Array.isArray(env)) {
     throw new Error("Preset env must be an object");
   }
-  const allowedKeys = new Set(["values", "databases"]);
+  const allowedKeys = new Set(["values", "databases", "resources"]);
   const unexpectedKeys = Object.keys(env).filter((key) => !allowedKeys.has(key));
   if (unexpectedKeys.length > 0) {
     throw new Error(
@@ -508,9 +566,12 @@ function normalizePresetEnv(env) {
   const values = env.values && typeof env.values === "object" && !Array.isArray(env.values) ? env.values : {};
   const databases =
     env.databases && typeof env.databases === "object" && !Array.isArray(env.databases) ? env.databases : {};
+  const resources =
+    env.resources && typeof env.resources === "object" && !Array.isArray(env.resources) ? env.resources : {};
 
   return {
     ...expandDatabaseBindings(databases),
+    ...expandResourceBindings(resources),
     ...values,
   };
 }
@@ -533,6 +594,22 @@ function expandDatabaseBindings(bindings) {
   return env;
 }
 
+function expandResourceBindings(bindings) {
+  const env = {};
+  for (const [envName, binding] of Object.entries(bindings || {})) {
+    if (typeof binding === "string") {
+      const [resourceName, field = "url"] = binding.split(".");
+      env[envName] = resourceField(resourceName, field);
+      continue;
+    }
+    if (!binding || typeof binding !== "object" || Array.isArray(binding)) {
+      throw new Error(`env.resources.${envName} must be a string or object`);
+    }
+    env[envName] = resourceField(binding.resource, binding.field || "url");
+  }
+  return env;
+}
+
 function normalizeDatabaseEnvToken(value, label, sanitize = true) {
   const raw = String(value || "").trim();
   const normalized = sanitize

package/lib/kiln/client.mjs

@@ -72,6 +72,26 @@ export class KilnClient {
     return this.request("POST", `/vms/${encodeURIComponent(ref)}/exec`, { command });
   }
 
+  ensureAppliance(req) {
+    return this.request("POST", "/appliances/ensure", req);
+  }
+
+  getAppliance(ref) {
+    return this.request("GET", `/appliances/${encodeURIComponent(ref)}`);
+  }
+
+  listAppliances() {
+    return this.request("GET", "/appliances");
+  }
+
+  stopAppliance(ref) {
+    return this.request("POST", `/appliances/${encodeURIComponent(ref)}/stop`);
+  }
+
+  deleteAppliance(ref) {
+    return this.request("DELETE", `/appliances/${encodeURIComponent(ref)}`);
+  }
+
   sshKey(machineId) {
     return this.requestRaw("GET", `/machines/${encodeURIComponent(machineId)}/ssh-key`);
   }

package/lib/local/kiln-driver.mjs

@@ -45,6 +45,7 @@ export async function kilnLocalUp(context, environment, options = {}) {
 
   try {
     const network = await ensureNetwork(client, environment);
+    const resources = await ensureResources(client, environment, network);
     let vm = await ensureVM(client, vmConfig, network?.id || "");
     vm = await ensureStarted(client, vm.name);
     vm = await waitForVMReady(client, vm.name);
@@ -74,7 +75,12 @@ export async function kilnLocalUp(context, environment, options = {}) {
       ...(environment.data === "reset" ? ["--reset"] : []),
       ...(environment.data === "rebuild" ? ["--rebuild"] : []),
       ...(environment.portOffset ? ["--port-offset", String(environment.portOffset)] : []),
-    ], { TESTKIT_PUBLIC_HOST: targetHost });
+    ], {
+      TESTKIT_PUBLIC_HOST: targetHost,
+      ...(Object.keys(resources.connections).length > 0
+        ? { TESTKIT_RESOURCE_CONNECTIONS_JSON: JSON.stringify(resources.connections) }
+        : {}),
+    });
     if (remote.exitCode !== 0) {
       throw new Error(`remote testkit local up failed\n${remote.stdout}${remote.stderr}`);
     }
@@ -90,6 +96,7 @@ export async function kilnLocalUp(context, environment, options = {}) {
         network: network ? { id: network.id, name: network.name, cidr: network.cidr } : null,
       },
       endpoints: rewriteEndpoints(status?.manifest?.endpoints || {}, targetHost),
+      resources: resources.manifest,
       remoteStatus: status?.manifest || null,
     });
     return buildKilnLocalStatus(context.productDir, environment.name);
@@ -126,6 +133,9 @@ export async function kilnLocalDown(context, name, options = {}) {
       stoppedAt: new Date().toISOString(),
       services: [],
     });
+    if (options.destroyState) {
+      await deleteManifestResources(manifest);
+    }
     return manifest;
   } finally {
     ssh.cleanup?.();
@@ -193,6 +203,14 @@ export function buildKilnLocalStatus(productDir, name) {
     lines.push("  endpoints:");
     for (const [service, url] of Object.entries(endpoints)) lines.push(`    ${service}: ${url}`);
   }
+  const resources = manifest.resources || {};
+  if (Object.keys(resources).length > 0) {
+    lines.push("  resources:");
+    for (const [name, resource] of Object.entries(resources)) {
+      const address = resource.private_ip || resource.ip || "";
+      lines.push(`    ${name}: ${resource.kind} ${resource.name}${address ? ` ${address}` : ""}`);
+    }
+  }
   return { name, exists: true, active: manifest.status === "running", manifest, services: [], lines };
 }
 
@@ -226,6 +244,70 @@ async function attachExistingVMs(client, network, vmRefs) {
   }
 }
 
+async function ensureResources(client, environment, network) {
+  const configured = environment.resources || {};
+  const manifest = {};
+  const connections = {};
+  for (const [name, resource] of Object.entries(configured)) {
+    if (resource.kind === "postgres") {
+      const appliance = await client.ensureAppliance({
+        name: resource.vm?.name || `${environment.name}-${name}`,
+        kind: "postgres",
+        network_id: resource.vm?.networkId || network?.id || "",
+        profile: resource.vm?.profile || "ubuntu-docker",
+        disk_size_mb: parseDiskMB(resource.vm?.disk || resource.vm?.diskSize || resource.vm?.diskSizeMB || resource.disk || "24G"),
+        memory_mb: Number(resource.vm?.memoryMB || resource.memoryMB || 1536),
+        vcpus: Number(resource.vm?.vcpus || resource.vcpus || 1),
+        autostart: Boolean(resource.vm?.autostart || resource.autostart),
+        postgres: {
+          version: resource.version || "16",
+          database: resource.database || name,
+          user: resource.user || "app",
+          ...(resource.password ? { password: resource.password } : {}),
+          ...(resource.port ? { port: Number(resource.port) } : {}),
+        },
+        metadata: {
+          "testkit.environment": environment.name,
+          "testkit.resource": name,
+        },
+      });
+      manifest[name] = pickAppliance(appliance);
+      connections[name] = appliance.connection || {};
+      continue;
+    }
+    if (resource.kind === "server") {
+      const appliance = await client.ensureAppliance({
+        name: resource.vm?.name || `${environment.name}-${name}`,
+        kind: "server",
+        network_id: resource.vm?.networkId || network?.id || "",
+        profile: resource.vm?.profile || "ubuntu-docker",
+        disk_size_mb: parseDiskMB(resource.vm?.disk || resource.vm?.diskSize || resource.vm?.diskSizeMB || resource.disk || "16G"),
+        memory_mb: Number(resource.vm?.memoryMB || resource.memoryMB || 1024),
+        vcpus: Number(resource.vm?.vcpus || resource.vcpus || 1),
+        autostart: Boolean(resource.vm?.autostart || resource.autostart),
+        metadata: {
+          "testkit.environment": environment.name,
+          "testkit.resource": name,
+        },
+      });
+      manifest[name] = pickAppliance(appliance);
+      connections[name] = appliance.connection || {};
+    }
+  }
+  return { manifest, connections };
+}
+
+async function deleteManifestResources(manifest) {
+  const resources = manifest.resources || {};
+  if (Object.keys(resources).length === 0) return;
+  const client = new KilnClient(manifest.kiln?.api || {});
+  for (const resource of Object.values(resources)) {
+    if (resource?.name) {
+      await client.deleteAppliance(resource.name).catch(() => {});
+    }
+  }
+}
+
 async function ensureVM(client, vmConfig, networkId) {
   try {
     const existing = await client.getVM(vmConfig.name);
@@ -525,6 +607,20 @@ function pickVM(vm) {
   };
 }
 
+function pickAppliance(appliance) {
+  return {
+    id: appliance.id,
+    name: appliance.name,
+    kind: appliance.kind,
+    vm_id: appliance.vm_id,
+    vm_name: appliance.vm_name,
+    state: appliance.state,
+    ip: appliance.ip,
+    private_ip: appliance.private_ip,
+    connection: appliance.connection || null,
+  };
+}
+
 function pickAPIConfig(api) {
   return {
     ...(api.apiUrl ? { apiUrl: api.apiUrl } : {}),

package/lib/local/orchestrator.mjs

@@ -242,6 +242,8 @@ export function resolveEnvironment(context, options = {}) {
     env: { ...(configured?.env || {}) },
     kiln: configured?.kiln || null,
     publicHost: process.env.TESTKIT_PUBLIC_HOST || configured?.publicHost || null,
+    resources: configured?.resources || {},
+    productionLike: Boolean(configured?.productionLike),
   };
 }
 

package/lib/runner/template.mjs

@@ -240,7 +240,9 @@ export function buildTaskExecutionEnv(config, lease, extraEnv = {}, processEnv =
 
 function buildExecutionEnvWithContext(config, lease, extraEnv, processEnv, options = {}) {
   const inheritedEnv = { ...processEnv };
-  const templateContext = buildTemplateContext(config, lease);
+  delete inheritedEnv.DATABASE_URL;
+  delete inheritedEnv.TESTKIT_RESOURCE_CONNECTIONS_JSON;
+  const templateContext = buildTemplateContext(config, lease, processEnv);
   const serviceEnv = options.omitRuntimeDatabaseBindings
     ? omitRuntimeDatabaseBindings(config.testkit.serviceEnv || {})
     : config.testkit.serviceEnv || {};
@@ -261,7 +263,6 @@ function buildExecutionEnvWithContext(config, lease, extraEnv, processEnv, optio
     ...(lease?.leaseId ? { TESTKIT_LEASE_ID: String(lease.leaseId) } : {}),
     ...(lease?.leaseDir ? { TESTKIT_LEASE_DIR: lease.leaseDir } : {}),
   };
-  delete env.DATABASE_URL;
   return env;
 }
 
@@ -284,7 +285,7 @@ export function buildPlaywrightEnv(config, baseUrl, lease, processEnv = process.
   );
 }
 
-function buildTemplateContext(config, lease) {
+function buildTemplateContext(config, lease, processEnv = process.env) {
   const baseContext = config.testkit?.templateContext || {};
   return {
     ...baseContext,
@@ -296,6 +297,7 @@ function buildTemplateContext(config, lease) {
     prepareDir: config.testkit?.prepareDir || baseContext.prepareDir || null,
     leaseId: lease?.leaseId || null,
     leaseDir: lease?.leaseDir || null,
+    resourceConnectionByName: parseResourceConnections(processEnv.TESTKIT_RESOURCE_CONNECTIONS_JSON),
   };
 }
 
@@ -331,7 +333,7 @@ function finalizeSerializable(value, context) {
 export function resolveTemplateString(value, context) {
   if (typeof value !== "string") return value;
 
-  return value.replace(/\{([a-zA-Z]+)(?::([a-zA-Z0-9_-]+))?\}/g, (_match, token, arg) => {
+  return value.replace(/\{([a-zA-Z]+)(?::([^}]+))?\}/g, (_match, token, arg) => {
     switch (token) {
       case "runtime":
       case "runtimeId":
@@ -391,6 +393,10 @@ export function resolveTemplateString(value, context) {
         const serviceName = arg || context.serviceName;
         return resolveDatabaseTemplateValue(token, serviceName, context);
       }
+      case "resource": {
+        const [resourceName, field = "url"] = String(arg || "").split(":");
+        return resolveResourceTemplateValue(resourceName, field, context);
+      }
       default:
         throw new Error(`Unsupported template token "{${token}${arg ? `:${arg}` : ""}}"`);
     }
@@ -423,7 +429,7 @@ function omitRuntimeDatabaseBindings(values = {}) {
   return Object.fromEntries(
     Object.entries(values).filter(([_key, value]) => {
       if (typeof value !== "string") return true;
-      return !/\{db(?:Url|Host|Port|Name|User|Password)(?::[a-zA-Z0-9_-]+)?\}/.test(value);
+      return !/\{(?:db(?:Url|Host|Port|Name|User|Password)(?::[^}]+)?|resource:[^}]+)\}/.test(value);
     })
   );
 }
@@ -473,6 +479,32 @@ function resolveDatabaseTemplateValue(token, serviceName, context) {
   }
 }
 
+function resolveResourceTemplateValue(resourceName, field, context) {
+  if (!resourceName) {
+    throw new Error("Resource placeholder requires a resource name");
+  }
+  const connections = context.resourceConnectionByName || {};
+  const resource = connections[resourceName];
+  if (!resource) {
+    throw new Error(`Unknown resource placeholder for resource "${resourceName}"`);
+  }
+  const value = resource[field];
+  if (value == null) {
+    throw new Error(`Unknown resource field "${field}" for resource "${resourceName}"`);
+  }
+  return String(value);
+}
+
+function parseResourceConnections(raw) {
+  if (!raw) return {};
+  try {
+    const parsed = JSON.parse(raw);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+
 export function rewriteUrlPort(rawUrl, port) {
   try {
     const original = new URL(rawUrl);

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

@@ -1,6 +1,6 @@
 {
   "name": "@elench/next-analysis",
-  "version": "0.1.137",
+  "version": "0.1.139",
   "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.137",
+  "version": "0.1.139",
   "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.137"
+    "@elench/testkit-protocol": "0.1.139"
   },
   "private": false
 }

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

@@ -1,6 +1,6 @@
 {
   "name": "@elench/testkit-protocol",
-  "version": "0.1.137",
+  "version": "0.1.139",
   "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.137",
+  "version": "0.1.139",
   "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.137",
+  "version": "0.1.139",
   "description": "Assistant-first CLI for running, inspecting, and debugging local testkit suites",
   "type": "module",
   "workspaces": [
@@ -98,10 +98,10 @@
   },
   "dependencies": {
     "@babel/code-frame": "^7.29.0",
-    "@elench/next-analysis": "0.1.137",
-    "@elench/testkit-bridge": "0.1.137",
-    "@elench/testkit-protocol": "0.1.137",
-    "@elench/ts-analysis": "0.1.137",
+    "@elench/next-analysis": "0.1.139",
+    "@elench/testkit-bridge": "0.1.139",
+    "@elench/testkit-protocol": "0.1.139",
+    "@elench/ts-analysis": "0.1.139",
     "@oclif/core": "^4.10.6",
     "@playwright/test": "^1.52.0",
     "esbuild": "^0.25.11",