@ripplo/testing 0.7.9 → 0.7.11

package/dist/index.js

@@ -108,7 +108,13 @@ function not(input) {
   if (isConditionInput(input)) {
     return condLeaf({ kind: "not", predicate: input.predicate });
   }
-  return leaf({ kind: "not", predicate: toPredicate(input) });
+  const predicate = toPredicate(input);
+  if (predicate.kind === "when") {
+    throw new Error(
+      "when() cannot be wrapped in not() \u2014 express the negation in branch conditions"
+    );
+  }
+  return leaf({ kind: "not", predicate });
 }
 function and(...conditions) {
   return condLeaf({ kind: "and", predicates: conditions.map((c) => c.predicate) });
@@ -118,26 +124,52 @@ function count(entity2) {
     is: (n) => condLeaf({ entity: entity2.name, kind: "count", value: n })
   };
 }
-function when(...clauses) {
-  const last = clauses.at(-1);
-  const fallback = last !== void 0 && !isClause(last) ? toPredicate(last) : void 0;
-  const rows = clauses.filter((clause) => isClause(clause));
-  const chain = rows.reduceRight(
-    (otherwise, [condition, consequence]) => ({
-      condition: condition.predicate,
-      consequence: toPredicate(consequence),
-      kind: "when",
-      otherwise
-    }),
-    fallback
-  );
-  if (chain == null) {
-    throw new Error("when() needs at least one [condition, consequence] clause");
+function branch(name) {
+  const close = (condition) => (consequence) => {
+    const resolved = toPredicate(consequence);
+    if (containsWhen(resolved)) {
+      throw new Error(
+        `branch "${name}" nests a when() inside its consequence \u2014 whens are one level deep; split the scenario into another workflow`
+      );
+    }
+    return { __branch: true, branch: { condition, consequence: resolved, name } };
+  };
+  return {
+    expect: close(void 0),
+    if: (condition) => ({
+      expect: close(condition.predicate)
+    })
+  };
+}
+function when(...branches) {
+  if (branches.length === 0) {
+    throw new Error("when() needs at least one branch(...)");
+  }
+  const rows = branches.map((input) => input.branch);
+  const fallbacks = rows.filter((row2) => row2.condition == null);
+  if (fallbacks.length > 1) {
+    throw new Error("when() allows one unconditional branch \u2014 give the others .if(...) conditions");
+  }
+  if (fallbacks.length === 1 && rows.at(-1)?.condition != null) {
+    throw new Error("when() requires the unconditional branch to come last");
   }
-  return leaf(chain);
+  const dup = rows.find((row2, index) => rows.findIndex((r) => r.name === row2.name) !== index);
+  if (dup != null) {
+    throw new Error(`when() branch name "${dup.name}" is used twice \u2014 branch names must be unique`);
+  }
+  return leaf({ branches: rows, kind: "when" });
 }
-function isClause(clause) {
-  return Array.isArray(clause);
+function containsWhen(predicate) {
+  if (predicate.kind === "when") {
+    return true;
+  }
+  if (predicate.kind === "not") {
+    return containsWhen(predicate.predicate);
+  }
+  if (predicate.kind === "and") {
+    return predicate.predicates.some((p) => containsWhen(p));
+  }
+  return false;
 }
 
 // src/util.ts
@@ -676,14 +708,17 @@ function assertPredicateScoped(predicate, given) {
   if (predicate.kind !== "when") {
     return;
   }
-  conditionSingletons(predicate.condition).forEach((name) => {
-    if (!given.has(name)) {
-      throw new Error(
-        `when() conditions on singleton "${name}", which is not in the test's given \u2014 add ${name}.of(...) to given`
-      );
-    }
+  predicate.branches.forEach((row2) => {
+    const names = row2.condition == null ? [] : conditionSingletons(row2.condition);
+    names.forEach((name) => {
+      if (!given.has(name)) {
+        throw new Error(
+          `when() conditions on singleton "${name}", which is not in the workflow's given \u2014 add ${name}.of(...) to given`
+        );
+      }
+    });
+    assertPredicateScoped(row2.consequence, given);
   });
-  assertPredicateScoped(predicate.consequence, given);
 }
 function conditionSingletons(predicate) {
   if (predicate.kind === "singleton") {
@@ -724,7 +759,7 @@ function assignParams(bindings) {
       return {
         counts: { ...acc.counts, [token.base]: ordinal + 1 },
         names: new Map([...acc.names, [b, name]]),
-        params: { ...acc.params, [name]: { example: token.example, valueSpace: token.valueSpace } }
+        params: { ...acc.params, [name]: { valueSpace: token.valueSpace } }
       };
     },
     { counts: {}, names: /* @__PURE__ */ new Map(), params: {} }
@@ -802,11 +837,10 @@ function predicateBindings(predicate) {
       return predicateBindings(predicate.predicate);
     }
     case "when": {
-      return [
-        ...predicateBindings(predicate.condition),
-        ...predicateBindings(predicate.consequence),
-        ...predicate.otherwise == null ? [] : predicateBindings(predicate.otherwise)
-      ];
+      return predicate.branches.flatMap((row2) => [
+        ...row2.condition == null ? [] : predicateBindings(row2.condition),
+        ...predicateBindings(row2.consequence)
+      ]);
     }
     case "and": {
       return predicate.predicates.flatMap((p) => predicateBindings(p));
@@ -958,9 +992,11 @@ function resolvePredicate(predicate, ctx) {
     case "when": {
       return {
         ...predicate,
-        condition: resolvePredicate(predicate.condition, ctx),
-        consequence: resolvePredicate(predicate.consequence, ctx),
-        otherwise: predicate.otherwise == null ? void 0 : resolvePredicate(predicate.otherwise, ctx)
+        branches: predicate.branches.map((row2) => ({
+          condition: row2.condition == null ? void 0 : resolveCondition(row2.condition, ctx),
+          consequence: resolvePredicate(row2.consequence, ctx),
+          name: row2.name
+        }))
       };
     }
     case "and": {
@@ -1004,9 +1040,34 @@ function whereMap(map, ctx) {
 function resolveWhere(value2, ctx) {
   return isWithin2(value2) ? { ...value2, selection: { ...value2.selection, where: whereMap(value2.selection.where, ctx) } } : resolveValue(value2, ctx);
 }
+function resolveCondition(condition, ctx) {
+  switch (condition.kind) {
+    case "singleton": {
+      return {
+        ...condition,
+        assertion: {
+          ...condition.assertion,
+          value: resolveValue(condition.assertion.value, ctx)
+        }
+      };
+    }
+    case "count": {
+      return condition;
+    }
+    case "not": {
+      return { ...condition, predicate: resolveCondition(condition.predicate, ctx) };
+    }
+    case "and": {
+      return {
+        ...condition,
+        predicates: condition.predicates.map((p) => resolveCondition(p, ctx))
+      };
+    }
+  }
+}
 
-// src/test.ts
-function test(intent, fn) {
+// src/workflow.ts
+function workflow(intent, fn) {
   const sourcePath = captureSourcePath();
   if (fn == null) {
     return { spec: stubSpec(intent, sourcePath) };
@@ -1024,6 +1085,7 @@ function test(intent, fn) {
       sourcePath,
       steps: final.steps,
       stub: false,
+      tests: [],
       world: final.world
     }
   };
@@ -1040,32 +1102,32 @@ function stubSpec(intent, sourcePath) {
     sourcePath,
     steps: [],
     stub: true,
+    tests: [],
     world: []
   };
 }
-var TESTS_ANCHOR_PATTERN = /[/\\]\.ripplo[/\\]tests[/\\]([^):]+?)(?::\d+:\d+\)?)?$/;
+var WORKFLOWS_ANCHOR_PATTERN = /[/\\]\.ripplo[/\\]workflows[/\\]([^):]+?)(?::\d+:\d+\)?)?$/;
 function captureSourcePath() {
   const stack = new Error("capture").stack;
   if (stack == null) {
     return void 0;
   }
-  const match = stack.split("\n").map((line) => TESTS_ANCHOR_PATTERN.exec(line)).find((m) => m != null);
+  const match = stack.split("\n").map((line) => WORKFLOWS_ANCHOR_PATTERN.exec(line)).find((m) => m != null);
   const captured = match?.[1];
   return captured == null ? void 0 : captured.replaceAll("\\", "/");
 }
 function slugify(intent) {
   const slug = intent.toLowerCase().replaceAll(/[^a-z0-9]+/g, " ").trim().split(" ").join("-");
   if (slug.length === 0) {
-    throw new Error(`test intent "${intent}" slugifies to an empty string`);
+    throw new Error(`workflow intent "${intent}" slugifies to an empty string`);
   }
   return slug;
 }
 
 // src/params.ts
-function arbitrary(field2, example) {
+function arbitrary(field2) {
   const token = {
     base: `${field2.entity}_${field2.field}`,
-    example,
     valueSpace: field2.valueSpaceName
   };
   return paramBinding(token);
@@ -1357,6 +1419,32 @@ var withinSchema = z2.object({
   selection: selectionSchema
 });
 var wait = z2.union([budgetSchema, z2.undefined()]).optional().transform((value2) => value2);
+var singletonPredicateSchema = z2.object({
+  assertion: singletonAssertionSchema,
+  kind: z2.literal("singleton"),
+  singleton: z2.string().min(1),
+  wait
+});
+var countPredicateSchema = z2.object({
+  entity: z2.string().min(1),
+  kind: z2.literal("count"),
+  value: z2.number().int().nonnegative()
+});
+var conditionSchema = z2.lazy(
+  () => z2.discriminatedUnion("kind", [
+    singletonPredicateSchema,
+    countPredicateSchema,
+    z2.object({ kind: z2.literal("not"), predicate: conditionSchema }),
+    z2.object({ kind: z2.literal("and"), predicates: z2.array(conditionSchema) })
+  ])
+);
+var whenBranchSchema = z2.lazy(
+  () => z2.object({
+    condition: z2.union([conditionSchema, z2.undefined()]).optional().transform((value2) => value2),
+    consequence: predicateSchema,
+    name: z2.string().min(1)
+  })
+);
 var predicateSchema = z2.lazy(
   () => z2.discriminatedUnion("kind", [
     z2.object({ kind: z2.literal("visible"), locator: locatorSchema, wait }),
@@ -1365,12 +1453,7 @@ var predicateSchema = z2.lazy(
     z2.object({ kind: z2.literal("focused"), locator: locatorSchema, wait }),
     z2.object({ kind: z2.literal("value"), locator: locatorSchema, value: stringValueSchema, wait }),
     z2.object({ kind: z2.literal("text"), locator: locatorSchema, value: stringValueSchema, wait }),
-    z2.object({
-      assertion: singletonAssertionSchema,
-      kind: z2.literal("singleton"),
-      singleton: z2.string().min(1),
-      wait
-    }),
+    singletonPredicateSchema,
     z2.object({
       kind: z2.literal("browser"),
       name: browserSingletonSchema,
@@ -1386,17 +1469,8 @@ var predicateSchema = z2.lazy(
     }),
     z2.object({ kind: z2.literal("not"), predicate: predicateSchema }),
     z2.object({ kind: z2.literal("and"), predicates: z2.array(predicateSchema) }),
-    z2.object({
-      entity: z2.string().min(1),
-      kind: z2.literal("count"),
-      value: z2.number().int().nonnegative()
-    }),
-    z2.object({
-      condition: predicateSchema,
-      consequence: predicateSchema,
-      kind: z2.literal("when"),
-      otherwise: z2.union([predicateSchema, z2.undefined()]).optional().transform((value2) => value2)
-    })
+    countPredicateSchema,
+    z2.object({ branches: z2.array(whenBranchSchema), kind: z2.literal("when") })
   ])
 );
 
@@ -1485,7 +1559,6 @@ var stepSchema = z4.object({
   expect: z4.array(predicateSchema).default([])
 });
 var paramSchema = z4.object({
-  example: primitiveSchema.optional(),
   valueSpace: z4.string().min(1)
 });
 var setupSchema = z4.object({
@@ -1497,7 +1570,19 @@ var absenceSchema = z4.object({
   entity: z4.string().min(1),
   where: z4.record(z4.string().min(1), setValueSchema)
 });
-var testSchema = z4.object({
+var resolvedTestSchema = z4.object({
+  absent: z4.array(absenceSchema).default([]),
+  exclusive: z4.array(z4.string().min(1)).default([]),
+  intent: z4.string().min(1),
+  name: z4.string().min(1),
+  params: z4.record(z4.string().min(1), paramSchema),
+  singletons: z4.record(z4.string().min(1), setValueSchema).default({}),
+  slug: z4.string().min(1),
+  steps: z4.array(stepSchema).default([]),
+  workflow: z4.string().min(1),
+  world: z4.array(setupSchema).default([])
+});
+var workflowSchema = z4.object({
   absent: z4.array(absenceSchema).default([]),
   exclusive: z4.array(z4.string().min(1)).default([]),
   intent: z4.string().min(1),
@@ -1508,6 +1593,7 @@ var testSchema = z4.object({
   sourcePath: z4.string().min(1).optional(),
   steps: z4.array(stepSchema).default([]),
   stub: z4.boolean().default(false),
+  tests: z4.array(resolvedTestSchema).default([]),
   world: z4.array(setupSchema).default([])
 });
 var fixtureEntrySchema = z4.object({
@@ -1518,8 +1604,8 @@ var lockfileSchema = z4.object({
   entities: z4.array(entitySchemaSchema),
   fixtures: z4.record(z4.string().min(1), fixtureEntrySchema).default({}),
   singletons: z4.array(singletonSchemaSchema).default([]),
-  tests: z4.array(testSchema),
-  valueSpaces: z4.array(valueSpaceSchema)
+  valueSpaces: z4.array(valueSpaceSchema),
+  workflows: z4.array(workflowSchema)
 });
 var lockfileCodec = defineCodec({ name: "ripplo-lockfile", schema: lockfileSchema });
 
@@ -1531,6 +1617,9 @@ var stepDescriptorSchema = z5.object({
   target: z5.string(),
   value: z5.string()
 });
+function slugify2(name) {
+  return name.toLowerCase().replaceAll(/[^a-z0-9]/g, "-").split("-").filter((part) => part.length > 0).join("-");
+}
 
 // ../spec/src/session.ts
 import { z as z6 } from "zod";
@@ -1618,17 +1707,491 @@ function mountClientEngine(ripplo, impls, { enabled: enabled2 }) {
   Reflect.set(globalThis, CLIENT_MOUNT_KEY, createClientEngine(ripplo, impls));
 }
 
+// src/expand.ts
+var MAX_CANDIDATES = 4096;
+function singletonValuesOf(singletons) {
+  return new Map(
+    singletons.flatMap((singleton2) => {
+      const space = singleton2.valueSpaces.find((s) => s.name === singleton2.schema.valueSpace);
+      return space?.values == null ? [] : [[singleton2.schema.name, space.values]];
+    })
+  );
+}
+function expandWorkflow(workflow2, options) {
+  if (workflow2.stub) {
+    return { ...workflow2, tests: [] };
+  }
+  assertUniqueBranchNames(workflow2);
+  const targets = collectTargets(workflow2.steps);
+  const whenIds = new Map(targets.map((target, index) => [target.when, index]));
+  const sims = proposeCandidates(workflow2, options).map((candidate) => simulate(workflow2, candidate)).filter((sim) => sim != null);
+  if (targets.length === 0) {
+    return { ...workflow2, tests: [requireMainTest(workflow2, sims)] };
+  }
+  const { tests } = targets.reduce(
+    (acc, target) => coverTarget({ acc, sims, target, whenIds, workflow: workflow2 }),
+    { covered: /* @__PURE__ */ new Set(), tests: [] }
+  );
+  return { ...workflow2, tests };
+}
+function resolveValidTest(workflow2, sim, name) {
+  const test = resolveTest(workflow2, sim, name);
+  return danglingRefHeads(test).length === 0 ? test : null;
+}
+function danglingRefHeads(test) {
+  const known = /* @__PURE__ */ new Set([
+    ...test.world.map((setup) => setup.as),
+    ...Object.keys(test.params),
+    ...test.steps.flatMap((step) => createdAliasesIn(step))
+  ]);
+  return [...new Set(collectRefObjects(test).map((ref) => headOf(ref)))].filter(
+    (head) => !known.has(head)
+  );
+}
+function createdAliasesIn(step) {
+  return step.expect.flatMap((predicate) => {
+    if (predicate.kind !== "state" || predicate.assertion.kind === "deleted") {
+      return [];
+    }
+    return [predicate.assertion.as];
+  });
+}
+function coverTarget({ acc, sims, target, whenIds, workflow: workflow2 }) {
+  const key2 = choiceKey(whenIds, target.when, target.index);
+  if (acc.covered.has(key2)) {
+    return { covered: acc.covered, tests: acc.tests };
+  }
+  const picked = sims.filter((s) => s.choices.get(target.when) === target.index).reduce((found, s) => {
+    if (found != null) {
+      return found;
+    }
+    const test = resolveValidTest(workflow2, s, target.name);
+    return test == null ? null : { sim: s, test };
+  }, null);
+  if (picked == null) {
+    throw new Error(
+      `workflow "${workflow2.name}": branch "${target.name}" is unreachable \u2014 no combination of optional entities and singleton values reaches it`
+    );
+  }
+  const reached = [...picked.sim.choices].map(([when2, index]) => choiceKey(whenIds, when2, index));
+  return {
+    covered: /* @__PURE__ */ new Set([...acc.covered, ...reached]),
+    tests: [...acc.tests, picked.test]
+  };
+}
+function choiceKey(whenIds, when2, index) {
+  const id2 = whenIds.get(when2);
+  if (id2 == null) {
+    throw new Error("internal: when node missing from target index");
+  }
+  return `${String(id2)}:${String(index)}`;
+}
+function requireMainTest(workflow2, sims) {
+  const test = sims.reduce(
+    (found, sim) => found ?? resolveValidTest(workflow2, sim, "main"),
+    null
+  );
+  if (test == null) {
+    throw new Error(
+      `workflow "${workflow2.name}": no valid seed found \u2014 steps may reference optional entities no candidate provides, or a condition mentions values the solver cannot pin`
+    );
+  }
+  return test;
+}
+function assertUniqueBranchNames(workflow2) {
+  const names = collectTargets(workflow2.steps).map((target) => target.name);
+  const dup = names.find((name, index) => names.indexOf(name) !== index);
+  if (dup != null) {
+    throw new Error(
+      `workflow "${workflow2.name}": branch name "${dup}" is used twice \u2014 branch names must be unique within a workflow`
+    );
+  }
+}
+function collectTargets(steps) {
+  return steps.flatMap((step) => step.expect.flatMap((predicate) => targetsIn(predicate)));
+}
+function targetsIn(predicate) {
+  if (predicate.kind === "not") {
+    return targetsIn(predicate.predicate);
+  }
+  if (predicate.kind === "and") {
+    return predicate.predicates.flatMap((p) => targetsIn(p));
+  }
+  if (predicate.kind !== "when") {
+    return [];
+  }
+  return predicate.branches.flatMap((row2, index) => [
+    { index, name: row2.name, when: predicate },
+    ...targetsIn(row2.consequence)
+  ]);
+}
+function proposeCandidates(workflow2, options) {
+  const subsets = maybeSubsets(workflow2.maybe);
+  const pinSets = pinAssignments(workflow2, options);
+  if (subsets.length * pinSets.length > MAX_CANDIDATES) {
+    throw new Error(
+      `workflow "${workflow2.name}": too many optional entities and singleton values to solve \u2014 split the workflow or convert maybe(...) entities to of(...)`
+    );
+  }
+  return subsets.flatMap((maybes) => pinSets.map((pins) => ({ maybes, pins })));
+}
+function maybeSubsets(maybe) {
+  const masks = Array.from({ length: 1 << maybe.length }, (_, mask) => mask);
+  return masks.map((mask) => ({ mask, size: maybe.filter((_, i) => (mask & 1 << i) !== 0).length })).toSorted((a, b) => a.size === b.size ? a.mask - b.mask : a.size - b.size).map(({ mask }) => maybe.filter((_, i) => (mask & 1 << i) !== 0));
+}
+function pinAssignments(workflow2, options) {
+  const domains = pinDomains(workflow2, options);
+  return Object.entries(domains).reduce(
+    (acc, [param, domain]) => acc.flatMap((pins) => domain.map((value2) => ({ ...pins, [param]: value2 }))),
+    [{}]
+  );
+}
+function pinDomains(workflow2, options) {
+  const literals = conditionSingletonLiterals(workflow2.steps);
+  return Object.entries(workflow2.singletons).reduce((acc, [name, value2]) => {
+    const param = paramRefOf(value2);
+    const compared = literals.get(name);
+    if (param == null || compared == null) {
+      return acc;
+    }
+    const enumValues = options.singletonValues.get(name);
+    return { ...acc, [param]: withComplements(compared, enumValues) };
+  }, {});
+}
+function conditionSingletonLiterals(steps) {
+  const pairs = steps.flatMap(
+    (step) => step.expect.flatMap((predicate) => conditionLiteralsIn(predicate))
+  );
+  return pairs.reduce(
+    (acc, [name, literal]) => new Map([...acc, [name, [.../* @__PURE__ */ new Set([...acc.get(name) ?? [], literal])]]]),
+    /* @__PURE__ */ new Map()
+  );
+}
+function conditionLiteralsIn(predicate) {
+  if (predicate.kind === "not") {
+    return conditionLiteralsIn(predicate.predicate);
+  }
+  if (predicate.kind === "and") {
+    return predicate.predicates.flatMap((p) => conditionLiteralsIn(p));
+  }
+  if (predicate.kind !== "when") {
+    return [];
+  }
+  return predicate.branches.flatMap((row2) => [
+    ...row2.condition == null ? [] : singletonLiteralsInCondition(row2.condition),
+    ...conditionLiteralsIn(row2.consequence)
+  ]);
+}
+function singletonLiteralsInCondition(condition) {
+  switch (condition.kind) {
+    case "singleton": {
+      const value2 = condition.assertion.value;
+      return value2 == null || typeof value2 !== "object" ? [[condition.singleton, value2]] : [];
+    }
+    case "count": {
+      return [];
+    }
+    case "not": {
+      return singletonLiteralsInCondition(condition.predicate);
+    }
+    case "and": {
+      return condition.predicates.flatMap((p) => singletonLiteralsInCondition(p));
+    }
+  }
+}
+function paramRefOf(value2) {
+  if (value2 == null || typeof value2 !== "object" || !("ref" in value2)) {
+    return void 0;
+  }
+  return value2.ref.includes(".") ? void 0 : value2.ref;
+}
+function withComplements(values, enumValues) {
+  if (enumValues != null) {
+    return [.../* @__PURE__ */ new Set([...values, ...enumValues])];
+  }
+  const complements = values.flatMap((value2) => {
+    if (typeof value2 === "boolean") {
+      return [!value2];
+    }
+    if (typeof value2 === "number") {
+      return [value2 + 1];
+    }
+    if (typeof value2 === "string") {
+      return [syntheticDistinct(value2, values)];
+    }
+    return [];
+  });
+  return [.../* @__PURE__ */ new Set([...values, ...complements])];
+}
+function syntheticDistinct(seed, taken) {
+  const candidate = `${seed}-alt`;
+  return taken.includes(candidate) ? syntheticDistinct(candidate, taken) : candidate;
+}
+function simulate(workflow2, candidate) {
+  const initial = {
+    choices: /* @__PURE__ */ new Map(),
+    state: {
+      rows: [...workflow2.world, ...candidate.maybes],
+      singles: seedSingles(workflow2.singletons, candidate.pins)
+    }
+  };
+  const folded = workflow2.steps.reduce(
+    (acc, step) => acc == null ? null : stepSim(acc, step),
+    initial
+  );
+  return folded == null ? null : { candidate, choices: folded.choices };
+}
+function seedSingles(singletons, pins) {
+  return Object.fromEntries(
+    Object.entries(singletons).map(([name, value2]) => {
+      const param = paramRefOf(value2);
+      return [name, param != null && param in pins ? pins[param] ?? null : value2];
+    })
+  );
+}
+function stepSim(acc, step) {
+  const rows = step.expect.filter((p) => p.kind === "state").reduce((current, effect) => applyEffect(current, effect), acc.state.rows);
+  const preWhens = { rows, singles: acc.state.singles };
+  const whens = step.expect.filter((p) => p.kind === "when");
+  const resolved = whens.reduce((current, when2) => current == null ? null : foldWhen(current, when2, preWhens), {
+    choices: acc.choices,
+    sets: {}
+  });
+  if (resolved == null) {
+    return null;
+  }
+  const immediate = singletonSets(step.expect);
+  return {
+    choices: resolved.choices,
+    state: { rows, singles: { ...preWhens.singles, ...immediate, ...resolved.sets } }
+  };
+}
+function foldWhen(acc, when2, state) {
+  const picked = pickBranch(when2, state);
+  if (picked === "unknown") {
+    return null;
+  }
+  if (picked == null) {
+    return acc;
+  }
+  const row2 = when2.branches[picked];
+  if (row2 == null) {
+    return acc;
+  }
+  const choices = new Map([...acc.choices, [when2, picked]]);
+  const consequence = row2.consequence;
+  if (consequence.kind === "when") {
+    return foldWhen({ choices, sets: acc.sets }, consequence, state);
+  }
+  return { choices, sets: { ...acc.sets, ...singletonSets([consequence]) } };
+}
+function pickBranch(when2, state) {
+  return when2.branches.reduce((picked, row2, index) => {
+    if (picked !== void 0) {
+      return picked;
+    }
+    if (row2.condition == null) {
+      return index;
+    }
+    const holds = evalCondition(row2.condition, state);
+    if (holds === "unknown") {
+      return "unknown";
+    }
+    return holds ? index : void 0;
+  }, void 0);
+}
+function evalCondition(condition, state) {
+  switch (condition.kind) {
+    case "count": {
+      return state.rows.filter((row2) => row2.entity === condition.entity).length === condition.value;
+    }
+    case "singleton": {
+      return compareValues(state.singles[condition.singleton], condition.assertion.value);
+    }
+    case "not": {
+      return negate(evalCondition(condition.predicate, state));
+    }
+    case "and": {
+      return conjoin(condition.predicates.map((p) => evalCondition(p, state)));
+    }
+  }
+}
+function compareValues(seeded, wanted) {
+  if (seeded === void 0) {
+    return "unknown";
+  }
+  const seededRef = isRefValue(seeded);
+  const wantedRef = isRefValue(wanted);
+  if (seededRef != null && wantedRef != null) {
+    return seededRef === wantedRef ? true : "unknown";
+  }
+  if (seededRef != null || wantedRef != null || isTemplateValue(seeded) || isTemplateValue(wanted)) {
+    return "unknown";
+  }
+  return sameSetValue(seeded, wanted);
+}
+function isRefValue(value2) {
+  return value2 != null && typeof value2 === "object" && "ref" in value2 ? value2.ref : void 0;
+}
+function isTemplateValue(value2) {
+  return value2 != null && typeof value2 === "object" && "template" in value2;
+}
+function negate(value2) {
+  return value2 === "unknown" ? "unknown" : !value2;
+}
+function conjoin(values) {
+  if (values.includes(false)) {
+    return false;
+  }
+  return values.every((v2) => v2 === true) ? true : "unknown";
+}
+function singletonSets(predicates) {
+  return Object.fromEntries(
+    predicates.flatMap((predicate) => {
+      if (predicate.kind === "singleton") {
+        return [[predicate.singleton, predicate.assertion.value]];
+      }
+      return [];
+    })
+  );
+}
+function applyEffect(rows, effect) {
+  if (effect.assertion.kind === "created") {
+    return [
+      ...rows,
+      { as: effect.assertion.as, entity: effect.entity, set: effect.assertion.props }
+    ];
+  }
+  if (effect.assertion.kind === "deleted") {
+    return rows.filter((row2) => row2.entity !== effect.entity || !matchesKey(row2, effect.key, rows));
+  }
+  return rows;
+}
+function matchesKey(row2, key2, rows) {
+  return Object.entries(key2).every(([field2, want]) => matchesField({ field: field2, row: row2, rows, want }));
+}
+function matchesField({ field: field2, row: row2, rows, want }) {
+  if (isWithinValue(want)) {
+    const candidates = rows.filter(
+      (candidate) => candidate.entity === want.selection.entity && matchesKey(candidate, want.selection.where, rows)
+    ).map((candidate) => fieldValue(candidate, want.field));
+    const own = fieldValue(row2, field2);
+    return candidates.some((candidate) => valuesEqual(own, candidate));
+  }
+  return valuesEqual(fieldValue(row2, field2), want);
+}
+function isWithinValue(value2) {
+  return value2 != null && typeof value2 === "object" && "kind" in value2;
+}
+function fieldValue(row2, field2) {
+  return row2.set[field2] ?? { ref: `${row2.as}.${field2}` };
+}
+function valuesEqual(a, b) {
+  const aRef = isRefValue(a);
+  const bRef = isRefValue(b);
+  if (aRef != null || bRef != null) {
+    return aRef === bRef;
+  }
+  if (isTemplateValue(a) || isTemplateValue(b)) {
+    return false;
+  }
+  return sameSetValue(a, b);
+}
+function resolveTest(workflow2, sim, name) {
+  const steps = workflow2.steps.map((step) => ({
+    action: step.action,
+    expect: step.expect.flatMap((predicate) => resolvePredicate2(predicate, sim.choices))
+  }));
+  const world = [...workflow2.world, ...sim.candidate.maybes];
+  const singletons = seedSingles(workflow2.singletons, sim.candidate.pins);
+  const used = usedRefHeads({ singletons, steps, workflow: workflow2, world });
+  return {
+    absent: workflow2.absent,
+    exclusive: workflow2.exclusive,
+    intent: workflow2.intent,
+    name,
+    params: Object.fromEntries(
+      Object.entries(workflow2.params).filter(([param]) => used.has(param))
+    ),
+    singletons,
+    slug: slugify2(name),
+    steps,
+    workflow: workflow2.name,
+    world
+  };
+}
+function resolvePredicate2(predicate, choices) {
+  if (predicate.kind === "not") {
+    const inner = resolvePredicate2(predicate.predicate, choices);
+    return inner.map((p) => ({ kind: "not", predicate: p }));
+  }
+  if (predicate.kind === "and") {
+    return [
+      {
+        kind: "and",
+        predicates: predicate.predicates.flatMap((p) => resolvePredicate2(p, choices))
+      }
+    ];
+  }
+  if (predicate.kind !== "when") {
+    return [predicate];
+  }
+  const picked = choices.get(predicate);
+  const row2 = picked == null ? void 0 : predicate.branches[picked];
+  return row2 == null ? [] : resolvePredicate2(row2.consequence, choices);
+}
+function usedRefHeads({ singletons, steps, workflow: workflow2, world }) {
+  const values = [
+    ...world.flatMap((setup) => Object.values(setup.set)),
+    ...workflow2.absent.flatMap((absence) => Object.values(absence.where)),
+    ...Object.values(singletons),
+    ...steps.flatMap((step) => stepRefValues(step))
+  ];
+  return new Set(values.flatMap((value2) => refStrings(value2)).map((ref) => headOf(ref)));
+}
+function stepRefValues(step) {
+  return collectRefObjects(step).map((ref) => ({ ref }));
+}
+function collectRefObjects(node) {
+  if (Array.isArray(node)) {
+    return node.flatMap((item) => collectRefObjects(item));
+  }
+  if (node == null || typeof node !== "object") {
+    return [];
+  }
+  if ("ref" in node && typeof node.ref === "string" && Object.keys(node).length === 1) {
+    return [node.ref];
+  }
+  return Object.values(node).flatMap((value2) => collectRefObjects(value2));
+}
+function refStrings(value2) {
+  const ref = isRefValue(value2);
+  if (ref != null) {
+    return [ref];
+  }
+  if (value2 != null && typeof value2 === "object" && "template" in value2) {
+    return value2.template.flatMap((segment) => typeof segment === "string" ? [] : [segment.ref]);
+  }
+  return [];
+}
+function headOf(ref) {
+  const dot = ref.indexOf(".");
+  return dot === -1 ? ref : ref.slice(0, dot);
+}
+
 // src/build.ts
 function buildLockfile(input) {
   assertUniqueNames(input.entities);
   const lockfile = lockfileSchema.parse({
     entities: input.entities.map((handle) => handle.schema),
     singletons: input.singletons.map((handle) => handle.schema),
-    tests: input.tests.map((ripploTest) => ripploTest.spec),
     valueSpaces: dedupeByName([
       ...input.entities.flatMap((handle) => handle.valueSpaces),
       ...input.singletons.flatMap((handle) => handle.valueSpaces)
-    ])
+    ]),
+    workflows: input.workflows.map(
+      (ripploWorkflow) => expandWorkflow(ripploWorkflow.spec, { singletonValues: singletonValuesOf(input.singletons) })
+    )
   });
   assertNoContradictions(lockfile);
   return lockfile;
@@ -1645,20 +2208,20 @@ function dedupeByName(spaces) {
   return [...byName.values()];
 }
 function assertNoContradictions(lockfile) {
-  lockfile.tests.forEach((test2) => {
-    assertNoContradiction(test2);
-    assertNoDanglingRefs(test2);
+  lockfile.workflows.forEach((workflow2) => {
+    assertNoContradiction(workflow2);
+    assertNoDanglingRefs(workflow2);
   });
 }
-function assertNoContradiction(test2) {
-  const setups = [...test2.world, ...test2.maybe];
-  test2.absent.forEach((absence) => {
+function assertNoContradiction(workflow2) {
+  const setups = [...workflow2.world, ...workflow2.maybe];
+  workflow2.absent.forEach((absence) => {
     const clash = setups.find(
       (setup) => setup.entity === absence.entity && whereMatches(absence.where, setup.set)
     );
     if (clash != null) {
       throw new Error(
-        `test "${test2.name}": creates a "${absence.entity}" ("${clash.as}") that a none(${absence.entity}, \u2026) in its world forbids`
+        `test "${workflow2.name}": creates a "${absence.entity}" ("${clash.as}") that a none(${absence.entity}, \u2026) in its world forbids`
       );
     }
   });
@@ -1669,19 +2232,19 @@ function whereMatches(where, set) {
 function sameValue(a, b) {
   return b !== void 0 && sameSetValue(a, b);
 }
-function assertNoDanglingRefs(test2) {
-  const aliases = new Set([...test2.world, ...test2.maybe].map((setup) => setup.as));
-  const paramKeys = new Set(Object.keys(test2.params));
+function assertNoDanglingRefs(workflow2) {
+  const aliases = new Set([...workflow2.world, ...workflow2.maybe].map((setup) => setup.as));
+  const paramKeys = new Set(Object.keys(workflow2.params));
   const fieldSets = [
-    ...test2.world.map((setup) => setup.set),
-    ...test2.maybe.map((setup) => setup.set),
-    ...test2.absent.map((absence) => absence.where)
+    ...workflow2.world.map((setup) => setup.set),
+    ...workflow2.maybe.map((setup) => setup.set),
+    ...workflow2.absent.map((absence) => absence.where)
   ];
   fieldSets.forEach((set) => {
-    assertSetRefs(test2.name, set, aliases, paramKeys);
+    assertSetRefs(workflow2.name, set, aliases, paramKeys);
   });
 }
-function assertSetRefs(testName, set, aliases, paramKeys) {
+function assertSetRefs(workflowName, set, aliases, paramKeys) {
   Object.values(set).forEach((value2) => {
     if (!isRef(value2) || paramKeys.has(value2.ref)) {
       return;
@@ -1693,7 +2256,7 @@ function assertSetRefs(testName, set, aliases, paramKeys) {
     const aliasPath = value2.ref.slice(0, lastDot);
     if (!aliases.has(aliasPath)) {
       throw new Error(
-        `test "${testName}": ref "${value2.ref}" points at unknown alias "${aliasPath}"`
+        `test "${workflowName}": ref "${value2.ref}" points at unknown alias "${aliasPath}"`
       );
     }
   });
@@ -1709,10 +2272,10 @@ function createRipplo(input) {
     lockfile: buildLockfile({
       entities: input.entities,
       singletons: input.singletons,
-      tests: input.tests
+      workflows: input.workflows
     }),
     singletons: input.singletons,
-    tests: input.tests
+    workflows: input.workflows
   };
 }
 export {
@@ -1723,6 +2286,7 @@ export {
   and,
   arbitrary,
   banner,
+  branch,
   button,
   cell,
   changed,
@@ -1784,7 +2348,6 @@ export {
   table,
   tablist,
   tabpanel,
-  test,
   testId,
   text,
   textbox,
@@ -1799,5 +2362,6 @@ export {
   viewport,
   visible,
   when,
-  within
+  within,
+  workflow
 };