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

package/dist/framework/framework.factory.js

@@ -1,28 +1,31 @@
 import { compileContracts } from "../compiler/contract.compiler.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 { createDiagnosticsReporter, createTransactionDiagnosticsChannel, recordDiagnosticsSink, } from "../runtime/diagnostics-reporter.js";
 import { createMisuseReporter, } from "../runtime/misuse-reporter.js";
 import { internalFailure, operationFailure, } from "../runtime/operation-response.js";
-import { createOperationRuntime } from "../runtime/operation-runtime.js";
+import { createOperationRuntime, createPipelineDependencies, } from "../runtime/operation-runtime.js";
 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 { createTransactionPlanAssembler } from "../transactions/transaction-plan-assembler.js";
 import { createTransactionRuntime } from "../transactions/transaction-runtime.js";
-import { FrameworkConstructionError } from "./framework-construction.error.js";
-import { createOperationFacade, createOperationTree, } from "./operation-facade.js";
+import { AvConstructionError } from "./framework-construction.error.js";
+import { createOperationFacade, createOperationTree, settleOperation, } from "./operation-facade.js";
+const APPLICATION_SQL_BUILDER = "$sql";
 export async function createFramework(config) {
     const configDiagnostics = validateFrameworkConfig(config);
     if (configDiagnostics.length > 0) {
-        throw new FrameworkConstructionError("configuration", configDiagnostics);
+        throw new AvConstructionError("configuration", configDiagnostics);
     }
     const model = config.adapter.model;
     if (model.transactions === "interactive" &&
         typeof config.adapter.transaction !== "function") {
-        throw new FrameworkConstructionError("discovery", [
+        throw new AvConstructionError("discovery", [
             {
                 code: "DISCOVERY_TRANSACTION_CAPABILITY_MISMATCH",
                 path: "adapter.transactions",
@@ -33,18 +36,20 @@ export async function createFramework(config) {
     const resolvedConfig = resolveFrameworkConfig(config);
     const compilation = await compileContracts(model, resolvedConfig);
     if (!compilation.ok) {
-        throw new FrameworkConstructionError("contract-compilation", compilation.diagnostics);
+        throw new AvConstructionError("contract-compilation", compilation.diagnostics);
     }
-    const execute = createOperationRuntime({
-        adapter: config.adapter,
-        contracts: compilation.contracts,
-        config: resolvedConfig,
-    });
-    const executeTransaction = createTransactionRuntime({
+    const forcing = validateForcedOperations(config, compilation.contracts);
+    if (forcing.length > 0) {
+        throw new AvConstructionError("configuration", forcing);
+    }
+    const runtimeDependencies = {
         adapter: config.adapter,
         contracts: compilation.contracts,
         config: resolvedConfig,
-    });
+    };
+    const pipelineDependencies = createPipelineDependencies(runtimeDependencies, model);
+    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 protocol = {
@@ -53,28 +58,34 @@ export async function createFramework(config) {
     };
     const assembler = createTransactionPlanAssembler(compilation.contracts, protocol, misuse);
     const framework = {
-        entrypoint: resolvedConfig.entrypoint,
+        api: resolvedConfig.api,
+        mcp: resolvedConfig.mcp,
         contracts: compilation.contracts,
-        application: createOperationFacade(model, (resource, identity, args, requestId) => ({
+        application: createOperationFacade(model, (resource, identity, args, requestId, state) => ({
             ...identity,
             origin: "application",
             requestId,
+            ...(state === undefined ? {} : { state }),
             resource,
             arguments: args,
         }), executeOperation),
-        client: createOperationFacade(model, (resource, identity, args, requestId) => ({
+        client: createOperationFacade(model, (resource, identity, args, requestId, state) => ({
             ...identity,
             origin: "client",
             protocol,
             requestId,
+            ...(state === undefined ? {} : { state }),
             resource,
             arguments: args,
         }), executeOperation),
-        appTx: createOperationTree(model, (resource, identity) => (args) => assembler.defer("application", resource, identity, args === undefined ? {} : args)),
+        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)),
         execute: (request) => executeRequestTotally(execute, request, resolvedConfig.diagnostics, misuse),
         executeTransaction: (request) => executeTransactionRequestTotally(executeTransaction, request, resolvedConfig.diagnostics, misuse),
-        transaction: ((operations, options) => runTransactionTotally(executeTransaction, assembler, operations, requestIdOf(options), resolvedConfig.diagnostics)),
+        transaction: (async (operations, options) => settleOperation(await runTransactionTotally(executeTransaction, assembler, operations, requestIdOf(options), stateOptionOf(options), resolvedConfig.diagnostics))),
     };
     recordDiagnosticsSink(framework, resolvedConfig.diagnostics);
     recordOwnedExecution(framework, {
@@ -138,7 +149,7 @@ async function executeTransactionTotally(execute, request, diagnostics, origins,
         return internalFailure();
     }
 }
-async function runTransactionTotally(execute, assembler, operations, requestId, diagnostics) {
+async function runTransactionTotally(execute, assembler, operations, requestId, state, diagnostics) {
     let assembled;
     try {
         assembled = await assembler.assemble(operations);
@@ -154,5 +165,14 @@ async function runTransactionTotally(execute, assembler, operations, requestId,
     if (!assembled.ok) {
         return assembled.response;
     }
-    return executeTransactionTotally(execute, { origin: "application", requestId, plan: assembled.plan }, diagnostics, assembled.origins, { source: "owned", refused: assembled.refused });
+    return executeTransactionTotally(execute, {
+        origin: "application",
+        requestId,
+        ...(state === undefined ? {} : { state }),
+        plan: assembled.plan,
+    }, diagnostics, assembled.origins, {
+        source: "owned",
+        refused: assembled.refused,
+        statements: assembled.statements,
+    });
 }

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

@@ -1,72 +1,137 @@
-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 { 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 { AvOperationIdentity } from "../operations/operation-identity.js";
+import type { AvExecutionOptions } 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";
+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 { AvTransactionResponse } from "../transactions/transaction-response.js";
+import type { AvContractApplicationView, 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
+ * 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 four typed surfaces of an `AvFramework`, named by the member that holds each. */
+type FacadeSurface = "application" | "client" | "appTx" | "clientTx";
 /**
- * `framework.application`: one call per operation the Application Contract's
- * view advertises, its arguments in the application forms.
+ * One variant on a surface: a direct call (application or wire forms), or a
+ * deferred one for a transaction (`appTx`, `clientTx`).
  */
-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;
+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">;
+/** 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.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.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.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.client`: the same over the Client Contract's view, its arguments in
- * the wire forms.
+ * `framework.application`: one {@link AvApplicationResourceFacade} per Resource
+ * of `C`, the Application Contract's view.
  */
-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 AvApplicationFacade<C extends AvContract> = {
+    readonly [R in AvResourceKey<C>]: AvApplicationResourceFacade<C, R>;
+};
 /**
- * `framework.appTx`: one deferred operation per operation the Application
- * Contract's view advertises — application rules, application forms.
+ * `framework.client`: one {@link AvClientResourceFacade} 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 AvClientFacade<C extends AvContract> = {
+    readonly [R in AvResourceKey<C>]: AvClientResourceFacade<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}.
+     */
+    readonly $sql: SqlStatementBuilder;
+};
+/**
+ * `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.clientTx`: one {@link AvClientTxResourceFacade} per Resource of
+ * `C`, the Client Contract's view.
+ */
+export type AvClientTxFacade<C extends AvContract> = {
+    readonly [R in AvResourceKey<C>]: AvClientTxResourceFacade<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 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;
+/** `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.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>>;
+/**
+ * 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) => FrameworkOperationRequest;
+type FacadeExecutor = (request: FrameworkOperationRequest) => 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 +139,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;
+export 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,16 @@
 import { isOperationVariantAvailable } from "../contracts/resource-operations.js";
 import { parseOperationIdentity } from "../operations/operation-identity.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)))));
+}
+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,56 @@
-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 { 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, } from "./contracts/contract.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 { 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 { 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, 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 { 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 { AvDecimal } from "./runtime/decimal.js";
+export type { AvDiagnostic, AvDiagnosticsSink, AvMcpDiagnostic, AvOperationDiagnostic, AvTransactionDiagnostic, } from "./runtime/diagnostics-reporter.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 { 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 { 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 { 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,7 @@
-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 { 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,17 +6,19 @@
  * 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";
@@ -25,11 +27,14 @@ 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 { 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 { 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 { ApplicationTransactionRequest, ClientTransactionRequest, FrameworkTransactionRequest, } from "./transactions/transaction-request.js";
+export type { AgentTransactionRequest, ApplicationTransactionRequest, ClientTransactionRequest, FrameworkTransactionRequest, } from "./transactions/transaction-request.js";

package/dist/internal.js

@@ -2,7 +2,7 @@ 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";
@@ -12,5 +12,7 @@ export { isOperationVariantAvailable, projectionScopeOf, writeScopeOf, } from ".
 export { BUILT_IN_SCALARS } from "./contracts/scalar.js";
 export { TRANSACTION_CAPABILITIES } from "./contracts/transaction-capability.js";
 export { VALIDATION_CODES } from "./operations/validation-code.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";