@ripplo/testing 0.4.8 → 0.5.1

package/README.md

@@ -77,6 +77,17 @@ export const preconditions = { authLoggedIn, dataProject };
 
 `precondition(name)` → `.description()` → `.requires()` (optional) → `.contract<T>()`. Each field in `T` must be a primitive — `string`, `number`, or `boolean` (run-scoped value).
 
+#### Preconditions are create-only
+
+Precondition setups must be **additive**: insert new rows, don't `update` or `delete` existing ones. Concurrent runs share a database, and a `WHERE` clause that looks scoped to the current run can match rows that belong to another run in flight. Even when writes are reliably scoped, mutating a row another precondition produced creates ordering dependencies that break under composition.
+
+If a test needs a non-default state, the precondition that **creates** the underlying row should accept that state as input — don't seed a default and mutate it from a downstream precondition.
+
+Allowed exceptions:
+
+- `upsert` on a row whose primary key makes it a 1:1 settings record for the current run (e.g. a per-`(userId, resourceId)` view). Treat it as create-with-default.
+- Teardown may delete — but only data the precondition itself created.
+
 ### Observers
 
 ```typescript
@@ -278,12 +289,21 @@ import { prisma } from "../lib/prisma.js";
 export const engine = createEngine(ripplo, {
   preconditions: {
     authLoggedIn: {
-      setup: async (ctx) => {
-        // create user, set cookies via ctx.setCookie()
-        return { userId: ctx.uniqueId("user") };
+      // setup receives a *batch* of items — one per concurrent run that requires this precondition.
+      // Issue one bulk write (createMany) and return one result per item, in input order.
+      setup: async (items) => {
+        const seeds = items.map(({ ctx }) => ({
+          id: ctx.uniqueId("user"),
+          email: ctx.uniqueEmail(),
+        }));
+        await prisma.user.createMany({ data: seeds });
+        // each item.ctx.setCookie(...) flows back to that run's browser
+        return seeds.map(({ id }) => ({ userId: id }));
       },
-      teardown: async (ctx) => {
-        // clean up using ctx.data.userId
+      teardown: async (items) => {
+        await prisma.user.deleteMany({
+          where: { id: { in: items.map((it) => it.ctx.data.userId) } },
+        });
       },
     },
     dataProject: notImplemented("awaiting prisma seed helper"), // stub for planning
@@ -302,15 +322,17 @@ export const engine = createEngine(ripplo, {
 });
 ```
 
+`setup` and `teardown` are **batched**: the runtime collects all concurrent runs that need a precondition within a 200ms window and calls the impl once with the full batch. Use `createMany` / `deleteMany` over per-item `create` / `delete` to keep DB load proportional to wall-clock time, not run count. The result array length must equal the input array length and order must be preserved (the engine zips by index back to runs).
+
 ### Setup context
 
-`ctx` passed to each precondition `setup`:
+`item.ctx` available inside each batched setup item:
 
 - `ctx.runId` — unique 12-char id for this run
 - `ctx.fixed<T extends string | number | boolean>(value: T)` — static test value (any primitive)
 - `ctx.uniqueId(prefix)` — `ripplo-test-<prefix>-<runId>`
 - `ctx.uniqueEmail()` — `ripplo-test-<runId>@test.ripplo.ai`
-- `ctx.setCookie(name, value, options?)` — forwarded to the test browser as `Set-Cookie`
+- `ctx.setCookie(name, value, options?)` — applied to the run's browser context before the test starts
 
 Helpers return plain primitives — interpolate, JSON.stringify, or pass through observer params directly. The return type is type-branded, so a hardcoded literal in a `setup` return fails at compile time.
 
@@ -447,10 +469,14 @@ const app = new Elysia().group("/ripplo", (g) => g.use(createElysiaHandler({ ena
 For unsupported frameworks. The adapters above are thin wrappers over this API.
 
 ```ts
-import { buildSetCookieHeader, serializeCookie, verifyWebhookSignature } from "@ripplo/testing";
+import {
+  readAdapterWebhookSecret,
+  toBatchRunResults,
+  verifyWebhookSignature,
+} from "@ripplo/testing";
 import { engine } from "./test/engine.js";
 
-const webhookSecret = engine.getConfig().webhookSecret;
+const webhookSecret = readAdapterWebhookSecret();
 
 async function executePreconditions(req: Request): Promise<Response> {
   const body = await req.text();
@@ -467,27 +493,31 @@ async function executePreconditions(req: Request): Promise<Response> {
     return new Response(JSON.stringify({ error: "Invalid signature" }), { status: 401 });
   }
 
-  const { preconditions } = JSON.parse(body);
+  // Request body is a batch: { batch: [{ runId, preconditions: [...names] }, ...] }
+  const { batch } = JSON.parse(body);
   const appUrl = `${req.headers.get("x-forwarded-proto") ?? "http"}://${req.headers.get("host")}`;
-  const result = await engine.executePreconditions(preconditions, { appUrl });
-
-  const headers = new Headers({ "content-type": "application/json" });
-  result.cookies.forEach((c) =>
-    headers.append("Set-Cookie", buildSetCookieHeader(serializeCookie(c))),
+  const results = await engine.executePreconditions(
+    batch.map((b) => ({ runId: b.runId, names: b.preconditions })),
+    { appUrl },
   );
-  return new Response(JSON.stringify(result), { headers });
+
+  // Response body: { results: [{ runId, ok, cookies, data, executed } | { runId, ok: false, error }] }
+  return new Response(JSON.stringify({ results: toBatchRunResults(results) }), {
+    headers: { "content-type": "application/json" },
+  });
 }
 // teardown-preconditions and execute-observer follow the same verify-then-dispatch pattern.
+// teardown's request shape is { batch: [{ runId, preconditions, data }, ...] }, response { results: [{ runId, ok, error? }] }.
 ```
 
-You're responsible for: webhook verification (always before invoking the engine), routing the three endpoints, forwarding `result.cookies` to the test browser as `Set-Cookie` headers, and reading the raw body for signature verification before `JSON.parse`.
+You're responsible for: webhook verification (always before invoking the engine), routing the three endpoints, calling `toBatchRunResults` / `toTeardownResults` to shape the response body, and reading the raw body for signature verification before `JSON.parse`. Cookies travel inside the JSON response body — never as `Set-Cookie` headers; the runtime parses them out and applies them to the test browser context.
 
 ## Security & parallelism
 
 - All requests signed via Standard Webhooks (HMAC-SHA256). Headers: `webhook-id`, `webhook-timestamp`, `webhook-signature`. **Always verify before executing.**
 - `ENABLE_RIPPLO_TESTING` gates every adapter. Never expose in production.
 - Use `ctx.uniqueId(prefix)` / `ctx.uniqueEmail()` so parallel runs don't collide.
-- Return created entity IDs in the data contract; teardown deletes only that run's data using the captured `runId`. Never bulk-delete.
+- Return created entity IDs in the data contract; teardown deletes only data this run created. Bulk operations are fine — and encouraged — as long as the `WHERE` is scoped to the batch's own ids (`deleteMany({ where: { id: { in: items.map((it) => it.ctx.data.userId) } } })`). Never write a `WHERE` that could match another run's rows.
 
 ## Lockfile
 

package/dist/actions.d.ts

@@ -20,6 +20,7 @@ declare function navigate(url: string): UnlabeledStep<{
     };
 }>;
 interface StepOptions {
+    readonly modifier?: "Alt" | "Control" | "Meta" | "Shift";
     readonly uiOnly?: boolean;
 }
 declare function click(locator: AnyLocator, options?: StepOptions): UnlabeledStep<{
@@ -31,6 +32,7 @@ declare function click(locator: AnyLocator, options?: StepOptions): UnlabeledSte
         role: string;
         name?: string | undefined;
     };
+    modifier: "Alt" | "Control" | "Meta" | "Shift" | undefined;
     type: "click";
     uiOnly: boolean | undefined;
 }>;

package/dist/actions.js

@@ -34,6 +34,7 @@ function navigate(url) {
 function click(locator, options) {
   return createStep({
     locator: toSpecLocator(locator),
+    modifier: options?.modifier,
     type: "click",
     uiOnly: options?.uiOnly
   });

package/dist/assert.d.ts

@@ -1,4 +1,4 @@
-import { O as ObserverHandle, a as ObserverInput, P as Primitive, b as ObserverBudgetTier } from './types-16SB7zjP.js';
+import { O as ObserverHandle, a as ObserverInput, P as Primitive, b as ObserverBudgetTier } from './types-BzZrl65Z.js';
 import { Variable, StaticStringRef, VariableRef } from './control.js';
 import { U as UnlabeledStep } from './step-De52hTLd.js';
 import { CheckLocator, AnyLocator } from './locators.js';

package/dist/{builder-BMjy83Iy.d.ts → builder-DiVz3t1D.d.ts}

@@ -1,4 +1,4 @@
-import { P as Primitive, O as ObserverHandle, h as Precondition, m as PreconditionData, j as TestDefinition, f as ObserverDefinition, l as PreconditionDefinition, U as UnimplementedItems, e as ObserverContext, g as ObserverOutcome, S as SetupContext, k as TestValue, T as TeardownContext } from './types-16SB7zjP.js';
+import { P as Primitive, O as ObserverHandle, h as Precondition, m as PreconditionData, j as TestDefinition, f as ObserverDefinition, l as PreconditionDefinition, U as UnimplementedItems, e as ObserverContext, g as ObserverOutcome, S as SetupContext, k as TestValue, T as TeardownContext } from './types-BzZrl65Z.js';
 import { ObserverBudget } from '@ripplo/spec';
 import { S as Step } from './step-De52hTLd.js';
 
@@ -90,9 +90,16 @@ interface TestNeedsCoverage {
 type PreconditionSetupResult<TData extends Record<string, Primitive>> = {
     readonly [K in keyof TData]: TestValue<TData[K]>;
 };
+interface PreconditionSetupItem<TDeps extends Record<string, Record<string, Primitive>>> {
+    readonly ctx: SetupContext;
+    readonly deps: TDeps;
+}
+interface PreconditionTeardownItem<TData extends Record<string, Primitive>> {
+    readonly ctx: TeardownContext<TData>;
+}
 interface PreconditionImpl<TData extends Record<string, Primitive>, TDeps extends Record<string, Record<string, Primitive>>> {
-    readonly setup: (ctx: SetupContext, deps: TDeps) => Promise<PreconditionSetupResult<TData>>;
-    readonly teardown: (ctx: TeardownContext<TData>) => Promise<void>;
+    readonly setup: (items: ReadonlyArray<PreconditionSetupItem<TDeps>>) => Promise<ReadonlyArray<PreconditionSetupResult<TData>>>;
+    readonly teardown: (items: ReadonlyArray<PreconditionTeardownItem<TData>>) => Promise<void>;
 }
 type ObserverImplFn<TInput extends Record<string, Primitive>> = (ctx: ObserverContext, params: TInput) => Promise<ObserverOutcome>;
 interface TestOptions {

package/dist/{chunk-V6LMXKGL.js → chunk-XO36IU66.js}

@@ -10,26 +10,28 @@ function readAdapterWebhookSecret() {
   }
   return value;
 }
+var primitiveSchema = z.union([z.string(), z.number(), z.boolean()]);
+var dataSchema = z.record(z.string(), z.record(z.string(), primitiveSchema));
 var batchRequestSchema = z.object({
-  preconditions: z.array(z.string().min(1))
+  batch: z.array(
+    z.object({
+      preconditions: z.array(z.string().min(1)),
+      runId: z.string().min(1)
+    })
+  ).min(1)
 });
 var teardownRequestSchema = z.object({
-  data: z.record(z.string(), z.record(z.string(), z.union([z.string(), z.number(), z.boolean()]))),
-  preconditions: z.array(z.string().min(1))
+  batch: z.array(
+    z.object({
+      data: dataSchema,
+      preconditions: z.array(z.string().min(1)),
+      runId: z.string().min(1)
+    })
+  ).min(1)
 });
 var observerRequestSchema = z.object({
   observer: z.string().min(1).max(200),
-  params: z.record(z.string().max(200), z.union([z.string(), z.number(), z.boolean()]))
-});
-var observerOutcomeSchema = z.discriminatedUnion("kind", [
-  z.object({ kind: z.literal("pass") }),
-  z.object({ kind: z.literal("retry"), reason: z.string() }),
-  z.object({ kind: z.literal("fail"), reason: z.string() })
-]);
-var observerResponseSchema = z.object({
-  error: z.string().optional(),
-  outcome: observerOutcomeSchema.optional(),
-  success: z.boolean()
+  params: z.record(z.string().max(200), primitiveSchema)
 });
 function verifyWebhookSignature(payload, headers, secret) {
   try {
@@ -50,7 +52,7 @@ function verifyWebhookSignature(payload, headers, secret) {
 function serializeCookie(cookie) {
   return {
     domain: cookie.options?.domain,
-    expires: cookie.options?.expires == null ? void 0 : new Date(cookie.options.expires * 1e3),
+    expires: cookie.options?.expires,
     httpOnly: cookie.options?.httpOnly,
     name: cookie.name,
     path: cookie.options?.path,
@@ -59,28 +61,19 @@ function serializeCookie(cookie) {
     value: cookie.value
   };
 }
-function buildSetCookieHeader(cookie) {
-  const parts = [`${cookie.name}=${cookie.value}`];
-  if (cookie.domain != null) {
-    parts.push(`Domain=${cookie.domain}`);
-  }
-  if (cookie.path != null) {
-    parts.push(`Path=${cookie.path}`);
-  }
-  if (cookie.expires != null) {
-    parts.push(`Expires=${cookie.expires.toUTCString()}`);
-  }
-  if (cookie.httpOnly === true) {
-    parts.push("HttpOnly");
-  }
-  if (cookie.secure === true) {
-    parts.push("Secure");
-  }
-  if (cookie.sameSite != null) {
-    const capitalized = cookie.sameSite.charAt(0).toUpperCase() + cookie.sameSite.slice(1);
-    parts.push(`SameSite=${capitalized}`);
-  }
-  return parts.join("; ");
+function toBatchRunResults(results) {
+  return results.map(
+    (r) => r.success ? {
+      cookies: r.cookies.map((c) => serializeCookie(c)),
+      data: r.data,
+      executed: [...r.executed],
+      ok: true,
+      runId: r.runId
+    } : { error: r.error ?? "unknown error", ok: false, runId: r.runId }
+  );
+}
+function toTeardownResults(results) {
+  return results.map((r) => ({ error: r.error, ok: r.success, runId: r.runId }));
 }
 
 export {
@@ -90,5 +83,6 @@ export {
   observerRequestSchema,
   verifyWebhookSignature,
   serializeCookie,
-  buildSetCookieHeader
+  toBatchRunResults,
+  toTeardownResults
 };

package/dist/compiler.d.ts

@@ -1,6 +1,6 @@
 import { Observer, Precondition, WorkflowSpec } from '@ripplo/spec';
-import { d as RipploBuilder } from './builder-BMjy83Iy.js';
-import './types-16SB7zjP.js';
+import { d as RipploBuilder } from './builder-DiVz3t1D.js';
+import './types-BzZrl65Z.js';
 import './step-De52hTLd.js';
 
 interface CompiledFixture {

package/dist/elysia.d.ts

@@ -1,7 +1,7 @@
 import { Elysia } from 'elysia';
-import { R as RipploEngine } from './engine-DMOkJdjd.js';
-import './builder-BMjy83Iy.js';
-import './types-16SB7zjP.js';
+import { R as RipploEngine } from './engine-DVbF4E5A.js';
+import './builder-DiVz3t1D.js';
+import './types-BzZrl65Z.js';
 import './step-De52hTLd.js';
 import '@ripplo/spec';
 

package/dist/elysia.js

@@ -1,12 +1,12 @@
 import {
   batchRequestSchema,
-  buildSetCookieHeader,
   observerRequestSchema,
   readAdapterWebhookSecret,
-  serializeCookie,
   teardownRequestSchema,
+  toBatchRunResults,
+  toTeardownResults,
   verifyWebhookSignature
-} from "./chunk-V6LMXKGL.js";
+} from "./chunk-XO36IU66.js";
 import "./chunk-4MGIQFAJ.js";
 
 // src/adapters/elysia.ts
@@ -27,29 +27,17 @@ function build({ enabled, engine }) {
     }
     const parsed = parseWith(gate.body, batchRequestSchema);
     if (parsed == null) {
-      return jsonResponse({ error: "Invalid request body", success: false }, 400);
+      return jsonResponse({ error: "Invalid request body" }, 400);
     }
     const host = request.headers.get("host");
     if (host == null || host.length === 0) {
-      return jsonResponse({ error: "Missing host header", success: false }, 400);
+      return jsonResponse({ error: "Missing host header" }, 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 }
-    );
+    const items = parsed.batch.map((b) => ({ names: b.preconditions, runId: b.runId }));
+    const results = await engine.executePreconditions(items, { appUrl });
+    return jsonResponse({ results: toBatchRunResults(results) }, 200);
   }).put("/execute-observer", async ({ request }) => {
     const gate = await verifyAndReadBody(request, webhookSecret);
     if ("response" in gate) {
@@ -71,10 +59,15 @@ function build({ enabled, engine }) {
     }
     const parsed = parseWith(gate.body, teardownRequestSchema);
     if (parsed == null) {
-      return jsonResponse({ error: "Invalid request body", success: false }, 400);
+      return jsonResponse({ error: "Invalid request body" }, 400);
     }
-    await engine.teardown(parsed.preconditions, parsed.data);
-    return jsonResponse({ success: true }, 200);
+    const items = parsed.batch.map((b) => ({
+      data: b.data,
+      names: b.preconditions,
+      runId: b.runId
+    }));
+    const results = await engine.teardown(items);
+    return jsonResponse({ results: toTeardownResults(results) }, 200);
   });
 }
 async function verifyAndReadBody(req, webhookSecret) {

package/dist/{engine-DMOkJdjd.d.ts → engine-DVbF4E5A.d.ts}

@@ -1,7 +1,7 @@
-import { c as PreconditionRegistry, a as ObserverRegistry, O as ObserverImplFn, P as PreconditionImpl, e as RipploInstance } from './builder-BMjy83Iy.js';
-import { P as Primitive, g as ObserverOutcome, C as CookieEntry, f as ObserverDefinition, l as PreconditionDefinition, U as UnimplementedItems, O as ObserverHandle, h as Precondition } from './types-16SB7zjP.js';
+import { c as PreconditionRegistry, a as ObserverRegistry, O as ObserverImplFn, P as PreconditionImpl, e as RipploInstance } from './builder-DiVz3t1D.js';
+import { P as Primitive, g as ObserverOutcome, C as CookieEntry, f as ObserverDefinition, l as PreconditionDefinition, U as UnimplementedItems, O as ObserverHandle, h as Precondition } from './types-BzZrl65Z.js';
 
-interface EngineResult {
+interface EngineRunResult {
     readonly cookies: ReadonlyArray<CookieEntry>;
     readonly data: Record<string, Record<string, Primitive>>;
     readonly error: string | undefined;
@@ -12,6 +12,20 @@ interface EngineResult {
 interface ExecuteBatchOptions {
     readonly appUrl: string | undefined;
 }
+interface ExecuteBatchItem {
+    readonly names: ReadonlyArray<string>;
+    readonly runId: string;
+}
+interface TeardownBatchItem {
+    readonly data: Record<string, Record<string, Primitive>>;
+    readonly names: ReadonlyArray<string>;
+    readonly runId: string;
+}
+interface TeardownRunResult {
+    readonly error: string | undefined;
+    readonly runId: string;
+    readonly success: boolean;
+}
 interface ObserverExecutionResult {
     readonly error: string | undefined;
     readonly outcome: ObserverOutcome | undefined;
@@ -19,11 +33,11 @@ interface ObserverExecutionResult {
 }
 interface RipploEngine {
     readonly executeObserver: (name: string, params: Record<string, Primitive>) => Promise<ObserverExecutionResult>;
-    readonly executePreconditions: (names: ReadonlyArray<string>, options?: ExecuteBatchOptions) => Promise<EngineResult>;
+    readonly executePreconditions: (items: ReadonlyArray<ExecuteBatchItem>, options?: ExecuteBatchOptions) => Promise<ReadonlyArray<EngineRunResult>>;
     readonly getObservers: () => ReadonlyArray<ObserverDefinition>;
     readonly getPreconditions: () => ReadonlyArray<PreconditionDefinition>;
     readonly getUnimplemented: () => UnimplementedItems;
-    readonly teardown: (names: ReadonlyArray<string>, data: Record<string, Record<string, Primitive>>) => Promise<void>;
+    readonly teardown: (items: ReadonlyArray<TeardownBatchItem>) => Promise<ReadonlyArray<TeardownRunResult>>;
 }
 declare const NOT_IMPLEMENTED_BRAND: unique symbol;
 interface NotImplemented {
@@ -43,4 +57,4 @@ interface EngineImpls<P extends PreconditionRegistry, O extends ObserverRegistry
 }
 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 PreconditionImplFor as P, type RipploEngine as R, type EngineResult as a, type ExecuteBatchOptions as b, createEngine as c, notImplemented as n };
+export { type EngineRunResult as E, type NotImplemented as N, type ObserverImplFnFor as O, type PreconditionImplFor as P, type RipploEngine as R, type TeardownRunResult as T, type EngineImpls as a, type ExecuteBatchItem as b, type ExecuteBatchOptions as c, type TeardownBatchItem as d, createEngine as e, notImplemented as n };

package/dist/express.d.ts

@@ -1,7 +1,7 @@
 import { Router } from 'express';
-import { R as RipploEngine } from './engine-DMOkJdjd.js';
-import './builder-BMjy83Iy.js';
-import './types-16SB7zjP.js';
+import { R as RipploEngine } from './engine-DVbF4E5A.js';
+import './builder-DiVz3t1D.js';
+import './types-BzZrl65Z.js';
 import './step-De52hTLd.js';
 import '@ripplo/spec';
 

package/dist/express.js

@@ -2,10 +2,11 @@ import {
   batchRequestSchema,
   observerRequestSchema,
   readAdapterWebhookSecret,
-  serializeCookie,
   teardownRequestSchema,
+  toBatchRunResults,
+  toTeardownResults,
   verifyWebhookSignature
-} from "./chunk-V6LMXKGL.js";
+} from "./chunk-XO36IU66.js";
 import "./chunk-4MGIQFAJ.js";
 
 // src/adapters/express.ts
@@ -29,22 +30,13 @@ function createExpressHandler({ enabled, engine }) {
   router.put("/execute-preconditions", (req, res) => {
     const parsed = batchRequestSchema.safeParse(req.body);
     if (!parsed.success) {
-      res.status(400).json({ error: "Invalid request body", success: false });
+      res.status(400).json({ error: "Invalid request body" });
       return;
     }
     const appUrl = `${req.protocol}://${req.get("host") ?? ""}`;
-    void engine.executePreconditions(parsed.data.preconditions, { appUrl }).then((result) => {
-      result.cookies.forEach((cookie) => {
-        const s = serializeCookie(cookie);
-        res.cookie(s.name, s.value, buildExpressCookieOptions(s));
-      });
-      res.json({
-        data: result.data,
-        error: result.error,
-        executed: result.executed,
-        runId: result.runId,
-        success: result.success
-      });
+    const items = parsed.data.batch.map((b) => ({ names: b.preconditions, runId: b.runId }));
+    void engine.executePreconditions(items, { appUrl }).then((results) => {
+      res.json({ results: toBatchRunResults(results) });
     });
   });
   router.put("/execute-observer", (req, res) => {
@@ -54,21 +46,22 @@ function createExpressHandler({ enabled, engine }) {
       return;
     }
     void engine.executeObserver(parsed.data.observer, parsed.data.params).then((result) => {
-      res.json({
-        error: result.error,
-        outcome: result.outcome,
-        success: result.success
-      });
+      res.json({ error: result.error, outcome: result.outcome, success: result.success });
     });
   });
   router.put("/teardown-preconditions", (req, res) => {
     const parsed = teardownRequestSchema.safeParse(req.body);
     if (!parsed.success) {
-      res.status(400).json({ error: "Invalid request body", success: false });
+      res.status(400).json({ error: "Invalid request body" });
       return;
     }
-    void engine.teardown(parsed.data.preconditions, parsed.data.data).then(() => {
-      res.json({ success: true });
+    const items = parsed.data.batch.map((b) => ({
+      data: b.data,
+      names: b.preconditions,
+      runId: b.runId
+    }));
+    void engine.teardown(items).then((results) => {
+      res.json({ results: toTeardownResults(results) });
     });
   });
   return router;
@@ -89,28 +82,6 @@ function asString(value) {
   }
   return void 0;
 }
-function buildExpressCookieOptions(s) {
-  const opts = {};
-  if (s.domain != null) {
-    opts.domain = s.domain;
-  }
-  if (s.expires != null) {
-    opts.expires = s.expires;
-  }
-  if (s.httpOnly != null) {
-    opts.httpOnly = s.httpOnly;
-  }
-  if (s.path != null) {
-    opts.path = s.path;
-  }
-  if (s.sameSite != null) {
-    opts.sameSite = s.sameSite;
-  }
-  if (s.secure != null) {
-    opts.secure = s.secure;
-  }
-  return opts;
-}
 export {
   createExpressHandler
 };

package/dist/fastify.d.ts

@@ -1,7 +1,7 @@
 import { FastifyInstance } from 'fastify';
-import { R as RipploEngine } from './engine-DMOkJdjd.js';
-import './builder-BMjy83Iy.js';
-import './types-16SB7zjP.js';
+import { R as RipploEngine } from './engine-DVbF4E5A.js';
+import './builder-DiVz3t1D.js';
+import './types-BzZrl65Z.js';
 import './step-De52hTLd.js';
 import '@ripplo/spec';
 

package/dist/fastify.js

@@ -1,12 +1,12 @@
 import {
   batchRequestSchema,
-  buildSetCookieHeader,
   observerRequestSchema,
   readAdapterWebhookSecret,
-  serializeCookie,
   teardownRequestSchema,
+  toBatchRunResults,
+  toTeardownResults,
   verifyWebhookSignature
-} from "./chunk-V6LMXKGL.js";
+} from "./chunk-XO36IU66.js";
 import "./chunk-4MGIQFAJ.js";
 
 // src/adapters/fastify.ts
@@ -34,21 +34,12 @@ function registerFastifyHandler({
     fastify.put("/execute-preconditions", async (req, reply) => {
       const parsed = batchRequestSchema.safeParse(req.body);
       if (!parsed.success) {
-        return reply.code(400).send({ error: "Invalid request body", success: false });
+        return reply.code(400).send({ error: "Invalid request body" });
       }
       const appUrl = `${req.protocol}://${req.hostname}`;
-      const result = await engine.executePreconditions(parsed.data.preconditions, { appUrl });
-      result.cookies.forEach((cookie) => {
-        const s = serializeCookie(cookie);
-        reply.header("Set-Cookie", buildSetCookieHeader(s));
-      });
-      return reply.send({
-        data: result.data,
-        error: result.error,
-        executed: result.executed,
-        runId: result.runId,
-        success: result.success
-      });
+      const items = parsed.data.batch.map((b) => ({ names: b.preconditions, runId: b.runId }));
+      const results = await engine.executePreconditions(items, { appUrl });
+      return reply.send({ results: toBatchRunResults(results) });
     });
     fastify.put("/execute-observer", async (req, reply) => {
       const parsed = observerRequestSchema.safeParse(req.body);
@@ -56,19 +47,20 @@ function registerFastifyHandler({
         return reply.code(400).send({ error: "Invalid request body", success: false });
       }
       const result = await engine.executeObserver(parsed.data.observer, parsed.data.params);
-      return reply.send({
-        error: result.error,
-        outcome: result.outcome,
-        success: result.success
-      });
+      return reply.send({ error: result.error, outcome: result.outcome, success: result.success });
     });
     fastify.put("/teardown-preconditions", async (req, reply) => {
       const parsed = teardownRequestSchema.safeParse(req.body);
       if (!parsed.success) {
-        return reply.code(400).send({ error: "Invalid request body", success: false });
+        return reply.code(400).send({ error: "Invalid request body" });
       }
-      await engine.teardown(parsed.data.preconditions, parsed.data.data);
-      return reply.send({ success: true });
+      const items = parsed.data.batch.map((b) => ({
+        data: b.data,
+        names: b.preconditions,
+        runId: b.runId
+      }));
+      const results = await engine.teardown(items);
+      return reply.send({ results: toTeardownResults(results) });
     });
   };
 }

package/dist/hono.d.ts

@@ -1,7 +1,7 @@
 import { Hono } from 'hono';
-import { R as RipploEngine } from './engine-DMOkJdjd.js';
-import './builder-BMjy83Iy.js';
-import './types-16SB7zjP.js';
+import { R as RipploEngine } from './engine-DVbF4E5A.js';
+import './builder-DiVz3t1D.js';
+import './types-BzZrl65Z.js';
 import './step-De52hTLd.js';
 import '@ripplo/spec';