@elench/testkit 0.1.25 → 0.1.26

package/README.md

@@ -83,6 +83,9 @@ import { check, group, http } from "@elench/testkit/runtime";
 
 `testkit` bundles these imports before execution, so tests do not need
 generated `_testkit` files, direct package-manager path imports, or any separate engine installation.
+The published package also ships first-party TypeScript declarations for both
+`@elench/testkit` and `@elench/testkit/runtime`, so consumer repos do not need
+local ambient module shims for the supported authoring surface.
 
 Legacy compatibility:
 

package/lib/config/model.mjs

@@ -21,94 +21,6 @@ export function parseDotenvString(source) {
   return env;
 }
 
-export function validateRunnerManifest(raw, manifestName = "runner.manifest.json", manifestPath = manifestName) {
-  if (!isObject(raw.services)) {
-    throw new Error(`${manifestName} must have a "services" object (${manifestPath})`);
-  }
-
-  for (const [serviceName, service] of Object.entries(raw.services)) {
-    if (!isObject(service)) {
-      throw new Error(`Service "${serviceName}" in ${manifestName} must be an object`);
-    }
-    if (!isObject(service.suites)) {
-      throw new Error(`Service "${serviceName}" in ${manifestName} must define suites`);
-    }
-
-    for (const [suiteType, suites] of Object.entries(service.suites)) {
-      if (!Array.isArray(suites)) {
-        throw new Error(
-          `Service "${serviceName}" suite type "${suiteType}" must be an array`
-        );
-      }
-
-      const seenNames = new Set();
-      for (const suite of suites) {
-        if (!isObject(suite)) {
-          throw new Error(
-            `Service "${serviceName}" suite type "${suiteType}" contains a non-object suite`
-          );
-        }
-        if (typeof suite.name !== "string" || !suite.name.length) {
-          throw new Error(
-            `Service "${serviceName}" suite type "${suiteType}" has a suite with no name`
-          );
-        }
-        if (seenNames.has(suite.name)) {
-          throw new Error(
-            `Service "${serviceName}" suite type "${suiteType}" has duplicate suite name "${suite.name}"`
-          );
-        }
-        seenNames.add(suite.name);
-
-        if (!Array.isArray(suite.files) || suite.files.length === 0) {
-          throw new Error(
-            `Service "${serviceName}" suite "${suite.name}" must define one or more files`
-          );
-        }
-        for (const file of suite.files) {
-          if (typeof file !== "string" || !file.length) {
-            throw new Error(
-              `Service "${serviceName}" suite "${suite.name}" contains an invalid file entry`
-            );
-          }
-        }
-
-        const framework = suite.framework || "k6";
-        if (!VALID_FRAMEWORKS.has(framework)) {
-          throw new Error(
-            `Service "${serviceName}" suite "${suite.name}" uses unsupported framework "${framework}"`
-          );
-        }
-
-        if (suite.testkit !== undefined) {
-          if (!isObject(suite.testkit)) {
-            throw new Error(
-              `Service "${serviceName}" suite "${suite.name}" testkit config must be an object`
-            );
-          }
-          if (
-            suite.testkit.maxFileConcurrency !== undefined &&
-            (!Number.isInteger(suite.testkit.maxFileConcurrency) ||
-              suite.testkit.maxFileConcurrency <= 0)
-          ) {
-            throw new Error(
-              `Service "${serviceName}" suite "${suite.name}" testkit.maxFileConcurrency must be a positive integer`
-            );
-          }
-          if (
-            suite.testkit.weight !== undefined &&
-            (!Number.isInteger(suite.testkit.weight) || suite.testkit.weight <= 0)
-          ) {
-            throw new Error(
-              `Service "${serviceName}" suite "${suite.name}" testkit.weight must be a positive integer`
-            );
-          }
-        }
-      }
-    }
-  }
-}
-
 export function validateConfigCoverage(
   config,
   configName = "testkit.config.json"

package/lib/config/model.test.mjs

@@ -8,7 +8,6 @@ import {
   resolveSelectedDatabase,
   validateConfigCoverage,
   validateLifecycleConfig,
-  validateRunnerManifest,
   validateServiceConfig,
   validateTelemetryConfig,
 } from "./model.mjs";
@@ -29,36 +28,6 @@ QUX='zap'
     });
   });
 
-  it("validates runner manifests", () => {
-    expect(() =>
-      validateRunnerManifest({
-        services: {
-          api: {
-            suites: {
-              integration: [
-                { name: "health", files: ["tests/health.js"] },
-              ],
-            },
-          },
-        },
-      })
-    ).not.toThrow();
-
-    expect(() =>
-      validateRunnerManifest({
-        services: {
-          api: {
-            suites: {
-              integration: [
-                { name: "health", files: ["a.js"], framework: "jest" },
-              ],
-            },
-          },
-        },
-      })
-    ).toThrow("unsupported framework");
-  });
-
   it("validates config coverage", () => {
     const config = {
       services: {

package/lib/index.d.ts

@@ -0,0 +1,92 @@
+import type {
+  HttpClient,
+  HttpClientConfig,
+  RuntimeDb,
+  RuntimeDalContext,
+  RuntimeEnv,
+  RuntimeHeaders,
+  RuntimeOptions,
+  RuntimeResponse,
+} from "./runtime/index";
+
+export interface TestkitSuite<TSetup = unknown> {
+  options: RuntimeOptions;
+  setup: () => TSetup | null;
+  exec: (setupData: TSetup | null) => unknown;
+}
+
+export interface HeaderBuilderContext {
+  env: RuntimeEnv;
+}
+
+export type HeaderBuilder<TSetup = unknown> = (
+  setupData?: TSetup | null,
+  context?: HeaderBuilderContext
+) => RuntimeHeaders | void;
+
+export interface AuthAdapter<TSetup = unknown> {
+  setup?: (context: { env: RuntimeEnv }) => TSetup;
+  headers?: HeaderBuilder<TSetup>;
+}
+
+export interface HttpSuiteContext<TSetup = unknown> {
+  env: RuntimeEnv;
+  req: HttpClient<TSetup>["request"];
+  rawReq: HttpClient["raw"];
+  getWithHeaders: HttpClient<TSetup>["getWithHeaders"];
+  setupData: TSetup | null;
+  session: TSetup | null;
+}
+
+export interface HttpSuiteConfig<TSetup = unknown> {
+  auth?: AuthAdapter<TSetup> | null;
+  env?: RuntimeEnv;
+  headers?: HeaderBuilder<TSetup>;
+  rawHeaders?: HeaderBuilder<never>;
+  options?: RuntimeOptions;
+}
+
+export interface DalSuiteContext<TSetup = unknown> {
+  db: RuntimeDb;
+  dal: RuntimeDalContext;
+  setupData: TSetup | null;
+}
+
+export interface DalSuiteConfig<TSetup = unknown> {
+  db?: RuntimeDb;
+  options?: RuntimeOptions;
+  setup?: (context: { db: RuntimeDb; dal: RuntimeDalContext }) => TSetup;
+}
+
+export declare function defineHttpSuite<TSetup = unknown>(
+  run: (context: HttpSuiteContext<TSetup>) => unknown
+): TestkitSuite<TSetup>;
+
+export declare function defineHttpSuite<TSetup = unknown>(
+  config: HttpSuiteConfig<TSetup>,
+  run: (context: HttpSuiteContext<TSetup>) => unknown
+): TestkitSuite<TSetup>;
+
+export declare function defineDalSuite<TSetup = unknown>(
+  run: (context: DalSuiteContext<TSetup>) => unknown
+): TestkitSuite<TSetup>;
+
+export declare function defineDalSuite<TSetup = unknown>(
+  config: DalSuiteConfig<TSetup>,
+  run: (context: DalSuiteContext<TSetup>) => unknown
+): TestkitSuite<TSetup>;
+
+export declare function createAuthAdapter<TSetup = unknown>(
+  adapter?: AuthAdapter<TSetup>
+): AuthAdapter<TSetup>;
+
+export type {
+  HttpClient,
+  HttpClientConfig,
+  RuntimeDb,
+  RuntimeDalContext,
+  RuntimeEnv,
+  RuntimeHeaders,
+  RuntimeOptions,
+  RuntimeResponse,
+};

package/lib/package.test.mjs

@@ -0,0 +1,24 @@
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+import { describe, expect, it } from "vitest";
+
+const rootDir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const packageJsonPath = path.join(rootDir, "package.json");
+const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+
+describe("package metadata", () => {
+  it("ships first-party type declarations for the public exports", () => {
+    expect(packageJson.types).toBe("./lib/index.d.ts");
+    expect(packageJson.exports["."]).toEqual({
+      types: "./lib/index.d.ts",
+      default: "./lib/index.mjs",
+    });
+    expect(packageJson.exports["./runtime"]).toEqual({
+      types: "./lib/runtime/index.d.ts",
+      default: "./lib/runtime/index.mjs",
+    });
+    expect(fs.existsSync(path.join(rootDir, "lib", "index.d.ts"))).toBe(true);
+    expect(fs.existsSync(path.join(rootDir, "lib", "runtime", "index.d.ts"))).toBe(true);
+  });
+});

package/lib/runner/index.mjs

@@ -832,12 +832,15 @@ function printRunSummary(results, durationMs) {
   );
   const failedSuites = executedServices.reduce((sum, result) => sum + result.failedSuiteCount, 0);
   const passedSuites = completedSuites - failedSuites;
+  const totalFiles = executedServices.reduce((sum, result) => sum + (result.totalFileCount || 0), 0);
+  const passedFiles = executedServices.reduce((sum, result) => sum + (result.passedFileCount || 0), 0);
 
   console.log("\n══ Summary ══");
   console.log(
     [
       `services ${passedServices.length}/${executedServices.length} passed`,
       `suites ${passedSuites}/${totalSuites} passed`,
+      totalFiles > 0 ? `files ${passedFiles}/${totalFiles} passed` : null,
       skippedServices.length > 0 ? `${skippedServices.length} skipped` : null,
       `duration ${formatDuration(durationMs)}`,
     ]

package/lib/runner/results.mjs

@@ -156,6 +156,19 @@ export function finalizeServiceResult(tracker, startedAt, finishedAt) {
     (suite) => suite.completedFileCount === suite.fileCount
   ).length;
   const failedSuiteCount = suites.filter((suite) => suite.failedFiles.length > 0).length;
+  const totalFileCount = suites.reduce((sum, suite) => sum + suite.fileCount, 0);
+  const completedFileCount = suites.reduce(
+    (sum, suite) => sum + suite.completedFileCount,
+    0
+  );
+  const failedFileCount = suites.reduce((sum, suite) => sum + suite.failedFiles.length, 0);
+  const passedFileCount = suites.reduce(
+    (sum, suite) =>
+      sum +
+      suite.fileResults.filter((file) => file.status === "passed").length,
+    0
+  );
+  const notRunFileCount = totalFileCount - completedFileCount;
   const accumulatedDurationMs = suites.reduce((sum, suite) => sum + suite.durationMs, 0);
   const durationMs =
     tracker.firstTaskAt && tracker.lastTaskAt
@@ -173,6 +186,11 @@ export function finalizeServiceResult(tracker, startedAt, finishedAt) {
     suiteCount: tracker.suiteCount,
     completedSuiteCount,
     failedSuiteCount,
+    totalFileCount,
+    completedFileCount,
+    passedFileCount,
+    failedFileCount,
+    notRunFileCount,
     durationMs,
     suites: suites.map((suite) => ({
       name: suite.name,
@@ -180,6 +198,10 @@ export function finalizeServiceResult(tracker, startedAt, finishedAt) {
       framework: formatFrameworkForArtifact(suite.framework),
       failed: suite.failedFiles.length > 0,
       fileCount: suite.fileCount,
+      completedFileCount: suite.completedFileCount,
+      passedFileCount: suite.fileResults.filter((file) => file.status === "passed").length,
+      failedFileCount: suite.failedFiles.length,
+      notRunFileCount: suite.fileCount - suite.completedFileCount,
       failedFiles: suite.failedFiles,
       durationMs: suite.durationMs,
       error: suite.error,
@@ -299,6 +321,10 @@ export function buildRunArtifact({
   const totalSuites = executed.reduce((sum, result) => sum + result.suiteCount, 0);
   const completedSuites = executed.reduce((sum, result) => sum + result.completedSuiteCount, 0);
   const failedSuites = executed.reduce((sum, result) => sum + result.failedSuiteCount, 0);
+  const totalFiles = executed.reduce((sum, result) => sum + (result.totalFileCount || 0), 0);
+  const passedFiles = executed.reduce((sum, result) => sum + (result.passedFileCount || 0), 0);
+  const failedFiles = executed.reduce((sum, result) => sum + (result.failedFileCount || 0), 0);
+  const notRunFiles = executed.reduce((sum, result) => sum + (result.notRunFileCount || 0), 0);
   const dbBackend = summarizeDbBackend(results);
 
   return {
@@ -339,6 +365,12 @@ export function buildRunArtifact({
         passed: completedSuites - failedSuites,
         failed: failedSuites,
       },
+      files: {
+        total: totalFiles,
+        passed: passedFiles,
+        failed: failedFiles,
+        notRun: notRunFiles,
+      },
     },
     services: results.map((result) => ({
       name: result.name,
@@ -347,6 +379,11 @@ export function buildRunArtifact({
       suiteCount: result.suiteCount,
       completedSuiteCount: result.completedSuiteCount,
       failedSuiteCount: result.failedSuiteCount,
+      totalFileCount: result.totalFileCount,
+      completedFileCount: result.completedFileCount,
+      passedFileCount: result.passedFileCount,
+      failedFileCount: result.failedFileCount,
+      notRunFileCount: result.notRunFileCount,
       durationMs: result.durationMs,
       dbBackend: result.dbBackend,
       suites: result.suites,
@@ -372,10 +409,15 @@ export function formatDuration(durationMs) {
 
 export function formatServiceSummary(result) {
   const passedSuites = result.completedSuiteCount - result.failedSuiteCount;
-  const notRun = result.suiteCount - result.completedSuiteCount;
+  const notRunSuites = result.suiteCount - result.completedSuiteCount;
   let detail = `${passedSuites}/${result.suiteCount} suites passed`;
-  if (notRun > 0) {
-    detail += `, ${notRun} not run`;
+  if ((result.totalFileCount || 0) > 0) {
+    detail += `, ${result.passedFileCount}/${result.totalFileCount} files passed`;
+  }
+  if (notRunSuites > 0) {
+    detail += `, ${notRunSuites} ${pluralize(notRunSuites, "suite", "suites")} not run`;
+  } else if ((result.notRunFileCount || 0) > 0) {
+    detail += `, ${result.notRunFileCount} ${pluralize(result.notRunFileCount, "file", "files")} not run`;
   }
   return detail;
 }
@@ -404,3 +446,7 @@ function sanitizeErrorMessage(message) {
     .replace(/Command failed with exit code (\d+): k6 run\b/g, "Default runtime failed with exit code $1:")
     .replace(/[\\/]vendor[\\/]k6\b/g, "default-runtime");
 }
+
+function pluralize(value, singular, plural) {
+  return value === 1 ? singular : plural;
+}

package/lib/runner/results.test.mjs

@@ -64,8 +64,12 @@ describe("runner-results", () => {
     const result = finalizeServiceResult(tracker, 1000, 1500);
     expect(result.failed).toBe(true);
     expect(result.failedSuiteCount).toBe(1);
+    expect(result.totalFileCount).toBe(1);
+    expect(result.failedFileCount).toBe(1);
+    expect(result.passedFileCount).toBe(0);
     expect(result.errors).toEqual(["worker failed", "graph failed"]);
     expect(result.suites[0].framework).toBe("default");
+    expect(result.suites[0].failedFileCount).toBe(1);
     expect(result.suites[0].files).toEqual([
       {
         path: "tests/health.js",
@@ -86,6 +90,11 @@ describe("runner-results", () => {
         suiteCount: 1,
         completedSuiteCount: 1,
         failedSuiteCount: 0,
+        totalFileCount: 3,
+        completedFileCount: 3,
+        passedFileCount: 3,
+        failedFileCount: 0,
+        notRunFileCount: 0,
         durationMs: 1200,
         dbBackend: "local",
         suites: [],
@@ -98,6 +107,11 @@ describe("runner-results", () => {
         suiteCount: 0,
         completedSuiteCount: 0,
         failedSuiteCount: 0,
+        totalFileCount: 0,
+        completedFileCount: 0,
+        passedFileCount: 0,
+        failedFileCount: 0,
+        notRunFileCount: 0,
         durationMs: 0,
         dbBackend: null,
         suites: [],
@@ -134,6 +148,12 @@ describe("runner-results", () => {
 
     expect(artifact.product.name).toBe("my-product");
     expect(artifact.summary.services.total).toBe(1);
+    expect(artifact.summary.files).toEqual({
+      total: 3,
+      passed: 3,
+      failed: 0,
+      notRun: 0,
+    });
     expect(summarizeDbBackend(results)).toBe("local");
     expect(formatDuration(65_000)).toBe("1m 05s");
     expect(
@@ -141,8 +161,11 @@ describe("runner-results", () => {
         completedSuiteCount: 2,
         failedSuiteCount: 1,
         suiteCount: 3,
+        totalFileCount: 6,
+        passedFileCount: 5,
+        notRunFileCount: 1,
       })
-    ).toBe("1/3 suites passed, 1 not run");
+    ).toBe("1/3 suites passed, 5/6 files passed, 1 suite not run");
     expect(formatError(new Error("boom"))).toBe("boom");
   });
 

package/lib/runtime/index.d.ts

@@ -0,0 +1,183 @@
+export type RuntimeMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+
+export interface RuntimeHeaders {
+  [key: string]: string;
+}
+
+export interface RuntimeCookie {
+  value: string;
+}
+
+export interface RuntimeResponse {
+  body: string;
+  cookies?: Record<string, RuntimeCookie[]>;
+  headers?: Record<string, string | string[] | undefined>;
+  status: number;
+  timings?: {
+    duration: number;
+  };
+}
+
+export interface RuntimeOptions {
+  [key: string]: unknown;
+  thresholds?: Record<string, unknown>;
+}
+
+export interface RuntimeEnv {
+  BASE: string;
+  MACHINE_ID?: string;
+  routeParams: RuntimeHeaders;
+}
+
+export interface RuntimeDb {
+  exec(sql: string): unknown;
+  query<T = Record<string, unknown>>(sql: string): T[];
+}
+
+export interface RuntimeDalContext {
+  db: RuntimeDb;
+  truncate(...tables: string[]): void;
+}
+
+export interface HttpRequestParams {
+  headers?: RuntimeHeaders;
+  redirects?: number;
+}
+
+export interface RuntimeHttpClient {
+  del(url: string, body?: unknown, params?: HttpRequestParams): RuntimeResponse;
+  file(data: unknown, filename?: string, contentType?: string): unknown;
+  get(url: string, params?: HttpRequestParams): RuntimeResponse;
+  patch(url: string, body?: unknown, params?: HttpRequestParams): RuntimeResponse;
+  post(url: string, body?: unknown, params?: HttpRequestParams): RuntimeResponse;
+  put(url: string, body?: unknown, params?: HttpRequestParams): RuntimeResponse;
+}
+
+export interface Metric {
+  add(value: number): void;
+}
+
+export declare class Rate implements Metric {
+  constructor(name: string, isTime?: boolean);
+  add(value: number): void;
+}
+
+export declare class Trend implements Metric {
+  constructor(name: string, isTime?: boolean);
+  add(value: number): void;
+}
+
+export interface HttpClientConfig<TSetup = unknown> {
+  baseUrl: string;
+  defaultHeaders?: RuntimeHeaders;
+  getHeaders?: (setupData?: TSetup | null) => RuntimeHeaders | void;
+  getRawHeaders?: (setupData?: TSetup | null) => RuntimeHeaders | void;
+  routeHeaders?: RuntimeHeaders;
+}
+
+export interface HttpClient<TSetup = unknown> {
+  delete(path: string, setupData?: TSetup | null, extraHeaders?: RuntimeHeaders): RuntimeResponse;
+  get(path: string, setupData?: TSetup | null, extraHeaders?: RuntimeHeaders): RuntimeResponse;
+  getWithHeaders(
+    path: string,
+    setupData?: TSetup | null,
+    extraHeaders?: RuntimeHeaders
+  ): RuntimeResponse;
+  patch(
+    path: string,
+    setupData?: TSetup | null,
+    body?: unknown,
+    extraHeaders?: RuntimeHeaders
+  ): RuntimeResponse;
+  post(
+    path: string,
+    setupData?: TSetup | null,
+    body?: unknown,
+    extraHeaders?: RuntimeHeaders
+  ): RuntimeResponse;
+  put(
+    path: string,
+    setupData?: TSetup | null,
+    body?: unknown,
+    extraHeaders?: RuntimeHeaders
+  ): RuntimeResponse;
+  raw(
+    method: RuntimeMethod,
+    path: string,
+    body?: unknown,
+    extraHeaders?: RuntimeHeaders
+  ): RuntimeResponse;
+  rawDelete(path: string, extraHeaders?: RuntimeHeaders): RuntimeResponse;
+  rawGet(path: string, extraHeaders?: RuntimeHeaders): RuntimeResponse;
+  rawPatch(path: string, body?: unknown, extraHeaders?: RuntimeHeaders): RuntimeResponse;
+  rawPost(path: string, body?: unknown, extraHeaders?: RuntimeHeaders): RuntimeResponse;
+  rawPut(path: string, body?: unknown, extraHeaders?: RuntimeHeaders): RuntimeResponse;
+  request(
+    method: RuntimeMethod,
+    path: string,
+    setupData?: TSetup | null,
+    body?: unknown,
+    extraHeaders?: RuntimeHeaders
+  ): RuntimeResponse;
+}
+
+export declare const check: <T>(
+  value: T,
+  checks: Record<string, (value: T) => boolean>
+) => boolean;
+export declare const fail: (message: string) => never;
+export declare const group: (name: string, fn: () => void) => void;
+export declare const sleep: (seconds?: number) => void;
+
+export declare const http: RuntimeHttpClient;
+
+export declare function file(data: unknown, filename?: string, contentType?: string): unknown;
+export declare function json<T = unknown>(response: Pick<RuntimeResponse, "body">): T;
+export declare function contains<T extends Record<string, unknown>>(
+  rows: T[],
+  field: keyof T | string,
+  value: unknown
+): boolean;
+export declare function allMatch<T>(
+  rows: T[],
+  predicate: (row: T) => boolean
+): boolean;
+export declare function isSorted<T extends Record<string, unknown>>(
+  rows: T[],
+  field: keyof T | string,
+  direction?: "asc" | "desc"
+): boolean;
+
+export declare function singleIterationOptions(overrides?: RuntimeOptions): RuntimeOptions;
+export declare const defaultOptions: RuntimeOptions;
+export declare const httpDefaultOptions: RuntimeOptions;
+
+export declare function createDalContext(db?: RuntimeDb): RuntimeDalContext;
+export declare function openDb(): RuntimeDb;
+export declare function truncate(db: RuntimeDb, ...tables: string[]): void;
+
+export declare function getEnv(): RuntimeEnv;
+export declare function createHttpClient<TSetup = unknown>(
+  config: HttpClientConfig<TSetup>
+): HttpClient<TSetup>;
+export declare function makeReq<TSetup = unknown>(
+  baseUrl: string,
+  routeHeaders?: RuntimeHeaders,
+  getHeaders?: (setupData?: TSetup | null) => RuntimeHeaders | void
+): HttpClient<TSetup>["request"];
+export declare function makeRawReq(
+  baseUrl: string,
+  routeHeaders?: RuntimeHeaders,
+  getRawHeaders?: (setupData?: never) => RuntimeHeaders | void
+): HttpClient["raw"];
+export declare function makeGetWithHeaders<TSetup = unknown>(
+  baseUrl: string,
+  routeHeaders?: RuntimeHeaders,
+  getHeaders?: (setupData?: TSetup | null) => RuntimeHeaders | void
+): HttpClient<TSetup>["getWithHeaders"];
+
+declare global {
+  const __ENV: Record<string, string | undefined>;
+}
+
+export {};

package/package.json

@@ -1,11 +1,18 @@
 {
   "name": "@elench/testkit",
-  "version": "0.1.25",
+  "version": "0.1.26",
   "description": "CLI for discovering and running local HTTP, DAL, and Playwright test suites",
   "type": "module",
+  "types": "./lib/index.d.ts",
   "exports": {
-    ".": "./lib/index.mjs",
-    "./runtime": "./lib/runtime/index.mjs",
+    ".": {
+      "types": "./lib/index.d.ts",
+      "default": "./lib/index.mjs"
+    },
+    "./runtime": {
+      "types": "./lib/runtime/index.d.ts",
+      "default": "./lib/runtime/index.mjs"
+    },
     "./package.json": "./package.json"
   },
   "bin": {