@aventara/next 1.0.0-rc.10 → 1.0.0-rc.12

package/CHANGELOG.md

@@ -1,5 +1,66 @@
 # @aventara/next
 
+## 1.0.0-rc.12
+
+### Patch Changes
+
+- Updated dependencies [fdeee8a]
+  - @aventara/core@1.0.0-rc.12
+  - @aventara/mcp@1.0.0-rc.12
+
+## 1.0.0-rc.11
+
+### Patch Changes
+
+- 6197c08: `@/aventara/universal`'s calls are the generated client's own calls again. The entry no longer wraps each one in
+  `io().then(call)`, so its own `signal`, `avClient.all`'s `signal` and strict abort, and `avLazy` all reach it, in the
+  browser and on the server. Next's `io()` is now awaited before the request is sent.
+
+  In the browser, the calls made in one tick are still grouped into one `/_all`. On the server, none is grouped: each
+  call has a client of its own with grouping off, and it is sent from the async context of the code that made it. Before,
+  one queue served every request. Calls from two concurrent requests, or a call inside `unstable_cache` and one outside
+  it, could share a flush and run with the first call's headers and `state`.
+
+  `avLazy` no longer keeps one answer for every request on a server:
+
+  - The generated client's `avLazy` keeps its answer in a page. On a server (no `location`) it keeps none, and each await
+    makes the call again.
+  - `@aventara/core`'s `avLazy` keeps none: each await makes the call again.
+  - `@/aventara/universal` now exports its own `avLazy`, which keeps one answer per request inside a React render
+    (React's `cache`, which the entry now imports) and none where React keeps no request.
+
+  Before, an `avLazy` made at module scope handed the first request's answer to every request after it.
+
+  `ready()`'s in-process path now splits a cached read's GET URL into its path and its `?q=&v=` query, with an empty
+  body, so the read reaches its GET route instead of being answered as absent.
+
+- e0e89c1: `POST {api}/_all` now streams when the client asks for it: the hosts forward `Accept`, so with
+  `application/x-ndjson` each entry's line is written as it settles (Nest on Express and Fastify writes it to the response,
+  flushed through `compression` when present; Next returns a `ReadableStream`), and plain JSON stays the answer otherwise.
+  When the client disconnects, the set stops: entries not yet started never start.
+- 186bc29: `POST {api}/_all` is mounted with the other protocol routes and answered by the binding's `handleAll`.
+- 33b5f83: The hosts hand the request URL's query to the protocol, so a cached read's `GET` (a read with a `cache({ for, maxAge })` stage)
+  is mounted and answered like every other route in `protocol.surface()`, on Express, Fastify and Next.js.
+- 11ece49: `avClient.all(entries, { settle?, signal? })` is the Framework's `serverClient.all` with this request's state, so a
+  Server Component, Route Handler or Server Action writes it as a browser component writes the generated client's
+  `avClient.all`. `avClient` calls still run when made and now take their own `signal`; wrap one in `avLazy(() => …)`
+  (`@aventara/core`) for `all` to start it under `limits.maxAllConcurrency`.
+- a05d970: Every `avClient` call of one render is checked as the same principal. The state `state` seeds once per render is
+  held as that request's, so the principal is derived once, before any stage runs. A stage in one call that writes
+  `ctx.$state` no longer changes who a later or concurrent call of the same render, an `avClient.transaction`, or a
+  server-side `@/aventara/universal` call is checked as.
+- Updated dependencies [6197c08]
+- Updated dependencies [e0e89c1]
+- Updated dependencies [186bc29]
+- Updated dependencies [33b5f83]
+- Updated dependencies [6d8b589]
+- Updated dependencies [11ece49]
+- Updated dependencies [92fd093]
+- Updated dependencies [e5e98e6]
+- Updated dependencies [a05d970]
+  - @aventara/core@1.0.0-rc.11
+  - @aventara/mcp@1.0.0-rc.11
+
 ## 1.0.0-rc.10
 
 ### Patch Changes

package/README.md

@@ -102,6 +102,27 @@ Contract's view (what the client layer hides is absent), taking and answering ap
 policy as a request to `handlers`, with the principal `policy.principal` reads from `state`. A refusal is thrown as
 its `AvError` class (`AvAuthError` for the policy).
 
+`avClient.all({ key: call, … }, { settle?, signal? })` awaits an object of calls together, in process, as the
+generated client's `avClient.all` does in the browser, so a component reads alike on both sides:
+
+```ts
+import { avLazy } from "@aventara/core";
+
+const { campaigns, count } = await avClient.all({
+  campaigns: avClient.Campaign.find.many({ select: ["id", "name"] }),
+  count: avLazy(() => avClient.Campaign.find.count({})),
+});
+```
+
+A call runs when it is made, so `all` cannot pace it. Wrap a call in `avLazy(() => …)` to have `all` start it: at
+most `limits.maxAllConcurrency` at once, and never once `all` has failed or been aborted. `@aventara/core`'s `avLazy`
+keeps no answer: each await makes the call again, so one made at module scope never hands one request's answer to
+another. It takes any number of
+entries: `limits.maxAll` bounds `POST /_all` only. Strict by default: the first
+failure rejects it (fail-fast, not atomic). With `settle: true` each key is `{ status: "fulfilled", value }` or
+`{ status: "rejected", reason }`. Its `signal` aborts each entry; a call's own `signal` (`{ signal }` in its options)
+aborts only that call. Nothing is aborted for you. A Resource named `all` is refused when the Framework is built.
+
 `state` is called with `{ headers }` from `next/headers` (there is no `request` outside a route call), once per
 server render however many calls the render makes. Outside a render, in a Server Action's body for example, it runs
 once per call. A call that names its own `state` in its options uses it as given. Without a `state` option, calls
@@ -197,6 +218,15 @@ both sides: in the browser it calls `/api`; on the server it answers the same re
 protocol and with this request's `state`, so a query prefetched in a Server Component and refetched in the browser
 gets the same values (`Date`, `bigint`, the client's own `AvDecimal`).
 
+Its calls are the generated client's own on both sides: made when written, aborted by their own `signal`, and reached
+by `avClient.all`'s `signal` and strict abort and by `avLazy`. In the browser the calls made in one tick are grouped
+into one `/_all`. On the server none is grouped: each call is sent on its own, from the async context of the code that
+made it (its request, `unstable_cache`'s scope, your own), so it runs with that scope's `state`; in process a group
+would save no round trip. It exports `avLazy` beside `avClient`, for components that run on both sides. In the
+browser an `avLazy` makes its call once and keeps the answer. On the server it keeps one answer per request inside a
+render (React's `cache`), and none where React keeps no request, such as a route handler or a Server Action, where each
+await makes the call again.
+
 A decimal is a class instance, which React refuses to pass from a Server Component to a Client Component. `avDehydrate`
 (this package, server side) turns each `Date`, `bigint`, `Uint8Array` and decimal into a tagged plain object, and
 `avHydrate` (`@/aventara/client`, browser side) turns them back.

package/dist/aventara.factory.d.ts

@@ -85,6 +85,11 @@ type AventaraHostOf<F extends HostedMembers> = {
      *
      * `avClient.tx` builds client-layer transaction handles and
      * `avClient.transaction([...])` runs them with the same state.
+     *
+     * `avClient.all({ … }, { settle?, signal? })` awaits an object of calls
+     * together, in process, as the generated client's `avClient.all` does in the
+     * browser; `avLazy(() => call)` entries (`@aventara/core`) it starts itself,
+     * at most `limits.maxAllConcurrency` at once.
      */
     readonly avClient: F["serverClient"] & {
         /**

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

@@ -5,8 +5,12 @@ import type { McpBinding, McpRequest, McpRoute } from "./mcp-binding.loader.js";
 type SurfaceRoute = ReturnType<AvProtocolBinding["surface"]>[number];
 /** The developer's `state` option over one route request: seeds its `ctx.$state`. */
 export type StateSeed = () => AvState | Promise<AvState>;
+/** An answer a route writes: the protocol's, its body text or, for a streamed `/_all`, lines as they settle. */
+export type RouteResponse = Awaited<ReturnType<AvProtocolBinding["handleAll"]>>;
 /** What a route answers its request with: a bound protocol member. */
-export type RouteAnswer = (request: AvProtocolRequest, state: StateSeed | undefined) => AvProtocolResponse | Promise<AvProtocolResponse>;
+export type RouteAnswer = (request: AvProtocolRequest, state: StateSeed | undefined, 
+/** Aborted when the client goes away (`request.signal`); only `/_all` reads it. */
+disconnect: AbortSignal) => RouteResponse | Promise<RouteResponse>;
 /** The bound member each kind of surface route is answered by. */
 type ProtocolRouteTable = {
     readonly [K in SurfaceRoute["kind"]]: (binding: AvProtocolBinding) => RouteAnswer;

package/dist/protocol-route.table.js

@@ -3,6 +3,9 @@ export const PROTOCOL_ROUTES = {
     contract: (binding) => (request) => binding.encodeContract(request),
     transactions: (binding) => (request, state) => binding.handleTransaction(request, state === undefined ? {} : { state }),
     can: (binding) => (request, state) => binding.handleCan(request, state === undefined ? {} : { state }),
+    all: (binding) => (request, state, disconnect) => binding.handleAll(request, state === undefined
+        ? { signal: disconnect }
+        : { state, signal: disconnect }),
 };
 export const MCP_ROUTES = {
     endpoint: (binding) => (request, state) => binding.handleEndpoint(request, state === undefined ? {} : { state }),

package/dist/request-state.cache.d.ts

@@ -2,8 +2,8 @@ import type { AvState } from "@aventara/core";
 import type { HostState } from "./route-handlers.factory.js";
 /**
  * The request's state for `avClient`: the developer's `state`, handed the
- * headers `next/headers` reads, run once per request. `undefined` without a
- * `state` option, so the call starts from `{}` as on a route, and reads no
- * headers.
+ * headers `next/headers` reads, run once per request, its principal derived
+ * once for the request. `undefined` without a `state` option, so the call
+ * starts from `{}` as on a route, and reads no headers.
  */
 export declare function createRequestState(state: HostState | undefined): () => Promise<AvState | undefined>;

package/dist/request-state.cache.js

@@ -1,8 +1,13 @@
+import { holdRequestPrincipal } from "@aventara/core/internal";
 import { headers } from "next/headers.js";
 import { cache } from "react";
 export function createRequestState(state) {
     if (state === undefined) {
         return async () => undefined;
     }
-    return cache(async () => state({ headers: await headers() }));
+    return cache(async () => {
+        const seeded = await state({ headers: await headers() });
+        holdRequestPrincipal(seeded);
+        return seeded;
+    });
 }

package/dist/route-handlers.factory.js

@@ -57,7 +57,7 @@ export function createRouteHandlers(host, state) {
         if (body.kind !== "read") {
             return webResponse(unreadBodyAnswer(binding, body));
         }
-        return webResponse(await answer(protocolRequest(request, path, body.content), seed));
+        return webResponse(await answer(protocolRequest(request, path, body.content), seed, request.signal));
     };
     return Object.freeze({
         GET: handle,

package/dist/server-operations.factory.js

@@ -11,7 +11,7 @@ function ioBeforeCall() {
     }
 }
 const handlesBeforeBuild = (member) => `Aventara: \`${member}\` builds its handles on the Framework, which is built on first use; \`await ready()\` before building them.`;
-const CLIENT_MEMBERS = ["tx", "transaction", "$access"];
+const CLIENT_MEMBERS = ["all", "tx", "transaction", "$access"];
 const APPLICATION_MEMBERS = ["appTx", "transaction"];
 export function refuseMemberClashes(framework) {
     const clashes = [
@@ -41,10 +41,12 @@ export function createServerOperations(source, requestState, access) {
     };
     const asGiven = async (options) => options;
     const clientTransaction = transactionOf(source, withRequestState);
+    const all = allOf(source);
     const applicationTransaction = transactionOf(source, asGiven);
     const verbs = accessOf(source, withRequestState, access);
     return {
         avClient: operationTree("avClient", source, (framework) => framework.serverClient, withRequestState, {
+            all: () => all,
             tx: () => builders(source, "avClient.tx").serverClientTx,
             transaction: () => clientTransaction,
             $access: () => verbs,
@@ -125,6 +127,13 @@ function transactionOf(source, fill) {
     };
 }
 const NEVER_A_RESOURCE = new Set(["then", "__esModule"]);
+function allOf(source) {
+    return async (entries, options) => {
+        await ioBeforeCall();
+        const framework = await source.built();
+        return framework.serverClient.all(entries, options);
+    };
+}
 function operationTree(name, source, layer, fill, members) {
     const leaf = (path) => async (args, options) => {
         await ioBeforeCall();

package/dist/universal-path.registry.d.ts

@@ -2,11 +2,11 @@ import type { StateSeed } from "./protocol-route.table.js";
 import { type ProtocolHost } from "./route-handlers.factory.js";
 /** The `globalThis` key the in-process path is registered under. */
 export declare const UNIVERSAL_PATH_KEY: unique symbol;
-/** The request the generated client's transport hands to its `fetch`. */
+/** The request the generated client's transport hands to its `fetch`: a cached read's GET has no body. */
 export type UniversalRequest = {
     readonly method: string;
     readonly headers: Readonly<Record<string, string>>;
-    readonly body: string;
+    readonly body?: string;
 };
 /** What the generated client's transport reads of a `fetch` answer. */
 export type UniversalAnswer = {

package/dist/universal-path.registry.js

@@ -1,5 +1,6 @@
 import { routeKey } from "./route-handlers.factory.js";
 export const UNIVERSAL_PATH_KEY = Symbol.for("aventara.next.universal");
+const IN_PROCESS = new AbortController().signal;
 function outsideApi(url, api) {
     return `Aventara: @/aventara/universal called ${url} on the server, which is not under the configured \`api\` path ${api === "" ? "/" : api}; run aventara-build --client again (npm run aventara:prepare).`;
 }
@@ -9,23 +10,41 @@ export function universalPath(host, state) {
         if (url !== api && !url.startsWith(`${api}/`)) {
             throw new Error(outsideApi(url, api));
         }
-        const path = url.slice(api.length);
+        const [path = "", query] = splitQuery(url.slice(api.length));
         const request = {
             method: init.method,
             path,
+            ...(query === undefined ? {} : { query }),
             headers: Object.fromEntries(new Headers(init.headers)),
-            body: { kind: "raw", content: init.body },
+            body: { kind: "raw", content: init.body ?? "" },
         };
         const answer = routes.get(routeKey(init.method, path));
         const response = answer === undefined
             ? binding.answerAbsent(request)
-            : await answer(request, state);
+            : await answer(request, state, IN_PROCESS);
         if (response === undefined) {
             throw new Error(outsideApi(url, api));
         }
-        return { status: response.status, text: async () => response.body };
+        const { body } = response;
+        return {
+            status: response.status,
+            text: async () => (typeof body === "string" ? body : await joined(body)),
+        };
     };
 }
+function splitQuery(url) {
+    const mark = url.indexOf("?");
+    return mark === -1
+        ? [url, undefined]
+        : [url.slice(0, mark), url.slice(mark + 1)];
+}
+async function joined(lines) {
+    let text = "";
+    for await (const line of lines) {
+        text += line;
+    }
+    return text;
+}
 const UNIVERSAL_ACCESS_KEY = Symbol.for("aventara.next.universal.access");
 export function registerUniversalPath(path, access) {
     const holder = globalThis;

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

@@ -1,5 +1,6 @@
-import type { AvProtocolRequest, AvProtocolResponse } from "@aventara/core/protocol";
+import type { AvProtocolRequest } from "@aventara/core/protocol";
 import type { McpRequest } from "./mcp-binding.loader.js";
+import type { RouteResponse } from "./protocol-route.table.js";
 /** Zero bytes: the body of a request whose body the protocol does not read. */
 export declare const NO_BYTES: Uint8Array<ArrayBuffer>;
 /**
@@ -7,9 +8,16 @@ export declare const NO_BYTES: Uint8Array<ArrayBuffer>;
  * nothing URL-decoded.
  */
 export declare function pathnameOf(request: Request): string;
-/** The request as the protocol reads it: path relative to the mount path, its headers, raw body. */
+/**
+ * The request as the protocol reads it: path relative to the mount path, raw
+ * query (rc.11: a cached read's `q` and `v`), its headers, raw body.
+ */
 export declare function protocolRequest(request: Request, path: string, content: Uint8Array): AvProtocolRequest;
 /** The request as `@aventara/mcp` reads it: absolute URL at the origin the caller used, its headers, raw body, no peer address. */
 export declare function mcpRequest(request: Request, content: Uint8Array): McpRequest;
-/** The protocol's answer as the route handler's `Response`: status, headers and body as they are. */
-export declare function webResponse(answer: AvProtocolResponse): Response;
+/**
+ * The protocol's answer as the route handler's `Response`: status, headers and
+ * body as they are. A streamed body (`/_all` under NDJSON) is a
+ * `ReadableStream` that pulls each line as core yields it.
+ */
+export declare function webResponse(answer: RouteResponse): Response;

package/dist/web-exchange.translator.js

@@ -6,6 +6,7 @@ export function protocolRequest(request, path, content) {
     return {
         method: request.method,
         path,
+        query: new URL(request.url).search.slice(1),
         headers: Object.fromEntries(request.headers),
         body: { kind: "raw", content },
     };
@@ -30,8 +31,31 @@ function calledUrl(request) {
     return `${scheme ?? url.protocol.slice(0, -1)}://${host ?? url.host}${url.pathname}${url.search}`;
 }
 export function webResponse(answer) {
+    if (typeof answer.body !== "string") {
+        return new Response(streamOf(answer.body), {
+            status: answer.status,
+            headers: answer.headers,
+        });
+    }
     return new Response(answer.body === "" ? null : answer.body, {
         status: answer.status,
         headers: answer.headers,
     });
 }
+function streamOf(lines) {
+    const iterator = lines[Symbol.asyncIterator]();
+    const encoder = new TextEncoder();
+    return new ReadableStream({
+        async pull(controller) {
+            const next = await iterator.next();
+            if (next.done === true) {
+                controller.close();
+                return;
+            }
+            controller.enqueue(encoder.encode(next.value));
+        },
+        async cancel() {
+            await iterator.return?.();
+        },
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aventara/next",
-  "version": "1.0.0-rc.10",
+  "version": "1.0.0-rc.12",
   "license": "SEE LICENSE IN LICENSE",
   "description": "Next.js App Router host integration for Aventara.",
   "type": "module",
@@ -22,11 +22,11 @@
     "CHANGELOG.md"
   ],
   "dependencies": {
-    "@aventara/core": "1.0.0-rc.10",
+    "@aventara/core": "1.0.0-rc.12",
     "server-only": "0.0.1"
   },
   "peerDependencies": {
-    "@aventara/mcp": "1.0.0-rc.10",
+    "@aventara/mcp": "1.0.0-rc.12",
     "next": ">=16.4 <17",
     "react": "^19.0.0"
   },
@@ -53,10 +53,10 @@
     "access": "public"
   },
   "devDependencies": {
-    "@aventara/build": "1.0.0-rc.10",
-    "@aventara/client": "1.0.0-rc.10",
-    "@aventara/mcp": "1.0.0-rc.10",
-    "@aventara/testing": "1.0.0-rc.10",
+    "@aventara/build": "1.0.0-rc.12",
+    "@aventara/client": "1.0.0-rc.12",
+    "@aventara/mcp": "1.0.0-rc.12",
+    "@aventara/testing": "1.0.0-rc.12",
     "@modelcontextprotocol/sdk": "1.32.2",
     "@tanstack/react-query": "5.104.2",
     "@types/react": "19.3.0",