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

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

@@ -0,0 +1,127 @@
+import type { AvAdapterModel } from "../adapters/adapter-model.js";
+import type { AvAdapterFieldKey } from "../adapters/adapter-resource.js";
+import type { AvZCheck } from "../avz/avz-check.registry.js";
+import type { AvOperationFamily } from "../operations/operation-identity.js";
+import type { AvPreComputeStageArguments, AvStageArguments } from "../runtime/pipeline.js";
+import type { AvConfigAny } from "./any-framework-config.js";
+import type { AvPreComputeLift } from "./computed-fields.js";
+import type { AvConfigLayerName } from "./config-layer.js";
+import type { AvEffectiveFieldKey } from "./effective-fields.js";
+import type { AvRelationFieldPipeline, AvScalarFieldPipeline } from "./field-pipeline-config.js";
+import type { AvConfigAddedFieldDefinition, AvConfigFieldDefinition, AvConfigKnownFieldDefinition, AvConfigResourceKey } from "./framework-field-definition.js";
+import type { AvPipeline, AvTransactionPipeline } from "./pipeline-config.js";
+/**
+ * Whether a layer is the root, where fields are defined, or an overlay
+ * (`application`, `client`), which registers stages on them but never defines one.
+ */
+export type AvConfigLayerKind = "root" | "overlay";
+/** One operation variant's level: its stages and `forceTransaction`. */
+export type AvConfigVariant<M extends AvAdapterModel = AvAdapterModel, R extends string = AvConfigResourceKey<M>, F extends AvOperationFamily = AvOperationFamily, V extends string = string, A = NoInfer<AvStageArguments<M, R, F, V>>, PreCompute = NoInfer<AvPreComputeStageArguments<M, R, F, V>>> = {
+    /**
+     * Stages that run for this one operation: at a variant, `ctx.$args` (and a
+     * pipe's arguments) are typed as the operation's arguments; in a guard, a
+     * pipe or a filter a create may lack the fields `compute.create` fills
+     * (write compute runs after them).
+     */
+    readonly pipelines?: AvPipeline<NoInfer<M>, R, F, V, A, PreCompute>;
+    /** Runs a plain call of this operation as a one-step transaction. */
+    readonly forceTransaction?: boolean;
+};
+/**
+ * One operation family's level: stages and `forceTransaction` for every variant
+ * of it, and each variant's own level by name.
+ */
+export type AvConfigFamily<M extends AvAdapterModel = AvAdapterModel, Variants = {
+    readonly [V in "first" | "unique" | "many" | "count" | "one"]?: unknown;
+}, R extends string = AvConfigResourceKey<M>, F extends AvOperationFamily = AvOperationFamily, Layer extends AvConfigLayerName = "root"> = AvConfigVariant<M, R, F, F extends "create" | "update" | "delete" ? Extract<keyof NonNullable<Variants>, string> | "one" : Extract<keyof NonNullable<Variants>, string>, unknown, unknown> & {
+    readonly [V in Extract<keyof NonNullable<Variants>, string>]?: AvConfigVariant<M, R, F, V, NoInfer<AvStageArguments<M, R, F, V>>, NoInfer<AvPreComputeStageArguments<M, R, F, V, AvPreComputeLift<M, Layer>>>> | undefined;
+};
+/** A Resource's families, as the adapter model offers them, each with its level. */
+export type AvConfigOperations<M extends AvAdapterModel = AvAdapterModel, R extends AvConfigResourceKey<M> = AvConfigResourceKey<M>, Layer extends AvConfigLayerName = "root"> = {
+    readonly [F in Extract<keyof M["resources"][R]["operations"], AvOperationFamily>]?: AvConfigFamily<M, M["resources"][R]["operations"][F], R, F, Layer>;
+};
+/** A Resource's transaction level. */
+export type AvConfigResourceTransactions<M extends AvAdapterModel = AvAdapterModel> = {
+    /** Stages that run once per transaction with a top-level step on the Resource. */
+    readonly pipelines?: AvTransactionPipeline<NoInfer<M>>;
+};
+/** A field's entry at the root: its definition and its stages. */
+export type AvConfigRootField<M extends AvAdapterModel = AvAdapterModel, Cfg = AvConfigAny, R extends AvConfigResourceKey<M> = AvConfigResourceKey<M>> = {
+    /** What the field is. Root only. */
+    readonly definition?: AvConfigFieldDefinition<M>;
+    /** The field's stages. */
+    readonly pipelines?: AvScalarFieldPipeline<M, Cfg, R>;
+};
+/** A field's entry in an overlay: its stages only. */
+export type AvConfigOverlayField<M extends AvAdapterModel = AvAdapterModel, Cfg = AvConfigAny, R extends AvConfigResourceKey<M> = AvConfigResourceKey<M>> = {
+    /** The field's stages, added to the root's. */
+    readonly pipelines?: AvScalarFieldPipeline<M, Cfg, R>;
+};
+/** 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 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;
+/** 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: {
+        readonly scalar: "json";
+    };
+} ? Omit<AvScalarFieldPipeline<M, Cfg, R>, "validators"> & {
+    /** A Json field's checks are in its shape (`definition.json`). */
+    readonly validators?: never;
+} : AvScalarFieldPipeline<M, Cfg, R, FieldCheckOf<Field>>;
+/** The root entry one effective field name admits. */
+type RootFieldConfigFor<M extends AvAdapterModel, Cfg, R extends AvConfigResourceKey<M>, F extends string> = string extends F ? AvConfigRootField<M, Cfg, R> : F extends AvAdapterFieldKey<M, R> ? M["resources"][R]["fields"][F] extends {
+    readonly kind: "relation";
+} ? {
+    readonly definition?: never;
+    readonly pipelines?: AvRelationFieldPipeline<M, R>;
+} : {
+    readonly definition?: AvConfigKnownFieldDefinition<M["resources"][R]["fields"][F]>;
+    readonly pipelines?: KnownScalarFieldPipeline<M, Cfg, R, M["resources"][R]["fields"][F]>;
+} : {
+    readonly definition: AvConfigAddedFieldDefinition<M>;
+    readonly pipelines?: AvScalarFieldPipeline<M, Cfg, R>;
+};
+/** The overlay entry one effective field name admits. */
+type OverlayFieldConfigFor<M extends AvAdapterModel, Cfg, R extends AvConfigResourceKey<M>, F extends string> = string extends F ? AvConfigOverlayField<M, Cfg, R> : F extends AvAdapterFieldKey<M, R> ? M["resources"][R]["fields"][F] extends {
+    readonly kind: "relation";
+} ? {
+    readonly pipelines?: AvRelationFieldPipeline<M, R>;
+} : {
+    readonly pipelines?: KnownScalarFieldPipeline<M, Cfg, R, M["resources"][R]["fields"][F]>;
+} : AvConfigOverlayField<M, Cfg, R>;
+/** A Resource's fields at one layer, keyed by its effective field names. */
+export type AvConfigResourceFields<in out M extends AvAdapterModel = AvAdapterModel, in out Cfg = AvConfigAny, in out R extends AvConfigResourceKey<M> = AvConfigResourceKey<M>, Kind extends AvConfigLayerKind = "root"> = {
+    readonly [F in AvEffectiveFieldKey<M, Cfg, R>]?: Kind extends "root" ? RootFieldConfigFor<M, Cfg, R, F> : OverlayFieldConfigFor<M, Cfg, R, F>;
+};
+/** One Resource's tree: its stages, operations, transactions and fields. */
+export type AvConfigResource<in out M extends AvAdapterModel = AvAdapterModel, in out Cfg = AvConfigAny, in out R extends AvConfigResourceKey<M> = AvConfigResourceKey<M>, Kind extends AvConfigLayerKind = "root", Layer extends AvConfigLayerName = LayerOfKind<Kind>> = {
+    /** Stages that run for every operation of this Resource. */
+    readonly pipelines?: AvPipeline<NoInfer<M>, R>;
+    /** Per family, and per variant under its family. */
+    readonly operations?: AvConfigOperations<M, R, Layer>;
+    /** Stages that run once per transaction with a top-level step on this Resource. */
+    readonly transactions?: AvConfigResourceTransactions<M>;
+    /** Per field: its definition (root only) and its stages. */
+    readonly fields?: AvConfigResourceFields<M, Cfg, R, Kind>;
+    /**
+     * `true`: another service owns this Resource's table and migrates it. It is
+     * read and joined, never written: it has no write operation, no nested write
+     * reaches its rows, and the client and agent Contracts leave it out, with
+     * every relation to it. Root only.
+     */
+    readonly managedElsewhere?: Kind extends "root" ? boolean : never;
+};
+/** The `resources` tree of one layer, keyed by the adapter's Resource names. */
+export type AvConfigResources<in out M extends AvAdapterModel = AvAdapterModel, in out Cfg = AvConfigAny, in out Kind extends AvConfigLayerKind = "root", in out Layer extends AvConfigLayerName = LayerOfKind<Kind>> = {
+    readonly [R in AvConfigResourceKey<M>]?: AvConfigResource<M, Cfg, R, Kind, Layer>;
+};
+/** The layers a tree of kind `Kind` may be written in, when it names none. */
+export type LayerOfKind<Kind extends AvConfigLayerKind> = Kind extends "root" ? "root" : Exclude<AvConfigLayerName, "root">;
+export {};

package/dist/config/framework-resources-config.js

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

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

@@ -1,29 +1,65 @@
-import type { AdapterModel } from "../adapters/adapter-model.js";
-import type { AfterHook, BeforeHook, Filter, Guard, Interceptor, Pipe } from "../runtime/pipeline.js";
-/** Pipeline registrations for one configuration scope. See {@link PipelineContext}. */
-export type PipelineConfig<M extends AdapterModel = AdapterModel> = {
+import type { AvAdapterModel } from "../adapters/adapter-model.js";
+import type { AvOperationFamily } from "../operations/operation-identity.js";
+import type { AvAfterHook, AvBeforeHook, AvFilter, AvGuard, AvInterceptor, AvPipe, AvTransactionAfterHook, AvTransactionBeforeHook, AvTransactionFilter, AvTransactionGuard, AvTransactionInterceptor, AvTransactionPipe } from "../runtime/pipeline.js";
+import type { AvConfigResourceKey } from "./framework-field-definition.js";
+/**
+ * Pipeline registrations for one level of the configuration: a layer, a
+ * Resource, a family or a variant. See {@link AvContext}.
+ */
+export type AvPipeline<M extends AvAdapterModel = AvAdapterModel, R extends string = AvConfigResourceKey<M>, F extends AvOperationFamily = AvOperationFamily, V extends string = string, A = unknown, PreCompute = A> = {
     /** Run first; a guard returning `false` denies the operation with `A4001`. */
-    readonly guards?: readonly Guard<M>[];
+    readonly guards?: readonly AvGuard<M, R, F, V, PreCompute>[];
     /** Run in order on the arguments; a pipe may return replacement arguments. */
-    readonly pipes?: readonly Pipe<M>[];
-    /** Run just before (`before`) and after (`after`) the operation executes. */
+    readonly pipes?: readonly AvPipe<M, R, F, V, PreCompute>[];
+    /**
+     * Run around the operation, inside every level's interceptors: `before`
+     * hooks outer to inner, `after` hooks inner to outer.
+     */
     readonly hooks?: {
-        readonly before?: readonly BeforeHook<M>[];
-        readonly after?: readonly AfterHook<M>[];
+        readonly before?: readonly AvBeforeHook<M, R, F, V, A>[];
+        readonly after?: readonly AvAfterHook<M, R, F, V, A>[];
     };
-    /** Wrap the operation's execution; each calls `next()` to continue. */
-    readonly interceptors?: readonly Interceptor<M>[];
-    /** Turn a thrown error into a {@link FrameworkError} outcome. */
-    readonly filters?: readonly Filter<M>[];
+    /** Wrap everything below this level; each calls `next()` to continue. */
+    readonly interceptors?: readonly AvInterceptor<M, R, F, V, A>[];
+    /** Turn a thrown error into a {@link AvError} outcome. */
+    readonly filters?: readonly AvFilter<M, R, F, V, PreCompute>[];
 };
-/** The pipelines that run for one origin, root and overlay combined. */
+/**
+ * A Resource's transaction stages: they run once per transaction with a
+ * top-level step on the Resource, inside it, and see the whole plan.
+ */
+export type AvTransactionPipeline<M extends AvAdapterModel = AvAdapterModel> = {
+    readonly guards?: readonly AvTransactionGuard<M>[];
+    readonly pipes?: readonly AvTransactionPipe<M>[];
+    readonly hooks?: {
+        readonly before?: readonly AvTransactionBeforeHook<M>[];
+        readonly after?: readonly AvTransactionAfterHook<M>[];
+    };
+    readonly interceptors?: readonly AvTransactionInterceptor<M>[];
+    readonly filters?: readonly AvTransactionFilter<M>[];
+};
+/**
+ * One level's registrations, as one layer states them: the unit the pipeline
+ * tree composes (`pipeline-tree.resolver.ts`).
+ */
 export type ResolvedPipelineConfig = {
-    readonly guards: readonly Guard[];
-    readonly pipes: readonly Pipe[];
+    readonly guards: readonly AvGuard[];
+    readonly pipes: readonly AvPipe[];
+    readonly hooks: {
+        readonly before: readonly AvBeforeHook[];
+        readonly after: readonly AvAfterHook[];
+    };
+    readonly interceptors: readonly AvInterceptor[];
+    readonly filters: readonly AvFilter[];
+};
+/** One layer's registrations on one Resource's transactions. */
+export type ResolvedTransactionPipelineConfig = {
+    readonly guards: readonly AvTransactionGuard[];
+    readonly pipes: readonly AvTransactionPipe[];
     readonly hooks: {
-        readonly before: readonly BeforeHook[];
-        readonly after: readonly AfterHook[];
+        readonly before: readonly AvTransactionBeforeHook[];
+        readonly after: readonly AvTransactionAfterHook[];
     };
-    readonly interceptors: readonly Interceptor[];
-    readonly filters: readonly Filter[];
+    readonly interceptors: readonly AvTransactionInterceptor[];
+    readonly filters: readonly AvTransactionFilter[];
 };

package/dist/config/pipeline-tree.resolver.d.ts

@@ -0,0 +1,79 @@
+import type { AvOperationIdentity } from "../operations/operation-identity.js";
+import type { AvFieldGuard, AvFieldPipe } from "../runtime/pipeline.js";
+import type { ResolvedPipelineConfig, ResolvedTransactionPipelineConfig } from "./pipeline-config.js";
+/** One variant's levels and whether a layer forces it. */
+type ResolvedVariantPipelines = {
+    readonly pipelines: readonly ResolvedPipelineConfig[];
+    readonly forceTransaction: boolean;
+};
+/** One family's levels, its variants' and whether a layer forces the family. */
+type ResolvedFamilyPipelines = ResolvedVariantPipelines & {
+    readonly variants: Readonly<Record<string, ResolvedVariantPipelines>>;
+};
+/** One field's stages for one origin: the root's, then the overlay's. */
+export type ResolvedFieldStages = {
+    readonly pipes: readonly AvFieldPipe[];
+    readonly guards: readonly AvFieldGuard[];
+    /**
+     * The field's validators as authored, root's then overlay's: the Contract compiler
+     * checks and compiles them; the runtime reads the compiled form
+     * (`field-validator.registry.ts`).
+     */
+    readonly validators: readonly unknown[];
+};
+/** One Resource's levels for one origin. */
+export type ResolvedResourcePipelines = {
+    readonly pipelines: readonly ResolvedPipelineConfig[];
+    readonly families: Readonly<Record<string, ResolvedFamilyPipelines>>;
+    readonly transactions: readonly ResolvedTransactionPipelineConfig[];
+    readonly fields: Readonly<Record<string, ResolvedFieldStages>>;
+};
+/** Every stage that runs for one origin, by level. */
+export type ResolvedPipelineTree = {
+    readonly layer: readonly ResolvedPipelineConfig[];
+    readonly resources: Readonly<Record<string, ResolvedResourcePipelines>>;
+};
+type UnknownRecord = Readonly<Record<string, unknown>>;
+/**
+ * The pipeline tree of one origin: each layer's registrations in turn, at every
+ * level — the root's, then the overlay's; for the agent, the root's, then the
+ * overlay it extends, then its own. The root layer alone (the Core Contract's)
+ * is one layer.
+ */
+export declare function resolvePipelineTree(layers: readonly UnknownRecord[]): ResolvedPipelineTree;
+/** The tree a raw ctx call runs over: `tree`'s field pipes, and nothing else. */
+export declare function rawPipelineTree(tree: ResolvedPipelineTree): ResolvedPipelineTree;
+/**
+ * The levels of one operation, outer to inner: root layer, overlay layer, root
+ * Resource, overlay Resource, root family, overlay family, root variant, overlay
+ * variant. A level no layer states is left out.
+ */
+export declare function operationLevels(tree: ResolvedPipelineTree, operation: AvOperationIdentity & {
+    readonly resource: string;
+}): readonly ResolvedPipelineConfig[];
+/**
+ * The levels a nested write's target runs, outer to inner: root Resource,
+ * overlay Resource, root family, overlay family. A level no layer states is
+ * left out.
+ */
+export declare function nestedTargetLevels(tree: ResolvedPipelineTree, resource: string, family: string): readonly ResolvedPipelineConfig[];
+/** Whether a layer sets `forceTransaction` on the operation's family or variant. */
+export declare function isForcedOperation(tree: ResolvedPipelineTree, operation: AvOperationIdentity & {
+    readonly resource: string;
+}): boolean;
+/** The field stages registered on one Resource's fields, by field name. */
+export declare function fieldStagesOf(tree: ResolvedPipelineTree, resource: string): Readonly<Record<string, ResolvedFieldStages>>;
+/** One Resource's transaction levels: the root's, then the overlay's. */
+export declare function transactionLevelsOf(tree: ResolvedPipelineTree, resource: string): readonly ResolvedTransactionPipelineConfig[];
+/**
+ * Every `forceTransaction` the tree states, as the configuration paths that set
+ * it (`resources.R.operations.F[.V]`), with the operation each one forces. Read
+ * once at construction, for the startup check against `transactionsStyle`.
+ */
+export declare function forcedOperationsOf(layer: UnknownRecord, prefix: string): readonly {
+    readonly path: string;
+    readonly resource: string;
+    readonly family: string;
+    readonly variant: string | undefined;
+}[];
+export {};

package/dist/config/pipeline-tree.resolver.js

@@ -0,0 +1,220 @@
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function own(record, key) {
+    return record !== undefined && Object.hasOwn(record, key)
+        ? record[key]
+        : undefined;
+}
+function list(value) {
+    return Array.isArray(value) ? [...value] : [];
+}
+function levelOf(value) {
+    if (!isRecord(value)) {
+        return undefined;
+    }
+    const pipeline = value;
+    return {
+        guards: list(pipeline.guards),
+        pipes: list(pipeline.pipes),
+        hooks: {
+            before: list(pipeline.hooks?.before),
+            after: list(pipeline.hooks?.after),
+        },
+        interceptors: list(pipeline.interceptors),
+        filters: list(pipeline.filters),
+    };
+}
+function transactionLevelOf(value) {
+    if (!isRecord(value)) {
+        return undefined;
+    }
+    const pipeline = value;
+    return {
+        guards: list(pipeline.guards),
+        pipes: list(pipeline.pipes),
+        hooks: {
+            before: list(pipeline.hooks?.before),
+            after: list(pipeline.hooks?.after),
+        },
+        interceptors: list(pipeline.interceptors),
+        filters: list(pipeline.filters),
+    };
+}
+function levels(layers, read) {
+    return layers.flatMap((layer) => {
+        const level = read(layer);
+        return level === undefined ? [] : [level];
+    });
+}
+function child(value, key) {
+    return isRecord(value) && Object.hasOwn(value, key) ? value[key] : undefined;
+}
+function forced(layers) {
+    return layers.some((layer) => child(layer, "forceTransaction") === true);
+}
+function keysOf(layers, skip) {
+    const keys = new Set();
+    for (const layer of layers) {
+        if (!isRecord(layer)) {
+            continue;
+        }
+        for (const key of Object.keys(layer)) {
+            if (skip?.has(key) !== true) {
+                keys.add(key);
+            }
+        }
+    }
+    return keys;
+}
+const FAMILY_LEVEL_KEYS = new Set(["pipelines", "forceTransaction"]);
+function resolveVariant(layers) {
+    return {
+        pipelines: levels(layers, (layer) => levelOf(child(layer, "pipelines"))),
+        forceTransaction: forced(layers),
+    };
+}
+function resolveFamily(layers) {
+    const variants = {};
+    for (const variant of keysOf(layers, FAMILY_LEVEL_KEYS)) {
+        variants[variant] = resolveVariant(layers.map((layer) => child(layer, variant)));
+    }
+    return { ...resolveVariant(layers), variants };
+}
+function resolveFields(layers) {
+    const fields = {};
+    for (const field of keysOf(layers)) {
+        const pipelines = layers.map((layer) => child(child(layer, field), "pipelines"));
+        const pipes = pipelines.flatMap((stage) => list(child(stage, "pipes")));
+        const guards = pipelines.flatMap((stage) => list(child(stage, "guards")));
+        const validators = pipelines.flatMap((stage) => list(child(stage, "validators")));
+        if (pipes.length > 0 || guards.length > 0 || validators.length > 0) {
+            fields[field] = { pipes, guards, validators };
+        }
+    }
+    return fields;
+}
+function resolveResource(layers) {
+    const operations = layers.map((layer) => child(layer, "operations"));
+    const families = {};
+    for (const family of keysOf(operations)) {
+        families[family] = resolveFamily(operations.map((layer) => child(layer, family)));
+    }
+    return {
+        pipelines: levels(layers, (layer) => levelOf(child(layer, "pipelines"))),
+        families,
+        transactions: levels(layers, (layer) => transactionLevelOf(child(child(layer, "transactions"), "pipelines"))),
+        fields: resolveFields(layers.map((layer) => child(layer, "fields"))),
+    };
+}
+export function resolvePipelineTree(layers) {
+    const trees = layers.map((layer) => child(layer, "resources"));
+    const resources = {};
+    for (const resource of keysOf(trees)) {
+        resources[resource] = resolveResource(trees.map((tree) => child(tree, resource)));
+    }
+    return {
+        layer: levels(layers, (layer) => levelOf(child(layer, "pipelines"))),
+        resources,
+    };
+}
+const NO_LEVELS = Object.freeze([]);
+export function rawPipelineTree(tree) {
+    const resources = {};
+    for (const [name, resource] of Object.entries(tree.resources)) {
+        const fields = {};
+        for (const [field, stages] of Object.entries(resource.fields)) {
+            if (stages.pipes.length > 0) {
+                fields[field] = {
+                    pipes: stages.pipes,
+                    guards: [],
+                    validators: stages.validators,
+                };
+            }
+        }
+        resources[name] = {
+            pipelines: NO_LEVELS,
+            families: {},
+            transactions: [],
+            fields,
+        };
+    }
+    return { layer: NO_LEVELS, resources };
+}
+export function operationLevels(tree, operation) {
+    const resource = own(tree.resources, operation.resource);
+    if (resource === undefined) {
+        return tree.layer;
+    }
+    const family = own(resource.families, operation.family);
+    const variant = own(family?.variants, operation.variant);
+    return [
+        ...tree.layer,
+        ...resource.pipelines,
+        ...(family?.pipelines ?? NO_LEVELS),
+        ...(variant?.pipelines ?? NO_LEVELS),
+    ];
+}
+export function nestedTargetLevels(tree, resource, family) {
+    const found = own(tree.resources, resource);
+    if (found === undefined) {
+        return NO_LEVELS;
+    }
+    return [
+        ...found.pipelines,
+        ...(own(found.families, family)?.pipelines ?? NO_LEVELS),
+    ];
+}
+export function isForcedOperation(tree, operation) {
+    const family = own(own(tree.resources, operation.resource)?.families, operation.family);
+    return (family?.forceTransaction === true ||
+        own(family?.variants, operation.variant)?.forceTransaction === true);
+}
+const NO_FIELDS = Object.freeze({});
+export function fieldStagesOf(tree, resource) {
+    return own(tree.resources, resource)?.fields ?? NO_FIELDS;
+}
+export function transactionLevelsOf(tree, resource) {
+    return own(tree.resources, resource)?.transactions ?? [];
+}
+export function forcedOperationsOf(layer, prefix) {
+    const found = [];
+    const resources = child(layer, "resources");
+    if (!isRecord(resources)) {
+        return found;
+    }
+    for (const [resource, entry] of Object.entries(resources)) {
+        const operations = child(entry, "operations");
+        if (!isRecord(operations)) {
+            continue;
+        }
+        for (const [family, level] of Object.entries(operations)) {
+            const familyPath = `${prefix}resources.${resource}.operations.${family}`;
+            if (child(level, "forceTransaction") === true) {
+                found.push({
+                    path: `${familyPath}.forceTransaction`,
+                    resource,
+                    family,
+                    variant: undefined,
+                });
+            }
+            if (!isRecord(level)) {
+                continue;
+            }
+            for (const [variant, variantLevel] of Object.entries(level)) {
+                if (FAMILY_LEVEL_KEYS.has(variant)) {
+                    continue;
+                }
+                if (child(variantLevel, "forceTransaction") === true) {
+                    found.push({
+                        path: `${familyPath}.${variant}.forceTransaction`,
+                        resource,
+                        family,
+                        variant,
+                    });
+                }
+            }
+        }
+    }
+    return found;
+}

package/dist/config/stage-type.eraser.d.ts

@@ -0,0 +1,65 @@
+import type { AvComputeCreate, AvComputeRead, AvComputeUpdate } from "../runtime/field-compute.js";
+import type { AvScalarFieldPipeline } from "./field-pipeline-config.js";
+import type { AvPipeline, AvTransactionPipeline } from "./pipeline-config.js";
+/** Stage lists of one `pipelines` value as `Wide` states them; `validators` kept. */
+type ErasedPipelines<P, Wide> = P extends object ? {
+    [K in keyof P]: K extends "validators" ? P[K] : K extends "compute" ? ErasedCompute<P[K]> : K extends "hooks" ? ErasedStageGroup<P[K], NonNullable<Wide[K & keyof Wide]>> : K extends keyof Wide ? NonNullable<Wide[K]> : P[K];
+} : P;
+/** `hooks`, by phase (`before`, `after`). */
+type ErasedStageGroup<G, Wide> = G extends object ? {
+    [K in keyof G]: K extends keyof Wide ? NonNullable<Wide[K]> : G[K];
+} : G;
+/** A field's `compute`, by phase; a read stage's `dependsOn` kept. */
+type ErasedCompute<C> = C extends object ? {
+    [K in keyof C]: K extends "create" ? AvComputeCreate : K extends "update" ? AvComputeUpdate : K extends "read" ? C[K] extends {
+        readonly compute: unknown;
+    } ? {
+        [D in keyof C[K]]: D extends "compute" ? ComputeReadStage : C[K][D];
+    } : ComputeReadStage : C[K];
+} : C;
+/** A read compute stage's function form, for any model. */
+type ComputeReadStage = Parameters<Extract<AvComputeRead, (context: never) => unknown>>[0] extends infer Context ? (context: Context) => unknown : never;
+/** A variant's level: its `pipelines` erased, `forceTransaction` kept. */
+type ErasedVariant<V> = V extends object ? {
+    [K in keyof V]: K extends "pipelines" ? ErasedPipelines<V[K], AvPipeline> : V[K];
+} : V;
+/** A family's level: its own `pipelines` and each variant's. */
+type ErasedFamily<F> = F extends object ? {
+    [K in keyof F]: K extends "pipelines" ? ErasedPipelines<F[K], AvPipeline> : K extends "forceTransaction" ? F[K] : ErasedVariant<F[K]>;
+} : F;
+/** A field's entry: its `definition` kept, its `pipelines` erased. */
+type ErasedField<Field> = Field extends object ? {
+    [K in keyof Field]: K extends "pipelines" ? ErasedPipelines<Field[K], AvScalarFieldPipeline> : Field[K];
+} : Field;
+/**
+ * One Resource's block with every stage stated by its public type for any model.
+ */
+export type ErasedResourceBlock<B> = B extends object ? {
+    [K in keyof B]: K extends "pipelines" ? ErasedPipelines<B[K], AvPipeline> : K extends "operations" ? {
+        [F in keyof B[K]]: ErasedFamily<B[K][F]>;
+    } : K extends "transactions" ? {
+        [T in keyof B[K]]: T extends "pipelines" ? ErasedPipelines<B[K][T], AvTransactionPipeline> : B[K][T];
+    } : K extends "fields" ? {
+        [Name in keyof B[K]]: ErasedField<B[K][Name]>;
+    } : B[K];
+} : B;
+/** A Resource's overlay blocks (`application`, `client`, `agent`), each erased. */
+export type ErasedOverlayBlocks<Overlays> = Overlays extends object ? {
+    [L in keyof Overlays]: ErasedResourceBlock<Overlays[L]>;
+} : Overlays;
+/** A `resources` tree: each Resource's block erased. */
+export type ErasedResources<Resources> = Resources extends object ? {
+    [R in keyof Resources]: ErasedResourceBlock<Resources[R]>;
+} : Resources;
+/** One layer (the root's keys, `application`, `client`, `agent`): its stages erased. */
+type ErasedLayer<Layer> = Layer extends object ? {
+    [K in keyof Layer]: K extends "pipelines" ? ErasedPipelines<Layer[K], AvPipeline> : K extends "resources" ? ErasedResources<Layer[K]> : Layer[K];
+} : Layer;
+/**
+ * An authored configuration with every stage stated by its public type for any
+ * model: the `Cfg` a Framework carries (see the note above).
+ */
+export type ErasedConfig<Cfg> = Cfg extends object ? {
+    [K in keyof Cfg]: K extends "pipelines" ? ErasedPipelines<Cfg[K], AvPipeline> : K extends "resources" ? ErasedResources<Cfg[K]> : K extends "application" | "client" | "agent" ? ErasedLayer<Cfg[K]> : Cfg[K];
+} : Cfg;
+export {};

package/dist/config/stage-type.eraser.js

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

package/dist/contracts/access-route.rules.d.ts

@@ -0,0 +1,10 @@
+/**
+ * An absolute `http:`/`https:` URL, or a root-relative path other than `"/"`:
+ * never `//host`, a backslash, a control character, a space or a dot segment.
+ */
+export declare function isAccessUrl(value: unknown): value is string;
+/**
+ * A verb's path under the section's `url`: starting with one `/`, never a
+ * backslash, a control character, a space or a dot segment.
+ */
+export declare function isAccessPath(value: unknown): value is string;

package/dist/contracts/access-route.rules.js

@@ -0,0 +1,45 @@
+function hasControlOrSpace(value) {
+    for (let index = 0; index < value.length; index += 1) {
+        const code = value.charCodeAt(index);
+        if (code <= 0x20 || code === 0x7f) {
+            return true;
+        }
+    }
+    return false;
+}
+const DOT_SEGMENT = /^(?:\.|%2e){1,2}$/i;
+function hasDotSegment(path) {
+    const end = path.search(/[?#]/);
+    return (end === -1 ? path : path.slice(0, end))
+        .split("/")
+        .some((segment) => DOT_SEGMENT.test(segment));
+}
+export function isAccessUrl(value) {
+    if (typeof value !== "string" ||
+        value.includes("\\") ||
+        hasControlOrSpace(value)) {
+        return false;
+    }
+    if (value.startsWith("/")) {
+        return value !== "/" && !value.startsWith("//") && !hasDotSegment(value);
+    }
+    const authority = /^[a-z][a-z0-9+.-]*:\/\/[^/?#]*/i.exec(value)?.[0];
+    if (authority === undefined || hasDotSegment(value.slice(authority.length))) {
+        return false;
+    }
+    try {
+        const { protocol } = new URL(value);
+        return protocol === "https:" || protocol === "http:";
+    }
+    catch {
+        return false;
+    }
+}
+export function isAccessPath(value) {
+    return (typeof value === "string" &&
+        value.startsWith("/") &&
+        !value.startsWith("//") &&
+        !value.includes("\\") &&
+        !hasControlOrSpace(value) &&
+        !hasDotSegment(value));
+}