@aventara/core 1.0.0-rc.1 → 1.0.0-rc.2

package/dist/runtime/create-requirement.js

@@ -1,6 +1,6 @@
 import { lookupField, lookupResource } from "../contracts/contract-lookup.js";
 import { advertisedDirectivesAt } from "../contracts/field.js";
-import { NESTED_WRITE_SCOPE, resolveWriteScope, } from "../operations/write-scope.resolver.js";
+import { LOOPBACK_WRITE_SCOPE, NESTED_WRITE_SCOPE, resolveWriteScope, } from "../operations/write-scope.resolver.js";
 import { isRelationMutationDirective, RELATION_MUTATION_RECORD_SITES, } from "./mutation-planner.js";
 function isRecord(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value);
@@ -63,9 +63,19 @@ function checkCreateRecord(context, resource, record, path, scope, via) {
     if (!isRecord(record)) {
         return;
     }
+    if (context.computed !== undefined) {
+        computedRequirementGaps(context, resource, record, path, via);
+        walkNestedCreates(context, resource, record, path);
+        return;
+    }
     const { contract, issues } = context;
-    const conflicted = referenceConflicts(context, resource, record, path);
-    mixedReferenceWrites(context, resource, record, path, conflicted);
+    const looped = loopbackWrites(context, resource, record, path, via, "create");
+    const conflicted = looped.size > 0
+        ? looped
+        : referenceConflicts(context, resource, record, path);
+    if (looped.size === 0) {
+        mixedReferenceWrites(context, resource, record, path, conflicted);
+    }
     const requirements = requirementsOf(contract, resource);
     if (requirements !== undefined) {
         const supplied = suppliedThrough(requirements, via);
@@ -157,14 +167,93 @@ function mixedReferenceWrites(context, resource, record, path, conflicted) {
         });
     }
 }
-function checkUpdateRecord(context, resource, record, path) {
+function checkUpdateRecord(context, resource, record, path, via) {
     if (!isRecord(record)) {
         return;
     }
-    const conflicted = referenceConflicts(context, resource, record, path);
-    mixedReferenceWrites(context, resource, record, path, conflicted);
+    if (context.computed === undefined &&
+        loopbackWrites(context, resource, record, path, via, "update").size === 0) {
+        const conflicted = referenceConflicts(context, resource, record, path);
+        mixedReferenceWrites(context, resource, record, path, conflicted);
+    }
     walkNestedCreates(context, resource, record, path);
 }
+function loopbackWrites(context, resource, record, path, via, stage) {
+    const refused = new Set();
+    if (via === undefined) {
+        return refused;
+    }
+    const { contract } = context;
+    const edge = lookupField(lookupResource(contract, via.resource), via.relation);
+    if (edge?.kind !== "relation" || typeof edge.inverse !== "string") {
+        return refused;
+    }
+    const inverse = edge.inverse;
+    const other = lookupField(lookupResource(contract, resource), inverse);
+    if (other?.kind === "relation" &&
+        advertisedDirectivesAt(other.capabilities[stage], LOOPBACK_WRITE_SCOPE) !==
+            undefined) {
+        return refused;
+    }
+    const references = edgesOf(context.references, resource).find((candidate) => candidate.field === inverse) ?? undefined;
+    for (const field of [
+        inverse,
+        ...(references === undefined ? [] : referencesOf(references)),
+    ]) {
+        if (!written(record, field)) {
+            continue;
+        }
+        refused.add(field);
+        context.issues.push({
+            code: "V1012",
+            path: [...path, field],
+            message: field === inverse
+                ? `Relation "${field}" is the relation this ${resource} is written through, from its other end ("${via.resource}.${via.relation}"): the write it sits in supplies it.`
+                : `Field "${field}" holds the reference of "${inverse}", the relation this ${resource} is written through ("${via.resource}.${via.relation}"): the write it sits in supplies it.`,
+        });
+    }
+    return refused;
+}
+function computedRequirementGaps(context, resource, record, path, via) {
+    const reader = context.computed;
+    const computed = reader?.computed(resource);
+    const stated = reader?.stated(resource);
+    if (computed === undefined || computed.size === 0 || stated === undefined) {
+        return;
+    }
+    const supplied = suppliedThrough(stated, via);
+    const gap = (field) => {
+        context.gaps?.push({
+            resource,
+            field,
+            issue: {
+                code: "V1000",
+                path: [...path, field],
+                message: `compute.create on ${resource}.${field} returned undefined for a required field.`,
+            },
+        });
+    };
+    for (const field of namesOf(stated.required)) {
+        if (computed.has(field) &&
+            !supplied.has(field) &&
+            !written(record, field)) {
+            gap(field);
+        }
+    }
+    const groups = Array.isArray(stated.oneOf) ? stated.oneOf : [];
+    for (const group of groups) {
+        const [relation, ...references] = namesOf(group);
+        const left = references.find((field) => computed.has(field) && !written(record, field));
+        if (relation === undefined ||
+            left === undefined ||
+            supplied.has(relation) ||
+            references.some((field) => supplied.has(field)) ||
+            written(record, relation)) {
+            continue;
+        }
+        gap(left);
+    }
+}
 function walkNestedCreates(context, resource, record, path) {
     if (!isRecord(record)) {
         return;
@@ -196,7 +285,7 @@ function walkNestedCreates(context, resource, record, path) {
                         checkCreateRecord(context, field.target, siteRecord, sitePath, NESTED_WRITE_SCOPE, via);
                     }
                     else {
-                        checkUpdateRecord(context, field.target, siteRecord, sitePath);
+                        checkUpdateRecord(context, field.target, siteRecord, sitePath, via);
                     }
                 }
             }
@@ -204,17 +293,52 @@ function walkNestedCreates(context, resource, record, path) {
     }
 }
 export function recordWriteFactsOf(adapter) {
-    return { references: adapter.referentialActions ?? {} };
+    const resources = adapter.model?.resources ?? {};
+    return {
+        references: adapter.referentialActions ?? {},
+        stated: (resource) => {
+            const found = Object.hasOwn(resources, resource)
+                ? resources[resource]
+                : undefined;
+            const stated = isRecord(found) ? found.createRequirements : undefined;
+            return isRecord(stated) ? stated : undefined;
+        },
+    };
 }
 export function createRequirementIssues(contract, facts, request, args, argumentsPath) {
-    if (!isRecord(args)) {
-        return [];
-    }
     const context = {
         contract,
         references: facts.references,
         issues: [],
     };
+    walkOperation(context, request, args, argumentsPath);
+    return context.issues;
+}
+export function preliminaryRecordIssues(contract, facts, request, args, argumentsPath) {
+    const context = {
+        contract,
+        references: facts.references,
+        issues: [],
+    };
+    walkOperation(context, request, args, argumentsPath);
+    return context.issues;
+}
+export function computedRequirementGapsOf(contract, facts, request, args, argumentsPath, computed) {
+    const gaps = [];
+    walkOperation({
+        contract,
+        references: facts.references,
+        issues: [],
+        computed: { stated: facts.stated, computed },
+        gaps,
+    }, request, args, argumentsPath);
+    return gaps;
+}
+function walkOperation(context, request, args, argumentsPath) {
+    if (!isRecord(args)) {
+        return;
+    }
+    const contract = context.contract;
     const scope = resolveWriteScope(lookupResource(contract, request.resource), request);
     if (request.family === "create" && written(args, "data")) {
         const data = args.data;
@@ -229,16 +353,9 @@ export function createRequirementIssues(contract, facts, request, args, argument
     }
     if (request.family === "upsert") {
         checkCreateRecord(context, request.resource, args.create, [...argumentsPath, "create"], scope, undefined);
-        checkUpdateRecord(context, request.resource, args.update, [
-            ...argumentsPath,
-            "update",
-        ]);
+        checkUpdateRecord(context, request.resource, args.update, [...argumentsPath, "update"], undefined);
     }
     if (request.family === "update") {
-        checkUpdateRecord(context, request.resource, args.data, [
-            ...argumentsPath,
-            "data",
-        ]);
+        checkUpdateRecord(context, request.resource, args.data, [...argumentsPath, "data"], undefined);
     }
-    return context.issues;
 }

package/dist/runtime/diagnostics-reporter.d.ts

@@ -47,7 +47,8 @@ export type AvTransactionDiagnostic = {
 };
 /**
  * One unplanned failure of the MCP endpoint itself, outside any tool call's
- * operation: the raw error, answered `500` with no detail.
+ * operation: the raw error, answered `500` with no detail, or `401` when it is
+ * the throw of `mcp.authorization.verify`.
  */
 export type AvMcpDiagnostic = {
     readonly kind: "mcp";

package/dist/runtime/error-boundary.js

@@ -1,3 +1,4 @@
+import { isDatabaseRefusalMessage } from "../operations/database-refusal.js";
 import { VALIDATION_CODE_MESSAGES, VALIDATION_CODES, } from "../operations/validation-code.js";
 import { AvError } from "./framework-error.js";
 import { INTERNAL_FAILURE_MESSAGE, internalFailure, OPERATION_CODES, operationFailure, } from "./operation-response.js";
@@ -164,6 +165,9 @@ function projectIssue(value, unvouched, view, author) {
             unvouched.push(supplied);
         }
     }
+    else if (isDatabaseRefusalMessage(code, supplied)) {
+        message = supplied;
+    }
     if (rawPath === undefined) {
         return { code, message };
     }

package/dist/runtime/error-guidance.d.ts

@@ -0,0 +1,12 @@
+/** Why a code is answered, and what the one who meets it should do. */
+export type ErrorCodeGuidance = {
+    /** What typically produced the code, in a sentence or two. */
+    readonly cause: string;
+    /** What to change so it does not happen again. */
+    readonly fix: string;
+};
+/** Guidance for a code whose table holds no message of its own. */
+export type ErrorCodeDescription = ErrorCodeGuidance & {
+    /** The code's meaning, in one short sentence. */
+    readonly message: string;
+};

package/dist/runtime/error-guidance.js

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

package/dist/runtime/error.catalog.d.ts

@@ -0,0 +1,49 @@
+import type { AvAdapterDiscoveryDiagnosticCode } from "../adapters/adapter-discovery-diagnostic.js";
+import type { AvContractCompilerDiagnosticCode } from "../compiler/contract-compiler-diagnostic.js";
+import type { AvConfigDiagnosticCode } from "../config/config-diagnostic.js";
+import type { AvConstructionStage } from "../framework/framework-construction.error.js";
+import { type AvValidationCode } from "../operations/validation-code.js";
+import { type AvOperationCode } from "./operation-response.js";
+/**
+ * The documentation page every catalog entry links into. Each code has its own
+ * anchor there: the code in lower case (`#a2004`, `#config_required`).
+ */
+export declare const ERROR_CODES_DOCS_URL = "https://aventara-framework.vercel.app/docs/error-codes";
+/**
+ * What kind of code an entry is: an outcome code's family (`success` `A1xxx`,
+ * `request` `A2xxx`, `internal` `A3xxx`, `auth` `A4xxx`), a `validation` issue
+ * code (`V1xxx`), or a startup code, by the construction stage that reports it.
+ */
+export type AvErrorKind = "success" | "request" | "internal" | "auth" | "validation" | AvConstructionStage;
+/** Every code the catalog describes: outcome, validation and startup codes. */
+export type AvErrorCatalogCode = AvOperationCode | AvValidationCode | AvConfigDiagnosticCode | AvAdapterDiscoveryDiagnosticCode | AvContractCompilerDiagnosticCode;
+/** One code: what it means, why it happens, what to do, and where it is documented. */
+export type AvErrorCatalogEntry<C extends AvErrorCatalogCode = AvErrorCatalogCode> = {
+    readonly code: C;
+    readonly kind: AvErrorKind;
+    /** Its meaning in one sentence; for a V-code, the framework's message for it. */
+    readonly message: string;
+    /** What typically produces it. */
+    readonly cause: string;
+    /** What to change. */
+    readonly fix: string;
+    /** Its entry on the error-codes page. */
+    readonly docs: string;
+};
+/** The error catalog's type: one entry per code. */
+export type AvErrorCatalog = {
+    readonly [C in AvErrorCatalogCode]: AvErrorCatalogEntry<C>;
+};
+/** The documentation URL of one code: the error-codes page at its anchor. */
+export declare function errorDocsUrl(code: AvErrorCatalogCode): string;
+/**
+ * Every code Aventara answers or refuses with, by code: its `kind`, `message`,
+ * `cause`, `fix` and `docs` URL. An operation's `code`, a validation issue's
+ * `code` and a startup diagnostic's `code` are all keys of it:
+ *
+ * ```ts
+ * AvErrorCatalog[error.code].fix;
+ * AvErrorCatalog.V1000.docs; // https://aventara-framework.vercel.app/docs/error-codes#v1000
+ * ```
+ */
+export declare const AvErrorCatalog: AvErrorCatalog;

package/dist/runtime/error.catalog.js

@@ -0,0 +1,49 @@
+import { ADAPTER_DISCOVERY_DIAGNOSTIC_GUIDANCE } from "../adapters/adapter-discovery-diagnostic.guidance.js";
+import { CONTRACT_COMPILER_DIAGNOSTIC_GUIDANCE } from "../compiler/contract-compiler-diagnostic.guidance.js";
+import { CONFIG_DIAGNOSTIC_GUIDANCE } from "../config/config-diagnostic.guidance.js";
+import { VALIDATION_CODE_GUIDANCE } from "../operations/validation-code.guidance.js";
+import { VALIDATION_CODE_MESSAGES, VALIDATION_CODES, } from "../operations/validation-code.js";
+import { OPERATION_CODE_GUIDANCE } from "./operation-code.guidance.js";
+import { OPERATION_CODES } from "./operation-response.js";
+export const ERROR_CODES_DOCS_URL = "https://aventara-framework.vercel.app/docs/error-codes";
+export function errorDocsUrl(code) {
+    return `${ERROR_CODES_DOCS_URL}#${code.toLowerCase()}`;
+}
+const OUTCOME_KIND = {
+    "1": "success",
+    "2": "request",
+    "3": "internal",
+    "4": "auth",
+};
+function entry(code, kind, description) {
+    return Object.freeze({
+        code,
+        kind,
+        message: description.message,
+        cause: description.cause,
+        fix: description.fix,
+        docs: errorDocsUrl(code),
+    });
+}
+function entriesOf(table, kind) {
+    return Object.keys(table).map((code) => [
+        code,
+        entry(code, kind, table[code]),
+    ]);
+}
+export const AvErrorCatalog = Object.freeze(Object.fromEntries([
+    ...OPERATION_CODES.map((code) => [
+        code,
+        entry(code, OUTCOME_KIND[code[1]], OPERATION_CODE_GUIDANCE[code]),
+    ]),
+    ...VALIDATION_CODES.map((code) => [
+        code,
+        entry(code, "validation", {
+            message: VALIDATION_CODE_MESSAGES[code],
+            ...VALIDATION_CODE_GUIDANCE[code],
+        }),
+    ]),
+    ...entriesOf(CONFIG_DIAGNOSTIC_GUIDANCE, "configuration"),
+    ...entriesOf(ADAPTER_DISCOVERY_DIAGNOSTIC_GUIDANCE, "discovery"),
+    ...entriesOf(CONTRACT_COMPILER_DIAGNOSTIC_GUIDANCE, "contract-compilation"),
+]));

package/dist/runtime/field-stage.runtime.d.ts

@@ -6,6 +6,8 @@ export type Path = readonly (string | number)[];
 type UnknownRecord = Readonly<Record<string, unknown>>;
 /** A plain object: what a write record, or a directive's operand, is. */
 export declare function isPlainRecord(value: unknown): value is UnknownRecord;
+/** The containers a family writes, by argument key. */
+export declare const WRITE_KEYS: Readonly<Partial<Record<AvOperationFamily, readonly string[]>>>;
 /** The fields of `resource` with stages, in the Resource's field order. */
 export declare function stagedFieldsOf(contract: AvContract, resource: string, stages: Readonly<Record<string, ResolvedFieldStages>>, kind: "pipes" | "guards"): readonly string[];
 /** The value at `path` in `args`, or `undefined` when nothing is there. */

package/dist/runtime/field-stage.runtime.js

@@ -1,3 +1,4 @@
+import { frozenCopy } from "./readonly-value.js";
 export function isPlainRecord(value) {
     if (value === null || typeof value !== "object" || Array.isArray(value)) {
         return false;
@@ -5,7 +6,7 @@ export function isPlainRecord(value) {
     const prototype = Object.getPrototypeOf(value);
     return prototype === Object.prototype || prototype === null;
 }
-const WRITE_KEYS = {
+export const WRITE_KEYS = {
     create: ["data"],
     update: ["data"],
     upsert: ["create", "update"],
@@ -104,9 +105,12 @@ export async function pipeSentFields(stages, fields, records, args, select) {
             }
             let value = record[field];
             for (const pipe of stages[field]?.pipes ?? []) {
-                const next = await pipe(value);
+                const told = frozenCopy(value);
+                const next = await pipe(told);
                 if (next !== undefined) {
-                    value = next;
+                    if (next !== told) {
+                        value = next;
+                    }
                     changed = true;
                 }
             }
@@ -133,7 +137,7 @@ export async function guardSentFields(stages, fields, records, args, context) {
             }
             for (const guard of stages[field]?.guards ?? []) {
                 const told = context();
-                if ((await guard(record[field], told)) === false) {
+                if ((await guard(frozenCopy(record[field]), told)) === false) {
                     return false;
                 }
             }

package/dist/runtime/field-validator.runtime.d.ts

@@ -3,9 +3,17 @@ import type { AvValidationIssue } from "../operations/validation-code.js";
 import { type Path } from "./field-stage.runtime.js";
 import type { OperationExecutionRequest } from "./operation-request.js";
 import type { ReferentialActionTable } from "./referential-action.js";
+/** The write phase of a record: a created row (an upsert's `create` branch too) or an updated one. */
+export type WriteStage = "create" | "update";
+/**
+ * The fields a judgment leaves for later: a plan step's (or a forced call's)
+ * literal values are judged before BEGIN, except a field a write compute stage
+ * of that phase may still change, which is judged after write compute.
+ */
+export type DeferredField = (resource: string, stage: WriteStage, field: string) => boolean;
 /**
  * Every way the sent fields `select` admits break their validators: the
  * operation's own records, then each nested write target's. Paths are the
  * request's: `argumentsPath` and then the value's place in the arguments.
  */
-export declare function fieldValidatorIssues(contract: AvContract, references: ReferentialActionTable, request: OperationExecutionRequest, args: unknown, argumentsPath: Path, select: (path: Path) => boolean): readonly AvValidationIssue[];
+export declare function fieldValidatorIssues(contract: AvContract, references: ReferentialActionTable, request: OperationExecutionRequest, args: unknown, argumentsPath: Path, select: (path: Path) => boolean, deferred?: DeferredField): readonly AvValidationIssue[];

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

@@ -36,17 +36,17 @@ function entryIssues(rules, entry, at) {
     const { compiled } = rules;
     return entryCheckIssues(compiled.checks, entry, compiled.subject ?? "string", at);
 }
-function recordIssues(contract, resource, records, args, argumentsPath, select) {
+function recordIssues(contract, resource, records, args, argumentsPath, select, deferred) {
     const compiled = validatedFieldsOf(contract, resource);
     const issues = [];
-    for (const path of records) {
+    for (const { path, stage } of records) {
         const record = valueAt(args, path);
         if (!isPlainRecord(record)) {
             continue;
         }
         for (const name of Object.keys(record)) {
             const rules = rulesOf(contract, compiled, resource, name);
-            if (rules === undefined) {
+            if (rules === undefined || deferred?.(resource, stage, name) === true) {
                 continue;
             }
             const fieldPath = [...path, name];
@@ -78,10 +78,15 @@ function recordIssues(contract, resource, records, args, argumentsPath, select)
     }
     return issues;
 }
-export function fieldValidatorIssues(contract, references, request, args, argumentsPath, select) {
-    const issues = recordIssues(contract, request.resource, writeRecordPathsOf(request.family, args), args, argumentsPath, select);
+export function fieldValidatorIssues(contract, references, request, args, argumentsPath, select, deferred) {
+    const issues = recordIssues(contract, request.resource, writeRecordPathsOf(request.family, args).map((path) => ({
+        path,
+        stage: request.family === "create" || path[0] === "create"
+            ? "create"
+            : "update",
+    })), args, argumentsPath, select, deferred);
     for (const target of nestedWriteTargetsOf(contract, references, request, args)) {
-        issues.push(...recordIssues(contract, target.resource, target.records.map((site) => site.path), args, argumentsPath, select));
+        issues.push(...recordIssues(contract, target.resource, target.records, args, argumentsPath, select, deferred));
     }
     return issues;
 }

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

@@ -1,15 +1,20 @@
 /**
  * A JSON value: the form of the `json` scalar, in arguments and results.
  *
- * A `Date`, a `bigint`, a `Uint8Array`, a {@link AvDecimal}, any other class
- * instance and an `undefined` property are refused (`V1001`), as are a
- * non-finite `number` (`V1004`) and a cycle (`V1001`).
+ * A `Date`, a `bigint`, a `Uint8Array`, a {@link AvDecimal} and any other class
+ * instance are refused (`V1001`), as are a non-finite `number` (`V1004`) and a
+ * cycle (`V1001`). An `undefined` inside the value is what JSON makes of it: a key
+ * holding it is left out, an array element holding it (or a hole) is `null`. The
+ * type admits a key holding `undefined`, so an object with an optional property is
+ * a JSON value; an array element stays typed without it, as JSON has no such
+ * value.
  *
- * Results are fresh plain copies, so mutating one is safe.
+ * Results are fresh plain copies, so mutating one is safe; a result never holds a
+ * key whose value is `undefined`.
  *
  * A `json` field's value is this without its top-level `null`: a field-level
  * `null` is the field's absence, which only `nullable: true` admits.
  */
 export type AvJsonValue = string | number | boolean | null | readonly AvJsonValue[] | {
-    readonly [key: string]: AvJsonValue;
+    readonly [key: string]: AvJsonValue | undefined;
 };

package/dist/runtime/level-lifecycle.runtime.d.ts

@@ -17,8 +17,8 @@ export type NextReuse<Refusal extends Error = Error> = {
  * Runs `levels`' lifecycle around `inner`: every interceptor, outer to inner,
  * around every before hook, `inner`, and every after hook. `settle` turns what
  * `inner` or an interceptor below resolved into what the stage above sees (the
- * operation read-materializes it). An after hook is told a deep-frozen copy of
- * the result; the result itself goes on to the interceptors, which may answer a
+ * operation read-materializes it). Each after hook is told its own deep-frozen
+ * copy of the result; the result itself goes on to the interceptors, which may answer a
  * different one. Every `next()` is single use: a second call rejects with
  * `refuse()`'s error, recorded in `reuse`, and runs nothing.
  */

package/dist/runtime/level-lifecycle.runtime.js

@@ -20,11 +20,8 @@ export async function runLevelLifecycle(levels, context, inner, settle, reuse, r
         }
         const result = await settle(await inner());
         const after = [...levels].reverse().flatMap((level) => level.hooks.after);
-        if (after.length > 0) {
-            const told = frozenCopy(result);
-            for (const hook of after) {
-                await hook(told, context());
-            }
+        for (const hook of after) {
+            await hook(frozenCopy(result), context());
         }
         return result;
     };

package/dist/runtime/mutation-planner.js

@@ -1,7 +1,8 @@
 import { lookupField, lookupResource } from "../contracts/contract-lookup.js";
 import { AvComputedValueError } from "./computed-value.error.js";
 import { replaceAt, valueAt } from "./field-stage.runtime.js";
-import { jsonShapeIssues, normalizeScalarFieldValue, } from "./scalar-runtime.js";
+import { frozenCopy } from "./readonly-value.js";
+import { normalizeScalarFieldValue } from "./scalar-runtime.js";
 function writeScalarField(contracts, resourceName, fieldName) {
     const field = lookupField(lookupResource(contracts.core, resourceName), fieldName) ??
         lookupField(lookupResource(contracts.active, resourceName), fieldName);
@@ -57,7 +58,7 @@ async function computeRecord(contracts, compute, resourceName, stage, data, cont
             if (field === undefined) {
                 continue;
             }
-            const snapshot = Object.freeze({ ...logicalData });
+            const snapshot = frozenCopy(logicalData);
             const computed = await callback({
                 field: fieldName,
                 value: snapshot[fieldName],
@@ -79,18 +80,6 @@ async function computeRecord(contracts, compute, resourceName, stage, data, cont
             if (!validation.ok) {
                 throw new AvComputedValueError(resourceName, fieldName, stage, validation.issues);
             }
-            const shapeIssues = jsonShapeIssues(field, validation.value, [
-                "resources",
-                resourceName,
-                "fields",
-                fieldName,
-                "pipelines",
-                "compute",
-                stage,
-            ]);
-            if (shapeIssues.length > 0) {
-                throw new AvComputedValueError(resourceName, fieldName, stage, shapeIssues);
-            }
             logicalData[fieldName] = validation.value;
         }
     }

package/dist/runtime/operation-code.guidance.d.ts

@@ -0,0 +1,6 @@
+import type { ErrorCodeDescription } from "./error-guidance.js";
+import type { AvOperationCode } from "./operation-response.js";
+/** Meaning, cause and fix of every outcome code. */
+export declare const OPERATION_CODE_GUIDANCE: {
+    readonly [C in AvOperationCode]: ErrorCodeDescription;
+};