@aventara/core 1.0.0-rc.0 → 1.0.0-rc.2

package/dist/operations/operation-arguments.d.ts

@@ -1,28 +1,28 @@
-import type { ProjectionScope, RelationMutationDirective, ScalarFilterOperator, ScalarMutationDirective, WriteScope } from "../contracts/capability.js";
-import type { Contract } from "../contracts/contract.js";
-import type { ProjectionScopes, ScalarField } from "../contracts/field.js";
-import type { FieldAtom, ScalarForms, ScalarValueType } from "../contracts/scalar-value-type.js";
-import type { JsonValue } from "../runtime/json-value.js";
-import type { TransactionReference, TransactionSlotShape } from "../transactions/transaction-reference.js";
-import type { OperationIdentity } from "./operation-identity.js";
+import type { AvProjectionScope, AvRelationMutationDirective, AvScalarFilterOperator, AvScalarMutationDirective, AvWriteScope, ScalarFilterMode } from "../contracts/capability.js";
+import type { AvContract } from "../contracts/contract.js";
+import type { AvProjectionScopes, AvScalarField } from "../contracts/field.js";
+import type { AvScalarValueType, FieldAtom, ScalarForms } from "../contracts/scalar-value-type.js";
+import type { AvJsonValue } from "../runtime/json-value.js";
+import type { AvTransactionReference, TransactionSlotShape } from "../transactions/transaction-reference.js";
+import type { AvOperationIdentity } from "./operation-identity.js";
 /** The Resource names of Contract `C`. */
-export type ResourceKey<C extends Contract> = Extract<keyof C["resources"], string>;
+export type AvResourceKey<C extends AvContract> = Extract<keyof C["resources"], string>;
 /** The field names of Resource `K` in Contract `C`. */
-export type FieldKey<C extends Contract, K extends ResourceKey<C>> = Extract<keyof C["resources"][K]["fields"], string>;
-type FieldAt<C extends Contract, K extends ResourceKey<C>, F extends FieldKey<C, K>> = C["resources"][K]["fields"][F];
-type ScalarFieldAt<C extends Contract, K extends ResourceKey<C>, F extends FieldKey<C, K>> = Extract<FieldAt<C, K, F>, {
+export type AvFieldKey<C extends AvContract, K extends AvResourceKey<C>> = Extract<keyof C["resources"][K]["fields"], string>;
+type FieldAt<C extends AvContract, K extends AvResourceKey<C>, F extends AvFieldKey<C, K>> = C["resources"][K]["fields"][F];
+type ScalarFieldAt<C extends AvContract, K extends AvResourceKey<C>, F extends AvFieldKey<C, K>> = Extract<FieldAt<C, K, F>, {
     readonly kind: "scalar";
 }>;
-type RelationFieldAt<C extends Contract, K extends ResourceKey<C>, F extends FieldKey<C, K>> = Extract<FieldAt<C, K, F>, {
+type RelationFieldAt<C extends AvContract, K extends AvResourceKey<C>, F extends AvFieldKey<C, K>> = Extract<FieldAt<C, K, F>, {
     readonly kind: "relation";
 }>;
-type ScalarFieldKeyOf<C extends Contract, K extends ResourceKey<C>> = {
-    [F in FieldKey<C, K>]: ScalarFieldAt<C, K, F> extends never ? never : F;
-}[FieldKey<C, K>];
-type RelationFieldKeyOf<C extends Contract, K extends ResourceKey<C>> = {
-    [F in FieldKey<C, K>]: RelationFieldAt<C, K, F> extends never ? never : F;
-}[FieldKey<C, K>];
-type CapabilitiesOf<C extends Contract, K extends ResourceKey<C>, F extends FieldKey<C, K>> = FieldAt<C, K, F> extends {
+type ScalarFieldKeyOf<C extends AvContract, K extends AvResourceKey<C>> = {
+    [F in AvFieldKey<C, K>]: ScalarFieldAt<C, K, F> extends never ? never : F;
+}[AvFieldKey<C, K>];
+type RelationFieldKeyOf<C extends AvContract, K extends AvResourceKey<C>> = {
+    [F in AvFieldKey<C, K>]: RelationFieldAt<C, K, F> extends never ? never : F;
+}[AvFieldKey<C, K>];
+type CapabilitiesOf<C extends AvContract, K extends AvResourceKey<C>, F extends AvFieldKey<C, K>> = FieldAt<C, K, F> extends {
     readonly capabilities: infer Capabilities;
 } ? Capabilities : never;
 /** The projection position read when no position applies: `"record"`. */
@@ -30,15 +30,15 @@ type UnrestrictedProjection = "record";
 /** The write position read when no position applies, and the one nested writes use: `"nested"`. */
 type UnrestrictedWrite = "nested";
 /** Whether a capability member's answer holds at one argument scope. */
-type HoldsAtScope<Value, Scope extends ProjectionScope | WriteScope> = Value extends {
+type HoldsAtScope<Value, Scope extends AvProjectionScope | AvWriteScope> = Value extends {
     readonly scopes: readonly (infer Stated)[];
-} ? Scope extends Stated ? true : false : Value extends ProjectionScopes ? Scope extends Value[number] ? true : false : true;
+} ? Scope extends Stated ? true : false : Value extends AvProjectionScopes ? Scope extends Value[number] ? true : false : true;
 /** The tokens a capability member advertises, in any argument position. */
 type AdvertisedTokens<Value> = Value extends {
-    readonly scopes: readonly WriteScope[];
+    readonly scopes: readonly AvWriteScope[];
     readonly directives: readonly (infer Directive)[];
 } ? Directive : Value extends {
-    readonly scopes: readonly ProjectionScope[];
+    readonly scopes: readonly AvProjectionScope[];
     readonly reducers: readonly (infer Reducer)[];
 } ? Reducer : Value extends readonly (infer Token)[] ? Token : never;
 /**
@@ -47,48 +47,48 @@ type AdvertisedTokens<Value> = Value extends {
  * Presence first, scope second: an absent or `false` member is unavailable
  * everywhere, and only a present one is asked where it holds.
  */
-type HasCapability<C extends Contract, K extends ResourceKey<C>, F extends FieldKey<C, K>, Capability extends PropertyKey, Scope extends ProjectionScope | WriteScope> = Capability extends keyof CapabilitiesOf<C, K, F> ? CapabilitiesOf<C, K, F>[Capability] extends false | undefined ? false : HoldsAtScope<CapabilitiesOf<C, K, F>[Capability], Scope> : false;
+type HasCapability<C extends AvContract, K extends AvResourceKey<C>, F extends AvFieldKey<C, K>, Capability extends PropertyKey, Scope extends AvProjectionScope | AvWriteScope> = Capability extends keyof CapabilitiesOf<C, K, F> ? CapabilitiesOf<C, K, F>[Capability] extends false | undefined ? false : HoldsAtScope<CapabilitiesOf<C, K, F>[Capability], Scope> : false;
 /**
  * The tokens a field advertises for one capability **at one argument scope** —
  * `never` where the member does not hold at that scope, so a token list that
  * holds only in the unrestricted position offers no token in a bulk one.
  */
-type CapabilityTokens<C extends Contract, K extends ResourceKey<C>, F extends FieldKey<C, K>, Capability extends PropertyKey, Scope extends ProjectionScope | WriteScope> = Capability extends keyof CapabilitiesOf<C, K, F> ? HoldsAtScope<CapabilitiesOf<C, K, F>[Capability], Scope> extends true ? AdvertisedTokens<CapabilitiesOf<C, K, F>[Capability]> : never : never;
-type HasCapabilityToken<C extends Contract, K extends ResourceKey<C>, F extends FieldKey<C, K>, Capability extends PropertyKey, Scope extends ProjectionScope | WriteScope, Token> = Token extends CapabilityTokens<C, K, F, Capability, Scope> ? true : false;
-type RelationTarget<C extends Contract, K extends ResourceKey<C>, F extends RelationFieldKeyOf<C, K>> = Extract<RelationFieldAt<C, K, F>["target"], ResourceKey<C>>;
-type RelationCardinality<C extends Contract, K extends ResourceKey<C>, F extends RelationFieldKeyOf<C, K>> = RelationFieldAt<C, K, F>["cardinality"];
-type RelationNullable<C extends Contract, K extends ResourceKey<C>, F extends RelationFieldKeyOf<C, K>> = RelationFieldAt<C, K, F>["nullable"];
-type KeysWithCapability<C extends Contract, K extends ResourceKey<C>, Keys extends FieldKey<C, K>, Capability extends PropertyKey, Scope extends ProjectionScope | WriteScope> = {
+type CapabilityTokens<C extends AvContract, K extends AvResourceKey<C>, F extends AvFieldKey<C, K>, Capability extends PropertyKey, Scope extends AvProjectionScope | AvWriteScope> = Capability extends keyof CapabilitiesOf<C, K, F> ? HoldsAtScope<CapabilitiesOf<C, K, F>[Capability], Scope> extends true ? AdvertisedTokens<CapabilitiesOf<C, K, F>[Capability]> : never : never;
+type HasCapabilityToken<C extends AvContract, K extends AvResourceKey<C>, F extends AvFieldKey<C, K>, Capability extends PropertyKey, Scope extends AvProjectionScope | AvWriteScope, Token> = Token extends CapabilityTokens<C, K, F, Capability, Scope> ? true : false;
+type RelationTarget<C extends AvContract, K extends AvResourceKey<C>, F extends RelationFieldKeyOf<C, K>> = Extract<RelationFieldAt<C, K, F>["target"], AvResourceKey<C>>;
+type RelationCardinality<C extends AvContract, K extends AvResourceKey<C>, F extends RelationFieldKeyOf<C, K>> = RelationFieldAt<C, K, F>["cardinality"];
+type RelationNullable<C extends AvContract, K extends AvResourceKey<C>, F extends RelationFieldKeyOf<C, K>> = RelationFieldAt<C, K, F>["nullable"];
+type KeysWithCapability<C extends AvContract, K extends AvResourceKey<C>, Keys extends AvFieldKey<C, K>, Capability extends PropertyKey, Scope extends AvProjectionScope | AvWriteScope> = {
     [F in Keys]: HasCapability<C, K, F, Capability, Scope> extends true ? F : never;
 }[Keys];
 /**
  * The scalar-form map used when no side of a boundary is named: every built-in
- * value is `unknown`. Pass `ApplicationScalarForms` or `WireScalarForms` to type
+ * value is `unknown`. Pass `AvApplicationScalarForms` or `AvWireScalarForms` to type
  * values. Enum values are their member union under every map.
  */
 type UnstatedForms = ScalarForms;
 /** Field `F`'s value under `Forms`, the same as in results. */
-type ScalarValueAt<C extends Contract, K extends ResourceKey<C>, F extends FieldKey<C, K>, Forms extends ScalarForms> = ScalarFieldAt<C, K, F> extends infer Field extends ScalarField<C> ? ScalarValueType<C, Field, Forms> : never;
+type ScalarValueAt<C extends AvContract, K extends AvResourceKey<C>, F extends AvFieldKey<C, K>, Forms extends ScalarForms> = ScalarFieldAt<C, K, F> extends infer Field extends AvScalarField<C> ? AvScalarValueType<C, Field, Forms> : never;
 /** One entry of field `F`'s value — the whole value when `F` is not a list. */
-type ScalarAtomAt<C extends Contract, K extends ResourceKey<C>, F extends FieldKey<C, K>, Forms extends ScalarForms> = FieldAtom<C, ScalarFieldAt<C, K, F>, Forms>;
+type ScalarAtomAt<C extends AvContract, K extends AvResourceKey<C>, F extends AvFieldKey<C, K>, Forms extends ScalarForms> = FieldAtom<C, ScalarFieldAt<C, K, F>, Forms>;
 /**
  * A `$ref` to a source whose value fits slot shape `Shape` of field `F`, typed in
  * `ReferenceForms` — the forms a source's final data is read in. `never` when
  * `ReferenceForms` is `never`: no position takes one outside a transaction plan.
  */
-type SlotReference<C extends Contract, K extends ResourceKey<C>, F extends FieldKey<C, K>, ReferenceForms extends ScalarForms, Shape extends TransactionSlotShape> = [ReferenceForms] extends [never] ? never : TransactionReference<Shape extends "value" ? ScalarValueAt<C, K, F, ReferenceForms> : Shape extends "nonNullValue" ? Exclude<ScalarValueAt<C, K, F, ReferenceForms>, null> : Shape extends "entry" ? ScalarAtomAt<C, K, F, ReferenceForms> : readonly ScalarAtomAt<C, K, F, ReferenceForms>[]>;
+type SlotReference<C extends AvContract, K extends AvResourceKey<C>, F extends AvFieldKey<C, K>, ReferenceForms extends ScalarForms, Shape extends TransactionSlotShape> = [ReferenceForms] extends [never] ? never : AvTransactionReference<Shape extends "value" ? ScalarValueAt<C, K, F, ReferenceForms> : Shape extends "nonNullValue" ? Exclude<ScalarValueAt<C, K, F, ReferenceForms>, null> : Shape extends "entry" ? ScalarAtomAt<C, K, F, ReferenceForms> : readonly ScalarAtomAt<C, K, F, ReferenceForms>[]>;
 /**
  * A JSON object. Positions that accept both a value and an object of operators
  * read a JSON object as the operators, so their value forms leave it out.
  */
-type JsonObject = Extract<JsonValue, {
-    readonly [key: string]: JsonValue;
+type JsonObject = Extract<AvJsonValue, {
+    readonly [key: string]: AvJsonValue | undefined;
 }>;
 /**
  * The field-independent shape of one scalar filter: any value, or an object of the
  * operator vocabulary.
  */
-export type ScalarFilterInput = unknown | Readonly<Partial<Record<ScalarFilterOperator, unknown>>>;
+export type ScalarFilterInput = unknown | Readonly<Partial<Record<AvScalarFilterOperator, unknown>>>;
 /**
  * A scalar filter's shorthand equality value: the field's value, minus a JSON
  * object.
@@ -98,64 +98,121 @@ type ScalarFilterShorthand<Value> = Exclude<Value, JsonObject>;
  * The `$ref` each slot shape of field `F` takes, by shape: every member `never`
  * outside a transaction plan.
  */
-type FieldSlotReferences<C extends Contract, K extends ResourceKey<C>, F extends FieldKey<C, K>, ReferenceForms extends ScalarForms> = {
+type FieldSlotReferences<C extends AvContract, K extends AvResourceKey<C>, F extends AvFieldKey<C, K>, ReferenceForms extends ScalarForms> = {
     readonly [Shape in TransactionSlotShape]: SlotReference<C, K, F, ReferenceForms, Shape>;
 };
 /**
- * A scalar filter's operator object: a comparison operand is the field's whole
- * value; `in`, `notIn`, `hasEvery` and `hasSome` take a list of entries; `has`
- * one entry; a `json` field's `string*`/`array*` operand a {@link JsonValue};
- * `not` a value or a nested operator object. `mode`, `isEmpty` and `path` are
- * passed to the adapter as given. Only `equals`, `not` and the `json` `array*`
- * operands take `null`. Inside a transaction plan every operand but `mode`,
- * `isEmpty`, `path` and the `json` ones may be a `$ref` of the shape it holds
- * (`References`).
- */
-type ScalarFilterOperators<Value, Atom, Json, References extends Readonly<Record<TransactionSlotShape, unknown>>> = Readonly<{
-    equals?: Value | References["value"];
-    not?: Exclude<Value, JsonObject> | References["value"] | ScalarFilterOperators<Value, Atom, Json, References>;
-    in?: readonly Atom[] | References["entries"];
-    notIn?: readonly Atom[] | References["entries"];
-    lt?: Exclude<Value, null> | References["nonNullValue"];
-    lte?: Exclude<Value, null> | References["nonNullValue"];
-    gt?: Exclude<Value, null> | References["nonNullValue"];
-    gte?: Exclude<Value, null> | References["nonNullValue"];
-    contains?: Exclude<Value, null> | References["nonNullValue"];
-    startsWith?: Exclude<Value, null> | References["nonNullValue"];
-    endsWith?: Exclude<Value, null> | References["nonNullValue"];
-    mode?: unknown;
-    has?: Atom | References["entry"];
-    hasEvery?: readonly Atom[] | References["entries"];
-    hasSome?: readonly Atom[] | References["entries"];
-    isEmpty?: unknown;
-    path?: unknown;
-    stringContains?: Exclude<Json, null>;
-    stringStartsWith?: Exclude<Json, null>;
-    stringEndsWith?: Exclude<Json, null>;
-    arrayContains?: Json;
-    arrayStartsWith?: Json;
-    arrayEndsWith?: Json;
-}>;
+ * Every scalar filter operator's operand: a comparison operand is the field's
+ * whole value; `in`, `notIn`, `hasEvery` and `hasSome` take a list of entries;
+ * `has` one entry; a `json` field's `string*`/`array*` operand a
+ * {@link AvJsonValue}; `not` a nested operator object of the same operators, or
+ * a value where `equals` is one of them. `mode` takes one of the modes the
+ * field offers at this level (`LevelMode`), `isEmpty` a boolean, `path` a list of
+ * JSON keys and a `json` field's `string*` operand a string: none of these is a
+ * value of the field. Only `equals`, `not` and the `json` `array*` operands take
+ * `null`. Inside a transaction plan every
+ * operand but `mode`, `isEmpty`, `path` and the `json` ones may be a `$ref` of
+ * the shape it holds (`References`).
+ */
+type ScalarFilterOperands<Value, Atom, Json, References extends Readonly<Record<TransactionSlotShape, unknown>>, Operator extends AvScalarFilterOperator, Mode extends ScalarFilterMode, PathMode extends ScalarFilterMode, LevelMode extends ScalarFilterMode> = {
+    equals: Value | References["value"];
+    not: NegatedValue<Value, References, Operator> | ScalarFilterOperators<Value, Atom, Json, References, Operator, Mode, PathMode>;
+    in: readonly Atom[] | References["entries"];
+    notIn: readonly Atom[] | References["entries"];
+    lt: Exclude<Value, null> | References["nonNullValue"];
+    lte: Exclude<Value, null> | References["nonNullValue"];
+    gt: Exclude<Value, null> | References["nonNullValue"];
+    gte: Exclude<Value, null> | References["nonNullValue"];
+    contains: Exclude<Value, null> | References["nonNullValue"];
+    startsWith: Exclude<Value, null> | References["nonNullValue"];
+    endsWith: Exclude<Value, null> | References["nonNullValue"];
+    mode: LevelMode;
+    has: Atom | References["entry"];
+    hasEvery: readonly Atom[] | References["entries"];
+    hasSome: readonly Atom[] | References["entries"];
+    isEmpty: boolean;
+    path: readonly string[];
+    stringContains: string;
+    stringStartsWith: string;
+    stringEndsWith: string;
+    arrayContains: Json;
+    arrayStartsWith: Json;
+    arrayEndsWith: Json;
+};
 /**
- * One scalar field's filter under `Forms`: a shorthand value or an operator object.
- * Inside a transaction plan the value and every operand that holds a field value may
- * be a `$ref` (see {@link TransactionSlotShape}): equality to a source nullable only
- * where the field is, a comparison to a non-null source, `in` and the list operators
- * to a list source, `has` to one entry.
+ * A scalar filter's operator object: the operators `Operator` names — the ones
+ * the field's `filter` member advertises — each with its operand. Where `path`
+ * is one of them, an object that names it takes `PathMode`, and one that does
+ * not takes `Mode`. An object that names `mode` or `path` names a comparing
+ * operator beside it.
  */
-type ScalarFilterFor<C extends Contract, K extends ResourceKey<C>, F extends FieldKey<C, K>, Forms extends ScalarForms, ReferenceForms extends ScalarForms> = ScalarFilterShorthand<ScalarValueAt<C, K, F, Forms>> | SlotReference<C, K, F, ReferenceForms, "value"> | ScalarFilterOperators<ScalarValueAt<C, K, F, Forms>, ScalarAtomAt<C, K, F, Forms>, ScalarFieldAt<C, K, F>["type"] extends {
+type ScalarFilterOperators<Value, Atom, Json, References extends Readonly<Record<TransactionSlotShape, unknown>>, Operator extends AvScalarFilterOperator, Mode extends ScalarFilterMode, PathMode extends ScalarFilterMode> = ScalarFilterLevel<ReadonlyOperands<Value, Atom, Json, References, Operator, Mode, PathMode, Mode>, Operator, Mode, NegatedValue<Value, References, Operator>, "path" extends Operator ? {
+    readonly path?: never;
+} : unknown> | ("path" extends Operator ? ScalarFilterOperatorsAtPath<ReadonlyOperands<Value, Atom, Json, References, Operator, Mode, PathMode, PathMode>, Operator, PathMode, NegatedValue<Value, References, Operator>> : never);
+/** {@link ScalarFilterOperands}, each operand read-only. */
+type ReadonlyOperands<Value, Atom, Json, References extends Readonly<Record<TransactionSlotShape, unknown>>, Operator extends AvScalarFilterOperator, Mode extends ScalarFilterMode, PathMode extends ScalarFilterMode, LevelMode extends ScalarFilterMode> = Readonly<ScalarFilterOperands<Value, Atom, Json, References, Operator, Mode, PathMode, LevelMode>>;
+/** The operators of a level that compare something: all but `mode` and `path`. */
+type ComparingOperator<Operator extends AvScalarFilterOperator> = Exclude<Operator, "mode" | "path">;
+/** `not`'s value arm: equality negated, offered only where `equals` is. */
+type NegatedValue<Value, References extends Readonly<Record<TransactionSlotShape, unknown>>, Operator extends AvScalarFilterOperator> = "equals" extends Operator ? Exclude<Value, JsonObject> | References["value"] : never;
+/** A level's comparing operators, each optional. */
+type ComparingOperators<Operands extends Readonly<Record<AvScalarFilterOperator, unknown>>, Operator extends AvScalarFilterOperator> = Partial<Pick<Operands, ComparingOperator<Operator>>>;
+/**
+ * A level's comparing operators with at least one of them present; `not` is
+ * one only with a value (an object under `not` compares at its own level).
+ */
+type SomeComparingOperator<Operands extends Readonly<Record<AvScalarFilterOperator, unknown>>, Operator extends AvScalarFilterOperator, Negated> = ({
+    [Key in Exclude<ComparingOperator<Operator>, "not">]-?: Pick<Operands, Key>;
+}[Exclude<ComparingOperator<Operator>, "not">] & ComparingOperators<Operands, Operator>) | ("not" extends Operator ? {
+    readonly not: Negated;
+} & Partial<Pick<Operands, Exclude<ComparingOperator<Operator>, "not">>> : never);
+/**
+ * One operator object that names no `path`: without `mode`, any of its comparing
+ * operators; with `mode` (one of `Mode`), at least one of them.
+ */
+type ScalarFilterLevel<Operands extends Readonly<Record<AvScalarFilterOperator, unknown>>, Operator extends AvScalarFilterOperator, Mode extends ScalarFilterMode, Negated, PathKey> = ("mode" extends Operator ? (ComparingOperators<Operands, Operator> & {
+    readonly mode?: never;
+}) | (SomeComparingOperator<Operands, Operator, Negated> & {
+    readonly mode?: Mode;
+}) : ComparingOperators<Operands, Operator>) & PathKey;
+/** An operator object that names `path`: `PathMode`, and a comparing operator. */
+type ScalarFilterOperatorsAtPath<Operands extends Readonly<Record<AvScalarFilterOperator, unknown>>, Operator extends AvScalarFilterOperator, PathMode extends ScalarFilterMode, Negated> = SomeComparingOperator<Operands, Operator, Negated> & {
+    readonly path: readonly string[];
+} & ("mode" extends Operator ? {
+    readonly mode?: PathMode;
+} : unknown);
+/** The filter operators field `F` advertises: `never` when it advertises none. */
+type ScalarFilterOperatorAt<C extends AvContract, K extends AvResourceKey<C>, F extends AvFieldKey<C, K>> = Extract<CapabilityTokens<C, K, F, "filter", UnrestrictedProjection>, AvScalarFilterOperator>;
+/** The `mode` operands field `F` takes in an operator object without `path`. */
+type ScalarFilterModeAt<C extends AvContract, K extends AvResourceKey<C>, F extends AvFieldKey<C, K>> = "default" | Extract<CapabilityTokens<C, K, F, "filterModes", UnrestrictedProjection>, ScalarFilterMode>;
+/** The `mode` operands field `F` takes in an operator object that names `path`. */
+type ScalarPathFilterModeAt<C extends AvContract, K extends AvResourceKey<C>, F extends AvFieldKey<C, K>> = "pathFilterModes" extends keyof CapabilitiesOf<C, K, F> ? "default" | Extract<CapabilityTokens<C, K, F, "pathFilterModes", UnrestrictedProjection>, ScalarFilterMode> : ScalarFilterModeAt<C, K, F>;
+/**
+ * One scalar field's filter under `Forms`: a shorthand value where the field
+ * advertises `equals`, or an object of the operators it advertises. Inside a
+ * transaction plan the value and every operand that holds a field value may be a
+ * `$ref` (see {@link TransactionSlotShape}): equality to a source nullable only
+ * where the field is, a comparison to a non-null source, `in` and the list
+ * operators to a list source, `has` to one entry.
+ */
+type ScalarFilterFor<C extends AvContract, K extends AvResourceKey<C>, F extends AvFieldKey<C, K>, Forms extends ScalarForms, ReferenceForms extends ScalarForms> = ("equals" extends ScalarFilterOperatorAt<C, K, F> ? ScalarFilterShorthand<ScalarValueAt<C, K, F, Forms>> | SlotReference<C, K, F, ReferenceForms, "value"> : never) | ScalarFilterOperators<ScalarValueAt<C, K, F, Forms>, ScalarAtomAt<C, K, F, Forms>, ScalarFieldAt<C, K, F>["type"] extends {
     readonly scalar: "json";
-} ? JsonValue : ScalarValueAt<C, K, F, Forms>, FieldSlotReferences<C, K, F, ReferenceForms>>;
-type ScalarFilterableKey<C extends Contract, K extends ResourceKey<C>> = KeysWithCapability<C, K, ScalarFieldKeyOf<C, K>, "filter", UnrestrictedProjection>;
-type RelationParentFilterKey<C extends Contract, K extends ResourceKey<C>> = {
+} ? AvJsonValue : ScalarValueAt<C, K, F, Forms>, FieldSlotReferences<C, K, F, ReferenceForms>, ScalarFilterOperatorAt<C, K, F>, ScalarFilterModeAt<C, K, F>, ScalarPathFilterModeAt<C, K, F>>;
+/** The scalar fields of `K` a `where` can name: those advertising an operator. */
+type ScalarFilterableKey<C extends AvContract, K extends AvResourceKey<C>> = {
+    [F in ScalarFieldKeyOf<C, K>]: [ScalarFilterOperatorAt<C, K, F>] extends [
+        never
+    ] ? never : F;
+}[ScalarFieldKeyOf<C, K>];
+type RelationParentFilterKey<C extends AvContract, K extends AvResourceKey<C>> = {
     [F in RelationFieldKeyOf<C, K>]: RelationCardinality<C, K, F> extends "one" ? HasCapabilityToken<C, K, F, "filter", UnrestrictedProjection, "match"> extends true ? F : HasCapabilityToken<C, K, F, "filter", UnrestrictedProjection, "null"> extends true ? F : never : Extract<CapabilityTokens<C, K, F, "filter", UnrestrictedProjection>, "some" | "every" | "none"> extends never ? never : F;
 }[RelationFieldKeyOf<C, K>];
-type ToManyRelationWhereInput<C extends Contract, K extends ResourceKey<C>, F extends RelationParentFilterKey<C, K> & RelationFieldKeyOf<C, K>, Forms extends ScalarForms, ReferenceForms extends ScalarForms> = Readonly<Partial<Record<Extract<CapabilityTokens<C, K, F, "filter", UnrestrictedProjection>, "some" | "every" | "none">, WhereInput<C, RelationTarget<C, K, F>, Forms, ReferenceForms>>>>;
-type RelationWhereInput<C extends Contract, K extends ResourceKey<C>, F extends RelationParentFilterKey<C, K> & RelationFieldKeyOf<C, K>, Forms extends ScalarForms, ReferenceForms extends ScalarForms> = RelationCardinality<C, K, F> extends "one" ? (HasCapabilityToken<C, K, F, "filter", UnrestrictedProjection, "match"> extends true ? WhereInput<C, RelationTarget<C, K, F>, Forms, ReferenceForms> : never) | (RelationNullable<C, K, F> extends true ? HasCapabilityToken<C, K, F, "filter", UnrestrictedProjection, "null"> extends true ? null : never : never) : ToManyRelationWhereInput<C, K, F, Forms, ReferenceForms>;
-type ScalarWhereFields<C extends Contract, K extends ResourceKey<C>, Forms extends ScalarForms, ReferenceForms extends ScalarForms> = Readonly<{
+type ToManyRelationWhereInput<C extends AvContract, K extends AvResourceKey<C>, F extends RelationParentFilterKey<C, K> & RelationFieldKeyOf<C, K>, Forms extends ScalarForms, ReferenceForms extends ScalarForms> = Readonly<Partial<Record<Extract<CapabilityTokens<C, K, F, "filter", UnrestrictedProjection>, "some" | "every" | "none">, AvWhereInput<C, RelationTarget<C, K, F>, Forms, ReferenceForms>>>>;
+type RelationWhereInput<C extends AvContract, K extends AvResourceKey<C>, F extends RelationParentFilterKey<C, K> & RelationFieldKeyOf<C, K>, Forms extends ScalarForms, ReferenceForms extends ScalarForms> = RelationCardinality<C, K, F> extends "one" ? (HasCapabilityToken<C, K, F, "filter", UnrestrictedProjection, "match"> extends true ? AvWhereInput<C, RelationTarget<C, K, F>, Forms, ReferenceForms> : never) | (RelationNullable<C, K, F> extends true ? HasCapabilityToken<C, K, F, "filter", UnrestrictedProjection, "null"> extends true ? null : never : never) : ToManyRelationWhereInput<C, K, F, Forms, ReferenceForms>;
+type ScalarWhereFields<C extends AvContract, K extends AvResourceKey<C>, Forms extends ScalarForms, ReferenceForms extends ScalarForms> = Readonly<{
     [F in ScalarFilterableKey<C, K>]?: ScalarFilterFor<C, K, F, Forms, ReferenceForms>;
 }>;
-type RelationWhereFields<C extends Contract, K extends ResourceKey<C>, Forms extends ScalarForms, ReferenceForms extends ScalarForms> = Readonly<{
+type RelationWhereFields<C extends AvContract, K extends AvResourceKey<C>, Forms extends ScalarForms, ReferenceForms extends ScalarForms> = Readonly<{
     [F in RelationParentFilterKey<C, K>]?: RelationWhereInput<C, K, F & RelationFieldKeyOf<C, K>, Forms, ReferenceForms>;
 }>;
 /**
@@ -163,47 +220,47 @@ type RelationWhereFields<C extends Contract, K extends ResourceKey<C>, Forms ext
  * through; see {@link UnstatedForms} for the default. `ReferenceForms` opens a
  * transaction step's own `where` to `$ref`s, at every depth of it.
  */
-export type WhereInput<C extends Contract, K extends ResourceKey<C>, Forms extends ScalarForms = UnstatedForms, ReferenceForms extends ScalarForms = never> = Readonly<{
-    AND?: readonly WhereInput<C, K, Forms, ReferenceForms>[];
-    OR?: readonly WhereInput<C, K, Forms, ReferenceForms>[];
-    NOT?: WhereInput<C, K, Forms, ReferenceForms>;
+export type AvWhereInput<C extends AvContract, K extends AvResourceKey<C>, Forms extends ScalarForms = UnstatedForms, ReferenceForms extends ScalarForms = never> = Readonly<{
+    AND?: readonly AvWhereInput<C, K, Forms, ReferenceForms>[];
+    OR?: readonly AvWhereInput<C, K, Forms, ReferenceForms>[];
+    NOT?: AvWhereInput<C, K, Forms, ReferenceForms>;
 } & ScalarWhereFields<C, K, Forms, ReferenceForms> & RelationWhereFields<C, K, Forms, ReferenceForms>>;
-type ActiveIdentifier<C extends Contract, K extends ResourceKey<C>> = C["resources"][K]["identifiers"][number];
-type IdentifierObject<C extends Contract, K extends ResourceKey<C>, I extends readonly string[], Forms extends ScalarForms, ReferenceForms extends ScalarForms> = Readonly<{
-    [F in Extract<I[number], FieldKey<C, K>>]: ScalarValueAt<C, K, F, Forms> | SlotReference<C, K, F, ReferenceForms, "nonNullValue">;
+type ActiveIdentifier<C extends AvContract, K extends AvResourceKey<C>> = C["resources"][K]["identifiers"][number];
+type IdentifierObject<C extends AvContract, K extends AvResourceKey<C>, I extends readonly string[], Forms extends ScalarForms, ReferenceForms extends ScalarForms> = Readonly<{
+    [F in Extract<I[number], AvFieldKey<C, K>>]: ScalarValueAt<C, K, F, Forms> | SlotReference<C, K, F, ReferenceForms, "nonNullValue">;
 } & {
-    [F in Exclude<FieldKey<C, K>, I[number]>]?: never;
+    [F in Exclude<AvFieldKey<C, K>, I[number]>]?: never;
 }>;
 /**
  * A `where` argument for a unique operation: the values of one identifier. Inside a
  * transaction plan (`ReferenceForms` stated) each value may be a `$ref` to a non-null
  * source of the same type.
  */
-export type UniqueWhereInput<C extends Contract, K extends ResourceKey<C>, Forms extends ScalarForms = UnstatedForms, ReferenceForms extends ScalarForms = never> = ActiveIdentifier<C, K> extends infer I ? I extends readonly string[] ? IdentifierObject<C, K, I, Forms, ReferenceForms> : never : never;
+export type AvUniqueWhereInput<C extends AvContract, K extends AvResourceKey<C>, Forms extends ScalarForms = UnstatedForms, ReferenceForms extends ScalarForms = never> = ActiveIdentifier<C, K> extends infer I ? I extends readonly string[] ? IdentifierObject<C, K, I, Forms, ReferenceForms> : never : never;
 /** `"asc"` or `"desc"`. */
-export type SortDirection = "asc" | "desc";
+export type AvSortDirection = "asc" | "desc";
 /** Where `null`s sort: `"first"` or `"last"`. */
-export type NullsOrder = "first" | "last";
+export type AvNullsOrder = "first" | "last";
 /** How one scalar field sorts: a direction, or a direction and a `nulls` order. */
-export type ScalarOrderInput = SortDirection | Readonly<{
-    sort: SortDirection;
-    nulls: NullsOrder;
+export type AvScalarOrderInput = AvSortDirection | Readonly<{
+    sort: AvSortDirection;
+    nulls: AvNullsOrder;
 }>;
-type OrderableScalarKey<C extends Contract, K extends ResourceKey<C>> = KeysWithCapability<C, K, ScalarFieldKeyOf<C, K>, "order", UnrestrictedProjection>;
-type OrderableRelationKey<C extends Contract, K extends ResourceKey<C>> = KeysWithCapability<C, K, RelationFieldKeyOf<C, K>, "order", UnrestrictedProjection>;
-type OrderableFieldKey<C extends Contract, K extends ResourceKey<C>> = OrderableScalarKey<C, K> | OrderableRelationKey<C, K>;
-type ScalarOrderForField<C extends Contract, K extends ResourceKey<C>, F extends OrderableScalarKey<C, K>> = ScalarFieldAt<C, K, F>["nullable"] extends true ? HasCapability<C, K, F, "orderNulls", UnrestrictedProjection> extends true ? ScalarOrderInput : SortDirection : SortDirection;
+type OrderableScalarKey<C extends AvContract, K extends AvResourceKey<C>> = KeysWithCapability<C, K, ScalarFieldKeyOf<C, K>, "order", UnrestrictedProjection>;
+type OrderableRelationKey<C extends AvContract, K extends AvResourceKey<C>> = KeysWithCapability<C, K, RelationFieldKeyOf<C, K>, "order", UnrestrictedProjection>;
+type OrderableFieldKey<C extends AvContract, K extends AvResourceKey<C>> = OrderableScalarKey<C, K> | OrderableRelationKey<C, K>;
+type ScalarOrderForField<C extends AvContract, K extends AvResourceKey<C>, F extends OrderableScalarKey<C, K>> = ScalarFieldAt<C, K, F>["nullable"] extends true ? HasCapability<C, K, F, "orderNulls", UnrestrictedProjection> extends true ? AvScalarOrderInput : AvSortDirection : AvSortDirection;
 /**
  * The `orderBy` value of a relation field: a to-many relation orders by
  * `$count`; a to-one relation takes one entry of the related Resource's
  * `orderBy`, not a list.
  */
-type RelationOrderForField<C extends Contract, K extends ResourceKey<C>, F extends OrderableRelationKey<C, K> & RelationFieldKeyOf<C, K>> = RelationCardinality<C, K, F> extends "many" ? HasCapabilityToken<C, K, F, "reducers", UnrestrictedProjection, "$count"> extends true ? Readonly<{
-    $count: SortDirection;
-}> : never : OrderByEntry<C, RelationTarget<C, K, F>>;
-type OrderValue<C extends Contract, K extends ResourceKey<C>, F extends OrderableFieldKey<C, K>> = F extends OrderableScalarKey<C, K> ? ScalarOrderForField<C, K, F> : F extends OrderableRelationKey<C, K> & RelationFieldKeyOf<C, K> ? RelationOrderForField<C, K, F> : never;
+type RelationOrderForField<C extends AvContract, K extends AvResourceKey<C>, F extends OrderableRelationKey<C, K> & RelationFieldKeyOf<C, K>> = RelationCardinality<C, K, F> extends "many" ? HasCapabilityToken<C, K, F, "reducers", UnrestrictedProjection, "$count"> extends true ? Readonly<{
+    $count: AvSortDirection;
+}> : never : AvOrderByEntry<C, RelationTarget<C, K, F>>;
+type OrderValue<C extends AvContract, K extends AvResourceKey<C>, F extends OrderableFieldKey<C, K>> = F extends OrderableScalarKey<C, K> ? ScalarOrderForField<C, K, F> : F extends OrderableRelationKey<C, K> & RelationFieldKeyOf<C, K> ? RelationOrderForField<C, K, F> : never;
 /** One `orderBy` precedence entry: exactly one orderable field and its value. */
-export type OrderByEntry<C extends Contract, K extends ResourceKey<C>> = {
+export type AvOrderByEntry<C extends AvContract, K extends AvResourceKey<C>> = {
     [F in OrderableFieldKey<C, K>]: {
         readonly [Only in F]: OrderValue<C, K, Only>;
     } & {
@@ -211,18 +268,18 @@ export type OrderByEntry<C extends Contract, K extends ResourceKey<C>> = {
     };
 }[OrderableFieldKey<C, K>];
 /** An `orderBy` argument: one entry, or a list in order of precedence. */
-export type OrderByInput<C extends Contract, K extends ResourceKey<C>> = OrderByEntry<C, K> | readonly OrderByEntry<C, K>[];
+export type AvOrderByInput<C extends AvContract, K extends AvResourceKey<C>> = AvOrderByEntry<C, K> | readonly AvOrderByEntry<C, K>[];
 /**
  * A `cursor` argument: scalar field values of the row the page starts from. Inside
  * a transaction plan each may be a `$ref` to a non-null source of the same type.
  */
-export type CursorInput<C extends Contract, K extends ResourceKey<C>, Forms extends ScalarForms = UnstatedForms, ReferenceForms extends ScalarForms = never> = Readonly<{
+export type AvCursorInput<C extends AvContract, K extends AvResourceKey<C>, Forms extends ScalarForms = UnstatedForms, ReferenceForms extends ScalarForms = never> = Readonly<{
     [F in ScalarFieldKeyOf<C, K>]?: ScalarValueAt<C, K, F, Forms> | SlotReference<C, K, F, ReferenceForms, "nonNullValue">;
 }>;
 /** The scalar fields selectable at one projection position. */
-type SelectableScalarKey<C extends Contract, K extends ResourceKey<C>, Scope extends ProjectionScope> = KeysWithCapability<C, K, ScalarFieldKeyOf<C, K>, "select", Scope>;
-type SelectableRelationKey<C extends Contract, K extends ResourceKey<C>, Scope extends ProjectionScope> = KeysWithCapability<C, K, RelationFieldKeyOf<C, K>, "select", Scope>;
-type IncludeRelationKey<C extends Contract, K extends ResourceKey<C>, Scope extends ProjectionScope> = KeysWithCapability<C, K, RelationFieldKeyOf<C, K>, "include", Scope>;
+type SelectableScalarKey<C extends AvContract, K extends AvResourceKey<C>, Scope extends AvProjectionScope> = KeysWithCapability<C, K, ScalarFieldKeyOf<C, K>, "select", Scope>;
+type SelectableRelationKey<C extends AvContract, K extends AvResourceKey<C>, Scope extends AvProjectionScope> = KeysWithCapability<C, K, RelationFieldKeyOf<C, K>, "select", Scope>;
+type IncludeRelationKey<C extends AvContract, K extends AvResourceKey<C>, Scope extends AvProjectionScope> = KeysWithCapability<C, K, RelationFieldKeyOf<C, K>, "include", Scope>;
 /**
  * Whether `$count` may be asked for inside relation `F`'s projection argument.
  *
@@ -230,27 +287,27 @@ type IncludeRelationKey<C extends Contract, K extends ResourceKey<C>, Scope exte
  * unrestricted scope one level in: `{ posts: { select: ["$count"] } }` is the
  * parent's reducer over `F`, so it sits in the parent's argument position. The
  * target's own projection is a separate question and is unrestricted — see
- * {@link RelationProjectionInput}.
+ * {@link AvRelationProjectionInput}.
  */
-type RelationAllowsCount<C extends Contract, K extends ResourceKey<C>, F extends RelationFieldKeyOf<C, K>, Scope extends ProjectionScope> = RelationCardinality<C, K, F> extends "many" ? HasCapabilityToken<C, K, F, "reducers", Scope, "$count"> : false;
-type NestedWhereArgument<C extends Contract, K extends ResourceKey<C>, F extends RelationFieldKeyOf<C, K>, Forms extends ScalarForms> = HasCapabilityToken<C, K, F, "filter", UnrestrictedProjection, "nested"> extends true ? Readonly<{
-    where?: WhereInput<C, RelationTarget<C, K, F>, Forms>;
+type RelationAllowsCount<C extends AvContract, K extends AvResourceKey<C>, F extends RelationFieldKeyOf<C, K>, Scope extends AvProjectionScope> = RelationCardinality<C, K, F> extends "many" ? HasCapabilityToken<C, K, F, "reducers", Scope, "$count"> : false;
+type NestedWhereArgument<C extends AvContract, K extends AvResourceKey<C>, F extends RelationFieldKeyOf<C, K>, Forms extends ScalarForms> = HasCapabilityToken<C, K, F, "filter", UnrestrictedProjection, "nested"> extends true ? Readonly<{
+    where?: AvWhereInput<C, RelationTarget<C, K, F>, Forms>;
 }> : Readonly<Record<never, never>>;
-type NestedOrderArgument<C extends Contract, K extends ResourceKey<C>, F extends RelationFieldKeyOf<C, K>> = HasCapability<C, K, F, "order", UnrestrictedProjection> extends true ? Readonly<{
-    orderBy?: OrderByInput<C, RelationTarget<C, K, F>>;
+type NestedOrderArgument<C extends AvContract, K extends AvResourceKey<C>, F extends RelationFieldKeyOf<C, K>> = HasCapability<C, K, F, "order", UnrestrictedProjection> extends true ? Readonly<{
+    orderBy?: AvOrderByInput<C, RelationTarget<C, K, F>>;
 }> : Readonly<Record<never, never>>;
-type NestedPaginationArgument<C extends Contract, K extends ResourceKey<C>, F extends RelationFieldKeyOf<C, K>, Capability extends "limit" | "offset" | "cursor", Forms extends ScalarForms> = RelationCardinality<C, K, F> extends "many" ? HasCapabilityToken<C, K, F, "pagination", UnrestrictedProjection, Capability> extends true ? Capability extends "cursor" ? Readonly<{
-    cursor?: CursorInput<C, RelationTarget<C, K, F>, Forms>;
+type NestedPaginationArgument<C extends AvContract, K extends AvResourceKey<C>, F extends RelationFieldKeyOf<C, K>, Capability extends "limit" | "offset" | "cursor", Forms extends ScalarForms> = RelationCardinality<C, K, F> extends "many" ? HasCapabilityToken<C, K, F, "pagination", UnrestrictedProjection, Capability> extends true ? Capability extends "cursor" ? Readonly<{
+    cursor?: AvCursorInput<C, RelationTarget<C, K, F>, Forms>;
 }> : Capability extends "limit" ? Readonly<{
     limit?: number;
 }> : Readonly<{
     offset?: number;
 }> : Readonly<Record<never, never>> : Readonly<Record<never, never>>;
-type ProjectionChoice<C extends Contract, K extends ResourceKey<C>, Scope extends ProjectionScope, AllowCount extends boolean, Forms extends ScalarForms> = Readonly<{
-    select?: SelectInput<C, K, Scope, AllowCount, Forms>;
+type ProjectionChoice<C extends AvContract, K extends AvResourceKey<C>, Scope extends AvProjectionScope, AllowCount extends boolean, Forms extends ScalarForms> = Readonly<{
+    select?: AvSelectInput<C, K, Scope, AllowCount, Forms>;
     include?: never;
 }> | Readonly<{
-    include?: IncludeInput<C, K, Scope, Forms>;
+    include?: AvIncludeInput<C, K, Scope, Forms>;
     select?: never;
 }>;
 /**
@@ -258,48 +315,48 @@ type ProjectionChoice<C extends Contract, K extends ResourceKey<C>, Scope extend
  * applies to this entry only; the related rows' own projection is
  * unrestricted.
  */
-export type RelationProjectionInput<C extends Contract, K extends ResourceKey<C>, F extends RelationFieldKeyOf<C, K> = RelationFieldKeyOf<C, K>, Scope extends ProjectionScope = UnrestrictedProjection, Forms extends ScalarForms = UnstatedForms> = F extends RelationFieldKeyOf<C, K> ? Readonly<NestedWhereArgument<C, K, F, Forms> & NestedOrderArgument<C, K, F> & NestedPaginationArgument<C, K, F, "limit", Forms> & NestedPaginationArgument<C, K, F, "offset", Forms> & NestedPaginationArgument<C, K, F, "cursor", Forms> & ProjectionChoice<C, RelationTarget<C, K, F>, UnrestrictedProjection, RelationAllowsCount<C, K, F, Scope>, Forms>> : never;
+export type AvRelationProjectionInput<C extends AvContract, K extends AvResourceKey<C>, F extends RelationFieldKeyOf<C, K> = RelationFieldKeyOf<C, K>, Scope extends AvProjectionScope = UnrestrictedProjection, Forms extends ScalarForms = UnstatedForms> = F extends RelationFieldKeyOf<C, K> ? Readonly<NestedWhereArgument<C, K, F, Forms> & NestedOrderArgument<C, K, F> & NestedPaginationArgument<C, K, F, "limit", Forms> & NestedPaginationArgument<C, K, F, "offset", Forms> & NestedPaginationArgument<C, K, F, "cursor", Forms> & ProjectionChoice<C, RelationTarget<C, K, F>, UnrestrictedProjection, RelationAllowsCount<C, K, F, Scope>, Forms>> : never;
 /**
  * One relation entry of a projection: exactly relation `F` of `Keys`, with its
  * argument object, and every other key of `Keys` absent.
  */
-type RelationProjectionEntry<C extends Contract, K extends ResourceKey<C>, Keys extends RelationFieldKeyOf<C, K>, F extends Keys, Scope extends ProjectionScope, Forms extends ScalarForms> = {
-    readonly [Only in F]: RelationProjectionInput<C, K, Only & RelationFieldKeyOf<C, K>, Scope, Forms>;
+type RelationProjectionEntry<C extends AvContract, K extends AvResourceKey<C>, Keys extends RelationFieldKeyOf<C, K>, F extends Keys, Scope extends AvProjectionScope, Forms extends ScalarForms> = {
+    readonly [Only in F]: AvRelationProjectionInput<C, K, Only & RelationFieldKeyOf<C, K>, Scope, Forms>;
 } & {
     readonly [Other in Exclude<Keys, F>]?: never;
 };
-type SelectRelationProjectionEntry<C extends Contract, K extends ResourceKey<C>, Scope extends ProjectionScope, Forms extends ScalarForms> = {
+type SelectRelationProjectionEntry<C extends AvContract, K extends AvResourceKey<C>, Scope extends AvProjectionScope, Forms extends ScalarForms> = {
     [F in SelectableRelationKey<C, K, Scope>]: RelationProjectionEntry<C, K, SelectableRelationKey<C, K, Scope>, F, Scope, Forms>;
 }[SelectableRelationKey<C, K, Scope>];
-type IncludeRelationProjectionEntry<C extends Contract, K extends ResourceKey<C>, Scope extends ProjectionScope, Forms extends ScalarForms> = {
+type IncludeRelationProjectionEntry<C extends AvContract, K extends AvResourceKey<C>, Scope extends AvProjectionScope, Forms extends ScalarForms> = {
     [F in IncludeRelationKey<C, K, Scope>]: RelationProjectionEntry<C, K, IncludeRelationKey<C, K, Scope>, F, Scope, Forms>;
 }[IncludeRelationKey<C, K, Scope>];
 /**
  * One entry of a `select` argument, at one projection position. The default is
  * the unrestricted position.
  */
-export type ProjectionEntry<C extends Contract, K extends ResourceKey<C>, Scope extends ProjectionScope = UnrestrictedProjection, AllowCount extends boolean = false, Forms extends ScalarForms = UnstatedForms> = SelectableScalarKey<C, K, Scope> | SelectableRelationKey<C, K, Scope> | SelectRelationProjectionEntry<C, K, Scope, Forms> | (AllowCount extends true ? "$count" : never);
+export type AvProjectionEntry<C extends AvContract, K extends AvResourceKey<C>, Scope extends AvProjectionScope = UnrestrictedProjection, AllowCount extends boolean = false, Forms extends ScalarForms = UnstatedForms> = SelectableScalarKey<C, K, Scope> | SelectableRelationKey<C, K, Scope> | SelectRelationProjectionEntry<C, K, Scope, Forms> | (AllowCount extends true ? "$count" : never);
 /** A `select` argument: the fields to return. */
-export type SelectInput<C extends Contract, K extends ResourceKey<C>, Scope extends ProjectionScope = UnrestrictedProjection, AllowCount extends boolean = false, Forms extends ScalarForms = UnstatedForms> = readonly ProjectionEntry<C, K, Scope, AllowCount, Forms>[];
+export type AvSelectInput<C extends AvContract, K extends AvResourceKey<C>, Scope extends AvProjectionScope = UnrestrictedProjection, AllowCount extends boolean = false, Forms extends ScalarForms = UnstatedForms> = readonly AvProjectionEntry<C, K, Scope, AllowCount, Forms>[];
 /** An `include` argument: the relations to return with each row. */
-export type IncludeInput<C extends Contract, K extends ResourceKey<C>, Scope extends ProjectionScope = UnrestrictedProjection, Forms extends ScalarForms = UnstatedForms> = readonly (IncludeRelationKey<C, K, Scope> | IncludeRelationProjectionEntry<C, K, Scope, Forms>)[];
+export type AvIncludeInput<C extends AvContract, K extends AvResourceKey<C>, Scope extends AvProjectionScope = UnrestrictedProjection, Forms extends ScalarForms = UnstatedForms> = readonly (IncludeRelationKey<C, K, Scope> | IncludeRelationProjectionEntry<C, K, Scope, Forms>)[];
 /** A scalar update directive and its operand, such as `{ $increment: 1 }`. */
-export type ScalarMutationAction = Readonly<Partial<Record<ScalarMutationDirective, unknown>>>;
+export type ScalarMutationAction = Readonly<Partial<Record<AvScalarMutationDirective, unknown>>>;
 /** A relation write: one or more relation directives and their payloads. */
-export type RelationMutationAction = Readonly<Partial<Record<RelationMutationDirective, unknown>>>;
+export type RelationMutationAction = Readonly<Partial<Record<AvRelationMutationDirective, unknown>>>;
 /** The scalar fields writable at one stage and write position. */
-type WritableScalarKey<C extends Contract, K extends ResourceKey<C>, Stage extends "create" | "update", Scope extends WriteScope> = KeysWithCapability<C, K, ScalarFieldKeyOf<C, K>, Stage, Scope>;
+type WritableScalarKey<C extends AvContract, K extends AvResourceKey<C>, Stage extends "create" | "update", Scope extends AvWriteScope> = KeysWithCapability<C, K, ScalarFieldKeyOf<C, K>, Stage, Scope>;
 /**
  * The relations writable at one stage in one write position. The default is
  * the unrestricted position.
  */
-export type WritableRelationKey<C extends Contract, K extends ResourceKey<C>, Stage extends "create" | "update", Scope extends WriteScope = UnrestrictedWrite> = KeysWithCapability<C, K, RelationFieldKeyOf<C, K>, Stage, Scope>;
-type ManyOrOne<C extends Contract, K extends ResourceKey<C>, F extends RelationFieldKeyOf<C, K>, Value> = RelationCardinality<C, K, F> extends "many" ? Value | readonly Value[] : Value;
+export type WritableRelationKey<C extends AvContract, K extends AvResourceKey<C>, Stage extends "create" | "update", Scope extends AvWriteScope = UnrestrictedWrite> = KeysWithCapability<C, K, RelationFieldKeyOf<C, K>, Stage, Scope>;
+type ManyOrOne<C extends AvContract, K extends AvResourceKey<C>, F extends RelationFieldKeyOf<C, K>, Value> = RelationCardinality<C, K, F> extends "many" ? Value | readonly Value[] : Value;
 /**
  * A `where` of plain fields: each scalar field's filter, combined with
  * `AND`/`OR`/`NOT`, and no relation filter at any depth.
  */
-type ScalarOnlyWhereInput<C extends Contract, K extends ResourceKey<C>, Forms extends ScalarForms, ReferenceForms extends ScalarForms> = Readonly<{
+type ScalarOnlyWhereInput<C extends AvContract, K extends AvResourceKey<C>, Forms extends ScalarForms, ReferenceForms extends ScalarForms> = Readonly<{
     AND?: readonly ScalarOnlyWhereInput<C, K, Forms, ReferenceForms>[];
     OR?: readonly ScalarOnlyWhereInput<C, K, Forms, ReferenceForms>[];
     NOT?: ScalarOnlyWhereInput<C, K, Forms, ReferenceForms>;
@@ -308,38 +365,38 @@ type ScalarOnlyWhereInput<C extends Contract, K extends ResourceKey<C>, Forms ex
  * The `where` of a nested `$update` or `$delete` through relation `F`: plain fields
  * only where the relation states `nestedWriteFilter: "scalar"`, any filter otherwise.
  */
-type NestedWriteWhereInput<C extends Contract, K extends ResourceKey<C>, F extends RelationFieldKeyOf<C, K>, Forms extends ScalarForms, ReferenceForms extends ScalarForms> = CapabilitiesOf<C, K, F> extends {
+type NestedWriteWhereInput<C extends AvContract, K extends AvResourceKey<C>, F extends RelationFieldKeyOf<C, K>, Forms extends ScalarForms, ReferenceForms extends ScalarForms> = CapabilitiesOf<C, K, F> extends {
     readonly nestedWriteFilter: "scalar";
-} ? ScalarOnlyWhereInput<C, RelationTarget<C, K, F>, Forms, ReferenceForms> : WhereInput<C, RelationTarget<C, K, F>, Forms, ReferenceForms>;
-type ConnectOrCreateEntry<C extends Contract, K extends ResourceKey<C>, F extends RelationFieldKeyOf<C, K>, Forms extends ScalarForms, ReferenceForms extends ScalarForms> = Readonly<{
-    where: UniqueWhereInput<C, RelationTarget<C, K, F>, Forms, ReferenceForms>;
-    create: CreateDataInput<C, RelationTarget<C, K, F>, UnrestrictedWrite, Forms, ReferenceForms>;
+} ? ScalarOnlyWhereInput<C, RelationTarget<C, K, F>, Forms, ReferenceForms> : AvWhereInput<C, RelationTarget<C, K, F>, Forms, ReferenceForms>;
+type ConnectOrCreateEntry<C extends AvContract, K extends AvResourceKey<C>, F extends RelationFieldKeyOf<C, K>, Forms extends ScalarForms, ReferenceForms extends ScalarForms> = Readonly<{
+    where: AvUniqueWhereInput<C, RelationTarget<C, K, F>, Forms, ReferenceForms>;
+    create: AvCreateDataInput<C, RelationTarget<C, K, F>, UnrestrictedWrite, Forms, ReferenceForms, readonly [K, F]>;
 }>;
-type ToOneUpdateEntry<C extends Contract, K extends ResourceKey<C>, F extends RelationFieldKeyOf<C, K>, Forms extends ScalarForms, ReferenceForms extends ScalarForms> = Readonly<{
+type ToOneUpdateEntry<C extends AvContract, K extends AvResourceKey<C>, F extends RelationFieldKeyOf<C, K>, Forms extends ScalarForms, ReferenceForms extends ScalarForms> = Readonly<{
     where?: NestedWriteWhereInput<C, K, F, Forms, ReferenceForms>;
-    data: UpdateDataInput<C, RelationTarget<C, K, F>, UnrestrictedWrite, Forms, ReferenceForms>;
+    data: AvUpdateDataInput<C, RelationTarget<C, K, F>, UnrestrictedWrite, Forms, ReferenceForms, readonly [K, F]>;
 }>;
-type ToManyUpdateEntry<C extends Contract, K extends ResourceKey<C>, F extends RelationFieldKeyOf<C, K>, Forms extends ScalarForms, ReferenceForms extends ScalarForms> = Readonly<{
+type ToManyUpdateEntry<C extends AvContract, K extends AvResourceKey<C>, F extends RelationFieldKeyOf<C, K>, Forms extends ScalarForms, ReferenceForms extends ScalarForms> = Readonly<{
     where: NestedWriteWhereInput<C, K, F, Forms, ReferenceForms>;
-    data: UpdateDataInput<C, RelationTarget<C, K, F>, UnrestrictedWrite, Forms, ReferenceForms>;
+    data: AvUpdateDataInput<C, RelationTarget<C, K, F>, "bulkWrite", Forms, ReferenceForms, readonly [K, F]>;
 }>;
-type ToOneDeleteEntry<C extends Contract, K extends ResourceKey<C>, F extends RelationFieldKeyOf<C, K>, Forms extends ScalarForms, ReferenceForms extends ScalarForms> = true | Readonly<{
+type ToOneDeleteEntry<C extends AvContract, K extends AvResourceKey<C>, F extends RelationFieldKeyOf<C, K>, Forms extends ScalarForms, ReferenceForms extends ScalarForms> = true | Readonly<{
     where?: NestedWriteWhereInput<C, K, F, Forms, ReferenceForms>;
 }>;
-type ToManyDeleteEntry<C extends Contract, K extends ResourceKey<C>, F extends RelationFieldKeyOf<C, K>, Forms extends ScalarForms, ReferenceForms extends ScalarForms> = Readonly<{
+type ToManyDeleteEntry<C extends AvContract, K extends AvResourceKey<C>, F extends RelationFieldKeyOf<C, K>, Forms extends ScalarForms, ReferenceForms extends ScalarForms> = Readonly<{
     where: NestedWriteWhereInput<C, K, F, Forms, ReferenceForms>;
 }>;
-type ToOneUpsertEntry<C extends Contract, K extends ResourceKey<C>, F extends RelationFieldKeyOf<C, K>, Forms extends ScalarForms, ReferenceForms extends ScalarForms> = Readonly<{
-    where?: UniqueWhereInput<C, RelationTarget<C, K, F>, Forms, ReferenceForms>;
-    create: CreateDataInput<C, RelationTarget<C, K, F>, UnrestrictedWrite, Forms, ReferenceForms>;
-    update: UpdateDataInput<C, RelationTarget<C, K, F>, UnrestrictedWrite, Forms, ReferenceForms>;
+type ToOneUpsertEntry<C extends AvContract, K extends AvResourceKey<C>, F extends RelationFieldKeyOf<C, K>, Forms extends ScalarForms, ReferenceForms extends ScalarForms> = Readonly<{
+    where?: AvUniqueWhereInput<C, RelationTarget<C, K, F>, Forms, ReferenceForms>;
+    create: AvCreateDataInput<C, RelationTarget<C, K, F>, UnrestrictedWrite, Forms, ReferenceForms, readonly [K, F]>;
+    update: AvUpdateDataInput<C, RelationTarget<C, K, F>, UnrestrictedWrite, Forms, ReferenceForms, readonly [K, F]>;
 }>;
-type ToManyUpsertEntry<C extends Contract, K extends ResourceKey<C>, F extends RelationFieldKeyOf<C, K>, Forms extends ScalarForms, ReferenceForms extends ScalarForms> = Readonly<{
-    where: UniqueWhereInput<C, RelationTarget<C, K, F>, Forms, ReferenceForms>;
-    create: CreateDataInput<C, RelationTarget<C, K, F>, UnrestrictedWrite, Forms, ReferenceForms>;
-    update: UpdateDataInput<C, RelationTarget<C, K, F>, UnrestrictedWrite, Forms, ReferenceForms>;
+type ToManyUpsertEntry<C extends AvContract, K extends AvResourceKey<C>, F extends RelationFieldKeyOf<C, K>, Forms extends ScalarForms, ReferenceForms extends ScalarForms> = Readonly<{
+    where: AvUniqueWhereInput<C, RelationTarget<C, K, F>, Forms, ReferenceForms>;
+    create: AvCreateDataInput<C, RelationTarget<C, K, F>, UnrestrictedWrite, Forms, ReferenceForms, readonly [K, F]>;
+    update: AvUpdateDataInput<C, RelationTarget<C, K, F>, UnrestrictedWrite, Forms, ReferenceForms, readonly [K, F]>;
 }>;
-type RelationDirectiveValue<C extends Contract, K extends ResourceKey<C>, F extends RelationFieldKeyOf<C, K>, Directive extends RelationMutationDirective, Forms extends ScalarForms, ReferenceForms extends ScalarForms> = Directive extends "$create" ? ManyOrOne<C, K, F, CreateDataInput<C, RelationTarget<C, K, F>, UnrestrictedWrite, Forms, ReferenceForms>> : Directive extends "$connect" ? ManyOrOne<C, K, F, UniqueWhereInput<C, RelationTarget<C, K, F>, Forms, ReferenceForms>> : Directive extends "$connectOrCreate" ? ManyOrOne<C, K, F, ConnectOrCreateEntry<C, K, F, Forms, ReferenceForms>> : Directive extends "$disconnect" ? RelationCardinality<C, K, F> extends "one" ? true : UniqueWhereInput<C, RelationTarget<C, K, F>, Forms, ReferenceForms> | readonly UniqueWhereInput<C, RelationTarget<C, K, F>, Forms, ReferenceForms>[] : Directive extends "$set" ? RelationCardinality<C, K, F> extends "one" ? UniqueWhereInput<C, RelationTarget<C, K, F>, Forms, ReferenceForms> | null : readonly UniqueWhereInput<C, RelationTarget<C, K, F>, Forms, ReferenceForms>[] : Directive extends "$update" ? RelationCardinality<C, K, F> extends "one" ? ToOneUpdateEntry<C, K, F, Forms, ReferenceForms> : ManyOrOne<C, K, F, ToManyUpdateEntry<C, K, F, Forms, ReferenceForms>> : Directive extends "$delete" ? RelationCardinality<C, K, F> extends "one" ? ToOneDeleteEntry<C, K, F, Forms, ReferenceForms> : ManyOrOne<C, K, F, ToManyDeleteEntry<C, K, F, Forms, ReferenceForms>> : Directive extends "$upsert" ? RelationCardinality<C, K, F> extends "one" ? ToOneUpsertEntry<C, K, F, Forms, ReferenceForms> : ManyOrOne<C, K, F, ToManyUpsertEntry<C, K, F, Forms, ReferenceForms>> : never;
+type RelationDirectiveValue<C extends AvContract, K extends AvResourceKey<C>, F extends RelationFieldKeyOf<C, K>, Directive extends AvRelationMutationDirective, Forms extends ScalarForms, ReferenceForms extends ScalarForms> = Directive extends "$create" ? ManyOrOne<C, K, F, AvCreateDataInput<C, RelationTarget<C, K, F>, UnrestrictedWrite, Forms, ReferenceForms, readonly [K, F]>> : Directive extends "$connect" ? ManyOrOne<C, K, F, AvUniqueWhereInput<C, RelationTarget<C, K, F>, Forms, ReferenceForms>> : Directive extends "$connectOrCreate" ? ManyOrOne<C, K, F, ConnectOrCreateEntry<C, K, F, Forms, ReferenceForms>> : Directive extends "$disconnect" ? RelationCardinality<C, K, F> extends "one" ? true : AvUniqueWhereInput<C, RelationTarget<C, K, F>, Forms, ReferenceForms> | readonly AvUniqueWhereInput<C, RelationTarget<C, K, F>, Forms, ReferenceForms>[] : Directive extends "$set" ? RelationCardinality<C, K, F> extends "one" ? AvUniqueWhereInput<C, RelationTarget<C, K, F>, Forms, ReferenceForms> | null : readonly AvUniqueWhereInput<C, RelationTarget<C, K, F>, Forms, ReferenceForms>[] : Directive extends "$update" ? RelationCardinality<C, K, F> extends "one" ? ToOneUpdateEntry<C, K, F, Forms, ReferenceForms> : ManyOrOne<C, K, F, ToManyUpdateEntry<C, K, F, Forms, ReferenceForms>> : Directive extends "$delete" ? RelationCardinality<C, K, F> extends "one" ? ToOneDeleteEntry<C, K, F, Forms, ReferenceForms> : ManyOrOne<C, K, F, ToManyDeleteEntry<C, K, F, Forms, ReferenceForms>> : Directive extends "$upsert" ? RelationCardinality<C, K, F> extends "one" ? ToOneUpsertEntry<C, K, F, Forms, ReferenceForms> : ManyOrOne<C, K, F, ToManyUpsertEntry<C, K, F, Forms, ReferenceForms>> : never;
 declare const NO_ADVERTISED_MEMBER: unique symbol;
 /**
  * A write member that advertises nothing: it accepts `{}` and refuses every key.
@@ -349,126 +406,205 @@ type NoAdvertisedMember = {
 };
 /** `Write`, or {@link NoAdvertisedMember} when `Write` has no keys at all. */
 type RefuseEveryKeyWhenEmpty<Write> = [keyof Write] extends [never] ? NoAdvertisedMember : Write;
-type RelationMutationActionFor<C extends Contract, K extends ResourceKey<C>, F extends RelationFieldKeyOf<C, K>, Stage extends "create" | "update", Scope extends WriteScope, Forms extends ScalarForms, ReferenceForms extends ScalarForms> = RefuseEveryKeyWhenEmpty<Readonly<Partial<{
-    [Directive in Extract<CapabilityTokens<C, K, F, Stage, Scope>, RelationMutationDirective>]: RelationDirectiveValue<C, K, F, Directive, Forms, ReferenceForms>;
+type RelationMutationActionFor<C extends AvContract, K extends AvResourceKey<C>, F extends RelationFieldKeyOf<C, K>, Stage extends "create" | "update", Scope extends AvWriteScope, Forms extends ScalarForms, ReferenceForms extends ScalarForms> = RefuseEveryKeyWhenEmpty<Readonly<Partial<{
+    [Directive in Extract<CapabilityTokens<C, K, F, Stage, Scope>, AvRelationMutationDirective>]: RelationDirectiveValue<C, K, F, Directive, Forms, ReferenceForms>;
 }>>>;
 /**
  * One scalar mutation directive's operand: one entry of the field (`$push` on a
  * list also takes a list of them). `$unset`'s operand is passed to the adapter as
  * given.
  */
-type ScalarDirectiveOperand<C extends Contract, K extends ResourceKey<C>, F extends FieldKey<C, K>, Directive extends ScalarMutationDirective, Forms extends ScalarForms> = Directive extends "$unset" ? unknown : Directive extends "$push" ? [ScalarFieldAt<C, K, F>["list"]] extends [false] ? ScalarAtomAt<C, K, F, Forms> : ScalarAtomAt<C, K, F, Forms> | readonly ScalarAtomAt<C, K, F, Forms>[] : ScalarAtomAt<C, K, F, Forms>;
+type ScalarDirectiveOperand<C extends AvContract, K extends AvResourceKey<C>, F extends AvFieldKey<C, K>, Directive extends AvScalarMutationDirective, Forms extends ScalarForms> = Directive extends "$unset" ? unknown : Directive extends "$push" ? [ScalarFieldAt<C, K, F>["list"]] extends [false] ? ScalarAtomAt<C, K, F, Forms> : ScalarAtomAt<C, K, F, Forms> | readonly ScalarAtomAt<C, K, F, Forms>[] : ScalarAtomAt<C, K, F, Forms>;
 /**
  * The directive object a scalar field accepts at one stage, or `never` when it
  * advertises no directive.
  */
-type ScalarMutationActionFor<C extends Contract, K extends ResourceKey<C>, F extends FieldKey<C, K>, Stage extends "create" | "update", Scope extends WriteScope, Forms extends ScalarForms> = [
-    Extract<CapabilityTokens<C, K, F, Stage, Scope>, ScalarMutationDirective>
-] extends [never] ? never : Readonly<{
-    [Directive in Extract<CapabilityTokens<C, K, F, Stage, Scope>, ScalarMutationDirective>]?: ScalarDirectiveOperand<C, K, F, Directive, Forms>;
-}>;
+type ScalarMutationActionFor<C extends AvContract, K extends AvResourceKey<C>, F extends AvFieldKey<C, K>, Stage extends "create" | "update", Scope extends AvWriteScope, Forms extends ScalarForms> = [
+    Extract<CapabilityTokens<C, K, F, Stage, Scope>, AvScalarMutationDirective>
+] extends [never] ? never : OneDirective<Extract<CapabilityTokens<C, K, F, Stage, Scope>, AvScalarMutationDirective>, C, K, F, Forms>;
+type OneDirective<Tokens extends AvScalarMutationDirective, C extends AvContract, K extends AvResourceKey<C>, F extends AvFieldKey<C, K>, Forms extends ScalarForms> = {
+    [Directive in Tokens]: Readonly<{
+        [Key in Directive]: ScalarDirectiveOperand<C, K, F, Key, Forms>;
+    } & {
+        [Other in Exclude<Tokens, Directive>]?: never;
+    }>;
+}[Tokens];
 /**
  * Each writable scalar takes its value under `Forms`, or a directive object of
  * the directives it advertises at this stage — or, in a transaction plan's
  * top-level data, a `$ref` to a source of the same type.
  */
-type ScalarMutationFields<C extends Contract, K extends ResourceKey<C>, Stage extends "create" | "update", Scope extends WriteScope, Forms extends ScalarForms, ReferenceForms extends ScalarForms> = Readonly<{
-    [F in WritableScalarKey<C, K, Stage, Scope>]?: ScalarValueAt<C, K, F, Forms> | ScalarMutationActionFor<C, K, F, Stage, Scope, Forms> | SlotReference<C, K, F, ReferenceForms, "value">;
+type ScalarMutationFields<C extends AvContract, K extends AvResourceKey<C>, Stage extends "create" | "update", Scope extends AvWriteScope, Forms extends ScalarForms, ReferenceForms extends ScalarForms, Via extends ParentEdge = never> = Readonly<{
+    [F in Exclude<WritableScalarKey<C, K, Stage, Scope>, LoopbackRefused<C, K, Stage, Via>>]?: ScalarValueAt<C, K, F, Forms> | ScalarMutationActionFor<C, K, F, Stage, Scope, Forms> | SlotReference<C, K, F, ReferenceForms, "value">;
 }>;
-type RelationMutationFields<C extends Contract, K extends ResourceKey<C>, Stage extends "create" | "update", Scope extends WriteScope, Forms extends ScalarForms, ReferenceForms extends ScalarForms> = Readonly<{
-    [F in WritableRelationKey<C, K, Stage, Scope>]?: RelationMutationActionFor<C, K, F & RelationFieldKeyOf<C, K>, Stage, Scope, Forms, ReferenceForms>;
+type RelationMutationFields<C extends AvContract, K extends AvResourceKey<C>, Stage extends "create" | "update", Scope extends AvWriteScope, Forms extends ScalarForms, ReferenceForms extends ScalarForms, Via extends ParentEdge = never> = Readonly<{
+    [F in Exclude<WritableRelationKey<C, K, Stage, Scope>, LoopbackRefused<C, K, Stage, Via>>]?: RelationMutationActionFor<C, K, F & RelationFieldKeyOf<C, K>, Stage, Scope, Forms, ReferenceForms>;
 }>;
+/** A relation edge a nested create is reached through: `[parent, relation]`. */
+type ParentEdge = readonly [string, string];
+/** The other end of `Via`'s relation, as the Contract pairs it; `never` when it does not. */
+type LoopbackOf<C extends AvContract, Via> = Via extends readonly [
+    infer Parent,
+    infer Relation
+] ? Parent extends AvResourceKey<C> ? Relation extends keyof C["resources"][Parent]["fields"] ? C["resources"][Parent]["fields"][Relation] extends {
+    readonly inverse: infer Inverse extends string;
+} ? Inverse : never : never : never : never;
+/** The fields `K`'s relation `Relation` states hold its reference; `never` when it states none. */
+type ReferenceFieldsOf<C extends AvContract, K extends AvResourceKey<C>, Relation extends string> = Relation extends keyof C["resources"][K]["fields"] ? C["resources"][K]["fields"][Relation] extends {
+    readonly referenceFields: readonly (infer Field extends string)[];
+} ? Field : never : never;
+/**
+ * The members a record of `K` reached through `Via` cannot write at `Stage`:
+ * the other end of `Via`'s relation and the fields that hold its reference,
+ * unless the Contract admits that relation at the `"loopback"` position.
+ */
+type LoopbackRefused<C extends AvContract, K extends AvResourceKey<C>, Stage extends "create" | "update", Via> = [Via] extends [never] ? never : LoopbackOf<C, Via> extends infer Loopback extends string ? [
+    Extract<Loopback, WritableRelationKey<C, K, Stage, "loopback">>
+] extends [never] ? Loopback | ReferenceFieldsOf<C, K, Loopback> : never : never;
+/** The names a requirement list holds; `never` when the member is absent. */
+type RequirementNames<Requirements, Member extends PropertyKey> = Requirements extends {
+    readonly [P in Member]?: infer List;
+} ? List extends readonly (infer Name)[] ? Name : never : never;
+/** Resource `K`'s create requirements, or `never` when its Contract states none. */
+type CreateRequirementsAt<C extends AvContract, K extends AvResourceKey<C>> = "createRequirements" extends keyof C["resources"][K] ? Exclude<C["resources"][K]["createRequirements"], undefined> : never;
+/** The names a create nested through `Via` gets from its parent. */
+type SuppliedThrough<Requirements, Via> = Via extends readonly [
+    infer Parent,
+    infer Relation
+] ? Requirements extends {
+    readonly parentSupplies?: infer Supplies;
+} ? Parent extends keyof Supplies ? Relation extends keyof NonNullable<Supplies[Parent]> ? NonNullable<Supplies[Parent]>[Relation] extends readonly (infer Name)[] ? Name : never : never : never : never : never;
+/** A value that is written: anything but `undefined`. */
+type WrittenValue = NonNullable<unknown> | null;
+/** Keys that must be present: `never` names none. */
+type Present<Keys extends PropertyKey> = [Keys] extends [never] ? unknown : {
+    readonly [P in Keys]: WrittenValue;
+};
+/**
+ * One required relation's group: the relation alone, or every reference field
+ * together, never both — where this position can write both; the relation
+ * alone where it can write the relation but not every reference field; every
+ * reference field where it cannot write the relation (a bulk record); nothing
+ * where the parent supplies the group.
+ */
+type GroupPresence<Group, Scalars, Relations, Supplied> = Group extends readonly [
+    infer Relation extends string,
+    ...infer References extends readonly string[]
+] ? string extends Relation ? unknown : [References[number]] extends [never] ? unknown : [Extract<Relation | References[number], Supplied>] extends [never] ? Relation extends Relations ? [Exclude<References[number], Scalars>] extends [never] ? (Present<Relation> & {
+    readonly [P in References[number]]?: never;
+}) | (Present<References[number]> & {
+    readonly [P in Relation]?: never;
+}) : Present<Relation> : Present<References[number]> : unknown : unknown;
+/** Every group of a `oneOf` tuple, each one's presence intersected. */
+type GroupsPresence<Groups, Scalars, Relations, Supplied> = Groups extends readonly [infer Group, ...infer Rest] ? GroupPresence<Group, Scalars, Relations, Supplied> & GroupsPresence<Rest, Scalars, Relations, Supplied> : unknown;
+/**
+ * What a create of Resource `K` at write position `Scope` must and must not
+ * write: every `required` name it can write, and one side of every `oneOf`
+ * group — less what the parent supplies when the create is nested through
+ * `Via`. `unknown` (no constraint) when the Contract states nothing.
+ */
+type CreateRequirementPresence<C extends AvContract, K extends AvResourceKey<C>, Scope extends AvWriteScope, Via> = [CreateRequirementsAt<C, K>] extends [never] ? unknown : CreateRequirementsAt<C, K> extends infer Requirements ? string extends RequirementNames<Requirements, "required"> ? unknown : Present<Exclude<Extract<RequirementNames<Requirements, "required">, WritableScalarKey<C, K, "create", Scope> | WritableRelationKey<C, K, "create", Scope>>, SuppliedThrough<Requirements, Via>>> & (Requirements extends {
+    readonly oneOf?: infer Groups;
+} ? GroupsPresence<Groups, WritableScalarKey<C, K, "create", Scope>, WritableRelationKey<C, K, "create", Scope>, SuppliedThrough<Requirements, Via>> : unknown) : unknown;
 /**
  * A `create` data argument, at one write position. A write position applies
  * to the top level only; nested writes use the unrestricted position (see
- * {@link WriteScope}). `ReferenceForms` opens a transaction plan's reference
- * positions — its scalar values and the unique keys its relation directives name
- * — and is never passed to nested data, which holds none.
+ * {@link AvWriteScope}). `ReferenceForms` opens a transaction plan's reference
+ * positions (its scalar values and the unique keys its relation directives name)
+ * and is never passed to nested data, which holds none.
+ *
+ * Every field the Contract's `createRequirements` names must be written, and
+ * one side of every required relation's group — the relation, or all of its
+ * reference fields — never both. `Via` is the `[parent, relation]` a nested
+ * create is reached through: what that parent supplies is not required.
+ */
+export type AvCreateDataInput<C extends AvContract, K extends AvResourceKey<C>, Scope extends AvWriteScope = UnrestrictedWrite, Forms extends ScalarForms = UnstatedForms, ReferenceForms extends ScalarForms = never, Via extends ParentEdge = never> = RefuseEveryKeyWhenEmpty<Readonly<ScalarMutationFields<C, K, "create", Scope, Forms, ReferenceForms, Via> & RelationMutationFields<C, K, "create", Scope, Forms, ReferenceForms, Via>>> & CreateRequirementPresence<C, K, Scope, Via>;
+/**
+ * An `update` data argument, at one write position. See {@link AvCreateDataInput};
+ * `Via` is the `[parent, relation]` a nested update is reached through.
  */
-export type CreateDataInput<C extends Contract, K extends ResourceKey<C>, Scope extends WriteScope = UnrestrictedWrite, Forms extends ScalarForms = UnstatedForms, ReferenceForms extends ScalarForms = never> = RefuseEveryKeyWhenEmpty<Readonly<ScalarMutationFields<C, K, "create", Scope, Forms, ReferenceForms> & RelationMutationFields<C, K, "create", Scope, Forms, ReferenceForms>>>;
-/** An `update` data argument, at one write position. See {@link CreateDataInput}. */
-export type UpdateDataInput<C extends Contract, K extends ResourceKey<C>, Scope extends WriteScope = UnrestrictedWrite, Forms extends ScalarForms = UnstatedForms, ReferenceForms extends ScalarForms = never> = RefuseEveryKeyWhenEmpty<Readonly<ScalarMutationFields<C, K, "update", Scope, Forms, ReferenceForms> & RelationMutationFields<C, K, "update", Scope, Forms, ReferenceForms>>>;
-type QueryProjectionArgs<C extends Contract, K extends ResourceKey<C>, Scope extends ProjectionScope, Forms extends ScalarForms> = ProjectionChoice<C, K, Scope, false, Forms>;
+export type AvUpdateDataInput<C extends AvContract, K extends AvResourceKey<C>, Scope extends AvWriteScope = UnrestrictedWrite, Forms extends ScalarForms = UnstatedForms, ReferenceForms extends ScalarForms = never, Via extends ParentEdge = never> = RefuseEveryKeyWhenEmpty<Readonly<ScalarMutationFields<C, K, "update", Scope, Forms, ReferenceForms, Via> & RelationMutationFields<C, K, "update", Scope, Forms, ReferenceForms, Via>>>;
+type QueryProjectionArgs<C extends AvContract, K extends AvResourceKey<C>, Scope extends AvProjectionScope, Forms extends ScalarForms> = ProjectionChoice<C, K, Scope, false, Forms>;
 /**
  * Every standard operation's argument object, with each argument at its
  * projection or write position.
  */
-export type OperationArgumentMap<C extends Contract, K extends ResourceKey<C>, Forms extends ScalarForms = UnstatedForms, ReferenceForms extends ScalarForms = never> = {
+export type AvOperationArgumentMap<C extends AvContract, K extends AvResourceKey<C>, Forms extends ScalarForms = UnstatedForms, ReferenceForms extends ScalarForms = never> = {
     find: {
         first: QueryProjectionArgs<C, K, "record", Forms> & {
-            where?: WhereInput<C, K, Forms, ReferenceForms>;
-            orderBy?: OrderByInput<C, K>;
+            where?: AvWhereInput<C, K, Forms, ReferenceForms>;
+            orderBy?: AvOrderByInput<C, K>;
         };
         unique: QueryProjectionArgs<C, K, "record", Forms> & {
-            where: UniqueWhereInput<C, K, Forms, ReferenceForms>;
+            where: AvUniqueWhereInput<C, K, Forms, ReferenceForms>;
         };
         many: QueryProjectionArgs<C, K, "record", Forms> & {
-            where?: WhereInput<C, K, Forms, ReferenceForms>;
-            orderBy?: OrderByInput<C, K>;
+            where?: AvWhereInput<C, K, Forms, ReferenceForms>;
+            orderBy?: AvOrderByInput<C, K>;
             limit?: number;
             offset?: number;
-            cursor?: CursorInput<C, K, Forms, ReferenceForms>;
+            cursor?: AvCursorInput<C, K, Forms, ReferenceForms>;
         };
         count: {
-            where?: WhereInput<C, K, Forms, ReferenceForms>;
+            where?: AvWhereInput<C, K, Forms, ReferenceForms>;
         };
     };
     create: {
         one: QueryProjectionArgs<C, K, "record", Forms> & {
-            data: CreateDataInput<C, K, "nested", Forms, ReferenceForms>;
+            data: AvCreateDataInput<C, K, "nested", Forms, ReferenceForms>;
         };
         many: QueryProjectionArgs<C, K, "bulkWrite", Forms> & {
-            data: readonly CreateDataInput<C, K, "bulkWrite", Forms, ReferenceForms>[];
+            data: readonly AvCreateDataInput<C, K, "bulkWrite", Forms, ReferenceForms>[];
         };
         count: {
-            data: readonly CreateDataInput<C, K, "bulkWrite", Forms, ReferenceForms>[];
+            data: readonly AvCreateDataInput<C, K, "bulkWrite", Forms, ReferenceForms>[];
         };
     };
     update: {
         first: QueryProjectionArgs<C, K, "record", Forms> & {
-            where?: WhereInput<C, K, Forms, ReferenceForms>;
-            orderBy?: OrderByInput<C, K>;
-            data: UpdateDataInput<C, K, "nested", Forms, ReferenceForms>;
+            where?: AvWhereInput<C, K, Forms, ReferenceForms>;
+            orderBy?: AvOrderByInput<C, K>;
+            data: AvUpdateDataInput<C, K, "nested", Forms, ReferenceForms>;
         };
         unique: QueryProjectionArgs<C, K, "record", Forms> & {
-            where: UniqueWhereInput<C, K, Forms, ReferenceForms>;
-            data: UpdateDataInput<C, K, "nested", Forms, ReferenceForms>;
+            where: AvUniqueWhereInput<C, K, Forms, ReferenceForms>;
+            data: AvUpdateDataInput<C, K, "nested", Forms, ReferenceForms>;
         };
         many: QueryProjectionArgs<C, K, "bulkWrite", Forms> & {
-            where?: WhereInput<C, K, Forms, ReferenceForms>;
-            data: UpdateDataInput<C, K, "bulkWrite", Forms, ReferenceForms>;
+            where?: AvWhereInput<C, K, Forms, ReferenceForms>;
+            data: AvUpdateDataInput<C, K, "bulkWrite", Forms, ReferenceForms>;
         };
         count: {
-            where?: WhereInput<C, K, Forms, ReferenceForms>;
-            data: UpdateDataInput<C, K, "bulkWrite", Forms, ReferenceForms>;
+            where?: AvWhereInput<C, K, Forms, ReferenceForms>;
+            data: AvUpdateDataInput<C, K, "bulkWrite", Forms, ReferenceForms>;
         };
     };
     delete: {
         first: QueryProjectionArgs<C, K, "record", Forms> & {
-            where?: WhereInput<C, K, Forms, ReferenceForms>;
-            orderBy?: OrderByInput<C, K>;
+            where?: AvWhereInput<C, K, Forms, ReferenceForms>;
+            orderBy?: AvOrderByInput<C, K>;
         };
         unique: QueryProjectionArgs<C, K, "record", Forms> & {
-            where: UniqueWhereInput<C, K, Forms, ReferenceForms>;
+            where: AvUniqueWhereInput<C, K, Forms, ReferenceForms>;
         };
         many: QueryProjectionArgs<C, K, "record", Forms> & {
-            where?: WhereInput<C, K, Forms, ReferenceForms>;
+            where?: AvWhereInput<C, K, Forms, ReferenceForms>;
         };
         count: {
-            where?: WhereInput<C, K, Forms, ReferenceForms>;
+            where?: AvWhereInput<C, K, Forms, ReferenceForms>;
         };
     };
     upsert: {
         unique: QueryProjectionArgs<C, K, "record", Forms> & {
-            where: UniqueWhereInput<C, K, Forms, ReferenceForms>;
-            create: CreateDataInput<C, K, "nested", Forms, ReferenceForms>;
-            update: UpdateDataInput<C, K, "nested", Forms, ReferenceForms>;
+            where: AvUniqueWhereInput<C, K, Forms, ReferenceForms>;
+            create: AvCreateDataInput<C, K, "nested", Forms, ReferenceForms>;
+            update: AvUpdateDataInput<C, K, "nested", Forms, ReferenceForms>;
         };
     };
 };
 /** One standard operation's argument object. */
-export type OperationArgumentsFor<C extends Contract, K extends ResourceKey<C>, I extends OperationIdentity, Forms extends ScalarForms = UnstatedForms, ReferenceForms extends ScalarForms = never> = I extends {
+export type AvOperationArgumentsFor<C extends AvContract, K extends AvResourceKey<C>, I extends AvOperationIdentity, Forms extends ScalarForms = UnstatedForms, ReferenceForms extends ScalarForms = never> = I extends {
     family: infer F;
     variant: infer V;
-} ? F extends keyof OperationArgumentMap<C, K, Forms, ReferenceForms> ? V extends keyof OperationArgumentMap<C, K, Forms, ReferenceForms>[F] ? OperationArgumentMap<C, K, Forms, ReferenceForms>[F][V] : never : never : never;
+} ? F extends keyof AvOperationArgumentMap<C, K, Forms, ReferenceForms> ? V extends keyof AvOperationArgumentMap<C, K, Forms, ReferenceForms>[F] ? AvOperationArgumentMap<C, K, Forms, ReferenceForms>[F][V] : never : never : never;
 export {};