@researchdatabox/redbox-core 5.0.2 → 5.0.4-beta.12498

package/dist/services/RecordValidationService.js

@@ -0,0 +1,1898 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Services = exports.RECORD_VALIDATION_DIAGNOSTIC_CODES = void 0;
+exports.resolveValidationMode = resolveValidationMode;
+const rxjs_1 = require("rxjs");
+const node_perf_hooks_1 = require("node:perf_hooks");
+const lodash_1 = __importDefault(require("lodash"));
+const api_1 = require("@opentelemetry/api");
+const sails_ng_common_1 = require("@researchdatabox/sails-ng-common");
+const CoreService_1 = require("../CoreService");
+const recordSchema_config_1 = require("../config/recordSchema.config");
+const RecordFormFingerprint_1 = require("../RecordFormFingerprint");
+const record_contract_context_1 = require("../record-contract/record-contract-context");
+const construct_visitor_1 = require("../visitor/construct.visitor");
+const validator_visitor_1 = require("../visitor/validator.visitor");
+exports.RECORD_VALIDATION_DIAGNOSTIC_CODES = {
+    formReferenceMissing: 'record-validation-form-reference-missing',
+    formReferenceMalformed: 'record-validation-form-reference-malformed',
+    formNotFound: 'record-validation-form-not-found',
+    formConfigurationMissing: 'record-validation-form-configuration-missing',
+    formConfigurationMalformed: 'record-validation-form-configuration-malformed',
+    formReferenceDivergence: 'record-validation-form-reference-divergence',
+    recordTypeReferenceMissing: 'record-validation-record-type-reference-missing',
+    recordTypeReferenceMalformed: 'record-validation-record-type-reference-malformed',
+    recordTypeNotFound: 'record-validation-record-type-not-found',
+    brandReferenceMissing: 'record-validation-brand-reference-missing',
+    brandReferenceMalformed: 'record-validation-brand-reference-malformed',
+    workflowStepReferenceMissing: 'record-validation-workflow-step-reference-missing',
+    workflowStepReferenceMalformed: 'record-validation-workflow-step-reference-malformed',
+    workflowStepNotFound: 'record-validation-workflow-step-not-found',
+    workflowStepFormMissing: 'record-validation-workflow-step-form-missing',
+    operationMalformed: 'record-validation-operation-malformed',
+    operationUnknown: 'record-validation-operation-unknown',
+    operationRoleUnauthorized: 'record-validation-operation-role-unauthorized',
+    operationTargetUnauthorized: 'record-validation-operation-target-unauthorized',
+    operationPolicyMalformed: 'record-validation-operation-policy-malformed',
+    rolloutModeMalformed: 'record-validation-rollout-mode-malformed',
+    expressionUnsupported: 'record-validation-expression-unsupported',
+    expressionEvaluationFailed: 'record-validation-expression-evaluation-failed',
+    expressionResultMalformed: 'record-validation-expression-result-malformed',
+    expressionContextUnsupported: 'record-validation-expression-context-unsupported',
+    transformationInapplicable: 'record-validation-transformation-inapplicable',
+    validationGroupUnknown: 'record-validation-group-unknown',
+    requestParameterDropped: 'record-validation-request-parameter-dropped',
+    resolutionFailed: 'record-validation-resolution-failed',
+    advisoryConfigurationMalformed: 'record-validation-advisory-configuration-malformed',
+    advisoryGroupUnknown: 'record-validation-advisory-group-unknown',
+    validationGroupOverlap: 'record-validation-group-overlap',
+    blockingExecutionFailed: 'record-validation-execution-failed',
+    advisoryExecutionFailed: 'record-validation-advisory-execution-failed',
+    blockingTimeout: 'record-validation-timeout',
+    advisoryTimeout: 'record-validation-advisory-timeout',
+};
+function operationMode(config, operation) {
+    if (!operation || !config?.operations || typeof config.operations !== 'object' || Array.isArray(config.operations)) {
+        return undefined;
+    }
+    const operations = config.operations;
+    if (!Object.hasOwn(operations, operation))
+        return undefined;
+    const override = operations[operation];
+    return override && typeof override === 'object' && !Array.isArray(override)
+        ? override.mode
+        : undefined;
+}
+/**
+ * Resolve rollout mode with one shared precedence rule:
+ * global -> global operation -> record type -> record-type operation.
+ */
+function resolveValidationMode(globalConfig, recordTypeConfig, operation) {
+    const configuredValues = [
+        globalConfig?.mode,
+        operationMode(globalConfig, operation),
+        recordTypeConfig?.mode,
+        operationMode(recordTypeConfig, operation),
+    ];
+    let mode = 'shadow';
+    let malformedModeCount = 0;
+    for (const configured of configuredValues) {
+        if (configured === undefined)
+            continue;
+        if (configured === 'shadow' || configured === 'enforce') {
+            mode = configured;
+        }
+        else {
+            malformedModeCount += 1;
+        }
+    }
+    return { mode, malformedModeCount };
+}
+const SAFE_FIELD_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/;
+const SAFE_VALIDATOR_CLASS_PATTERN = /^[A-Za-z][A-Za-z0-9_.#-]{0,127}$/;
+const SAFE_TRANSLATION_KEY_PATTERN = /^@[A-Za-z0-9][A-Za-z0-9_.:-]{0,255}$/;
+const SAFE_DIAGNOSTIC_CODE_PATTERN = /^[A-Za-z][A-Za-z0-9._-]{0,127}$/;
+const STRICT_ALL_OPERATION = 'strict-all';
+const UNRESOLVED_DIMENSION = 'unresolved';
+const UNKNOWN_OPERATION_DIMENSION = 'unknown';
+const MALFORMED_OPERATION_DIMENSION = 'malformed';
+const VALIDATOR_FAILURE_DIAGNOSTIC_CODE = 'record-validation-validator-failure';
+const OTHER_DIAGNOSTIC_CODE = 'record-validation-diagnostic-other';
+const openTelemetryDiagnosticCodes = new Set([
+    ...Object.values(exports.RECORD_VALIDATION_DIAGNOSTIC_CODES),
+    VALIDATOR_FAILURE_DIAGNOSTIC_CODE,
+]);
+function openTelemetryResolvedDimension(metric, value) {
+    return metric.status === 'resolved' && value ? value : UNRESOLVED_DIMENSION;
+}
+function openTelemetryOperationDimension(metric) {
+    if (!metric.operation)
+        return STRICT_ALL_OPERATION;
+    if (metric.operation === UNKNOWN_OPERATION_DIMENSION || metric.operation === MALFORMED_OPERATION_DIMENSION) {
+        return metric.operation;
+    }
+    return metric.status === 'resolved' ? metric.operation : UNRESOLVED_DIMENSION;
+}
+function openTelemetryDiagnosticCode(code) {
+    return openTelemetryDiagnosticCodes.has(code) ? code : OTHER_DIAGNOSTIC_CODE;
+}
+const requestRejectionCodes = new Set([
+    exports.RECORD_VALIDATION_DIAGNOSTIC_CODES.operationMalformed,
+    exports.RECORD_VALIDATION_DIAGNOSTIC_CODES.operationUnknown,
+    exports.RECORD_VALIDATION_DIAGNOSTIC_CODES.operationRoleUnauthorized,
+    exports.RECORD_VALIDATION_DIAGNOSTIC_CODES.operationTargetUnauthorized,
+]);
+const recordValidationMeter = api_1.metrics.getMeter('redbox.record-validation');
+const recordValidationDuration = recordValidationMeter.createHistogram('redbox.record_validation.duration', {
+    description: 'Authoritative record-validation resolution duration.',
+    unit: 'ms',
+});
+const recordValidationRuns = recordValidationMeter.createCounter('redbox.record_validation.runs', {
+    description: 'Authoritative record-validation resolutions by mode and outcome.',
+    unit: '{run}',
+});
+const recordValidationBlockingErrors = recordValidationMeter.createCounter('redbox.record_validation.blocking_errors', { description: 'Blocking validator failures returned by authoritative validation.', unit: '{error}' });
+const recordValidationAdvisoryErrors = recordValidationMeter.createCounter('redbox.record_validation.advisory_errors', { description: 'Advisory validator failures observed by authoritative validation.', unit: '{error}' });
+const recordValidationTimeouts = recordValidationMeter.createCounter('redbox.record_validation.timeouts', {
+    description: 'Blocking or advisory authoritative-validation timeouts.',
+    unit: '{timeout}',
+});
+const recordValidationConfigurationDiagnostics = recordValidationMeter.createCounter('redbox.record_validation.configuration_diagnostics', { description: 'Safe authoritative-validation configuration or execution diagnostics.', unit: '{diagnostic}' });
+const recordValidationDiagnostics = recordValidationMeter.createCounter('redbox.record_validation.diagnostics', {
+    description: 'Safe authoritative-validation diagnostics by stable code.',
+    unit: '{diagnostic}',
+});
+class ValidationDeadlineExceeded extends Error {
+    constructor() {
+        super('Record validation deadline exceeded.');
+        this.name = 'ValidationDeadlineExceeded';
+    }
+}
+function isRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+/**
+ * Detach submitted record data without evaluating accessor properties. Record
+ * candidates are JSON-shaped, but this boundary also has to reject hostile or
+ * malformed in-memory inputs without running caller-owned code while cloning.
+ */
+function cloneRecordValidationValue(value, seen = new WeakMap()) {
+    if (value === null || typeof value !== 'object')
+        return value;
+    if (value instanceof Date)
+        return new Date(value.getTime());
+    const existing = seen.get(value);
+    if (existing !== undefined)
+        return existing;
+    const clone = Array.isArray(value)
+        ? []
+        : Object.create(Object.getPrototypeOf(value) === null ? null : Object.prototype);
+    seen.set(value, clone);
+    for (const key of Reflect.ownKeys(value)) {
+        const descriptor = Object.getOwnPropertyDescriptor(value, key);
+        if (!descriptor?.enumerable || !('value' in descriptor))
+            continue;
+        Object.defineProperty(clone, key, {
+            configurable: true,
+            enumerable: true,
+            value: cloneRecordValidationValue(descriptor.value, seen),
+            writable: true,
+        });
+    }
+    return clone;
+}
+function cloneRecordValidationCandidate(candidate) {
+    return cloneRecordValidationValue(candidate);
+}
+function isFormValueTransformation(value) {
+    if (!isRecord(value) ||
+        value.kind !== 'rich-html-sanitized' ||
+        typeof value.sourceValue !== 'string' ||
+        typeof value.value !== 'string')
+        return false;
+    if (!Array.isArray(value.dataModelPath) || value.dataModelPath.length === 0 || value.dataModelPath.some(segment => typeof segment !== 'string' && !(typeof segment === 'number' && Number.isSafeInteger(segment) && segment >= 0)))
+        return false;
+    const advisory = value.advisorySummary;
+    return isRecord(advisory) && Array.isArray(advisory.errors) && advisory.errors.every(error => isRecord(error) && typeof error.message === 'string');
+}
+function stringProperty(value, property) {
+    if (!isRecord(value))
+        return undefined;
+    const item = value[property];
+    return typeof item === 'string' && item.trim() ? item.trim() : undefined;
+}
+function normalizeUniqueStrings(value) {
+    if (value === undefined)
+        return undefined;
+    if (!Array.isArray(value) || value.some(item => typeof item !== 'string'))
+        return undefined;
+    return [...new Set(value.map(item => item.trim()).filter(Boolean))];
+}
+function intersectRestrictions(existing, next) {
+    if (next === undefined)
+        return existing === undefined ? undefined : [...existing];
+    if (existing === undefined)
+        return [...next];
+    const allowed = new Set(next);
+    return existing.filter(item => allowed.has(item));
+}
+function normalizeRoles(roles) {
+    return [...new Set((roles ?? []).map(role => role.trim()).filter(Boolean))].sort();
+}
+function createDiagnostic(code, message, extras = {}) {
+    return { code, severity: 'error', message, ...extras };
+}
+function safeRequestId(value) {
+    return typeof value === 'string' && value.length <= 128 && sails_ng_common_1.RECORD_VALIDATION_REFERENCE_PATTERN.test(value)
+        ? value
+        : undefined;
+}
+function safeLogReference(value) {
+    const normalized = typeof value === 'string' ? value.trim() : '';
+    return sails_ng_common_1.RECORD_VALIDATION_REFERENCE_PATTERN.test(normalized) ? normalized : 'unavailable';
+}
+/** Remove repeatable indices before a JSON pointer becomes a metric label. */
+function lowCardinalityPointer(value) {
+    if (typeof value !== 'string' || !value.startsWith('/') || value.length > 2_048)
+        return undefined;
+    const normalized = value
+        .split('/')
+        .map((segment, index) => index > 0 && /^(?:0|[1-9][0-9]*)$/.test(segment) ? '*' : segment)
+        .join('/');
+    return normalized.length <= 2_048 ? normalized : undefined;
+}
+function applyPolicyLayer(policy, layer, diagnostics) {
+    if (!layer)
+        return policy;
+    const groups = layer.enabledValidationGroups === undefined
+        ? [...policy.enabledValidationGroups]
+        : normalizeUniqueStrings(layer.enabledValidationGroups);
+    const roles = normalizeUniqueStrings(layer.roles);
+    const targetSteps = normalizeUniqueStrings(layer.allowedTargetSteps);
+    if (groups === undefined ||
+        (layer.roles !== undefined && roles === undefined) ||
+        (layer.allowedTargetSteps !== undefined && targetSteps === undefined)) {
+        diagnostics.push(createDiagnostic(exports.RECORD_VALIDATION_DIAGNOSTIC_CODES.operationPolicyMalformed, 'A validation operation policy layer is malformed.', { operation: policy.name }));
+        return policy;
+    }
+    return {
+        name: policy.name,
+        enabledValidationGroups: groups,
+        label: layer.label ?? policy.label,
+        description: layer.description ?? policy.description,
+        roles: intersectRestrictions(policy.roles, roles),
+        allowedTargetSteps: intersectRestrictions(policy.allowedTargetSteps, targetSteps),
+    };
+}
+function parseGroupChange(value) {
+    if (!isRecord(value))
+        return undefined;
+    const initial = value.initial;
+    const validInitial = initial === undefined || initial === 'all' || initial === 'none' || initial === 'current' || initial === 'empty';
+    if (!validInitial)
+        return undefined;
+    const rawGroups = value.groups;
+    if (rawGroups === undefined)
+        return { initial: initial };
+    if (!isRecord(rawGroups))
+        return undefined;
+    const include = normalizeUniqueStrings(rawGroups.include);
+    const exclude = normalizeUniqueStrings(rawGroups.exclude);
+    if ((rawGroups.include !== undefined && include === undefined) ||
+        (rawGroups.exclude !== undefined && exclude === undefined))
+        return undefined;
+    return {
+        initial: initial,
+        groups: { ...(include === undefined ? {} : { include }), ...(exclude === undefined ? {} : { exclude }) },
+    };
+}
+/**
+ * Traverse only form-schema containment edges. Model values and all other
+ * arbitrary object properties are deliberately opaque candidate data.
+ */
+function schemaOwnedFormNodes(form) {
+    const nodes = [{ value: form, pointer: '' }];
+    const visited = new WeakSet();
+    const walkDefinition = (value, pointer) => {
+        if (!isRecord(value) || visited.has(value))
+            return;
+        visited.add(value);
+        const field = typeof value.name === 'string' && SAFE_FIELD_PATTERN.test(value.name) ? value.name : undefined;
+        nodes.push({ value, pointer, ...(field ? { field } : {}) });
+        const component = isRecord(value.component) ? value.component : undefined;
+        const config = component && isRecord(component.config) ? component.config : undefined;
+        if (!config)
+            return;
+        for (const key of ['componentDefinitions', 'tabs', 'panels']) {
+            const children = config[key];
+            if (!Array.isArray(children))
+                continue;
+            children.forEach((child, index) => walkDefinition(child, `${pointer}/component/config/${key}/${index}`));
+        }
+        if (isRecord(config.elementTemplate)) {
+            walkDefinition(config.elementTemplate, `${pointer}/component/config/elementTemplate`);
+        }
+    };
+    (form.componentDefinitions ?? []).forEach((definition, index) => walkDefinition(definition, `/componentDefinitions/${index}`));
+    return nodes;
+}
+function discoverValidationGroupExpressions(form) {
+    const expressions = [];
+    for (const node of schemaOwnedFormNodes(form)) {
+        if (!Array.isArray(node.value.expressions))
+            continue;
+        for (const expression of node.value.expressions) {
+            if (!isValidationGroupExpression(expression))
+                continue;
+            const expressionName = SAFE_FIELD_PATTERN.test(expression.name) ? expression.name : undefined;
+            expressions.push({ ...node, expression, ...(expressionName ? { expressionName } : {}) });
+        }
+    }
+    return expressions;
+}
+function isValidationGroupExpression(value) {
+    return (isRecord(value) &&
+        typeof value.name === 'string' &&
+        isRecord(value.config) &&
+        value.config.target === sails_ng_common_1.FormExpressionsTargetValidationGroups);
+}
+var Services;
+(function (Services) {
+    /**
+     * Resolves and executes authoritative record validation while exposing only
+     * bounded, value-free observability data.
+     *
+     * @extensionPoint Hooks may replace the service implementation; replacements must preserve authoritative form, operation, group, privacy, timeout, and shadow/enforce semantics.
+     * @see https://github.com/redbox-mint/redbox-portal/wiki/Server-Side-Form-Validation-Operations
+     */
+    class RecordValidation extends CoreService_1.Services.Core.Service {
+        dependencyOverrides;
+        _exportedMethods = ['resolve', 'resolveContractContext', 'discoverOperations'];
+        resolvedDependencies;
+        constructor(dependencyOverrides) {
+            super();
+            this.dependencyOverrides = dependencyOverrides;
+        }
+        /**
+         * Resolve the authoritative form and execute its blocking/advisory validators.
+         *
+         * @param request Complete server-owned candidate and save intent.
+         * @returns The authoritative decision plus safe diagnostics and resolved context.
+         */
+        async resolve(request) {
+            const startedAt = node_perf_hooks_1.performance.now();
+            const diagnostics = [];
+            const progress = { mode: 'shadow' };
+            let result;
+            try {
+                result = await this.resolveRequest(request, diagnostics, progress);
+            }
+            catch (error) {
+                this.logger.warn(`Record validation resolution could not be completed` +
+                    ` (recordType=${safeLogReference(request.candidate.metaMetadata.type)},` +
+                    ` form=${safeLogReference(request.candidate.metaMetadata.form)},` +
+                    ` errorType=${safeLogReference(error instanceof Error ? error.name : typeof error)}).`);
+                diagnostics.push(createDiagnostic(exports.RECORD_VALIDATION_DIAGNOSTIC_CODES.resolutionFailed, 'Record validation resolution could not be completed.'));
+                result = this.buildResult(progress.mode, diagnostics, {
+                    outcome: 'unresolved',
+                    operation: progress.operation,
+                    recordType: progress.recordType,
+                    formName: progress.formName,
+                });
+            }
+            try {
+                this.observeResolution(request, result, progress, node_perf_hooks_1.performance.now() - startedAt);
+            }
+            catch {
+                // Observability must never change the validation decision or save path.
+                try {
+                    this.logger.warn('Record validation observability failed.');
+                }
+                catch {
+                    // A failed logger is observational too; preserve the resolved result.
+                }
+            }
+            return result;
+        }
+        /**
+         * Resolve the authoritative validation context without executing validators.
+         *
+         * This is the shared selection boundary for form-facing and schema-facing
+         * consumers. Private record, actor, and source-form data remains separated
+         * from the allowlisted public schema context by the Phase5A1 result types.
+         *
+         * @param request Authoritative create or update context request.
+         * @returns The selected public context and private construction inputs.
+         */
+        async resolveContractContext(request) {
+            try {
+                return await this.resolveContractContextOrThrow(request);
+            }
+            catch (error) {
+                if (error instanceof record_contract_context_1.RecordContractContextResolutionError) {
+                    throw error;
+                }
+                throw this.contractContextError('unavailable');
+            }
+        }
+        async resolveContractContextOrThrow(request) {
+            const brand = this.contractReference(request.brand, 'brand');
+            const portal = this.contractReference(request.portal, 'portal');
+            if (typeof request.actor.authenticated !== 'boolean') {
+                throw this.contractContextError('invalid-request');
+            }
+            const actor = Object.freeze({
+                authenticated: request.actor.authenticated,
+                roles: Object.freeze(normalizeRoles(request.actor.roles)),
+            });
+            let candidate;
+            let resolvedOid;
+            let existingRecord;
+            if (request.kind === 'create') {
+                candidate = {
+                    metadata: {},
+                    metaMetadata: { brandId: brand, type: request.recordType },
+                };
+            }
+            else {
+                resolvedOid = this.contractReference(request.oid, 'oid');
+                const loadedRecord = await this.dependencies().loadRecord(resolvedOid);
+                if (!loadedRecord)
+                    throw this.contractContextError('not-found');
+                existingRecord = lodash_1.default.cloneDeep(loadedRecord);
+                candidate = this.recordContractCandidate(resolvedOid, existingRecord);
+            }
+            const validationRequest = {
+                candidate,
+                writeKind: request.kind,
+                validationOperation: request.operation,
+                evaluateFormValidators: false,
+                ...(request.kind === 'create' && request.targetStep !== undefined ? { targetStep: request.targetStep } : {}),
+                actor,
+            };
+            const diagnostics = [];
+            const progress = { mode: 'shadow' };
+            const authoritative = await this.resolveAuthoritativeContext(validationRequest, diagnostics, progress, false);
+            if (authoritative.status !== 'resolved') {
+                throw this.contractContextError(this.contractContextFailureKind(diagnostics), diagnostics);
+            }
+            if (authoritative.brand !== brand) {
+                throw this.contractContextError('not-resolvable');
+            }
+            const workflowStep = authoritative.selection.workflowStep;
+            if (!workflowStep)
+                throw this.contractContextError('not-resolvable');
+            const configuredUnknownProperties = sails.config.recordSchema?.unknownProperties;
+            if (!(0, recordSchema_config_1.isRecordSchemaUnknownProperties)(configuredUnknownProperties)) {
+                throw this.contractContextError('unavailable');
+            }
+            if (authoritative.recordType.recordSchema !== undefined &&
+                authoritative.recordType.recordSchema !== null &&
+                (0, recordSchema_config_1.validateRecordTypeRecordSchemaConfig)(authoritative.recordType.recordSchema, 'recordType.recordSchema').length >
+                    0) {
+                throw this.contractContextError('unavailable');
+            }
+            const unknownProperties = (0, recordSchema_config_1.resolveRecordSchemaUnknownProperties)(configuredUnknownProperties, authoritative.recordType.recordSchema);
+            const privateResolution = this.recordContractPrivateResolution(authoritative, actor);
+            const publicFields = {
+                brand,
+                portal,
+                recordType: authoritative.recordTypeName,
+                workflowStep,
+                form: authoritative.selection.formName,
+                operation: authoritative.operation ?? STRICT_ALL_OPERATION,
+                unknownProperties,
+                enforcement: authoritative.mode,
+            };
+            if (request.kind === 'create') {
+                const context = Object.freeze({
+                    publicContext: Object.freeze({ ...publicFields, kind: 'create' }),
+                    resolution: Object.freeze(privateResolution),
+                });
+                return context;
+            }
+            if (!existingRecord || !resolvedOid) {
+                throw new Error('The authoritative record-contract update record is unavailable.');
+            }
+            const context = Object.freeze({
+                publicContext: Object.freeze({ ...publicFields, kind: 'update' }),
+                resolution: Object.freeze({
+                    ...privateResolution,
+                    oid: resolvedOid,
+                    existingRecord,
+                }),
+            });
+            return context;
+        }
+        /**
+         * Resolve public operation metadata without executing expressions or
+         * validators. Any incomplete/malformed context fails to an empty list so
+         * discovery cannot become an authorization oracle or leak diagnostics.
+         *
+         * @param request Authorized server-owned discovery context.
+         * @returns Operations visible to the actor for the exact resolved form.
+         */
+        async discoverOperations(request) {
+            if (!request.canEdit || !request.actor.authenticated)
+                return [];
+            try {
+                return await this.discoverOperationsForContext(request);
+            }
+            catch (error) {
+                const type = error instanceof Error ? error.name : typeof error;
+                const recordType = safeLogReference(request.candidate.metaMetadata.type);
+                const form = safeLogReference(request.candidate.metaMetadata.form);
+                this.logger.warn(`Record validation operation discovery could not be completed` +
+                    ` (recordType=${recordType}, form=${form}, errorType=${type}).`);
+                return [];
+            }
+        }
+        async discoverOperationsForContext(request) {
+            const diagnostics = [];
+            const normalized = this.normalizeRequest({
+                candidate: request.candidate,
+                writeKind: request.writeKind,
+                targetStep: request.targetStep,
+                currentStep: request.currentStep,
+                actor: request.actor,
+            }, diagnostics, true);
+            if (!normalized)
+                return [];
+            if (request.writeKind === 'transition' && !normalized.targetStep)
+                return [];
+            const brand = this.requiredReference(request.candidate.metaMetadata.brandId, 'brand', diagnostics);
+            const recordTypeName = this.requiredReference(request.candidate.metaMetadata.type, 'recordType', diagnostics);
+            if (!brand || !recordTypeName)
+                return [];
+            const dependencies = this.dependencies();
+            const recordType = await dependencies.loadRecordType(brand, recordTypeName);
+            if (!recordType)
+                return [];
+            const authorizedTargets = new Set(normalizeUniqueStrings(request.authorizedTargetSteps)
+                ?.filter(step => sails_ng_common_1.RECORD_VALIDATION_REFERENCE_PATTERN.test(step)) ?? []);
+            if (normalized.targetStep && !authorizedTargets.has(normalized.targetStep))
+                return [];
+            // Load workflow configuration once, then resolve the base and all
+            // actor-authorized targets against the in-memory set. This bounds query
+            // work independently of the number of authorized transitions.
+            const workflowSteps = await dependencies.loadWorkflowSteps(recordType);
+            const workflowStepByName = new Map();
+            for (const step of workflowSteps) {
+                const name = typeof step.name === 'string' ? step.name.trim() : '';
+                if (sails_ng_common_1.RECORD_VALIDATION_REFERENCE_PATTERN.test(name))
+                    workflowStepByName.set(name, step);
+            }
+            const workflowStepLookups = new Map();
+            for (const [name, step] of workflowStepByName) {
+                workflowStepLookups.set(name, Promise.resolve(step));
+            }
+            const fallbackWorkflowSteps = new Set();
+            const candidateWorkflowStep = request.candidate.workflow?.stage;
+            if (typeof candidateWorkflowStep === 'string' &&
+                sails_ng_common_1.RECORD_VALIDATION_REFERENCE_PATTERN.test(candidateWorkflowStep.trim())) {
+                fallbackWorkflowSteps.add(candidateWorkflowStep.trim());
+            }
+            if (normalized.targetStep)
+                fallbackWorkflowSteps.add(normalized.targetStep);
+            const loadWorkflowStep = async (step) => {
+                const cached = workflowStepLookups.get(step);
+                if (cached)
+                    return await cached;
+                if (!fallbackWorkflowSteps.has(step)) {
+                    workflowStepLookups.set(step, Promise.resolve(null));
+                    return null;
+                }
+                const lookup = dependencies.loadWorkflowStep(recordType, step);
+                workflowStepLookups.set(step, lookup);
+                return await lookup;
+            };
+            const discoveryDependencies = {
+                ...dependencies,
+                loadWorkflowStep: async (_recordType, step) => await loadWorkflowStep(step),
+                loadStartingWorkflowStep: async () => workflowSteps.find(step => step.starting === true) ?? dependencies.loadStartingWorkflowStep(recordType),
+            };
+            const contexts = normalized.targetStep
+                ? [normalized]
+                : [
+                    normalized,
+                    ...[...authorizedTargets]
+                        .sort(sails_ng_common_1.compareRecordValidationIdentifiers)
+                        .map(targetStep => ({
+                        ...normalized,
+                        source: {
+                            ...normalized.source,
+                            writeKind: request.writeKind === 'create' ? 'create' : 'transition',
+                            targetStep,
+                        },
+                        targetStep,
+                    })),
+                ];
+            const resolvedContexts = [];
+            for (const context of contexts) {
+                const contextDiagnostics = [];
+                const selection = await this.resolveFormSelection(context, recordType, contextDiagnostics, discoveryDependencies);
+                // Discovery is an authorization-sensitive presentation surface. A
+                // partially resolved workflow may still be validated in shadow mode,
+                // but must not advertise operations from an unauthoritative stage.
+                if (selection && !contextDiagnostics.some(item => item.severity === 'error')) {
+                    resolvedContexts.push({ request: context, selection });
+                }
+            }
+            const constructedForms = new Map();
+            const getConstructedForm = async (formName) => {
+                if (constructedForms.has(formName))
+                    return constructedForms.get(formName) ?? null;
+                let constructed = null;
+                try {
+                    const form = await this.loadFormDefinition(formName, brand);
+                    if (form?.form.configuration) {
+                        constructed = await this.constructForm(form, request.candidate.metadata);
+                    }
+                }
+                catch (error) {
+                    const errorType = safeLogReference(error instanceof Error ? error.name : typeof error);
+                    this.logger.warn(`Validation operation discovery form construction was safely omitted` +
+                        ` (recordType=${safeLogReference(recordTypeName)},` +
+                        ` form=${safeLogReference(formName)}, errorType=${errorType}).`);
+                    constructed = null;
+                }
+                constructedForms.set(formName, constructed);
+                return constructed;
+            };
+            const merged = new Map();
+            for (const context of resolvedContexts) {
+                const constructedForm = await getConstructedForm(context.selection.formName);
+                const formOperations = constructedForm?.validationOperations;
+                if (!formOperations || typeof formOperations !== 'object' || Array.isArray(formOperations))
+                    continue;
+                for (const name of Object.keys(formOperations).sort(sails_ng_common_1.compareRecordValidationIdentifiers)) {
+                    if (!sails_ng_common_1.VALIDATION_OPERATION_NAME_PATTERN.test(name))
+                        continue;
+                    const operationDiagnostics = [];
+                    const policy = this.resolveOperationPolicy(name, formOperations, recordType.recordValidation?.operations, this.workflowOperationOverrides(context.selection.workflowConfig), operationDiagnostics);
+                    if (!policy || operationDiagnostics.some(item => item.severity === 'error'))
+                        continue;
+                    const operationRequest = { ...context.request, operation: name };
+                    if (!this.authorizeOperation(policy, operationRequest, operationDiagnostics))
+                        continue;
+                    // A target is advertised only from that target's authoritative form
+                    // context. The base update/create context keeps the operation
+                    // discoverable without implying that every actor-authorized target
+                    // defines it.
+                    const contextTargets = new Set(context.request.targetStep ? [context.request.targetStep] : []);
+                    const policyTargets = policy.allowedTargetSteps === undefined
+                        ? [...contextTargets]
+                        : policy.allowedTargetSteps.filter(step => contextTargets.has(step));
+                    const safeOperation = (0, sails_ng_common_1.sanitizeValidationOperationDiscovery)({
+                        name,
+                        label: policy.label,
+                        description: policy.description,
+                        allowedTargetSteps: policyTargets,
+                    }, authorizedTargets);
+                    if (!safeOperation)
+                        continue;
+                    const existing = merged.get(name);
+                    // Prefer the current/base form's presentation metadata. If an
+                    // operation exists only on target forms, the lexically first target
+                    // wins. Target lists are still unioned across every defining form.
+                    const metadataPrecedence = context.request.targetStep
+                        ? `1:${context.request.targetStep}:${context.selection.formName}`
+                        : `0:${context.selection.formName}`;
+                    const presentation = !existing || metadataPrecedence < existing.metadataPrecedence
+                        ? safeOperation
+                        : existing.operation;
+                    const mergedTargets = [...new Set([
+                            ...(existing?.operation.allowedTargetSteps ?? []),
+                            ...(safeOperation.allowedTargetSteps ?? []),
+                        ])].sort(sails_ng_common_1.compareRecordValidationIdentifiers);
+                    merged.set(name, {
+                        operation: {
+                            ...presentation,
+                            ...(mergedTargets.length > 0 ? { allowedTargetSteps: mergedTargets } : {}),
+                        },
+                        metadataPrecedence: existing && existing.metadataPrecedence < metadataPrecedence
+                            ? existing.metadataPrecedence
+                            : metadataPrecedence,
+                    });
+                }
+            }
+            return [...merged.values()].map(({ operation }) => operation).sort((left, right) => (0, sails_ng_common_1.compareRecordValidationIdentifiers)(left.name, right.name));
+        }
+        async resolveAuthoritativeContext(request, diagnostics, progress, validateCandidateFormReference) {
+            const globalConfig = sails.config.recordValidation;
+            const normalized = this.normalizeRequest(request, diagnostics);
+            const initialModeResolution = resolveValidationMode(globalConfig, undefined, normalized?.operation);
+            this.addMalformedModeDiagnostics(initialModeResolution.malformedModeCount, diagnostics);
+            let mode = initialModeResolution.mode;
+            progress.mode = mode;
+            if (!normalized)
+                return { status: 'unresolved', mode, contractFailure: true };
+            const operation = normalized.operation;
+            progress.operation = operation;
+            const brand = this.requiredReference(request.candidate.metaMetadata.brandId, 'brand', diagnostics);
+            const recordTypeName = this.requiredReference(request.candidate.metaMetadata.type, 'recordType', diagnostics);
+            progress.recordType = recordTypeName;
+            if (!brand || !recordTypeName)
+                return { status: 'unresolved', mode };
+            // Resolve configured rollout before the model lookup so an enforce-only
+            // record type cannot fail open when its runtime model is unavailable.
+            const configuredRecordType = sails.config.recordtype?.[recordTypeName];
+            const configuredModeResolution = resolveValidationMode(globalConfig, configuredRecordType?.recordValidation, operation);
+            this.addMalformedModeDiagnostics(Math.max(0, configuredModeResolution.malformedModeCount - initialModeResolution.malformedModeCount), diagnostics);
+            mode = configuredModeResolution.mode;
+            progress.mode = mode;
+            const dependencies = this.dependencies();
+            const recordType = await dependencies.loadRecordType(brand, recordTypeName);
+            if (!recordType) {
+                diagnostics.push(createDiagnostic(exports.RECORD_VALIDATION_DIAGNOSTIC_CODES.recordTypeNotFound, 'The candidate record type could not be resolved.'));
+                return { status: 'unresolved', mode };
+            }
+            const effectiveModeResolution = resolveValidationMode(globalConfig, recordType.recordValidation, operation);
+            this.addMalformedModeDiagnostics(Math.max(0, effectiveModeResolution.malformedModeCount - configuredModeResolution.malformedModeCount), diagnostics);
+            mode = effectiveModeResolution.mode;
+            progress.mode = mode;
+            const selection = await this.resolveFormSelection(normalized, recordType, diagnostics, dependencies);
+            if (!selection)
+                return { status: 'unresolved', mode };
+            progress.formName = selection.formName;
+            if (validateCandidateFormReference && (request.writeKind === 'create' || request.writeKind === 'transition')) {
+                const candidateForm = request.candidate.metaMetadata.form;
+                const normalizedCandidateForm = typeof candidateForm === 'string' ? candidateForm.trim() : '';
+                if (!sails_ng_common_1.RECORD_VALIDATION_REFERENCE_PATTERN.test(normalizedCandidateForm) ||
+                    normalizedCandidateForm !== selection.formName) {
+                    diagnostics.push(createDiagnostic(exports.RECORD_VALIDATION_DIAGNOSTIC_CODES.formReferenceDivergence, 'The final candidate form diverges from the authoritative workflow form.', { formName: selection.formName }));
+                }
+            }
+            const form = await this.loadFormDefinition(selection.formName, brand);
+            if (!form) {
+                diagnostics.push(createDiagnostic(exports.RECORD_VALIDATION_DIAGNOSTIC_CODES.formNotFound, 'The exact configured form could not be resolved.', { formName: selection.formName }));
+                return { status: 'unresolved', mode };
+            }
+            if (!form.form.configuration) {
+                diagnostics.push(createDiagnostic(exports.RECORD_VALIDATION_DIAGNOSTIC_CODES.formConfigurationMissing, 'The exact configured form has no configuration.', { formName: selection.formName }));
+                return { status: 'unresolved', mode };
+            }
+            let constructedForm;
+            try {
+                constructedForm = await this.constructForm(form, request.candidate.metadata);
+            }
+            catch {
+                diagnostics.push(createDiagnostic(exports.RECORD_VALIDATION_DIAGNOSTIC_CODES.formConfigurationMalformed, 'The exact configured form could not be constructed.', { formName: selection.formName }));
+                return { status: 'unresolved', mode };
+            }
+            const operationPolicy = this.resolveOperationPolicy(operation, constructedForm.validationOperations, recordType.recordValidation?.operations, this.workflowOperationOverrides(selection.workflowConfig), diagnostics);
+            if (operation && !operationPolicy)
+                return { status: 'unresolved', mode, contractFailure: true };
+            if (operationPolicy && !this.authorizeOperation(operationPolicy, normalized, diagnostics)) {
+                return { status: 'unresolved', mode, contractFailure: true };
+            }
+            return {
+                status: 'resolved',
+                mode,
+                operation,
+                normalized,
+                brand,
+                recordTypeName,
+                recordType,
+                selection,
+                form,
+                constructedForm,
+                operationPolicy,
+            };
+        }
+        async resolveRequest(request, diagnostics, progress) {
+            const authoritative = await this.resolveAuthoritativeContext(request, diagnostics, progress, true);
+            if (authoritative.status !== 'resolved') {
+                return this.buildResult(authoritative.mode, diagnostics, {
+                    outcome: 'unresolved',
+                    operation: progress.operation,
+                    recordType: progress.recordType,
+                    formName: progress.formName,
+                    contractFailure: authoritative.contractFailure,
+                });
+            }
+            const { mode, operation, normalized, brand, recordTypeName, selection, form, constructedForm, operationPolicy: policy, } = authoritative;
+            const globalConfig = sails.config.recordValidation;
+            if (request.evaluateFormValidators === false) {
+                const resolved = {
+                    constructedForm,
+                    formName: selection.formName,
+                    recordType: recordTypeName,
+                    brand,
+                    workflowStep: selection.workflowStep,
+                    operationPolicy: policy,
+                    conditionalGroups: [],
+                };
+                return this.buildResult(mode, diagnostics, {
+                    outcome: 'resolved',
+                    operation,
+                    recordType: recordTypeName,
+                    effectiveGroups: [],
+                    resolved,
+                    blockingErrors: [],
+                    advisoryErrors: [],
+                    advisoryGroups: [],
+                    transformedCandidate: cloneRecordValidationCandidate(request.candidate),
+                });
+            }
+            const timeoutMs = this.timeoutMs(globalConfig?.timeoutMs);
+            const deadline = this.createDeadline(timeoutMs);
+            let persistenceCandidate;
+            // Until the schema-owned transformation pass completes, shadow mode must
+            // not treat the raw submitted candidate as safe for persistence.
+            let transformationContractFailed = true;
+            const blockingRun = await this.withDeadline(async () => {
+                const transformations = await this.collectCandidateTransformations(lodash_1.default.cloneDeep(constructedForm), deadline);
+                const transformationApplication = this.applyCandidateTransformations(request.candidate, transformations, diagnostics);
+                let transformedCandidate = transformationApplication.candidate;
+                const appliedTransformations = [...transformationApplication.applied];
+                persistenceCandidate = transformedCandidate;
+                if (transformationApplication.inapplicable) {
+                    return undefined;
+                }
+                transformationContractFailed = false;
+                this.checkDeadline(deadline);
+                const normalizedForContext = {
+                    ...normalized,
+                    source: { ...normalized.source, candidate: transformedCandidate },
+                };
+                const context = this.buildExpressionContext(normalizedForContext, recordTypeName, selection.formName, brand, globalConfig?.allowedRequestParameters, diagnostics);
+                if (!context)
+                    return undefined;
+                const validationForm = transformationApplication.applied.length > 0
+                    ? await this.constructForm(form, transformedCandidate.metadata)
+                    : constructedForm;
+                const groupResolution = await this.resolveValidationGroups(validationForm, policy, context, diagnostics, deadline);
+                if (!groupResolution)
+                    return undefined;
+                const advisoryGroups = this.discoverAdvisoryGroups(validationForm, groupResolution.effectiveGroups, diagnostics);
+                const validatorDefinitionsMap = this.validatorDefinitions(validationForm, diagnostics);
+                if (!validatorDefinitionsMap)
+                    return undefined;
+                const validation = await this.executeValidators(validationForm, groupResolution.effectiveGroups, validatorDefinitionsMap, advisoryGroups, deadline);
+                const validatorTransformationApplication = this.applyCandidateTransformations(transformedCandidate, validation.transformations, diagnostics);
+                transformedCandidate = validatorTransformationApplication.candidate;
+                persistenceCandidate = transformedCandidate;
+                appliedTransformations.push(...validatorTransformationApplication.applied);
+                if (validatorTransformationApplication.inapplicable) {
+                    transformationContractFailed = true;
+                    return undefined;
+                }
+                this.checkDeadline(deadline);
+                const mappedIssues = this.mapValidatorSummaries(validation.summaries);
+                const transformationAdvisories = this.mapTransformationAdvisories(appliedTransformations);
+                this.checkDeadline(deadline);
+                return {
+                    context,
+                    validationForm,
+                    groupResolution,
+                    advisoryGroups,
+                    validatorDefinitionsMap,
+                    mappedIssues,
+                    transformationAdvisories,
+                    transformedCandidate,
+                };
+            }, deadline);
+            if (blockingRun.status === 'timed-out') {
+                diagnostics.push(createDiagnostic(exports.RECORD_VALIDATION_DIAGNOSTIC_CODES.blockingTimeout, 'Blocking record validation timed out.'));
+                return this.buildResult(mode, diagnostics, {
+                    outcome: 'unresolved',
+                    operation,
+                    recordType: recordTypeName,
+                    formName: selection.formName,
+                    contractFailure: transformationContractFailed,
+                    ...(persistenceCandidate ? { transformedCandidate: persistenceCandidate } : {}),
+                });
+            }
+            if (blockingRun.status === 'failed') {
+                diagnostics.push(createDiagnostic(exports.RECORD_VALIDATION_DIAGNOSTIC_CODES.blockingExecutionFailed, 'Blocking record validation could not be completed.'));
+                return this.buildResult(mode, diagnostics, {
+                    outcome: 'unresolved',
+                    operation,
+                    recordType: recordTypeName,
+                    formName: selection.formName,
+                    contractFailure: transformationContractFailed,
+                    ...(persistenceCandidate ? { transformedCandidate: persistenceCandidate } : {}),
+                });
+            }
+            if (!blockingRun.value) {
+                return this.buildResult(mode, diagnostics, {
+                    outcome: 'unresolved',
+                    operation,
+                    recordType: recordTypeName,
+                    formName: selection.formName,
+                    contractFailure: transformationContractFailed,
+                    ...(persistenceCandidate ? { transformedCandidate: persistenceCandidate } : {}),
+                });
+            }
+            const { context, validationForm, groupResolution, advisoryGroups, validatorDefinitionsMap, mappedIssues, transformationAdvisories, transformedCandidate: blockingTransformedCandidate, } = blockingRun.value;
+            const blockingErrors = mappedIssues.blocking;
+            let advisoryErrors = [...transformationAdvisories];
+            let transformedCandidate = blockingTransformedCandidate;
+            if (advisoryGroups.length > 0) {
+                const advisoryRun = await this.withDeadline(async () => {
+                    const validation = await this.executeValidators(validationForm, advisoryGroups, validatorDefinitionsMap, [], deadline);
+                    const advisoryTransformationApplication = this.applyCandidateTransformations(transformedCandidate, validation.transformations, diagnostics);
+                    transformedCandidate = advisoryTransformationApplication.candidate;
+                    persistenceCandidate = transformedCandidate;
+                    if (advisoryTransformationApplication.inapplicable) {
+                        transformationContractFailed = true;
+                        return undefined;
+                    }
+                    advisoryErrors = [
+                        ...advisoryErrors,
+                        ...this.mapTransformationAdvisories(advisoryTransformationApplication.applied),
+                    ];
+                    this.checkDeadline(deadline);
+                    const issues = this.mapValidatorSummaries(validation.summaries);
+                    this.checkDeadline(deadline);
+                    return {
+                        issues: issues.blocking,
+                    };
+                }, deadline);
+                if (advisoryRun.status === 'timed-out') {
+                    diagnostics.push(createDiagnostic(exports.RECORD_VALIDATION_DIAGNOSTIC_CODES.advisoryTimeout, 'Advisory record validation timed out.', { severity: 'warning' }));
+                }
+                else if (advisoryRun.status === 'failed') {
+                    diagnostics.push(createDiagnostic(exports.RECORD_VALIDATION_DIAGNOSTIC_CODES.advisoryExecutionFailed, 'Advisory record validation could not be completed.', { severity: 'warning' }));
+                }
+                else if (!advisoryRun.value) {
+                    return this.buildResult(mode, diagnostics, {
+                        outcome: 'unresolved',
+                        operation,
+                        recordType: recordTypeName,
+                        formName: selection.formName,
+                        contractFailure: transformationContractFailed,
+                        ...(persistenceCandidate ? { transformedCandidate: persistenceCandidate } : {}),
+                    });
+                }
+                else {
+                    advisoryErrors = [...advisoryErrors, ...advisoryRun.value.issues];
+                }
+            }
+            const resolved = {
+                constructedForm: validationForm,
+                formName: selection.formName,
+                recordType: recordTypeName,
+                brand,
+                workflowStep: selection.workflowStep,
+                operationPolicy: policy,
+                conditionalGroups: groupResolution.conditionalGroups,
+                expressionContext: context,
+            };
+            return this.buildResult(mode, diagnostics, {
+                outcome: 'resolved',
+                operation,
+                recordType: recordTypeName,
+                effectiveGroups: groupResolution.effectiveGroups,
+                resolved,
+                blockingErrors,
+                advisoryErrors,
+                advisoryGroups,
+                transformedCandidate,
+            });
+        }
+        contractReference(value, _kind) {
+            const normalized = typeof value === 'string' ? value.trim() : '';
+            if (!sails_ng_common_1.RECORD_VALIDATION_REFERENCE_PATTERN.test(normalized)) {
+                throw this.contractContextError('invalid-request');
+            }
+            return normalized;
+        }
+        contractContextFailureKind(diagnostics) {
+            const codes = new Set(diagnostics.map(diagnostic => diagnostic.code));
+            if (codes.has(exports.RECORD_VALIDATION_DIAGNOSTIC_CODES.operationRoleUnauthorized) ||
+                codes.has(exports.RECORD_VALIDATION_DIAGNOSTIC_CODES.operationTargetUnauthorized)) {
+                return 'forbidden';
+            }
+            if (codes.has(exports.RECORD_VALIDATION_DIAGNOSTIC_CODES.recordTypeNotFound)) {
+                return 'not-found';
+            }
+            if (codes.has(exports.RECORD_VALIDATION_DIAGNOSTIC_CODES.brandReferenceMissing) ||
+                codes.has(exports.RECORD_VALIDATION_DIAGNOSTIC_CODES.brandReferenceMalformed) ||
+                codes.has(exports.RECORD_VALIDATION_DIAGNOSTIC_CODES.recordTypeReferenceMissing) ||
+                codes.has(exports.RECORD_VALIDATION_DIAGNOSTIC_CODES.recordTypeReferenceMalformed) ||
+                codes.has(exports.RECORD_VALIDATION_DIAGNOSTIC_CODES.operationMalformed) ||
+                codes.has(exports.RECORD_VALIDATION_DIAGNOSTIC_CODES.workflowStepReferenceMalformed)) {
+                return 'invalid-request';
+            }
+            return 'not-resolvable';
+        }
+        contractContextError(failureKind, diagnostics = []) {
+            return new record_contract_context_1.RecordContractContextResolutionError(failureKind, diagnostics.map(diagnostic => diagnostic.code));
+        }
+        recordContractCandidate(oid, existingRecord) {
+            const storedOid = stringProperty(existingRecord, 'redboxOid');
+            if (storedOid && storedOid !== oid) {
+                throw new Error('The loaded record OID does not match the record-contract request.');
+            }
+            const metadata = existingRecord.metadata;
+            const rawMetaMetadata = existingRecord.metaMetadata;
+            if (!isRecord(metadata) || !isRecord(rawMetaMetadata)) {
+                throw new Error('The record-contract update record is malformed.');
+            }
+            const metaMetadata = {};
+            for (const field of ['brandId', 'type', 'form']) {
+                const value = stringProperty(rawMetaMetadata, field);
+                if (value)
+                    metaMetadata[field] = value;
+            }
+            const rawWorkflow = existingRecord.workflow;
+            const workflow = {};
+            if (isRecord(rawWorkflow)) {
+                const stage = stringProperty(rawWorkflow, 'stage');
+                const stageLabel = stringProperty(rawWorkflow, 'stageLabel');
+                if (stage)
+                    workflow.stage = stage;
+                if (stageLabel)
+                    workflow.stageLabel = stageLabel;
+            }
+            return {
+                redboxOid: storedOid ?? oid,
+                metadata: lodash_1.default.cloneDeep(metadata),
+                metaMetadata,
+                ...(Object.keys(workflow).length > 0 ? { workflow } : {}),
+            };
+        }
+        recordContractPrivateResolution(authoritative, actor) {
+            const configuration = authoritative.form.form.configuration;
+            if (!configuration)
+                throw this.contractContextError('not-resolvable');
+            const sourceFormSnapshot = lodash_1.default.cloneDeep(configuration);
+            const sourceForm = Object.freeze({
+                ...sourceFormSnapshot,
+                componentDefinitions: Object.freeze([...(sourceFormSnapshot.componentDefinitions ?? [])]),
+            });
+            const reusableFormDefinitions = Object.freeze(lodash_1.default.cloneDeep(authoritative.form.reusableFormDefinitions));
+            const reusableFingerprint = (0, RecordFormFingerprint_1.formatRecordFormFingerprint)(reusableFormDefinitions);
+            if (!reusableFingerprint)
+                throw new Error('The reusable record-contract form definitions are too large.');
+            const fingerprint = (0, RecordFormFingerprint_1.formatRecordFormFingerprint)({
+                id: authoritative.form.form.id,
+                name: authoritative.form.form.name,
+                branding: authoritative.form.form.branding,
+                reusableDefinitions: reusableFingerprint.slice('sha256:'.length),
+                configuration: authoritative.form.form.configuration,
+            });
+            if (!fingerprint)
+                throw new Error('The authoritative record-contract source form is too large.');
+            return {
+                sourceFormFingerprint: fingerprint.slice('sha256:'.length),
+                sourceForm,
+                reusableFormDefinitions,
+                actor,
+                formMode: 'edit',
+                contextVariables: Object.freeze({}),
+            };
+        }
+        dependencies() {
+            if (this.resolvedDependencies)
+                return this.resolvedDependencies;
+            const defaults = {
+                loadRecord: oid => RecordsService.getMeta(oid),
+                loadRecordType: async (brand, recordType) => (await (0, rxjs_1.firstValueFrom)(RecordTypesService.get({ id: brand }, recordType))),
+                loadStartingWorkflowStep: async (recordType) => (await (0, rxjs_1.firstValueFrom)(WorkflowStepsService.getFirst(recordType))),
+                loadWorkflowStep: async (recordType, step) => (await (0, rxjs_1.firstValueFrom)(WorkflowStepsService.get(recordType, step))),
+                loadWorkflowSteps: async (recordType) => (await (0, rxjs_1.firstValueFrom)(WorkflowStepsService.getAllForRecordType(recordType))),
+                loadForm: async (formName, brand) => await (0, rxjs_1.firstValueFrom)(FormsService.getFormByName(formName, true, brand)),
+                constructForm: async (form, metadata, reusableFormDefinitions) => await new construct_visitor_1.ConstructFormConfigVisitor(this.logger).start({
+                    data: form,
+                    formMode: 'edit',
+                    record: metadata,
+                    reusableFormDefs: reusableFormDefinitions,
+                }),
+                collectTransformations: async (form, checkDeadline) => (await new validator_visitor_1.ValidatorFormConfigVisitor(this.logger).startWithResult({
+                    form,
+                    transformationOnly: true,
+                    checkDeadline,
+                })).transformations,
+                executeValidators: async (form, enabledValidationGroups, validatorDefinitionsMap, evaluatorFactory, excludedOnlyValidationGroups, checkDeadline) => await new validator_visitor_1.ValidatorFormConfigVisitor(this.logger).startWithResult({
+                    form,
+                    enabledValidationGroups: [...enabledValidationGroups],
+                    validatorDefinitionsMap,
+                    jsonataEvaluatorFactory: evaluatorFactory,
+                    excludedOnlyValidationGroups: [...(excludedOnlyValidationGroups ?? [])],
+                    checkDeadline,
+                }),
+            };
+            this.resolvedDependencies = { ...defaults, ...this.dependencyOverrides };
+            // A custom validator executor owns its preprocessing contract as well.
+            // Legacy/test executors that do not expose a collector are explicitly
+            // transformation-free instead of being traversed as framework forms.
+            if (this.dependencyOverrides?.executeValidators && !this.dependencyOverrides.collectTransformations) {
+                this.resolvedDependencies.collectTransformations = async () => [];
+            }
+            return this.resolvedDependencies;
+        }
+        normalizeRequest(request, diagnostics, requireResolvedWorkflowStep = false) {
+            const operation = this.normalizeOperation(request.validationOperation, diagnostics);
+            const targetStep = this.optionalStepReference(request.targetStep, diagnostics);
+            if (!operation.ok || !targetStep.ok)
+                return undefined;
+            const mustResolveWorkflowStep = requireResolvedWorkflowStep || operation.value !== undefined;
+            const currentStep = this.optionalStepReference(request.currentStep, diagnostics, mustResolveWorkflowStep ? 'error' : 'warning');
+            return {
+                source: request,
+                operation: operation.value,
+                targetStep: targetStep.value,
+                // currentStep can come from an already-stored legacy record. Keep the
+                // diagnostic mode-aware instead of turning it into an unconditional
+                // public-request contract rejection; shadow mode must remain neutral so
+                // an operator can repair the record.
+                currentStep: currentStep.ok ? currentStep.value : undefined,
+                actorRoles: normalizeRoles(request.actor.roles),
+                requireResolvedWorkflowStep: mustResolveWorkflowStep,
+            };
+        }
+        normalizeOperation(value, diagnostics) {
+            if (value === undefined || value === null)
+                return { ok: true };
+            if (typeof value !== 'string') {
+                diagnostics.push(createDiagnostic(exports.RECORD_VALIDATION_DIAGNOSTIC_CODES.operationMalformed, 'The validation operation has an invalid format.'));
+                return { ok: false };
+            }
+            const operation = value.trim();
+            if (!sails_ng_common_1.VALIDATION_OPERATION_NAME_PATTERN.test(operation)) {
+                diagnostics.push(createDiagnostic(exports.RECORD_VALIDATION_DIAGNOSTIC_CODES.operationMalformed, 'The validation operation has an invalid format.'));
+                return { ok: false };
+            }
+            return { ok: true, value: operation };
+        }
+        requiredReference(value, kind, diagnostics) {
+            const missingCode = kind === 'brand'
+                ? exports.RECORD_VALIDATION_DIAGNOSTIC_CODES.brandReferenceMissing
+                : exports.RECORD_VALIDATION_DIAGNOSTIC_CODES.recordTypeReferenceMissing;
+            const malformedCode = kind === 'brand'
+                ? exports.RECORD_VALIDATION_DIAGNOSTIC_CODES.brandReferenceMalformed
+                : exports.RECORD_VALIDATION_DIAGNOSTIC_CODES.recordTypeReferenceMalformed;
+            if (typeof value !== 'string' || !value.trim()) {
+                diagnostics.push(createDiagnostic(missingCode, `The candidate ${kind} reference is missing.`));
+                return undefined;
+            }
+            const normalized = value.trim();
+            if (!sails_ng_common_1.RECORD_VALIDATION_REFERENCE_PATTERN.test(normalized)) {
+                diagnostics.push(createDiagnostic(malformedCode, `The candidate ${kind} reference is malformed.`));
+                return undefined;
+            }
+            return normalized;
+        }
+        optionalStepReference(value, diagnostics, severity = 'error') {
+            if (value === undefined || value === null)
+                return { ok: true };
+            if (typeof value !== 'string' || !sails_ng_common_1.RECORD_VALIDATION_REFERENCE_PATTERN.test(value.trim())) {
+                diagnostics.push(createDiagnostic(exports.RECORD_VALIDATION_DIAGNOSTIC_CODES.workflowStepReferenceMalformed, 'The workflow step reference is malformed.', { severity }));
+                return { ok: false };
+            }
+            return { ok: true, value: value.trim() };
+        }
+        async resolveFormSelection(request, recordType, diagnostics, dependencies) {
+            const { targetStep } = request;
+            if (request.source.writeKind === 'transition' && !targetStep) {
+                diagnostics.push(createDiagnostic(exports.RECORD_VALIDATION_DIAGNOSTIC_CODES.workflowStepReferenceMalformed, 'A transition requires a target workflow step.'));
+                return undefined;
+            }
+            if ((request.source.writeKind === 'transition' || request.source.writeKind === 'create') && targetStep) {
+                const step = await dependencies.loadWorkflowStep(recordType, targetStep);
+                if (!step) {
+                    diagnostics.push(createDiagnostic(exports.RECORD_VALIDATION_DIAGNOSTIC_CODES.workflowStepNotFound, 'The exact requested workflow step could not be resolved.'));
+                    return undefined;
+                }
+                return this.selectionFromWorkflowStep(step, diagnostics);
+            }
+            if (request.source.writeKind === 'create') {
+                const step = await dependencies.loadStartingWorkflowStep(recordType);
+                if (!step) {
+                    diagnostics.push(createDiagnostic(exports.RECORD_VALIDATION_DIAGNOSTIC_CODES.workflowStepNotFound, 'The starting workflow step could not be resolved.'));
+                    return undefined;
+                }
+                return this.selectionFromWorkflowStep(step, diagnostics);
+            }
+            const formName = request.source.candidate.metaMetadata.form;
+            if (typeof formName !== 'string' || !formName.trim()) {
+                diagnostics.push(createDiagnostic(exports.RECORD_VALIDATION_DIAGNOSTIC_CODES.formReferenceMissing, 'The candidate form reference is missing.'));
+                return undefined;
+            }
+            const normalized = formName.trim();
+            if (!sails_ng_common_1.RECORD_VALIDATION_REFERENCE_PATTERN.test(normalized)) {
+                diagnostics.push(createDiagnostic(exports.RECORD_VALIDATION_DIAGNOSTIC_CODES.formReferenceMalformed, 'The candidate form reference is malformed.'));
+                return undefined;
+            }
+            const rawWorkflowStep = request.source.candidate.workflow?.stage;
+            if ((rawWorkflowStep === undefined || rawWorkflowStep === null || rawWorkflowStep === '') &&
+                request.requireResolvedWorkflowStep) {
+                diagnostics.push(createDiagnostic(exports.RECORD_VALIDATION_DIAGNOSTIC_CODES.workflowStepReferenceMissing, 'A named validation operation requires a resolved current workflow step.'));
+            }
+            const parsedWorkflowStep = this.optionalStepReference(rawWorkflowStep, diagnostics, request.requireResolvedWorkflowStep ? 'error' : 'warning');
+            // A malformed stored stage is configuration state, not a malformed
+            // operation request. Continue with the exact form and non-stage policy
+            // so form and record-type operation restrictions remain authoritative.
+            const workflowStep = parsedWorkflowStep.ok ? parsedWorkflowStep.value : undefined;
+            let workflowConfig;
+            if (workflowStep) {
+                const step = await dependencies.loadWorkflowStep(recordType, workflowStep);
+                if (!step) {
+                    diagnostics.push(createDiagnostic(exports.RECORD_VALIDATION_DIAGNOSTIC_CODES.workflowStepNotFound, 'The candidate workflow step could not be resolved.', { severity: request.requireResolvedWorkflowStep ? 'error' : 'warning' }));
+                }
+                else {
+                    workflowConfig = step.config;
+                }
+            }
+            return { formName: normalized, workflowStep, workflowConfig };
+        }
+        selectionFromWorkflowStep(step, diagnostics) {
+            const formName = stringProperty(step.config, 'form');
+            if (!formName) {
+                diagnostics.push(createDiagnostic(exports.RECORD_VALIDATION_DIAGNOSTIC_CODES.workflowStepFormMissing, 'The resolved workflow step has no form reference.'));
+                return undefined;
+            }
+            if (!sails_ng_common_1.RECORD_VALIDATION_REFERENCE_PATTERN.test(formName)) {
+                diagnostics.push(createDiagnostic(exports.RECORD_VALIDATION_DIAGNOSTIC_CODES.formReferenceMalformed, 'The resolved workflow step form reference is malformed.'));
+                return undefined;
+            }
+            return { formName, workflowStep: step.name, workflowConfig: step.config };
+        }
+        workflowOperationOverrides(config) {
+            return config?.recordValidation?.operations;
+        }
+        resolveOperationPolicy(operation, formOperations, recordTypeOperations, workflowOperations, diagnostics) {
+            if (!operation)
+                return undefined;
+            const formPolicy = formOperations && Object.hasOwn(formOperations, operation) ? formOperations[operation] : undefined;
+            if (!formPolicy) {
+                diagnostics.push(createDiagnostic(exports.RECORD_VALIDATION_DIAGNOSTIC_CODES.operationUnknown, 'The validation operation is not defined by the exact resolved form.', { operation }));
+                return undefined;
+            }
+            const groups = normalizeUniqueStrings(formPolicy.enabledValidationGroups);
+            const roles = normalizeUniqueStrings(formPolicy.roles);
+            const targetSteps = normalizeUniqueStrings(formPolicy.allowedTargetSteps);
+            if (groups === undefined ||
+                (formPolicy.roles !== undefined && roles === undefined) ||
+                (formPolicy.allowedTargetSteps !== undefined && targetSteps === undefined)) {
+                diagnostics.push(createDiagnostic(exports.RECORD_VALIDATION_DIAGNOSTIC_CODES.operationPolicyMalformed, 'The form validation operation policy is malformed.', { operation }));
+                return undefined;
+            }
+            let policy = {
+                name: operation,
+                enabledValidationGroups: groups,
+                label: formPolicy.label,
+                description: formPolicy.description,
+                roles,
+                allowedTargetSteps: targetSteps,
+            };
+            policy = applyPolicyLayer(policy, recordTypeOperations && Object.hasOwn(recordTypeOperations, operation)
+                ? recordTypeOperations[operation]
+                : undefined, diagnostics);
+            policy = applyPolicyLayer(policy, workflowOperations && Object.hasOwn(workflowOperations, operation) ? workflowOperations[operation] : undefined, diagnostics);
+            return policy;
+        }
+        authorizeOperation(policy, request, diagnostics) {
+            const actorRoles = new Set(request.actorRoles);
+            if (policy.roles !== undefined && !policy.roles.some(role => actorRoles.has(role))) {
+                diagnostics.push(createDiagnostic(exports.RECORD_VALIDATION_DIAGNOSTIC_CODES.operationRoleUnauthorized, 'The actor is not authorized for this validation operation.', { operation: policy.name }));
+                return false;
+            }
+            if (request.targetStep !== undefined &&
+                policy.allowedTargetSteps !== undefined &&
+                !policy.allowedTargetSteps.includes(request.targetStep)) {
+                diagnostics.push(createDiagnostic(exports.RECORD_VALIDATION_DIAGNOSTIC_CODES.operationTargetUnauthorized, 'The target workflow step is not authorized for this validation operation.', { operation: policy.name }));
+                return false;
+            }
+            return true;
+        }
+        buildExpressionContext(request, recordType, formName, brand, configuredAllowedRequestParameters, diagnostics) {
+            const requestParams = {};
+            const serverAllowed = new Set(normalizeUniqueStrings(configuredAllowedRequestParameters) ?? []);
+            const callerNames = normalizeUniqueStrings(request.source.allowedRequestParameterNames);
+            const callerNarrowing = request.source.allowedRequestParameterNames === undefined ? serverAllowed : new Set(callerNames ?? []);
+            let droppedRequestParameter = false;
+            for (const [name, value] of Object.entries(request.source.requestParameters ?? {})) {
+                if (serverAllowed.has(name) &&
+                    callerNarrowing.has(name) &&
+                    name !== '__proto__' &&
+                    name !== 'prototype' &&
+                    name !== 'constructor') {
+                    requestParams[name] = value;
+                }
+                else {
+                    droppedRequestParameter = true;
+                }
+            }
+            if (droppedRequestParameter) {
+                diagnostics.push(createDiagnostic(exports.RECORD_VALIDATION_DIAGNOSTIC_CODES.requestParameterDropped, 'One or more request parameters are unavailable to validation expressions.', { severity: 'warning' }));
+            }
+            const rawCurrentStep = request.currentStep ??
+                request.source.candidate.previousWorkflow?.stage ??
+                request.source.candidate.workflow?.stage;
+            const currentStep = this.optionalStepReference(rawCurrentStep, diagnostics, request.requireResolvedWorkflowStep ? 'error' : 'warning');
+            const formData = this.projectExpressionContextObject(request.source.candidate.metadata, 'formData', diagnostics);
+            const projectedRequestParams = this.projectExpressionContextObject(requestParams, 'requestParams', diagnostics);
+            const runtimeContext = this.projectExpressionContextObject(request.source.runtimeContext ?? {}, 'runtimeContext', diagnostics);
+            if (!formData || !projectedRequestParams || !runtimeContext)
+                return undefined;
+            return {
+                formData,
+                ...(request.operation ? { operation: request.operation } : {}),
+                recordType,
+                formName,
+                brand,
+                workflow: {
+                    ...(currentStep.ok && currentStep.value ? { currentStep: currentStep.value } : {}),
+                    ...(request.targetStep ? { targetStep: request.targetStep } : {}),
+                },
+                requestParams: projectedRequestParams,
+                runtimeContext,
+                actor: { authenticated: request.source.actor.authenticated === true, roles: request.actorRoles },
+            };
+        }
+        projectExpressionContextObject(value, label, diagnostics) {
+            try {
+                const serialized = JSON.stringify(value);
+                const projected = serialized === undefined ? undefined : JSON.parse(serialized);
+                if (isRecord(projected)) {
+                    return projected;
+                }
+            }
+            catch {
+                // Report the same bounded configuration diagnostic below.
+            }
+            diagnostics.push(createDiagnostic(exports.RECORD_VALIDATION_DIAGNOSTIC_CODES.expressionContextUnsupported, `The ${label} validation-expression context could not be projected safely.`));
+            return undefined;
+        }
+        async resolveValidationGroups(form, policy, context, diagnostics, deadline) {
+            // ConstructFormConfigVisitor always materializes this default and validates
+            // the built-in `all`/`none` group definitions before resolution reaches here.
+            let groups = [...(form.enabledValidationGroups ?? [])];
+            const availableGroups = form.validationGroups ?? {};
+            const available = new Set(Object.keys(availableGroups));
+            const diagnoseUnknownGroups = (names) => {
+                let unknown = false;
+                for (const group of names) {
+                    if (available.has(group))
+                        continue;
+                    unknown = true;
+                    diagnostics.push(createDiagnostic(exports.RECORD_VALIDATION_DIAGNOSTIC_CODES.validationGroupUnknown, 'An effective blocking validation group is not declared by the form.', { group }));
+                }
+                return unknown;
+            };
+            if (diagnoseUnknownGroups(groups))
+                return undefined;
+            for (const expression of discoverValidationGroupExpressions(form)) {
+                this.checkDeadline(deadline);
+                const change = await this.evaluateGroupExpression(expression, context, diagnostics, deadline);
+                this.checkDeadline(deadline);
+                if (!change)
+                    continue;
+                if (diagnoseUnknownGroups([
+                    ...(change.groups?.include ?? []),
+                    ...(change.groups?.exclude ?? []),
+                ]))
+                    return undefined;
+                const folded = (0, sails_ng_common_1.calculateValidationGroups)(groups, availableGroups, change.initial, change.groups);
+                groups = folded.enabledValidationGroups;
+                diagnostics.push(...folded.diagnostics);
+            }
+            const conditionalGroups = [...groups];
+            // A named operation is an exact trusted group set applied last. Omission
+            // is the explicit strict-all compatibility path: conditional browser
+            // groups remain observable but cannot suppress a blocking validator.
+            if (policy && diagnoseUnknownGroups(policy.enabledValidationGroups))
+                return undefined;
+            const effectiveGroups = policy
+                ? (0, sails_ng_common_1.calculateValidationGroups)(groups, availableGroups, 'current', undefined, policy.enabledValidationGroups)
+                    .enabledValidationGroups
+                : [];
+            return { conditionalGroups, effectiveGroups };
+        }
+        async evaluateGroupExpression(discovered, context, diagnostics, deadline) {
+            const config = discovered.expression.config;
+            const identity = {
+                ...(discovered.expressionName ? { expressionName: discovered.expressionName } : {}),
+                ...(discovered.field ? { field: discovered.field } : {}),
+                ...(discovered.pointer ? { pointer: discovered.pointer } : {}),
+            };
+            if (config.runOnFormReady === false) {
+                diagnostics.push(createDiagnostic(exports.RECORD_VALIDATION_DIAGNOSTIC_CODES.expressionUnsupported, 'A validation-group expression disabled on form ready is client-interaction-only.', identity));
+                return undefined;
+            }
+            try {
+                this.checkDeadline(deadline);
+                if (config.condition !== undefined) {
+                    const conditionKind = config.conditionKind ?? sails_ng_common_1.ExpressionsConditionKind.JSONPointer;
+                    if (conditionKind === sails_ng_common_1.ExpressionsConditionKind.JSONPointer) {
+                        const message = config.condition.includes('::')
+                            ? 'A blocking validation-group expression depends on browser event history.'
+                            : 'A JSONPointer condition routes browser events and has no authoritative server meaning.';
+                        diagnostics.push(createDiagnostic(exports.RECORD_VALIDATION_DIAGNOSTIC_CODES.expressionUnsupported, message, identity));
+                        return undefined;
+                    }
+                    if (conditionKind === sails_ng_common_1.ExpressionsConditionKind.JSONataQuery) {
+                        diagnostics.push(createDiagnostic(exports.RECORD_VALIDATION_DIAGNOSTIC_CODES.expressionUnsupported, 'A JSONataQuery condition requires a browser query source.', identity));
+                        return undefined;
+                    }
+                    if (conditionKind !== sails_ng_common_1.ExpressionsConditionKind.JSONata) {
+                        diagnostics.push(createDiagnostic(exports.RECORD_VALIDATION_DIAGNOSTIC_CODES.expressionUnsupported, 'A blocking validation-group expression uses an unsupported condition kind.', identity));
+                        return undefined;
+                    }
+                    const matches = Boolean(await this.evaluateJSONata(config.condition, context, deadline));
+                    if (!matches)
+                        return undefined;
+                }
+                if (typeof config.template !== 'string') {
+                    diagnostics.push(createDiagnostic(exports.RECORD_VALIDATION_DIAGNOSTIC_CODES.expressionUnsupported, 'An operation-only validation-group expression has no registered server implementation.', identity));
+                    return undefined;
+                }
+                const value = await this.evaluateJSONata(config.template, context, deadline);
+                const change = parseGroupChange(value);
+                if (!change) {
+                    diagnostics.push(createDiagnostic(exports.RECORD_VALIDATION_DIAGNOSTIC_CODES.expressionResultMalformed, 'A blocking validation-group expression returned a malformed group change.', identity));
+                }
+                return change;
+            }
+            catch (error) {
+                if (error instanceof ValidationDeadlineExceeded)
+                    throw error;
+                diagnostics.push(createDiagnostic(exports.RECORD_VALIDATION_DIAGNOSTIC_CODES.expressionEvaluationFailed, 'A blocking validation-group expression could not be evaluated.', identity));
+                return undefined;
+            }
+        }
+        async loadFormDefinition(formName, brand) {
+            const form = await this.dependencies().loadForm(formName, brand);
+            return form ? {
+                form: lodash_1.default.cloneDeep(form),
+                reusableFormDefinitions: lodash_1.default.cloneDeep(sails.config.reusableFormDefinitions ?? {}),
+            } : null;
+        }
+        async constructForm(entry, metadata) {
+            if (!entry.form.configuration)
+                throw new Error('Form configuration is unavailable.');
+            return await this.dependencies().constructForm(lodash_1.default.cloneDeep(entry.form.configuration), metadata, lodash_1.default.cloneDeep(entry.reusableFormDefinitions));
+        }
+        discoverAdvisoryGroups(form, blockingGroups, diagnostics) {
+            const advisoryGroups = [];
+            for (const node of schemaOwnedFormNodes(form)) {
+                const component = isRecord(node.value.component) ? node.value.component : undefined;
+                if (component?.class === sails_ng_common_1.SuggestedValidationSummaryComponentName) {
+                    const config = isRecord(component.config) ? component.config : undefined;
+                    const groups = normalizeUniqueStrings(config?.enabledValidationGroups);
+                    if (!config || groups === undefined || groups.length === 0) {
+                        diagnostics.push(createDiagnostic(exports.RECORD_VALIDATION_DIAGNOSTIC_CODES.advisoryConfigurationMalformed, 'An advisory validation summary has malformed validation groups.'));
+                    }
+                    else {
+                        for (const group of groups)
+                            if (!advisoryGroups.includes(group))
+                                advisoryGroups.push(group);
+                    }
+                }
+            }
+            const available = new Set(Object.keys(form.validationGroups ?? {}));
+            const malformedInitialAllGroups = new Set();
+            for (const group of advisoryGroups) {
+                if (!available.has(group)) {
+                    diagnostics.push(createDiagnostic(exports.RECORD_VALIDATION_DIAGNOSTIC_CODES.advisoryGroupUnknown, 'An advisory validation group is not declared by the form.', { group }));
+                }
+                else if (form.validationGroups?.[group]?.initialMembership === 'all') {
+                    malformedInitialAllGroups.add(group);
+                    diagnostics.push(createDiagnostic(exports.RECORD_VALIDATION_DIAGNOSTIC_CODES.advisoryConfigurationMalformed, 'An advisory validation group cannot use all initial membership.', { group }));
+                }
+            }
+            const validGroups = advisoryGroups.filter(group => available.has(group) && !malformedInitialAllGroups.has(group));
+            // Empty blocking groups is the established strict-all sentinel. It is
+            // not a named group intersection and advisory-only validators are
+            // removed from that pass by ValidatorFormConfigVisitor.
+            const overlap = validGroups.filter(group => blockingGroups.includes(group));
+            for (const group of overlap) {
+                diagnostics.push(createDiagnostic(exports.RECORD_VALIDATION_DIAGNOSTIC_CODES.validationGroupOverlap, 'A validation group is configured as both blocking and advisory.', { group }));
+            }
+            return validGroups;
+        }
+        validatorDefinitions(_form, diagnostics) {
+            const definitions = sails.config.validators?.definitions;
+            try {
+                return new sails_ng_common_1.ValidatorsSupport().createValidatorDefinitionMapping(definitions ?? []);
+            }
+            catch {
+                diagnostics.push(createDiagnostic(exports.RECORD_VALIDATION_DIAGNOSTIC_CODES.blockingExecutionFailed, 'Validator definitions could not be prepared.'));
+                return undefined;
+            }
+        }
+        async executeValidators(form, groups, mapping, excludedOnlyGroups, deadline) {
+            const execute = this.dependencies().executeValidators;
+            if (!execute)
+                throw new Error('Record validation executor is unavailable.');
+            this.checkDeadline(deadline);
+            const result = await execute(form, groups, mapping, expression => this.jsonataEvaluator(expression, deadline), excludedOnlyGroups, () => this.checkDeadline(deadline));
+            return result;
+        }
+        async collectCandidateTransformations(form, deadline) {
+            const collect = this.dependencies().collectTransformations;
+            if (!collect)
+                throw new Error('Record validation transformation collector is unavailable.');
+            this.checkDeadline(deadline);
+            const transformations = await collect(form, () => this.checkDeadline(deadline));
+            return transformations;
+        }
+        applyCandidateTransformations(candidate, transformations, diagnostics) {
+            // Always detach the returned candidate, including the empty
+            // transformation path, so callers never receive their own object back.
+            const detachedCandidate = cloneRecordValidationCandidate(candidate);
+            const metadata = cloneRecordValidationValue(detachedCandidate.metadata ?? {});
+            const transformedCandidate = {
+                ...detachedCandidate,
+                metadata,
+            };
+            const applied = [];
+            let inapplicable = false;
+            for (const candidateTransformation of transformations) {
+                if (!isFormValueTransformation(candidateTransformation)) {
+                    inapplicable = true;
+                    diagnostics.push(createDiagnostic(exports.RECORD_VALIDATION_DIAGNOSTIC_CODES.transformationInapplicable, 'A malformed schema-owned candidate transformation could not be safely applied.'));
+                    continue;
+                }
+                if (!this.isCanonicalRichHtmlTransformation(candidateTransformation)) {
+                    inapplicable = true;
+                    diagnostics.push(createDiagnostic(exports.RECORD_VALIDATION_DIAGNOSTIC_CODES.transformationInapplicable, 'A schema-owned candidate transformation did not contain the canonical sanitized value.'));
+                    continue;
+                }
+                if (this.replaceCandidateMetadataValue(metadata, candidateTransformation.dataModelPath, candidateTransformation.sourceValue, candidateTransformation.value)) {
+                    applied.push(candidateTransformation);
+                }
+                else {
+                    inapplicable = true;
+                    diagnostics.push(createDiagnostic(exports.RECORD_VALIDATION_DIAGNOSTIC_CODES.transformationInapplicable, 'A schema-owned candidate transformation no longer matched the submitted form data.'));
+                }
+            }
+            return { candidate: transformedCandidate, applied, inapplicable };
+        }
+        isCanonicalRichHtmlTransformation(transformation) {
+            try {
+                return transformation.value === DomSanitizerService.sanitizeWithProfile(transformation.sourceValue, 'html');
+            }
+            catch {
+                return false;
+            }
+        }
+        replaceCandidateMetadataValue(metadata, path, sourceValue, value) {
+            if (path.length === 0 || !lodash_1.default.has(metadata, path) || lodash_1.default.get(metadata, path) !== sourceValue)
+                return false;
+            lodash_1.default.set(metadata, path, value);
+            return true;
+        }
+        jsonataEvaluator(expression, deadline) {
+            this.checkDeadline(deadline);
+            const compiled = this.compiledExpression(expression);
+            this.checkDeadline(deadline);
+            return async (value) => {
+                this.checkDeadline(deadline);
+                const result = await (0, sails_ng_common_1.jsonataEvaluate)(compiled, value);
+                this.checkDeadline(deadline);
+                return result;
+            };
+        }
+        compiledExpression(expression) {
+            return (0, sails_ng_common_1.jsonataCompile)(expression);
+        }
+        async evaluateJSONata(expression, context, deadline) {
+            this.checkDeadline(deadline);
+            const compiled = this.compiledExpression(expression);
+            this.checkDeadline(deadline);
+            const result = await (0, sails_ng_common_1.jsonataEvaluate)(compiled, context);
+            this.checkDeadline(deadline);
+            return result;
+        }
+        mapValidatorSummaries(summaries) {
+            const blocking = [];
+            for (const summary of summaries) {
+                for (const error of summary.errors ?? []) {
+                    const pointer = summary.lineagePaths?.angularComponentsJsonPointer;
+                    const dataPointer = summary.lineagePaths?.dataModel
+                        ? (0, sails_ng_common_1.getJSONPointerByArrayPaths)(summary.lineagePaths.dataModel)
+                        : undefined;
+                    const safe = (0, sails_ng_common_1.sanitizeRecordSaveIssue)({
+                        message: SAFE_TRANSLATION_KEY_PATTERN.test(error.message)
+                            ? error.message
+                            : '@validator-error-record-validation',
+                        ...(typeof summary.id === 'string' && SAFE_FIELD_PATTERN.test(summary.id) ? { field: summary.id } : {}),
+                        ...(typeof pointer === 'string'
+                            ? { pointer }
+                            : typeof dataPointer === 'string'
+                                ? { pointer: dataPointer }
+                                : {}),
+                        ...(typeof error.class === 'string' && SAFE_VALIDATOR_CLASS_PATTERN.test(error.class)
+                            ? { class: error.class }
+                            : {}),
+                        params: error.params,
+                        targetField: error.targetField,
+                        lineagePaths: summary.lineagePaths,
+                    });
+                    blocking.push(safe);
+                }
+            }
+            return { blocking };
+        }
+        mapTransformationAdvisories(transformations) {
+            const advisories = [];
+            for (const transformation of transformations) {
+                advisories.push(...this.mapValidatorSummaries([transformation.advisorySummary]).blocking);
+            }
+            return advisories;
+        }
+        timeoutMs(value) {
+            return typeof value === 'number' && Number.isSafeInteger(value) && value > 0 ? value : 5_000;
+        }
+        createDeadline(timeoutMs) {
+            return { expiresAt: node_perf_hooks_1.performance.now() + timeoutMs };
+        }
+        checkDeadline(deadline) {
+            if (node_perf_hooks_1.performance.now() >= deadline.expiresAt)
+                throw new ValidationDeadlineExceeded();
+        }
+        remainingBudgetMs(deadline) {
+            return Math.max(0, deadline.expiresAt - node_perf_hooks_1.performance.now());
+        }
+        async withDeadline(work, deadline) {
+            const remainingBudgetMs = this.remainingBudgetMs(deadline);
+            if (remainingBudgetMs <= 0)
+                return { status: 'timed-out' };
+            let timer;
+            // Install the timer before invoking work. Promise.resolve() defers the
+            // first unit until after the timer exists, and explicit elapsed checks
+            // still classify synchronous event-loop blocking as a timeout.
+            const settledWork = (async () => {
+                await Promise.resolve();
+                try {
+                    this.checkDeadline(deadline);
+                    const value = await work();
+                    this.checkDeadline(deadline);
+                    return { status: 'completed', value };
+                }
+                catch (error) {
+                    return error instanceof ValidationDeadlineExceeded
+                        ? { status: 'timed-out' }
+                        : { status: 'failed' };
+                }
+            })();
+            const timeout = new Promise(resolve => {
+                timer = setTimeout(() => resolve({ status: 'timed-out' }), remainingBudgetMs);
+            });
+            try {
+                return await Promise.race([settledWork, timeout]);
+            }
+            finally {
+                if (timer)
+                    clearTimeout(timer);
+            }
+        }
+        addMalformedModeDiagnostics(malformedModeCount, diagnostics) {
+            for (let index = 0; index < malformedModeCount; index += 1) {
+                diagnostics.push(createDiagnostic(exports.RECORD_VALIDATION_DIAGNOSTIC_CODES.rolloutModeMalformed, 'A record-validation rollout mode is malformed.'));
+            }
+        }
+        buildResult(mode, diagnostics, options) {
+            const hasConfigurationError = diagnostics.some(item => item.severity === 'error');
+            const hasBlockingErrors = options.outcome === 'resolved' && options.blockingErrors.length > 0;
+            const shouldBlock = (options.outcome === 'unresolved' && options.contractFailure === true) ||
+                (mode === 'enforce' && (hasConfigurationError || hasBlockingErrors));
+            const formName = options.outcome === 'resolved' ? options.resolved.formName : options.formName;
+            const common = {
+                shouldBlock,
+                mode,
+                ...(formName ? { formName } : {}),
+                ...(options.operation ? { effectiveOperation: options.operation } : {}),
+                diagnostics: [...diagnostics],
+            };
+            const result = options.outcome === 'resolved'
+                ? {
+                    ...common,
+                    status: 'resolved',
+                    formName: options.resolved.formName,
+                    effectiveGroups: [...options.effectiveGroups],
+                    resolved: options.resolved,
+                    blockingErrors: [...options.blockingErrors],
+                    advisoryErrors: [...options.advisoryErrors],
+                    advisoryGroups: [...options.advisoryGroups],
+                    transformedCandidate: cloneRecordValidationCandidate(options.transformedCandidate),
+                }
+                : {
+                    ...common,
+                    status: 'unresolved',
+                    ...(options.transformedCandidate
+                        ? { transformedCandidate: cloneRecordValidationCandidate(options.transformedCandidate) }
+                        : {}),
+                };
+            return result;
+        }
+        validatorFailureIdentities(issues, scope) {
+            return issues.slice(0, 128).map(issue => {
+                const validatorClass = typeof issue.class === 'string' && SAFE_VALIDATOR_CLASS_PATTERN.test(issue.class)
+                    ? issue.class
+                    : undefined;
+                const explicitCode = typeof issue.code === 'string' && SAFE_DIAGNOSTIC_CODE_PATTERN.test(issue.code)
+                    ? issue.code
+                    : undefined;
+                const translatedCode = typeof issue.message === 'string' && issue.message.startsWith('@')
+                    ? issue.message.slice(1)
+                    : undefined;
+                const validatorCode = explicitCode ?? (translatedCode && SAFE_DIAGNOSTIC_CODE_PATTERN.test(translatedCode) ? translatedCode : undefined);
+                const field = typeof issue.field === 'string' && SAFE_FIELD_PATTERN.test(issue.field)
+                    ? issue.field
+                    : undefined;
+                const pointer = lowCardinalityPointer(issue.pointer);
+                const lineageParts = ['formConfig', 'dataModel', 'angularComponents', 'layout'].flatMap(key => {
+                    const path = issue.lineagePaths?.[key];
+                    if (!Array.isArray(path))
+                        return [];
+                    const lineagePointer = lowCardinalityPointer((0, sails_ng_common_1.getJSONPointerByArrayPaths)(path));
+                    return lineagePointer ? [`${key}=${lineagePointer}`] : [];
+                });
+                const lineageValue = lineageParts.join('|');
+                const lineage = lineageValue && lineageValue.length <= 2_048 ? lineageValue : undefined;
+                return {
+                    code: VALIDATOR_FAILURE_DIAGNOSTIC_CODE,
+                    scope,
+                    ...(validatorClass ? { validatorClass } : {}),
+                    ...(validatorCode ? { validatorCode } : {}),
+                    ...(field ? { field } : {}),
+                    ...(pointer ? { pointer } : {}),
+                    ...(lineage ? { lineage } : {}),
+                };
+            });
+        }
+        observeResolution(request, result, progress, rawDurationMs) {
+            const requestId = safeRequestId(request.requestId);
+            const diagnosticCodes = result.diagnostics
+                .map(item => item.code)
+                .filter(code => SAFE_DIAGNOSTIC_CODE_PATTERN.test(code))
+                .slice(0, 128);
+            const configurationIdentities = result.diagnostics.slice(0, 128).flatMap(diagnostic => {
+                if (!SAFE_DIAGNOSTIC_CODE_PATTERN.test(diagnostic.code))
+                    return [];
+                const expressionName = typeof diagnostic.expressionName === 'string' && SAFE_FIELD_PATTERN.test(diagnostic.expressionName)
+                    ? diagnostic.expressionName
+                    : undefined;
+                const field = typeof diagnostic.field === 'string' && SAFE_FIELD_PATTERN.test(diagnostic.field)
+                    ? diagnostic.field
+                    : undefined;
+                const pointer = lowCardinalityPointer(diagnostic.pointer);
+                return [{
+                        code: diagnostic.code,
+                        scope: 'diagnostic',
+                        ...(expressionName ? { expressionName } : {}),
+                        ...(field ? { field } : {}),
+                        ...(pointer ? { pointer } : {}),
+                    }];
+            });
+            const diagnosticCodeSet = new Set(diagnosticCodes);
+            const blockingErrorCount = result.status === 'resolved' ? result.blockingErrors.length : 0;
+            const advisoryErrorCount = result.status === 'resolved' ? result.advisoryErrors.length : 0;
+            const diagnosticIdentities = result.status === 'resolved'
+                ? [
+                    ...configurationIdentities,
+                    ...this.validatorFailureIdentities(result.blockingErrors, 'blocking-validator'),
+                    ...this.validatorFailureIdentities(result.advisoryErrors, 'advisory-validator'),
+                ].slice(0, 128)
+                : configurationIdentities;
+            const timeoutKind = diagnosticCodeSet.has(exports.RECORD_VALIDATION_DIAGNOSTIC_CODES.blockingTimeout)
+                ? 'blocking'
+                : diagnosticCodeSet.has(exports.RECORD_VALIDATION_DIAGNOSTIC_CODES.advisoryTimeout)
+                    ? 'advisory'
+                    : 'none';
+            const requestRejected = [...diagnosticCodeSet].some(code => requestRejectionCodes.has(code));
+            const configurationDiagnosticCount = result.diagnostics.filter(diagnostic => SAFE_DIAGNOSTIC_CODE_PATTERN.test(diagnostic.code) &&
+                !requestRejectionCodes.has(diagnostic.code) &&
+                diagnostic.code !== exports.RECORD_VALIDATION_DIAGNOSTIC_CODES.blockingTimeout &&
+                diagnostic.code !== exports.RECORD_VALIDATION_DIAGNOSTIC_CODES.advisoryTimeout &&
+                diagnostic.code !== exports.RECORD_VALIDATION_DIAGNOSTIC_CODES.requestParameterDropped).length;
+            const outcome = timeoutKind === 'blocking'
+                ? 'timed-out'
+                : requestRejected
+                    ? 'request-rejected'
+                    : configurationDiagnosticCount > 0 && result.diagnostics.some(item => item.severity === 'error')
+                        ? 'configuration-error'
+                        : blockingErrorCount > 0
+                            ? 'invalid'
+                            : 'valid';
+            const durationMs = Number.isFinite(rawDurationMs) && rawDurationMs >= 0 ? rawDurationMs : 0;
+            const wouldBlock = outcome === 'invalid' ||
+                outcome === 'request-rejected' ||
+                outcome === 'configuration-error' ||
+                outcome === 'timed-out';
+            const formName = result.formName ?? progress.formName;
+            const operation = diagnosticCodeSet.has(exports.RECORD_VALIDATION_DIAGNOSTIC_CODES.operationUnknown)
+                ? UNKNOWN_OPERATION_DIMENSION
+                : diagnosticCodeSet.has(exports.RECORD_VALIDATION_DIAGNOSTIC_CODES.operationMalformed)
+                    ? MALFORMED_OPERATION_DIMENSION
+                    : result.effectiveOperation ?? progress.operation;
+            const metric = Object.freeze({
+                ...(requestId ? { requestId } : {}),
+                ...(progress.recordType ? { recordType: progress.recordType } : {}),
+                ...(formName ? { formName } : {}),
+                ...(operation ? { operation } : {}),
+                writeKind: request.writeKind,
+                phase: request.phase ?? 'pre-save',
+                mode: result.mode,
+                status: result.status,
+                shouldBlock: result.shouldBlock,
+                wouldBlock,
+                outcome,
+                durationMs,
+                blockingErrorCount,
+                advisoryErrorCount,
+                timeoutKind,
+                configurationDiagnosticCount,
+                diagnosticCodes: Object.freeze([...diagnosticCodes]),
+                diagnosticIdentities: Object.freeze(diagnosticIdentities.map(identity => Object.freeze(identity))),
+            });
+            this.emitOpenTelemetry(metric);
+            this.logger.info('record_validation_completed', {
+                event: 'record_validation_completed',
+                request_id: metric.requestId ?? 'unavailable',
+                record_type: metric.recordType ?? UNRESOLVED_DIMENSION,
+                form: metric.formName ?? UNRESOLVED_DIMENSION,
+                validation_operation: metric.operation ?? STRICT_ALL_OPERATION,
+                write_kind: metric.writeKind,
+                phase: metric.phase,
+                mode: metric.mode,
+                status: metric.status,
+                outcome: metric.outcome,
+                should_block: metric.shouldBlock,
+                would_block: metric.wouldBlock,
+                blocking_error_count: metric.blockingErrorCount,
+                advisory_error_count: metric.advisoryErrorCount,
+                timeout_kind: metric.timeoutKind,
+                configuration_diagnostic_count: metric.configurationDiagnosticCount,
+                diagnostic_codes: metric.diagnosticCodes,
+                diagnostic_identities: metric.diagnosticIdentities,
+                duration_ms: metric.durationMs,
+            });
+        }
+        warnObservabilityFailure(message) {
+            try {
+                this.logger.warn(message);
+            }
+            catch {
+                // Logging is observational too and must not reject a detached observer.
+            }
+        }
+        emitOpenTelemetry(metric) {
+            const attributes = {
+                'record_validation.mode': metric.mode,
+                'record_validation.outcome': metric.outcome,
+                'record_validation.status': metric.status,
+                'record_validation.record_type': openTelemetryResolvedDimension(metric, metric.recordType),
+                'record_validation.form': openTelemetryResolvedDimension(metric, metric.formName),
+                'record_validation.operation': openTelemetryOperationDimension(metric),
+                'record_validation.write_kind': metric.writeKind,
+                'record_validation.phase': metric.phase,
+            };
+            try {
+                recordValidationDuration.record(metric.durationMs, attributes);
+                recordValidationRuns.add(1, attributes);
+                if (metric.blockingErrorCount > 0)
+                    recordValidationBlockingErrors.add(metric.blockingErrorCount, attributes);
+                if (metric.advisoryErrorCount > 0)
+                    recordValidationAdvisoryErrors.add(metric.advisoryErrorCount, attributes);
+                if (metric.timeoutKind !== 'none') {
+                    recordValidationTimeouts.add(1, { ...attributes, 'record_validation.timeout_kind': metric.timeoutKind });
+                }
+                if (metric.configurationDiagnosticCount > 0) {
+                    recordValidationConfigurationDiagnostics.add(metric.configurationDiagnosticCount, attributes);
+                }
+                for (const diagnostic of metric.diagnosticIdentities) {
+                    recordValidationDiagnostics.add(1, {
+                        ...attributes,
+                        'record_validation.code': openTelemetryDiagnosticCode(diagnostic.code),
+                        'record_validation.failure_scope': diagnostic.scope,
+                    });
+                }
+            }
+            catch {
+                this.warnObservabilityFailure('Record validation OpenTelemetry emission failed.');
+            }
+        }
+    }
+    Services.RecordValidation = RecordValidation;
+})(Services || (exports.Services = Services = {}));
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"RecordValidationService.js","sourceRoot":"","sources":["../../src/services/RecordValidationService.ts"],"names":[],"mappings":"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"}