@aventara/core 1.0.0-rc.12 → 1.0.0-rc.14

package/dist/config/framework-exemptions-config.d.ts

@@ -8,8 +8,10 @@ import type { AvConfigResourceKey } from "./framework-field-definition.js";
 export type AvScalarFieldCapabilityName = "select" | "filter" | "order" | "orderNulls" | "create" | "update";
 /** The capability names a relation field's exemption can list. */
 export type AvRelationFieldCapabilityName = "select" | "include" | "filter" | "order" | "pagination" | "reducers" | "create" | "update";
-/** A scalar field's exemption: whole, by capability name, or per capability. */
-export type AvConfigScalarFieldExemption = boolean | readonly AvScalarFieldCapabilityName[] | ({
+/** The capabilities `"read"` names: every exemptable one but `create` and `update`. */
+export type ReadCapabilityName = Exclude<AvScalarFieldCapabilityName | AvRelationFieldCapabilityName, "create" | "update">;
+/** A scalar field's exemption: whole, its reads, by capability name, or per capability. */
+export type AvConfigScalarFieldExemption = boolean | "read" | readonly AvScalarFieldCapabilityName[] | ({
     readonly select?: boolean;
     readonly filter?: boolean | readonly AvScalarFilterOperator[];
     readonly order?: boolean;
@@ -17,8 +19,8 @@ export type AvConfigScalarFieldExemption = boolean | readonly AvScalarFieldCapab
     readonly create?: boolean | readonly AvScalarMutationDirective[];
     readonly update?: boolean | readonly AvScalarMutationDirective[];
 } & NotAList);
-/** A relation field's exemption: whole, by capability name, or per capability. */
-export type AvConfigRelationFieldExemption = boolean | readonly AvRelationFieldCapabilityName[] | ({
+/** A relation field's exemption: whole, its reads, by capability name, or per capability. */
+export type AvConfigRelationFieldExemption = boolean | "read" | readonly AvRelationFieldCapabilityName[] | ({
     readonly select?: boolean;
     readonly include?: boolean;
     readonly filter?: boolean | readonly AvRelationFilterCapability[];
@@ -58,13 +60,13 @@ type TokenExemption<Caps, K> = K extends keyof Caps ? boolean | readonly MemberT
 /** The capability names a discovered scalar's exemption can name: its own, and `select`. */
 type ScalarNameOf<Caps> = Extract<keyof Caps, AvScalarFieldCapabilityName> | "select";
 /** A discovered scalar field's exemption, by its capabilities. */
-type ScalarFieldExemptionOf<Caps> = boolean | readonly ScalarNameOf<Caps>[] | ({
+type ScalarFieldExemptionOf<Caps> = boolean | "read" | readonly ScalarNameOf<Caps>[] | ({
     readonly [K in ScalarNameOf<Caps>]?: K extends "filter" | "create" | "update" ? TokenExemption<Caps, K> : boolean;
 } & NotAList);
 /** The capability names a discovered relation's exemption can name: its own. */
 type RelationNameOf<Caps> = Extract<keyof Caps, AvRelationFieldCapabilityName>;
 /** A discovered relation field's exemption, by its capabilities. */
-type RelationFieldExemptionOf<Caps> = boolean | readonly RelationNameOf<Caps>[] | ({
+type RelationFieldExemptionOf<Caps> = boolean | "read" | readonly RelationNameOf<Caps>[] | ({
     readonly [K in RelationNameOf<Caps>]?: K extends "select" | "include" | "order" ? boolean : TokenExemption<Caps, K>;
 } & NotAList);
 /** The exemption shape one effective field name admits. */
@@ -74,10 +76,13 @@ type FieldExemptionFor<M extends AvAdapterModel, R extends AvConfigResourceKey<M
 } ? RelationFieldExemptionOf<Caps> : M["resources"][R]["fields"][F] extends {
     readonly capabilities: infer Caps;
 } ? ScalarFieldExemptionOf<Caps> : AvConfigScalarFieldExemption : AvConfigScalarFieldExemption;
-/** A Resource's exemption: whole, or its operations and fields. No list. */
+/**
+ * A Resource's exemption: whole, or its operations and fields, `fields` being
+ * per field or `"read"` (every field's reads). No list.
+ */
 export type AvConfigResourceExemption<M extends AvAdapterModel = AvAdapterModel, Cfg = AvConfigAny, R extends AvConfigResourceKey<M> = AvConfigResourceKey<M>> = boolean | ({
     readonly operations?: AvConfigOperationsExemption<M, R>;
-    readonly fields?: {
+    readonly fields?: "read" | {
         readonly [F in AvEffectiveFieldKey<M, Cfg, R>]?: FieldExemptionFor<M, R, F>;
     };
 } & NotAList);

package/dist/config/framework-resources-config.d.ts

@@ -59,13 +59,21 @@ export type AvConfigOverlayField<M extends AvAdapterModel = AvAdapterModel, Cfg
 };
 /** The checks a scalar type takes, or `never`. */
 type ScalarChecks<Scalar> = Scalar extends "string" ? AvZCheck<"string"> : Scalar extends "int" | "float" ? AvZCheck<"number"> : Scalar extends "bigint" | "decimal" | "datetime" | "bytes" ? AvZCheck<Scalar> : never;
+/** The checks a field's type takes, or `never` (an enum, a boolean). */
+type TypeChecks<Type> = Type extends {
+    readonly scalar: infer Scalar;
+} ? string extends Scalar ? AvZCheck : ScalarChecks<Scalar> : never;
+/** Why a field whose type takes no check refuses one; a list still takes its length. */
+type NoCheckRefusal<Type, List> = Type extends {
+    readonly enum: string;
+} ? false extends List ? "Error: an enum field takes no check: its enum already is the closed set of values it admits" : "Error: an enum list takes only a list length (AvZ.minItems, AvZ.maxItems): its enum already is the closed set of values it admits" : Type extends {
+    readonly scalar: infer Scalar extends string;
+} ? false extends List ? `Error: a ${Scalar} field takes no check` : `Error: a ${Scalar} list takes only a list length (AvZ.minItems, AvZ.maxItems)` : false extends List ? "Error: this field's type takes no check" : "Error: this field's type takes only a list length (AvZ.minItems, AvZ.maxItems)";
 /** The checks a discovered scalar field takes: its type's, and a list's length. */
 type FieldCheckOf<Field> = Field extends {
     readonly type: infer Type;
     readonly list: infer List;
-} ? (Type extends {
-    readonly scalar: infer Scalar;
-} ? string extends Scalar ? AvZCheck : ScalarChecks<Scalar> : never) | (false extends List ? never : AvZCheck<"list">) : AvZCheck;
+} ? ([TypeChecks<Type>] extends [never] ? NoCheckRefusal<Type, List> : TypeChecks<Type>) | (false extends List ? never : AvZCheck<"list">) : AvZCheck;
 /** A discovered scalar field's stages, its `validators` typed by the field. */
 type KnownScalarFieldPipeline<M extends AvAdapterModel, Cfg, R extends AvConfigResourceKey<M>, Field> = Field extends {
     readonly type: {

package/dist/contracts/client-contract-structure.validator.d.ts

@@ -1383,6 +1383,9 @@ export declare const CLIENT_CONTRACT_STRUCTURE: {
                 readonly maxTransactionOperations: {
                     readonly is: "number";
                 };
+                readonly maxTransactionWrites: {
+                    readonly is: "number";
+                };
                 readonly maxBooleanNodes: {
                     readonly is: "number";
                 };
@@ -1400,7 +1403,7 @@ export declare const CLIENT_CONTRACT_STRUCTURE: {
         };
         readonly transactions: {
             readonly is: "literal";
-            readonly values: readonly ["none", "interactive"];
+            readonly values: readonly ["none", "server", "interactive"];
         };
         readonly protocol: {
             readonly is: "object";

package/dist/contracts/client-contract-structure.validator.js

@@ -3,7 +3,7 @@ import { FILTER_MODES, PROJECTION_SCOPES, WRITE_SCOPES } from "./capability.js";
 import { AVENTARA_PROTOCOL_VERSION } from "./contract-protocol.js";
 import { LIFECYCLE_TRAITS } from "./lifecycle-trait.js";
 import { REFERENCE_WRITE_LIMITS } from "./reference-write-limit.js";
-import { TRANSACTION_CAPABILITIES } from "./transaction-capability.js";
+import { TRANSACTIONS_STYLES } from "./transaction-capability.js";
 const STRING = { is: "string" };
 const NUMBER = { is: "number" };
 const BOOLEAN = { is: "boolean" };
@@ -344,12 +344,13 @@ export const CLIENT_CONTRACT_STRUCTURE = object({
         maxNestingDepth: NUMBER,
         maxListLimit: NUMBER,
         maxTransactionOperations: NUMBER,
+        maxTransactionWrites: NUMBER,
         maxBooleanNodes: NUMBER,
         maxJsonDepth: NUMBER,
         maxAll: NUMBER,
         maxAllConcurrency: NUMBER,
     }),
-    transactions: literal(TRANSACTION_CAPABILITIES),
+    transactions: literal(TRANSACTIONS_STYLES),
     protocol: object({
         version: literal([AVENTARA_PROTOCOL_VERSION]),
         hash: { is: "prefixed", prefix: "sha256:" },

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

@@ -6,8 +6,14 @@ export type AvContractLimits = {
     readonly maxNestingDepth: number;
     /** The largest `limit` a list read may ask for. */
     readonly maxListLimit: number;
-    /** The most operations one transaction may hold. */
+    /** The most steps one transaction plan may hold: reads, writes and `$sql` steps alike. */
     readonly maxTransactionOperations: number;
+    /**
+     * The most write steps one transaction plan may hold: `create`, `update`,
+     * `upsert` and `delete` steps, and every `$sql` step (a statement is not
+     * classed, so it counts as a write).
+     */
+    readonly maxTransactionWrites: number;
     /** The most boolean and filter nodes one request may hold. */
     readonly maxBooleanNodes: number;
     /** How deeply a `json` field's value may nest: its arrays and objects, counted from the value. */
@@ -23,6 +29,7 @@ export declare const DEFAULT_CONTRACT_LIMITS: {
     readonly maxNestingDepth: 12;
     readonly maxListLimit: 250;
     readonly maxTransactionOperations: 20;
+    readonly maxTransactionWrites: 20;
     readonly maxBooleanNodes: 50;
     readonly maxJsonDepth: 64;
     readonly maxAll: 10;

package/dist/contracts/contract-limits.js

@@ -3,6 +3,7 @@ export const DEFAULT_CONTRACT_LIMITS = {
     maxNestingDepth: 12,
     maxListLimit: 250,
     maxTransactionOperations: 20,
+    maxTransactionWrites: 20,
     maxBooleanNodes: 50,
     maxJsonDepth: 64,
     maxAll: 10,

package/dist/contracts/contract.d.ts

@@ -6,7 +6,6 @@ import type { AvCoreField } from "./field.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 AvContract {
     /** The scalar types available. */
@@ -17,8 +16,13 @@ export interface AvContract {
     readonly resources: Readonly<Record<string, AvResource<this>>>;
     /** The request limits in force. */
     readonly limits: AvContractLimits;
-    /** Whether interactive transactions are available. */
-    readonly transactions: AvTransactionCapability;
+    /**
+     * What the layer's transactions allow: `"interactive"`, transactions the
+     * server opens and plans callers send; `"server"`, only those the server
+     * opens (a forced call, a policy-checked write, `ctx.$transaction`), with no
+     * plan; `"none"`, neither.
+     */
+    readonly transactions: "none" | "server" | "interactive";
     /**
      * `"uniform"` when one record must write the relations that hold a reference
      * either all as relations or all through their reference fields; a record

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

@@ -2,3 +2,11 @@
 export declare const TRANSACTION_CAPABILITIES: readonly ["none", "interactive"];
 /** `"none"` or `"interactive"`: whether transactions can run. */
 export type AvTransactionCapability = (typeof TRANSACTION_CAPABILITIES)[number];
+/** The transaction styles a layer can state, and its Contract's `transactions` carries. */
+export declare const TRANSACTIONS_STYLES: readonly ["none", "server", "interactive"];
+/** `"none"`, `"server"` or `"interactive"`: what a layer's transactions allow. */
+export type TransactionsStyle = (typeof TRANSACTIONS_STYLES)[number];
+/** Whether the server may open a transaction under `style`: `"server"` or `"interactive"`. */
+export declare function opensServerTransactions(style: TransactionsStyle): boolean;
+/** Whether callers may send a transaction plan under `style`: `"interactive"` alone. */
+export declare function takesTransactionPlans(style: TransactionsStyle): boolean;

package/dist/contracts/transaction-capability.js

@@ -1 +1,8 @@
 export const TRANSACTION_CAPABILITIES = ["none", "interactive"];
+export const TRANSACTIONS_STYLES = ["none", "server", "interactive"];
+export function opensServerTransactions(style) {
+    return style === "server" || style === "interactive";
+}
+export function takesTransactionPlans(style) {
+    return style === "interactive";
+}

package/dist/framework/access-facade.js

@@ -4,6 +4,7 @@ import { copyAtDoor } from "../runtime/caller-data.door.js";
 import { isRecord } from "../runtime/record.guard.js";
 import { requestIdOf } from "../runtime/request-id.js";
 import { stateOptionOf } from "../runtime/request-state.resolver.js";
+import { inProcessStateRejection } from "../runtime/state-refusal.mapper.js";
 import { encodeOperationArgumentsForWire } from "../transactions/operation-arguments-encoder.js";
 import { settleOperation } from "./operation-facade.js";
 export function createServerClientAccess(dependencies) {
@@ -12,12 +13,19 @@ export function createServerClientAccess(dependencies) {
         if (options?.state !== undefined || options?.headers === undefined) {
             return stateOf(options);
         }
-        return {
-            state: await dependencies.state({
-                headers: requestHeadersOf(options.headers),
-                ...(options.request === undefined ? {} : { request: options.request }),
-            }),
-        };
+        try {
+            return {
+                state: await dependencies.state({
+                    headers: requestHeadersOf(options.headers),
+                    ...(options.request === undefined
+                        ? {}
+                        : { request: options.request }),
+                }),
+            };
+        }
+        catch (error) {
+            throw inProcessStateRejection(error);
+        }
     };
     const can = async (questions, options) => settleOperation(await answer({
         origin: "client",

package/dist/framework/contract-view.d.ts

@@ -1,7 +1,9 @@
 import type { AvAdapterModel } from "../adapters/adapter-model.js";
 import type { AvConfigAny } from "../config/any-framework-config.js";
 import type { AvRequestOrigin } from "../config/config-layer.js";
+import type { ReadCapabilityName } from "../config/framework-exemptions-config.js";
 import type { ErasedResources } from "../config/stage-type.eraser.js";
+import type { AvContract } from "../contracts/contract.js";
 import type { AvContractLimits } from "../contracts/contract-limits.js";
 import type { JsonShape, ShapedJsonSchema } from "../contracts/json-shape.js";
 /**
@@ -181,11 +183,47 @@ type ManagedResources<in out Resources, in out Managed, in out Hidden> = {
 /**
  * One Resource before exposure: the model's own, with its fields layered and
  * marked where governed, and its create requirements less what the layers'
- * compute stages fill.
+ * compute stages fill, its non-null added fields among them.
  */
 type LayeredResource<in out Resource, in out ResourceConfig, in out OverlayConfig, in out Governed = never> = {
-    readonly [P in keyof Resource]: P extends "fields" ? GovernedFields<LayeredFields<Resource[P], EntryOf<ResourceConfig, "fields">>, Governed> : P extends "createRequirements" ? RequirementsLessComputed<Exclude<Resource[P], undefined>, ComputedOnCreateKey<EntryOf<ResourceConfig, "fields">> | ComputedOnCreateKey<EntryOf<OverlayConfig, "fields">>> : Resource[P];
+    readonly [P in keyof (Resource & {
+        readonly createRequirements?: unknown;
+    })]: P extends "fields" ? GovernedFields<LayeredFields<Resource[P & keyof Resource], EntryOf<ResourceConfig, "fields">>, Governed> : P extends "createRequirements" ? LayeredRequirements<"createRequirements" extends keyof Resource ? Exclude<Resource[P & keyof Resource], undefined> : never, NonNullAddedKey<(Resource & {
+        readonly fields: unknown;
+    })["fields"], EntryOf<ResourceConfig, "fields">>, EntryOf<ResourceConfig, "fields">, EntryOf<OverlayConfig, "fields">> : Resource[P & keyof Resource];
 };
+/**
+ * The model's statement (`never` when it states none) less what a
+ * `compute.create` of either layer fills, with the non-null added fields
+ * (`NonNull`) it leaves required too; `never` when nothing is required. The
+ * fields compute fills are read only where there is something to subtract them
+ * from.
+ */
+type LayeredRequirements<Requirements, NonNull, FieldsBlock, OverlayFieldsBlock> = [Requirements] extends [never] ? [NonNull] extends [never] ? never : AddedOnly<Exclude<NonNull, ComputedOnCreateKey<FieldsBlock> | ComputedOnCreateKey<OverlayFieldsBlock>>> : LayeredStatement<Requirements, NonNull, ComputedOnCreateKey<FieldsBlock> | ComputedOnCreateKey<OverlayFieldsBlock>>;
+/** {@link LayeredRequirements} of a statement the model makes, `Computed` named once. */
+type LayeredStatement<Requirements, NonNull, Computed> = RequirementsWithAdded<RequirementsLessComputed<Requirements, Computed>, [
+    NonNull
+] extends [never] ? never : Exclude<NonNull, Computed>>;
+/** `Added` as a statement of its own; `never` (no statement) when it names none. */
+type AddedOnly<Added> = [Added] extends [never] ? never : {
+    readonly required: RequiredNames<Added>;
+};
+/** The fields a `fields` block adds as `nullable: false`. */
+type NonNullAddedKey<ModelFields, FieldsBlock> = {
+    [F in AddedFieldKey<ModelFields, FieldsBlock>]-?: DefinitionOf<EntryOf<FieldsBlock, F>> extends {
+        readonly nullable: false;
+    } ? F : never;
+}[AddedFieldKey<ModelFields, FieldsBlock>];
+/** A create-requirement statement with `Added` required too. */
+type RequirementsWithAdded<Requirements, Added> = [Added] extends [never] ? Requirements : {
+    readonly [P in keyof Requirements as P extends "required" ? never : P]: Requirements[P];
+} & {
+    readonly required: RequiredNames<(Requirements extends {
+        readonly required?: infer List;
+    } ? List extends readonly (infer Name)[] ? Name : never : never) | Added>;
+};
+/** Names as a statement's `required` member, a non-empty list (their order is the compiler's). */
+type RequiredNames<Names> = readonly [Names, ...Names[]];
 /** The fields of a `fields` block with a `compute.create` stage. */
 type ComputedOnCreateKey<FieldsBlock> = [FieldsBlock] extends [never] ? never : {
     [F in keyof FieldsBlock]-?: NonNullable<FieldsBlock[F]> extends {
@@ -220,6 +258,20 @@ type GroupsLessComputed<Groups, Computed> = Groups extends readonly [
     readonly [Relation, ...NamesLessComputed<References, Computed>],
     ...GroupsLessComputed<Rest, Computed>
 ] : GroupsLessComputed<Rest, Computed> : readonly [];
+/** A Contract view with the create requirements `Lift` names lifted. */
+export type PreComputeView<C, Lift extends string> = Extract<{
+    readonly [P in keyof C]: P extends "resources" ? string extends Lift ? {
+        readonly [R in keyof C[P]]: Omit<C[P][R], "createRequirements">;
+    } : {
+        readonly [R in keyof C[P]]: LiftedResource<C[P][R], LiftedFieldOf<Lift, R>>;
+    } : C[P];
+}, AvContract>;
+/** The fields of Resource `R` that `Lift` names. */
+type LiftedFieldOf<Lift extends string, R> = Lift extends `${R & string}.${infer Field}` ? Field : never;
+/** One Resource with the create requirements on `Fields` lifted; itself when none. */
+type LiftedResource<Resource, Fields> = [Fields] extends [never] ? Resource : {
+    readonly [P in keyof Resource]: P extends "createRequirements" ? RequirementsLessComputed<Exclude<Resource[P], undefined>, Fields> : Resource[P];
+};
 /** The Resources before exposure: the model, with the root's definitions applied. */
 type LayeredResources<Resources, Block, OverlayBlock, Governed = never> = {
     readonly [R in keyof Resources]: LayeredResource<Resources[R], EntryOf<Block, R>, EntryOf<OverlayBlock, R>, GovernedNames<Governed, R>>;
@@ -258,7 +310,7 @@ type AnyMemberGrants<Entry, Exclude = never> = true extends {
     [K in keyof Entry]-?: K extends Exclude ? false : Grants<NonNullable<Entry[K]>>;
 }[keyof Entry] ? true : false;
 /** Whether a Pick field entry grants a capability: an object must grant one inside. */
-type FieldGrants<Entry> = [Entry] extends [readonly unknown[]] ? Grants<Entry> : [Entry] extends [boolean] ? Grants<Entry> : [Entry] extends [object] ? AnyMemberGrants<Entry, AdapterLimit> : false;
+type FieldGrants<Entry> = [Entry] extends ["read"] ? true : [Entry] extends [readonly unknown[]] ? Grants<Entry> : [Entry] extends [boolean] ? Grants<Entry> : [Entry] extends [object] ? AnyMemberGrants<Entry, AdapterLimit> : false;
 /** Whether one family's entry grants a variant. */
 type FamilyGrants<Entry> = [Entry] extends [readonly unknown[]] ? Grants<Entry> : [Entry] extends [boolean] ? Grants<Entry> : [Entry] extends [object] ? AnyMemberGrants<Entry> : false;
 /** Whether an operations entry grants an operation. */
@@ -266,7 +318,7 @@ type OperationsGrant<Entry> = [Entry] extends [readonly unknown[]] ? Grants<Entr
     [F in keyof Entry]-?: FamilyGrants<NonNullable<Entry[F]>>;
 }[keyof Entry] ? true : false : false;
 /** Whether a Pick Resource entry grants a field or an operation. */
-type ResourceGrants<Entry> = [Entry] extends [boolean] ? Grants<Entry> : [Entry] extends [object] ? true extends OperationsGrant<NonNullable<OperationsEntryOf<Entry>>> | (true extends {
+type ResourceGrants<Entry> = [Entry] extends [boolean] ? Grants<Entry> : [Entry] extends [object] ? true extends OperationsGrant<NonNullable<OperationsEntryOf<Entry>>> | ([RawFieldsEntryOf<Entry>] extends ["read"] ? true : false) | (true extends {
     [F in keyof FieldsEntryOf<Entry>]-?: FieldGrants<NonNullable<FieldsEntryOf<Entry>[F]>>;
 }[keyof FieldsEntryOf<Entry>] ? true : false) ? true : false : false;
 /** The keys of a Pick `fields` block whose entry grants (see {@link FieldGrants}). */
@@ -307,18 +359,40 @@ type ExemptedCapabilities<Caps, Entry, Style> = Style extends "omit" ? Entry ext
 } : {
     readonly [P in keyof Caps as P extends AdapterLimit ? P : P extends keyof Entry ? Grants<Entry[P]> extends true ? P : never : never]: P extends keyof Entry ? PickedMember<Caps[P], Entry[P]> : Caps[P];
 };
+/** The read capability names a field's capabilities carry: present and not `false`. */
+type OfferedReadName<Caps> = {
+    [P in keyof Caps & ReadCapabilityName]-?: [
+        Exclude<Caps[P], undefined>
+    ] extends [false] ? never : P;
+}[keyof Caps & ReadCapabilityName];
+/** A field entry as the walk reads it: `"read"` as the list of the read names its capabilities carry. */
+type EntryForm<Entry, Caps> = [Entry] extends ["read"] ? readonly OfferedReadName<Caps>[] : Entry;
 /** One field under its exemption: `true` (or `boolean`) keeps the parent's field. */
 type ExemptedField<Field, Entry, Style> = [Entry] extends [boolean] ? Field : {
-    readonly [P in keyof Field]: P extends "capabilities" ? ExemptedCapabilities<Field[P], Entry, Style> : Field[P];
+    readonly [P in keyof Field]: P extends "capabilities" ? ExemptedCapabilities<Field[P], EntryForm<Entry, Field[P]>, Style> : Field[P];
 };
+/** A field's capabilities, or `never`. */
+type CapabilitiesOf<Field> = Field extends {
+    readonly capabilities: infer Caps;
+} ? Caps : never;
+/** The fields a Pick `"read"` names that carry no read capability. */
+type UnreadableKey<Fields, Block> = [
+    Extract<Block[keyof Block], "read">
+] extends [never] ? never : {
+    [F in keyof Fields & keyof Block]-?: [NonNullable<Block[F]>] extends [
+        "read"
+    ] ? [OfferedReadName<CapabilitiesOf<Fields[F]>>] extends [never] ? F : never : never;
+}[keyof Fields & keyof Block];
+/** The fields a Pick `fields` block keeps. */
+type PickedFieldKey<Fields, Block> = Exclude<Extract<keyof Fields, GrantedFieldKey<Block>>, UnreadableKey<Fields, Block>>;
 /** A Resource's fields under its exemptions' `fields` block. */
 type ExemptedFields<Fields, Block, Style> = Style extends "omit" ? [Block] extends [never] ? Fields : {
     readonly [F in Exclude<keyof Fields, WholeKey<Block>>]: F extends keyof Block ? ExemptedField<Fields[F], NonNullable<Block[F]>, "omit"> : Fields[F];
 } : {
-    readonly [F in Extract<keyof Fields, GrantedFieldKey<Block>>]: ExemptedField<Fields[F], RawEntry<Block, F>, "pick">;
+    readonly [F in PickedFieldKey<Fields, Block>]: ExemptedField<Fields[F], RawEntry<Block, F>, "pick">;
 };
 /** The fields an exemptions `fields` block leaves a Resource without. */
-type RemovedField<Fields, Block, Style> = Style extends "omit" ? WholeKey<Block> : Exclude<keyof Fields, GrantedFieldKey<Block>>;
+type RemovedField<Fields, Block, Style> = Style extends "omit" ? WholeKey<Block> : Exclude<keyof Fields, PickedFieldKey<Fields, Block>>;
 /** Whether a field's capabilities offer a filter operator. */
 type Filters<Field> = Field extends {
     readonly capabilities: infer Caps;
@@ -359,9 +433,17 @@ type IdentifiersLost<Identifiers, Removed> = [Removed] extends [never] ? false :
     KeptIdentifiers<Identifiers, Removed> extends readonly (infer Kept)[] ? Kept : never
 ] extends [never] ? true : false;
 /** A Resource's `fields` and `operations` entries, read off its exemption object. */
-type FieldsEntryOf<Entry> = LiteralRecord<(Entry & {
+type FieldsEntryOf<Entry> = LiteralRecord<RawFieldsEntryOf<Entry>>;
+/** A Resource exemption's `fields` as written: an object, or `"read"`. */
+type RawFieldsEntryOf<Entry> = NonNullable<(Entry & {
     readonly fields?: unknown;
 })["fields"]>;
+/** A Resource's `fields` block, `"read"` written out over the parent's fields. */
+type FieldsBlockOf<Entry, Resource> = [RawFieldsEntryOf<Entry>] extends ["read"] ? {
+    readonly [F in keyof (Resource extends {
+        readonly fields: infer Fields;
+    } ? Fields : never)]: "read";
+} : FieldsEntryOf<Entry>;
 type OperationsEntryOf<Entry> = (Entry & {
     readonly operations?: unknown;
 })["operations"];
@@ -376,7 +458,7 @@ type ExemptedResourceObject<in out Resource, in out FieldsBlock, in out Operatio
     } ? Fields : never, FieldsBlock, Style>> : Resource[P];
 };
 /** One Resource under its exemption: `true` (or `boolean`) keeps the parent's. */
-type ExemptedResource<Resource, Entry, Style> = [Entry] extends [boolean] ? Resource : ExemptedResourceObject<Resource, FieldsEntryOf<Entry>, OperationsEntryOf<Entry>, Style>;
+type ExemptedResource<Resource, Entry, Style> = [Entry] extends [boolean] ? Resource : ExemptedResourceObject<Resource, FieldsBlockOf<Entry, Resource>, OperationsEntryOf<Entry>, Style>;
 /** A layer's Resources: its parent's, with its exemptions applied in its style. */
 type ExposedResources<Resources, Style, Block> = Style extends "omit" ? [Block] extends [never] ? Resources : {
     readonly [R in Exclude<keyof Resources, WholeKey<Block>>]: R extends keyof Block ? ExemptedResource<Resources[R], NonNullable<Block[R]>, "omit"> : Resources[R];

package/dist/framework/operation-facade.d.ts

@@ -1,4 +1,5 @@
 import type { AvAdapterModel } from "../adapters/adapter-model.js";
+import type { AvContextComputeLift } from "../config/computed-fields.js";
 import type { AvContract } from "../contracts/contract.js";
 import type { AvApplicationScalarForms, AvWireScalarForms } from "../contracts/scalar-value-type.js";
 import type { AvOperationArgumentsFor, AvResourceKey } from "../operations/operation-arguments.js";
@@ -12,7 +13,7 @@ import type { AvState } from "../runtime/request-state.js";
 import type { AvSqlStatementBuilder } from "../transactions/sql-statement.js";
 import type { AvTransactionResponse } from "../transactions/transaction-response.js";
 import type { AccessProviderOf, ServerClientAccess } from "./access-facade.js";
-import type { AvContractApplicationView, ClientContractView } from "./contract-view.js";
+import type { AvContractApplicationView, ClientContractView, PreComputeView } from "./contract-view.js";
 /**
  * A model whose Resource names are not literal — the abstract `AvAdapterModel` behind
  * the default `AvFramework` — has no Contract to type a call against, so a surface over
@@ -227,9 +228,13 @@ export type ClientTransactionBuilders<M extends AvAdapterModel, Cfg> = ClientDef
 export type ServerClientTransactionBuilders<M extends AvAdapterModel, Cfg> = ServerClientDeferredSurface<ClientContractView<M, Cfg>>;
 /**
  * The Resources of a pipeline ctx: `ctx.<Resource>.<family>.<variant>(args)`,
- * application-origin, resolving the operation's data.
+ * application-origin, resolving the operation's data. A create need not write a
+ * field the root's or the application's `compute.create` fills, when the model's
+ * type states them.
  */
-export type AvContextOperations<M extends AvAdapterModel> = ContextFacade<AvContractApplicationView<M>>;
+export type AvContextOperations<M extends AvAdapterModel> = ContextFacade<ContextView<AvContractApplicationView<M>, AvContextComputeLift<M>>>;
+/** The ctx executor's view: `C`, its create requirements less `Lift`. */
+type ContextView<C, Lift extends string> = [Lift] extends [never] ? C : PreComputeView<C, Lift>;
 type ContextFacade<C> = C extends AvContract ? string extends AvResourceKey<C> ? unknown : {
     readonly [R in AvResourceKey<C>]: {
         readonly [F in keyof AvOperationGrammar<C>[R]]: {

package/dist/internal.d.ts

@@ -43,5 +43,6 @@ export { mcpFailureReporterOf } from "./runtime/diagnostics-reporter.js";
 export type { AvErrorClassName } from "./runtime/framework-error-class.table.js";
 export { FRAMEWORK_ERROR_CLASS_OF } from "./runtime/framework-error-class.table.js";
 export { OPERATION_CODES } from "./runtime/operation-response.js";
+export { inProcessStateRejection } from "./runtime/state-refusal.mapper.js";
 export type { BuiltinNonRow, OperationFingerprint, } from "./transactions/deferred-operation.js";
 export { computeOperationFingerprint } from "./transactions/operation-fingerprint.js";

package/dist/internal.js

@@ -23,4 +23,5 @@ export { emitPrebuiltContracts, prebuiltContractsOf, } from "./prebuilt/prebuilt
 export { mcpFailureReporterOf } from "./runtime/diagnostics-reporter.js";
 export { FRAMEWORK_ERROR_CLASS_OF } from "./runtime/framework-error-class.table.js";
 export { OPERATION_CODES } from "./runtime/operation-response.js";
+export { inProcessStateRejection } from "./runtime/state-refusal.mapper.js";
 export { computeOperationFingerprint } from "./transactions/operation-fingerprint.js";

package/dist/operations/validation-code.guidance.js

@@ -56,7 +56,7 @@ export const VALIDATION_CODE_GUIDANCE = {
         fix: "Nest less, or raise limits.maxNestingDepth.",
     },
     V1014: {
-        cause: "A limit above maxListLimit, or more steps than maxTransactionOperations.",
+        cause: "A limit above maxListLimit, more steps than maxTransactionOperations, or more write steps than maxTransactionWrites.",
         fix: "Paginate or split the plan, or raise the limit.",
     },
     V1015: {

package/dist/policy/access-provider.interface.d.ts

@@ -18,8 +18,13 @@ export interface AvAccessProvider {
      * the stages read. Called once per request by the host. `request` is the
      * host's own request when it has one: Express's `req`, Fastify's
      * `request`, or the Next.js route handler's `Request`. A throw is answered
-     * like any developer failure: a thrown `AvError` as its own outcome,
-     * anything else as an internal failure.
+     * as a thrown `AvError`'s own outcome. A rejection carrying `status` or
+     * `statusCode` 401 or 403 (an authentication library's refusal; two
+     * numbers that disagree are none) is `A4000` or `A4001`, with core's own
+     * message and nothing of the rejection's, unreported: a route answers it,
+     * and an in-process call (Next.js's `avClient`, `serverClient.$access.can`
+     * given `headers`) rejects with that code's `AvError`. Anything else is an
+     * internal failure on a route, and rejects an in-process call unchanged.
      */
     state(input: {
         readonly headers: {

package/dist/policy/access-question.runtime.js

@@ -1,6 +1,7 @@
 import { adapterPrimaryIdentifier } from "../adapters/adapter-identifier.js";
 import { lookupOwn, lookupResource } from "../contracts/contract-lookup.js";
 import { isOperationVariantAvailable } from "../contracts/resource-operations.js";
+import { opensServerTransactions } from "../contracts/transaction-capability.js";
 import { resourceUnavailableIssue, validateOperationArguments, } from "../operations/operation-validator-core.js";
 import { validationIssue, } from "../operations/validation-code.js";
 import { copyAtDoor, refuseCallerData } from "../runtime/caller-data.door.js";
@@ -172,7 +173,7 @@ async function answerQuestion(session, dependencies, active, question) {
     }
     const { resource, action, where } = question;
     const identifier = adapterPrimaryIdentifier(dependencies.adapter.model, resource);
-    const interactive = active.transactions === "interactive";
+    const interactive = opensServerTransactions(active.transactions);
     if (action === "update") {
         const checkedAfter = session.checksAfter(resource, "update");
         if ((!interactive && checkedAfter) ||

package/dist/prebuilt/core-version.generated.d.ts

@@ -1,2 +1,2 @@
 /** The version of this `@aventara/core`. */
-export declare const CORE_VERSION = "1.0.0-rc.12";
+export declare const CORE_VERSION = "1.0.0-rc.14";

package/dist/prebuilt/core-version.generated.js

@@ -1 +1 @@
-export const CORE_VERSION = "1.0.0-rc.12";
+export const CORE_VERSION = "1.0.0-rc.14";

package/dist/protocol/absent-route.responder.d.ts

@@ -41,8 +41,8 @@ type OperationRouteResolution = {
 export declare function resolveOperationRoute(contracts: AvContracts, protocol: AvRequestProtocol, route: OperationRouteSegments, origin?: RemoteRequestOrigin): OperationRouteResolution;
 /**
  * The `/_transactions` route under one client protocol identity: version → hash → the
- * ClientContract's transaction capability. The route exists only when that capability
- * is `"interactive"` — tested against the value itself, as `protocol.surface()` tests
+ * ClientContract's transactions. The route exists only when they take plans
+ * (`"interactive"`; `"server"` takes none) — tested as `protocol.surface()` tests
  * it — and is otherwise absent with core's own refusal of a plan. `undefined` when the
  * route is there.
  */

package/dist/protocol/absent-route.responder.js

@@ -1,6 +1,7 @@
 import { lookupOwn, lookupResource } from "../contracts/contract-lookup.js";
 import { AVENTARA_PROTOCOL_VERSION } from "../contracts/contract-protocol.js";
 import { isOperationVariantAvailable, } from "../contracts/resource-operations.js";
+import { takesTransactionPlans } from "../contracts/transaction-capability.js";
 import { parseOperationIdentity, } from "../operations/operation-identity.js";
 import { operationUnavailableIssue } from "../operations/operation-validator.js";
 import { resourceUnavailableIssue } from "../operations/operation-validator-core.js";
@@ -45,7 +46,7 @@ export function resolveOperationRoute(contracts, protocol, route, origin = "clie
 }
 function transactionsRouteFailure(contracts, protocol, origin = "client") {
     return (protocolIdentityFailure(contracts, protocol, origin) ??
-        (contracts[origin].transactions === "interactive"
+        (takesTransactionPlans(contracts[origin].transactions)
             ? undefined
             : transactionsUnavailableFailure()));
 }

package/dist/protocol/av-protocol.d.ts

@@ -4,6 +4,7 @@
  */
 export { normalizeEntrypoint } from "../config/entrypoint.normalizer.js";
 export { scalarFormats } from "../contracts/wire-scalar-format.js";
+export { computeOperationFingerprint as fingerprint } from "../transactions/operation-fingerprint.js";
 export { httpStatus } from "./http-status.table.js";
 export { isOperationResponse } from "./operation-response.guard.js";
 export { bind } from "./protocol.binder.js";

package/dist/protocol/av-protocol.js

@@ -1,5 +1,6 @@
 export { normalizeEntrypoint } from "../config/entrypoint.normalizer.js";
 export { scalarFormats } from "../contracts/wire-scalar-format.js";
+export { computeOperationFingerprint as fingerprint } from "../transactions/operation-fingerprint.js";
 export { httpStatus } from "./http-status.table.js";
 export { isOperationResponse } from "./operation-response.guard.js";
 export { bind } from "./protocol.binder.js";

package/dist/protocol/protocol-surface.js

@@ -1,5 +1,6 @@
 import { lookupOwn, lookupResource } from "../contracts/contract-lookup.js";
 import { isOperationVariantAvailable } from "../contracts/resource-operations.js";
+import { takesTransactionPlans } from "../contracts/transaction-capability.js";
 import { parseOperationIdentity, } from "../operations/operation-identity.js";
 const ownKeys = (record) => record === undefined ? [] : Object.keys(record);
 export function advertisesAnyOperation(client) {
@@ -56,7 +57,7 @@ export function surfaceOf(client) {
         method: "GET",
         path: "/_contract",
     }));
-    if (client.transactions === "interactive") {
+    if (takesTransactionPlans(client.transactions)) {
         routes.push(Object.freeze({
             kind: "transactions",
             method: "POST",

package/dist/protocol/protocol.handler.js

@@ -2,6 +2,7 @@ import { copyAtDoor } from "../runtime/caller-data.door.js";
 import { createDiagnosticsReporter, createReporter, } from "../runtime/diagnostics-reporter.js";
 import { sanitizeOperationFailure } from "../runtime/error-boundary.js";
 import { internalFailure, } from "../runtime/operation-response.js";
+import { stateRefusalOf } from "../runtime/state-refusal.mapper.js";
 import { capturePlanAtCall } from "../transactions/transaction-plan-validator.js";
 import { checkOperationRoute } from "./absent-route.responder.js";
 import { adoptParsedBody, decodeCanRequest, decodeOperationRead, decodeTransactionRequest, isParsedByDecoder, transportOf, } from "./http-request.decoder.js";
@@ -77,7 +78,8 @@ export async function seededState(options, report, view) {
     catch (error) {
         return {
             ok: false,
-            response: sanitizeOperationFailure(error, "runtime", report, view),
+            response: stateRefusalOf(error) ??
+                sanitizeOperationFailure(error, "runtime", report, view),
         };
     }
 }

package/dist/runtime/context-executor.runtime.js

@@ -1,4 +1,5 @@
 import { isOperationVariantAvailable } from "../contracts/resource-operations.js";
+import { opensServerTransactions } from "../contracts/transaction-capability.js";
 import { parseOperationIdentity } from "../operations/operation-identity.js";
 import { validationIssue } from "../operations/validation-code.js";
 import { readSqlTemplate } from "../transactions/sql-statement.js";
@@ -218,7 +219,7 @@ export function createContextExecutor(dependencies) {
         if (scope.transaction !== undefined) {
             return (async () => run(context))();
         }
-        if (dependencies.application.transactions === "none") {
+        if (!opensServerTransactions(dependencies.application.transactions)) {
             return Promise.reject(thrownFailure(unavailable("Transactions are not available on the application Contract.")));
         }
         return openTransaction(scope, (executor) => run(contextOf(prototype, {