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

package/dist/compiler/field-validator.compiler.js

@@ -0,0 +1,238 @@
+import { avzCheckOf, } from "../avz/avz-check.registry.js";
+import { FIELD_CHECK_SUBJECTS, } from "../runtime/field-check.evaluator.js";
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function own(record, key) {
+    return Object.hasOwn(record, key) ? record[key] : undefined;
+}
+function scalarOf(field) {
+    const type = field.type;
+    return typeof type?.scalar === "string" ? type.scalar : undefined;
+}
+function subjectOf(field) {
+    const scalar = scalarOf(field);
+    return scalar === undefined ? undefined : own(FIELD_CHECK_SUBJECTS, scalar);
+}
+function describeField(field) {
+    const scalar = scalarOf(field) ?? "enum";
+    const noun = `${scalar}${field.list === true ? " list" : ""} field`;
+    return `${/^[aeiou]/.test(scalar) ? "an" : "a"} ${noun}`;
+}
+function describeCheck(check) {
+    switch (check.check) {
+        case "less_than":
+            return check.inclusive ? "AvZ.lte" : "AvZ.lt";
+        case "greater_than":
+            return check.inclusive ? "AvZ.gte" : "AvZ.gt";
+        case "multiple_of":
+            return "AvZ.multipleOf";
+        case "max_length":
+            return check.list === true ? "AvZ.maxItems" : "AvZ.maxLength";
+        case "min_length":
+            return check.list === true ? "AvZ.minItems" : "AvZ.minLength";
+        case "length_equals":
+            return "AvZ.length";
+        case "string_format":
+            return `a string format check (${check.format})`;
+        case "max_size":
+            return "AvZ.maxSize";
+        case "min_size":
+            return "AvZ.minSize";
+        case "size_equals":
+            return "AvZ.size";
+    }
+}
+function boundFor(value, subject, multiple) {
+    switch (subject) {
+        case "number":
+            return typeof value === "number"
+                ? { value }
+                : { fault: "an int or float field's bound is a number" };
+        case "decimal":
+            return value instanceof Date
+                ? { fault: "a decimal field's bound is a number or a bigint" }
+                : { value: String(value) };
+        case "bigint":
+            return typeof value === "bigint" ||
+                (typeof value === "number" && Number.isSafeInteger(value))
+                ? { value: String(value) }
+                : { fault: "a bigint field's bound is a bigint" };
+        case "datetime":
+            return multiple
+                ? { fault: "a datetime takes bounds, not multiples" }
+                : value instanceof Date
+                    ? { value: value.toISOString() }
+                    : { fault: "a datetime field's bound is a Date" };
+        default:
+            return {
+                fault: "bounds apply to number, bigint, decimal and datetime fields",
+            };
+    }
+}
+function compileCheck(check, field) {
+    const subject = subjectOf(field);
+    switch (check.check) {
+        case "less_than":
+        case "greater_than":
+        case "multiple_of": {
+            const written = boundFor(check.value, subject, check.check === "multiple_of");
+            if ("fault" in written) {
+                return written;
+            }
+            return {
+                check: check.check === "multiple_of"
+                    ? { check: "multiple_of", value: written.value }
+                    : {
+                        check: check.check,
+                        value: written.value,
+                        inclusive: check.inclusive,
+                    },
+            };
+        }
+        case "max_length":
+        case "min_length":
+            if (check.list === true) {
+                return field.list === true
+                    ? { check }
+                    : {
+                        fault: "AvZ.minItems and AvZ.maxItems check a list's length; the field is not a list",
+                    };
+            }
+            return subject === "string"
+                ? { check }
+                : { fault: "length checks apply to string fields" };
+        case "length_equals":
+        case "string_format":
+            return subject === "string"
+                ? { check }
+                : { fault: "string checks apply to string fields" };
+        case "max_size":
+        case "min_size":
+        case "size_equals":
+            return subject === "bytes"
+                ? { check }
+                : { fault: "size checks apply to bytes fields" };
+    }
+}
+function label(resource, field) {
+    return `${resource}.${field}`;
+}
+export function checkLayerValidators(resources, layer, tree, diagnostics) {
+    if (!isRecord(tree)) {
+        return;
+    }
+    for (const [resourceName, entry] of Object.entries(tree)) {
+        const resource = own(resources, resourceName);
+        if (resource === undefined || !isRecord(entry) || !isRecord(entry.fields)) {
+            continue;
+        }
+        for (const [fieldName, fieldEntry] of Object.entries(entry.fields)) {
+            const field = own(resource.fields, fieldName);
+            if (field === undefined ||
+                !isRecord(fieldEntry) ||
+                !isRecord(fieldEntry.pipelines) ||
+                !Object.hasOwn(fieldEntry.pipelines, "validators")) {
+                continue;
+            }
+            const path = `${layer}.resources.${resourceName}.fields.${fieldName}.pipelines.validators`;
+            const refuse = (at, message) => diagnostics.push({
+                code: "COMPILER_INVALID_VALIDATOR",
+                path: at,
+                message,
+            });
+            if (field.kind === "relation") {
+                refuse(path, `relation field "${label(resourceName, fieldName)}" takes write guards only; validators check a scalar field's value`);
+                continue;
+            }
+            if (scalarOf(field) === "json") {
+                refuse(path, `field "${label(resourceName, fieldName)}" is a Json field: Json fields carry their checks in definition.json (AvZ.string().check(AvZ.maxLength(80)), …)`);
+                continue;
+            }
+            const validators = fieldEntry.pipelines.validators;
+            if (!Array.isArray(validators)) {
+                continue;
+            }
+            for (const [index, value] of validators.entries()) {
+                const at = `${path}[${index}]`;
+                const check = avzCheckOf(value);
+                if (check === undefined) {
+                    refuse(at, `field "${label(resourceName, fieldName)}": a validator must be a check built with AvZ from "@aventara/core/avz" (AvZ.maxLength(80), AvZ.email(), …); a Zod check or any other value is not accepted`);
+                    continue;
+                }
+                const compiled = compileCheck(check, field);
+                if ("fault" in compiled) {
+                    refuse(at, `${describeCheck(check)} does not fit field "${label(resourceName, fieldName)}", ${describeField(field)}: ${compiled.fault}`);
+                }
+            }
+        }
+    }
+}
+export function compileValidatorTable(resources, tree) {
+    const table = {};
+    for (const [resourceName, pipelines] of Object.entries(tree.resources)) {
+        const resource = own(resources, resourceName);
+        if (resource === undefined) {
+            continue;
+        }
+        for (const [fieldName, field] of Object.entries(resource.fields)) {
+            const stages = own(pipelines.fields, fieldName);
+            if (stages === undefined ||
+                field.kind !== "scalar" ||
+                scalarOf(field) === "json" ||
+                stages.validators.length === 0) {
+                continue;
+            }
+            const checks = stages.validators.flatMap((value) => {
+                const check = avzCheckOf(value);
+                const compiled = check === undefined ? undefined : compileCheck(check, field);
+                return compiled !== undefined && "check" in compiled
+                    ? [compiled.check]
+                    : [];
+            });
+            if (checks.length > 0) {
+                table[resourceName] ??= {};
+                table[resourceName][fieldName] = {
+                    checks,
+                    subject: subjectOf(field),
+                    list: field.list === true,
+                };
+            }
+        }
+    }
+    return table;
+}
+export function applyValidators(resources, table) {
+    for (const [resourceName, fields] of Object.entries(table)) {
+        const resource = own(resources, resourceName);
+        for (const [fieldName, compiled] of Object.entries(fields)) {
+            const field = resource === undefined ? undefined : own(resource.fields, fieldName);
+            if (field !== undefined && field.kind === "scalar") {
+                field.validators = compiled.checks.map((check) => ({ ...check }));
+            }
+        }
+    }
+}
+const tables = new WeakMap();
+export function bindFieldValidators(contract, table) {
+    tables.set(contract, table);
+}
+const shaped = new WeakMap();
+function hasShapedField(contract) {
+    let found = shaped.get(contract);
+    if (found === undefined) {
+        found = Object.values(contract.resources).some((resource) => Object.values(resource.fields).some((field) => field.kind === "scalar" && field.json !== undefined));
+        shaped.set(contract, found);
+    }
+    return found;
+}
+export function hasFieldValidators(contract) {
+    const table = tables.get(contract);
+    return ((table !== undefined && Object.keys(table).length > 0) ||
+        hasShapedField(contract));
+}
+const NO_FIELDS = Object.freeze({});
+export function validatedFieldsOf(contract, resource) {
+    const table = tables.get(contract);
+    return (table === undefined ? undefined : own(table, resource)) ?? NO_FIELDS;
+}

package/dist/compiler/managed-elsewhere.projector.d.ts

@@ -0,0 +1,52 @@
+import type { AvAdapterModel } from "../adapters/adapter-model.js";
+import type { AvContractCompilerDiagnostic } from "./contract-compiler-diagnostic.js";
+type ProjectedField = Record<string, unknown> & {
+    kind: "scalar" | "relation";
+};
+type ProjectedResource = {
+    fields: Record<string, ProjectedField>;
+    operations: Record<string, unknown>;
+    schema?: string;
+    managedElsewhere?: true;
+};
+type ProjectedContract = {
+    resources: Record<string, ProjectedResource>;
+};
+/** The Resources the root's `resources` tree marks `managedElsewhere: true`. */
+export declare function managedElsewhereOf(rootTree: unknown): ReadonlySet<string>;
+/**
+ * Takes every write of a managed Resource away from `baseline`: its write
+ * families, its fields' `create`/`update`, and the directives of every relation
+ * into it that would write its rows.
+ */
+export declare function withholdManagedWrites(baseline: ProjectedContract, managed: ReadonlySet<string>): void;
+/**
+ * Leaves every managed Resource out of `view`, with every relation into it: the
+ * client's and the agent's parent view.
+ */
+export declare function hideManagedElsewhere(view: ProjectedContract, managed: ReadonlySet<string>): void;
+/**
+ * Leaves out of `view` (a client's or the agent's projection) each enum the
+ * managed Resources' fields use in `unhidden` (the view before they were
+ * hidden) and no field of `view` uses.
+ */
+export declare function pruneManagedEnums(view: ProjectedContract & {
+    enums: Record<string, unknown>;
+}, unhidden: ProjectedContract, managed: ReadonlySet<string>): void;
+/**
+ * The Core Contract's Resource facts: the `schema` the adapter states, and
+ * `managedElsewhere: true` on each managed Resource.
+ */
+export declare function markCoreResources(projection: ProjectedContract, model: AvAdapterModel, managed: ReadonlySet<string>): void;
+/**
+ * Why a write family of a managed Resource is unavailable, or `undefined` when
+ * the Resource is not managed or the family is not a write.
+ */
+export declare function managedWriteReason(managed: ReadonlySet<string>, resource: string, family: string): string | undefined;
+/**
+ * Adds to each create-requirement refusal from `from` on whose relation points
+ * at a managed Resource why that relation cannot be written, and the reference
+ * fields that can: exposing the relation, the refusal's own advice, is not open.
+ */
+export declare function explainManagedRefusals(diagnostics: AvContractCompilerDiagnostic[], from: number, layer: string, universe: ProjectedContract, managed: ReadonlySet<string>): void;
+export {};

package/dist/compiler/managed-elsewhere.projector.js

@@ -0,0 +1,179 @@
+const WRITE_FAMILIES = [
+    "create",
+    "update",
+    "delete",
+    "upsert",
+];
+const SOURCE_ROW_DIRECTIVES = [
+    "$connect",
+    "$disconnect",
+];
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export function managedElsewhereOf(rootTree) {
+    const managed = new Set();
+    if (!isRecord(rootTree)) {
+        return managed;
+    }
+    for (const [name, entry] of Object.entries(rootTree)) {
+        if (isRecord(entry) && entry.managedElsewhere === true) {
+            managed.add(name);
+        }
+    }
+    return managed;
+}
+function keptDirectives(capability, kept) {
+    if (Array.isArray(capability)) {
+        const left = capability.filter((directive) => kept.includes(directive));
+        return left.length > 0 ? left : undefined;
+    }
+    if (isRecord(capability) && Array.isArray(capability.directives)) {
+        const left = capability.directives.filter((directive) => kept.includes(directive));
+        return left.length > 0 ? { ...capability, directives: left } : undefined;
+    }
+    return capability;
+}
+function narrowWrites(field, kept) {
+    const capabilities = field.capabilities;
+    if (!isRecord(capabilities)) {
+        return;
+    }
+    for (const stage of ["create", "update"]) {
+        if (!Object.hasOwn(capabilities, stage)) {
+            continue;
+        }
+        const narrowed = keptDirectives(capabilities[stage], kept);
+        if (narrowed === undefined) {
+            delete capabilities[stage];
+        }
+        else {
+            capabilities[stage] = narrowed;
+        }
+    }
+}
+export function withholdManagedWrites(baseline, managed) {
+    if (managed.size === 0) {
+        return;
+    }
+    for (const [name, resource] of Object.entries(baseline.resources)) {
+        const isManaged = managed.has(name);
+        if (isManaged) {
+            for (const family of WRITE_FAMILIES) {
+                delete resource.operations[family];
+            }
+        }
+        for (const field of Object.values(resource.fields)) {
+            if (isManaged) {
+                narrowWrites(field, []);
+                continue;
+            }
+            if (field.kind !== "relation" || !managed.has(String(field.target))) {
+                continue;
+            }
+            narrowWrites(field, Array.isArray(field.referenceFields) && field.referenceFields.length > 0
+                ? SOURCE_ROW_DIRECTIVES
+                : []);
+        }
+    }
+}
+export function hideManagedElsewhere(view, managed) {
+    for (const name of managed) {
+        delete view.resources[name];
+    }
+    if (managed.size === 0) {
+        return;
+    }
+    for (const resource of Object.values(view.resources)) {
+        for (const [fieldName, field] of Object.entries(resource.fields)) {
+            if (field.kind === "relation" && managed.has(String(field.target))) {
+                delete resource.fields[fieldName];
+            }
+        }
+    }
+}
+function enumOf(field) {
+    const type = field.kind === "scalar" ? field.type : undefined;
+    return typeof type === "object" &&
+        type !== null &&
+        typeof type.enum === "string"
+        ? type.enum
+        : undefined;
+}
+function enumsUsed(resources) {
+    const used = new Set();
+    for (const resource of resources) {
+        for (const field of Object.values(resource.fields)) {
+            const name = enumOf(field);
+            if (name !== undefined) {
+                used.add(name);
+            }
+        }
+    }
+    return used;
+}
+export function pruneManagedEnums(view, unhidden, managed) {
+    const managedUse = enumsUsed([...managed].flatMap((name) => Object.hasOwn(unhidden.resources, name)
+        ? [unhidden.resources[name]]
+        : []));
+    if (managedUse.size === 0) {
+        return;
+    }
+    const served = enumsUsed(Object.values(view.resources));
+    for (const name of managedUse) {
+        if (!served.has(name)) {
+            delete view.enums[name];
+        }
+    }
+}
+export function markCoreResources(projection, model, managed) {
+    for (const [name, resource] of Object.entries(projection.resources)) {
+        const schema = Object.hasOwn(model.resources, name)
+            ? model.resources[name]?.schema
+            : undefined;
+        if (typeof schema === "string") {
+            resource.schema = schema;
+        }
+        if (managed.has(name)) {
+            resource.managedElsewhere = true;
+        }
+    }
+}
+export function managedWriteReason(managed, resource, family) {
+    return managed.has(resource) && WRITE_FAMILIES.includes(family)
+        ? `operation family "${family}" is not available for resource "${resource}": it is managed elsewhere (resources.${resource}.managedElsewhere), read and joined, never written`
+        : undefined;
+}
+export function explainManagedRefusals(diagnostics, from, layer, universe, managed) {
+    if (managed.size === 0) {
+        return;
+    }
+    const prefix = `${layer}.exemptions.resources.`;
+    for (let index = from; index < diagnostics.length; index += 1) {
+        const diagnostic = diagnostics[index];
+        if (diagnostic?.code !== "COMPILER_HIDDEN_REQUIRED_FIELD" ||
+            !diagnostic.path.startsWith(prefix)) {
+            continue;
+        }
+        const [resource, fieldsKey, field] = diagnostic.path
+            .slice(prefix.length)
+            .split(".");
+        const relation = resource !== undefined &&
+            fieldsKey === "fields" &&
+            field !== undefined &&
+            Object.hasOwn(universe.resources, resource)
+            ? universe.resources[resource]?.fields[field]
+            : undefined;
+        const target = String(relation?.target);
+        if (relation?.kind !== "relation" || !managed.has(target)) {
+            continue;
+        }
+        const references = Array.isArray(relation.referenceFields)
+            ? relation.referenceFields.map((name) => `"${String(name)}"`)
+            : [];
+        diagnostics[index] = {
+            ...diagnostic,
+            message: `${diagnostic.message}; "${field}" points at resource "${target}", which is managed elsewhere (resources.${target}.managedElsewhere): the ${layer} layer never writes it${references.length === 0 ? "" : `, so expose ${references.join(" and ")}`}`,
+        };
+    }
+}

package/dist/compiler/managed-elsewhere.validator.d.ts

@@ -0,0 +1,9 @@
+import type { AvConfigDiagnostic } from "../config/config-diagnostic.js";
+import type { ReferentialActionTable } from "../runtime/referential-action.js";
+import type { AvContracts } from "./contract.compiler.js";
+/**
+ * One `CONFIG_INVALID_VALUE` per deletable Resource whose delete — directly, or
+ * through the cascades it sets off — does `cascade`, `setNull` or `setDefault`
+ * to the rows of a Resource managed elsewhere.
+ */
+export declare function validateManagedDeletes(contracts: AvContracts, referentialActions: ReferentialActionTable | undefined): readonly AvConfigDiagnostic[];

package/dist/compiler/managed-elsewhere.validator.js

@@ -0,0 +1,74 @@
+import { advertisedDirectives } from "../contracts/field.js";
+function deletable(contracts) {
+    const names = new Set();
+    for (const contract of contracts) {
+        for (const [name, resource] of Object.entries(contract.resources)) {
+            if (Object.hasOwn(resource.operations, "delete")) {
+                names.add(name);
+            }
+            for (const field of Object.values(resource.fields)) {
+                if (field.kind !== "relation") {
+                    continue;
+                }
+                const { create, update } = field.capabilities;
+                if (advertisedDirectives(create)?.includes("$delete") === true ||
+                    advertisedDirectives(update)?.includes("$delete") === true) {
+                    names.add(field.target);
+                }
+            }
+        }
+    }
+    return names;
+}
+function hopLabel(resource, edge) {
+    return `${resource}.${edge.field} → ${edge.target}`;
+}
+export function validateManagedDeletes(contracts, referentialActions) {
+    const core = contracts.core;
+    const managed = new Set(Object.entries(core.resources)
+        .filter(([, resource]) => resource.managedElsewhere === true)
+        .map(([name]) => name));
+    if (managed.size === 0 || referentialActions === undefined) {
+        return [];
+    }
+    const firedBy = new Map();
+    for (const [resource, edges] of Object.entries(referentialActions)) {
+        for (const edge of edges) {
+            firedBy.set(edge.target, [
+                ...(firedBy.get(edge.target) ?? []),
+                { edge, from: resource },
+            ]);
+        }
+    }
+    const diagnostics = [];
+    const deleters = [
+        ...deletable([contracts.application, contracts.client, contracts.agent]),
+    ]
+        .filter((name) => !managed.has(name))
+        .sort();
+    for (const deleted of deleters) {
+        const reachedBy = new Map([[deleted, []]]);
+        const queue = [deleted];
+        for (let next = queue.shift(); next !== undefined; next = queue.shift()) {
+            const chain = reachedBy.get(next) ?? [];
+            for (const { edge, from } of firedBy.get(next) ?? []) {
+                const hop = [hopLabel(from, edge), ...chain];
+                if (managed.has(from)) {
+                    if (edge.onDelete !== "restrict" && edge.onDelete !== "noAction") {
+                        diagnostics.push({
+                            code: "CONFIG_INVALID_VALUE",
+                            path: `resources.${from}.managedElsewhere`,
+                            message: `resources.${from}.managedElsewhere: deleting a "${deleted}" row does ${edge.onDelete} to "${from}" rows (${hop.join(", ")}), and another service owns "${from}"; take every delete of "${deleted}" away at the root (exemptions.resources.${deleted}.operations: ["delete"], and every $delete into it), or make the reference refuse the delete (onDelete: Restrict or NoAction)`,
+                        });
+                    }
+                    continue;
+                }
+                if (edge.onDelete === "cascade" && !reachedBy.has(from)) {
+                    reachedBy.set(from, hop);
+                    queue.push(from);
+                }
+            }
+        }
+    }
+    return diagnostics;
+}

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

@@ -1,19 +1,26 @@
-/** A `fields` block whose resource and field names are both unconstrained. */
-export type AnyFieldsBlock = Readonly<Record<string, Readonly<Record<string, unknown>> | undefined>>;
-/** The widest scope overlay: a `fields` block, and anything else. */
-export type AnyScopeConfig = {
+/**
+ * A `resources` block whose Resource and field names are both unconstrained:
+ * each Resource entry may carry a `fields` record of any names.
+ */
+export type AvConfigResourcesAny = Readonly<Record<string, {
     readonly [key: string]: unknown;
-    readonly fields?: AnyFieldsBlock;
+    readonly fields?: Readonly<Record<string, unknown>> | undefined;
+} | undefined>>;
+/** The widest layer overlay: a `resources` block, and anything else. */
+export type AvConfigLayerAny = {
+    readonly [key: string | symbol]: unknown;
+    readonly resources?: AvConfigResourcesAny;
 };
 /**
- * The widest configuration type: every resource admits every field name. It
- * is the default `Cfg` of `FrameworkConfig`, `Framework` and
+ * The widest configuration type: every Resource admits every field name. It
+ * is the default `Cfg` of `AvConfig`, `AvFramework` and
  * `createFramework`; pass your own configuration's type instead to get field
  * names checked.
  */
-export type AnyFrameworkConfig = {
-    readonly [key: string]: unknown;
-    readonly fields?: AnyFieldsBlock;
-    readonly application?: AnyScopeConfig;
-    readonly client?: AnyScopeConfig;
+export type AvConfigAny = {
+    readonly [key: string | symbol]: unknown;
+    readonly resources?: AvConfigResourcesAny;
+    readonly application?: AvConfigLayerAny;
+    readonly client?: AvConfigLayerAny;
+    readonly agent?: AvConfigLayerAny;
 };

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

@@ -0,0 +1,62 @@
+import type { AvConfigAgentParent, AvConfigLayerName } from "./config-layer.js";
+/** The fields one layer's write compute fills, per Resource and phase. */
+type LayerComputedFields = Readonly<Record<string, {
+    /** Fields with a `compute.create` stage, sorted. */
+    readonly create?: readonly string[];
+    /** Fields with a `compute.update` stage, sorted. */
+    readonly update?: readonly string[];
+}>>;
+/**
+ * Which fields a configuration's write compute fills: per layer, the
+ * Resources, and per Resource the fields with a `compute.create` and a
+ * `compute.update` stage, each list sorted; and the layer the agent layer
+ * extends. Written by an adapter's generate step from the configuration's type,
+ * and compared with the configuration at startup.
+ */
+export type AvConfigComputedFields = {
+    readonly agent: LayerComputedFields;
+    /** The agent layer's `extends`: `"client"` when the configuration leaves it out. */
+    readonly agentExtends: Exclude<AvConfigLayerName, "agent">;
+    readonly application: LayerComputedFields;
+    readonly client: LayerComputedFields;
+    readonly root: LayerComputedFields;
+};
+/** The layers whose compute may have filled a field when a stage of layer `L` runs. */
+type ComputingLayers<Facts extends AvConfigComputedFields, L extends AvConfigLayerName> = L extends "root" ? AvConfigLayerName : L extends "agent" ? "root" | "agent" | Exclude<Facts["agentExtends"], "root"> : "root" | L | (Facts["agentExtends"] extends L ? "agent" : never);
+/** `"<Resource>.<field>"` for every field a layer's `compute.create` fills. */
+type CreateComputedOf<Layer> = Layer extends object ? {
+    [R in keyof Layer]: Layer[R] extends {
+        readonly create?: readonly (infer Field extends string)[];
+    } ? `${R & string}.${Field}` : never;
+}[keyof Layer] : never;
+/**
+ * The create fields a variant's guards, pipes and filters of layer `L` may be
+ * told without, as `"<Resource>.<field>"`: those a layer whose compute runs for
+ * the stage's origins fills on create. `string` (every field) when the model's
+ * type carries no statement of them.
+ */
+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 configuration's layers' `resources` trees and the agent's parent. */
+type ComputedFieldsSource = {
+    readonly trees: Readonly<Record<AvConfigLayerName, unknown>>;
+    readonly agentExtends: AvConfigAgentParent;
+};
+/** The computed fields of a configuration, in the form a generate step writes them. */
+export declare function computedFieldsOf(source: ComputedFieldsSource): AvConfigComputedFields;
+/**
+ * How the configuration's computed fields differ from the ones the generated
+ * types were written with, one sentence per difference; empty when they agree.
+ */
+export declare function computedFieldsDrift(generated: AvConfigComputedFields, configured: AvConfigComputedFields): string[];
+/** The warning's code, as `process.emitWarning` reports it. */
+export declare const STALE_GENERATED_TYPES_WARNING = "AVENTARA_STALE_GENERATED_TYPES";
+/**
+ * Warns, through `process.emitWarning` (code
+ * {@link STALE_GENERATED_TYPES_WARNING}), when the generated types' computed
+ * fields differ from the configuration's. Nothing to compare (an Adapter that
+ * carries none) warns nothing.
+ */
+export declare function warnOnStaleComputedFields(generated: AvConfigComputedFields | undefined, configured: AvConfigComputedFields): void;
+export {};