@aventara/core 1.0.0-rc.8 → 1.0.0-rc.9

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

@@ -20,8 +20,8 @@ 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). */
@@ -38,13 +38,28 @@ export type AvAppTxPlainCall<in out C extends AvContract, in out R extends AvRes
 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`), projecting when its
- * arguments carry a `select` (as `AvOperationCall` and `AvDeferredOperationCall`
- * decide it).
+ * deferred one for a transaction (`appTx`, `clientTx`, `serverClientTx`),
+ * projecting when its arguments carry a `select` (as `AvOperationCall` and
+ * `AvDeferredOperationCall` decide it). `serverClient` and `serverClientTx` take
+ * the application forms over the Client Contract's view.
  */
-type SurfaceCall<C extends AvContract, R extends AvResourceKey<C>, I extends AvOperationIdentity, S extends FacadeSurface> = S extends "application" ? "select" extends keyof AvOperationArgumentsFor<C, R, I, AvApplicationScalarForms> ? AvApplicationProjectingCall<C, R, I> : AvApplicationPlainCall<C, R, I> : S extends "client" ? "select" extends keyof AvOperationArgumentsFor<C, R, I, AvWireScalarForms> ? AvClientProjectingCall<C, R, I> : AvClientPlainCall<C, R, I> : S extends "appTx" ? "select" extends keyof DeferredArguments<C, R, I, AvApplicationScalarForms, AvApplicationScalarForms> ? AvAppTxProjectingCall<C, R, I> : AvAppTxPlainCall<C, R, I> : "select" extends keyof DeferredArguments<C, R, I, AvWireScalarForms, AvApplicationScalarForms> ? AvClientTxProjectingCall<C, R, I> : AvClientTxPlainCall<C, R, I>;
+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. */
@@ -55,10 +70,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>;
@@ -67,6 +86,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>;
@@ -75,6 +98,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.
@@ -89,6 +116,13 @@ 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 = {
     /**
@@ -112,18 +146,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. */
+export type ServerClientOperations<M extends AvAdapterModel, Cfg> = ServerClientSurface<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>>;
+/** `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.

package/dist/index.d.ts

@@ -32,12 +32,13 @@ 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, AvApplicationPlainCall, AvApplicationProjectingCall, AvApplicationResourceFacade, AvAppTxFacade, AvAppTxFamilyFacade, AvAppTxPlainCall, AvAppTxProjectingCall, AvAppTxResourceFacade, AvClientFacade, AvClientFamilyFacade, AvClientPlainCall, AvClientProjectingCall, AvClientResourceFacade, AvClientTxFacade, AvClientTxFamilyFacade, AvClientTxPlainCall, AvClientTxProjectingCall, AvClientTxResourceFacade, } from "./framework/operation-facade.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 { AvPolicyEngine, AvPolicyWhere, } from "./policy/policy-engine.js";
 export type { AvPrebuiltContracts } from "./prebuilt/prebuilt-contracts.js";
 export { AvDecimal } from "./runtime/decimal.js";

package/dist/internal.d.ts

@@ -32,6 +32,7 @@ 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 { accessStateOf } from "./policy/access-provider.registry.js";
 export { prebuiltFileChanges } from "./prebuilt/prebuilt-changes.js";
 export { emitPrebuiltContracts, prebuiltContractsOf, } from "./prebuilt/prebuilt-contracts.emitter.js";
 export { mcpFailureReporterOf } from "./runtime/diagnostics-reporter.js";

package/dist/internal.js

@@ -13,6 +13,7 @@ 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 { accessStateOf } from "./policy/access-provider.registry.js";
 export { prebuiltFileChanges } from "./prebuilt/prebuilt-changes.js";
 export { emitPrebuiltContracts, prebuiltContractsOf, } from "./prebuilt/prebuilt-contracts.emitter.js";
 export { mcpFailureReporterOf } from "./runtime/diagnostics-reporter.js";

package/dist/policy/access-provider.interface.d.ts

@@ -0,0 +1,36 @@
+import type { AvState } from "../runtime/request-state.js";
+import type { AvPolicyEngine } from "./policy-engine.js";
+/**
+ * What the framework's `access` option takes: the policy engine every client
+ * and agent request is checked against, and how a request's state is seeded.
+ * Aventara Access provides one; one written by hand works the same way.
+ *
+ * The request's principal is `ctx.$state.me` (`null` when it is absent), so
+ * `state` names it as `me`. With `access`, the configuration states no
+ * `policy`, and the host no `state` of its own.
+ */
+export interface AvAccessProvider {
+    /** The policy engine (`AvPolicyEngine`), asked about every client and agent request. */
+    readonly policy: AvPolicyEngine;
+    /**
+     * Seeds a request's `ctx.$state` from its headers (a Web `Headers`): `me`, the principal the
+     * policy is asked about (`null` for an anonymous caller), and anything else
+     * the stages read. Called once per request by the host. `request` is the
+     * host's own request when it has one: Express's `req`, Fastify's
+     * `request`, or the Next.js route handler's `Request`. A throw is answered
+     * like any developer failure: a thrown `AvError` as its own outcome,
+     * anything else as an internal failure.
+     */
+    state(input: {
+        readonly headers: {
+            get(name: string): string | null;
+            has(name: string): boolean;
+            forEach(callback: (value: string, name: string) => void): void;
+        };
+        readonly request?: unknown;
+    }): (AvState & {
+        readonly me: unknown;
+    }) | Promise<AvState & {
+        readonly me: unknown;
+    }>;
+}

package/dist/policy/access-provider.interface.js

@@ -0,0 +1 @@
+export {};

package/dist/policy/access-provider.registry.d.ts

@@ -0,0 +1,9 @@
+import type { AvAccessProvider } from "./access-provider.interface.js";
+/** Records the provider `framework` was configured with; called once, at construction. */
+export declare function recordAccessProvider(framework: object, access: AvAccessProvider | undefined): void;
+/**
+ * The `state` of the provider `framework` was configured with (`access`),
+ * called on the provider; `undefined` for a Framework without `access`, or a
+ * value that is no constructed Framework.
+ */
+export declare function accessStateOf(framework: object): AvAccessProvider["state"] | undefined;

package/dist/policy/access-provider.registry.js

@@ -0,0 +1,10 @@
+const ACCESS_PROVIDERS = new WeakMap();
+export function recordAccessProvider(framework, access) {
+    if (access !== undefined) {
+        ACCESS_PROVIDERS.set(framework, access);
+    }
+}
+export function accessStateOf(framework) {
+    const access = ACCESS_PROVIDERS.get(framework);
+    return access === undefined ? undefined : (input) => access.state(input);
+}

package/dist/policy/policy-startup.validator.js

@@ -3,10 +3,10 @@ const TO_MANY_OPERATORS = new Set(["some", "every", "none"]);
 function invalid(path, message) {
     return { code: "CONFIG_INVALID_VALUE", path, message };
 }
-function governedDiagnostics(core, governed) {
+function governedDiagnostics(core, { at, governed }) {
     const diagnostics = [];
     for (const [resourceName, names] of Object.entries(governed)) {
-        const path = `policy.engine.governed.${resourceName}`;
+        const path = `${at}.governed.${resourceName}`;
         const resource = lookupResource(core, resourceName);
         if (resource === undefined) {
             diagnostics.push(invalid(path, `"${resourceName}" is no Resource of the Core Contract`));
@@ -20,9 +20,9 @@ function governedDiagnostics(core, governed) {
     }
     return diagnostics;
 }
-function afterCheckDiagnostics(core, afterChecks) {
+function afterCheckDiagnostics(core, { at, afterChecks }) {
     return Object.keys(afterChecks).flatMap((resourceName) => {
-        const path = `policy.engine.afterChecks.${resourceName}`;
+        const path = `${at}.afterChecks.${resourceName}`;
         return lookupResource(core, resourceName) === undefined
             ? [invalid(path, `"${resourceName}" is no Resource of the Core Contract`)]
             : [];
@@ -82,10 +82,10 @@ function pathFault(core, path) {
     }
     return `the path ends at Resource "${current}", not at a field`;
 }
-function pathDiagnostics(core, paths) {
+function pathDiagnostics(core, policy) {
     const diagnostics = [];
-    for (const [rule, list] of Object.entries(paths)) {
-        const at = `policy.engine.paths.${rule}`;
+    for (const [rule, list] of Object.entries(policy.paths)) {
+        const at = `${policy.at}.paths.${rule}`;
         for (const path of list) {
             const fault = pathFault(core, path);
             if (fault !== undefined) {
@@ -97,8 +97,8 @@ function pathDiagnostics(core, paths) {
 }
 export function policyStartupDiagnostics(core, policy) {
     return [
-        ...governedDiagnostics(core, policy.governed),
-        ...pathDiagnostics(core, policy.paths),
-        ...afterCheckDiagnostics(core, policy.afterChecks),
+        ...governedDiagnostics(core, policy),
+        ...pathDiagnostics(core, policy),
+        ...afterCheckDiagnostics(core, policy),
     ];
 }

package/dist/prebuilt/core-version.generated.d.ts

@@ -1,2 +1,2 @@
 /** The version of this `@aventara/core`. */
-export declare const CORE_VERSION = "1.0.0-rc.8";
+export declare const CORE_VERSION = "1.0.0-rc.9";

package/dist/prebuilt/core-version.generated.js

@@ -1 +1 @@
-export const CORE_VERSION = "1.0.0-rc.8";
+export const CORE_VERSION = "1.0.0-rc.9";

package/dist/prebuilt/prebuilt-inputs.fingerprint.js

@@ -126,12 +126,27 @@ function policyInput(policy) {
         : undefined;
     return { ...policy, engine: { governed: governed ?? null } };
 }
+function accessInput(access) {
+    if (!isRecord(access)) {
+        return access;
+    }
+    const engine = access.policy;
+    const governed = engine !== null && typeof engine === "object"
+        ? engine.governed
+        : undefined;
+    return { policy: { governed: governed ?? null } };
+}
 function authoredInputs(config) {
     const authored = config;
     const root = {};
     for (const key of Object.keys(authored)) {
         if (!NOT_INPUTS.has(key)) {
-            root[key] = key === "policy" ? policyInput(authored[key]) : authored[key];
+            root[key] =
+                key === "policy"
+                    ? policyInput(authored[key])
+                    : key === "access"
+                        ? accessInput(authored[key])
+                        : authored[key];
         }
     }
     return root;

package/dist/protocol/http-response.encoder.js

@@ -1,5 +1,5 @@
 import { encodeBase64, WIRE_SCALAR_PATTERNS, } from "../contracts/wire-scalar-format.js";
-import { AvDecimal } from "../runtime/decimal.js";
+import { isAvDecimal } from "../runtime/decimal.js";
 import { SERIALIZATION_FAILURE_MESSAGE } from "../runtime/error-boundary.js";
 import { operationFailure, } from "../runtime/operation-response.js";
 import { httpStatus } from "./http-status.table.js";
@@ -161,7 +161,7 @@ function scalarWireText(value) {
         }
         return JSON.stringify(wire);
     }
-    if (value instanceof AvDecimal) {
+    if (isAvDecimal(value)) {
         return JSON.stringify(value.toString());
     }
     if (value instanceof Uint8Array) {

package/dist/runtime/caller-data.copier.js

@@ -1,4 +1,4 @@
-import { AvDecimal } from "./decimal.js";
+import { AvDecimal, decimalDigitsOf, isAvDecimal } from "./decimal.js";
 const FAILURE_MESSAGES = {
     "unreadable-value": "Value could not be read.",
     "non-plain-value": "Value must be plain data.",
@@ -19,7 +19,6 @@ const NO_POLICY = {};
 const OBJECT_PROTOTYPE = Object.prototype;
 const DATE_PROTOTYPE = Date.prototype;
 const dateValueOf = Date.prototype.getTime;
-const decimalValueOf = AvDecimal.prototype.toString;
 const FAST_WALK_DEPTH = 256;
 const SLOW_WALK = Symbol("slow walk");
 class FastWalkFailure {
@@ -33,8 +32,8 @@ function copyValueType(value, prototype) {
     if (prototype === DATE_PROTOTYPE || value instanceof Date) {
         return new Date(dateValueOf.call(value));
     }
-    if (value instanceof AvDecimal) {
-        return new AvDecimal(decimalValueOf.call(value));
+    if (isAvDecimal(value)) {
+        return new AvDecimal(decimalDigitsOf(value));
     }
     if (value instanceof Uint8Array) {
         return new Uint8Array(value);

package/dist/runtime/core-class.brand.d.ts

@@ -0,0 +1,10 @@
+/** The registered symbol every copy of this major brands class `name` with. */
+export declare function coreBrandOf(name: string): symbol;
+/** Whether `value` carries `brand`, wherever it was made: one `in`. */
+export declare function hasCoreBrand(value: unknown, brand: symbol): boolean;
+/**
+ * Brands `type`'s prototype as `name` and makes `instanceof type` read the brand.
+ * A developer's own subclass of `type` inherits the static `Symbol.hasInstance`, so
+ * on any constructor but `type` itself it answers as `instanceof` always does.
+ */
+export declare function brandCoreClass(type: abstract new (...args: never[]) => object, name: string): symbol;

package/dist/runtime/core-class.brand.js

@@ -0,0 +1,21 @@
+import { CORE_VERSION } from "../prebuilt/core-version.generated.js";
+const CORE_MAJOR = CORE_VERSION.slice(0, CORE_VERSION.indexOf("."));
+export function coreBrandOf(name) {
+    return Symbol.for(`aventara.core.${name}@${CORE_MAJOR}`);
+}
+export function hasCoreBrand(value, brand) {
+    return typeof value === "object" && value !== null && brand in value;
+}
+const ordinaryHasInstance = Function.prototype[Symbol.hasInstance];
+export function brandCoreClass(type, name) {
+    const brand = coreBrandOf(name);
+    Object.defineProperty(type.prototype, brand, { value: true });
+    Object.defineProperty(type, Symbol.hasInstance, {
+        value: function hasInstance(value) {
+            return this === type
+                ? hasCoreBrand(value, brand)
+                : ordinaryHasInstance.call(this, value);
+        },
+    });
+    return brand;
+}

package/dist/runtime/decimal.d.ts

@@ -12,3 +12,17 @@ export declare class AvDecimal {
      */
     toJSON(): string;
 }
+/**
+ * Whether `value` is an `AvDecimal`, made by this copy of core or by another of
+ * its major: one `in`, for the hot paths that ask about every value.
+ */
+export declare function isAvDecimal(value: unknown): value is AvDecimal;
+/**
+ * The digits of `value`, read without running anything the caller could have put
+ * on it when this copy made it. Another copy's decimal is read through its own
+ * `toString`, which only that copy can answer; what it returns is checked as a
+ * decimal string, so the caller's copy keeps the grammar.
+ *
+ * @throws TypeError when another copy's decimal does not answer a decimal string.
+ */
+export declare function decimalDigitsOf(value: AvDecimal): string;

package/dist/runtime/decimal.js

@@ -1,6 +1,11 @@
 import { WIRE_SCALAR_PATTERNS } from "../contracts/wire-scalar-format.js";
+import { brandCoreClass, hasCoreBrand } from "./core-class.brand.js";
+let ownDigitsOf;
 export class AvDecimal {
     #value;
+    static {
+        ownDigitsOf = (value) => (#value in value ? value.#value : undefined);
+    }
     constructor(value) {
         if (typeof value !== "string") {
             throw new TypeError("Decimal value must be a string.");
@@ -17,3 +22,19 @@ export class AvDecimal {
         return this.#value;
     }
 }
+const DECIMAL_BRAND = brandCoreClass(AvDecimal, "AvDecimal");
+export function isAvDecimal(value) {
+    return hasCoreBrand(value, DECIMAL_BRAND);
+}
+export function decimalDigitsOf(value) {
+    const own = ownDigitsOf(value);
+    if (own !== undefined) {
+        return own;
+    }
+    const digits = value.toString();
+    if (typeof digits !== "string" ||
+        !WIRE_SCALAR_PATTERNS.decimal.test(digits)) {
+        throw new TypeError("Decimal value must be a valid decimal string.");
+    }
+    return digits;
+}

package/dist/runtime/diagnostics-reporter.js

@@ -1,3 +1,4 @@
+import { coreBrandOf } from "./core-class.brand.js";
 import { internalFailure, } from "./operation-response.js";
 import { requestIdOf } from "./request-id.js";
 const IGNORE_DIAGNOSTIC = () => undefined;
@@ -31,7 +32,18 @@ export function createReporter(sink, identity) {
         }
     };
 }
-const CONFIGURED_SINKS = new WeakMap();
+const CONFIGURED_SINKS = sharedSinkRegistry();
+function sharedSinkRegistry() {
+    const key = coreBrandOf("diagnostics");
+    const holder = globalThis;
+    const existing = holder[key];
+    if (existing instanceof WeakMap) {
+        return existing;
+    }
+    const registry = new WeakMap();
+    Object.defineProperty(holder, key, { value: registry });
+    return registry;
+}
 export function mcpFailureReporterOf(framework) {
     const sink = CONFIGURED_SINKS.get(framework);
     return (error) => {

package/dist/runtime/framework-error.js

@@ -1,3 +1,4 @@
+import { brandCoreClass } from "./core-class.brand.js";
 export class AvError extends Error {
     name = "AvError";
     code;
@@ -30,3 +31,11 @@ export class AvProtocolError extends AvError {
 export class AvContractMismatchError extends AvError {
     name = "AvContractMismatchError";
 }
+brandCoreClass(AvError, "AvError");
+brandCoreClass(AvValidationError, "AvValidationError");
+brandCoreClass(AvNotFoundError, "AvNotFoundError");
+brandCoreClass(AvConflictError, "AvConflictError");
+brandCoreClass(AvAuthError, "AvAuthError");
+brandCoreClass(AvInternalError, "AvInternalError");
+brandCoreClass(AvProtocolError, "AvProtocolError");
+brandCoreClass(AvContractMismatchError, "AvContractMismatchError");

package/dist/runtime/readonly-value.d.ts

@@ -1,4 +1,4 @@
-import { AvDecimal } from "./decimal.js";
+import { type AvDecimal } from "./decimal.js";
 /** A value `AvDeepReadonly` leaves as it is: a primitive, a function, or a scalar instance. */
 export type AvDeepReadonlyLeaf = string | number | boolean | bigint | symbol | null | undefined | Date | Uint8Array | AvDecimal | ((...args: never[]) => unknown);
 /**

package/dist/runtime/readonly-value.js

@@ -1,4 +1,4 @@
-import { AvDecimal } from "./decimal.js";
+import { isAvDecimal } from "./decimal.js";
 function isContainer(value) {
     if (value === null || typeof value !== "object") {
         return false;
@@ -6,7 +6,7 @@ function isContainer(value) {
     if (Array.isArray(value)) {
         return true;
     }
-    if (value instanceof AvDecimal) {
+    if (isAvDecimal(value)) {
         return false;
     }
     const prototype = Object.getPrototypeOf(value);

package/dist/runtime/scalar-runtime.js

@@ -4,7 +4,7 @@ import { FILTER_MODES, } from "../contracts/capability.js";
 import { lookupField, lookupOwn, lookupResource, } from "../contracts/contract-lookup.js";
 import { decodeBase64, WIRE_SCALAR_PATTERNS, } from "../contracts/wire-scalar-format.js";
 import { routeTransactionReferenceCandidate, } from "../transactions/transaction-reference.js";
-import { AvDecimal } from "./decimal.js";
+import { AvDecimal, isAvDecimal } from "./decimal.js";
 import { fieldCheckIssues } from "./field-check.evaluator.js";
 const INT_MIN = -(2 ** 31);
 const INT_MAX = 2 ** 31 - 1;
@@ -238,10 +238,9 @@ function normalizeScalarAtom(contract, field, value, origin, path, allowNull) {
             break;
         case "decimal":
             if (origin === "application") {
-                normalized =
-                    value instanceof AvDecimal
-                        ? { ok: true, value }
-                        : { ok: false, issues: [typeIssue(path, "an Aventara Decimal")] };
+                normalized = isAvDecimal(value)
+                    ? { ok: true, value }
+                    : { ok: false, issues: [typeIssue(path, "an Aventara Decimal")] };
             }
             else if (typeof value !== "string") {
                 normalized = {

package/dist/transactions/operation-arguments-encoder.js

@@ -1,6 +1,6 @@
 import { lookupField, lookupResource } from "../contracts/contract-lookup.js";
 import { encodeBase64 } from "../contracts/wire-scalar-format.js";
-import { AvDecimal } from "../runtime/decimal.js";
+import { isAvDecimal } from "../runtime/decimal.js";
 import { isRelationMutationDirective, RELATION_MUTATION_RECORD_SITES, } from "../runtime/mutation-planner.js";
 import { isTransactionReferenceCandidate } from "./transaction-reference.js";
 function isPlainRecord(value) {
@@ -27,9 +27,11 @@ function encodeScalarAtom(field, value) {
         case "bigint":
             return typeof value === "bigint" ? value.toString(10) : value;
         case "decimal":
-            return value instanceof AvDecimal ? value.toString() : value;
+            return isAvDecimal(value) ? value.toString() : value;
         case "datetime":
-            return value instanceof Date ? value.toISOString() : value;
+            return value instanceof Date && !Number.isNaN(value.getTime())
+                ? value.toISOString()
+                : value;
         case "bytes":
             return value instanceof Uint8Array ? encodeBase64(value) : value;
         default:
@@ -282,6 +284,9 @@ function isUniqueOperation(operation) {
             operation.family === "upsert"));
 }
 export function encodeOperationArgumentsForWire(contract, operation, args) {
+    if (!isPlainRecord(args)) {
+        return args;
+    }
     const encoded = cloneRecord(args);
     if (hasOwnWireProperty(args, "where")) {
         encoded.where = isUniqueOperation(operation)

package/dist/transactions/sql-statement.validator.js

@@ -1,7 +1,7 @@
 import { validationIssue } from "../operations/validation-code.js";
 import { AvCallerDataError, locateCallerDataError, } from "../runtime/caller-data.copier.js";
 import { refuseCallerData } from "../runtime/caller-data.door.js";
-import { AvDecimal } from "../runtime/decimal.js";
+import { isAvDecimal } from "../runtime/decimal.js";
 import { planStepPath } from "../runtime/error-boundary.js";
 import { operationFailure } from "../runtime/operation-response.js";
 import { mapValidationOutcome } from "../runtime/outcome-mapper.js";
@@ -19,7 +19,7 @@ export function normalizeSqlValue(value, path) {
         typeof value === "string" ||
         typeof value === "boolean" ||
         typeof value === "bigint" ||
-        value instanceof AvDecimal ||
+        isAvDecimal(value) ||
         value instanceof Uint8Array) {
         return { ok: true, value };
     }

package/dist/transactions/transaction-integrity-error.js

@@ -1,3 +1,4 @@
+import { brandCoreClass } from "../runtime/core-class.brand.js";
 const TRANSACTION_INTEGRITY_MESSAGES = {
     "transaction-unavailable": "Adapter transaction function is unavailable.",
     "resolved-after-abort": "Adapter transaction resolved after the framework requested rollback.",
@@ -15,3 +16,4 @@ export class AvTransactionIntegrityError extends Error {
         this.violation = violation;
     }
 }
+brandCoreClass(AvTransactionIntegrityError, "AvTransactionIntegrityError");

package/dist/transactions/transaction-plan-assembler.d.ts

@@ -9,6 +9,8 @@ import type { PlannedSqlStatement } from "./sql-statement.js";
 import type { TransactionOperationOrigin } from "./transaction-request.js";
 /** The origin a handle's builder gives it. */
 type HandleOrigin = "application" | "client";
+/** The scalar forms a builder takes its arguments in. */
+type ArgumentForms = "wire" | "application";
 /** One wire node, exactly as the transaction runtime receives it. */
 type WireOperationNode = {
     readonly resource: string;
@@ -37,8 +39,13 @@ export type AssembledTransactionPlan = {
     readonly response: AvOperationFailureResponse;
 };
 export type TransactionPlanAssembler = {
-    /** Defers one operation into a handle; nothing runs. */
-    defer(origin: HandleOrigin, resource: string, identity: AvOperationIdentity, args: unknown): AvOperation<unknown>;
+    /**
+     * Defers one operation into a handle; nothing runs. `forms` says which scalar
+     * forms a client-origin handle's arguments are in: `"wire"` (`clientTx`, the
+     * default) or `"application"` (`serverClientTx`), encoded into the wire forms
+     * from the builder's copy.
+     */
+    defer(origin: HandleOrigin, resource: string, identity: AvOperationIdentity, args: unknown, forms?: ArgumentForms): AvOperation<unknown>;
     /** Defers one `appTx.$sql` statement into a handle; nothing runs. */
     deferSql(strings: unknown, values: readonly unknown[]): AvOperation<unknown>;
     /** Binds a list of handles into the passive plan, or refuses it. */