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

package/dist/contracts/create-requirements.d.ts

@@ -0,0 +1,35 @@
+/**
+ * A required to-one relation and the scalar fields that hold its reference,
+ * relation first: `["author", "authorId"]`. A create writes the relation, or
+ * every one of the fields together (`["author", "tenantId", "authorId"]` for a
+ * composite reference), never both.
+ */
+export type AvCreateRequirementGroup = readonly [string, string, ...string[]];
+/**
+ * What a create of one Resource cannot do without, as the Contract's layer
+ * exposes it. Only fields the layer lets a caller write at create appear: a
+ * group whose reference fields the layer hides is its relation alone, in
+ * `required`; one whose relation it hides is its reference fields, in
+ * `required`; a field a compute stage fills at create (`COMPUTED_ON_CREATE`) is
+ * not required.
+ */
+export type AvCreateRequirements = {
+    /**
+     * The fields every create must write: scalars with no default, generated or
+     * computed value, and relations whose reference fields the layer hides.
+     */
+    readonly required?: readonly [string, ...string[]];
+    /** The required relations a create writes either way: see {@link AvCreateRequirementGroup}. */
+    readonly oneOf?: readonly [
+        AvCreateRequirementGroup,
+        ...AvCreateRequirementGroup[]
+    ];
+    /**
+     * By parent Resource, then by its relation: the fields above that a create
+     * nested through that relation gets from its parent, so it is not required
+     * there. `{ "User": { "posts": ["author", "authorId"] } }`: a post created in
+     * `User.posts` needs neither `author` nor `authorId`; a group any of whose
+     * fields is listed is satisfied whole.
+     */
+    readonly parentSupplies?: Readonly<Record<string, Readonly<Record<string, readonly [string, ...string[]]>>>>;
+};

package/dist/contracts/create-requirements.js

@@ -0,0 +1 @@
+export {};

package/dist/contracts/enum-definition.d.ts

@@ -1,5 +1,5 @@
 /** An enum: its allowed values. */
-export type EnumDefinition = {
+export type AvEnumDefinition = {
     /** The allowed values, in declaration order. */
     readonly values: readonly string[];
 };

package/dist/contracts/field-check.d.ts

@@ -0,0 +1,101 @@
+/** The named string formats: what `AvZ.email()`, `AvZ.uuid()` and the rest check. */
+export type AvFieldCheckFormat = "email" | "url" | "emoji" | "uuid" | "guid" | "nanoid" | "cuid" | "cuid2" | "ulid" | "xid" | "ksuid" | "datetime" | "date" | "time" | "duration" | "ipv4" | "ipv6" | "cidrv4" | "cidrv6" | "base64" | "base64url" | "json_string" | "e164" | "credit_card" | "iban" | "jwt";
+/**
+ * A bound on a value (`AvZ.lt`, `AvZ.gte`, `AvZ.positive`, …). `value` is a number
+ * for an `int` or `float` field and a Json number; for a `bigint`, `decimal` or
+ * `datetime` field it is the bound's wire string.
+ */
+export type AvFieldRangeCheck = {
+    readonly check: "less_than" | "greater_than";
+    readonly value: number | string;
+    readonly inclusive: boolean;
+};
+/** `AvZ.multipleOf`: `value` is written as {@link AvFieldRangeCheck}'s is. */
+export type AvFieldMultipleCheck = {
+    readonly check: "multiple_of";
+    readonly value: number | string;
+};
+/** A length bound: a string's, or with `list: true` a list's. */
+export type AvFieldLengthCheck = {
+    readonly check: "max_length";
+    readonly maximum: number;
+    readonly list?: true;
+} | {
+    readonly check: "min_length";
+    readonly minimum: number;
+    readonly list?: true;
+} | {
+    readonly check: "length_equals";
+    readonly length: number;
+};
+/** A pattern or a named format a string must match. */
+export type AvFieldFormatCheck = {
+    readonly check: "string_format";
+    readonly format: "regex";
+    /** A JavaScript regular expression: its `source` and its `flags`. */
+    readonly pattern: {
+        readonly source: string;
+        readonly flags: string;
+    };
+} | {
+    readonly check: "string_format";
+    readonly format: "includes";
+    readonly includes: string;
+} | {
+    readonly check: "string_format";
+    readonly format: "starts_with";
+    readonly prefix: string;
+} | {
+    readonly check: "string_format";
+    readonly format: "ends_with";
+    readonly suffix: string;
+} | {
+    readonly check: "string_format";
+    readonly format: "lowercase" | "uppercase" | AvFieldCheckFormat;
+};
+/** A `bytes` value's byte length. */
+export type AvFieldSizeCheck = {
+    readonly check: "max_size";
+    readonly maximum: number;
+} | {
+    readonly check: "min_size";
+    readonly minimum: number;
+} | {
+    readonly check: "size_equals";
+    readonly size: number;
+};
+/**
+ * One field validator as the Contract stores it: its check's name (`check`) and
+ * the check's parameters.
+ */
+export type AvFieldCheck = AvFieldRangeCheck | AvFieldMultipleCheck | AvFieldLengthCheck | AvFieldFormatCheck | AvFieldSizeCheck;
+/** The checks a Json Shape's string node may carry: its length, a pattern or a format. */
+export type AvJsonStringCheck = {
+    readonly check: "max_length";
+    readonly maximum: number;
+} | {
+    readonly check: "min_length";
+    readonly minimum: number;
+} | {
+    readonly check: "length_equals";
+    readonly length: number;
+} | AvFieldFormatCheck;
+/** The checks a Json Shape's number or integer node may carry: bounds are numbers. */
+export type AvJsonNumberCheck = {
+    readonly check: "less_than" | "greater_than";
+    readonly value: number;
+    readonly inclusive: boolean;
+} | {
+    readonly check: "multiple_of";
+    readonly value: number;
+};
+/** The checks a Json Shape's array node may carry: its length. */
+export type AvJsonListCheck = {
+    readonly check: "max_length";
+    readonly maximum: number;
+    readonly list: true;
+} | {
+    readonly check: "min_length";
+    readonly minimum: number;
+    readonly list: true;
+};

package/dist/contracts/field-check.js

@@ -0,0 +1 @@
+export {};

package/dist/contracts/field.d.ts

@@ -1,72 +1,76 @@
-import type { PaginationCapability, ProjectionScope, RelationFilterCapability, RelationMutationDirective, RelationReducer, ScalarFilterOperator, ScalarMutationDirective, WriteScope } from "./capability.js";
-import type { Contract } from "./contract.js";
+import type { AvPaginationCapability, AvProjectionScope, AvRelationFilterCapability, AvRelationMutationDirective, AvRelationReducer, AvScalarFilterOperator, AvScalarMutationDirective, AvWriteScope } from "./capability.js";
+import type { AvContract } from "./contract.js";
+import type { AvFieldCheck } from "./field-check.js";
 import type { JsonSchema } from "./json-shape.js";
-import type { LifecycleTrait } from "./lifecycle-trait.js";
+import type { AvLifecycleTrait } from "./lifecycle-trait.js";
 /** A format name that refines a scalar type, carried in the Contract as data. */
-export type ScalarFormat = string;
+export type AvScalarFormat = string;
 /** The projection positions a field can be selected in (at least one). */
-export type ProjectionScopes = readonly [ProjectionScope, ...ProjectionScope[]];
+export type AvProjectionScopes = readonly [
+    AvProjectionScope,
+    ...AvProjectionScope[]
+];
 /**
  * The write positions a field can be written in (at least one). A scope list
- * applies to the top level of a write argument only; see {@link WriteScope}.
+ * applies to the top level of a write argument only; see {@link AvWriteScope}.
  */
-export type WriteScopes = readonly [WriteScope, ...WriteScope[]];
+export type AvWriteScopes = readonly [AvWriteScope, ...AvWriteScope[]];
 /**
  * Whether a relation can be selected or included: `true`, or the projection
  * positions it can be used in.
  */
-export type RelationProjectionCapability = boolean | ProjectionScopes;
+export type AvRelationProjectionCapability = boolean | AvProjectionScopes;
 /**
  * The reducers a relation admits, qualified by the projection positions they are
  * admitted in. The reducer list and the scope list are separate facts: `$count` is
  * one of a closed set of reducers, and the scopes say where the reducer may be
  * asked for.
  */
-export type ScopedRelationReducers = {
-    readonly reducers: readonly RelationReducer[];
-    readonly scopes: ProjectionScopes;
+export type AvScopedRelationReducers = {
+    readonly reducers: readonly AvRelationReducer[];
+    readonly scopes: AvProjectionScopes;
 };
 /**
  * A relation's reducers: a reducer list, or an object with the reducers and
  * the projection positions they apply in.
  */
-export type RelationReducerCapability = readonly RelationReducer[] | ScopedRelationReducers;
+export type AvRelationReducerCapability = readonly AvRelationReducer[] | AvScopedRelationReducers;
 /**
  * The mutation directives a relation admits at one write stage, and the write
  * positions they are admitted in. `directives: []` means writable with no
  * directive.
  */
-export type ScopedRelationMutations = {
-    readonly directives: readonly RelationMutationDirective[];
-    readonly scopes: WriteScopes;
+export type AvScopedRelationMutations = {
+    readonly directives: readonly AvRelationMutationDirective[];
+    readonly scopes: AvWriteScopes;
 };
 /**
  * A relation's write capability for `create` or `update`: a directive list, or
  * an object with the directives and the write positions they apply in.
  */
-export type RelationMutationCapability = readonly RelationMutationDirective[] | ScopedRelationMutations;
+export type AvRelationMutationCapability = readonly AvRelationMutationDirective[] | AvScopedRelationMutations;
 /** What can be done with a scalar field. Scalar capabilities apply in every position. */
-export type ScalarFieldCapabilities = {
+export type AvScalarFieldCapabilities = {
     readonly select?: boolean;
-    readonly filter?: readonly ScalarFilterOperator[];
+    readonly filter?: readonly AvScalarFilterOperator[];
     readonly order?: boolean;
     readonly orderNulls?: boolean;
-    readonly create?: readonly ScalarMutationDirective[];
-    readonly update?: readonly ScalarMutationDirective[];
+    readonly create?: readonly AvScalarMutationDirective[];
+    readonly update?: readonly AvScalarMutationDirective[];
 };
 /** What can be done with a relation field. */
-export type RelationFieldCapabilities = {
-    readonly select?: RelationProjectionCapability;
-    readonly include?: RelationProjectionCapability;
-    readonly filter?: readonly RelationFilterCapability[];
+export type AvRelationFieldCapabilities = {
+    readonly select?: AvRelationProjectionCapability;
+    readonly include?: AvRelationProjectionCapability;
+    readonly filter?: readonly AvRelationFilterCapability[];
     readonly order?: boolean;
-    readonly pagination?: readonly PaginationCapability[];
-    readonly reducers?: RelationReducerCapability;
-    readonly create?: RelationMutationCapability;
-    readonly update?: RelationMutationCapability;
+    readonly pagination?: readonly AvPaginationCapability[];
+    readonly reducers?: AvRelationReducerCapability;
+    readonly create?: AvRelationMutationCapability;
+    readonly update?: AvRelationMutationCapability;
     /**
      * What the `where` of a nested `$update` or `$delete` through this relation may
-     * filter: `"scalar"` — the target's scalar fields only, combined with
+     * filter: `"scalar"` means the target's scalar fields only, combined with
      * `AND`/`OR`/`NOT`, and no relation filter at any depth. Absent: any filter the
      * target takes.
      */
@@ -76,53 +80,59 @@ export type RelationFieldCapabilities = {
  * The reducers a relation advertises, in any projection position. Use
  * {@link advertisedReducersAt} for one position.
  */
-export declare function advertisedReducers(capability: RelationReducerCapability | undefined): readonly RelationReducer[] | undefined;
+export declare function advertisedReducers(capability: AvRelationReducerCapability | undefined): readonly AvRelationReducer[] | undefined;
 /** Whether a projection capability holds at one projection position. */
-export declare function holdsAt(capability: RelationProjectionCapability | undefined, scope: ProjectionScope): boolean;
+export declare function holdsAt(capability: AvRelationProjectionCapability | undefined, scope: AvProjectionScope): boolean;
 /**
  * Whether a projection capability holds in **any** projection position. Use
  * {@link holdsAt} when the position is known.
  */
-export declare function holdsInAnyScope(capability: RelationProjectionCapability | undefined): boolean;
+export declare function holdsInAnyScope(capability: AvRelationProjectionCapability | undefined): boolean;
 /**
  * The reducers a relation advertises at one projection position, or
  * `undefined` where it has none there.
  */
-export declare function advertisedReducersAt(capability: RelationReducerCapability | undefined, scope: ProjectionScope): readonly RelationReducer[] | undefined;
+export declare function advertisedReducersAt(capability: AvRelationReducerCapability | undefined, scope: AvProjectionScope): readonly AvRelationReducer[] | undefined;
 /**
  * The mutation directives a relation advertises at one write stage, in any
  * write position. `undefined` means the stage is unavailable; `[]` means
  * available with no directive.
  */
-export declare function advertisedDirectives(capability: RelationMutationCapability | undefined): readonly RelationMutationDirective[] | undefined;
+export declare function advertisedDirectives(capability: AvRelationMutationCapability | undefined): readonly AvRelationMutationDirective[] | undefined;
 /**
  * The mutation directives a relation advertises at one write position, or
  * `undefined` where it is not writable there.
  */
-export declare function advertisedDirectivesAt(capability: RelationMutationCapability | undefined, scope: WriteScope): readonly RelationMutationDirective[] | undefined;
+export declare function advertisedDirectivesAt(capability: AvRelationMutationCapability | undefined, scope: AvWriteScope): readonly AvRelationMutationDirective[] | undefined;
 /** A scalar field, including an enum-backed one. */
-export type ScalarField<C extends Contract> = {
+export type AvScalarField<C extends AvContract> = {
     readonly kind: "scalar";
     readonly type: {
         readonly scalar: Extract<keyof C["scalars"], string>;
     } | {
         readonly enum: Extract<keyof C["enums"], string>;
     };
-    readonly format?: ScalarFormat;
+    readonly format?: AvScalarFormat;
     readonly nullable: boolean;
     readonly list: boolean;
-    readonly lifecycle: readonly LifecycleTrait[];
-    readonly capabilities: ScalarFieldCapabilities;
+    readonly lifecycle: readonly AvLifecycleTrait[];
+    readonly capabilities: AvScalarFieldCapabilities;
     /** A `json` field's shape, as JSON Schema: what every value written to it is. */
     readonly json?: JsonSchema;
+    /**
+     * The field's validators: the root's checks, then the overlay's, in
+     * registration order. On a list field a check applies to each entry, except a
+     * `list: true` length check, which applies to the list.
+     */
+    readonly validators?: readonly AvFieldCheck[];
 };
 /** A relation field; the `target` Resource describes the related row. */
-export type RelationField<C extends Contract> = {
+export type AvRelationField<C extends AvContract> = {
     readonly kind: "relation";
     readonly target: Extract<keyof C["resources"], string>;
     readonly cardinality: "one" | "many";
     readonly nullable: boolean;
-    readonly capabilities: RelationFieldCapabilities;
+    readonly capabilities: AvRelationFieldCapabilities;
 };
 /** One field of a Resource: a scalar or a relation. */
-export type Field<C extends Contract> = ScalarField<C> | RelationField<C>;
+export type AvField<C extends AvContract> = AvScalarField<C> | AvRelationField<C>;

package/dist/contracts/identifier.d.ts

@@ -1,7 +1,7 @@
-import type { Contract } from "./contract.js";
-import type { Field } from "./field.js";
+import type { AvContract } from "./contract.js";
+import type { AvField } from "./field.js";
 /** Keys of `TFields` whose field can be scalar-shaped. */
-export type ScalarFieldKey<TFields extends Readonly<Record<string, Field<Contract>>>> = Extract<{
+export type AvScalarFieldKey<TFields extends Readonly<Record<string, AvField<AvContract>>>> = Extract<{
     [K in keyof TFields]: [
         Extract<TFields[K], {
             readonly kind: "scalar";
@@ -9,4 +9,4 @@ export type ScalarFieldKey<TFields extends Readonly<Record<string, Field<Contrac
     ] extends [never] ? never : K;
 }[keyof TFields], string>;
 /** Non-empty tuple of scalar field keys that identifies at most one Resource. */
-export type Identifier<TFields extends Readonly<Record<string, Field<Contract>>>> = readonly [ScalarFieldKey<TFields>, ...ScalarFieldKey<TFields>[]];
+export type AvIdentifier<TFields extends Readonly<Record<string, AvField<AvContract>>>> = readonly [AvScalarFieldKey<TFields>, ...AvScalarFieldKey<TFields>[]];

package/dist/contracts/json-shape.d.ts

@@ -1,3 +1,4 @@
+import type { AvJsonListCheck, AvJsonNumberCheck, AvJsonStringCheck } from "./field-check.js";
 /**
  * The phantom key a Json Shape's TypeScript type travels under. Type-level only:
  * no value ever holds it.
@@ -20,7 +21,15 @@ export type JsonSchemaPrimitive = string | number | boolean | null;
  * the forms Aventara emits.
  */
 export type JsonSchema = {
-    readonly type: "string" | "number" | "integer" | "boolean" | "null";
+    readonly type: "boolean" | "null";
+} | {
+    readonly type: "string";
+    /** The node's checks, in the order they were added. */
+    readonly checks?: readonly AvJsonStringCheck[];
+} | {
+    readonly type: "number" | "integer";
+    /** The node's checks, in the order they were added. */
+    readonly checks?: readonly AvJsonNumberCheck[];
 } | {
     readonly const: JsonSchemaPrimitive;
 } | {
@@ -39,6 +48,8 @@ export type JsonSchema = {
 } | {
     readonly type: "array";
     readonly items: JsonSchema;
+    /** The list's length checks, in the order they were added. */
+    readonly checks?: readonly AvJsonListCheck[];
 } | {
     readonly type: "array";
     readonly prefixItems: readonly [JsonSchema, ...JsonSchema[]];

package/dist/contracts/lifecycle-trait.d.ts

@@ -1,8 +1,8 @@
 /**
  * Where a field's value comes from, without saying whether it is writable:
  * `DEFAULTED` and `GENERATED_ON_*` by the data source, `COMPUTED_ON_*` by a
- * framework behavior; `VIRTUAL` marks a field that is not stored.
+ * compute stage; `VIRTUAL` marks a field that is not stored.
  */
 export declare const LIFECYCLE_TRAITS: readonly ["DEFAULTED", "GENERATED_ON_CREATE", "GENERATED_ON_UPDATE", "COMPUTED_ON_CREATE", "COMPUTED_ON_UPDATE", "COMPUTED_ON_READ", "VIRTUAL"];
 /** One of {@link LIFECYCLE_TRAITS}. */
-export type LifecycleTrait = (typeof LIFECYCLE_TRAITS)[number];
+export type AvLifecycleTrait = (typeof LIFECYCLE_TRAITS)[number];

package/dist/contracts/resource-operations.d.ts

@@ -1,62 +1,62 @@
-import type { ProjectionScope, WriteScope } from "./capability.js";
+import type { AvProjectionScope, AvWriteScope } from "./capability.js";
 /**
  * The argument scopes one advertised operation variant qualifies its arguments
  * with: which projection position its projection arguments sit in, and which write
  * position its data argument sits in.
  */
-export type OperationVariantScopes = {
-    readonly projection: ProjectionScope;
-    readonly write?: WriteScope;
+export type AvOperationVariantScopes = {
+    readonly projection: AvProjectionScope;
+    readonly write?: AvWriteScope;
 } | {
-    readonly projection?: ProjectionScope;
-    readonly write: WriteScope;
+    readonly projection?: AvProjectionScope;
+    readonly write: AvWriteScope;
 };
 /**
  * Availability of one standard operation variant: `true` for "available, with no
  * scope qualification stated", or the scopes the variant qualifies its arguments
  * with.
  */
-export type OperationAvailability = true | OperationVariantScopes;
+export type AvOperationAvailability = true | AvOperationVariantScopes;
 /** Availability of protocol-defined standard operations for one Resource. */
-export type ResourceOperations = {
+export type AvResourceOperations = {
     readonly find?: {
-        readonly first?: OperationAvailability;
-        readonly unique?: OperationAvailability;
-        readonly many?: OperationAvailability;
-        readonly count?: OperationAvailability;
+        readonly first?: AvOperationAvailability;
+        readonly unique?: AvOperationAvailability;
+        readonly many?: AvOperationAvailability;
+        readonly count?: AvOperationAvailability;
     };
     readonly create?: {
-        readonly one?: OperationAvailability;
-        readonly many?: OperationAvailability;
-        readonly count?: OperationAvailability;
+        readonly one?: AvOperationAvailability;
+        readonly many?: AvOperationAvailability;
+        readonly count?: AvOperationAvailability;
     };
     readonly update?: {
-        readonly first?: OperationAvailability;
-        readonly unique?: OperationAvailability;
-        readonly many?: OperationAvailability;
-        readonly count?: OperationAvailability;
+        readonly first?: AvOperationAvailability;
+        readonly unique?: AvOperationAvailability;
+        readonly many?: AvOperationAvailability;
+        readonly count?: AvOperationAvailability;
     };
     readonly delete?: {
-        readonly first?: OperationAvailability;
-        readonly unique?: OperationAvailability;
-        readonly many?: OperationAvailability;
-        readonly count?: OperationAvailability;
+        readonly first?: AvOperationAvailability;
+        readonly unique?: AvOperationAvailability;
+        readonly many?: AvOperationAvailability;
+        readonly count?: AvOperationAvailability;
     };
     readonly upsert?: {
-        readonly unique?: OperationAvailability;
+        readonly unique?: AvOperationAvailability;
     };
 };
 /**
- * Whether one `ResourceOperations` entry marks its variant available: it is
+ * Whether one `AvResourceOperations` entry marks its variant available: it is
  * `true` or an argument-position descriptor.
  */
-export declare function isOperationVariantAvailable(availability: unknown): availability is OperationAvailability;
+export declare function isOperationVariantAvailable(availability: unknown): availability is AvOperationAvailability;
 /**
  * The projection position one advertised variant's projection arguments sit in.
  */
-export declare function projectionScopeOf(availability: unknown): ProjectionScope;
+export declare function projectionScopeOf(availability: unknown): AvProjectionScope;
 /**
  * The write position one advertised variant's data argument sits in, and the write
  * mirror of {@link projectionScopeOf}.
  */
-export declare function writeScopeOf(availability: unknown): WriteScope;
+export declare function writeScopeOf(availability: unknown): AvWriteScope;

package/dist/contracts/resource.d.ts

@@ -1,12 +1,18 @@
-import type { Contract } from "./contract.js";
-import type { Field } from "./field.js";
-import type { Identifier } from "./identifier.js";
-import type { ResourceOperations } from "./resource-operations.js";
+import type { AvContract } from "./contract.js";
+import type { AvCreateRequirements } from "./create-requirements.js";
+import type { AvField } from "./field.js";
+import type { AvIdentifier } from "./identifier.js";
+import type { AvResourceOperations } from "./resource-operations.js";
 /** A Resource's fields, by name. */
-export type ResourceFieldMap<C extends Contract> = Readonly<Record<string, Field<C>>>;
-/** One Resource: its fields, identifiers and available operations. */
-export type Resource<C extends Contract, TFields extends ResourceFieldMap<C> = ResourceFieldMap<C>> = {
+export type AvResourceFieldMap<C extends AvContract> = Readonly<Record<string, AvField<C>>>;
+/**
+ * One Resource: its fields, identifiers and available operations, and what a
+ * create of it cannot do without.
+ */
+export type AvResource<C extends AvContract, TFields extends AvResourceFieldMap<C> = AvResourceFieldMap<C>> = {
     readonly fields: TFields;
-    readonly identifiers: readonly Identifier<TFields>[];
-    readonly operations: ResourceOperations;
+    readonly identifiers: readonly AvIdentifier<TFields>[];
+    readonly operations: AvResourceOperations;
+    /** What a create must write; absent when it requires nothing. */
+    readonly createRequirements?: AvCreateRequirements;
 };

package/dist/contracts/scalar-value-type.d.ts

@@ -1,42 +1,42 @@
-import type { Decimal } from "../runtime/decimal.js";
-import type { JsonValue } from "../runtime/json-value.js";
-import type { Contract } from "./contract.js";
-import type { ScalarField } from "./field.js";
+import type { AvDecimal } from "../runtime/decimal.js";
+import type { AvJsonValue } from "../runtime/json-value.js";
+import type { AvContract } from "./contract.js";
+import type { AvScalarField } from "./field.js";
 import type { JsonFieldType } from "./json-shape.js";
-import type { BuiltInScalar } from "./scalar.js";
+import type { AvBuiltInScalar } from "./scalar.js";
 /**
  * A scalar-form map: the TypeScript type each built-in scalar takes on one side
  * of a boundary. Every built-in must be listed.
  */
 export type ScalarForms = {
-    readonly [Scalar in BuiltInScalar]: unknown;
+    readonly [Scalar in AvBuiltInScalar]: unknown;
 };
 /**
  * The TypeScript form each built-in scalar takes in process: in results of
  * either origin, and in `framework.application` arguments. `decimal` is
- * Aventara's own {@link Decimal}.
+ * Aventara's own {@link AvDecimal}.
  */
-export type ApplicationScalarForms = {
+export type AvApplicationScalarForms = {
     readonly string: string;
     readonly boolean: boolean;
     readonly int: number;
     readonly float: number;
     readonly bigint: bigint;
-    readonly decimal: Decimal;
+    readonly decimal: AvDecimal;
     readonly datetime: Date;
     readonly bytes: Uint8Array;
     /**
      * Any JSON value. A field-level `null` is the field's absence and is allowed
      * only where the field is nullable; a `null` inside the value is JSON's own.
      */
-    readonly json: Exclude<JsonValue, null>;
+    readonly json: Exclude<AvJsonValue, null>;
 };
 /**
  * The encoded forms of the built-in scalars: base-10 bigint strings, decimal strings,
  * canonical ISO-8601 UTC datetimes and RFC 4648 base64 bytes. For a transport or a
  * generated client to pass as `Forms`.
  */
-export type WireScalarForms = {
+export type AvWireScalarForms = {
     readonly string: string;
     readonly boolean: boolean;
     readonly int: number;
@@ -46,10 +46,10 @@ export type WireScalarForms = {
     readonly datetime: string;
     readonly bytes: string;
     /** The same as in process: a JSON value needs no encoding to cross a JSON wire. */
-    readonly json: Exclude<JsonValue, null>;
+    readonly json: Exclude<AvJsonValue, null>;
 };
 /** One value of a scalar field, before `list` and `nullable` apply. */
-export type ScalarAtom<C extends Contract, Type, Forms extends ScalarForms> = Type extends {
+export type ScalarAtom<C extends AvContract, Type, Forms extends ScalarForms> = Type extends {
     readonly enum: infer Enum extends keyof C["enums"];
 } ? C["enums"][Enum]["values"][number] : Type extends {
     readonly scalar: infer Scalar;
@@ -58,7 +58,7 @@ export type ScalarAtom<C extends Contract, Type, Forms extends ScalarForms> = Ty
  * One value of a scalar field, before `list` and `nullable` apply: its Json
  * Shape's type where the field is shaped, otherwise {@link ScalarAtom}.
  */
-export type FieldAtom<C extends Contract, Field extends {
+export type FieldAtom<C extends AvContract, Field extends {
     readonly type: unknown;
     readonly json?: unknown;
 }, Forms extends ScalarForms> = Field extends {
@@ -78,5 +78,5 @@ type ListValue<List, Atom> = [List] extends [false] ? Atom : [List] extends [tru
  * - `list: true` → `readonly T[]`, whose entries are never `null`;
  * - `nullable: true` → `| null`, on the whole value, list or not.
  */
-export type ScalarValueType<C extends Contract, Field extends ScalarField<C>, Forms extends ScalarForms = ApplicationScalarForms> = ListValue<Field["list"], FieldAtom<C, Field, Forms>> | (true extends Field["nullable"] ? null : never);
+export type AvScalarValueType<C extends AvContract, Field extends AvScalarField<C>, Forms extends ScalarForms = AvApplicationScalarForms> = ListValue<Field["list"], FieldAtom<C, Field, Forms>> | (true extends Field["nullable"] ? null : never);
 export {};

package/dist/contracts/scalar.d.ts

@@ -1,10 +1,10 @@
 /** The built-in scalar types of the Aventara protocol. */
 export declare const BUILT_IN_SCALARS: readonly ["string", "boolean", "int", "float", "bigint", "decimal", "datetime", "bytes", "json"];
 /** One of {@link BUILT_IN_SCALARS}. */
-export type BuiltInScalar = (typeof BUILT_IN_SCALARS)[number];
+export type AvBuiltInScalar = (typeof BUILT_IN_SCALARS)[number];
 /** One entry of a scalar registry. */
-export type ScalarDefinition = {
+export type AvScalarDefinition = {
     readonly builtin: true;
 };
 /** The scalar types an adapter model or Contract supports, by name. */
-export type ScalarRegistry = Readonly<Record<string, ScalarDefinition>>;
+export type AvScalarRegistry = Readonly<Record<string, AvScalarDefinition>>;

package/dist/contracts/transaction-capability.d.ts

@@ -1,4 +1,4 @@
 /** The transaction capabilities. */
 export declare const TRANSACTION_CAPABILITIES: readonly ["none", "interactive"];
 /** `"none"` or `"interactive"`: whether transactions can run. */
-export type TransactionCapability = (typeof TRANSACTION_CAPABILITIES)[number];
+export type AvTransactionCapability = (typeof TRANSACTION_CAPABILITIES)[number];

package/dist/contracts/wire-scalar-format.d.ts

@@ -1,5 +1,5 @@
-import type { BuiltInScalar } from "./scalar.js";
-import type { ApplicationScalarForms, WireScalarForms } from "./scalar-value-type.js";
+import type { AvBuiltInScalar } from "./scalar.js";
+import type { AvApplicationScalarForms, AvWireScalarForms } from "./scalar-value-type.js";
 /**
  * The built-in scalars whose wire form is not their runtime form — the ones a JSON
  * wire carries as a string with a grammar of its own. Derived from the two form maps
@@ -7,8 +7,8 @@ import type { ApplicationScalarForms, WireScalarForms } from "./scalar-value-typ
  * compile below until its grammar is written.
  */
 type WireEncodedScalar = {
-    readonly [S in BuiltInScalar]: WireScalarForms[S] extends ApplicationScalarForms[S] ? never : S;
-}[BuiltInScalar];
+    readonly [S in AvBuiltInScalar]: AvWireScalarForms[S] extends AvApplicationScalarForms[S] ? never : S;
+}[AvBuiltInScalar];
 /**
  * `AvProtocol.scalarFormats` — the wire grammars of protocol version 1, as passive
  * data: one anchored pattern SOURCE string per wire-encoded scalar, in