@ripplo/testing 0.3.4 → 0.3.6

package/README.md

@@ -518,9 +518,88 @@ export const PUT = createNextHandler({
 
 The handler dispatches on the last URL segment (`execute-preconditions`, `execute-observer`, `teardown-preconditions`) and returns 404 for anything else. It depends only on the Web `Request` / `Response` types, so it runs on both the Node and Edge runtimes — no `next` import required.
 
+### Hono
+
+```ts
+import { Hono } from "hono";
+import { createHonoHandler } from "@ripplo/testing/hono";
+import { engine } from "./test/engine.js";
+
+const app = new Hono();
+app.route(
+  "/ripplo",
+  createHonoHandler({
+    enabled: process.env.ENABLE_RIPPLO_TESTING === "true",
+    engine,
+  }),
+);
+```
+
+The Hono adapter uses the Web `Request` / `Response` standard and runs on Node, Bun, Deno, and Cloudflare Workers.
+
+### Koa
+
+```ts
+import Koa from "koa";
+import mount from "koa-mount";
+import { createKoaHandler } from "@ripplo/testing/koa";
+import { engine } from "./test/engine.js";
+
+const app = new Koa();
+app.use(
+  mount(
+    "/ripplo",
+    createKoaHandler({
+      enabled: process.env.ENABLE_RIPPLO_TESTING === "true",
+      engine,
+    }),
+  ),
+);
+```
+
+The Koa adapter reads the raw request body itself — do not mount a body-parser in front of it. Mount it at any prefix with `koa-mount`.
+
+### NestJS
+
+```ts
+import { Module } from "@nestjs/common";
+import { RipploTestingModule } from "@ripplo/testing/nestjs";
+import { engine } from "./test/engine.js";
+
+@Module({
+  imports: [
+    RipploTestingModule.forRoot({
+      enabled: process.env.ENABLE_RIPPLO_TESTING === "true",
+      engine,
+      path: "ripplo",
+    }),
+  ],
+})
+export class AppModule {}
+```
+
+Requires the Express platform adapter (`@nestjs/platform-express`) and `reflect-metadata` at the entry point. `path` defaults to `"ripplo"`.
+
+### Elysia
+
+```ts
+import { Elysia } from "elysia";
+import { createElysiaHandler } from "@ripplo/testing/elysia";
+import { engine } from "./test/engine.js";
+
+const app = new Elysia().group("/ripplo", (app) =>
+  app.use(
+    createElysiaHandler({
+      enabled: process.env.ENABLE_RIPPLO_TESTING === "true",
+      engine,
+    }),
+  ),
+);
+```
+
 ### Custom integration (raw engine)
 
-If your framework isn't covered above (Hono, Koa, Bun, Deno, Cloudflare Workers, etc.), use the engine directly. The adapters are thin wrappers over the same API.
+If your framework isn't covered above, use the engine directly. The adapters are thin wrappers over the same API.
 
 ```ts
 import { buildSetCookieHeader, serializeCookie, verifyWebhookSignature } from "@ripplo/testing";

package/dist/actions.js

@@ -2,11 +2,12 @@ import {
   readVariable,
   toSpecLocator,
   toStringValueRef
-} from "./chunk-P67G7RA7.js";
+} from "./chunk-YJ4KB56W.js";
+import "./chunk-DCJBLS2U.js";
 import {
   createStep
 } from "./chunk-MGATMMCZ.js";
-import "./chunk-DCJBLS2U.js";
+import "./chunk-4MGIQFAJ.js";
 
 // src/steps/actions.ts
 function navigate(url) {

package/dist/assert.js

@@ -1,15 +1,16 @@
-import {
-  toSpecLocator,
-  toStringValueRef
-} from "./chunk-P67G7RA7.js";
 import {
   readObserverBudget,
   readObserverName
-} from "./chunk-55HIO5LW.js";
+} from "./chunk-XBYG5NBY.js";
+import {
+  toSpecLocator,
+  toStringValueRef
+} from "./chunk-YJ4KB56W.js";
+import "./chunk-DCJBLS2U.js";
 import {
   createStep
 } from "./chunk-MGATMMCZ.js";
-import "./chunk-DCJBLS2U.js";
+import "./chunk-4MGIQFAJ.js";
 
 // src/steps/assert.ts
 var assert = {

package/dist/chunk-4MGIQFAJ.js

@@ -0,0 +1,16 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+var __decorateParam = (index, decorator) => (target, key) => decorator(target, key, index);
+
+export {
+  __decorateClass,
+  __decorateParam
+};

package/dist/{chunk-55HIO5LW.js → chunk-XBYG5NBY.js}

@@ -1,28 +1,28 @@
 // src/types.ts
 import { z } from "zod";
 var DEFAULT_WATCH_PATHS = [
-  "src/**",
-  "app/**",
-  "apps/**",
-  "pages/**",
-  "routes/**",
-  "components/**",
-  "server/**",
-  "api/**",
-  "backend/**",
-  "features/**",
-  "modules/**",
-  "views/**",
-  "ui/**",
-  "hooks/**",
-  "contexts/**",
-  "providers/**",
-  "controllers/**",
-  "handlers/**",
-  "resolvers/**",
-  "services/**",
-  "middleware/**",
-  "lib/**"
+  "**/src/**",
+  "**/app/**",
+  "**/apps/**",
+  "**/pages/**",
+  "**/routes/**",
+  "**/components/**",
+  "**/server/**",
+  "**/api/**",
+  "**/backend/**",
+  "**/features/**",
+  "**/modules/**",
+  "**/views/**",
+  "**/ui/**",
+  "**/hooks/**",
+  "**/contexts/**",
+  "**/providers/**",
+  "**/controllers/**",
+  "**/handlers/**",
+  "**/resolvers/**",
+  "**/services/**",
+  "**/middleware/**",
+  "**/lib/**"
 ];
 var DEFAULT_IGNORE_PATHS = [
   "**/*.gen.*",

package/dist/compiler.js

@@ -2,6 +2,7 @@ import {
   compile
 } from "./chunk-KNF4K4JH.js";
 import "./chunk-MGATMMCZ.js";
+import "./chunk-4MGIQFAJ.js";
 export {
   compile
 };

package/dist/control.js

@@ -4,9 +4,10 @@ import {
   readVariable,
   toStringValueRef,
   variable
-} from "./chunk-P67G7RA7.js";
-import "./chunk-MGATMMCZ.js";
+} from "./chunk-YJ4KB56W.js";
 import "./chunk-DCJBLS2U.js";
+import "./chunk-MGATMMCZ.js";
+import "./chunk-4MGIQFAJ.js";
 export {
   extract,
   isVariable,

package/dist/elysia.d.ts

@@ -0,0 +1,79 @@
+import { Elysia } from 'elysia';
+import { R as RipploEngine } from './engine-CZ4F_Csu.js';
+import './builder-BGr5JvrY.js';
+import './types-Degkxs1f.js';
+import 'zod';
+import './step-De52hTLd.js';
+import '@ripplo/spec';
+
+interface CreateElysiaHandlerParams {
+    readonly enabled: boolean;
+    readonly engine: RipploEngine;
+}
+declare function createElysiaHandler(params: CreateElysiaHandlerParams): ReturnType<typeof build>;
+declare function build({ enabled, engine }: CreateElysiaHandlerParams): Elysia<"", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {
+    "execute-preconditions": {
+        put: {
+            body: unknown;
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                200: Response;
+            };
+        };
+    };
+} & {
+    "execute-observer": {
+        put: {
+            body: unknown;
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                200: Response;
+            };
+        };
+    };
+} & {
+    "teardown-preconditions": {
+        put: {
+            body: unknown;
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                200: Response;
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;
+
+export { type CreateElysiaHandlerParams, createElysiaHandler };

package/dist/elysia.js

@@ -0,0 +1,120 @@
+import {
+  batchRequestSchema,
+  buildSetCookieHeader,
+  observerRequestSchema,
+  serializeCookie,
+  teardownRequestSchema,
+  verifyWebhookSignature
+} from "./chunk-TO3T2D2Y.js";
+import "./chunk-4MGIQFAJ.js";
+
+// src/adapters/elysia.ts
+import { Elysia } from "elysia";
+function createElysiaHandler(params) {
+  return build(params);
+}
+function build({ enabled, engine }) {
+  const app = new Elysia();
+  if (!enabled) {
+    return app.put("/execute-preconditions", () => notFoundResponse()).put("/execute-observer", () => notFoundResponse()).put("/teardown-preconditions", () => notFoundResponse());
+  }
+  const webhookSecret = engine.getConfig().webhookSecret;
+  return app.put("/execute-preconditions", async ({ request }) => {
+    const gate = await verifyAndReadBody(request, webhookSecret);
+    if ("response" in gate) {
+      return gate.response;
+    }
+    const parsed = parseWith(gate.body, batchRequestSchema);
+    if (parsed == null) {
+      return jsonResponse({ error: "Invalid request body", success: false }, 400);
+    }
+    const host = request.headers.get("host");
+    if (host == null || host.length === 0) {
+      return jsonResponse({ error: "Missing host header", success: false }, 400);
+    }
+    const proto = request.headers.get("x-forwarded-proto") ?? "http";
+    const appUrl = `${proto}://${host}`;
+    const result = await engine.executePreconditions(parsed.preconditions, { appUrl });
+    const headers = new Headers({ "content-type": "application/json" });
+    result.cookies.forEach((cookie) => {
+      headers.append("Set-Cookie", buildSetCookieHeader(serializeCookie(cookie)));
+    });
+    return new Response(
+      JSON.stringify({
+        data: result.data,
+        error: result.error,
+        executed: result.executed,
+        runId: result.runId,
+        success: result.success
+      }),
+      { headers, status: 200 }
+    );
+  }).put("/execute-observer", async ({ request }) => {
+    const gate = await verifyAndReadBody(request, webhookSecret);
+    if ("response" in gate) {
+      return gate.response;
+    }
+    const parsed = parseWith(gate.body, observerRequestSchema);
+    if (parsed == null) {
+      return jsonResponse({ error: "Invalid request body", success: false }, 400);
+    }
+    const result = await engine.executeObserver(parsed.observer, parsed.params);
+    return jsonResponse(
+      { error: result.error, outcome: result.outcome, success: result.success },
+      200
+    );
+  }).put("/teardown-preconditions", async ({ request }) => {
+    const gate = await verifyAndReadBody(request, webhookSecret);
+    if ("response" in gate) {
+      return gate.response;
+    }
+    const parsed = parseWith(gate.body, teardownRequestSchema);
+    if (parsed == null) {
+      return jsonResponse({ error: "Invalid request body", success: false }, 400);
+    }
+    await engine.teardown(parsed.preconditions, parsed.data);
+    return jsonResponse({ success: true }, 200);
+  });
+}
+async function verifyAndReadBody(req, webhookSecret) {
+  if (webhookSecret.length === 0) {
+    return { response: jsonResponse({ error: "Webhook secret not configured" }, 403) };
+  }
+  const body = await req.text();
+  const headers = {
+    "webhook-id": req.headers.get("webhook-id") ?? void 0,
+    "webhook-signature": req.headers.get("webhook-signature") ?? void 0,
+    "webhook-timestamp": req.headers.get("webhook-timestamp") ?? void 0
+  };
+  if (!verifyWebhookSignature(body, headers, webhookSecret)) {
+    return { response: jsonResponse({ error: "Invalid webhook signature" }, 401) };
+  }
+  return { body };
+}
+function parseWith(body, schema) {
+  const json = tryParseJson(body);
+  if (json == null) {
+    return null;
+  }
+  const result = schema.safeParse(json);
+  return result.success ? result.data : null;
+}
+function tryParseJson(body) {
+  try {
+    return JSON.parse(body);
+  } catch {
+    return null;
+  }
+}
+function jsonResponse(payload, status) {
+  return new Response(JSON.stringify(payload), {
+    headers: { "content-type": "application/json" },
+    status
+  });
+}
+function notFoundResponse() {
+  return jsonResponse({ error: "Not found" }, 404);
+}
+export {
+  createElysiaHandler
+};

package/dist/{engine-Bo5nkg02.d.ts → engine-CZ4F_Csu.d.ts}

@@ -17,7 +17,7 @@ interface ObserverExecutionResult {
     readonly outcome: ObserverOutcome | undefined;
     readonly success: boolean;
 }
-interface PreconditionEngine {
+interface RipploEngine {
     readonly executeObserver: (name: string, params: Record<string, string>) => Promise<ObserverExecutionResult>;
     readonly executePreconditions: (names: ReadonlyArray<string>, options?: ExecuteBatchOptions) => Promise<EngineResult>;
     readonly getConfig: () => DslConfig;
@@ -42,6 +42,6 @@ interface EngineImpls<P extends PreconditionRegistry, O extends ObserverRegistry
         readonly [K in keyof P]: NotImplemented | PreconditionImplFor<P[K]>;
     };
 }
-declare function createEngine<P extends PreconditionRegistry, O extends ObserverRegistry>(ripplo: RipploInstance<P, O>, impls: EngineImpls<P, O>): PreconditionEngine;
+declare function createEngine<P extends PreconditionRegistry, O extends ObserverRegistry>(ripplo: RipploInstance<P, O>, impls: EngineImpls<P, O>): RipploEngine;
 
-export { type EngineImpls as E, type NotImplemented as N, type ObserverImplFnFor as O, type PreconditionEngine as P, type EngineResult as a, type ExecuteBatchOptions as b, type PreconditionImplFor as c, createEngine as d, notImplemented as n };
+export { type EngineImpls as E, type NotImplemented as N, type ObserverImplFnFor as O, type PreconditionImplFor as P, type RipploEngine as R, type EngineResult as a, type ExecuteBatchOptions as b, createEngine as c, notImplemented as n };

package/dist/express.d.ts

@@ -1,5 +1,5 @@
 import { Router } from 'express';
-import { P as PreconditionEngine } from './engine-Bo5nkg02.js';
+import { R as RipploEngine } from './engine-CZ4F_Csu.js';
 import './builder-BGr5JvrY.js';
 import './types-Degkxs1f.js';
 import 'zod';
@@ -8,7 +8,7 @@ import '@ripplo/spec';
 
 interface CreateExpressHandlerParams {
     readonly enabled: boolean;
-    readonly engine: PreconditionEngine;
+    readonly engine: RipploEngine;
 }
 declare function createExpressHandler({ enabled, engine }: CreateExpressHandlerParams): Router;
 

package/dist/express.js

@@ -5,6 +5,7 @@ import {
   teardownRequestSchema,
   verifyWebhookSignature
 } from "./chunk-TO3T2D2Y.js";
+import "./chunk-4MGIQFAJ.js";
 
 // src/adapters/express.ts
 import { Router, json } from "express";

package/dist/fastify.d.ts

@@ -1,5 +1,5 @@
 import { FastifyInstance } from 'fastify';
-import { P as PreconditionEngine } from './engine-Bo5nkg02.js';
+import { R as RipploEngine } from './engine-CZ4F_Csu.js';
 import './builder-BGr5JvrY.js';
 import './types-Degkxs1f.js';
 import 'zod';
@@ -8,7 +8,7 @@ import '@ripplo/spec';
 
 interface RegisterFastifyHandlerParams {
     readonly enabled: boolean;
-    readonly engine: PreconditionEngine;
+    readonly engine: RipploEngine;
 }
 declare function registerFastifyHandler({ enabled, engine, }: RegisterFastifyHandlerParams): (fastify: FastifyInstance) => Promise<void>;
 

package/dist/fastify.js

@@ -6,6 +6,7 @@ import {
   teardownRequestSchema,
   verifyWebhookSignature
 } from "./chunk-TO3T2D2Y.js";
+import "./chunk-4MGIQFAJ.js";
 
 // src/adapters/fastify.ts
 function registerFastifyHandler({

package/dist/hono.d.ts

@@ -0,0 +1,20 @@
+import { Hono } from 'hono';
+import { R as RipploEngine } from './engine-CZ4F_Csu.js';
+import './builder-BGr5JvrY.js';
+import './types-Degkxs1f.js';
+import 'zod';
+import './step-De52hTLd.js';
+import '@ripplo/spec';
+
+interface CreateHonoHandlerParams {
+    readonly enabled: boolean;
+    readonly engine: RipploEngine;
+}
+interface HonoEnv {
+    Variables: {
+        rawBody: string;
+    };
+}
+declare function createHonoHandler({ enabled, engine }: CreateHonoHandlerParams): Hono<HonoEnv>;
+
+export { type CreateHonoHandlerParams, createHonoHandler };

package/dist/hono.js

@@ -0,0 +1,95 @@
+import {
+  batchRequestSchema,
+  buildSetCookieHeader,
+  observerRequestSchema,
+  serializeCookie,
+  teardownRequestSchema,
+  verifyWebhookSignature
+} from "./chunk-TO3T2D2Y.js";
+import "./chunk-4MGIQFAJ.js";
+
+// src/adapters/hono.ts
+import { Hono } from "hono";
+function createHonoHandler({ enabled, engine }) {
+  const app = new Hono();
+  if (!enabled) {
+    return app;
+  }
+  const webhookSecret = engine.getConfig().webhookSecret;
+  app.use("*", createWebhookMiddleware(webhookSecret));
+  app.put("/execute-preconditions", async (c) => {
+    const body = tryParseJson(c.get("rawBody"));
+    const parsed = body == null ? null : batchRequestSchema.safeParse(body);
+    if (parsed == null || !parsed.success) {
+      return c.json({ error: "Invalid request body", success: false }, 400);
+    }
+    const host = c.req.header("host");
+    if (host == null || host.length === 0) {
+      return c.json({ error: "Missing host header", success: false }, 400);
+    }
+    const proto = c.req.header("x-forwarded-proto") ?? "http";
+    const appUrl = `${proto}://${host}`;
+    const result = await engine.executePreconditions(parsed.data.preconditions, { appUrl });
+    result.cookies.forEach((cookie) => {
+      c.header("Set-Cookie", buildSetCookieHeader(serializeCookie(cookie)), { append: true });
+    });
+    return c.json({
+      data: result.data,
+      error: result.error,
+      executed: result.executed,
+      runId: result.runId,
+      success: result.success
+    });
+  });
+  app.put("/execute-observer", async (c) => {
+    const body = tryParseJson(c.get("rawBody"));
+    const parsed = body == null ? null : observerRequestSchema.safeParse(body);
+    if (parsed == null || !parsed.success) {
+      return c.json({ error: "Invalid request body", success: false }, 400);
+    }
+    const result = await engine.executeObserver(parsed.data.observer, parsed.data.params);
+    return c.json({
+      error: result.error,
+      outcome: result.outcome,
+      success: result.success
+    });
+  });
+  app.put("/teardown-preconditions", async (c) => {
+    const body = tryParseJson(c.get("rawBody"));
+    const parsed = body == null ? null : teardownRequestSchema.safeParse(body);
+    if (parsed == null || !parsed.success) {
+      return c.json({ error: "Invalid request body", success: false }, 400);
+    }
+    await engine.teardown(parsed.data.preconditions, parsed.data.data);
+    return c.json({ success: true });
+  });
+  return app;
+}
+function createWebhookMiddleware(webhookSecret) {
+  return async (c, next) => {
+    if (webhookSecret.length === 0) {
+      return c.json({ error: "Webhook secret not configured" }, 403);
+    }
+    const body = await c.req.text();
+    const headers = {
+      "webhook-id": c.req.header("webhook-id"),
+      "webhook-signature": c.req.header("webhook-signature"),
+      "webhook-timestamp": c.req.header("webhook-timestamp")
+    };
+    if (!verifyWebhookSignature(body, headers, webhookSecret)) {
+      return c.json({ error: "Invalid webhook signature" }, 401);
+    }
+    c.set("rawBody", body);
+    await next();
+  };
+}
+function tryParseJson(body) {
+  try {
+    return JSON.parse(body);
+  } catch {
+    return null;
+  }
+}
+export {
+  createHonoHandler
+};

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 export { O as ObserverImplFn, a as ObserverRegistry, P as PreconditionImpl, b as PreconditionRecord, c as PreconditionRegistry, R as ResolveDeps, d as RipploBuilder, e as RipploInstance, f as RipploRegistries, g as createRipplo, o as observer, p as precondition, t as test } from './builder-BGr5JvrY.js';
 import { CompileResult } from './compiler.js';
 export { CompiledTest, compile } from './compiler.js';
-export { E as EngineImpls, a as EngineResult, b as ExecuteBatchOptions, N as NotImplemented, O as ObserverImplFnFor, P as PreconditionEngine, c as PreconditionImplFor, d as createEngine, n as notImplemented } from './engine-Bo5nkg02.js';
+export { E as EngineImpls, a as EngineResult, b as ExecuteBatchOptions, N as NotImplemented, O as ObserverImplFnFor, P as PreconditionImplFor, R as RipploEngine, c as createEngine, n as notImplemented } from './engine-CZ4F_Csu.js';
 import { C as CookieEntry } from './types-Degkxs1f.js';
 export { c as CookieOptions, D as DEFAULT_IGNORE_PATHS, d as DEFAULT_WATCH_PATHS, e as DslConfig, f as ObserverContext, g as ObserverDefinition, O as ObserverHandle, a as ObserverInput, h as ObserverOutcome, P as Precondition, i as PreconditionDeps, S as SetupContext, T as TeardownContext, j as TestDefinition } from './types-Degkxs1f.js';
 export { D as DslNodeInput } from './step-De52hTLd.js';

package/dist/index.js

@@ -12,7 +12,7 @@ import {
   readPreconditionName,
   readTestValue,
   userDslConfigSchema
-} from "./chunk-55HIO5LW.js";
+} from "./chunk-XBYG5NBY.js";
 import {
   compile
 } from "./chunk-KNF4K4JH.js";
@@ -22,6 +22,7 @@ import {
   serializeCookie,
   verifyWebhookSignature
 } from "./chunk-TO3T2D2Y.js";
+import "./chunk-4MGIQFAJ.js";
 
 // src/observer.ts
 function createPassOutcome() {

package/dist/koa.d.ts

@@ -0,0 +1,15 @@
+import { Middleware } from 'koa';
+import { R as RipploEngine } from './engine-CZ4F_Csu.js';
+import './builder-BGr5JvrY.js';
+import './types-Degkxs1f.js';
+import 'zod';
+import './step-De52hTLd.js';
+import '@ripplo/spec';
+
+interface CreateKoaHandlerParams {
+    readonly enabled: boolean;
+    readonly engine: RipploEngine;
+}
+declare function createKoaHandler({ enabled, engine }: CreateKoaHandlerParams): Middleware;
+
+export { type CreateKoaHandlerParams, createKoaHandler };

package/dist/koa.js

@@ -0,0 +1,142 @@
+import {
+  batchRequestSchema,
+  buildSetCookieHeader,
+  observerRequestSchema,
+  serializeCookie,
+  teardownRequestSchema,
+  verifyWebhookSignature
+} from "./chunk-TO3T2D2Y.js";
+import "./chunk-4MGIQFAJ.js";
+
+// src/adapters/koa.ts
+function createKoaHandler({ enabled, engine }) {
+  if (!enabled) {
+    return async (ctx, next) => {
+      await next();
+    };
+  }
+  const webhookSecret = engine.getConfig().webhookSecret;
+  return async (ctx, next) => {
+    if (ctx.method !== "PUT") {
+      await next();
+      return;
+    }
+    const action = lastPathSegment(ctx.path);
+    if (action == null) {
+      await next();
+      return;
+    }
+    if (webhookSecret.length === 0) {
+      ctx.status = 403;
+      ctx.body = { error: "Webhook secret not configured" };
+      return;
+    }
+    const body = await readBody(ctx);
+    const headers = {
+      "webhook-id": headerString(ctx.get("webhook-id")),
+      "webhook-signature": headerString(ctx.get("webhook-signature")),
+      "webhook-timestamp": headerString(ctx.get("webhook-timestamp"))
+    };
+    if (!verifyWebhookSignature(body, headers, webhookSecret)) {
+      ctx.status = 401;
+      ctx.body = { error: "Invalid webhook signature" };
+      return;
+    }
+    await dispatchAction({ action, body, ctx, engine });
+  };
+}
+async function dispatchAction({ action, body, ctx, engine }) {
+  if (action === "execute-preconditions") {
+    await handleExecutePreconditions({ body, ctx, engine });
+    return;
+  }
+  if (action === "execute-observer") {
+    await handleExecuteObserver({ body, ctx, engine });
+    return;
+  }
+  await handleTeardown({ body, ctx, engine });
+}
+async function handleExecutePreconditions({ body, ctx, engine }) {
+  const json = tryParseJson(body);
+  const parsed = json == null ? null : batchRequestSchema.safeParse(json);
+  if (parsed == null || !parsed.success) {
+    ctx.status = 400;
+    ctx.body = { error: "Invalid request body", success: false };
+    return;
+  }
+  const host = ctx.get("host");
+  if (host.length === 0) {
+    ctx.status = 400;
+    ctx.body = { error: "Missing host header", success: false };
+    return;
+  }
+  const proto = ctx.get("x-forwarded-proto").length > 0 ? ctx.get("x-forwarded-proto") : "http";
+  const appUrl = `${proto}://${host}`;
+  const result = await engine.executePreconditions(parsed.data.preconditions, { appUrl });
+  result.cookies.forEach((cookie) => {
+    ctx.append("Set-Cookie", buildSetCookieHeader(serializeCookie(cookie)));
+  });
+  ctx.status = 200;
+  ctx.body = {
+    data: result.data,
+    error: result.error,
+    executed: result.executed,
+    runId: result.runId,
+    success: result.success
+  };
+}
+async function handleExecuteObserver({ body, ctx, engine }) {
+  const json = tryParseJson(body);
+  const parsed = json == null ? null : observerRequestSchema.safeParse(json);
+  if (parsed == null || !parsed.success) {
+    ctx.status = 400;
+    ctx.body = { error: "Invalid request body", success: false };
+    return;
+  }
+  const result = await engine.executeObserver(parsed.data.observer, parsed.data.params);
+  ctx.status = 200;
+  ctx.body = { error: result.error, outcome: result.outcome, success: result.success };
+}
+async function handleTeardown({ body, ctx, engine }) {
+  const json = tryParseJson(body);
+  const parsed = json == null ? null : teardownRequestSchema.safeParse(json);
+  if (parsed == null || !parsed.success) {
+    ctx.status = 400;
+    ctx.body = { error: "Invalid request body", success: false };
+    return;
+  }
+  await engine.teardown(parsed.data.preconditions, parsed.data.data);
+  ctx.status = 200;
+  ctx.body = { success: true };
+}
+function lastPathSegment(path) {
+  const segments = path.split("/").filter((s) => s.length > 0);
+  const last = segments.at(-1);
+  if (last === "execute-preconditions" || last === "execute-observer" || last === "teardown-preconditions") {
+    return last;
+  }
+  return null;
+}
+async function readBody(ctx) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    ctx.req.on("data", (chunk) => chunks.push(chunk));
+    ctx.req.on("end", () => {
+      resolve(Buffer.concat(chunks).toString("utf8"));
+    });
+    ctx.req.on("error", reject);
+  });
+}
+function headerString(value) {
+  return value.length > 0 ? value : void 0;
+}
+function tryParseJson(body) {
+  try {
+    return JSON.parse(body);
+  } catch {
+    return null;
+  }
+}
+export {
+  createKoaHandler
+};

package/dist/locators.js

@@ -3,6 +3,7 @@ import {
   role,
   testId
 } from "./chunk-DCJBLS2U.js";
+import "./chunk-4MGIQFAJ.js";
 export {
   readLocator,
   role,

package/dist/lockfile.js

@@ -1,3 +1,5 @@
+import "./chunk-4MGIQFAJ.js";
+
 // src/lockfile.ts
 import fs from "fs/promises";
 import path from "path";

package/dist/nestjs.d.ts

@@ -0,0 +1,18 @@
+import { DynamicModule } from '@nestjs/common';
+import { R as RipploEngine } from './engine-CZ4F_Csu.js';
+import './builder-BGr5JvrY.js';
+import './types-Degkxs1f.js';
+import 'zod';
+import './step-De52hTLd.js';
+import '@ripplo/spec';
+
+interface RipploTestingModuleOptions {
+    readonly enabled: boolean;
+    readonly engine: RipploEngine;
+    readonly path: string | undefined;
+}
+declare class RipploTestingModule {
+    static forRoot(options: RipploTestingModuleOptions): DynamicModule;
+}
+
+export { RipploTestingModule, type RipploTestingModuleOptions };

package/dist/nestjs.js

@@ -0,0 +1,143 @@
+import {
+  batchRequestSchema,
+  buildSetCookieHeader,
+  observerRequestSchema,
+  serializeCookie,
+  teardownRequestSchema,
+  verifyWebhookSignature
+} from "./chunk-TO3T2D2Y.js";
+import {
+  __decorateClass,
+  __decorateParam
+} from "./chunk-4MGIQFAJ.js";
+
+// src/adapters/nestjs.ts
+import { Controller, Inject, Module, Put, Req, Res } from "@nestjs/common";
+var RIPPLO_OPTIONS = "RIPPLO_TESTING_OPTIONS";
+var RipploTestingModule = class {
+  static forRoot(options) {
+    const path = options.path ?? "ripplo";
+    const controller = createController(path);
+    return {
+      controllers: [controller],
+      module: RipploTestingModule,
+      providers: [
+        {
+          provide: RIPPLO_OPTIONS,
+          useValue: { enabled: options.enabled, engine: options.engine }
+        }
+      ]
+    };
+  }
+};
+RipploTestingModule = __decorateClass([
+  Module({})
+], RipploTestingModule);
+function createController(path) {
+  let RipploController = class {
+    constructor(opts) {
+      this.opts = opts;
+    }
+    async executePreconditions(req, res) {
+      if (!guard(req, res, this.opts)) {
+        return;
+      }
+      const parsed = batchRequestSchema.safeParse(req.body);
+      if (!parsed.success) {
+        res.status(400).json({ error: "Invalid request body", success: false });
+        return;
+      }
+      const host = req.get("host") ?? "";
+      const proto = req.get("x-forwarded-proto") ?? req.protocol;
+      const appUrl = `${proto}://${host}`;
+      const result = await this.opts.engine.executePreconditions(parsed.data.preconditions, {
+        appUrl
+      });
+      result.cookies.forEach((cookie) => {
+        res.append("Set-Cookie", buildSetCookieHeader(serializeCookie(cookie)));
+      });
+      res.status(200).json({
+        data: result.data,
+        error: result.error,
+        executed: result.executed,
+        runId: result.runId,
+        success: result.success
+      });
+    }
+    async executeObserver(req, res) {
+      if (!guard(req, res, this.opts)) {
+        return;
+      }
+      const parsed = observerRequestSchema.safeParse(req.body);
+      if (!parsed.success) {
+        res.status(400).json({ error: "Invalid request body", success: false });
+        return;
+      }
+      const result = await this.opts.engine.executeObserver(
+        parsed.data.observer,
+        parsed.data.params
+      );
+      res.status(200).json({ error: result.error, outcome: result.outcome, success: result.success });
+    }
+    async teardown(req, res) {
+      if (!guard(req, res, this.opts)) {
+        return;
+      }
+      const parsed = teardownRequestSchema.safeParse(req.body);
+      if (!parsed.success) {
+        res.status(400).json({ error: "Invalid request body", success: false });
+        return;
+      }
+      await this.opts.engine.teardown(parsed.data.preconditions, parsed.data.data);
+      res.status(200).json({ success: true });
+    }
+  };
+  __decorateClass([
+    Put("execute-preconditions"),
+    __decorateParam(0, Req()),
+    __decorateParam(1, Res())
+  ], RipploController.prototype, "executePreconditions", 1);
+  __decorateClass([
+    Put("execute-observer"),
+    __decorateParam(0, Req()),
+    __decorateParam(1, Res())
+  ], RipploController.prototype, "executeObserver", 1);
+  __decorateClass([
+    Put("teardown-preconditions"),
+    __decorateParam(0, Req()),
+    __decorateParam(1, Res())
+  ], RipploController.prototype, "teardown", 1);
+  RipploController = __decorateClass([
+    Controller(path),
+    __decorateParam(0, Inject(RIPPLO_OPTIONS))
+  ], RipploController);
+  return RipploController;
+}
+function guard(req, res, opts) {
+  if (!opts.enabled) {
+    res.status(404).json({ error: "Not found" });
+    return false;
+  }
+  const webhookSecret = opts.engine.getConfig().webhookSecret;
+  if (webhookSecret.length === 0) {
+    res.status(403).json({ error: "Webhook secret not configured" });
+    return false;
+  }
+  const payload = JSON.stringify(req.body);
+  const headers = {
+    "webhook-id": headerString(req.get("webhook-id")),
+    "webhook-signature": headerString(req.get("webhook-signature")),
+    "webhook-timestamp": headerString(req.get("webhook-timestamp"))
+  };
+  if (!verifyWebhookSignature(payload, headers, webhookSecret)) {
+    res.status(401).json({ error: "Invalid webhook signature" });
+    return false;
+  }
+  return true;
+}
+function headerString(value) {
+  return value != null && value.length > 0 ? value : void 0;
+}
+export {
+  RipploTestingModule
+};

package/dist/nextjs.d.ts

@@ -1,4 +1,4 @@
-import { P as PreconditionEngine } from './engine-Bo5nkg02.js';
+import { R as RipploEngine } from './engine-CZ4F_Csu.js';
 import './builder-BGr5JvrY.js';
 import './types-Degkxs1f.js';
 import 'zod';
@@ -7,7 +7,7 @@ import '@ripplo/spec';
 
 interface CreateNextHandlerParams {
     readonly enabled: boolean;
-    readonly engine: PreconditionEngine;
+    readonly engine: RipploEngine;
 }
 type NextHandler = (req: Request) => Promise<Response>;
 declare function createNextHandler({ enabled, engine }: CreateNextHandlerParams): NextHandler;

package/dist/nextjs.js

@@ -6,6 +6,7 @@ import {
   teardownRequestSchema,
   verifyWebhookSignature
 } from "./chunk-TO3T2D2Y.js";
+import "./chunk-4MGIQFAJ.js";
 
 // src/adapters/nextjs.ts
 function createNextHandler({ enabled, engine }) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ripplo/testing",
   "description": "TypeScript DSL for defining and running Ripplo e2e workflow tests",
-  "version": "0.3.4",
+  "version": "0.3.6",
   "type": "module",
   "files": [
     "dist"
@@ -42,6 +42,11 @@
       "import": "./dist/lockfile.js",
       "default": "./dist/lockfile.js"
     },
+    "./elysia": {
+      "types": "./dist/elysia.d.ts",
+      "import": "./dist/elysia.js",
+      "default": "./dist/elysia.js"
+    },
     "./express": {
       "types": "./dist/express.d.ts",
       "import": "./dist/express.js",
@@ -52,6 +57,21 @@
       "import": "./dist/fastify.js",
       "default": "./dist/fastify.js"
     },
+    "./hono": {
+      "types": "./dist/hono.d.ts",
+      "import": "./dist/hono.js",
+      "default": "./dist/hono.js"
+    },
+    "./koa": {
+      "types": "./dist/koa.d.ts",
+      "import": "./dist/koa.js",
+      "default": "./dist/koa.js"
+    },
+    "./nestjs": {
+      "types": "./dist/nestjs.d.ts",
+      "import": "./dist/nestjs.js",
+      "default": "./dist/nestjs.js"
+    },
     "./nextjs": {
       "types": "./dist/nextjs.d.ts",
       "import": "./dist/nextjs.js",
@@ -63,31 +83,59 @@
     "zod": "^4.3.6"
   },
   "devDependencies": {
+    "@nestjs/common": "^10.0.0",
+    "@nestjs/core": "^10.0.0",
     "@types/express": "^5.0.2",
+    "@types/koa": "^2.15.0",
     "@types/node": "catalog:",
+    "elysia": "^1.0.0",
     "eslint": "catalog:",
     "express": "^5.1.0",
     "fastify": "^5.3.3",
+    "hono": "^4.0.0",
+    "koa": "^2.15.0",
+    "reflect-metadata": "^0.2.0",
+    "rxjs": "^7.8.0",
     "tsup": "^8.5.1",
     "typescript": "catalog:",
     "vitest": "^4.1.4",
-    "@ripplo/spec": "^0.0.0",
-    "@ripplo/eslint-config": "0.0.0"
+    "@ripplo/eslint-config": "0.0.0",
+    "@ripplo/spec": "^0.0.0"
   },
   "peerDependencies": {
+    "@nestjs/common": "^10.0.0 || ^11.0.0",
+    "@nestjs/core": "^10.0.0 || ^11.0.0",
     "dotenv": "^16.0.0 || ^17.0.0",
+    "elysia": "^1.0.0",
     "express": "^4.0.0 || ^5.0.0",
-    "fastify": "^5.0.0"
+    "fastify": "^5.0.0",
+    "hono": "^4.0.0",
+    "koa": "^2.0.0 || ^3.0.0"
   },
   "peerDependenciesMeta": {
+    "@nestjs/common": {
+      "optional": true
+    },
+    "@nestjs/core": {
+      "optional": true
+    },
     "dotenv": {
       "optional": true
     },
+    "elysia": {
+      "optional": true
+    },
     "express": {
       "optional": true
     },
     "fastify": {
       "optional": true
+    },
+    "hono": {
+      "optional": true
+    },
+    "koa": {
+      "optional": true
     }
   },
   "scripts": {

package/dist/{chunk-P67G7RA7.js → chunk-YJ4KB56W.js}

@@ -1,9 +1,9 @@
-import {
-  createStep
-} from "./chunk-MGATMMCZ.js";
 import {
   readLocator
 } from "./chunk-DCJBLS2U.js";
+import {
+  createStep
+} from "./chunk-MGATMMCZ.js";
 
 // src/steps/to-spec-locator.ts
 function toSpecLocator(loc) {