@ripplo/testing 0.0.8 → 0.0.10

package/dist/{builder-DTWMrbuv.d.ts → builder-1kySbit_.d.ts}

@@ -1,10 +1,14 @@
 import { z } from 'zod';
 import { S as Step } from './step-DLfkKI3V.js';
 
+declare const DEFAULT_WATCH_PATHS: ReadonlyArray<string>;
+declare const DEFAULT_IGNORE_PATHS: ReadonlyArray<string>;
 declare const dslConfigSchema: z.ZodObject<{
     appUrl: z.ZodString;
+    ignorePaths: z.ZodOptional<z.ZodArray<z.ZodString>>;
     preconditionsUrl: z.ZodString;
     projectId: z.ZodString;
+    watchPaths: z.ZodOptional<z.ZodArray<z.ZodString>>;
     webhookSecret: z.ZodString;
 }, z.core.$strip>;
 type DslConfig = z.infer<typeof dslConfigSchema>;
@@ -130,4 +134,4 @@ interface RipploBuilder {
 }
 declare function createRipplo(rawConfig: DslConfig): RipploBuilder;
 
-export { type CookieEntry as C, type DslConfig as D, type Precondition as P, type RipploBuilder as R, type SetupContext as S, type TeardownContext as T, type CookieOptions as a, type PreconditionDeps as b, type PreconditionImpl as c, type PreconditionRecord as d, type ResolveDeps as e, createRipplo as f };
+export { type CookieEntry as C, DEFAULT_IGNORE_PATHS as D, type Precondition as P, type RipploBuilder as R, type SetupContext as S, type TeardownContext as T, type CookieOptions as a, DEFAULT_WATCH_PATHS as b, type DslConfig as c, type PreconditionDeps as d, type PreconditionImpl as e, type PreconditionRecord as f, type ResolveDeps as g, createRipplo as h };

package/dist/{chunk-KWUKVAGI.js → chunk-7ETQVVAA.js}

@@ -1,9 +1,31 @@
 // src/types.ts
 import { z } from "zod";
+var DEFAULT_WATCH_PATHS = [
+  "src/**",
+  "app/**",
+  "apps/**",
+  "pages/**",
+  "routes/**",
+  "components/**"
+];
+var DEFAULT_IGNORE_PATHS = [
+  "**/*.gen.*",
+  "**/generated/**",
+  "**/*.d.ts",
+  "**/*.test.*",
+  "**/*.spec.*",
+  "**/node_modules/**",
+  "**/dist/**",
+  "**/build/**",
+  ".ripplo/**",
+  "**/*.md"
+];
 var dslConfigSchema = z.object({
   appUrl: z.string(),
+  ignorePaths: z.array(z.string()).optional(),
   preconditionsUrl: z.string(),
   projectId: z.string(),
+  watchPaths: z.array(z.string()).optional(),
   webhookSecret: z.string()
 });
 function readTestValue(value) {
@@ -216,6 +238,8 @@ function buildSetCookieHeader(cookie) {
 }
 
 export {
+  DEFAULT_WATCH_PATHS,
+  DEFAULT_IGNORE_PATHS,
   dslConfigSchema,
   readPreconditionName,
   createEngine,

package/dist/{chunk-AQ52MYXE.js → chunk-LEIKZ6BE.js}

@@ -8,9 +8,16 @@ function compile(ripplo) {
   const preconditionDefs = ripplo.getPreconditions();
   const testDefs = ripplo.getTests();
   validateUniqueIds(testDefs);
-  const tests = testDefs.map((def) => compileTest(def));
-  const graph = compileGraph(preconditionDefs, testDefs);
-  return { config: ripplo.getConfig(), graph, tests };
+  const preconditions = {};
+  preconditionDefs.forEach((def) => {
+    preconditions[def.name] = {
+      depends: [...def.dependsOn],
+      description: def.description,
+      returns: [...def.returns]
+    };
+  });
+  const tests = testDefs.map((def) => compileTest(def, preconditionDefs));
+  return { config: ripplo.getConfig(), preconditions, tests };
 }
 function validateUniqueIds(defs) {
   const seen = /* @__PURE__ */ new Map();
@@ -22,7 +29,7 @@ function validateUniqueIds(defs) {
     seen.set(def.id, def.name);
   });
 }
-function compileTest(def) {
+function compileTest(def, preconditionDefs) {
   const slug = def.id;
   const { accessedKeys, vars } = buildPlaceholderVars(def.requiresKeys);
   const startsAtUrl = def.startsAtFn == null ? void 0 : def.startsAtFn(vars);
@@ -36,12 +43,15 @@ function compileTest(def) {
       "Test requires preconditions but never references their data \u2014 destructure and use precondition data in steps()"
     );
   }
+  const resolvedPreconditions = resolveDependencyChain(def.requires, preconditionDefs);
   return {
     additionalChecks: [],
     description: def.description,
     expectedOutcome: def.expectedOutcome,
     implemented: def.implemented,
     name: def.name,
+    preconditions: resolvedPreconditions,
+    requiresKeys: { ...def.requiresKeys },
     slug,
     spec,
     warnings
@@ -89,35 +99,6 @@ function compileNode(step, id, next) {
   const { label, node: raw } = readStep(step);
   return { ...raw, id, label, next };
 }
-function compileGraph(preconditionDefs, testDefs) {
-  const preconditions = {};
-  preconditionDefs.forEach((def) => {
-    preconditions[def.name] = {
-      depends: [...def.dependsOn],
-      description: def.description,
-      returns: [...def.returns]
-    };
-  });
-  const states = {};
-  const edges = [];
-  testDefs.forEach((def) => {
-    if (!def.implemented || def.startsAtFn == null) {
-      return;
-    }
-    const resolved = resolveDependencyChain(def.requires, preconditionDefs);
-    const { vars } = buildPlaceholderVars(def.requiresKeys);
-    const route = def.startsAtFn(vars);
-    const stateId = deriveStateId(resolved, route);
-    states[stateId] = { preconditions: [...resolved], route };
-    edges.push({
-      from: stateId,
-      requiresKeys: def.requiresKeys,
-      to: stateId,
-      workflow: def.id
-    });
-  });
-  return { edges, preconditions, states };
-}
 function resolveDependencyChain(requires, preconditionDefs) {
   const defsByName = new Map(preconditionDefs.map((d) => [d.name, d]));
   const resolved = [];
@@ -137,13 +118,6 @@ function resolveDependencyChain(requires, preconditionDefs) {
   });
   return resolved;
 }
-function deriveStateId(preconditions, route) {
-  const sorted = preconditions.toSorted((a, b) => a.localeCompare(b));
-  return slugify(`${sorted.join("-")}-${route}`);
-}
-function slugify(input) {
-  return input.toLowerCase().replaceAll(/[^a-z0-9]+/g, "-").replaceAll(/^-|-$/g, "");
-}
 
 export {
   compile

package/dist/compiler.d.ts

@@ -1,11 +1,11 @@
-import { StateGraph, WorkflowSpec } from '@ripplo/spec';
-import { D as DslConfig, R as RipploBuilder } from './builder-DTWMrbuv.js';
+import { Precondition, WorkflowSpec } from '@ripplo/spec';
+import { c as DslConfig, R as RipploBuilder } from './builder-1kySbit_.js';
 import 'zod';
 import './step-DLfkKI3V.js';
 
 interface CompileResult {
     readonly config: DslConfig;
-    readonly graph: StateGraph;
+    readonly preconditions: Record<string, Precondition>;
     readonly tests: ReadonlyArray<CompiledTest>;
 }
 interface CompiledTest {
@@ -14,6 +14,8 @@ interface CompiledTest {
     readonly expectedOutcome: string;
     readonly implemented: boolean;
     readonly name: string;
+    readonly preconditions: ReadonlyArray<string>;
+    readonly requiresKeys: Record<string, string>;
     readonly slug: string;
     readonly spec: WorkflowSpec;
     readonly warnings: ReadonlyArray<string>;

package/dist/compiler.js

@@ -1,6 +1,6 @@
 import {
   compile
-} from "./chunk-AQ52MYXE.js";
+} from "./chunk-LEIKZ6BE.js";
 import "./chunk-MGATMMCZ.js";
 export {
   compile

package/dist/express.d.ts

@@ -1,5 +1,5 @@
 import { Router } from 'express';
-import { R as RipploBuilder } from './builder-DTWMrbuv.js';
+import { R as RipploBuilder } from './builder-1kySbit_.js';
 import 'zod';
 import './step-DLfkKI3V.js';
 import '@ripplo/spec';

package/dist/express.js

@@ -4,7 +4,7 @@ import {
   serializeCookie,
   teardownRequestSchema,
   verifyWebhookSignature
-} from "./chunk-KWUKVAGI.js";
+} from "./chunk-7ETQVVAA.js";
 
 // src/adapters/express.ts
 import { Router, json } from "express";

package/dist/fastify.d.ts

@@ -1,5 +1,5 @@
 import { FastifyInstance } from 'fastify';
-import { R as RipploBuilder } from './builder-DTWMrbuv.js';
+import { R as RipploBuilder } from './builder-1kySbit_.js';
 import 'zod';
 import './step-DLfkKI3V.js';
 import '@ripplo/spec';

package/dist/fastify.js

@@ -5,7 +5,7 @@ import {
   serializeCookie,
   teardownRequestSchema,
   verifyWebhookSignature
-} from "./chunk-KWUKVAGI.js";
+} from "./chunk-7ETQVVAA.js";
 
 // src/adapters/fastify.ts
 function registerFastifyHandler({

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { C as CookieEntry, R as RipploBuilder } from './builder-DTWMrbuv.js';
-export { a as CookieOptions, D as DslConfig, P as Precondition, b as PreconditionDeps, c as PreconditionImpl, d as PreconditionRecord, e as ResolveDeps, S as SetupContext, T as TeardownContext, f as createRipplo } from './builder-DTWMrbuv.js';
+import { C as CookieEntry, R as RipploBuilder } from './builder-1kySbit_.js';
+export { a as CookieOptions, D as DEFAULT_IGNORE_PATHS, b as DEFAULT_WATCH_PATHS, c as DslConfig, P as Precondition, d as PreconditionDeps, e as PreconditionImpl, f as PreconditionRecord, g as ResolveDeps, S as SetupContext, T as TeardownContext, h as createRipplo } from './builder-1kySbit_.js';
 import { CompileResult } from './compiler.js';
 export { CompiledTest, compile } from './compiler.js';
 export { D as DslNodeInput } from './step-DLfkKI3V.js';

package/dist/index.js

@@ -1,15 +1,17 @@
 import {
   compile
-} from "./chunk-AQ52MYXE.js";
+} from "./chunk-LEIKZ6BE.js";
 import "./chunk-MGATMMCZ.js";
 import {
+  DEFAULT_IGNORE_PATHS,
+  DEFAULT_WATCH_PATHS,
   buildSetCookieHeader,
   createEngine,
   dslConfigSchema,
   readPreconditionName,
   serializeCookie,
   verifyWebhookSignature
-} from "./chunk-KWUKVAGI.js";
+} from "./chunk-7ETQVVAA.js";
 
 // src/builder.ts
 function createRipplo(rawConfig) {
@@ -637,6 +639,8 @@ var RULES = [
   expectedOutcomeKeywordCoverage
 ];
 export {
+  DEFAULT_IGNORE_PATHS,
+  DEFAULT_WATCH_PATHS,
   buildSetCookieHeader,
   compile,
   createEngine,

package/dist/lockfile.d.ts

@@ -1,33 +1,21 @@
 import { Codec } from '@ripplo/spec';
 import { z } from 'zod';
 import { CompileResult } from './compiler.js';
-import './builder-DTWMrbuv.js';
+import './builder-1kySbit_.js';
 import './step-DLfkKI3V.js';
 
 declare const LOCKFILE_RELATIVE_PATH = ".ripplo/ripplo.lock";
 declare const lockfileBodySchema: z.ZodObject<{
-    graph: z.ZodObject<{
-        edges: z.ZodArray<z.ZodObject<{
-            from: z.ZodString;
-            requiresKeys: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-            to: z.ZodString;
-            workflow: z.ZodString;
-        }, z.core.$strip>>;
-        preconditions: z.ZodRecord<z.ZodString, z.ZodObject<{
-            depends: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            description: z.ZodString;
-            returns: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        }, z.core.$strip>>;
-        states: z.ZodRecord<z.ZodString, z.ZodObject<{
-            preconditions: z.ZodArray<z.ZodString>;
-            route: z.ZodString;
-        }, z.core.$strip>>;
-    }, z.core.$strip>;
-    tests: z.ZodArray<z.ZodObject<{
+    preconditions: z.ZodRecord<z.ZodString, z.ZodObject<{
+        depends: z.ZodOptional<z.ZodArray<z.ZodString>>;
         description: z.ZodString;
+        returns: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+    tests: z.ZodArray<z.ZodObject<{
         expectedOutcome: z.ZodString;
-        implemented: z.ZodBoolean;
         name: z.ZodString;
+        preconditions: z.ZodArray<z.ZodString>;
+        requiresKeys: z.ZodRecord<z.ZodString, z.ZodString>;
         slug: z.ZodString;
         spec: z.ZodObject<{
             entryNode: z.ZodString;

package/dist/lockfile.js

@@ -124,84 +124,39 @@ function migrateStep(state, data, version) {
 }
 
 // ../spec/src/codecs.ts
-import { z as z11 } from "zod";
-
-// ../spec/src/graph.ts
-import { z as z5 } from "zod";
-
-// ../spec/src/edge.ts
-import { z as z2 } from "zod";
-var edgeSchema = z2.object({
-  from: z2.string().min(1).describe("Key of the source state in the states record"),
-  requiresKeys: z2.record(z2.string(), z2.string()).optional().describe(
-    "Maps workflow variable namespace to precondition name. Used by the runtime to namespace batch precondition data into dot-namespaced variables (e.g. { project: 'data:project' } maps projectId \u2192 project.projectId)."
-  ),
-  to: z2.string().min(1).describe("Key of the target state in the states record"),
-  workflow: z2.string().min(1).describe(
-    "Filename (without .json) of the workflow in .ripplo/workflows/ that executes this edge"
-  )
-}).describe("A directed edge between two states, executed by a workflow");
+import { z as z8 } from "zod";
 
 // ../spec/src/precondition.ts
-import { z as z3 } from "zod";
-var preconditionSchema = z3.object({
-  depends: z3.array(z3.string().min(1)).optional().describe(
+import { z as z2 } from "zod";
+var preconditionSchema = z2.object({
+  depends: z2.array(z2.string().min(1)).optional().describe(
     "Names of other preconditions that must be satisfied first. Resolved via topological sort; cycles are rejected at validation time."
   ),
-  description: z3.string().min(1).describe("Human-readable description of what this precondition ensures"),
-  returns: z3.array(z3.string().min(1)).optional().describe(
+  description: z2.string().min(1).describe("Human-readable description of what this precondition ensures"),
+  returns: z2.array(z2.string().min(1)).optional().describe(
     "Keys that the execute response's data field will contain. e.g. ['projectId', 'workflowId']. These are used for route param interpolation ({{projectId}}) and workflow variables. Declared here so generated types are strongly typed per precondition."
   )
 }).describe("A named precondition declared at the graph level. States reference these by name.");
 
-// ../spec/src/state.ts
-import { z as z4 } from "zod";
-var stateNodeSchema = z4.object({
-  preconditions: z4.array(z4.string().min(1)).describe("Ordered list of precondition names to satisfy before entering this state"),
-  route: z4.string().min(1).describe(
-    "URL pattern with {{placeholders}} for dynamic segments, e.g. '/projects/{{projectId}}/settings'"
-  )
-}).describe(
-  "A distinct application state \u2014 a unique combination of location, auth context, and data conditions"
-);
-
-// ../spec/src/graph.ts
-var MAX_STATES = 1e3;
-var MAX_EDGES = 5e3;
-var MAX_PRECONDITIONS = 500;
-var stateGraphSchema = z5.object({
-  edges: z5.array(edgeSchema).max(MAX_EDGES).describe("Directed edges between states, each executed by a workflow"),
-  preconditions: z5.record(z5.string().max(200), preconditionSchema).refine(
-    (obj) => Object.keys(obj).length <= MAX_PRECONDITIONS,
-    `Graph has more than ${String(MAX_PRECONDITIONS)} preconditions`
-  ).describe(
-    "Named preconditions keyed by name (e.g. 'auth:admin', 'data:three-projects'). States reference these by name."
-  ),
-  states: z5.record(z5.string().max(200), stateNodeSchema).refine(
-    (obj) => Object.keys(obj).length <= MAX_STATES,
-    `Graph has more than ${String(MAX_STATES)} states`
-  ).describe("States keyed by stable ID (kebab-case)")
-}).describe("Ripplo State Graph \u2014 models application states, edges, and executable preconditions");
-
 // ../spec/src/schema.ts
-import { z as z10 } from "zod";
+import { z as z7 } from "zod";
 
 // ../spec/src/locators.ts
-import { z as z6 } from "zod";
-var testIdLocator = z6.object({
-  by: z6.literal("testId"),
-  value: z6.string().min(1)
+import { z as z3 } from "zod";
+var testIdLocator = z3.object({
+  by: z3.literal("testId"),
+  value: z3.string().min(1)
 });
-var roleLocator = z6.object({
-  by: z6.literal("role"),
-  name: z6.string().optional(),
-  role: z6.string().min(1)
+var roleLocator = z3.object({
+  by: z3.literal("role"),
+  name: z3.string().optional(),
+  role: z3.string().min(1)
 });
-var locatorSchema = z6.discriminatedUnion("by", [testIdLocator, roleLocator]);
+var locatorSchema = z3.discriminatedUnion("by", [testIdLocator, roleLocator]);
 
 // ../spec/src/operators.ts
-import { z as z7 } from "zod";
-var comparisonOperator = z7.enum([
+import { z as z4 } from "zod";
+var comparisonOperator = z4.enum([
   "equals",
   "notEquals",
   "contains",
@@ -209,7 +164,7 @@ var comparisonOperator = z7.enum([
   "endsWith",
   "matches"
 ]);
-var numericOperator = z7.enum([
+var numericOperator = z4.enum([
   "equals",
   "notEquals",
   "greaterThan",
@@ -219,241 +174,241 @@ var numericOperator = z7.enum([
 ]);
 
 // ../spec/src/value-ref.ts
-import { z as z8 } from "zod";
-var staticValueSchema = z8.object({
-  type: z8.literal("static"),
-  value: z8.union([z8.string(), z8.number(), z8.boolean()])
+import { z as z5 } from "zod";
+var staticValueSchema = z5.object({
+  type: z5.literal("static"),
+  value: z5.union([z5.string(), z5.number(), z5.boolean()])
 });
-var variableRefSchema = z8.object({
-  name: z8.string().min(1),
-  type: z8.literal("variable")
+var variableRefSchema = z5.object({
+  name: z5.string().min(1),
+  type: z5.literal("variable")
 });
-var valueRefSchema = z8.discriminatedUnion("type", [staticValueSchema, variableRefSchema]);
-var stringValueRefSchema = z8.discriminatedUnion("type", [
-  z8.object({ type: z8.literal("static"), value: z8.string() }),
+var valueRefSchema = z5.discriminatedUnion("type", [staticValueSchema, variableRefSchema]);
+var stringValueRefSchema = z5.discriminatedUnion("type", [
+  z5.object({ type: z5.literal("static"), value: z5.string() }),
   variableRefSchema
 ]);
-var numericValueRefSchema = z8.discriminatedUnion("type", [
-  z8.object({ type: z8.literal("static"), value: z8.number().int().nonnegative() }),
+var numericValueRefSchema = z5.discriminatedUnion("type", [
+  z5.object({ type: z5.literal("static"), value: z5.number().int().nonnegative() }),
   variableRefSchema
 ]);
 
 // ../spec/src/variables.ts
-import { z as z9 } from "zod";
-var variableDefSchema = z9.discriminatedUnion("type", [
-  z9.object({
-    default: z9.string().optional(),
-    type: z9.literal("string")
+import { z as z6 } from "zod";
+var variableDefSchema = z6.discriminatedUnion("type", [
+  z6.object({
+    default: z6.string().optional(),
+    type: z6.literal("string")
   }),
-  z9.object({
-    default: z9.number().optional(),
-    type: z9.literal("number")
+  z6.object({
+    default: z6.number().optional(),
+    type: z6.literal("number")
   }),
-  z9.object({
-    default: z9.boolean().optional(),
-    type: z9.literal("boolean")
+  z6.object({
+    default: z6.boolean().optional(),
+    type: z6.literal("boolean")
   }),
-  z9.object({
-    key: z9.string().min(1),
-    type: z9.literal("env")
+  z6.object({
+    key: z6.string().min(1),
+    type: z6.literal("env")
   })
 ]);
 
 // ../spec/src/schema.ts
 var nodeBase = {
-  comment: z10.string().max(2e3).optional(),
-  id: z10.string().min(1).max(200),
-  label: z10.string().max(500).optional(),
-  next: z10.string().max(200).optional(),
-  timeout: z10.number().int().positive().optional()
+  comment: z7.string().max(2e3).optional(),
+  id: z7.string().min(1).max(200),
+  label: z7.string().max(500).optional(),
+  next: z7.string().max(200).optional(),
+  timeout: z7.number().int().positive().optional()
 };
 var MAX_NODES_PER_WORKFLOW = 500;
-var gotoNode = z10.object({
+var gotoNode = z7.object({
   ...nodeBase,
-  type: z10.literal("goto"),
+  type: z7.literal("goto"),
   url: stringValueRefSchema
 });
-var clickNode = z10.object({ ...nodeBase, locator: locatorSchema, type: z10.literal("click") });
-var fillNode = z10.object({
+var clickNode = z7.object({ ...nodeBase, locator: locatorSchema, type: z7.literal("click") });
+var fillNode = z7.object({
   ...nodeBase,
   locator: locatorSchema,
-  type: z10.literal("fill"),
+  type: z7.literal("fill"),
   value: stringValueRefSchema
 });
-var selectNode = z10.object({
+var selectNode = z7.object({
   ...nodeBase,
   locator: locatorSchema,
-  type: z10.literal("select"),
+  type: z7.literal("select"),
   value: stringValueRefSchema
 });
-var hoverNode = z10.object({ ...nodeBase, locator: locatorSchema, type: z10.literal("hover") });
-var pressNode = z10.object({
+var hoverNode = z7.object({ ...nodeBase, locator: locatorSchema, type: z7.literal("hover") });
+var pressNode = z7.object({
   ...nodeBase,
-  key: z10.string().min(1),
+  key: z7.string().min(1),
   locator: locatorSchema.optional(),
-  type: z10.literal("press")
+  type: z7.literal("press")
 });
-var checkNode = z10.object({ ...nodeBase, locator: locatorSchema, type: z10.literal("check") });
-var uncheckNode = z10.object({ ...nodeBase, locator: locatorSchema, type: z10.literal("uncheck") });
-var setViewportNode = z10.object({
+var checkNode = z7.object({ ...nodeBase, locator: locatorSchema, type: z7.literal("check") });
+var uncheckNode = z7.object({ ...nodeBase, locator: locatorSchema, type: z7.literal("uncheck") });
+var setViewportNode = z7.object({
   ...nodeBase,
-  height: z10.number().int().positive(),
-  type: z10.literal("setViewport"),
-  width: z10.number().int().positive()
+  height: z7.number().int().positive(),
+  type: z7.literal("setViewport"),
+  width: z7.number().int().positive()
 });
-var failNode = z10.object({ ...nodeBase, message: z10.string().min(1), type: z10.literal("fail") });
-var setVariableNode = z10.object({
+var failNode = z7.object({ ...nodeBase, message: z7.string().min(1), type: z7.literal("fail") });
+var setVariableNode = z7.object({
   ...nodeBase,
-  type: z10.literal("setVariable"),
+  type: z7.literal("setVariable"),
   value: valueRefSchema,
-  variable: z10.string().min(1)
+  variable: z7.string().min(1)
 });
-var extractTextNode = z10.object({
+var extractTextNode = z7.object({
   ...nodeBase,
   locator: locatorSchema,
-  type: z10.literal("extractText"),
-  variable: z10.string().min(1)
+  type: z7.literal("extractText"),
+  variable: z7.string().min(1)
 });
-var uploadNode = z10.object({
+var uploadNode = z7.object({
   ...nodeBase,
-  files: z10.array(z10.string()).min(1),
+  files: z7.array(z7.string()).min(1),
   locator: locatorSchema,
-  type: z10.literal("upload")
+  type: z7.literal("upload")
 });
-var dblclickNode = z10.object({
+var dblclickNode = z7.object({
   ...nodeBase,
   locator: locatorSchema,
-  type: z10.literal("dblclick")
+  type: z7.literal("dblclick")
 });
-var dragNode = z10.object({
+var dragNode = z7.object({
   ...nodeBase,
   source: locatorSchema,
   target: locatorSchema,
-  type: z10.literal("drag")
+  type: z7.literal("drag")
 });
-var scrollIntoViewNode = z10.object({
+var scrollIntoViewNode = z7.object({
   ...nodeBase,
   locator: locatorSchema,
-  type: z10.literal("scrollIntoView")
+  type: z7.literal("scrollIntoView")
 });
-var typeNode = z10.object({
+var typeNode = z7.object({
   ...nodeBase,
   locator: locatorSchema,
-  type: z10.literal("type"),
+  type: z7.literal("type"),
   value: stringValueRefSchema
 });
-var focusNode = z10.object({
+var focusNode = z7.object({
   ...nodeBase,
   locator: locatorSchema,
-  type: z10.literal("focus")
+  type: z7.literal("focus")
 });
-var clearNode = z10.object({ ...nodeBase, locator: locatorSchema, type: z10.literal("clear") });
-var rightClickNode = z10.object({
+var clearNode = z7.object({ ...nodeBase, locator: locatorSchema, type: z7.literal("clear") });
+var rightClickNode = z7.object({
   ...nodeBase,
   locator: locatorSchema,
-  type: z10.literal("rightClick")
+  type: z7.literal("rightClick")
 });
-var handleDialogNode = z10.object({
+var handleDialogNode = z7.object({
   ...nodeBase,
-  action: z10.enum(["accept", "dismiss"]),
-  promptText: z10.string().optional(),
-  type: z10.literal("handleDialog")
+  action: z7.enum(["accept", "dismiss"]),
+  promptText: z7.string().optional(),
+  type: z7.literal("handleDialog")
 });
-var clipboardNode = z10.object({
+var clipboardNode = z7.object({
   ...nodeBase,
-  action: z10.enum(["read", "write"]),
-  type: z10.literal("clipboard"),
+  action: z7.enum(["read", "write"]),
+  type: z7.literal("clipboard"),
   value: stringValueRefSchema.optional(),
-  variable: z10.string().min(1).optional()
+  variable: z7.string().min(1).optional()
 });
-var setPermissionNode = z10.object({
+var setPermissionNode = z7.object({
   ...nodeBase,
-  permission: z10.string().min(1),
-  state: z10.enum(["granted", "prompt"]),
-  type: z10.literal("setPermission")
+  permission: z7.string().min(1),
+  state: z7.enum(["granted", "prompt"]),
+  type: z7.literal("setPermission")
 });
-var assertVisibleNode = z10.object({
+var assertVisibleNode = z7.object({
   ...nodeBase,
   locator: locatorSchema,
-  type: z10.literal("assertVisible")
+  type: z7.literal("assertVisible")
 });
-var assertNotVisibleNode = z10.object({
+var assertNotVisibleNode = z7.object({
   ...nodeBase,
   locator: locatorSchema,
-  type: z10.literal("assertNotVisible")
+  type: z7.literal("assertNotVisible")
 });
-var assertTextNode = z10.object({
+var assertTextNode = z7.object({
   ...nodeBase,
   expected: stringValueRefSchema,
   locator: locatorSchema,
   operator: comparisonOperator,
-  type: z10.literal("assertText")
+  type: z7.literal("assertText")
 });
-var assertUrlNode = z10.object({
+var assertUrlNode = z7.object({
   ...nodeBase,
   expected: stringValueRefSchema,
   operator: comparisonOperator,
-  type: z10.literal("assertUrl")
+  type: z7.literal("assertUrl")
 });
-var assertCountNode = z10.object({
+var assertCountNode = z7.object({
   ...nodeBase,
   expected: numericValueRefSchema,
   locator: locatorSchema,
   operator: numericOperator,
-  type: z10.literal("assertCount")
+  type: z7.literal("assertCount")
 });
-var assertValueNode = z10.object({
+var assertValueNode = z7.object({
   ...nodeBase,
   expected: stringValueRefSchema,
   locator: locatorSchema,
   operator: comparisonOperator,
-  type: z10.literal("assertValue")
+  type: z7.literal("assertValue")
 });
-var assertAttributeNode = z10.object({
+var assertAttributeNode = z7.object({
   ...nodeBase,
-  attribute: z10.string().min(1),
+  attribute: z7.string().min(1),
   expected: stringValueRefSchema,
   locator: locatorSchema,
   operator: comparisonOperator,
-  type: z10.literal("assertAttribute")
+  type: z7.literal("assertAttribute")
 });
-var assertEnabledNode = z10.object({
+var assertEnabledNode = z7.object({
   ...nodeBase,
   locator: locatorSchema,
-  type: z10.literal("assertEnabled")
+  type: z7.literal("assertEnabled")
 });
-var assertDisabledNode = z10.object({
+var assertDisabledNode = z7.object({
   ...nodeBase,
   locator: locatorSchema,
-  type: z10.literal("assertDisabled")
+  type: z7.literal("assertDisabled")
 });
-var assertTitleNode = z10.object({
+var assertTitleNode = z7.object({
   ...nodeBase,
   expected: stringValueRefSchema,
   operator: comparisonOperator,
-  type: z10.literal("assertTitle")
+  type: z7.literal("assertTitle")
 });
-var assertCheckedNode = z10.object({
+var assertCheckedNode = z7.object({
   ...nodeBase,
   locator: locatorSchema,
-  type: z10.literal("assertChecked")
+  type: z7.literal("assertChecked")
 });
-var assertNotCheckedNode = z10.object({
+var assertNotCheckedNode = z7.object({
   ...nodeBase,
   locator: locatorSchema,
-  type: z10.literal("assertNotChecked")
+  type: z7.literal("assertNotChecked")
 });
-var assertFocusedNode = z10.object({
+var assertFocusedNode = z7.object({
   ...nodeBase,
   locator: locatorSchema,
-  type: z10.literal("assertFocused")
+  type: z7.literal("assertFocused")
 });
-var assertNotFocusedNode = z10.object({
+var assertNotFocusedNode = z7.object({
   ...nodeBase,
   locator: locatorSchema,
-  type: z10.literal("assertNotFocused")
+  type: z7.literal("assertNotFocused")
 });
-var specNodeSchema = z10.discriminatedUnion("type", [
+var specNodeSchema = z7.discriminatedUnion("type", [
   gotoNode,
   clickNode,
   fillNode,
@@ -492,59 +447,55 @@ var specNodeSchema = z10.discriminatedUnion("type", [
   assertFocusedNode,
   assertNotFocusedNode
 ]);
-var workflowSpecSchema = z10.object({
-  entryNode: z10.string().min(1).max(200),
-  nodes: z10.record(z10.string().max(200), specNodeSchema).refine(
+var workflowSpecSchema = z7.object({
+  entryNode: z7.string().min(1).max(200),
+  nodes: z7.record(z7.string().max(200), specNodeSchema).refine(
     (nodes) => Object.keys(nodes).length <= MAX_NODES_PER_WORKFLOW,
     `Workflow has more than ${String(MAX_NODES_PER_WORKFLOW)} nodes`
   ),
-  variableNamespaces: z10.record(z10.string().max(200), z10.string().max(500)).optional(),
-  variables: z10.record(z10.string().max(200), variableDefSchema).optional()
+  variableNamespaces: z7.record(z7.string().max(200), z7.string().max(500)).optional(),
+  variables: z7.record(z7.string().max(200), variableDefSchema).optional()
 });
 
 // ../spec/src/codecs.ts
-var preconditionMapSchema = z11.record(z11.string().max(200), preconditionSchema);
+var preconditionMapSchema = z8.record(z8.string().max(200), preconditionSchema);
 var looksLikeWorkflowSpec = {
   assumedVersion: 1,
   detect: (raw) => typeof raw === "object" && raw !== null && "entryNode" in raw && "nodes" in raw
 };
-var looksLikeStateGraph = {
-  assumedVersion: 1,
-  detect: (raw) => typeof raw === "object" && raw !== null && "edges" in raw && "states" in raw && "preconditions" in raw
-};
 var looksLikePreconditionMap = {
   assumedVersion: 1,
   detect: (raw) => typeof raw === "object" && raw !== null && !Array.isArray(raw) && !("__codec" in raw)
 };
 var workflowSpecCodec = defineCodec("workflow-spec").legacy(looksLikeWorkflowSpec).initial(workflowSpecSchema).build();
-var stateGraphCodec = defineCodec("state-graph").legacy(looksLikeStateGraph).initial(stateGraphSchema).build();
 var preconditionMapCodec = defineCodec("precondition-map").legacy(looksLikePreconditionMap).initial(preconditionMapSchema).build();
 
 // src/lockfile.ts
-import { z as z12 } from "zod";
+import { z as z9 } from "zod";
 var LOCKFILE_RELATIVE_PATH = ".ripplo/ripplo.lock";
 var MAX_TESTS = 5e3;
-var compiledTestSchema = z12.object({
-  description: z12.string().max(2e3),
-  expectedOutcome: z12.string().max(2e3),
-  implemented: z12.boolean(),
-  name: z12.string().max(200),
-  slug: z12.string().max(200),
+var requiresKeysSchema = z9.record(z9.string().max(200), z9.string().max(200));
+var compiledTestSchema = z9.object({
+  expectedOutcome: z9.string().max(2e3),
+  name: z9.string().max(200),
+  preconditions: z9.array(z9.string().max(200)).max(1e3),
+  requiresKeys: requiresKeysSchema,
+  slug: z9.string().max(200),
   spec: workflowSpecSchema
 });
-var lockfileBodySchema = z12.object({
-  graph: stateGraphSchema,
-  tests: z12.array(compiledTestSchema).max(MAX_TESTS)
+var lockfileBodySchema = z9.object({
+  preconditions: z9.record(z9.string().max(200), preconditionSchema),
+  tests: z9.array(compiledTestSchema).max(MAX_TESTS)
 });
 var lockfileCodec = defineCodec("ripplo-lockfile").initial(lockfileBodySchema).build();
 function compileResultToLockfile(result) {
   return {
-    graph: result.graph,
-    tests: result.tests.map((test) => ({
-      description: test.description,
+    preconditions: result.preconditions,
+    tests: result.tests.filter((test) => test.implemented).map((test) => ({
       expectedOutcome: test.expectedOutcome,
-      implemented: test.implemented,
       name: test.name,
+      preconditions: [...test.preconditions],
+      requiresKeys: { ...test.requiresKeys },
       slug: test.slug,
       spec: test.spec
     }))

package/dist/nextjs.d.ts

@@ -1,4 +1,4 @@
-import { R as RipploBuilder } from './builder-DTWMrbuv.js';
+import { R as RipploBuilder } from './builder-1kySbit_.js';
 import 'zod';
 import './step-DLfkKI3V.js';
 import '@ripplo/spec';

package/dist/nextjs.js

@@ -5,7 +5,7 @@ import {
   serializeCookie,
   teardownRequestSchema,
   verifyWebhookSignature
-} from "./chunk-KWUKVAGI.js";
+} from "./chunk-7ETQVVAA.js";
 
 // src/adapters/nextjs.ts
 function createNextHandler({ enabled, ripplo }) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ripplo/testing",
   "description": "TypeScript DSL for defining and running Ripplo e2e workflow tests",
-  "version": "0.0.8",
+  "version": "0.0.10",
   "type": "module",
   "files": [
     "dist"