@mcp-abap-adt/interfaces-adt 20.2.0 → 22.0.0

package/CHANGELOG.md

@@ -7,6 +7,215 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [22.0.0] - 2026-10-28
+
+A major for one change: the ABAP cloud table loses the program and include
+operations the cloud refuses (see "Changed (breaking)"). Everything else is
+added beside 21.0.0's types: each keeps its meaning, and a type parameter
+added to an existing type has the 21.0.0 type as its default.
+
+### Changed (breaking)
+
+- **`ADT_TYPES_CLOUD`: a program and an include change nothing.** ABAP cloud
+  refuses to create either (`403`, S_DEVELOP, measured on the BTP trial
+  2026-10-28), so `PROG/P` and `PROG/I` no longer list `create`, `update`,
+  `lock`, `unlock`, `activate`, `validate`, `deletionCheck` or `delete`.
+  What a delivered one answers stays: `read`, `source` and `readMetadata`
+  (measured on both), `check` and `versions` for a program (measured),
+  and the operations not measured — the enhancement reads, `transport`,
+  `run`, `profile` and the unit-test runs — as the release's `typestructure`
+  lists them. Leaving out the change operations beyond `create` is an
+  inference from the refusal: S_DEVELOP is the change authorization, and an
+  object nobody can create has nothing of one's own to change. A function
+  include (`FUGR/I`) is unchanged: the cloud creates one (`200`, measured).
+  `AdtTypeCodeWith<'cloud', Op>` and `AdtCodeWith<AdtModernVariant, Op>` no
+  longer name `PROG/P` or `PROG/I` for those operations, and the cloud table
+  is no longer the on-premise one in operations.
+
+### Added
+
+- **`updateMetadata`** on `CLAS/OC`, `INTF/OI`, `FUGR/FF` and `DDLS/DF` in
+  `ADT_TYPES_ONPREM` and `ADT_TYPES_CLOUD`, and on `PROG/P` in
+  `ADT_TYPES_ONPREM`: the object's whole metadata document, written back with
+  the media type it was read with, answers `200` on S/4HANA 2025 and on ABAP
+  cloud (measured 2026-10-27). 7.40 is not measured yet and keeps none.
+
+- **Intersecting helpers.** `AdtCodeOf<V>` and `AdtCodeWith<V, Op>`: the codes
+  every variant of `V` lists (with `Op`) — the default modern variant,
+  `AdtModernVariant` (`'onprem' | 'cloud'`), gets what both newer tables
+  serve. `AdtCodeOfIn<Tables, V>` and `AdtCodeWithIn<Tables, V, Op>` are the
+  same over any set of tables; `AdtServingVariantsIn<Tables, A>` and
+  `AdtPerformingVariantsIn<Tables, A, Op>` name the variants whose table
+  serves an API, or one of its codes an operation. `AdtTypeCodeOf`,
+  `AdtTypeCodeWith`, `AdtApiWith` and `AdtApiWithIn` are unchanged; their docs
+  now state what they answer for a union of variants — the APIs all of them
+  serve, and for those the codes and operations any of them lists.
+- **Utility code tables**, `ADT_UTILITY_CODES_ONPREM`, `_CLOUD`,
+  `_BASIS_740` (`IAdtUtilityCodeTables`, `AdtUtilityCodeTable<R>`,
+  `IAdtUtilityCodeFacts<R>`, `AdtUtilityOperation`, `AdtUtilityCodeWith<V,
+  Op>`, `AdtUtilityCode`): the codes `getUtils()` takes beyond the API tables,
+  each with its operations, whether they were measured, and its evidence.
+  - `VIEW/DV`, a DDIC database view, on every release: group activation,
+    group deletion and where-used, under `/sap/bc/adt/ddic/views`. No API
+    serves it — a **group-only code**, `AdtGroupOnlyCode`,
+    `AdtGroupOnlyCodeOf<V>`. Sent, unmeasured.
+  - `DEVC/K` in a group activation on the newer releases — sent, unmeasured.
+  - `DEVC/K` in `fetchNodeStructure` on 7.40 — measured (the legacy
+    `UtilsReaders` cycle). A table of its own rather than a package entry on
+    7.40, because an entry would gate `getPackage()` open where every package
+    member is refused, and a new `AdtOperation` word would break a 21.0.0
+    consumer's exhaustive map over the vocabulary.
+- `IObjectReference<C>`, `IGetWhereUsedParams<C>` and
+  `IGetWhereUsedScopeParams<C>` take a group-only code as their type
+  argument (`IObjectReference<'VIEW/DV'>`). Their defaults are 21.0.0's: a
+  bare `IObjectReference` still admits `AdtTypeCode` alone.
+- **What each group operation is given:** `AdtGroupActivationCode<V>`,
+  `AdtGroupDeletionCheckCode<V>`, `AdtGroupDeletionCode<V>` (no `MSAG/NN`,
+  which has no address of its own), `AdtWhereUsedCode<V>` (no `FUGR/I` or
+  `MSAG/NN`), and the references over them, `IAdtGroupActivationReference<V>`,
+  `IAdtGroupDeletionCheckReference<V>`, `IAdtGroupDeletionReference<V>`,
+  `IAdtWhereUsedParamsOf<V>`, `IAdtWhereUsedScopeParamsOf<V>`, built by
+  `IAdtCodedReference<C>`: `parentName` required for each parented code, and
+  a reference from a code known only by its set compiles when it names its
+  parent — inside TypeScript's 25-combination limit.
+- `IAdtTypedGroupLifecycle<TActivation, TDeletionCheck, TDeletion, V>` and
+  `IAdtTypedWhereUsed<TWhereUsed, TScope, V>`: the group and where-used members
+  over those references. New atoms beside `IAdtGroupLifecycle` and
+  `IAdtWhereUsed`, with the same member names: an implementation declaring
+  both offers both signatures, and a caller passing `IObjectReference[]` is
+  unaffected. Adding the signatures to the 21.0.0 atoms instead would have
+  made every implementation of them stop compiling.
+- `IAdtTypeStructure<TTypeStructure>`: `getTypeStructure({ headers })`,
+  `POST /sap/bc/adt/repository/typestructure`, an atom of its own like
+  `IAdtObjectProperties`, and `IUtilResults.typeStructure`, its reading —
+  optional, so a 21.0.0 result set is still one.
+
+## [21.0.0] - 2026-10-27
+
+### Added
+
+- **The ADT type tables**, one per release variant: `ADT_TYPES_ONPREM`
+  (S/4HANA 2025 on-premise), `ADT_TYPES_CLOUD` (ABAP cloud) and
+  `ADT_TYPES_BASIS_740` (SAP_BASIS 7.40 SP04), `as const`, keyed by API — the
+  client's factory name. Each entry holds its `kind`, its `collection` and its
+  `codes`; each code its `parent` API, `nameMaxLength`, `operations` and
+  `evidence`, the corpus case of the release's `typestructure` answer, and,
+  where it lives elsewhere than its API, its own `collection` (the enhancement
+  codes: `/sap/bc/adt/enhancements/enhoxhh`, `/enhoxhb`, `/enhsxsb`). The
+  local class includes and the transport request are entries with
+  `codes: {}`, their `parent`, `operations` and `evidence` on the entry. An
+  API the 7.40 client refuses whole is absent from its table, and an operation
+  it refuses is absent from its code.
+- The operations' closed vocabulary, `AdtOperation`. The ABAP Unit runners'
+  four members are four operations, `unitTestRun`, `unitTestRunSync`,
+  `unitTestStatus` and `unitTestResult`, because 7.40 serves them apart: there
+  `run` and `runSync` are served for a class, a program and a function group,
+  only `runSync` for a function module, and `getStatus` and `getResult` for
+  none (no run id to poll or fetch).
+- The entry shape every table `satisfies` (`AdtApiTable<R>`, `AdtApiEntry<R>`,
+  `IAdtCodedApiEntry<R>`, `IAdtCodelessApiEntry<R>`, `IAdtCodeFacts<R>`,
+  `AdtApiName`, `AdtOperations`, `AdtCollection`, `AdtTypeEvidence<R>`,
+  `AdtCheckedTable<T>`): a misspelt field, an operation outside the
+  vocabulary, an API with no factory, another release's evidence, a codeless
+  entry without evidence or a coded entry without a code does not compile.
+- The variants and the types derived from the tables: `AdtVariant`
+  (`'onprem' | 'cloud' | 'basis740'`), `IAdtTypeTables`, `AdtApi<V>`,
+  `AdtTypeCode`, `AdtTypeCodeOf<V>`, `AdtApiWith<V, Op>` and
+  `AdtApiWithIn<T, Op>` (the APIs one code of which performs every operation
+  of `Op` — operations spread across two codes do not count),
+  `AdtTypeCodeWith<V, Op>`, `AdtObjectKind`, `AdtSourceTypeCode`,
+  `AdtParentedTypeCode`.
+- `IAdtAnsweredObject`: `{ type: AdtTypeCode }` or `{ unknownType: string }`,
+  exclusive — what a code read from an answer is, so an unknown one reaches the
+  consumer as the text ADT sent rather than being dropped.
+- `AdtObjectIdentity<TConfig, TParent>`: what an identifying member takes —
+  `Partial<TConfig>` itself when `TParent` is `never`, otherwise every field
+  optional but `TParent`, which is required.
+
+### Changed (breaking)
+
+- **The identifying atoms take the parent's field as a last type parameter,**
+  `TParent extends keyof TConfig = never`: `IAdtReadable`,
+  `IAdtMetadataReadable`, `IAdtEnhancementHost`, `IAdtIncludeEnhancementHost`,
+  `IAdtDeletable` (after `TChecked`), `IAdtValidatable`, `IAdtCheckable`,
+  `IAdtActivatable`, `IAdtLockable`, `IAdtVersionable`, `IAdtTransportAware`.
+  Their `config` is `AdtObjectIdentity<TConfig, TParent>`. With the default it
+  is `Partial<TConfig>` — the same type as before, so an existing contract and
+  code generic in `TConfig` compile unchanged. A contract whose API has a
+  parent passes its field: `functionGroupName` for a function module and a
+  function include, `className` for the four local class includes and for a
+  message class message; its identifying members then require it.
+- **`IObjectReference` is generic in its code,**
+  `IObjectReference<C extends AdtTypeCode = AdtTypeCode>`: `type` is `C`, and
+  `parentName` is required when `[C] extends [AdtParentedTypeCode]` —
+  `IObjectReference<'FUGR/FF'>` needs it — and optional otherwise, the default
+  included. The condition is not distributive: a reference built from a code
+  typed `AdtTypeCode` compiles, and an interface can extend `IObjectReference`
+  (a union of one member per code exceeds TypeScript's 25 combinations and
+  cannot be extended). The group operations take `IObjectReference[]`, so a
+  caller that wants the parent enforced types its references by code.
+- **Every code parameter is a code of the tables:**
+  - `IAdtObjectAccess`: `readObjectSource` and `getObjectSourceUri` take an
+    `AdtSourceTypeCode` (the codes the library reads a source of);
+    `readObjectMetadata` and `supportsSourceCode` an `AdtTypeCode` (any
+    object has metadata, and asking whether a code has source is asked of any
+    code).
+  - `IAdtRepositoryStructure.fetchNodeStructure(parentType)` and
+    `getObjectStructure(objectType)` take an `AdtTypeCode`: the node and
+    object structures are asked of any object — a package's contents, a
+    class's includes, a program's parts — so no narrower set is stated.
+  - `IGetWhereUsedScopeParams.object_type` and `IGetWhereUsedParams.object_type`
+    are an `AdtTypeCode`: where-used is asked of any object.
+  - `ISearchObjectsParams.objectType` is an `AdtTypeCode`: the search filters
+    by any code.
+
+### Removed (breaking)
+
+- `AdtObjectTypeLower`, `AdtObjectType`, `AdtSourceObjectTypeLower` and
+  `AdtSourceObjectType`. With them go the codes no release lists, which no
+  table holds: `INTF/IF`, `STRU/DT`, `STRU/DS`, `TTYP/DF`, `TTYP/TT`,
+  `TTYP/ST`, `DOMA/DM`, `BDEF/BD`, `BIMP/BIM`, `BIMP/`, `BIMPL/`, `FUGR/FC`,
+  `FUNC`, bare `SCGR`, `DSFD/DSF`, `DSFI/DSF`, `SUSO/O`, the bare `FUGR` and
+  `DTEL`, the lower-case spellings and the friendly names.
+
+### Known library defects, entered as served
+
+The tables declare what the library sends, so two members that send a request
+known or inferred to fail are entered as served rather than hidden:
+
+- `transformation` `validate` posts to `/sap/bc/adt/xslt/validation`, which
+  answers `404` — a known-wrong address.
+- `enhancement` `versions` for `ENHO/XHB` and `ENHS/XSB` addresses
+  `…/source/main/versions`, which these source-less codes lack — an inferred
+  `404`, unmeasured.
+
+### Migration
+
+- Replace `AdtObjectType` with `AdtTypeCode` and `AdtSourceObjectType` with
+  `AdtSourceTypeCode` — or `AdtTypeCodeOf<V>` / `AdtTypeCodeWith<V, 'source'>`
+  where the variant is known — and pass upper-case codes: `'CLAS/OC'` for
+  `'class'`, `'FUGR/FF'` for `'functionmodule'`, `'DDLS/DF'` for `'view'`.
+- Replace each dropped code with the one the releases list: `INTF/IF` →
+  `INTF/OI`; `STRU/DT`, `STRU/DS` → `TABL/DS`; `DOMA/DM` → `DOMA/DD`;
+  `BDEF/BD` → `BDEF/BDO`; `BIMP/BIM`, `BIMP/`, `BIMPL/` → `CLAS/OC`;
+  `DSFD/DSF` → `DSFD/SCF`; `DSFI/DSF` → `DSFI/SFI`; `SUSO/O` → `AUTH`;
+  `FUNC` → `FUGR/FF` for a module, `FUGR/F` for a group; `FUGR/FC` and `SCGR`
+  have no replacement the library serves.
+- `TTYP/DF`, `TTYP/TT` and `TTYP/ST` become `TTYP/DA` **where any code is
+  taken** — `readObjectMetadata`, `supportsSourceCode`, a reference, a
+  where-used or search parameter. A table type has no source: `TTYP/DA` is no
+  `AdtSourceTypeCode`, so a `readObjectSource` or `getObjectSourceUri` call
+  on a table type has no replacement and goes — read its document with
+  `readObjectMetadata`.
+- A contract whose API has a parent passes its field to the identifying atoms
+  — `IAdtReadable<IFunctionModuleConfig, R, 'functionGroupName'>` — and a
+  caller then names it. An `IObjectReference<'FUGR/FF'>` or
+  `IObjectReference<'FUGR/I'>` names `parentName`.
+- Type a result's code read from an answer as `IAdtAnsweredObject`, and handle
+  `unknownType`.
+- An implementation that declares `(config: Partial<TConfig>, …)` still
+  satisfies every atom; nothing an implementation sends changes.
+
 ## [20.2.0] - 2026-10-24
 
 ### Added

package/README.md

@@ -5,12 +5,14 @@ ADT contracts: object operations, runtime analysis, execution, feeds and service
 ## TL;DR
 
 - **Only ADT.** The test is who imports this package: `@mcp-abap-adt/adt-clients` and whatever replaces its objects, and nobody else. Measured against every repository in development before 11.0.0 — the only others reaching in were `gcts-client` and `cloud-llm-hub`, for `IAbapConnection`, `IAbapRequestOptions` and `IAdtResponse`. Since 11.0.0 the first two come from `interfaces-adt-connection`; `IAdtResponse` is still here.
-- What it holds: ADT object operations for 31 object types, runtime analysis, execution, feeds, service bindings, `IAdtResponse` and the error codes. **The ABAP connection** — `IAbapConnection`, `IAdtWireResponse`, its capability atoms, `ITimeoutConfig` — is [`interfaces-adt-connection`](../interfaces-adt-connection) since 11.0.0, and is not re-exported here.
+- What it holds: ADT object operations for 31 object types, the ADT type tables per release variant, runtime analysis, execution, feeds, service bindings, `IAdtResponse` and the error codes. **The ABAP connection** — `IAbapConnection`, `IAdtWireResponse`, its capability atoms, `ITimeoutConfig` — is [`interfaces-adt-connection`](../interfaces-adt-connection) since 11.0.0, and is not re-exported here.
 - **What left, and where.** Every HTTP header name, the HTTP frame and `HttpError` → [`interfaces-network`](../interfaces-network). Cloud ALM → [`interfaces-calm`](../interfaces-calm). `XmlNode` → [`interfaces-utils`](../interfaces-utils). Authentication in general — credentials, OAuth grants, tokens, interactive login, SAML assertions, `AUTH_TYPE_JWT`/`BASIC` → [`interfaces-auth`](../interfaces-auth). Everything naming SAP or BTP — `ISapConfig`, `SapAuthType`, `SapConnectionType`, `IConfig`, `IConnectionConfig`, `IAuthorizationConfig`, `ICertificateMaterialLoader`, `IServiceKeyStore`, `ISessionStore`, `ITokenProviderResult`, the two validation results and `AUTH_TYPE_XSUAA` with its union → [`interfaces-auth-sap`](../interfaces-auth-sap). Of those, `IConfig`, `IConnectionConfig`, `IServiceKeyStore`, `ISessionStore` and `ITokenProviderResult` moved on to [`interfaces-auth-broker`](../interfaces-auth-broker) in `interfaces-auth-sap` 2.0.0. `ISessionState` and `ISessionStorage` are deleted, not moved.
 - `IAdtWireResponse` extends `IHttpWireResponse` from `-network` and keeps the headers ADT sends (`sap-adt-location`, both spellings of `content-location`). It lives in `interfaces-adt-connection` since 11.0.0, name and shape unchanged.
 - Since 14.0.0 `IDebuggerIdentity` is a union by `debuggingMode` (required), `attach` takes the identity, `condition` is for line breakpoints only, and `IAbapDebugger` gains `TSettings` and five members. The CHANGELOG has the migration note.
 - Since 15.0.0 `skipCount` is gone from breakpoints (the server ignores it) and `clientId` pairs an answer row with its request. The CHANGELOG has the migration note.
 - Since 15.1.0 the plain class and program run take `debuggee` (`IDebuggeeIds`): the terminal id and IDE id a terminal-mode listener catches the run by.
+- Since 22.0.0, the ABAP cloud table creates and changes no program or include (`403`, S_DEVELOP; see "Migrating to 22.0.0"), and `updateMetadata` is listed where it was measured. Beside that, additions only: intersecting helpers (`AdtCodeOf<V>`, `AdtCodeWith<V, Op>`, `AdtServingVariantsIn`, `AdtPerformingVariantsIn`; the default `AdtModernVariant` gets what both newer tables serve), utility code tables per variant (`ADT_UTILITY_CODES_*`: the group-only `VIEW/DV`, `DEVC/K` in a modern group activation and in 7.40's node structure), group references per operation with the typed atoms `IAdtTypedGroupLifecycle` and `IAdtTypedWhereUsed`, and `IAdtTypeStructure` with its `IUtilResults.typeStructure` slot. See "Intersections, group-only codes and group references".
+- Since 21.0.0 the object type codes are the library's own tables — `ADT_TYPES_ONPREM` (S/4HANA 2025), `ADT_TYPES_CLOUD` (ABAP cloud), `ADT_TYPES_BASIS_740` (SAP_BASIS 7.40 SP04), keyed by API — and every code in a contract is an `AdtTypeCode` drawn from them. `AdtObjectTypeLower`, `AdtObjectType`, `AdtSourceObjectTypeLower` and `AdtSourceObjectType` are removed, and with them the codes no release lists. An identifying atom takes the parent's field as its last type parameter (`TParent`, default `never`, which leaves the config `Partial<TConfig>` as before), and `IObjectReference<C>` requires `parentName` for a code with a parent. A code read from an answer is an `IAdtAnsweredObject`. See "The ADT type tables" and "Migrating to 21.0.0".
 - Since 20.2.0 every object's result-set contract (`IClassResults`, `IProgramResults`, … 30 in all, `IMessageClassMessageResults<TRead, TWritten, TDeleted>` among them) and `IServiceBindingPublicationConfig` are declared here, in the object's own `IAdtX.ts`: the slot map an implementation is constructed with, each slot an `IResultStrategy<unknown>`. A consumer composes its client contract from these and the atoms. Additions only.
 - Since 20.1.0 `IAdtObjectProperties` reads one repository object's properties from `/informationsystem/objectproperties/values?uri=`, any object uri (a transaction by its `vit` workbench uri); its own atom, not part of `IAdtInformationSystem`.
 - Since 20.0.0 `IAdtClientOptions` has no `enableAcceptCorrection`: correcting a refused format is the consumer's own. See "Migrating to 20.0.0".
@@ -30,26 +32,181 @@ npm install @mcp-abap-adt/interfaces-adt
 
 | directory | files | what |
 |---|---|---|
-| `adt/` | 39 | the object contracts: capability atoms, the object types, `IAdtResponse`, `IAdtError`, the error codes, the transport request's object list |
+| `adt/` | 42 | the object contracts: capability atoms, the object types, the ADT type tables and their entry shape, `IAdtResponse`, `IAdtError`, the error codes, the transport request's object list |
 | `runtime/` | 14 | runtime analysis: the debuggers (`IAbapDebugger`, `IAmdpDebugger`) and `IMemorySnapshots`, `IProfiler`, the trace contracts (`ITraceListing`/`ITraceReading`, `ICrossTrace`, `ISt05Trace`), `IApplicationLog`, `IAtcLog` and the ATC run (`IAtcRunOptions`, `IAtcFindings`), `IDdicActivation`, `IGatewayErrorLog`, `IRuntimeDumps`, `ISystemMessages` |
 | `execution/` | 3 | class and program execution, with profiling |
 | `feeds/` | 2 | the ADT feed contracts |
 | `service/` | 1 | service definitions and bindings |
 | `shared/` | 1 | what more than one object type needs |
 
-Six directories, all ADT. `connection/` left for `interfaces-adt-connection` in 11.0.0. `sap/`, `auth/`, `token/`, `session/`, `serviceKey/`, `store/`, `validation/` and `Headers.ts` were here until 9.0.0 and are listed above under what left; `__typechecks__/` holds 24 files that compile shapes this contract must and must not accept, and ships in no tarball.
+Six directories, all ADT. `connection/` left for `interfaces-adt-connection` in 11.0.0. `sap/`, `auth/`, `token/`, `session/`, `serviceKey/`, `store/`, `validation/` and `Headers.ts` were here until 9.0.0 and are listed above under what left; `__typechecks__/` holds 30 files that compile shapes this contract must and must not accept, and ships in no tarball.
 
 The contract rules — what a member answers, how a strategy is supplied, how a contract is built — are in [`docs/architecture/ARCHITECTURE.md`](../../docs/architecture/ARCHITECTURE.md). Domain-by-domain documentation with examples used to sit in the facade's README; the facade is deleted, and each package documents its own contracts.
 
 **There is no facade to stay compatible with.** It was pinned to its 44.0.0 surface in both directions — nothing from that release could disappear from it and nothing could appear without being written down — and `tools/check-surface.js`, `surface-44.0.0.txt`, `baseline-44.0.0.json` and `surface-added.txt` existed to enforce exactly that. The facade is deleted in its 52.0.0 (decision 34), so the property is gone along with the files that proved it; git holds them. What `check-surface.js` still asks is the half that never depended on it: is each symbol declared in the package `tools/package-map.json` assigns it to.
 
+## The ADT type tables
+
+What the library serves, per release variant, is declared here as three `as
+const` tables — constants, written by hand:
+
+| table | variant | release |
+|---|---|---|
+| `ADT_TYPES_ONPREM` | `'onprem'` | S/4HANA 2025 on-premise |
+| `ADT_TYPES_CLOUD` | `'cloud'` | ABAP cloud |
+| `ADT_TYPES_BASIS_740` | `'basis740'` | SAP_BASIS 7.40 SP04 |
+
+**Keyed by API, not by code.** The key is the client's factory name (`class`
+for `getClass()`, `functionModule`, `request` for `getRequest()`), because one
+code serves two APIs (`CLAS/OC`: `class` and `behaviorImplementation`;
+`TABL/DS`: `structure` and `appendStructure`) and one API several codes
+(`enhancement`: `ENHO/XHH`, `ENHO/XHB`, `ENHS/XSB`). An entry holds:
+
+- `kind` — the object's kind in the tools' one vocabulary (`function_module`);
+  two APIs on one code share it;
+- `collection` — the ADT collection its resource lives in, the parent's for an
+  API addressed under a parent;
+- `codes` — for each code: `parent` (the parent API, or `null`),
+  `nameMaxLength`, `operations` and `evidence`, the corpus case of the
+  release's `typestructure` answer that lists the code
+  (`system-description-basis-740--07-typestructure`); and, where a code lives
+  elsewhere than its API, its own `collection` — the enhancement codes under
+  `/sap/bc/adt/enhancements/enhoxhh`, `/enhoxhb` and `/enhsxsb`.
+
+The local class includes and the transport request have no code the library
+sends: their entries have `codes: {}`, and their `parent`, `operations` and
+`evidence` on the entry — the case that lists the parent's code, or for the
+request the release's `typestructure` case. A coded entry names at least one
+code: `IAdtTypeTables` takes each table as `AdtCheckedTable<T>`, which refuses
+an empty `codes` that `satisfies` cannot see.
+
+**Operations** come from one closed vocabulary, `AdtOperation`: `create`,
+`read`, `source`, `readMetadata`, `update`, `updateMetadata`, `lock`,
+`unlock`, `activate`, `check`, `validate`, `versions`, `deletionCheck`,
+`delete`, `transport`; the families of one API (`readEnhancementElements`,
+`readEnhancementOptions`, `activateTestClasses`, `checkCdsTestDoubles`, the
+feature toggle's `switchOn`, `switchOff`, `getRuntimeState`, `checkState`, the
+service binding's `getServiceBindingTypes`, `getServiceGroup`, the transport
+request's `list` … `changeTaskType`); `run` and `profile` for the executors;
+and `unitTestRun`, `unitTestRunSync`, `unitTestStatus`, `unitTestResult` for
+the ABAP Unit runners' four members, which 7.40 serves apart. `source` says the object has a source the
+library reads; `AdtSourceTypeCode` is drawn from it.
+
+**What is not in a table is not served.** An API whose every member the 7.40
+client refuses is absent from `ADT_TYPES_BASIS_740`, and an operation it
+refuses is absent from its code — 7.40 has no `deletionCheck`, no `transport`,
+no `run`. On ABAP cloud a program and an include list no operation that
+changes an object, since the cloud refuses to create either. The entry shape (`AdtApiTable<R>`) refuses a misspelt field, an
+operation outside the vocabulary, an API with no factory and another release's
+evidence at compile time.
+
+**Derived types**, all from the tables:
+
+| type | what |
+|---|---|
+| `AdtVariant` | `'onprem' \| 'cloud' \| 'basis740'` |
+| `AdtApi<V>` | the APIs of variant `V` |
+| `AdtTypeCode` | every code of any table |
+| `AdtTypeCodeOf<V>` | the codes of variant `V` |
+| `AdtApiWith<V, Op>` | the APIs of `V` one code of which performs every operation of `Op` (`AdtApiWithIn<T, Op>` over any table) |
+| `AdtTypeCodeWith<V, Op>` | the codes of `V` whose facts list `Op` |
+| `AdtObjectKind` | every kind |
+| `AdtSourceTypeCode` | the codes with `source` |
+| `AdtParentedTypeCode` | the codes with a parent API: `FUGR/FF`, `FUGR/I` |
+
+A map a consumer keeps over the codes is typed by them, and the compiler then
+asks for every code and refuses any other:
+
+```ts
+const label: { readonly [C in AdtTypeCode]: string } = { 'CLAS/OC': 'Class', /* … every code */ };
+```
+
+**Proved against the systems elsewhere.** This package holds no code, so it
+holds no test against the releases: the conformance check in
+`@mcp-abap-adt/adt-clients` reads each release's recorded `typestructure`,
+`discovery` and, on the newer releases, `urimapper` answers. It fails on a code
+not listed, a parent or a name length that disagrees, a collection not
+advertised, and an address built for a sample object that differs from the
+`urimapper` answer for it. It holds the capabilities too: `run` on a code that
+does not list `EXECUTE`, or `profile` without `PROFILE`, is a conflict; a
+`create` on a code without `CREATE` is listed apart, since ADT creates those
+through their own collection; and a code listing `CREATE` that no entry
+creates goes into the coverage. `src/__typechecks__/` holds the tables
+recorded cell for cell — per variant, API and code, the parent and the exact
+set of operations — as an exact equality, so a table edit is made twice, on
+purpose.
+
+**An answered code.** A code read from an ADT answer is an
+`IAdtAnsweredObject`: `{ type: AdtTypeCode }` when the tables know it,
+`{ unknownType: string }` with the text as sent when they do not. The two are
+exclusive.
+
+**Parents.** The atoms that identify an object take the parent's field as
+their last type parameter, `TParent extends keyof TConfig = never`, and their
+`config` is `AdtObjectIdentity<TConfig, TParent>`: with `never` that is
+`Partial<TConfig>` itself — the same type as before 21.0.0, so a contract
+written then, or code generic in `TConfig`, is unchanged — and otherwise every
+field optional but `TParent`, which is required. A contract whose API has a
+parent passes it: `functionGroupName` for a function module and a function
+include, `className` for a local class include and a message class message.
+
+```ts
+type ModuleRead = IAdtReadable<IFunctionModuleConfig, string, 'functionGroupName'>;
+// read({ functionModuleName }) does not compile; read({ functionGroupName, functionModuleName }) does
+```
+
+`IObjectReference<C extends AdtTypeCode = AdtTypeCode>` requires `parentName`
+when `[C] extends [AdtParentedTypeCode]` — `IObjectReference<'FUGR/FF'>` —
+and leaves it optional otherwise, the default included, so a reference built
+from a code typed `AdtTypeCode` compiles and an interface can extend it.
+
+### Intersections, group-only codes and group references (22.0.0)
+
+**A union of variants.** `AdtTypeCodeOf<V>`, `AdtTypeCodeWith<V, Op>` and
+`AdtApiWith<V, Op>` read a union of variants as one union table: the APIs all
+of them serve, and for those the codes and operations any of them lists. The
+intersecting helpers ask every variant: `AdtCodeOf<V>` and `AdtCodeWith<V, Op>`
+are the codes every variant of `V` lists (with `Op`), and
+`AdtServingVariantsIn<IAdtTypeTables, A>` and
+`AdtPerformingVariantsIn<IAdtTypeTables, A, Op>` name the variants that serve
+an API or perform an operation on one of its codes — what a client's gates
+need. For `AdtModernVariant`, `'onprem' | 'cloud'`, that is what both tables
+serve. `AdtCodeOfIn` and `AdtCodeWithIn` take any set of tables.
+
+**Utility codes.** `ADT_UTILITY_CODES_ONPREM`, `_CLOUD` and `_BASIS_740` hold
+what `getUtils()` takes beyond the API tables, with its operations
+(`AdtUtilityOperation`), whether they were measured, and the evidence:
+
+| code | where | operations | measured |
+|---|---|---|---|
+| `VIEW/DV` | every release, `/sap/bc/adt/ddic/views` | group activation, group deletion, where-used | no |
+| `DEVC/K` | S/4HANA 2025, ABAP cloud | group activation | no |
+| `DEVC/K` | SAP_BASIS 7.40 SP04 | node structure | yes |
+
+`VIEW/DV` is a **group-only code** (`AdtGroupOnlyCode`): no API serves it, so
+it is no `AdtTypeCode`. `IObjectReference<'VIEW/DV'>` and
+`IGetWhereUsedParams<'VIEW/DV'>` name it; the defaults do not.
+
+**Group references.** `IAdtGroupActivationReference<V>`,
+`IAdtGroupDeletionCheckReference<V>`, `IAdtGroupDeletionReference<V>` and
+`IAdtWhereUsedParamsOf<V>` take only the codes their operation sends on `V`
+— no message class in an activation, no package in a 7.40 one, no function
+include in where-used — and require `parentName` for `FUGR/FF` and `FUGR/I`.
+`IAdtTypedGroupLifecycle` and `IAdtTypedWhereUsed` declare the members over
+them, beside `IAdtGroupLifecycle` and `IAdtWhereUsed`: a contract composed of
+both takes typed references and the 21.0.0 `IObjectReference[]` alike.
+
+**The type structure.** `IAdtTypeStructure.getTypeStructure({ headers })`
+posts to `/sap/bc/adt/repository/typestructure`; its reading is
+`IUtilResults.typeStructure`, optional so a 21.0.0 set is still one.
+
 ## Enhancements and their hosts
 
 `EnhancementType` accepts `enhoxhb` (BAdI implementation, ENHO/XHB), `enhoxhh`
 (source code plugin, ENHO/XHH), and `enhsxsb` (BAdI enhancement spot, ENHS/XSB).
 The ABAP Cloud trial refuses the `enhoxhh` collection (403 on create and read;
 no content type in its discovery). Class enhancements (`enhoxh`) and plain
-spots (`enhsxs`) answered 500 on reads on E19 (2026-10-15) and on premise +
+spots (`enhsxs`) answered 500 on reads on S/4HANA on-premise (2026-10-15) and on premise +
 trial in mcp-abap-adt `5046d8a6` (2026-10-02), which also measured Eclipse
 opening them in SAP GUI. The trial discovery lists no content type for either.
 Callers migrating from 16.0 must remove those calls; the removed subtypes now
@@ -70,7 +227,7 @@ names used to create plugins.
 atom for an include's elements and options, with the same two members. Both
 reads take optional `context` naming the include's main program (`SAPLSVIM`
 for an include of function group SVIM). Without it, both reads answered 400
-ED/258 "No main program for include … found" (E19, 2026-10-15). Context stays
+ED/258 "No main program for include … found" (S/4HANA on-premise, 2026-10-15). Context stays
 optional because an include with a single main program is unmeasured.
 Both atoms accept per-call `analyse` and return `IAdtResponse`.
 
@@ -116,6 +273,67 @@ The field is on each member's own options, not on `IAdtAnalyseOptions` or
 `IAdtOperationOptions`. `src/__typechecks__/headersOnEveryMember.ts` holds this
 for every member and every overload.
 
+## Migrating to 22.0.0
+
+- **ABAP cloud: no program or include of one's own.** `ADT_TYPES_CLOUD` no
+  longer lists `create`, `update`, `lock`, `unlock`, `activate`, `validate`,
+  `deletionCheck` or `delete` for `PROG/P` and `PROG/I`: the cloud refuses to
+  create either (`403`, S_DEVELOP). Code gated on the cloud variant, or on
+  the intersecting helpers over `AdtModernVariant` (`AdtCodeWith`,
+  `AdtPerformingVariantsIn` — what both newer tables serve), that creates or
+  changes a program or an include stops compiling; on ABAP cloud the system
+  would have refused it. The union helpers (`AdtApiWith`, `AdtTypeCodeWith`)
+  over `AdtModernVariant` still name the program, since on-premise creates
+  one. Reading, checking and versioning a delivered program
+  compile as before. A function include (`FUGR/I`) is unchanged.
+- Nothing else breaks: every other change is an addition (see the
+  CHANGELOG).
+
+## Migrating to 21.0.0
+
+Every break is a type error; nothing a correct call sends changes.
+
+- **The four unions are gone.** Replace `AdtObjectType` with `AdtTypeCode` and
+  `AdtSourceObjectType` with `AdtSourceTypeCode`, or with the variant's own
+  `AdtTypeCodeOf<V>` / `AdtTypeCodeWith<V, 'source'>` where the variant is
+  known. The lower-case spellings and the friendly names (`'class'`,
+  `'functionmodule'`, `'view'`, …) are no codes: pass the upper-case code
+  (`'CLAS/OC'`, `'FUGR/FF'`, `'DDLS/DF'`).
+- **The codes no release lists do not compile.** `INTF/IF` is `INTF/OI`;
+  `STRU/DT` and `STRU/DS` are `TABL/DS`; `DOMA/DM` is `DOMA/DD`; `BDEF/BD` is
+  `BDEF/BDO`; `BIMP/BIM`, `BIMP/` and `BIMPL/` are `CLAS/OC`; `DSFD/DSF` is
+  `DSFD/SCF`, `DSFI/DSF` is `DSFI/SFI`, `SUSO/O` is `AUTH`; a function module
+  is `FUGR/FF` and a function group `FUGR/F`, so `FUNC` and `FUGR/FC` go; bare
+  `SCGR` and the other bare codes (`FUGR`, `DTEL`) are none — `AUTH` is the
+  one bare code a table holds.
+- **A table type is `TTYP/DA` where any code is taken.** `TTYP/DF`, `TTYP/TT`
+  and `TTYP/ST` become `TTYP/DA` in `readObjectMetadata`, `supportsSourceCode`,
+  a reference, a where-used or a search parameter. A table type has no source,
+  so `TTYP/DA` is no `AdtSourceTypeCode`: a `readObjectSource` or
+  `getObjectSourceUri` of a table type has no replacement — read its document
+  with `readObjectMetadata`.
+- **Every code parameter takes these codes:** `IObjectReference.type`,
+  `readObjectSource`, `getObjectSourceUri` (`AdtSourceTypeCode`),
+  `readObjectMetadata`, `supportsSourceCode`, `fetchNodeStructure`'s
+  `parentType`, `getObjectStructure`'s `objectType`, the where-used
+  parameters' `object_type` and `ISearchObjectsParams.objectType`
+  (`AdtTypeCode`).
+- **A parent is named by the contract.** A contract composing the identifying
+  atoms for a function module or a function include passes
+  `'functionGroupName'` as their `TParent`, for a local class include or a
+  message class message `'className'`; a caller of that contract then names
+  the parent. A contract that passes nothing is unchanged. An
+  `IObjectReference<'FUGR/FF'>` or `IObjectReference<'FUGR/I'>` names
+  `parentName`.
+- **An implementation** declaring an identifying member as
+  `(config: Partial<TConfig>, …)` still satisfies the atom — it accepts more.
+- **A result** that carries a code read from an answer is typed
+  `IAdtAnsweredObject`: switch on `type`, and handle `unknownType` for a code
+  the tables do not hold.
+- **The tables are new.** `ADT_TYPES_ONPREM`, `ADT_TYPES_CLOUD`,
+  `ADT_TYPES_BASIS_740` and the types derived from them are additions; see "The
+  ADT type tables".
+
 ## Migrating to 20.0.0
 
 `IAdtClientOptions.enableAcceptCorrection` is removed, so code that sets it