@aventara/nest 0.1.0-pilot.3 → 1.0.0-rc.0

package/CHANGELOG.md

@@ -0,0 +1,150 @@
+# @aventara/nest
+
+## 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.
+
+### Patch Changes
+
+- 24ffbab: Each package ships its `CHANGELOG.md`, so the release notes are in the installed package beside the README.
+- 24ffbab: **Behaviour changes:** Pipelines and guards read where a request came from as `request.origin` (was `request.scope`).
+  The same property is renamed everywhere it means `"application"` or `"client"`: the pipeline context
+  (`context.origin`), the request objects `framework.execute` and `framework.executeTransaction` take
+  (`{ origin: "client", … }`), the context a computed field's behaviour receives, and every diagnostic the diagnostics
+  sink receives. There is no `scope` alias: replace `scope` with `origin` in those places. Nothing sent over HTTP
+  changes.
+
+  The Nest host's log line for an internal failure now reads `(client origin, request …)` instead of
+  `(client scope, request …)`.
+
+- 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
+
+- @aventara/core@0.1.0-pilot.3
+
+## 0.1.0-pilot.2
+
+### Patch Changes
+
+- 5535994: Internal failures are visible in the host's log: when `AventaraModule` builds the framework from `config`, every
+  `A3000`–`A3003` writes one error line through Nest's `Logger` (context `Aventara`) with the code, the operation, the
+  scope, the request id and the thrown value's class name — never the error's message. A configured `diagnostics` sink
+  still receives the raw error.
+- 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.
+- 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
+
+- 1c45eb7: Startup says what Aventara mounted. Its routes are platform routes, which Nest's `RouterExplorer` never lists, so a
+  started server showed no sign of them. On mount, the module now logs one line through Nest's `Logger` (context
+  `AventaraModule`), read off `protocol.surface()`: `Aventara mounted 10 operations at /api (+ GET /api/_contract, POST
+/api/_transactions)`. The application's logger settings govern it.
+- 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.
+- e58aebf: The READMEs show how to call the API by hand: a copy-pasteable `curl` that fetches `/api/_contract` and sends a
+  `find.many` with both identity headers, and runs as printed against a scaffolded server. They also say that
+  Resource keys are the model names as written (`/_resources/User/…`, `avClient.User.find.many`), and that list results are
+  `readonly` arrays (`readonly User[]`).
+- 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/nest`: it hosts an Aventara Framework in a NestJS 12 application (peers
+  `@nestjs/common` and `@nestjs/core` `^12.0.0`). It exports `AventaraModule`, `AVENTARA_FRAMEWORK`, `InjectFramework`
+  and the types `AventaraModuleOptions` / `AventaraModuleAsyncOptions`.
+
+  - **Mounting.** `AventaraModule.forRoot({ framework })` uses your own instance; `forRoot({ config })` calls
+    `createFramework(config)` itself; `forRootAsync({ imports, inject, useFactory })` resolves either. Both forms are
+    generic like `createFramework`, so a configuration is checked against its adapter's model. The module is global;
+    inject the Framework with `@InjectFramework()`. A configuration error rejects `NestFactory.create` before the
+    application listens, and passing both `framework` and `config`, neither, a value that is not a Framework, or
+    mounting the module twice is refused with a fixed message.
+  - **Routes.** One platform route per route the protocol advertises — every operation, `GET /_contract`, and
+    `POST /_transactions` when transactions are interactive — at its literal path under `FrameworkConfig.entrypoint`
+    (a Nest global prefix does not move it), on Express and on Fastify. Any other path under the entrypoint's `/_`
+    namespace gets the protocol's own answer; every other path goes on to Nest.
+  - **What runs on them.** Nest's guards, interceptors and pipes do not; `app.use` middleware and `enableCors()` do.
+    `MiddlewareConsumer` middleware does not run on them on Express, and does on Fastify — exclude `<entrypoint>/_*`
+    (for example `.exclude("api/_*path")`) to keep it off. A throw while translating a request reaches your exception
+    filter.
+  - **Request bodies.** Read raw and bounded by the contract's `limits.maxRequestBytes`; `gzip`, `deflate` and `br` are
+    decoded and the limit counts decoded bytes (`413 A2010`); any other coding answers `415 A2011`, and a body that does
+    not decode in the coding it names answers `400 A2000`. Nothing is executed in either case. Your own routes keep Nest's
+    parsed `req.body`.
+  - **Platform differences.** On Fastify, Resource keys or an entrypoint holding `*` or a reserved character
+    (`: + # $ & , / ; = ? @`) are refused at startup, naming them — rename them, or host on Express. Express answers a
+    non-canonical percent-encoding of a protocol route with `500 A3000`, and matches the entrypoint in any case by
+    default.
+  - Works under Nest's testing module (`Test.createTestingModule(…).compile()` then `createNestApplication()`), and every
+    export has a `default` condition, so a CommonJS NestJS project can `require()` it. The README covers the ways to
+    mount the module, typed injection, what fails before listen, and the platform differences.
+
+### Patch Changes
+
+- Updated dependencies
+  - @aventara/core@0.1.0-pilot.0

package/README.md

@@ -127,12 +127,12 @@ own when it mounts them, through Nest's `Logger` (context `AventaraModule`; `log
 ```
 
 An internal failure (`A3000`–`A3004`, answered as a 500) is logged as one error line through Nest's `Logger`
-(context `Aventara`): the code, the operation, the scope and the request id, and the thrown value's class name — never
+(context `Aventara`): the code, the operation, the origin and the request id, and the thrown value's class name — never
 its message, which can hold SQL or a connection string. The raw error still goes to your `diagnostics` sink, when you
 configure one:
 
 ```text
-[Nest] ERROR [Aventara] A3001 on Post.create.one (client scope, request 3f1c…): PrismaClientValidationError. The raw error goes to the framework's diagnostics sink.
+[Nest] ERROR [Aventara] A3001 on Post.create.one (client origin, request 3f1c…): PrismaClientValidationError. The raw error goes to the framework's diagnostics sink.
 ```
 
 For `A3004` — one of your pipes returned arguments the server contract refuses — the line also names the pipe, the

package/dist/aventara.module.d.ts

@@ -2,16 +2,9 @@ import { type AdapterModel, type AnyFrameworkConfig, type Framework, type Framew
 import { type DynamicModule, type FactoryProvider, type ModuleMetadata, type NestModule, type OnModuleInit } from "@nestjs/common";
 import { type PendingProtocolHost } from "./protocol-host.factory.js";
 /**
- * How the application's Framework enters Nest: either the developer's own instance
- * — they called `createFramework` — or the configuration the module hands to
- * `createFramework` itself. Exactly one arm; the `?: never` halves make both a
- * type error.
- *
- * The `config` arm is typed exactly as `createFramework`'s parameter, so a
- * configuration annotated `FrameworkConfig<M>`, written inline, inferred or
- * checked with `satisfies` is accepted — and checked against its own Adapter model
- * — wherever `createFramework` would accept it. The defaults are the untyped
- * forms.
+ * How the application's Framework enters Nest: your own instance
+ * (`{ framework }`, from `createFramework`) or a configuration the module
+ * passes to `createFramework` itself (`{ config }`). Pass exactly one.
  */
 export type AventaraModuleOptions<M extends AdapterModel = AdapterModel, Cfg = AnyFrameworkConfig> = {
     readonly framework: Framework;
@@ -21,28 +14,40 @@ export type AventaraModuleOptions<M extends AdapterModel = AdapterModel, Cfg = A
     readonly framework?: never;
 };
 /**
- * `forRootAsync`'s options: the Nest idiom when what builds the Framework (a
- * Prisma client, a configuration service) is itself a provider. The factory
- * resolves to either arm of {@link AventaraModuleOptions}.
+ * `forRootAsync`'s options: the Nest idiom when what builds the Framework
+ * (a Prisma client, a configuration service) is itself a provider. The
+ * factory resolves to either arm of {@link AventaraModuleOptions}.
  */
 export type AventaraModuleAsyncOptions<M extends AdapterModel = AdapterModel, Cfg = AnyFrameworkConfig> = {
+    /** Modules whose providers the factory injects. */
     readonly imports?: ModuleMetadata["imports"];
+    /** The providers passed to `useFactory`, in order. */
     readonly inject?: FactoryProvider["inject"];
+    /** Returns the module options: `{ framework }` or `{ config }`. */
     readonly useFactory: (...deps: never[]) => AventaraModuleOptions<M, Cfg> | Promise<AventaraModuleOptions<M, Cfg>>;
 };
 /**
- * The global module that hosts one Aventara Framework, and mounts its protocol on
- * the application's platform from `configure()`: after the developer's `app.use` /
- * `enableCors`, before `MiddlewareConsumer` middleware and every controller, so
- * the reserved `_` namespace cannot be shadowed.
+ * The global module that hosts one Aventara Framework and mounts its protocol
+ * on the application's platform: after your `app.use` / `enableCors`, before
+ * `MiddlewareConsumer` middleware and every controller, so the reserved `_`
+ * namespace cannot be shadowed.
  */
 export declare class AventaraModule implements NestModule, OnModuleInit {
     private readonly host;
     constructor(host: PendingProtocolHost);
+    /** Mounts the protocol routes on the HTTP platform. */
     configure(): void;
-    /** An application context never receives a platform: refused here, at its init. */
+    /**
+     * Refuses to start in a Nest application context with no HTTP platform, where
+     * the protocol cannot be mounted.
+     */
     onModuleInit(): void;
+    /** Registers the module with a Framework instance or a configuration. */
     static forRoot<M extends AdapterModel, const Cfg = AnyFrameworkConfig>(options: AventaraModuleOptions<M, Cfg>): DynamicModule;
+    /**
+     * Registers the module with options built by a factory, for when the
+     * Framework's inputs (a Prisma client, a config service) are providers.
+     */
     static forRootAsync<M extends AdapterModel, const Cfg = AnyFrameworkConfig>(options: AventaraModuleAsyncOptions<M, Cfg>): DynamicModule;
     private static mount;
 }

package/dist/express-protocol.mounter.d.ts

@@ -2,21 +2,10 @@ import type { AvProtocolBinding } from "@aventara/core/protocol";
 import { type NodeIncoming, type NodeOutgoing } from "./node-exchange.translator.js";
 import type { ProtocolHost } from "./protocol-host.factory.js";
 /**
- * The protocol on Nest's Express platform.
- *
- * - **The pre-parser**, installed while Nest instantiates providers — before
- *   Nest's own body parsers: a request under `<entrypoint>/_` has its body read
- *   raw, bounded and decoded, and kept for its route. Its stream is then finished,
- *   so Nest's parsers skip it; every other request keeps Nest's parsed body. It
- *   reads; it answers nothing.
- * - **The routes**, mounted from the module's `configure()`: one platform route
- *   per `protocol.surface()` entry, each at its escaped literal path under the
- *   entrypoint, then one fallback — `protocol.answerAbsent`, the absence handler,
- *   not a catch-all: it executes nothing, and a path it does not own (`undefined`)
- *   goes on to Nest.
- *
- * Its whole job is translation: the Express request into an `AvProtocolRequest`,
- * the `AvProtocolResponse` back onto the wire.
+ * The protocol on Nest's Express platform: one platform route per protocol
+ * route under the entrypoint, translating the Express request into the
+ * protocol's request and the protocol's response back onto the wire. A path the
+ * protocol does not own goes on to Nest.
  */
 /** Express's request: Node's `IncomingMessage`, plus `originalUrl`. */
 type ExpressRequest = NodeIncoming & {

package/dist/fastify-protocol.mounter.d.ts

@@ -2,33 +2,13 @@ import type { AvProtocolBinding } from "@aventara/core/protocol";
 import { type NodeIncoming, type NodeOutgoing, type PlatformHeaders } from "./node-exchange.translator.js";
 import type { ProtocolHost } from "./protocol-host.factory.js";
 /**
- * The protocol on Nest's Fastify platform, mounted from the module's
- * `configure()`.
- *
- * - **One Fastify route per `protocol.surface()` entry**, at its literal path
- *   under the entrypoint, with Fastify's automatic `HEAD` route off, so `HEAD
- *   /_contract` reaches the protocol's `405` as on Express.
- * - **Each route is answered from its own `onRequest` hook** — Fastify's first
- *   step, before its content-type check and body parsing: the body is read raw off
- *   Node's request by the bounded reader, the bound member answers, and the reply
- *   is hijacked. Fastify's parsers, `bodyLimit` and early `415` (on a
- *   `Content-Type` it cannot parse) never run on a protocol route, so every body
- *   failure is the protocol's own answer, as on Express. The route handler is
- *   never reached.
- * - **The absence fallback** is a root `onRequest` hook acting only on a request
- *   Fastify matched to no route (`request.is404`) under `<entrypoint>/`:
- *   `protocol.answerAbsent`, and `undefined` hands the request on to Nest's own
- *   not-found handler. A not-found handler of our own could not hand back: inside
- *   one, Fastify answers its plain-text 404, not Nest's.
- * - **Literal paths**: each route is registered `decodeURI`-ed, as find-my-way
- *   decodes a request path before matching it (`café`, `a[b]`). A path find-my-way
- *   cannot match as a literal — a `*` (its wildcard) or a reserved escape (it
- *   keeps those encoded, and never matches them against a static route) — is
- *   refused while Nest builds the application, naming the Resource keys; Express
- *   mounts them all.
- * - **Writes** go through Node's response after `reply.hijack()`, with the headers
- *   Fastify hooks already set (CORS) beneath the protocol's own — what Node's
- *   `writeHead` does on Express.
+ * The protocol on Nest's Fastify platform: one Fastify route per protocol route
+ * under the entrypoint, answered from its own `onRequest` hook before Fastify's
+ * content-type check and body parsing, so every body failure is the protocol's
+ * own answer, as on Express. A path the protocol does not own goes on to Nest's
+ * not-found handler. A route path Fastify cannot match literally (a `*`, or a
+ * reserved escape) is refused while Nest builds the application, naming the
+ * Resource keys.
  */
 /** Fastify's request: Node's own under `raw`, and whether a route matched. */
 type FastifyRequest = {

package/dist/framework.token.d.ts

@@ -1,9 +1,7 @@
 /**
- * The DI token under which `AventaraModule` provides the application's
- * `Framework`. A symbol, so injection is exact: an abstract-class token would type
- * the injected value as an empty class, not the application's own `Framework<M,
- * Cfg>`.
+ * The injection token under which `AventaraModule` provides the application's
+ * `Framework`. Type the injected value with your own `Framework<M, Cfg>` alias.
  */
 export declare const AVENTARA_FRAMEWORK: unique symbol;
-/** `@InjectFramework()` — `@Inject(AVENTARA_FRAMEWORK)` in one call. */
+/** `@InjectFramework()`: `@Inject(AVENTARA_FRAMEWORK)` in one call. */
 export declare function InjectFramework(): ParameterDecorator;

package/dist/internal-failure.logger.d.ts

@@ -2,7 +2,7 @@ import type { FrameworkDiagnostic, FrameworkDiagnosticsSink } from "@aventara/co
 /** Wraps the application's sink (if any): log an internal failure, then forward. */
 export declare function withInternalFailureLog(sink: FrameworkDiagnosticsSink | undefined): FrameworkDiagnosticsSink;
 /**
- * e.g. `A3001 on Post.create.one (client scope, request 7f3c…): Error. The raw
+ * e.g. `A3001 on Post.create.one (client origin, request 7f3c…): Error. The raw
  * error goes to the framework's diagnostics sink.`
  */
 export declare function internalFailureLine(diagnostic: FrameworkDiagnostic): string;

package/dist/internal-failure.logger.js

@@ -19,7 +19,7 @@ export function internalFailureLine(diagnostic) {
     const step = diagnostic.operation === undefined
         ? ""
         : `, plan operation ${diagnostic.operation}`;
-    return `${diagnostic.code} on ${subject} (${diagnostic.scope} scope, request ${diagnostic.requestId}${step}): ${thrownKind(diagnostic.error)}${frameworkDetail(diagnostic.error)}. The raw error goes to the framework's diagnostics sink.`;
+    return `${diagnostic.code} on ${subject} (${diagnostic.origin} origin, request ${diagnostic.requestId}${step}): ${thrownKind(diagnostic.error)}${frameworkDetail(diagnostic.error)}. The raw error goes to the framework's diagnostics sink.`;
 }
 function frameworkDetail(error) {
     try {

package/dist/node-exchange.translator.d.ts

@@ -10,16 +10,13 @@ export type NodeOutgoing = {
 export type PlatformHeaders = Readonly<Record<string, string | number | readonly string[] | undefined>>;
 /** Zero bytes: the body of a request whose body the protocol does not read. */
 export declare const NO_BYTES: Uint8Array<ArrayBuffer>;
-/** A request URL's raw pathname — query dropped, not URL-decoded. */
+/** A request URL's raw pathname: the query is dropped and nothing is URL-decoded. */
 export declare function pathnameOf(url: string): string;
-/**
- * The request as the protocol reads it: path relative to the entrypoint,
- * `headersDistinct`, the raw arm.
- */
+/** The request as the protocol reads it: path relative to the entrypoint, distinct headers, raw body. */
 export declare function protocolRequest(method: string, url: string, incoming: NodeIncoming, entrypoint: string, content: Uint8Array): AvProtocolRequest;
 /**
- * The protocol's answer, written as it is. Headers the platform's hooks already
- * set (CORS, say) go beneath it; a protocol header of the same name, in any case,
- * wins — what Node's `writeHead` does with `setHeader`'s on Express.
+ * Writes the protocol's answer as it is. Headers the platform's hooks already
+ * set (CORS, say) go beneath it; a protocol header of the same name, in any
+ * case, wins.
  */
 export declare function writeAnswer(response: NodeOutgoing, answer: AvProtocolResponse, beneath?: PlatformHeaders): void;

package/dist/protocol-host.factory.d.ts

@@ -7,9 +7,9 @@ export type ProtocolHost = {
 };
 /**
  * Binds `framework`'s protocol for the application's platform, refusing an
- * unsupported platform while providers are instantiated — so `NestFactory.create`
- * rejects before the application listens. The routes are mounted later, from the
- * module's `configure()`.
+ * unsupported platform while providers are instantiated, so `NestFactory.create`
+ * rejects before the application listens. The routes are mounted later, from
+ * the module's `configure()`.
  */
 export declare function createProtocolHost(adapter: AbstractHttpAdapter | undefined, framework: Framework): ProtocolHost;
 /**
@@ -32,14 +32,7 @@ export type AdapterHostView = {
     };
 };
 /**
- * `NestFactory.create` sets the adapter first: the host is created at once, and an
- * unsupported platform rejects then, as before. Nest's testing module compiles
- * first and receives its adapter from `createNestApplication()`, which sets it on
- * the `HttpAdapterHost` — `init$` fires — before `app.init()` registers Nest's
- * body parsers: the host is created at that moment, so a platform's body reader is
- * still installed ahead of them. A refusal there is kept and raised by `mount()`
- * or `assertReady()`, from `app.init()` — still before the application listens.
- * With no adapter at all (`createApplicationContext`), `assertReady()` refuses
- * from `onModuleInit`.
+ * A host for an application whose HTTP adapter may arrive after the providers
+ * are instantiated (Nest's testing module).
  */
 export declare function createPendingProtocolHost(application: AdapterHostView, framework: Framework): PendingProtocolHost;

package/dist/protocol-route.table.d.ts

@@ -1,17 +1,9 @@
 import type { AvProtocolBinding, AvProtocolRequest, AvProtocolResponse } from "@aventara/core/protocol";
-/**
- * One route `protocol.surface()` lists. Core keeps `SurfaceRoute` a module
- * type, so the host derives it from the binding — no new core export.
- */
+/** One route `protocol.surface()` lists. */
 export type SurfaceRoute = ReturnType<AvProtocolBinding["surface"]>[number];
 /** What a mounted route answers its request with: a bound protocol member. */
 export type RouteAnswer = (request: AvProtocolRequest) => AvProtocolResponse | Promise<AvProtocolResponse>;
-/**
- * The bound member each kind of surface route is answered by — total over
- * `SurfaceRoute["kind"]`, so a route kind core adds fails to compile here
- * rather than mounting a route nothing answers. Every platform's mounter
- * reads this one table; none decides an answer of its own.
- */
+/** The bound member each kind of surface route is answered by. */
 export type ProtocolRouteTable = {
     readonly [K in SurfaceRoute["kind"]]: (binding: AvProtocolBinding) => RouteAnswer;
 };

package/dist/request-body.reader.d.ts

@@ -1,18 +1,7 @@
 import type { AvProtocolBinding, AvProtocolResponse } from "@aventara/core/protocol";
 /**
- * The raw arm's body reader: a request body read off a Node stream, decoded per
- * its `Content-Encoding`, and stored up to `maxRequestBytes + 1` DECODED bytes —
- * one more than the limit is all the decoder needs to answer `A2010`, and counting
- * decoded bytes is also the decompression-bomb bound. Past the bound the stream is
- * still read to its end and discarded, so the connection stays usable; nothing
- * more is inflated.
- *
- * Platform-free: it reads an async iterable of bytes, as Node's `IncomingMessage`
- * is.
- */
-/**
- * What the reader hands on: the stored bytes; an unsupported coding; or a body
- * that does not decode in the coding it names — a malformed request.
+ * What the body reader hands on: the stored bytes, an unsupported coding, or a
+ * body that does not decode in the coding it names.
  */
 export type RequestBodyRead = {
     readonly kind: "read";
@@ -23,11 +12,9 @@ export type RequestBodyRead = {
     readonly kind: "undecodable";
 };
 /**
- * The answer to a body the reader could not hand on, through the bound `failure`
- * member — the one place the host names an A-code: an unsupported coding is `415
- * A2011`; a body that does not decode in its coding is malformed, `400 A2000`. The
- * request id is minted by core: it exposes no adoption of the client's id to a
- * host.
+ * The answer to a body the reader could not hand on, through the bound
+ * `failure` member: an unsupported coding is `415 A2011`; a body that does not
+ * decode in its coding is malformed, `400 A2000`.
  */
 export declare function unreadBodyAnswer(binding: AvProtocolBinding, read: Exclude<RequestBodyRead, {
     readonly kind: "read";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aventara/nest",
-  "version": "0.1.0-pilot.3",
+  "version": "1.0.0-rc.0",
   "license": "SEE LICENSE IN LICENSE",
   "description": "NestJS host integration for Aventara.",
   "type": "module",
@@ -18,10 +18,11 @@
   },
   "files": [
     "dist",
-    "LICENSE-ADDITIONAL-PERMISSION.md"
+    "LICENSE-ADDITIONAL-PERMISSION.md",
+    "CHANGELOG.md"
   ],
   "dependencies": {
-    "@aventara/core": "0.1.0-pilot.3"
+    "@aventara/core": "1.0.0-rc.0"
   },
   "peerDependencies": {
     "@nestjs/common": "^12.0.0",
@@ -31,8 +32,8 @@
     "access": "public"
   },
   "devDependencies": {
-    "@aventara/prisma7-adapter": "0.1.0-pilot.3",
-    "@aventara/testing": "0.1.0-pilot.3",
+    "@aventara/prisma7-adapter": "1.0.0-rc.0",
+    "@aventara/testing": "1.0.0-rc.0",
     "@nestjs/common": "^12.1.2",
     "@nestjs/core": "^12.1.2",
     "@nestjs/platform-express": "^12.1.2",
@@ -43,7 +44,7 @@
     "rxjs": "^7.8.2"
   },
   "scripts": {
-    "build": "tsc -p tsconfig.json --removeComments --declaration false && tsc -p tsconfig.json --emitDeclarationOnly && node ../../scripts/build/declaration-comments.sanitizer.ts dist",
+    "build": "node ../../scripts/build/build-output.cleaner.ts dist && tsc -p tsconfig.json --removeComments --declaration false && tsc -p tsconfig.json --emitDeclarationOnly && node ../../scripts/build/declaration-comments.sanitizer.ts dist",
     "typecheck": "tsc -p tsconfig.typecheck.json --noEmit",
     "test": "vitest run --typecheck --config ../../vitest.config.mts --root .",
     "lint": "biome lint src"