@ripplo/testing 0.6.0 → 0.7.0

package/dist/engine-BT7hUouB.d.ts

@@ -0,0 +1,1095 @@
+import { ResultAsync } from 'neverthrow';
+import { z } from 'zod';
+
+declare const budgetSchema: z.ZodEnum<{
+    fast: "fast";
+    slow: "slow";
+    async: "async";
+}>;
+type Budget = z.infer<typeof budgetSchema>;
+declare const valueRefSchema: z.ZodObject<{
+    ref: z.ZodString;
+}, z.core.$strip>;
+type ValueRef = z.infer<typeof valueRefSchema>;
+declare const primitiveSchema: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+type Primitive$1 = z.infer<typeof primitiveSchema>;
+declare const setValueSchema: z.ZodUnion<readonly [z.ZodObject<{
+    ref: z.ZodString;
+}, z.core.$strip>, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>, z.ZodObject<{
+    template: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        ref: z.ZodString;
+    }, z.core.$strip>]>>;
+}, z.core.$strip>, z.ZodNull]>;
+type SetValue = z.infer<typeof setValueSchema>;
+declare const changedSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"changed">;
+}, z.core.$strip>;
+type Changed = z.infer<typeof changedSchema>;
+declare const updateValueSchema: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodObject<{
+    ref: z.ZodString;
+}, z.core.$strip>, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>, z.ZodObject<{
+    template: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        ref: z.ZodString;
+    }, z.core.$strip>]>>;
+}, z.core.$strip>, z.ZodNull]>, z.ZodObject<{
+    kind: z.ZodLiteral<"changed">;
+}, z.core.$strip>]>;
+type UpdateValue = z.infer<typeof updateValueSchema>;
+declare const stringValueSchema: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+    ref: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    template: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        ref: z.ZodString;
+    }, z.core.$strip>]>>;
+}, z.core.$strip>]>;
+type StringValue = z.infer<typeof stringValueSchema>;
+type Locator = {
+    readonly by: "role";
+    readonly name: StringValue | undefined;
+    readonly role: string;
+} | {
+    readonly by: "testId";
+    readonly value: StringValue;
+} | {
+    readonly by: "inside";
+    readonly scope: Locator;
+    readonly target: Locator;
+};
+declare const primitiveTypeSchema: z.ZodEnum<{
+    string: "string";
+    number: "number";
+    boolean: "boolean";
+}>;
+type PrimitiveType = z.infer<typeof primitiveTypeSchema>;
+declare const consistencyClassSchema: z.ZodEnum<{
+    strict: "strict";
+    eventual: "eventual";
+}>;
+type ConsistencyClass = z.infer<typeof consistencyClassSchema>;
+declare const stringConstraintsSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"string">;
+    maxLength: z.ZodOptional<z.ZodNumber>;
+    minLength: z.ZodOptional<z.ZodNumber>;
+    pattern: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const numberConstraintsSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"number">;
+    max: z.ZodOptional<z.ZodNumber>;
+    min: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+declare const constraintsSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"string">;
+    maxLength: z.ZodOptional<z.ZodNumber>;
+    minLength: z.ZodOptional<z.ZodNumber>;
+    pattern: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"number">;
+    max: z.ZodOptional<z.ZodNumber>;
+    min: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"datetime">;
+    maxOffsetDays: z.ZodNumber;
+    minOffsetDays: z.ZodNumber;
+}, z.core.$strip>], "kind">;
+type StringConstraints = z.infer<typeof stringConstraintsSchema>;
+type NumberConstraints = z.infer<typeof numberConstraintsSchema>;
+type Constraints = z.infer<typeof constraintsSchema>;
+declare const generatorSchema: z.ZodEnum<{
+    "company.name": "company.name";
+    "date.iso": "date.iso";
+    "internet.email": "internet.email";
+    "internet.url": "internet.url";
+    "person.fullName": "person.fullName";
+    "lorem.slug": "lorem.slug";
+    "lorem.word": "lorem.word";
+}>;
+type Generator = z.infer<typeof generatorSchema>;
+declare const valueSpaceSchema: z.ZodObject<{
+    constraints: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"string">;
+        maxLength: z.ZodOptional<z.ZodNumber>;
+        minLength: z.ZodOptional<z.ZodNumber>;
+        pattern: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"number">;
+        max: z.ZodOptional<z.ZodNumber>;
+        min: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"datetime">;
+        maxOffsetDays: z.ZodNumber;
+        minOffsetDays: z.ZodNumber;
+    }, z.core.$strip>], "kind">>;
+    generator: z.ZodEnum<{
+        "company.name": "company.name";
+        "date.iso": "date.iso";
+        "internet.email": "internet.email";
+        "internet.url": "internet.url";
+        "person.fullName": "person.fullName";
+        "lorem.slug": "lorem.slug";
+        "lorem.word": "lorem.word";
+    }>;
+    name: z.ZodString;
+    type: z.ZodEnum<{
+        string: "string";
+        number: "number";
+        boolean: "boolean";
+    }>;
+    values: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+}, z.core.$strip>;
+type ValueSpace = z.infer<typeof valueSpaceSchema>;
+declare const propSpecSchema: z.ZodObject<{
+    consistency: z.ZodDefault<z.ZodEnum<{
+        strict: "strict";
+        eventual: "eventual";
+    }>>;
+    optional: z.ZodBoolean;
+    stable: z.ZodBoolean;
+    type: z.ZodEnum<{
+        string: "string";
+        number: "number";
+        boolean: "boolean";
+    }>;
+    valueSpace: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type PropSpec = z.infer<typeof propSpecSchema>;
+declare const sourceSchema: z.ZodEnum<{
+    backend: "backend";
+    client: "client";
+}>;
+type Source = z.infer<typeof sourceSchema>;
+declare const entitySchemaSchema: z.ZodObject<{
+    description: z.ZodOptional<z.ZodString>;
+    identity: z.ZodArray<z.ZodString>;
+    identityKind: z.ZodEnum<{
+        surrogate: "surrogate";
+        natural: "natural";
+    }>;
+    name: z.ZodString;
+    props: z.ZodRecord<z.ZodString, z.ZodObject<{
+        consistency: z.ZodDefault<z.ZodEnum<{
+            strict: "strict";
+            eventual: "eventual";
+        }>>;
+        optional: z.ZodBoolean;
+        stable: z.ZodBoolean;
+        type: z.ZodEnum<{
+            string: "string";
+            number: "number";
+            boolean: "boolean";
+        }>;
+        valueSpace: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    source: z.ZodDefault<z.ZodEnum<{
+        backend: "backend";
+        client: "client";
+    }>>;
+}, z.core.$strip>;
+type EntitySchema = z.infer<typeof entitySchemaSchema>;
+declare const singletonSchemaSchema: z.ZodObject<{
+    consistency: z.ZodDefault<z.ZodEnum<{
+        strict: "strict";
+        eventual: "eventual";
+    }>>;
+    default: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+    description: z.ZodOptional<z.ZodString>;
+    name: z.ZodString;
+    source: z.ZodDefault<z.ZodEnum<{
+        backend: "backend";
+        client: "client";
+    }>>;
+    type: z.ZodEnum<{
+        string: "string";
+        number: "number";
+        boolean: "boolean";
+    }>;
+    valueSpace: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type SingletonSchema = z.infer<typeof singletonSchemaSchema>;
+declare const browserSingletonSchema: z.ZodEnum<{
+    title: "title";
+    url: "url";
+    viewport: "viewport";
+}>;
+type BrowserSingleton = z.infer<typeof browserSingletonSchema>;
+
+type StateAssertion$1 = {
+    readonly as: string;
+    readonly kind: "created";
+    readonly props: Record<string, SetValue>;
+} | {
+    readonly as: string;
+    readonly kind: "updated";
+    readonly props: Record<string, UpdateValue>;
+} | {
+    readonly kind: "deleted";
+};
+type SingletonAssertion = {
+    readonly kind: "is";
+    readonly value: SetValue;
+};
+interface Selection$1 {
+    readonly entity: string;
+    readonly where: Record<string, WhereValue>;
+}
+interface Within {
+    readonly field: string;
+    readonly kind: "within";
+    readonly selection: Selection$1;
+}
+type WhereValue = SetValue | Within;
+type Predicate = {
+    readonly kind: "visible";
+    readonly locator: Locator;
+    readonly wait: Budget | undefined;
+} | {
+    readonly kind: "disabled";
+    readonly locator: Locator;
+    readonly wait: Budget | undefined;
+} | {
+    readonly kind: "enabled";
+    readonly locator: Locator;
+    readonly wait: Budget | undefined;
+} | {
+    readonly kind: "focused";
+    readonly locator: Locator;
+    readonly wait: Budget | undefined;
+} | {
+    readonly kind: "value";
+    readonly locator: Locator;
+    readonly value: StringValue;
+    readonly wait: Budget | undefined;
+} | {
+    readonly kind: "text";
+    readonly locator: Locator;
+    readonly value: StringValue;
+    readonly wait: Budget | undefined;
+} | {
+    readonly assertion: SingletonAssertion;
+    readonly kind: "singleton";
+    readonly singleton: string;
+    readonly wait: Budget | undefined;
+} | {
+    readonly kind: "browser";
+    readonly name: BrowserSingleton;
+    readonly value: StringValue;
+    readonly wait: Budget | undefined;
+} | {
+    readonly assertion: StateAssertion$1;
+    readonly entity: string;
+    readonly key: Record<string, WhereValue>;
+    readonly kind: "state";
+    readonly wait: Budget | undefined;
+} | {
+    readonly kind: "jsErrors";
+} | {
+    readonly kind: "not";
+    readonly predicate: Predicate;
+} | {
+    readonly kind: "and";
+    readonly predicates: ReadonlyArray<Predicate>;
+} | {
+    readonly entity: string;
+    readonly kind: "count";
+    readonly value: number;
+} | {
+    readonly condition: Predicate;
+    readonly consequence: Predicate;
+    readonly kind: "when";
+    readonly otherwise: Predicate | undefined;
+};
+type Condition = Extract<Predicate, {
+    kind: "singleton" | "count";
+}> | {
+    readonly kind: "not";
+    readonly predicate: Condition;
+} | {
+    readonly kind: "and";
+    readonly predicates: ReadonlyArray<Condition>;
+};
+
+declare const CLIENT_MOUNT_KEY = "__ripplo__";
+declare const CLIENT_SEED_KEY = "__ripplo_seed__";
+declare const stepSchema: z.ZodObject<{
+    action: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"goto">;
+        url: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            ref: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            template: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                ref: z.ZodString;
+            }, z.core.$strip>]>>;
+        }, z.core.$strip>]>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"fill">;
+        locator: z.ZodType<Locator, unknown, z.core.$ZodTypeInternals<Locator, unknown>>;
+        value: z.ZodUnion<readonly [z.ZodObject<{
+            ref: z.ZodString;
+        }, z.core.$strip>, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>, z.ZodObject<{
+            template: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                ref: z.ZodString;
+            }, z.core.$strip>]>>;
+        }, z.core.$strip>, z.ZodNull]>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"clear">;
+        locator: z.ZodType<Locator, unknown, z.core.$ZodTypeInternals<Locator, unknown>>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"click">;
+        locator: z.ZodType<Locator, unknown, z.core.$ZodTypeInternals<Locator, unknown>>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"dblclick">;
+        locator: z.ZodType<Locator, unknown, z.core.$ZodTypeInternals<Locator, unknown>>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"select">;
+        locator: z.ZodType<Locator, unknown, z.core.$ZodTypeInternals<Locator, unknown>>;
+        value: z.ZodUnion<readonly [z.ZodObject<{
+            ref: z.ZodString;
+        }, z.core.$strip>, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>, z.ZodObject<{
+            template: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                ref: z.ZodString;
+            }, z.core.$strip>]>>;
+        }, z.core.$strip>, z.ZodNull]>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"check">;
+        locator: z.ZodType<Locator, unknown, z.core.$ZodTypeInternals<Locator, unknown>>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"uncheck">;
+        locator: z.ZodType<Locator, unknown, z.core.$ZodTypeInternals<Locator, unknown>>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"hover">;
+        locator: z.ZodType<Locator, unknown, z.core.$ZodTypeInternals<Locator, unknown>>;
+    }, z.core.$strip>, z.ZodObject<{
+        files: z.ZodArray<z.ZodString>;
+        kind: z.ZodLiteral<"upload">;
+        locator: z.ZodType<Locator, unknown, z.core.$ZodTypeInternals<Locator, unknown>>;
+    }, z.core.$strip>, z.ZodObject<{
+        key: z.ZodString;
+        kind: z.ZodLiteral<"press">;
+        locator: z.ZodOptional<z.ZodType<Locator, unknown, z.core.$ZodTypeInternals<Locator, unknown>>>;
+    }, z.core.$strip>], "kind">;
+    expect: z.ZodDefault<z.ZodArray<z.ZodType<Predicate, unknown, z.core.$ZodTypeInternals<Predicate, unknown>>>>;
+}, z.core.$strip>;
+type Step = z.infer<typeof stepSchema>;
+declare const testSchema: z.ZodObject<{
+    absent: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        entity: z.ZodString;
+        where: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+            ref: z.ZodString;
+        }, z.core.$strip>, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>, z.ZodObject<{
+            template: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                ref: z.ZodString;
+            }, z.core.$strip>]>>;
+        }, z.core.$strip>, z.ZodNull]>>;
+    }, z.core.$strip>>>;
+    exclusive: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    intent: z.ZodString;
+    invariants: z.ZodDefault<z.ZodArray<z.ZodType<Predicate, unknown, z.core.$ZodTypeInternals<Predicate, unknown>>>>;
+    maybe: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        as: z.ZodString;
+        entity: z.ZodString;
+        set: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+            ref: z.ZodString;
+        }, z.core.$strip>, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>, z.ZodObject<{
+            template: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                ref: z.ZodString;
+            }, z.core.$strip>]>>;
+        }, z.core.$strip>, z.ZodNull]>>;
+    }, 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<{
+        ref: z.ZodString;
+    }, z.core.$strip>, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>, z.ZodObject<{
+        template: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            ref: z.ZodString;
+        }, z.core.$strip>]>>;
+    }, z.core.$strip>, z.ZodNull]>>>;
+    sourcePath: z.ZodOptional<z.ZodString>;
+    steps: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        action: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"goto">;
+            url: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                ref: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                template: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                    ref: z.ZodString;
+                }, z.core.$strip>]>>;
+            }, z.core.$strip>]>;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"fill">;
+            locator: z.ZodType<Locator, unknown, z.core.$ZodTypeInternals<Locator, unknown>>;
+            value: z.ZodUnion<readonly [z.ZodObject<{
+                ref: z.ZodString;
+            }, z.core.$strip>, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>, z.ZodObject<{
+                template: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                    ref: z.ZodString;
+                }, z.core.$strip>]>>;
+            }, z.core.$strip>, z.ZodNull]>;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"clear">;
+            locator: z.ZodType<Locator, unknown, z.core.$ZodTypeInternals<Locator, unknown>>;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"click">;
+            locator: z.ZodType<Locator, unknown, z.core.$ZodTypeInternals<Locator, unknown>>;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"dblclick">;
+            locator: z.ZodType<Locator, unknown, z.core.$ZodTypeInternals<Locator, unknown>>;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"select">;
+            locator: z.ZodType<Locator, unknown, z.core.$ZodTypeInternals<Locator, unknown>>;
+            value: z.ZodUnion<readonly [z.ZodObject<{
+                ref: z.ZodString;
+            }, z.core.$strip>, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>, z.ZodObject<{
+                template: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                    ref: z.ZodString;
+                }, z.core.$strip>]>>;
+            }, z.core.$strip>, z.ZodNull]>;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"check">;
+            locator: z.ZodType<Locator, unknown, z.core.$ZodTypeInternals<Locator, unknown>>;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"uncheck">;
+            locator: z.ZodType<Locator, unknown, z.core.$ZodTypeInternals<Locator, unknown>>;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"hover">;
+            locator: z.ZodType<Locator, unknown, z.core.$ZodTypeInternals<Locator, unknown>>;
+        }, z.core.$strip>, z.ZodObject<{
+            files: z.ZodArray<z.ZodString>;
+            kind: z.ZodLiteral<"upload">;
+            locator: z.ZodType<Locator, unknown, z.core.$ZodTypeInternals<Locator, unknown>>;
+        }, z.core.$strip>, z.ZodObject<{
+            key: z.ZodString;
+            kind: z.ZodLiteral<"press">;
+            locator: z.ZodOptional<z.ZodType<Locator, unknown, z.core.$ZodTypeInternals<Locator, unknown>>>;
+        }, z.core.$strip>], "kind">;
+        expect: z.ZodDefault<z.ZodArray<z.ZodType<Predicate, unknown, z.core.$ZodTypeInternals<Predicate, unknown>>>>;
+    }, z.core.$strip>>>;
+    stub: z.ZodDefault<z.ZodBoolean>;
+    world: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        as: z.ZodString;
+        entity: z.ZodString;
+        set: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+            ref: z.ZodString;
+        }, z.core.$strip>, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>, z.ZodObject<{
+            template: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                ref: z.ZodString;
+            }, z.core.$strip>]>>;
+        }, z.core.$strip>, z.ZodNull]>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+type Test = z.infer<typeof testSchema>;
+declare const lockfileSchema: z.ZodObject<{
+    entities: z.ZodArray<z.ZodObject<{
+        description: z.ZodOptional<z.ZodString>;
+        identity: z.ZodArray<z.ZodString>;
+        identityKind: z.ZodEnum<{
+            surrogate: "surrogate";
+            natural: "natural";
+        }>;
+        name: z.ZodString;
+        props: z.ZodRecord<z.ZodString, z.ZodObject<{
+            consistency: z.ZodDefault<z.ZodEnum<{
+                strict: "strict";
+                eventual: "eventual";
+            }>>;
+            optional: z.ZodBoolean;
+            stable: z.ZodBoolean;
+            type: z.ZodEnum<{
+                string: "string";
+                number: "number";
+                boolean: "boolean";
+            }>;
+            valueSpace: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        source: z.ZodDefault<z.ZodEnum<{
+            backend: "backend";
+            client: "client";
+        }>>;
+    }, z.core.$strip>>;
+    fixtures: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        sha256: z.ZodString;
+        size: z.ZodNumber;
+    }, z.core.$strip>>>;
+    singletons: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        consistency: z.ZodDefault<z.ZodEnum<{
+            strict: "strict";
+            eventual: "eventual";
+        }>>;
+        default: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+        description: z.ZodOptional<z.ZodString>;
+        name: z.ZodString;
+        source: z.ZodDefault<z.ZodEnum<{
+            backend: "backend";
+            client: "client";
+        }>>;
+        type: z.ZodEnum<{
+            string: "string";
+            number: "number";
+            boolean: "boolean";
+        }>;
+        valueSpace: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    tests: z.ZodArray<z.ZodObject<{
+        absent: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            entity: z.ZodString;
+            where: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                ref: z.ZodString;
+            }, z.core.$strip>, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>, z.ZodObject<{
+                template: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                    ref: z.ZodString;
+                }, z.core.$strip>]>>;
+            }, z.core.$strip>, z.ZodNull]>>;
+        }, z.core.$strip>>>;
+        exclusive: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        intent: z.ZodString;
+        invariants: z.ZodDefault<z.ZodArray<z.ZodType<Predicate, unknown, z.core.$ZodTypeInternals<Predicate, unknown>>>>;
+        maybe: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            as: z.ZodString;
+            entity: z.ZodString;
+            set: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                ref: z.ZodString;
+            }, z.core.$strip>, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>, z.ZodObject<{
+                template: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                    ref: z.ZodString;
+                }, z.core.$strip>]>>;
+            }, z.core.$strip>, z.ZodNull]>>;
+        }, 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<{
+            ref: z.ZodString;
+        }, z.core.$strip>, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>, z.ZodObject<{
+            template: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                ref: z.ZodString;
+            }, z.core.$strip>]>>;
+        }, z.core.$strip>, z.ZodNull]>>>;
+        sourcePath: z.ZodOptional<z.ZodString>;
+        steps: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            action: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"goto">;
+                url: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                    ref: z.ZodString;
+                }, z.core.$strip>, z.ZodObject<{
+                    template: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                        ref: z.ZodString;
+                    }, z.core.$strip>]>>;
+                }, z.core.$strip>]>;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"fill">;
+                locator: z.ZodType<Locator, unknown, z.core.$ZodTypeInternals<Locator, unknown>>;
+                value: z.ZodUnion<readonly [z.ZodObject<{
+                    ref: z.ZodString;
+                }, z.core.$strip>, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>, z.ZodObject<{
+                    template: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                        ref: z.ZodString;
+                    }, z.core.$strip>]>>;
+                }, z.core.$strip>, z.ZodNull]>;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"clear">;
+                locator: z.ZodType<Locator, unknown, z.core.$ZodTypeInternals<Locator, unknown>>;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"click">;
+                locator: z.ZodType<Locator, unknown, z.core.$ZodTypeInternals<Locator, unknown>>;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"dblclick">;
+                locator: z.ZodType<Locator, unknown, z.core.$ZodTypeInternals<Locator, unknown>>;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"select">;
+                locator: z.ZodType<Locator, unknown, z.core.$ZodTypeInternals<Locator, unknown>>;
+                value: z.ZodUnion<readonly [z.ZodObject<{
+                    ref: z.ZodString;
+                }, z.core.$strip>, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>, z.ZodObject<{
+                    template: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                        ref: z.ZodString;
+                    }, z.core.$strip>]>>;
+                }, z.core.$strip>, z.ZodNull]>;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"check">;
+                locator: z.ZodType<Locator, unknown, z.core.$ZodTypeInternals<Locator, unknown>>;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"uncheck">;
+                locator: z.ZodType<Locator, unknown, z.core.$ZodTypeInternals<Locator, unknown>>;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"hover">;
+                locator: z.ZodType<Locator, unknown, z.core.$ZodTypeInternals<Locator, unknown>>;
+            }, z.core.$strip>, z.ZodObject<{
+                files: z.ZodArray<z.ZodString>;
+                kind: z.ZodLiteral<"upload">;
+                locator: z.ZodType<Locator, unknown, z.core.$ZodTypeInternals<Locator, unknown>>;
+            }, z.core.$strip>, z.ZodObject<{
+                key: z.ZodString;
+                kind: z.ZodLiteral<"press">;
+                locator: z.ZodOptional<z.ZodType<Locator, unknown, z.core.$ZodTypeInternals<Locator, unknown>>>;
+            }, z.core.$strip>], "kind">;
+            expect: z.ZodDefault<z.ZodArray<z.ZodType<Predicate, unknown, z.core.$ZodTypeInternals<Predicate, unknown>>>>;
+        }, z.core.$strip>>>;
+        stub: z.ZodDefault<z.ZodBoolean>;
+        world: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            as: z.ZodString;
+            entity: z.ZodString;
+            set: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+                ref: z.ZodString;
+            }, z.core.$strip>, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>, z.ZodObject<{
+                template: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                    ref: z.ZodString;
+                }, z.core.$strip>]>>;
+            }, z.core.$strip>, z.ZodNull]>>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    valueSpaces: z.ZodArray<z.ZodObject<{
+        constraints: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"string">;
+            maxLength: z.ZodOptional<z.ZodNumber>;
+            minLength: z.ZodOptional<z.ZodNumber>;
+            pattern: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"number">;
+            max: z.ZodOptional<z.ZodNumber>;
+            min: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"datetime">;
+            maxOffsetDays: z.ZodNumber;
+            minOffsetDays: z.ZodNumber;
+        }, z.core.$strip>], "kind">>;
+        generator: z.ZodEnum<{
+            "company.name": "company.name";
+            "date.iso": "date.iso";
+            "internet.email": "internet.email";
+            "internet.url": "internet.url";
+            "person.fullName": "person.fullName";
+            "lorem.slug": "lorem.slug";
+            "lorem.word": "lorem.word";
+        }>;
+        name: z.ZodString;
+        type: z.ZodEnum<{
+            string: "string";
+            number: "number";
+            boolean: "boolean";
+        }>;
+        values: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type Lockfile = z.infer<typeof lockfileSchema>;
+declare const sessionSchema: z.ZodObject<{
+    cookies: z.ZodArray<z.ZodObject<{
+        domain: z.ZodString;
+        expires: z.ZodNumber;
+        httpOnly: z.ZodBoolean;
+        name: z.ZodString;
+        path: z.ZodString;
+        sameSite: z.ZodEnum<{
+            Strict: "Strict";
+            Lax: "Lax";
+            None: "None";
+        }>;
+        secure: z.ZodBoolean;
+        value: z.ZodString;
+    }, z.core.$strip>>;
+    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    origins: z.ZodArray<z.ZodObject<{
+        localStorage: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            value: z.ZodString;
+        }, z.core.$strip>>;
+        origin: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type Session = z.infer<typeof sessionSchema>;
+
+declare const rowSchema: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>, z.ZodNull]>>;
+type Row = z.infer<typeof rowSchema>;
+declare const setupSpecSchema: z.ZodObject<{
+    as: z.ZodString;
+    entity: z.ZodString;
+    fields: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+        ref: z.ZodString;
+    }, z.core.$strip>, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>, z.ZodObject<{
+        template: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            ref: z.ZodString;
+        }, z.core.$strip>]>>;
+    }, z.core.$strip>, z.ZodNull]>>;
+}, z.core.$strip>;
+type SetupSpec = z.infer<typeof setupSpecSchema>;
+declare const setupRowSchema: z.ZodObject<{
+    as: z.ZodString;
+    row: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>, z.ZodNull]>>;
+    session: z.ZodOptional<z.ZodObject<{
+        cookies: z.ZodArray<z.ZodObject<{
+            domain: z.ZodString;
+            expires: z.ZodNumber;
+            httpOnly: z.ZodBoolean;
+            name: z.ZodString;
+            path: z.ZodString;
+            sameSite: z.ZodEnum<{
+                Strict: "Strict";
+                Lax: "Lax";
+                None: "None";
+            }>;
+            secure: z.ZodBoolean;
+            value: z.ZodString;
+        }, z.core.$strip>>;
+        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        origins: z.ZodArray<z.ZodObject<{
+            localStorage: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                value: z.ZodString;
+            }, z.core.$strip>>;
+            origin: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type SetupRow = z.infer<typeof setupRowSchema>;
+
+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";
+type CaptureKind = "created" | "updated";
+interface EntityDescriptor {
+    readonly entity: string;
+    readonly kind: EntityKind | CaptureKind;
+    readonly props: Record<string, SetValue>;
+}
+interface AbsenceDescriptor {
+    readonly entity: string;
+    readonly kind: "none";
+    readonly where: Record<string, SetValue>;
+}
+interface SingletonStateDescriptor {
+    readonly kind: "singletonState";
+    readonly singleton: string;
+    readonly value: SetValue;
+}
+type AnyDescriptor = EntityDescriptor | AbsenceDescriptor | SingletonStateDescriptor;
+interface FieldBind {
+    readonly descriptor: EntityDescriptor;
+    readonly field: string;
+    readonly kind: "field";
+}
+interface ParamBind {
+    readonly kind: "param";
+    readonly token: ParamToken;
+}
+type Bind = FieldBind | ParamBind;
+declare const bindingBrand: unique symbol;
+type Binding<T extends Primitive> = ValueRef & {
+    readonly __bind: Bind;
+    readonly [bindingBrand]: T;
+};
+type AnyBinding = Binding<Primitive>;
+interface Carrier<D extends AnyDescriptor> {
+    readonly __entity: D;
+}
+type EntityHandle<F extends Fields> = {
+    readonly [K in keyof F]: Binding<F[K]>;
+} & Carrier<EntityDescriptor>;
+type AbsenceHandle = Carrier<AbsenceDescriptor>;
+type GivenItem = Carrier<AnyDescriptor>;
+
+interface LeafPredicate {
+    readonly predicate: Predicate;
+    readonly wait: (budget: Budget) => LeafPredicate;
+}
+interface ConditionPredicate {
+    readonly __condition: true;
+    readonly predicate: Condition;
+    readonly wait: (budget: Budget) => ConditionPredicate;
+}
+type ConditionInput = ConditionPredicate;
+interface CapturePredicate<Out extends Fields> {
+    readonly predicate: Predicate;
+    readonly ref: EntityHandle<Out>;
+    readonly wait: (budget: Budget) => CapturePredicate<Out>;
+}
+type StateAssertion = Extract<Predicate, {
+    kind: "state";
+}>["assertion"];
+interface Capture {
+    readonly assertion: StateAssertion;
+    readonly descriptor: EntityDescriptor;
+}
+type PredicateInput = LeafPredicate | Predicate;
+declare function visible(locator: Locator): LeafPredicate;
+declare function disabled(locator: Locator): LeafPredicate;
+declare function enabled(locator: Locator): LeafPredicate;
+declare function focused(locator: Locator): LeafPredicate;
+declare function value(locator: Locator, binding: Binding<string> | string): LeafPredicate;
+declare function text(locator: Locator, binding: Binding<string> | string): LeafPredicate;
+declare function not(input: ConditionInput): ConditionPredicate;
+declare function not(input: PredicateInput): LeafPredicate;
+declare function and(...conditions: ReadonlyArray<ConditionInput>): ConditionPredicate;
+interface Countable {
+    readonly name: string;
+}
+interface CountCondition {
+    readonly is: (count: number) => ConditionPredicate;
+}
+declare function count(entity: Countable): CountCondition;
+type WhenClause = readonly [ConditionInput, PredicateInput];
+declare function when(...clauses: readonly WhenClause[]): LeafPredicate;
+declare function when(...clausesThenFallback: readonly [...WhenClause[], PredicateInput]): LeafPredicate;
+
+interface ValueSpacePartial<T extends Primitive> {
+    readonly __t: T | undefined;
+    readonly constraints: Constraints | undefined;
+    readonly generator: Generator;
+    readonly primitive: PrimitiveType;
+    readonly values: ReadonlyArray<T> | undefined;
+}
+type StringConstraintsArg = Omit<StringConstraints, "kind">;
+type NumberConstraintsArg = Required<Omit<NumberConstraints, "kind">>;
+interface DatetimeOptions {
+    readonly offsetDays: {
+        readonly max: number;
+        readonly min: number;
+    };
+}
+declare const v: {
+    boolean: () => ValueSpacePartial<boolean>;
+    companyName: (constraints?: StringConstraintsArg) => ValueSpacePartial<string>;
+    datetime: (options: DatetimeOptions) => ValueSpacePartial<string>;
+    email: (constraints?: StringConstraintsArg) => ValueSpacePartial<string>;
+    fullName: (constraints?: StringConstraintsArg) => ValueSpacePartial<string>;
+    id: (constraints?: StringConstraintsArg) => ValueSpacePartial<string>;
+    number: (constraints: NumberConstraintsArg) => ValueSpacePartial<number>;
+    oneOf: <T extends Primitive>(values: readonly [T, ...T[]]) => ValueSpacePartial<T>;
+    slug: (constraints?: StringConstraintsArg) => ValueSpacePartial<string>;
+    url: (constraints?: StringConstraintsArg) => ValueSpacePartial<string>;
+    word: (constraints?: StringConstraintsArg) => ValueSpacePartial<string>;
+};
+interface PropBuilder<T extends Primitive, Opt extends boolean = boolean> {
+    readonly __o: Opt | undefined;
+    readonly __t: T | undefined;
+    readonly spec: PropSpec;
+    readonly valueSpace: ValueSpacePartial<Primitive> | undefined;
+}
+type Mods = Partial<{
+    readonly consistency: ConsistencyClass;
+    readonly optional: boolean;
+    readonly stable: boolean;
+}>;
+type IsOptional = {
+    readonly optional: true;
+};
+type FieldOptions<T extends Primitive> = {
+    readonly value: ValueSpacePartial<T>;
+} & Mods;
+declare function field<T extends Primitive>(options: FieldOptions<T> & IsOptional): PropBuilder<T, true>;
+declare function field<T extends Primitive>(options: FieldOptions<T>): PropBuilder<T, false>;
+interface IdentityBuilder<T extends Primitive, K extends "natural" | "surrogate" = "natural" | "surrogate"> {
+    readonly idKind: K;
+    readonly prop: PropBuilder<T>;
+}
+declare function id(): IdentityBuilder<string, "surrogate">;
+declare function key<T extends Primitive>(options: FieldOptions<T>): IdentityBuilder<T, "natural">;
+interface FieldHandle<T extends Primitive> {
+    readonly __t: T | undefined;
+    readonly entity: string;
+    readonly field: string;
+    readonly primitive: PrimitiveType;
+    readonly valueSpaceName: string;
+}
+type Settable<T extends Primitive, K, OptK> = Binding<T> | T | (K extends OptK ? null : never);
+type Props<Out extends Fields, OptK extends PropertyKey> = Partial<{
+    [K in keyof Out]: Settable<Out[K], K, OptK>;
+}>;
+type UpdateProps<Out extends Fields, OptK extends PropertyKey> = Partial<{
+    [K in keyof Out]: Settable<Out[K], K, OptK> | Changed;
+}>;
+type Setters<In extends Fields, OptK extends PropertyKey> = Partial<{
+    [K in keyof In]: Settable<In[K], K, OptK>;
+}>;
+interface Selection<S extends Fields> {
+    readonly __s: S | undefined;
+    readonly entity: string;
+    readonly where: Record<string, WhereValue>;
+}
+interface WithinMatcher<T extends Primitive> {
+    readonly __t: T | undefined;
+    readonly field: string;
+    readonly kind: "within";
+    readonly selection: {
+        readonly entity: string;
+        readonly where: Record<string, WhereValue>;
+    };
+}
+type Criteria<S extends Fields> = Partial<{
+    [K in keyof S]: Binding<S[K]> | S[K] | WithinMatcher<S[K]>;
+}>;
+type WhereInput<Sel extends Fields, OptK extends PropertyKey> = Partial<{
+    [K in keyof Sel]: Settable<Sel[K], K, OptK> | WithinMatcher<Sel[K]>;
+}>;
+type FieldsOfType<S, T extends Primitive> = {
+    [K in keyof S]: S[K] extends T ? K : never;
+}[keyof S];
+declare function within<S extends Fields, T extends Primitive = Primitive>(selection: Selection<S>, sourceField: FieldsOfType<S, T>): WithinMatcher<T>;
+declare function changed(): Changed;
+interface EntityDef<In extends Fields = Fields, Out extends Fields = Fields, Sel extends Fields = Out, OptK extends PropertyKey = PropertyKey, Name extends string = string, Src extends Source = Source> {
+    readonly field: {
+        readonly [K in keyof Out]: FieldHandle<Out[K]>;
+    };
+    readonly name: Name;
+    readonly schema: EntitySchema;
+    readonly source: Src;
+    readonly valueSpaces: ReadonlyArray<ValueSpace>;
+    readonly created: (props: Props<Out, OptK>) => CapturePredicate<Out>;
+    readonly deleted: (where: WhereInput<Sel, OptK>) => LeafPredicate;
+    readonly maybe: (where: Setters<In, OptK>) => EntityHandle<Out>;
+    readonly none: (where: Setters<In, OptK>) => AbsenceHandle;
+    readonly of: (props: Setters<In, OptK>) => EntityHandle<Out>;
+    readonly only: (props: Setters<In, OptK>) => EntityHandle<Out>;
+    readonly updated: (where: WhereInput<Sel, OptK>, props: UpdateProps<Out, OptK>) => CapturePredicate<Out>;
+    readonly where: (criteria: Criteria<Sel>) => Selection<Out>;
+}
+type Handle<M extends EntityDef> = ReturnType<M["of"]>;
+interface EntityConfig<I, P, Src extends Source> {
+    readonly description: string;
+    readonly fields: P;
+    readonly identity: I;
+    readonly source: Src;
+}
+type IdentityRecord = Record<string, IdentityBuilder<Primitive>>;
+type PropRecord = Record<string, PropBuilder<Primitive>>;
+type FieldTypeOf<B> = B extends PropBuilder<infer T> ? T : never;
+type IdTypeOf<B> = B extends IdentityBuilder<infer T> ? T : never;
+type Flatten<T> = {
+    [K in keyof T]: T[K];
+};
+type AllIds<I> = {
+    [K in keyof I]: IdTypeOf<I[K]>;
+};
+type NaturalIds<I> = {
+    [K in keyof I as I[K] extends IdentityBuilder<Primitive, "natural"> ? K : never]: IdTypeOf<I[K]>;
+};
+type AllProps<P> = {
+    [K in keyof P]: FieldTypeOf<P[K]>;
+};
+type OutFields<I, P> = Flatten<AllIds<I> & AllProps<P>>;
+type InFields<I, P> = Flatten<NaturalIds<I> & AllProps<P>>;
+type MatchFields<I, P> = Flatten<AllIds<I> & AllProps<P>>;
+type OptionalKeys<P> = {
+    [K in keyof P]: P[K] extends PropBuilder<Primitive, true> ? K : never;
+}[keyof P];
+declare function entity<I extends IdentityRecord, P extends PropRecord, Name extends string, Src extends Source>(name: Name, definition: EntityConfig<I, P, Src>): EntityDef<InFields<I, P>, OutFields<I, P>, MatchFields<I, P>, OptionalKeys<P>, Name, Src>;
+
+type SingletonConfig<T extends Primitive$1, Src extends Source> = {
+    readonly default: T;
+    readonly description: string;
+    readonly source: Src;
+    readonly value: ValueSpacePartial<T>;
+} & Partial<{
+    readonly consistency: ConsistencyClass;
+}>;
+type SingletonValue<T extends Primitive$1> = T | Binding<T>;
+interface SingletonStateHandle<T extends Primitive$1> extends Carrier<SingletonStateDescriptor> {
+    readonly is: (value: SingletonValue<T>) => ConditionPredicate;
+}
+interface SingletonDef<Name extends string, T extends Primitive$1 = Primitive$1, Src extends Source = Source> {
+    readonly name: Name;
+    readonly schema: SingletonSchema;
+    readonly source: Src;
+    readonly value: FieldHandle<T>;
+    readonly valueSpaces: ReadonlyArray<ValueSpace>;
+    readonly is: (value: SingletonValue<T>) => ConditionPredicate;
+    readonly of: (value: SingletonValue<T>) => SingletonStateHandle<T>;
+}
+declare function singleton<Name extends string, T extends Primitive$1, Src extends Source>(name: Name, config: SingletonConfig<T, Src>): SingletonDef<Name, T, Src>;
+
+interface EngineError {
+    readonly message: string;
+}
+interface EntityMeta {
+    readonly name: string;
+    readonly schema: EntitySchema;
+    readonly valueSpaces: ReadonlyArray<ValueSpace>;
+}
+interface SingletonMeta {
+    readonly name: string;
+    readonly schema: SingletonSchema;
+    readonly source: Source;
+    readonly valueSpaces: ReadonlyArray<ValueSpace>;
+}
+type EntityList = ReadonlyArray<EntityMeta>;
+type SingletonList = ReadonlyArray<SingletonMeta>;
+type Cell = Primitive$1 | null;
+interface EntityImpl<In extends RowFields, Out extends RowFields> {
+    readonly read: (ctx: {
+        readonly runId: string;
+    }) => Promise<ReadonlyArray<Out>>;
+    readonly seed: (ctx: {
+        readonly fields: In;
+        readonly runId: string;
+    }) => Promise<{
+        readonly row: Out;
+        readonly session: Session | undefined;
+    }>;
+}
+type RowFields = Record<string, Cell>;
+type NullifyOptional<F, Opt extends PropertyKey> = {
+    [K in keyof F]: K extends Opt ? F[K] | null : F[K];
+};
+interface SingletonImpl<T extends Primitive$1> {
+    readonly read: (ctx: {
+        readonly runId: string;
+    }) => Promise<T | null>;
+    readonly seed: (ctx: {
+        readonly runId: string;
+        readonly value: T;
+    }) => Promise<void>;
+}
+type Teardown = (runId: string) => Promise<void>;
+interface DeclSource {
+    readonly entities: EntityList;
+    readonly singletons: SingletonList;
+}
+type EntityImplFor<D> = D extends EntityDef<infer In, infer Out, infer _Sel, infer Opt, infer _Name, infer _Src> ? EntityImpl<NullifyOptional<In, Opt>, NullifyOptional<Out, Opt>> : never;
+type SingletonImplFor<D> = D extends SingletonDef<infer _N, infer T, infer _S> ? SingletonImpl<T> : never;
+interface EngineImpls<R extends DeclSource, Src extends Source> {
+    readonly entities: {
+        readonly [D in Extract<R["entities"][number], {
+            readonly source: Src;
+        }> as D["name"]]: EntityImplFor<D>;
+    };
+    readonly singletons: {
+        readonly [D in Extract<R["singletons"][number], {
+            readonly source: Src;
+        }> as D["name"]]: SingletonImplFor<D>;
+    };
+}
+type NameOf<H> = H extends EntityDef<infer _In, infer _Out, infer _Sel, infer _Opt, infer Name> ? Name : never;
+interface DuplicateEntityName<Name extends string> {
+    readonly __duplicateEntityName: `entity name "${Name}" is declared more than once`;
+}
+type UniqueNames<Entities extends EntityList, Seen extends string = never> = Entities extends readonly [infer Head, ...infer Tail] ? Tail extends EntityList ? readonly [
+    NameOf<Head> extends Seen ? DuplicateEntityName<NameOf<Head>> : Head,
+    ...UniqueNames<Tail, Seen | NameOf<Head>>
+] : Entities : Entities;
+interface EngineRead {
+    readonly entities: Record<string, Row[]>;
+    readonly singletons: Record<string, Cell>;
+}
+interface EngineSeedRequest {
+    readonly entities: ReadonlyArray<SetupSpec>;
+    readonly singletons: Record<string, Cell>;
+}
+interface EngineReadRequest {
+    readonly entities: ReadonlyArray<string>;
+    readonly singletons: ReadonlyArray<string>;
+}
+interface Engine {
+    readonly read: (request: EngineReadRequest, runId: string) => ResultAsync<EngineRead, EngineError>;
+    readonly seed: (request: EngineSeedRequest, runId: string) => ResultAsync<SetupRow[], EngineError>;
+    readonly teardown: (runId: string) => ResultAsync<void, EngineError>;
+}
+declare function createEngine<R extends DeclSource>(ripplo: R, impls: EngineImpls<R, "backend">, teardown: Teardown): Engine;
+
+export { key as $, type AnyBinding as A, type Binding as B, type Capture as C, type DeclSource as D, type Engine as E, type FieldHandle as F, type GivenItem as G, type Handle as H, type SingletonValue as I, type WithinMatcher as J, and as K, type Locator as L, changed as M, count as N, createEngine as O, type PredicateInput as P, disabled as Q, type Row as R, type Step as S, type Test as T, type UniqueNames as U, enabled as V, type WhenClause as W, entity as X, field as Y, focused as Z, id as _, type EntityList as a, not as a0, singleton as a1, text as a2, v as a3, value as a4, visible as a5, when as a6, within as a7, type SingletonList as b, type Lockfile as c, type BrowserSingleton as d, type LeafPredicate as e, type Primitive as f, type Primitive$1 as g, type SingletonDef as h, type AbsenceHandle as i, CLIENT_MOUNT_KEY as j, CLIENT_SEED_KEY as k, type ConditionInput as l, type ConditionPredicate as m, type CountCondition as n, type DuplicateEntityName as o, type EngineError as p, type EngineImpls as q, type EngineRead as r, type EntityDef as s, type EntityHandle as t, type EntityImpl as u, type FieldOptions as v, type Fields as w, type Selection as x, type SingletonConfig as y, type SingletonImpl as z };