@cynodia/axiom-core 0.4.0-alpha.1 → 0.4.1-alpha.1

package/dist/derive-edges.js

@@ -1,4 +1,4 @@
-import { expressionFieldIds, walkExpression } from './expressions.js';
+import { constructedFieldIds, expressionFieldIds, walkExpression } from './expressions.js';
 import { locationExpressions, locationFieldIds, locationRootStateId, locationSelectorFieldIds, } from './location.js';
 import { isUINode } from './ui.js';
 /** Ids a `ref` expression mentions anywhere in the tree. */
@@ -42,6 +42,19 @@ export function deriveEdges(nodes) {
             rootScope.set(node.id, statesOf(node.source, new Map(), states));
         }
     }
+    // Which states can hold instances of an entity, including nested ones. An entity-scoped
+    // constraint reads its fields wherever those instances actually live.
+    const entities = new Map(nodes.filter((node) => node.kind === 'entity').map((node) => [node.id, node]));
+    const statesByEntity = new Map();
+    for (const node of nodes) {
+        if (node.kind !== 'state' || node.draft || node.derivation) {
+            continue;
+        }
+        for (const entityId of reachableEntities(node.valueType, entities)) {
+            statesByEntity.set(entityId, [...(statesByEntity.get(entityId) ?? []), node.id]);
+        }
+    }
+    const entityScope = (entityId) => new Map([...rootScope, [entityId, statesByEntity.get(entityId) ?? []]]);
     const link = (from, to, kind, fieldIds = []) => {
         if (from === to || !known.has(from) || !known.has(to)) {
             return;
@@ -92,8 +105,14 @@ export function deriveEdges(nodes) {
                 if (node.entityId) {
                     link(node.id, node.entityId, 'constrains', expressionFieldIds(node.expression));
                 }
-                reads(node.id, node.expression, rootScope);
+                reads(node.id, node.expression, node.entityId ? entityScope(node.entityId) : rootScope);
+                break;
+            case 'transition-constraint': {
+                link(node.id, node.entityId, 'constrains', expressionFieldIds(node.expression));
+                const holders = statesByEntity.get(node.entityId) ?? [];
+                reads(node.id, node.expression, new Map([...rootScope, [node.previousScopeId, holders], [node.proposedScopeId, holders]]));
                 break;
+            }
             case 'route':
                 link(node.id, node.viewId, 'routes-to');
                 break;
@@ -111,7 +130,11 @@ export function deriveEdges(nodes) {
         },
     }));
 }
-/** The states an expression ultimately draws its members from. */
+/**
+ * The states an expression ultimately draws its members from. Following `field` and calls
+ * matters: a collection reached as `coalesce(field(ref(state), lines), [])` still comes
+ * from that state, and its members' fields are still reads of it.
+ */
 function statesOf(expression, scope, states) {
     switch (expression.kind) {
         case 'ref': {
@@ -125,11 +148,38 @@ function statesOf(expression, scope, states) {
         case 'find':
         case 'sort':
         case 'map':
+        case 'flatten':
+            return statesOf(expression.source, scope, states);
+        case 'conditional':
+            return [
+                ...new Set([
+                    ...statesOf(expression.whenTrue, scope, states),
+                    ...statesOf(expression.whenFalse, scope, states),
+                ]),
+            ];
+        case 'field':
             return statesOf(expression.source, scope, states);
+        case 'call':
+            return [...new Set(expression.arguments.flatMap((argument) => statesOf(argument, scope, states)))];
         default:
             return [];
     }
 }
+/** Entities reachable from a type, following entity fields as well as collections. */
+function reachableEntities(type, entities, seen = new Set()) {
+    const found = [];
+    for (const entityId of entityIdsIn(type)) {
+        if (seen.has(entityId)) {
+            continue;
+        }
+        seen.add(entityId);
+        found.push(entityId);
+        for (const field of entities.get(entityId)?.fields ?? []) {
+            found.push(...reachableEntities(field.valueType, entities, seen));
+        }
+    }
+    return found;
+}
 function bind(scope, id, targets) {
     const next = new Map(scope);
     next.set(id, targets);
@@ -180,7 +230,9 @@ function collectReads(expression, scope, states, found = new Map()) {
         case 'filter':
         case 'find':
         case 'map':
-        case 'sort': {
+        case 'sort':
+        case 'every':
+        case 'some': {
             collectReads(expression.source, scope, states, found);
             const inner = bind(scope, expression.scopeId, statesOf(expression.source, scope, states));
             const body = expression.kind === 'map'
@@ -191,6 +243,14 @@ function collectReads(expression, scope, states, found = new Map()) {
             collectReads(body, inner, states, found);
             return found;
         }
+        case 'flatten':
+            collectReads(expression.source, scope, states, found);
+            return found;
+        case 'conditional':
+            collectReads(expression.condition, scope, states, found);
+            collectReads(expression.whenTrue, scope, states, found);
+            collectReads(expression.whenFalse, scope, states, found);
+            return found;
         default:
             return found;
     }
@@ -217,8 +277,9 @@ function linkOperations(actionId, operations, linker, scope) {
                 linker.reads(actionId, operation.value, scope);
                 break;
             case 'insert':
-                // Inserting a constructed record writes every field the record declares.
-                linker.writes(actionId, operation.target, scope, 'writes', expressionFieldIds(operation.value));
+                // A constructed record writes the fields it declares. Fields consulted while
+                // computing those values are reads, and must not be reported as writes.
+                linker.writes(actionId, operation.target, scope, 'writes', constructedFieldIds(operation.value));
                 linker.reads(actionId, operation.value, scope);
                 break;
             case 'remove':

package/dist/diagnostics.d.ts

@@ -48,5 +48,7 @@ export declare const VALIDATION_CODES: {
     readonly initialValueUnknownField: "INITIAL_VALUE_UNKNOWN_FIELD";
     readonly initialValueMissingRequiredField: "INITIAL_VALUE_MISSING_REQUIRED_FIELD";
     readonly initialValueInvalidEntity: "INITIAL_VALUE_INVALID_ENTITY";
+    readonly scopeShadowing: "SCOPE_SHADOWING";
+    readonly scopeCollidesWithNode: "SCOPE_COLLIDES_WITH_NODE";
 };
 //# sourceMappingURL=diagnostics.d.ts.map

package/dist/diagnostics.js

@@ -31,4 +31,6 @@ export const VALIDATION_CODES = {
     initialValueUnknownField: 'INITIAL_VALUE_UNKNOWN_FIELD',
     initialValueMissingRequiredField: 'INITIAL_VALUE_MISSING_REQUIRED_FIELD',
     initialValueInvalidEntity: 'INITIAL_VALUE_INVALID_ENTITY',
+    scopeShadowing: 'SCOPE_SHADOWING',
+    scopeCollidesWithNode: 'SCOPE_COLLIDES_WITH_NODE',
 };

package/dist/expressions.d.ts

@@ -5,7 +5,7 @@ import type { LiteralValue } from './nodes.js';
  * identifier: `ref` resolves an id against the evaluation scope chain (route parameters,
  * action parameters, iteration scopes, then state), and `field` reads a field by id.
  */
-export type Expression = LiteralExpression | RefExpression | FieldExpression | ObjectExpression | BinaryExpression | UnaryExpression | CallExpression | FilterExpression | FindExpression | MapExpression | SortExpression;
+export type Expression = LiteralExpression | RefExpression | FieldExpression | ObjectExpression | BinaryExpression | UnaryExpression | CallExpression | FilterExpression | FindExpression | MapExpression | SortExpression | EveryExpression | SomeExpression | FlattenExpression | ConditionalExpression;
 export type ExpressionKind = Expression['kind'];
 /** Every expression kind the runtime is required to evaluate. */
 export declare const EXPRESSION_KINDS: readonly ExpressionKind[];
@@ -57,7 +57,7 @@ export interface UnaryExpression {
  * must be implemented by the runtime: a function that is declared here but unevaluated
  * would be a construct that typechecks, validates and then does nothing.
  */
-export type BuiltinFunction = 'required' | 'is-empty' | 'length' | 'contains' | 'concat' | 'coalesce' | 'one-of' | 'count' | 'sum' | 'lowercase' | 'to-string' | 'now' | 'uuid';
+export type BuiltinFunction = 'required' | 'is-empty' | 'non-empty' | 'length' | 'contains' | 'concat' | 'coalesce' | 'one-of' | 'count' | 'sum' | 'lowercase' | 'to-string' | 'now' | 'uuid';
 export declare const BUILTIN_FUNCTIONS: readonly BuiltinFunction[];
 /** Functions that reduce a collection of numbers to a number. */
 export declare const AGGREGATE_FUNCTIONS: readonly BuiltinFunction[];
@@ -99,6 +99,32 @@ export interface SortExpression {
     by: Expression;
     direction?: 'asc' | 'desc';
 }
+/** True when every member satisfies the predicate. An empty collection satisfies it. */
+export interface EveryExpression {
+    kind: 'every';
+    source: Expression;
+    scopeId: NodeId;
+    predicate: Expression;
+}
+/** True when at least one member satisfies the predicate. An empty collection does not. */
+export interface SomeExpression {
+    kind: 'some';
+    source: Expression;
+    scopeId: NodeId;
+    predicate: Expression;
+}
+/** Collapses one level of nesting: Collection<Collection<T>> becomes Collection<T>. */
+export interface FlattenExpression {
+    kind: 'flatten';
+    source: Expression;
+}
+/** Chooses between two values. Both branches are expressions, never callbacks. */
+export interface ConditionalExpression {
+    kind: 'conditional';
+    condition: Expression;
+    whenTrue: Expression;
+    whenFalse: Expression;
+}
 export declare function literal(value: LiteralValue): LiteralExpression;
 export declare function ref(targetId: NodeId): RefExpression;
 export declare function field(source: Expression, id: FieldId): FieldExpression;
@@ -113,8 +139,24 @@ export declare function sort(source: Expression, scopeId: NodeId, by: Expression
 /** Sums a collection of numbers. An empty collection sums to zero. */
 export declare function sum(source: Expression): CallExpression;
 export declare function count(source: Expression): CallExpression;
+/** True when a value exists at all — an empty collection or string still exists. */
+export declare function required(value: Expression): CallExpression;
+/** True when a collection or string has no members. */
+export declare function isEmpty(value: Expression): CallExpression;
+export declare function nonEmpty(value: Expression): CallExpression;
+/** The first value that exists. Only null and undefined are skipped. */
+export declare function coalesce(...values: Expression[]): CallExpression;
+export declare function every(source: Expression, scopeId: NodeId, predicate: Expression): EveryExpression;
+export declare function some(source: Expression, scopeId: NodeId, predicate: Expression): SomeExpression;
+export declare function flatten(source: Expression): FlattenExpression;
+export declare function conditional(condition: Expression, whenTrue: Expression, whenFalse: Expression): ConditionalExpression;
 /** Visits every sub-expression, parents before children. */
 export declare function walkExpression(expression: Expression, visit: (node: Expression) => void): void;
+/**
+ * Field ids a constructed record assigns. Only the record's own entries count: the
+ * expressions that compute those values are reads, not writes.
+ */
+export declare function constructedFieldIds(expression: Expression): FieldId[];
 /** Field ids an expression reads, including nested sources and constructed records. */
 export declare function expressionFieldIds(expression: Expression): FieldId[];
 //# sourceMappingURL=expressions.d.ts.map

package/dist/expressions.js

@@ -11,10 +11,15 @@ export const EXPRESSION_KINDS = [
     'find',
     'map',
     'sort',
+    'every',
+    'some',
+    'flatten',
+    'conditional',
 ];
 export const BUILTIN_FUNCTIONS = [
     'required',
     'is-empty',
+    'non-empty',
     'length',
     'contains',
     'concat',
@@ -69,6 +74,33 @@ export function sum(source) {
 export function count(source) {
     return call('count', source);
 }
+/** True when a value exists at all — an empty collection or string still exists. */
+export function required(value) {
+    return call('required', value);
+}
+/** True when a collection or string has no members. */
+export function isEmpty(value) {
+    return call('is-empty', value);
+}
+export function nonEmpty(value) {
+    return call('non-empty', value);
+}
+/** The first value that exists. Only null and undefined are skipped. */
+export function coalesce(...values) {
+    return call('coalesce', ...values);
+}
+export function every(source, scopeId, predicate) {
+    return { kind: 'every', source, scopeId, predicate };
+}
+export function some(source, scopeId, predicate) {
+    return { kind: 'some', source, scopeId, predicate };
+}
+export function flatten(source) {
+    return { kind: 'flatten', source };
+}
+export function conditional(condition, whenTrue, whenFalse) {
+    return { kind: 'conditional', condition, whenTrue, whenFalse };
+}
 /** Visits every sub-expression, parents before children. */
 export function walkExpression(expression, visit) {
     visit(expression);
@@ -106,9 +138,29 @@ export function walkExpression(expression, visit) {
             walkExpression(expression.source, visit);
             walkExpression(expression.by, visit);
             return;
+        case 'every':
+        case 'some':
+            walkExpression(expression.source, visit);
+            walkExpression(expression.predicate, visit);
+            return;
+        case 'flatten':
+            walkExpression(expression.source, visit);
+            return;
+        case 'conditional':
+            walkExpression(expression.condition, visit);
+            walkExpression(expression.whenTrue, visit);
+            walkExpression(expression.whenFalse, visit);
+            return;
         default:
     }
 }
+/**
+ * Field ids a constructed record assigns. Only the record's own entries count: the
+ * expressions that compute those values are reads, not writes.
+ */
+export function constructedFieldIds(expression) {
+    return expression.kind === 'object' ? expression.entries.map((entry) => entry.fieldId) : [];
+}
 /** Field ids an expression reads, including nested sources and constructed records. */
 export function expressionFieldIds(expression) {
     const found = [];

package/dist/graph.js

@@ -16,7 +16,7 @@ export class ApplicationGraph {
     /** Bumped by every change, so the derived edge index can never serve stale data. */
     revision = 0;
     semanticIndex;
-    constructor(id, name, version = '0.4.0') {
+    constructor(id, name, version = '0.4.1') {
         this.data = { id, name, version, nodes: {}, edges: {} };
     }
     get id() {

package/dist/infer.js

@@ -141,6 +141,14 @@ export function inferExpressionType(expression, context, scope) {
             const item = itemTypeOf(inferExpressionType(expression.source, context, scope));
             return item ? optionalType(item) : undefined;
         }
+        case 'every':
+        case 'some':
+            return primitiveType('boolean');
+        case 'flatten':
+            return itemTypeOf(inferExpressionType(expression.source, context, scope));
+        case 'conditional':
+            return (inferExpressionType(expression.whenTrue, context, scope) ??
+                inferExpressionType(expression.whenFalse, context, scope));
         case 'map': {
             const item = itemTypeOf(inferExpressionType(expression.source, context, scope));
             const projected = inferExpressionType(expression.projection, context, withScope(scope, expression.scopeId, item));
@@ -157,6 +165,8 @@ export function scopeForExpression(expression, context, scope) {
         case 'find':
         case 'map':
         case 'sort':
+        case 'every':
+        case 'some':
             return withScope(scope, expression.scopeId, itemTypeOf(inferExpressionType(expression.source, context, scope)));
         default:
             return scope ?? new Map();

package/dist/ir.d.ts

@@ -1,5 +1,5 @@
 import type { FieldId, NodeId } from './ids.js';
-import type { ActionDef, ConstraintDef, EntityDef, GraphEdge, RouteParameter, StateDef } from './nodes.js';
+import type { ActionDef, ConstraintDef, EntityDef, GraphEdge, RouteParameter, StateDef, TransitionConstraintDef } from './nodes.js';
 import type { FieldIndexEntry } from './graph.js';
 import type { UINode } from './ui.js';
 import type { AnyNode } from './types.js';
@@ -34,6 +34,8 @@ export interface ApplicationIR {
     actions: Record<NodeId, ActionDef>;
     uiNodes: Record<NodeId, UINode>;
     constraints: ConstraintDef[];
+    /** Rules about how state may change, enforced on every governed mutation path. */
+    transitionConstraints: TransitionConstraintDef[];
     routes: CompiledRoute[];
     edges: GraphEdge[];
     /**

package/dist/nodes.d.ts

@@ -62,9 +62,16 @@ export interface FailureMode {
     code: string;
     message?: string;
 }
+/** A condition together with the failure it reports, so the two cannot drift apart. */
+export interface ActionGuard {
+    condition: Expression;
+    failureMode?: FailureMode;
+}
 export interface ActionDef extends NodeBase {
     kind: 'action';
     parameters?: ActionParameter[];
+    /** Preferred over the parallel `preconditions` and `failureModes` arrays. */
+    guards?: ActionGuard[];
     preconditions?: Expression[];
     operations: Operation[];
     postconditions?: Expression[];
@@ -74,6 +81,11 @@ export interface ActionDef extends NodeBase {
     requiresConfirmation?: boolean;
     confirmationMessage?: string;
 }
+/**
+ * The conditions an action checks, however they were written. `guards` pairs each
+ * condition with its failure; the older parallel arrays are matched by position.
+ */
+export declare function actionGuards(action: ActionDef): ActionGuard[];
 export type Operation = SetOperation | InsertOperation | RemoveOperation | ForEachOperation | InvokeOperation | NavigateOperation | NativeOperation;
 export type OperationKind = Operation['kind'];
 /** Every operation kind the runtime is required to execute. */
@@ -159,6 +171,29 @@ export interface ConstraintDef extends NodeBase {
     severity?: 'error' | 'warning';
     message?: string;
 }
+/**
+ * A rule about how state may change, rather than about what state may be.
+ *
+ * An ordinary constraint judges the proposed state on its own; a transition constraint
+ * sees the instance as it was when the transaction began *and* as the transaction
+ * proposes it. That is what lets a rule like "once confirmed, an order may not change"
+ * hold no matter which path attempts the write — an action, an input binding, an
+ * iteration, or something added later.
+ *
+ * `previousScopeId` and `proposedScopeId` bind those two instances for the expression.
+ * When the instance is being removed, the proposed scope is bound to nothing.
+ */
+export interface TransitionConstraintDef extends NodeBase {
+    kind: 'transition-constraint';
+    /** The entity whose transitions are governed. It must have an identity field. */
+    entityId: NodeId;
+    previousScopeId: NodeId;
+    proposedScopeId: NodeId;
+    /** Must hold for every governed transition. */
+    expression: Expression;
+    severity?: 'error' | 'warning';
+    message?: string;
+}
 export interface RouteParameter {
     id: NodeId;
     /** Matches the `:name` placeholder in the route path. */

package/dist/nodes.js

@@ -1,3 +1,16 @@
+/**
+ * The conditions an action checks, however they were written. `guards` pairs each
+ * condition with its failure; the older parallel arrays are matched by position.
+ */
+export function actionGuards(action) {
+    if (action.guards && action.guards.length > 0) {
+        return action.guards;
+    }
+    return (action.preconditions ?? []).map((condition, index) => ({
+        condition,
+        ...(action.failureModes?.[index] ? { failureMode: action.failureModes[index] } : {}),
+    }));
+}
 /** Every operation kind the runtime is required to execute. */
 export const OPERATION_KINDS = [
     'set',

package/dist/types.d.ts

@@ -1,9 +1,9 @@
-import type { ActionDef, ConstraintDef, EntityDef, GraphEdge, RouteDef, StateDef } from './nodes.js';
+import type { ActionDef, ConstraintDef, EntityDef, GraphEdge, RouteDef, StateDef, TransitionConstraintDef } from './nodes.js';
 import type { NodeId } from './ids.js';
 import type { UINode, UINodeKind } from './ui.js';
-export type SemanticNodeKind = 'entity' | 'state' | 'action' | 'constraint' | 'route';
+export type SemanticNodeKind = 'entity' | 'state' | 'action' | 'constraint' | 'transition-constraint' | 'route';
 export type NodeKind = SemanticNodeKind | UINodeKind;
-export type AnyNode = EntityDef | StateDef | ActionDef | ConstraintDef | RouteDef | UINode;
+export type AnyNode = EntityDef | StateDef | ActionDef | ConstraintDef | TransitionConstraintDef | RouteDef | UINode;
 export type NodeOfKind<K extends NodeKind> = Extract<AnyNode, {
     kind: K;
 }>;

package/dist/validate.js

@@ -1,6 +1,7 @@
 import { AGGREGATE_FUNCTIONS, BUILTIN_FUNCTIONS } from './expressions.js';
 import { VALIDATION_CODES } from './diagnostics.js';
-import { EDGE_KINDS, isMutationOperation } from './nodes.js';
+import { EDGE_KINDS, actionGuards, isMutationOperation } from './nodes.js';
+import { entityType } from './type-ref.js';
 import { isUINode, uiChildIds } from './ui.js';
 import { semanticContextFromGraph } from './context.js';
 import { inferExpressionType, inferLocationType, isNonNumericCollection, isObviouslyIncompatible, itemTypeOf, } from './infer.js';
@@ -94,6 +95,9 @@ function validateNode(node, context) {
         case 'constraint':
             validateConstraint(node, context);
             return;
+        case 'transition-constraint':
+            validateTransitionConstraint(node, context);
+            return;
         case 'route':
             validateRoute(node, context);
             return;
@@ -219,8 +223,15 @@ function validateAction(action, context) {
             local.types.set(parameter.id, parameter.valueType);
         }
     }
-    for (const precondition of action.preconditions ?? []) {
-        validateExpression(precondition, action.id, context, local);
+    if (action.guards?.length && action.preconditions?.length) {
+        context.errors.push({
+            code: VALIDATION_CODES.unsupportedOperation,
+            message: `Action ${action.id} declares both guards and preconditions; use guards alone`,
+            nodeId: action.id,
+        });
+    }
+    for (const guard of actionGuards(action)) {
+        validateExpression(guard.condition, action.id, context, local);
     }
     for (const postcondition of action.postconditions ?? []) {
         validateExpression(postcondition, action.id, context, local);
@@ -234,7 +245,7 @@ function validateOperation(operation, action, context, local) {
         case 'for-each': {
             validateExpression(operation.collection, action.id, context, local);
             requireCollection(operation.collection, action.id, context, local, 'for-each');
-            const scoped = iterationScope(local, operation.scopeId, operation.collection, context);
+            const scoped = iterationScope(local, operation.scopeId, operation.collection, context, action.id);
             if ((operation.operations ?? []).length === 0) {
                 context.warnings.push({
                     code: VALIDATION_CODES.unsupportedOperation,
@@ -381,6 +392,32 @@ function validateConstraint(constraint, context) {
     }
     validateExpression(constraint.expression, constraint.id, context, local);
 }
+function validateTransitionConstraint(constraint, context) {
+    requireKind(constraint.entityId, 'entity', constraint.id, context, VALIDATION_CODES.danglingNodeRef);
+    const entity = context.nodes.get(constraint.entityId);
+    // Without an identity field there is no way to say which previous instance a proposed
+    // instance corresponds to, so the rule could not be evaluated at all.
+    if (entity?.kind === 'entity' && !entity.identityFieldId) {
+        context.errors.push({
+            code: VALIDATION_CODES.unsupportedConstraintScope,
+            message: `Transition constraint ${constraint.id} governs ${entity.id}, which has no identity field to match instances by`,
+            nodeId: constraint.id,
+        });
+    }
+    if (constraint.previousScopeId === constraint.proposedScopeId) {
+        context.errors.push({
+            code: VALIDATION_CODES.unsupportedConstraintScope,
+            message: `Transition constraint ${constraint.id} uses one scope for both the previous and the proposed instance`,
+            nodeId: constraint.id,
+        });
+    }
+    const scope = emptyScope(new Set([constraint.previousScopeId, constraint.proposedScopeId]));
+    if (entity?.kind === 'entity') {
+        scope.types.set(constraint.previousScopeId, entityType(entity.id));
+        scope.types.set(constraint.proposedScopeId, entityType(entity.id));
+    }
+    validateExpression(constraint.expression, constraint.id, context, scope);
+}
 function validateRoute(route, context) {
     const view = context.nodes.get(route.viewId);
     if (!view || view.kind !== 'view') {
@@ -607,8 +644,27 @@ function validateTypeRef(type, ownerId, context, field, inCollection = false) {
 function emptyScope(ids = new Set()) {
     return { ids, types: new Map() };
 }
-/** Extends a scope with the member type of the collection an iteration walks. */
-function iterationScope(scope, scopeId, source, context) {
+/**
+ * Extends a scope with the member type of the collection an iteration walks.
+ *
+ * An iteration binder is not a graph node, and reusing an id that is already bound — or
+ * one that names a node — makes a reference ambiguous to read and to analyze.
+ */
+function iterationScope(scope, scopeId, source, context, ownerId) {
+    if (scope.ids.has(scopeId)) {
+        context.errors.push({
+            code: VALIDATION_CODES.scopeShadowing,
+            message: `Scope ${scopeId} in ${ownerId ?? 'an expression'} is already bound by an enclosing iteration`,
+            ...(ownerId ? { nodeId: ownerId } : {}),
+        });
+    }
+    if (context.nodes.has(scopeId)) {
+        context.errors.push({
+            code: VALIDATION_CODES.scopeCollidesWithNode,
+            message: `Scope ${scopeId} in ${ownerId ?? 'an expression'} has the same id as a graph node`,
+            ...(ownerId ? { nodeId: ownerId } : {}),
+        });
+    }
     const item = itemTypeOf(inferExpressionType(source, context.semantics, scope.types));
     const types = new Map(scope.types);
     if (item) {
@@ -691,19 +747,46 @@ function validateExpression(expression, ownerId, context, local) {
         case 'find': {
             validateExpression(expression.source, ownerId, context, scope);
             requireCollection(expression.source, ownerId, context, scope, expression.kind);
-            validateExpression(expression.predicate, ownerId, context, iterationScope(scope, expression.scopeId, expression.source, context));
+            validateExpression(expression.predicate, ownerId, context, iterationScope(scope, expression.scopeId, expression.source, context, ownerId));
             return;
         }
         case 'map': {
             validateExpression(expression.source, ownerId, context, scope);
             requireCollection(expression.source, ownerId, context, scope, 'map');
-            validateExpression(expression.projection, ownerId, context, iterationScope(scope, expression.scopeId, expression.source, context));
+            validateExpression(expression.projection, ownerId, context, iterationScope(scope, expression.scopeId, expression.source, context, ownerId));
+            return;
+        }
+        case 'every':
+        case 'some': {
+            validateExpression(expression.source, ownerId, context, scope);
+            requireCollection(expression.source, ownerId, context, scope, expression.kind);
+            validateExpression(expression.predicate, ownerId, context, iterationScope(scope, expression.scopeId, expression.source, context, ownerId));
+            return;
+        }
+        case 'flatten': {
+            validateExpression(expression.source, ownerId, context, scope);
+            requireCollection(expression.source, ownerId, context, scope, 'flatten');
+            const inner = itemTypeOf(inferExpressionType(expression.source, context.semantics, scope.types));
+            if (inner && resolveKnownType(inner)?.kind !== 'collection') {
+                context.errors.push({
+                    code: VALIDATION_CODES.notACollection,
+                    message: `flatten in ${ownerId} expects a collection of collections but its members are ${describeType(inner)}`,
+                    nodeId: ownerId,
+                });
+            }
+            return;
+        }
+        case 'conditional': {
+            validateExpression(expression.condition, ownerId, context, scope);
+            validateExpression(expression.whenTrue, ownerId, context, scope);
+            validateExpression(expression.whenFalse, ownerId, context, scope);
+            reportIncompatible(inferExpressionType(expression.whenTrue, context.semantics, scope.types), inferExpressionType(expression.whenFalse, context.semantics, scope.types), ownerId, context);
             return;
         }
         case 'sort': {
             validateExpression(expression.source, ownerId, context, scope);
             requireCollection(expression.source, ownerId, context, scope, 'sort');
-            validateExpression(expression.by, ownerId, context, iterationScope(scope, expression.scopeId, expression.source, context));
+            validateExpression(expression.by, ownerId, context, iterationScope(scope, expression.scopeId, expression.source, context, ownerId));
             return;
         }
         default:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cynodia/axiom-core",
-  "version": "0.4.0-alpha.1",
+  "version": "0.4.1-alpha.1",
   "description": "Application Graph, semantic types, locations and validation for Axiom.",
   "license": "MIT",
   "author": "AskTech AS",