@aventara/core 0.1.0-pilot.4 → 1.0.0-rc.1

package/dist/contracts/contract-limits.js

@@ -4,4 +4,5 @@ export const DEFAULT_CONTRACT_LIMITS = {
     maxListLimit: 250,
     maxTransactionOperations: 20,
     maxBooleanNodes: 50,
+    maxJsonDepth: 64,
 };

package/dist/contracts/contract-lookup.d.ts

@@ -1,6 +1,6 @@
-import type { Contract } from "./contract.js";
-import type { Field } from "./field.js";
-import type { Resource } from "./resource.js";
+import type { AvContract } from "./contract.js";
+import type { AvField } from "./field.js";
+import type { AvResource } from "./resource.js";
 /**
  * Own-property lookups over Contract registries.
  *
@@ -12,5 +12,5 @@ import type { Resource } from "./resource.js";
  * must go through here so an unknown key is unknown, whatever its name.
  */
 export declare function lookupOwn<T>(registry: Readonly<Record<string, T>> | undefined, key: string): T | undefined;
-export declare function lookupResource<C extends Contract>(contract: C, resourceName: string): Resource<C> | undefined;
-export declare function lookupField<C extends Contract>(resource: Resource<C> | undefined, fieldName: string): Field<C> | undefined;
+export declare function lookupResource<C extends AvContract>(contract: C, resourceName: string): AvResource<C> | undefined;
+export declare function lookupField<C extends AvContract>(resource: AvResource<C> | undefined, fieldName: string): AvField<C> | undefined;

package/dist/contracts/contract-protocol.d.ts

@@ -5,13 +5,13 @@
  */
 export declare const AVENTARA_PROTOCOL_VERSION: 1;
 /** A Contract hash: `sha256:` followed by the hex digest. */
-export type ContractHash = `sha256:${string}`;
+export type AvContractHash = `sha256:${string}`;
 /** The protocol a Contract is written for. */
-export type ContractProtocol = {
+export type AvContractProtocol = {
     /** The protocol version; see {@link AVENTARA_PROTOCOL_VERSION}. */
     readonly version: typeof AVENTARA_PROTOCOL_VERSION;
 };
 /** A ClientContract's `protocol`: the protocol version and the Contract hash. */
-export type ClientContractProtocol = ContractProtocol & {
-    readonly hash: ContractHash;
+export type AvContractClientProtocol = AvContractProtocol & {
+    readonly hash: AvContractHash;
 };

package/dist/contracts/contract.d.ts

@@ -1,33 +1,48 @@
-import type { ContractLimits } from "./contract-limits.js";
-import type { ClientContractProtocol } from "./contract-protocol.js";
-import type { EnumDefinition } from "./enum-definition.js";
-import type { Resource } from "./resource.js";
-import type { ScalarRegistry } from "./scalar.js";
-import type { TransactionCapability } from "./transaction-capability.js";
+import type { AvContractLimits } from "./contract-limits.js";
+import type { AvContractClientProtocol } from "./contract-protocol.js";
+import type { AvEnumDefinition } from "./enum-definition.js";
+import type { ReferenceWriteLimit } from "./reference-write-limit.js";
+import type { AvResource } from "./resource.js";
+import type { AvScalarRegistry } from "./scalar.js";
+import type { AvTransactionCapability } from "./transaction-capability.js";
 /** What every Contract describes: scalars, enums, Resources, limits and transactions. */
-export interface Contract {
+export interface AvContract {
     /** The scalar types available. */
-    readonly scalars: ScalarRegistry;
+    readonly scalars: AvScalarRegistry;
     /** The enums, by name. */
-    readonly enums: Readonly<Record<string, EnumDefinition>>;
+    readonly enums: Readonly<Record<string, AvEnumDefinition>>;
     /** The Resources, by name. */
-    readonly resources: Readonly<Record<string, Resource<this>>>;
+    readonly resources: Readonly<Record<string, AvResource<this>>>;
     /** The request limits in force. */
-    readonly limits: ContractLimits;
+    readonly limits: AvContractLimits;
     /** Whether interactive transactions are available. */
-    readonly transactions: TransactionCapability;
+    readonly transactions: AvTransactionCapability;
+    /**
+     * `"uniform"` when one record must write the relations that hold a reference
+     * either all as relations or all through their reference fields; a record
+     * that mixes them is refused with `A2004`. Absent: each relation either way.
+     */
+    readonly referenceWrites?: ReferenceWriteLimit;
 }
 /** The Contract compiled from the root configuration. */
-export interface CoreContract extends Contract {
+export interface AvContractCore extends AvContract {
 }
 /** The Contract in-process calls run under (`framework.application`). */
-export interface ApplicationContract extends Contract {
+export interface AvContractApplication extends AvContract {
 }
 /**
  * The Contract remote clients run under, published at `GET /_contract` and
  * identified by its hash.
  */
-export interface ClientContract extends Contract {
+export interface AvContractClient extends AvContract {
     /** The protocol version and this Contract's hash. */
-    readonly protocol: ClientContractProtocol;
+    readonly protocol: AvContractClientProtocol;
+}
+/**
+ * The Contract an AI agent's calls run under (the `agent` layer), identified by
+ * its hash. MCP tools are built from it.
+ */
+export interface AvContractAgent extends AvContract {
+    /** The protocol version and this Contract's hash. */
+    readonly protocol: AvContractClientProtocol;
 }

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,118 +1,138 @@
-import type { PaginationCapability, ProjectionScope, RelationFilterCapability, RelationMutationDirective, RelationReducer, ScalarFilterOperator, ScalarMutationDirective, WriteScope } from "./capability.js";
-import type { Contract } from "./contract.js";
-import type { LifecycleTrait } from "./lifecycle-trait.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 { 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"` 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.
+     */
+    readonly nestedWriteFilter?: "scalar";
 };
 /**
  * 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

@@ -0,0 +1,76 @@
+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.
+ */
+declare const jsonShapeValue: unique symbol;
+/**
+ * A Json Shape, as the type system sees it: the TypeScript type `Value` of a
+ * value that conforms to it. `AvZ` builds every one; a value from anywhere else —
+ * a Zod schema included — is not one.
+ */
+export interface JsonShape<Value = unknown> {
+    readonly [jsonShapeValue]: Value;
+}
+/** The TypeScript type a {@link JsonShape} describes. */
+export type JsonShapeValue<Shape extends JsonShape> = Shape[typeof jsonShapeValue];
+/** A JSON primitive: what a `const` names. */
+export type JsonSchemaPrimitive = string | number | boolean | null;
+/**
+ * A Json Shape in a Contract: passive JSON Schema (draft 2020-12), restricted to
+ * the forms Aventara emits.
+ */
+export type JsonSchema = {
+    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;
+} | {
+    readonly type: "string";
+    readonly enum: readonly [string, ...string[]];
+} | {
+    readonly type: "object";
+    readonly properties: {
+        readonly [key: string]: JsonSchema;
+    };
+    readonly required?: readonly string[];
+    readonly additionalProperties: false;
+} | {
+    readonly type: "object";
+    readonly additionalProperties: 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[]];
+    readonly items: false;
+    readonly minItems: number;
+    readonly maxItems: number;
+} | {
+    readonly anyOf: readonly [JsonSchema, JsonSchema, ...JsonSchema[]];
+} | {
+    readonly oneOf: readonly [JsonSchema, ...JsonSchema[]];
+};
+/**
+ * The type-level carrier of a shaped Json field's TypeScript type, on the field's
+ * `json` member in a typed Contract view. Never present at runtime.
+ */
+export type JsonFieldType<Value> = {
+    readonly "~jsonType": Value;
+};
+/**
+ * A shaped Json field's `json` member in a typed Contract view: the schema, and
+ * the type it describes.
+ */
+export type ShapedJsonSchema<Value> = JsonSchema & JsonFieldType<Value>;
+export {};

package/dist/contracts/json-shape.js

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

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/reference-write-limit.d.ts

@@ -0,0 +1,7 @@
+/** The limits a data source may put on how one record writes its references. */
+export declare const REFERENCE_WRITE_LIMITS: readonly ["uniform"];
+/**
+ * `"uniform"`: one record writes the relations that hold a reference either all
+ * as relations or all through their reference fields, never some each way.
+ */
+export type ReferenceWriteLimit = (typeof REFERENCE_WRITE_LIMITS)[number];

package/dist/contracts/reference-write-limit.js

@@ -0,0 +1 @@
+export const REFERENCE_WRITE_LIMITS = ["uniform"];