@ripplo/testing 0.7.10 → 0.7.12

package/DSL.md

@@ -47,16 +47,14 @@ If you're unsure, it's backend. A value that's cached in the browser but owned b
 ### `field(options)`
 
 ```ts
-field({ value: v.email() }); // required, stable — Ripplo checks the app's value matches what the test expected
+field({ value: v.email() }); // required — Ripplo checks the app's value matches what the test expected
 field({ value: v.word(), optional: true }); // nullable; `null` is a valid set/assert value
-field({ value: v.number({ min: 0, max: 100 }), stable: false }); // adopt-only, drift not checked
 ```
 
-| option     | meaning                                                                                                              |
-| ---------- | -------------------------------------------------------------------------------------------------------------------- |
-| `value`    | the value-space (`v.*`) — required                                                                                   |
-| `optional` | `true` ⇒ the field is nullable (`null` allowed in `of`/`updated`/assertions); Ripplo treats `null ≡ absent`          |
-| `stable`   | default `true` (Ripplo checks the app's value matches what the test expected). `false` = adopt-only, drift unchecked |
+| option     | meaning                                                                                                     |
+| ---------- | ----------------------------------------------------------------------------------------------------------- |
+| `value`    | the value-space (`v.*`) — required                                                                          |
+| `optional` | `true` ⇒ the field is nullable (`null` allowed in `of`/`updated`/assertions); Ripplo treats `null ≡ absent` |
 
 ### Identity: `id()` and `key(options)`
 

package/dist/{engine-mt1A6IKW.d.ts → engine-CeG-3Q7o.d.ts}

@@ -143,7 +143,6 @@ declare const propSpecSchema: z.ZodObject<{
         eventual: "eventual";
     }>>;
     optional: z.ZodBoolean;
-    stable: z.ZodBoolean;
     type: z.ZodEnum<{
         string: "string";
         number: "number";
@@ -171,7 +170,6 @@ declare const entitySchemaSchema: z.ZodObject<{
             eventual: "eventual";
         }>>;
         optional: z.ZodBoolean;
-        stable: z.ZodBoolean;
         type: z.ZodEnum<{
             string: "string";
             number: "number";
@@ -396,7 +394,6 @@ declare const workflowSchema: z.ZodObject<{
     }, z.core.$strip>>>;
     name: z.ZodString;
     params: z.ZodRecord<z.ZodString, z.ZodObject<{
-        example: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
         valueSpace: z.ZodString;
     }, z.core.$strip>>;
     singletons: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
@@ -482,7 +479,6 @@ declare const workflowSchema: z.ZodObject<{
         intent: z.ZodString;
         name: z.ZodString;
         params: z.ZodRecord<z.ZodString, z.ZodObject<{
-            example: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
             valueSpace: z.ZodString;
         }, z.core.$strip>>;
         singletons: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
@@ -593,7 +589,6 @@ declare const lockfileSchema: z.ZodObject<{
                 eventual: "eventual";
             }>>;
             optional: z.ZodBoolean;
-            stable: z.ZodBoolean;
             type: z.ZodEnum<{
                 string: "string";
                 number: "number";
@@ -687,7 +682,6 @@ declare const lockfileSchema: z.ZodObject<{
         }, z.core.$strip>>>;
         name: z.ZodString;
         params: z.ZodRecord<z.ZodString, z.ZodObject<{
-            example: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
             valueSpace: z.ZodString;
         }, z.core.$strip>>;
         singletons: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
@@ -773,7 +767,6 @@ declare const lockfileSchema: z.ZodObject<{
             intent: z.ZodString;
             name: z.ZodString;
             params: z.ZodRecord<z.ZodString, z.ZodObject<{
-                example: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
                 valueSpace: z.ZodString;
             }, z.core.$strip>>;
             singletons: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
@@ -944,7 +937,6 @@ type Primitive = string | number | boolean;
 type Fields = Record<string, Primitive>;
 interface ParamToken {
     readonly base: string;
-    readonly example: Primitive | undefined;
     readonly valueSpace: string;
 }
 type EntityKind = "of" | "only" | "maybe";
@@ -1080,7 +1072,6 @@ interface PropBuilder<T extends Primitive, Opt extends boolean = boolean> {
 type Mods = Partial<{
     readonly consistency: ConsistencyClass;
     readonly optional: boolean;
-    readonly stable: boolean;
 }>;
 type IsOptional = {
     readonly optional: true;

package/dist/express.d.ts

@@ -1,5 +1,5 @@
 import { Router } from 'express';
-import { E as Engine } from './engine-mt1A6IKW.js';
+import { E as Engine } from './engine-CeG-3Q7o.js';
 import 'neverthrow';
 import 'zod';
 

package/dist/express.js

@@ -71,7 +71,6 @@ var valueSpaceSchema = z.object({
 var propSpecSchema = z.object({
   consistency: consistencyClassSchema.default("strict"),
   optional: z.boolean(),
-  stable: z.boolean(),
   type: primitiveTypeSchema,
   valueSpace: z.string().min(1).optional()
 });
@@ -260,7 +259,6 @@ var stepSchema = z4.object({
   expect: z4.array(predicateSchema).default([])
 });
 var paramSchema = z4.object({
-  example: primitiveSchema.optional(),
   valueSpace: z4.string().min(1)
 });
 var setupSchema = z4.object({

package/dist/index.d.ts

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

package/dist/index.js

@@ -270,7 +270,6 @@ function field(options) {
     spec: {
       consistency: options.consistency ?? "strict",
       optional: options.optional ?? false,
-      stable: options.stable ?? true,
       type: options.value.primitive
     },
     valueSpace: options.value
@@ -280,7 +279,7 @@ function id() {
   return {
     idKind: "surrogate",
     prop: propBuilder({
-      spec: { consistency: "strict", optional: false, stable: true, type: "string" },
+      spec: { consistency: "strict", optional: false, type: "string" },
       valueSpace: void 0
     })
   };
@@ -292,7 +291,6 @@ function key(options) {
       spec: {
         consistency: "strict",
         optional: false,
-        stable: true,
         type: options.value.primitive
       },
       valueSpace: options.value
@@ -598,6 +596,20 @@ function stepBuilder(action, expected, captures) {
   };
 }
 
+// src/coherence.ts
+function assertEntityCoherence(entities) {
+  const counts = entities.reduce(
+    (acc, d) => new Map([...acc, [d.entity, (acc.get(d.entity) ?? 0) + 1]]),
+    /* @__PURE__ */ new Map()
+  );
+  const over = entities.find((d) => d.kind === "only" && (counts.get(d.entity) ?? 0) > 1);
+  if (over != null) {
+    throw new Error(
+      `entity "${over.entity}" is declared only() but seeded ${String(counts.get(over.entity) ?? 0)} times \u2014 only() means a single exclusive instance; use of() for multiple instances`
+    );
+  }
+}
+
 // src/finalize.ts
 function finalize(body) {
   const descriptors = [...new Set(body.given.map((item) => item.__entity))];
@@ -611,6 +623,7 @@ function finalize(body) {
     )
   );
   assertNoMaybeRefs({ absences, entities, singletonStates });
+  assertEntityCoherence(entities);
   const captures = body.steps.flatMap((builder) => builder.captures);
   assertScopedConditions(body.steps, new Set(singletonStates.map((s) => s.singleton)));
   const aliases = assignAliases([...entities, ...captures.map((c) => c.descriptor)]);
@@ -759,7 +772,7 @@ function assignParams(bindings) {
       return {
         counts: { ...acc.counts, [token.base]: ordinal + 1 },
         names: new Map([...acc.names, [b, name]]),
-        params: { ...acc.params, [name]: { example: token.example, valueSpace: token.valueSpace } }
+        params: { ...acc.params, [name]: { valueSpace: token.valueSpace } }
       };
     },
     { counts: {}, names: /* @__PURE__ */ new Map(), params: {} }
@@ -1125,10 +1138,9 @@ function slugify(intent) {
 }
 
 // src/params.ts
-function arbitrary(field2, example) {
+function arbitrary(field2) {
   const token = {
     base: `${field2.entity}_${field2.field}`,
-    example,
     valueSpace: field2.valueSpaceName
   };
   return paramBinding(token);
@@ -1367,7 +1379,6 @@ var valueSpaceSchema = z.object({
 var propSpecSchema = z.object({
   consistency: consistencyClassSchema.default("strict"),
   optional: z.boolean(),
-  stable: z.boolean(),
   type: primitiveTypeSchema,
   valueSpace: z.string().min(1).optional()
 });
@@ -1560,7 +1571,6 @@ var stepSchema = z4.object({
   expect: z4.array(predicateSchema).default([])
 });
 var paramSchema = z4.object({
-  example: primitiveSchema.optional(),
   valueSpace: z4.string().min(1)
 });
 var setupSchema = z4.object({

package/package.json

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