@tikoci/centrs 0.1.9-next.22 → 0.1.9-next.24

package/src/explain/symbols.ts

@@ -308,7 +308,11 @@
 import { analyzeCoordinates } from "./coordinates.ts";
 import { type Defect, defectAt } from "./defects.ts";
 import { isMenuPath } from "./menus.ts";
-import { braceStartsStatements, hashStartsHardError } from "./scope-brace.ts";
+import {
+	braceStartsStatements,
+	hashStartsHardError,
+	startsArrayCommentLine,
+} from "./scope-brace.ts";
 import type { Continuation } from "./segment.ts";
 
 /** The five variable classes the console assigns. */
@@ -415,7 +419,10 @@ interface BracketFrame {
 	pendingSetTarget: boolean;
 	pendingErrVar: boolean;
 	pendingDecl: SymbolClass | null;
+	pendingDeclNameValue: boolean;
 	pendingLoopVars: boolean;
+	loopCounterOpen: boolean;
+	pendingLoopCounterValue: boolean;
 	declaredHere: boolean;
 	headSigil: ":" | "/" | "";
 	cont: Continuation;
@@ -507,6 +514,20 @@ export function resolveSymbols(original: string): SymbolAnalysis {
 		char: "{" | "[" | "(" | '"';
 		at: number;
 		statements: boolean;
+		/**
+		 * #533 reorder — a `{…}` resets the statement it interrupts, but a
+		 * `:for`/`:foreach` head stays open for `counter=` past it (notably a
+		 * `:foreach … in={…}` array), so the flag rides the frame and the
+		 * matching `}` restores it. Only `}` restores: `[` has the
+		 * `BracketFrame`, quotes and `(` never reset.
+		 */
+		loopCounterOpen: boolean;
+		/**
+		 * #533 reorder — likewise a `:local`/`:global` head stays open for a
+		 * later `name=` past an array VALUE (`:local value={1;2} name=foo`).
+		 * Saved only on a `{` that is an argument value; `}` restores it.
+		 */
+		pendingDecl?: SymbolClass | null;
 	}[] = [];
 	/** bracket/brace nesting, strings excluded (the S8 filter region uses it). */
 	let depth = 0;
@@ -521,7 +542,23 @@ export function resolveSymbols(original: string): SymbolAnalysis {
 	/** depth at which a filter word opened its region, or null. */
 	let filterDepth: number | null = null;
 	let pendingDecl: SymbolClass | null = null;
+	/**
+	 * #533 — the pending `:local`/`:global` declaration waits for the VALUE of
+	 * a `name=` argument (`:local name=foo` declares `foo`, not `name`). Set
+	 * when a `name=` arg name is read, cleared after its value declares or is
+	 * skipped. Values of other args (`value=`) never declare.
+	 */
+	let pendingDeclNameValue = false;
 	let pendingLoopVars = false;
+	/**
+	 * #533 reorder — a `:for`/`:foreach` head is still open for a named
+	 * `counter=`: unlike `pendingLoopVars` (positional vars, ended by
+	 * `in=`/`from=`/any `arg=`), this survives the whole head — CHR accepts
+	 * `:for from=1 counter=i to=2` — and only `do` (the body) closes it.
+	 */
+	let loopCounterOpen = false;
+	/** The next value word is a `counter=` loop var. */
+	let pendingLoopCounterValue = false;
 	/** inside a space-separated menu path run, where bare words are `dir` (S16). */
 	let inMenuPath = false;
 	/**
@@ -589,7 +626,10 @@ export function resolveSymbols(original: string): SymbolAnalysis {
 		pendingSetTarget = false;
 		pendingErrVar = false;
 		pendingDecl = null;
+		pendingDeclNameValue = false;
 		pendingLoopVars = false;
+		loopCounterOpen = false;
+		pendingLoopCounterValue = false;
 		declaredHere = false;
 		headSigil = "";
 		cont = "none";
@@ -662,7 +702,10 @@ export function resolveSymbols(original: string): SymbolAnalysis {
 			pendingSetTarget,
 			pendingErrVar,
 			pendingDecl,
+			pendingDeclNameValue,
 			pendingLoopVars,
+			loopCounterOpen,
+			pendingLoopCounterValue,
 			declaredHere,
 			headSigil,
 			cont,
@@ -715,7 +758,10 @@ export function resolveSymbols(original: string): SymbolAnalysis {
 		pendingSetTarget = frame.pendingSetTarget;
 		pendingErrVar = frame.pendingErrVar;
 		pendingDecl = frame.pendingDecl;
+		pendingDeclNameValue = frame.pendingDeclNameValue;
 		pendingLoopVars = frame.pendingLoopVars;
+		loopCounterOpen = frame.loopCounterOpen;
+		pendingLoopCounterValue = frame.pendingLoopCounterValue;
 		declaredHere = frame.declaredHere;
 		headSigil = frame.headSigil;
 		cont = frame.cont;
@@ -803,7 +849,12 @@ export function resolveSymbols(original: string): SymbolAnalysis {
 					// string. A scan that swallowed this as string bytes would flip
 					// its quote phase on the first nested string and lose every
 					// binding after it.
-					frames.push({ char: next, at: i + 1, statements: next === "[" });
+					frames.push({
+						char: next,
+						at: i + 1,
+						statements: next === "[",
+						loopCounterOpen,
+					});
 					depth++;
 					if (next === "[") {
 						// F6 — and it is a statement context like any other `[`. A `$[`
@@ -904,6 +955,18 @@ export function resolveSymbols(original: string): SymbolAnalysis {
 		// nested string flipping the quote phase, so every later `#` line read as
 		// string content) is now fixed in the shared scanner too, via the same
 		// frame model (#199); the two must stay in step.
+		// #503 — a column-0 `#` inside an array literal is a comment line too, but
+		// it ends nothing: the array's statement carries on past it. A continued
+		// line's comment keeps the H5 branch below, as in `maskUncached`.
+		if (
+			c === "#" &&
+			!contComment &&
+			startsArrayCommentLine(text, i, frames.at(-1))
+		) {
+			while (i < text.length && text[i] !== "\n") i++;
+			i--; // let the loop advance onto the newline (or end)
+			continue;
+		}
 		if (c === "#" && (atLead || contComment)) {
 			while (i < text.length && text[i] !== "\n") i++;
 			if (contComment) {
@@ -974,7 +1037,28 @@ export function resolveSymbols(original: string): SymbolAnalysis {
 			// `set-dns`, and the console carries the class across the quotes, so the
 			// span includes them. Without this the string is skipped and the next
 			// bare word (`do`) is declared instead.
-			if (pendingDecl !== null || pendingLoopVars || pendingErrVar) {
+			if (
+				pendingDecl !== null ||
+				pendingLoopVars ||
+				pendingErrVar ||
+				pendingLoopCounterValue
+			) {
+				// #533 — a quoted VALUE of a named arg declares only for `name=`.
+				// `:local name="foo"` declares `foo`; `:local value="foo"` declares
+				// nothing and stays a string (so `$` inside still classifies, S9).
+				// Positional quotes (`:local "foo"`) declare.
+				if (pendingDecl !== null) {
+					const prev = prevNonSpace(text, i);
+					if ((prev === "=" || prev === ",") && !pendingDeclNameValue) {
+						frames.push({
+							char: '"',
+							at: i,
+							statements: false,
+							loopCounterOpen,
+						});
+						continue;
+					}
+				}
 				const close = text.indexOf('"', i + 1);
 				if (close > i) {
 					const name = text.slice(i + 1, close);
@@ -998,6 +1082,7 @@ export function resolveSymbols(original: string): SymbolAnalysis {
 						const binding = bind(name, cls, i + 1);
 						if (binding !== null) bindingIds.push(binding.id);
 						pendingDecl = null;
+						pendingDeclNameValue = false;
 						declaredHere = true;
 					} else {
 						// F7 — statement scope, and for `:onerror` the enclosing claim
@@ -1023,7 +1108,12 @@ export function resolveSymbols(original: string): SymbolAnalysis {
 					continue;
 				}
 			}
-			frames.push({ char: '"', at: i, statements: false });
+			frames.push({
+				char: '"',
+				at: i,
+				statements: false,
+				loopCounterOpen,
+			});
 			continue;
 		}
 
@@ -1036,6 +1126,9 @@ export function resolveSymbols(original: string): SymbolAnalysis {
 					(c === "{" &&
 						(frames.at(-1)?.statements ?? true) &&
 						braceStartsStatements(text, i)),
+				loopCounterOpen,
+				pendingDecl:
+					c === "{" && prevNonSpace(text, i) === "=" ? pendingDecl : null,
 			});
 			depth++;
 			if (c === "[") openBracket(leadBefore, i);
@@ -1071,7 +1164,7 @@ export function resolveSymbols(original: string): SymbolAnalysis {
 				defects.push(defectAt("unbalanced-close", i, c));
 				continue;
 			}
-			frames.pop();
+			const popped = frames.pop();
 			if (filterDepth !== null && depth <= filterDepth) filterDepth = null;
 			// F6 — restore the statement the `[` interrupted, and drop the bracket's
 			// scope. Ordered after the `filterDepth` clear on purpose: the saved
@@ -1082,6 +1175,11 @@ export function resolveSymbols(original: string): SymbolAnalysis {
 				if (suppressedScopes > 0) suppressedScopes--;
 				else if (scopes.length > 1) scopes.pop();
 				resetStatement();
+				// #533 reorder — the head outlives its own array braces.
+				if (popped !== undefined) {
+					loopCounterOpen = popped.loopCounterOpen;
+					pendingDecl = popped.pendingDecl ?? null;
+				}
 			}
 			if (depth > 0) depth--;
 			continue;
@@ -1204,8 +1302,10 @@ export function resolveSymbols(original: string): SymbolAnalysis {
 					pathOpen = true;
 				}
 				if (DECL[lower] !== undefined) pendingDecl = DECL[lower] as SymbolClass;
-				else if (LOOP_HEADS.has(lower)) pendingLoopVars = true;
-				else if (lower === "set") pendingSetTarget = true;
+				else if (LOOP_HEADS.has(lower)) {
+					pendingLoopVars = true;
+					loopCounterOpen = true;
+				} else if (lower === "set") pendingSetTarget = true;
 				else if (ERRVAR_HEADS.has(lower)) pendingErrVar = true;
 				// S8 — `find`/`where` open a filter region from HEAD position too.
 				// `[find comment=$tag]` is the commonest shape of the whole corpus and
@@ -1299,6 +1399,17 @@ export function resolveSymbols(original: string): SymbolAnalysis {
 
 			// S1/S2 — this word is the declared name.
 			if (pendingDecl !== null) {
+				// #533 — named spelling (`:local name=foo value=1`): an argument
+				// NAME (`word=`) is never the declaration. Only `name=` carries
+				// it; its value declares. Other values (`value=foo`) are skipped,
+				// and the pending declaration survives for a later `name=`
+				// (`value=1 name=foo`). A positional word (`:local foo`, `:local
+				// name`) declares as before.
+				if (nextNonSpace(text, j) === "=") {
+					pendingDeclNameValue = lower === "name";
+					continue;
+				}
+				if (isValue && !pendingDeclNameValue) continue;
 				const binding = bind(word, pendingDecl, wordStart);
 				record(
 					wordStart,
@@ -1311,6 +1422,7 @@ export function resolveSymbols(original: string): SymbolAnalysis {
 					binding === null ? [] : [binding.id],
 				);
 				pendingDecl = null;
+				pendingDeclNameValue = false;
 				declaredHere = true;
 				continue;
 			}
@@ -1318,6 +1430,13 @@ export function resolveSymbols(original: string): SymbolAnalysis {
 			// S3 — `:foreach k,v in=…`: every word before `in=`/`from=` is a loop
 			// variable.
 			if (pendingLoopVars) {
+				// #533 — named spelling (`:for counter=i …`): `counter=` carries
+				// the loop var(s); the word `counter` itself is never one. Any
+				// other `arg=` ends the var list, like `in=`/`from=` already did.
+				if (nextNonSpace(text, j) === "=") {
+					if (lower !== "counter") pendingLoopVars = false;
+					continue;
+				}
 				if (lower === "in" || lower === "from") {
 					pendingLoopVars = false;
 					continue;
@@ -1339,6 +1458,43 @@ export function resolveSymbols(original: string): SymbolAnalysis {
 				continue;
 			}
 
+			// #533 reorder — a named `counter=` past `in=`/`from=` or other
+			// args still carries the loop var: CHR accepts
+			// `:for from=1 counter=i to=2`, and the value binds exactly like
+			// a positional. Only `do` (the body) closes the head; a value of
+			// another arg, or a further arg name, just ends this `counter=`.
+			if (!isValue && lower === "do") {
+				loopCounterOpen = false;
+				pendingLoopCounterValue = false;
+			}
+			if (
+				loopCounterOpen &&
+				lower === "counter" &&
+				nextNonSpace(text, j) === "="
+			) {
+				pendingLoopCounterValue = true;
+				continue;
+			}
+			if (pendingLoopCounterValue) {
+				if (nextNonSpace(text, j) === "=" || !isValue) {
+					pendingLoopCounterValue = false;
+				} else {
+					openStatementScope(wordStart);
+					const counterBinding = bind(word, "auto", wordStart);
+					record(
+						wordStart,
+						j,
+						word,
+						"auto",
+						true,
+						undefined,
+						"binding",
+						counterBinding === null ? [] : [counterBinding.id],
+					);
+					continue;
+				}
+			}
+
 			if (FILTER_WORDS.has(lower)) {
 				filterDepth = depth;
 				continue;

package/src/explain/transport.ts

@@ -111,6 +111,17 @@ export interface ExplainTransportInput {
 	 * centrs surface should be offered for them and none is rendered.
 	 */
 	rejected?: string;
+	/**
+	 * Why offline cannot pair the operands into a request, when two adjacent
+	 * words may be an argument and its value with the `=` left out (#350).
+	 *
+	 * Also distinct from an unread argument list: the bytes are no evaluation,
+	 * and nothing is wrong with them, but which word is an argument name is
+	 * per-command schema. The reading before #350 classified these `unknown`
+	 * through its positionals, and this keeps that fail-closed answer rather
+	 * than letting the withdrawal turn it into an `execute` line.
+	 */
+	unpaired?: string;
 }
 
 export interface ExplainTransportOptions {
@@ -440,6 +451,8 @@ export function classifyExplainTransport(
 	// syntax error, which is the false confident reading in a second place.
 	if (input.rejected !== undefined)
 		return unknown(input.rejected, options.evidenceId);
+	if (input.unpaired !== undefined)
+		return unknown(input.unpaired, options.evidenceId);
 
 	// Root scripting directives have no RouterOS REST path. They always ride the
 	// raw execute surface, regardless of whether their operands are literal.

package/src/explain/values.ts

@@ -17,8 +17,9 @@
  * them; only `:typeof` can. Grounded on CHR 7.21.5, 7.23.3 and 7.24rc4 in
  * `test/fixtures/explain/operators.json` → `sweep.runtime` rows
  * `typeof-deferred` / `deferred-array-typeof` and `sweep.opAxis` `defer-*`.
- * Offline abstains on every such form; a live `observedType` reports the
- * runtime type.
+ * Offline abstains on every such form, and so does the live `observedType`
+ * (#225): it reads only visible `:parse` conversions and never sends
+ * `:typeof`.
  *
  * ## The two contexts are different lexicons, not one lexicon plus a fallback
  *
@@ -51,8 +52,8 @@ import { isIP } from "node:net";
  * tests spellings, so reordering the members here must not change any result.
  * `array` is emitted by the structured anchor reader rather than
  * {@link valueShapeHints}, which receives decoded scalar values only.
- * `op` is not a member: a deferred `(> …)` form abstains offline and is
- * reported only as a live `observedType` (#288).
+ * `op` is not a member: a deferred `(> …)` form abstains offline and live
+ * (#288, #225).
  */
 export const VALUE_SHAPES = [
 	"num",
@@ -70,6 +71,56 @@ export const VALUE_SHAPES = [
 
 export type ValueShape = (typeof VALUE_SHAPES)[number];
 
+/**
+ * The types a visible `:parse` conversion can name (#225 `observedType`).
+ *
+ * A subset of {@link VALUE_SHAPES}: these are exactly the scalar types whose
+ * device rendering differs from some spelling of them (`2.2` → `2.0.0.2`,
+ * `0x10` → `16`, `yes` → `true`, `200ms` → `00:00:00.200`, `1:0:0::1` →
+ * `1::1`). `str`, `id` and `mac` never convert, so they are never observed.
+ */
+export const OBSERVED_VALUE_TYPES = [
+	"num",
+	"bool",
+	"ip",
+	"ip-prefix",
+	"ip6",
+	"ip6-prefix",
+	"time",
+] as const satisfies readonly ValueShape[];
+
+export type ObservedValueType = (typeof OBSERVED_VALUE_TYPES)[number];
+
+/**
+ * The normalized terms a schema declaration maps to (#225 `schemaType`).
+ *
+ * The scalar names are shared with {@link VALUE_SHAPES} so a schema fact and a
+ * shape hint compare directly. The schema-only terms name declarations no
+ * literal spelling has: `ip-range` (`A.B.C.D[-A.B.C.D|…] (IP address range)`),
+ * `enum` (a listed word set such as `input | forward | output`, never closed:
+ * the device also lists current configuration names this way) and `name` (a
+ * reference to a configuration object). `bool` and `name` are CLI Reference
+ * spellings (`bool`, `iface_enum`) the live projection never emits:
+ * `/console/inspect` declares a boolean with a blank row, and prints the
+ * current interface names exactly like keywords.
+ */
+export const SCHEMA_VALUE_TYPES = [
+	"num",
+	"bool",
+	"ip",
+	"ip-prefix",
+	"ip-range",
+	"ip6",
+	"ip6-prefix",
+	"time",
+	"mac",
+	"str",
+	"enum",
+	"name",
+] as const;
+
+export type SchemaValueType = (typeof SCHEMA_VALUE_TYPES)[number];
+
 /**
  * Where the value sits, because RouterOS reads the same bytes differently.
  *

package/src/explain/verbsplit.ts

@@ -88,6 +88,12 @@ import {
 	type Span,
 	type StatementAnalysis,
 } from "./pathresolve.ts";
+import {
+	asciiWordSpans,
+	isAsciiWhitespace,
+	type RunToken,
+	runTokens,
+} from "./run-tokens.ts";
 import {
 	documentRange,
 	type MaskedRange,
@@ -96,20 +102,6 @@ import {
 } from "./segment.ts";
 import { SUBMENU_DIRECTIVES, VERBS } from "./verbs.ts";
 
-const BARE_WORD = /^[A-Za-z][A-Za-z0-9._-]*$/;
-/**
- * A word that ends the leading run: it carries `=` (V2) or opens a group /
- * string / variable (V3). `:` is deliberately NOT here — RouterOS uses it only
- * to start a scripting directive, not as a mid-statement opener, and a
- * `:`-prefixed token is already rejected by `BARE_WORD` below, so it ends the
- * run regardless.
- */
-const RUN_TERMINATOR = /^[[({"$]/;
-
-function isAsciiWhitespace(char: string | undefined): boolean {
-	return char === " " || char === "\t" || char === "\r" || char === "\n";
-}
-
 function trimAscii(text: string): string {
 	let start = 0;
 	let end = text.length;
@@ -125,78 +117,14 @@ function trimAsciiStart(text: string): string {
 	return text.slice(start);
 }
 
-/** One whitespace-separated word, and where it sits in the text it came from. */
-interface Word {
-	name: string;
-	/** offset of the word's first character, inclusive. */
-	start: number;
-	/** offset just past its last character, exclusive. */
-	end: number;
-	/** Source span of each character retained in `name`. */
-	chars: Span[];
-}
-
-/**
- * The words of a statement, WITH their offsets (#202c).
- *
- * The one word scanner this module has. It replaced a
- * `replace(/\\\r?\n/g,"").split(whitespace)` pair whose output could not be
- * mapped back to the text it came from — and a second scanner written beside it
- * for the offsets would be free to disagree with the boundary rule, which is the
- * failure #202b hit three times in argument handling.
- *
- * H5 from the Q1 segmenter: a `\<newline>` is removed before RouterOS parses the
- * continued line, so it JOINS the words either side of it rather than separating
- * them (`na\<nl>me` is the single word `name`) and contributes no character to
- * the name. That is why a word's `end - start` is not its `name.length`: the span
- * covers the continuation bytes, the name does not. A caller taking an interior
- * offset from a name is therefore wrong on continued statements, and
- * {@link describeStatement} only ever publishes the run's END.
- */
-function* asciiWordSpans(text: string): Generator<Word> {
-	// Yielded ONE WORD AT A TIME rather than returned as a list. Both readers
-	// stop at the first word the leading run cannot take, and a statement's text
-	// carries its whole nested `do={…}` subtree — so building a word (and a span
-	// per character of it) for the rest of that subtree was work no caller ever
-	// looked at, once per enclosing level (#322). A word is complete when the
-	// next one starts, which is why the yield happens on the following boundary
-	// rather than at the point the word is opened.
-	let current: Word | null = null;
-	let i = 0;
-	while (i < text.length) {
-		const c = text[i] as string;
-		if (
-			c === "\\" &&
-			(text[i + 1] === "\n" || (text[i + 1] === "\r" && text[i + 2] === "\n"))
-		) {
-			// Inside a word this joins; between words it is whitespace that opens
-			// none — matching the removal-then-split the rule replaced.
-			i += text[i + 1] === "\r" ? 3 : 2;
-			if (current !== null) current.end = i;
-			continue;
-		}
-		if (isAsciiWhitespace(c)) {
-			if (current !== null) yield current;
-			current = null;
-			i++;
-			continue;
-		}
-		if (current === null) {
-			current = {
-				name: c,
-				start: i,
-				end: i + 1,
-				chars: [{ start: i, end: i + 1 }],
-			};
-		} else {
-			current.name += c;
-			current.end = i + 1;
-			current.chars.push({ start: i, end: i + 1 });
-		}
-		i++;
-	}
-	if (current !== null) yield current;
-}
+/** The run scanner lives in the leaf `run-tokens.ts` so `segment.ts` can share it (#496). */
+export {
+	type LocatedRunToken,
+	locatedRunTokens,
+	type RunToken,
+	runTokens,
+	type Sep,
+} from "./run-tokens.ts";
 
 /**
  * The frozen vocabulary lives in the leaf `verbs.ts` because `pathresolve.ts`
@@ -205,108 +133,6 @@ function* asciiWordSpans(text: string): Generator<Word> {
  */
 export { SUBMENU_DIRECTIVES, VERBS } from "./verbs.ts";
 
-/** Separator that precedes a run token (V1). */
-export type Sep = "start" | "slash" | "space";
-
-/** One token of the leading path run, with the punctuation that introduced it. */
-export interface RunToken {
-	name: string;
-	sep: Sep;
-}
-
-/** A run token mapped back to the statement bytes that spell it. */
-export interface LocatedRunToken extends RunToken {
-	/** Name bytes, split where a `\<newline>` continuation interrupts them. */
-	nameSpans: Span[];
-	/** One valid `/` immediately before this token, if present. */
-	slashBefore?: Span;
-	/** One trailing `/` after this token, if present. */
-	slashAfter?: Span;
-}
-
-function coalesceChars(chars: readonly Span[]): Span[] {
-	const out: Span[] = [];
-	for (const char of chars) {
-		const last = out.at(-1);
-		if (last !== undefined && last.end === char.start) last.end = char.end;
-		else out.push({ start: char.start, end: char.end });
-	}
-	return out;
-}
-
-/**
- * The leading path-token run WITH separators preserved (V1). Same stopping
- * rules as `pathresolve`'s run (V2/V3), so the two stay comparable: a slash-
- * joined word expands to several `slash`-separated tokens; a space-separated
- * word is one `space` token. Stops at the first `=`/group/string/var word, and
- * at any word carrying a non-`BARE_WORD` segment (a variable segment truncates
- * the run before the verb).
- */
-export function locatedRunTokens(text: string): LocatedRunToken[] {
-	const out: LocatedRunToken[] = [];
-	for (const word of asciiWordSpans(text)) {
-		if (word.name.includes("=") || RUN_TERMINATOR.test(word.name)) break;
-		const parts: {
-			name: string;
-			start: number;
-			end: number;
-			slashBefore?: Span;
-		}[] = [];
-		let start = 0;
-		for (let i = 0; i <= word.name.length; i++) {
-			if (i < word.name.length && word.name[i] !== "/") continue;
-			if (start < i) {
-				const slashRunStart = start;
-				let slashCount = 0;
-				while (
-					slashRunStart - slashCount - 1 >= 0 &&
-					word.name[slashRunStart - slashCount - 1] === "/"
-				)
-					slashCount++;
-				const slashIndex = slashCount === 1 ? slashRunStart - 1 : -1;
-				parts.push({
-					name: word.name.slice(start, i),
-					start,
-					end: i,
-					...(slashIndex < 0 ? {} : { slashBefore: word.chars[slashIndex] }),
-				});
-			}
-			start = i + 1;
-		}
-		if (parts.length === 0) continue;
-		if (!parts.every((p) => BARE_WORD.test(p.name))) break;
-		for (let i = 0; i < parts.length; i++) {
-			const part = parts[i] as (typeof parts)[number];
-			const leadingSlash = word.name.startsWith("/") && i === 0;
-			const trailingSlash =
-				i === parts.length - 1 &&
-				word.name.endsWith("/") &&
-				!word.name.endsWith("//")
-					? word.chars.at(-1)
-					: undefined;
-			out.push({
-				name: part.name,
-				sep:
-					out.length === 0
-						? "start"
-						: i > 0 || leadingSlash
-							? "slash"
-							: "space",
-				nameSpans: coalesceChars(word.chars.slice(part.start, part.end)),
-				...(part.slashBefore === undefined
-					? {}
-					: { slashBefore: part.slashBefore }),
-				...(trailingSlash === undefined ? {} : { slashAfter: trailingSlash }),
-			});
-		}
-	}
-	return out;
-}
-
-export function runTokens(text: string): RunToken[] {
-	return locatedRunTokens(text).map(({ name, sep }) => ({ name, sep }));
-}
-
 /** True when the statement is a scripting directive (`:x`, or a bare `x do={…}`). */
 export function isDirective(text: string, range?: MaskedRange): boolean {
 	const t = trimAscii(text);

package/src/explain/write.ts

@@ -694,7 +694,14 @@ function collect(
 			});
 			continue;
 		}
-		if (statement.isNav && !isCommandShaped(described, catalogAt)) {
+		// An ABSOLUTE `maybeNav` statement (#211) was `isNav` before R14, so it
+		// keeps this branch. `isConfirmedNav` cannot drop it, because its path is
+		// in neither table. A relative one never took this branch (#235), and
+		// still does not.
+		if (
+			(statement.isNav || (statement.maybeNav && t.startsWith("/"))) &&
+			!isCommandShaped(described, catalogAt)
+		) {
 			if (
 				isConfirmedNav(described) &&
 				!isDanglingBarePath(described, lastNonEmpty, index)