@ripplo/testing 0.6.1 → 0.7.0

package/dist/index.js

@@ -1,1279 +1,1783 @@
-import {
-  DEFAULT_IGNORE_PATHS,
-  DEFAULT_WATCH_PATHS,
-  brandTestValue,
-  isPrimitive,
-  makeObserverHandle,
-  readObserverBudget,
-  readObserverDescription,
-  readObserverName,
-  readPreconditionDepMapping,
-  readPreconditionDependsOn,
-  readPreconditionDescription,
-  readPreconditionName
-} from "./chunk-YQAEOH5W.js";
-import {
-  compile
-} from "./chunk-YFOTJIVF.js";
-import "./chunk-MGATMMCZ.js";
-import {
-  readAdapterWebhookSecret,
-  serializeCookie,
-  toBatchRunResults,
-  toTeardownResults,
-  verifyWebhookSignature
-} from "./chunk-XO36IU66.js";
-import "./chunk-4MGIQFAJ.js";
-
-// src/chainable.ts
-var BuilderChainError = class _BuilderChainError extends Error {
-  missingMethod;
-  validNext;
-  constructor(missingMethod, validNext) {
-    const valid = validNext.length === 0 ? "<chain is terminal>" : validNext.map((m) => `.${m}`).join(", ");
-    super(`\`.${missingMethod}\` is not a valid step in this builder chain. Valid next: ${valid}.`);
-    this.name = "BuilderChainError";
-    this.missingMethod = missingMethod;
-    this.validNext = validNext;
-    if (typeof Error.captureStackTrace === "function") {
-      Error.captureStackTrace(this, _BuilderChainError);
-    }
+// src/bindings.ts
+function fieldBinding(descriptor, field2) {
+  return { __bind: { descriptor, field: field2, kind: "field" }, ref: "" };
+}
+function paramBinding(token) {
+  return { __bind: { kind: "param", token }, ref: "" };
+}
+function entityHandle(descriptor, fieldNames) {
+  const fields = Object.fromEntries(
+    fieldNames.map((field2) => [field2, fieldBinding(descriptor, field2)])
+  );
+  return { ...fields, __entity: descriptor };
+}
+function isBinding(value2) {
+  return typeof value2 === "object" && value2 != null && "__bind" in value2;
+}
+function toSetMap(props) {
+  return Object.fromEntries(
+    Object.entries(props).map(([key2, value2]) => [key2, toSetValue(value2)])
+  );
+}
+function toSetValue(value2) {
+  if (value2 === null) {
+    return null;
   }
-};
-var PASSTHROUGH_PROPS = /* @__PURE__ */ new Set([
-  "then",
-  "catch",
-  "finally",
-  "toJSON",
-  "toString",
-  "valueOf",
-  "constructor",
-  "nodeType"
-]);
-function chainable(target) {
-  return new Proxy(target, {
-    get(t, prop, receiver) {
-      if (Reflect.has(t, prop)) {
-        return Reflect.get(t, prop, receiver);
-      }
-      if (typeof prop === "symbol") {
-        return void 0;
-      }
-      if (PASSTHROUGH_PROPS.has(prop)) {
-        return void 0;
-      }
-      const validNext = Object.keys(t).filter((k) => typeof Reflect.get(t, k) === "function");
-      throw new BuilderChainError(prop, validNext);
-    }
+  return isBinding(value2) ? value2 : asPrimitive(value2);
+}
+function isChanged(value2) {
+  return typeof value2 === "object" && value2 != null && "kind" in value2 && value2.kind === "changed";
+}
+function toUpdateMap(props) {
+  return Object.fromEntries(
+    Object.entries(props).map(([key2, value2]) => [
+      key2,
+      isChanged(value2) ? value2 : toSetValue(value2)
+    ])
+  );
+}
+function stringValueFromTemplate(strings, values) {
+  const segments = strings.flatMap((str, i) => {
+    const value2 = values[i];
+    const refs = value2 === void 0 ? [] : [value2];
+    return [str, ...refs];
   });
+  return { template: segments.filter((seg) => typeof seg !== "string" || seg.length > 0) };
+}
+function asPrimitive(value2) {
+  if (typeof value2 === "string" || typeof value2 === "number" || typeof value2 === "boolean") {
+    return value2;
+  }
+  throw new Error("setup set value must be a entity-sourced binding or a literal primitive");
 }
 
-// src/observer.ts
-function createPassOutcome() {
-  return { kind: "pass" };
+// src/predicates.ts
+function isCapturePredicate(input) {
+  return "ref" in input;
 }
-function createRetryOutcome(reason) {
-  return { kind: "retry", reason };
+function captureOf(predicate) {
+  if (predicate.predicate.kind !== "state") {
+    throw new Error("internal: a capture predicate must carry a state assertion");
+  }
+  return { assertion: predicate.predicate.assertion, descriptor: predicate.ref.__entity };
 }
-function createFailOutcome(reason) {
-  return { kind: "fail", reason };
+function leaf(predicate) {
+  return { predicate, wait: (budget) => leaf(withWait(predicate, budget)) };
 }
-function buildReady(state) {
-  return chainable({
-    contract: () => makeObserverHandle(state)
-  });
+function condLeaf(predicate) {
+  return {
+    __condition: true,
+    predicate,
+    wait: (budget) => condLeaf(withWaitCondition(predicate, budget))
+  };
 }
-function buildNeedsInput(state) {
-  return chainable({
-    input: () => buildReady(state)
-  });
+function isConditionInput(input) {
+  return "__condition" in input;
 }
-function buildObserver(name) {
-  return chainable({
-    description: (description) => chainable({
-      budget: (budget) => buildNeedsInput({ budget, description, name })
-    })
-  });
+function withWait(predicate, budget) {
+  if (predicate.kind === "not" || predicate.kind === "and" || predicate.kind === "count" || predicate.kind === "when") {
+    return predicate;
+  }
+  return { ...predicate, wait: budget };
+}
+function withWaitCondition(condition, budget) {
+  return condition.kind === "singleton" ? { ...condition, wait: budget } : condition;
+}
+function toPredicate(input) {
+  return "predicate" in input ? input.predicate : input;
+}
+function visible(locator) {
+  return leaf({ kind: "visible", locator, wait: void 0 });
+}
+function disabled(locator) {
+  return leaf({ kind: "disabled", locator, wait: void 0 });
+}
+function enabled(locator) {
+  return leaf({ kind: "enabled", locator, wait: void 0 });
+}
+function focused(locator) {
+  return leaf({ kind: "focused", locator, wait: void 0 });
+}
+function value(locator, binding) {
+  return leaf({ kind: "value", locator, value: binding, wait: void 0 });
+}
+function text(locator, binding) {
+  return leaf({ kind: "text", locator, value: binding, wait: void 0 });
+}
+function not(input) {
+  if (isConditionInput(input)) {
+    return condLeaf({ kind: "not", predicate: input.predicate });
+  }
+  return leaf({ kind: "not", predicate: toPredicate(input) });
+}
+function and(...conditions) {
+  return condLeaf({ kind: "and", predicates: conditions.map((c) => c.predicate) });
+}
+function count(entity2) {
+  return {
+    is: (n) => condLeaf({ entity: entity2.name, kind: "count", value: n })
+  };
+}
+function when(...clauses) {
+  const last = clauses.at(-1);
+  const fallback = last !== void 0 && !isClause(last) ? toPredicate(last) : void 0;
+  const rows = clauses.filter((clause) => isClause(clause));
+  const chain = rows.reduceRight(
+    (otherwise, [condition, consequence]) => ({
+      condition: condition.predicate,
+      consequence: toPredicate(consequence),
+      kind: "when",
+      otherwise
+    }),
+    fallback
+  );
+  if (chain == null) {
+    throw new Error("when() needs at least one [condition, consequence] clause");
+  }
+  return leaf(chain);
+}
+function isClause(clause) {
+  return Array.isArray(clause);
 }
 
-// src/builder.ts
-function precondition(name) {
-  return buildPreconditionStart(name);
+// src/util.ts
+function mapValues(record, fn) {
+  return Object.fromEntries(
+    Object.entries(record).map(([entryKey, value2]) => [entryKey, fn(value2, entryKey)])
+  );
 }
-function observer(name) {
-  return buildObserver(name);
+function sameSetValue(a, b) {
+  if (a === null || b === null || typeof a !== "object" || typeof b !== "object") {
+    return a === b;
+  }
+  if ("ref" in a || "ref" in b) {
+    return "ref" in a && "ref" in b && a.ref === b.ref;
+  }
+  return sameTemplate(a, b);
 }
-function test(id, options) {
-  validateTestId(id);
-  const sourcePath = captureTestSourcePath();
-  return buildTestName({ id, sourcePath, uiOnly: options?.uiOnly });
+function sameTemplate(a, b) {
+  return a.template.length === b.template.length && a.template.every((segment, index) => sameSegment(segment, b.template[index]));
 }
-var TESTS_ANCHOR_PATTERN = /[/\\]\.ripplo[/\\]tests[/\\]([^):]+?)(?::\d+:\d+\)?)?$/;
-function captureTestSourcePath() {
-  const stack = new Error("capture").stack;
-  if (stack == null) {
-    return void 0;
+function sameSegment(a, b) {
+  if (typeof a === "string" || typeof b === "string" || b === void 0) {
+    return a === b;
   }
-  const match = stack.split("\n").map((line) => TESTS_ANCHOR_PATTERN.exec(line)).find((m) => m != null);
-  const captured = match?.[1];
-  if (captured == null) {
-    return void 0;
+  return a.ref === b.ref;
+}
+
+// src/entity.ts
+function stringSpace(generator, constraints) {
+  return {
+    __t: void 0,
+    constraints: constraints == null ? void 0 : { kind: "string", ...constraints },
+    generator,
+    primitive: "string",
+    values: void 0
+  };
+}
+function primitiveTypeOf(value2) {
+  if (typeof value2 === "number") {
+    return "number";
+  }
+  if (typeof value2 === "boolean") {
+    return "boolean";
   }
-  return captured.replaceAll("\\", "/");
+  return "string";
+}
+var v = {
+  boolean: () => ({
+    __t: void 0,
+    constraints: void 0,
+    generator: "lorem.word",
+    primitive: "boolean",
+    values: void 0
+  }),
+  companyName: (constraints) => stringSpace("company.name", constraints),
+  datetime: (options) => ({
+    __t: void 0,
+    constraints: {
+      kind: "datetime",
+      maxOffsetDays: options.offsetDays.max,
+      minOffsetDays: options.offsetDays.min
+    },
+    generator: "date.iso",
+    primitive: "string",
+    values: void 0
+  }),
+  email: (constraints) => stringSpace("internet.email", constraints),
+  fullName: (constraints) => stringSpace("person.fullName", constraints),
+  id: (constraints) => stringSpace("lorem.slug", constraints),
+  number: (constraints) => ({
+    __t: void 0,
+    constraints: { kind: "number", ...constraints },
+    generator: "lorem.word",
+    primitive: "number",
+    values: void 0
+  }),
+  oneOf: (values) => ({
+    __t: void 0,
+    constraints: void 0,
+    generator: "lorem.word",
+    primitive: primitiveTypeOf(values[0]),
+    values
+  }),
+  slug: (constraints) => stringSpace("lorem.slug", constraints),
+  url: (constraints) => stringSpace("internet.url", constraints),
+  word: (constraints) => stringSpace("lorem.word", constraints)
+};
+function propBuilder(args) {
+  return {
+    __o: void 0,
+    __t: void 0,
+    spec: args.spec,
+    valueSpace: args.valueSpace
+  };
 }
-function createRipplo(registries) {
-  const { observers, preconditions, tests } = registries;
-  validateUniqueNames(preconditions, observers, tests);
-  const preconditionDefs = Object.values(preconditions).map((p) => stubPreconditionDef(p));
-  const observerDefs = Object.values(observers).map((o) => stubObserverDef(o));
-  const testDefs = [...tests];
+function field(options) {
+  return propBuilder({
+    spec: {
+      consistency: options.consistency ?? "strict",
+      optional: options.optional ?? false,
+      stable: options.stable ?? true,
+      type: options.value.primitive
+    },
+    valueSpace: options.value
+  });
+}
+function id() {
   return {
-    observers,
-    preconditions,
-    tests: testDefs,
-    getObservers: () => observerDefs,
-    getPreconditions: () => preconditionDefs,
-    getTests: () => testDefs,
-    getUnimplemented: () => ({
-      observers: observerDefs.filter((o) => !o.implemented).map((o) => o.name),
-      preconditions: preconditionDefs.filter((p) => !p.implemented).map((p) => p.name),
-      tests: testDefs.filter((t) => !t.implemented).map((t) => t.id)
+    idKind: "surrogate",
+    prop: propBuilder({
+      spec: { consistency: "strict", optional: false, stable: true, type: "string" },
+      valueSpace: void 0
     })
   };
 }
-function stubPreconditionDef(p) {
-  const name = readPreconditionName(p);
+function key(options) {
   return {
-    dependsOn: readPreconditionDependsOn(p),
-    depMapping: readPreconditionDepMapping(p),
-    description: readPreconditionDescription(p),
-    implemented: false,
-    name,
-    returns: [],
-    teardown: void 0,
-    setup: () => Promise.resolve([])
+    idKind: "natural",
+    prop: propBuilder({
+      spec: {
+        consistency: "strict",
+        optional: false,
+        stable: true,
+        type: options.value.primitive
+      },
+      valueSpace: options.value
+    })
   };
 }
-function stubObserverDef(o) {
-  const name = readObserverName(o);
+function within(selection, sourceField) {
   return {
-    budget: readObserverBudget(o),
-    description: readObserverDescription(o),
-    implemented: false,
-    name,
-    run: () => Promise.resolve(createFailOutcome(`observer "${name}" not implemented`))
+    __t: void 0,
+    field: String(sourceField),
+    kind: "within",
+    selection: { entity: selection.entity, where: selection.where }
   };
 }
-function validateUniqueNames(preconditions, observers, tests) {
-  const pNames = /* @__PURE__ */ new Set();
-  Object.values(preconditions).forEach((p) => {
-    const name = readPreconditionName(p);
-    if (pNames.has(name)) {
-      throw new Error(`Duplicate precondition name: "${name}"`);
-    }
-    pNames.add(name);
-  });
-  const oNames = /* @__PURE__ */ new Set();
-  Object.values(observers).forEach((o) => {
-    const name = readObserverName(o);
-    if (oNames.has(name)) {
-      throw new Error(`Duplicate observer name: "${name}"`);
-    }
-    oNames.add(name);
-  });
-  const tIds = /* @__PURE__ */ new Set();
-  tests.forEach((t) => {
-    if (tIds.has(t.id)) {
-      throw new Error(`Duplicate test id: "${t.id}"`);
-    }
-    tIds.add(t.id);
-  });
+function changed() {
+  return { kind: "changed" };
 }
-var TEST_ID_PATTERN = /^[a-z0-9]+(-[a-z0-9]+)*$/;
-function validateTestId(id) {
-  if (!TEST_ID_PATTERN.test(id)) {
-    throw new Error(
-      `Invalid test id "${id}". Must be lowercase alphanumeric with hyphens (e.g. "my-test-id").`
-    );
+function isWithin(value2) {
+  return value2 != null && typeof value2 === "object" && "kind" in value2;
+}
+function keyMap(where) {
+  return Object.fromEntries(
+    Object.entries(where).map(([col, value2]) => [col, keyValue(value2)])
+  );
+}
+function keyValue(value2) {
+  if (isWithin(value2)) {
+    return { field: value2.field, kind: "within", selection: value2.selection };
   }
+  return toSetValue(value2);
+}
+function entity(name, definition) {
+  const identityProps = mapValues(definition.identity, (builder) => builder.prop);
+  const allBuilders = { ...identityProps, ...definition.fields };
+  const fieldKeys = Object.keys(allBuilders);
+  const schema = {
+    description: definition.description,
+    identity: Object.keys(definition.identity),
+    identityKind: identityKindOf(definition.identity),
+    name,
+    props: mapValues(allBuilders, (builder, fieldName) => specWithSpace(name, fieldName, builder)),
+    source: definition.source
+  };
+  const handle = {
+    field: mapValues(allBuilders, (builder, fieldName) => ({
+      __t: void 0,
+      entity: name,
+      field: fieldName,
+      primitive: builder.spec.type,
+      valueSpaceName: `${name}.${fieldName}`
+    })),
+    name,
+    schema,
+    source: definition.source,
+    valueSpaces: collectValueSpaces(name, allBuilders),
+    created: (props) => captureLeaf({
+      assertion: { as: "", kind: "created", props: toSetMap(props) },
+      entity: name,
+      fieldKeys,
+      key: {}
+    }),
+    deleted: (where) => leaf({
+      assertion: { kind: "deleted" },
+      entity: name,
+      key: keyMap(where),
+      kind: "state",
+      wait: void 0
+    }),
+    maybe: (where) => makeEntity("maybe", name, fieldKeys, where),
+    none: (where) => ({
+      __entity: { entity: name, kind: "none", where: toSetMap(where) }
+    }),
+    of: (props) => makeEntity("of", name, fieldKeys, props),
+    only: (props) => makeEntity("only", name, fieldKeys, props),
+    updated: (where, props) => captureLeaf({
+      assertion: { as: "", kind: "updated", props: toUpdateMap(props) },
+      entity: name,
+      fieldKeys,
+      key: keyMap(where)
+    }),
+    where: (criteria) => ({
+      __s: void 0,
+      entity: name,
+      where: keyMap(criteria)
+    })
+  };
+  return handle;
 }
-function makePrecondition(params) {
-  return params;
+function makeEntity(kind, entityName, fieldKeys, props) {
+  const descriptor = { entity: entityName, kind, props: toSetMap(props) };
+  return entityHandle(descriptor, fieldKeys);
 }
-function buildDepMapping(deps) {
-  return Object.entries(deps).map(([key, dep]) => [key, readPreconditionName(dep)]);
+function matchPropsOf(props) {
+  return Object.fromEntries(
+    Object.entries(props).filter((entry) => !isChanged(entry[1]))
+  );
 }
-function buildPreconditionStart(name) {
-  let description = "";
-  const self = chainable({
-    contract: () => makePrecondition({
-      dependsOn: [],
-      depMapping: [],
-      description,
-      name
-    }),
-    description(text) {
-      description = text;
-      return self;
+function captureLeaf(params) {
+  const descriptor = {
+    entity: params.entity,
+    kind: params.assertion.kind,
+    props: matchPropsOf(params.assertion.props)
+  };
+  const ref = entityHandle(descriptor, params.fieldKeys);
+  const build = (wait2) => ({
+    predicate: {
+      assertion: params.assertion,
+      entity: params.entity,
+      key: params.key,
+      kind: "state",
+      wait: wait2
     },
-    requires(deps) {
-      return buildPreconditionWithDeps({ deps, name, getDescription: () => description });
-    }
+    ref,
+    wait: (budget) => build(budget)
   });
-  return self;
+  return build(void 0);
 }
-function buildPreconditionWithDeps({
-  deps,
-  getDescription,
-  name
-}) {
-  const description = getDescription();
-  const depMapping = buildDepMapping(deps);
-  const dependsOn = depMapping.map(([, depName]) => depName);
-  return chainable({
-    contract: () => makePrecondition({
-      dependsOn,
-      depMapping,
-      description,
-      name
-    })
-  });
+function specWithSpace(stateName, fieldName, builder) {
+  if (builder.valueSpace == null) {
+    return builder.spec;
+  }
+  return { ...builder.spec, valueSpace: `${stateName}.${fieldName}` };
+}
+function identityKindOf(fields) {
+  return Object.values(fields).every((f) => f.idKind === "surrogate") ? "surrogate" : "natural";
+}
+function collectValueSpaces(stateName, builders) {
+  return Object.entries(builders).map(([fieldName, builder]) => ({ field: fieldName, partial: builder.valueSpace })).filter(
+    (entry) => entry.partial != null
+  ).map((entry) => ({
+    constraints: entry.partial.constraints,
+    generator: entry.partial.generator,
+    name: `${stateName}.${entry.field}`,
+    type: entry.partial.primitive,
+    values: entry.partial.values == null ? void 0 : [...entry.partial.values]
+  }));
 }
-function buildTestName({ id, sourcePath, uiOnly }) {
-  return chainable({
-    name: (displayName) => buildTestRequires({ id, name: displayName, sourcePath, uiOnly })
-  });
+
+// src/locators.ts
+function role(roleName, name, ...bindings) {
+  return { by: "role", name: name == null ? void 0 : nameValue(name, bindings), role: roleName };
 }
-function castOutcome(value) {
-  return value;
+function inside(scope, target) {
+  return { by: "inside", scope, target };
 }
-function buildTestRequires({
-  id,
-  name,
-  sourcePath,
-  uiOnly
-}) {
-  let description = "";
-  const self = chainable({
-    description(text) {
-      description = text;
-      return self;
-    },
-    requires(reqs) {
-      const reqNames = Object.values(reqs).map((r) => readPreconditionName(r));
-      const requiresKeys = {};
-      Object.entries(reqs).forEach(([key, p]) => {
-        requiresKeys[key] = readPreconditionName(p);
-      });
-      return castOutcome(
-        buildTestOutcome({
-          id,
-          name,
-          reqNames,
-          requiresKeys,
-          sourcePath,
-          uiOnly,
-          getDescription: () => description
-        })
-      );
-    }
-  });
-  return self;
+function testId(value2, ...bindings) {
+  if (typeof value2 === "string") {
+    return { by: "testId", value: value2 };
+  }
+  return { by: "testId", value: stringValueFromTemplate(value2, bindings) };
+}
+var button = named("button");
+var cell = named("cell");
+var checkbox = named("checkbox");
+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 tab = named("tab");
+var textbox = named("textbox");
+var alert = container("alert");
+var banner = container("banner");
+var complementary = container("complementary");
+var contentinfo = container("contentinfo");
+var form = container("form");
+var list = container("list");
+var main = container("main");
+var menu = container("menu");
+var navigation = container("navigation");
+var region = container("region");
+var status = container("status");
+var table = container("table");
+var tablist = container("tablist");
+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);
 }
-function buildTestOutcome({
-  getDescription,
-  id,
-  name,
-  reqNames,
-  requiresKeys,
-  sourcePath,
-  uiOnly
-}) {
-  const description = getDescription();
-  return chainable({
-    expectedOutcome(text) {
-      return buildTestStartsAt({
-        description,
-        expectedOutcome: text,
-        id,
-        name,
-        reqNames,
-        requiresKeys,
-        sourcePath,
-        uiOnly
-      });
-    }
-  });
+
+// 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
+    });
+  }
 }
-function buildTestStartsAt({
-  description,
-  expectedOutcome,
-  id,
-  name,
-  reqNames,
-  requiresKeys,
-  sourcePath,
-  uiOnly
-}) {
-  return chainable({
-    notImplemented: () => ({
-      coverage: [],
-      description,
-      expectedOutcome,
-      id,
-      implemented: false,
+
+// src/builtins.ts
+function browserSingleton(name) {
+  return {
+    name,
+    is: (strings, ...values) => leaf({
+      kind: "browser",
       name,
-      requires: [...reqNames],
-      requiresKeys,
-      sourcePath,
-      startsAtFn: void 0,
-      stepsFn: void 0,
-      uiOnly
-    }),
-    startsAt(fn) {
-      return buildTestSteps({
-        description,
-        expectedOutcome,
-        id,
-        name,
-        reqNames,
-        requiresKeys,
-        sourcePath,
-        startsAtFn: fn,
-        uiOnly
-      });
-    }
-  });
-}
-function buildTestSteps({
-  description,
-  expectedOutcome,
-  id,
-  name,
-  reqNames,
-  requiresKeys,
-  sourcePath,
-  startsAtFn,
-  uiOnly
-}) {
-  return chainable({
-    steps: (stepsFn) => chainable({
-      coverage: (...ids) => ({
-        coverage: ids,
-        description,
-        expectedOutcome,
-        id,
-        implemented: true,
-        name,
-        requires: [...reqNames],
-        requiresKeys,
-        sourcePath,
-        startsAtFn,
-        stepsFn,
-        uiOnly
-      })
+      value: stringValueFromTemplate(strings, values),
+      wait: void 0
     })
-  });
+  };
 }
+var url = browserSingleton("url");
+var title = browserSingleton("title");
+var viewport = browserSingleton("viewport");
 
-// src/lint.ts
-function lint(result) {
-  const diagnostics = [];
-  result.tests.forEach((test2) => {
-    const nodes = getOrderedNodes(test2);
-    const report = (diagnostic) => {
-      diagnostics.push({ ...diagnostic, test: test2.slug });
-    };
-    RULES.forEach((rule) => {
-      rule(nodes, test2, report);
-    });
-  });
-  return { diagnostics };
-}
-function getOrderedNodes(test2) {
-  const result = [];
-  let currentId = test2.spec.entryNode;
-  const visited = /* @__PURE__ */ new Set();
-  while (currentId != null && !visited.has(currentId)) {
-    visited.add(currentId);
-    const found = test2.spec.nodes[currentId];
-    if (found == null) {
-      break;
-    }
-    result.push(found);
-    currentId = found.next;
-  }
-  return result;
-}
-function exactTextMatch(nodes, _test, report) {
-  nodes.forEach((node) => {
-    if (node.type === "assertText" && "operator" in node && node.operator !== "equals") {
-      report({
-        message: `${node.type} uses operator "${node.operator}" \u2014 only "equals" is allowed for determinism`,
-        rule: "exact-text-match",
-        step: node.label ?? node.id
-      });
-    }
-  });
+// src/actions.ts
+function goto(strings, ...values) {
+  return stepBuilder({ kind: "goto", url: stringValueFromTemplate(strings, values) }, [], []);
 }
-function noHardcodedData(nodes, test2, report) {
-  const hasVariables = Object.keys(test2.spec.variables ?? {}).length > 0;
-  if (!hasVariables) {
-    return;
-  }
-  nodes.forEach((node) => {
-    if (node.type === "fill" && isStaticStringValue(node.value)) {
-      const val = node.value.value;
-      if (!isTemplateVar(val) && looksLikeDynamicData(val)) {
-        report({
-          message: `fill() uses hardcoded value "${val}" \u2014 consider using precondition data via {{namespace.key}}`,
-          rule: "no-hardcoded-data",
-          step: node.label ?? node.id
-        });
-      }
-    }
-  });
+function click(locator) {
+  return stepBuilder({ kind: "click", locator }, [], []);
 }
-function preferPreconditionData(nodes, test2, report) {
-  const variableKeys = Object.keys(test2.spec.variables ?? {});
-  if (variableKeys.length === 0) {
-    return;
-  }
-  const hasAnyTemplateRef = nodes.some((node) => JSON.stringify(node).includes("{{"));
-  if (!hasAnyTemplateRef) {
-    report({
-      message: "Test requires preconditions but steps() never references precondition data \u2014 destructure and use it",
-      rule: "prefer-precondition-data",
-      step: void 0
-    });
-  }
+function dblclick(locator) {
+  return stepBuilder({ kind: "dblclick", locator }, [], []);
 }
-function missingLabel(nodes, _test, report) {
-  nodes.forEach((node) => {
-    if (node.label == null || node.label.length === 0) {
-      report({
-        message: `Step "${node.id}" lacks .as("...") label \u2014 every step must be labeled`,
-        rule: "missing-label",
-        step: node.id
-      });
-    }
-  });
+function fill(locator, binding) {
+  return stepBuilder({ kind: "fill", locator, value: binding }, [], []);
 }
-function noDuplicateLabels(nodes, _test, report) {
-  const seen = /* @__PURE__ */ new Map();
-  nodes.forEach((node) => {
-    if (node.label == null) {
-      return;
-    }
-    const existing = seen.get(node.label);
-    if (existing == null) {
-      seen.set(node.label, node.id);
-    } else {
-      report({
-        message: `Duplicate label "${node.label}" \u2014 also used by ${existing}`,
-        rule: "no-duplicate-labels",
-        step: node.label
-      });
-    }
-  });
+function clear(locator) {
+  return stepBuilder({ kind: "clear", locator }, [], []);
 }
-function assertAfterAction(nodes, _test, report) {
-  let consecutiveActions = 0;
-  nodes.forEach((node, index) => {
-    if (index === 0 && node.type === "goto") {
-      return;
-    }
-    if (isAssertionNode(node)) {
-      consecutiveActions = 0;
-      return;
-    }
-    consecutiveActions++;
-    if (consecutiveActions === 3) {
-      report({
-        message: "3+ consecutive actions without an assertion \u2014 add verification between actions",
-        rule: "assert-after-action",
-        step: node.label ?? node.id
-      });
-    }
-  });
+function select(locator, binding) {
+  return stepBuilder({ kind: "select", locator, value: binding }, [], []);
 }
-function assertMatchesOutcome(nodes, _test, report) {
-  if (nodes.length === 0) {
-    return;
-  }
-  const lastNode = nodes.at(-1);
-  if (lastNode != null && !isAssertionNode(lastNode)) {
-    report({
-      message: "Last step is an action, not an assertion \u2014 expectedOutcome should be verified by assertions at the end",
-      rule: "assert-matches-outcome",
-      step: lastNode.label ?? lastNode.id
-    });
-  }
+function check(locator) {
+  return stepBuilder({ kind: "check", locator }, [], []);
 }
-function noEmptySteps(nodes, test2, report) {
-  if (!test2.implemented) {
-    return;
-  }
-  if (nodes.length === 0) {
-    report({
-      message: "Test has zero steps",
-      rule: "no-empty-steps",
-      step: void 0
-    });
-  }
+function uncheck(locator) {
+  return stepBuilder({ kind: "uncheck", locator }, [], []);
 }
-function isStaticStringValue(val) {
-  if (typeof val !== "object" || val == null) {
-    return false;
-  }
-  if (!("type" in val) || val.type !== "static") {
-    return false;
-  }
-  if (!("value" in val) || typeof val.value !== "string") {
-    return false;
-  }
-  return true;
+function hover(locator) {
+  return stepBuilder({ kind: "hover", locator }, [], []);
 }
-function isTemplateVar(value) {
-  return value.includes("{{");
+function upload(locator, files) {
+  return stepBuilder({ files: [...files], kind: "upload", locator }, [], []);
 }
-function looksLikeDynamicData(value) {
-  return value.includes("@") || /\b[a-f0-9]{8,}\b/.test(value) || /^(test|ripplo|example|sample|demo)/i.test(value);
+function press(pressKey, locator) {
+  return stepBuilder({ key: pressKey, kind: "press", locator }, [], []);
 }
-function isAssertionNode(node) {
-  return node.type.startsWith("assert");
+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)] : [])]
+    )
+  };
 }
-var EFFECT_ASSERTION_TYPES = /* @__PURE__ */ new Set([
-  "assertText",
-  "assertValue",
-  "assertCount",
-  "assertUrl",
-  "assertNotVisible",
-  "assertChecked",
-  "assertNotChecked",
-  "assertAttribute",
-  "assertDisabled",
-  "assertEnabled"
-]);
-function isEffectAssertion(node) {
-  return EFFECT_ASSERTION_TYPES.has(node.type);
+
+// 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 });
+  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 noAssertions(nodes, test2, report) {
-  if (!test2.implemented || nodes.length === 0) {
+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;
   }
-  if (!nodes.some((n) => isAssertionNode(n))) {
-    report({
-      message: "Test has zero assertion steps \u2014 cannot verify expectedOutcome. Add assert.* steps.",
-      rule: "no-assertions",
-      step: void 0
-    });
-  }
+  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 lowAssertionRatio(nodes, test2, report) {
-  if (!test2.implemented || nodes.length <= 3) {
-    return;
-  }
-  const assertions = nodes.filter((n) => isAssertionNode(n)).length;
-  if (assertions === 0) {
-    return;
-  }
-  const ratio = assertions / nodes.length;
-  if (ratio < 0.15) {
-    const pct = Math.round(ratio * 100);
-    report({
-      message: `Only ${String(assertions)}/${String(nodes.length)} steps are assertions (${String(pct)}%) \u2014 add more verification between actions`,
-      rule: "low-assertion-ratio",
-      step: void 0
-    });
-  }
+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 locatorSignature(node) {
-  if (!("locator" in node) || node.locator == null) {
-    return void 0;
+function valueBindings(value2) {
+  if (isBinding(value2)) {
+    return [value2];
   }
-  const loc = node.locator;
-  if (loc.by === "role") {
-    return `role:${loc.role}:${loc.name ?? ""}`;
+  if (isTemplate(value2)) {
+    return value2.template.flatMap((segment) => isBinding(segment) ? [segment] : []);
   }
-  return `testId:${loc.value}`;
+  return [];
 }
-function tautologicalPostClickAssert(nodes, _test, report) {
-  nodes.forEach((node, index) => {
-    if (node.type !== "click") {
-      return;
-    }
-    const sig = locatorSignature(node);
-    if (sig == null) {
-      return;
-    }
-    const window = nodes.slice(index + 1, index + 4);
-    const matchesSameAssertVisible = window.find(
-      (n) => n.type === "assertVisible" && locatorSignature(n) === sig
-    );
-    if (matchesSameAssertVisible == null) {
-      return;
-    }
-    const hasOtherEffect = window.some(
-      (n) => isEffectAssertion(n) || isAssertionNode(n) && locatorSignature(n) !== sig
-    );
-    if (hasOtherEffect) {
-      return;
-    }
-    report({
-      message: `click "${node.label ?? node.id}" is followed only by assert.visible on the same locator \u2014 verifies nothing about the click's effect`,
-      rule: "tautological-post-click-assert",
-      step: node.label ?? node.id
-    });
-  });
+function isTemplate(value2) {
+  return typeof value2 === "object" && value2 !== null && "template" in value2;
 }
-var STOPWORDS = /* @__PURE__ */ new Set([
-  "the",
-  "is",
-  "a",
-  "an",
-  "and",
-  "or",
-  "of",
-  "to",
-  "in",
-  "on",
-  "at",
-  "for",
-  "that",
-  "this",
-  "with",
-  "be",
-  "are",
-  "was",
-  "were",
-  "it",
-  "its",
-  "as",
-  "by",
-  "from",
-  "after",
-  "before",
-  "should",
-  "will",
-  "can",
-  "still",
-  "but",
-  "not",
-  "no",
-  "so",
-  "if",
-  "then",
-  "than",
-  "user",
-  "users",
-  "page",
-  "view",
-  "shows",
-  "show",
-  "see",
-  "click",
-  "clicks",
-  "clicked",
-  "clickable",
-  "visible",
-  "appears",
-  "appear",
-  "displayed",
-  "stays",
-  "remains"
-]);
-function tokenize(text) {
-  return text.toLowerCase().split(/[^a-z0-9]+/).filter((t) => t.length >= 3 && !STOPWORDS.has(t));
+function topoSort(entities) {
+  return emitReady([], entities);
 }
-function nodeKeywords(node) {
-  const fromLabel = node.label == null ? [] : tokenize(node.label);
-  if (!("locator" in node) || node.locator == null) {
-    return fromLabel;
+function emitReady(done, remaining) {
+  if (remaining.length === 0) {
+    return [...done];
   }
-  const loc = node.locator;
-  const locName = loc.by === "role" ? loc.name ?? "" : loc.value;
-  return [...fromLabel, ...tokenize(locName)];
+  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 expectedOutcomeKeywordCoverage(nodes, test2, report) {
-  if (!test2.implemented || nodes.length === 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 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;
   }
-  const outcomeTokens = new Set(tokenize(test2.expectedOutcome));
-  if (outcomeTokens.size === 0) {
+  if (predicate.kind !== "when") {
     return;
   }
-  const assertions = nodes.filter((n) => isAssertionNode(n));
-  if (assertions.length === 0) {
-    return;
+  conditionSingletons(predicate.condition).forEach((name) => {
+    if (!given.has(name)) {
+      throw new Error(
+        `when() conditions on singleton "${name}", which is not in the test's given \u2014 add ${name}.of(...) to given`
+      );
+    }
+  });
+  assertPredicateScoped(predicate.consequence, given);
+}
+function conditionSingletons(predicate) {
+  if (predicate.kind === "singleton") {
+    return [predicate.singleton];
   }
-  const covered = assertions.some(
-    (node) => nodeKeywords(node).some((tok) => outcomeTokens.has(tok))
-  );
-  if (!covered) {
-    report({
-      message: `No assertion references any keyword from expectedOutcome (${[...outcomeTokens].join(", ")}) \u2014 the outcome may not actually be verified`,
-      rule: "expected-outcome-keyword-coverage",
-      step: void 0
-    });
+  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]: { example: token.example, valueSpace: token.valueSpace } }
+      };
+    },
+    { counts: {}, names: /* @__PURE__ */ new Map(), params: {} }
+  );
+  return { names: assigned.names, params: assigned.params };
 }
-var BACKEND_MUTATION_KEYWORDS = /save|submit|create|delete|remove|send|invite|update|confirm|publish|apply|pay|subscribe|upgrade|cancel|archive|rename/i;
-function isLikelyBackendMutation(node) {
-  if (node.type === "upload") {
-    return true;
+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);
   }
-  if (node.type !== "click") {
-    return false;
+  if (action.kind === "upload") {
+    return locatorBindings(action.locator);
   }
-  const loc = node.locator;
-  const name = loc.by === "role" ? loc.name ?? "" : loc.value;
-  return BACKEND_MUTATION_KEYWORDS.test(name);
+  return locatorBindings(action.locator);
 }
-function mutationWithoutObserverCoverage(nodes, test2, report) {
-  if (!test2.implemented || test2.spec.uiOnly === true) {
-    return;
+function locatorBindings(locator) {
+  if (locator.by === "inside") {
+    return [...locatorBindings(locator.scope), ...locatorBindings(locator.target)];
   }
-  nodes.forEach((node, index) => {
-    if (!isLikelyBackendMutation(node)) {
-      return;
+  if (locator.by === "role") {
+    return locator.name == null ? [] : valueBindings(locator.name);
+  }
+  return valueBindings(locator.value);
+}
+function predicateBindings(predicate) {
+  switch (predicate.kind) {
+    case "visible":
+    case "disabled":
+    case "enabled":
+    case "focused": {
+      return locatorBindings(predicate.locator);
     }
-    if ("uiOnly" in node && node.uiOnly === true) {
-      return;
+    case "value":
+    case "text": {
+      return [...locatorBindings(predicate.locator), ...valueBindings(predicate.value)];
     }
-    const rest = nodes.slice(index + 1);
-    const nextMutationIdx = rest.findIndex((n) => isLikelyBackendMutation(n));
-    const windowEnd = nextMutationIdx === -1 ? rest.length : nextMutationIdx;
-    const window = rest.slice(0, windowEnd);
-    const hasObserver = window.some((n) => n.type === "assertObserver");
-    if (hasObserver) {
-      return;
+    case "singleton": {
+      return valueBindings(predicate.assertion.value);
     }
-    report({
-      message: `"${node.label ?? node.id}" looks like it mutates backend state but no assert.backend(...) observer verifies it \u2014 the test can pass while the server is broken. You need to add an observer that checks the persisted result (see .ripplo/observers/ for examples). Only if this action truly does NOT change any server state (pure client-side interaction, presentation toggle, etc.) should you fall back to marking the step { uiOnly: true } to silence this rule.`,
-      rule: "mutation-without-observer-coverage",
-      step: node.label ?? node.id
-    });
-  });
-}
-function observerParamsReferenceVariables(nodes, test2, report) {
-  const variableKeys = Object.keys(test2.spec.variables ?? {});
-  if (variableKeys.length === 0) {
-    return;
-  }
-  nodes.forEach((node) => {
-    if (node.type !== "assertObserver") {
-      return;
+    case "browser": {
+      return valueBindings(predicate.value);
     }
-    const paramEntries = Object.entries(node.params);
-    if (paramEntries.length === 0) {
-      return;
+    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))
+      ];
     }
-    const anyReferencesVariable = paramEntries.some(([, ref]) => {
-      return isStaticStringValue(ref) && isTemplateVar(ref.value);
-    });
-    if (anyReferencesVariable) {
-      return;
+    case "not": {
+      return predicateBindings(predicate.predicate);
     }
-    report({
-      message: `assert.backend "${node.label ?? node.id}" passes only hardcoded params while the test defines precondition variables \u2014 observer assertions should reference {{namespace.key}} so they match the actual precondition data`,
-      rule: "observer-params-reference-variables",
-      step: node.label ?? node.id
-    });
-  });
-}
-function uploadFixtureName(nodes, _test, report) {
-  nodes.forEach((node) => {
-    if (node.type !== "upload") {
-      return;
+    case "when": {
+      return [
+        ...predicateBindings(predicate.condition),
+        ...predicateBindings(predicate.consequence),
+        ...predicate.otherwise == null ? [] : predicateBindings(predicate.otherwise)
+      ];
     }
-    node.files.forEach((name) => {
-      if (name.length === 0) {
-        report({
-          message: `upload "${node.label ?? node.id}" references an empty fixture name`,
-          rule: "upload-fixture-name",
-          step: node.label ?? node.id
-        });
-        return;
-      }
-      if (name.includes("..") || name.startsWith("/")) {
-        report({
-          message: `upload "${node.label ?? node.id}" references "${name}" \u2014 fixture names must be relative paths under .ripplo/fixtures/, no ".." or absolute paths`,
-          rule: "upload-fixture-name",
-          step: node.label ?? node.id
-        });
-      }
-    });
-  });
-}
-function noLiteralTemplateStrings(nodes, test2, report) {
-  const declaredKeys = new Set(Object.keys(test2.spec.variables ?? {}));
-  const pattern = /\{\{([^{}]+?)\}\}/g;
-  nodes.forEach((node) => {
-    const serialized = JSON.stringify(node);
-    const allMatches = [...serialized.matchAll(pattern)];
-    const undeclared = [
-      ...new Set(
-        allMatches.map((m) => m[1]).filter((key) => key != null && !declaredKeys.has(key))
-      )
-    ];
-    if (undeclared.length === 0) {
-      return;
+    case "and": {
+      return predicate.predicates.flatMap((p) => predicateBindings(p));
     }
-    const keyList = undeclared.map((k) => `{{${k}}}`).join(", ");
-    const namespaces = [...new Set(undeclared.map((k) => k.split(".")[0] ?? k))].join(", ");
-    report({
-      message: `"${node.label ?? node.id}" contains literal template string(s) ${keyList} \u2014 destructure the proxy in .steps(({ ${namespaces} }) => \u2026) and pass the proxy value (e.g. \`${undeclared[0] ?? ""}\`) directly. Writing the template as a string bypasses type-checking and silently accepts typos.`,
-      rule: "no-literal-template-strings",
-      step: node.label ?? node.id
-    });
-  });
+    case "count": {
+      return [];
+    }
+  }
 }
-var RULES = [
-  exactTextMatch,
-  noHardcodedData,
-  noLiteralTemplateStrings,
-  preferPreconditionData,
-  missingLabel,
-  noDuplicateLabels,
-  assertAfterAction,
-  assertMatchesOutcome,
-  noEmptySteps,
-  noAssertions,
-  lowAssertionRatio,
-  tautologicalPostClickAssert,
-  expectedOutcomeKeywordCoverage,
-  mutationWithoutObserverCoverage,
-  observerParamsReferenceVariables,
-  uploadFixtureName
-];
-
-// src/engine.ts
-var TEST_ID_PREFIX = "ripplo-test-";
-function notImplemented(reason) {
-  return { reason: reason ?? "not implemented" };
-}
-function isNotImplemented(value) {
-  return typeof value === "object" && value !== null && "reason" in value && Object.keys(value).length === 1;
-}
-function createEngine(ripplo, impls) {
-  const preconditionDefs = wirePreconditions(ripplo.preconditions, impls.preconditions);
-  const observerDefs = wireObservers(ripplo.observers, impls.observers);
-  const preconditionsByName = new Map(preconditionDefs.map((d) => [d.name, d]));
-  const observersByName = new Map(observerDefs.map((d) => [d.name, d]));
-  return {
-    executeObserver: (name, params) => executeObserver(observersByName, name, params),
-    executePreconditions: (items, options) => executePreconditions({ defsByName: preconditionsByName, items, options }),
-    getObservers: () => observerDefs,
-    getPreconditions: () => preconditionDefs,
-    getUnimplemented: () => ({
-      observers: observerDefs.filter((o) => !o.implemented).map((o) => o.name),
-      preconditions: preconditionDefs.filter((p) => !p.implemented).map((p) => p.name),
-      tests: ripplo.tests.filter((t) => !t.implemented).map((t) => t.id)
-    }),
-    teardown: (items) => teardown({ defsByName: preconditionsByName, items })
-  };
+function whereBindings(value2) {
+  return isWithin2(value2) ? Object.values(value2.selection.where).flatMap((v2) => whereBindings(v2)) : valueBindings(value2);
 }
-function wirePreconditions(registry, impls) {
-  return Object.entries(registry).map(([key, handle]) => {
-    const impl = Reflect.get(impls, key);
-    if (isNotImplemented(impl)) {
-      return makeNotImplementedPreconditionDef(handle, impl);
-    }
-    return makeWiredPreconditionDef(handle, impl);
-  });
+function isWithin2(value2) {
+  return typeof value2 === "object" && value2 !== null && "kind" in value2;
+}
+function setMap(map, ctx) {
+  return Object.fromEntries(
+    Object.entries(map).map(([key2, value2]) => [key2, resolveValue(value2, ctx)])
+  );
 }
-function wireObservers(registry, impls) {
-  return Object.entries(registry).map(([key, handle]) => {
-    const impl = Reflect.get(impls, key);
-    if (isNotImplemented(impl)) {
-      return makeNotImplementedObserverDef(handle, impl);
+function resolveValue(value2, ctx) {
+  if (isBinding(value2)) {
+    return resolveBinding(value2, ctx);
+  }
+  if (isTemplate(value2)) {
+    return resolveTemplate(value2, ctx);
+  }
+  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 makeWiredObserverDef(handle, impl);
-  });
+    return { ref: name };
+  }
+  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`
+    );
+  }
+  return { ref: `${alias}.${bind.field}` };
 }
-function makeNotImplementedPreconditionDef(handle, sentinel) {
-  const name = readPreconditionName(handle);
+function resolveTemplate(template, ctx) {
   return {
-    dependsOn: readPreconditionDepMappingKeys(handle),
-    depMapping: readPreconditionDepMapping(handle),
-    description: readDescriptionOf(handle),
-    implemented: false,
-    name,
-    returns: [],
-    teardown: void 0,
-    setup: () => Promise.reject(new Error(`Precondition "${name}" is ${sentinel.reason}`))
+    template: template.template.map(
+      (segment) => isBinding(segment) ? resolveBinding(segment, ctx) : segment
+    )
   };
 }
-function makeWiredPreconditionDef(handle, impl) {
-  const name = readPreconditionName(handle);
-  const mapping = readPreconditionDepMapping(handle);
-  const typedImpl = impl;
-  return {
-    dependsOn: mapping.map(([, depName]) => depName),
-    depMapping: mapping,
-    description: readDescriptionOf(handle),
-    implemented: true,
-    name,
-    returns: [],
-    setup: async (items) => {
-      const resolvedItems = items.map((item) => {
-        const resolved = {};
-        mapping.forEach(([key, depName]) => {
-          const data = item.deps[depName];
-          if (data != null) {
-            resolved[key] = data;
-          }
-        });
-        return { ctx: item.ctx, deps: resolved };
-      });
-      const results = await typedImpl.setup(resolvedItems);
-      return results.map((r) => {
-        const out = {};
-        Object.entries(r).forEach(([key, value]) => {
-          if (!isPrimitive(value)) {
-            throw new TypeError(
-              `Precondition "${name}" returned non-primitive value at key "${key}". Setup return values must be string, number, or boolean \u2014 produced via ctx.fixed/uniqueEmail/uniqueId.`
-            );
-          }
-          out[key] = value;
-        });
-        return out;
-      });
-    },
-    teardown: async (items) => {
-      const typed = items;
-      await typedImpl.teardown(typed);
-    }
-  };
+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 makeNotImplementedObserverDef(handle, sentinel) {
-  const name = readObserverName(handle);
-  return {
-    budget: readBudgetOf(handle),
-    description: readDescriptionOfObserver(handle),
-    implemented: false,
-    name,
-    run: () => Promise.resolve(createFailOutcome(`observer "${name}" is ${sentinel.reason}`))
-  };
+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 makeWiredObserverDef(handle, impl) {
-  const name = readObserverName(handle);
-  const typedImpl = impl;
+function resolveStep(step, ctx) {
   return {
-    budget: readBudgetOf(handle),
-    description: readDescriptionOfObserver(handle),
-    implemented: true,
-    name,
-    run: async (ctx, params) => {
-      return typedImpl(ctx, params);
-    }
+    action: resolveAction(step.action, ctx),
+    expect: step.expect.map((predicate) => resolvePredicate(predicate, ctx))
   };
 }
-function readPreconditionDepMappingKeys(handle) {
-  return readPreconditionDepMapping(handle).map(([, depName]) => depName);
-}
-function readDescriptionOf(handle) {
-  return handle.description;
-}
-function readDescriptionOfObserver(handle) {
-  return handle.description;
+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)
+    };
+  }
+  if (action.kind === "upload") {
+    return { ...action, locator: resolveLocator(action.locator, ctx) };
+  }
+  return { ...action, locator: resolveLocator(action.locator, ctx) };
 }
-function readBudgetOf(handle) {
-  return handle.budget;
+function resolveString(value2, ctx) {
+  if (isBinding(value2)) {
+    return resolveBinding(value2, ctx);
+  }
+  if (isTemplate(value2)) {
+    return resolveTemplate(value2, ctx);
+  }
+  return value2;
 }
-async function executePreconditions({
-  defsByName,
-  items,
-  options
-}) {
-  const defaultDomain = deriveDefaultDomain(options?.appUrl);
-  const initial = items.map((item) => {
-    const cookiesRef = [];
+function resolveLocator(locator, ctx) {
+  if (locator.by === "inside") {
     return {
-      cookies: cookiesRef,
-      cookiesRef,
-      ctx: createSetupContext({ cookies: cookiesRef, defaultDomain, runId: item.runId }),
-      data: {},
-      executed: [],
-      failure: void 0,
-      names: item.names,
-      runId: item.runId
+      by: "inside",
+      scope: resolveLocator(locator.scope, ctx),
+      target: resolveLocator(locator.target, ctx)
     };
-  });
-  const order = topoOrder(defsByName, items);
-  const orderError = order.error;
-  if (orderError != null) {
-    return initial.map((s) => failResult(s, orderError));
-  }
-  const sequence = order.names ?? [];
-  let states = initial;
-  let i = 0;
-  while (i < sequence.length) {
-    const name = sequence[i];
-    if (name != null) {
-      states = await executeStep({ defsByName, name, states });
+  }
+  if (locator.by === "role") {
+    return locator.name == null ? locator : { ...locator, name: resolveString(locator.name, ctx) };
+  }
+  return { ...locator, value: resolveString(locator.value, ctx) };
+}
+function resolvePredicate(predicate, ctx) {
+  switch (predicate.kind) {
+    case "visible":
+    case "disabled":
+    case "enabled":
+    case "focused": {
+      return { ...predicate, locator: resolveLocator(predicate.locator, ctx) };
     }
-    i += 1;
-  }
-  return states.map(
-    (s) => s.failure == null ? {
-      cookies: s.cookiesRef,
-      data: s.data,
-      error: void 0,
-      executed: s.executed,
-      runId: s.runId,
-      success: true
-    } : failResult(s, s.failure)
-  );
-}
-function topoOrder(defsByName, items) {
-  const seen = /* @__PURE__ */ new Set();
-  const order = [];
-  const visiting = /* @__PURE__ */ new Set();
-  const visitDeps = (deps) => {
-    const found = deps.find((d) => visit(d) != null);
-    return found == null ? void 0 : visit(found);
-  };
-  const visit = (name) => {
-    if (seen.has(name)) {
-      return void 0;
+    case "value":
+    case "text": {
+      return {
+        ...predicate,
+        locator: resolveLocator(predicate.locator, ctx),
+        value: resolveString(predicate.value, ctx)
+      };
     }
-    if (visiting.has(name)) {
-      return `Cycle detected at precondition "${name}"`;
+    case "singleton": {
+      return {
+        ...predicate,
+        assertion: { ...predicate.assertion, value: resolveValue(predicate.assertion.value, ctx) }
+      };
     }
-    const def = defsByName.get(name);
-    if (def == null) {
-      return `Unknown precondition: "${name}"`;
+    case "browser": {
+      return { ...predicate, value: resolveString(predicate.value, ctx) };
     }
-    visiting.add(name);
-    const deps = def.depMapping.map(([, depName]) => depName);
-    const cycleError = visitDeps(deps);
-    visiting.delete(name);
-    if (cycleError != null) {
-      return cycleError;
+    case "state": {
+      return {
+        ...predicate,
+        assertion: resolveAssertion(predicate.assertion, ctx),
+        key: whereMap(predicate.key, ctx)
+      };
     }
-    seen.add(name);
-    order.push(name);
-    return void 0;
-  };
-  let err;
-  let k = 0;
-  const allNames = items.flatMap((item) => item.names);
-  while (k < allNames.length && err == null) {
-    const n = allNames[k];
-    if (n != null) {
-      err = visit(n);
+    case "not": {
+      return { ...predicate, predicate: resolvePredicate(predicate.predicate, ctx) };
     }
-    k += 1;
-  }
-  if (err != null) {
-    return { error: err, names: void 0 };
-  }
-  return { error: void 0, names: order };
-}
-async function executeStep({
-  defsByName,
-  name,
-  states
-}) {
-  const isActive = (s) => s.failure == null && s.names.includes(name);
-  const active = states.filter((s) => isActive(s));
-  if (active.length === 0) {
-    return states;
-  }
-  const def = defsByName.get(name);
-  if (def == null) {
-    return states.map(
-      (s) => isActive(s) ? { ...s, failure: `Unknown precondition: "${name}"` } : s
-    );
-  }
-  if (!def.implemented) {
-    return states.map(
-      (s) => isActive(s) ? { ...s, failure: `Precondition "${name}" is not implemented` } : s
-    );
-  }
-  const stepResult = await runSetup({ active, def, name });
-  return states.map((s) => isActive(s) ? mergeStepResult(s, name, stepResult) : s);
-}
-async function runSetup({ active, def, name }) {
-  const itemsForCall = active.map((s) => ({ ctx: s.ctx, deps: s.data }));
-  try {
-    const results = await def.setup(itemsForCall);
-    if (results.length !== active.length) {
+    case "when": {
       return {
-        batchError: `Precondition "${name}" returned ${String(results.length)} results for ${String(active.length)} items`,
-        perItem: /* @__PURE__ */ new Map()
+        ...predicate,
+        condition: resolvePredicate(predicate.condition, ctx),
+        consequence: resolvePredicate(predicate.consequence, ctx),
+        otherwise: predicate.otherwise == null ? void 0 : resolvePredicate(predicate.otherwise, ctx)
       };
     }
-    const entries = active.map((s, idx) => {
-      const r = results[idx];
-      return r == null ? void 0 : [s.runId, r];
-    });
-    const valid = entries.filter(
-      (e) => e != null
-    );
-    if (valid.length !== active.length) {
+    case "and": {
       return {
-        batchError: `Precondition "${name}" returned a null result for at least one item`,
-        perItem: /* @__PURE__ */ new Map()
+        ...predicate,
+        predicates: predicate.predicates.map((p) => resolvePredicate(p, ctx))
       };
     }
-    return { batchError: void 0, perItem: new Map(valid) };
-  } catch (error) {
-    return {
-      batchError: error instanceof Error ? error.message : String(error),
-      perItem: /* @__PURE__ */ new Map()
-    };
+    case "count": {
+      return predicate;
+    }
   }
 }
-function mergeStepResult(s, name, result) {
-  if (result.batchError != null) {
-    return { ...s, failure: result.batchError };
+function resolveAssertion(assertion, ctx) {
+  if (assertion.kind === "deleted") {
+    return assertion;
+  }
+  const descriptor = ctx.captures.get(assertion);
+  if (descriptor == null) {
+    throw new Error("internal: capture assertion was not registered");
   }
-  const data = result.perItem.get(s.runId);
-  if (data == null) {
-    return { ...s, failure: `Precondition "${name}" produced no result for run "${s.runId}"` };
+  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 whereMap(map, ctx) {
+  return Object.fromEntries(
+    Object.entries(map).map(([key2, value2]) => [
+      key2,
+      resolveWhere(value2, ctx)
+    ])
+  );
+}
+function resolveWhere(value2, ctx) {
+  return isWithin2(value2) ? { ...value2, selection: { ...value2.selection, where: whereMap(value2.selection.where, ctx) } } : resolveValue(value2, ctx);
+}
+
+// src/test.ts
+function test(intent, fn) {
+  const sourcePath = captureSourcePath();
+  if (fn == null) {
+    return { spec: stubSpec(intent, sourcePath) };
   }
+  const final = finalize(fn());
   return {
-    ...s,
-    data: { ...s.data, [name]: data },
-    executed: [...s.executed, name]
+    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,
+      world: final.world
+    }
   };
 }
-function failResult(s, error) {
+function stubSpec(intent, sourcePath) {
   return {
-    cookies: s.cookies,
-    data: s.data,
-    error,
-    executed: s.executed,
-    runId: s.runId,
-    success: false
+    absent: [],
+    exclusive: [],
+    intent,
+    maybe: [],
+    name: slugify(intent),
+    params: {},
+    singletons: {},
+    sourcePath,
+    steps: [],
+    stub: true,
+    world: []
   };
 }
-async function executeObserver(observersByName, name, params) {
-  const def = observersByName.get(name);
-  if (def == null) {
-    return { error: `Unknown observer: "${name}"`, outcome: void 0, success: false };
-  }
-  if (!def.implemented) {
-    return { error: `Observer "${name}" is not implemented`, outcome: void 0, success: false };
+var TESTS_ANCHOR_PATTERN = /[/\\]\.ripplo[/\\]tests[/\\]([^):]+?)(?::\d+:\d+\)?)?$/;
+function captureSourcePath() {
+  const stack = new Error("capture").stack;
+  if (stack == null) {
+    return void 0;
   }
-  const ctx = createObserverContext(crypto.randomUUID().slice(0, 12));
-  try {
-    const outcome = await def.run(ctx, params);
-    return { error: void 0, outcome, success: true };
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    return { error: void 0, outcome: createFailOutcome(message), success: true };
+  const match = stack.split("\n").map((line) => TESTS_ANCHOR_PATTERN.exec(line)).find((m) => m != null);
+  const captured = match?.[1];
+  return captured == null ? void 0 : captured.replaceAll("\\", "/");
+}
+function slugify(intent) {
+  const slug = intent.toLowerCase().replaceAll(/[^a-z0-9]+/g, " ").trim().split(" ").join("-");
+  if (slug.length === 0) {
+    throw new Error(`test intent "${intent}" slugifies to an empty string`);
   }
+  return slug;
 }
-function createObserverContext(runId) {
+
+// src/params.ts
+function arbitrary(field2, example) {
+  const token = {
+    base: `${field2.entity}_${field2.field}`,
+    example,
+    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 {
-    runId,
-    fail: (reason) => createFailOutcome(reason),
-    pass: () => createPassOutcome(),
-    retry: (reason) => createRetryOutcome(reason)
+    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)
   };
 }
-async function teardown({
-  defsByName,
-  items
-}) {
-  const errors = /* @__PURE__ */ new Map();
-  const allNamesUnique = [...new Set(items.flatMap((i2) => i2.names))];
-  const order = topoOrder(
-    defsByName,
-    allNamesUnique.map((n) => ({ names: [n], runId: "" }))
+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)
   );
-  const reversed = (order.names ?? []).toReversed();
-  let i = 0;
-  while (i < reversed.length) {
-    const name = reversed[i];
-    if (name != null) {
-      await teardownStep({ defsByName, errors, items, 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`);
     }
-    i += 1;
-  }
-  return items.map((it) => {
-    const err = errors.get(it.runId);
-    return { error: err, runId: it.runId, success: err == null };
   });
 }
-async function teardownStep({
-  defsByName,
-  errors,
-  items,
-  name
-}) {
-  const def = defsByName.get(name);
-  if (def?.teardown == null) {
-    return;
+function lookup(impl, name) {
+  return impl == null ? err({ message: `no engine impl for "${name}"` }) : ok(impl);
+}
+function readEntity(impl, name, runId) {
+  return impl.asyncAndThen(
+    (i) => ResultAsync.fromPromise(i.read({ runId }), implFailure).map((rows) => [
+      name,
+      [...rows]
+    ])
+  );
+}
+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 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 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 dependencyWaves(specs) {
+  return buildWaves([], specs);
+}
+function buildWaves(done, remaining) {
+  if (remaining.length === 0) {
+    return done;
   }
-  const active = items.filter((i) => i.names.includes(name));
-  if (active.length === 0) {
-    return;
+  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 teardownItems = active.map((it) => ({
-    ctx: { data: it.data[name] ?? {} }
-  }));
-  try {
-    await def.teardown(teardownItems);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    active.forEach((it) => {
-      if (!errors.has(it.runId)) {
-        errors.set(it.runId, message);
-      }
-    });
+  return buildWaves(
+    [...done, ready],
+    remaining.filter((spec) => !ready.includes(spec))
+  );
+}
+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 seedWave(wave, entityImpl, acc, runId) {
+  return ResultAsync.combine(
+    wave.map((spec) => seedSetup(entityImpl(spec.entity), acc, spec, runId))
+  ).map((folds) => mergeFolds(acc, folds));
+}
+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 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 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 runSeed(impl, fields, runId) {
+  return impl.asyncAndThen((i) => ResultAsync.fromPromise(i.seed({ fields, runId }), implFailure));
+}
+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 createSetupContext({
-  cookies,
-  defaultDomain,
-  runId
+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 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/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(),
+  stable: 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 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("value"), locator: locatorSchema, value: stringValueSchema, wait }),
+    z2.object({ kind: z2.literal("text"), locator: locatorSchema, value: stringValueSchema, wait }),
+    z2.object({
+      assertion: singletonAssertionSchema,
+      kind: z2.literal("singleton"),
+      singleton: z2.string().min(1),
+      wait
+    }),
+    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) }),
+    z2.object({
+      entity: z2.string().min(1),
+      kind: z2.literal("count"),
+      value: z2.number().int().nonnegative()
+    }),
+    z2.object({
+      condition: predicateSchema,
+      consequence: predicateSchema,
+      kind: z2.literal("when"),
+      otherwise: z2.union([predicateSchema, z2.undefined()]).optional().transform((value2) => value2)
+    })
+  ])
+);
+
+// ../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 defineCodec({
+  name,
+  schema
 }) {
-  let callCounter = 0;
-  const nextSuffix = () => {
-    callCounter += 1;
-    return `${runId}-${String(callCounter)}`;
+  return {
+    currentVersion: 1,
+    name,
+    decode: (raw) => decode({ name, raw, schema }),
+    encode: (value2) => ({
+      __codec: name,
+      data: value2,
+      version: 1
+    })
   };
+}
+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 });
+  }
+  return schema.parse(envelope.data);
+}
+
+// ../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({
+  example: primitiveSchema.optional(),
+  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 testSchema = 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),
+  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([]),
+  tests: z4.array(testSchema),
+  valueSpaces: z4.array(valueSpaceSchema)
+});
+var lockfileCodec = defineCodec({ name: "ripplo-lockfile", schema: lockfileSchema });
+
+// ../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()
+});
+var workflowSpecSchema = z5.object({
+  steps: z5.array(stepDescriptorSchema),
+  stub: z5.boolean().default(false)
+});
+
+// ../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/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]) => [
+      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 {
-    runId,
-    fixed: (value) => brandTestValue(value),
-    setCookie: (name, value, options) => {
-      const resolvedOptions = options != null && options.domain == null && defaultDomain != null ? { ...options, domain: defaultDomain } : options ?? void 0;
-      cookies.push({ name, options: resolvedOptions, value });
-    },
-    uniqueEmail: () => brandTestValue(`${TEST_ID_PREFIX}${nextSuffix()}@test.ripplo.ai`),
-    uniqueId: (prefix) => brandTestValue(`${TEST_ID_PREFIX}${prefix}-${nextSuffix()}`)
+    readEntity: (name) => entities.get(name)?.read() ?? [],
+    readSingleton: (name) => singletons.get(name)?.read() ?? null
   };
 }
-function deriveDefaultDomain(baseUrl) {
-  if (baseUrl == null) {
-    return void 0;
+function mountClientEngine(ripplo, impls, { enabled: enabled2 }) {
+  if (!enabled2) {
+    return;
   }
-  try {
-    return new URL(baseUrl).hostname;
-  } catch {
-    return void 0;
+  Reflect.set(globalThis, CLIENT_MOUNT_KEY, createClientEngine(ripplo, impls));
+}
+
+// src/build.ts
+function buildLockfile(input) {
+  assertUniqueNames(input.entities);
+  const lockfile = lockfileSchema.parse({
+    entities: input.entities.map((handle) => handle.schema),
+    singletons: input.singletons.map((handle) => handle.schema),
+    tests: input.tests.map((ripploTest) => ripploTest.spec),
+    valueSpaces: dedupeByName([
+      ...input.entities.flatMap((handle) => handle.valueSpaces),
+      ...input.singletons.flatMap((handle) => handle.valueSpaces)
+    ])
+  });
+  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 dedupeByName(spaces) {
+  const byName = new Map(spaces.map((space) => [space.name, space]));
+  return [...byName.values()];
+}
+function assertNoContradictions(lockfile) {
+  lockfile.tests.forEach((test2) => {
+    assertNoContradiction(test2);
+    assertNoDanglingRefs(test2);
+  });
+}
+function assertNoContradiction(test2) {
+  const setups = [...test2.world, ...test2.maybe];
+  test2.absent.forEach((absence) => {
+    const clash = setups.find(
+      (setup) => setup.entity === absence.entity && whereMatches(absence.where, setup.set)
+    );
+    if (clash != null) {
+      throw new Error(
+        `test "${test2.name}": creates a "${absence.entity}" ("${clash.as}") that a none(${absence.entity}, \u2026) in its world forbids`
+      );
+    }
+  });
+}
+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(test2) {
+  const aliases = new Set([...test2.world, ...test2.maybe].map((setup) => setup.as));
+  const paramKeys = new Set(Object.keys(test2.params));
+  const fieldSets = [
+    ...test2.world.map((setup) => setup.set),
+    ...test2.maybe.map((setup) => setup.set),
+    ...test2.absent.map((absence) => absence.where)
+  ];
+  fieldSets.forEach((set) => {
+    assertSetRefs(test2.name, set, aliases, paramKeys);
+  });
+}
+function assertSetRefs(testName, 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 "${testName}": 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 {
+    entities: input.entities,
+    lockfile: buildLockfile({
+      entities: input.entities,
+      singletons: input.singletons,
+      tests: input.tests
+    }),
+    singletons: input.singletons,
+    tests: input.tests
+  };
+}
 export {
-  DEFAULT_IGNORE_PATHS,
-  DEFAULT_WATCH_PATHS,
-  TEST_ID_PREFIX,
-  compile,
+  CLIENT_MOUNT_KEY,
+  CLIENT_SEED_KEY,
+  alert,
+  and,
+  arbitrary,
+  banner,
+  button,
+  cell,
+  changed,
+  check,
+  checkbox,
+  clear,
+  click,
+  combobox,
+  complementary,
+  contentinfo,
+  count,
+  createClientEngine,
   createEngine,
   createRipplo,
-  lint,
-  notImplemented,
-  observer,
-  precondition,
-  readAdapterWebhookSecret,
-  serializeCookie,
+  dblclick,
+  dialog,
+  disabled,
+  enabled,
+  entity,
+  field,
+  fill,
+  focused,
+  form,
+  goto,
+  heading,
+  hover,
+  id,
+  img,
+  inside,
+  key,
+  link,
+  list,
+  listitem,
+  main,
+  menu,
+  menuitem,
+  mountClientEngine,
+  navigation,
+  not,
+  option,
+  press,
+  radio,
+  region,
+  role,
+  row,
+  searchbox,
+  select,
+  singleton,
+  status,
+  tab,
+  table,
+  tablist,
   test,
-  toBatchRunResults,
-  toTeardownResults,
-  verifyWebhookSignature
+  testId,
+  text,
+  textbox,
+  title,
+  uncheck,
+  upload,
+  url,
+  v,
+  value,
+  viewport,
+  visible,
+  when,
+  within
 };