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

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

@@ -1,48 +1,35 @@
-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";
+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";
-/**
- * Whether `resolveRecord` descends into a value: an object that is no array and
- * no Json Shape.
- */
-type IsLayeredRecord<T> = [T] extends [readonly unknown[]] ? false : [T] extends [JsonShape] ? 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;
-};
 /**
  * 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 & {
-    readonly [K in Key]?: unknown;
-})[Key]>, LiteralRecord<((Cfg & {
-    readonly [L in Layer]?: unknown;
-})[Layer] & {
-    readonly [K in Key]?: unknown;
-})[Key]>>;
-/** Root's own `Key` block, before any layer is layered over it. */
-type RootBlock<Cfg, Key extends "fields" | "restrictions"> = LiteralRecord<(Cfg & {
+/** The root's own `Key` block. */
+type RootBlock<Cfg, Key extends PropertyKey> = LiteralRecord<(Cfg & {
     readonly [K in Key]?: unknown;
 })[Key]>;
-/** One key's entry in a layered block, or `never` when the block has none. */
+/** The root's `resources` block, its stages erased. */
+type ResourcesBlock<Cfg> = ErasedResources<RootBlock<Cfg, "resources">>;
+/** A `resources` block reduced to the `fields` entries the view reads. */
+type ViewBlock<Block> = [Block] extends [never] ? never : {
+    readonly [R in keyof Block as "fields" extends keyof NonNullable<Block[R]> ? R : never]: {
+        readonly fields: (NonNullable<Block[R]> & {
+            readonly fields?: unknown;
+        })["fields"];
+    };
+};
+/** 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;
@@ -102,148 +89,331 @@ 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 configuration's `policy.engine`, read by indexed access (see {@link RootBlock}). */
+type PolicyEngineOf<Cfg> = (NonNullable<(Cfg & {
+    readonly policy?: unknown;
+})["policy"]> & {
+    readonly engine?: unknown;
+})["engine"];
+/** The configuration's `access.policy`, read by indexed access. */
+type AccessEngineOf<Cfg> = ((Cfg & {
+    readonly access?: {
+        readonly policy?: unknown;
+    };
+})["access"] & {
+    readonly policy?: unknown;
+})["policy"];
+/** The configuration's policy engine's `governed` set, when its type states one. */
+type GovernedBlock<Cfg> = LiteralRecord<(NonNullable<PolicyEngineOf<Cfg>> & AccessEngineOf<Cfg> & {
+    readonly governed?: unknown;
+})["governed"]>;
+/** The names `Governed` lists for Resource `R`, or `never`. */
+type GovernedNames<Governed, R> = [Governed] extends [never] ? never : R extends keyof Governed ? Governed[R] extends readonly (infer Name)[] ? Name : never : never;
+/** The `governed: true` mark, added to a field: a key the field does not have. */
+type GovernedMark = {
+    readonly governed: true;
+};
+/** A Resource's fields with each governed one marked. */
+type GovernedFields<Fields, Governed> = [Governed] extends [never] ? Fields : {
+    readonly [F in keyof Fields]: F extends Governed ? Fields[F] & GovernedMark : Fields[F];
+};
+/** The root's `resources` block's Resources marked `managedElsewhere: true`. */
+type ManagedBlock<Block> = [Block] extends [never] ? never : {
+    [R in keyof Block]-?: NonNullable<Block[R]> extends {
+        readonly managedElsewhere: true;
+    } ? R : never;
+}[keyof Block];
+/** The write families a managed Resource never offers. */
+type WriteFamily = "create" | "update" | "delete" | "upsert";
+/** The two write capabilities a field may have. */
+type WriteStage = "create" | "update";
+/** A managed Resource's operations: its reads alone. */
+type ReadOperations<Operations> = {
+    readonly [F in keyof Operations as F extends WriteFamily ? never : F]: Operations[F];
+};
+/** Capabilities with each write member narrowed to `Kept` tokens, dropped when none is left. */
+type KeptWrites<Caps, Kept> = {
+    readonly [K in keyof Caps as K extends WriteStage ? [Extract<MemberTokens<NonNullable<Caps[K]>>, Kept>] extends [never] ? never : K : K]: K extends WriteStage ? WithTokens<NonNullable<Caps[K]>, Extract<MemberTokens<NonNullable<Caps[K]>>, Kept>> : Caps[K];
+};
+/** A field whose writes keep only `Kept` directives. */
+type WritesKept<Field, Kept> = {
+    readonly [P in keyof Field]: P extends "capabilities" ? KeptWrites<Field[P], Kept> : Field[P];
+};
+/** The directives a relation into a managed Resource keeps: the source row's own, where it holds the key. */
+type SourceRowDirectives<Field> = Field extends {
+    readonly referenceFields: readonly [unknown, ...unknown[]];
+} ? "$connect" | "$disconnect" : never;
+/** A Resource's fields, written as a managed Resource's or as relations into one. */
+type ManagedFields<Fields, Managed, IsManaged> = [Managed] extends [never] ? Fields : IsManaged extends true ? {
+    readonly [F in keyof Fields]: WritesKept<Fields[F], never>;
+} : {
+    readonly [F in keyof Fields]: Fields[F] extends {
+        readonly kind: "relation";
+        readonly target: Managed;
+    } ? WritesKept<Fields[F], SourceRowDirectives<Fields[F]>> : Fields[F];
+};
 /**
- * The keys a restrictions block hides, or `never` for a view that reads no
- * restrictions.
+ * The root's view with what is managed elsewhere applied: each managed
+ * Resource's writes withheld, and each relation's into one; under `Hidden` (the
+ * client's view) the managed Resources and every relation into them left out.
  */
-type HiddenKey<Restrictions> = [Restrictions] extends [never] ? never : {
-    [K in keyof Restrictions]-?: IsHidden<EntryOf<Restrictions, K>> extends true ? K : never;
-}[keyof Restrictions];
-/** A restriction entry's `capabilities` block, or `never` when it states none. */
-type CapabilityRestrictionsOf<Entry> = [Entry] extends [never] ? never : EntryOf<Entry, "capabilities">;
-/** A restriction member that is a literal `false`: a denial. */
-type IsDenial<Value> = [Value] extends [false] ? true : false;
-/** A restriction member that is a literal `true`: a restoration. */
-type IsRestoration<Value> = [Value] extends [true] ? true : false;
-/** The tokens a capability member advertises, its qualifier aside. */
-type MemberTokens<Member, TokenKey extends string> = Member extends {
-    readonly scopes: unknown;
-} ? TokenKey extends keyof Member ? Member[TokenKey] : never : Member;
-/** The positions a scope-qualified member holds in; `never` for an unqualified one. */
-type MemberScopes<Member> = Member extends {
-    readonly scopes: infer Scopes;
-} ? Scopes : never;
-/** A relation's `create`, `update` or `reducers` member narrowed by a restriction. */
-type NarrowedScopedTokens<Member, Restriction, TokenKey extends "directives" | "reducers"> = Restriction extends readonly unknown[] ? [MemberScopes<Member>] extends [never] ? Restriction : {
-    readonly [K in TokenKey | "scopes"]: K extends "scopes" ? MemberScopes<Member> : Restriction;
-} : Restriction extends object ? (Restriction extends {
-    readonly scopes: infer Scopes;
-} ? Scopes : MemberScopes<Member>) extends infer Scopes ? [Scopes] extends [never] ? Restriction extends {
-    readonly [K in TokenKey]: infer Tokens;
-} ? Tokens : MemberTokens<Member, TokenKey> : Scopes extends readonly [] ? false : {
-    readonly [K in TokenKey | "scopes"]: K extends "scopes" ? Scopes : Restriction extends {
-        readonly [T in TokenKey]: infer Tokens;
-    } ? Tokens : MemberTokens<Member, TokenKey>;
-} : never : Member;
-/** One capability member narrowed by a list (or, on a relation, an object) restriction. */
-type NarrowedMember<Kind, Key, Member, Restriction> = Kind extends "relation" ? Key extends "select" | "include" ? Restriction extends readonly [] ? false : Restriction : Key extends "create" | "update" ? NarrowedScopedTokens<Member, Restriction, "directives"> : Key extends "reducers" ? NarrowedScopedTokens<Member, Restriction, "reducers"> : Restriction : Restriction;
-/** One capability member of a field under its layer's restrictions. */
-type RestrictedMember<Kind, Key, Member, Root, Layered> = IsRestoration<Layered> extends true ? Root extends readonly unknown[] | {
-    readonly scopes?: unknown;
-} ? NarrowedMember<Kind, Key, Member, Root> : Member : [Layered] extends [boolean] ? Member : NarrowedMember<Kind, Key, Member, Layered>;
-/** The members a capabilities restriction denies, or narrows to nothing. */
-type DeniedMember<Kind, Own, Root, Layered> = {
-    [P in keyof Own]-?: P extends keyof Layered ? IsDenial<Layered[P]> extends true ? P : [
-        RestrictedMember<Kind, P, Own[P], P extends keyof Root ? Root[P] : undefined, Layered[P]>
-    ] extends [false] ? P : never : never;
-}[keyof Own];
-/** A field's capabilities under its layer's restrictions. */
-type RestrictedCapabilities<Kind, Own, Root, Layered> = {
-    readonly [P in keyof Own as P extends DeniedMember<Kind, Own, Root, Layered> ? never : P]: P extends keyof Layered ? RestrictedMember<Kind, P, Own[P], P extends keyof Root ? Root[P] : undefined, Layered[P]> : Own[P];
-};
-/** A view field with its layer's capability restrictions applied. */
-type RestrictedField<Field, RootEntry, Entry> = [
-    CapabilityRestrictionsOf<Entry>
-] extends [never] ? Field : {
-    readonly [P in keyof Field]: P extends "capabilities" ? RestrictedCapabilities<Field extends {
-        readonly kind: infer Kind;
-    } ? Kind : never, Field[P], CapabilityRestrictionsOf<RootEntry>, CapabilityRestrictionsOf<Entry>> : Field[P];
+type ManagedView<Resources, Managed, Hidden> = [Managed] extends [never] ? Resources : ManagedResources<Resources, Managed, Hidden>;
+/** {@link ManagedView}'s Resources when something is managed elsewhere. */
+type ManagedResources<in out Resources, in out Managed, in out Hidden> = {
+    readonly [R in Exclude<keyof Resources, Hidden>]: {
+        readonly [P in keyof Resources[R]]: P extends "fields" ? [Hidden] extends [never] ? ManagedFields<Resources[R][P], Managed, R extends Managed ? true : false> : {
+            readonly [F in keyof Resources[R][P] as Resources[R][P][F] extends {
+                readonly kind: "relation";
+                readonly target: Hidden;
+            } ? never : F]: Resources[R][P][F];
+        } : P extends "operations" ? R extends Managed ? ReadOperations<Resources[R][P]> : Resources[R][P] : Resources[R][P];
+    };
 };
 /**
- * A Resource's fields in the view: the model's and the ones the configuration
- * adds, less the ones this view's restrictions hide, each with its capability
- * restrictions applied.
+ * 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.
  */
-type LayeredFields<ModelFields, ResourceConfig, FieldRestrictions, RootFieldRestrictions> = {
-    readonly [F in Exclude<keyof ModelFields | AddedFieldKey<ModelFields, ResourceConfig>, HiddenKey<FieldRestrictions>>]: RestrictedField<F extends keyof ModelFields ? LayeredModelField<ModelFields[F], EntryOf<ResourceConfig, F>> : AddedField<EntryOf<ResourceConfig, F>>, EntryOf<RootFieldRestrictions, F>, EntryOf<FieldRestrictions, F>>;
+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];
+};
+/** 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 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`).
+ */
+export 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 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, Governed = never> = {
+    readonly [R in keyof Resources]: LayeredResource<Resources[R], EntryOf<Block, R>, EntryOf<OverlayBlock, R>, GovernedNames<Governed, R>>;
 };
-/** The variants of one family an operations restriction turns off: literal `false` only. */
-type DisabledVariant<FamilyRestriction> = [FamilyRestriction] extends [never] ? never : {
-    [V in keyof FamilyRestriction]-?: IsDenial<FamilyRestriction[V]> extends true ? V : never;
-}[keyof FamilyRestriction];
-/** The variants of the unique style, which need an identifier the layer keeps. */
-type UniqueVariant = "unique";
 /**
- * The variants of one family the layer advertises: the model's, less those turned
- * off, less the unique one when no identifier survives.
+ * The style a layer's `exposed` sets: `false` picks, `true` or absent omits, a
+ * widened `boolean` keeps the parent's view.
  */
-type AvailableVariant<Family, FamilyRestriction, UniqueLost> = Exclude<keyof Family, DisabledVariant<FamilyRestriction> | (UniqueLost extends true ? UniqueVariant : never)>;
-/** The families with at least one variant the layer advertises. */
-type AvailableFamily<Operations, OperationRestrictions, UniqueLost> = {
+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" | "filterModes" | "pathFilterModes";
+/** 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]-?: [
-        AvailableVariant<NonNullable<Operations[F]>, EntryOf<OperationRestrictions, F>, UniqueLost>
+        KeptVariant<NonNullable<Operations[F]>, FamilyEntry<Entry, F>, Style, UniqueLost>
     ] extends [never] ? never : F;
 }[keyof Operations];
-/** A Resource's operations under its layer's restrictions. */
-type RestrictedOperations<Operations, OperationRestrictions, UniqueLost> = [
-    OperationRestrictions
-] extends [never] ? UniqueLost extends true ? LayerOperations<Operations, never, UniqueLost> : Operations : LayerOperations<Operations, OperationRestrictions, UniqueLost>;
-type LayerOperations<Operations, OperationRestrictions, UniqueLost> = {
-    readonly [F in AvailableFamily<Operations, OperationRestrictions, UniqueLost>]: {
-        readonly [V in AvailableVariant<NonNullable<Operations[F]>, EntryOf<OperationRestrictions, F>, UniqueLost>]: NonNullable<Operations[F]>[V];
+/** 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 hidden field. */
-type KeptIdentifiers<Identifiers, Hidden> = [Hidden] extends [never] ? Identifiers : Identifiers extends readonly (infer Identifier)[] ? readonly (Identifier extends readonly (infer Field)[] ? [Extract<Field, Hidden>] extends [never] ? Identifier : never : never)[] : Identifiers;
-/** Whether hiding fields left a Resource with no identifier at all. */
-type IdentifiersLost<Identifiers, Hidden> = [Hidden] extends [never] ? false : [
-    KeptIdentifiers<Identifiers, Hidden> extends readonly (infer Kept)[] ? Kept : never
+/** 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;
-/**
- * One Resource in the view: the model's own, with its fields layered and its
- * layer's restrictions applied to its fields, operations and identifiers.
- */
-type LayeredResource<in out Resource, in out ResourceConfig, in out ResourceRestrictions, in out RootResourceRestrictions> = {
-    readonly [P in keyof Resource]: P extends "fields" ? LayeredFields<Resource[P], ResourceConfig, EntryOf<ResourceRestrictions, "fields">, EntryOf<RootResourceRestrictions, "fields">> : P extends "operations" ? RestrictedOperations<Resource[P], EntryOf<ResourceRestrictions, "operations">, IdentifiersLost<Resource extends {
+/** 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, HiddenKey<EntryOf<ResourceRestrictions, "fields">>>> : P extends "identifiers" ? KeptIdentifiers<Resource[P], HiddenKey<EntryOf<ResourceRestrictions, "fields">>> : Resource[P];
+    } ? 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> = ManagedView<ExposedResources<LayeredResources<M["resources"], ResourcesBlock<Cfg>, never>, ExposureStyleOf<ExposedOf<Cfg>>, ExemptionsOf<Cfg>>, ManagedBlock<RootBlock<Cfg, "resources">>, never>;
+/** 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<ManagedView<ExposedResources<LayeredResources<M["resources"], ResourcesBlock<Cfg>, OverlayResourcesBlock<Cfg, Layer>>, ExposureStyleOf<ExposedOf<Cfg>>, ExemptionsOf<Cfg>>, ManagedBlock<RootBlock<Cfg, "resources">>, Layer extends "client" ? ManagedBlock<RootBlock<Cfg, "resources">> : never>, ExposureStyleOf<ExposedOf<OverlayOf<Cfg, Layer>>>, ExemptionsOf<OverlayOf<Cfg, Layer>>>;
 /**
- * The Resources in the view. `Restrictions` is the layer's layered
- * `restrictions` block and `RootRestrictions` root's own, whose narrowings a
- * restoration inherits; both `never` for a configuration that restricts nothing.
+ * One derived Contract's type: the model, with the root's `fields` entries
+ * applied, then the root's exposure, then the overlay's over the root's view.
+ * `framework.application`, `client`, `appTx` and `clientTx` are typed over it,
+ * and a declaration file names it when it writes one of their nodes.
  */
-type LayeredResources<Resources, Block, Restrictions, RootRestrictions> = {
-    readonly [R in Exclude<keyof Resources, HiddenKey<Restrictions>>]: LayeredResource<Resources[R], EntryOf<Block, R>, EntryOf<Restrictions, R>, EntryOf<RootRestrictions, R>>;
+export type AvContractView<M extends AvAdapterModel, RootFields, RootStyle, RootExemptions, OverlayStyle, OverlayExemptions, OverlayFields, Governed = never> = {
+    readonly scalars: M["scalars"];
+    readonly enums: M["enums"];
+    readonly resources: ExposedResources<ExposedResources<LayeredResources<M["resources"], RootFields, OverlayFields, Governed>, RootStyle, RootExemptions>, OverlayStyle, OverlayExemptions>;
+    readonly limits: AvContractLimits;
+    readonly transactions: M["transactions"];
 };
 /**
- * One derived Contract's type: the model, with a layer's `fields` block applied
- * and its layered `restrictions` block (`Restrictions`, over root's own,
- * `RootRestrictions`) applied.
+ * {@link AvContractView} for a configuration that marks Resources managed
+ * elsewhere (`Managed`): their writes, and the writes of relations into them,
+ * withheld after the root's exposure; under `Hidden` (the client's view) they
+ * and every relation into them left out.
  */
-type DerivedContractView<M extends AdapterModel, FieldsBlock, Restrictions, RootRestrictions> = {
+export type AvManagedContractView<M extends AvAdapterModel, RootFields, RootStyle, RootExemptions, OverlayStyle, OverlayExemptions, OverlayFields, Governed, in out Managed, in out Hidden> = {
     readonly scalars: M["scalars"];
     readonly enums: M["enums"];
-    readonly resources: LayeredResources<M["resources"], FieldsBlock, Restrictions, RootRestrictions>;
-    readonly limits: ContractLimits;
+    readonly resources: ExposedResources<ManagedView<ExposedResources<LayeredResources<M["resources"], RootFields, OverlayFields, Governed>, RootStyle, RootExemptions>, Managed, Hidden>, 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">, LayerBlock<Cfg, "application", "restrictions">, RootBlock<Cfg, "restrictions">> : never;
+export type AvContractApplicationView<M extends AvAdapterModel, Cfg = AvConfigAny> = [Cfg] extends [unknown] ? [ManagedBlock<RootBlock<Cfg, "resources">>] extends [never] ? AvContractView<M, ViewBlock<ResourcesBlock<Cfg>>, ExposureStyleOf<ExposedOf<Cfg>>, ExemptionsOf<Cfg>, ExposureStyleOf<ExposedOf<OverlayOf<Cfg, "application">>>, ExemptionsOf<OverlayOf<Cfg, "application">>, ViewBlock<OverlayResourcesBlock<Cfg, "application">>, GovernedBlock<Cfg>> : AvManagedContractView<M, ViewBlock<ResourcesBlock<Cfg>>, ExposureStyleOf<ExposedOf<Cfg>>, ExemptionsOf<Cfg>, ExposureStyleOf<ExposedOf<OverlayOf<Cfg, "application">>>, ExemptionsOf<OverlayOf<Cfg, "application">>, ViewBlock<OverlayResourcesBlock<Cfg, "application">>, GovernedBlock<Cfg>, ManagedBlock<RootBlock<Cfg, "resources">>, never> : 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">, RootBlock<Cfg, "restrictions">> : never;
+export type ClientContractView<M extends AvAdapterModel, Cfg = AvConfigAny> = [
+    Cfg
+] extends [unknown] ? [ManagedBlock<RootBlock<Cfg, "resources">>] extends [never] ? AvContractView<M, ViewBlock<ResourcesBlock<Cfg>>, ExposureStyleOf<ExposedOf<Cfg>>, ExemptionsOf<Cfg>, ExposureStyleOf<ExposedOf<OverlayOf<Cfg, "client">>>, ExemptionsOf<OverlayOf<Cfg, "client">>, ViewBlock<OverlayResourcesBlock<Cfg, "client">>, GovernedBlock<Cfg>> : AvManagedContractView<M, ViewBlock<ResourcesBlock<Cfg>>, ExposureStyleOf<ExposedOf<Cfg>>, ExemptionsOf<Cfg>, ExposureStyleOf<ExposedOf<OverlayOf<Cfg, "client">>>, ExemptionsOf<OverlayOf<Cfg, "client">>, ViewBlock<OverlayResourcesBlock<Cfg, "client">>, GovernedBlock<Cfg>, ManagedBlock<RootBlock<Cfg, "resources">>, ManagedBlock<RootBlock<Cfg, "resources">>> : never;
 export {};

package/dist/framework/framework-construction.error.d.ts

@@ -1,16 +1,26 @@
-import type { AdapterDiscoveryDiagnostic } from "../adapters/adapter-discovery-diagnostic.js";
-import type { ContractCompilerDiagnostic } from "../compiler/contract-compiler-diagnostic.js";
-import type { ConfigDiagnostic } from "../config/config-diagnostic.js";
+import type { AvAdapterDiscoveryDiagnostic } from "../adapters/adapter-discovery-diagnostic.js";
+import type { AvContractCompilerDiagnostic } from "../compiler/contract-compiler-diagnostic.js";
+import type { AvConfigDiagnostic } from "../config/config-diagnostic.js";
 /** The construction step that failed. */
-export type FrameworkConstructionStage = "configuration" | "discovery" | "contract-compilation";
-/** One problem reported by {@link FrameworkConstructionError}. */
-export type FrameworkConstructionDiagnostic = ConfigDiagnostic | AdapterDiscoveryDiagnostic | ContractCompilerDiagnostic;
+export type AvConstructionStage = "configuration" | "discovery" | "contract-compilation";
+/** One problem found while constructing, before its documentation link is added. */
+type ConstructionProblem = AvConfigDiagnostic | AvAdapterDiscoveryDiagnostic | AvContractCompilerDiagnostic;
+/**
+ * One problem reported by {@link AvConstructionError}: its `code`, `path` and
+ * `message`, and `docs`, the URL of the code's entry on the error-codes page
+ * (the same as `AvErrorCatalog[code].docs`).
+ */
+export type AvConstructionDiagnostic = ConstructionProblem & {
+    readonly docs: string;
+};
 /**
  * Thrown by {@link createFramework} when construction fails: `stage` says
- * where, and `diagnostics` lists every problem found there.
+ * where, and `diagnostics` lists every problem found there. The message names
+ * the first of them and how many more there are.
  */
-export declare class FrameworkConstructionError extends Error {
-    readonly stage: FrameworkConstructionStage;
-    readonly diagnostics: readonly FrameworkConstructionDiagnostic[];
-    constructor(stage: FrameworkConstructionStage, diagnostics: readonly FrameworkConstructionDiagnostic[]);
+export declare class AvConstructionError extends Error {
+    readonly stage: AvConstructionStage;
+    readonly diagnostics: readonly AvConstructionDiagnostic[];
+    constructor(stage: AvConstructionStage, diagnostics: readonly ConstructionProblem[]);
 }
+export {};

package/dist/framework/framework-construction.error.js

@@ -1,15 +1,31 @@
+import { brandCoreClass } from "../runtime/core-class.brand.js";
+import { errorDocsUrl } from "../runtime/error.catalog.js";
 const FRAMEWORK_CONSTRUCTION_MESSAGES = {
     configuration: "Aventara framework configuration validation failed",
     discovery: "Aventara adapter discovery validation failed",
     "contract-compilation": "Aventara contract compilation failed",
 };
-export class FrameworkConstructionError extends Error {
+function constructionMessage(stage, diagnostics) {
+    const base = FRAMEWORK_CONSTRUCTION_MESSAGES[stage];
+    const [first] = diagnostics;
+    if (first === undefined) {
+        return base;
+    }
+    const where = first.path === "" ? "" : ` at ${first.path}`;
+    const more = diagnostics.length > 1 ? ` (+${diagnostics.length - 1} more)` : "";
+    return `${base}: ${first.code}${where}: ${first.message}${more}`;
+}
+export class AvConstructionError extends Error {
     stage;
     diagnostics;
     constructor(stage, diagnostics) {
-        super(FRAMEWORK_CONSTRUCTION_MESSAGES[stage]);
-        this.name = "FrameworkConstructionError";
+        super(constructionMessage(stage, diagnostics));
+        this.name = "AvConstructionError";
         this.stage = stage;
-        this.diagnostics = [...diagnostics];
+        this.diagnostics = diagnostics.map((diagnostic) => ({
+            ...diagnostic,
+            docs: errorDocsUrl(diagnostic.code),
+        }));
     }
 }
+brandCoreClass(AvConstructionError, "AvConstructionError");