@formaui-net/nexo 0.0.0 → 1.0.0-preview.1

package/src/language/DefinitionValidator.mjs

@@ -0,0 +1,1265 @@
+/**
+ * DefinitionValidator — a definition checked against Nexo's structure, as its canonical, frozen copy
+ */
+
+import { ArrayUtils } from '../common/ArrayUtils.mjs';
+import { ObjectUtils } from '../common/ObjectUtils.mjs';
+import { DefinitionLocations } from './DefinitionLocations.mjs';
+import { Imports } from './Imports.mjs';
+import { Limits } from './Limits.mjs';
+import { NexoErrors } from './NexoError.mjs';
+import { Names } from './Names.mjs';
+import { Versions } from './Versions.mjs';
+
+/** @typedef {import('./TextLocations.mjs').TextLocations} TextLocations */
+
+/** The properties each kind of node holds, and those it requires. */
+const NODE_PROPERTIES = {
+    literal: { properties: ['kind', 'value'], required: ['value'] },
+    scriptParameter: { properties: ['kind', 'name'], required: ['name'] },
+    it: { properties: ['kind'], required: [] },
+    root: { properties: ['kind'], required: [] },
+    namespace: { properties: ['kind', 'name'], required: ['name'] },
+    local: { properties: ['kind', 'name'], required: ['name'] },
+    memberAccess: { properties: ['kind', 'receiver', 'name', 'optional', 'extension', 'continues'], required: ['receiver', 'name'] },
+    call: { properties: ['kind', 'callee', 'arguments'], required: ['callee', 'arguments'] },
+    indexerAccess: { properties: ['kind', 'receiver', 'optional', 'argument'], required: ['receiver', 'argument'] },
+    object: { properties: ['kind', 'context', 'locals', 'objectFields'], required: ['objectFields'] },
+    list: { properties: ['kind', 'items'], required: ['items'] },
+    dictionary: { properties: ['kind', 'entries'], required: ['entries'] },
+    optionalChain: { properties: ['kind', 'chain'], required: ['chain'] },
+    equality: { properties: ['kind', 'left', 'right'], required: ['left', 'right'] },
+    comparison: { properties: ['kind', 'operands', 'operators'], required: ['operands', 'operators'] },
+    interpolatedString: { properties: ['kind', 'parts'], required: ['parts'] },
+    conditional: { properties: ['kind', 'condition', 'binding', 'consequent', 'alternative'], required: ['consequent', 'alternative'] },
+    body: { properties: ['kind', 'locals', 'result'], required: ['locals', 'result'] },
+    do: { properties: ['kind', 'body'], required: ['body'] },
+    function: { properties: ['kind', 'parameters', 'body', 'arrow'], required: ['parameters', 'body'] },
+    arithmetic: { properties: ['kind', 'operator', 'left', 'right'], required: ['operator', 'left', 'right'] },
+    arithmeticNegation: { properties: ['kind', 'operand'], required: ['operand'] },
+    fromEndIndex: { properties: ['kind', 'offset'], required: ['offset'] },
+    range: { properties: ['kind', 'start', 'end'], required: [] },
+    coalescing: { properties: ['kind', 'value', 'fallback'], required: ['value', 'fallback'] },
+    not: { properties: ['kind', 'operand'], required: ['operand'] },
+    cast: { properties: ['kind', 'type', 'operand'], required: ['type', 'operand'] },
+    conversion: { properties: ['kind', 'type', 'operand'], required: ['type', 'operand'] },
+    try: { properties: ['kind', 'operand'], required: ['operand'] },
+    and: { properties: ['kind', 'operands'], required: ['operands'] },
+    or: { properties: ['kind', 'operands'], required: ['operands'] },
+};
+
+/** The kinds of node that continue a chain through their receiver, a call's member or an object expression's context, and so carry its optional chain to the access that is. */
+const CHAIN_KINDS = new Set(['memberAccess', 'call', 'indexerAccess', 'object']);
+
+/**
+ * The kinds of node a cast's operand starts from, its receiver, as text writes one: an input, a namespace's member, a call of the function a name holds and an object expression following no value among them, or a grouped
+ * cast.
+ */
+const CAST_RECEIVER_KINDS = new Set(['it', 'scriptParameter', 'root', 'namespace', 'local', 'literal', 'interpolatedString', 'call', 'object', 'list', 'dictionary', 'cast']);
+
+/** The keys a dictionary's entry holds, both written: its key, the string its key literal writes, and its value. */
+const DICTIONARY_ENTRY_PROPERTIES = { properties: ['key', 'value'], required: ['key', 'value'] };
+
+/** A surrogate standing alone, which a Unicode pattern reads as one, a pair being one character outside the Basic Multilingual Plane. */
+const LONE_SURROGATE = /\p{Cs}/u;
+
+/** The operators an arithmetic node holds. */
+const ARITHMETIC_OPERATORS = ['+', '-', '*', '/', '%'];
+
+/** The direction each comparison operator points, which every operator of a chain shares. */
+/** The properties each kind of part of an interpolated string has. */
+const INTERPOLATION_PARTS = Object.freeze({
+    text: { properties: ['kind', 'value'], required: ['value'] },
+    expression: { properties: ['kind', 'expression'], required: ['expression'] },
+});
+
+const COMPARISON_DIRECTIONS = Object.freeze({ '<': 'ascending', '<=': 'ascending', '>': 'descending', '>=': 'descending' });
+
+/** The kinds of node `try` attempts: the operations with a rejection of their own, which an attempt answers null for. */
+const ATTEMPTED_KINDS = new Set(['conversion', 'cast']);
+
+/** The keys a local, a conditional binding and an object field each hold: a name, always written, and a value. */
+const ENTRY_PROPERTIES = { properties: ['name', 'value'], required: ['name', 'value'] };
+
+/** Where a node's implicit parameter stands: absent at the top level, present in an object expression following a value, unknown in an argument. */
+const ContextAvailability = Object.freeze({ absent: 'absent', present: 'present', unknown: 'unknown' });
+
+export class DefinitionValidator {
+    /** Where in the definition its caller supplied each part of a canonical copy came from, for each copy whose validation moved a part. @type {WeakMap<object, DefinitionLocations>} */
+    static #suppliedLocations = new WeakMap();
+
+    /** Every canonical definition validation gave, which validating again answers as it is. @type {WeakSet<object>} */
+    static #canonicalDefinitions = new WeakSet();
+
+    /** The parameter nodes of canonical definitions that a text wrote alone, a bare name no local in scope has, rather than with `~`. @type {WeakSet<object>} */
+    static #scriptParametersWrittenAlone = new WeakSet();
+
+    /**
+     * The parameter nodes of canonical definitions written with `~`, or given in a definition, whose name a local, an object field, a conditional binding or a function parameter in scope where they stand hides,
+     * or a local or a conditional binding of their scope declares later, which canonical text therefore writes with `~`. @type {WeakSet<object>}
+     */
+    static #hiddenScriptParameters = new WeakSet();
+
+    #locations;
+
+    /** The index each part of an interpolated string had in the definition being validated, by the canonical node, for each node whose parts validation moved. @type {WeakMap<object, number[]>} */
+    #partIndexes = new WeakMap();
+
+    /** Whether validation moved a part of the definition, which its locations then say. */
+    #hasMovedParts = false;
+
+    /** The local names the definition's imports give modules, which a namespace and an extension selection's module name. @type {ReadonlySet<string>} */
+    #namespaceNames = Names.noNamespaceNames;
+
+    /** Whether an object expression's locals or fields hold the node being validated, lexically, so an outermost object is being built where it stands. */
+    #isInObjectExpression = false;
+
+    /** The names of the locals and the fields in scope where the node being validated stands. @type {Set<string>} */
+    #localNames = new Set();
+
+    /** The names of the locals declared later in a scope the node being validated stands in, the local whose value it is among them, which no parameter there may name, each with whether a local or a conditional binding declares it. @type {Map<string, 'local' | 'conditionalBinding'>} */
+    #laterNames = new Map();
+
+    /** The optional chain the node being validated continues, with whether an access of it is optional so far; null where it continues none. @type {{ hasOptional: boolean } | null} */
+    #optionalChain = null;
+
+    /** The nodes holding the node being validated, outermost first, so a definition nesting past `Limits.nesting` is refused, and a node holding itself is refused as no tree. @type {Set<object>} */
+    #enclosingNodes = new Set();
+
+    /**
+     * The simple expression the node being validated stands in, an argument, an indexer's key, a computed property access's name or an interpolation's expression, with the subject its messages open with and whether a conditional holds the node;
+     * null outside one. A simple expression nested in another keeps the conditional that holds it.
+     * @type {{ subject: string, isInConditional: boolean } | null}
+     */
+    #simpleExpression = null;
+
+    /** The parameters of a definition parsed from text that the text wrote alone, as the lowering gave them; null for a definition not parsed from text. @type {WeakSet<object> | null} */
+    #parametersWrittenAloneInText;
+
+    /**
+     * @param {TextLocations | null} locations Where in a text each part of the definition came from, for one parsed from text.
+     * @param {WeakSet<object> | null} scriptParametersWrittenAlone The parameters a text wrote alone, for one parsed from text.
+     */
+    constructor(locations = null, scriptParametersWrittenAlone = null) {
+        this.#locations = locations;
+        this.#parametersWrittenAloneInText = scriptParametersWrittenAlone;
+    }
+
+    /** Whether a canonical definition's parameter node is a name a text wrote alone, which reads a local or field of its name where one is in scope, rather than a script parameter written with `~` or a definition's. */
+    static isWrittenAlone(node) {
+        return DefinitionValidator.#scriptParametersWrittenAlone.has(node);
+    }
+
+    /**
+     * Whether a canonical definition's parameter node is a script parameter that a local, an object field, a conditional binding or a function parameter in scope where it stands hides, or a local or a conditional binding
+     * of its scope declares later, so that canonical text writes it with `~`; a parameter written alone is never one, since it reads no name a local in scope has.
+     */
+    static isHidden(node) {
+        return DefinitionValidator.#hiddenScriptParameters.has(node);
+    }
+
+    /**
+     * A deep copy of a canonical definition's node, its own keys alone, each parameter node a text wrote alone, and each one hidden where it stands, marked as one in the copy too. A node's keys are the definition
+     * format's own, so each is assigned as it is; only a parameter node is ever marked, so no other is looked up.
+     */
+    static copyOf(node) {
+        if (Array.isArray(node)) {
+            const copy = new Array(node.length);
+
+            for (let index = 0; index < node.length; index++) {
+                copy[index] = DefinitionValidator.copyOf(node[index]);
+            }
+
+            return copy;
+        }
+
+        if (node === null || typeof node !== 'object') {
+            return node;
+        }
+
+        const copy = {};
+
+        for (const key of Object.keys(node)) {
+            copy[key] = DefinitionValidator.copyOf(node[key]);
+        }
+
+        if (node.kind === 'scriptParameter') {
+            if (DefinitionValidator.#scriptParametersWrittenAlone.has(node)) {
+                DefinitionValidator.#scriptParametersWrittenAlone.add(copy);
+            }
+
+            if (DefinitionValidator.#hiddenScriptParameters.has(node)) {
+                DefinitionValidator.#hiddenScriptParameters.add(copy);
+            }
+        }
+
+        return copy;
+    }
+
+    /**
+     * Validates the definition's structure and answers its canonical, frozen copy, recording it as canonical, so validating it again answers it as it is, keeping the locations it has. For a definition its caller supplied,
+     * where validation moved a part of an interpolated string, it records the index each moved part had, so a diagnostic names each part as the caller did. It refuses a definition of another version (NEXO2007) before
+     * anything else, its imports where they break their rules (NEXO2008), and any other structure the definition format does not allow.
+     */
+    validate(definition) {
+        if (DefinitionValidator.#canonicalDefinitions.has(definition)) {
+            return definition;
+        }
+
+        // One version is read, and none is converted into another, so a definition of another version names both, before anything else its version's contract may hold.
+        if (definition !== null && typeof definition === 'object' && Object.hasOwn(definition, 'version') && definition.version !== Versions.definition) {
+            this.#fail('NEXO2007', `A definition is of version ${Versions.definition}, the one this implementation reads, and this one is of version ${JSON.stringify(definition.version)}`, '/version');
+        }
+
+        this.#requireProperties(definition, '', { properties: ['version', 'imports', 'expression'], required: ['version', 'imports', 'expression'] });
+
+        const imports = this.#validateImports(definition.imports);
+
+        this.#namespaceNames = Imports.namespaceNamesOf(imports);
+
+        const validated = Object.freeze({ version: Versions.definition, imports, expression: this.#validateBodyOrExpression(definition.expression, '/expression', ContextAvailability.absent) });
+
+        // A definition parsed from text has its text's locations; one a caller supplied, where a part moved, has locations that name its parts as the caller did.
+        if (this.#locations === null && this.#hasMovedParts) {
+            DefinitionValidator.#suppliedLocations.set(validated, new DefinitionLocations(validated, this.#partIndexes));
+        }
+
+        DefinitionValidator.#canonicalDefinitions.add(validated);
+
+        return validated;
+    }
+
+    /**
+     * Validates a definition's imports: a list, each import's shape as its rules say, and every import once, in order of the local name it gives, so two giving one local name to different declarations conflict; each
+     * refusal is NEXO2008, located at the import.
+     */
+    #validateImports(imports) {
+        this.#requireArray(imports, '/imports');
+
+        return Object.freeze(imports.map((entry, index) => {
+            const pointer = `/imports/${index}`;
+
+            Imports.validateImport(entry, message => this.#fail('NEXO2008', message, pointer));
+
+            const previous = imports[index - 1];
+
+            if (previous !== undefined && Imports.localNameOf(previous) === Imports.localNameOf(entry) && !Imports.isSameImport(previous, entry)) {
+                this.#fail('NEXO2008', Imports.describeConflict([previous, entry]), pointer);
+            }
+
+            if (previous !== undefined && !(Imports.localNameOf(previous) < Imports.localNameOf(entry))) {
+                this.#fail('NEXO2008', "A definition's imports are each once, in order of the local name each gives", pointer);
+            }
+
+            return Object.freeze({ module: entry.module, ...(entry.type === undefined ? {} : { type: entry.type }), ...(entry.alias === undefined ? {} : { alias: entry.alias }) });
+        }));
+    }
+
+    /** Where in the definition its caller supplied each part of the canonical copy came from, or null where validation moved none, so each part's pointer is the caller's. */
+    static locationsOf(definition) {
+        return DefinitionValidator.#suppliedLocations.get(definition) ?? null;
+    }
+
+    #validateNode(node, pointer, contextAvailability) {
+        // A definition is a tree, so no node holds itself, and it nests as deep as a text may.
+        if (this.#enclosingNodes.has(node)) {
+            this.#fail('NEXO2000', 'A definition is a tree, and this node holds itself', pointer);
+        }
+
+        if (this.#enclosingNodes.size >= Limits.nesting) {
+            this.#fail('NEXO2046', `A definition nests at most ${Limits.nesting} levels, and this node stands deeper`, pointer);
+        }
+
+        const isNode = ObjectUtils.isNonArrayObject(node);
+
+        if (isNode) {
+            this.#enclosingNodes.add(node);
+        }
+
+        try {
+            return this.#validateNodeOfKind(node, pointer, contextAvailability);
+        } finally {
+            if (isNode) {
+                this.#enclosingNodes.delete(node);
+            }
+        }
+    }
+
+    /** Validates a node by its kind, within the nesting `#validateNode` holds it to. */
+    #validateNodeOfKind(node, pointer, contextAvailability) {
+        // A member that takes an argument is written as a call or an indexer, so an infix call is no node, and the message says which nodes take its place.
+        if (ObjectUtils.isNonArrayObject(node) && node.kind === 'infixCall') {
+            this.#fail('NEXO2000', 'An infixCall is not a node: a function is a call node, or an indexer node for a named or unnamed indexer', pointer);
+        }
+
+        if (!ObjectUtils.isNonArrayObject(node) || !Object.hasOwn(NODE_PROPERTIES, node.kind)) {
+            this.#fail('NEXO2000', 'A node is an object whose kind is literal, scriptParameter, it, root, namespace, local, memberAccess, call, indexerAccess, object, list, dictionary, optionalChain, equality, comparison, interpolatedString, body, do, function, arithmetic, arithmeticNegation, fromEndIndex, range, conditional, coalescing, not, cast, conversion, try, and or or', pointer);
+        }
+
+        this.#requireProperties(node, pointer, NODE_PROPERTIES[node.kind]);
+
+        const enclosingOptionalChain = this.#optionalChain;
+
+        // A chain continues through a property access's and an indexer's receiver, a call's member and an object expression's context alone, so any other node ends it.
+        if (!CHAIN_KINDS.has(node.kind)) {
+            this.#optionalChain = null;
+        }
+
+        try {
+            return this.#validateKind(node, pointer, contextAvailability);
+        } finally {
+            this.#optionalChain = enclosingOptionalChain;
+        }
+    }
+
+    #validateKind(node, pointer, contextAvailability) {
+        switch (node.kind) {
+            case 'literal':
+                return this.#validateLiteral(node, pointer);
+            case 'scriptParameter': {
+                if (!Names.isIdentifier(node.name)) {
+                    this.#fail('NEXO2000', 'A script parameter is named by a letter followed by letters and digits', `${pointer}/name`);
+                }
+
+                const parameter = Object.freeze({ kind: 'scriptParameter', name: node.name });
+
+                // A name a text wrote alone reads the local in scope of its name, so one before a later local of its name reads nothing; a script parameter written with `~` and a definition's parameter read the script parameter wherever they stand.
+                if (this.#parametersWrittenAloneInText?.has(node) === true) {
+                    this.#requireScriptParameterName(node.name, pointer);
+                    DefinitionValidator.#scriptParametersWrittenAlone.add(parameter);
+
+                    return parameter;
+                }
+
+                // A local, an object field, a conditional binding or a function parameter of its name in scope hides it, and so does a local or a conditional binding declared later in its scope, which a bare name there would read.
+                if (this.#localNames.has(node.name) || this.#laterNames.has(node.name)) {
+                    DefinitionValidator.#hiddenScriptParameters.add(parameter);
+                }
+
+                return parameter;
+            }
+            case 'root':
+                // The object root is a reference to the outermost object, which an object expression around the reference builds, lexically.
+                if (!this.#isInObjectExpression) {
+                    this.#fail('NEXO2018', "'root' refers to the outermost object being built, and no object expression encloses it here", pointer);
+                }
+
+                return Object.freeze({ kind: 'root' });
+            case 'it':
+                if (contextAvailability === ContextAvailability.absent) {
+                    this.#fail('NEXO2026', "'it' is the implicit parameter, and the top level has none; a chain there starts from a script parameter, root, a namespace's member, a local, a literal or another input", pointer);
+                }
+
+                return Object.freeze({ kind: 'it' });
+            case 'namespace':
+                this.#fail('NEXO2520', DefinitionValidator.#namespaceAloneMessageOf(node.name), pointer);
+                break;
+            case 'local':
+                this.#requireName(node.name, `${pointer}/name`);
+
+                // A local is read where one of its name, or a field, is in scope, which `@` and a reserved word name as a name written alone does any other.
+                if (!this.#localNames.has(node.name)) {
+                    this.#fail('NEXO2012', `No local, object field, conditional binding or function parameter named '${node.name}' is in scope. Use '~${node.name}' to read the script parameter.`, pointer);
+                }
+
+                return Object.freeze({ kind: 'local', name: node.name });
+            case 'memberAccess':
+            case 'indexerAccess':
+                return this.#validateMemberAccess(node, pointer, contextAvailability);
+            case 'call':
+                return this.#validateCall(node, pointer, contextAvailability);
+            case 'equality':
+                return Object.freeze({
+                    kind: 'equality',
+                    left: this.#validateNode(node.left, `${pointer}/left`, contextAvailability),
+                    right: this.#validateNode(node.right, `${pointer}/right`, contextAvailability),
+                });
+            case 'comparison':
+                return this.#validateComparison(node, pointer, contextAvailability);
+            case 'interpolatedString':
+                return this.#validateInterpolatedString(node, pointer, contextAvailability);
+            case 'list':
+                return this.#validateList(node, pointer, contextAvailability);
+            case 'dictionary':
+                return this.#validateDictionary(node, pointer, contextAvailability);
+            case 'arithmetic':
+                if (!ARITHMETIC_OPERATORS.includes(node.operator)) {
+                    this.#fail('NEXO2000', `An arithmetic operator is ${ARITHMETIC_OPERATORS.join(', ')}`, `${pointer}/operator`);
+                }
+
+                return Object.freeze({
+                    kind: 'arithmetic',
+                    operator: node.operator,
+                    left: this.#validateNode(node.left, `${pointer}/left`, contextAvailability),
+                    right: this.#validateNode(node.right, `${pointer}/right`, contextAvailability),
+                });
+            case 'arithmeticNegation': {
+                const operand = this.#validateNode(node.operand, `${pointer}/operand`, contextAvailability);
+
+                // A numeric literal negated is the negative literal, as text reads one, so a negation has one definition whatever wrote it.
+                if (operand.kind === 'literal' && typeof operand.value === 'number') {
+                    return Object.freeze({ kind: 'literal', value: -operand.value });
+                }
+
+                return Object.freeze({ kind: 'arithmeticNegation', operand });
+            }
+            case 'fromEndIndex':
+                return Object.freeze({ kind: 'fromEndIndex', offset: this.#validateNode(node.offset, `${pointer}/offset`, contextAvailability) });
+            case 'range': {
+                // A boundary the range leaves out is no property of its node.
+                const range = { kind: 'range' };
+
+                for (const boundary of ['start', 'end']) {
+                    if (node[boundary] !== undefined) {
+                        range[boundary] = this.#validateNode(node[boundary], `${pointer}/${boundary}`, contextAvailability);
+                    }
+                }
+
+                return Object.freeze(range);
+            }
+            case 'conditional':
+                return this.#validateConditional(node, pointer, contextAvailability);
+            case 'body':
+                this.#fail('NEXO2017', "A body is the root expression's, a do block's, a function's or a conditional branch's, and stands nowhere else", pointer);
+                break;
+            case 'do':
+                if (this.#simpleExpression !== null) {
+                    this.#fail('NEXO2011', `${this.#simpleExpression.subject} is a simple expression, which holds no do block: ${this.#simpleExpression.advice ?? "bind the block's value to a local first, and use the local"}`, pointer);
+                }
+
+                return Object.freeze({ kind: 'do', body: this.#validateBodyOrExpression(node.body, `${pointer}/body`, contextAvailability) });
+            case 'function':
+                this.#fail(node.arrow === true ? 'NEXO2027' : 'NEXO2004', node.arrow === true ? 'An arrow function is the value of a local or an argument, and stands nowhere else' : 'A function is the value of a local, as let name = function(…) … end, and stands nowhere else', pointer);
+                break;
+            case 'and':
+            case 'or':
+                return this.#validateLogical(node, pointer, contextAvailability);
+            case 'optionalChain':
+                return this.#validateOptionalChain(node, pointer, contextAvailability);
+            case 'not':
+                return Object.freeze({ kind: 'not', operand: this.#validateNode(node.operand, `${pointer}/operand`, contextAvailability) });
+            case 'cast':
+                return this.#validateCast(node, pointer, contextAvailability);
+            case 'conversion':
+                if (!DefinitionValidator.#isTypeName(node.type)) {
+                    this.#fail('NEXO2000', "A conversion names the type it converts to by its name, a letter followed by letters and digits, or by its module's name, a dot and its name", `${pointer}/type`);
+                }
+
+                return Object.freeze({ kind: 'conversion', type: node.type, operand: this.#validateNode(node.operand, `${pointer}/operand`, contextAvailability) });
+            case 'try':
+                if (!ATTEMPTED_KINDS.has(node.operand?.kind)) {
+                    this.#fail('NEXO2523', "What 'try' attempts is a conversion or a cast", `${pointer}/operand`);
+                }
+
+                return Object.freeze({ kind: 'try', operand: this.#validateNode(node.operand, `${pointer}/operand`, contextAvailability) });
+            case 'coalescing':
+                return Object.freeze({
+                    kind: 'coalescing',
+                    value: this.#validateNode(node.value, `${pointer}/value`, contextAvailability),
+                    fallback: this.#validateNode(node.fallback, `${pointer}/fallback`, contextAvailability),
+                });
+            default:
+                return this.#validateObjectExpression(node, pointer, contextAvailability);
+        }
+    }
+
+    /**
+     * Validates a conditional: a condition or a conditional binding, exactly one of them, its consequent and its alternative.
+     * A conditional binding's name is any name, which hides a local or a field of its name outside it, in scope in the consequent alone, never in its own value or the alternative.
+     */
+    #validateConditional(node, pointer, contextAvailability) {
+        if ((node.condition === undefined) === (node.binding === undefined)) {
+            this.#fail('NEXO2000', 'A conditional holds a condition or a conditional binding, one of them', pointer);
+        }
+
+        if (this.#simpleExpression !== null) {
+            return this.#validateSimpleConditional(node, pointer, contextAvailability);
+        }
+
+        // Every branch of one conditional is a body, whose `return` gives its result, or none is; an `elseif` continues its style, and the alternative of one whose branches are expressions may hold a conditional of either, as `else if … end` writes one.
+        const isExplicit = node.consequent?.kind === 'body';
+        const alternative = node.alternative;
+        const isConsistent = alternative?.kind === 'conditional' ? !isExplicit || alternative.consequent?.kind === 'body' : (alternative?.kind === 'body') === isExplicit;
+
+        if (!isConsistent) {
+            this.#fail('NEXO2524', 'All branches of this conditional must give their results with return, or none of them', pointer);
+        }
+
+        if (node.condition !== undefined) {
+            return Object.freeze({
+                kind: 'conditional',
+                condition: this.#validateNode(node.condition, `${pointer}/condition`, contextAvailability),
+                consequent: this.#validateBodyOrExpression(node.consequent, `${pointer}/consequent`, contextAvailability),
+                alternative: this.#validateBodyOrExpression(node.alternative, `${pointer}/alternative`, contextAvailability),
+            });
+        }
+
+        const bindingPointer = `${pointer}/binding`;
+
+        this.#requireProperties(node.binding, bindingPointer, ENTRY_PROPERTIES);
+        this.#requireName(node.binding.name, `${bindingPointer}/name`);
+
+        const { name } = node.binding;
+
+
+        const value = this.#validateWithLater([name], () => this.#validateNode(node.binding.value, `${bindingPointer}/value`, contextAvailability), 'conditionalBinding');
+
+        const enclosingLocalNames = this.#localNames;
+
+        this.#localNames = new Set(this.#localNames).add(name);
+
+        let consequent;
+
+        try {
+            consequent = this.#validateBodyOrExpression(node.consequent, `${pointer}/consequent`, contextAvailability);
+        } finally {
+            this.#localNames = enclosingLocalNames;
+        }
+
+        return Object.freeze({
+            kind: 'conditional',
+            binding: Object.freeze({ name, value }),
+            consequent,
+            alternative: this.#validateBodyOrExpression(node.alternative, `${pointer}/alternative`, contextAvailability),
+        });
+    }
+
+    /**
+     * Validates a conditional within a simple expression: a condition and two branches, each a simple value expression, so it binds no value, its branches give their values without `return` or locals,
+     * and it holds no other conditional, an `elseif` among them, through any path, a group, a call, an indexer or an interpolation included.
+     */
+    #validateSimpleConditional(node, pointer, contextAvailability) {
+        const simpleExpression = this.#simpleExpression;
+        const { subject } = simpleExpression;
+        const advice = simpleExpression.advice ?? "bind the conditional's value to a local first, and use the local";
+
+        if (simpleExpression.isInConditional) {
+            this.#fail('NEXO2011', `${subject} is a simple expression, whose conditional holds no other conditional, elseif included: ${advice}`, pointer);
+        }
+
+        if (node.binding !== undefined) {
+            this.#fail('NEXO2011', `${subject} is a simple expression, whose conditional tests a value and binds none: ${advice}`, `${pointer}/binding`);
+        }
+
+        for (const branch of ['consequent', 'alternative']) {
+            if (node[branch]?.kind === 'body') {
+                this.#fail('NEXO2011', `${subject} is a simple expression, whose conditional gives each branch's value without return or locals, as if … then … else … end does: ${advice}`, `${pointer}/${branch}`);
+            }
+        }
+
+        this.#simpleExpression = { ...simpleExpression, isInConditional: true };
+
+        try {
+            return Object.freeze({
+                kind: 'conditional',
+                condition: this.#validateNode(node.condition, `${pointer}/condition`, contextAvailability),
+                consequent: this.#validateNode(node.consequent, `${pointer}/consequent`, contextAvailability),
+                alternative: this.#validateNode(node.alternative, `${pointer}/alternative`, contextAvailability),
+            });
+        } finally {
+            this.#simpleExpression = simpleExpression;
+        }
+    }
+
+    /**
+     * Validates a simple expression the subject names: the node and everything within it, which hold no do block, no local, no conditional binding, no `return`, and no conditional beyond an if branch and an else branch of simple value expressions.
+     * A simple expression within another keeps the conditional that holds it, and the advice a refusal gives where a local cannot hold what it refuses, as within an arrow function's body.
+     */
+    #validateSimpleExpression(node, pointer, contextAvailability, subject, advice = undefined) {
+        const enclosingSimpleExpression = this.#simpleExpression;
+
+        this.#simpleExpression = { subject, isInConditional: enclosingSimpleExpression?.isInConditional ?? false, advice: advice ?? enclosingSimpleExpression?.advice };
+
+        try {
+            return this.#validateNode(node, pointer, contextAvailability);
+        } finally {
+            this.#simpleExpression = enclosingSimpleExpression;
+        }
+    }
+
+    /** Validates a list a collection expression writes: its items, a list, each a simple expression, which evaluates against the implicit parameter around it. */
+    #validateList(node, pointer, contextAvailability) {
+        this.#requireArray(node.items, `${pointer}/items`, "A list's items are a list of nodes, in order");
+
+        return Object.freeze({ kind: 'list', items: Object.freeze(node.items.map((item, index) => this.#validateSimpleExpression(item, `${pointer}/items/${index}`, contextAvailability, "A list's item"))) });
+    }
+
+    /**
+     * Validates a dictionary a collection expression writes: its entries, a list, each its key, a string, and its value, a simple expression, no two of one key, compared exactly, which its later entry is refused for
+     * (NEXO2043).
+     */
+    #validateDictionary(node, pointer, contextAvailability) {
+        this.#requireArray(node.entries, `${pointer}/entries`, "A dictionary's entries are a list, each its key and its value, in order");
+
+        const keys = new Set();
+        const entries = node.entries.map((entry, index) => {
+            const entryPointer = `${pointer}/entries/${index}`;
+
+            this.#requireProperties(entry, entryPointer, DICTIONARY_ENTRY_PROPERTIES);
+
+            if (typeof entry.key !== 'string') {
+                this.#fail('NEXO2000', "A dictionary entry's key is a string, which a collection expression writes as an inline string literal", `${entryPointer}/key`);
+            }
+
+            this.#requireWellFormed(entry.key, `${entryPointer}/key`);
+
+            if (keys.has(entry.key)) {
+                this.#fail('NEXO2043', `A dictionary holds each key once, and ${JSON.stringify(entry.key)} is the key of an entry before this one`, entryPointer);
+            }
+
+            keys.add(entry.key);
+
+            return Object.freeze({ key: entry.key, value: this.#validateSimpleExpression(entry.value, `${entryPointer}/value`, contextAvailability, "A dictionary's value") });
+        });
+
+        return Object.freeze({ kind: 'dictionary', entries: Object.freeze(entries) });
+    }
+
+    /** Whether the name is a type's as a cast or a conversion writes it: its local name, or its module's name, a dot and its local name, each an identifier. */
+    static #isTypeName(name) {
+        return typeof name === 'string' && name.split('.').length <= 2 && name.split('.').every(part => Names.isIdentifier(part));
+    }
+
+    /** Validates a cast: the name of the type it casts to, and its operand, which is a receiver and its accesses, a coalescing operator, another cast, or an optional chain, as text can write one. */
+    #validateCast(node, pointer, contextAvailability) {
+        if (!DefinitionValidator.#isTypeName(node.type)) {
+            this.#fail('NEXO2000', "A cast names the type it casts to by its name, a letter followed by letters and digits, or by its module's name, a dot and its name", `${pointer}/type`);
+        }
+
+        const operand = this.#validateNode(node.operand, `${pointer}/operand`, contextAvailability);
+
+        if (!DefinitionValidator.#isCastOperand(operand)) {
+            this.#fail('NEXO2002', "A cast's operand is a receiver and the members after it, a coalescing operator in parentheses, or an optional enclosed access", `${pointer}/operand`);
+        }
+
+        return Object.freeze({ kind: 'cast', type: node.type, operand });
+    }
+
+    /**
+     * Whether the node is a cast's operand as text writes one: a coalescing operator or a cast, each grouped as it is, or a receiver and the accesses after it, an optional chain of them included,
+     * the receiver an input or a grouped cast, so every operand a definition gives is written as text that parses.
+     */
+    static #isCastOperand(node) {
+        if (node.kind === 'coalescing' || node.kind === 'cast') {
+            return true;
+        }
+
+        let receiver = node.kind === 'optionalChain' ? node.chain : node;
+
+        for (;;) {
+            if (receiver.kind === 'memberAccess' || receiver.kind === 'indexerAccess') {
+                receiver = receiver.receiver;
+            } else if (receiver.kind === 'call' && receiver.callee.kind === 'memberAccess') {
+                receiver = receiver.callee.receiver;
+            } else {
+                break;
+            }
+        }
+
+        // A negative number is a negation in text, which only parentheses make a receiver, and a cast's receiver is never a group.
+        const isNegativeNumber = receiver.kind === 'literal' && typeof receiver.value === 'number' && (receiver.value < 0 || Object.is(receiver.value, -0));
+
+        return CAST_RECEIVER_KINDS.has(receiver.kind) && !(receiver.kind === 'object' && receiver.context !== undefined) && !isNegativeNumber;
+    }
+
+    /** Validates an optional chain: the chain whose optional accesses end at it, at least one of them, since a chain with none is the chain alone. */
+    #validateOptionalChain(node, pointer, contextAvailability) {
+        const optionalChain = { hasOptional: false };
+
+        this.#optionalChain = optionalChain;
+
+        const chain = this.#validateNode(node.chain, `${pointer}/chain`, contextAvailability);
+
+        if (!optionalChain.hasOptional) {
+            this.#fail('NEXO2030', 'An optional chain holds a chain with an optional access, written ?.', pointer);
+        }
+
+        return Object.freeze({ kind: 'optionalChain', chain });
+    }
+
+    /** Validates an and or an or: two or more expressions it combines, each with the implicit parameter the and or the or has. */
+    #validateLogical(node, pointer, contextAvailability) {
+        this.#requireArray(node.operands, `${pointer}/operands`);
+
+        if (node.operands.length < 2) {
+            this.#fail('NEXO2525', `An ${node.kind} combines two or more expressions`, `${pointer}/operands`);
+        }
+
+        return Object.freeze({ kind: node.kind, operands: Object.freeze(node.operands.map((operand, index) => this.#validateNode(operand, `${pointer}/operands/${index}`, contextAvailability))) });
+    }
+
+    /** Validates a comparison: two or more operands, each with the implicit parameter the comparison has, and between each two of them a comparison operator, every one pointing one way. */
+    #validateComparison(node, pointer, contextAvailability) {
+        this.#requireArray(node.operands, `${pointer}/operands`);
+
+        if (node.operands.length < 2) {
+            this.#fail('NEXO2029', 'A comparison compares two or more expressions', `${pointer}/operands`);
+        }
+
+        this.#requireArray(node.operators, `${pointer}/operators`);
+
+        if (node.operators.length !== node.operands.length - 1) {
+            this.#fail('NEXO2526', 'A comparison has an operator between each two of its operands, one fewer than they are', `${pointer}/operators`);
+        }
+
+        node.operators.forEach((operator, index) => {
+            if (!Object.hasOwn(COMPARISON_DIRECTIONS, operator)) {
+                this.#fail('NEXO2000', 'A comparison operator is <, <=, > or >=', `${pointer}/operators/${index}`);
+            }
+
+            if (COMPARISON_DIRECTIONS[operator] !== COMPARISON_DIRECTIONS[node.operators[0]]) {
+                this.#fail('NEXO2001', 'A comparison chain keeps one direction: its operators are all < and <=, or all > and >=', `${pointer}/operators/${index}`);
+            }
+        });
+
+        return Object.freeze({
+            kind: 'comparison',
+            operands: Object.freeze(node.operands.map((operand, index) => this.#validateNode(operand, `${pointer}/operands/${index}`, contextAvailability))),
+            operators: Object.freeze([...node.operators]),
+        });
+    }
+
+    /**
+     * Validates an interpolated string: its parts, each text, a string, or an expression, which has the implicit parameter the string has.
+     * Adjacent text is one part and empty text none, so a string written in text and its definition hold the same parts; where that moves a part, it records the index each part had, which `validate` keeps for the definition.
+     */
+    #validateInterpolatedString(node, pointer, contextAvailability) {
+        this.#requireArray(node.parts, `${pointer}/parts`);
+
+        const parts = [];
+        const indexes = [];
+
+        node.parts.forEach((part, index) => {
+            const partPointer = `${pointer}/parts/${index}`;
+
+            if (!ObjectUtils.isNonArrayObject(part) || !Object.hasOwn(INTERPOLATION_PARTS, part.kind)) {
+                this.#fail('NEXO2000', 'A part of an interpolated string is an object whose kind is text or expression', partPointer);
+            }
+
+            this.#requireProperties(part, partPointer, INTERPOLATION_PARTS[part.kind]);
+
+            if (part.kind === 'expression') {
+                parts.push(Object.freeze({ kind: 'expression', expression: this.#validateSimpleExpression(part.expression, `${partPointer}/expression`, contextAvailability, "An interpolation's expression") }));
+                indexes.push(index);
+
+                return;
+            }
+
+            if (typeof part.value !== 'string') {
+                this.#fail('NEXO2000', 'The text of an interpolated string is a string', `${partPointer}/value`);
+            }
+
+            this.#requireWellFormed(part.value, `${partPointer}/value`);
+
+            if (part.value === '') {
+                return;
+            }
+
+            const previous = parts.at(-1);
+
+            if (previous?.kind === 'text') {
+                parts[parts.length - 1] = Object.freeze({ kind: 'text', value: previous.value + part.value });
+            } else {
+                parts.push(Object.freeze({ kind: 'text', value: part.value }));
+                indexes.push(index);
+            }
+        });
+
+        const validated = Object.freeze({ kind: 'interpolatedString', parts: Object.freeze(parts) });
+
+        // A part joined into the text before it, or empty and dropped, moves each after it, which a diagnostic still names by the index the caller gave it.
+        if (indexes.some((original, index) => original !== index)) {
+            this.#partIndexes.set(validated, indexes);
+            this.#hasMovedParts = true;
+        }
+
+        return validated;
+    }
+
+    /** Validates what a body stands for, the root expression's, a do block's, a function's or a conditional branch's: a body, or the expression alone it is. */
+    #validateBodyOrExpression(node, pointer, contextAvailability) {
+        return ObjectUtils.isNonArrayObject(node) && node.kind === 'body' ? this.#validateBody(node, pointer, contextAvailability) : this.#validateNode(node, pointer, contextAvailability);
+    }
+
+    /**
+     * Validates a body: its locals, each with its name and value, in scope after its value, through the locals after it and the result, and seen by no value before it, and its result, each with the implicit parameter the body has.
+     * A body's local may reuse a name an enclosing scope has, which it hides, and two of one body never share one.
+     */
+    #validateBody(node, pointer, contextAvailability) {
+        this.#requireProperties(node, pointer, NODE_PROPERTIES.body);
+        this.#requireArray(node.locals, `${pointer}/locals`);
+
+        const names = node.locals.map(local => local?.name);
+        const enclosingLocalNames = this.#localNames;
+        const enclosingOptionalChain = this.#optionalChain;
+        const declared = new Set();
+
+        // A body's locals and its result continue no chain of what holds it.
+        this.#optionalChain = null;
+
+        try {
+            const locals = node.locals.map((local, index) => {
+                const localPointer = `${pointer}/locals/${index}`;
+
+                this.#requireProperties(local, localPointer, ENTRY_PROPERTIES);
+                this.#requireName(local.name, `${localPointer}/name`);
+
+                if (declared.has(local.name)) {
+                    this.#fail('NEXO2015', `Two locals of one body are named '${local.name}'`, localPointer);
+                }
+
+                declared.add(local.name);
+
+                const value = this.#validateWithLater(names.slice(index), () => this.#validateLocalValue(local.value, `${localPointer}/value`, contextAvailability));
+
+                this.#localNames = new Set(this.#localNames).add(local.name);
+
+                return Object.freeze({ name: local.name, value });
+            });
+
+            return Object.freeze({ kind: 'body', locals: Object.freeze(locals), result: this.#validateNode(node.result, `${pointer}/result`, contextAvailability) });
+        } finally {
+            this.#localNames = enclosingLocalNames;
+            this.#optionalChain = enclosingOptionalChain;
+        }
+    }
+
+    /** Validates a local's value, which a function may be, as no other node's is. */
+    #validateLocalValue(value, pointer, contextAvailability) {
+        return value?.kind === 'function' ? this.#validateFunction(value, pointer, contextAvailability) : this.#validateNode(value, pointer, contextAvailability);
+    }
+
+    /**
+     * Validates a function: its parameters, each a name of its own, and its body, which sees them and the locals in scope where the function is declared, with the implicit parameter it has there.
+     * Its own local and those declared after it stay later names in its body, so it calls neither directly. An arrow function's body is one simple expression, which declares no locals.
+     */
+    #validateFunction(node, pointer, contextAvailability) {
+        this.#requireProperties(node, pointer, NODE_PROPERTIES.function);
+        this.#requireArray(node.parameters, `${pointer}/parameters`);
+
+        if (node.arrow !== undefined && node.arrow !== true) {
+            this.#fail('NEXO2000', 'An arrow function is marked by arrow: true, and a regular function leaves it out', `${pointer}/arrow`);
+        }
+
+        const seen = new Set();
+
+        node.parameters.forEach((parameter, index) => {
+            const parameterPointer = `${pointer}/parameters/${index}`;
+
+            this.#requireName(parameter, parameterPointer);
+
+            if (seen.has(parameter)) {
+                this.#fail('NEXO2032', `Two parameters of one function are named '${parameter}'`, parameterPointer);
+            }
+
+            seen.add(parameter);
+        });
+
+        const enclosingLocalNames = this.#localNames;
+        const enclosingLaterNames = this.#laterNames;
+        const enclosingOptionalChain = this.#optionalChain;
+
+        // Its parameters are declared in its own scope, so in its body each hides a local of its name declared later around it.
+        this.#localNames = new Set([...this.#localNames, ...node.parameters]);
+        this.#laterNames = new Map([...this.#laterNames].filter(([name]) => !node.parameters.includes(name)));
+        this.#optionalChain = null;
+
+        try {
+            if (node.arrow !== true) {
+                return Object.freeze({ kind: 'function', parameters: Object.freeze([...node.parameters]), body: this.#validateBodyOrExpression(node.body, `${pointer}/body`, contextAvailability) });
+            }
+
+            if (node.body?.kind === 'body' || node.body?.kind === 'function') {
+                this.#fail('NEXO2006', "An arrow function's body is a simple expression, which gives its result: a function that holds more is a regular function bound to a local, passed by its name", `${pointer}/body`);
+            }
+
+            return Object.freeze({ kind: 'function', parameters: Object.freeze([...node.parameters]), body: this.#validateSimpleExpression(node.body, `${pointer}/body`, contextAvailability, "An arrow function's body", 'a function that holds more is a regular function bound to a local, passed by its name'), arrow: true });
+        } finally {
+            this.#localNames = enclosingLocalNames;
+            this.#laterNames = enclosingLaterNames;
+            this.#optionalChain = enclosingOptionalChain;
+        }
+    }
+
+    /**
+     * Validates a call: its callee, the member it calls, a property access named after its dot, whose receiver continues the chain, or the local, the function parameter or the conditional binding holding the function it
+     * calls, which no function calls before the local of that name is declared, itself included; and its arguments, which continue no chain.
+     */
+    #validateCall(node, pointer, contextAvailability) {
+        const { callee } = node;
+        const calleePointer = `${pointer}/callee`;
+
+        if (!ObjectUtils.isNonArrayObject(callee) || (callee.kind !== 'memberAccess' && callee.kind !== 'local')) {
+            this.#fail('NEXO2000', "A call's callee is a memberAccess node, the member it calls, or a local node, the name holding the function it calls", calleePointer);
+        }
+
+        let validatedCallee;
+
+        if (callee.kind === 'local') {
+            this.#requireProperties(callee, calleePointer, NODE_PROPERTIES.local);
+            this.#requireName(callee.name, `${calleePointer}/name`);
+
+            if (this.#laterNames.has(callee.name)) {
+                this.#fail('NEXO2016', `'${callee.name}' is called before the local of that name is declared in its scope, so no function calls itself or one declared after it`, pointer);
+            }
+
+            validatedCallee = Object.freeze({ kind: 'local', name: callee.name });
+        } else {
+            this.#requireProperties(callee, calleePointer, NODE_PROPERTIES.memberAccess);
+
+            if (typeof callee.name !== 'string') {
+                this.#fail('NEXO2000', 'A call names the member it calls after its dot, a letter followed by letters and digits', `${calleePointer}/name`);
+            }
+
+            validatedCallee = this.#validateMemberAccess(callee, calleePointer, contextAvailability);
+        }
+
+        this.#optionalChain = null;
+
+        // Whether an argument has an implicit parameter is the function's to say, a reference's as its qualified form's member does, which only resolution knows, so an `it` there is resolution's to refuse.
+        return Object.freeze({ kind: 'call', callee: validatedCallee, arguments: this.#validateArguments(node.arguments, `${pointer}/arguments`, ContextAvailability.unknown) });
+    }
+
+    /** Validates a call's arguments, each a simple expression or an arrow function; a regular function is bound to a local and passed by its name. */
+    #validateArguments(argumentNodes, pointer, contextAvailability) {
+        this.#requireArray(argumentNodes, pointer);
+
+        return Object.freeze(argumentNodes.map((argument, index) => {
+            const argumentPointer = `${pointer}/${index}`;
+
+            if (argument?.kind !== 'function') {
+                return this.#validateSimpleExpression(argument, argumentPointer, contextAvailability, 'An argument');
+            }
+
+            if (argument.arrow !== true) {
+                this.#fail('NEXO2005', "A function declared with 'function' cannot appear directly as an argument. Bind it to a local and pass its name, or use an arrow function.", argumentPointer);
+            }
+
+            return this.#validateFunction(argument, argumentPointer, contextAvailability);
+        }));
+    }
+
+    /** Refuses a conditional or a body as the receiver of a chain, or the context an object expression follows, whose value a local holds first. */
+    #refuseBlockReceiver(receiver, pointer) {
+        if (receiver?.kind === 'conditional' || receiver?.kind === 'do') {
+            this.#fail('NEXO2003', `${receiver.kind === 'do' ? 'A do block' : 'A conditional'} is never the receiver of a chain: bind its value to a local first, and continue from the local`, pointer);
+        }
+    }
+
+    #validateLiteral(node, pointer) {
+        const { value } = node;
+
+        if (value !== null && typeof value !== 'string' && typeof value !== 'boolean' && !Number.isFinite(value)) {
+            this.#fail(typeof value === 'number' ? 'NEXO2019' : 'NEXO2000', 'A literal is a string, a finite number, a Boolean or null', `${pointer}/value`);
+        }
+
+        if (typeof value === 'string') {
+            this.#requireWellFormed(value, `${pointer}/value`);
+        }
+
+        return Object.freeze({ kind: 'literal', value });
+    }
+
+    /** Refuses a string a definition holds that holds a surrogate standing alone, which no text writes, so that every string a script holds is text a host's text and canonical text hold alike. */
+    #requireWellFormed(value, pointer) {
+        if (LONE_SURROGATE.test(value)) {
+            this.#fail('NEXO2000', 'A string a definition holds is well-formed text, and this one holds a surrogate standing alone', pointer);
+        }
+    }
+
+    /**
+     * Validates a property access, a call's member or an indexer: its name, its receiver, whether it is optional, which it is within an optional chain alone, the extension it selects explicitly, and an indexer's key, a simple
+     * expression whose implicit parameter its declaration decides.
+     */
+    #validateMemberAccess(node, pointer, contextAvailability) {
+        this.#refuseBlockReceiver(node.receiver, `${pointer}/receiver`);
+
+        const name = node.kind === 'memberAccess' && ObjectUtils.isNonArrayObject(node.name) ? this.#validateNameExpression(node.name, `${pointer}/name`, contextAvailability) : node.name;
+
+        // A name a computed property access's expression gave is checked as that expression, and an indexer has none; any other is a member's name, which any word can be, a reserved word among them.
+        if (name === node.name && node.kind !== 'indexerAccess' && !Names.isIdentifier(name)) {
+            this.#fail('NEXO2000', 'A member is named by a letter followed by letters and digits', `${pointer}/name`);
+        }
+
+        if (node.optional !== undefined) {
+            if (node.optional !== true) {
+                this.#fail('NEXO2000', 'An optional access holds optional: true, and a required one leaves it out', `${pointer}/optional`);
+            }
+
+            if (this.#optionalChain === null) {
+                this.#fail('NEXO2010', 'An optional access stands within an optional chain, which ends where a null receiver ends it', pointer);
+            }
+
+            this.#optionalChain.hasOptional = true;
+        }
+
+        this.#validateExtensionAccess(node, pointer);
+
+        const receiver = node.receiver?.kind === 'namespace' ? this.#validateNamespace(node, pointer) : this.#validateNode(node.receiver, `${pointer}/receiver`, contextAvailability);
+        const marks = { ...(node.extension === true ? { extension: true } : {}), ...(node.continues === true ? { continues: true } : {}) };
+        const access = Object.freeze({ kind: node.kind, receiver, ...(name === undefined ? {} : { name }), ...(node.optional === true ? { optional: true } : {}), ...marks });
+
+        if (node.kind === 'memberAccess') {
+            return access;
+        }
+
+        this.#optionalChain = null;
+
+        return Object.freeze({ ...access, argument: this.#validateSimpleExpression(node.argument, `${pointer}/argument`, ContextAvailability.unknown, "An indexer's key") });
+    }
+
+    /**
+     * Validates the marks of an extension access's names: `extension`, true on its first name, which the colon is written before, and `continues`, true on each later one, which a dot joins to the one before it, its
+     * receiver, a name of the access, so neither is optional, both being written by name, and no name is both. A computed property access is no name of one, since it reads a property by a name it computes.
+     */
+    #validateExtensionAccess(node, pointer) {
+        if (node.extension !== undefined && node.extension !== true) {
+            this.#fail('NEXO2000', "An extension access's first name holds extension: true", `${pointer}/extension`);
+        }
+
+        if (node.continues !== undefined && node.continues !== true) {
+            this.#fail('NEXO2000', "A name continuing an extension access holds continues: true", `${pointer}/continues`);
+        }
+
+        if (node.extension === undefined && node.continues === undefined) {
+            return;
+        }
+
+        if (node.kind !== 'memberAccess' || typeof node.name !== 'string') {
+            this.#fail('NEXO2000', "An extension access's names are written names, never a computed property access's", pointer);
+        }
+
+        if (node.continues === true) {
+            const { receiver } = node;
+
+            if (node.extension === true || node.optional === true || receiver?.kind !== 'memberAccess' || (receiver.extension !== true && receiver.continues !== true)) {
+                this.#fail('NEXO2000', "A name continuing an extension access follows one of its names after a dot, and is neither optional nor its first", `${pointer}/continues`);
+            }
+        }
+    }
+
+    /** Refuses a namespace's or an extension's module named by a local name the definition's imports give no module (NEXO2028). */
+    #requireImportedNamespace(name, pointer) {
+        if (!this.#namespaceNames.has(name)) {
+            this.#fail('NEXO2028', `'${name}' names a module no import of the definition gives that local name`, pointer);
+        }
+    }
+
+    /**
+     * The message refusing a namespace that stands alone, where a value stands: a module's namespace is read through, never a value, and the forms that read the script parameter and the local of its name are given, since
+     * `@Home` reads the import binding only where no local of its name is in scope.
+     */
+    static #namespaceAloneMessageOf(name) {
+        const shown = typeof name === 'string' && Names.isIdentifier(name) ? name : 'Home';
+
+        return `'${shown}' is the namespace of the module the script imports under that name, the receiver of a member read or called through it, as ${shown}.member, and stands nowhere else; write '~${shown}' for the script parameter of that name, or declare a local of that name for '@${shown}' to read`;
+    }
+
+    /**
+     * Validates the namespace a member read or called stands on: a local name the definition's imports give a module (NEXO2028), through which a member is named by a dot, never optional, since a namespace is never null,
+     * and never through brackets or an indexer, which no namespace has. Which modules a registry holds is the registry's to check.
+     */
+    #validateNamespace(node, pointer) {
+        const namespace = node.receiver;
+        const namespacePointer = `${pointer}/receiver`;
+
+        this.#requireProperties(namespace, namespacePointer, NODE_PROPERTIES.namespace);
+        this.#requireName(namespace.name, `${namespacePointer}/name`);
+        this.#requireImportedNamespace(namespace.name, namespacePointer);
+
+        if (node.kind === 'indexerAccess') {
+            this.#fail('NEXO2520', 'No indexer is written through a namespace, which has none', pointer);
+        }
+
+        if (typeof node.name !== 'string') {
+            this.#fail('NEXO2521', `A member is read through the namespace '${namespace.name}' by the name it is declared by, and by no computed name`, `${pointer}/name`);
+        }
+
+        if (node.optional === true) {
+            this.#fail('NEXO2522', "A namespace is never null, so a member is read through it after '.', and never optionally", `${pointer}/optional`);
+        }
+
+        if (node.extension === true || node.continues === true) {
+            this.#fail('NEXO2520', "No extension extends a namespace, whose members are read after '.', as Home.member", pointer);
+        }
+
+        return Object.freeze({ kind: 'namespace', name: namespace.name });
+    }
+
+    /** Validates the expression a computed property access holds, which continues no chain; a string literal that is a name is the name itself, as `.` writes it, so an access has one definition. */
+    #validateNameExpression(node, pointer, contextAvailability) {
+        const enclosingOptionalChain = this.#optionalChain;
+
+        this.#optionalChain = null;
+
+        try {
+            const expression = this.#validateSimpleExpression(node, pointer, contextAvailability, 'The name a computed property access reads');
+
+            return expression.kind === 'literal' && Names.isIdentifier(expression.value) ? expression.value : expression;
+        } finally {
+            this.#optionalChain = enclosingOptionalChain;
+        }
+    }
+
+    /**
+     * Validates an object expression and answers it in canonical form: the context it follows, never a block, validated outside it; its locals, against the implicit parameter, which the context supplies and the enclosing
+     * one otherwise, none within a simple expression; and its object fields, at least one, each a name and a value, no two of one name, each in scope for the fields after it and hiding a local or a field of its name outside
+     * it. Its entries continue no chain of the context, and are validated within the outermost object; the names in scope and whether an object expression encloses them are restored after it.
+     */
+    #validateObjectExpression(node, pointer, contextAvailability) {
+        this.#refuseBlockReceiver(node.context, `${pointer}/context`);
+
+        const context = node.context === undefined ? undefined : this.#validateNode(node.context, `${pointer}/context`, contextAvailability);
+
+        this.#requireArray(node.objectFields, `${pointer}/objectFields`);
+
+        if (node.objectFields.length === 0) {
+            this.#fail('NEXO2009', 'An object expression names at least one object field', pointer);
+        }
+
+        const fieldContextAvailability = context === undefined ? contextAvailability : ContextAvailability.present;
+        const enclosingLocalNames = this.#localNames;
+        const wasInObjectExpression = this.#isInObjectExpression;
+
+        // An object expression's entries continue no chain of the one it follows, and are built within the outermost object.
+        this.#optionalChain = null;
+        this.#isInObjectExpression = true;
+
+        try {
+            if (node.locals !== undefined && this.#simpleExpression !== null) {
+                this.#fail('NEXO2527', `${this.#simpleExpression.subject} is a simple expression, whose object expressions hold no locals: ${this.#simpleExpression.advice ?? 'bind each value to a local before the expression, and use the local'}`, `${pointer}/locals/0`);
+            }
+
+            const locals = node.locals === undefined ? [] : this.#validateLocals(node.locals, `${pointer}/locals`, fieldContextAvailability);
+
+            /** @type {Set<string>} */
+            const names = new Set();
+
+            const objectFields = node.objectFields.map((field, index) => {
+                const fieldPointer = `${pointer}/objectFields/${index}`;
+                this.#requireProperties(field, fieldPointer, ENTRY_PROPERTIES);
+                this.#requireName(field.name, `${fieldPointer}/name`);
+
+                const value = this.#validateNode(field.value, `${fieldPointer}/value`, fieldContextAvailability);
+                const { name } = field;
+
+                if (names.has(name)) {
+                    this.#fail('NEXO2031', `Two fields of one object expression are named '${name}'`, fieldPointer);
+                }
+
+                // A field is in scope after its value, through the fields after it, hiding a local or a field of its name outside it.
+                names.add(name);
+                this.#localNames = new Set(this.#localNames).add(name);
+
+                return Object.freeze({ name, value });
+            });
+
+            return Object.freeze({
+                kind: 'object',
+                ...(context === undefined ? {} : { context }),
+                ...(locals.length === 0 ? {} : { locals: Object.freeze(locals) }),
+                objectFields: Object.freeze(objectFields),
+            });
+        } finally {
+            this.#localNames = enclosingLocalNames;
+            this.#isInObjectExpression = wasInObjectExpression;
+        }
+    }
+
+    /** Validates an object expression's locals in order, each seeing those before it, and leaves every one in scope for its fields; a local may hide one of its name outside its object expression, and two of one never share a name. */
+    #validateLocals(locals, pointer, contextAvailability) {
+        this.#requireArray(locals, pointer);
+
+        const names = locals.map(local => local?.name);
+        const declared = new Set();
+
+        return locals.map((local, index) => {
+            const localPointer = `${pointer}/${index}`;
+            this.#requireProperties(local, localPointer, ENTRY_PROPERTIES);
+            this.#requireName(local.name, `${localPointer}/name`);
+
+            // A local's value and the locals before it see neither it nor the locals after it, whose names no parameter there reads.
+            const value = this.#validateWithLater(names.slice(index), () => this.#validateLocalValue(local.value, `${localPointer}/value`, contextAvailability));
+            const { name } = local;
+
+            if (declared.has(name)) {
+                this.#fail('NEXO2015', `Two locals of one object expression are named '${name}'`, localPointer);
+            }
+
+            declared.add(name);
+            this.#localNames = new Set(this.#localNames).add(name);
+
+            return Object.freeze({ name, value });
+        });
+    }
+
+    /** What validating answers, with the names given declared later in its scope besides those already, by a local or, for a conditional binding's name, by the conditional binding. */
+    #validateWithLater(names, validate, declaredBy = 'local') {
+        const enclosingLaterNames = this.#laterNames;
+
+        this.#laterNames = new Map([...this.#laterNames, ...names.map(name => [name, declaredBy])]);
+
+        try {
+            return validate();
+        } finally {
+            this.#laterNames = enclosingLaterNames;
+        }
+    }
+
+    /**
+     * Refuses a script parameter a text wrote as a bare name where that name cannot denote one: one named as a local or a field in scope where it stands, which the name reads there instead, and one named as a local declared
+     * later in its scope, the local whose value it is among them, which a name reads only after its declaration and never as a binding of that name before it. It is not the general check of an identifier, and a parameter
+     * written with `~` follows its own rules.
+     */
+    #requireScriptParameterName(name, pointer) {
+        if (this.#localNames.has(name)) {
+            this.#fail('NEXO2528', `'${name}' names the local or field in scope here, so no binding of that name is read where it is`, pointer);
+        }
+
+        if (this.#laterNames.has(name)) {
+            this.#fail(this.#laterNames.get(name) === 'conditionalBinding' ? 'NEXO2014' : 'NEXO2013', `'${name}' is used before the local of that name is declared in its scope: a local is read after its declaration, and the name reads no binding before it`, pointer);
+        }
+    }
+
+    #requireProperties(part, pointer, { properties, required }) {
+        if (!ObjectUtils.isNonArrayObject(part)) {
+            this.#fail('NEXO2000', 'This part of a definition is an object', pointer);
+        }
+
+        for (const key of Object.keys(part)) {
+            if (!properties.includes(key)) {
+                this.#fail('NEXO2000', `'${key}' is no property of this part of a definition`, pointer);
+            }
+        }
+
+        for (const key of required) {
+            if (!Object.hasOwn(part, key)) {
+                this.#fail('NEXO2000', `This part of a definition requires '${key}'`, pointer);
+            }
+        }
+    }
+
+    /** Refuses what is no array, with the message given, and an array with no entry at an index, since a definition's arrays hold one at each, at the first index missing. */
+    #requireArray(value, pointer, message = 'This part of a definition is an array') {
+        if (!Array.isArray(value)) {
+            this.#fail('NEXO2000', message, pointer);
+        }
+
+        const hole = ArrayUtils.findMissingIndex(value);
+
+        if (hole !== -1) {
+            this.#fail('NEXO2000', 'This part of a definition is an array with an entry at every index', `${pointer}/${hole}`);
+        }
+    }
+
+    #requireName(value, pointer) {
+        if (!Names.isIdentifier(value)) {
+            this.#fail('NEXO2000', 'A name is a letter followed by letters and digits', pointer);
+        }
+    }
+
+    /** Refuses the definition with a structure error of the code and the message, located at the source of the pointer. */
+    #fail(code, message, pointer) {
+        throw NexoErrors.structure(code, message, this.#locations?.locate(pointer) ?? { pointer });
+    }
+}