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

package/CHANGELOG.md

@@ -0,0 +1,679 @@
+# @aventara/client
+
+## 1.0.0-rc.1
+
+### Patch Changes
+
+- 8bb1d6a: Breaking: public type and class names take the `Av` prefix. Every public type and class is now `Av` plus what
+  it is, with a namespace only where the bare name would be ambiguous: configuration types are `AvConfig…`
+  (`AvConfig`, `AvConfigLayer`, `AvConfigResource`, …) and the three Contracts are `AvContract…` (`AvContractCore`,
+  `AvContractApplication`, `AvContractClient`). Functions keep their names (`createFramework`, `createFakeAdapter`,
+  `createPrismaAdapter`, `defineClientConfig`, `env`), and so do the names that already started with `Av`,
+  `AventaraModule`, `AventaraModuleOptions` and `AventaraModuleAsyncOptions`. There are no
+  aliases: replace each old name with the new one.
+
+  Three names merged or left:
+
+  - `PipelineContext` and `ComputeContext` (which was the same type) are one name, `AvContext`. A compute stage
+    now gets its own read-only ctx, `AvComputeContext` (see the ctx entry in `@aventara/core`'s changelog).
+  - `ComputedRead` is `AvComputeRead`, the one name of a read compute stage: a function, or `{ compute, dependsOn }`.
+    `ComputeOnRead`, the bare function type, is no longer exported; `AvComputeRead` accepts the function as it is.
+  - `defineFields` and `FrameworkFieldsShape` are removed; `defineResource` replaces them (below).
+
+  `defineResource` replaces `defineFields`. A Resource's configuration, its root block and its overlay blocks, can
+  live in its own module and be spread into each layer's `resources` tree:
+
+  ```ts
+  export const submission = defineResource<Model>()(
+    "Submission",
+    {
+      pipelines: { guards: [signedIn] },
+      fields: { title: { pipelines: { pipes: [trim] } } },
+    },
+    { client: { fields: { title: { pipelines: { validators: [AvZ.maxLength(80)] } } } } },
+  );
+
+  // aventara.config.ts
+  resources: { ...submission.root, ...payment.root },
+  client: { resources: { ...submission.client } },
+  ```
+
+  It returns `{ root, application?, client? }`, each `{ Submission: block }`; a layer given no block is left out. The
+  root block is typed exactly as `resources.Submission` is typed in place: field definitions are checked against what
+  the adapter discovered, stages are typed for the Resource, and a key no level admits is a type error at the key.
+  Each overlay block is typed as `application.resources.Submission` or `client.resources.Submission` is in place,
+  against the root block: it may name a field the root block defines, and a `definition` in it is a type error (and
+  `CONFIG_FORBIDDEN_IN_OVERLAY` at startup). Spread, the configuration is the inline one: the same Contracts and
+  ClientContract hash. A field `definition` that `defineFields` returned now sits at
+  `fields.<field>.definition` inside the block.
+
+  The generated client's names follow the same rule. Regenerate with `avclient generate`; then rename the
+  imports from `AvClient.ts`:
+
+  | Before                  | After                     |
+  | ----------------------- | ------------------------- |
+  | `AuthError`             | `AvAuthError`             |
+  | `CallOptions`           | `AvCallOptions`           |
+  | `Cause`                 | `AvCause`                 |
+  | `ConflictError`         | `AvConflictError`         |
+  | `ContractMismatchError` | `AvContractMismatchError` |
+  | `Decimal`               | `AvDecimal`               |
+  | `Fetch`                 | `AvFetch`                 |
+  | `FrameworkError`        | `AvError`                 |
+  | `InternalError`         | `AvInternalError`         |
+  | `NotFoundError`         | `AvNotFoundError`         |
+  | `Operation<T>`          | `AvOperation<T>`          |
+  | `OperationCode`         | `AvOperationCode`         |
+  | `ProtocolError`         | `AvProtocolError`         |
+  | `TransportError`        | `AvTransportError`        |
+  | `ValidationCode`        | `AvValidationCode`        |
+  | `ValidationError`       | `AvValidationError`       |
+  | `ValidationIssue`       | `AvValidationIssue`       |
+
+  An enum whose name is one of these now walks the rename ladder (`AvDecimal` → `AvDecimalEnum`); an enum named
+  `Decimal` is emitted as `Decimal`.
+
+  `@aventara/core`, every renamed export:
+
+  | Before                                | After                              |
+  | ------------------------------------- | ---------------------------------- |
+  | `Adapter`                             | `AvAdapter`                        |
+  | `AdapterDiscoveryDiagnostic`          | `AvAdapterDiscoveryDiagnostic`     |
+  | `AdapterDiscoveryDiagnosticCode`      | `AvAdapterDiscoveryDiagnosticCode` |
+  | `AdapterModel`                        | `AvAdapterModel`                   |
+  | `AddedFieldDefinition`                | `AvConfigAddedFieldDefinition`     |
+  | `AfterHook`                           | `AvAfterHook`                      |
+  | `AnyFrameworkConfig`                  | `AvConfigAny`                      |
+  | `AnyLayerConfig`                      | `AvConfigLayerAny`                 |
+  | `AnyResourcesBlock`                   | `AvConfigResourcesAny`             |
+  | `ApplicationContract`                 | `AvContractApplication`            |
+  | `ApplicationScalarForms`              | `AvApplicationScalarForms`         |
+  | `BeforeHook`                          | `AvBeforeHook`                     |
+  | `BuiltInScalar`                       | `AvBuiltInScalar`                  |
+  | `Cause`                               | `AvCause`                          |
+  | `ClientContract`                      | `AvContractClient`                 |
+  | `ClientContractProtocol`              | `AvContractClientProtocol`         |
+  | `ComputedRead`                        | `AvComputeRead`                    |
+  | `ComputeOnCreate`                     | `AvComputeCreate`                  |
+  | `ComputeOnUpdate`                     | `AvComputeUpdate`                  |
+  | `ConfigDiagnostic`                    | `AvConfigDiagnostic`               |
+  | `ConfigDiagnosticCode`                | `AvConfigDiagnosticCode`           |
+  | `ConfigFieldKey`                      | `AvConfigFieldKey`                 |
+  | `ConfigLayer`                         | `AvConfigLayerName`                |
+  | `Contract`                            | `AvContract`                       |
+  | `ContractCompilerDiagnostic`          | `AvContractCompilerDiagnostic`     |
+  | `ContractCompilerDiagnosticCode`      | `AvContractCompilerDiagnosticCode` |
+  | `ContractHash`                        | `AvContractHash`                   |
+  | `ContractLimits`                      | `AvContractLimits`                 |
+  | `ContractProtocol`                    | `AvContractProtocol`               |
+  | `CoreContract`                        | `AvContractCore`                   |
+  | `CreateDataInput`                     | `AvCreateDataInput`                |
+  | `CursorInput`                         | `AvCursorInput`                    |
+  | `Decimal`                             | `AvDecimal`                        |
+  | `DeferredOperationCall`               | `AvDeferredOperationCall`          |
+  | `EffectiveFieldKey`                   | `AvEffectiveFieldKey`              |
+  | `EnumDefinition`                      | `AvEnumDefinition`                 |
+  | `ExactFrameworkConfig`                | `AvConfigExact`                    |
+  | `ExecutionOptions`                    | `AvExecutionOptions`               |
+  | `Field`                               | `AvField`                          |
+  | `FieldComputeConfig`                  | `AvFieldCompute`                   |
+  | `FieldKey`                            | `AvFieldKey`                       |
+  | `FieldPipe`                           | `AvFieldPipe`                      |
+  | `FieldWriteGuard`                     | `AvFieldGuard`                     |
+  | `Filter`                              | `AvFilter`                         |
+  | `Framework`                           | `AvFramework`                      |
+  | `FrameworkConfig`                     | `AvConfig`                         |
+  | `FrameworkConstructionDiagnostic`     | `AvConstructionDiagnostic`         |
+  | `FrameworkConstructionError`          | `AvConstructionError`              |
+  | `FrameworkConstructionStage`          | `AvConstructionStage`              |
+  | `FrameworkContracts`                  | `AvContracts`                      |
+  | `FrameworkDiagnostic`                 | `AvDiagnostic`                     |
+  | `FrameworkDiagnosticsSink`            | `AvDiagnosticsSink`                |
+  | `FrameworkError`                      | `AvError`                          |
+  | `FrameworkExemptionsConfig`           | `AvConfigExemptions`               |
+  | `FrameworkFamilyConfig`               | `AvConfigFamily`                   |
+  | `FrameworkFieldDefinition`            | `AvConfigFieldDefinition`          |
+  | `FrameworkFieldLifecycleTrait`        | `AvConfigFieldLifecycleTrait`      |
+  | `FrameworkLayerConfig`                | `AvConfigLayer`                    |
+  | `FrameworkLayerKind`                  | `AvConfigLayerKind`                |
+  | `FrameworkLimitsConfig`               | `AvConfigLimits`                   |
+  | `FrameworkMisuseEvent`                | `AvMisuseEvent`                    |
+  | `FrameworkMisuseSink`                 | `AvMisuseSink`                     |
+  | `FrameworkOperationsConfig`           | `AvConfigOperations`               |
+  | `FrameworkOperationsExemption`        | `AvConfigOperationsExemption`      |
+  | `FrameworkOverlayFieldConfig`         | `AvConfigOverlayField`             |
+  | `FrameworkRelationFieldExemption`     | `AvConfigRelationFieldExemption`   |
+  | `FrameworkResourceConfig`             | `AvConfigResource`                 |
+  | `FrameworkResourceExemption`          | `AvConfigResourceExemption`        |
+  | `FrameworkResourceFieldsConfig`       | `AvConfigResourceFields`           |
+  | `FrameworkResourceKey`                | `AvConfigResourceKey`              |
+  | `FrameworkResourcesConfig`            | `AvConfigResources`                |
+  | `FrameworkResourceTransactionsConfig` | `AvConfigResourceTransactions`     |
+  | `FrameworkRootFieldConfig`            | `AvConfigRootField`                |
+  | `FrameworkScalarFieldExemption`       | `AvConfigScalarFieldExemption`     |
+  | `FrameworkScalarTypeRef`              | `AvConfigScalarTypeRef`            |
+  | `FrameworkVariantConfig`              | `AvConfigVariant`                  |
+  | `Guard`                               | `AvGuard`                          |
+  | `Identifier`                          | `AvIdentifier`                     |
+  | `IncludeInput`                        | `AvIncludeInput`                   |
+  | `Interceptor`                         | `AvInterceptor`                    |
+  | `JsonValue`                           | `AvJsonValue`                      |
+  | `KnownFieldDefinition`                | `AvConfigKnownFieldDefinition`     |
+  | `LifecycleTrait`                      | `AvLifecycleTrait`                 |
+  | `NullsOrder`                          | `AvNullsOrder`                     |
+  | `Operation`                           | `AvOperation`                      |
+  | `OperationArgumentMap`                | `AvOperationArgumentMap`           |
+  | `OperationArgumentsFor`               | `AvOperationArgumentsFor`          |
+  | `OperationAvailability`               | `AvOperationAvailability`          |
+  | `OperationCall`                       | `AvOperationCall`                  |
+  | `OperationCode`                       | `AvOperationCode`                  |
+  | `OperationDiagnostic`                 | `AvOperationDiagnostic`            |
+  | `OperationErrorCode`                  | `AvOperationErrorCode`             |
+  | `OperationFailureResponse`            | `AvOperationFailureResponse`       |
+  | `OperationFamily`                     | `AvOperationFamily`                |
+  | `OperationGrammar`                    | `AvOperationGrammar`               |
+  | `OperationIdentity`                   | `AvOperationIdentity`              |
+  | `OperationNoMatchResponse`            | `AvOperationNoMatchResponse`       |
+  | `OperationReferenceSurface`           | `AvOperationReferenceSurface`      |
+  | `OperationResponse`                   | `AvOperationResponse`              |
+  | `OperationResultFor`                  | `AvOperationResultFor`             |
+  | `OperationSlot`                       | `AvOperationSlot`                  |
+  | `OperationSuccessCode`                | `AvOperationSuccessCode`           |
+  | `OperationSuccessDataCode`            | `AvOperationSuccessDataCode`       |
+  | `OperationSuccessResponse`            | `AvOperationSuccessResponse`       |
+  | `OperationVariant`                    | `AvOperationVariant`               |
+  | `OperationVariantScopes`              | `AvOperationVariantScopes`         |
+  | `OrderByEntry`                        | `AvOrderByEntry`                   |
+  | `OrderByInput`                        | `AvOrderByInput`                   |
+  | `PaginationCapability`                | `AvPaginationCapability`           |
+  | `Pipe`                                | `AvPipe`                           |
+  | `PipelineConfig`                      | `AvPipeline`                       |
+  | `PipelineContext`                     | `AvContext`                        |
+  | `PipelineTransportContext`            | `AvTransportContext`               |
+  | `ProjectionEntry`                     | `AvProjectionEntry`                |
+  | `ProjectionScope`                     | `AvProjectionScope`                |
+  | `ProjectionScopes`                    | `AvProjectionScopes`               |
+  | `ReferenceableField`                  | `AvReferenceableField`             |
+  | `ReferenceBuilder`                    | `AvReferenceBuilder`               |
+  | `RelationField`                       | `AvRelationField`                  |
+  | `RelationFieldCapabilities`           | `AvRelationFieldCapabilities`      |
+  | `RelationFieldCapabilityName`         | `AvRelationFieldCapabilityName`    |
+  | `RelationFieldPipelineConfig`         | `AvRelationFieldPipeline`          |
+  | `RelationFilterCapability`            | `AvRelationFilterCapability`       |
+  | `RelationMutationCapability`          | `AvRelationMutationCapability`     |
+  | `RelationMutationDirective`           | `AvRelationMutationDirective`      |
+  | `RelationProjectionCapability`        | `AvRelationProjectionCapability`   |
+  | `RelationProjectionInput`             | `AvRelationProjectionInput`        |
+  | `RelationReducer`                     | `AvRelationReducer`                |
+  | `RelationReducerCapability`           | `AvRelationReducerCapability`      |
+  | `RequestOrigin`                       | `AvRequestOrigin`                  |
+  | `Resource`                            | `AvResource`                       |
+  | `ResourceFieldMap`                    | `AvResourceFieldMap`               |
+  | `ResourceKey`                         | `AvResourceKey`                    |
+  | `ResourceOperations`                  | `AvResourceOperations`             |
+  | `ScalarDefinition`                    | `AvScalarDefinition`               |
+  | `ScalarField`                         | `AvScalarField`                    |
+  | `ScalarFieldCapabilities`             | `AvScalarFieldCapabilities`        |
+  | `ScalarFieldCapabilityName`           | `AvScalarFieldCapabilityName`      |
+  | `ScalarFieldKey`                      | `AvScalarFieldKey`                 |
+  | `ScalarFieldPipelineConfig`           | `AvScalarFieldPipeline`            |
+  | `ScalarFilterOperator`                | `AvScalarFilterOperator`           |
+  | `ScalarFormat`                        | `AvScalarFormat`                   |
+  | `ScalarMutationDirective`             | `AvScalarMutationDirective`        |
+  | `ScalarOrderInput`                    | `AvScalarOrderInput`               |
+  | `ScalarRegistry`                      | `AvScalarRegistry`                 |
+  | `ScalarValueType`                     | `AvScalarValueType`                |
+  | `ScopedRelationMutations`             | `AvScopedRelationMutations`        |
+  | `ScopedRelationReducers`              | `AvScopedRelationReducers`         |
+  | `SelectInput`                         | `AvSelectInput`                    |
+  | `SingleRowResult`                     | `AvSingleRowResult`                |
+  | `SortDirection`                       | `AvSortDirection`                  |
+  | `TransactionAfterHook`                | `AvTransactionAfterHook`           |
+  | `TransactionBeforeHook`               | `AvTransactionBeforeHook`          |
+  | `TransactionCapability`               | `AvTransactionCapability`          |
+  | `TransactionCommittedResponse`        | `AvTransactionCommittedResponse`   |
+  | `TransactionDiagnostic`               | `AvTransactionDiagnostic`          |
+  | `TransactionFilter`                   | `AvTransactionFilter`              |
+  | `TransactionGuard`                    | `AvTransactionGuard`               |
+  | `TransactionIntegrityError`           | `AvTransactionIntegrityError`      |
+  | `TransactionIntegrityViolation`       | `AvTransactionIntegrityViolation`  |
+  | `TransactionInterceptor`              | `AvTransactionInterceptor`         |
+  | `TransactionPipe`                     | `AvTransactionPipe`                |
+  | `TransactionPipelineConfig`           | `AvTransactionPipeline`            |
+  | `TransactionPipelineContext`          | `AvTransactionContext`             |
+  | `TransactionReference`                | `AvTransactionReference`           |
+  | `TransactionResponse`                 | `AvTransactionResponse`            |
+  | `TransactionResults`                  | `AvTransactionResults`             |
+  | `TransactionRunner`                   | `AvTransactionRunner`              |
+  | `TransactionSlotPathError`            | `AvTransactionSlotPathError`       |
+  | `TransactionSlotPathViolation`        | `AvTransactionSlotPathViolation`   |
+  | `UniqueWhereInput`                    | `AvUniqueWhereInput`               |
+  | `UpdateDataInput`                     | `AvUpdateDataInput`                |
+  | `ValidationCode`                      | `AvValidationCode`                 |
+  | `ValidationIssue`                     | `AvValidationIssue`                |
+  | `WhereInput`                          | `AvWhereInput`                     |
+  | `WireScalarForms`                     | `AvWireScalarForms`                |
+  | `WriteScope`                          | `AvWriteScope`                     |
+  | `WriteScopes`                         | `AvWriteScopes`                    |
+
+  Error classes whose `name` a log or a test may read:
+
+  | Before                   | After                      |
+  | ------------------------ | -------------------------- |
+  | `CallerDataError`        | `AvCallerDataError`        |
+  | `ClientConfigError`      | `AvClientConfigError`      |
+  | `ComputedValueError`     | `AvComputedValueError`     |
+  | `ContractProtocolError`  | `AvContractProtocolError`  |
+  | `ContractTransportError` | `AvContractTransportError` |
+  | `EnvFileError`           | `AvEnvFileError`           |
+  | `OutputValidationError`  | `AvOutputValidationError`  |
+  | `OutputWriteError`       | `AvOutputWriteError`       |
+  | `PipeOutputError`        | `AvPipeOutputError`        |
+  | `UnmountedRouteError`    | `AvUnmountedRouteError`    |
+
+  `@aventara/testing`:
+
+  | Before                   | After                      |
+  | ------------------------ | -------------------------- |
+  | `AdapterFactory`         | `AvAdapterFactory`         |
+  | `FakeAdapter`            | `AvFakeAdapter`            |
+  | `FakeAdapterExecute`     | `AvFakeAdapterExecute`     |
+  | `FakeAdapterOptions`     | `AvFakeAdapterOptions`     |
+  | `FakeAdapterRollback`    | `AvFakeAdapterRollback`    |
+  | `FakeTransactionOutcome` | `AvFakeTransactionOutcome` |
+  | `FakeTransactionTrace`   | `AvFakeTransactionTrace`   |
+
+  `@aventara/client` (the `framework.client.ts` config types):
+
+  | Before              | After                 |
+  | ------------------- | --------------------- |
+  | `ClientConfigInput` | `AvClientConfigInput` |
+  | `ConfigValue`       | `AvClientConfigValue` |
+  | `EnvReference`      | `AvEnvReference`      |
+
+  `@aventara/prisma7-adapter`: its public types and error classes (`createPrismaAdapter` keeps its name):
+
+  | Before                             | After                                |
+  | ---------------------------------- | ------------------------------------ |
+  | `PrismaAdapterModel`               | `AvPrismaAdapterModel`               |
+  | `PrismaAdapterOptions`             | `AvPrismaAdapterOptions`             |
+  | `PrismaDelegate`                   | `AvPrismaDelegate`                   |
+  | `PrismaDelegateHost`               | `AvPrismaDelegateHost`               |
+  | `PrismaDelegateIndex`              | `AvPrismaDelegateIndex`              |
+  | `PrismaDiscoveryArtifact`          | `AvPrismaDiscoveryArtifact`          |
+  | `PrismaDriver`                     | `AvPrismaDriver`                     |
+  | `PrismaIsolationLevel`             | `AvPrismaIsolationLevel`             |
+  | `PrismaProvider`                   | `AvPrismaProvider`                   |
+  | `PrismaProviderProfile`            | `AvPrismaProviderProfile`            |
+  | `PrismaReferentialAction`          | `AvPrismaReferentialAction`          |
+  | `PrismaReferentialActionTable`     | `AvPrismaReferentialActionTable`     |
+  | `PrismaReferentialEdge`            | `AvPrismaReferentialEdge`            |
+  | `PrismaResourceReferentialActions` | `AvPrismaResourceReferentialActions` |
+  | `PrismaTransactionOptions`         | `AvPrismaTransactionOptions`         |
+  | `PrismaCapabilityDerivationError`  | `AvPrismaCapabilityDerivationError`  |
+  | `PrismaDiscoveryArtifactError`     | `AvPrismaDiscoveryArtifactError`     |
+  | `PrismaEmulationError`             | `AvPrismaEmulationError`             |
+  | `PrismaExecutionError`             | `AvPrismaExecutionError`             |
+  | `PrismaExistenceGateError`         | `AvPrismaExistenceGateError`         |
+  | `PrismaFieldProjectionError`       | `AvPrismaFieldProjectionError`       |
+  | `PrismaGenerateCliError`           | `AvPrismaGenerateCliError`           |
+  | `PrismaGenerateStepError`          | `AvPrismaGenerateStepError`          |
+  | `PrismaModelCompositionError`      | `AvPrismaModelCompositionError`      |
+  | `PrismaMutationTranslationError`   | `AvPrismaMutationTranslationError`   |
+  | `PrismaOperationTranslationError`  | `AvPrismaOperationTranslationError`  |
+  | `PrismaOrderTranslationError`      | `AvPrismaOrderTranslationError`      |
+  | `PrismaProjectionTranslationError` | `AvPrismaProjectionTranslationError` |
+  | `PrismaResultShapeError`           | `AvPrismaResultShapeError`           |
+  | `PrismaScalarConversionError`      | `AvPrismaScalarConversionError`      |
+  | `PrismaSchemaReaderError`          | `AvPrismaSchemaReaderError`          |
+  | `PrismaTypesReaderError`           | `AvPrismaTypesReaderError`           |
+  | `PrismaWhereTranslationError`      | `AvPrismaWhereTranslationError`      |
+
+- 68d4395: New: the generated client checks field validators before it sends. When the ClientContract carries a field's
+  `validators` or a Json Shape's checks, `avclient generate` emits them into the client with the check code that runs
+  them, and every call and every transaction checks the values it holds first. A call that breaks a check rejects with
+  the same `AvValidationError` the server would answer, `A2004` with the same issues (`code`, `path`, `check`,
+  `params`, `message`), and no request is sent:
+
+  ```ts
+  try {
+    await avClient.projects.create.one({ data: { id: "p1", name: "no" } });
+  } catch (error) {
+    // error instanceof AvValidationError, error.code === "A2004", nothing was sent:
+    // error.cause.issues[0] → { code: "V1004", path: ["arguments", "data", "name"],
+    //   message: "Value must be at least 3 characters long.", check: "min_length", params: { minimum: 3 } }
+  }
+  ```
+
+  - The server checks every value again. The client checks a value as the caller wrote it and the server checks it
+    after its field pipes, so a field pipe that normalizes a value (trims it, lower-cases it) must not turn a value the
+    client accepted into one the server refuses.
+  - A transaction is checked whole before it is sent: a bad literal value in any step rejects with the server's answer,
+    `cause.operation` naming the step. A `$ref` value is checked by the server, at its step.
+  - Nested write data, list fields (each entry and the list's length), `$push` entries and Json Shape checks are all
+    checked, a Json Shape's checks with the other validators in the order the call wrote the fields, and a plan step
+    by step, as the server does. A Json value that does not match its shape is sent, and the server answers it.
+  - The check code is `@aventara/core`'s own, copied into the generated output; the client still imports nothing from
+    `@aventara/*` or zod at runtime. A contract with no checks generates the same files as before.
+  - `AvValidationIssue` declares `check` and `params`, and the client keeps them on the issues a server sends (they
+    were dropped before).
+  - The server lists validator issues in the order the call wrote the fields (it used the model's field order), and a
+    Json Shape's issues in the order of its keys as the Contract lists them, so the client can list the same issues in
+    the same order. An issue inside a nested write whose operand is one entry rather than a list no longer names an
+    index the request does not have (`[…, "$update", "data", …]`, not `[…, "$update", 0, "data", …]`).
+
+- 7a0cab9: A `where` now offers each field only the filter operators that field allows. The types of `framework.client`,
+  `framework.application`, `framework.clientTx`, `framework.appTx` and a generated client read the operators from the
+  field's effective `filter` capability, so an operator the server would refuse with `V1006` is now a type error
+  instead. That covers an operator the adapter does not offer for the field's type (no `contains` on an Int), an
+  operator a layer's exemptions removed (the client layer narrowing `email` to `equals` is refused on
+  `framework.client` and still allowed on `framework.application`), and operators inside a nested `not`. A plain
+  value, `null` or `$ref` as shorthand is equality, so it is only accepted where the field allows `equals`, and a field
+  narrowed to no operators at all can no longer be named in a `where`. Runtime behavior is unchanged.
+
+  A generated client picks this up when it is regenerated with this version of `@aventara/client`.
+
+- c6e5010: Breaking: one stage order, and hooks now run inside interceptors. Every operation runs
+
+  ```
+  guards → pipes → validators → interceptors (before) → hooks.before → operation → hooks.after → interceptors (after) → filters
+  ```
+
+  Each stage runs over every level, outer to inner, before the next starts, so every interceptor wraps every hook: all
+  interceptors enter, then every `before` hook runs, then the operation, then every `after` hook (inner to outer), then
+  the interceptors unwind (inner to outer). In rc.0 every `before` hook ran ahead of every interceptor, every `after`
+  hook after every interceptor had unwound, and the overlay's `after` hooks after the root's; now the overlay's run
+  before the root's. Filters run inner to outer, and the first filter that handles an error wins. A call that a guard,
+  a pipe's output or a validator refuses runs no interceptor and no hook; the filters still see a thrown error. Inside
+  a transaction, a step's error its own filters leave unhandled continues to the Resource transaction filters (the
+  transaction's outer layer) before it is answered.
+
+  New: stages at every level of `resources`. `resources.<R>.pipelines`, `resources.<R>.operations.<family>.pipelines`
+  and `resources.<R>.operations.<family>.<variant>.pipelines` run now, in both layers, level by level: root layer,
+  overlay layer, root Resource, overlay Resource, root family, overlay family, root variant, overlay variant. Nothing
+  below removes a stage above. A stage is told the level it sits at: a Resource's `ctx.$operation.resource` is its name, a
+  family's `ctx.$operation.family` too, a variant's `ctx.$operation.variant` as well.
+
+  - Field pipes (`resources.<R>.fields.<f>.pipelines.pipes`) are pure: value in, value out, no `ctx`. They run on
+    each value the caller sent in top-level create, update or upsert data, right after the operation's pipes, root's
+    then overlay's; guards see the value as sent. In a transaction they run on every step's literal values before the
+    transaction opens, and on a `$ref` value when it is resolved at its step. A value a field pipe returns is held to the server's rules
+    (`A3004`). A relation field takes no field pipes (`COMPILER_RELATION_FIELD_CONFIG_UNSUPPORTED`).
+  - Field write guards (`resources.<R>.fields.<f>.pipelines.guards`) refuse with `A4001` when the caller sends
+    the field in create, update or upsert data, a relation field's `$connect` included. They run right after the
+    operation's guards, last among the guards.
+  - Transactions: every step's guards, pipes and validators run before the transaction opens, in plan order; an
+    operation pipe sees a `$ref` as the reference it is. A refused step opens nothing. Then BEGIN, and at each step
+    its `$ref`s are resolved, their field pipes and validators run, then the step's interceptors and hooks around its
+    adapter call. A forced call runs the same way. A step's guards and pipes no longer run inside the transaction, so
+    their ctx calls do not join it.
+  - Resource transaction stages (`resources.<R>.transactions.pipelines`) run once per transaction with a
+    top-level step on the Resource, inside it: guards and pipes see the whole plan (`ctx.$args`, `$ref`s unresolved),
+    interceptors and hooks wrap every step, and the `after` hooks see every step's result before the commit, so a
+    throw rolls everything back. Touched Resources run in the order their first step appears; a SQL step touches
+    nothing. A transaction pipe may change a step's arguments; they are held to the server's rules and their
+    validators at the step.
+  - `forceTransaction` on a family or a variant runs a plain call of that operation as a one-step transaction,
+    so its after hooks commit with the write or not at all, and the Resource's transaction stages run. It holds when
+    any layer sets it. As a step of a plan it is just a step. Under an effective `transactionsStyle: "none"` it is a
+    startup error (`CONFIG_INVALID_VALUE`).
+
+  Breaking: a transaction has one origin. `framework.transaction` refuses a list that mixes `appTx` and
+  `clientTx` handles: `A2004` with one new `V1020` issue, "Transaction mixes application and client steps.", at the
+  first step of the other origin, before anything runs. An `appTx.$sql` step is application-origin. Run each
+  origin's steps as its own transaction. The generated client's error codes include `V1020`.
+
+- Generated clients changed. Regenerate with `avclient generate` after upgrading. `AvOperationCall` lost its
+  `Settlement` parameter, because every direct call now resolves its data. The generated tree no longer copies two
+  declaration files, `derivation/runtime/operation-response.d.ts` and `derivation/transactions/transaction-response.d.ts`,
+  since nothing in it uses them now. And core's in-process calls (`framework.application`, `framework.client`,
+  `framework.transaction`) now throw the same `AvError` subclasses the generated client throws, chosen by the same
+  code-to-class table, so the server and the client classify every failure the same way.
+
+- Generated clients type required create fields. The ClientContract now states each Resource's create requirements
+  (`createRequirements`), and a generated client's create payloads require them: leaving out a required field, or
+  writing a required relation neither way or both ways (`author` and `authorId`), is a type error. A nested create
+  gets the relation it is created through from its parent. The Client Contract's hash changes; regenerate with
+  `avclient generate`. The generated tree copies one more declaration file, `derivation/contracts/create-requirements.d.ts`.
+
+- Updated dependencies [800123b]
+- Updated dependencies [8bb1d6a]
+- Updated dependencies [68d4395]
+- Updated dependencies [7e3d06f]
+- Updated dependencies [1b5d3c0]
+- Updated dependencies [6317811]
+- Updated dependencies [6d0e5d6]
+- Updated dependencies [7a0cab9]
+- Updated dependencies [eb2a718]
+- Updated dependencies [03312c5]
+- Updated dependencies [123f6dc]
+- Updated dependencies [b65df2e]
+- Updated dependencies [c6e5010]
+- Updated dependencies [c1f9389]
+- Updated dependencies [9c52482]
+- Updated dependencies [8396148]
+- Updated dependencies [e8fbb02]
+- Updated dependencies [916e5f6]
+- Updated dependencies [6cbd158]
+  - @aventara/core@1.0.0-rc.1
+
+## 1.0.0-rc.0
+
+### Major Changes
+
+- First release candidate of Aventara 1.0. The public API is now considered stable; changes before 1.0.0 are possible
+  based on feedback.
+
+### Minor Changes
+
+- 24ffbab: A `Json` field can now have a type. Build its shape with `AvZ` from the new entry `@aventara/core/json` and declare it
+  on the field: `fields: { Post: { meta: { json: AvZ.object({ title: AvZ.string() }) } } }`. `framework.application`,
+  `framework.client`, `appTx`/`clientTx` and the generated client then read and write the field as that type instead of
+  generic JSON, and every write to it — create, update, upsert, nested writes and transaction steps, a value taken from
+  an earlier step included — is checked before the database is asked: a value out of shape is refused with `A2004` and
+  one issue per problem at its exact path (`V1000` missing key, `V1001` wrong type, `V1002` outside an enum or literal,
+  `V1004` integer out of range, `V1005` unknown key). Shapes are types only and their objects are closed; reads and
+  filters are never checked. Only a field the adapter discovered as `Json` takes a shape, and a Zod schema is not
+  accepted. The shape is part of the ClientContract (as JSON Schema), so declaring or changing one changes its hash:
+  regenerate the client. `@aventara/core` now depends on `zod` (`^4.6.5`), which only `@aventara/core/json` loads. The
+  shape types `AvZShape`, `AvZObject`, `AvZOptional` and `AvZNullable` are exported too, so a project that emits
+  declarations can export a shape or a configuration holding one.
+- 24ffbab: Transaction steps can now reference earlier results in `$connect`, `$disconnect`, `$set`, `$connectOrCreate`'s `where`,
+  a `cursor`, a unique `where`, anywhere in a filter, and at any depth of nested relation writes. The generated client binds a `$ref` wherever a step's arguments
+  hold one, and its types accept one exactly where the server does: of the field's own type, nullable only for a filter's
+  equality on a nullable field, a list field for `in`, `notIn`, `hasEvery` and `hasSome`. Regenerate the client to use them.
+- 24ffbab: `aventara new`, `aventara init`, `avclient init` and `avclient generate` show their steps while they work, so a long
+  install never looks hung: on a terminal, `[3/4] Installing dependencies (npm install)` with a spinner and the seconds so
+  far, then `✓` or `✗` and its time; in a pipe, in CI or with `NO_COLOR`, one plain line per step (`… done (12.4s)`),
+  with no control sequence. A closing line gives the total time. The steps go to stderr; stdout keeps the results and the
+  next steps. The output of `nest new` and of the install is shown only when it fails, as before, or as it runs with the
+  new `--verbose`.
+- 24ffbab: A nested `$update` or `$delete` through a to-many relation filters plain fields only on Prisma 7, and Aventara now says
+  so up front: a relation filter in its `where` — `{ posts: { $update: { where: { category: { name: "x" } }, … } } }`, at
+  any depth, under `AND`/`OR`/`NOT` too — is refused with `A2004` / `V1006` before the database is asked, and is a type
+  error in `framework.application`, `framework.client`, `appTx`/`clientTx` and the generated client. Before, it reached
+  Prisma and fail as `A3001`. A to-one relation's nested filter keeps relation filters. The limit is stated by the adapter
+  in the Contract (`nestedWriteFilter: "scalar"`), so the ClientContract hash changes: regenerate the client.
+
+### Patch Changes
+
+- 24ffbab: Each package ships its `CHANGELOG.md`, so the release notes are in the installed package beside the README.
+- 24ffbab: **Behaviour changes:** server-side calls now copy what you pass them. `framework.application`, `framework.client`,
+  `framework.execute`, `framework.executeTransaction` and the `appTx`/`clientTx` builders read your arguments once, when
+  you call them, into plain data the framework owns; validation, guards, pipes, computed values and the adapter see only
+  that copy, so changing or revoking your object afterwards (an Immer draft after `produce`) no longer affects the
+  operation. A live Proxy (Vue `reactive`, MobX) still works.
+
+  A value that cannot be read — a revoked Proxy, a getter that throws — or that is not plain data — a class instance or a
+  `Map`; `Date`, `Decimal` and `Uint8Array` are fine — is now refused as your request's error: `A2004` with one `V1001` at
+  the value's path (`["arguments", …]`, or `["operations", i, "args", …]` with `cause.operation` in a transaction), before
+  any guard, pipe or adapter runs. Before, it was `A3000` (an internal error) or, from `appTx`/`clientTx`, a `TypeError`
+  thrown at the builder call; a builder now never throws, and `framework.transaction([...])` answers the refusal. The same
+  holds for a `framework.execute` / `executeTransaction` request object that cannot be read. Two answers change for
+  inputs that were never supported: a class instance where an object of arguments belongs (`where`, `data`, …) was
+  accepted or failed as `A3000`, and is now refused; inherited, non-enumerable and symbol keys are dropped, as JSON drops
+  them.
+
+  New optional root setting `misuse` (types `FrameworkMisuseSink`, `FrameworkMisuseEvent`), beside `diagnostics`: it
+  receives one event per refused value — its `kind` (`"unreadable-value"` or `"non-plain-value"`), the `path` the caller
+  received, and the operation's `origin`, `resource`, `family`, `variant` and transaction step (`operation`) when they
+  could be read — never the value itself. It cannot change a response; an error it throws or a promise it rejects is
+  ignored. `diagnostics` keeps receiving only unexpected failures.
+
+  HTTP requests are not copied again: a body the protocol parses from raw content is already plain data.
+
+  The generated client reads your arguments through one guard too: a value that cannot be read is refused with a
+  `TypeError` naming where (`… the value at /where/id could not be read.`) before anything is sent, and a `tx` builder
+  never throws — `transaction([...])` rejects with that error instead. Regenerate the client to pick this up.
+
+- 032f792: The generated client's `transaction([...])` refuses an entry that is not one of its `tx` handles, or one handle
+  placed twice, with the path core answers for it: `["operations", i]`, the entry itself (was `["operation"]`).
+  Regenerate the client to pick this up.
+- Updated dependencies [24ffbab]
+- Updated dependencies [24ffbab]
+- Updated dependencies [24ffbab]
+- Updated dependencies [24ffbab]
+- Updated dependencies [24ffbab]
+- Updated dependencies [24ffbab]
+- Updated dependencies [24ffbab]
+- Updated dependencies [24ffbab]
+- Updated dependencies [24ffbab]
+- Updated dependencies [24ffbab]
+- Updated dependencies [24ffbab]
+- Updated dependencies [24ffbab]
+- Updated dependencies [a973e89]
+- Updated dependencies [1e65e9a]
+- Updated dependencies
+- Updated dependencies [a973e89]
+- Updated dependencies [a973e89]
+- Updated dependencies [1e65e9a]
+- Updated dependencies [1e65e9a]
+- Updated dependencies [24ffbab]
+- Updated dependencies [2d00ad7]
+- Updated dependencies [384a50c]
+- Updated dependencies [d43d1cc]
+- Updated dependencies [3f98749]
+- Updated dependencies [032f792]
+- Updated dependencies [dbe6961]
+  - @aventara/core@1.0.0-rc.0
+
+## 0.1.0-pilot.4
+
+### Patch Changes
+
+- f37dcd6: The documentation shipped with the package — the comments an editor shows on hover, and the README — now describes
+  what each export does, how to use it, what it returns and what it throws. Notes about how the package was built and
+  why are no longer part of what is published.
+- Updated dependencies [f37dcd6]
+  - @aventara/core@0.1.0-pilot.4
+
+## 0.1.0-pilot.3
+
+### Patch Changes
+
+- 0c4b352: `avclient init` adds `.env` to the frontend's `.gitignore` whenever it puts the entrypoint variable in `.env`: Vite's
+  `.gitignore` lists only `*.local`, so the `.env` init wrote was committed. The file is only appended to — every line
+  kept, nothing added when `.env` is already listed — and created where the project has none, as `aventara init` does on
+  the server. The generated client itself is still committed.
+- ac1ae3a: `avclient init` refuses a project with no `tsconfig.json` before it writes or installs anything. 0.1.0-pilot.2 wrote
+  `framework.client.ts`, the `.env` entry, the script and the devDependency, ran the install, and only then had the first
+  generation refuse the JavaScript project. The check is the one `avclient generate` makes — the same search from
+  `generateAt` up, the same sentence — and it runs once the questions are answered, before anything is written.
+- c34e65d: `avclient init` and `avclient generate` no longer print Node's `ExperimentalWarning: stripTypeScriptTypes is an
+experimental feature`. With your project's `typescript` the output is type-checked and Node's parser is never called;
+  without it, the degraded check still parses with Node's parser and says so in its own warning, and only that one Node
+  warning is held back while it parses.
+- 5ab40b2: The generated client is type-checked with your project's own `typescript`, resolved from `generateAt`, not with one
+  installed beside `@aventara/client`. Run through `npx @aventara/client init`, the generator lives in npm's cache, where
+  its optional peer is never installed, so 0.1.0-pilot.2 warned "`typescript` could not be resolved … NOT type-checked"
+  and reported `(checked: syntax)` in a project that had TypeScript. It now reports `(checked: types)`. The degraded check
+  runs only when the project has no `typescript`, or one it cannot check with: TypeScript 7 (no classic compiler API), or
+  one older than 5.5, the peer range's floor — each said in its own warning.
+  - @aventara/core@0.1.0-pilot.3
+
+## 0.1.0-pilot.2
+
+### Patch Changes
+
+- 80527cf: The generated client is still TypeScript source — `AvClient.ts` and `generated/` — compiled by your own toolchain, but
+  its internal imports are now written the way your project imports its own files, read from your `tsconfig.json` by
+  Prisma 7's rules: extensionless under `moduleResolution: "bundler"` (Next.js with Turbopack or webpack) or `module: "commonjs"`,
+  `.js` under `nodenext` (NestJS 12), `.ts` with `allowImportingTsExtensions` (Vite's react-ts template, Node's type
+  stripping). So
+  Next.js 16's Turbopack, which could not resolve 0.1.0-pilot.1's client, builds it, and you import it as you import your
+  own files: `./api/AvClient`, `./api/AvClient.js` in a `nodenext` ES module project, `./api/AvClient.ts` where your
+  imports name `.ts` files. A project with no
+  `tsconfig.json` is refused with a sentence saying so: JavaScript projects are not supported yet. The client also
+  type-checks under `"strict": false` (the tsconfig Next.js writes itself), where 0.1.0-pilot.1's transport did not.
+
+  The config is loaded the way Prisma 7 loads `prisma.config.ts` (c12 over jiti): `framework.client.ts` — or `.mts`,
+  `.cts`, `.js`, `.mjs`, `.cjs`, in ES module or CommonJS syntax, in any project. `avclient init` writes
+  `framework.client.ts`; a 0.1.0-pilot.1 `framework.client.mts` keeps working and is reused. Two config files are refused.
+
+- e69e88d: The published packages are written for the people who use them. The JavaScript ships without comments; the type
+  declarations keep their documentation, and it, the error messages, the protocol fixtures' labels and the comments in a
+  generated client no longer carry the project's internal development notes.
+- ab58424: A pipe's output is checked against the server's own rules before it reaches the adapter. The request is validated
+  against the caller's Contract; after each pipe, the arguments are validated against the Core Contract (plus fields the
+  caller's scope adds), so a pipe may still write what the caller cannot — a field the client Contract hides, such as a
+  password hash — but not what the server cannot store. A refusal is the new internal code `A3004 PIPE_OUTPUT_INVALID` (HTTP
+  500). The caller receives only the generic `A server pipeline produced invalid arguments.`, like every internal
+  failure; the pipe (`pipes[i]` and its function name), the operation, the offending field and its V-code go to the
+  diagnostics sink as a `PipeOutputError`, and `@aventara/nest` writes them into its error log line. Nothing reaches the
+  adapter. This holds for operations and transaction steps alike (a plan answers with `cause.operation`). Generated
+  clients map `A3004` to `InternalError`; the protocol fixtures in `@aventara/testing` include an `A3004` row.
+- 0ec37d4: `avclient --version` (and `-v`) prints the generator's version and exits 0, and `aventara` now accepts `-v` beside
+  `--version`, so both bins answer the same two flags.
+- Updated dependencies [c2a3b7c]
+- Updated dependencies [e69e88d]
+- Updated dependencies [ab58424]
+- Updated dependencies [23937f8]
+  - @aventara/core@0.1.0-pilot.2
+
+## 0.1.0-pilot.1
+
+### Patch Changes
+
+- d5bd6eb: A CommonJS frontend works. `npm init -y` writes `"type": "commonjs"`, under which Node read `framework.client.ts` as
+  CommonJS and `avclient generate` stopped with "Cannot use import statement outside a module". `avclient init` now writes
+  `framework.client.mts`, an ES module in every project, and moves an existing `framework.client.ts` to it (asking first if
+  it was edited). `avclient generate` reads `framework.client.mts`, still reads `framework.client.ts`, refuses in one
+  sentence when both are present, and tells a `.ts` that fails to evaluate to rename itself.
+- 4a12683: TypeScript 7 no longer blocks a frontend. The optional `typescript` peer is `>=5.5.0` with no upper bound, so `npm i`
+  in a project on `typescript` 7.x no longer fails with `ERESOLVE`. Under a `typescript` without the classic compiler API
+  (`createProgram`), `avclient generate` no longer refuses: it degrades to the syntax check with one warning naming the
+  version, and writes the client — which then type-checks under the project's own `tsc` 7.
+- 799346e: The package READMEs (each package's npm page) are rewritten for the people who use the packages. The Prisma 7
+  adapter's README now states the actual behaviour of a to-many relation or `$count` projected on
+  `update.many`/`create.many`: a validation refusal, `A2004` with `V1008`, before any statement runs (it said `A3001`).
+  Every install or run command names the `@pilot` dist-tag.
+- 88408be: `--help` (and `-h`) works after a command: `aventara new --help`, `aventara init --help`, `avclient init --help` and
+  `avclient generate --help` print that command's usage and exit 0, instead of refusing "unknown flag --help". Nothing
+  else on the line is read or run.
+- Updated dependencies [a45f8a8]
+- Updated dependencies [799346e]
+  - @aventara/core@0.1.0-pilot.1
+
+## 0.1.0-pilot.0
+
+### Minor Changes
+
+- First pilot release of `@aventara/client`, the development-time client generator, bin `avclient`.
+
+  - `avclient init` sets up a frontend — `framework.client.ts`, the `.env` entry, the `avclient:generate` script and an
+    exact `@aventara/client` devDependency — then installs and generates.
+  - `avclient generate` reads the server's ClientContract and writes a standalone typed client that your application
+    imports; the generated code needs no `@aventara/client` at runtime. A client generated for an older contract fails
+    with a message telling you to run `avclient generate`. Messages are prefixed `avclient:`.
+  - The client's entrypoint follows the server's rule: `"api"`, `"/api/"` and `"//api//"` all mean `"/api"`, and a mount
+    path holding a backslash, a `.` segment, a non-ASCII character, a `%` or another character not allowed in a URL path
+    segment is refused rather than silently rewritten.
+  - `bigint`, `decimal`, `datetime` and `bytes` travel in the server's wire forms, and only canonical base64 is accepted
+    for `bytes`.
+  - At this release the `typescript` peer is `>=5.5.0 <7`, and TypeScript 7 is refused in one sentence (0.1.0-pilot.1
+    lifts this).
+
+### Patch Changes
+
+- Updated dependencies
+  - @aventara/core@0.1.0-pilot.0