@ripplo/testing 0.7.11 → 0.7.13

package/DSL.md

@@ -47,16 +47,14 @@ If you're unsure, it's backend. A value that's cached in the browser but owned b
 ### `field(options)`
 
 ```ts
-field({ value: v.email() }); // required, stable — Ripplo checks the app's value matches what the test expected
+field({ value: v.email() }); // required — Ripplo checks the app's value matches what the test expected
 field({ value: v.word(), optional: true }); // nullable; `null` is a valid set/assert value
-field({ value: v.number({ min: 0, max: 100 }), stable: false }); // adopt-only, drift not checked
 ```
 
-| option     | meaning                                                                                                              |
-| ---------- | -------------------------------------------------------------------------------------------------------------------- |
-| `value`    | the value-space (`v.*`) — required                                                                                   |
-| `optional` | `true` ⇒ the field is nullable (`null` allowed in `of`/`updated`/assertions); Ripplo treats `null ≡ absent`          |
-| `stable`   | default `true` (Ripplo checks the app's value matches what the test expected). `false` = adopt-only, drift unchecked |
+| option     | meaning                                                                                                     |
+| ---------- | ----------------------------------------------------------------------------------------------------------- |
+| `value`    | the value-space (`v.*`) — required                                                                          |
+| `optional` | `true` ⇒ the field is nullable (`null` allowed in `of`/`updated`/assertions); Ripplo treats `null ≡ absent` |
 
 ### Identity: `id()` and `key(options)`
 
@@ -165,19 +163,20 @@ The compiler enumerates one concrete test per `when` branch at `ripplo compile`/
 
 Each returns a step; chain `.expect(...assertions)` to assert after it runs.
 
-| action     | signature                      | example                                  |
-| ---------- | ------------------------------ | ---------------------------------------- |
-| `goto`     | `` goto`/path/${handle.id}` `` | `` goto`/projects/${p.id}` ``            |
-| `click`    | `click(locator)`               | `click(button("Save"))`                  |
-| `dblclick` | `dblclick(locator)`            | `dblclick(testId\`row-${r.id}\`)`        |
-| `fill`     | `fill(locator, value)`         | `fill(textbox("Name"), "Acme")`          |
-| `clear`    | `clear(locator)`               | `clear(textbox("Name"))`                 |
-| `select`   | `select(locator, value)`       | `select(combobox("Plan"), "pro")`        |
-| `check`    | `check(locator)`               | `check(checkbox("Agree"))`               |
-| `uncheck`  | `uncheck(locator)`             | `uncheck(checkbox("Agree"))`             |
-| `hover`    | `hover(locator)`               | `hover(button("More"))`                  |
-| `upload`   | `upload(locator, files)`       | `upload(testId\`avatar\`, ["face.png"])` |
-| `press`    | `press(key, locator?)`         | `press("Enter", textbox("Search"))`      |
+| action     | signature                                                                                             | example                                         |
+| ---------- | ----------------------------------------------------------------------------------------------------- | ----------------------------------------------- |
+| `goto`     | `` goto`/path/${handle.id}` ``                                                                        | `` goto`/projects/${p.id}` ``                   |
+| `click`    | `click(locator)`                                                                                      | `click(button("Save"))`                         |
+| `dblclick` | `dblclick(locator)`                                                                                   | `dblclick(testId\`row-${r.id}\`)`               |
+| `fill`     | `fill(locator, value)`                                                                                | `fill(textbox("Name"), "Acme")`                 |
+| `clear`    | `clear(locator)`                                                                                      | `clear(textbox("Name"))`                        |
+| `select`   | `select(locator, value)`                                                                              | `select(combobox("Plan"), "pro")`               |
+| —          | drives native `<select>` and ARIA comboboxes (react-select, etc.); `value` is the visible option text | `select(combobox("Timezone"), "Europe/London")` |
+| `check`    | `check(locator)`                                                                                      | `check(checkbox("Agree"))`                      |
+| `uncheck`  | `uncheck(locator)`                                                                                    | `uncheck(checkbox("Agree"))`                    |
+| `hover`    | `hover(locator)`                                                                                      | `hover(button("More"))`                         |
+| `upload`   | `upload(locator, files)`                                                                              | `upload(testId\`avatar\`, ["face.png"])`        |
+| `press`    | `press(key, locator?)`                                                                                | `press("Enter", textbox("Search"))`             |
 
 `fill`/`select`/`value`/`text` accept a literal string or a `Binding<string>` (e.g. `arbitrary(...)` or a handle field). `goto`/`testId` are template literals — interpolate handle ids directly.
 
@@ -232,6 +231,7 @@ Used inside a step's `.expect(...)`.
 | `disabled` | `disabled(locator)`               | element is disabled                       |
 | `enabled`  | `enabled(locator)`                | element is enabled                        |
 | `focused`  | `focused(locator)`                | element has focus                         |
+| `checked`  | `checked(locator)`                | checkbox, radio, or switch is checked     |
 | `value`    | `value(locator, string\|binding)` | input's value equals                      |
 | `text`     | `text(locator, string\|binding)`  | element's text equals                     |
 | `not`      | `not(assertion)`                  | negation — `not(visible(role("dialog")))` |

package/dist/{engine-Dv3trweR.d.ts → engine-D-X3F_hc.d.ts}

@@ -143,7 +143,6 @@ declare const propSpecSchema: z.ZodObject<{
         eventual: "eventual";
     }>>;
     optional: z.ZodBoolean;
-    stable: z.ZodBoolean;
     type: z.ZodEnum<{
         string: "string";
         number: "number";
@@ -171,7 +170,6 @@ declare const entitySchemaSchema: z.ZodObject<{
             eventual: "eventual";
         }>>;
         optional: z.ZodBoolean;
-        stable: z.ZodBoolean;
         type: z.ZodEnum<{
             string: "string";
             number: "number";
@@ -591,7 +589,6 @@ declare const lockfileSchema: z.ZodObject<{
                 eventual: "eventual";
             }>>;
             optional: z.ZodBoolean;
-            stable: z.ZodBoolean;
             type: z.ZodEnum<{
                 string: "string";
                 number: "number";
@@ -1012,6 +1009,7 @@ declare function visible(locator: Locator): LeafPredicate;
 declare function disabled(locator: Locator): LeafPredicate;
 declare function enabled(locator: Locator): LeafPredicate;
 declare function focused(locator: Locator): LeafPredicate;
+declare function checked(locator: Locator): LeafPredicate;
 declare function value(locator: Locator, binding: Binding<string> | string): LeafPredicate;
 declare function text(locator: Locator, binding: Binding<string> | string): LeafPredicate;
 declare function not(input: ConditionInput): ConditionPredicate;
@@ -1029,11 +1027,11 @@ interface BranchInput {
     readonly branch: WhenBranch;
 }
 interface NamedBranch {
-    readonly expect: (consequence: PredicateInput) => BranchInput;
+    readonly expect: (...consequences: ReadonlyArray<PredicateInput>) => BranchInput;
     readonly if: (condition: ConditionInput) => ConditionedBranch;
 }
 interface ConditionedBranch {
-    readonly expect: (consequence: PredicateInput) => BranchInput;
+    readonly expect: (...consequences: ReadonlyArray<PredicateInput>) => BranchInput;
 }
 declare function branch(name: string): NamedBranch;
 declare function when(...branches: ReadonlyArray<BranchInput>): LeafPredicate;
@@ -1075,7 +1073,6 @@ interface PropBuilder<T extends Primitive, Opt extends boolean = boolean> {
 type Mods = Partial<{
     readonly consistency: ConsistencyClass;
     readonly optional: boolean;
-    readonly stable: boolean;
 }>;
 type IsOptional = {
     readonly optional: true;
@@ -1292,4 +1289,4 @@ interface Engine {
 }
 declare function createEngine<R extends DeclSource>(ripplo: R, impls: EngineImpls<R, "backend">, teardown: Teardown): Engine;
 
-export { field as $, type AnyBinding as A, type Binding as B, type Capture as C, type DeclSource as D, type Engine as E, type FieldHandle as F, type GivenItem as G, type Handle as H, type SingletonConfig as I, type SingletonImpl as J, type SingletonValue as K, type Locator as L, type WithinMatcher as M, type NamedBranch as N, and as O, type PredicateInput as P, branch as Q, type Row as R, type Step as S, changed as T, type UniqueNames as U, count as V, type Workflow as W, createEngine as X, disabled as Y, enabled as Z, entity as _, type EntityList as a, focused as a0, id as a1, key as a2, not as a3, singleton as a4, text as a5, v as a6, value as a7, visible as a8, when as a9, within as aa, type SingletonList as b, type Lockfile as c, type BrowserSingleton as d, type LeafPredicate as e, type Primitive as f, type Primitive$1 as g, type SingletonDef as h, type AbsenceHandle as i, type BranchInput as j, CLIENT_MOUNT_KEY as k, CLIENT_SEED_KEY as l, type ConditionInput as m, type ConditionPredicate as n, type ConditionedBranch as o, type CountCondition as p, type DuplicateEntityName as q, type EngineError as r, type EngineImpls as s, type EngineRead as t, type EntityDef as u, type EntityHandle as v, type EntityImpl as w, type FieldOptions as x, type Fields as y, type Selection as z };
+export { entity as $, type AnyBinding as A, type Binding as B, type Capture as C, type DeclSource as D, type Engine as E, type FieldHandle as F, type GivenItem as G, type Handle as H, type SingletonConfig as I, type SingletonImpl as J, type SingletonValue as K, type Locator as L, type WithinMatcher as M, type NamedBranch as N, and as O, type PredicateInput as P, branch as Q, type Row as R, type Step as S, changed as T, type UniqueNames as U, checked as V, type Workflow as W, count as X, createEngine as Y, disabled as Z, enabled as _, type EntityList as a, field as a0, focused as a1, id as a2, key as a3, not as a4, singleton as a5, text as a6, v as a7, value as a8, visible as a9, when as aa, within as ab, type SingletonList as b, type Lockfile as c, type BrowserSingleton as d, type LeafPredicate as e, type Primitive as f, type Primitive$1 as g, type SingletonDef as h, type AbsenceHandle as i, type BranchInput as j, CLIENT_MOUNT_KEY as k, CLIENT_SEED_KEY as l, type ConditionInput as m, type ConditionPredicate as n, type ConditionedBranch as o, type CountCondition as p, type DuplicateEntityName as q, type EngineError as r, type EngineImpls as s, type EngineRead as t, type EntityDef as u, type EntityHandle as v, type EntityImpl as w, type FieldOptions as x, type Fields as y, type Selection as z };

package/dist/express.d.ts

@@ -1,5 +1,5 @@
 import { Router } from 'express';
-import { E as Engine } from './engine-Dv3trweR.js';
+import { E as Engine } from './engine-D-X3F_hc.js';
 import 'neverthrow';
 import 'zod';
 

package/dist/express.js

@@ -71,7 +71,6 @@ var valueSpaceSchema = z.object({
 var propSpecSchema = z.object({
   consistency: consistencyClassSchema.default("strict"),
   optional: z.boolean(),
-  stable: z.boolean(),
   type: primitiveTypeSchema,
   valueSpace: z.string().min(1).optional()
 });
@@ -146,7 +145,7 @@ var conditionSchema = z2.lazy(
 var whenBranchSchema = z2.lazy(
   () => z2.object({
     condition: z2.union([conditionSchema, z2.undefined()]).optional().transform((value) => value),
-    consequence: predicateSchema,
+    consequence: z2.array(predicateSchema),
     name: z2.string().min(1)
   })
 );
@@ -156,6 +155,7 @@ var predicateSchema = z2.lazy(
     z2.object({ kind: z2.literal("disabled"), locator: locatorSchema, wait }),
     z2.object({ kind: z2.literal("enabled"), locator: locatorSchema, wait }),
     z2.object({ kind: z2.literal("focused"), locator: locatorSchema, wait }),
+    z2.object({ kind: z2.literal("checked"), 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 }),
     singletonPredicateSchema,

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { C as Capture, S as Step, P as PredicateInput, L as Locator, B as Binding, A as AnyBinding, G as GivenItem, W as Workflow, a as EntityList, b as SingletonList, c as Lockfile, U as UniqueNames, d as BrowserSingleton, e as LeafPredicate, f as Primitive, F as FieldHandle, D as DeclSource, R as Row, g as Primitive$1, h as SingletonDef } from './engine-Dv3trweR.js';
-export { i as AbsenceHandle, j as BranchInput, k as CLIENT_MOUNT_KEY, l as CLIENT_SEED_KEY, m as ConditionInput, n as ConditionPredicate, o as ConditionedBranch, p as CountCondition, q as DuplicateEntityName, E as Engine, r as EngineError, s as EngineImpls, t as EngineRead, u as EntityDef, v as EntityHandle, w as EntityImpl, x as FieldOptions, y as Fields, H as Handle, N as NamedBranch, z as Selection, I as SingletonConfig, J as SingletonImpl, K as SingletonValue, M as WithinMatcher, O as and, Q as branch, T as changed, V as count, X as createEngine, Y as disabled, Z as enabled, _ as entity, $ as field, a0 as focused, a1 as id, a2 as key, a3 as not, a4 as singleton, a5 as text, a6 as v, a7 as value, a8 as visible, a9 as when, aa as within } from './engine-Dv3trweR.js';
+import { C as Capture, S as Step, P as PredicateInput, L as Locator, B as Binding, A as AnyBinding, G as GivenItem, W as Workflow, a as EntityList, b as SingletonList, c as Lockfile, U as UniqueNames, d as BrowserSingleton, e as LeafPredicate, f as Primitive, F as FieldHandle, D as DeclSource, R as Row, g as Primitive$1, h as SingletonDef } from './engine-D-X3F_hc.js';
+export { i as AbsenceHandle, j as BranchInput, k as CLIENT_MOUNT_KEY, l as CLIENT_SEED_KEY, m as ConditionInput, n as ConditionPredicate, o as ConditionedBranch, p as CountCondition, q as DuplicateEntityName, E as Engine, r as EngineError, s as EngineImpls, t as EngineRead, u as EntityDef, v as EntityHandle, w as EntityImpl, x as FieldOptions, y as Fields, H as Handle, N as NamedBranch, z as Selection, I as SingletonConfig, J as SingletonImpl, K as SingletonValue, M as WithinMatcher, O as and, Q as branch, T as changed, V as checked, X as count, Y as createEngine, Z as disabled, _ as enabled, $ as entity, a0 as field, a1 as focused, a2 as id, a3 as key, a4 as not, a5 as singleton, a6 as text, a7 as v, a8 as value, a9 as visible, aa as when, ab as within } from './engine-D-X3F_hc.js';
 import 'neverthrow';
 import 'zod';
 

package/dist/index.js

@@ -98,6 +98,9 @@ function enabled(locator) {
 function focused(locator) {
   return leaf({ kind: "focused", locator, wait: void 0 });
 }
+function checked(locator) {
+  return leaf({ kind: "checked", locator, wait: void 0 });
+}
 function value(locator, binding) {
   return leaf({ kind: "value", locator, value: binding, wait: void 0 });
 }
@@ -125,9 +128,9 @@ function count(entity2) {
   };
 }
 function branch(name) {
-  const close = (condition) => (consequence) => {
-    const resolved = toPredicate(consequence);
-    if (containsWhen(resolved)) {
+  const close = (condition) => (...consequences) => {
+    const resolved = consequences.map((consequence) => toPredicate(consequence));
+    if (resolved.some((predicate) => containsWhen(predicate))) {
       throw new Error(
         `branch "${name}" nests a when() inside its consequence \u2014 whens are one level deep; split the scenario into another workflow`
       );
@@ -270,7 +273,6 @@ function field(options) {
     spec: {
       consistency: options.consistency ?? "strict",
       optional: options.optional ?? false,
-      stable: options.stable ?? true,
       type: options.value.primitive
     },
     valueSpace: options.value
@@ -280,7 +282,7 @@ function id() {
   return {
     idKind: "surrogate",
     prop: propBuilder({
-      spec: { consistency: "strict", optional: false, stable: true, type: "string" },
+      spec: { consistency: "strict", optional: false, type: "string" },
       valueSpace: void 0
     })
   };
@@ -292,7 +294,6 @@ function key(options) {
       spec: {
         consistency: "strict",
         optional: false,
-        stable: true,
         type: options.value.primitive
       },
       valueSpace: options.value
@@ -598,6 +599,20 @@ function stepBuilder(action, expected, captures) {
   };
 }
 
+// src/coherence.ts
+function assertEntityCoherence(entities) {
+  const counts = entities.reduce(
+    (acc, d) => new Map([...acc, [d.entity, (acc.get(d.entity) ?? 0) + 1]]),
+    /* @__PURE__ */ new Map()
+  );
+  const over = entities.find((d) => d.kind === "only" && (counts.get(d.entity) ?? 0) > 1);
+  if (over != null) {
+    throw new Error(
+      `entity "${over.entity}" is declared only() but seeded ${String(counts.get(over.entity) ?? 0)} times \u2014 only() means a single exclusive instance; use of() for multiple instances`
+    );
+  }
+}
+
 // src/finalize.ts
 function finalize(body) {
   const descriptors = [...new Set(body.given.map((item) => item.__entity))];
@@ -611,6 +626,7 @@ function finalize(body) {
     )
   );
   assertNoMaybeRefs({ absences, entities, singletonStates });
+  assertEntityCoherence(entities);
   const captures = body.steps.flatMap((builder) => builder.captures);
   assertScopedConditions(body.steps, new Set(singletonStates.map((s) => s.singleton)));
   const aliases = assignAliases([...entities, ...captures.map((c) => c.descriptor)]);
@@ -717,7 +733,9 @@ function assertPredicateScoped(predicate, given) {
         );
       }
     });
-    assertPredicateScoped(row2.consequence, given);
+    row2.consequence.forEach((consequence) => {
+      assertPredicateScoped(consequence, given);
+    });
   });
 }
 function conditionSingletons(predicate) {
@@ -812,7 +830,8 @@ function predicateBindings(predicate) {
     case "visible":
     case "disabled":
     case "enabled":
-    case "focused": {
+    case "focused":
+    case "checked": {
       return locatorBindings(predicate.locator);
     }
     case "value":
@@ -839,7 +858,7 @@ function predicateBindings(predicate) {
     case "when": {
       return predicate.branches.flatMap((row2) => [
         ...row2.condition == null ? [] : predicateBindings(row2.condition),
-        ...predicateBindings(row2.consequence)
+        ...row2.consequence.flatMap((consequence) => predicateBindings(consequence))
       ]);
     }
     case "and": {
@@ -959,7 +978,8 @@ function resolvePredicate(predicate, ctx) {
     case "visible":
     case "disabled":
     case "enabled":
-    case "focused": {
+    case "focused":
+    case "checked": {
       return { ...predicate, locator: resolveLocator(predicate.locator, ctx) };
     }
     case "value":
@@ -994,7 +1014,7 @@ function resolvePredicate(predicate, ctx) {
         ...predicate,
         branches: predicate.branches.map((row2) => ({
           condition: row2.condition == null ? void 0 : resolveCondition(row2.condition, ctx),
-          consequence: resolvePredicate(row2.consequence, ctx),
+          consequence: row2.consequence.map((consequence) => resolvePredicate(consequence, ctx)),
           name: row2.name
         }))
       };
@@ -1366,7 +1386,6 @@ var valueSpaceSchema = z.object({
 var propSpecSchema = z.object({
   consistency: consistencyClassSchema.default("strict"),
   optional: z.boolean(),
-  stable: z.boolean(),
   type: primitiveTypeSchema,
   valueSpace: z.string().min(1).optional()
 });
@@ -1441,7 +1460,7 @@ var conditionSchema = z2.lazy(
 var whenBranchSchema = z2.lazy(
   () => z2.object({
     condition: z2.union([conditionSchema, z2.undefined()]).optional().transform((value2) => value2),
-    consequence: predicateSchema,
+    consequence: z2.array(predicateSchema),
     name: z2.string().min(1)
   })
 );
@@ -1451,6 +1470,7 @@ var predicateSchema = z2.lazy(
     z2.object({ kind: z2.literal("disabled"), locator: locatorSchema, wait }),
     z2.object({ kind: z2.literal("enabled"), locator: locatorSchema, wait }),
     z2.object({ kind: z2.literal("focused"), locator: locatorSchema, wait }),
+    z2.object({ kind: z2.literal("checked"), 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 }),
     singletonPredicateSchema,
@@ -1707,6 +1727,54 @@ function mountClientEngine(ripplo, impls, { enabled: enabled2 }) {
   Reflect.set(globalThis, CLIENT_MOUNT_KEY, createClientEngine(ripplo, impls));
 }
 
+// src/expand-refs.ts
+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 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 isRefValue(value2) {
+  return value2 != null && typeof value2 === "object" && "ref" in value2 ? value2.ref : void 0;
+}
+function headOf(ref) {
+  const dot = ref.indexOf(".");
+  return dot === -1 ? ref : ref.slice(0, dot);
+}
+function stepRefValues(step) {
+  return collectRefObjects(step).map((ref) => ({ ref }));
+}
+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 [];
+}
+
 // src/expand.ts
 var MAX_CANDIDATES = 4096;
 function singletonValuesOf(singletons) {
@@ -1822,7 +1890,7 @@ function targetsIn(predicate) {
   }
   return predicate.branches.flatMap((row2, index) => [
     { index, name: row2.name, when: predicate },
-    ...targetsIn(row2.consequence)
+    ...row2.consequence.flatMap((consequence) => targetsIn(consequence))
   ]);
 }
 function proposeCandidates(workflow2, options) {
@@ -1879,7 +1947,7 @@ function conditionLiteralsIn(predicate) {
   }
   return predicate.branches.flatMap((row2) => [
     ...row2.condition == null ? [] : singletonLiteralsInCondition(row2.condition),
-    ...conditionLiteralsIn(row2.consequence)
+    ...row2.consequence.flatMap((consequence) => conditionLiteralsIn(consequence))
   ]);
 }
 function singletonLiteralsInCondition(condition) {
@@ -1979,11 +2047,18 @@ function foldWhen(acc, when2, state) {
     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]) } };
+  return row2.consequence.reduce(
+    (folded, consequence) => {
+      if (folded == null) {
+        return null;
+      }
+      if (consequence.kind === "when") {
+        return foldWhen(folded, consequence, state);
+      }
+      return { choices: folded.choices, sets: { ...folded.sets, ...singletonSets([consequence]) } };
+    },
+    { choices, sets: acc.sets }
+  );
 }
 function pickBranch(when2, state) {
   return when2.branches.reduce((picked, row2, index) => {
@@ -2030,9 +2105,6 @@ function compareValues(seeded, wanted) {
   }
   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;
 }
@@ -2138,45 +2210,7 @@ function resolvePredicate2(predicate, choices) {
   }
   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);
+  return row2 == null ? [] : row2.consequence.flatMap((c) => resolvePredicate2(c, choices));
 }
 
 // src/build.ts
@@ -2292,6 +2326,7 @@ export {
   changed,
   check,
   checkbox,
+  checked,
   clear,
   click,
   columnheader,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ripplo/testing",
-  "version": "0.7.11",
+  "version": "0.7.13",
   "description": "Typed test DSL for Ripplo — declare entities and user flows, compile to a lockfile",
   "homepage": "https://ripplo.ai",
   "license": "SEE LICENSE IN LICENSE.md",