@aventara/next 0.0.0-stage → 1.0.0-rc.10

package/dist/aventara.factory.d.ts

@@ -0,0 +1,155 @@
+import { type AvAdapter, type AvAdapterModel, type AvConfig, type AvConfigAny, type AvConfigExact, type AvFramework, type AvState, createFramework } from "@aventara/core";
+import { type AvNextHandlers, type AvNextStateContext } from "./route-handlers.factory.js";
+import { type AvNextAppTransaction, type AvNextClientTransaction } from "./server-operations.factory.js";
+/** `Aventara()`'s options: a configuration whose adapter may be built on first use, and `state`. */
+type AventaraOptions<M extends AvAdapterModel, Cfg> = Omit<AvConfig<M, Cfg>, "adapter"> & HostOptions<M>;
+/** The two host keys: an adapter that may be built on first use, and `state`. */
+type HostOptions<M extends AvAdapterModel> = {
+    /**
+     * The adapter, or a function that builds it (it may return a promise),
+     * called once, on the first request.
+     */
+    readonly adapter: AvAdapter<M> | (() => AvAdapter<M> | PromiseLike<AvAdapter<M>>);
+    /**
+     * Seeds a request's `ctx.$state`, once per request, from its headers and,
+     * on a route call, the route handler's request. A throw is answered like
+     * any developer failure: a thrown `AvError` as its own outcome, anything
+     * else as an internal failure. Omitted, the state is `{}`, or what the
+     * `access` provider's `state` seeds; not together with `access`.
+     */
+    state?(context: AvNextStateContext): AvState | Promise<AvState>;
+};
+/**
+ * On Next.js, `mcp` needs `authorization`: Next adds `x-forwarded-for` to
+ * every request, so an endpoint without it would refuse every caller. The
+ * expected type of an `mcp` written without it; `undefined` otherwise.
+ */
+type McpOnNext<Cfg> = Cfg extends {
+    readonly mcp: infer Endpoint;
+} ? [Endpoint] extends [undefined] ? undefined : string extends Endpoint ? undefined : Endpoint extends string ? {
+    readonly "On Next.js, `mcp` needs `authorization` ({ path, authorization: { servers, verify } }): Next.js adds x-forwarded-for to every request, so an MCP endpoint without it would refuse every caller.": true;
+} : "authorization" extends keyof Endpoint ? undefined : {
+    readonly "On Next.js, `mcp` needs `authorization` ({ path, authorization: { servers, verify } }): Next.js adds x-forwarded-for to every request, so an MCP endpoint without it would refuse every caller.": true;
+    readonly path?: unknown;
+} : undefined;
+/** `state` refused beside `access`, by the sentence that says why. */
+type StateBesideAccess<Cfg> = Cfg extends {
+    readonly access: object;
+} ? {
+    readonly state?: readonly [
+        "Error: `access` seeds each request's state; remove `state`"
+    ];
+} : unknown;
+/** The options as `createFramework` reads them: `state` taken out. */
+type ConfigOf<Cfg> = Cfg extends {
+    readonly state: (...context: never) => unknown;
+} ? Omit<Cfg, "state"> : Cfg;
+/** The Framework `Aventara()` builds from its options. */
+type HostedFramework<M extends AvAdapterModel, Cfg> = Awaited<ReturnType<typeof createFramework<M, ConfigOf<Cfg>>>>;
+/**
+ * `Aventara({ framework, state })`'s options: a Framework `createFramework`
+ * built, and `state`. A configuration key beside `framework` is refused.
+ */
+type FrameworkOptions = {
+    /** A Framework built elsewhere: what `createFramework` resolved to. */
+    readonly framework: AvFramework;
+    /** A configuration's: refused beside `framework`. */
+    readonly adapter?: never;
+    state?(context: AvNextStateContext): AvState | Promise<AvState>;
+};
+/** The Framework the options carry under `framework`, else the one they configure. */
+type GivenFramework<M extends AvAdapterModel, Cfg> = Cfg extends {
+    readonly framework: infer Given extends HostedMembers;
+} ? Given : HostedFramework<M, Cfg>;
+/** The four members of a Framework the host's members are typed from. */
+type HostedMembers = {
+    readonly serverClient: unknown;
+    readonly serverClientTx: unknown;
+    readonly application: unknown;
+    readonly appTx: unknown;
+};
+/** What `Aventara()` returns: the members over its Framework. */
+type AventaraHostOf<F extends HostedMembers> = {
+    /**
+     * `{ GET, POST, PUT, PATCH, DELETE }` for the catch-all route file under the
+     * configured `api` path: `export const { GET, POST, PUT, PATCH, DELETE } = handlers;`
+     */
+    readonly handlers: AvNextHandlers;
+    /**
+     * The client layer for Server Components and Server Actions:
+     * `avClient.<resource>.<family>.<variant>(args, options?)`, the Framework's
+     * `serverClient`. Arguments and results are application values (a `Date`,
+     * a `bigint`, an `AvDecimal`); what the client layer hides is absent; the
+     * policy checks the principal `state` gives, the `state` run once per
+     * request with the headers of `next/headers`. A direct call: no HTTP.
+     *
+     * `avClient.tx` builds client-layer transaction handles and
+     * `avClient.transaction([...])` runs them with the same state.
+     */
+    readonly avClient: F["serverClient"] & {
+        /**
+         * Transaction handles under the client layer's rules, taking application
+         * values: `avClient.tx.<resource>.<family>.<variant>(args)`. Built on the
+         * built Framework: after `await ready()`.
+         */
+        readonly tx: F["serverClientTx"];
+        /**
+         * Runs `avClient.tx` handles as one transaction with this request's
+         * state: `avClient.transaction([h1, h2, …], options?)`.
+         */
+        readonly transaction: AvNextClientTransaction;
+    };
+    /**
+     * The application layer, for trusted server code:
+     * `avApp.<resource>.<family>.<variant>(args, options?)`, the Framework's
+     * `application`. The policy checks a call only when it names a principal
+     * (`{ as }`).
+     *
+     * `avApp.appTx` builds application transaction handles and
+     * `avApp.transaction([...])` runs them.
+     */
+    readonly avApp: F["application"] & {
+        /**
+         * Transaction handles under the application layer's rules:
+         * `avApp.appTx.<resource>.<family>.<variant>(args)`, and `avApp.appTx.$sql`.
+         * Built on the built Framework: after `await ready()`.
+         */
+        readonly appTx: F["appTx"];
+        /**
+         * Runs `avApp.appTx` handles as one transaction:
+         * `avApp.transaction([h1, h2, …], options?)`.
+         */
+        readonly transaction: AvNextAppTransaction;
+    };
+    /**
+     * Builds the Framework and its routes, once; rejects with the construction
+     * error. `src/instrumentation.ts` awaits it at startup, so a bad
+     * configuration fails `next start`. Reads no request: it runs outside one.
+     * Once built, it registers the in-process path `@/aventara/universal`'s
+     * `avClient` calls on the server, with each request's state.
+     */
+    readonly ready: () => Promise<void>;
+};
+/**
+ * Hosts an Aventara Framework in a Next.js App Router application. Returns at
+ * once and builds nothing: the Framework is created on first use, or by
+ * `ready()`, once.
+ *
+ * ```ts
+ * export const { handlers, avClient, avApp, ready } = Aventara({
+ *   ...aventaraConfig,
+ *   adapter: () => createPrismaAdapter({ ...adapter, client: prisma }),
+ *   state: async ({ headers }) => ({ user: await userOf(headers) }),
+ * });
+ * ```
+ *
+ * Or a Framework built elsewhere, as `createFramework` resolved it (with
+ * `state` beside it, and no configuration key):
+ * `Aventara({ framework, state })`.
+ */
+export declare function Aventara<M extends AvAdapterModel, const Cfg = AvConfigAny>(options: Cfg extends {
+    readonly framework: object;
+} ? FrameworkOptions : McpOnNext<Cfg> extends object ? Omit<Cfg, "mcp"> & HostOptions<M> & {
+    readonly mcp: McpOnNext<Cfg>;
+} & StateBesideAccess<Cfg> : Cfg & AvConfigExact<M, ConfigOf<Cfg>> & AventaraOptions<M, ConfigOf<Cfg>> & StateBesideAccess<Cfg>): AventaraHostOf<GivenFramework<M, Cfg>>;
+export {};

package/dist/aventara.factory.js

@@ -0,0 +1,61 @@
+import { createFramework, } from "@aventara/core";
+import { checkedOptions } from "./host-bootstrap.validator.js";
+import { loadMcpBinding } from "./mcp-binding.loader.js";
+import { createRequestState } from "./request-state.cache.js";
+import { bindProtocolHost, createRouteHandlers, } from "./route-handlers.factory.js";
+import { createServerOperations, refuseMemberClashes, } from "./server-operations.factory.js";
+import { frameworkSlot, optionsFingerprint, } from "./shared-framework.registry.js";
+import { registerUniversalPath, universalPath, } from "./universal-path.registry.js";
+export function Aventara(options) {
+    const checked = checkedOptions(options);
+    const { source } = checked;
+    const slot = source.kind === "config"
+        ? frameworkSlot(String(options.api), optionsFingerprint(options), optionsFingerprint(options, "source"))
+        : { fingerprint: "", framework: undefined, built: undefined };
+    const held = (created) => {
+        refuseMemberClashes(created);
+        slot.built = created;
+        return created;
+    };
+    if (source.kind === "framework") {
+        try {
+            slot.framework = Promise.resolve(held(source.framework));
+        }
+        catch (error) {
+            slot.framework = Promise.reject(error);
+            slot.framework.catch(() => undefined);
+        }
+    }
+    const frameworkOf = () => {
+        slot.framework ??=
+            source.kind === "config"
+                ? source
+                    .config()
+                    .then((config) => createFramework(config))
+                    .then(held)
+                : Promise.resolve(held(source.framework));
+        return slot.framework;
+    };
+    let protocol;
+    const protocolOf = () => {
+        protocol ??= frameworkOf().then(async (built) => bindProtocolHost(built, await loadMcpBinding(built)));
+        return protocol;
+    };
+    let readied;
+    const requestState = createRequestState(checked.state);
+    const universalState = checked.state === undefined
+        ? undefined
+        : async () => (await requestState()) ?? {};
+    const { avClient, avApp } = createServerOperations({ built: frameworkOf, current: () => slot.built }, requestState, checked.access);
+    return {
+        handlers: createRouteHandlers(protocolOf, checked.state),
+        avClient,
+        avApp,
+        ready: () => {
+            readied ??= protocolOf().then(() => {
+                registerUniversalPath(universalPath(protocolOf, universalState), avClient.$access);
+            });
+            return readied;
+        },
+    };
+}

package/dist/host-bootstrap.validator.d.ts

@@ -0,0 +1,49 @@
+import type { AvAccessProvider, AvConfigAny, AvFramework } from "@aventara/core";
+import type { HostState } from "./route-handlers.factory.js";
+/**
+ * Refuses an MCP endpoint without `authorization`: on Next.js it could answer
+ * no caller. Checked when the Framework is built, on its resolved `mcp`.
+ */
+export declare function refuseOpenMcp(endpoint: {
+    readonly authorization?: unknown;
+}): void;
+/** The options, split into what the host keeps and where its Framework comes from. */
+type CheckedOptions = {
+    /**
+     * What seeds each request's state: the developer's `state`, or the
+     * Framework's access provider's (`access`). Core never sees it.
+     */
+    readonly state: HostState | undefined;
+    /** The Framework's source: one built elsewhere, or a configuration this host builds. */
+    readonly source: FrameworkSourceOption;
+    /**
+     * The Framework's access provider's `client`, known before the Framework
+     * is built (`null` for a provider without one), or `undefined` with no
+     * `access`: which verbs `avClient.$access` holds.
+     */
+    readonly access: AccessClient | undefined;
+};
+/** What `avClient.$access` reads of an access provider: its `client`, or `null`. */
+export type AccessClient = {
+    readonly client: AvAccessProvider["client"] | null;
+};
+/** `{ framework }`: a Framework `createFramework` built; or a configuration for it. */
+type FrameworkSourceOption = {
+    readonly kind: "framework";
+    readonly framework: AvFramework;
+} | {
+    readonly kind: "config";
+    /**
+     * The configuration without `state`, and with `adapter` resolved: built
+     * on this call when it was given as a function.
+     */
+    readonly config: () => Promise<AvConfigAny>;
+};
+/**
+ * The options as given, split: `state` taken out, and either the given
+ * Framework, or the configuration with a function `adapter` deferred to first
+ * use, since core refuses a root key it does not know and a function in place
+ * of an adapter.
+ */
+export declare function checkedOptions(options: unknown): CheckedOptions;
+export {};

package/dist/host-bootstrap.validator.js

@@ -0,0 +1,73 @@
+import { accessProviderOf } from "@aventara/core/internal";
+const NOT_AN_OBJECT = "Aventara: the options are not an object; pass `{ ...aventaraConfig, adapter, state }`, or `{ framework, state }`.";
+const NOT_A_FRAMEWORK = "Aventara: `framework` is not an Aventara Framework (it has no string `api` and no `contracts.client`); pass what `createFramework` resolved to.";
+function bothForms(keys) {
+    return `Aventara: the options carry both \`framework\` and configuration keys (${keys.map((key) => `\`${key}\``).join(", ")}); pass \`{ framework, state }\` or \`{ ...aventaraConfig, adapter, state }\`, not both.`;
+}
+const STATE_BESIDE_ACCESS = "Aventara: the options carry both `access` and `state`; `access` seeds each request's state, so remove `state`.";
+const STATE_NOT_A_FUNCTION = "Aventara: `state` is not a function; pass `({ headers, request }) => ({ … })`, called once per request.";
+const MCP_WITHOUT_AUTHORIZATION = "Aventara: `mcp` on Next.js needs `authorization` (`mcp: { path, authorization: { servers, verify } }`). Without it the MCP endpoint answers only loopback callers that send no `x-forwarded-for`, and Next.js adds `x-forwarded-for` to every request, so every caller would be refused.";
+export function refuseOpenMcp(endpoint) {
+    if (endpoint.authorization === undefined) {
+        throw new Error(MCP_WITHOUT_AUTHORIZATION);
+    }
+}
+export function checkedOptions(options) {
+    if (typeof options !== "object" || options === null) {
+        throw new Error(NOT_AN_OBJECT);
+    }
+    const { state, ...config } = options;
+    if (state !== undefined && typeof state !== "function") {
+        throw new Error(STATE_NOT_A_FUNCTION);
+    }
+    const boundState = state === undefined
+        ? undefined
+        : state.bind(options);
+    const { framework, ...rest } = config;
+    if (framework !== undefined) {
+        const configured = Object.entries(rest)
+            .filter(([, value]) => value !== undefined)
+            .map(([key]) => key);
+        if (configured.length > 0) {
+            throw new Error(bothForms(configured));
+        }
+        if (!isFramework(framework)) {
+            throw new Error(NOT_A_FRAMEWORK);
+        }
+        const provider = accessProviderOf(framework);
+        return {
+            state: oneStateSeed(boundState, provider?.state),
+            source: { kind: "framework", framework },
+            access: provider === undefined
+                ? undefined
+                : { client: provider.client ?? null },
+        };
+    }
+    const access = config.access;
+    const adapter = config.adapter;
+    return {
+        state: oneStateSeed(boundState, access === undefined ? undefined : (context) => access.state(context)),
+        source: {
+            kind: "config",
+            config: async () => typeof adapter === "function"
+                ? { ...config, adapter: await adapter() }
+                : config,
+        },
+        access: access === undefined ? undefined : { client: access.client ?? null },
+    };
+}
+function oneStateSeed(state, access) {
+    if (state !== undefined && access !== undefined) {
+        throw new Error(STATE_BESIDE_ACCESS);
+    }
+    return state ?? access;
+}
+function isFramework(value) {
+    if (typeof value !== "object" || value === null) {
+        return false;
+    }
+    const candidate = value;
+    return (typeof candidate.api === "string" &&
+        typeof candidate.contracts?.client === "object" &&
+        candidate.contracts.client !== null);
+}

package/dist/hydration-tag.format.d.ts

@@ -0,0 +1,11 @@
+/** The tagged form a dehydrated value takes: `{ [tagKey]: <tag>, [valueKey]: <wire form> }`. */
+export declare const HYDRATION_FORMAT: {
+    /** The key a tag is under. */
+    readonly tagKey: "$av";
+    /** The key the tagged value's wire form is under. */
+    readonly valueKey: "v";
+    /** The tag of a plain object that holds `tagKey` as data. */
+    readonly objectTag: "object";
+    /** The scalars a value is tagged as: those whose runtime values JSON does not carry. */
+    readonly scalarTags: readonly ["bigint", "bytes", "datetime", "decimal"];
+};

package/dist/hydration-tag.format.js

@@ -0,0 +1,6 @@
+export const HYDRATION_FORMAT = {
+    tagKey: "$av",
+    valueKey: "v",
+    objectTag: "object",
+    scalarTags: ["bigint", "bytes", "datetime", "decimal"],
+};

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+import "server-only";
+export { Aventara } from "./aventara.factory.js";
+export type { AvNextHandlers, AvNextStateContext, } from "./route-handlers.factory.js";
+export type { AvNextAppTransaction, AvNextClientTransaction, } from "./server-operations.factory.js";
+export { avDehydrate } from "./value.dehydrator.js";

package/dist/index.js

@@ -0,0 +1,3 @@
+import "server-only";
+export { Aventara } from "./aventara.factory.js";
+export { avDehydrate } from "./value.dehydrator.js";

package/dist/mcp-binding.loader.d.ts

@@ -0,0 +1,33 @@
+import type { AvFramework, AvState } from "@aventara/core";
+import type { AvProtocolResponse } from "@aventara/core/protocol";
+/** One request to the MCP endpoint or its metadata, as `@aventara/mcp` reads it. */
+export type McpRequest = {
+    readonly method: string;
+    /** The request's absolute URL: the OAuth metadata names the endpoint by its origin. */
+    readonly url: string;
+    readonly headers: Readonly<Record<string, string>>;
+    readonly body: Uint8Array;
+    /** A route handler never sees the socket. */
+    readonly remoteAddress: undefined;
+};
+/** One route the MCP binding lists. */
+export type McpRoute = {
+    readonly kind: "endpoint" | "metadata";
+    readonly path: string;
+    readonly methods: readonly ("GET" | "POST" | "DELETE")[];
+};
+export type McpBinding = {
+    readonly surface: () => readonly McpRoute[];
+    readonly maxRequestBytes: number;
+    readonly handleEndpoint: (request: McpRequest, options?: {
+        readonly state?: () => AvState | Promise<AvState>;
+    }) => Promise<AvProtocolResponse>;
+    readonly encodeMetadata: (request: McpRequest) => AvProtocolResponse;
+};
+/**
+ * The MCP binding for `framework`, or `undefined` when its configuration has no
+ * `mcp`. Called once, when the Framework is built: an `mcp` without
+ * `authorization`, or a missing `@aventara/mcp`, rejects that build with a
+ * fixed sentence.
+ */
+export declare function loadMcpBinding(framework: AvFramework, specifier?: string): Promise<McpBinding | undefined>;

package/dist/mcp-binding.loader.js

@@ -0,0 +1,39 @@
+import { refuseOpenMcp } from "./host-bootstrap.validator.js";
+const MCP_PACKAGE = "@aventara/mcp";
+const missing = (specifier, coreVersion) => `Aventara: the configuration has \`mcp\`, and the package that serves it, ${specifier}, is not installed. Install it at @aventara/core's exact version (npm install --save-exact ${specifier}@${coreVersion ?? "<your @aventara/core version>"}), or remove \`mcp\` from the configuration.`;
+async function installedCoreVersion() {
+    try {
+        const manifest = new URL("../package.json", import.meta.resolve("@aventara/core"));
+        const { default: read } = (await import(manifest.href, { with: { type: "json" } }));
+        return read.name === "@aventara/core" && typeof read.version === "string"
+            ? read.version
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function isMissing(error, specifier) {
+    const { code, message } = (error ?? {});
+    return ((code === "ERR_MODULE_NOT_FOUND" || code === "MODULE_NOT_FOUND") &&
+        typeof message === "string" &&
+        message.includes(`'${specifier}'`));
+}
+export async function loadMcpBinding(framework, specifier = MCP_PACKAGE) {
+    if (framework.mcp === undefined) {
+        return undefined;
+    }
+    refuseOpenMcp(framework.mcp);
+    let loaded;
+    try {
+        loaded = await import(specifier);
+    }
+    catch (error) {
+        if (isMissing(error, specifier)) {
+            throw new Error(missing(specifier, await installedCoreVersion()));
+        }
+        throw error;
+    }
+    const { AvMcp } = loaded;
+    return AvMcp.bind(framework);
+}

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

@@ -0,0 +1,21 @@
+import type { AvState } from "@aventara/core";
+import type { AvProtocolBinding, AvProtocolRequest, AvProtocolResponse } from "@aventara/core/protocol";
+import type { McpBinding, McpRequest, McpRoute } from "./mcp-binding.loader.js";
+/** One route `protocol.surface()` lists. */
+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>;
+/** What a route answers its request with: a bound protocol member. */
+export type RouteAnswer = (request: AvProtocolRequest, state: StateSeed | undefined) => AvProtocolResponse | Promise<AvProtocolResponse>;
+/** The bound member each kind of surface route is answered by. */
+type ProtocolRouteTable = {
+    readonly [K in SurfaceRoute["kind"]]: (binding: AvProtocolBinding) => RouteAnswer;
+};
+export declare const PROTOCOL_ROUTES: ProtocolRouteTable;
+/** What an MCP route answers its request with: a bound `@aventara/mcp` member. */
+export type McpRouteAnswer = (request: McpRequest, state: StateSeed | undefined) => AvProtocolResponse | Promise<AvProtocolResponse>;
+/** The bound `@aventara/mcp` member each kind of MCP route is answered by. */
+export declare const MCP_ROUTES: {
+    readonly [K in McpRoute["kind"]]: (binding: McpBinding) => McpRouteAnswer;
+};
+export {};

package/dist/protocol-route.table.js

@@ -0,0 +1,10 @@
+export const PROTOCOL_ROUTES = {
+    operation: (binding) => (request, state) => binding.handleOperation(request, state === undefined ? {} : { state }),
+    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 }),
+};
+export const MCP_ROUTES = {
+    endpoint: (binding) => (request, state) => binding.handleEndpoint(request, state === undefined ? {} : { state }),
+    metadata: (binding) => (request) => binding.encodeMetadata(request),
+};

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

@@ -0,0 +1,35 @@
+import type { AvProtocolBinding, AvProtocolResponse } from "@aventara/core/protocol";
+/**
+ * What the body reader hands on: the stored bytes, an unsupported coding, or a
+ * body that does not decode in the coding it names.
+ */
+type RequestBodyRead = {
+    readonly kind: "read";
+    readonly content: Uint8Array;
+} | {
+    readonly kind: "unsupported-coding";
+} | {
+    readonly kind: "undecodable";
+};
+/**
+ * The answer to a body the reader could not hand on, through the bound
+ * `failure` member: an unsupported coding is the protocol's `A2011`; a body
+ * that does not decode in its coding is malformed, `A2000`.
+ */
+export declare function unreadBodyAnswer(binding: AvProtocolBinding, read: Exclude<RequestBodyRead, {
+    readonly kind: "read";
+}>): AvProtocolResponse;
+/**
+ * Reads `request`'s body to its end. Its `Content-Encoding` absent, empty or
+ * `identity` is no coding; one of `gzip`, `deflate`, `br` (any case) is
+ * inflated; anything else, a stacked coding included, is unsupported. A body
+ * that does not decode in the coding it names is undecodable. Either way the
+ * stream is still read to its end.
+ */
+export declare function readRequestBody(request: Request, cap: number): Promise<RequestBodyRead>;
+/** Reads `request`'s body to its end, storing its bytes as sent, up to `cap + 1`. */
+export declare function readRawBody(request: Request, cap: number): Promise<{
+    readonly kind: "read";
+    readonly content: Uint8Array;
+}>;
+export {};

package/dist/request-body.reader.js

@@ -0,0 +1,130 @@
+export function unreadBodyAnswer(binding, read) {
+    return read.kind === "unsupported-coding"
+        ? binding.failure("A2011")
+        : binding.failure("A2000");
+}
+const INFLATERS = {
+    gzip: (zlib) => zlib.createGunzip(),
+    deflate: (zlib) => zlib.createInflate(),
+    br: (zlib) => zlib.createBrotliDecompress(),
+};
+let zlibModule;
+const zlib = () => {
+    const specifier = "node:zlib";
+    zlibModule ??= import(specifier);
+    return zlibModule;
+};
+async function* chunksOf(body) {
+    if (body === null) {
+        return;
+    }
+    const reader = body.getReader();
+    try {
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done) {
+                return;
+            }
+            yield value;
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+}
+export async function readRequestBody(request, cap) {
+    const source = chunksOf(request.body);
+    const coding = codingOf(request.headers.get("content-encoding"));
+    if (coding === undefined) {
+        for await (const _ of source) {
+        }
+        return { kind: "unsupported-coding" };
+    }
+    if (coding === "identity") {
+        return storedUpTo(source, cap);
+    }
+    const stored = boundedStore(cap + 1);
+    const inflater = INFLATERS[coding](await zlib());
+    const inflated = (async () => {
+        for await (const chunk of inflater) {
+            if (!stored.add(chunk)) {
+                inflater.destroy();
+                return;
+            }
+        }
+    })();
+    const stopped = inflated.then(() => undefined, () => undefined);
+    for await (const chunk of source) {
+        if (!inflater.destroyed) {
+            await Promise.race([
+                new Promise((written) => {
+                    inflater.write(chunk, () => written());
+                }),
+                stopped,
+            ]);
+        }
+    }
+    if (!inflater.destroyed) {
+        inflater.end();
+    }
+    try {
+        await inflated;
+    }
+    catch {
+        return { kind: "undecodable" };
+    }
+    return { kind: "read", content: stored.content() };
+}
+export function readRawBody(request, cap) {
+    return storedUpTo(chunksOf(request.body), cap);
+}
+async function storedUpTo(source, cap) {
+    const stored = boundedStore(cap + 1);
+    for await (const chunk of source) {
+        stored.add(chunk);
+    }
+    return { kind: "read", content: stored.content() };
+}
+function codingOf(contentEncoding) {
+    const named = (contentEncoding ?? "")
+        .split(",")
+        .map((token) => token.trim().toLowerCase())
+        .filter((token) => token !== "");
+    if (named.length === 0) {
+        return "identity";
+    }
+    if (named.length > 1) {
+        return undefined;
+    }
+    const [only] = named;
+    return only === "identity" ||
+        only === "gzip" ||
+        only === "deflate" ||
+        only === "br"
+        ? only
+        : undefined;
+}
+function boundedStore(limit) {
+    const chunks = [];
+    let size = 0;
+    return {
+        add(chunk) {
+            const room = limit - size;
+            if (room > 0) {
+                const kept = chunk.byteLength <= room ? chunk : chunk.subarray(0, room);
+                chunks.push(kept);
+                size += kept.byteLength;
+            }
+            return size < limit;
+        },
+        content() {
+            const bytes = new Uint8Array(size);
+            let offset = 0;
+            for (const chunk of chunks) {
+                bytes.set(chunk, offset);
+                offset += chunk.byteLength;
+            }
+            return bytes;
+        },
+    };
+}

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

@@ -0,0 +1,9 @@
+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.
+ */
+export declare function createRequestState(state: HostState | undefined): () => Promise<AvState | undefined>;

package/dist/request-state.cache.js

@@ -0,0 +1,8 @@
+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() }));
+}