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

package/src/explain/run-tokens.ts

@@ -0,0 +1,223 @@
+/**
+ * The leading path-token run of a statement, for `explain`.
+ *
+ * A leaf module (it imports only the leaf data tables) so that `segment.ts` and
+ * `scope-brace.ts` can ask the question `verbsplit.ts` asks — "does this run
+ * already name a command verb?" (#496) — without the import cycle
+ * `verbsplit.ts` → `segment.ts` would make.
+ * It is the one word scanner both use; a second one written beside it would be
+ * free to disagree with the boundary rule. `verbsplit.ts` re-exports the public
+ * names, so the Q6 surface is unchanged.
+ */
+
+import { commandVerbIndex } from "./catalog.ts";
+import type { Span } from "./pathresolve.ts";
+import { 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 = /^[[({"$]/;
+
+export function isAsciiWhitespace(char: string | undefined): boolean {
+	return char === " " || char === "\t" || char === "\r" || char === "\n";
+}
+
+/** One whitespace-separated word, and where it sits in the text it came from. */
+export 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.
+ */
+export 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;
+}
+
+/** 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 }));
+}
+
+/**
+ * #496 — the run before a `{` already names a command, so the brace is that
+ * command's operand and not a `/menu { … }` container. `/system/script add
+ * name beep source { :beep }` is one `add` whose `source` is the body, and
+ * `/ip/route/print {1;2}` is a positional brace the device rejects (CHR
+ * 7.22.1/7.24.5 `:parse`); neither is a command followed by a menu body.
+ * `segment.ts` (H7) and `scope-brace.ts` each spelled the container rule
+ * lexically, and both ask here. The two tables are the ones `verbsplit`
+ * decides a verb with — the frozen vocabulary and the catalog's command axis —
+ * and both are floors: a run naming neither keeps the container reading
+ * (`/system script { print }`).
+ */
+export function runNamesCommand(prefix: string): boolean {
+	const names = runTokens(prefix).map((token) => token.name);
+	return (
+		names.some((name) => VERBS.has(name)) || commandVerbIndex(names) !== null
+	);
+}

package/src/explain/scope-brace.ts

@@ -8,6 +8,7 @@
  */
 
 import { scanQuotedString } from "./quoted-string.ts";
+import { runNamesCommand } from "./run-tokens.ts";
 
 /** Error-variable shape for `:onerror V { … }` — a bare/`$`-prefixed name. */
 const ERROR_VAR = /^\$?[A-Za-z][A-Za-z0-9._-]*$/;
@@ -58,8 +59,53 @@ export const DIRECTIVE_BODY: Record<string, string> = {
 	onerror: "in",
 };
 
-/** Script-valued attribute naming convention already used by the corpus census. */
-const SCRIPT_BODY_ARG = /^(?:source|script|on-.*)$/;
+/**
+ * Script-valued attribute naming convention, the corpus census's
+ * `SCRIPT_BEARING_KEY` shape (`scripts/explain-corpus-census.ts`).
+ *
+ * A shape, not a list. It decides a brace's ROLE (statement body or value) for
+ * every reader of {@link braceStartsStatements}: segmentation, the argument
+ * lexer, symbols and path resolution, as well as the `invalid-command-brace`
+ * exemption. A name inside the shape is read as a body; a name outside it as a
+ * value. The shape errs toward body because the other error is the worse one:
+ * reading a real `up-script={ :beep }` as an array hard-failed input the device
+ * accepts. The cost is the fail-open direction. An argument the command does
+ * not have, `zzz-script={ :beep }` or `on-zzz={ :beep }`, is a device
+ * `syntax error` on CHR 7.24.5 that offline does not report, because naming the
+ * command's arguments is schema. The `on-…` half of that predates #350.
+ * Which slots take a body is per-menu and per-version schema: on CHR 7.24.5
+ * `/tool/netwatch add … up-script={ :beep }` and `/ip/dhcp-server set 0
+ * lease-script={ :beep }` both parse, while 7.22.1 accepts the first and
+ * rejects the second; `comment={ :beep }` and `zzzscript={ :beep }` are
+ * `syntax error` on both (#350). The earlier `^(?:source|script|on-.*)$` missed
+ * every `…-script` argument and hard-failed the netwatch row the device accepts.
+ * The suffix keeps its hyphen, which is how RouterOS spells these names: a bare
+ * `…script` would take `:put myScript={#test}`, whose brace CHR 7.23.3 reads as
+ * an array (#245).
+ */
+const SCRIPT_BODY_ARG = /^(?:source|script|.+-script|on-.+)$/;
+
+/**
+ * An abbreviation the {@link SCRIPT_BODY_ARG} shape still pins down (#496).
+ * RouterOS takes any unique prefix of an argument name: on CHR 7.24.5 and
+ * 7.23.8, `sour { :beep }` and `s={ :beep }` lower to `source=`, `on`/`o=` to
+ * `on-event=`, and `down-scr`/`down-s=` to `down-script=`. These are the
+ * prefixes of `source` and `script`, of `on-`, and a name ending in `-` plus a
+ * prefix of `script`, so each can only abbreviate a script-valued name. Like
+ * the shape, it errs toward body: `sc { :beep }` is rejected on device and
+ * offline misses it.
+ *
+ * Abbreviating the FIRST segment (`down={ :beep }` for `down-script`, also
+ * accepted on device) stays outside. Every word is a prefix of `<word>-script`,
+ * so admitting it would admit `comment={ :beep }`. Telling them apart needs the
+ * command's argument list, which is schema.
+ */
+const SCRIPT_BODY_ABBREVIATION =
+	/^(?:s(?:o(?:u(?:r(?:c)?)?)?)?|sc(?:r(?:i(?:p)?)?)?|on?|.+-(?:s(?:c(?:r(?:i(?:p)?)?)?)?)?)$/;
+
+function isScriptBodyName(name: string): boolean {
+	return SCRIPT_BODY_ARG.test(name) || SCRIPT_BODY_ABBREVIATION.test(name);
+}
 
 /** Grounded scripting directives whose positional arity makes a later `#` fatal. */
 const DIRECTIVE_POSITIONAL_ARITY: Readonly<Record<string, number>> = {
@@ -270,6 +316,19 @@ function trailingBareScopeName(
 	text: string,
 	start: number,
 	end: number,
+): string | null {
+	const name = trailingBareArgumentName(text, start, end);
+	return name !== null && SCOPE_ARG_NAMES.has(name) ? name : null;
+}
+
+/**
+ * The bare word before a `{` when it can be an argument name: not the
+ * statement's leading word, and not a `:` directive. Lower-cased.
+ */
+function trailingBareArgumentName(
+	text: string,
+	start: number,
+	end: number,
 ): string | null {
 	let i = end - 1;
 	while (i >= start && isAsciiWhitespace(text[i])) i--;
@@ -278,7 +337,6 @@ function trailingBareScopeName(
 	const nameStart = i + 1;
 	if (nameStart === nameEnd) return null;
 	const name = text.slice(nameStart, nameEnd).toLowerCase();
-	if (!SCOPE_ARG_NAMES.has(name)) return null;
 	// A COLON makes it a directive, never an argument name, and the device is
 	// emphatic: `:if (1=1) :do { :put a }` is `expected end of command` on both
 	// 7.21.5 and 7.24.2, while the bare `:if (1=1) do { :put a }` parses. So the
@@ -415,13 +473,52 @@ export function braceStartsStatements(
 	const boundary = index.boundaries[open] ?? -1;
 	const start = Math.max(boundary + 1, floor);
 	const named = trailingName(text, start, open);
-	if (named !== null) return SCRIPT_BODY_ARG.test(named.toLowerCase());
+	if (named !== null) return isScriptBodyName(named.toLowerCase());
+	// `source { :beep }` — the same body with the `=` left out (#350). Every
+	// grounded spelling lowers to the `source=` IL on CHR 7.22.1 and 7.24.5:
+	// `/system/script add name=beep source { :beep }`, `/system/scheduler add
+	// name=x on-event { :beep }`, `/tool/netwatch add … down-script { :beep }`.
+	// The control is `comment { :beep }`, a `syntax error` on both. A
+	// declaration's operand is a variable name, not an argument, so
+	// `:local myscript {1;2}` keeps its brace an array.
+	const bare = trailingBareArgumentName(text, start, open);
+	if (bare !== null && isScriptBodyName(bare)) {
+		const head = index.firstContent[open] ?? -1;
+		const word =
+			head < start ? "" : (leadingWords(text, head, open, 1)[0] ?? "");
+		if (!/^:|^(?:local|global)$/i.test(word)) return true;
+	}
 
-	// H7's bare `{...}` and `/menu {...}` containers are statement bodies too.
+	// H7's bare `{...}` and `/menu {...}` containers are statement bodies too,
+	// but a run that already names a command makes the brace its operand (#496).
+	// `start` follows the last `{`, so each brace reads its own run: linear.
 	const first = index.firstContent[open] ?? -1;
 	return (
 		first < start ||
-		(text[first] === "/" && (index.lastForbidden[open] ?? -1) < start)
+		(text[first] === "/" &&
+			(index.lastForbidden[open] ?? -1) < start &&
+			!runNamesCommand(text.slice(first, open)))
+	);
+}
+
+/**
+ * Whether the `#` at `at` opens a comment line inside an array literal (#503).
+ *
+ * `frame` is the innermost open delimiter. CHR 7.24.5 and 7.22.1 agree: inside
+ * a `{…}` that is not a statement body, a `#` at column 0 comments out the
+ * rest of its line, at any nesting depth and in argument values too
+ * (`:local z {a=1;⏎# c⏎b=2}` → `value=a=1;b=2`, `:foreach i in={1;⏎# c⏎2}`).
+ * An indented `#` (space or tab), a `#` after a value or `;` on the same line,
+ * and a `#` directly inside `( … )` are still syntax errors. A comment-only
+ * array is rejected, but so is `{}`: that is the empty-array rule, not this one.
+ */
+export function startsArrayCommentLine(
+	text: string,
+	at: number,
+	frame: { char: string; statements: boolean } | undefined,
+): boolean {
+	return (
+		text[at - 1] === "\n" && frame?.char === "{" && frame.statements === false
 	);
 }
 

package/src/explain/segment.ts

@@ -84,6 +84,7 @@ import {
 	MAX_STRING_FRAME_DEPTH,
 	scanQuotedString as scanQuotedStringShared,
 } from "./quoted-string.ts";
+import { runNamesCommand } from "./run-tokens.ts";
 import {
 	braceStartsStatements,
 	canRetainStatementIndex,
@@ -91,6 +92,7 @@ import {
 	isIndexedStatementStart,
 	matchingBraceEnd,
 	scopeNameFromMasked,
+	startsArrayCommentLine,
 } from "./scope-brace.ts";
 
 /** One top-level statement located in analyzed-byte space. */
@@ -130,6 +132,15 @@ export interface SegmentResult {
 	 * a throw. Includes the two coordinate-pass classes (`bom`, `non-ascii`).
 	 */
 	defects: Defect[];
+	/**
+	 * The first `}` or `]` that closes nothing at the top level, where RouterOS
+	 * stops reading (#504). The device accepts the script and silently discards
+	 * that byte and everything after it: `:put 1};:put 2` lowers to
+	 * `(evl /putmessage=1)` and `}⏎:put 1` to `/`, on CHR 7.24.5 and 7.23.8.
+	 * A `)` there, or any stray close inside an open group, is a rejection
+	 * instead and is only an `unbalanced-close` defect. Absent when there is none.
+	 */
+	discardFrom?: number;
 }
 
 const isSpace = (c: string): boolean => c === " " || c === "\t" || c === "\r";
@@ -510,7 +521,12 @@ function maskUncached(
 		// indented `#` is a comment when the statement is still empty (`do={\` +
 		// newline + `  # c`) and content when it is not (`:put a\` + newline +
 		// `  # x`, which the device classes `error`) — exactly what `atLead` says.
-		if (c === "#" && (atLead || contComment)) {
+		if (
+			c === "#" &&
+			(atLead ||
+				contComment ||
+				startsArrayCommentLine(original, i, contexts.at(-1)))
+		) {
 			const commentStart = i;
 			while (i < original.length && original[i] !== "\n") i++;
 			if (pieces === undefined) pieces = [];
@@ -650,6 +666,7 @@ function segmentStatementsInternal(
 			analysis === undefined ? [] : coordinateDefects(analysis),
 			raw.defects,
 		),
+		...(raw.discardFrom === undefined ? {} : { discardFrom: raw.discardFrom }),
 	};
 }
 
@@ -699,6 +716,8 @@ interface Frame {
 	/** Incremental equivalent of trimming and checking the H7 prefix. */
 	prefixSawNonSpace: boolean;
 	prefixValid: boolean;
+	/** The prefix's run has been checked for a command verb (#496). */
+	prefixVerbChecked: boolean;
 	/** statements collected here; the flattened output for a committed container. */
 	buffer: RawSegment[];
 	/** true for a container frame; false for the synthetic top level. */
@@ -726,6 +745,7 @@ function scanAscii(
 	segments: RawSegment[];
 	comments: { start: number; end: number }[];
 	defects: Defect[];
+	discardFrom?: number;
 } {
 	// Local indices remain local in the result; only index-backed questions use
 	// document coordinates. The floor prevents an enclosing head from becoming
@@ -736,6 +756,7 @@ function scanAscii(
 	const comments: { start: number; end: number }[] = [];
 	const defects: Defect[] = [];
 	const overDepth: number[] = [];
+	let discardFrom: number | undefined;
 	let hardHashSeen = false;
 	let hardApostropheSeen = false;
 	// H2 — every open bracket, for balance. Each frame carries WHERE it opened so
@@ -752,6 +773,7 @@ function scanAscii(
 		prefixScanEnd: -1,
 		prefixSawNonSpace: false,
 		prefixValid: true,
+		prefixVerbChecked: false,
 		buffer: [],
 		container: false,
 		openIndex: -1,
@@ -777,6 +799,7 @@ function scanAscii(
 		f.prefixScanEnd = -1;
 		f.prefixSawNonSpace = false;
 		f.prefixValid = true;
+		f.prefixVerbChecked = false;
 	};
 
 	const makeSegment = (
@@ -814,7 +837,8 @@ function scanAscii(
 	};
 
 	// A container prefix is empty or a bare `/`-menu path with no `=[($"` — the
-	// same test the old `containerOpen` applied to the group's prefix.
+	// same test the old `containerOpen` applied to the group's prefix — whose
+	// run names no command (#496).
 	const validPrefix = (f: Frame, start: number, end: number): boolean => {
 		if (f.prefixScanStart !== start || f.prefixScanEnd > end) {
 			resetPrefixScan(f);
@@ -841,6 +865,12 @@ function scanAscii(
 			}
 		}
 		f.prefixScanEnd = end;
+		// Checked once per statement: a later `{` sits behind this one, which
+		// already ended the run, so the answer cannot change.
+		if (f.prefixValid && !f.prefixVerbChecked) {
+			f.prefixVerbChecked = true;
+			if (runNamesCommand(ascii.slice(start, end))) f.prefixValid = false;
+		}
 		return f.prefixValid;
 	};
 
@@ -860,6 +890,7 @@ function scanAscii(
 			prefixScanEnd: -1,
 			prefixSawNonSpace: false,
 			prefixValid: true,
+			prefixVerbChecked: false,
 			buffer: [],
 			container: true,
 			openIndex: i,
@@ -920,7 +951,12 @@ function scanAscii(
 		// mid-continuation stays content.
 		const inCont = f.cont !== "none";
 		const contComment = c === "#" && inCont && f.contLineStart;
-		if (c === "#" && (f.atLead || contComment)) {
+		if (
+			c === "#" &&
+			(f.atLead ||
+				contComment ||
+				startsArrayCommentLine(ascii, i, delimStack.at(-1)))
+		) {
 			const nl = ascii.indexOf("\n", i);
 			const end = nl === -1 ? ascii.length : nl;
 			comments.push({ start: i, end });
@@ -1091,6 +1127,7 @@ function scanAscii(
 					f.atLead = false;
 				}
 			} else {
+				if (delimStack.length === 0 && c !== ")") discardFrom ??= i;
 				defects.push(defectAt("unbalanced-close", i, c));
 				ensureStmt(f, i);
 				f.atLead = false;
@@ -1148,6 +1185,7 @@ function scanAscii(
 			// event fail to de-duplicate across analyzers.
 			...overDepth.map((offset) => defectAt("over-depth", offset)),
 		],
+		...(discardFrom === undefined ? {} : { discardFrom }),
 	};
 }
 

package/src/explain/spaced-args.ts

@@ -0,0 +1,116 @@
+/**
+ * The space-for-`=` argument spelling (#350).
+ *
+ * RouterOS lets a space stand in for the `=` of an ordinary command argument:
+ * `/ip/firewall/layer7-protocol add comment "something" regexp 1.1` lowers to
+ * `(evl /ip/firewall/layer7-protocol/addcomment=something;regexp=1.1)`, byte for
+ * byte the IL of the `=` spelling, and the spellings mix freely. That is not a
+ * schema-free rule. The device pairs `comment` with `"something"` because it
+ * knows `/ip/firewall/layer7-protocol/add` has a `comment` argument:
+ * `/system/script add zzznotanarg beep` is `bad parameter zzznotanarg` on
+ * 7.24.5 and `expected end of command` on 7.22.1.
+ *
+ * ## What the device actually does (CHR 7.22.1 and 7.24.5, `:parse` + `highlight`)
+ *
+ * Identical on both builds:
+ *
+ * | input | IL | `highlight` on the gap |
+ * | ----- | -- | ---------------------- |
+ * | `/interface set ether1 comment "x"` | `setcomment=x;numbers=ether1` | `syntax-obsolete` |
+ * | `/interface set ether1 name x` | `setname=x;numbers=ether1` | `syntax-obsolete` |
+ * | `/interface set ether1 disabled yes` | `setdisabled=true;numbers=ether1` | `syntax-obsolete` |
+ * | `/user group set full policy "read,write"` | `setnumbers=full;policy=read,write` | `syntax-obsolete` |
+ * | `/interface print detail without-paging` | `printdetail=true;without-paging=true` | none |
+ *
+ * Two facts come out of that table, and they are why this module has two
+ * outputs rather than one.
+ *
+ * - **Two adjacent bare operands have no schema-free reading.** `name x` is an
+ *   argument and its value; `detail without-paging` is two value-less flags;
+ *   `ether1 name` is an unnamed `numbers` operand and then an argument name. The
+ *   bytes are the same shape in all three. So the strict reading ABSTAINS on any
+ *   such pair: it never publishes `args: {}` plus a positional list, which
+ *   claims the list was read and holds no arguments.
+ * - **The obsolete marker follows the value, not the name.** The device marks
+ *   the gap `syntax-obsolete` exactly when it paired the words, and a flag pair
+ *   gets no marker. Offline can see one half of that: a second operand that is
+ *   not itself name-shaped (`"x"`, `1.1`, `10s`, `$v`) cannot be a flag, so the
+ *   pair is very probably the spaced spelling and gets a warning. A bare-word
+ *   second operand (`name x`, `disabled yes`) is also obsolete on device, but
+ *   offline cannot tell it from `detail without-paging`, so it abstains with no
+ *   warning rather than flagging the most common `print` spelling there is. The
+ *   warning says "possible"; a live probe (#491) is what makes it definite.
+ *
+ * ## What this deliberately does not decide
+ *
+ * Root statements are out of scope. A scripting directive's operands are
+ * positional by grammar, not spelling: `:pick abc 0 1` lowers to
+ * `pickbegin=0;counter=abc;end=1`, and `:local t 200ms` to `name=t;value=200ms`.
+ * Pairing those would fabricate argument names the device never uses. `/ping
+ * 1.1.1.1 count 1` is spaced (`count` is `syntax-obsolete`) and resolves to the
+ * root, so it stays read here; telling a root command's positional grammar from a
+ * spaced argument is per-command schema and belongs to the live probe.
+ *
+ * `where` ends the scan. What follows it is a query expression, and the word
+ * before it is never paired with it: `print count-only where …` lowers to
+ * `count-only=true;where=…`.
+ *
+ * Like the #311 separator rule, this reads only what the argument lexer
+ * already decided (`lexArgumentTokens`, the skip-tolerant reading), so a
+ * `[…]` substitution or a quoted run is one token by construction.
+ */
+
+import { ARGUMENT_NAME, type Argument } from "./args.ts";
+
+/** Two adjacent operands that may be the spaced spelling of `name=value`. */
+export interface SpacedPair {
+	/** First byte of the would-be name through the end of the would-be value. */
+	span: { start: number; end: number };
+	/** The would-be argument name, verbatim. */
+	name: string;
+	/** The would-be value, verbatim (quotes kept). */
+	value: string;
+	/**
+	 * The second operand cannot be a flag, so the device very probably reads the
+	 * pair as `name=value` and marks the gap `syntax-obsolete`.
+	 */
+	valueShaped: boolean;
+}
+
+/**
+ * An argument-name-shaped bare word. This is the lexer's own grammar, so a word
+ * the lexer would read as `name=` in the `=` spelling is a name here too.
+ */
+const NAME_SHAPED = ARGUMENT_NAME;
+
+function isWhere(token: Argument): boolean {
+	return token.kind === "positional" && token.text.toLowerCase() === "where";
+}
+
+/**
+ * Every adjacent `name operand` pair in one statement's argument tokens.
+ *
+ * Pairs overlap on purpose. `set ether1 comment "x"` yields `ether1 comment`
+ * and `comment "x"`: the first only abstains, the second also warns, and
+ * consuming the first would hide the second.
+ *
+ * Coordinate-space agnostic, like `findMissingSeparators`: spans come back in
+ * whatever space `tokens` were lexed in.
+ */
+export function findSpacedPairs(tokens: readonly Argument[]): SpacedPair[] {
+	const out: SpacedPair[] = [];
+	for (let i = 0; i + 1 < tokens.length; i++) {
+		const name = tokens[i] as Argument;
+		const value = tokens[i + 1] as Argument;
+		if (isWhere(name)) break;
+		if (name.kind !== "positional" || value.kind !== "positional") continue;
+		if (!NAME_SHAPED.test(name.text) || isWhere(value)) continue;
+		out.push({
+			span: { start: name.span.start, end: value.span.end },
+			name: name.text,
+			value: value.text,
+			valueShaped: !NAME_SHAPED.test(value.text),
+		});
+	}
+	return out;
+}

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. */
@@ -904,6 +908,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) {