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

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

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

package/dist/contracts/resource.d.ts

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

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

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

package/dist/contracts/scalar.d.ts

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

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

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

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

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

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

@@ -1,40 +1,27 @@
-import type { AdapterModel } from "../adapters/adapter-model.js";
-import type { AnyFrameworkConfig } from "../config/any-framework-config.js";
-import type { RequestOrigin } from "../config/config-layer.js";
-import type { ContractLimits } from "../contracts/contract-limits.js";
-/** Whether `resolveRecord` descends into a value: an object that is no array. */
-type IsLayeredRecord<T> = [T] extends [readonly unknown[]] ? false : [T] extends [object] ? true : false;
-/**
- * A root record with a scoped record layered over it: a key the scoped side
- * states wins; when both sides are records they merge, recursively; otherwise
- * the scoped value replaces the root one.
- */
-type LayeredRecord<Root, Scoped> = {
-    readonly [K in keyof Root | keyof Scoped]: K extends keyof Scoped ? K extends keyof Root ? [IsLayeredRecord<Root[K]>, IsLayeredRecord<Scoped[K]>] extends [
-        true,
-        true
-    ] ? LayeredRecord<Root[K], Scoped[K]> : Scoped[K] : Scoped[K] : K extends keyof Root ? Root[K] : never;
-};
+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 { ErasedResources } from "../config/stage-type.eraser.js";
+import type { AvContractLimits } from "../contracts/contract-limits.js";
+import type { JsonShape, ShapedJsonSchema } from "../contracts/json-shape.js";
 /**
  * A record whose keys are literal, or `never`. An absent block, an index-signature
- * record — the `AnyFrameworkConfig` default, or a configuration annotated with the
- * wide `FrameworkConfig<M>` — names no field, so it contributes nothing rather
+ * record — the `AvConfigAny` default, or a configuration annotated with the
+ * wide `AvConfig<M>` — names no field, so it contributes nothing rather
  * than widening every resource's field set to `string`.
  */
 type LiteralRecord<T> = unknown extends T ? never : [NonNullable<T>] extends [never] ? never : [NonNullable<T>] extends [object] ? string extends keyof NonNullable<T> ? never : NonNullable<T> : never;
-type LayeredBlocks<Root, Scoped> = [Root] extends [never] ? Scoped : [Scoped] extends [never] ? Root : LayeredRecord<Root, Scoped>;
-/**
- * One configuration block as a derived Contract is compiled from it: the root
- * `Key`, with layer `Layer`'s `Key` layered over it.
- */
-type LayerBlock<Cfg, Layer extends RequestOrigin, Key extends "fields" | "restrictions"> = LayeredBlocks<LiteralRecord<(Cfg & {
+/** The root's own `Key` block. */
+type RootBlock<Cfg, Key extends PropertyKey> = LiteralRecord<(Cfg & {
     readonly [K in Key]?: unknown;
-})[Key]>, LiteralRecord<((Cfg & {
-    readonly [L in Layer]?: unknown;
-})[Layer] & {
-    readonly [K in Key]?: unknown;
-})[Key]>>;
-/** One key's entry in a layered block, or `never` when the block has none. */
+})[Key]>;
+/** The root's `resources` block, its stages erased. */
+type ResourcesBlock<Cfg> = ErasedResources<RootBlock<Cfg, "resources">>;
+/** An overlay's `resources` block, its stages erased (see {@link ResourcesBlock}). */
+type OverlayResourcesBlock<Cfg, Layer extends AvRequestOrigin> = ErasedResources<LiteralRecord<(LiteralRecord<OverlayOf<Cfg, Layer>> & {
+    readonly resources?: unknown;
+})["resources"]>>;
+/** One key's entry in a block, or `never` when the block has none. */
 type EntryOf<Block, Key> = [Block] extends [never] ? never : Key extends keyof Block ? LiteralRecord<NonNullable<Block[Key]>> : never;
 type ConfiguredCapabilities<FieldConfig> = [FieldConfig] extends [never] ? Record<never, never> : FieldConfig extends {
     readonly capabilities: infer Capabilities;
@@ -61,10 +48,19 @@ type LayeredModelField<Field, FieldConfig> = Field extends {
 } ? [FieldConfig] extends [never] ? Field extends {
     readonly capabilities: infer Capabilities;
 } ? "select" extends keyof Capabilities ? Field : ConfiguredModelField<Field, FieldConfig> : ConfiguredModelField<Field, FieldConfig> : ConfiguredModelField<Field, FieldConfig> : Field;
-/** A discovered scalar with its configured capabilities applied, member by member. */
+/**
+ * A discovered scalar with its configured capabilities applied, member by member,
+ * and its configured Json Shape, whose type its value takes.
+ */
 type ConfiguredModelField<Field, FieldConfig> = {
     readonly [P in keyof Field]: P extends "capabilities" ? LayeredCapabilities<Field[P], ConfiguredCapabilities<FieldConfig>> : Field[P];
-};
+} & ConfiguredJsonShape<FieldConfig>;
+/** A configured Json Shape as a view field's `json` member; nothing otherwise. */
+type ConfiguredJsonShape<FieldConfig> = [FieldConfig] extends [never] ? unknown : FieldConfig extends {
+    readonly json: JsonShape<infer Value>;
+} ? {
+    readonly json: ShapedJsonSchema<Value>;
+} : unknown;
 /** A scalar the configuration adds, exactly as the configuration states it. */
 type AddedField<FieldConfig> = {
     readonly kind: "scalar";
@@ -85,60 +81,235 @@ type AddedField<FieldConfig> = {
 type AddedFieldKey<ModelFields, ResourceConfig> = [ResourceConfig] extends [
     never
 ] ? never : Exclude<Extract<keyof ResourceConfig, string>, keyof ModelFields>;
+/** A field entry's `definition`, or `never` when it states none. */
+type DefinitionOf<FieldEntry> = EntryOf<FieldEntry, "definition">;
 /**
- * Whether a restriction entry hides what it names: only a literal `hidden: true`
- * does; `false` restores it.
+ * A Resource's fields before exposure: the model's and the ones the root's
+ * definitions add, each with its definition applied.
  */
-type IsHidden<Restriction> = [Restriction] extends [never] ? false : Restriction extends {
-    readonly hidden: true;
-} ? true : false;
+type LayeredFields<ModelFields, ResourceConfig> = {
+    readonly [F in keyof ModelFields | AddedFieldKey<ModelFields, ResourceConfig>]: F extends keyof ModelFields ? LayeredModelField<ModelFields[F], DefinitionOf<EntryOf<ResourceConfig, F>>> : AddedField<DefinitionOf<EntryOf<ResourceConfig, F>>>;
+};
 /**
- * The keys a restrictions block hides, or `never` for a view that reads no
- * restrictions.
+ * One Resource before exposure: the model's own, with its fields layered and
+ * its create requirements less what the layers' compute stages fill.
  */
-type HiddenKey<Restrictions> = [Restrictions] extends [never] ? never : {
-    [K in keyof Restrictions]-?: IsHidden<EntryOf<Restrictions, K>> extends true ? K : never;
-}[keyof Restrictions];
+type LayeredResource<in out Resource, in out ResourceConfig, in out OverlayConfig> = {
+    readonly [P in keyof Resource]: P extends "fields" ? LayeredFields<Resource[P], EntryOf<ResourceConfig, "fields">> : P extends "createRequirements" ? RequirementsLessComputed<Exclude<Resource[P], undefined>, ComputedOnCreateKey<EntryOf<ResourceConfig, "fields">> | ComputedOnCreateKey<EntryOf<OverlayConfig, "fields">>> : Resource[P];
+};
+/** 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 {
+        readonly pipelines?: infer Pipelines;
+    } ? NonNullable<Pipelines> extends {
+        readonly compute?: infer Compute;
+    } ? "create" extends keyof NonNullable<Compute> ? F : never : never : never;
+}[keyof FieldsBlock];
 /**
- * A Resource's fields in the view: the model's and the ones the configuration
- * adds, less the ones this view's restrictions hide.
+ * A create-requirement statement less `Computed`: a required field leaves
+ * `required`, a group's reference field leaves its group, and a group left with
+ * none is satisfied and leaves `oneOf`. A member left empty is absent, as the
+ * compiler leaves it (`projectCreateRequirements`).
  */
-type LayeredFields<ModelFields, ResourceConfig, FieldRestrictions> = {
-    readonly [F in Exclude<keyof ModelFields | AddedFieldKey<ModelFields, ResourceConfig>, HiddenKey<FieldRestrictions>>]: F extends keyof ModelFields ? LayeredModelField<ModelFields[F], EntryOf<ResourceConfig, F>> : AddedField<EntryOf<ResourceConfig, F>>;
+type RequirementsLessComputed<Requirements, Computed> = [Computed] extends [
+    never
+] ? Requirements : {
+    readonly [P in keyof Requirements as P extends "required" | "oneOf" ? LessComputed<P, Requirements[P], Computed> extends readonly [] ? never : P : P]: P extends "required" | "oneOf" ? LessComputed<P, Requirements[P], Computed> : Requirements[P];
 };
-/** One Resource in the view: the model's own, with its fields layered. */
-type LayeredResource<in out Resource, in out ResourceConfig, in out ResourceRestrictions> = {
-    readonly [P in keyof Resource]: P extends "fields" ? LayeredFields<Resource[P], ResourceConfig, EntryOf<ResourceRestrictions, "fields">> : Resource[P];
+/** One member of a statement less `Computed`: its names, or its groups. */
+type LessComputed<Member, List, Computed> = Member extends "required" ? NamesLessComputed<List, Computed> : GroupsLessComputed<List, Computed>;
+/** A name tuple less `Computed`, still a tuple. */
+type NamesLessComputed<Names, Computed> = Names extends readonly [
+    infer Head,
+    ...infer Rest
+] ? Head extends Computed ? NamesLessComputed<Rest, Computed> : readonly [Head, ...NamesLessComputed<Rest, Computed>] : readonly [];
+/** A group tuple less `Computed` reference fields; a group left with none is dropped. */
+type GroupsLessComputed<Groups, Computed> = Groups extends readonly [
+    infer Group,
+    ...infer Rest
+] ? Group extends readonly [infer Relation, ...infer References] ? NamesLessComputed<References, Computed> extends readonly [] ? GroupsLessComputed<Rest, Computed> : readonly [
+    readonly [Relation, ...NamesLessComputed<References, Computed>],
+    ...GroupsLessComputed<Rest, Computed>
+] : GroupsLessComputed<Rest, Computed> : readonly [];
+/** The Resources before exposure: the model, with the root's definitions applied. */
+type LayeredResources<Resources, Block, OverlayBlock> = {
+    readonly [R in keyof Resources]: LayeredResource<Resources[R], EntryOf<Block, R>, EntryOf<OverlayBlock, R>>;
 };
 /**
- * The Resources in the view. `Restrictions` is the layered `restrictions` block
- * whose `hidden` entries this view applies, or `never` for a view that applies
- * none.
+ * The style a layer's `exposed` sets: `false` picks, `true` or absent omits, a
+ * widened `boolean` keeps the parent's view.
  */
-type LayeredResources<Resources, Block, Restrictions> = {
-    readonly [R in Exclude<keyof Resources, HiddenKey<Restrictions>>]: LayeredResource<Resources[R], EntryOf<Block, R>, EntryOf<Restrictions, R>>;
+type ExposureStyleOf<Exposed> = [Exposed] extends [false] ? "pick" : [Exposed] extends [true] ? "omit" : unknown extends Exposed ? "omit" : "keep";
+/** A layer's `exposed`, read by indexed access (see {@link RootBlock}). */
+type ExposedOf<Layer> = (Layer & {
+    readonly exposed?: unknown;
+})["exposed"];
+/** A layer's `exemptions.resources` block, or `never` when it states none. */
+type ExemptionsOf<Layer> = LiteralRecord<(LiteralRecord<(Layer & {
+    readonly exemptions?: unknown;
+})["exemptions"]> & {
+    readonly resources?: unknown;
+})["resources"]>;
+/** An overlay's own configuration: `application` or `client`. */
+type OverlayOf<Cfg, Layer extends AvRequestOrigin> = (Cfg & {
+    readonly [L in Layer]?: unknown;
+})[Layer];
+/** One key's raw entry in an exemptions block: `true`, a list or an object. */
+type RawEntry<Block, Key> = [Block] extends [never] ? unknown : Key extends keyof Block ? NonNullable<Block[Key]> : unknown;
+/** An entry that exempts its subtree whole under Omit: a literal `true`. */
+type IsWhole<Entry> = [Entry] extends [true] ? true : false;
+/** Whether a Pick entry exempts anything: `true`, `boolean`, a non-empty list or an object. */
+type Grants<Entry> = [Entry] extends [false] ? false : [Entry] extends [boolean] ? true : [Entry] extends [readonly []] ? false : [Entry] extends [object] ? true : false;
+/** The keys of a block whose entry is a literal `true`. */
+type WholeKey<Block> = [Block] extends [never] ? never : {
+    [K in keyof Block]-?: IsWhole<NonNullable<Block[K]>> extends true ? K : never;
+}[keyof Block];
+/** Whether any member of an object entry grants (see {@link Grants}). */
+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;
+/** 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. */
+type OperationsGrant<Entry> = [Entry] extends [readonly unknown[]] ? Grants<Entry> : [Entry] extends [boolean] ? Grants<Entry> : [Entry] extends [object] ? true extends {
+    [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 {
+    [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}). */
+type GrantedFieldKey<Block> = [Block] extends [never] ? never : {
+    [K in keyof Block]-?: FieldGrants<NonNullable<Block[K]>> extends true ? K : never;
+}[keyof Block];
+/** The keys of a Pick `resources` block whose entry grants (see {@link ResourceGrants}). */
+type GrantedResourceKey<Block> = [Block] extends [never] ? never : {
+    [K in keyof Block]-?: ResourceGrants<NonNullable<Block[K]>> extends true ? K : never;
+}[keyof Block];
+/** The names a list entry lists. */
+type Listed<Entry> = Entry extends readonly (infer Name)[] ? Name : never;
+/** A token member's tokens, its qualifier aside. */
+type MemberTokens<Member> = Member extends {
+    readonly scopes: unknown;
+} ? {
+    [K in keyof Member]: K extends "scopes" ? never : Member[K] extends readonly (infer Token)[] ? Token : never;
+}[keyof Member] : Member extends readonly (infer Token)[] ? Token : never;
+/** A token member with its tokens replaced by `Tokens`, qualifier kept. */
+type WithTokens<Member, Tokens> = Member extends {
+    readonly scopes: unknown;
+} ? {
+    readonly [K in keyof Member]: K extends "scopes" ? Member[K] : readonly Tokens[];
+} : readonly Tokens[];
+/** One capability member under an Omit object entry: a token list removes those tokens. */
+type OmittedMember<Member, Entry> = Entry extends readonly unknown[] ? WithTokens<Member, Exclude<MemberTokens<Member>, Listed<Entry>>> : Member;
+/** One capability member under a Pick object entry: a token list keeps only those tokens. */
+type PickedMember<Member, Entry> = Entry extends readonly unknown[] ? WithTokens<Member, Extract<MemberTokens<Member>, Listed<Entry>>> : Member;
+/** The capability members no exemption names and a Pick still keeps. */
+type AdapterLimit = "nestedWriteFilter";
+/** A field's capabilities under its exemption, a list of names or an object. */
+type ExemptedCapabilities<Caps, Entry, Style> = Style extends "omit" ? Entry extends readonly unknown[] ? {
+    readonly [P in keyof Caps as P extends Listed<Entry> ? never : P]: Caps[P];
+} : {
+    readonly [P in keyof Caps as P extends keyof Entry ? IsWhole<Entry[P]> extends true ? never : P : P]: P extends keyof Entry ? OmittedMember<Caps[P], Entry[P]> : Caps[P];
+} : Entry extends readonly unknown[] ? {
+    readonly [P in keyof Caps as P extends Listed<Entry> | AdapterLimit ? P : never]: Caps[P];
+} : {
+    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];
+};
+/** 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];
+};
+/** 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">;
+};
+/** 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>>;
+/** 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`. */
+type TrueVariant<Entry> = {
+    [V in keyof Entry]-?: IsWhole<NonNullable<Entry[V]>> extends true ? V : never;
+}[keyof Entry];
+/** The variants of one family a layer keeps, by its style. */
+type KeptVariant<Family, Entry, Style, UniqueLost> = Exclude<Style extends "omit" ? IsWhole<Entry> extends true ? never : Entry extends readonly unknown[] ? Exclude<keyof Family, Listed<Entry>> : [Entry] extends [boolean] ? keyof Family : Entry extends object ? Exclude<keyof Family, TrueVariant<Entry>> : keyof Family : [Entry] extends [false] ? never : [Entry] extends [boolean] ? keyof Family : Entry extends readonly unknown[] ? Extract<keyof Family, Listed<Entry>> : Entry extends object ? Extract<keyof Family, TrueVariant<Entry>> : never, UniqueLost extends true ? UniqueVariant : never>;
+/** The variants of the unique style, which need an identifier the layer keeps. */
+type UniqueVariant = "unique";
+/** The families with at least one variant the layer keeps. */
+type KeptFamily<Operations, Entry, Style, UniqueLost> = {
+    [F in keyof Operations]-?: [
+        KeptVariant<NonNullable<Operations[F]>, FamilyEntry<Entry, F>, Style, UniqueLost>
+    ] extends [never] ? never : F;
+}[keyof Operations];
+/** A Resource's operations under its exemptions' `operations` entry. */
+type ExemptedOperations<Operations, Entry, Style, UniqueLost> = Style extends "omit" ? unknown extends Entry ? UniqueLost extends true ? KeptOperations<Operations, Entry, Style, UniqueLost> : Operations : KeptOperations<Operations, Entry, Style, UniqueLost> : KeptOperations<Operations, Entry, Style, UniqueLost>;
+type KeptOperations<Operations, Entry, Style, UniqueLost> = {
+    readonly [F in KeptFamily<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. */
+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 & {
+    readonly fields?: unknown;
+})["fields"]>;
+type OperationsEntryOf<Entry> = (Entry & {
+    readonly operations?: unknown;
+})["operations"];
+/** One Resource under an object exemption: its fields, operations and identifiers. */
+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 {
+        readonly fields: infer Fields;
+    } ? Fields : never, FieldsBlock, Style>>> : P extends "identifiers" ? KeptIdentifiers<Resource[P], RemovedField<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>;
+/** 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];
+} : Style extends "pick" ? {
+    readonly [R in Extract<keyof Resources, GrantedResourceKey<Block>>]: ExemptedResource<Resources[R], RawEntry<Block, R>, "pick">;
+} : Resources;
+/** The Resources of the root's final view: what every overlay starts from. */
+export type RootViewResources<M extends AvAdapterModel, Cfg> = ExposedResources<LayeredResources<M["resources"], ResourcesBlock<Cfg>, never>, ExposureStyleOf<ExposedOf<Cfg>>, ExemptionsOf<Cfg>>;
+/** The Resources of an overlay's final view: the root's view, narrowed by it. */
+export type OverlayViewResources<M extends AvAdapterModel, Cfg, Layer extends "application" | "client"> = ExposedResources<ExposedResources<LayeredResources<M["resources"], ResourcesBlock<Cfg>, OverlayResourcesBlock<Cfg, Layer>>, ExposureStyleOf<ExposedOf<Cfg>>, ExemptionsOf<Cfg>>, ExposureStyleOf<ExposedOf<OverlayOf<Cfg, Layer>>>, ExemptionsOf<OverlayOf<Cfg, Layer>>>;
 /**
- * One derived Contract's type: the model, with a layer's `fields` block applied
- * and, when `Restrictions` is a block rather than `never`, its hidden entries
- * removed.
+ * One derived Contract's type: the model, with the root's `resources` block
+ * applied, then the root's exposure, then the overlay's over the root's view.
  */
-type DerivedContractView<M extends AdapterModel, FieldsBlock, Restrictions> = {
+type DerivedContractView<M extends AvAdapterModel, FieldsBlock, RootStyle, RootExemptions, OverlayStyle, OverlayExemptions, OverlayBlock> = {
     readonly scalars: M["scalars"];
     readonly enums: M["enums"];
-    readonly resources: LayeredResources<M["resources"], FieldsBlock, Restrictions>;
-    readonly limits: ContractLimits;
+    readonly resources: ExposedResources<ExposedResources<LayeredResources<M["resources"], FieldsBlock, OverlayBlock>, RootStyle, RootExemptions>, OverlayStyle, OverlayExemptions>;
+    readonly limits: AvContractLimits;
     readonly transactions: M["transactions"];
 };
 /**
  * The Application Contract's type, derived from the adapter model and the
  * configuration.
  */
-export type ApplicationContractView<M extends AdapterModel, Cfg = AnyFrameworkConfig> = [Cfg] extends [unknown] ? DerivedContractView<M, LayerBlock<Cfg, "application", "fields">, never> : never;
+export type AvContractApplicationView<M extends AvAdapterModel, Cfg = AvConfigAny> = [Cfg] extends [unknown] ? DerivedContractView<M, ResourcesBlock<Cfg>, ExposureStyleOf<ExposedOf<Cfg>>, ExemptionsOf<Cfg>, ExposureStyleOf<ExposedOf<OverlayOf<Cfg, "application">>>, ExemptionsOf<OverlayOf<Cfg, "application">>, OverlayResourcesBlock<Cfg, "application">> : never;
 /**
  * The Client Contract's type, derived from the adapter model and the
  * configuration: what the client layer hides is absent. It types
  * `framework.client` and `framework.clientTx`.
  */
-export type ClientContractView<M extends AdapterModel, Cfg = AnyFrameworkConfig> = [Cfg] extends [unknown] ? DerivedContractView<M, LayerBlock<Cfg, "client", "fields">, LayerBlock<Cfg, "client", "restrictions">> : never;
+export type ClientContractView<M extends AvAdapterModel, Cfg = AvConfigAny> = [
+    Cfg
+] extends [unknown] ? DerivedContractView<M, ResourcesBlock<Cfg>, ExposureStyleOf<ExposedOf<Cfg>>, ExemptionsOf<Cfg>, ExposureStyleOf<ExposedOf<OverlayOf<Cfg, "client">>>, ExemptionsOf<OverlayOf<Cfg, "client">>, OverlayResourcesBlock<Cfg, "client">> : never;
 export {};