@aventara/core 1.0.0-rc.0 → 1.0.0-rc.10

package/dist/framework/operation-facade.d.ts

@@ -1,72 +1,204 @@
-import type { AdapterModel } from "../adapters/adapter-model.js";
-import type { Contract } from "../contracts/contract.js";
-import type { ApplicationScalarForms, WireScalarForms } from "../contracts/scalar-value-type.js";
-import type { ResourceKey } from "../operations/operation-arguments.js";
-import type { DeferredOperationCall, OperationCall, OperationGrammar } from "../operations/operation-call.js";
-import type { OperationIdentity } from "../operations/operation-identity.js";
-import type { ExecutionOptions } from "../runtime/execution-options.js";
-import type { FrameworkOperationRequest } from "../runtime/operation-request.js";
-import type { OperationResponse } from "../runtime/operation-response.js";
-import type { ApplicationContractView, ClientContractView } from "./contract-view.js";
-/**
- * A model whose Resource names are not literal — the abstract `AdapterModel` behind
- * the default `Framework` — has no Contract to type a call against, so a surface over
+import type { AvAdapterModel } from "../adapters/adapter-model.js";
+import type { AvContract } from "../contracts/contract.js";
+import type { AvApplicationScalarForms, AvWireScalarForms } from "../contracts/scalar-value-type.js";
+import type { AvOperationArgumentsFor, AvResourceKey } from "../operations/operation-arguments.js";
+import type { AvOperationCall, AvOperationGrammar, DeferredArguments, DeferredPlainCall, DeferredProjectingCall, PlainCall, ProjectingCall } from "../operations/operation-call.js";
+import type { AvOperationIdentity } from "../operations/operation-identity.js";
+import { type PolicyCaller } from "../policy/policy-request.js";
+import type { AvExecutionOptions } from "../runtime/execution-options.js";
+import type { AvOperationRequest } from "../runtime/operation-request.js";
+import type { AvOperationResponse } from "../runtime/operation-response.js";
+import type { AvState } from "../runtime/request-state.js";
+import type { AvSqlStatementBuilder } from "../transactions/sql-statement.js";
+import type { AvTransactionResponse } from "../transactions/transaction-response.js";
+import type { AccessProviderOf, ServerClientAccess } from "./access-facade.js";
+import type { AvContractApplicationView, ClientContractView } from "./contract-view.js";
+/**
+ * A model whose Resource names are not literal — the abstract `AvAdapterModel` behind
+ * the default `AvFramework` — has no Contract to type a call against, so a surface over
  * it is typed as the opaque object it is, and such a caller uses `execute`.
  */
 type OpaqueSurface = {
     readonly [resource: string]: unknown;
 };
+/** The typed surfaces of an `AvFramework`, named by the member that holds each. */
+type FacadeSurface = "application" | "client" | "serverClient" | "appTx" | "clientTx" | "serverClientTx";
+/** `framework.application.<Resource>.<family>.<variant>` when the variant takes a `select` or `include`. */
+export type AvApplicationProjectingCall<in out C extends AvContract, in out R extends AvResourceKey<C>, in out I extends AvOperationIdentity> = ProjectingCall<C, R, I, AvOperationArgumentsFor<C, R, I, AvApplicationScalarForms>, AvApplicationScalarForms, AvExecutionOptions>;
+/** `framework.application.<Resource>.<family>.<variant>` when it does not (the `count` variants). */
+export type AvApplicationPlainCall<in out C extends AvContract, in out R extends AvResourceKey<C>, in out I extends AvOperationIdentity> = PlainCall<C, R, I, AvOperationArgumentsFor<C, R, I, AvApplicationScalarForms>, AvApplicationScalarForms, AvExecutionOptions>;
+/** `framework.client.<Resource>.<family>.<variant>` when the variant takes a `select` or `include`: wire forms in. */
+export type AvClientProjectingCall<in out C extends AvContract, in out R extends AvResourceKey<C>, in out I extends AvOperationIdentity> = ProjectingCall<C, R, I, AvOperationArgumentsFor<C, R, I, AvWireScalarForms>, AvApplicationScalarForms, AvExecutionOptions>;
+/** `framework.client.<Resource>.<family>.<variant>` when it does not. */
+export type AvClientPlainCall<in out C extends AvContract, in out R extends AvResourceKey<C>, in out I extends AvOperationIdentity> = PlainCall<C, R, I, AvOperationArgumentsFor<C, R, I, AvWireScalarForms>, AvApplicationScalarForms, AvExecutionOptions>;
+/** `framework.appTx.<Resource>.<family>.<variant>` when the variant takes a `select` or `include`. */
+export type AvAppTxProjectingCall<in out C extends AvContract, in out R extends AvResourceKey<C>, in out I extends AvOperationIdentity> = DeferredProjectingCall<C, R, I, DeferredArguments<C, R, I, AvApplicationScalarForms, AvApplicationScalarForms>, AvApplicationScalarForms, "application">;
+/** `framework.appTx.<Resource>.<family>.<variant>` when it does not. */
+export type AvAppTxPlainCall<in out C extends AvContract, in out R extends AvResourceKey<C>, in out I extends AvOperationIdentity> = DeferredPlainCall<C, R, I, DeferredArguments<C, R, I, AvApplicationScalarForms, AvApplicationScalarForms>, AvApplicationScalarForms, "application">;
+/** `framework.clientTx.<Resource>.<family>.<variant>` when the variant takes a `select` or `include`: wire forms in. */
+export type AvClientTxProjectingCall<in out C extends AvContract, in out R extends AvResourceKey<C>, in out I extends AvOperationIdentity> = DeferredProjectingCall<C, R, I, DeferredArguments<C, R, I, AvWireScalarForms, AvApplicationScalarForms>, AvApplicationScalarForms, "client">;
+/** `framework.clientTx.<Resource>.<family>.<variant>` when it does not. */
+export type AvClientTxPlainCall<in out C extends AvContract, in out R extends AvResourceKey<C>, in out I extends AvOperationIdentity> = DeferredPlainCall<C, R, I, DeferredArguments<C, R, I, AvWireScalarForms, AvApplicationScalarForms>, AvApplicationScalarForms, "client">;
 /**
- * `framework.application`: one call per operation the Application Contract's
- * view advertises, its arguments in the application forms.
+ * `framework.serverClient.<Resource>.<family>.<variant>` when the variant takes a `select` or `include`:
+ * the Client Contract's view, application forms in.
  */
-export type ApplicationOperations<M extends AdapterModel, Cfg> = ApplicationFacade<ApplicationContractView<M, Cfg>>;
-type ApplicationFacade<C> = C extends Contract ? string extends ResourceKey<C> ? OpaqueSurface : {
-    readonly [R in ResourceKey<C>]: {
-        readonly [F in keyof OperationGrammar<C>[R]]: {
-            readonly [V in keyof OperationGrammar<C>[R][F]]: OperationCall<C, R, OperationGrammar<C>[R][F][V] & OperationIdentity, ApplicationScalarForms, ApplicationScalarForms, "response", ExecutionOptions>;
-        };
-    };
-} : never;
+export type AvServerClientProjectingCall<in out C extends AvContract, in out R extends AvResourceKey<C>, in out I extends AvOperationIdentity> = ProjectingCall<C, R, I, AvOperationArgumentsFor<C, R, I, AvApplicationScalarForms>, AvApplicationScalarForms, AvExecutionOptions>;
+/** `framework.serverClient.<Resource>.<family>.<variant>` when it does not. */
+export type AvServerClientPlainCall<in out C extends AvContract, in out R extends AvResourceKey<C>, in out I extends AvOperationIdentity> = PlainCall<C, R, I, AvOperationArgumentsFor<C, R, I, AvApplicationScalarForms>, AvApplicationScalarForms, AvExecutionOptions>;
 /**
- * `framework.client`: the same over the Client Contract's view, its arguments in
- * the wire forms.
+ * `framework.serverClientTx.<Resource>.<family>.<variant>` when the variant takes a `select` or `include`:
+ * the Client Contract's view, application forms in, a client-origin handle out.
  */
-export type ClientOperations<M extends AdapterModel, Cfg> = ClientFacade<ClientContractView<M, Cfg>>;
-type ClientFacade<C> = C extends Contract ? string extends ResourceKey<C> ? OpaqueSurface : {
-    readonly [R in ResourceKey<C>]: {
-        readonly [F in keyof OperationGrammar<C>[R]]: {
-            readonly [V in keyof OperationGrammar<C>[R][F]]: OperationCall<C, R, OperationGrammar<C>[R][F][V] & OperationIdentity, WireScalarForms, ApplicationScalarForms, "response", ExecutionOptions>;
-        };
-    };
-} : never;
+export type AvServerClientTxProjectingCall<in out C extends AvContract, in out R extends AvResourceKey<C>, in out I extends AvOperationIdentity> = DeferredProjectingCall<C, R, I, DeferredArguments<C, R, I, AvApplicationScalarForms, AvApplicationScalarForms>, AvApplicationScalarForms, "client">;
+/** `framework.serverClientTx.<Resource>.<family>.<variant>` when it does not. */
+export type AvServerClientTxPlainCall<in out C extends AvContract, in out R extends AvResourceKey<C>, in out I extends AvOperationIdentity> = DeferredPlainCall<C, R, I, DeferredArguments<C, R, I, AvApplicationScalarForms, AvApplicationScalarForms>, AvApplicationScalarForms, "client">;
+/**
+ * One variant on a surface: a direct call (application or wire forms), or a
+ * deferred one for a transaction (`appTx`, `clientTx`, `serverClientTx`),
+ * projecting when its arguments carry a `select` (as `AvOperationCall` and
+ * `AvDeferredOperationCall` decide it). `serverClient` and `serverClientTx` take
+ * the application forms over the Client Contract's view.
+ */
+type SurfaceCall<C extends AvContract, R extends AvResourceKey<C>, I extends AvOperationIdentity, S extends FacadeSurface> = S extends "application" ? "select" extends keyof AvOperationArgumentsFor<C, R, I, AvApplicationScalarForms> ? AvApplicationProjectingCall<C, R, I> : AvApplicationPlainCall<C, R, I> : S extends "client" ? "select" extends keyof AvOperationArgumentsFor<C, R, I, AvWireScalarForms> ? AvClientProjectingCall<C, R, I> : AvClientPlainCall<C, R, I> : S extends "serverClient" ? "select" extends keyof AvOperationArgumentsFor<C, R, I, AvApplicationScalarForms> ? AvServerClientProjectingCall<C, R, I> : AvServerClientPlainCall<C, R, I> : S extends "appTx" ? "select" extends keyof DeferredArguments<C, R, I, AvApplicationScalarForms, AvApplicationScalarForms> ? AvAppTxProjectingCall<C, R, I> : AvAppTxPlainCall<C, R, I> : S extends "clientTx" ? "select" extends keyof DeferredArguments<C, R, I, AvWireScalarForms, AvApplicationScalarForms> ? AvClientTxProjectingCall<C, R, I> : AvClientTxPlainCall<C, R, I> : "select" extends keyof DeferredArguments<C, R, I, AvApplicationScalarForms, AvApplicationScalarForms> ? AvServerClientTxProjectingCall<C, R, I> : AvServerClientTxPlainCall<C, R, I>;
+/** The families view `C` advertises on Resource `R`. */
+type FamilyKey<C extends AvContract, R extends AvResourceKey<C>> = keyof AvOperationGrammar<C>[R];
+/** One family node of surface `S`; the public names below are its four instances. */
+type FamilyNode<C extends AvContract, S extends FacadeSurface, R extends AvResourceKey<C>, F extends FamilyKey<C, R>> = {
+    readonly [V in keyof AvOperationGrammar<C>[R][F]]: SurfaceCall<C, R, AvOperationGrammar<C>[R][F][V] & AvOperationIdentity, S>;
+};
+/** `framework.application.<Resource>.<family>`: one direct call per variant, application forms. */
+export type AvApplicationFamilyFacade<in out C extends AvContract, in out R extends AvResourceKey<C>, in out F extends FamilyKey<C, R>> = FamilyNode<C, "application", R, F>;
+/** `framework.client.<Resource>.<family>`: one direct call per variant, wire forms. */
+export type AvClientFamilyFacade<in out C extends AvContract, in out R extends AvResourceKey<C>, in out F extends FamilyKey<C, R>> = FamilyNode<C, "client", R, F>;
+/** `framework.serverClient.<Resource>.<family>`: one direct call per variant, application forms. */
+export type AvServerClientFamilyFacade<in out C extends AvContract, in out R extends AvResourceKey<C>, in out F extends FamilyKey<C, R>> = FamilyNode<C, "serverClient", R, F>;
+/** `framework.appTx.<Resource>.<family>`: one deferred operation per variant. */
+export type AvAppTxFamilyFacade<in out C extends AvContract, in out R extends AvResourceKey<C>, in out F extends FamilyKey<C, R>> = FamilyNode<C, "appTx", R, F>;
+/** `framework.clientTx.<Resource>.<family>`: one deferred operation per variant. */
+export type AvClientTxFamilyFacade<in out C extends AvContract, in out R extends AvResourceKey<C>, in out F extends FamilyKey<C, R>> = FamilyNode<C, "clientTx", R, F>;
+/** `framework.serverClientTx.<Resource>.<family>`: one deferred operation per variant, application forms. */
+export type AvServerClientTxFamilyFacade<in out C extends AvContract, in out R extends AvResourceKey<C>, in out F extends FamilyKey<C, R>> = FamilyNode<C, "serverClientTx", R, F>;
+/** `framework.application.<Resource>`: one {@link AvApplicationFamilyFacade} per family. */
+export type AvApplicationResourceFacade<in out C extends AvContract, in out R extends AvResourceKey<C>> = {
+    readonly [F in FamilyKey<C, R>]: AvApplicationFamilyFacade<C, R, F>;
+};
+/** `framework.client.<Resource>`: one {@link AvClientFamilyFacade} per family. */
+export type AvClientResourceFacade<in out C extends AvContract, in out R extends AvResourceKey<C>> = {
+    readonly [F in FamilyKey<C, R>]: AvClientFamilyFacade<C, R, F>;
+};
+/** `framework.serverClient.<Resource>`: one {@link AvServerClientFamilyFacade} per family. */
+export type AvServerClientResourceFacade<in out C extends AvContract, in out R extends AvResourceKey<C>> = {
+    readonly [F in FamilyKey<C, R>]: AvServerClientFamilyFacade<C, R, F>;
+};
+/** `framework.appTx.<Resource>`: one {@link AvAppTxFamilyFacade} per family. */
+export type AvAppTxResourceFacade<in out C extends AvContract, in out R extends AvResourceKey<C>> = {
+    readonly [F in FamilyKey<C, R>]: AvAppTxFamilyFacade<C, R, F>;
+};
+/** `framework.clientTx.<Resource>`: one {@link AvClientTxFamilyFacade} per family. */
+export type AvClientTxResourceFacade<in out C extends AvContract, in out R extends AvResourceKey<C>> = {
+    readonly [F in FamilyKey<C, R>]: AvClientTxFamilyFacade<C, R, F>;
+};
+/** `framework.serverClientTx.<Resource>`: one {@link AvServerClientTxFamilyFacade} per family. */
+export type AvServerClientTxResourceFacade<in out C extends AvContract, in out R extends AvResourceKey<C>> = {
+    readonly [F in FamilyKey<C, R>]: AvServerClientTxFamilyFacade<C, R, F>;
+};
+/**
+ * `framework.application`: one {@link AvApplicationResourceFacade} per Resource
+ * of `C`, the Application Contract's view.
+ */
+export type AvApplicationFacade<C extends AvContract> = {
+    readonly [R in AvResourceKey<C>]: AvApplicationResourceFacade<C, R>;
+};
+/**
+ * `framework.client`: one {@link AvClientResourceFacade} per Resource of `C`,
+ * the Client Contract's view.
+ */
+export type AvClientFacade<C extends AvContract> = {
+    readonly [R in AvResourceKey<C>]: AvClientResourceFacade<C, R>;
+};
+/**
+ * `framework.serverClient`: one {@link AvServerClientResourceFacade} per Resource
+ * of `C`, the Client Contract's view, taking application forms.
+ */
+export type AvServerClientFacade<C extends AvContract> = {
+    readonly [R in AvResourceKey<C>]: AvServerClientResourceFacade<C, R>;
+};
+/** `framework.appTx.$sql`: the developer SQL step only an application transaction has. */
+type ApplicationSqlStep = {
+    /**
+     * A developer SQL step, written only as a tagged template:
+     * ``framework.appTx.$sql<Row>`select … ${value}` ``. Every interpolated value
+     * is bound as a parameter. See {@link AvSqlStatementBuilder}.
+     */
+    readonly $sql: AvSqlStatementBuilder;
+};
+/**
+ * `framework.appTx`: one {@link AvAppTxResourceFacade} per Resource of `C`, the
+ * Application Contract's view, and `$sql`.
+ */
+export type AvAppTxFacade<C extends AvContract> = {
+    readonly [R in AvResourceKey<C>]: AvAppTxResourceFacade<C, R>;
+} & ApplicationSqlStep;
 /**
- * `framework.appTx`: one deferred operation per operation the Application
- * Contract's view advertises — application rules, application forms.
+ * `framework.clientTx`: one {@link AvClientTxResourceFacade} per Resource of
+ * `C`, the Client Contract's view.
  */
-export type ApplicationTransactionBuilders<M extends AdapterModel, Cfg> = ApplicationDeferredSurface<ApplicationContractView<M, Cfg>>;
-type ApplicationDeferredSurface<C> = C extends Contract ? string extends ResourceKey<C> ? OpaqueSurface : {
-    readonly [R in ResourceKey<C>]: {
-        readonly [F in keyof OperationGrammar<C>[R]]: {
-            readonly [V in keyof OperationGrammar<C>[R][F]]: DeferredOperationCall<C, R, OperationGrammar<C>[R][F][V] & OperationIdentity, ApplicationScalarForms, ApplicationScalarForms>;
+export type AvClientTxFacade<C extends AvContract> = {
+    readonly [R in AvResourceKey<C>]: AvClientTxResourceFacade<C, R>;
+};
+/**
+ * `framework.serverClientTx`: one {@link AvServerClientTxResourceFacade} per
+ * Resource of `C`, the Client Contract's view, taking application forms.
+ */
+export type AvServerClientTxFacade<C extends AvContract> = {
+    readonly [R in AvResourceKey<C>]: AvServerClientTxResourceFacade<C, R>;
+};
+type ApplicationSurface<C> = C extends AvContract ? string extends AvResourceKey<C> ? OpaqueSurface : AvApplicationFacade<C> : never;
+type ClientSurface<C> = C extends AvContract ? string extends AvResourceKey<C> ? OpaqueSurface : AvClientFacade<C> : never;
+type ServerClientSurface<C> = C extends AvContract ? string extends AvResourceKey<C> ? OpaqueSurface : AvServerClientFacade<C> : never;
+type ApplicationDeferredSurface<C> = C extends AvContract ? string extends AvResourceKey<C> ? OpaqueSurface & ApplicationSqlStep : AvAppTxFacade<C> : never;
+type ClientDeferredSurface<C> = C extends AvContract ? string extends AvResourceKey<C> ? OpaqueSurface : AvClientTxFacade<C> : never;
+type ServerClientDeferredSurface<C> = C extends AvContract ? string extends AvResourceKey<C> ? OpaqueSurface : AvServerClientTxFacade<C> : never;
+/** `framework.application`'s type: {@link AvApplicationFacade}, or opaque. */
+export type ApplicationOperations<M extends AvAdapterModel, Cfg> = ApplicationSurface<AvContractApplicationView<M, Cfg>>;
+/** `framework.client`'s type: {@link AvClientFacade}, or opaque. */
+export type ClientOperations<M extends AvAdapterModel, Cfg> = ClientSurface<ClientContractView<M, Cfg>>;
+/** `framework.serverClient`'s type: {@link AvServerClientFacade}, or opaque, and `$access`. */
+export type ServerClientOperations<M extends AvAdapterModel, Cfg> = ServerClientSurface<ClientContractView<M, Cfg>> & ServerClientAccess<ClientContractView<M, Cfg>, AccessProviderOf<Cfg>>;
+/** `framework.appTx`'s type: {@link AvAppTxFacade}, or opaque with `$sql`. */
+export type ApplicationTransactionBuilders<M extends AvAdapterModel, Cfg> = ApplicationDeferredSurface<AvContractApplicationView<M, Cfg>>;
+/** `framework.clientTx`'s type: {@link AvClientTxFacade}, or opaque. */
+export type ClientTransactionBuilders<M extends AvAdapterModel, Cfg> = ClientDeferredSurface<ClientContractView<M, Cfg>>;
+/** `framework.serverClientTx`'s type: {@link AvServerClientTxFacade}, or opaque. */
+export type ServerClientTransactionBuilders<M extends AvAdapterModel, Cfg> = ServerClientDeferredSurface<ClientContractView<M, Cfg>>;
+/**
+ * The Resources of a pipeline ctx: `ctx.<Resource>.<family>.<variant>(args)`,
+ * application-origin, resolving the operation's data.
+ */
+export type AvContextOperations<M extends AvAdapterModel> = ContextFacade<AvContractApplicationView<M>>;
+type ContextFacade<C> = C extends AvContract ? string extends AvResourceKey<C> ? unknown : {
+    readonly [R in AvResourceKey<C>]: {
+        readonly [F in keyof AvOperationGrammar<C>[R]]: {
+            readonly [V in keyof AvOperationGrammar<C>[R][F]]: AvOperationCall<C, R, AvOperationGrammar<C>[R][F][V] & AvOperationIdentity, AvApplicationScalarForms, AvApplicationScalarForms, never>;
         };
     };
 } : never;
 /**
- * `framework.clientTx`: the same over the Client Contract's view — ClientContract
- * rules, wire forms.
+ * The Resources of compute's read-only ctx: `ctx.<Resource>.find.<variant>(args)`
+ * only (`find.count` included).
  */
-export type ClientTransactionBuilders<M extends AdapterModel, Cfg> = ClientDeferredSurface<ClientContractView<M, Cfg>>;
-type ClientDeferredSurface<C> = C extends Contract ? string extends ResourceKey<C> ? OpaqueSurface : {
-    readonly [R in ResourceKey<C>]: {
-        readonly [F in keyof OperationGrammar<C>[R]]: {
-            readonly [V in keyof OperationGrammar<C>[R][F]]: DeferredOperationCall<C, R, OperationGrammar<C>[R][F][V] & OperationIdentity, WireScalarForms, ApplicationScalarForms>;
+export type AvComputeReads<M extends AvAdapterModel> = ComputeReadFacade<AvContractApplicationView<M>>;
+type ComputeReadFacade<C> = C extends AvContract ? string extends AvResourceKey<C> ? unknown : {
+    readonly [R in AvResourceKey<C>]: {
+        readonly [F in Extract<keyof AvOperationGrammar<C>[R], "find">]: {
+            readonly [V in keyof AvOperationGrammar<C>[R][F]]: AvOperationCall<C, R, AvOperationGrammar<C>[R][F][V] & AvOperationIdentity, AvApplicationScalarForms, AvApplicationScalarForms, never>;
         };
     };
 } : never;
-/** Builds the request one façade call hands to `execute`, under its request id. */
-export type FacadeRequest = (resource: string, identity: OperationIdentity, args: unknown, requestId: string) => FrameworkOperationRequest;
-type FacadeExecutor = (request: FrameworkOperationRequest) => Promise<OperationResponse>;
+/** Builds the request one façade call hands to `execute`, under its request id and state. */
+export type FacadeRequest = (resource: string, identity: AvOperationIdentity, args: unknown, requestId: string, state: AvState | undefined) => AvOperationRequest;
+type FacadeExecutor = (request: AvOperationRequest, caller: PolicyCaller | undefined) => Promise<AvOperationResponse>;
 /**
  * Builds a façade over `model`, the same object its types are read from, so a
  * call that type-checks always reaches `execute`: a Resource, variant or field
@@ -74,20 +206,26 @@ type FacadeExecutor = (request: FrameworkOperationRequest) => Promise<OperationR
  * validation layer answers it.
  *
  * Each call's request is `request`'s — its origin — under the caller's
- * `ExecutionOptions.requestId`, or a freshly minted id when there is none; an
+ * `AvExecutionOptions.requestId`, or a freshly minted id when there is none, and
+ * with the caller's `AvExecutionOptions.state` when it gives one; an
  * omitted argument is the empty argument object, which the type admits only
  * when every member is optional.
  */
-export declare function createOperationFacade<Facade>(model: AdapterModel, request: FacadeRequest, execute: FacadeExecutor): Facade;
+export declare function createOperationFacade<Facade>(model: AvAdapterModel, request: FacadeRequest, execute: FacadeExecutor): Facade;
+/**
+ * An in-process call's settlement (a façade call or `framework.transaction`):
+ * the response's data, or its failure thrown.
+ */
+export declare function settleOperation(response: AvOperationResponse | AvTransactionResponse): unknown;
 /**
  * One leaf of an operation tree: the callable for one advertised variant. The
  * second parameter is a façade call's options; a builder leaf ignores it.
  */
-export type OperationLeaf = (resource: string, identity: OperationIdentity) => (args?: unknown, options?: unknown) => unknown;
+type OperationLeaf = (resource: string, identity: AvOperationIdentity) => (args?: unknown, options?: unknown) => unknown;
 /**
  * The runtime shape every façade and builder shares: one frozen property per
  * Resource of `model`, one per family under it, one leaf per variant the model
  * advertises in the standard grammar.
  */
-export declare function createOperationTree<Tree>(model: AdapterModel, leaf: OperationLeaf): Tree;
+export declare function createOperationTree<Tree>(model: AvAdapterModel, leaf: OperationLeaf): Tree;
 export {};

package/dist/framework/operation-facade.js

@@ -1,8 +1,17 @@
 import { isOperationVariantAvailable } from "../contracts/resource-operations.js";
 import { parseOperationIdentity } from "../operations/operation-identity.js";
+import { callerOf } from "../policy/policy-request.js";
+import { thrownFailure } from "../runtime/framework-error.factory.js";
 import { requestIdOf } from "../runtime/request-id.js";
+import { stateOptionOf } from "../runtime/request-state.resolver.js";
 export function createOperationFacade(model, request, execute) {
-    return createOperationTree(model, (resource, identity) => (args, options) => execute(request(resource, identity, args === undefined ? {} : args, requestIdOf(options))));
+    return createOperationTree(model, (resource, identity) => async (args, options) => settleOperation(await execute(request(resource, identity, args === undefined ? {} : args, requestIdOf(options), stateOptionOf(options)), callerOf(options))));
+}
+export function settleOperation(response) {
+    if (response.cause !== null) {
+        throw thrownFailure(response);
+    }
+    return response.data;
 }
 export function createOperationTree(model, leaf) {
     const resources = Object.entries(model.resources).map(([resource, { operations }]) => {

package/dist/index.d.ts

@@ -1,51 +1,68 @@
-export type { Adapter } from "./adapters/adapter.interface.js";
-export type { AdapterDiscoveryDiagnostic, AdapterDiscoveryDiagnosticCode, } from "./adapters/adapter-discovery-diagnostic.js";
-export type { AdapterModel } from "./adapters/adapter-model.js";
-export type { FrameworkContracts } from "./compiler/contract.compiler.js";
-export type { ContractCompilerDiagnostic, ContractCompilerDiagnosticCode, } from "./compiler/contract-compiler-diagnostic.js";
-export type { ConfigDiagnostic, ConfigDiagnosticCode, } from "./config/config-diagnostic.js";
-export type { ConfigLayer, RequestOrigin } from "./config/config-layer.js";
-export type { AddedScalarFieldConfig, FrameworkFieldsShape, KnownScalarFieldConfig, } from "./config/define-fields.js";
-export { defineFields } from "./config/define-fields.js";
-export type { ConfigFieldKey, EffectiveFieldKey, } from "./config/effective-fields.js";
-export type { FrameworkFieldBehaviorConfig, FrameworkReadBehavior, FrameworkResourceBehaviorsConfig, } from "./config/framework-behaviors-config.js";
-export type { AnyFieldsBlock, AnyFrameworkConfig, AnyScopeConfig, FrameworkBehaviorsConfig, FrameworkCapabilitySetRestriction, FrameworkConfig, FrameworkFieldLifecycleTrait, FrameworkFieldRestrictions, FrameworkFieldsConfig, FrameworkLimitsConfig, FrameworkProjectionScopeRestriction, FrameworkRelationCapabilityRestrictions, FrameworkRelationFieldRestrictions, FrameworkRelationMutationRestriction, FrameworkRelationReducerRestriction, FrameworkResourceFieldRestrictions, FrameworkResourceFieldsConfig, FrameworkResourceKey, FrameworkResourceOperationRestrictions, FrameworkResourceRestrictions, FrameworkRestrictionsConfig, FrameworkScalarCapabilityRestrictions, FrameworkScalarFieldConfig, FrameworkScalarFieldRestrictions, FrameworkScalarTypeRef, FrameworkScopeConfig, } from "./config/framework-config.js";
-export type { PipelineConfig } from "./config/pipeline-config.js";
-export type { PaginationCapability, ProjectionScope, RelationFilterCapability, RelationMutationDirective, RelationReducer, ScalarFilterOperator, ScalarMutationDirective, WriteScope, } from "./contracts/capability.js";
-export type { ApplicationContract, ClientContract, Contract, CoreContract, } from "./contracts/contract.js";
-export type { ContractLimits } from "./contracts/contract-limits.js";
-export type { ClientContractProtocol, ContractHash, ContractProtocol, } from "./contracts/contract-protocol.js";
-export type { EnumDefinition } from "./contracts/enum-definition.js";
-export type { Field, ProjectionScopes, RelationField, RelationFieldCapabilities, RelationMutationCapability, RelationProjectionCapability, RelationReducerCapability, ScalarField, ScalarFieldCapabilities, ScalarFormat, ScopedRelationMutations, ScopedRelationReducers, WriteScopes, } from "./contracts/field.js";
-export type { Identifier, ScalarFieldKey } from "./contracts/identifier.js";
-export type { LifecycleTrait } from "./contracts/lifecycle-trait.js";
-export type { Resource, ResourceFieldMap } from "./contracts/resource.js";
-export type { OperationAvailability, OperationVariantScopes, ResourceOperations, } from "./contracts/resource-operations.js";
-export type { BuiltInScalar, ScalarDefinition, ScalarRegistry, } from "./contracts/scalar.js";
-export type { ApplicationScalarForms, ScalarValueType, WireScalarForms, } from "./contracts/scalar-value-type.js";
-export type { TransactionCapability } from "./contracts/transaction-capability.js";
+export type { AvAdapter } from "./adapters/adapter.interface.js";
+export type { AvAdapterDiscoveryDiagnostic, AvAdapterDiscoveryDiagnosticCode, } from "./adapters/adapter-discovery-diagnostic.js";
+export type { AvAdapterModel } from "./adapters/adapter-model.js";
+export type { AvContracts } from "./compiler/contract.compiler.js";
+export type { AvContractCompilerDiagnostic, AvContractCompilerDiagnosticCode, } from "./compiler/contract-compiler-diagnostic.js";
+export type { AvConfigComputedFields } from "./config/computed-fields.js";
+export type { AvMcpEndpoint } from "./config/config.resolver.js";
+export type { AvConfigDiagnostic, AvConfigDiagnosticCode, } from "./config/config-diagnostic.js";
+export type { AvConfigLayerName, AvRequestOrigin, } from "./config/config-layer.js";
+export { type AvDefinedResource, defineResource, } from "./config/define-resource.js";
+export type { AvConfigFieldKey, AvEffectiveFieldKey, } from "./config/effective-fields.js";
+export type { AvConfigExact } from "./config/exact-framework-config.js";
+export type { AvConfig, AvConfigAddedFieldDefinition, AvConfigAgentLayer, AvConfigAny, AvConfigExemptions, AvConfigFamily, AvConfigFieldDefinition, AvConfigFieldLifecycleTrait, AvConfigKnownFieldDefinition, AvConfigLayer, AvConfigLayerAny, AvConfigLayerKind, AvConfigLimits, AvConfigMcp, AvConfigOperations, AvConfigOperationsExemption, AvConfigOverlayField, AvConfigRelationFieldExemption, AvConfigResource, AvConfigResourceExemption, AvConfigResourceFields, AvConfigResourceKey, AvConfigResources, AvConfigResourcesAny, AvConfigResourceTransactions, AvConfigRootField, AvConfigScalarFieldExemption, AvConfigScalarTypeRef, AvConfigVariant, AvFieldCompute, AvRelationFieldCapabilityName, AvRelationFieldPipeline, AvScalarFieldCapabilityName, AvScalarFieldPipeline, AvZCheck, AvZFormat, } from "./config/framework-config.js";
+export type { AvPipeline, AvTransactionPipeline, } from "./config/pipeline-config.js";
+export type { AvPaginationCapability, AvProjectionScope, AvRelationFilterCapability, AvRelationMutationDirective, AvRelationReducer, AvScalarFilterOperator, AvScalarMutationDirective, AvWriteScope, } from "./contracts/capability.js";
+export type { AvContract, AvContractAgent, AvContractApplication, AvContractClient, AvContractCore, AvCoreResource, } from "./contracts/contract.js";
+export type { AvContractClientAccess } from "./contracts/contract-access.js";
+export type { AvContractLimits } from "./contracts/contract-limits.js";
+export type { AvContractClientProtocol, AvContractHash, AvContractProtocol, } from "./contracts/contract-protocol.js";
+export type { AvCreateRequirementGroup, AvCreateRequirements, } from "./contracts/create-requirements.js";
+export type { AvEnumDefinition } from "./contracts/enum-definition.js";
+export type { AvCoreField, AvCoreRelationField, AvField, AvProjectionScopes, AvRelationField, AvRelationFieldCapabilities, AvRelationMutationCapability, AvRelationProjectionCapability, AvRelationReducerCapability, AvScalarField, AvScalarFieldCapabilities, AvScalarFormat, AvScopedRelationMutations, AvScopedRelationReducers, AvWriteScopes, } from "./contracts/field.js";
+export type { AvFieldCheck } from "./contracts/field-check.js";
+export type { AvIdentifier, AvScalarFieldKey } from "./contracts/identifier.js";
+export type { AvLifecycleTrait } from "./contracts/lifecycle-trait.js";
+export type { AvResource, AvResourceFieldMap } from "./contracts/resource.js";
+export type { AvOperationAvailability, AvOperationVariantScopes, AvResourceOperations, } from "./contracts/resource-operations.js";
+export type { AvBuiltInScalar, AvScalarDefinition, AvScalarRegistry, } from "./contracts/scalar.js";
+export type { AvApplicationScalarForms, AvScalarValueType, AvWireScalarForms, } from "./contracts/scalar-value-type.js";
+export type { AvTransactionCapability } from "./contracts/transaction-capability.js";
+export type { AvContractView, AvManagedContractView, } from "./framework/contract-view.js";
 export { createFramework } from "./framework/framework.factory.js";
-export type { Framework } from "./framework/framework.js";
-export type { FrameworkConstructionDiagnostic, FrameworkConstructionStage, } from "./framework/framework-construction.error.js";
-export { FrameworkConstructionError } from "./framework/framework-construction.error.js";
-export type { CreateDataInput, CursorInput, FieldKey, IncludeInput, NullsOrder, OperationArgumentMap, OperationArgumentsFor, OrderByEntry, OrderByInput, ProjectionEntry, RelationProjectionInput, ResourceKey, ScalarOrderInput, SelectInput, SortDirection, UniqueWhereInput, UpdateDataInput, WhereInput, } from "./operations/operation-arguments.js";
-export type { DeferredOperationCall, OperationCall, OperationGrammar, OperationSlot, } from "./operations/operation-call.js";
-export type { OperationFamily, OperationIdentity, OperationVariant, } from "./operations/operation-identity.js";
-export type { OperationResultFor } from "./operations/operation-result.js";
-export type { ValidationCode, ValidationIssue, } from "./operations/validation-code.js";
-export { Decimal } from "./runtime/decimal.js";
-export type { FrameworkDiagnostic, FrameworkDiagnosticsSink, OperationDiagnostic, TransactionDiagnostic, } from "./runtime/diagnostics-reporter.js";
-export type { ExecutionOptions } from "./runtime/execution-options.js";
-export type { ComputedReadBehavior, ComputeOnCreate, ComputeOnRead, ComputeOnUpdate, } from "./runtime/field-behavior.js";
-export { FrameworkError } from "./runtime/framework-error.js";
-export type { JsonValue } from "./runtime/json-value.js";
-export type { FrameworkMisuseEvent, FrameworkMisuseSink, } from "./runtime/misuse-reporter.js";
-export type { Cause, OperationCode, OperationErrorCode, OperationFailureResponse, OperationNoMatchResponse, OperationResponse, OperationSuccessCode, OperationSuccessDataCode, OperationSuccessResponse, } from "./runtime/operation-response.js";
-export type { AfterHook, BeforeHook, Filter, Guard, Interceptor, Pipe, PipelineContext, PipelineTransportContext, } from "./runtime/pipeline.js";
-export type { Operation, OperationReferenceSurface, ReferenceableField, ReferenceBuilder, SingleRowResult, TransactionResults, TransactionRunner, } from "./transactions/deferred-operation.js";
-export type { TransactionIntegrityViolation } from "./transactions/transaction-integrity-error.js";
-export { TransactionIntegrityError } from "./transactions/transaction-integrity-error.js";
-export type { TransactionReference } from "./transactions/transaction-reference.js";
-export type { TransactionCommittedResponse, TransactionResponse, } from "./transactions/transaction-response.js";
-export type { TransactionSlotPathViolation } from "./transactions/transaction-slot-path-error.js";
-export { TransactionSlotPathError } from "./transactions/transaction-slot-path-error.js";
+export type { AvFramework } from "./framework/framework.js";
+export type { AvConstructionDiagnostic, AvConstructionStage, } from "./framework/framework-construction.error.js";
+export { AvConstructionError } from "./framework/framework-construction.error.js";
+export type { AvApplicationFacade, AvApplicationFamilyFacade, AvApplicationPlainCall, AvApplicationProjectingCall, AvApplicationResourceFacade, AvAppTxFacade, AvAppTxFamilyFacade, AvAppTxPlainCall, AvAppTxProjectingCall, AvAppTxResourceFacade, AvClientFacade, AvClientFamilyFacade, AvClientPlainCall, AvClientProjectingCall, AvClientResourceFacade, AvClientTxFacade, AvClientTxFamilyFacade, AvClientTxPlainCall, AvClientTxProjectingCall, AvClientTxResourceFacade, AvServerClientFacade, AvServerClientFamilyFacade, AvServerClientPlainCall, AvServerClientProjectingCall, AvServerClientResourceFacade, AvServerClientTxFacade, AvServerClientTxFamilyFacade, AvServerClientTxPlainCall, AvServerClientTxProjectingCall, AvServerClientTxResourceFacade, } from "./framework/operation-facade.js";
+export type { AvCreateDataInput, AvCursorInput, AvFieldKey, AvIncludeInput, AvNoAdvertisedMember, AvNullsOrder, AvOperationArgumentMap, AvOperationArgumentsFor, AvOrderByEntry, AvOrderByInput, AvProjectionEntry, AvRelationProjectionInput, AvResourceKey, AvScalarFilterOperands, AvScalarOrderInput, AvScalarWhereInput, AvSelectInput, AvSortDirection, AvUniqueWhereInput, AvUpdateDataInput, AvWhereInput, } from "./operations/operation-arguments.js";
+export type { AvDeferredOperationCall, AvOperationCall, AvOperationGrammar, AvOperationSlot, } from "./operations/operation-call.js";
+export type { AvOperationFamily, AvOperationIdentity, AvOperationVariant, } from "./operations/operation-identity.js";
+export type { AvOperationResultFor } from "./operations/operation-result.js";
+export type { AvValidationCode, AvValidationIssue, } from "./operations/validation-code.js";
+export type { AvAccessProvider } from "./policy/access-provider.interface.js";
+export type { AvAccessQuestion } from "./policy/access-question.js";
+export type { AvAccessVerbs } from "./policy/access-verbs.js";
+export type { AvPolicyEngine, AvPolicyWhere, } from "./policy/policy-engine.js";
+export type { AvPrebuiltContracts } from "./prebuilt/prebuilt-contracts.js";
+export { AvDecimal } from "./runtime/decimal.js";
+export type { AvCanDiagnostic, AvDiagnostic, AvDiagnosticsSink, AvMcpDiagnostic, AvOperationDiagnostic, AvTransactionDiagnostic, } from "./runtime/diagnostics-reporter.js";
+export { AvErrorCatalog, type AvErrorCatalogCode, type AvErrorCatalogEntry, type AvErrorKind, } from "./runtime/error.catalog.js";
+export type { AvExecutionOptions } from "./runtime/execution-options.js";
+export type { AvComputeContext, AvComputeCreate, AvComputeRead, AvComputeUpdate, } from "./runtime/field-compute.js";
+export { AvAuthError, AvConflictError, AvContractMismatchError, AvError, AvInternalError, AvNotFoundError, AvProtocolError, AvValidationError, } from "./runtime/framework-error.js";
+export type { AvJsonValue } from "./runtime/json-value.js";
+export type { AvMisuseEvent, AvMisuseSink, } from "./runtime/misuse-reporter.js";
+export type { AvAgentOperationRequest, AvApplicationOperationRequest, AvClientOperationRequest, AvOperationRequest, AvRequestProtocol, } from "./runtime/operation-request.js";
+export type { AvCause, AvOperationCode, AvOperationErrorCode, AvOperationFailureResponse, AvOperationNoMatchResponse, AvOperationResponse, AvOperationSuccessCode, AvOperationSuccessDataCode, AvOperationSuccessResponse, } from "./runtime/operation-response.js";
+export type { AvAfterHook, AvBeforeHook, AvContext, AvFieldGuard, AvFieldPipe, AvFilter, AvGuard, AvInterceptor, AvPipe, AvTransactionAfterHook, AvTransactionBeforeHook, AvTransactionContext, AvTransactionFilter, AvTransactionGuard, AvTransactionInterceptor, AvTransactionPipe, AvTransactionStep, AvTransportContext, } from "./runtime/pipeline.js";
+export type { AvDeepReadonly } from "./runtime/readonly-value.js";
+export type { AvState } from "./runtime/request-state.js";
+export type { AvOperation, AvOperationHandle, AvOperationReferenceSurface, AvReferenceableField, AvReferenceBuilder, AvSingleRowResult, AvTransactionResults, AvTransactionRunner, } from "./transactions/deferred-operation.js";
+export type { AvSqlStatementBuilder, AvSqlStatementValue, } from "./transactions/sql-statement.js";
+export type { AvTransactionIntegrityViolation } from "./transactions/transaction-integrity-error.js";
+export { AvTransactionIntegrityError } from "./transactions/transaction-integrity-error.js";
+export type { AvTransactionReference } from "./transactions/transaction-reference.js";
+export type { AvAgentTransactionRequest, AvApplicationTransactionRequest, AvClientTransactionRequest, AvTransactionRequest, } from "./transactions/transaction-request.js";
+export type { AvTransactionCommittedResponse, AvTransactionResponse, } from "./transactions/transaction-response.js";
+export type { AvTransactionSlotPathViolation } from "./transactions/transaction-slot-path-error.js";
+export { AvTransactionSlotPathError } from "./transactions/transaction-slot-path-error.js";

package/dist/index.js

@@ -1,7 +1,8 @@
-export { defineFields } from "./config/define-fields.js";
+export { defineResource, } from "./config/define-resource.js";
 export { createFramework } from "./framework/framework.factory.js";
-export { FrameworkConstructionError } from "./framework/framework-construction.error.js";
-export { Decimal } from "./runtime/decimal.js";
-export { FrameworkError } from "./runtime/framework-error.js";
-export { TransactionIntegrityError } from "./transactions/transaction-integrity-error.js";
-export { TransactionSlotPathError } from "./transactions/transaction-slot-path-error.js";
+export { AvConstructionError } from "./framework/framework-construction.error.js";
+export { AvDecimal } from "./runtime/decimal.js";
+export { AvErrorCatalog, } from "./runtime/error.catalog.js";
+export { AvAuthError, AvConflictError, AvContractMismatchError, AvError, AvInternalError, AvNotFoundError, AvProtocolError, AvValidationError, } from "./runtime/framework-error.js";
+export { AvTransactionIntegrityError } from "./transactions/transaction-integrity-error.js";
+export { AvTransactionSlotPathError } from "./transactions/transaction-slot-path-error.js";

package/dist/internal.d.ts

@@ -6,30 +6,40 @@
  * stability promise: any export here may change or disappear in any release,
  * including a patch release. Applications import from `@aventara/core`.
  */
-export type { AdapterField, AdapterLifecycleTrait, AdapterRelationField, AdapterScalarField, } from "./adapters/adapter-field.js";
-export type { AdapterIdentifier, AdapterScalarFieldKey, } from "./adapters/adapter-identifier.js";
-export type { AdapterOperation } from "./adapters/adapter-operation.js";
-export type { AdapterOperationExecutor } from "./adapters/adapter-operation-executor.interface.js";
-export type { AdapterFieldKey, AdapterFieldMap, AdapterResource, } from "./adapters/adapter-resource.js";
+export type { AvAdapterField, AvAdapterLifecycleTrait, AvAdapterRelationField, AvAdapterScalarField, } from "./adapters/adapter-field.js";
+export type { AvAdapterIdentifier, AvAdapterScalarFieldKey, } from "./adapters/adapter-identifier.js";
+export type { AvAdapterOperation } from "./adapters/adapter-operation.js";
+export type { AvAdapterOperationExecutor } from "./adapters/adapter-operation-executor.interface.js";
+export type { AvAdapterFieldKey, AvAdapterFieldMap, AvAdapterResource, } from "./adapters/adapter-resource.js";
+export type { AvAdapterSqlStatement, AvAdapterSqlValue, } from "./adapters/adapter-sql-statement.js";
+export type { AvAdapterTransactionExecutor } from "./adapters/adapter-transaction-executor.interface.js";
 export { compileContracts } from "./compiler/contract.compiler.js";
 export { resolveFrameworkConfig } from "./config/config.resolver.js";
 export { PROJECTION_SCOPES, WRITE_SCOPES } from "./contracts/capability.js";
 export { validateClientContractStructure } from "./contracts/client-contract-structure.validator.js";
-export { CanonicalJsonError, canonicalizeContract, canonicalizeJson, } from "./contracts/contract-canonicalizer.js";
-export type { ClientContractHashInput } from "./contracts/contract-hash.js";
+export { AvCanonicalJsonError, canonicalizeContract, canonicalizeJson, } from "./contracts/contract-canonicalizer.js";
+export type { AvContractClientHashInput } from "./contracts/contract-hash.js";
 export { computeClientContractHash, verifyClientContractHash, } from "./contracts/contract-hash.js";
 export { DEFAULT_CONTRACT_LIMITS } from "./contracts/contract-limits.js";
 export { AVENTARA_PROTOCOL_VERSION } from "./contracts/contract-protocol.js";
 export { advertisedDirectives, advertisedReducers } from "./contracts/field.js";
+export { projectJsonValue } from "./contracts/json-schema.projector.js";
 export { LIFECYCLE_TRAITS } from "./contracts/lifecycle-trait.js";
 export { isOperationVariantAvailable, projectionScopeOf, writeScopeOf, } from "./contracts/resource-operations.js";
 export { BUILT_IN_SCALARS } from "./contracts/scalar.js";
 export { TRANSACTION_CAPABILITIES } from "./contracts/transaction-capability.js";
-export type { ApplicationContractView } from "./framework/contract-view.js";
+export type { AvContractApplicationView } from "./framework/contract-view.js";
+export type { AvDatabaseRefusal } from "./operations/database-refusal.js";
+export { DATABASE_REFUSALS } from "./operations/database-refusal.js";
 export type { SemanticOperationArguments } from "./operations/operation-validator.js";
 export { VALIDATION_CODES } from "./operations/validation-code.js";
-export type { ApplicationOperationRequest, ClientOperationRequest, ClientProtocolIdentity, FrameworkOperationRequest, } from "./runtime/operation-request.js";
+export { accessProviderOf } from "./policy/access-provider.registry.js";
+export { ACCESS_VERB_NAMES, ACCESS_VERBS, providerVerb, } from "./policy/access-verb.table.js";
+export { prebuiltFileChanges } from "./prebuilt/prebuilt-changes.js";
+export { emitPrebuiltContracts, prebuiltContractsOf, } from "./prebuilt/prebuilt-contracts.emitter.js";
+export { mcpFailureReporterOf } from "./runtime/diagnostics-reporter.js";
+export type { AvErrorClassName } from "./runtime/framework-error-class.table.js";
+export { FRAMEWORK_ERROR_CLASS_OF } from "./runtime/framework-error-class.table.js";
 export { OPERATION_CODES } from "./runtime/operation-response.js";
 export type { BuiltinNonRow, OperationFingerprint, } from "./transactions/deferred-operation.js";
 export { computeOperationFingerprint } from "./transactions/operation-fingerprint.js";
-export type { ApplicationTransactionRequest, ClientTransactionRequest, FrameworkTransactionRequest, } from "./transactions/transaction-request.js";

package/dist/internal.js

@@ -2,15 +2,23 @@ export { compileContracts } from "./compiler/contract.compiler.js";
 export { resolveFrameworkConfig } from "./config/config.resolver.js";
 export { PROJECTION_SCOPES, WRITE_SCOPES } from "./contracts/capability.js";
 export { validateClientContractStructure } from "./contracts/client-contract-structure.validator.js";
-export { CanonicalJsonError, canonicalizeContract, canonicalizeJson, } from "./contracts/contract-canonicalizer.js";
+export { AvCanonicalJsonError, canonicalizeContract, canonicalizeJson, } from "./contracts/contract-canonicalizer.js";
 export { computeClientContractHash, verifyClientContractHash, } from "./contracts/contract-hash.js";
 export { DEFAULT_CONTRACT_LIMITS } from "./contracts/contract-limits.js";
 export { AVENTARA_PROTOCOL_VERSION } from "./contracts/contract-protocol.js";
 export { advertisedDirectives, advertisedReducers } from "./contracts/field.js";
+export { projectJsonValue } from "./contracts/json-schema.projector.js";
 export { LIFECYCLE_TRAITS } from "./contracts/lifecycle-trait.js";
 export { isOperationVariantAvailable, projectionScopeOf, writeScopeOf, } from "./contracts/resource-operations.js";
 export { BUILT_IN_SCALARS } from "./contracts/scalar.js";
 export { TRANSACTION_CAPABILITIES } from "./contracts/transaction-capability.js";
+export { DATABASE_REFUSALS } from "./operations/database-refusal.js";
 export { VALIDATION_CODES } from "./operations/validation-code.js";
+export { accessProviderOf } from "./policy/access-provider.registry.js";
+export { ACCESS_VERB_NAMES, ACCESS_VERBS, providerVerb, } from "./policy/access-verb.table.js";
+export { prebuiltFileChanges } from "./prebuilt/prebuilt-changes.js";
+export { emitPrebuiltContracts, prebuiltContractsOf, } from "./prebuilt/prebuilt-contracts.emitter.js";
+export { mcpFailureReporterOf } from "./runtime/diagnostics-reporter.js";
+export { FRAMEWORK_ERROR_CLASS_OF } from "./runtime/framework-error-class.table.js";
 export { OPERATION_CODES } from "./runtime/operation-response.js";
 export { computeOperationFingerprint } from "./transactions/operation-fingerprint.js";