@aventara/core 1.0.0-rc.11 → 1.0.0-rc.13

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,50 @@ 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;
+} ? [MemberTokens<NonNullable<Caps[keyof Caps & "filter"]>>] extends [never] ? false : true : false;
+/** The fields a `fields` block stops filtering on: the parent filters on them, the layer no longer does. */
+type UnfilteredField<Fields, Block, Style> = [Block] extends [never] ? never : {
+    [F in keyof Fields & keyof Block]-?: Filters<Fields[F]> extends true ? Filters<ExemptedField<Fields[F], NonNullable<Block[F]>, Style>> extends true ? never : F : never;
+}[keyof Fields & keyof Block];
+/** The fields no identifier of the layer may name. */
+type UnaddressableField<Fields, Block, Style> = RemovedField<Fields, Block, Style> | UnfilteredField<Fields, Block, Style>;
 /** One family's entry in an operations entry: `true` for a listed family. */
 type FamilyEntry<Operations, Family> = Operations extends readonly unknown[] ? Family extends Listed<Operations> ? true : unknown : [Operations] extends [boolean] ? Operations : Family extends keyof Operations ? NonNullable<Operations[Family]> : unknown;
 /** The keys of a per-variant object entry set to a literal `true`. */
@@ -342,16 +426,24 @@ type KeptOperations<Operations, Entry, Style, UniqueLost> = {
         readonly [V in KeptVariant<NonNullable<Operations[F]>, FamilyEntry<Entry, F>, Style, UniqueLost>]: NonNullable<Operations[F]>[V];
     };
 };
-/** A Resource's identifiers less those naming a removed field. */
+/** A Resource's identifiers less those naming an unaddressable field. */
 type KeptIdentifiers<Identifiers, Removed> = [Removed] extends [never] ? Identifiers : Identifiers extends readonly (infer Identifier)[] ? readonly (Identifier extends readonly (infer Field)[] ? [Extract<Field, Removed>] extends [never] ? Identifier : never : never)[] : Identifiers;
 /** Whether removing fields left a Resource with no identifier at all. */
 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"];
@@ -359,14 +451,14 @@ type OperationsEntryOf<Entry> = (Entry & {
 type ExemptedResourceObject<in out Resource, in out FieldsBlock, in out OperationsEntry, in out Style> = {
     readonly [P in keyof Resource]: P extends "fields" ? ExemptedFields<Resource[P], FieldsBlock, Style> : P extends "operations" ? ExemptedOperations<Resource[P], OperationsEntry, Style, IdentifiersLost<Resource extends {
         readonly identifiers: infer Ids;
-    } ? Ids : never, RemovedField<Resource extends {
+    } ? Ids : never, UnaddressableField<Resource extends {
         readonly fields: infer Fields;
-    } ? Fields : never, FieldsBlock, Style>>> : P extends "identifiers" ? KeptIdentifiers<Resource[P], RemovedField<Resource extends {
+    } ? Fields : never, FieldsBlock, Style>>> : P extends "identifiers" ? KeptIdentifiers<Resource[P], UnaddressableField<Resource extends {
         readonly fields: infer Fields;
     } ? 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.11";
+export declare const CORE_VERSION = "1.0.0-rc.13";

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

@@ -1 +1 @@
-export const CORE_VERSION = "1.0.0-rc.11";
+export const CORE_VERSION = "1.0.0-rc.13";

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, {

package/dist/runtime/create-requirement.d.ts

@@ -21,12 +21,16 @@ export type RecordWriteFacts = {
     readonly references: ReferentialActionTable;
     readonly stated: (resource: string) => AvCreateRequirements | undefined;
 };
-/** The facts an Adapter stated, read off it once; an absent table states nothing. */
+/**
+ * The facts an Adapter stated, read off it once, with the non-null added
+ * (`VIRTUAL`) fields of `core` required too; an absent table states nothing.
+ */
 export declare function recordWriteFactsOf(adapter: {
     readonly referentialActions?: ReferentialActionTable;
     readonly model?: {
         readonly resources: Readonly<Record<string, unknown>>;
     };
+    readonly core?: AvContract;
 }): RecordWriteFacts;
 /**
  * The `V1000` issues for every create position in one operation's arguments

package/dist/runtime/create-requirement.js

@@ -1,3 +1,4 @@
+import { withVirtualRequirements } from "../compiler/create-requirements.projector.js";
 import { lookupField, lookupResource } from "../contracts/contract-lookup.js";
 import { advertisedDirectivesAt } from "../contracts/field.js";
 import { LOOPBACK_WRITE_SCOPE, NESTED_WRITE_SCOPE, resolveWriteScope, } from "../operations/write-scope.resolver.js";
@@ -292,14 +293,21 @@ function walkNestedCreates(context, resource, record, path) {
 }
 export function recordWriteFactsOf(adapter) {
     const resources = adapter.model?.resources ?? {};
+    const contracted = adapter.core?.resources ?? {};
     return {
         references: adapter.referentialActions ?? {},
         stated: (resource) => {
             const found = Object.hasOwn(resources, resource)
                 ? resources[resource]
                 : undefined;
-            const stated = isRecord(found) ? found.createRequirements : undefined;
-            return isRecord(stated) ? stated : undefined;
+            const own = isRecord(found) ? found.createRequirements : undefined;
+            const stated = isRecord(own) ? own : undefined;
+            const fields = Object.hasOwn(contracted, resource)
+                ? contracted[resource]?.fields
+                : undefined;
+            return fields === undefined
+                ? stated
+                : withVirtualRequirements(stated, { fields });
         },
     };
 }

package/dist/runtime/field-check.evaluator.js

@@ -418,10 +418,47 @@ const FORMAT_LABELS = {
 function plural(count, one, many) {
     return `${count} ${count === 1 ? one : many}`;
 }
+const PATTERN_SYNTAX = "\\^$.*+?()[]{}|/";
+function listedValues(pattern) {
+    const { source, flags } = pattern;
+    if (flags !== "" || !source.startsWith("^(?:") || !source.endsWith(")$")) {
+        return undefined;
+    }
+    const body = source.slice(4, -2);
+    const values = [];
+    let value = "";
+    for (let index = 0; index < body.length; index += 1) {
+        const character = body.charAt(index);
+        if (character === "\\") {
+            const escaped = body.charAt(index + 1);
+            if (escaped === "" || !PATTERN_SYNTAX.includes(escaped)) {
+                return undefined;
+            }
+            value += escaped;
+            index += 1;
+        }
+        else if (character === "|") {
+            values.push(value);
+            value = "";
+        }
+        else if (PATTERN_SYNTAX.includes(character)) {
+            return undefined;
+        }
+        else {
+            value += character;
+        }
+    }
+    values.push(value);
+    return values;
+}
 function formatMessage(check) {
     switch (check.format) {
-        case "regex":
-            return `Value must match the pattern /${check.pattern.source}/${check.pattern.flags}.`;
+        case "regex": {
+            const listed = listedValues(check.pattern);
+            return listed === undefined
+                ? `Value must match the pattern /${check.pattern.source}/${check.pattern.flags}.`
+                : `Value must be one of ${listed.map((value) => JSON.stringify(value)).join(", ")}.`;
+        }
         case "includes":
             return `Value must include ${JSON.stringify(check.includes)}.`;
         case "starts_with":

package/dist/runtime/field-validator.runtime.d.ts

@@ -7,11 +7,12 @@ import type { ReferentialActionTable } from "./referential-action.js";
 /** The write phase of a record: a created row (an upsert's `create` branch too) or an updated one. */
 type WriteStage = "create" | "update";
 /**
- * The fields a judgment leaves for later: a plan step's (or a forced call's)
- * literal values are judged before BEGIN, except a field a write compute stage
- * of that phase may still change, which is judged after write compute.
+ * The fields a judgment leaves out (`hiddenFieldRefusal`: the ones the active
+ * layer shows, which its own judgment covers).
  */
 type DeferredField = (resource: string, stage: WriteStage, field: string) => boolean;
+/** Whether the value at a path differs between `before` and `after`. */
+export declare function valuesChangedBetween(before: unknown, after: unknown): (path: Path) => boolean;
 /**
  * Every way the sent fields `select` admits break their validators: the
  * operation's own records, then each nested write target's. Paths are the

package/dist/runtime/field-validator.runtime.js

@@ -1,5 +1,6 @@
 import { hasFieldValidators, validatedFieldsOf, } from "../compiler/field-validator.compiler.js";
 import { AvComputedValueError } from "./computed-value.error.js";
+import { isAvDecimal } from "./decimal.js";
 import { entryCheckIssues, fieldCheckIssues } from "./field-check.evaluator.js";
 import { valueAt, writeRecordPathsOf, } from "./field-stage.runtime.js";
 import { nestedWriteTargetsOf } from "./nested-write.walker.js";
@@ -41,6 +42,34 @@ function entryIssues(rules, entry, at) {
     const { compiled } = rules;
     return entryCheckIssues(compiled.checks, entry, compiled.subject ?? "string", at);
 }
+function sameWrittenValue(left, right) {
+    if (Object.is(left, right)) {
+        return true;
+    }
+    if (left instanceof Date && right instanceof Date) {
+        return Object.is(left.getTime(), right.getTime());
+    }
+    if (isAvDecimal(left) && isAvDecimal(right)) {
+        return left.toString() === right.toString();
+    }
+    if (left instanceof Uint8Array && right instanceof Uint8Array) {
+        return (left.length === right.length &&
+            left.every((byte, index) => byte === right[index]));
+    }
+    if (Array.isArray(left) && Array.isArray(right)) {
+        return (left.length === right.length &&
+            left.every((entry, index) => sameWrittenValue(entry, right[index])));
+    }
+    if (isPlainRecord(left) && isPlainRecord(right)) {
+        const keys = Object.keys(left);
+        return (keys.length === Object.keys(right).length &&
+            keys.every((key) => Object.hasOwn(right, key) && sameWrittenValue(left[key], right[key])));
+    }
+    return false;
+}
+export function valuesChangedBetween(before, after) {
+    return (path) => !sameWrittenValue(valueAt(before, path), valueAt(after, path));
+}
 function recordIssues(contract, resource, records, args, argumentsPath, select, deferred) {
     const compiled = validatedFieldsOf(contract, resource);
     const issues = [];