@aventara/core 1.0.0-rc.11 → 1.0.0-rc.13

package/dist/config/computed-fields.d.ts

@@ -38,6 +38,14 @@ type CreateComputedOf<Layer> = Layer extends object ? {
 export type AvPreComputeLift<M, L extends AvConfigLayerName> = M extends {
     readonly "~computedFields"?: infer Facts;
 } ? Exclude<Facts, undefined> extends infer Stated extends AvConfigComputedFields ? string extends keyof Stated["root"] ? string : CreateComputedOf<Stated[ComputingLayers<Stated, L>]> : string : string;
+/**
+ * The create fields a ctx call need not write, as `"<Resource>.<field>"`: those
+ * the root's or the application's `compute.create` fills. `never` when the
+ * model's type carries no statement of them.
+ */
+export type AvContextComputeLift<M> = M extends {
+    readonly "~computedFields"?: infer Facts;
+} ? Exclude<Facts, undefined> extends infer Stated extends AvConfigComputedFields ? string extends keyof Stated["root"] ? never : CreateComputedOf<Stated["root" | "application"]> : never : never;
 /** The configuration's layers' `resources` trees and the agent's parent. */
 type ComputedFieldsSource = {
     readonly trees: Readonly<Record<AvConfigLayerName, unknown>>;

package/dist/config/computed-fields.js

@@ -66,7 +66,7 @@ export function warnOnStaleComputedFields(generated, configured) {
     if (drift.length === 0) {
         return;
     }
-    const message = `generated types are stale: run aventara:prepare. The computed fields the pre-compute stages are typed with differ from the configuration's:\n${drift
+    const message = `generated types are stale: run aventara:prepare. The computed fields the pre-compute stages and ctx creates are typed with differ from the configuration's:\n${drift
         .map((line) => `  - ${line}`)
         .join("\n")}`;
     emitFrameworkWarning(message, STALE_GENERATED_TYPES_WARNING);

package/dist/config/config-diagnostic.guidance.js

@@ -26,7 +26,7 @@ export const CONFIG_DIAGNOSTIC_GUIDANCE = {
     },
     CONFIG_FORBIDDEN_IN_OVERLAY: {
         message: "A root-only key is written in an overlay.",
-        cause: "A field definition in application, client or agent.",
-        fix: "Define the field once at the root (`resources.<R>.fields.<f>.definition`); an overlay only chooses its visibility.",
+        cause: "A field definition, or a Resource's managedElsewhere, in application, client or agent.",
+        fix: "State it once at the root (`resources.<R>.fields.<f>.definition`, `resources.<R>.managedElsewhere`); an overlay only chooses visibility.",
     },
 };

package/dist/config/config.resolver.d.ts

@@ -1,7 +1,7 @@
 import type { AvAdapter } from "../adapters/adapter.interface.js";
 import type { AvAdapterModel } from "../adapters/adapter-model.js";
 import type { AvContractClientAccess } from "../contracts/contract-access.js";
-import type { AvTransactionCapability } from "../contracts/transaction-capability.js";
+import type { TransactionsStyle } from "../contracts/transaction-capability.js";
 import type { AvPolicyEngine } from "../policy/policy-engine.js";
 import type { AvDiagnosticsSink } from "../runtime/diagnostics-reporter.js";
 import type { AvMisuseSink } from "../runtime/misuse-reporter.js";
@@ -45,7 +45,7 @@ export type ResolvedFrameworkLayerConfig = {
      * registrations, then the overlay's, at each level.
      */
     readonly pipelines: ResolvedPipelineTree;
-    readonly transactionsStyle: AvTransactionCapability | undefined;
+    readonly transactionsStyle: TransactionsStyle | undefined;
 };
 /**
  * The MCP endpoint a Framework serves (`mcp` resolved): its mount path in

package/dist/config/config.validator.js

@@ -1,5 +1,5 @@
 import { isAccessPath, isAccessUrl } from "../contracts/access-route.rules.js";
-import { TRANSACTION_CAPABILITIES } from "../contracts/transaction-capability.js";
+import { TRANSACTIONS_STYLES } from "../contracts/transaction-capability.js";
 import { ACCESS_VERB_NAMES, isAccessVerbName, providerVerb, } from "../policy/access-verb.table.js";
 import { isPlainRecord } from "../runtime/record.guard.js";
 import { normalizeEntrypoint } from "./entrypoint.normalizer.js";
@@ -69,13 +69,14 @@ const OPERATION_FAMILIES = new Set([
     "upsert",
 ]);
 const OPERATION_VARIANTS = new Set(["first", "unique", "many", "count", "one"]);
-const TRANSACTION_CAPABILITY_SET = new Set(TRANSACTION_CAPABILITIES);
+const TRANSACTIONS_STYLE_SET = new Set(TRANSACTIONS_STYLES);
 const AVZ_FORMAT_SET = new Set(AVZ_FORMATS);
 const LIMIT_PROPERTIES = new Set([
     "maxRequestBytes",
     "maxNestingDepth",
     "maxListLimit",
     "maxTransactionOperations",
+    "maxTransactionWrites",
     "maxBooleanNodes",
     "maxJsonDepth",
     "maxAll",
@@ -436,6 +437,7 @@ function validateResources(value, path, isRoot, diagnostics) {
 const EXEMPTIONS_PROPERTIES = new Set(["resources"]);
 const RESOURCE_EXEMPTION_PROPERTIES = new Set(["operations", "fields"]);
 const FLAG_CAPABILITIES = new Set(["select", "include", "order", "orderNulls"]);
+const READ_EXEMPTION = "read";
 function movedHidden(path) {
     return diagnostic("CONFIG_MOVED_PROPERTY", path, `${path} moved in rc.1: an entry is hidden with \`true\` under exposed: true`);
 }
@@ -492,9 +494,12 @@ function validateOperationsExemption(value, path, diagnostics) {
     }
 }
 function validateFieldExemption(value, path, diagnostics) {
+    if (value === READ_EXEMPTION) {
+        return;
+    }
     const kind = validateExemptionValue(value, path, "a capability name", diagnostics);
     if (kind === undefined) {
-        diagnostics.push(diagnostic("CONFIG_INVALID_TYPE", path, `${path} must be true, false, a list of capability names, or an object of them`));
+        diagnostics.push(diagnostic("CONFIG_INVALID_TYPE", path, `${path} must be true, false, "read", a list of capability names, or an object of them`));
         return;
     }
     if (kind !== "object") {
@@ -543,7 +548,11 @@ function validateResourceExemption(value, path, diagnostics) {
             validateOperationsExemption(entry, keyPath, diagnostics);
             continue;
         }
-        if (!requireRecord(entry, keyPath, diagnostics)) {
+        if (entry === READ_EXEMPTION) {
+            continue;
+        }
+        if (!isPlainRecord(entry)) {
+            diagnostics.push(diagnostic("CONFIG_INVALID_TYPE", keyPath, `${keyPath} must be "read" or an object of field exemptions`));
             continue;
         }
         for (const [field, fieldEntry] of Object.entries(entry)) {
@@ -616,9 +625,9 @@ function validateLayer(value, path, kind, diagnostics) {
         validateExemptions(value.exemptions, exemptionsPath, diagnostics);
     }
     if (Object.hasOwn(value, "transactionsStyle") &&
-        !TRANSACTION_CAPABILITY_SET.has(value.transactionsStyle)) {
+        !TRANSACTIONS_STYLE_SET.has(value.transactionsStyle)) {
         const stylePath = childPath(path, "transactionsStyle");
-        diagnostics.push(diagnostic("CONFIG_INVALID_VALUE", stylePath, `${stylePath} must be "none" or "interactive"`));
+        diagnostics.push(diagnostic("CONFIG_INVALID_VALUE", stylePath, `${stylePath} must be "none", "server" or "interactive"`));
     }
     if (Object.hasOwn(value, "limits")) {
         validateLimits(value.limits, childPath(path, "limits"), diagnostics);

package/dist/config/exact-framework-config.d.ts

@@ -26,6 +26,7 @@ type LimitsSchema = {
     readonly maxNestingDepth: Leaf;
     readonly maxListLimit: Leaf;
     readonly maxTransactionOperations: Leaf;
+    readonly maxTransactionWrites: Leaf;
     readonly maxBooleanNodes: Leaf;
     readonly maxJsonDepth: Leaf;
     readonly maxAll: Leaf;

package/dist/config/field-pipeline-config.d.ts

@@ -20,9 +20,9 @@ export type AvFieldCompute<M extends AvAdapterModel = AvAdapterModel, Cfg = AvCo
 /**
  * A scalar field's stages: validators, field pipes, compute and write guards.
  * `Check` is the checks the field takes (any, when the field's type is not
- * known here).
+ * known here), or the sentence a type that takes none refuses them with.
  */
-export type AvScalarFieldPipeline<M extends AvAdapterModel = AvAdapterModel, Cfg = AvConfigAny, R extends AvConfigResourceKey<M> = AvConfigResourceKey<M>, Check extends AvZCheck = AvZCheck> = {
+export type AvScalarFieldPipeline<M extends AvAdapterModel = AvAdapterModel, Cfg = AvConfigAny, R extends AvConfigResourceKey<M> = AvConfigResourceKey<M>, Check extends AvZCheck | `Error: ${string}` = AvZCheck> = {
     /**
      * Declarative checks on the value, built with `AvZ` and carried in the Contract;
      * root's, then the overlay's. On a list field `AvZ.minItems` and `AvZ.maxItems`

package/dist/config/forced-operation.validator.js

@@ -1,4 +1,5 @@
 import { isOperationVariantAvailable } from "../contracts/resource-operations.js";
+import { opensServerTransactions } from "../contracts/transaction-capability.js";
 import { forcedOperationsOf } from "./pipeline-tree.resolver.js";
 function reachable(contract, resource, family, variant) {
     if (!Object.hasOwn(contract.resources, resource)) {
@@ -45,7 +46,7 @@ export function validateForcedOperations(config, contracts) {
         : ["application", "client"];
     for (const origin of origins) {
         const contract = contracts[origin];
-        if (contract.transactions !== "none") {
+        if (opensServerTransactions(contract.transactions)) {
             continue;
         }
         const forced = [
@@ -61,6 +62,6 @@ export function validateForcedOperations(config, contracts) {
     return [...refused].map(([path, layers]) => ({
         code: "CONFIG_INVALID_VALUE",
         path,
-        message: `${path}: forceTransaction runs a plain call as a one-step transaction, and the effective transactionsStyle of the ${layers.join(" and ")} ${layers.length === 1 ? "layer is" : "layers are"} "none"; set transactionsStyle: "interactive" there (the adapter must offer interactive transactions) or remove forceTransaction`,
+        message: `${path}: forceTransaction runs a plain call as a one-step transaction, and the effective transactionsStyle of the ${layers.join(" and ")} ${layers.length === 1 ? "layer is" : "layers are"} "none"; set transactionsStyle: "server" (no plans from callers) or "interactive" there (the adapter must offer interactive transactions) or remove forceTransaction`,
     }));
 }

package/dist/config/framework-config.d.ts

@@ -1,7 +1,6 @@
 import type { AvAdapter } from "../adapters/adapter.interface.js";
 import type { AvAdapterModel } from "../adapters/adapter-model.js";
 import type { AvContractLimits } from "../contracts/contract-limits.js";
-import type { AvTransactionCapability } from "../contracts/transaction-capability.js";
 import type { AvAccessProvider } from "../policy/access-provider.interface.js";
 import type { AvPolicyEngine } from "../policy/policy-engine.js";
 import type { AvPrebuiltContracts } from "../prebuilt/prebuilt-contracts.js";
@@ -38,8 +37,14 @@ export type AvConfigLayer<M extends AvAdapterModel = AvAdapterModel, Cfg = AvCon
      * the adapter's model, an overlay the root's view.
      */
     readonly exposed?: boolean;
-    /** `"none"` turns transactions off; `"interactive"` needs adapter support. */
-    readonly transactionsStyle?: AvTransactionCapability;
+    /**
+     * `"interactive"`: the server opens transactions and callers send plans
+     * (`/_transactions`, a generated client's `tx`). `"server"`: only the server
+     * opens them (`forceTransaction`, a policy-checked write, `ctx.$transaction`);
+     * a plan answers as an absent route. `"none"`: no transactions. Both
+     * `"server"` and `"interactive"` need adapter support.
+     */
+    readonly transactionsStyle?: "none" | "server" | "interactive";
     /** Request limits; see {@link AvConfigLimits}. */
     readonly limits?: AvConfigLimits;
     /** Guards, pipes, hooks, interceptors and filters run around every operation of the layer. */

package/dist/config/framework-exemptions-config.d.ts

@@ -8,8 +8,10 @@ import type { AvConfigResourceKey } from "./framework-field-definition.js";
 export type AvScalarFieldCapabilityName = "select" | "filter" | "order" | "orderNulls" | "create" | "update";
 /** The capability names a relation field's exemption can list. */
 export type AvRelationFieldCapabilityName = "select" | "include" | "filter" | "order" | "pagination" | "reducers" | "create" | "update";
-/** A scalar field's exemption: whole, by capability name, or per capability. */
-export type AvConfigScalarFieldExemption = boolean | readonly AvScalarFieldCapabilityName[] | ({
+/** The capabilities `"read"` names: every exemptable one but `create` and `update`. */
+export type ReadCapabilityName = Exclude<AvScalarFieldCapabilityName | AvRelationFieldCapabilityName, "create" | "update">;
+/** A scalar field's exemption: whole, its reads, by capability name, or per capability. */
+export type AvConfigScalarFieldExemption = boolean | "read" | readonly AvScalarFieldCapabilityName[] | ({
     readonly select?: boolean;
     readonly filter?: boolean | readonly AvScalarFilterOperator[];
     readonly order?: boolean;
@@ -17,8 +19,8 @@ export type AvConfigScalarFieldExemption = boolean | readonly AvScalarFieldCapab
     readonly create?: boolean | readonly AvScalarMutationDirective[];
     readonly update?: boolean | readonly AvScalarMutationDirective[];
 } & NotAList);
-/** A relation field's exemption: whole, by capability name, or per capability. */
-export type AvConfigRelationFieldExemption = boolean | readonly AvRelationFieldCapabilityName[] | ({
+/** A relation field's exemption: whole, its reads, by capability name, or per capability. */
+export type AvConfigRelationFieldExemption = boolean | "read" | readonly AvRelationFieldCapabilityName[] | ({
     readonly select?: boolean;
     readonly include?: boolean;
     readonly filter?: boolean | readonly AvRelationFilterCapability[];
@@ -58,13 +60,13 @@ type TokenExemption<Caps, K> = K extends keyof Caps ? boolean | readonly MemberT
 /** The capability names a discovered scalar's exemption can name: its own, and `select`. */
 type ScalarNameOf<Caps> = Extract<keyof Caps, AvScalarFieldCapabilityName> | "select";
 /** A discovered scalar field's exemption, by its capabilities. */
-type ScalarFieldExemptionOf<Caps> = boolean | readonly ScalarNameOf<Caps>[] | ({
+type ScalarFieldExemptionOf<Caps> = boolean | "read" | readonly ScalarNameOf<Caps>[] | ({
     readonly [K in ScalarNameOf<Caps>]?: K extends "filter" | "create" | "update" ? TokenExemption<Caps, K> : boolean;
 } & NotAList);
 /** The capability names a discovered relation's exemption can name: its own. */
 type RelationNameOf<Caps> = Extract<keyof Caps, AvRelationFieldCapabilityName>;
 /** A discovered relation field's exemption, by its capabilities. */
-type RelationFieldExemptionOf<Caps> = boolean | readonly RelationNameOf<Caps>[] | ({
+type RelationFieldExemptionOf<Caps> = boolean | "read" | readonly RelationNameOf<Caps>[] | ({
     readonly [K in RelationNameOf<Caps>]?: K extends "select" | "include" | "order" ? boolean : TokenExemption<Caps, K>;
 } & NotAList);
 /** The exemption shape one effective field name admits. */
@@ -74,10 +76,13 @@ type FieldExemptionFor<M extends AvAdapterModel, R extends AvConfigResourceKey<M
 } ? RelationFieldExemptionOf<Caps> : M["resources"][R]["fields"][F] extends {
     readonly capabilities: infer Caps;
 } ? ScalarFieldExemptionOf<Caps> : AvConfigScalarFieldExemption : AvConfigScalarFieldExemption;
-/** A Resource's exemption: whole, or its operations and fields. No list. */
+/**
+ * A Resource's exemption: whole, or its operations and fields, `fields` being
+ * per field or `"read"` (every field's reads). No list.
+ */
 export type AvConfigResourceExemption<M extends AvAdapterModel = AvAdapterModel, Cfg = AvConfigAny, R extends AvConfigResourceKey<M> = AvConfigResourceKey<M>> = boolean | ({
     readonly operations?: AvConfigOperationsExemption<M, R>;
-    readonly fields?: {
+    readonly fields?: "read" | {
         readonly [F in AvEffectiveFieldKey<M, Cfg, R>]?: FieldExemptionFor<M, R, F>;
     };
 } & NotAList);

package/dist/config/framework-resources-config.d.ts

@@ -59,13 +59,21 @@ export type AvConfigOverlayField<M extends AvAdapterModel = AvAdapterModel, Cfg
 };
 /** The checks a scalar type takes, or `never`. */
 type ScalarChecks<Scalar> = Scalar extends "string" ? AvZCheck<"string"> : Scalar extends "int" | "float" ? AvZCheck<"number"> : Scalar extends "bigint" | "decimal" | "datetime" | "bytes" ? AvZCheck<Scalar> : never;
+/** The checks a field's type takes, or `never` (an enum, a boolean). */
+type TypeChecks<Type> = Type extends {
+    readonly scalar: infer Scalar;
+} ? string extends Scalar ? AvZCheck : ScalarChecks<Scalar> : never;
+/** Why a field whose type takes no check refuses one; a list still takes its length. */
+type NoCheckRefusal<Type, List> = Type extends {
+    readonly enum: string;
+} ? false extends List ? "Error: an enum field takes no check: its enum already is the closed set of values it admits" : "Error: an enum list takes only a list length (AvZ.minItems, AvZ.maxItems): its enum already is the closed set of values it admits" : Type extends {
+    readonly scalar: infer Scalar extends string;
+} ? false extends List ? `Error: a ${Scalar} field takes no check` : `Error: a ${Scalar} list takes only a list length (AvZ.minItems, AvZ.maxItems)` : false extends List ? "Error: this field's type takes no check" : "Error: this field's type takes only a list length (AvZ.minItems, AvZ.maxItems)";
 /** The checks a discovered scalar field takes: its type's, and a list's length. */
 type FieldCheckOf<Field> = Field extends {
     readonly type: infer Type;
     readonly list: infer List;
-} ? (Type extends {
-    readonly scalar: infer Scalar;
-} ? string extends Scalar ? AvZCheck : ScalarChecks<Scalar> : never) | (false extends List ? never : AvZCheck<"list">) : AvZCheck;
+} ? ([TypeChecks<Type>] extends [never] ? NoCheckRefusal<Type, List> : TypeChecks<Type>) | (false extends List ? never : AvZCheck<"list">) : AvZCheck;
 /** A discovered scalar field's stages, its `validators` typed by the field. */
 type KnownScalarFieldPipeline<M extends AvAdapterModel, Cfg, R extends AvConfigResourceKey<M>, Field> = Field extends {
     readonly type: {

package/dist/contracts/client-contract-structure.validator.d.ts

@@ -1383,6 +1383,9 @@ export declare const CLIENT_CONTRACT_STRUCTURE: {
                 readonly maxTransactionOperations: {
                     readonly is: "number";
                 };
+                readonly maxTransactionWrites: {
+                    readonly is: "number";
+                };
                 readonly maxBooleanNodes: {
                     readonly is: "number";
                 };
@@ -1400,7 +1403,7 @@ export declare const CLIENT_CONTRACT_STRUCTURE: {
         };
         readonly transactions: {
             readonly is: "literal";
-            readonly values: readonly ["none", "interactive"];
+            readonly values: readonly ["none", "server", "interactive"];
         };
         readonly protocol: {
             readonly is: "object";

package/dist/contracts/client-contract-structure.validator.js

@@ -3,7 +3,7 @@ import { FILTER_MODES, PROJECTION_SCOPES, WRITE_SCOPES } from "./capability.js";
 import { AVENTARA_PROTOCOL_VERSION } from "./contract-protocol.js";
 import { LIFECYCLE_TRAITS } from "./lifecycle-trait.js";
 import { REFERENCE_WRITE_LIMITS } from "./reference-write-limit.js";
-import { TRANSACTION_CAPABILITIES } from "./transaction-capability.js";
+import { TRANSACTIONS_STYLES } from "./transaction-capability.js";
 const STRING = { is: "string" };
 const NUMBER = { is: "number" };
 const BOOLEAN = { is: "boolean" };
@@ -344,12 +344,13 @@ export const CLIENT_CONTRACT_STRUCTURE = object({
         maxNestingDepth: NUMBER,
         maxListLimit: NUMBER,
         maxTransactionOperations: NUMBER,
+        maxTransactionWrites: NUMBER,
         maxBooleanNodes: NUMBER,
         maxJsonDepth: NUMBER,
         maxAll: NUMBER,
         maxAllConcurrency: NUMBER,
     }),
-    transactions: literal(TRANSACTION_CAPABILITIES),
+    transactions: literal(TRANSACTIONS_STYLES),
     protocol: object({
         version: literal([AVENTARA_PROTOCOL_VERSION]),
         hash: { is: "prefixed", prefix: "sha256:" },

package/dist/contracts/contract-limits.d.ts

@@ -6,8 +6,14 @@ export type AvContractLimits = {
     readonly maxNestingDepth: number;
     /** The largest `limit` a list read may ask for. */
     readonly maxListLimit: number;
-    /** The most operations one transaction may hold. */
+    /** The most steps one transaction plan may hold: reads, writes and `$sql` steps alike. */
     readonly maxTransactionOperations: number;
+    /**
+     * The most write steps one transaction plan may hold: `create`, `update`,
+     * `upsert` and `delete` steps, and every `$sql` step (a statement is not
+     * classed, so it counts as a write).
+     */
+    readonly maxTransactionWrites: number;
     /** The most boolean and filter nodes one request may hold. */
     readonly maxBooleanNodes: number;
     /** How deeply a `json` field's value may nest: its arrays and objects, counted from the value. */
@@ -23,6 +29,7 @@ export declare const DEFAULT_CONTRACT_LIMITS: {
     readonly maxNestingDepth: 12;
     readonly maxListLimit: 250;
     readonly maxTransactionOperations: 20;
+    readonly maxTransactionWrites: 20;
     readonly maxBooleanNodes: 50;
     readonly maxJsonDepth: 64;
     readonly maxAll: 10;

package/dist/contracts/contract-limits.js

@@ -3,6 +3,7 @@ export const DEFAULT_CONTRACT_LIMITS = {
     maxNestingDepth: 12,
     maxListLimit: 250,
     maxTransactionOperations: 20,
+    maxTransactionWrites: 20,
     maxBooleanNodes: 50,
     maxJsonDepth: 64,
     maxAll: 10,

package/dist/contracts/contract.d.ts

@@ -6,7 +6,6 @@ import type { AvCoreField } from "./field.js";
 import type { ReferenceWriteLimit } from "./reference-write-limit.js";
 import type { AvResource } from "./resource.js";
 import type { AvScalarRegistry } from "./scalar.js";
-import type { AvTransactionCapability } from "./transaction-capability.js";
 /** What every Contract describes: scalars, enums, Resources, limits and transactions. */
 export interface AvContract {
     /** The scalar types available. */
@@ -17,8 +16,13 @@ export interface AvContract {
     readonly resources: Readonly<Record<string, AvResource<this>>>;
     /** The request limits in force. */
     readonly limits: AvContractLimits;
-    /** Whether interactive transactions are available. */
-    readonly transactions: AvTransactionCapability;
+    /**
+     * What the layer's transactions allow: `"interactive"`, transactions the
+     * server opens and plans callers send; `"server"`, only those the server
+     * opens (a forced call, a policy-checked write, `ctx.$transaction`), with no
+     * plan; `"none"`, neither.
+     */
+    readonly transactions: "none" | "server" | "interactive";
     /**
      * `"uniform"` when one record must write the relations that hold a reference
      * either all as relations or all through their reference fields; a record

package/dist/contracts/transaction-capability.d.ts

@@ -2,3 +2,11 @@
 export declare const TRANSACTION_CAPABILITIES: readonly ["none", "interactive"];
 /** `"none"` or `"interactive"`: whether transactions can run. */
 export type AvTransactionCapability = (typeof TRANSACTION_CAPABILITIES)[number];
+/** The transaction styles a layer can state, and its Contract's `transactions` carries. */
+export declare const TRANSACTIONS_STYLES: readonly ["none", "server", "interactive"];
+/** `"none"`, `"server"` or `"interactive"`: what a layer's transactions allow. */
+export type TransactionsStyle = (typeof TRANSACTIONS_STYLES)[number];
+/** Whether the server may open a transaction under `style`: `"server"` or `"interactive"`. */
+export declare function opensServerTransactions(style: TransactionsStyle): boolean;
+/** Whether callers may send a transaction plan under `style`: `"interactive"` alone. */
+export declare function takesTransactionPlans(style: TransactionsStyle): boolean;

package/dist/contracts/transaction-capability.js

@@ -1 +1,8 @@
 export const TRANSACTION_CAPABILITIES = ["none", "interactive"];
+export const TRANSACTIONS_STYLES = ["none", "server", "interactive"];
+export function opensServerTransactions(style) {
+    return style === "server" || style === "interactive";
+}
+export function takesTransactionPlans(style) {
+    return style === "interactive";
+}

package/dist/framework/access-facade.js

@@ -4,6 +4,7 @@ import { copyAtDoor } from "../runtime/caller-data.door.js";
 import { isRecord } from "../runtime/record.guard.js";
 import { requestIdOf } from "../runtime/request-id.js";
 import { stateOptionOf } from "../runtime/request-state.resolver.js";
+import { inProcessStateRejection } from "../runtime/state-refusal.mapper.js";
 import { encodeOperationArgumentsForWire } from "../transactions/operation-arguments-encoder.js";
 import { settleOperation } from "./operation-facade.js";
 export function createServerClientAccess(dependencies) {
@@ -12,12 +13,19 @@ export function createServerClientAccess(dependencies) {
         if (options?.state !== undefined || options?.headers === undefined) {
             return stateOf(options);
         }
-        return {
-            state: await dependencies.state({
-                headers: requestHeadersOf(options.headers),
-                ...(options.request === undefined ? {} : { request: options.request }),
-            }),
-        };
+        try {
+            return {
+                state: await dependencies.state({
+                    headers: requestHeadersOf(options.headers),
+                    ...(options.request === undefined
+                        ? {}
+                        : { request: options.request }),
+                }),
+            };
+        }
+        catch (error) {
+            throw inProcessStateRejection(error);
+        }
     };
     const can = async (questions, options) => settleOperation(await answer({
         origin: "client",