@ripplo/testing 0.7.23 → 0.7.25

package/dist/index.js

@@ -1054,1890 +1054,1888 @@ function collectValueSpaces(stateName, builders) {
   }));
 }
 
-// src/locators.ts
-function role(roleName, name, ...bindings) {
-  return { by: "role", name: name == null ? void 0 : nameValue(name, bindings), role: roleName };
-}
-function inside(scope, target) {
-  return { by: "inside", scope, target };
-}
-function testId(value2, ...bindings) {
-  if (typeof value2 === "string") {
-    return { by: "testId", value: value2 };
-  }
-  return { by: "testId", value: stringValueFromTemplate(value2, bindings) };
-}
-var alertdialog = named("alertdialog");
-var button = named("button");
-var cell = named("cell");
-var checkbox = named("checkbox");
-var columnheader = named("columnheader");
-var combobox = named("combobox");
-var dialog = named("dialog");
-var heading = named("heading");
-var img = named("img");
-var link = named("link");
-var listitem = named("listitem");
-var menuitem = named("menuitem");
-var option = named("option");
-var radio = named("radio");
-var row = named("row");
-var searchbox = named("searchbox");
-var slider = named("slider");
-var spinbutton = named("spinbutton");
-var switchControl = named("switch");
-var tab = named("tab");
-var textbox = named("textbox");
-var treeitem = named("treeitem");
-var alert = container("alert");
-var banner = container("banner");
-var complementary = container("complementary");
-var contentinfo = container("contentinfo");
-var form = container("form");
-var grid = container("grid");
-var group = container("group");
-var list = container("list");
-var main = container("main");
-var menu = container("menu");
-var navigation = container("navigation");
-var progressbar = container("progressbar");
-var radiogroup = container("radiogroup");
-var region = container("region");
-var status = container("status");
-var table = container("table");
-var tablist = container("tablist");
-var tabpanel = container("tabpanel");
-var toolbar = container("toolbar");
-function named(roleName) {
-  return (name, ...bindings) => role(roleName, name, ...bindings);
-}
-function container(roleName) {
-  return (name, ...bindings) => role(roleName, name, ...bindings);
-}
-function nameValue(name, bindings) {
-  if (typeof name === "string") {
-    return name;
-  }
-  if (isBinding(name)) {
-    return name;
-  }
-  return stringValueFromTemplate(name, bindings);
-}
-
-// src/singleton.ts
-function singleton(name, config) {
-  const valueSpaceName = `singleton.${name}`;
-  const { constraints, generator, primitive } = config.value;
-  const schema = {
-    consistency: config.consistency ?? "strict",
-    default: config.default,
-    description: config.description,
-    name,
-    source: config.source,
-    type: primitive,
-    valueSpace: valueSpaceName
-  };
-  return {
-    is: isPredicate,
-    name,
-    schema,
-    source: config.source,
-    value: { __t: void 0, entity: name, field: "value", primitive, valueSpaceName },
-    valueSpaces: [{ constraints, generator, name: valueSpaceName, type: primitive }],
-    of: (value2) => ({
-      __entity: { kind: "singletonState", singleton: name, value: toSetValue(value2) },
-      is: isPredicate
-    })
-  };
-  function isPredicate(value2) {
-    return condLeaf({
-      assertion: { kind: "is", value: value2 },
-      kind: "singleton",
-      singleton: name,
-      wait: void 0
-    });
-  }
-}
-
-// src/builtins.ts
-function browserSingleton(name) {
-  return {
-    name,
-    is: (strings, ...values) => leaf({
-      kind: "browser",
-      name,
-      value: stringValueFromTemplate(strings, values),
-      wait: void 0
-    })
-  };
-}
-var url = browserSingleton("url");
-var title = browserSingleton("title");
-var viewport = browserSingleton("viewport");
-
-// src/actions.ts
-function goto(strings, ...values) {
-  return stepBuilder({ kind: "goto", url: stringValueFromTemplate(strings, values) }, [], []);
-}
-function click(locator) {
-  return stepBuilder({ kind: "click", locator }, [], []);
-}
-function dblclick(locator) {
-  return stepBuilder({ kind: "dblclick", locator }, [], []);
-}
-function fill(locator, binding) {
-  return stepBuilder({ kind: "fill", locator, value: binding }, [], []);
-}
-function clear(locator) {
-  return stepBuilder({ kind: "clear", locator }, [], []);
-}
-function select(locator, binding) {
-  return stepBuilder({ kind: "select", locator, value: binding }, [], []);
-}
-function check(locator) {
-  return stepBuilder({ kind: "check", locator }, [], []);
-}
-function uncheck(locator) {
-  return stepBuilder({ kind: "uncheck", locator }, [], []);
-}
-function hover(locator) {
-  return stepBuilder({ kind: "hover", locator }, [], []);
-}
-function upload(locator, files) {
-  return stepBuilder({ files: [...files], kind: "upload", locator }, [], []);
-}
-function press(pressKey, locator) {
-  return stepBuilder({ key: pressKey, kind: "press", locator }, [], []);
-}
-function stepBuilder(action, expected, captures) {
-  return {
-    captures,
-    step: { action, expect: [...expected] },
-    expect: (...predicates) => stepBuilder(
-      action,
-      [...expected, ...predicates.map((p) => toPredicate(p))],
-      [...captures, ...predicates.flatMap((p) => isCapturePredicate(p) ? [captureOf(p)] : [])]
-    )
-  };
-}
-
-// 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`
-    );
-  }
-}
+// ../spec/src/leaves.ts
+import { z } from "zod";
+var budgetSchema = z.enum(["fast", "slow", "async"]);
+var valueRefSchema = z.object({ ref: z.string().min(1) });
+var primitiveSchema = z.union([z.string(), z.number(), z.boolean()]);
+var templateSchema = z.object({
+  template: z.array(z.union([z.string(), valueRefSchema])).min(1)
+});
+var setValueSchema = z.union([valueRefSchema, primitiveSchema, templateSchema, z.null()]);
+var changedSchema = z.object({ kind: z.literal("changed") });
+var updateValueSchema = z.union([setValueSchema, changedSchema]);
+var stringValueSchema = z.union([z.string(), valueRefSchema, templateSchema]);
+var roleLocatorSchema = z.object({
+  by: z.literal("role"),
+  name: z.union([stringValueSchema, z.undefined()]).optional().transform((value2) => value2),
+  role: z.string().min(1)
+});
+var testIdLocatorSchema = z.object({ by: z.literal("testId"), value: stringValueSchema });
+var insideLocatorSchema = z.object({
+  by: z.literal("inside"),
+  scope: z.lazy(() => locatorSchema),
+  target: z.lazy(() => locatorSchema)
+});
+var locatorSchema = z.discriminatedUnion("by", [
+  roleLocatorSchema,
+  testIdLocatorSchema,
+  insideLocatorSchema
+]);
+var primitiveTypeSchema = z.enum(["string", "number", "boolean"]);
+var consistencyClassSchema = z.enum(["strict", "eventual"]);
+var stringConstraintsSchema = z.object({
+  kind: z.literal("string"),
+  maxLength: z.number().int().positive().optional(),
+  minLength: z.number().int().nonnegative().optional(),
+  pattern: z.string().optional()
+});
+var numberConstraintsSchema = z.object({
+  kind: z.literal("number"),
+  max: z.number().int().optional(),
+  min: z.number().int().optional()
+});
+var datetimeConstraintsSchema = z.object({
+  kind: z.literal("datetime"),
+  maxOffsetDays: z.number().int(),
+  minOffsetDays: z.number().int()
+});
+var constraintsSchema = z.discriminatedUnion("kind", [
+  stringConstraintsSchema,
+  numberConstraintsSchema,
+  datetimeConstraintsSchema
+]);
+var generatorSchema = z.enum([
+  "company.name",
+  "date.iso",
+  "internet.email",
+  "internet.url",
+  "person.fullName",
+  "lorem.slug",
+  "lorem.word"
+]);
+var valueSpaceSchema = z.object({
+  constraints: constraintsSchema.optional(),
+  generator: generatorSchema,
+  name: z.string().min(1),
+  type: primitiveTypeSchema,
+  values: z.array(primitiveSchema).min(1).optional()
+});
+var propSpecSchema = z.object({
+  consistency: consistencyClassSchema.default("strict"),
+  optional: z.boolean(),
+  type: primitiveTypeSchema,
+  valueSpace: z.string().min(1).optional()
+});
+var sourceSchema = z.enum(["backend", "client"]);
+var entitySchemaSchema = z.object({
+  description: z.string().optional(),
+  identity: z.array(z.string().min(1)).min(1),
+  identityKind: z.enum(["surrogate", "natural"]),
+  name: z.string().min(1),
+  props: z.record(z.string().min(1), propSpecSchema),
+  source: sourceSchema.default("backend")
+});
+var singletonSchemaSchema = z.object({
+  consistency: consistencyClassSchema.default("strict"),
+  default: primitiveSchema,
+  description: z.string().optional(),
+  name: z.string().min(1),
+  source: sourceSchema.default("backend"),
+  type: primitiveTypeSchema,
+  valueSpace: z.string().min(1).optional()
+});
+var browserSingletonSchema = z.enum(["url", "title", "viewport"]);
 
-// src/finalize.ts
-function finalize(body) {
-  const descriptors = [...new Set(body.given.map((item) => item.__entity))];
-  const absences = descriptors.filter((d) => d.kind === "none");
-  const singletonStates = descriptors.filter(
-    (d) => d.kind === "singletonState"
-  );
-  const entities = topoSort(
-    descriptors.filter(
-      (d) => d.kind === "of" || d.kind === "only" || d.kind === "maybe"
-    )
-  );
-  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)]);
-  const { names, params } = assignParams(allBindings(body, entities, absences, singletonStates));
-  const ctx = {
-    aliases,
-    captures: new Map(
-      captures.map((c) => [c.assertion, c.descriptor])
-    ),
-    params: names
-  };
-  return {
-    absent: absences.map((a) => ({ entity: a.entity, where: setMap(a.where, ctx) })),
-    exclusive: [...new Set(entities.filter((d) => d.kind === "only").map((d) => d.entity))],
-    maybe: setupsOf(entities, "maybe", ctx),
-    params,
-    singletons: resolveSingletons(singletonStates, ctx),
-    steps: body.steps.map((builder) => resolveStep(builder.step, ctx)),
-    world: entities.filter((d) => d.kind === "of" || d.kind === "only").map((d) => ({ as: aliasFor(ctx, d), entity: d.entity, set: setMap(d.props, ctx) }))
-  };
-}
-function resolveSingletons(states, ctx) {
-  return states.reduce((acc, state) => {
-    const value2 = resolveValue(state.value, ctx);
-    const existing = acc[state.singleton];
-    if (existing !== void 0 && !sameSetValue(existing, value2)) {
-      throw new Error(
-        `singleton "${state.singleton}" is given two conflicting values \u2014 a test may set each singleton to one value`
-      );
-    }
-    return { ...acc, [state.singleton]: value2 };
-  }, {});
-}
-function assertNoMaybeRefs({ absences, entities, singletonStates }) {
-  const offenders = [
-    ...entities.filter((d) => d.kind === "of" || d.kind === "only").flatMap((d) => maybeBindings(Object.values(d.props), `${d.kind}(${d.entity})`)),
-    ...absences.flatMap((a) => maybeBindings(Object.values(a.where), `none(${a.entity})`)),
-    ...singletonStates.flatMap((s) => maybeBindings([s.value], `singleton "${s.singleton}"`))
-  ];
-  const first = offenders[0];
-  if (first == null || first.binding.__bind.kind !== "field") {
-    return;
-  }
-  const { descriptor, field: field2 } = first.binding.__bind;
-  throw new Error(
-    `${first.site} references ${descriptor.entity}.${field2} from a maybe(${descriptor.entity}) \u2014 maybe entities are not materialized at setup; reference them only in steps`
-  );
-}
-function maybeBindings(values, site) {
-  return values.flatMap((value2) => valueBindings(value2)).filter((b) => b.__bind.kind === "field" && b.__bind.descriptor.kind === "maybe").map((binding) => ({ binding, site }));
-}
-function valueBindings(value2) {
-  if (isBinding(value2)) {
-    return [value2];
-  }
-  if (isTemplate(value2)) {
-    return value2.template.flatMap((segment) => isBinding(segment) ? [segment] : []);
-  }
-  return [];
-}
-function isTemplate(value2) {
-  return typeof value2 === "object" && value2 !== null && "template" in value2;
-}
-function topoSort(entities) {
-  return emitReady([], entities);
-}
-function emitReady(done, remaining) {
-  if (remaining.length === 0) {
-    return [...done];
-  }
-  const ready = remaining.filter(
-    (d) => depsOf(d, remaining).every((dep) => done.includes(dep) || dep === d)
-  );
-  if (ready.length === 0) {
-    throw new Error("cyclic dependency between given entities");
-  }
-  return emitReady(
-    [...done, ...ready],
-    remaining.filter((d) => !ready.includes(d))
-  );
-}
-function depsOf(descriptor, among) {
-  return Object.values(descriptor.props).flatMap((v2) => valueBindings(v2)).flatMap((b) => b.__bind.kind === "field" ? [b.__bind.descriptor] : []).filter((target) => target !== descriptor && among.includes(target));
-}
-function assertScopedConditions(steps, givenSingletons) {
-  steps.flatMap((builder) => builder.step.expect).forEach((predicate) => {
-    assertPredicateScoped(predicate, givenSingletons);
-  });
-}
-function assertPredicateScoped(predicate, given) {
-  if (predicate.kind === "not") {
-    assertPredicateScoped(predicate.predicate, given);
-    return;
-  }
-  if (predicate.kind !== "when") {
-    return;
-  }
-  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`
-        );
-      }
-    });
-    row2.consequence.forEach((consequence) => {
-      assertPredicateScoped(consequence, given);
-    });
-  });
-}
-function conditionSingletons(predicate) {
-  if (predicate.kind === "singleton") {
-    return [predicate.singleton];
-  }
-  if (predicate.kind === "not") {
-    return conditionSingletons(predicate.predicate);
-  }
-  if (predicate.kind === "and") {
-    return predicate.predicates.flatMap((p) => conditionSingletons(p));
-  }
-  return [];
-}
-function assignAliases(entities) {
-  return entities.reduce(
-    (acc, d) => {
-      const ordinal = acc.counts[d.entity] ?? 0;
-      return {
-        aliases: new Map([...acc.aliases, [d, `${d.entity}_${String(ordinal)}`]]),
-        counts: { ...acc.counts, [d.entity]: ordinal + 1 }
-      };
-    },
-    { aliases: /* @__PURE__ */ new Map(), counts: {} }
-  ).aliases;
-}
-function assignParams(bindings) {
-  const unique = [...new Set(bindings.filter((b) => b.__bind.kind === "param"))];
-  const assigned = unique.reduce(
-    (acc, b) => {
-      const token = tokenOf(b);
-      const ordinal = acc.counts[token.base] ?? 0;
-      const name = ordinal === 0 ? token.base : `${token.base}_${String(ordinal - 1)}`;
-      if (name in acc.params) {
-        throw new Error(
-          `param name "${name}" collides with an existing param \u2014 rename the field so deduplicated param names stay unique`
-        );
-      }
-      return {
-        counts: { ...acc.counts, [token.base]: ordinal + 1 },
-        names: new Map([...acc.names, [b, name]]),
-        params: { ...acc.params, [name]: { valueSpace: token.valueSpace } }
-      };
-    },
-    { counts: {}, names: /* @__PURE__ */ new Map(), params: {} }
-  );
-  return { names: assigned.names, params: assigned.params };
-}
-function tokenOf(binding) {
-  if (binding.__bind.kind !== "param") {
-    throw new Error("internal: expected a param binding");
-  }
-  return binding.__bind.token;
-}
-function allBindings(body, entities, absences, singletonStates) {
-  return [
-    ...entities.flatMap((d) => Object.values(d.props).flatMap((v2) => valueBindings(v2))),
-    ...absences.flatMap((a) => Object.values(a.where).flatMap((v2) => valueBindings(v2))),
-    ...singletonStates.flatMap((s) => valueBindings(s.value)),
-    ...body.steps.flatMap((builder) => stepBindings(builder.step))
-  ];
-}
-function stepBindings(step) {
-  return [...actionBindings(step.action), ...step.expect.flatMap((p) => predicateBindings(p))];
-}
-function actionBindings(action) {
-  if (action.kind === "goto") {
-    return valueBindings(action.url);
-  }
-  if (action.kind === "fill" || action.kind === "select") {
-    return [...locatorBindings(action.locator), ...valueBindings(action.value)];
-  }
-  if (action.kind === "press") {
-    return action.locator == null ? [] : locatorBindings(action.locator);
+// ../spec/src/predicate.ts
+import { z as z2 } from "zod";
+var stateAssertionSchema = z2.discriminatedUnion("kind", [
+  z2.object({
+    as: z2.string().min(1),
+    kind: z2.literal("created"),
+    props: z2.record(z2.string().min(1), setValueSchema)
+  }),
+  z2.object({
+    as: z2.string().min(1),
+    kind: z2.literal("updated"),
+    props: z2.record(z2.string().min(1), updateValueSchema)
+  }),
+  z2.object({ kind: z2.literal("deleted") })
+]);
+var singletonAssertionSchema = z2.object({ kind: z2.literal("is"), value: setValueSchema });
+var whereValueSchema = z2.lazy(
+  () => z2.union([setValueSchema, withinSchema])
+);
+var selectionSchema = z2.object({
+  entity: z2.string().min(1),
+  where: z2.record(z2.string().min(1), whereValueSchema)
+});
+var withinSchema = z2.object({
+  field: z2.string().min(1),
+  kind: z2.literal("within"),
+  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: z2.array(predicateSchema),
+    name: z2.string().min(1)
+  })
+);
+var predicateSchema = z2.lazy(
+  () => z2.discriminatedUnion("kind", [
+    z2.object({ kind: z2.literal("visible"), locator: locatorSchema, wait }),
+    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,
+    z2.object({
+      kind: z2.literal("browser"),
+      name: browserSingletonSchema,
+      value: stringValueSchema,
+      wait
+    }),
+    z2.object({
+      assertion: stateAssertionSchema,
+      entity: z2.string().min(1),
+      key: z2.record(z2.string().min(1), whereValueSchema),
+      kind: z2.literal("state"),
+      wait
+    }),
+    z2.object({ kind: z2.literal("not"), predicate: predicateSchema }),
+    z2.object({ kind: z2.literal("and"), predicates: z2.array(predicateSchema) }),
+    countPredicateSchema,
+    z2.object({ branches: z2.array(whenBranchSchema), kind: z2.literal("when") })
+  ])
+);
+
+// ../spec/src/codec.ts
+import { z as z3 } from "zod";
+var envelopeSchema = z3.object({
+  __codec: z3.string().min(1),
+  data: z3.unknown(),
+  version: z3.number().int().positive()
+});
+var CodecVersionError = class extends Error {
+  codec;
+  currentVersion;
+  gotVersion;
+  constructor(params) {
+    super(
+      `Unsupported ${params.codec} version ${String(params.gotVersion)} (current ${String(params.currentVersion)}). Upgrade Ripplo or rebuild with a compatible CLI.`
+    );
+    this.name = "CodecVersionError";
+    this.codec = params.codec;
+    this.currentVersion = params.currentVersion;
+    this.gotVersion = params.gotVersion;
   }
-  if (action.kind === "upload") {
-    return locatorBindings(action.locator);
+};
+var CodecMismatchError = class extends Error {
+  constructor(params) {
+    super(`Codec mismatch: expected "${params.expected}", got "${params.got}"`);
+    this.name = "CodecMismatchError";
   }
-  return locatorBindings(action.locator);
+};
+function defineCodec({
+  name,
+  schema
+}) {
+  return {
+    currentVersion: 1,
+    name,
+    decode: (raw) => decode({ name, raw, schema }),
+    encode: (value2) => ({
+      __codec: name,
+      data: value2,
+      version: 1
+    })
+  };
 }
-function locatorBindings(locator) {
-  if (locator.by === "inside") {
-    return [...locatorBindings(locator.scope), ...locatorBindings(locator.target)];
-  }
-  if (locator.by === "role") {
-    return locator.name == null ? [] : valueBindings(locator.name);
+function decode({
+  name,
+  raw,
+  schema
+}) {
+  const envelope = envelopeSchema.parse(raw);
+  if (envelope.__codec !== name) {
+    throw new CodecMismatchError({ expected: name, got: envelope.__codec });
   }
-  return valueBindings(locator.value);
-}
-function predicateBindings(predicate) {
-  switch (predicate.kind) {
-    case "visible":
-    case "disabled":
-    case "enabled":
-    case "focused":
-    case "checked": {
-      return locatorBindings(predicate.locator);
-    }
-    case "value":
-    case "text": {
-      return [...locatorBindings(predicate.locator), ...valueBindings(predicate.value)];
-    }
-    case "singleton": {
-      return valueBindings(predicate.assertion.value);
-    }
-    case "browser": {
-      return valueBindings(predicate.value);
-    }
-    case "state": {
-      return [
-        ...predicate.assertion.kind === "deleted" ? [] : Object.values(predicate.assertion.props).flatMap(
-          (v2) => isChanged(v2) ? [] : valueBindings(v2)
-        ),
-        ...Object.values(predicate.key).flatMap((v2) => whereBindings(v2))
-      ];
-    }
-    case "not": {
-      return predicateBindings(predicate.predicate);
-    }
-    case "when": {
-      return predicate.branches.flatMap((row2) => [
-        ...row2.condition == null ? [] : predicateBindings(row2.condition),
-        ...row2.consequence.flatMap((consequence) => predicateBindings(consequence))
-      ]);
-    }
-    case "and": {
-      return predicate.predicates.flatMap((p) => predicateBindings(p));
-    }
-    case "count": {
-      return [];
-    }
+  if (envelope.version !== 1) {
+    throw new CodecVersionError({ codec: name, currentVersion: 1, gotVersion: envelope.version });
   }
+  return schema.parse(envelope.data);
 }
-function whereBindings(value2) {
-  return isWithin2(value2) ? Object.values(value2.selection.where).flatMap((v2) => whereBindings(v2)) : valueBindings(value2);
-}
-function isWithin2(value2) {
-  return typeof value2 === "object" && value2 !== null && "kind" in value2;
+
+// ../spec/src/client-channel.ts
+var CLIENT_MOUNT_KEY = "__ripplo__";
+var CLIENT_SEED_KEY = "__ripplo_seed__";
+
+// ../spec/src/lockfile.ts
+import { z as z4 } from "zod";
+var actionSchema = z4.discriminatedUnion("kind", [
+  z4.object({ kind: z4.literal("goto"), url: stringValueSchema }),
+  z4.object({ kind: z4.literal("fill"), locator: locatorSchema, value: setValueSchema }),
+  z4.object({ kind: z4.literal("clear"), locator: locatorSchema }),
+  z4.object({ kind: z4.literal("click"), locator: locatorSchema }),
+  z4.object({ kind: z4.literal("dblclick"), locator: locatorSchema }),
+  z4.object({ kind: z4.literal("select"), locator: locatorSchema, value: setValueSchema }),
+  z4.object({ kind: z4.literal("check"), locator: locatorSchema }),
+  z4.object({ kind: z4.literal("uncheck"), locator: locatorSchema }),
+  z4.object({ kind: z4.literal("hover"), locator: locatorSchema }),
+  z4.object({
+    files: z4.array(z4.string().min(1)).min(1),
+    kind: z4.literal("upload"),
+    locator: locatorSchema
+  }),
+  z4.object({ key: z4.string().min(1), kind: z4.literal("press"), locator: locatorSchema.optional() })
+]);
+var stepSchema = z4.object({
+  action: actionSchema,
+  expect: z4.array(predicateSchema).default([])
+});
+var paramSchema = z4.object({
+  valueSpace: z4.string().min(1)
+});
+var setupSchema = z4.object({
+  as: z4.string().min(1),
+  entity: z4.string().min(1),
+  set: z4.record(z4.string().min(1), setValueSchema)
+});
+var absenceSchema = z4.object({
+  entity: z4.string().min(1),
+  where: z4.record(z4.string().min(1), setValueSchema)
+});
+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),
+  maybe: z4.array(setupSchema).default([]),
+  name: z4.string().min(1),
+  params: z4.record(z4.string().min(1), paramSchema),
+  singletons: z4.record(z4.string().min(1), setValueSchema).default({}),
+  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({
+  sha256: z4.string().regex(/^[0-9a-f]{64}$/u),
+  size: z4.number().int().nonnegative()
+});
+var lockfileSchema = z4.object({
+  entities: z4.array(entitySchemaSchema),
+  fixtures: z4.record(z4.string().min(1), fixtureEntrySchema).default({}),
+  singletons: z4.array(singletonSchemaSchema).default([]),
+  valueSpaces: z4.array(valueSpaceSchema),
+  workflows: z4.array(workflowSchema)
+});
+var lockfileCodec = defineCodec({ name: "ripplo-lockfile", schema: lockfileSchema });
+
+// ../../node_modules/.pnpm/safe-stable-stringify@2.5.0/node_modules/safe-stable-stringify/esm/wrapper.js
+var import__ = __toESM(require_safe_stable_stringify(), 1);
+var configure = import__.default.configure;
+
+// ../spec/src/sync-payload.ts
+import { z as z5 } from "zod";
+var stepDescriptorSchema = z5.object({
+  index: z5.number().int().nonnegative(),
+  kind: z5.string(),
+  target: z5.string(),
+  value: z5.string()
+});
+function slugify(name) {
+  return name.toLowerCase().replaceAll(/[^a-z0-9]/g, "-").split("-").filter((part) => part.length > 0).join("-");
 }
-function setMap(map, ctx) {
-  return Object.fromEntries(
-    Object.entries(map).map(([key2, value2]) => [key2, resolveValue(value2, ctx)])
-  );
+
+// ../spec/src/session.ts
+import { z as z6 } from "zod";
+var sameSiteSchema = z6.enum(["Strict", "Lax", "None"]);
+var cookieSchema = z6.object({
+  domain: z6.string().min(1),
+  expires: z6.number(),
+  httpOnly: z6.boolean(),
+  name: z6.string().min(1),
+  path: z6.string().min(1),
+  sameSite: sameSiteSchema,
+  secure: z6.boolean(),
+  value: z6.string()
+});
+var originSchema = z6.object({
+  localStorage: z6.array(z6.object({ name: z6.string().min(1), value: z6.string() })),
+  origin: z6.string().min(1)
+});
+var sessionSchema = z6.object({
+  cookies: z6.array(cookieSchema),
+  headers: z6.record(z6.string().min(1), z6.string()).optional(),
+  origins: z6.array(originSchema)
+});
+
+// ../spec/src/engine.ts
+import { z as z7 } from "zod";
+var cellSchema = z7.union([primitiveSchema, z7.null()]);
+var rowSchema = z7.record(z7.string().min(1), cellSchema);
+var setupSpecSchema = z7.object({
+  as: z7.string().min(1),
+  entity: z7.string().min(1),
+  fields: z7.record(z7.string().min(1), setValueSchema)
+});
+var setupRequestSchema = z7.object({
+  entities: z7.array(setupSpecSchema),
+  runId: z7.string().min(1),
+  singletons: z7.record(z7.string().min(1), cellSchema).default({})
+});
+var setupRowSchema = z7.object({
+  as: z7.string().min(1),
+  row: rowSchema,
+  session: sessionSchema.optional()
+});
+var setupResponseSchema = z7.object({
+  rows: z7.array(setupRowSchema)
+});
+var stateRequestSchema = z7.object({
+  entities: z7.array(z7.string().min(1)),
+  runId: z7.string().min(1),
+  singletons: z7.array(z7.string().min(1)).default([])
+});
+var stateResponseSchema = z7.object({
+  entities: z7.record(z7.string().min(1), z7.array(rowSchema)),
+  singletons: z7.record(z7.string().min(1), cellSchema).default({})
+});
+var teardownRequestSchema = z7.object({
+  runId: z7.string().min(1)
+});
+var teardownResponseSchema = z7.object({
+  ok: z7.literal(true)
+});
+
+// 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 resolveValue(value2, ctx) {
-  if (isBinding(value2)) {
-    return resolveBinding(value2, ctx);
-  }
-  if (isTemplate(value2)) {
-    return resolveTemplate(value2, ctx);
+function collectRefObjects(node) {
+  if (Array.isArray(node)) {
+    return node.flatMap((item) => collectRefObjects(item));
   }
-  return value2;
-}
-function resolveBinding(binding, ctx) {
-  const bind = binding.__bind;
-  if (bind.kind === "param") {
-    const name = ctx.params.get(binding);
-    if (name == null) {
-      throw new Error("internal: param binding was not collected");
-    }
-    return { ref: name };
+  if (node == null || typeof node !== "object") {
+    return [];
   }
-  const alias = ctx.aliases.get(bind.descriptor);
-  if (alias == null) {
-    throw new Error(
-      `references a "${bind.descriptor.entity}" entity that is not included in the test's given`
-    );
+  if ("ref" in node && typeof node.ref === "string" && Object.keys(node).length === 1) {
+    return [node.ref];
   }
-  return { ref: `${alias}.${bind.field}` };
-}
-function resolveTemplate(template, ctx) {
-  return {
-    template: template.template.map(
-      (segment) => isBinding(segment) ? resolveBinding(segment, ctx) : segment
-    )
-  };
+  return Object.values(node).flatMap((value2) => collectRefObjects(value2));
 }
-function setupsOf(entities, kind, ctx) {
-  return entities.filter((d) => d.kind === kind).map((d) => ({ as: aliasFor(ctx, d), entity: d.entity, set: setMap(d.props, ctx) }));
+function isRefValue(value2) {
+  return value2 != null && typeof value2 === "object" && "ref" in value2 ? value2.ref : void 0;
 }
-function aliasFor(ctx, descriptor) {
-  const alias = ctx.aliases.get(descriptor);
-  if (alias == null) {
-    throw new Error(`internal: no alias for ${descriptor.entity}`);
-  }
-  return alias;
+function headOf(ref) {
+  const dot = ref.indexOf(".");
+  return dot === -1 ? ref : ref.slice(0, dot);
 }
-function resolveStep(step, ctx) {
-  return {
-    action: resolveAction(step.action, ctx),
-    expect: step.expect.map((predicate) => resolvePredicate(predicate, ctx))
-  };
+function stepRefValues(step) {
+  return collectRefObjects(step).map((ref) => ({ ref }));
 }
-function resolveAction(action, ctx) {
-  if (action.kind === "goto") {
-    return { ...action, url: resolveString(action.url, ctx) };
-  }
-  if (action.kind === "fill" || action.kind === "select") {
-    return {
-      ...action,
-      locator: resolveLocator(action.locator, ctx),
-      value: resolveValue(action.value, ctx)
-    };
-  }
-  if (action.kind === "press") {
-    return {
-      ...action,
-      locator: action.locator == null ? void 0 : resolveLocator(action.locator, ctx)
-    };
+function refStrings(value2) {
+  const ref = isRefValue(value2);
+  if (ref != null) {
+    return [ref];
   }
-  if (action.kind === "upload") {
-    return { ...action, locator: resolveLocator(action.locator, ctx) };
+  if (value2 != null && typeof value2 === "object" && "template" in value2) {
+    return value2.template.flatMap((segment) => typeof segment === "string" ? [] : [segment.ref]);
   }
-  return { ...action, locator: resolveLocator(action.locator, ctx) };
+  return [];
 }
-function resolveString(value2, ctx) {
-  if (isBinding(value2)) {
-    return resolveBinding(value2, ctx);
-  }
-  if (isTemplate(value2)) {
-    return resolveTemplate(value2, ctx);
-  }
-  return value2;
+
+// 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 resolveLocator(locator, ctx) {
-  if (locator.by === "inside") {
-    return {
-      by: "inside",
-      scope: resolveLocator(locator.scope, ctx),
-      target: resolveLocator(locator.target, ctx)
-    };
+function expandWorkflow(workflow2, options) {
+  if (workflow2.stub) {
+    return { ...workflow2, tests: [] };
   }
-  if (locator.by === "role") {
-    return locator.name == null ? locator : { ...locator, name: resolveString(locator.name, ctx) };
+  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)] };
   }
-  return { ...locator, value: resolveString(locator.value, ctx) };
+  const { tests } = targets.reduce(
+    (acc, target) => coverTarget({ acc, sims, target, whenIds, workflow: workflow2 }),
+    { covered: /* @__PURE__ */ new Set(), tests: [] }
+  );
+  return { ...workflow2, tests };
 }
-function resolvePredicate(predicate, ctx) {
-  switch (predicate.kind) {
-    case "visible":
-    case "disabled":
-    case "enabled":
-    case "focused":
-    case "checked": {
-      return { ...predicate, locator: resolveLocator(predicate.locator, ctx) };
-    }
-    case "value":
-    case "text": {
-      return {
-        ...predicate,
-        locator: resolveLocator(predicate.locator, ctx),
-        value: resolveString(predicate.value, ctx)
-      };
-    }
-    case "singleton": {
-      return {
-        ...predicate,
-        assertion: { ...predicate.assertion, value: resolveValue(predicate.assertion.value, ctx) }
-      };
-    }
-    case "browser": {
-      return { ...predicate, value: resolveString(predicate.value, ctx) };
-    }
-    case "state": {
-      return {
-        ...predicate,
-        assertion: resolveAssertion(predicate.assertion, ctx),
-        key: whereMap(predicate.key, ctx)
-      };
-    }
-    case "not": {
-      return { ...predicate, predicate: resolvePredicate(predicate.predicate, ctx) };
-    }
-    case "when": {
-      return {
-        ...predicate,
-        branches: predicate.branches.map((row2) => ({
-          condition: row2.condition == null ? void 0 : resolveCondition(row2.condition, ctx),
-          consequence: row2.consequence.map((consequence) => resolvePredicate(consequence, ctx)),
-          name: row2.name
-        }))
-      };
-    }
-    case "and": {
-      return {
-        ...predicate,
-        predicates: predicate.predicates.map((p) => resolvePredicate(p, ctx))
-      };
+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 [];
     }
-    case "count": {
-      return predicate;
+    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 resolveAssertion(assertion, ctx) {
-  if (assertion.kind === "deleted") {
-    return assertion;
+function choiceKey(whenIds, when2, index) {
+  const id2 = whenIds.get(when2);
+  if (id2 == null) {
+    throw new Error("internal: when node missing from target index");
   }
-  const descriptor = ctx.captures.get(assertion);
-  if (descriptor == null) {
-    throw new Error("internal: capture assertion was not registered");
+  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`
+    );
   }
-  const as = aliasFor(ctx, descriptor);
-  return assertion.kind === "created" ? { as, kind: "created", props: setMap(assertion.props, ctx) } : { as, kind: "updated", props: updateMap(assertion.props, ctx) };
+  return test;
 }
-function updateMap(map, ctx) {
-  return Object.fromEntries(
-    Object.entries(map).map(([key2, value2]) => [
-      key2,
-      isChanged(value2) ? value2 : resolveValue(value2, ctx)
-    ])
+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 },
+    ...row2.consequence.flatMap((consequence) => targetsIn(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 whereMap(map, ctx) {
-  return Object.fromEntries(
-    Object.entries(map).map(([key2, value2]) => [
-      key2,
-      resolveWhere(value2, ctx)
-    ])
+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 resolveWhere(value2, ctx) {
-  return isWithin2(value2) ? { ...value2, selection: { ...value2.selection, where: whereMap(value2.selection.where, ctx) } } : resolveValue(value2, ctx);
+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),
+    ...row2.consequence.flatMap((consequence) => conditionLiteralsIn(consequence))
+  ]);
 }
-function resolveCondition(condition, ctx) {
+function singletonLiteralsInCondition(condition) {
   switch (condition.kind) {
     case "singleton": {
-      return {
-        ...condition,
-        assertion: {
-          ...condition.assertion,
-          value: resolveValue(condition.assertion.value, ctx)
-        }
-      };
+      const value2 = condition.assertion.value;
+      return value2 == null || typeof value2 !== "object" ? [[condition.singleton, value2]] : [];
     }
     case "count": {
-      return condition;
+      return [];
     }
     case "not": {
-      return { ...condition, predicate: resolveCondition(condition.predicate, ctx) };
+      return singletonLiteralsInCondition(condition.predicate);
     }
     case "and": {
-      return {
-        ...condition,
-        predicates: condition.predicates.map((p) => resolveCondition(p, ctx))
-      };
+      return condition.predicates.flatMap((p) => singletonLiteralsInCondition(p));
     }
   }
 }
-
-// src/workflow.ts
-function workflow(intent, fn) {
-  const sourcePath = captureSourcePath();
-  if (fn == null) {
-    return { spec: stubSpec(intent, sourcePath) };
-  }
-  const final = finalize(fn());
-  return {
-    spec: {
-      absent: final.absent,
-      exclusive: final.exclusive,
-      intent,
-      maybe: final.maybe,
-      name: slugify(intent),
-      params: final.params,
-      singletons: final.singletons,
-      sourcePath,
-      steps: final.steps,
-      stub: false,
-      tests: [],
-      world: final.world
-    }
-  };
-}
-function stubSpec(intent, sourcePath) {
-  return {
-    absent: [],
-    exclusive: [],
-    intent,
-    maybe: [],
-    name: slugify(intent),
-    params: {},
-    singletons: {},
-    sourcePath,
-    steps: [],
-    stub: true,
-    tests: [],
-    world: []
-  };
-}
-var WORKFLOWS_ANCHOR_PATTERN = /[/\\]\.ripplo[/\\]workflows[/\\]([^):]+?)(?::\d+:\d+\)?)?$/;
-function captureSourcePath() {
-  const stack = new Error("capture").stack;
-  if (stack == null) {
+function paramRefOf(value2) {
+  if (value2 == null || typeof value2 !== "object" || !("ref" in value2)) {
     return void 0;
   }
-  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("\\", "/");
+  return value2.ref.includes(".") ? void 0 : value2.ref;
 }
-function slugify(intent) {
-  const slug = intent.toLowerCase().replaceAll(/[^a-z0-9]+/g, " ").trim().split(" ").join("-");
-  if (slug.length === 0) {
-    throw new Error(`workflow intent "${intent}" slugifies to an empty string`);
+function withComplements(values, enumValues) {
+  if (enumValues != null) {
+    return [.../* @__PURE__ */ new Set([...values, ...enumValues])];
   }
-  return slug;
-}
-
-// src/params.ts
-function arbitrary(field2) {
-  const token = {
-    base: `${field2.entity}_${field2.field}`,
-    valueSpace: field2.valueSpaceName
-  };
-  return paramBinding(token);
-}
-
-// src/engine.ts
-import { err, ok, okAsync, Result, ResultAsync } from "neverthrow";
-function createEngine(ripplo, impls, teardown) {
-  const entities = new Map(Object.entries(impls.entities));
-  const singletons = new Map(
-    Object.entries(impls.singletons).map(([name, impl]) => [
-      name,
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- per-name impls typed at the call site; erase the contravariant scalar seed to the loose dispatch shape
-      impl
-    ])
-  );
-  assertDeclared(ripplo, [...entities.keys()], [...singletons.keys()]);
-  const entityImpl = (name) => lookup(entities.get(name), name);
-  const singletonImpl = (name) => lookup(singletons.get(name), name);
-  return {
-    read: (request, runId) => ResultAsync.combine([
-      ResultAsync.combine(
-        request.entities.map((name) => readEntity(entityImpl(name), name, runId))
-      ),
-      ResultAsync.combine(
-        request.singletons.map((name) => readSingleton(singletonImpl(name), name, runId))
-      )
-    ]).map(([entityPairs, singletonPairs]) => ({
-      entities: Object.fromEntries(entityPairs),
-      singletons: Object.fromEntries(singletonPairs)
-    })),
-    seed: (request, runId) => ResultAsync.fromPromise(teardown(runId), implFailure).andThen(() => seedSingletons(request.singletons, singletonImpl, runId)).andThen(() => seedSetups(request.entities, entityImpl, runId)),
-    teardown: (runId) => ResultAsync.fromPromise(teardown(runId), implFailure)
-  };
-}
-function assertDeclared(ripplo, entityNames, singletonNames) {
-  const backendEntities = new Set(
-    ripplo.entities.filter((e) => e.schema.source === "backend").map((e) => e.name)
-  );
-  const backendSingletons = new Set(
-    ripplo.singletons.filter((s) => s.schema.source === "backend").map((s) => s.name)
-  );
-  entityNames.forEach((name) => {
-    if (!backendEntities.has(name)) {
-      throw new Error(`engine impl "${name}" has no matching backend entity`);
+  const complements = values.flatMap((value2) => {
+    if (typeof value2 === "boolean") {
+      return [!value2];
+    }
+    if (typeof value2 === "number") {
+      return [value2 + 1];
     }
-  });
-  singletonNames.forEach((name) => {
-    if (!backendSingletons.has(name)) {
-      throw new Error(`engine impl "${name}" has no matching backend singleton`);
+    if (typeof value2 === "string") {
+      return [syntheticDistinct(value2, values)];
     }
+    return [];
   });
+  return [.../* @__PURE__ */ new Set([...values, ...complements])];
 }
-function lookup(impl, name) {
-  return impl == null ? err({ message: `no engine impl for "${name}"` }) : ok(impl);
+function syntheticDistinct(seed, taken) {
+  const candidate = `${seed}-alt`;
+  return taken.includes(candidate) ? syntheticDistinct(candidate, taken) : candidate;
 }
-function readEntity(impl, name, runId) {
-  return impl.asyncAndThen(
-    (i) => ResultAsync.fromPromise(i.read({ runId }), implFailure).map((rows) => [
-      name,
-      [...rows]
-    ])
+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 implFailure(error) {
-  return { message: error instanceof Error ? error.message : String(error) };
-}
-function readSingleton(impl, name, runId) {
-  return impl.asyncAndThen(
-    (i) => ResultAsync.fromPromise(i.read({ runId }), implFailure).map((value2) => [
-      name,
-      value2
-    ])
+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 seedSingletons(values, singletonImpl, runId) {
-  return ResultAsync.combine(
-    Object.entries(values).map(
-      ([name, value2]) => singletonImpl(name).asyncAndThen(
-        (impl) => ResultAsync.fromPromise(impl.seed({ runId, value: value2 }), implFailure)
-      )
-    )
+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]]);
+  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 seedSetups(specs, entityImpl, runId) {
-  const waves = dependencyWaves(specs);
-  return waves.reduce((accR, wave) => accR.andThen((acc) => seedWave(wave, entityImpl, acc, runId)), okAsync({ env: /* @__PURE__ */ new Map(), rows: [] })).map((fold) => orderRows(specs, fold.rows));
+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 dependencyWaves(specs) {
-  return buildWaves([], specs);
+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 buildWaves(done, remaining) {
-  if (remaining.length === 0) {
-    return done;
+function compareValues(seeded, wanted) {
+  if (seeded === void 0) {
+    return "unknown";
   }
-  const seeded = new Set(done.flat().map((spec) => spec.as));
-  const ready = remaining.filter((spec) => refAliases(spec).every((alias) => seeded.has(alias)));
-  if (ready.length === 0) {
-    return [...done, remaining];
+  const seededRef = isRefValue(seeded);
+  const wantedRef = isRefValue(wanted);
+  if (seededRef != null && wantedRef != null) {
+    return seededRef === wantedRef ? true : "unknown";
   }
-  return buildWaves(
-    [...done, ready],
-    remaining.filter((spec) => !ready.includes(spec))
-  );
+  if (seededRef != null || wantedRef != null || isTemplateValue(seeded) || isTemplateValue(wanted)) {
+    return "unknown";
+  }
+  return sameSetValue(seeded, wanted);
 }
-function refAliases(spec) {
-  return Object.values(spec.fields).flatMap((value2) => {
-    if (value2 === null || typeof value2 !== "object" || !("ref" in value2)) {
-      return [];
-    }
-    const lastDot = value2.ref.lastIndexOf(".");
-    return lastDot === -1 ? [] : [value2.ref.slice(0, lastDot)];
-  });
+function isTemplateValue(value2) {
+  return value2 != null && typeof value2 === "object" && "template" in value2;
 }
-function seedWave(wave, entityImpl, acc, runId) {
-  return ResultAsync.combine(
-    wave.map((spec) => seedSetup(entityImpl(spec.entity), acc, spec, runId))
-  ).map((folds) => mergeFolds(acc, folds));
+function negate(value2) {
+  return value2 === "unknown" ? "unknown" : !value2;
 }
-function seedSetup(impl, acc, spec, runId) {
-  return resolveFields(spec.fields, acc.env).asyncAndThen((fields) => runSeed(impl, fields, runId)).map(({ row: row2, session }) => foldRow(acc, spec, row2, session));
+function conjoin(values) {
+  if (values.includes(false)) {
+    return false;
+  }
+  return values.every((v2) => v2 === true) ? true : "unknown";
 }
-function resolveFields(fields, env) {
-  return Result.combine(
-    Object.entries(fields).map(
-      ([field2, value2]) => resolveValue2(value2, env).map((cell2) => [field2, cell2])
-    )
-  ).map((entries) => Object.fromEntries(entries));
+function singletonSets(predicates) {
+  return Object.fromEntries(
+    predicates.flatMap((predicate) => {
+      if (predicate.kind === "singleton") {
+        return [[predicate.singleton, predicate.assertion.value]];
+      }
+      return [];
+    })
+  );
 }
-function resolveValue2(value2, env) {
-  if (value2 === null || typeof value2 !== "object") {
-    return ok(value2);
+function applyEffect(rows, effect) {
+  if (effect.assertion.kind === "created") {
+    return [
+      ...rows,
+      { as: effect.assertion.as, entity: effect.entity, set: effect.assertion.props }
+    ];
   }
-  if ("ref" in value2) {
-    return env.has(value2.ref) ? ok(env.get(value2.ref) ?? null) : err({ message: `setup ref "${value2.ref}" was not produced by an earlier entity` });
+  if (effect.assertion.kind === "deleted") {
+    return rows.filter((row2) => row2.entity !== effect.entity || !matchesKey(row2, effect.key, rows));
   }
-  throw new Error("internal: a setup value resolved to an unresolved template");
+  return rows;
 }
-function runSeed(impl, fields, runId) {
-  return impl.asyncAndThen((i) => ResultAsync.fromPromise(i.seed({ fields, runId }), implFailure));
+function matchesKey(row2, key2, rows) {
+  return Object.entries(key2).every(([field2, want]) => matchesField({ field: field2, row: row2, rows, want }));
 }
-function foldRow(acc, spec, row2, session) {
-  const next = Object.entries(row2).map(([field2, value2]) => [
-    `${spec.as}.${field2}`,
-    value2
-  ]);
+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) => resolvePredicate(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 {
-    env: new Map([...acc.env, ...next]),
-    rows: [...acc.rows, { as: spec.as, row: row2, session }]
+    absent: workflow2.absent,
+    exclusive: workflow2.exclusive,
+    intent: workflow2.intent,
+    name,
+    params: Object.fromEntries(
+      Object.entries(workflow2.params).filter(([param]) => used.has(param))
+    ),
+    singletons,
+    slug: slugify(name),
+    steps,
+    workflow: workflow2.name,
+    world
   };
 }
-function mergeFolds(base, folds) {
-  return {
-    env: new Map([...base.env, ...folds.flatMap((fold) => [...fold.env])]),
-    rows: [...base.rows, ...folds.flatMap((fold) => fold.rows.slice(base.rows.length))]
-  };
+function resolvePredicate(predicate, choices) {
+  if (predicate.kind === "not") {
+    const inner = resolvePredicate(predicate.predicate, choices);
+    return inner.map((p) => ({ kind: "not", predicate: p }));
+  }
+  if (predicate.kind === "and") {
+    return [
+      {
+        kind: "and",
+        predicates: predicate.predicates.flatMap((p) => resolvePredicate(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 ? [] : row2.consequence.flatMap((c) => resolvePredicate(c, choices));
 }
-function orderRows(specs, rows) {
-  const byAs = new Map(rows.map((row2) => [row2.as, row2]));
-  return specs.flatMap((spec) => {
-    const row2 = byAs.get(spec.as);
-    return row2 == null ? [] : [row2];
+
+// 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),
+    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;
 }
-
-// src/client-engine.ts
-import { z as z8 } from "zod";
-
-// ../spec/src/leaves.ts
-import { z } from "zod";
-var budgetSchema = z.enum(["fast", "slow", "async"]);
-var valueRefSchema = z.object({ ref: z.string().min(1) });
-var primitiveSchema = z.union([z.string(), z.number(), z.boolean()]);
-var templateSchema = z.object({
-  template: z.array(z.union([z.string(), valueRefSchema])).min(1)
-});
-var setValueSchema = z.union([valueRefSchema, primitiveSchema, templateSchema, z.null()]);
-var changedSchema = z.object({ kind: z.literal("changed") });
-var updateValueSchema = z.union([setValueSchema, changedSchema]);
-var stringValueSchema = z.union([z.string(), valueRefSchema, templateSchema]);
-var roleLocatorSchema = z.object({
-  by: z.literal("role"),
-  name: z.union([stringValueSchema, z.undefined()]).optional().transform((value2) => value2),
-  role: z.string().min(1)
-});
-var testIdLocatorSchema = z.object({ by: z.literal("testId"), value: stringValueSchema });
-var insideLocatorSchema = z.object({
-  by: z.literal("inside"),
-  scope: z.lazy(() => locatorSchema),
-  target: z.lazy(() => locatorSchema)
-});
-var locatorSchema = z.discriminatedUnion("by", [
-  roleLocatorSchema,
-  testIdLocatorSchema,
-  insideLocatorSchema
-]);
-var primitiveTypeSchema = z.enum(["string", "number", "boolean"]);
-var consistencyClassSchema = z.enum(["strict", "eventual"]);
-var stringConstraintsSchema = z.object({
-  kind: z.literal("string"),
-  maxLength: z.number().int().positive().optional(),
-  minLength: z.number().int().nonnegative().optional(),
-  pattern: z.string().optional()
-});
-var numberConstraintsSchema = z.object({
-  kind: z.literal("number"),
-  max: z.number().int().optional(),
-  min: z.number().int().optional()
-});
-var datetimeConstraintsSchema = z.object({
-  kind: z.literal("datetime"),
-  maxOffsetDays: z.number().int(),
-  minOffsetDays: z.number().int()
-});
-var constraintsSchema = z.discriminatedUnion("kind", [
-  stringConstraintsSchema,
-  numberConstraintsSchema,
-  datetimeConstraintsSchema
-]);
-var generatorSchema = z.enum([
-  "company.name",
-  "date.iso",
-  "internet.email",
-  "internet.url",
-  "person.fullName",
-  "lorem.slug",
-  "lorem.word"
-]);
-var valueSpaceSchema = z.object({
-  constraints: constraintsSchema.optional(),
-  generator: generatorSchema,
-  name: z.string().min(1),
-  type: primitiveTypeSchema,
-  values: z.array(primitiveSchema).min(1).optional()
-});
-var propSpecSchema = z.object({
-  consistency: consistencyClassSchema.default("strict"),
-  optional: z.boolean(),
-  type: primitiveTypeSchema,
-  valueSpace: z.string().min(1).optional()
-});
-var sourceSchema = z.enum(["backend", "client"]);
-var entitySchemaSchema = z.object({
-  description: z.string().optional(),
-  identity: z.array(z.string().min(1)).min(1),
-  identityKind: z.enum(["surrogate", "natural"]),
-  name: z.string().min(1),
-  props: z.record(z.string().min(1), propSpecSchema),
-  source: sourceSchema.default("backend")
-});
-var singletonSchemaSchema = z.object({
-  consistency: consistencyClassSchema.default("strict"),
-  default: primitiveSchema,
-  description: z.string().optional(),
-  name: z.string().min(1),
-  source: sourceSchema.default("backend"),
-  type: primitiveTypeSchema,
-  valueSpace: z.string().min(1).optional()
-});
-var browserSingletonSchema = z.enum(["url", "title", "viewport"]);
-
-// ../spec/src/predicate.ts
-import { z as z2 } from "zod";
-var stateAssertionSchema = z2.discriminatedUnion("kind", [
-  z2.object({
-    as: z2.string().min(1),
-    kind: z2.literal("created"),
-    props: z2.record(z2.string().min(1), setValueSchema)
-  }),
-  z2.object({
-    as: z2.string().min(1),
-    kind: z2.literal("updated"),
-    props: z2.record(z2.string().min(1), updateValueSchema)
-  }),
-  z2.object({ kind: z2.literal("deleted") })
-]);
-var singletonAssertionSchema = z2.object({ kind: z2.literal("is"), value: setValueSchema });
-var whereValueSchema = z2.lazy(
-  () => z2.union([setValueSchema, withinSchema])
-);
-var selectionSchema = z2.object({
-  entity: z2.string().min(1),
-  where: z2.record(z2.string().min(1), whereValueSchema)
-});
-var withinSchema = z2.object({
-  field: z2.string().min(1),
-  kind: z2.literal("within"),
-  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: z2.array(predicateSchema),
-    name: z2.string().min(1)
-  })
-);
-var predicateSchema = z2.lazy(
-  () => z2.discriminatedUnion("kind", [
-    z2.object({ kind: z2.literal("visible"), locator: locatorSchema, wait }),
-    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,
-    z2.object({
-      kind: z2.literal("browser"),
-      name: browserSingletonSchema,
-      value: stringValueSchema,
-      wait
-    }),
-    z2.object({
-      assertion: stateAssertionSchema,
-      entity: z2.string().min(1),
-      key: z2.record(z2.string().min(1), whereValueSchema),
-      kind: z2.literal("state"),
-      wait
-    }),
-    z2.object({ kind: z2.literal("not"), predicate: predicateSchema }),
-    z2.object({ kind: z2.literal("and"), predicates: z2.array(predicateSchema) }),
-    countPredicateSchema,
-    z2.object({ branches: z2.array(whenBranchSchema), kind: z2.literal("when") })
-  ])
-);
-
-// ../spec/src/codec.ts
-import { z as z3 } from "zod";
-var envelopeSchema = z3.object({
-  __codec: z3.string().min(1),
-  data: z3.unknown(),
-  version: z3.number().int().positive()
-});
-var CodecVersionError = class extends Error {
-  codec;
-  currentVersion;
-  gotVersion;
-  constructor(params) {
-    super(
-      `Unsupported ${params.codec} version ${String(params.gotVersion)} (current ${String(params.currentVersion)}). Upgrade Ripplo or rebuild with a compatible CLI.`
-    );
-    this.name = "CodecVersionError";
-    this.codec = params.codec;
-    this.currentVersion = params.currentVersion;
-    this.gotVersion = params.gotVersion;
-  }
-};
-var CodecMismatchError = class extends Error {
-  constructor(params) {
-    super(`Codec mismatch: expected "${params.expected}", got "${params.got}"`);
-    this.name = "CodecMismatchError";
+function assertUniqueNames(entities) {
+  const names = entities.map((handle) => handle.schema.name);
+  const duplicate = names.find((name, index) => names.indexOf(name) !== index);
+  if (duplicate != null) {
+    throw new Error(`duplicate entity name "${duplicate}" \u2014 each entity name must be unique`);
   }
-};
-function defineCodec({
-  name,
-  schema
-}) {
+}
+function dedupeByName(spaces) {
+  const byName = new Map(spaces.map((space) => [space.name, space]));
+  return [...byName.values()];
+}
+function assertNoContradictions(lockfile) {
+  lockfile.workflows.forEach((workflow2) => {
+    assertNoContradiction(workflow2);
+    assertNoDanglingRefs(workflow2);
+  });
+}
+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 "${workflow2.name}": creates a "${absence.entity}" ("${clash.as}") that a none(${absence.entity}, \u2026) in its world forbids`
+      );
+    }
+  });
+}
+function whereMatches(where, set) {
+  return Object.entries(where).every(([field2, want]) => sameValue(want, set[field2]));
+}
+function sameValue(a, b) {
+  return b !== void 0 && sameSetValue(a, b);
+}
+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 = [
+    ...workflow2.world.map((setup) => setup.set),
+    ...workflow2.maybe.map((setup) => setup.set),
+    ...workflow2.absent.map((absence) => absence.where)
+  ];
+  fieldSets.forEach((set) => {
+    assertSetRefs(workflow2.name, set, aliases, paramKeys);
+  });
+}
+function assertSetRefs(workflowName, set, aliases, paramKeys) {
+  Object.values(set).forEach((value2) => {
+    if (!isRef(value2) || paramKeys.has(value2.ref)) {
+      return;
+    }
+    const lastDot = value2.ref.lastIndexOf(".");
+    if (lastDot === -1) {
+      return;
+    }
+    const aliasPath = value2.ref.slice(0, lastDot);
+    if (!aliases.has(aliasPath)) {
+      throw new Error(
+        `test "${workflowName}": ref "${value2.ref}" points at unknown alias "${aliasPath}"`
+      );
+    }
+  });
+}
+function isRef(value2) {
+  return value2 != null && typeof value2 === "object" && "ref" in value2;
+}
+
+// src/ripplo.ts
+function createRipplo(input) {
   return {
-    currentVersion: 1,
-    name,
-    decode: (raw) => decode({ name, raw, schema }),
-    encode: (value2) => ({
-      __codec: name,
-      data: value2,
-      version: 1
-    })
+    entities: input.entities,
+    lockfile: buildLockfile({
+      entities: input.entities,
+      singletons: input.singletons,
+      workflows: input.workflows
+    }),
+    singletons: input.singletons,
+    workflows: input.workflows
   };
 }
-function decode({
-  name,
-  raw,
-  schema
-}) {
-  const envelope = envelopeSchema.parse(raw);
-  if (envelope.__codec !== name) {
-    throw new CodecMismatchError({ expected: name, got: envelope.__codec });
-  }
-  if (envelope.version !== 1) {
-    throw new CodecVersionError({ codec: name, currentVersion: 1, gotVersion: envelope.version });
+
+// src/locators.ts
+function role(roleName, name, ...bindings) {
+  return { by: "role", name: name == null ? void 0 : nameValue(name, bindings), role: roleName };
+}
+function inside(scope, target) {
+  return { by: "inside", scope, target };
+}
+function testId(value2, ...bindings) {
+  if (typeof value2 === "string") {
+    return { by: "testId", value: value2 };
   }
-  return schema.parse(envelope.data);
+  return { by: "testId", value: stringValueFromTemplate(value2, bindings) };
 }
-
-// ../spec/src/client-channel.ts
-var CLIENT_MOUNT_KEY = "__ripplo__";
-var CLIENT_SEED_KEY = "__ripplo_seed__";
-
-// ../spec/src/lockfile.ts
-import { z as z4 } from "zod";
-var actionSchema = z4.discriminatedUnion("kind", [
-  z4.object({ kind: z4.literal("goto"), url: stringValueSchema }),
-  z4.object({ kind: z4.literal("fill"), locator: locatorSchema, value: setValueSchema }),
-  z4.object({ kind: z4.literal("clear"), locator: locatorSchema }),
-  z4.object({ kind: z4.literal("click"), locator: locatorSchema }),
-  z4.object({ kind: z4.literal("dblclick"), locator: locatorSchema }),
-  z4.object({ kind: z4.literal("select"), locator: locatorSchema, value: setValueSchema }),
-  z4.object({ kind: z4.literal("check"), locator: locatorSchema }),
-  z4.object({ kind: z4.literal("uncheck"), locator: locatorSchema }),
-  z4.object({ kind: z4.literal("hover"), locator: locatorSchema }),
-  z4.object({
-    files: z4.array(z4.string().min(1)).min(1),
-    kind: z4.literal("upload"),
-    locator: locatorSchema
-  }),
-  z4.object({ key: z4.string().min(1), kind: z4.literal("press"), locator: locatorSchema.optional() })
-]);
-var stepSchema = z4.object({
-  action: actionSchema,
-  expect: z4.array(predicateSchema).default([])
-});
-var paramSchema = z4.object({
-  valueSpace: z4.string().min(1)
-});
-var setupSchema = z4.object({
-  as: z4.string().min(1),
-  entity: z4.string().min(1),
-  set: z4.record(z4.string().min(1), setValueSchema)
-});
-var absenceSchema = z4.object({
-  entity: z4.string().min(1),
-  where: z4.record(z4.string().min(1), setValueSchema)
-});
-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),
-  maybe: z4.array(setupSchema).default([]),
-  name: z4.string().min(1),
-  params: z4.record(z4.string().min(1), paramSchema),
-  singletons: z4.record(z4.string().min(1), setValueSchema).default({}),
-  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({
-  sha256: z4.string().regex(/^[0-9a-f]{64}$/u),
-  size: z4.number().int().nonnegative()
-});
-var lockfileSchema = z4.object({
-  entities: z4.array(entitySchemaSchema),
-  fixtures: z4.record(z4.string().min(1), fixtureEntrySchema).default({}),
-  singletons: z4.array(singletonSchemaSchema).default([]),
-  valueSpaces: z4.array(valueSpaceSchema),
-  workflows: z4.array(workflowSchema)
-});
-var lockfileCodec = defineCodec({ name: "ripplo-lockfile", schema: lockfileSchema });
-
-// ../../node_modules/.pnpm/safe-stable-stringify@2.5.0/node_modules/safe-stable-stringify/esm/wrapper.js
-var import__ = __toESM(require_safe_stable_stringify(), 1);
-var configure = import__.default.configure;
-
-// ../spec/src/sync-payload.ts
-import { z as z5 } from "zod";
-var stepDescriptorSchema = z5.object({
-  index: z5.number().int().nonnegative(),
-  kind: z5.string(),
-  target: z5.string(),
-  value: z5.string()
-});
-function slugify2(name) {
-  return name.toLowerCase().replaceAll(/[^a-z0-9]/g, "-").split("-").filter((part) => part.length > 0).join("-");
+var alertdialog = named("alertdialog");
+var button = named("button");
+var cell = named("cell");
+var checkbox = named("checkbox");
+var columnheader = named("columnheader");
+var combobox = named("combobox");
+var dialog = named("dialog");
+var heading = named("heading");
+var img = named("img");
+var link = named("link");
+var listitem = named("listitem");
+var menuitem = named("menuitem");
+var option = named("option");
+var radio = named("radio");
+var row = named("row");
+var searchbox = named("searchbox");
+var slider = named("slider");
+var spinbutton = named("spinbutton");
+var switchControl = named("switch");
+var tab = named("tab");
+var textbox = named("textbox");
+var treeitem = named("treeitem");
+var alert = container("alert");
+var banner = container("banner");
+var complementary = container("complementary");
+var contentinfo = container("contentinfo");
+var form = container("form");
+var grid = container("grid");
+var group = container("group");
+var list = container("list");
+var main = container("main");
+var menu = container("menu");
+var navigation = container("navigation");
+var progressbar = container("progressbar");
+var radiogroup = container("radiogroup");
+var region = container("region");
+var status = container("status");
+var table = container("table");
+var tablist = container("tablist");
+var tabpanel = container("tabpanel");
+var toolbar = container("toolbar");
+function named(roleName) {
+  return (name, ...bindings) => role(roleName, name, ...bindings);
+}
+function container(roleName) {
+  return (name, ...bindings) => role(roleName, name, ...bindings);
+}
+function nameValue(name, bindings) {
+  if (typeof name === "string") {
+    return name;
+  }
+  if (isBinding(name)) {
+    return name;
+  }
+  return stringValueFromTemplate(name, bindings);
 }
 
-// ../spec/src/session.ts
-import { z as z6 } from "zod";
-var sameSiteSchema = z6.enum(["Strict", "Lax", "None"]);
-var cookieSchema = z6.object({
-  domain: z6.string().min(1),
-  expires: z6.number(),
-  httpOnly: z6.boolean(),
-  name: z6.string().min(1),
-  path: z6.string().min(1),
-  sameSite: sameSiteSchema,
-  secure: z6.boolean(),
-  value: z6.string()
-});
-var originSchema = z6.object({
-  localStorage: z6.array(z6.object({ name: z6.string().min(1), value: z6.string() })),
-  origin: z6.string().min(1)
-});
-var sessionSchema = z6.object({
-  cookies: z6.array(cookieSchema),
-  headers: z6.record(z6.string().min(1), z6.string()).optional(),
-  origins: z6.array(originSchema)
-});
-
-// ../spec/src/engine.ts
-import { z as z7 } from "zod";
-var cellSchema = z7.union([primitiveSchema, z7.null()]);
-var rowSchema = z7.record(z7.string().min(1), cellSchema);
-var setupSpecSchema = z7.object({
-  as: z7.string().min(1),
-  entity: z7.string().min(1),
-  fields: z7.record(z7.string().min(1), setValueSchema)
-});
-var setupRequestSchema = z7.object({
-  entities: z7.array(setupSpecSchema),
-  runId: z7.string().min(1),
-  singletons: z7.record(z7.string().min(1), cellSchema).default({})
-});
-var setupRowSchema = z7.object({
-  as: z7.string().min(1),
-  row: rowSchema,
-  session: sessionSchema.optional()
-});
-var setupResponseSchema = z7.object({
-  rows: z7.array(setupRowSchema)
-});
-var stateRequestSchema = z7.object({
-  entities: z7.array(z7.string().min(1)),
-  runId: z7.string().min(1),
-  singletons: z7.array(z7.string().min(1)).default([])
-});
-var stateResponseSchema = z7.object({
-  entities: z7.record(z7.string().min(1), z7.array(rowSchema)),
-  singletons: z7.record(z7.string().min(1), cellSchema).default({})
-});
-var teardownRequestSchema = z7.object({
-  runId: z7.string().min(1)
-});
-var teardownResponseSchema = z7.object({
-  ok: z7.literal(true)
-});
+// src/singleton.ts
+function singleton(name, config) {
+  const valueSpaceName = `singleton.${name}`;
+  const { constraints, generator, primitive } = config.value;
+  const schema = {
+    consistency: config.consistency ?? "strict",
+    default: config.default,
+    description: config.description,
+    name,
+    source: config.source,
+    type: primitive,
+    valueSpace: valueSpaceName
+  };
+  return {
+    is: isPredicate,
+    name,
+    schema,
+    source: config.source,
+    value: { __t: void 0, entity: name, field: "value", primitive, valueSpaceName },
+    valueSpaces: [{ constraints, generator, name: valueSpaceName, type: primitive }],
+    of: (value2) => ({
+      __entity: { kind: "singletonState", singleton: name, value: toSetValue(value2) },
+      is: isPredicate
+    })
+  };
+  function isPredicate(value2) {
+    return condLeaf({
+      assertion: { kind: "is", value: value2 },
+      kind: "singleton",
+      singleton: name,
+      wait: void 0
+    });
+  }
+}
 
-// src/client-engine.ts
-var seedSchema = z8.record(z8.string(), z8.union([z8.string(), z8.number(), z8.boolean()])).catch({});
-function createClientEngine(_ripplo, impls) {
-  const singletons = new Map(
-    Object.entries(impls.singletons).map(([name, impl]) => [
+// src/builtins.ts
+function browserSingleton(name) {
+  return {
+    name,
+    is: (strings, ...values) => leaf({
+      kind: "browser",
       name,
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- per-name impls typed at the call site; erase the contravariant scalar seed to the loose dispatch shape
-      impl
-    ])
-  );
-  const entities = new Map(Object.entries(impls.entities));
-  const seed = seedSchema.parse(Reflect.get(globalThis, CLIENT_SEED_KEY));
-  Object.entries(seed).forEach(([name, value2]) => singletons.get(name)?.seed(value2));
+      value: stringValueFromTemplate(strings, values),
+      wait: void 0
+    })
+  };
+}
+var url = browserSingleton("url");
+var title = browserSingleton("title");
+var viewport = browserSingleton("viewport");
+
+// src/actions.ts
+function goto(strings, ...values) {
+  return stepBuilder({ kind: "goto", url: stringValueFromTemplate(strings, values) }, [], []);
+}
+function click(locator) {
+  return stepBuilder({ kind: "click", locator }, [], []);
+}
+function dblclick(locator) {
+  return stepBuilder({ kind: "dblclick", locator }, [], []);
+}
+function fill(locator, binding) {
+  return stepBuilder({ kind: "fill", locator, value: binding }, [], []);
+}
+function clear(locator) {
+  return stepBuilder({ kind: "clear", locator }, [], []);
+}
+function select(locator, binding) {
+  return stepBuilder({ kind: "select", locator, value: binding }, [], []);
+}
+function check(locator) {
+  return stepBuilder({ kind: "check", locator }, [], []);
+}
+function uncheck(locator) {
+  return stepBuilder({ kind: "uncheck", locator }, [], []);
+}
+function hover(locator) {
+  return stepBuilder({ kind: "hover", locator }, [], []);
+}
+function upload(locator, files) {
+  return stepBuilder({ files: [...files], kind: "upload", locator }, [], []);
+}
+function press(pressKey, locator) {
+  return stepBuilder({ key: pressKey, kind: "press", locator }, [], []);
+}
+function stepBuilder(action, expected, captures) {
   return {
-    readEntity: (name) => entities.get(name)?.read() ?? [],
-    readSingleton: (name) => singletons.get(name)?.read() ?? null
+    captures,
+    step: { action, expect: [...expected] },
+    expect: (...predicates) => stepBuilder(
+      action,
+      [...expected, ...predicates.map((p) => toPredicate(p))],
+      [...captures, ...predicates.flatMap((p) => isCapturePredicate(p) ? [captureOf(p)] : [])]
+    )
   };
 }
-function mountClientEngine(ripplo, impls, { enabled: enabled2 }) {
-  if (!enabled2) {
-    return;
+
+// 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`
+    );
   }
-  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))
+// src/finalize.ts
+function finalize(body) {
+  const descriptors = [...new Set(body.given.map((item) => item.__entity))];
+  const absences = descriptors.filter((d) => d.kind === "none");
+  const singletonStates = descriptors.filter(
+    (d) => d.kind === "singletonState"
+  );
+  const entities = topoSort(
+    descriptors.filter(
+      (d) => d.kind === "of" || d.kind === "only" || d.kind === "maybe"
+    )
+  );
+  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)]);
+  const { names, params } = assignParams(allBindings(body, entities, absences, singletonStates));
+  const ctx = {
+    aliases,
+    captures: new Map(
+      captures.map((c) => [c.assertion, c.descriptor])
+    ),
+    params: names
+  };
+  return {
+    absent: absences.map((a) => ({ entity: a.entity, where: setMap(a.where, ctx) })),
+    exclusive: [...new Set(entities.filter((d) => d.kind === "only").map((d) => d.entity))],
+    maybe: setupsOf(entities, "maybe", ctx),
+    params,
+    singletons: resolveSingletons(singletonStates, ctx),
+    steps: body.steps.map((builder) => resolveStep(builder.step, ctx)),
+    world: entities.filter((d) => d.kind === "of" || d.kind === "only").map((d) => ({ as: aliasFor(ctx, d), entity: d.entity, set: setMap(d.props, ctx) }))
+  };
+}
+function resolveSingletons(states, ctx) {
+  return states.reduce((acc, state) => {
+    const value2 = resolveValue(state.value, ctx);
+    const existing = acc[state.singleton];
+    if (existing !== void 0 && !sameSetValue(existing, value2)) {
+      throw new Error(
+        `singleton "${state.singleton}" is given two conflicting values \u2014 a test may set each singleton to one value`
+      );
+    }
+    return { ...acc, [state.singleton]: value2 };
+  }, {});
+}
+function assertNoMaybeRefs({ absences, entities, singletonStates }) {
+  const offenders = [
+    ...entities.filter((d) => d.kind === "of" || d.kind === "only").flatMap((d) => maybeBindings(Object.values(d.props), `${d.kind}(${d.entity})`)),
+    ...absences.flatMap((a) => maybeBindings(Object.values(a.where), `none(${a.entity})`)),
+    ...singletonStates.flatMap((s) => maybeBindings([s.value], `singleton "${s.singleton}"`))
   ];
-  return new Set(values.flatMap((value2) => refStrings(value2)).map((ref) => headOf(ref)));
+  const first = offenders[0];
+  if (first == null || first.binding.__bind.kind !== "field") {
+    return;
+  }
+  const { descriptor, field: field2 } = first.binding.__bind;
+  throw new Error(
+    `${first.site} references ${descriptor.entity}.${field2} from a maybe(${descriptor.entity}) \u2014 maybe entities are not materialized at setup; reference them only in steps`
+  );
 }
-function collectRefObjects(node) {
-  if (Array.isArray(node)) {
-    return node.flatMap((item) => collectRefObjects(item));
+function maybeBindings(values, site) {
+  return values.flatMap((value2) => valueBindings(value2)).filter((b) => b.__bind.kind === "field" && b.__bind.descriptor.kind === "maybe").map((binding) => ({ binding, site }));
+}
+function valueBindings(value2) {
+  if (isBinding(value2)) {
+    return [value2];
   }
-  if (node == null || typeof node !== "object") {
-    return [];
+  if (isTemplate(value2)) {
+    return value2.template.flatMap((segment) => isBinding(segment) ? [segment] : []);
   }
-  if ("ref" in node && typeof node.ref === "string" && Object.keys(node).length === 1) {
-    return [node.ref];
+  return [];
+}
+function isTemplate(value2) {
+  return typeof value2 === "object" && value2 !== null && "template" in value2;
+}
+function topoSort(entities) {
+  return emitReady([], entities);
+}
+function emitReady(done, remaining) {
+  if (remaining.length === 0) {
+    return [...done];
   }
-  return Object.values(node).flatMap((value2) => collectRefObjects(value2));
+  const ready = remaining.filter(
+    (d) => depsOf(d, remaining).every((dep) => done.includes(dep) || dep === d)
+  );
+  if (ready.length === 0) {
+    throw new Error("cyclic dependency between given entities");
+  }
+  return emitReady(
+    [...done, ...ready],
+    remaining.filter((d) => !ready.includes(d))
+  );
 }
-function isRefValue(value2) {
-  return value2 != null && typeof value2 === "object" && "ref" in value2 ? value2.ref : void 0;
+function depsOf(descriptor, among) {
+  return Object.values(descriptor.props).flatMap((v2) => valueBindings(v2)).flatMap((b) => b.__bind.kind === "field" ? [b.__bind.descriptor] : []).filter((target) => target !== descriptor && among.includes(target));
 }
-function headOf(ref) {
-  const dot = ref.indexOf(".");
-  return dot === -1 ? ref : ref.slice(0, dot);
+function assertScopedConditions(steps, givenSingletons) {
+  steps.flatMap((builder) => builder.step.expect).forEach((predicate) => {
+    assertPredicateScoped(predicate, givenSingletons);
+  });
 }
-function stepRefValues(step) {
-  return collectRefObjects(step).map((ref) => ({ ref }));
+function assertPredicateScoped(predicate, given) {
+  if (predicate.kind === "not") {
+    assertPredicateScoped(predicate.predicate, given);
+    return;
+  }
+  if (predicate.kind !== "when") {
+    return;
+  }
+  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`
+        );
+      }
+    });
+    row2.consequence.forEach((consequence) => {
+      assertPredicateScoped(consequence, given);
+    });
+  });
 }
-function refStrings(value2) {
-  const ref = isRefValue(value2);
-  if (ref != null) {
-    return [ref];
+function conditionSingletons(predicate) {
+  if (predicate.kind === "singleton") {
+    return [predicate.singleton];
   }
-  if (value2 != null && typeof value2 === "object" && "template" in value2) {
-    return value2.template.flatMap((segment) => typeof segment === "string" ? [] : [segment.ref]);
+  if (predicate.kind === "not") {
+    return conditionSingletons(predicate.predicate);
+  }
+  if (predicate.kind === "and") {
+    return predicate.predicates.flatMap((p) => conditionSingletons(p));
   }
   return [];
 }
-
-// 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 assignAliases(entities) {
+  return entities.reduce(
+    (acc, d) => {
+      const ordinal = acc.counts[d.entity] ?? 0;
+      return {
+        aliases: new Map([...acc.aliases, [d, `${d.entity}_${String(ordinal)}`]]),
+        counts: { ...acc.counts, [d.entity]: ordinal + 1 }
+      };
+    },
+    { aliases: /* @__PURE__ */ new Map(), counts: {} }
+  ).aliases;
+}
+function assignParams(bindings) {
+  const unique = [...new Set(bindings.filter((b) => b.__bind.kind === "param"))];
+  const assigned = unique.reduce(
+    (acc, b) => {
+      const token = tokenOf(b);
+      const ordinal = acc.counts[token.base] ?? 0;
+      const name = ordinal === 0 ? token.base : `${token.base}_${String(ordinal - 1)}`;
+      if (name in acc.params) {
+        throw new Error(
+          `param name "${name}" collides with an existing param \u2014 rename the field so deduplicated param names stay unique`
+        );
+      }
+      return {
+        counts: { ...acc.counts, [token.base]: ordinal + 1 },
+        names: new Map([...acc.names, [b, name]]),
+        params: { ...acc.params, [name]: { valueSpace: token.valueSpace } }
+      };
+    },
+    { counts: {}, names: /* @__PURE__ */ new Map(), params: {} }
   );
+  return { names: assigned.names, params: assigned.params };
 }
-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)] };
+function tokenOf(binding) {
+  if (binding.__bind.kind !== "param") {
+    throw new Error("internal: expected a param binding");
   }
-  const { tests } = targets.reduce(
-    (acc, target) => coverTarget({ acc, sims, target, whenIds, workflow: workflow2 }),
-    { covered: /* @__PURE__ */ new Set(), tests: [] }
-  );
-  return { ...workflow2, tests };
+  return binding.__bind.token;
 }
-function resolveValidTest(workflow2, sim, name) {
-  const test = resolveTest(workflow2, sim, name);
-  return danglingRefHeads(test).length === 0 ? test : null;
+function allBindings(body, entities, absences, singletonStates) {
+  return [
+    ...entities.flatMap((d) => Object.values(d.props).flatMap((v2) => valueBindings(v2))),
+    ...absences.flatMap((a) => Object.values(a.where).flatMap((v2) => valueBindings(v2))),
+    ...singletonStates.flatMap((s) => valueBindings(s.value)),
+    ...body.steps.flatMap((builder) => stepBindings(builder.step))
+  ];
 }
-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 stepBindings(step) {
+  return [...actionBindings(step.action), ...step.expect.flatMap((p) => predicateBindings(p))];
 }
-function createdAliasesIn(step) {
-  return step.expect.flatMap((predicate) => {
-    if (predicate.kind !== "state" || predicate.assertion.kind === "deleted") {
-      return [];
-    }
-    return [predicate.assertion.as];
-  });
+function actionBindings(action) {
+  if (action.kind === "goto") {
+    return valueBindings(action.url);
+  }
+  if (action.kind === "fill" || action.kind === "select") {
+    return [...locatorBindings(action.locator), ...valueBindings(action.value)];
+  }
+  if (action.kind === "press") {
+    return action.locator == null ? [] : locatorBindings(action.locator);
+  }
+  if (action.kind === "upload") {
+    return locatorBindings(action.locator);
+  }
+  return locatorBindings(action.locator);
 }
-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 };
+function locatorBindings(locator) {
+  if (locator.by === "inside") {
+    return [...locatorBindings(locator.scope), ...locatorBindings(locator.target)];
   }
-  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`
-    );
+  if (locator.by === "role") {
+    return locator.name == null ? [] : valueBindings(locator.name);
   }
-  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]
-  };
+  return valueBindings(locator.value);
 }
-function choiceKey(whenIds, when2, index) {
-  const id2 = whenIds.get(when2);
-  if (id2 == null) {
-    throw new Error("internal: when node missing from target index");
+function predicateBindings(predicate) {
+  switch (predicate.kind) {
+    case "visible":
+    case "disabled":
+    case "enabled":
+    case "focused":
+    case "checked": {
+      return locatorBindings(predicate.locator);
+    }
+    case "value":
+    case "text": {
+      return [...locatorBindings(predicate.locator), ...valueBindings(predicate.value)];
+    }
+    case "singleton": {
+      return valueBindings(predicate.assertion.value);
+    }
+    case "browser": {
+      return valueBindings(predicate.value);
+    }
+    case "state": {
+      return [
+        ...predicate.assertion.kind === "deleted" ? [] : Object.values(predicate.assertion.props).flatMap(
+          (v2) => isChanged(v2) ? [] : valueBindings(v2)
+        ),
+        ...Object.values(predicate.key).flatMap((v2) => whereBindings(v2))
+      ];
+    }
+    case "not": {
+      return predicateBindings(predicate.predicate);
+    }
+    case "when": {
+      return predicate.branches.flatMap((row2) => [
+        ...row2.condition == null ? [] : predicateBindings(row2.condition),
+        ...row2.consequence.flatMap((consequence) => predicateBindings(consequence))
+      ]);
+    }
+    case "and": {
+      return predicate.predicates.flatMap((p) => predicateBindings(p));
+    }
+    case "count": {
+      return [];
+    }
   }
-  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 whereBindings(value2) {
+  return isWithin2(value2) ? Object.values(value2.selection.where).flatMap((v2) => whereBindings(v2)) : valueBindings(value2);
 }
-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 isWithin2(value2) {
+  return typeof value2 === "object" && value2 !== null && "kind" in value2;
 }
-function collectTargets(steps) {
-  return steps.flatMap((step) => step.expect.flatMap((predicate) => targetsIn(predicate)));
+function setMap(map, ctx) {
+  return Object.fromEntries(
+    Object.entries(map).map(([key2, value2]) => [key2, resolveValue(value2, ctx)])
+  );
 }
-function targetsIn(predicate) {
-  if (predicate.kind === "not") {
-    return targetsIn(predicate.predicate);
-  }
-  if (predicate.kind === "and") {
-    return predicate.predicates.flatMap((p) => targetsIn(p));
+function resolveValue(value2, ctx) {
+  if (isBinding(value2)) {
+    return resolveBinding(value2, ctx);
   }
-  if (predicate.kind !== "when") {
-    return [];
+  if (isTemplate(value2)) {
+    return resolveTemplate(value2, ctx);
   }
-  return predicate.branches.flatMap((row2, index) => [
-    { index, name: row2.name, when: predicate },
-    ...row2.consequence.flatMap((consequence) => targetsIn(consequence))
-  ]);
+  return value2;
 }
-function proposeCandidates(workflow2, options) {
-  const subsets = maybeSubsets(workflow2.maybe);
-  const pinSets = pinAssignments(workflow2, options);
-  if (subsets.length * pinSets.length > MAX_CANDIDATES) {
+function resolveBinding(binding, ctx) {
+  const bind = binding.__bind;
+  if (bind.kind === "param") {
+    const name = ctx.params.get(binding);
+    if (name == null) {
+      throw new Error("internal: param binding was not collected");
+    }
+    return { ref: name };
+  }
+  const alias = ctx.aliases.get(bind.descriptor);
+  if (alias == null) {
     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(...)`
+      `references a "${bind.descriptor.entity}" entity that is not included in the test's given`
     );
   }
-  return subsets.flatMap((maybes) => pinSets.map((pins) => ({ maybes, pins })));
+  return { ref: `${alias}.${bind.field}` };
 }
-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 resolveTemplate(template, ctx) {
+  return {
+    template: template.template.map(
+      (segment) => isBinding(segment) ? resolveBinding(segment, ctx) : segment
+    )
+  };
 }
-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 setupsOf(entities, kind, ctx) {
+  return entities.filter((d) => d.kind === kind).map((d) => ({ as: aliasFor(ctx, d), entity: d.entity, set: setMap(d.props, ctx) }));
 }
-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 aliasFor(ctx, descriptor) {
+  const alias = ctx.aliases.get(descriptor);
+  if (alias == null) {
+    throw new Error(`internal: no alias for ${descriptor.entity}`);
+  }
+  return alias;
 }
-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 resolveStep(step, ctx) {
+  return {
+    action: resolveAction(step.action, ctx),
+    expect: step.expect.map((predicate) => resolvePredicate2(predicate, ctx))
+  };
 }
-function conditionLiteralsIn(predicate) {
-  if (predicate.kind === "not") {
-    return conditionLiteralsIn(predicate.predicate);
+function resolveAction(action, ctx) {
+  if (action.kind === "goto") {
+    return { ...action, url: resolveString(action.url, ctx) };
   }
-  if (predicate.kind === "and") {
-    return predicate.predicates.flatMap((p) => conditionLiteralsIn(p));
+  if (action.kind === "fill" || action.kind === "select") {
+    return {
+      ...action,
+      locator: resolveLocator(action.locator, ctx),
+      value: resolveValue(action.value, ctx)
+    };
   }
-  if (predicate.kind !== "when") {
-    return [];
+  if (action.kind === "press") {
+    return {
+      ...action,
+      locator: action.locator == null ? void 0 : resolveLocator(action.locator, ctx)
+    };
   }
-  return predicate.branches.flatMap((row2) => [
-    ...row2.condition == null ? [] : singletonLiteralsInCondition(row2.condition),
-    ...row2.consequence.flatMap((consequence) => conditionLiteralsIn(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));
-    }
+  if (action.kind === "upload") {
+    return { ...action, locator: resolveLocator(action.locator, ctx) };
   }
+  return { ...action, locator: resolveLocator(action.locator, ctx) };
 }
-function paramRefOf(value2) {
-  if (value2 == null || typeof value2 !== "object" || !("ref" in value2)) {
-    return void 0;
+function resolveString(value2, ctx) {
+  if (isBinding(value2)) {
+    return resolveBinding(value2, ctx);
   }
-  return value2.ref.includes(".") ? void 0 : value2.ref;
+  if (isTemplate(value2)) {
+    return resolveTemplate(value2, ctx);
+  }
+  return value2;
 }
-function withComplements(values, enumValues) {
-  if (enumValues != null) {
-    return [.../* @__PURE__ */ new Set([...values, ...enumValues])];
+function resolveLocator(locator, ctx) {
+  if (locator.by === "inside") {
+    return {
+      by: "inside",
+      scope: resolveLocator(locator.scope, ctx),
+      target: resolveLocator(locator.target, ctx)
+    };
   }
-  const complements = values.flatMap((value2) => {
-    if (typeof value2 === "boolean") {
-      return [!value2];
+  if (locator.by === "role") {
+    return locator.name == null ? locator : { ...locator, name: resolveString(locator.name, ctx) };
+  }
+  return { ...locator, value: resolveString(locator.value, ctx) };
+}
+function resolvePredicate2(predicate, ctx) {
+  switch (predicate.kind) {
+    case "visible":
+    case "disabled":
+    case "enabled":
+    case "focused":
+    case "checked": {
+      return { ...predicate, locator: resolveLocator(predicate.locator, ctx) };
     }
-    if (typeof value2 === "number") {
-      return [value2 + 1];
+    case "value":
+    case "text": {
+      return {
+        ...predicate,
+        locator: resolveLocator(predicate.locator, ctx),
+        value: resolveString(predicate.value, ctx)
+      };
     }
-    if (typeof value2 === "string") {
-      return [syntheticDistinct(value2, values)];
+    case "singleton": {
+      return {
+        ...predicate,
+        assertion: { ...predicate.assertion, value: resolveValue(predicate.assertion.value, ctx) }
+      };
     }
-    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)
+    case "browser": {
+      return { ...predicate, value: resolveString(predicate.value, ctx) };
+    }
+    case "state": {
+      return {
+        ...predicate,
+        assertion: resolveAssertion(predicate.assertion, ctx),
+        key: whereMap(predicate.key, ctx)
+      };
+    }
+    case "not": {
+      return { ...predicate, predicate: resolvePredicate2(predicate.predicate, ctx) };
+    }
+    case "when": {
+      return {
+        ...predicate,
+        branches: predicate.branches.map((row2) => ({
+          condition: row2.condition == null ? void 0 : resolveCondition(row2.condition, ctx),
+          consequence: row2.consequence.map((consequence) => resolvePredicate2(consequence, ctx)),
+          name: row2.name
+        }))
+      };
+    }
+    case "and": {
+      return {
+        ...predicate,
+        predicates: predicate.predicates.map((p) => resolvePredicate2(p, ctx))
+      };
+    }
+    case "count": {
+      return predicate;
     }
-  };
-  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;
+function resolveAssertion(assertion, ctx) {
+  if (assertion.kind === "deleted") {
+    return assertion;
   }
-  const row2 = when2.branches[picked];
-  if (row2 == null) {
-    return acc;
+  const descriptor = ctx.captures.get(assertion);
+  if (descriptor == null) {
+    throw new Error("internal: capture assertion was not registered");
   }
-  const choices = new Map([...acc.choices, [when2, picked]]);
-  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 }
+  const as = aliasFor(ctx, descriptor);
+  return assertion.kind === "created" ? { as, kind: "created", props: setMap(assertion.props, ctx) } : { as, kind: "updated", props: updateMap(assertion.props, ctx) };
+}
+function updateMap(map, ctx) {
+  return Object.fromEntries(
+    Object.entries(map).map(([key2, value2]) => [
+      key2,
+      isChanged(value2) ? value2 : resolveValue(value2, ctx)
+    ])
   );
 }
-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 whereMap(map, ctx) {
+  return Object.fromEntries(
+    Object.entries(map).map(([key2, value2]) => [
+      key2,
+      resolveWhere(value2, ctx)
+    ])
+  );
 }
-function evalCondition(condition, state) {
+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 "count": {
-      return state.rows.filter((row2) => row2.entity === condition.entity).length === condition.value;
-    }
     case "singleton": {
-      return compareValues(state.singles[condition.singleton], condition.assertion.value);
+      return {
+        ...condition,
+        assertion: {
+          ...condition.assertion,
+          value: resolveValue(condition.assertion.value, ctx)
+        }
+      };
+    }
+    case "count": {
+      return condition;
     }
     case "not": {
-      return negate(evalCondition(condition.predicate, state));
+      return { ...condition, predicate: resolveCondition(condition.predicate, ctx) };
     }
     case "and": {
-      return conjoin(condition.predicates.map((p) => evalCondition(p, state)));
+      return {
+        ...condition,
+        predicates: condition.predicates.map((p) => resolveCondition(p, ctx))
+      };
     }
   }
 }
-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";
+
+// src/workflow.ts
+function workflow(intent, fn) {
+  const sourcePath = captureSourcePath();
+  if (fn == null) {
+    return { spec: stubSpec(intent, sourcePath) };
   }
-  return sameSetValue(seeded, wanted);
+  const final = finalize(fn());
+  return {
+    spec: {
+      absent: final.absent,
+      exclusive: final.exclusive,
+      intent,
+      maybe: final.maybe,
+      name: slugify2(intent),
+      params: final.params,
+      singletons: final.singletons,
+      sourcePath,
+      steps: final.steps,
+      stub: false,
+      tests: [],
+      world: final.world
+    }
+  };
 }
-function isTemplateValue(value2) {
-  return value2 != null && typeof value2 === "object" && "template" in value2;
+function stubSpec(intent, sourcePath) {
+  return {
+    absent: [],
+    exclusive: [],
+    intent,
+    maybe: [],
+    name: slugify2(intent),
+    params: {},
+    singletons: {},
+    sourcePath,
+    steps: [],
+    stub: true,
+    tests: [],
+    world: []
+  };
 }
-function negate(value2) {
-  return value2 === "unknown" ? "unknown" : !value2;
+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) => WORKFLOWS_ANCHOR_PATTERN.exec(line)).find((m) => m != null);
+  const captured = match?.[1];
+  return captured == null ? void 0 : captured.replaceAll("\\", "/");
 }
-function conjoin(values) {
-  if (values.includes(false)) {
-    return false;
+function slugify2(intent) {
+  const slug = intent.toLowerCase().replaceAll(/[^a-z0-9]+/g, " ").trim().split(" ").join("-");
+  if (slug.length === 0) {
+    throw new Error(`workflow intent "${intent}" slugifies to an empty string`);
   }
-  return values.every((v2) => v2 === true) ? true : "unknown";
+  return slug;
 }
-function singletonSets(predicates) {
-  return Object.fromEntries(
-    predicates.flatMap((predicate) => {
-      if (predicate.kind === "singleton") {
-        return [[predicate.singleton, predicate.assertion.value]];
-      }
-      return [];
-    })
+
+// src/params.ts
+function arbitrary(field2) {
+  const token = {
+    base: `${field2.entity}_${field2.field}`,
+    valueSpace: field2.valueSpaceName
+  };
+  return paramBinding(token);
+}
+
+// src/engine.ts
+import { err, ok, okAsync, Result, ResultAsync } from "neverthrow";
+function createEngine(ripplo, impls, teardown) {
+  const entities = new Map(Object.entries(impls.entities));
+  const singletons = new Map(
+    Object.entries(impls.singletons).map(([name, impl]) => [
+      name,
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- per-name impls typed at the call site; erase the contravariant scalar seed to the loose dispatch shape
+      impl
+    ])
   );
+  assertDeclared(ripplo, [...entities.keys()], [...singletons.keys()]);
+  const entityImpl = (name) => lookup(entities.get(name), name);
+  const singletonImpl = (name) => lookup(singletons.get(name), name);
+  return {
+    read: (request, runId) => ResultAsync.combine([
+      ResultAsync.combine(
+        request.entities.map((name) => readEntity(entityImpl(name), name, runId))
+      ),
+      ResultAsync.combine(
+        request.singletons.map((name) => readSingleton(singletonImpl(name), name, runId))
+      )
+    ]).map(([entityPairs, singletonPairs]) => ({
+      entities: Object.fromEntries(entityPairs),
+      singletons: Object.fromEntries(singletonPairs)
+    })),
+    seed: (request, runId) => ResultAsync.fromPromise(teardown(runId), implFailure).andThen(() => seedSingletons(request.singletons, singletonImpl, runId)).andThen(() => seedSetups(request.entities, entityImpl, runId)),
+    teardown: (runId) => ResultAsync.fromPromise(teardown(runId), implFailure)
+  };
 }
-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 assertDeclared(ripplo, entityNames, singletonNames) {
+  const backendEntities = new Set(
+    ripplo.entities.filter((e) => e.schema.source === "backend").map((e) => e.name)
+  );
+  const backendSingletons = new Set(
+    ripplo.singletons.filter((s) => s.schema.source === "backend").map((s) => s.name)
+  );
+  entityNames.forEach((name) => {
+    if (!backendEntities.has(name)) {
+      throw new Error(`engine impl "${name}" has no matching backend entity`);
+    }
+  });
+  singletonNames.forEach((name) => {
+    if (!backendSingletons.has(name)) {
+      throw new Error(`engine impl "${name}" has no matching backend singleton`);
+    }
+  });
 }
-function matchesKey(row2, key2, rows) {
-  return Object.entries(key2).every(([field2, want]) => matchesField({ field: field2, row: row2, rows, want }));
+function lookup(impl, name) {
+  return impl == null ? err({ message: `no engine impl for "${name}"` }) : ok(impl);
 }
-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 readEntity(impl, name, runId) {
+  return impl.asyncAndThen(
+    (i) => ResultAsync.fromPromise(i.read({ runId }), implFailure).map((rows) => [
+      name,
+      [...rows]
+    ])
+  );
 }
-function isWithinValue(value2) {
-  return value2 != null && typeof value2 === "object" && "kind" in value2;
+function implFailure(error) {
+  return { message: error instanceof Error ? error.message : String(error) };
 }
-function fieldValue(row2, field2) {
-  return row2.set[field2] ?? { ref: `${row2.as}.${field2}` };
+function readSingleton(impl, name, runId) {
+  return impl.asyncAndThen(
+    (i) => ResultAsync.fromPromise(i.read({ runId }), implFailure).map((value2) => [
+      name,
+      value2
+    ])
+  );
 }
-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 seedSingletons(values, singletonImpl, runId) {
+  return ResultAsync.combine(
+    Object.entries(values).map(
+      ([name, value2]) => singletonImpl(name).asyncAndThen(
+        (impl) => ResultAsync.fromPromise(impl.seed({ runId, value: value2 }), implFailure)
+      )
+    )
+  );
 }
-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 seedSetups(specs, entityImpl, runId) {
+  const waves = dependencyWaves(specs);
+  return waves.reduce((accR, wave) => accR.andThen((acc) => seedWave(wave, entityImpl, acc, runId)), okAsync({ env: /* @__PURE__ */ new Map(), rows: [] })).map((fold) => orderRows(specs, fold.rows));
 }
-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))
-      }
-    ];
+function dependencyWaves(specs) {
+  return buildWaves([], specs);
+}
+function buildWaves(done, remaining) {
+  if (remaining.length === 0) {
+    return done;
   }
-  if (predicate.kind !== "when") {
-    return [predicate];
+  const seeded = new Set(done.flat().map((spec) => spec.as));
+  const ready = remaining.filter((spec) => refAliases(spec).every((alias) => seeded.has(alias)));
+  if (ready.length === 0) {
+    return [...done, remaining];
   }
-  const picked = choices.get(predicate);
-  const row2 = picked == null ? void 0 : predicate.branches[picked];
-  return row2 == null ? [] : row2.consequence.flatMap((c) => resolvePredicate2(c, choices));
+  return buildWaves(
+    [...done, ready],
+    remaining.filter((spec) => !ready.includes(spec))
+  );
 }
-
-// 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),
-    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) })
-    )
+function refAliases(spec) {
+  return Object.values(spec.fields).flatMap((value2) => {
+    if (value2 === null || typeof value2 !== "object" || !("ref" in value2)) {
+      return [];
+    }
+    const lastDot = value2.ref.lastIndexOf(".");
+    return lastDot === -1 ? [] : [value2.ref.slice(0, lastDot)];
   });
-  assertNoContradictions(lockfile);
-  return lockfile;
 }
-function assertUniqueNames(entities) {
-  const names = entities.map((handle) => handle.schema.name);
-  const duplicate = names.find((name, index) => names.indexOf(name) !== index);
-  if (duplicate != null) {
-    throw new Error(`duplicate entity name "${duplicate}" \u2014 each entity name must be unique`);
-  }
+function seedWave(wave, entityImpl, acc, runId) {
+  return ResultAsync.combine(
+    wave.map((spec) => seedSetup(entityImpl(spec.entity), acc, spec, runId))
+  ).map((folds) => mergeFolds(acc, folds));
 }
-function dedupeByName(spaces) {
-  const byName = new Map(spaces.map((space) => [space.name, space]));
-  return [...byName.values()];
+function seedSetup(impl, acc, spec, runId) {
+  return resolveFields(spec.fields, acc.env).asyncAndThen((fields) => runSeed(impl, fields, runId)).map(({ row: row2, session }) => foldRow(acc, spec, row2, session));
 }
-function assertNoContradictions(lockfile) {
-  lockfile.workflows.forEach((workflow2) => {
-    assertNoContradiction(workflow2);
-    assertNoDanglingRefs(workflow2);
-  });
+function resolveFields(fields, env) {
+  return Result.combine(
+    Object.entries(fields).map(
+      ([field2, value2]) => resolveValue2(value2, env).map((cell2) => [field2, cell2])
+    )
+  ).map((entries) => Object.fromEntries(entries));
 }
-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 "${workflow2.name}": creates a "${absence.entity}" ("${clash.as}") that a none(${absence.entity}, \u2026) in its world forbids`
-      );
-    }
-  });
+function resolveValue2(value2, env) {
+  if (value2 === null || typeof value2 !== "object") {
+    return ok(value2);
+  }
+  if ("ref" in value2) {
+    return env.has(value2.ref) ? ok(env.get(value2.ref) ?? null) : err({ message: `setup ref "${value2.ref}" was not produced by an earlier entity` });
+  }
+  throw new Error("internal: a setup value resolved to an unresolved template");
 }
-function whereMatches(where, set) {
-  return Object.entries(where).every(([field2, want]) => sameValue(want, set[field2]));
+function runSeed(impl, fields, runId) {
+  return impl.asyncAndThen((i) => ResultAsync.fromPromise(i.seed({ fields, runId }), implFailure));
 }
-function sameValue(a, b) {
-  return b !== void 0 && sameSetValue(a, b);
+function foldRow(acc, spec, row2, session) {
+  const next = Object.entries(row2).map(([field2, value2]) => [
+    `${spec.as}.${field2}`,
+    value2
+  ]);
+  return {
+    env: new Map([...acc.env, ...next]),
+    rows: [...acc.rows, { as: spec.as, row: row2, session }]
+  };
 }
-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 = [
-    ...workflow2.world.map((setup) => setup.set),
-    ...workflow2.maybe.map((setup) => setup.set),
-    ...workflow2.absent.map((absence) => absence.where)
-  ];
-  fieldSets.forEach((set) => {
-    assertSetRefs(workflow2.name, set, aliases, paramKeys);
-  });
+function mergeFolds(base, folds) {
+  return {
+    env: new Map([...base.env, ...folds.flatMap((fold) => [...fold.env])]),
+    rows: [...base.rows, ...folds.flatMap((fold) => fold.rows.slice(base.rows.length))]
+  };
 }
-function assertSetRefs(workflowName, set, aliases, paramKeys) {
-  Object.values(set).forEach((value2) => {
-    if (!isRef(value2) || paramKeys.has(value2.ref)) {
-      return;
-    }
-    const lastDot = value2.ref.lastIndexOf(".");
-    if (lastDot === -1) {
-      return;
-    }
-    const aliasPath = value2.ref.slice(0, lastDot);
-    if (!aliases.has(aliasPath)) {
-      throw new Error(
-        `test "${workflowName}": ref "${value2.ref}" points at unknown alias "${aliasPath}"`
-      );
-    }
+function orderRows(specs, rows) {
+  const byAs = new Map(rows.map((row2) => [row2.as, row2]));
+  return specs.flatMap((spec) => {
+    const row2 = byAs.get(spec.as);
+    return row2 == null ? [] : [row2];
   });
 }
-function isRef(value2) {
-  return value2 != null && typeof value2 === "object" && "ref" in value2;
-}
 
-// src/ripplo.ts
-function createRipplo(input) {
+// src/client-engine.ts
+import { z as z8 } from "zod";
+var seedSchema = z8.record(z8.string(), z8.union([z8.string(), z8.number(), z8.boolean()])).catch({});
+function createClientEngine(_ripplo, impls) {
+  const singletons = new Map(
+    Object.entries(impls.singletons).map(([name, impl]) => [
+      name,
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- per-name impls typed at the call site; erase the contravariant scalar seed to the loose dispatch shape
+      impl
+    ])
+  );
+  const entities = new Map(Object.entries(impls.entities));
+  const seed = seedSchema.parse(Reflect.get(globalThis, CLIENT_SEED_KEY));
+  Object.entries(seed).forEach(([name, value2]) => singletons.get(name)?.seed(value2));
   return {
-    entities: input.entities,
-    lockfile: buildLockfile({
-      entities: input.entities,
-      singletons: input.singletons,
-      workflows: input.workflows
-    }),
-    singletons: input.singletons,
-    workflows: input.workflows
+    readEntity: (name) => entities.get(name)?.read() ?? [],
+    readSingleton: (name) => singletons.get(name)?.read() ?? null
   };
 }
+function mountClientEngine(ripplo, impls, { enabled: enabled2 }) {
+  if (!enabled2) {
+    return;
+  }
+  Reflect.set(globalThis, CLIENT_MOUNT_KEY, createClientEngine(ripplo, impls));
+}
 export {
   CLIENT_MOUNT_KEY,
   CLIENT_SEED_KEY,