@cynodia/axiom-core 0.5.0-alpha.1 → 0.5.2-alpha.1

package/README.md

@@ -6,13 +6,17 @@ framework.
 **Status: experimental / alpha.** The API may change between alpha releases.
 
 The Application Graph and its semantic model: nodes, fields, structured types,
-expressions, **locations** (addressable writable positions), edge derivation,
-validation and type inference.
+expressions, **locations** (addressable writable positions), edge derivation, validation
+and type inference. It also owns the presentation and UX layer — semantic roles, layout and
+spacing tokens, device classes, value formats and the `Theme` — with presentation
+resolution and validation.
 
-It also owns the presentation and UX layer — semantic roles, layout, spacing and sizing
-tokens, device classes, value formats and the `Theme` — together with presentation
-resolution and validation. Presentation lives here because it is part of the canonical
-graph: it is intent, not styling, and it names no colour, length or CSS property.
+Presentation lives here because it is part of the canonical graph: it is intent, not
+styling, and it names no colour, length or CSS property.
+
+Main exports: `ApplicationGraph`, `TypeRef` builders, expression builders, `Location`
+builders, `Presentation`, `Theme`, `resolvePresentationMap`, `validateGraph`,
+`VALIDATION_CODES`, `ApplicationIR`.
 
 ## Installation
 
@@ -26,6 +30,13 @@ Most applications should install the facade package instead, which re-exports th
 npm install @cynodia/axiom@alpha
 ```
 
+
+## Documentation
+
+The canonical operational contract lives in the `docs/` directory of the
+[`@cynodia/axiom`](https://www.npmjs.com/package/@cynodia/axiom) package, and in
+[the repository](https://github.com/cynodia/axiom). Start with `docs/AGENT_REFERENCE.md`.
+
 ## License
 
 MIT

package/dist/graph.d.ts

@@ -10,9 +10,15 @@ export interface EdgeQuery {
     kinds?: readonly EdgeKind[];
 }
 /**
- * The Application Graph is the canonical representation of an application. Reads return
- * deep clones, so a node retrieved from the graph must be written back with
- * `updateNode` for the change to take effect.
+ * The Application Graph is the canonical representation of an application. Everything else
+ * — the IR, the emitted page, the DOM — is derived from it and is never edited.
+ *
+ * Reads return **deep clones**, so a node retrieved from the graph must be written back
+ * with `updateNode` for the change to take effect.
+ *
+ * Relationships are derived from the current nodes on demand and cached against a revision
+ * counter, so an edge cannot fall out of step with the nodes it describes and no
+ * correctness property depends on resynchronizing anything.
  */
 export declare class ApplicationGraph {
     private data;

package/dist/graph.js

@@ -5,9 +5,15 @@ function clone(value) {
     return structuredClone(value);
 }
 /**
- * The Application Graph is the canonical representation of an application. Reads return
- * deep clones, so a node retrieved from the graph must be written back with
- * `updateNode` for the change to take effect.
+ * The Application Graph is the canonical representation of an application. Everything else
+ * — the IR, the emitted page, the DOM — is derived from it and is never edited.
+ *
+ * Reads return **deep clones**, so a node retrieved from the graph must be written back
+ * with `updateNode` for the change to take effect.
+ *
+ * Relationships are derived from the current nodes on demand and cached against a revision
+ * counter, so an edge cannot fall out of step with the nodes it describes and no
+ * correctness property depends on resynchronizing anything.
  */
 export class ApplicationGraph {
     data;
@@ -17,7 +23,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.5.0') {
+    constructor(id, name, version = '0.5.2') {
         this.data = { id, name, version, nodes: {}, edges: {} };
     }
     get id() {

package/dist/infer.js

@@ -131,6 +131,15 @@ export function inferExpressionType(expression, context, scope) {
                     return primitiveType('string');
                 case 'now':
                     return primitiveType('datetime');
+                case 'coalesce': {
+                    // The type of the first argument, with its optionality removed: a fallback is
+                    // what makes the value present. Inferring this is what lets a repeat over
+                    // `coalesce(field(...), [])` still know how to identify its members.
+                    const first = expression.arguments[0]
+                        ? inferExpressionType(expression.arguments[0], context, scope)
+                        : undefined;
+                    return first?.kind === 'optional' ? first.valueType : first;
+                }
                 default:
                     return undefined;
             }

package/dist/ir.d.ts

@@ -55,6 +55,15 @@ export interface ApplicationIR {
      * renderer can mark it without re-deriving the model.
      */
     locationRequired: Record<NodeId, boolean>;
+    /**
+     * The field that distinguishes the members of each `repeat` node's collection, resolved
+     * here so a runtime carries no type inference of its own.
+     *
+     * A renderer uses it to give every rendered repeat instance a stable identity. A repeat
+     * whose member type cannot be resolved statically is absent from this map, and the
+     * renderer falls back to the iteration index.
+     */
+    repeatIdentityFields: Record<NodeId, FieldId>;
     /** The application's visual identity, completed against the default theme. */
     theme: Theme;
     /**

package/dist/nodes.d.ts

@@ -8,10 +8,23 @@ export interface NodeBase {
     name?: string;
     metadata?: Record<string, unknown>;
 }
+/**
+ * A field of an entity.
+ *
+ * Fields are independently identifiable and globally unique across the graph, and
+ * **instance data is keyed by `FieldId`, never by `name`**: a record looks like
+ * `{ [F_TITLE]: 'Dune' }`, not `{ title: 'Dune' }`. `name` is metadata for humans and
+ * resolves nothing.
+ */
 export interface FieldDef {
     id: FieldId;
     name?: string;
     valueType: TypeRef;
+    /**
+     * The value must be **present** in every canonical instance — not `null` and not
+     * `undefined`. It says nothing about emptiness: `0`, `false`, `''` and `[]` all satisfy
+     * it. Express "must not be blank" as a `ConstraintDef` using `non-empty`.
+     */
     required?: boolean;
     defaultValue?: LiteralValue;
     metadata?: Record<string, unknown>;
@@ -19,10 +32,21 @@ export interface FieldDef {
 export type LiteralValue = string | number | boolean | null | LiteralValue[] | {
     [key: string]: LiteralValue;
 };
+/**
+ * A record type. Instances of it are found wherever a state's declared type says they
+ * live — including nested inside collections and inside other entities — and are validated
+ * there.
+ */
 export interface EntityDef extends NodeBase {
     kind: 'entity';
     fields: FieldDef[];
-    /** Field used to distinguish instances of this entity. */
+    /**
+     * Field used to distinguish instances of this entity.
+     *
+     * Required in order to address an instance by identity (`identitySelector`), and
+     * required by every `TransitionConstraintDef` on this entity — without it such a rule is
+     * **silently skipped**. Declare it on every entity stored in a collection.
+     */
     identityFieldId?: FieldId;
 }
 export type StatePersistence = {
@@ -34,11 +58,34 @@ export type StatePersistence = {
     kind: 'remote';
     sourceId: NodeId;
 };
+/**
+ * A named application value: stored, or computed from other state.
+ *
+ * A state with no `derivation` is stored, and one that is neither `draft` nor `ephemeral`
+ * is **canonical** — the state entity constraints and schema conformance apply to. Stored
+ * values are deeply frozen on entry to the store, and every read hands out a copy.
+ */
 export interface StateDef extends NodeBase {
     kind: 'state';
     valueType: TypeRef;
+    /**
+     * Seed data, keyed by `FieldId` wherever it contains a record. It is walked against
+     * `valueType` recursively at validation time, so data keyed by field *name* is rejected
+     * rather than surfacing later as an inexplicably empty UI.
+     *
+     * Absent, the state starts at the default for its type: `optional` → `null`,
+     * `collection` → `[]`, `number` → `0`, `boolean` → `false`, other primitive → `''`,
+     * `enum` → its first value, `entity` → `null`.
+     */
     initialValue?: LiteralValue;
-    /** When present the state is computed rather than stored. */
+    /**
+     * When present the state is computed rather than stored.
+     *
+     * Derived state is **read-only**: a write is rejected by `validateGraph` and by the
+     * runtime. It is recomputed on demand and handed out as a frozen deep copy, so nothing
+     * can work by sharing an object with the state it was derived from. Instance validation
+     * skips it, because the data is already validated where it is stored.
+     */
     derivation?: Expression;
     /**
      * Marks a state that holds work in progress. Draft instances are incomplete by
@@ -72,6 +119,18 @@ export interface ActionGuard {
     condition: Expression;
     failureMode?: FailureMode;
 }
+/**
+ * Behaviour expressed as data, executed as a transaction.
+ *
+ * An invocation proceeds: resolve the action, bind parameters, evaluate preconditions in
+ * order, ask for confirmation if required — **none of which opens a transaction, so a
+ * refusal at any of those stages mutates nothing** — then begin a transaction, run the
+ * operations sequentially against provisional state, evaluate entity constraints,
+ * transition constraints and postconditions, and either commit everything or roll back
+ * every mutation.
+ *
+ * `invokeAction` returns the diagnostics of that invocation.
+ */
 export interface ActionDef extends NodeBase {
     kind: 'action';
     parameters?: ActionParameter[];
@@ -99,30 +158,53 @@ export type OperationKind = Operation['kind'];
 export declare const OPERATION_KINDS: readonly OperationKind[];
 /** Every mutation is a set, an insert or a remove against an addressed Location. */
 export type MutationOperation = SetOperation | InsertOperation | RemoveOperation;
+/**
+ * Writes a value to an addressed position.
+ *
+ * A missing field along the path is created. A missing **collection item** is not: an
+ * identity selector that matches nothing reports `LOCATION_RESOLUTION_FAILED`.
+ */
 export interface SetOperation {
     kind: 'set';
     target: Location;
     value: Expression;
 }
+/**
+ * Adds a member to a collection. The constructed value is deep-cloned before it is stored.
+ *
+ * A newly inserted entity instance has no previous state, so **no transition constraint is
+ * evaluated for it**. Govern creation with an action guard or an entity constraint.
+ */
 export interface InsertOperation {
     kind: 'insert';
-    /** A location addressing a collection. */
+    /** A location addressing a collection. A non-array current value is treated as `[]`. */
     target: Location;
     value: Expression;
+    /** Defaults to `'end'`. */
     position?: 'start' | 'end';
 }
+/**
+ * Removes one member of a collection.
+ *
+ * A selector that matches nothing is a **no-op**: no mutation, no log entry and no
+ * diagnostic. Removing an existing instance *is* a transition, with the proposed value
+ * bound to nothing.
+ */
 export interface RemoveOperation {
     kind: 'remove';
     target: CollectionItemLocation;
 }
 /**
- * Performs a set of mutations once per member of a collection. The iteration is not a
- * transaction of its own: it runs inside the action's transaction, so a failure in any
- * iteration rolls the whole action back.
+ * Performs a set of mutations once per member of a collection.
+ *
+ * Iteration N observes provisional writes from previous iterations. The loop executes
+ * inside the containing action's transaction and opens none of its own, so any failure
+ * rolls back the complete action — every iteration included. The collection itself is
+ * evaluated **once**, before the first member is mutated.
  *
  * `scopeId` introduces an iteration scope. Nested expressions refer to the current member
  * as `ref(scopeId)`, and nested locations may use it to address the canonical record the
- * member points at.
+ * member points at. Nested operations must be mutations only.
  */
 export interface ForEachOperation {
     kind: 'for-each';
@@ -170,11 +252,22 @@ export interface NativeOperation {
     resultTarget?: Location;
     declaredEffects?: NativeEffect[];
 }
+/**
+ * An invariant over proposed state, evaluated after every governed mutation.
+ *
+ * A constraint that cannot be evaluated counts as **violated**, never as satisfied.
+ */
 export interface ConstraintDef extends NodeBase {
     kind: 'constraint';
     expression: Expression;
-    /** When set, the expression is evaluated once per instance of this entity. */
+    /**
+     * When set, the expression is evaluated once per canonical instance of this entity, with
+     * the instance bound to `ref(entityId)` — wherever that instance is stored, including
+     * nested inside another entity. Without it the expression is evaluated once, in the root
+     * scope.
+     */
     entityId?: NodeId;
+    /** Defaults to `'error'`. A `'warning'` is advice and **never blocks a write**. */
     severity?: 'error' | 'warning';
     message?: string;
 }
@@ -189,6 +282,13 @@ export interface ConstraintDef extends NodeBase {
  *
  * `previousScopeId` and `proposedScopeId` bind those two instances for the expression.
  * When the instance is being removed, the proposed scope is bound to nothing.
+ *
+ * "Previous" means committed state as it stood immediately before the **outermost**
+ * transaction began — not the previous operation, and not the previous iteration.
+ *
+ * A **newly inserted** instance has no previous state and is therefore **not evaluated**.
+ * Govern creation with an action guard or an entity constraint. The entity must declare
+ * `identityFieldId`; without one this rule is silently skipped.
  */
 export interface TransitionConstraintDef extends NodeBase {
     kind: 'transition-constraint';

package/dist/presentation.d.ts

@@ -70,9 +70,28 @@ export type PaddingIntent = SpacingToken | {
 };
 export type SurfaceRole = 'transparent' | 'base' | 'subtle' | 'raised' | 'inset';
 export declare const SURFACE_ROLES: readonly SurfaceRole[];
-/** Semantic text roles. A theme maps each to font metrics; the graph names no sizes. */
+/**
+ * Semantic text roles. A theme maps each to font metrics; the graph names no sizes.
+ *
+ * A text role is a **typographic** decision only. Whether the value is a document heading
+ * is `headingLevel`, which is separate on purpose: a large monetary total or a dashboard
+ * statistic wants `display` type at `headingLevel: 'none'`.
+ */
 export type TextRole = 'body' | 'caption' | 'label' | 'heading' | 'title' | 'display';
 export declare const TEXT_ROLES: readonly TextRole[];
+/**
+ * Where a value sits in the document outline, independently of how large it is drawn.
+ * `'none'` means the value is not a heading at all.
+ */
+export type HeadingLevel = 1 | 2 | 3 | 4 | 5 | 6 | 'none';
+export declare const HEADING_LEVELS: readonly HeadingLevel[];
+/**
+ * The outline level a text role implies when nothing says otherwise.
+ *
+ * This is the 0.5.0 mapping, kept so existing applications do not lose their heading
+ * structure. An explicit `headingLevel` always wins.
+ */
+export declare const TEXT_ROLE_HEADING_LEVELS: Readonly<Record<TextRole, HeadingLevel>>;
 /**
  * Why a node exists in the interface. A UX role is high-information: `toolbar` implies a
  * horizontal, wrapping, centre-aligned group, so an author states the role rather than
@@ -165,6 +184,12 @@ export interface Presentation {
     emphasis?: Emphasis;
     density?: Density | LegacyDensity;
     textRole?: TextRole;
+    /**
+     * The document-outline level, independent of `textRole`. `'none'` renders the value as
+     * ordinary text however large it is drawn. Omitted, it is inferred from `textRole` by
+     * `TEXT_ROLE_HEADING_LEVELS`.
+     */
+    headingLevel?: HeadingLevel;
     uxRole?: UxRole;
     surface?: SurfaceRole;
     treatment?: Treatment;
@@ -241,6 +266,8 @@ export interface ResolvedPresentation {
     emphasis: Emphasis;
     density: Density;
     textRole: TextRole;
+    /** `'none'` when the value is not part of the document outline. */
+    headingLevel: HeadingLevel;
     uxRole?: UxRole;
     surface: SurfaceRole;
     treatment: Treatment;

package/dist/presentation.js

@@ -26,6 +26,21 @@ export const JUSTIFICATIONS = [...ALIGNMENTS, 'between'];
 export const LAYOUT_KINDS = ['vertical', 'horizontal', 'grid', 'stack'];
 export const SURFACE_ROLES = ['transparent', 'base', 'subtle', 'raised', 'inset'];
 export const TEXT_ROLES = ['body', 'caption', 'label', 'heading', 'title', 'display'];
+export const HEADING_LEVELS = [1, 2, 3, 4, 5, 6, 'none'];
+/**
+ * The outline level a text role implies when nothing says otherwise.
+ *
+ * This is the 0.5.0 mapping, kept so existing applications do not lose their heading
+ * structure. An explicit `headingLevel` always wins.
+ */
+export const TEXT_ROLE_HEADING_LEVELS = {
+    display: 1,
+    title: 2,
+    heading: 3,
+    body: 'none',
+    caption: 'none',
+    label: 'none',
+};
 export const UX_ROLES = [
     'primary-action',
     'secondary-action',

package/dist/resolve-presentation.d.ts

@@ -1,7 +1,7 @@
 import type { NodeId } from './ids.js';
 import type { ActionDef } from './nodes.js';
 import type { AnyNode } from './types.js';
-import type { Density, PresentationOrigin, ResolvedLayout, ResolvedPadding, ResolvedPresentation, ResolvedSizing, UxRole, ValueFormat } from './presentation.js';
+import type { Density, HeadingLevel, PresentationOrigin, ResolvedLayout, ResolvedPadding, ResolvedPresentation, ResolvedSizing, UxRole, ValueFormat } from './presentation.js';
 import type { Theme } from './theme.js';
 /**
  * Presentation resolution, §40.
@@ -28,6 +28,7 @@ interface Layer {
     emphasis?: ResolvedPresentation['emphasis'];
     density?: Density;
     textRole?: ResolvedPresentation['textRole'];
+    headingLevel?: HeadingLevel;
     uxRole?: UxRole;
     surface?: ResolvedPresentation['surface'];
     treatment?: ResolvedPresentation['treatment'];

package/dist/resolve-presentation.js

@@ -1,5 +1,5 @@
 import { isUINode, uiChildIds } from './ui.js';
-import { normalizeDensity, normalizeLayout, normalizePadding, normalizeRole, } from './presentation.js';
+import { TEXT_ROLE_HEADING_LEVELS, normalizeDensity, normalizeLayout, normalizePadding, normalizeRole, } from './presentation.js';
 import { DEFAULT_THEME } from './theme.js';
 /**
  * Presentation resolution, §40.
@@ -68,8 +68,14 @@ function buildIndex(nodes) {
     }
     return { nodes: byId, parentOf, formOf, fieldTypes };
 }
-/** What a node's kind implies, before anything about the application is considered. */
-function kindLayer(node) {
+/**
+ * What a node's kind implies, before anything about the application is considered.
+ *
+ * A control carries its own internal arrangement — a button is a centred row containing an
+ * icon and a label, not a bare box. Getting this right here is what stops every
+ * application from restating the same corrective layout and padding on every button.
+ */
+function kindLayer(node, theme) {
     switch (node.kind) {
         case 'view':
             return { origin: 'inferred', layout: { kind: 'vertical', gap: 'large' }, sizing: { width: 'fill' } };
@@ -92,6 +98,8 @@ function kindLayer(node) {
             return { origin: 'inferred', layout: { kind: 'vertical', gap: 'small' }, sizing: { width: 'fill' } };
         case 'conditional':
             return { origin: 'inferred', layout: { kind: 'vertical', gap: 'medium' }, sizing: { width: 'fill' } };
+        case 'diagnostic':
+            return { origin: 'inferred', layout: { kind: 'vertical', gap: 'xsmall' }, sizing: { width: 'fill' } };
         case 'field-display':
             return {
                 origin: 'inferred',
@@ -102,8 +110,23 @@ function kindLayer(node) {
             return { origin: 'inferred', sizing: { width: 'content' } };
         case 'input':
             return { origin: 'inferred', layout: { kind: 'vertical', gap: 'xsmall' }, sizing: { width: 'fill' } };
-        case 'button':
-            return { origin: 'inferred', role: 'secondary', sizing: { width: 'content' } };
+        case 'button': {
+            const buttons = theme.buttons;
+            return {
+                origin: 'inferred',
+                role: 'secondary',
+                sizing: { width: 'content' },
+                layout: {
+                    kind: buttons.layout,
+                    gap: buttons.gap,
+                    align: buttons.align,
+                    justify: buttons.justify,
+                    wrap: false,
+                },
+                // Control padding comes from the theme's control metrics, not from spacing tokens.
+                padding: { horizontal: 'none', vertical: 'none' },
+            };
+        }
         default:
             return { origin: 'inferred' };
     }
@@ -213,6 +236,13 @@ function statusLayer(role, icon) {
  * destructive action is presented as destructive without the graph saying so twice.
  */
 function semanticLayer(node, index) {
+    if (node.kind === 'diagnostic') {
+        // A region that reports a refusal is a status region of the matching severity.
+        return {
+            origin: 'inferred',
+            uxRole: node.severity === 'warning' ? 'warning-state' : 'error-state',
+        };
+    }
     if (node.kind !== 'button') {
         return { origin: 'inferred' };
     }
@@ -279,6 +309,9 @@ function nodeLayer(presentation) {
     if (presentation.textRole) {
         layer.textRole = presentation.textRole;
     }
+    if (presentation.headingLevel !== undefined) {
+        layer.headingLevel = presentation.headingLevel;
+    }
     if (presentation.uxRole) {
         layer.uxRole = presentation.uxRole;
     }
@@ -333,6 +366,7 @@ function applyLayers(nodeId, layers) {
         emphasis: 'normal',
         density: 'comfortable',
         textRole: 'body',
+        headingLevel: 'none',
         surface: 'transparent',
         treatment: 'plain',
         layout: { ...DEFAULT_LAYOUT },
@@ -348,6 +382,7 @@ function applyLayers(nodeId, layers) {
         'emphasis',
         'density',
         'textRole',
+        'headingLevel',
         'uxRole',
         'surface',
         'treatment',
@@ -402,6 +437,14 @@ function applyLayers(nodeId, layers) {
             origins.padding = layer.origin;
         }
     }
+    // The outline level follows the type scale unless something stated it. This is the
+    // 0.5.0 mapping, kept so an existing application does not lose its heading structure.
+    if (origins.headingLevel === undefined) {
+        resolved.headingLevel = TEXT_ROLE_HEADING_LEVELS[resolved.textRole];
+        if (resolved.headingLevel !== 'none') {
+            origins.headingLevel = 'inferred';
+        }
+    }
     // Anything no layer had an opinion about came from the renderer's own baseline.
     void layoutKindDeclared;
     const record = (key, value) => {
@@ -512,7 +555,7 @@ export function resolvePresentationMap(nodes, theme = DEFAULT_THEME) {
         if (inherited) {
             layers.push(inherited);
         }
-        layers.push(kindLayer(node));
+        layers.push(kindLayer(node, theme));
         const uxRole = declared?.uxRole ?? semanticLayer(node, index).uxRole;
         if (uxRole) {
             layers.push(uxRoleLayer(uxRole));

package/dist/theme.d.ts

@@ -1,4 +1,4 @@
-import type { BoundedSize, Density, Emphasis, IconName, SpacingToken, SurfaceRole, TextRole } from './presentation.js';
+import type { Alignment, BoundedSize, Density, Emphasis, IconName, Justification, LayoutKind, SpacingToken, SurfaceRole, TextRole } from './presentation.js';
 /**
  * A theme is the translation layer between semantic presentation intent and visual
  * rendering. It is the one place concrete values are allowed to live, because it is not
@@ -69,6 +69,23 @@ export interface SurfaceStyle {
     elevation: 0 | 1 | 2 | 3;
     radius: RadiusToken;
 }
+/**
+ * How an ordinary button is put together internally.
+ *
+ * These are the affordances every button needs and none should have to restate. An
+ * application annotates a button only where it differs from this.
+ */
+export interface ButtonTheme {
+    /** Direction of a button's own contents. Horizontal keeps an icon beside its label. */
+    layout: LayoutKind;
+    gap: SpacingToken;
+    align: Alignment;
+    justify: Justification;
+    /** Horizontal padding, relative to `controls.paddingX`. */
+    paddingScale: number;
+    /** Where an icon sits relative to the label. */
+    iconPlacement: 'leading' | 'trailing';
+}
 export interface ControlTheme {
     /** Control height per density. */
     height: Record<Density, number>;
@@ -114,6 +131,8 @@ export interface Theme {
     sizes: Record<BoundedSize, number>;
     surfaces: Record<SurfaceRole, SurfaceStyle>;
     controls: ControlTheme;
+    /** Internal arrangement of an ordinary button. See `ButtonTheme`. */
+    buttons: ButtonTheme;
     /** How much the density scales spacing and control metrics. */
     density: Record<Density, {
         scale: number;

package/dist/theme.js

@@ -73,6 +73,14 @@ export const DEFAULT_THEME = {
         borderWidth: 1,
         focusWidth: 3,
     },
+    buttons: {
+        layout: 'horizontal',
+        gap: 'xsmall',
+        align: 'center',
+        justify: 'center',
+        paddingScale: 1.15,
+        iconPlacement: 'leading',
+    },
     density: { compact: { scale: 0.7 }, comfortable: { scale: 1 }, spacious: { scale: 1.35 } },
     colors: {
         light: {

package/dist/ui.d.ts

@@ -2,12 +2,18 @@ import type { Expression } from './expressions.js';
 import type { FieldId, NodeId } from './ids.js';
 import type { Location } from './location.js';
 import type { Presentation } from './presentation.js';
-export type UINodeKind = 'view' | 'container' | 'text' | 'repeat' | 'field-display' | 'form' | 'input' | 'button' | 'conditional';
+export type UINodeKind = 'view' | 'container' | 'text' | 'repeat' | 'field-display' | 'form' | 'input' | 'button' | 'conditional' | 'diagnostic';
 export declare const UI_NODE_KINDS: readonly UINodeKind[];
 export interface UIBase {
     id: NodeId;
     kind: UINodeKind;
     name?: string;
+    /**
+     * Whether the node is rendered. This is interaction behaviour, **not authorization**:
+     * hidden is not forbidden, and a governed write is checked whether or not any control
+     * for it is visible. A rule belongs in an action guard, a `ConstraintDef` or a
+     * `TransitionConstraintDef`.
+     */
     visibleWhen?: Expression;
     /** Presentation and UX intent. Entirely optional; defaults do the rest. */
     presentation?: Presentation;
@@ -34,8 +40,12 @@ export interface TextNode extends UIBase {
     value: string | Expression;
 }
 /**
- * Repeats `templateId` over `source`. The current item is bound to this node's own id,
+ * Repeats `templateId` over `source`. The current item is bound to **this node's own id**,
  * so templates reference it with `{ kind: 'ref', targetId: <repeat node id> }`.
+ *
+ * `itemAlias` is metadata for humans and resolves nothing. A `source` that evaluates to
+ * `null` fails the evaluation rather than rendering nothing — use
+ * `coalesce(..., literal([]))` where a collection may legitimately be absent.
  */
 export interface RepeatNode extends UIBase {
     kind: 'repeat';
@@ -50,12 +60,37 @@ export interface FieldDisplayNode extends UIBase {
     fieldId: FieldId;
     label?: string;
 }
+/**
+ * Groups controls, and optionally submits an action.
+ *
+ * There are two ways to give a form a submit control:
+ *
+ * - `submitActionId` (+ `submitLabel`) is the simple form: the renderer generates the
+ *   button. Nothing else has to be declared.
+ * - `submitButtonId` is the advanced form: a declared `ButtonNode` inside the form becomes
+ *   the submit control. It stays an ordinary graph node — queryable, positionable in an
+ *   action group, and able to carry its own presentation and icon — while still receiving
+ *   native form-submit behaviour.
+ *
+ * `target` is the record the form is about. It is a read: it does **not** decide where the
+ * children write, because every input carries its own location.
+ */
 export interface FormNode extends UIBase {
     kind: 'form';
     target: Expression;
     children: NodeId[];
+    /**
+     * The action the form submits. Optional when `submitButtonId` is given, in which case
+     * that button's own `actionId` is the submit action; if both are given they must agree.
+     */
     submitActionId?: NodeId;
+    /** Label for the generated submit button. Ignored when `submitButtonId` is given. */
     submitLabel?: string;
+    /**
+     * A `ButtonNode` among this form's descendants to use as the submit control instead of a
+     * generated one.
+     */
+    submitButtonId?: NodeId;
 }
 /**
  * An input writes to an addressed Location, never to whatever object an expression
@@ -64,6 +99,19 @@ export interface FormNode extends UIBase {
 export interface InputBinding {
     location: Location;
 }
+/**
+ * An input's write goes through the same mutation engine and the same transaction
+ * machinery as an action; there is no second write path inside the renderer.
+ *
+ * What governs it depends on what the location is **rooted in**. Rooted in canonical
+ * state, the write is transactional with respect to hard invariants: a value that would
+ * break one is rolled back and the control re-renders with what is actually stored. Rooted
+ * in a `draft` or `ephemeral` state it is not guarded per keystroke, because such a value
+ * is incomplete by definition while it is being filled in.
+ *
+ * Transition constraints apply either way. Binding an input to a protected location does
+ * not bypass anything.
+ */
 export type InputHint = 'text' | 'email' | 'number' | 'password' | 'date' | 'checkbox' | 'multiline' | 'select';
 /**
  * Offers a choice drawn from application data rather than a fixed enum, which is how a
@@ -79,7 +127,11 @@ export interface InputOptionsSource {
 export interface InputNode extends UIBase {
     kind: 'input';
     binding: InputBinding;
-    /** Presentation hint only; the runtime infers a control from the field type otherwise. */
+    /**
+     * The 0.2 spelling of control intent, shaped after HTML input types.
+     * `presentation.control` supersedes it and is consulted first; absent both, the runtime
+     * infers a control from the type of the bound location.
+     */
     inputHint?: InputHint;
     options?: InputOptionsSource;
     label?: string;
@@ -103,10 +155,49 @@ export interface ConditionalNode extends UIBase {
     whenTrue: NodeId[];
     whenFalse?: NodeId[];
 }
-export type UINode = ViewNode | ContainerNode | TextNode | RepeatNode | FieldDisplayNode | FormNode | InputNode | ButtonNode | ConditionalNode;
+/**
+ * Presents why an action refused.
+ *
+ * The runtime already knows an action failed and why. This node makes that available to
+ * the semantic application model, so an application never has to duplicate an action's
+ * guards as derived state merely to explain them, inspect console output, or copy an
+ * `ActionResult` into its own state.
+ *
+ * It presents the diagnostics of the referenced action's **most recent invocation**:
+ *
+ * - a failed invocation replaces whatever was there with its own diagnostics;
+ * - a successful one replaces them with nothing, so the message clears;
+ * - a declined confirmation is recorded as `cancelled` and likewise presents nothing;
+ * - the record is cleared by `clearDiagnostics()` and by navigating to another route.
+ *
+ * The messages come from the structured diagnostics — `failureMode.message` for a refused
+ * guard, `ConstraintDef.message` for a broken invariant — never from wording in the
+ * renderer.
+ */
+export interface DiagnosticNode extends UIBase {
+    kind: 'diagnostic';
+    /** The action whose most recent invocation is reported. */
+    actionId: NodeId;
+    /**
+     * The lowest severity presented. `'error'` (the default) presents only errors;
+     * `'warning'` presents warnings as well.
+     */
+    severity?: 'error' | 'warning';
+}
+export type UINode = ViewNode | ContainerNode | TextNode | RepeatNode | FieldDisplayNode | FormNode | InputNode | ButtonNode | ConditionalNode | DiagnosticNode;
 export declare function isUINode(node: {
     kind: string;
 }): node is UINode;
+/**
+ * Children along the **primary render path**: the arrangement that appears when every
+ * collection has members and every condition holds.
+ *
+ * An empty template and a false branch are *alternatives* to that path, not part of it.
+ * Analysis of structure that is on screen together — a document outline, the sections of a
+ * form — walks this rather than `uiChildIds`, which is what keeps it free of findings about
+ * content that never appears at the same time.
+ */
+export declare function primaryChildIds(node: UINode): NodeId[];
 /** Child ids declared by a UI node, in render order. */
 export declare function uiChildIds(node: UINode): NodeId[];
 //# sourceMappingURL=ui.d.ts.map

package/dist/ui.js

@@ -8,10 +8,30 @@ export const UI_NODE_KINDS = [
     'input',
     'button',
     'conditional',
+    'diagnostic',
 ];
 export function isUINode(node) {
     return UI_NODE_KINDS.includes(node.kind);
 }
+/**
+ * Children along the **primary render path**: the arrangement that appears when every
+ * collection has members and every condition holds.
+ *
+ * An empty template and a false branch are *alternatives* to that path, not part of it.
+ * Analysis of structure that is on screen together — a document outline, the sections of a
+ * form — walks this rather than `uiChildIds`, which is what keeps it free of findings about
+ * content that never appears at the same time.
+ */
+export function primaryChildIds(node) {
+    switch (node.kind) {
+        case 'repeat':
+            return [node.templateId];
+        case 'conditional':
+            return [...node.whenTrue];
+        default:
+            return uiChildIds(node);
+    }
+}
 /** Child ids declared by a UI node, in render order. */
 export function uiChildIds(node) {
     switch (node.kind) {

package/dist/validate-location.js

@@ -1,5 +1,5 @@
 import { VALIDATION_CODES } from './diagnostics.js';
-import { inferLocationType, locationCapabilities } from './infer.js';
+import { inferExpressionType, inferLocationType, locationCapabilities } from './infer.js';
 import { locationRootStateId } from './location.js';
 /**
  * Structural validation of a location: does every state, field and selector it names
@@ -58,6 +58,15 @@ function walk(location, context, report) {
                 return;
             }
             if (location.selector.kind !== 'identity') {
+                // An index has to be a number. Type inference is partial, so this rejects only
+                // what is statically certain to be wrong.
+                const indexType = inferExpressionType(location.selector.index, context);
+                const resolvedIndex = indexType?.kind === 'optional' ? indexType.valueType : indexType;
+                const numeric = resolvedIndex === undefined ||
+                    (resolvedIndex.kind === 'primitive' && resolvedIndex.primitive === 'number');
+                if (!numeric) {
+                    report(VALIDATION_CODES.invalidSelectorType, `An index selector must be a number, but this one is a ${resolvedIndex.kind === 'primitive' ? resolvedIndex.primitive : resolvedIndex.kind} value`);
+                }
                 return;
             }
             const entry = context.getField(location.selector.fieldId);

package/dist/validate-presentation.js

@@ -1,8 +1,8 @@
 import { VALIDATION_CODES } from './diagnostics.js';
-import { ALIGNMENTS, BOUNDED_SIZES, CONTROL_VARIANTS, DENSITIES, DEVICE_CLASSES, EMPHASIS_LEVELS, ICON_NAMES, JUSTIFICATIONS, LAYOUT_KINDS, PRESENTATION_ROLES, SIZING_VALUES, SPACING_TOKENS, SURFACE_ROLES, TEXT_ROLES, TREATMENTS, UX_ROLES, VALUE_FORMAT_KINDS, } from './presentation.js';
+import { ACTION_UX_ROLES, ALIGNMENTS, BOUNDED_SIZES, CONTROL_VARIANTS, DENSITIES, DEVICE_CLASSES, EMPHASIS_LEVELS, ICON_NAMES, JUSTIFICATIONS, LAYOUT_KINDS, PRESENTATION_ROLES, SIZING_VALUES, SPACING_TOKENS, SURFACE_ROLES, TEXT_ROLES, TREATMENTS, HEADING_LEVELS, UX_ROLES, VALUE_FORMAT_KINDS, } from './presentation.js';
 import { isDestructiveAction } from './resolve-presentation.js';
 import { APPEARANCES, RADIUS_TOKENS, SEMANTIC_COLOR_ROLES } from './theme.js';
-import { isUINode, uiChildIds } from './ui.js';
+import { isUINode, primaryChildIds, uiChildIds } from './ui.js';
 /** More than this many controls side by side stops being a group and becomes a wall. */
 const HORIZONTAL_ACTION_LIMIT = 5;
 /** Below this a non-wrapping row is not yet a responsive problem. */
@@ -12,6 +12,7 @@ const PRESENTATION_KEYS = [
     'emphasis',
     'density',
     'textRole',
+    'headingLevel',
     'uxRole',
     'surface',
     'treatment',
@@ -158,6 +159,9 @@ function checkPresentationTokens(bag, nodeId, presentation) {
     checkToken(bag, nodeId, `${path}.emphasis`, declared.emphasis, EMPHASIS_LEVELS);
     checkToken(bag, nodeId, `${path}.density`, declared.density, ACCEPTED_DENSITIES);
     checkToken(bag, nodeId, `${path}.textRole`, declared.textRole, TEXT_ROLES);
+    if (declared.headingLevel !== undefined && !HEADING_LEVELS.includes(declared.headingLevel)) {
+        unknown(bag, nodeId, `${path}.headingLevel`, declared.headingLevel, HEADING_LEVELS.map(String));
+    }
     checkToken(bag, nodeId, `${path}.uxRole`, declared.uxRole, UX_ROLES);
     checkToken(bag, nodeId, `${path}.surface`, declared.surface, SURFACE_ROLES);
     checkToken(bag, nodeId, `${path}.treatment`, declared.treatment, TREATMENTS);
@@ -215,6 +219,7 @@ function checkTheme(bag, theme) {
         'sizes',
         'surfaces',
         'controls',
+        'buttons',
         'density',
         'colors',
         'responsive',
@@ -274,6 +279,25 @@ function checkTheme(bag, theme) {
             checkKeys(bag, undefined, 'theme.typography.emphasis', declared.typography.emphasis, EMPHASIS_LEVELS);
         }
     }
+    if (isRecord(declared.buttons)) {
+        const buttons = declared.buttons;
+        checkKeys(bag, undefined, 'theme.buttons', buttons, [
+            'layout',
+            'gap',
+            'align',
+            'justify',
+            'paddingScale',
+            'iconPlacement',
+        ]);
+        checkToken(bag, undefined, 'theme.buttons.layout', buttons.layout, LAYOUT_KINDS);
+        checkToken(bag, undefined, 'theme.buttons.gap', buttons.gap, SPACING_TOKENS);
+        checkToken(bag, undefined, 'theme.buttons.align', buttons.align, ALIGNMENTS);
+        checkToken(bag, undefined, 'theme.buttons.justify', buttons.justify, JUSTIFICATIONS);
+        checkToken(bag, undefined, 'theme.buttons.iconPlacement', buttons.iconPlacement, [
+            'leading',
+            'trailing',
+        ]);
+    }
     if (isRecord(declared.responsive)) {
         checkKeys(bag, undefined, 'theme.responsive', declared.responsive, DEVICE_CLASSES);
     }
@@ -281,15 +305,43 @@ function checkTheme(bag, theme) {
 function buildIndex(nodes) {
     const byId = new Map();
     const children = new Map();
+    const primaryChildren = new Map();
+    const fieldTypes = new Map();
     for (const node of nodes) {
         byId.set(node.id, node);
+        if (node.kind === 'entity') {
+            for (const field of node.fields) {
+                fieldTypes.set(field.id, field.valueType);
+            }
+        }
     }
     for (const node of byId.values()) {
         if (isUINode(node)) {
             children.set(node.id, uiChildIds(node));
+            primaryChildren.set(node.id, primaryChildIds(node));
         }
     }
-    return { nodes: byId, children };
+    return { nodes: byId, children, primaryChildren, fieldTypes };
+}
+/** UI nodes along the primary render path, in render order. */
+function primaryDescendants(index, id) {
+    const found = [];
+    const seen = new Set([id]);
+    const visit = (current) => {
+        for (const childId of index.primaryChildren.get(current) ?? []) {
+            if (seen.has(childId)) {
+                continue;
+            }
+            seen.add(childId);
+            const child = index.nodes.get(childId);
+            if (child && isUINode(child)) {
+                found.push(child);
+                visit(childId);
+            }
+        }
+    };
+    visit(id);
+    return found;
 }
 function descendants(index, id) {
     const found = [];
@@ -366,6 +418,7 @@ export function validatePresentation(nodes, theme, resolved) {
         checkRigidLayout(bag, index, node, view);
         checkAccessibleName(bag, node);
         checkDestructive(bag, node, view, actions);
+        checkNodeCompatibility(bag, index, node, actions);
         checkEmptyState(bag, index, node, view);
     }
     checkPrimaryActions(bag, index, resolved);
@@ -431,6 +484,128 @@ function checkAccessibleName(bag, node) {
         nodeId: node.id,
     });
 }
+/** UX roles that describe a control's place in the action hierarchy. */
+const CONTROL_ONLY_UX_ROLES = new Set(ACTION_UX_ROLES);
+/** UX roles that describe a region containing other nodes. */
+const REGION_UX_ROLES = new Set([
+    'form-section',
+    'action-group',
+    'navigation-group',
+    'toolbar',
+    'sidebar',
+    'content-region',
+    'header-region',
+    'footer-region',
+]);
+/** Node kinds that can contain other UI nodes. */
+const CONTAINING_KINDS = new Set(['view', 'container', 'form', 'conditional', 'repeat']);
+/** Node kinds that render a value, and can therefore be formatted or given a treatment. */
+const VALUE_KINDS = new Set(['text', 'field-display']);
+/** Whether an action navigates, directly or through one level of invocation. */
+function navigates(action, actions, depth = 1) {
+    for (const operation of action.operations ?? []) {
+        if (operation.kind === 'navigate') {
+            return true;
+        }
+        if (operation.kind === 'invoke' && depth > 0) {
+            const target = actions.get(operation.actionId);
+            if (target && navigates(target, actions, depth - 1)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+/** Whether a format could describe a value of this type. */
+function formatFits(format, type) {
+    if (!type) {
+        return true;
+    }
+    const resolved = type.kind === 'optional' ? type.valueType : type;
+    if (resolved.kind === 'collection' || resolved.kind === 'entity') {
+        return format.kind === 'text';
+    }
+    if (resolved.kind === 'enum') {
+        return format.kind === 'text' || format.kind === 'boolean';
+    }
+    if (resolved.kind !== 'primitive') {
+        return true;
+    }
+    switch (format.kind) {
+        case 'number':
+        case 'currency':
+        case 'percentage':
+            return resolved.primitive === 'number';
+        case 'boolean':
+            return resolved.primitive === 'boolean';
+        case 'date':
+        case 'datetime':
+            return resolved.primitive === 'date' || resolved.primitive === 'datetime';
+        default:
+            return true;
+    }
+}
+/**
+ * Presentation that contradicts what the node it sits on actually is.
+ *
+ * Every check here is decided from the graph alone — a role that only a control can have,
+ * a region role on something that holds no children, a format that could never describe
+ * the declared type. Nothing here is a heuristic about taste.
+ */
+function checkNodeCompatibility(bag, index, node, actions) {
+    const declared = node.presentation;
+    if (!declared) {
+        return;
+    }
+    const conflict = (message, details) => {
+        bag.warnings.push({
+            code: VALIDATION_CODES.presentationSemanticConflict,
+            message: `${node.name ?? node.id} ${message}`,
+            nodeId: node.id,
+            details: { kind: node.kind, ...details },
+        });
+    };
+    if (declared.uxRole && CONTROL_ONLY_UX_ROLES.has(declared.uxRole) && node.kind !== 'button') {
+        conflict(`is a ${node.kind}, which cannot be a "${declared.uxRole}"`, { uxRole: declared.uxRole });
+    }
+    if (declared.uxRole && REGION_UX_ROLES.has(declared.uxRole) && !CONTAINING_KINDS.has(node.kind)) {
+        conflict(`is presented as a "${declared.uxRole}" but holds no children`, {
+            uxRole: declared.uxRole,
+        });
+    }
+    if (declared.uxRole === 'navigation-action' && node.kind === 'button') {
+        const action = actions.get(node.actionId);
+        if (action && !navigates(action, actions)) {
+            conflict(`is presented as navigation but ${action.name ?? action.id} does not navigate`, {
+                uxRole: 'navigation-action',
+                actionId: node.actionId,
+            });
+        }
+    }
+    if (declared.treatment && declared.treatment !== 'plain' && !VALUE_KINDS.has(node.kind)) {
+        conflict(`is a ${node.kind}, which renders no value to present as a "${declared.treatment}"`, {
+            treatment: declared.treatment,
+        });
+    }
+    if (declared.format && !VALUE_KINDS.has(node.kind)) {
+        conflict(`is a ${node.kind}, which renders no value to format`, { format: declared.format.kind });
+    }
+    if (declared.format && node.kind === 'field-display') {
+        const type = index.fieldTypes.get(node.fieldId);
+        if (!formatFits(declared.format, type)) {
+            conflict(`formats ${node.fieldId} as ${declared.format.kind}, which its declared type is not`, {
+                format: declared.format.kind,
+                fieldId: node.fieldId,
+            });
+        }
+    }
+    if (declared.control && node.kind !== 'input') {
+        conflict(`is a ${node.kind}, which is not edited by a control`, { control: declared.control });
+    }
+    if (typeof declared.headingLevel === 'number' && node.kind !== 'text') {
+        conflict(`is a ${node.kind}, which cannot be a heading`, { headingLevel: declared.headingLevel });
+    }
+}
 function checkDestructive(bag, node, view, actions) {
     if (node.kind !== 'button') {
         return;
@@ -516,21 +691,52 @@ function checkPrimaryActions(bag, index, resolved) {
         }
     }
 }
-/** A view that has section headings but no title of its own has no top of the outline. */
+/**
+ * The document outline of each view, checked on **resolved heading levels** rather than on
+ * rendered markup.
+ *
+ * Only the primary render path is walked: an empty template and a false branch are
+ * alternatives to the outline, not part of it, so including them would report headings
+ * that are never on screen together.
+ */
 function checkHeadingStructure(bag, index, resolved) {
     for (const node of index.nodes.values()) {
         if (!isUINode(node) || node.kind !== 'view') {
             continue;
         }
-        const roles = descendants(index, node.id)
-            .filter((child) => child.kind === 'text')
-            .map((child) => resolved[child.id]?.textRole);
-        if (roles.includes('heading') && !roles.includes('title') && !roles.includes('display')) {
+        const levels = [];
+        for (const child of primaryDescendants(index, node.id)) {
+            const level = resolved[child.id]?.headingLevel;
+            if (typeof level === 'number') {
+                levels.push(level);
+            }
+        }
+        if (levels.length === 0) {
+            // A view with no headings at all has no outline to be wrong about.
+            continue;
+        }
+        const report = (message, details) => {
             bag.warnings.push({
                 code: VALIDATION_CODES.invalidHeadingStructure,
-                message: `View ${node.name ?? node.id} has section headings but no title above them`,
+                message: `View ${node.name ?? node.id} ${message}`,
                 nodeId: node.id,
+                details: { levels: [...levels], ...details },
             });
+        };
+        const primary = levels.filter((level) => level === 1).length;
+        if (primary === 0) {
+            report('has headings but no level-1 heading', { primaryHeadings: 0 });
+        }
+        else if (primary > 1) {
+            report(`has ${primary} level-1 headings`, { primaryHeadings: primary });
+        }
+        let previous = 0;
+        for (const level of levels) {
+            if (previous !== 0 && level > previous + 1) {
+                report(`skips from heading level ${previous} to ${level}`, { from: previous, to: level });
+                break;
+            }
+            previous = level;
         }
     }
 }

package/dist/validate.js

@@ -493,12 +493,39 @@ function validateUiNode(node, context) {
             validateExpression(node.source, node.id, context, new Set());
             requireField(node.fieldId, node.id, context);
             return;
-        case 'form':
+        case 'form': {
             validateExpression(node.target, node.id, context, new Set());
             if (node.submitActionId) {
                 requireKind(node.submitActionId, 'action', node.id, context, VALIDATION_CODES.invalidActionRef);
             }
+            if (node.submitButtonId) {
+                const button = context.nodes.get(node.submitButtonId);
+                if (button?.kind !== 'button') {
+                    context.errors.push({
+                        code: VALIDATION_CODES.invalidUiChild,
+                        message: `Form ${node.id} names ${node.submitButtonId} as its submit control, which is not a button`,
+                        nodeId: node.id,
+                    });
+                }
+                else {
+                    if (!uiDescendants(node.id, context).has(node.submitButtonId)) {
+                        context.errors.push({
+                            code: VALIDATION_CODES.invalidUiChild,
+                            message: `Form ${node.id} names ${node.submitButtonId} as its submit control, but that button is not inside the form`,
+                            nodeId: node.id,
+                        });
+                    }
+                    if (node.submitActionId && button.actionId !== node.submitActionId) {
+                        context.errors.push({
+                            code: VALIDATION_CODES.invalidActionRef,
+                            message: `Form ${node.id} submits ${node.submitActionId} but its submit control invokes ${button.actionId}`,
+                            nodeId: node.id,
+                        });
+                    }
+                }
+            }
             return;
+        }
         case 'input':
             if (!node.binding?.location) {
                 context.errors.push({
@@ -538,9 +565,31 @@ function validateUiNode(node, context) {
         case 'conditional':
             validateExpression(node.condition, node.id, context, new Set());
             return;
+        case 'diagnostic':
+            requireKind(node.actionId, 'action', node.id, context, VALIDATION_CODES.invalidActionRef);
+            return;
         default:
     }
 }
+/** Every UI node beneath this one, for checks that must know what a subtree contains. */
+function uiDescendants(id, context) {
+    const found = new Set();
+    const visit = (current) => {
+        const node = context.nodes.get(current);
+        if (!node || !isUINode(node)) {
+            return;
+        }
+        for (const childId of uiChildIds(node)) {
+            if (found.has(childId)) {
+                continue;
+            }
+            found.add(childId);
+            visit(childId);
+        }
+    };
+    visit(id);
+    return found;
+}
 function validateEdges(context) {
     for (const edge of context.graph.listEdges()) {
         if (!EDGE_KINDS.includes(edge.kind)) {

package/package.json

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