@nowline/lsp 0.8.6 → 0.10.0

package/src/providers/document-symbols.ts

@@ -13,11 +13,13 @@ import {
     isStatusDeclaration,
     isSwimlaneDeclaration,
     isTeamDeclaration,
+    isWaveDeclaration,
     type ParallelBlock,
     type RoadmapDeclaration,
-    type SwimlaneContent,
     type SwimlaneDeclaration,
+    singleLine,
 } from '@nowline/core';
+import { type TrackNode, trackChildren } from '@nowline/core/internal';
 import type { AstNode, LangiumDocument, MaybePromise } from 'langium';
 import type { DocumentSymbolProvider } from 'langium/lsp';
 import type {
@@ -30,10 +32,20 @@ import { SymbolKind } from '../lsp-protocol.js';
 import type { NowlineLspServices } from '../nowline-lsp-module.js';
 import { entityKind, fileFromDocument, nameRangeOf } from '../references/ast-utils.js';
 
+/**
+ * An outline entry is one line of text, but a quoted title can carry
+ * explicit line breaks (`"Technology\nSelection"`), so each break is shown
+ * as a single space. `undefined` stays `undefined` so callers can fall back
+ * (as they must for a title that was only line breaks, which collapses to '').
+ */
+function singleLineTitle(title: string | undefined): string | undefined {
+    return title === undefined ? undefined : singleLine(title);
+}
+
 /**
  * Outline view: roadmap → swimlanes → items, with parallel/group nesting and
  * top-level anchors / milestones / footnotes / people / teams / labels /
- * sizes / statuses surfaced as siblings of the swimlanes. Mirrors the layout
+ * sizes / statuses / waves surfaced as siblings of the swimlanes. Mirrors the layout
  * engine's traversal so what authors see in the outline matches what gets
  * rendered.
  */
@@ -71,8 +83,8 @@ export class NowlineDocumentSymbolProvider implements DocumentSymbolProvider {
         const range = roadmap.$cstNode!.range;
         const nameRange = nameRangeOf(roadmap) ?? range;
         return {
-            name: roadmap.name ?? roadmap.title ?? 'roadmap',
-            detail: roadmap.title && roadmap.name ? roadmap.title : 'roadmap',
+            name: roadmap.name ?? (singleLineTitle(roadmap.title) || 'roadmap'),
+            detail: roadmap.title && roadmap.name ? singleLine(roadmap.title) : 'roadmap',
             kind: SymbolKind.Package,
             range,
             selectionRange: nameRange,
@@ -90,19 +102,15 @@ export class NowlineDocumentSymbolProvider implements DocumentSymbolProvider {
         if (isLabelDeclaration(entry)) return this.simpleSymbol(entry, SymbolKind.EnumMember);
         if (isSizeDeclaration(entry)) return this.simpleSymbol(entry, SymbolKind.Number);
         if (isStatusDeclaration(entry)) return this.simpleSymbol(entry, SymbolKind.Enum);
+        if (isWaveDeclaration(entry)) return this.simpleSymbol(entry, SymbolKind.Struct);
         return undefined;
     }
 
     private swimlaneSymbol(lane: SwimlaneDeclaration): DocumentSymbol {
-        const sym = this.simpleSymbol(lane, SymbolKind.Namespace, true);
-        for (const child of lane.content) {
-            const sub = this.trackChildSymbol(child);
-            if (sub) sym.children!.push(sub);
-        }
-        return sym;
+        return this.withTrackChildren(this.simpleSymbol(lane, SymbolKind.Namespace, true), lane);
     }
 
-    private trackChildSymbol(child: SwimlaneContent): DocumentSymbol | undefined {
+    private trackChildSymbol(child: TrackNode): DocumentSymbol | undefined {
         if (isItemDeclaration(child)) return this.itemSymbol(child);
         if (isParallelBlock(child)) return this.parallelSymbol(child);
         if (isGroupBlock(child)) return this.groupSymbol(child);
@@ -114,17 +122,19 @@ export class NowlineDocumentSymbolProvider implements DocumentSymbolProvider {
     }
 
     private parallelSymbol(node: ParallelBlock): DocumentSymbol {
-        const sym = this.simpleSymbol(node, SymbolKind.Array, true);
-        for (const child of node.content) {
-            const sub = this.trackChildSymbol(child);
-            if (sub) sym.children!.push(sub);
-        }
-        return sym;
+        return this.withTrackChildren(this.simpleSymbol(node, SymbolKind.Array, true), node);
     }
 
     private groupSymbol(node: GroupBlock): DocumentSymbol {
-        const sym = this.simpleSymbol(node, SymbolKind.Object, true);
-        for (const child of node.content) {
+        return this.withTrackChildren(this.simpleSymbol(node, SymbolKind.Object, true), node);
+    }
+
+    // The container's track children (descriptions skipped) as nested symbols.
+    private withTrackChildren(
+        sym: DocumentSymbol,
+        container: SwimlaneDeclaration | GroupBlock | ParallelBlock,
+    ): DocumentSymbol {
+        for (const child of trackChildren(container)) {
             const sub = this.trackChildSymbol(child);
             if (sub) sym.children!.push(sub);
         }
@@ -137,8 +147,8 @@ export class NowlineDocumentSymbolProvider implements DocumentSymbolProvider {
         withChildrenSlot = false,
     ): DocumentSymbol {
         const range: Range = entity.$cstNode!.range;
-        const name = entity.name ?? entity.title ?? entityKind(entity);
-        const detail = entity.title && entity.name ? entity.title : entityKind(entity);
+        const name = entity.name ?? (singleLineTitle(entity.title) || entityKind(entity));
+        const detail = entity.title && entity.name ? singleLine(entity.title) : entityKind(entity);
         const symbol: DocumentSymbol = {
             name,
             detail,

package/src/providers/hover.ts

@@ -1,4 +1,21 @@
-import type { LangiumDocument, MaybePromise } from 'langium';
+import {
+    assignWaves,
+    isGroupBlock,
+    isItemDeclaration,
+    isNonWorkingDeclaration,
+    isParallelBlock,
+    isSwimlaneDeclaration,
+    isWaveDeclaration,
+    isWorkingDeclaration,
+    type NowlineFile,
+    ownWaves,
+    singleLine,
+    type WaveAssignment,
+    type WaveDeclaration,
+    waveIndexMap,
+} from '@nowline/core';
+import { classifyCalendarDeclaration } from '@nowline/core/internal';
+import type { AstNode, LangiumDocument, MaybePromise } from 'langium';
 import type { HoverProvider } from 'langium/lsp';
 import type { CancellationToken, Hover, HoverParams, Range } from '../lsp-protocol.js';
 import { MarkupKind } from '../lsp-protocol.js';
@@ -8,6 +25,7 @@ import {
     declarationAt,
     entityKind,
     fileFromDocument,
+    isCalendarDeclaration,
     leafAt,
     type NamedEntity,
     propertyValueAt,
@@ -22,6 +40,15 @@ import {
  *
  *  - The `name=ID` token of an entity declaration.
  *  - The value of a reference property (`after:`, `before:`, `owner:`, etc.).
+ *
+ * Waves (specs/waves.md): a wave shows its position (`wave k of n`), title,
+ * description and member count; an item in a roadmap with waves shows its
+ * effective wave, or `background (no wave)`. Waves come from the file's own
+ * declarations only — the LSP does not resolve includes.
+ *
+ * Calendar declarations (`non-working`, `working`, specs/working-calendar.md):
+ * the declaration shows its id, title, and `date`, `every`, `start` and `end`,
+ * plus a note when its title is never drawn on the chart (§7.4).
  */
 export class NowlineHoverProvider implements HoverProvider {
     constructor(_services: NowlineLspServices) {
@@ -40,19 +67,19 @@ export class NowlineHoverProvider implements HoverProvider {
         if (!leaf) return undefined;
 
         const decl = declarationAt(leaf);
-        if (decl) return this.hoverFor(decl, leaf.range);
+        if (decl) return this.hoverFor(file, decl, leaf.range);
 
         const propHit = propertyValueAt(leaf);
         if (propHit && REFERENCE_PROP_KEYS.has(propKey(propHit.prop))) {
             const target = buildEntityIndex(file).get(propHit.value);
             if (!target) return undefined;
-            return this.hoverFor(target, leaf.range);
+            return this.hoverFor(file, target, leaf.range);
         }
 
         return undefined;
     }
 
-    private hoverFor(entity: NamedEntity, range: Range): Hover {
+    private hoverFor(file: NowlineFile, entity: NamedEntity, range: Range): Hover {
         const kind = entityKind(entity);
         const id = entity.name ?? '';
         const title = entity.title;
@@ -61,20 +88,14 @@ export class NowlineHoverProvider implements HoverProvider {
         const header = id ? `**${kind} \`${id}\`**` : `**${kind}**`;
         lines.push(header);
         if (title) lines.push(`_${title}_`);
+        // Own paragraph so Markdown does not fold the wave lines into the title.
+        const waveInfo = waveLines(file, entity);
+        if (waveInfo.length) lines.push('', ...waveInfo);
 
         const props =
             (entity as { properties?: { key: string; value?: string; values?: string[] }[] })
                 .properties ?? [];
-        const surfaced = [
-            'status',
-            'owner',
-            'link',
-            'date',
-            'duration',
-            'size',
-            'effort',
-            'capacity',
-        ];
+        const surfaced = isCalendarDeclaration(entity) ? CALENDAR_SURFACED : ITEM_SURFACED;
         const rendered: string[] = [];
         for (const key of surfaced) {
             const prop = props.find((p) => propKey(p as { key: string }) === key);
@@ -86,6 +107,8 @@ export class NowlineHoverProvider implements HoverProvider {
             lines.push('');
             lines.push(...rendered);
         }
+        const note = undrawnTitleNote(entity);
+        if (note) lines.push('', `_${note}_`);
 
         return {
             range,
@@ -96,3 +119,90 @@ export class NowlineHoverProvider implements HoverProvider {
         };
     }
 }
+
+const ITEM_SURFACED = ['status', 'owner', 'link', 'date', 'duration', 'size', 'effort', 'capacity'];
+
+// A `non-working` / `working` declaration is described by its days, not by an
+// item's status or duration (specs/working-calendar.md §4.1).
+const CALENDAR_SURFACED = ['date', 'every', 'start', 'end'];
+
+/**
+ * Why a calendar declaration's title is never drawn, or undefined when it is
+ * drawn, there is no title, or the shape is malformed (NW1, §4.1; core's
+ * `classifyCalendarDeclaration` reads the shape). Dated,
+ * titled declarations are labelled, `non-working` or `working`; a titled
+ * bounded recurrence is not (specs/working-calendar.md §7.4 "Which rules are
+ * labelled"). The open-ended week is the baseline and gets no note.
+ */
+function undrawnTitleNote(entity: NamedEntity): string | undefined {
+    if (!isNonWorkingDeclaration(entity) && !isWorkingDeclaration(entity)) return undefined;
+    if (!entity.title) return undefined;
+    const { shape } = classifyCalendarDeclaration(entity);
+    if (shape === 'half-bounded-recurrence' || shape === 'bounded-recurrence') {
+        return 'Title not drawn on the chart: bounded recurrences are not labelled.';
+    }
+    return undefined;
+}
+
+/**
+ * Wave lines for the hover: the wave summary on a wave declaration, the
+ * effective wave on an item. Empty when the file declares no waves.
+ */
+function waveLines(file: NowlineFile, entity: NamedEntity): string[] {
+    if (!isWaveDeclaration(entity) && !isItemDeclaration(entity)) return [];
+    const waves = ownWaves(file);
+    if (waves.length === 0) return [];
+    const waveIds = waveIndexMap(file);
+    const lanes = file.roadmapEntries.filter(isSwimlaneDeclaration);
+    const assignment = assignWaves(lanes, waveIds);
+    if (isWaveDeclaration(entity)) return waveSummary(entity, waves, waveIds, assignment);
+    const ew = assignment.waveOf.get(entity);
+    if (ew === undefined) return ['background (no wave)'];
+    const wave = waves[ew - 1];
+    const source = waveSource(entity, assignment);
+    if (source === entity) return [`wave "${wave.name}"`];
+    return [`wave "${wave.name}" (inherited from ${describeContainer(source)})`];
+}
+
+function waveSummary(
+    wave: WaveDeclaration,
+    waves: readonly WaveDeclaration[],
+    waveIds: ReadonlyMap<string, number>,
+    assignment: WaveAssignment,
+): string[] {
+    const k = wave.name ? waveIds.get(wave.name) : undefined;
+    // A repeated wave id (NL.E0300) only counts its first declaration.
+    if (k === undefined || waves[k - 1] !== wave) return [];
+    const lines = [`wave ${k} of ${waves.length}`];
+    if (wave.description?.text) lines.push('', wave.description.text);
+    let members = 0;
+    for (const [node, ew] of assignment.waveOf) {
+        if (ew === k && isItemDeclaration(node)) members++;
+    }
+    lines.push('', `${members} ${members === 1 ? 'member' : 'members'}`);
+    const labels = wave.properties.find((p) => propKey(p) === 'labels');
+    const labelIds = labels?.values ?? (labels?.value ? [labels.value] : []);
+    if (labelIds.length) lines.push('', `labels: ${labelIds.join(', ')}`);
+    return lines;
+}
+
+// The node that sets an item's effective wave: the outermost of the item and
+// its enclosing groups / parallels that has one. An enclosing container's wave
+// wins over the item's own (specs/waves.md §4.4), and it reaches the item only
+// through the containers in between.
+function waveSource(item: AstNode, assignment: WaveAssignment): AstNode {
+    let source = item;
+    let node = item.$container;
+    while ((isGroupBlock(node) || isParallelBlock(node)) && assignment.waveOf.has(node)) {
+        source = node;
+        node = node.$container;
+    }
+    return source;
+}
+
+function describeContainer(node: AstNode): string {
+    const kind = entityKind(node);
+    const named = node as { name?: string; title?: string };
+    const label = named.name ?? (named.title === undefined ? undefined : singleLine(named.title));
+    return label ? `${kind} "${label}"` : kind;
+}

package/src/providers/references.ts

@@ -8,6 +8,7 @@ import {
     declarationAt,
     fileFromDocument,
     findDeclarationRange,
+    isCalendarDeclaration,
     leafAt,
     propertyValueAt,
     propKey,
@@ -66,6 +67,7 @@ export class NowlineReferencesProvider implements ReferencesProvider {
 
 function resolveTargetId(leaf: CstNode): string | undefined {
     const decl = declarationAt(leaf);
+    if (decl && isCalendarDeclaration(decl)) return undefined;
     if (decl?.name) return decl.name;
     const propHit = propertyValueAt(leaf);
     if (propHit && REFERENCE_PROP_KEYS.has(propKey(propHit.prop))) {

package/src/providers/rename.ts

@@ -16,6 +16,7 @@ import {
     declarationAt,
     fileFromDocument,
     findDeclarationRange,
+    isCalendarDeclaration,
     leafAt,
     propertyValueAt,
     propKey,
@@ -93,7 +94,7 @@ function renameRangeAt(document: LangiumDocument, position: Position): RenameTar
     const leaf = leafAt(document, offset);
     if (!leaf) return undefined;
     const decl = declarationAt(leaf);
-    if (decl?.name === leaf.text) {
+    if (decl && !isCalendarDeclaration(decl) && decl.name === leaf.text) {
         return { id: decl.name, range: leaf.range };
     }
     const hit = propertyValueAt(leaf);

package/src/references/ast-utils.ts

@@ -3,21 +3,21 @@ import type {
     EntityProperty,
     FootnoteDeclaration,
     GroupBlock,
-    GroupContent,
     ItemDeclaration,
     LabelDeclaration,
     MilestoneDeclaration,
+    NonWorkingDeclaration,
     NowlineFile,
     ParallelBlock,
-    ParallelContent,
     PersonDeclaration,
     SizeDeclaration,
     StatusDeclaration,
     StyleDeclaration,
-    SwimlaneContent,
     SwimlaneDeclaration,
     SymbolDeclaration,
     TeamDeclaration,
+    WaveDeclaration,
+    WorkingDeclaration,
 } from '@nowline/core';
 import {
     isAnchorDeclaration,
@@ -26,19 +26,22 @@ import {
     isItemDeclaration,
     isLabelDeclaration,
     isMilestoneDeclaration,
+    isNonWorkingDeclaration,
     isNowlineFile,
     isParallelBlock,
     isPersonDeclaration,
-    isPersonMemberRef,
     isSizeDeclaration,
     isStatusDeclaration,
     isStyleDeclaration,
     isSwimlaneDeclaration,
     isSymbolDeclaration,
     isTeamDeclaration,
+    isWaveDeclaration,
+    isWorkingDeclaration,
 } from '@nowline/core';
+import { declarations, propKey, visitProperties } from '@nowline/core/internal';
 import type { AstNode, CstNode, LangiumDocument } from 'langium';
-import { CstUtils } from 'langium';
+import { CstUtils, GrammarUtils } from 'langium';
 import type { Range } from '../lsp-protocol.js';
 
 /**
@@ -49,7 +52,7 @@ import type { Range } from '../lsp-protocol.js';
  * Wider than the validator's `checkReferenceResolution` (which is strict only
  * for sequencing — `after` / `before` / `on`). Categorisation references
  * (`size` / `status` / `style` / `labels`), decoration references
- * (`icon` / `capacity-icon`), and ownership references (`owner` / `team`) are
+ * (`icon` / `capacity-icon`), and the ownership reference (`owner`) are
  * permissive in the validator (an undeclared id is not an error) but still
  * navigable when a declaration exists.
  *
@@ -57,60 +60,44 @@ import type { Range } from '../lsp-protocol.js';
  * form was removed in favor of the spec-mandated reverse direction.
  * Footnote association flows only from the footnote declaration's `on:`,
  * and the validator now rejects `footnote:` as a property on host entities.
+ *
+ * Every key here must be one the validator accepts; `reference-keys.test.ts`
+ * checks that.
  */
 export const REFERENCE_PROP_KEYS = new Set([
     'after',
     'before',
-    'depends',
     'on',
     'owner',
-    'team',
     'size',
     'status',
     'style',
     'labels',
     'icon',
     'capacity-icon',
+    'wave',
 ]);
 
-/** Status value-completion source: built-in statuses ship with the renderer. */
-export const BUILTIN_STATUSES: readonly string[] = [
-    'planned',
-    'in-progress',
-    'done',
-    'at-risk',
-    'blocked',
-];
-
-/**
- * Built-in `capacity-icon:` vocabulary. Mirrors `BUILTIN_CAPACITY_ICONS` in
- * the validator — kept as a literal here so the LSP doesn't have to import a
- * non-public symbol from `@nowline/core`.
- */
-export const BUILTIN_CAPACITY_ICONS: readonly string[] = [
-    'none',
-    'multiplier',
-    'person',
-    'people',
-    'points',
-    'time',
-];
-
 /**
- * Built-in `icon:` vocabulary. Superset of `BUILTIN_CAPACITY_ICONS` plus the
- * entity-decoration glyphs the renderer ships.
+ * Value-completion sources. The vocabularies are core's (`value-tables.ts`):
+ * the validator checks values against the same lists, so the editor offers
+ * exactly what validates. Kept as `@nowline/lsp` exports. `WEEKDAY_NAMES` is
+ * the weekday names `every:` takes, Sunday first.
  */
-export const BUILTIN_ICON_NAMES: readonly string[] = [
-    ...BUILTIN_CAPACITY_ICONS,
-    'shield',
-    'warning',
-    'lock',
-];
+export {
+    BUILTIN_CAPACITY_ICONS,
+    BUILTIN_ICON_NAMES,
+    BUILTIN_STATUSES,
+    CALENDAR_MODES,
+    COLOR_NAMES,
+    INCLUDE_MODES,
+    NON_WORKING_DISPLAYS,
+    STYLE_PROP_ENUMS,
+    WEEKDAYS as WEEKDAY_NAMES,
+} from '@nowline/core/internal';
 
-/** Strip the trailing `:` an `EntityProperty.key` carries from the grammar. */
-export function propKey(prop: { key: string }): string {
-    return prop.key.endsWith(':') ? prop.key.slice(0, -1) : prop.key;
-}
+/** `prop.key` without a trailing `:` (core's, kept as an `@nowline/lsp` export). */
+export { propKey };
 
 /**
  * Named declaration shapes we expose for navigation. All have `name?: string`,
@@ -119,6 +106,11 @@ export function propKey(prop: { key: string }): string {
  * Includes both roadmap-section declarations (item, swimlane, person, …) and
  * config-section declarations (`style`, `symbol`) so cmd+click on
  * `style:enterprise-style` and `icon:my-symbol` resolves to the right place.
+ *
+ * `non-working` and `working` declarations are here so `declarationAt` (hover)
+ * sees them, but `collectNamedEntities` skips them: nothing references a
+ * calendar declaration by id, so they stay out of reference completion,
+ * definition and rename.
  */
 export type NamedEntity =
     | RoadmapEntryNamed
@@ -126,7 +118,9 @@ export type NamedEntity =
     | ParallelBlock
     | GroupBlock
     | StyleDeclaration
-    | SymbolDeclaration;
+    | SymbolDeclaration
+    | NonWorkingDeclaration
+    | WorkingDeclaration;
 
 type RoadmapEntryNamed =
     | SwimlaneDeclaration
@@ -137,64 +131,33 @@ type RoadmapEntryNamed =
     | TeamDeclaration
     | LabelDeclaration
     | SizeDeclaration
-    | StatusDeclaration;
+    | StatusDeclaration
+    | WaveDeclaration;
 
 /**
- * Walk the `NowlineFile` and collect every entity that owns an `id`. Covers
- * roadmap-section entities (mirrors the validator's `collectReferenceableIds`)
- * plus the named config-section declarations (`style`, `symbol`) so style and
- * symbol references navigate correctly. Anonymous config blocks (`scale`,
- * `calendar`, `default <entity>`) are skipped.
+ * True for a `non-working` or `working` declaration. Hover describes them, but
+ * nothing references a calendar declaration by id, so definition, references
+ * and rename leave them alone.
+ */
+export function isCalendarDeclaration(entity: AstNode): boolean {
+    return isNonWorkingDeclaration(entity) || isWorkingDeclaration(entity);
+}
+
+/**
+ * Collect every entity that owns an `id`, in the order of core's declaration
+ * walk (config entries first, then roadmap entries with their track content or
+ * nested teams): the roadmap-section entities `@nowline/core`'s
+ * `referenceableIds` covers, plus the named config-section declarations
+ * (`style`, `symbol`) so style and symbol references navigate correctly.
+ * The LSP skips the roadmap line itself (not walked here) and the calendar
+ * declarations (`isCalendarDeclaration`); anonymous declarations have no id.
  */
 export function collectNamedEntities(file: NowlineFile): NamedEntity[] {
     const out: NamedEntity[] = [];
-
-    for (const entry of file.configEntries) {
-        if (isStyleDeclaration(entry) && entry.name) out.push(entry);
-        else if (isSymbolDeclaration(entry) && entry.name) out.push(entry);
+    for (const node of declarations(file, { config: true })) {
+        if (!(node as { name?: string }).name || isCalendarDeclaration(node)) continue;
+        out.push(node as NamedEntity);
     }
-
-    const visitTeam = (team: TeamDeclaration) => {
-        if (team.name) out.push(team);
-        for (const c of team.content) {
-            if (isTeamDeclaration(c)) visitTeam(c);
-            // `PersonMemberRef` and `DescriptionDirective` are references / prose,
-            // not declarations — skip.
-            else if (isPersonMemberRef(c)) {
-                /* skip */
-            }
-        }
-    };
-
-    const visitTrackChild = (child: SwimlaneContent | GroupContent | ParallelContent) => {
-        if (isItemDeclaration(child) && child.name) out.push(child);
-        else if (isParallelBlock(child)) {
-            if (child.name) out.push(child);
-            for (const sub of child.content) visitTrackChild(sub);
-        } else if (isGroupBlock(child)) {
-            if (child.name) out.push(child);
-            for (const sub of child.content) visitTrackChild(sub);
-        }
-    };
-
-    for (const entry of file.roadmapEntries) {
-        if (isSwimlaneDeclaration(entry)) {
-            if (entry.name) out.push(entry);
-            for (const c of entry.content) visitTrackChild(c);
-        } else if (isTeamDeclaration(entry)) visitTeam(entry);
-        else if (
-            isPersonDeclaration(entry) ||
-            isAnchorDeclaration(entry) ||
-            isMilestoneDeclaration(entry) ||
-            isFootnoteDeclaration(entry) ||
-            isLabelDeclaration(entry) ||
-            isSizeDeclaration(entry) ||
-            isStatusDeclaration(entry)
-        ) {
-            if (entry.name) out.push(entry);
-        }
-    }
-
     return out;
 }
 
@@ -213,27 +176,7 @@ export function buildEntityIndex(file: NowlineFile): Map<string, NamedEntity> {
 }
 
 /** Visit every `EntityProperty` reachable from a roadmap entry, depth-first. */
-export function visitProperties(
-    node: AstNode,
-    visit: (prop: EntityProperty, owner: AstNode) => void,
-): void {
-    const walk = (n: AstNode): void => {
-        const props = (n as { properties?: EntityProperty[] }).properties;
-        if (Array.isArray(props)) {
-            for (const p of props) visit(p, n);
-        }
-        if (isSwimlaneDeclaration(n)) {
-            for (const c of n.content) walk(c);
-        } else if (isParallelBlock(n) || isGroupBlock(n)) {
-            for (const c of n.content) walk(c);
-        } else if (isTeamDeclaration(n)) {
-            for (const c of n.content) {
-                if (isTeamDeclaration(c) || isPersonDeclaration(c)) walk(c);
-            }
-        }
-    };
-    walk(node);
-}
+export { visitProperties };
 
 /**
  * Iterate every `EntityProperty` in the file, including those on the roadmap
@@ -297,13 +240,16 @@ export function propertyValueAt(
 
 /**
  * When `leaf` is the `name=ID` token of a named entity declaration, return the
- * declaring entity. Returns `undefined` for any other position.
+ * declaring entity. Returns `undefined` for any other position, including the
+ * declaration keyword (`wave wave "W"` names its wave after the keyword).
  */
 export function declarationAt(leaf: CstNode | undefined): NamedEntity | undefined {
     if (!leaf) return undefined;
     const owner = leaf.astNode as AstNode & { name?: string };
     if (!owner || typeof owner.name !== 'string') return undefined;
     if (owner.name !== leaf.text) return undefined;
+    const nameNode = nameNodeOf(owner);
+    if (!nameNode || leaf.offset < nameNode.offset || leaf.end > nameNode.end) return undefined;
     if (
         isSwimlaneDeclaration(owner) ||
         isItemDeclaration(owner) ||
@@ -317,8 +263,11 @@ export function declarationAt(leaf: CstNode | undefined): NamedEntity | undefine
         isLabelDeclaration(owner) ||
         isSizeDeclaration(owner) ||
         isStatusDeclaration(owner) ||
+        isWaveDeclaration(owner) ||
         isStyleDeclaration(owner) ||
-        isSymbolDeclaration(owner)
+        isSymbolDeclaration(owner) ||
+        isNonWorkingDeclaration(owner) ||
+        isWorkingDeclaration(owner)
     ) {
         return owner as NamedEntity;
     }
@@ -348,6 +297,8 @@ export function findDeclarationRange(file: NowlineFile, id: string): Range | und
  * Render a one-line "type id" label used by hover and document-symbols.
  */
 export function entityKind(entity: AstNode): string {
+    // `NonWorkingDeclaration` would lowercase to `nonworking`; the keyword is hyphenated.
+    if (entity.$type === 'NonWorkingDeclaration') return 'non-working';
     return entity.$type
         .replace(/Declaration$/, '')
         .replace(/Block$/, '')
@@ -355,18 +306,21 @@ export function entityKind(entity: AstNode): string {
 }
 
 /**
- * Find the CST node that holds the given entity's `name=ID` token. Walks the
- * entity's CST subtree and returns the first leaf whose text equals the
- * entity's resolved name. Returns `undefined` when the entity has no `name`
- * (anonymous declaration), no CST node, or no matching leaf.
+ * Find the range of the given entity's `name=ID` token. Uses the grammar
+ * assignment rather than matching leaf text, so a name that equals the
+ * declaration keyword (`wave wave "W"`) resolves to the name, not the
+ * keyword. Returns `undefined` when the entity has no `name` (anonymous
+ * declaration) or no CST node.
  */
 export function nameRangeOf(entity: AstNode): Range | undefined {
+    return nameNodeOf(entity)?.range;
+}
+
+// The CST node assigned to the entity's `name` property.
+function nameNodeOf(entity: AstNode): CstNode | undefined {
     const name = (entity as { name?: string }).name;
     if (!name || !entity.$cstNode) return undefined;
-    for (const leaf of CstUtils.flattenCst(entity.$cstNode)) {
-        if (leaf.text === name) return leaf.range;
-    }
-    return undefined;
+    return GrammarUtils.findNodeForProperty(entity.$cstNode, 'name');
 }
 
 /**