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

package/dist/framework/framework.factory.js

@@ -1,9 +1,18 @@
-import { compileContracts } from "../compiler/contract.compiler.js";
-import { resolveFrameworkConfig } from "../config/config.resolver.js";
+import { compileContracts, } from "../compiler/contract.compiler.js";
+import { validateManagedDeletes } from "../compiler/managed-elsewhere.validator.js";
+import { computedFieldsOf, warnOnStaleComputedFields, } from "../config/computed-fields.js";
+import { resolveFrameworkConfig, } from "../config/config.resolver.js";
 import { validateFrameworkConfig } from "../config/config.validator.js";
 import { validateForcedOperations } from "../config/forced-operation.validator.js";
 import { AVENTARA_PROTOCOL_VERSION } from "../contracts/contract-protocol.js";
-import { copyEnvelopeAtDoor, refuseCallerData, } from "../runtime/caller-data.door.js";
+import { recordAccessProvider } from "../policy/access-provider.registry.js";
+import { recordAccessQuestions } from "../policy/access-question.registry.js";
+import { createAccessQuestionAnswerer } from "../policy/access-question.runtime.js";
+import { heldTargetsOf } from "../policy/policy-reference-write.runtime.js";
+import { callerOf } from "../policy/policy-request.js";
+import { policyStartupDiagnostics } from "../policy/policy-startup.validator.js";
+import { loadPrebuiltContracts, warnStalePrebuilt, } from "../prebuilt/prebuilt-contracts.loader.js";
+import { copyAtDoor, copyEnvelopeAtDoor, refuseCallerData, } from "../runtime/caller-data.door.js";
 import { createDiagnosticsReporter, createTransactionDiagnosticsChannel, recordDiagnosticsSink, } from "../runtime/diagnostics-reporter.js";
 import { createMisuseReporter, } from "../runtime/misuse-reporter.js";
 import { internalFailure, operationFailure, } from "../runtime/operation-response.js";
@@ -12,8 +21,10 @@ import { recordOwnedExecution } from "../runtime/owned-execution.registry.js";
 import { validateOperationEnvelope, validateTransactionEnvelope, } from "../runtime/request-envelope.validator.js";
 import { requestIdOf } from "../runtime/request-id.js";
 import { stateOptionOf } from "../runtime/request-state.resolver.js";
+import { encodeOperationArgumentsForWire } from "../transactions/operation-arguments-encoder.js";
 import { createTransactionPlanAssembler } from "../transactions/transaction-plan-assembler.js";
 import { createTransactionRuntime } from "../transactions/transaction-runtime.js";
+import { createServerClientAccess } from "./access-facade.js";
 import { AvConstructionError } from "./framework-construction.error.js";
 import { createOperationFacade, createOperationTree, settleOperation, } from "./operation-facade.js";
 const APPLICATION_SQL_BUILDER = "$sql";
@@ -34,7 +45,13 @@ export async function createFramework(config) {
         ]);
     }
     const resolvedConfig = resolveFrameworkConfig(config);
-    const compilation = await compileContracts(model, resolvedConfig);
+    warnOnStaleComputedFields(config.adapter.computedFields, computedFieldsOf({
+        trees: resolvedConfig.trees,
+        agentExtends: resolvedConfig.agent.parent,
+    }));
+    const compilation = (config.prebuilt === undefined
+        ? undefined
+        : await prebuiltCompilation(config.prebuilt, model, config, resolvedConfig)) ?? (await compileContracts(model, resolvedConfig));
     if (!compilation.ok) {
         throw new AvConstructionError("contract-compilation", compilation.diagnostics);
     }
@@ -42,6 +59,16 @@ export async function createFramework(config) {
     if (forcing.length > 0) {
         throw new AvConstructionError("configuration", forcing);
     }
+    const managedDeletes = validateManagedDeletes(compilation.contracts, config.adapter.referentialActions);
+    if (managedDeletes.length > 0) {
+        throw new AvConstructionError("configuration", managedDeletes);
+    }
+    if (resolvedConfig.policy !== undefined) {
+        const policy = policyStartupDiagnostics(compilation.contracts.core, resolvedConfig.policy, model);
+        if (policy.length > 0) {
+            throw new AvConstructionError("configuration", policy);
+        }
+    }
     const runtimeDependencies = {
         adapter: config.adapter,
         contracts: compilation.contracts,
@@ -51,12 +78,31 @@ export async function createFramework(config) {
     const execute = createOperationRuntime(runtimeDependencies, pipelineDependencies);
     const executeTransaction = createTransactionRuntime(runtimeDependencies, pipelineDependencies);
     const misuse = createMisuseReporter(resolvedConfig.misuse);
-    const executeOperation = (request) => executeTotally(execute, request, resolvedConfig.diagnostics, "caller");
+    const executeOperation = (request, caller) => executeTotally(execute, request, resolvedConfig.diagnostics, "caller", caller);
+    const executeApplicationValues = (request, caller) => executeTotally(encodingApplicationValues(execute, compilation.contracts.client), request, resolvedConfig.diagnostics, "caller", caller);
     const protocol = {
         version: AVENTARA_PROTOCOL_VERSION,
         hash: compilation.contracts.client.protocol.hash,
     };
     const assembler = createTransactionPlanAssembler(compilation.contracts, protocol, misuse);
+    const clientRequest = (resource, identity, args, requestId, state) => ({
+        ...identity,
+        origin: "client",
+        protocol,
+        requestId,
+        ...(state === undefined ? {} : { state }),
+        resource,
+        arguments: args,
+    });
+    const accessAnswerer = compilation.contracts.client.access === undefined
+        ? undefined
+        : createAccessQuestionAnswerer({
+            contracts: compilation.contracts,
+            policy: resolvedConfig.policy,
+            adapter: config.adapter,
+            diagnostics: resolvedConfig.diagnostics,
+            misuse,
+        });
     const framework = {
         api: resolvedConfig.api,
         mcp: resolvedConfig.mcp,
@@ -69,35 +115,76 @@ export async function createFramework(config) {
             resource,
             arguments: args,
         }), executeOperation),
-        client: createOperationFacade(model, (resource, identity, args, requestId, state) => ({
-            ...identity,
-            origin: "client",
-            protocol,
-            requestId,
-            ...(state === undefined ? {} : { state }),
-            resource,
-            arguments: args,
-        }), executeOperation),
+        client: createOperationFacade(model, clientRequest, executeOperation),
+        serverClient: withServerClientAccess(createOperationFacade(model, clientRequest, executeApplicationValues), accessAnswerer === undefined
+            ? undefined
+            : createServerClientAccess({
+                contract: compilation.contracts.client,
+                answer: accessAnswerer,
+                client: config.access?.client,
+                state: (input) => config.access.state(input),
+            })),
         appTx: Object.freeze({
             ...createOperationTree(model, (resource, identity) => (args) => assembler.defer("application", resource, identity, args === undefined ? {} : args)),
             [APPLICATION_SQL_BUILDER]: (strings, ...values) => assembler.deferSql(strings, values),
         }),
         clientTx: createOperationTree(model, (resource, identity) => (args) => assembler.defer("client", resource, identity, args === undefined ? {} : args)),
+        serverClientTx: createOperationTree(model, (resource, identity) => (args) => assembler.defer("client", resource, identity, args === undefined ? {} : args, "application")),
         execute: (request) => executeRequestTotally(execute, request, resolvedConfig.diagnostics, misuse),
         executeTransaction: (request) => executeTransactionRequestTotally(executeTransaction, request, resolvedConfig.diagnostics, misuse),
-        transaction: (async (operations, options) => settleOperation(await runTransactionTotally(executeTransaction, assembler, operations, requestIdOf(options), stateOptionOf(options), resolvedConfig.diagnostics))),
+        transaction: (async (operations, options) => settleOperation(await runTransactionTotally(executeTransaction, assembler, operations, requestIdOf(options), stateOptionOf(options), resolvedConfig.diagnostics, callerOf(options)))),
     };
     recordDiagnosticsSink(framework, resolvedConfig.diagnostics);
+    recordAccessProvider(framework, config.access);
+    if (accessAnswerer !== undefined) {
+        recordAccessQuestions(framework, accessAnswerer);
+    }
     recordOwnedExecution(framework, {
-        execute: (request) => executeTotally(execute, request, resolvedConfig.diagnostics, "owned"),
-        executeTransaction: (request) => executeTransactionTotally(executeTransaction, request, resolvedConfig.diagnostics, undefined, { source: "owned" }),
+        execute: (request, refused) => executeTotally(execute, request, resolvedConfig.diagnostics, refused === undefined ? "owned" : { refused }),
+        executeTransaction: (request, refused) => executeTransactionTotally(executeTransaction, request, resolvedConfig.diagnostics, undefined, refused === undefined
+            ? { source: "owned" }
+            : { source: "owned", refused }),
     });
+    if (resolvedConfig.policy !== undefined) {
+        await resolvedConfig.policy.engine.hosted?.({
+            held: heldTargetsOf(compilation.contracts.core, resolvedConfig.policy.unheld),
+        });
+    }
     return framework;
 }
-async function executeTotally(execute, request, diagnostics, source) {
+async function prebuiltCompilation(prebuilt, model, config, resolved) {
+    let loaded;
+    try {
+        loaded = await loadPrebuiltContracts(prebuilt, model, config, resolved);
+    }
+    catch (error) {
+        loaded = {
+            ok: false,
+            reason: `it could not be read (${error instanceof Error ? error.message : String(error)})`,
+        };
+    }
+    if (!loaded.ok) {
+        warnStalePrebuilt(loaded.reason);
+        return undefined;
+    }
+    return { ok: true, contracts: loaded.contracts };
+}
+function encodingApplicationValues(execute, contract) {
+    return (request, report, _source, caller) => {
+        const copy = copyAtDoor(request.arguments);
+        if (!copy.ok) {
+            return execute(request, report, { refused: copy.error }, caller);
+        }
+        return execute({
+            ...request,
+            arguments: encodeOperationArgumentsForWire(contract, request, copy.value),
+        }, report, "owned", caller);
+    };
+}
+async function executeTotally(execute, request, diagnostics, source, caller) {
     const report = createDiagnosticsReporter(diagnostics, request);
     try {
-        return await execute(request, report, source);
+        return await execute(request, report, source, caller);
     }
     catch (error) {
         report(error, "A3000");
@@ -138,18 +225,18 @@ function executeTransactionRequestTotally(execute, request, diagnostics, misuse)
     }
     return executeTransactionTotally(execute, envelope.value, diagnostics, undefined, { source: "caller" });
 }
-async function executeTransactionTotally(execute, request, diagnostics, origins, planArguments) {
+async function executeTransactionTotally(execute, request, diagnostics, origins, planArguments, caller) {
     const channel = createTransactionDiagnosticsChannel(diagnostics, request);
     const report = channel.transaction();
     try {
-        return await execute(request, channel, origins, planArguments);
+        return await execute(request, channel, origins, planArguments, caller);
     }
     catch (error) {
         report(error, "A3000");
         return internalFailure();
     }
 }
-async function runTransactionTotally(execute, assembler, operations, requestId, state, diagnostics) {
+async function runTransactionTotally(execute, assembler, operations, requestId, state, diagnostics, caller) {
     let assembled;
     try {
         assembled = await assembler.assemble(operations);
@@ -174,5 +261,10 @@ async function runTransactionTotally(execute, assembler, operations, requestId,
         source: "owned",
         refused: assembled.refused,
         statements: assembled.statements,
-    });
+    }, caller);
+}
+function withServerClientAccess(facade, access) {
+    return access === undefined
+        ? facade
+        : Object.freeze({ ...facade, $access: access });
 }

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

@@ -1,15 +1,17 @@
 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 { AvResourceKey } from "../operations/operation-arguments.js";
-import type { AvDeferredOperationCall, AvOperationCall, AvOperationGrammar } from "../operations/operation-call.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 { FrameworkOperationRequest } from "../runtime/operation-request.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 { SqlStatementBuilder } from "../transactions/sql-statement.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
@@ -19,13 +21,46 @@ import type { AvContractApplicationView, ClientContractView } from "./contract-v
 type OpaqueSurface = {
     readonly [resource: string]: unknown;
 };
-/** The four typed surfaces of an `AvFramework`, named by the member that holds each. */
-type FacadeSurface = "application" | "client" | "appTx" | "clientTx";
+/** 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.serverClient.<Resource>.<family>.<variant>` when the variant takes a `select` or `include`:
+ * the Client Contract's view, application forms in.
+ */
+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.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 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`).
+ * 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" ? AvOperationCall<C, R, I, AvApplicationScalarForms, AvApplicationScalarForms, AvExecutionOptions> : S extends "client" ? AvOperationCall<C, R, I, AvWireScalarForms, AvApplicationScalarForms, AvExecutionOptions> : S extends "appTx" ? AvDeferredOperationCall<C, R, I, AvApplicationScalarForms, AvApplicationScalarForms, "application"> : AvDeferredOperationCall<C, R, I, AvWireScalarForms, AvApplicationScalarForms, "client">;
+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. */
@@ -36,10 +71,14 @@ type FamilyNode<C extends AvContract, S extends FacadeSurface, R extends AvResou
 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>;
@@ -48,6 +87,10 @@ export type AvApplicationResourceFacade<in out C extends AvContract, in out R ex
 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>;
@@ -56,6 +99,10 @@ export type AvAppTxResourceFacade<in out C extends AvContract, in out R extends
 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.
@@ -70,14 +117,21 @@ export type AvApplicationFacade<C extends AvContract> = {
 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 SqlStatementBuilder}.
+     * is bound as a parameter. See {@link AvSqlStatementBuilder}.
      */
-    readonly $sql: SqlStatementBuilder;
+    readonly $sql: AvSqlStatementBuilder;
 };
 /**
  * `framework.appTx`: one {@link AvAppTxResourceFacade} per Resource of `C`, the
@@ -93,18 +147,31 @@ export type AvAppTxFacade<C extends AvContract> = {
 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.
@@ -130,8 +197,8 @@ type ComputeReadFacade<C> = C extends AvContract ? string extends AvResourceKey<
     };
 } : never;
 /** 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) => FrameworkOperationRequest;
-type FacadeExecutor = (request: FrameworkOperationRequest) => Promise<AvOperationResponse>;
+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
@@ -154,7 +221,7 @@ export declare function settleOperation(response: AvOperationResponse | AvTransa
  * 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: AvOperationIdentity) => (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

package/dist/framework/operation-facade.js

@@ -1,10 +1,11 @@
 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) => async (args, options) => settleOperation(await execute(request(resource, identity, args === undefined ? {} : args, requestIdOf(options), stateOptionOf(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) {

package/dist/index.d.ts

@@ -3,6 +3,7 @@ export type { AvAdapterDiscoveryDiagnostic, AvAdapterDiscoveryDiagnosticCode, }
 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";
@@ -12,12 +13,13 @@ 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, } from "./contracts/contract.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 { AvField, AvProjectionScopes, AvRelationField, AvRelationFieldCapabilities, AvRelationMutationCapability, AvRelationProjectionCapability, AvRelationReducerCapability, AvScalarField, AvScalarFieldCapabilities, AvScalarFormat, AvScopedRelationMutations, AvScopedRelationReducers, AvWriteScopes, } from "./contracts/field.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";
@@ -26,31 +28,41 @@ export type { AvOperationAvailability, AvOperationVariantScopes, AvResourceOpera
 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 { 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, AvApplicationResourceFacade, AvAppTxFacade, AvAppTxFamilyFacade, AvAppTxResourceFacade, AvClientFacade, AvClientFamilyFacade, AvClientResourceFacade, AvClientTxFacade, AvClientTxFamilyFacade, AvClientTxResourceFacade, } from "./framework/operation-facade.js";
-export type { AvCreateDataInput, AvCursorInput, AvFieldKey, AvIncludeInput, AvNullsOrder, AvOperationArgumentMap, AvOperationArgumentsFor, AvOrderByEntry, AvOrderByInput, AvProjectionEntry, AvRelationProjectionInput, AvResourceKey, AvScalarOrderInput, AvSelectInput, AvSortDirection, AvUniqueWhereInput, AvUpdateDataInput, AvWhereInput, } from "./operations/operation-arguments.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 { AvDiagnostic, AvDiagnosticsSink, AvMcpDiagnostic, AvOperationDiagnostic, AvTransactionDiagnostic, } from "./runtime/diagnostics-reporter.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

@@ -2,6 +2,7 @@ export { defineResource, } from "./config/define-resource.js";
 export { createFramework } from "./framework/framework.factory.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

@@ -23,18 +23,23 @@ export { computeClientContractHash, verifyClientContractHash, } from "./contract
 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 { 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 { 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 type { AgentOperationRequest, ApplicationOperationRequest, ClientOperationRequest, ClientProtocolIdentity, FrameworkOperationRequest, } from "./runtime/operation-request.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 { AgentTransactionRequest, ApplicationTransactionRequest, ClientTransactionRequest, FrameworkTransactionRequest, } from "./transactions/transaction-request.js";

package/dist/internal.js

@@ -7,11 +7,17 @@ export { computeClientContractHash, verifyClientContractHash, } from "./contract
 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";

package/dist/operations/database-refusal.d.ts

@@ -0,0 +1,51 @@
+import type { AvValidationCode } from "./validation-code.js";
+/**
+ * Why the database refused a caller's value, each with the validation code and the
+ * issue message an adapter answers it with.
+ */
+export declare const DATABASE_REFUSALS: {
+    readonly tooLong: {
+        readonly code: "V1004";
+        readonly message: "The database refused this value: it is longer than the database can hold for its column.";
+    };
+    readonly outOfRange: {
+        readonly code: "V1004";
+        readonly message: "The database refused this value: it is outside the range its column can hold.";
+    };
+    readonly datetimeOutOfRange: {
+        readonly code: "V1004";
+        readonly message: "The database refused this value: the date and time is outside the range the database can hold.";
+    };
+    readonly divisionByZero: {
+        readonly code: "V1004";
+        readonly message: "The database refused this value: it divides by zero.";
+    };
+    readonly computedNull: {
+        readonly code: "V1004";
+        readonly message: "The database refused this value: the write computes no value for a column that requires one, as a division by zero does.";
+    };
+    readonly invalidInput: {
+        readonly code: "V1001";
+        readonly message: "The database refused this value: it is not valid input for its column's type.";
+    };
+    readonly nulInText: {
+        readonly code: "V1001";
+        readonly message: "The database refused this value: its text cannot contain the NUL character (U+0000).";
+    };
+    readonly nulInJson: {
+        readonly code: "V1001";
+        readonly message: "The database refused this value: its JSON cannot contain the NUL character (U+0000).";
+    };
+    readonly trailingEscape: {
+        readonly code: "V1001";
+        readonly message: "The database refused this value: a text match cannot end with the escape character \\.";
+    };
+    readonly backReference: {
+        readonly code: "V1012";
+        readonly message: "The data source refused this nested write: a record written through a relation cannot write that relation or its reference fields back.";
+    };
+};
+/** A reason the database refused a caller's value: a key of {@link DATABASE_REFUSALS}. */
+export type AvDatabaseRefusal = keyof typeof DATABASE_REFUSALS;
+/** Whether `message` is the message of a database refusal answered under `code`. */
+export declare function isDatabaseRefusalMessage(code: AvValidationCode, message: string): boolean;