@ripplo/testing 0.4.8 → 0.5.1

package/dist/hono.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/hono.ts
@@ -22,25 +22,17 @@ function createHonoHandler({ enabled, engine }) {
     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);
+      return c.json({ error: "Invalid request body" }, 400);
     }
     const host = c.req.header("host");
     if (host == null || host.length === 0) {
-      return c.json({ error: "Missing host header", success: false }, 400);
+      return c.json({ error: "Missing host header" }, 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
-    });
+    const items = parsed.data.batch.map((b) => ({ names: b.preconditions, runId: b.runId }));
+    const results = await engine.executePreconditions(items, { appUrl });
+    return c.json({ results: toBatchRunResults(results) });
   });
   app.put("/execute-observer", async (c) => {
     const body = tryParseJson(c.get("rawBody"));
@@ -49,20 +41,21 @@ function createHonoHandler({ enabled, engine }) {
       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
-    });
+    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);
+      return c.json({ error: "Invalid request body" }, 400);
     }
-    await engine.teardown(parsed.data.preconditions, parsed.data.data);
-    return c.json({ 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 c.json({ results: toTeardownResults(results) });
   });
   return app;
 }

package/dist/index.d.ts

@@ -1,9 +1,10 @@
-export { C as CoverageRegistry, 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-BMjy83Iy.js';
+export { C as CoverageRegistry, 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-DiVz3t1D.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 PreconditionImplFor, R as RipploEngine, c as createEngine, n as notImplemented } from './engine-DMOkJdjd.js';
-import { C as CookieEntry } from './types-16SB7zjP.js';
-export { c as CookieOptions, D as DEFAULT_IGNORE_PATHS, d as DEFAULT_WATCH_PATHS, e as ObserverContext, f as ObserverDefinition, O as ObserverHandle, a as ObserverInput, g as ObserverOutcome, h as Precondition, i as PreconditionDeps, P as Primitive, S as SetupContext, T as TeardownContext, j as TestDefinition, k as TestValue } from './types-16SB7zjP.js';
+import { E as EngineRunResult, T as TeardownRunResult$1 } from './engine-DVbF4E5A.js';
+export { a as EngineImpls, b as ExecuteBatchItem, c as ExecuteBatchOptions, N as NotImplemented, O as ObserverImplFnFor, P as PreconditionImplFor, R as RipploEngine, d as TeardownBatchItem, e as createEngine, n as notImplemented } from './engine-DVbF4E5A.js';
+import { C as CookieEntry } from './types-BzZrl65Z.js';
+export { c as CookieOptions, D as DEFAULT_IGNORE_PATHS, d as DEFAULT_WATCH_PATHS, e as ObserverContext, f as ObserverDefinition, O as ObserverHandle, a as ObserverInput, g as ObserverOutcome, h as Precondition, i as PreconditionDeps, P as Primitive, S as SetupContext, T as TeardownContext, j as TestDefinition, k as TestValue } from './types-BzZrl65Z.js';
 export { D as DslNodeInput } from './step-De52hTLd.js';
 import '@ripplo/spec';
 
@@ -18,15 +19,10 @@ interface LintResult {
 }
 declare function lint(result: CompileResult): LintResult;
 
-interface WebhookHeaders {
-    readonly "webhook-id": string | undefined;
-    readonly "webhook-signature": string | undefined;
-    readonly "webhook-timestamp": string | undefined;
-}
-declare function verifyWebhookSignature(payload: string, headers: WebhookHeaders, secret: string): boolean;
+declare function readAdapterWebhookSecret(): string;
 interface SerializedCookie {
     readonly domain: string | undefined;
-    readonly expires: Date | undefined;
+    readonly expires: number | undefined;
     readonly httpOnly: boolean | undefined;
     readonly name: string;
     readonly path: string | undefined;
@@ -34,7 +30,30 @@ interface SerializedCookie {
     readonly secure: boolean | undefined;
     readonly value: string;
 }
+type BatchRunResult = {
+    readonly cookies: ReadonlyArray<SerializedCookie>;
+    readonly data: Record<string, Record<string, string | number | boolean>>;
+    readonly executed: ReadonlyArray<string>;
+    readonly ok: true;
+    readonly runId: string;
+} | {
+    readonly error: string;
+    readonly ok: false;
+    readonly runId: string;
+};
+type TeardownRunResult = {
+    readonly error: string | undefined;
+    readonly ok: boolean;
+    readonly runId: string;
+};
+interface WebhookHeaders {
+    readonly "webhook-id": string | undefined;
+    readonly "webhook-signature": string | undefined;
+    readonly "webhook-timestamp": string | undefined;
+}
+declare function verifyWebhookSignature(payload: string, headers: WebhookHeaders, secret: string): boolean;
 declare function serializeCookie(cookie: CookieEntry): SerializedCookie;
-declare function buildSetCookieHeader(cookie: SerializedCookie): string;
+declare function toBatchRunResults(results: ReadonlyArray<EngineRunResult>): ReadonlyArray<BatchRunResult>;
+declare function toTeardownResults(results: ReadonlyArray<TeardownRunResult$1>): ReadonlyArray<TeardownRunResult>;
 
-export { CompileResult, CookieEntry, type LintDiagnostic, type LintResult, type SerializedCookie, buildSetCookieHeader, lint, serializeCookie, verifyWebhookSignature };
+export { CompileResult, CookieEntry, EngineRunResult, type LintDiagnostic, type LintResult, type SerializedCookie, TeardownRunResult$1 as TeardownRunResult, lint, readAdapterWebhookSecret, serializeCookie, toBatchRunResults, toTeardownResults, verifyWebhookSignature };

package/dist/index.js

@@ -17,10 +17,12 @@ import {
 } from "./chunk-YFOTJIVF.js";
 import "./chunk-MGATMMCZ.js";
 import {
-  buildSetCookieHeader,
+  readAdapterWebhookSecret,
   serializeCookie,
+  toBatchRunResults,
+  toTeardownResults,
   verifyWebhookSignature
-} from "./chunk-V6LMXKGL.js";
+} from "./chunk-XO36IU66.js";
 import "./chunk-4MGIQFAJ.js";
 
 // src/chainable.ts
@@ -149,7 +151,7 @@ function stubPreconditionDef(p) {
     name,
     returns: [],
     teardown: void 0,
-    setup: () => Promise.resolve({})
+    setup: () => Promise.resolve([])
   };
 }
 function stubObserverDef(o) {
@@ -860,7 +862,7 @@ function createEngine(ripplo, impls) {
   const observersByName = new Map(observerDefs.map((d) => [d.name, d]));
   return {
     executeObserver: (name, params) => executeObserver(observersByName, name, params),
-    executePreconditions: (names, options) => executePreconditions({ defsByName: preconditionsByName, names, options }),
+    executePreconditions: (items, options) => executePreconditions({ defsByName: preconditionsByName, items, options }),
     getObservers: () => observerDefs,
     getPreconditions: () => preconditionDefs,
     getUnimplemented: () => ({
@@ -868,7 +870,7 @@ function createEngine(ripplo, impls) {
       preconditions: preconditionDefs.filter((p) => !p.implemented).map((p) => p.name),
       tests: ripplo.tests.filter((t) => !t.implemented).map((t) => t.id)
     }),
-    teardown: (names, data) => teardown(preconditionsByName, names, data)
+    teardown: (items) => teardown({ defsByName: preconditionsByName, items })
   };
 }
 function wirePreconditions(registry, impls) {
@@ -913,17 +915,34 @@ function makeWiredPreconditionDef(handle, impl) {
     implemented: true,
     name,
     returns: [],
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- typedImpl.teardown has narrower TData, wider context at engine boundary
-    teardown: typedImpl.teardown,
-    setup: async (ctx, allDeps) => {
-      const resolved = {};
-      mapping.forEach(([key, depName]) => {
-        const data = allDeps[depName];
-        if (data != null) {
-          resolved[key] = data;
-        }
+    setup: async (items) => {
+      const resolvedItems = items.map((item) => {
+        const resolved = {};
+        mapping.forEach(([key, depName]) => {
+          const data = item.deps[depName];
+          if (data != null) {
+            resolved[key] = data;
+          }
+        });
+        return { ctx: item.ctx, deps: resolved };
+      });
+      const results = await typedImpl.setup(resolvedItems);
+      return results.map((r) => {
+        const out = {};
+        Object.entries(r).forEach(([key, value]) => {
+          if (!isPrimitive(value)) {
+            throw new TypeError(
+              `Precondition "${name}" returned non-primitive value at key "${key}". Setup return values must be string, number, or boolean \u2014 produced via ctx.fixed/uniqueEmail/uniqueId.`
+            );
+          }
+          out[key] = value;
+        });
+        return out;
       });
-      return typedImpl.setup(ctx, resolved);
+    },
+    teardown: async (items) => {
+      const typed = items;
+      await typedImpl.teardown(typed);
     }
   };
 }
@@ -964,88 +983,170 @@ function readBudgetOf(handle) {
 }
 async function executePreconditions({
   defsByName,
-  names,
+  items,
   options
 }) {
-  const runId = crypto.randomUUID().slice(0, 12);
-  const cookies = [];
   const defaultDomain = deriveDefaultDomain(options?.appUrl);
-  const state = {
-    cookies,
-    ctx: createSetupContext({ cookies, defaultDomain, runId }),
-    data: {},
-    defsByName,
-    executed: [],
-    runId
-  };
-  return runBatchSequence(state, names);
+  const initial = items.map((item) => {
+    const cookiesRef = [];
+    return {
+      cookies: cookiesRef,
+      cookiesRef,
+      ctx: createSetupContext({ cookies: cookiesRef, defaultDomain, runId: item.runId }),
+      data: {},
+      executed: [],
+      failure: void 0,
+      names: item.names,
+      runId: item.runId
+    };
+  });
+  const order = topoOrder(defsByName, items);
+  const orderError = order.error;
+  if (orderError != null) {
+    return initial.map((s) => failResult(s, orderError));
+  }
+  const sequence = order.names ?? [];
+  let states = initial;
+  let i = 0;
+  while (i < sequence.length) {
+    const name = sequence[i];
+    if (name != null) {
+      states = await executeStep({ defsByName, name, states });
+    }
+    i += 1;
+  }
+  return states.map(
+    (s) => s.failure == null ? {
+      cookies: s.cookiesRef,
+      data: s.data,
+      error: void 0,
+      executed: s.executed,
+      runId: s.runId,
+      success: true
+    } : failResult(s, s.failure)
+  );
 }
-async function runBatchSequence(state, names) {
-  let index = 0;
-  while (index < names.length) {
-    const name = names[index];
-    if (name == null) {
-      break;
+function topoOrder(defsByName, items) {
+  const seen = /* @__PURE__ */ new Set();
+  const order = [];
+  const visiting = /* @__PURE__ */ new Set();
+  const visitDeps = (deps) => {
+    const found = deps.find((d) => visit(d) != null);
+    return found == null ? void 0 : visit(found);
+  };
+  const visit = (name) => {
+    if (seen.has(name)) {
+      return void 0;
     }
-    const error = validatePrecondition(state.defsByName, name);
-    if (error != null) {
-      return fail(state, error);
+    if (visiting.has(name)) {
+      return `Cycle detected at precondition "${name}"`;
     }
-    const stepError = await executeOnePrecondition(state, name);
-    if (stepError != null) {
-      return fail(state, stepError);
+    const def = defsByName.get(name);
+    if (def == null) {
+      return `Unknown precondition: "${name}"`;
     }
-    index += 1;
-  }
-  return {
-    cookies: state.cookies,
-    data: state.data,
-    error: void 0,
-    executed: state.executed,
-    runId: state.runId,
-    success: true
+    visiting.add(name);
+    const deps = def.depMapping.map(([, depName]) => depName);
+    const cycleError = visitDeps(deps);
+    visiting.delete(name);
+    if (cycleError != null) {
+      return cycleError;
+    }
+    seen.add(name);
+    order.push(name);
+    return void 0;
   };
+  let err;
+  let k = 0;
+  const allNames = items.flatMap((item) => item.names);
+  while (k < allNames.length && err == null) {
+    const n = allNames[k];
+    if (n != null) {
+      err = visit(n);
+    }
+    k += 1;
+  }
+  if (err != null) {
+    return { error: err, names: void 0 };
+  }
+  return { error: void 0, names: order };
 }
-function validatePrecondition(defsByName, name) {
+async function executeStep({
+  defsByName,
+  name,
+  states
+}) {
+  const isActive = (s) => s.failure == null && s.names.includes(name);
+  const active = states.filter((s) => isActive(s));
+  if (active.length === 0) {
+    return states;
+  }
   const def = defsByName.get(name);
   if (def == null) {
-    return `Unknown precondition: "${name}"`;
+    return states.map(
+      (s) => isActive(s) ? { ...s, failure: `Unknown precondition: "${name}"` } : s
+    );
   }
   if (!def.implemented) {
-    return `Precondition "${name}" is not implemented`;
+    return states.map(
+      (s) => isActive(s) ? { ...s, failure: `Precondition "${name}" is not implemented` } : s
+    );
   }
-  return void 0;
+  const stepResult = await runSetup({ active, def, name });
+  return states.map((s) => isActive(s) ? mergeStepResult(s, name, stepResult) : s);
 }
-async function executeOnePrecondition(state, name) {
-  const def = state.defsByName.get(name);
-  if (def == null) {
-    return `Unknown precondition: "${name}"`;
-  }
+async function runSetup({ active, def, name }) {
+  const itemsForCall = active.map((s) => ({ ctx: s.ctx, deps: s.data }));
   try {
-    const result = await def.setup(state.ctx, state.data);
-    const resolved = {};
-    Object.entries(result).forEach(([key, value]) => {
-      if (!isPrimitive(value)) {
-        throw new TypeError(
-          `Precondition "${name}" returned non-primitive value at key "${key}". Setup return values must be string, number, or boolean \u2014 produced via ctx.fixed/uniqueEmail/uniqueId.`
-        );
-      }
-      resolved[key] = value;
+    const results = await def.setup(itemsForCall);
+    if (results.length !== active.length) {
+      return {
+        batchError: `Precondition "${name}" returned ${String(results.length)} results for ${String(active.length)} items`,
+        perItem: /* @__PURE__ */ new Map()
+      };
+    }
+    const entries = active.map((s, idx) => {
+      const r = results[idx];
+      return r == null ? void 0 : [s.runId, r];
     });
-    state.data[name] = resolved;
-    state.executed.push(name);
-    return void 0;
+    const valid = entries.filter(
+      (e) => e != null
+    );
+    if (valid.length !== active.length) {
+      return {
+        batchError: `Precondition "${name}" returned a null result for at least one item`,
+        perItem: /* @__PURE__ */ new Map()
+      };
+    }
+    return { batchError: void 0, perItem: new Map(valid) };
   } catch (error) {
-    return error instanceof Error ? error.message : String(error);
+    return {
+      batchError: error instanceof Error ? error.message : String(error),
+      perItem: /* @__PURE__ */ new Map()
+    };
   }
 }
-function fail(state, error) {
+function mergeStepResult(s, name, result) {
+  if (result.batchError != null) {
+    return { ...s, failure: result.batchError };
+  }
+  const data = result.perItem.get(s.runId);
+  if (data == null) {
+    return { ...s, failure: `Precondition "${name}" produced no result for run "${s.runId}"` };
+  }
   return {
-    cookies: state.cookies,
-    data: state.data,
+    ...s,
+    data: { ...s.data, [name]: data },
+    executed: [...s.executed, name]
+  };
+}
+function failResult(s, error) {
+  return {
+    cookies: s.cookies,
+    data: s.data,
     error,
-    executed: state.executed,
-    runId: state.runId,
+    executed: s.executed,
+    runId: s.runId,
     success: false
   };
 }
@@ -1074,25 +1175,56 @@ function createObserverContext(runId) {
     retry: (reason) => createRetryOutcome(reason)
   };
 }
-async function teardown(defsByName, names, data) {
-  const reversed = [...names].toReversed();
-  let index = 0;
-  while (index < reversed.length) {
-    const name = reversed[index];
+async function teardown({
+  defsByName,
+  items
+}) {
+  const errors = /* @__PURE__ */ new Map();
+  const allNamesUnique = [...new Set(items.flatMap((i2) => i2.names))];
+  const order = topoOrder(
+    defsByName,
+    allNamesUnique.map((n) => ({ names: [n], runId: "" }))
+  );
+  const reversed = (order.names ?? []).toReversed();
+  let i = 0;
+  while (i < reversed.length) {
+    const name = reversed[i];
     if (name != null) {
-      await teardownOne(defsByName, name, data);
+      await teardownStep({ defsByName, errors, items, name });
     }
-    index += 1;
+    i += 1;
   }
+  return items.map((it) => {
+    const err = errors.get(it.runId);
+    return { error: err, runId: it.runId, success: err == null };
+  });
 }
-async function teardownOne(defsByName, name, data) {
+async function teardownStep({
+  defsByName,
+  errors,
+  items,
+  name
+}) {
   const def = defsByName.get(name);
   if (def?.teardown == null) {
     return;
   }
+  const active = items.filter((i) => i.names.includes(name));
+  if (active.length === 0) {
+    return;
+  }
+  const teardownItems = active.map((it) => ({
+    ctx: { data: it.data[name] ?? {} }
+  }));
   try {
-    await def.teardown({ data: data[name] ?? {} });
-  } catch {
+    await def.teardown(teardownItems);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    active.forEach((it) => {
+      if (!errors.has(it.runId)) {
+        errors.set(it.runId, message);
+      }
+    });
   }
 }
 function createSetupContext({
@@ -1124,7 +1256,6 @@ function deriveDefaultDomain(baseUrl) {
 export {
   DEFAULT_IGNORE_PATHS,
   DEFAULT_WATCH_PATHS,
-  buildSetCookieHeader,
   compile,
   createEngine,
   createRipplo,
@@ -1132,7 +1263,10 @@ export {
   notImplemented,
   observer,
   precondition,
+  readAdapterWebhookSecret,
   serializeCookie,
   test,
+  toBatchRunResults,
+  toTeardownResults,
   verifyWebhookSignature
 };

package/dist/koa.d.ts

@@ -1,7 +1,7 @@
 import { Middleware } from 'koa';
-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/koa.js

@@ -1,18 +1,18 @@
 import {
   batchRequestSchema,
-  buildSetCookieHeader,
   observerRequestSchema,
   readAdapterWebhookSecret,
-  serializeCookie,
   teardownRequestSchema,
+  toBatchRunResults,
+  toTeardownResults,
   verifyWebhookSignature
-} from "./chunk-V6LMXKGL.js";
+} from "./chunk-XO36IU66.js";
 import "./chunk-4MGIQFAJ.js";
 
 // src/adapters/koa.ts
 function createKoaHandler({ enabled, engine }) {
   if (!enabled) {
-    return async (ctx, next) => {
+    return async (_ctx, next) => {
       await next();
     };
   }
@@ -57,29 +57,21 @@ async function handleExecutePreconditions({ body, ctx, engine }) {
   const parsed = json == null ? null : batchRequestSchema.safeParse(json);
   if (parsed == null || !parsed.success) {
     ctx.status = 400;
-    ctx.body = { error: "Invalid request body", success: false };
+    ctx.body = { error: "Invalid request body" };
     return;
   }
   const host = ctx.get("host");
   if (host.length === 0) {
     ctx.status = 400;
-    ctx.body = { error: "Missing host header", success: false };
+    ctx.body = { error: "Missing host header" };
     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)));
-  });
+  const items = parsed.data.batch.map((b) => ({ names: b.preconditions, runId: b.runId }));
+  const results = await engine.executePreconditions(items, { appUrl });
   ctx.status = 200;
-  ctx.body = {
-    data: result.data,
-    error: result.error,
-    executed: result.executed,
-    runId: result.runId,
-    success: result.success
-  };
+  ctx.body = { results: toBatchRunResults(results) };
 }
 async function handleExecuteObserver({ body, ctx, engine }) {
   const json = tryParseJson(body);
@@ -98,12 +90,17 @@ async function handleTeardown({ body, ctx, engine }) {
   const parsed = json == null ? null : teardownRequestSchema.safeParse(json);
   if (parsed == null || !parsed.success) {
     ctx.status = 400;
-    ctx.body = { error: "Invalid request body", success: false };
+    ctx.body = { error: "Invalid request body" };
     return;
   }
-  await engine.teardown(parsed.data.preconditions, parsed.data.data);
+  const items = parsed.data.batch.map((b) => ({
+    data: b.data,
+    names: b.preconditions,
+    runId: b.runId
+  }));
+  const results = await engine.teardown(items);
   ctx.status = 200;
-  ctx.body = { success: true };
+  ctx.body = { results: toTeardownResults(results) };
 }
 function lastPathSegment(path) {
   const segments = path.split("/").filter((s) => s.length > 0);

package/dist/lockfile.d.ts

@@ -1,8 +1,8 @@
 import { Codec } from '@ripplo/spec';
 import { z } from 'zod';
 import { CompileResult } from './compiler.js';
-import './builder-BMjy83Iy.js';
-import './types-16SB7zjP.js';
+import './builder-DiVz3t1D.js';
+import './types-BzZrl65Z.js';
 import './step-De52hTLd.js';
 
 declare const LOCKFILE_RELATIVE_PATH = ".ripplo/ripplo.lock";
@@ -62,6 +62,12 @@ declare const lockfileBodyV2Schema: z.ZodObject<{
                     name: z.ZodOptional<z.ZodString>;
                     role: z.ZodString;
                 }, z.core.$strip>], "by">;
+                modifier: z.ZodOptional<z.ZodEnum<{
+                    Alt: "Alt";
+                    Control: "Control";
+                    Meta: "Meta";
+                    Shift: "Shift";
+                }>>;
                 type: z.ZodLiteral<"click">;
                 id: z.ZodString;
                 label: z.ZodOptional<z.ZodString>;

package/dist/lockfile.js

@@ -237,7 +237,12 @@ var gotoNode = z7.object({
   type: z7.literal("goto"),
   url: stringValueRefSchema
 });
-var clickNode = z7.object({ ...nodeBase, locator: locatorSchema, type: z7.literal("click") });
+var clickNode = z7.object({
+  ...nodeBase,
+  locator: locatorSchema,
+  modifier: z7.enum(["Alt", "Control", "Meta", "Shift"]).optional(),
+  type: z7.literal("click")
+});
 var fillNode = z7.object({
   ...nodeBase,
   locator: locatorSchema,