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

package/src/explain/segment.ts

@@ -91,6 +91,7 @@ import {
 	hashStartsHardError,
 	isIndexedStatementStart,
 	matchingBraceEnd,
+	menuBlockPath,
 	scopeNameFromMasked,
 	startsArrayCommentLine,
 } from "./scope-brace.ts";
@@ -624,6 +625,137 @@ export function segmentScopeBody(
 	);
 }
 
+/** Nesting cap for dispatch-statement counting (#549): the 16× guard (#322). */
+const MAX_DISPATCH_STATEMENT_DEPTH = 16;
+
+/**
+ * Executable statements in `text`, at any nesting depth (#549).
+ *
+ * A dispatched script can carry statements inside executed control scopes
+ * (`:if … do={…}`, `:for`/`:foreach`/`:while`, `:do`, `:retry`, `:onerror`,
+ * `once do={…}`), and those run before a later refusal exactly like
+ * top-level ones do — `:if (true) do={ /system/note/set …; /user/add … }`
+ * applies the note before the refused add on CHR 7.25. Stored bodies
+ * (`source={…}`, `on-event={…}`, any other `name={`) never execute at
+ * dispatch, so only `scopeNameFromMasked` scopes recurse — except a `do={…}`
+ * under a `:global`/`:local`/`:set` head, which stores a function value.
+ * Command substitutions (`[…]`) run at dispatch too — `:put [:put "p5-first";
+ * /system/identity/set …]` prints before the refused set on CHR 7.25 — so
+ * they recurse unless they sit inside a stored or array `{…}`. An `else={…}`
+ * paired with its `do={…}` counts the larger side, not the sum, because the
+ * branches exclude each other.
+ *
+ * A segment with executed blocks or substitutions counts their inner
+ * statements, not itself (a control head is not an effect); a `/menu { … }`
+ * prefix counts nothing (navigation is not an effect); any other segment
+ * counts one. So the commonest write shape, `/… remove [find …]`, stays one
+ * statement — at the cost of a lone substitution that itself writes before a
+ * refused enclosing statement, which also counts one. Past the depth cap the
+ * inner text counts its top-level siblings only. Unbalanced input counts what
+ * precedes the break and never throws.
+ */
+export function countExecutableStatements(text: string): number {
+	return countExecutableStatementsWithin(text, 0);
+}
+
+function countExecutableStatementsWithin(text: string, depth: number): number {
+	const { segments, ascii } = segmentStatements(text);
+	if (depth >= MAX_DISPATCH_STATEMENT_DEPTH) return segments.length;
+	let count = 0;
+	for (const segment of segments) {
+		// A `/menu { … }` prefix only navigates; it is not an effect. The
+		// `ascii` guard is load-bearing: segment offsets are analyzed-byte
+		// offsets, which are string indexes only for pure-ASCII input.
+		if (ascii && segment.menuOnly && /^\s*\{/.test(text.slice(segment.end)))
+			continue;
+		const inner = countExecutedBlockStatements(segment.text, depth);
+		count += inner > 0 ? inner : 1;
+	}
+	return count;
+}
+
+/** Executable statements in the segment's executed `{…}` scopes and `[…]`. */
+function countExecutedBlockStatements(
+	segmentText: string,
+	depth: number,
+): number {
+	const masked = maskComments(segmentText);
+	const storedDoHead = /^:(?:global|local|set)\b/i.test(masked);
+	let total = 0;
+	let i = 0;
+	const stack: string[] = [];
+	// The last executed scope closed at this level, for `do`/`else` pairing.
+	let lastScope: { name: string; count: number; end: number } | null = null;
+	// The outermost open `[` that executes at dispatch, and its stack depth.
+	let substitution: { start: number; depth: number } | null = null;
+	while (i < masked.length) {
+		const c = masked[i];
+		if (c === '"') {
+			i = scanQuotedString(masked, i).end;
+			continue;
+		}
+		if (c === "[" || c === "(") {
+			if (c === "[" && !stack.includes("[") && !stack.includes("{")) {
+				substitution = { start: i, depth: stack.length };
+			}
+			stack.push(c);
+			i++;
+			continue;
+		}
+		if (c === "]" || c === ")") {
+			const want = c === "]" ? "[" : "(";
+			if (stack.at(-1) === want) {
+				stack.pop();
+				if (c === "]" && stack.length === substitution?.depth) {
+					total += countExecutableStatementsWithin(
+						segmentText.slice(substitution.start + 1, i),
+						depth + 1,
+					);
+					substitution = null;
+				}
+			}
+			i++;
+			continue;
+		}
+		if (c === "{") {
+			const scope = stack.length === 0 ? scopeNameFromMasked(masked, i) : null;
+			if (
+				scope !== null &&
+				!(storedDoHead && (scope === "do" || scope === "command"))
+			) {
+				const end = matchingBraceEnd(masked, i);
+				if (end === undefined) return total;
+				const count = countExecutableStatementsWithin(
+					segmentText.slice(i + 1, end),
+					depth + 1,
+				);
+				if (
+					scope === "else" &&
+					lastScope?.name === "do" &&
+					/^\s*else\s*=?\s*$/.test(masked.slice(lastScope.end + 1, i))
+				) {
+					total += Math.max(lastScope.count, count) - lastScope.count;
+				} else {
+					total += count;
+				}
+				lastScope = { name: scope, count, end };
+				i = end + 1;
+				continue;
+			}
+			stack.push("{");
+			i++;
+			continue;
+		}
+		if (c === "}") {
+			if (stack.at(-1) === "{") stack.pop();
+			i++;
+			continue;
+		}
+		i++;
+	}
+	return total;
+}
+
 function segmentStatementsInternal(
 	original: string,
 	range: MaskedRange | undefined,
@@ -1073,7 +1205,10 @@ function scanAscii(
 			if (
 				c === "{" &&
 				atContainerLevel() &&
-				validPrefix(f, f.stmtStart >= 0 ? f.stmtStart : i, i)
+				(validPrefix(f, f.stmtStart >= 0 ? f.stmtStart : i, i) ||
+					// A relative submenu inside a container is one too (#351).
+					(frames.length > 1 &&
+						menuBlockPath(indexed, floor + i, floor) !== null))
 			) {
 				if (frames.length - 1 < MAX_CONTAINER_DEPTH) {
 					openContainer(i);

package/src/explain/symbols.ts

@@ -419,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;
@@ -511,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;
@@ -525,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;
 	/**
@@ -593,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";
@@ -666,7 +702,10 @@ export function resolveSymbols(original: string): SymbolAnalysis {
 			pendingSetTarget,
 			pendingErrVar,
 			pendingDecl,
+			pendingDeclNameValue,
 			pendingLoopVars,
+			loopCounterOpen,
+			pendingLoopCounterValue,
 			declaredHere,
 			headSigil,
 			cont,
@@ -719,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;
@@ -807,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 `$[`
@@ -990,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);
@@ -1014,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
@@ -1039,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;
 		}
 
@@ -1052,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);
@@ -1087,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
@@ -1098,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;
@@ -1220,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
@@ -1315,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,
@@ -1327,6 +1422,7 @@ export function resolveSymbols(original: string): SymbolAnalysis {
 					binding === null ? [] : [binding.id],
 				);
 				pendingDecl = null;
+				pendingDeclNameValue = false;
 				declaredHere = true;
 				continue;
 			}
@@ -1334,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;
@@ -1355,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/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.
  *