@aventara/core 0.1.0-pilot.4 → 1.0.0-rc.0

package/dist/contracts/scalar-value-type.d.ts

@@ -2,6 +2,7 @@ import type { Decimal } from "../runtime/decimal.js";
 import type { JsonValue } from "../runtime/json-value.js";
 import type { Contract } from "./contract.js";
 import type { ScalarField } from "./field.js";
+import type { JsonFieldType } from "./json-shape.js";
 import type { BuiltInScalar } from "./scalar.js";
 /**
  * A scalar-form map: the TypeScript type each built-in scalar takes on one side
@@ -53,6 +54,16 @@ export type ScalarAtom<C extends Contract, Type, Forms extends ScalarForms> = Ty
 } ? C["enums"][Enum]["values"][number] : Type extends {
     readonly scalar: infer Scalar;
 } ? Scalar extends keyof Forms ? Forms[Scalar] : unknown : never;
+/**
+ * One value of a scalar field, before `list` and `nullable` apply: its Json
+ * Shape's type where the field is shaped, otherwise {@link ScalarAtom}.
+ */
+export type FieldAtom<C extends Contract, Field extends {
+    readonly type: unknown;
+    readonly json?: unknown;
+}, Forms extends ScalarForms> = Field extends {
+    readonly json: JsonFieldType<infer Value>;
+} ? Value : ScalarAtom<C, Field["type"], Forms>;
 /**
  * `list: true` makes the value a read-only array of atoms. A `list` the Contract
  * left as a plain `boolean` admits either, so neither form is promised.
@@ -67,5 +78,5 @@ type ListValue<List, Atom> = [List] extends [false] ? Atom : [List] extends [tru
  * - `list: true` → `readonly T[]`, whose entries are never `null`;
  * - `nullable: true` → `| null`, on the whole value, list or not.
  */
-export type ScalarValueType<C extends Contract, Field extends ScalarField<C>, Forms extends ScalarForms = ApplicationScalarForms> = ListValue<Field["list"], ScalarAtom<C, Field["type"], Forms>> | (true extends Field["nullable"] ? null : never);
+export type ScalarValueType<C extends Contract, Field extends ScalarField<C>, Forms extends ScalarForms = ApplicationScalarForms> = ListValue<Field["list"], FieldAtom<C, Field, Forms>> | (true extends Field["nullable"] ? null : never);
 export {};

package/dist/framework/contract-view.d.ts

@@ -2,8 +2,12 @@ import type { AdapterModel } from "../adapters/adapter-model.js";
 import type { AnyFrameworkConfig } from "../config/any-framework-config.js";
 import type { RequestOrigin } from "../config/config-layer.js";
 import type { ContractLimits } from "../contracts/contract-limits.js";
-/** Whether `resolveRecord` descends into a value: an object that is no array. */
-type IsLayeredRecord<T> = [T] extends [readonly unknown[]] ? false : [T] extends [object] ? true : false;
+import type { JsonShape, ShapedJsonSchema } from "../contracts/json-shape.js";
+/**
+ * Whether `resolveRecord` descends into a value: an object that is no array and
+ * no Json Shape.
+ */
+type IsLayeredRecord<T> = [T] extends [readonly unknown[]] ? false : [T] extends [JsonShape] ? false : [T] extends [object] ? true : false;
 /**
  * A root record with a scoped record layered over it: a key the scoped side
  * states wins; when both sides are records they merge, recursively; otherwise
@@ -34,6 +38,10 @@ type LayerBlock<Cfg, Layer extends RequestOrigin, Key extends "fields" | "restri
 })[Layer] & {
     readonly [K in Key]?: unknown;
 })[Key]>>;
+/** Root's own `Key` block, before any layer is layered over it. */
+type RootBlock<Cfg, Key extends "fields" | "restrictions"> = LiteralRecord<(Cfg & {
+    readonly [K in Key]?: unknown;
+})[Key]>;
 /** One key's entry in a layered block, or `never` when the block has none. */
 type EntryOf<Block, Key> = [Block] extends [never] ? never : Key extends keyof Block ? LiteralRecord<NonNullable<Block[Key]>> : never;
 type ConfiguredCapabilities<FieldConfig> = [FieldConfig] extends [never] ? Record<never, never> : FieldConfig extends {
@@ -61,10 +69,19 @@ type LayeredModelField<Field, FieldConfig> = Field extends {
 } ? [FieldConfig] extends [never] ? Field extends {
     readonly capabilities: infer Capabilities;
 } ? "select" extends keyof Capabilities ? Field : ConfiguredModelField<Field, FieldConfig> : ConfiguredModelField<Field, FieldConfig> : ConfiguredModelField<Field, FieldConfig> : Field;
-/** A discovered scalar with its configured capabilities applied, member by member. */
+/**
+ * A discovered scalar with its configured capabilities applied, member by member,
+ * and its configured Json Shape, whose type its value takes.
+ */
 type ConfiguredModelField<Field, FieldConfig> = {
     readonly [P in keyof Field]: P extends "capabilities" ? LayeredCapabilities<Field[P], ConfiguredCapabilities<FieldConfig>> : Field[P];
-};
+} & ConfiguredJsonShape<FieldConfig>;
+/** A configured Json Shape as a view field's `json` member; nothing otherwise. */
+type ConfiguredJsonShape<FieldConfig> = [FieldConfig] extends [never] ? unknown : FieldConfig extends {
+    readonly json: JsonShape<infer Value>;
+} ? {
+    readonly json: ShapedJsonSchema<Value>;
+} : unknown;
 /** A scalar the configuration adds, exactly as the configuration states it. */
 type AddedField<FieldConfig> = {
     readonly kind: "scalar";
@@ -99,34 +116,122 @@ type IsHidden<Restriction> = [Restriction] extends [never] ? false : Restriction
 type HiddenKey<Restrictions> = [Restrictions] extends [never] ? never : {
     [K in keyof Restrictions]-?: IsHidden<EntryOf<Restrictions, K>> extends true ? K : never;
 }[keyof Restrictions];
+/** A restriction entry's `capabilities` block, or `never` when it states none. */
+type CapabilityRestrictionsOf<Entry> = [Entry] extends [never] ? never : EntryOf<Entry, "capabilities">;
+/** A restriction member that is a literal `false`: a denial. */
+type IsDenial<Value> = [Value] extends [false] ? true : false;
+/** A restriction member that is a literal `true`: a restoration. */
+type IsRestoration<Value> = [Value] extends [true] ? true : false;
+/** The tokens a capability member advertises, its qualifier aside. */
+type MemberTokens<Member, TokenKey extends string> = Member extends {
+    readonly scopes: unknown;
+} ? TokenKey extends keyof Member ? Member[TokenKey] : never : Member;
+/** The positions a scope-qualified member holds in; `never` for an unqualified one. */
+type MemberScopes<Member> = Member extends {
+    readonly scopes: infer Scopes;
+} ? Scopes : never;
+/** A relation's `create`, `update` or `reducers` member narrowed by a restriction. */
+type NarrowedScopedTokens<Member, Restriction, TokenKey extends "directives" | "reducers"> = Restriction extends readonly unknown[] ? [MemberScopes<Member>] extends [never] ? Restriction : {
+    readonly [K in TokenKey | "scopes"]: K extends "scopes" ? MemberScopes<Member> : Restriction;
+} : Restriction extends object ? (Restriction extends {
+    readonly scopes: infer Scopes;
+} ? Scopes : MemberScopes<Member>) extends infer Scopes ? [Scopes] extends [never] ? Restriction extends {
+    readonly [K in TokenKey]: infer Tokens;
+} ? Tokens : MemberTokens<Member, TokenKey> : Scopes extends readonly [] ? false : {
+    readonly [K in TokenKey | "scopes"]: K extends "scopes" ? Scopes : Restriction extends {
+        readonly [T in TokenKey]: infer Tokens;
+    } ? Tokens : MemberTokens<Member, TokenKey>;
+} : never : Member;
+/** One capability member narrowed by a list (or, on a relation, an object) restriction. */
+type NarrowedMember<Kind, Key, Member, Restriction> = Kind extends "relation" ? Key extends "select" | "include" ? Restriction extends readonly [] ? false : Restriction : Key extends "create" | "update" ? NarrowedScopedTokens<Member, Restriction, "directives"> : Key extends "reducers" ? NarrowedScopedTokens<Member, Restriction, "reducers"> : Restriction : Restriction;
+/** One capability member of a field under its layer's restrictions. */
+type RestrictedMember<Kind, Key, Member, Root, Layered> = IsRestoration<Layered> extends true ? Root extends readonly unknown[] | {
+    readonly scopes?: unknown;
+} ? NarrowedMember<Kind, Key, Member, Root> : Member : [Layered] extends [boolean] ? Member : NarrowedMember<Kind, Key, Member, Layered>;
+/** The members a capabilities restriction denies, or narrows to nothing. */
+type DeniedMember<Kind, Own, Root, Layered> = {
+    [P in keyof Own]-?: P extends keyof Layered ? IsDenial<Layered[P]> extends true ? P : [
+        RestrictedMember<Kind, P, Own[P], P extends keyof Root ? Root[P] : undefined, Layered[P]>
+    ] extends [false] ? P : never : never;
+}[keyof Own];
+/** A field's capabilities under its layer's restrictions. */
+type RestrictedCapabilities<Kind, Own, Root, Layered> = {
+    readonly [P in keyof Own as P extends DeniedMember<Kind, Own, Root, Layered> ? never : P]: P extends keyof Layered ? RestrictedMember<Kind, P, Own[P], P extends keyof Root ? Root[P] : undefined, Layered[P]> : Own[P];
+};
+/** A view field with its layer's capability restrictions applied. */
+type RestrictedField<Field, RootEntry, Entry> = [
+    CapabilityRestrictionsOf<Entry>
+] extends [never] ? Field : {
+    readonly [P in keyof Field]: P extends "capabilities" ? RestrictedCapabilities<Field extends {
+        readonly kind: infer Kind;
+    } ? Kind : never, Field[P], CapabilityRestrictionsOf<RootEntry>, CapabilityRestrictionsOf<Entry>> : Field[P];
+};
 /**
  * A Resource's fields in the view: the model's and the ones the configuration
- * adds, less the ones this view's restrictions hide.
+ * adds, less the ones this view's restrictions hide, each with its capability
+ * restrictions applied.
+ */
+type LayeredFields<ModelFields, ResourceConfig, FieldRestrictions, RootFieldRestrictions> = {
+    readonly [F in Exclude<keyof ModelFields | AddedFieldKey<ModelFields, ResourceConfig>, HiddenKey<FieldRestrictions>>]: RestrictedField<F extends keyof ModelFields ? LayeredModelField<ModelFields[F], EntryOf<ResourceConfig, F>> : AddedField<EntryOf<ResourceConfig, F>>, EntryOf<RootFieldRestrictions, F>, EntryOf<FieldRestrictions, F>>;
+};
+/** The variants of one family an operations restriction turns off: literal `false` only. */
+type DisabledVariant<FamilyRestriction> = [FamilyRestriction] extends [never] ? never : {
+    [V in keyof FamilyRestriction]-?: IsDenial<FamilyRestriction[V]> extends true ? V : never;
+}[keyof FamilyRestriction];
+/** The variants of the unique style, which need an identifier the layer keeps. */
+type UniqueVariant = "unique";
+/**
+ * The variants of one family the layer advertises: the model's, less those turned
+ * off, less the unique one when no identifier survives.
  */
-type LayeredFields<ModelFields, ResourceConfig, FieldRestrictions> = {
-    readonly [F in Exclude<keyof ModelFields | AddedFieldKey<ModelFields, ResourceConfig>, HiddenKey<FieldRestrictions>>]: F extends keyof ModelFields ? LayeredModelField<ModelFields[F], EntryOf<ResourceConfig, F>> : AddedField<EntryOf<ResourceConfig, F>>;
+type AvailableVariant<Family, FamilyRestriction, UniqueLost> = Exclude<keyof Family, DisabledVariant<FamilyRestriction> | (UniqueLost extends true ? UniqueVariant : never)>;
+/** The families with at least one variant the layer advertises. */
+type AvailableFamily<Operations, OperationRestrictions, UniqueLost> = {
+    [F in keyof Operations]-?: [
+        AvailableVariant<NonNullable<Operations[F]>, EntryOf<OperationRestrictions, F>, UniqueLost>
+    ] extends [never] ? never : F;
+}[keyof Operations];
+/** A Resource's operations under its layer's restrictions. */
+type RestrictedOperations<Operations, OperationRestrictions, UniqueLost> = [
+    OperationRestrictions
+] extends [never] ? UniqueLost extends true ? LayerOperations<Operations, never, UniqueLost> : Operations : LayerOperations<Operations, OperationRestrictions, UniqueLost>;
+type LayerOperations<Operations, OperationRestrictions, UniqueLost> = {
+    readonly [F in AvailableFamily<Operations, OperationRestrictions, UniqueLost>]: {
+        readonly [V in AvailableVariant<NonNullable<Operations[F]>, EntryOf<OperationRestrictions, F>, UniqueLost>]: NonNullable<Operations[F]>[V];
+    };
 };
-/** One Resource in the view: the model's own, with its fields layered. */
-type LayeredResource<in out Resource, in out ResourceConfig, in out ResourceRestrictions> = {
-    readonly [P in keyof Resource]: P extends "fields" ? LayeredFields<Resource[P], ResourceConfig, EntryOf<ResourceRestrictions, "fields">> : Resource[P];
+/** A Resource's identifiers less those naming a hidden field. */
+type KeptIdentifiers<Identifiers, Hidden> = [Hidden] extends [never] ? Identifiers : Identifiers extends readonly (infer Identifier)[] ? readonly (Identifier extends readonly (infer Field)[] ? [Extract<Field, Hidden>] extends [never] ? Identifier : never : never)[] : Identifiers;
+/** Whether hiding fields left a Resource with no identifier at all. */
+type IdentifiersLost<Identifiers, Hidden> = [Hidden] extends [never] ? false : [
+    KeptIdentifiers<Identifiers, Hidden> extends readonly (infer Kept)[] ? Kept : never
+] extends [never] ? true : false;
+/**
+ * One Resource in the view: the model's own, with its fields layered and its
+ * layer's restrictions applied to its fields, operations and identifiers.
+ */
+type LayeredResource<in out Resource, in out ResourceConfig, in out ResourceRestrictions, in out RootResourceRestrictions> = {
+    readonly [P in keyof Resource]: P extends "fields" ? LayeredFields<Resource[P], ResourceConfig, EntryOf<ResourceRestrictions, "fields">, EntryOf<RootResourceRestrictions, "fields">> : P extends "operations" ? RestrictedOperations<Resource[P], EntryOf<ResourceRestrictions, "operations">, IdentifiersLost<Resource extends {
+        readonly identifiers: infer Ids;
+    } ? Ids : never, HiddenKey<EntryOf<ResourceRestrictions, "fields">>>> : P extends "identifiers" ? KeptIdentifiers<Resource[P], HiddenKey<EntryOf<ResourceRestrictions, "fields">>> : Resource[P];
 };
 /**
- * The Resources in the view. `Restrictions` is the layered `restrictions` block
- * whose `hidden` entries this view applies, or `never` for a view that applies
- * none.
+ * The Resources in the view. `Restrictions` is the layer's layered
+ * `restrictions` block and `RootRestrictions` root's own, whose narrowings a
+ * restoration inherits; both `never` for a configuration that restricts nothing.
  */
-type LayeredResources<Resources, Block, Restrictions> = {
-    readonly [R in Exclude<keyof Resources, HiddenKey<Restrictions>>]: LayeredResource<Resources[R], EntryOf<Block, R>, EntryOf<Restrictions, R>>;
+type LayeredResources<Resources, Block, Restrictions, RootRestrictions> = {
+    readonly [R in Exclude<keyof Resources, HiddenKey<Restrictions>>]: LayeredResource<Resources[R], EntryOf<Block, R>, EntryOf<Restrictions, R>, EntryOf<RootRestrictions, R>>;
 };
 /**
  * One derived Contract's type: the model, with a layer's `fields` block applied
- * and, when `Restrictions` is a block rather than `never`, its hidden entries
- * removed.
+ * and its layered `restrictions` block (`Restrictions`, over root's own,
+ * `RootRestrictions`) applied.
  */
-type DerivedContractView<M extends AdapterModel, FieldsBlock, Restrictions> = {
+type DerivedContractView<M extends AdapterModel, FieldsBlock, Restrictions, RootRestrictions> = {
     readonly scalars: M["scalars"];
     readonly enums: M["enums"];
-    readonly resources: LayeredResources<M["resources"], FieldsBlock, Restrictions>;
+    readonly resources: LayeredResources<M["resources"], FieldsBlock, Restrictions, RootRestrictions>;
     readonly limits: ContractLimits;
     readonly transactions: M["transactions"];
 };
@@ -134,11 +239,11 @@ type DerivedContractView<M extends AdapterModel, FieldsBlock, Restrictions> = {
  * The Application Contract's type, derived from the adapter model and the
  * configuration.
  */
-export type ApplicationContractView<M extends AdapterModel, Cfg = AnyFrameworkConfig> = [Cfg] extends [unknown] ? DerivedContractView<M, LayerBlock<Cfg, "application", "fields">, never> : never;
+export type ApplicationContractView<M extends AdapterModel, Cfg = AnyFrameworkConfig> = [Cfg] extends [unknown] ? DerivedContractView<M, LayerBlock<Cfg, "application", "fields">, LayerBlock<Cfg, "application", "restrictions">, RootBlock<Cfg, "restrictions">> : never;
 /**
  * The Client Contract's type, derived from the adapter model and the
  * configuration: what the client layer hides is absent. It types
  * `framework.client` and `framework.clientTx`.
  */
-export type ClientContractView<M extends AdapterModel, Cfg = AnyFrameworkConfig> = [Cfg] extends [unknown] ? DerivedContractView<M, LayerBlock<Cfg, "client", "fields">, LayerBlock<Cfg, "client", "restrictions">> : never;
+export type ClientContractView<M extends AdapterModel, Cfg = AnyFrameworkConfig> = [Cfg] extends [unknown] ? DerivedContractView<M, LayerBlock<Cfg, "client", "fields">, LayerBlock<Cfg, "client", "restrictions">, RootBlock<Cfg, "restrictions">> : never;
 export {};

package/dist/framework/framework.d.ts

@@ -19,8 +19,9 @@ export type Framework<M extends AdapterModel = AdapterModel, Cfg = AnyFrameworkC
      * Typed in-process operations under the Application Contract:
      * `framework.application.<resource>.<family>.<variant>(args, options?)`.
      *
-     * A call is validated like any other request, so it still refuses what a
-     * restriction removed. The optional second argument is
+     * Typed from the Application Contract as configured: what the application's
+     * restrictions hide, deny or turn off is absent from the types, and a call is
+     * validated like any other request. The optional second argument is
      * {@link ExecutionOptions}.
      */
     readonly application: ApplicationOperations<M, Cfg>;
@@ -28,7 +29,8 @@ export type Framework<M extends AdapterModel = AdapterModel, Cfg = AnyFrameworkC
      * The same operations under ClientContract rules:
      * `framework.client.<resource>.<family>.<variant>(args, options?)`.
      *
-     * What the client layer hides is absent, and arguments are read in the wire
+     * What the client layer hides, denies or turns off is absent from the types,
+     * as from a generated client, and arguments are read in the wire
      * forms a decoded request body carries, so a transport can pass `req.body` as
      * it is. Each call runs the client pipelines and the same validation as a
      * remote request.

package/dist/framework/framework.factory.js

@@ -2,9 +2,13 @@ import { compileContracts } from "../compiler/contract.compiler.js";
 import { resolveFrameworkConfig } from "../config/config.resolver.js";
 import { validateFrameworkConfig } from "../config/config.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 { internalFailure } from "../runtime/operation-response.js";
+import { createMisuseReporter, } from "../runtime/misuse-reporter.js";
+import { internalFailure, operationFailure, } from "../runtime/operation-response.js";
 import { createOperationRuntime } 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 { createTransactionPlanAssembler } from "../transactions/transaction-plan-assembler.js";
 import { createTransactionRuntime } from "../transactions/transaction-runtime.js";
@@ -41,25 +45,26 @@ export async function createFramework(config) {
         contracts: compilation.contracts,
         config: resolvedConfig,
     });
-    const executeOperation = (request) => executeTotally(execute, request, resolvedConfig.diagnostics);
+    const misuse = createMisuseReporter(resolvedConfig.misuse);
+    const executeOperation = (request) => executeTotally(execute, request, resolvedConfig.diagnostics, "caller");
     const protocol = {
         version: AVENTARA_PROTOCOL_VERSION,
         hash: compilation.contracts.client.protocol.hash,
     };
-    const assembler = createTransactionPlanAssembler(compilation.contracts, protocol);
+    const assembler = createTransactionPlanAssembler(compilation.contracts, protocol, misuse);
     const framework = {
         entrypoint: resolvedConfig.entrypoint,
         contracts: compilation.contracts,
         application: createOperationFacade(model, (resource, identity, args, requestId) => ({
             ...identity,
-            scope: "application",
+            origin: "application",
             requestId,
             resource,
             arguments: args,
         }), executeOperation),
         client: createOperationFacade(model, (resource, identity, args, requestId) => ({
             ...identity,
-            scope: "client",
+            origin: "client",
             protocol,
             requestId,
             resource,
@@ -67,28 +72,66 @@ export async function createFramework(config) {
         }), executeOperation),
         appTx: createOperationTree(model, (resource, identity) => (args) => assembler.defer("application", resource, identity, args === undefined ? {} : args)),
         clientTx: createOperationTree(model, (resource, identity) => (args) => assembler.defer("client", resource, identity, args === undefined ? {} : args)),
-        execute: executeOperation,
-        executeTransaction: (request) => executeTransactionTotally(executeTransaction, request, resolvedConfig.diagnostics),
+        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)),
     };
     recordDiagnosticsSink(framework, resolvedConfig.diagnostics);
+    recordOwnedExecution(framework, {
+        execute: (request) => executeTotally(execute, request, resolvedConfig.diagnostics, "owned"),
+        executeTransaction: (request) => executeTransactionTotally(executeTransaction, request, resolvedConfig.diagnostics, undefined, { source: "owned" }),
+    });
     return framework;
 }
-async function executeTotally(execute, request, diagnostics) {
+async function executeTotally(execute, request, diagnostics, source) {
     const report = createDiagnosticsReporter(diagnostics, request);
     try {
-        return await execute(request, report);
+        return await execute(request, report, source);
     }
     catch (error) {
         report(error, "A3000");
         return internalFailure();
     }
 }
-async function executeTransactionTotally(execute, request, diagnostics, origins) {
+function executeRequestTotally(execute, request, diagnostics, misuse) {
+    const envelope = copyEnvelopeAtDoor(request, ["protocol", "transport"]);
+    if (!envelope.ok) {
+        return Promise.resolve(operationFailure("A2004", {
+            message: "Operation arguments failed framework validation.",
+            issues: [refuseCallerData(envelope.error, [], {}, misuse)],
+        }));
+    }
+    const malformed = validateOperationEnvelope(envelope.value);
+    if (malformed.length > 0) {
+        return Promise.resolve(operationFailure("A2004", {
+            message: "Operation arguments failed framework validation.",
+            issues: malformed,
+        }));
+    }
+    return executeTotally(execute, envelope.value, diagnostics, "caller");
+}
+function executeTransactionRequestTotally(execute, request, diagnostics, misuse) {
+    const envelope = copyEnvelopeAtDoor(request, ["protocol", "transport"]);
+    if (!envelope.ok) {
+        return Promise.resolve(operationFailure("A2004", {
+            message: "Transaction plan failed framework validation.",
+            issues: [refuseCallerData(envelope.error, [], {}, misuse)],
+        }));
+    }
+    const malformed = validateTransactionEnvelope(envelope.value);
+    if (malformed.length > 0) {
+        return Promise.resolve(operationFailure("A2004", {
+            message: "Transaction plan failed framework validation.",
+            issues: malformed,
+        }));
+    }
+    return executeTransactionTotally(execute, envelope.value, diagnostics, undefined, { source: "caller" });
+}
+async function executeTransactionTotally(execute, request, diagnostics, origins, planArguments) {
     const channel = createTransactionDiagnosticsChannel(diagnostics, request);
     const report = channel.transaction();
     try {
-        return await execute(request, channel, origins);
+        return await execute(request, channel, origins, planArguments);
     }
     catch (error) {
         report(error, "A3000");
@@ -102,7 +145,7 @@ async function runTransactionTotally(execute, assembler, operations, requestId,
     }
     catch (error) {
         createTransactionDiagnosticsChannel(diagnostics, {
-            scope: "application",
+            origin: "application",
             requestId,
             plan: operations,
         }).transaction()(error, "A3000");
@@ -111,5 +154,5 @@ async function runTransactionTotally(execute, assembler, operations, requestId,
     if (!assembled.ok) {
         return assembled.response;
     }
-    return executeTransactionTotally(execute, { scope: "application", requestId, plan: assembled.plan }, diagnostics, assembled.origins);
+    return executeTransactionTotally(execute, { origin: "application", requestId, plan: assembled.plan }, diagnostics, assembled.origins, { source: "owned", refused: assembled.refused });
 }

package/dist/index.d.ts

@@ -1,83 +1,51 @@
 export type { Adapter } from "./adapters/adapter.interface.js";
 export type { AdapterDiscoveryDiagnostic, AdapterDiscoveryDiagnosticCode, } from "./adapters/adapter-discovery-diagnostic.js";
-export type { AdapterField, AdapterLifecycleTrait, AdapterRelationField, AdapterScalarField, } from "./adapters/adapter-field.js";
-export type { AdapterIdentifier, AdapterScalarFieldKey, } from "./adapters/adapter-identifier.js";
 export type { AdapterModel } from "./adapters/adapter-model.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 { ContractCompilationResult, FrameworkContracts, } from "./compiler/contract.compiler.js";
-export { compileContracts } from "./compiler/contract.compiler.js";
+export type { FrameworkContracts } from "./compiler/contract.compiler.js";
 export type { ContractCompilerDiagnostic, ContractCompilerDiagnosticCode, } from "./compiler/contract-compiler-diagnostic.js";
-export type { ResolvedFrameworkConfig, ResolvedFrameworkScopeConfig, } from "./config/config.resolver.js";
-export { resolveFrameworkConfig } from "./config/config.resolver.js";
-export { validateFrameworkConfig } from "./config/config.validator.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, EffectiveFieldKeyAt, } from "./config/effective-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, ResolvedPipelineConfig, } from "./config/pipeline-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 { PROJECTION_SCOPES, WRITE_SCOPES, } from "./contracts/capability.js";
-export type { ClientContractStructureVerdict } from "./contracts/client-contract-structure.validator.js";
-export { validateClientContractStructure } from "./contracts/client-contract-structure.validator.js";
 export type { ApplicationContract, ClientContract, Contract, CoreContract, } from "./contracts/contract.js";
-export { CanonicalJsonError, canonicalizeContract, canonicalizeJson, } from "./contracts/contract-canonicalizer.js";
-export type { ClientContractHashInput } from "./contracts/contract-hash.js";
-export { computeClientContractHash, verifyClientContractHash, } from "./contracts/contract-hash.js";
 export type { ContractLimits } from "./contracts/contract-limits.js";
-export { DEFAULT_CONTRACT_LIMITS } from "./contracts/contract-limits.js";
 export type { ClientContractProtocol, ContractHash, ContractProtocol, } from "./contracts/contract-protocol.js";
-export { AVENTARA_PROTOCOL_VERSION } 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 { advertisedDirectives, advertisedDirectivesAt, advertisedReducers, advertisedReducersAt, holdsAt, holdsInAnyScope, } from "./contracts/field.js";
 export type { Identifier, ScalarFieldKey } from "./contracts/identifier.js";
 export type { LifecycleTrait } from "./contracts/lifecycle-trait.js";
-export { LIFECYCLE_TRAITS } from "./contracts/lifecycle-trait.js";
 export type { Resource, ResourceFieldMap } from "./contracts/resource.js";
 export type { OperationAvailability, OperationVariantScopes, ResourceOperations, } from "./contracts/resource-operations.js";
-export { isOperationVariantAvailable, projectionScopeOf, writeScopeOf, } from "./contracts/resource-operations.js";
 export type { BuiltInScalar, ScalarDefinition, ScalarRegistry, } from "./contracts/scalar.js";
-export { BUILT_IN_SCALARS } from "./contracts/scalar.js";
 export type { ApplicationScalarForms, ScalarValueType, WireScalarForms, } from "./contracts/scalar-value-type.js";
 export type { TransactionCapability } from "./contracts/transaction-capability.js";
-export { TRANSACTION_CAPABILITIES } from "./contracts/transaction-capability.js";
-export type { ApplicationContractView } from "./framework/contract-view.js";
 export { createFramework } from "./framework/framework.factory.js";
 export type { Framework } from "./framework/framework.js";
 export type { FrameworkConstructionDiagnostic, FrameworkConstructionStage, } from "./framework/framework-construction.error.js";
 export { FrameworkConstructionError } from "./framework/framework-construction.error.js";
-export type { CreateDataInput, CursorInput, FieldKey, IncludeInput, NullsOrder, OperationArgumentMap, OperationArgumentsFor, OrderByEntry, OrderByInput, ProjectionEntry, RelationMutationAction, RelationProjectionInput, ResourceKey, ScalarFilterInput, ScalarMutationAction, ScalarOrderInput, SelectInput, SortDirection, UniqueWhereInput, UpdateDataInput, WhereInput, } from "./operations/operation-arguments.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 { OperationValidationResult, SemanticOperationArguments, } from "./operations/operation-validator.js";
-export { validateOperationArguments } from "./operations/operation-validator.js";
 export type { ValidationCode, ValidationIssue, } from "./operations/validation-code.js";
-export { VALIDATION_CODE_MESSAGES, VALIDATION_CODES, } 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 { ApplicationOperationRequest, ClientOperationRequest, ClientProtocolIdentity, FrameworkOperationRequest, OperationScope, } from "./runtime/operation-request.js";
-export type { Cause, OperationCode, OperationErrorCode, OperationFailureResponse, OperationInternalErrorCode, OperationNoMatchResponse, OperationResponse, OperationSuccessCode, OperationSuccessDataCode, OperationSuccessResponse, } from "./runtime/operation-response.js";
-export { OPERATION_CODES, operationFailure, operationNoMatch, operationSuccess, } from "./runtime/operation-response.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 { BuiltinNonRow, DeferredOperation, Operation, OperationFingerprint, OperationReferenceSurface, ReferenceableField, ReferenceBuilder, SingleRowResult, TransactionPlan, TransactionResults, TransactionRunner, } from "./transactions/deferred-operation.js";
-export type { OperationFingerprintNode } from "./transactions/operation-fingerprint.js";
-export { computeOperationFingerprint, isOperationFingerprint, } from "./transactions/operation-fingerprint.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 { TransactionCreateDataInput, TransactionOperationArgumentsFor, TransactionReference, TransactionReferenceCandidate, TransactionScalarValue, TransactionUpdateDataInput, } from "./transactions/transaction-reference.js";
-export { isTransactionReferenceCandidate, isTransactionReferenceObject, } from "./transactions/transaction-reference.js";
-export type { ApplicationTransactionRequest, ClientTransactionRequest, FrameworkTransactionRequest, } from "./transactions/transaction-request.js";
+export type { TransactionReference } from "./transactions/transaction-reference.js";
 export type { TransactionCommittedResponse, TransactionResponse, } from "./transactions/transaction-response.js";
-export { transactionCommitted, transactionInfrastructureFailure, transactionOperationFailure, } from "./transactions/transaction-response.js";
 export type { TransactionSlotPathViolation } from "./transactions/transaction-slot-path-error.js";
 export { TransactionSlotPathError } from "./transactions/transaction-slot-path-error.js";

package/dist/index.js

@@ -1,27 +1,7 @@
-export { compileContracts } from "./compiler/contract.compiler.js";
-export { resolveFrameworkConfig } from "./config/config.resolver.js";
-export { validateFrameworkConfig } from "./config/config.validator.js";
 export { defineFields } from "./config/define-fields.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 { computeClientContractHash, verifyClientContractHash, } from "./contracts/contract-hash.js";
-export { DEFAULT_CONTRACT_LIMITS } from "./contracts/contract-limits.js";
-export { AVENTARA_PROTOCOL_VERSION } from "./contracts/contract-protocol.js";
-export { advertisedDirectives, advertisedDirectivesAt, advertisedReducers, advertisedReducersAt, holdsAt, holdsInAnyScope, } from "./contracts/field.js";
-export { LIFECYCLE_TRAITS } from "./contracts/lifecycle-trait.js";
-export { isOperationVariantAvailable, projectionScopeOf, writeScopeOf, } from "./contracts/resource-operations.js";
-export { BUILT_IN_SCALARS } from "./contracts/scalar.js";
-export { TRANSACTION_CAPABILITIES } from "./contracts/transaction-capability.js";
 export { createFramework } from "./framework/framework.factory.js";
 export { FrameworkConstructionError } from "./framework/framework-construction.error.js";
-export { validateOperationArguments } from "./operations/operation-validator.js";
-export { VALIDATION_CODE_MESSAGES, VALIDATION_CODES, } from "./operations/validation-code.js";
 export { Decimal } from "./runtime/decimal.js";
 export { FrameworkError } from "./runtime/framework-error.js";
-export { OPERATION_CODES, operationFailure, operationNoMatch, operationSuccess, } from "./runtime/operation-response.js";
-export { computeOperationFingerprint, isOperationFingerprint, } from "./transactions/operation-fingerprint.js";
 export { TransactionIntegrityError } from "./transactions/transaction-integrity-error.js";
-export { isTransactionReferenceCandidate, isTransactionReferenceObject, } from "./transactions/transaction-reference.js";
-export { transactionCommitted, transactionInfrastructureFailure, transactionOperationFailure, } from "./transactions/transaction-response.js";
 export { TransactionSlotPathError } from "./transactions/transaction-slot-path-error.js";

package/dist/internal.d.ts

@@ -0,0 +1,35 @@
+/**
+ * `@aventara/core/internal` is not public API.
+ *
+ * It holds what Aventara's own packages (the adapters, the client generator,
+ * the testing kit) need from core and an application does not. It carries no
+ * 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 { 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 { computeClientContractHash, verifyClientContractHash, } from "./contracts/contract-hash.js";
+export { DEFAULT_CONTRACT_LIMITS } from "./contracts/contract-limits.js";
+export { AVENTARA_PROTOCOL_VERSION } from "./contracts/contract-protocol.js";
+export { advertisedDirectives, advertisedReducers } from "./contracts/field.js";
+export { 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 { 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 { OPERATION_CODES } from "./runtime/operation-response.js";
+export type { BuiltinNonRow, OperationFingerprint, } from "./transactions/deferred-operation.js";
+export { computeOperationFingerprint } from "./transactions/operation-fingerprint.js";
+export type { ApplicationTransactionRequest, ClientTransactionRequest, FrameworkTransactionRequest, } from "./transactions/transaction-request.js";

package/dist/internal.js

@@ -0,0 +1,16 @@
+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 { computeClientContractHash, verifyClientContractHash, } from "./contracts/contract-hash.js";
+export { DEFAULT_CONTRACT_LIMITS } from "./contracts/contract-limits.js";
+export { AVENTARA_PROTOCOL_VERSION } from "./contracts/contract-protocol.js";
+export { advertisedDirectives, advertisedReducers } from "./contracts/field.js";
+export { 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 { VALIDATION_CODES } from "./operations/validation-code.js";
+export { OPERATION_CODES } from "./runtime/operation-response.js";
+export { computeOperationFingerprint } from "./transactions/operation-fingerprint.js";