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

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

@@ -1,48 +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";
+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">>;
+/** 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 +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];
-/** 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];
+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 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 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];
 };
-/** 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];
+/** 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>>;
 };
 /**
- * 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.
+ * The style a layer's `exposed` sets: `false` picks, `true` or absent omits, a
+ * widened `boolean` keeps the parent's view.
  */
-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 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 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 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 variants of one family the layer advertises: the model's, less those turned
- * off, less the unique one when no identifier survives.
- */
-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> = {
+/** 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];
-};
-/**
- * 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.
- */
-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>>;
+    } ? 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 its layered `restrictions` block (`Restrictions`, over root's own,
- * `RootRestrictions`) applied.
+ * 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, RootRestrictions> = {
+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, RootRestrictions>;
-    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">, LayerBlock<Cfg, "application", "restrictions">, RootBlock<Cfg, "restrictions">> : 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">, RootBlock<Cfg, "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 {};

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

@@ -1,16 +1,16 @@
-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 reported by {@link AvConstructionError}. */
+export type AvConstructionDiagnostic = AvConfigDiagnostic | AvAdapterDiscoveryDiagnostic | AvContractCompilerDiagnostic;
 /**
  * Thrown by {@link createFramework} when construction fails: `stage` says
  * where, and `diagnostics` lists every problem found there.
  */
-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 AvConstructionDiagnostic[]);
 }

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

@@ -3,12 +3,12 @@ const FRAMEWORK_CONSTRUCTION_MESSAGES = {
     discovery: "Aventara adapter discovery validation failed",
     "contract-compilation": "Aventara contract compilation failed",
 };
-export class FrameworkConstructionError extends Error {
+export class AvConstructionError extends Error {
     stage;
     diagnostics;
     constructor(stage, diagnostics) {
         super(FRAMEWORK_CONSTRUCTION_MESSAGES[stage]);
-        this.name = "FrameworkConstructionError";
+        this.name = "AvConstructionError";
         this.stage = stage;
         this.diagnostics = [...diagnostics];
     }

package/dist/framework/framework.d.ts

@@ -1,28 +1,41 @@
-import type { AdapterModel } from "../adapters/adapter-model.js";
-import type { FrameworkContracts } from "../compiler/contract.compiler.js";
-import type { AnyFrameworkConfig } from "../config/any-framework-config.js";
+import type { AvAdapterModel } from "../adapters/adapter-model.js";
+import type { AvContracts } from "../compiler/contract.compiler.js";
+import type { AvConfigAny } from "../config/any-framework-config.js";
+import type { AvMcpEndpoint } from "../config/config.resolver.js";
 import type { FrameworkOperationRequest } from "../runtime/operation-request.js";
-import type { OperationResponse } from "../runtime/operation-response.js";
-import type { TransactionRunner } from "../transactions/deferred-operation.js";
+import type { AvOperationResponse } from "../runtime/operation-response.js";
+import type { AvTransactionRunner } from "../transactions/deferred-operation.js";
 import type { FrameworkTransactionRequest } from "../transactions/transaction-request.js";
-import type { TransactionResponse } from "../transactions/transaction-response.js";
+import type { AvTransactionResponse } from "../transactions/transaction-response.js";
 import type { ApplicationOperations, ApplicationTransactionBuilders, ClientOperations, ClientTransactionBuilders } from "./operation-facade.js";
 /**
  * One Aventara instance, as returned by {@link createFramework}: its compiled
  * Contracts, typed in-process operations, transaction builders and the
  * untyped `execute` entry a transport calls.
  */
-export type Framework<M extends AdapterModel = AdapterModel, Cfg = AnyFrameworkConfig> = {
-    readonly entrypoint: string;
-    readonly contracts: FrameworkContracts;
+export type AvFramework<M extends AvAdapterModel = AvAdapterModel, Cfg = AvConfigAny> = {
+    /**
+     * The protocol's mount path (`api`) in its canonical form: `""` at the
+     * root, otherwise `/seg(/seg)*`.
+     */
+    readonly api: string;
+    /**
+     * The MCP endpoint `mcp` turns on — its canonical mount path and its
+     * authorization — for the host that serves it; `undefined` when MCP is off.
+     */
+    readonly mcp: AvMcpEndpoint | undefined;
+    readonly contracts: AvContracts;
     /**
      * Typed in-process operations under the Application Contract:
      * `framework.application.<resource>.<family>.<variant>(args, options?)`.
      *
      * Typed from the Application Contract as configured: what the application's
-     * restrictions hide, deny or turn off is absent from the types, and a call is
-     * validated like any other request. The optional second argument is
-     * {@link ExecutionOptions}.
+     * exposure hides, denies or turns off is absent from the types, and a call is
+     * validated like any other request. A call resolves the operation's data (a
+     * first-style miss is `null`) and throws every failure as the `AvError`
+     * subclass of its code's class (`AvValidationError`, `AvNotFoundError`, …).
+     * The optional second argument is
+     * {@link AvExecutionOptions}.
      */
     readonly application: ApplicationOperations<M, Cfg>;
     /**
@@ -33,25 +46,33 @@ export type Framework<M extends AdapterModel = AdapterModel, Cfg = AnyFrameworkC
      * as from a generated client, and arguments are read in the wire
      * forms a decoded request body carries, so a transport can pass `req.body` as
      * it is. Each call runs the client pipelines and the same validation as a
-     * remote request.
+     * remote request, and settles like an application call: the data, or the
+     * failure thrown.
      */
     readonly client: ClientOperations<M, Cfg>;
     /**
      * Transaction builders under application rules:
      * `framework.appTx.<resource>.<family>.<variant>(args)` defers one operation
-     * into a handle typed `Operation<OperationResultFor<…>>` from the Application
+     * into a handle typed `AvOperation<AvOperationResultFor<…>>` from the Application
      * Contract's view, and runs nothing. A handle exposes `$ref(field)` exactly
      * where its result is one row; the reference is bound to the handle, and its
      * index is bound when {@link transaction} runs the list it is in.
+     *
+     * `framework.appTx.$sql` defers a developer SQL step, written only as a tagged
+     * template whose every interpolated value is bound as a parameter (a `$ref`
+     * among them, resolved when the earlier steps have run). It runs in plan order
+     * in the same database transaction, with no pipelines around it; its entry in
+     * the committed data is its rows, typed by `appTx.$sql<Row>`. It exists only
+     * here: `clientTx`, the Client Contract and `/_transactions` have no SQL step.
      */
     readonly appTx: ApplicationTransactionBuilders<M, Cfg>;
     /**
      * The same builders under ClientContract rules, taking wire-form arguments.
-     * Client and application handles may share one {@link transaction}; each step
-     * runs under its own handle's rules.
+     * A {@link transaction} has one origin: client and application handles never
+     * share one (`A2004`/`V1020` at the first step of the other origin).
      */
     readonly clientTx: ClientTransactionBuilders<M, Cfg>;
-    execute(request: FrameworkOperationRequest): Promise<OperationResponse>;
+    execute(request: FrameworkOperationRequest): Promise<AvOperationResponse>;
     /**
      * Validates a whole transaction plan, then runs its operations one after
      * another inside one Adapter transaction. Answers `A1009` with each
@@ -62,15 +83,18 @@ export type Framework<M extends AdapterModel = AdapterModel, Cfg = AnyFrameworkC
      * Guards, pipes, hooks and interceptors run while the transaction is open, so
      * they should not perform network I/O or other slow work.
      */
-    executeTransaction(request: FrameworkTransactionRequest): Promise<TransactionResponse>;
+    executeTransaction(request: FrameworkTransactionRequest): Promise<AvTransactionResponse>;
     /**
      * Runs handles from `appTx`/`clientTx` as one transaction:
-     * `framework.transaction([h1, h2, …], options?)`. Resolves the committed
-     * response, typed per position, or the failure response. Never rejects.
+     * `framework.transaction([h1, h2, …], options?)`. Resolves each handle's
+     * result in plan order, typed per position, once the transaction committed,
+     * or throws the failure as the `AvError` subclass of its code's class, with
+     * `cause.operation` naming the failing step.
      *
      * Refused before anything runs: an entry that is not one of this Framework's
-     * handles, or the same handle twice (`A2004`/`V1001`); a `$ref` to a handle
-     * not in the list (`A2007`/`V1010`).
+     * handles, or the same handle twice (`A2004`/`V1001`); `appTx` and `clientTx`
+     * handles in one list (`A2004`/`V1020`); a `$ref` to a handle not in the list
+     * (`A2007`/`V1010`).
      */
-    readonly transaction: TransactionRunner;
+    readonly transaction: AvTransactionRunner;
 };

package/dist/framework/framework.factory.d.ts

@@ -1,11 +1,13 @@
-import type { AdapterModel } from "../adapters/adapter-model.js";
-import type { AnyFrameworkConfig } from "../config/any-framework-config.js";
-import type { FrameworkConfig } from "../config/framework-config.js";
-import type { Framework } from "./framework.js";
+import type { AvAdapterModel } from "../adapters/adapter-model.js";
+import type { AvConfigAny } from "../config/any-framework-config.js";
+import type { AvConfigExact } from "../config/exact-framework-config.js";
+import type { AvConfig } from "../config/framework-config.js";
+import type { ErasedConfig } from "../config/stage-type.eraser.js";
+import type { AvFramework } from "./framework.js";
 /**
  * Creates a Framework: validates the configuration, reads the adapter's
  * model and compiles the Contracts.
  *
- * @throws {@link FrameworkConstructionError} when any of those steps fails.
+ * @throws {@link AvConstructionError} when any of those steps fails.
  */
-export declare function createFramework<M extends AdapterModel, const Cfg = AnyFrameworkConfig>(config: Cfg & FrameworkConfig<M, Cfg>): Promise<Framework<M, Cfg>>;
+export declare function createFramework<M extends AvAdapterModel, const Cfg = AvConfigAny>(config: Cfg & AvConfig<M, Cfg> & AvConfigExact<M, Cfg>): Promise<AvFramework<M, ErasedConfig<Cfg>>>;