sommark 4.5.3 → 5.0.1

package/core/parser.js

@@ -4,12 +4,9 @@
 import TOKEN_TYPES from "./tokenTypes.js";
 import peek from "../helpers/peek.js";
 import { parserError } from "./errors.js";
-import { safeDataParse } from "../helpers/safeDataParser.js";
 import {
 	BLOCK,
 	TEXT,
-	INLINE,
-	ATBLOCK,
 	COMMENT,
 	COMMENT_BLOCK,
 	STATIC_LOGIC,
@@ -19,11 +16,6 @@ import {
 	block_id,
 	block_key,
 	block_value,
-	inline_id,
-	inline_text,
-	at_id,
-	atblock_key,
-	at_value,
 	end_keyword,
 	SLOT,
 	slot_keyword,
@@ -93,7 +85,7 @@ function validateName(
 		: "must contain only letters, numbers, hyphens, underscores, or dollar signs ($)";
 
 	if (!keyRegex.test(id)) {
-		parserError([`{line}<$red:Invalid ${name}:$><$blue: '${id}'$>{N}<$yellow:${name} ${ruleMessage}$> <$cyan: ${rule}.$>{line}`]);
+		parserError([`{line}<$red:Invalid ${name}:$><$blue: '${id}'$>{N}<$yellow:${name} ${ruleMessage}$> <$cyan: ${rule}.$>`]);
 	}
 }
 
@@ -103,7 +95,7 @@ function makeBlockNode() {
 		type: BLOCK,
 		structure: "Block",
 		id: "",
-		args: {},
+		props: {},
 		body: [],
 		depth: 0,
 		range: {
@@ -138,41 +130,6 @@ function makeCommentNode() {
 		}
 	};
 }
-/** Creates a new empty Inline node. */
-function makeInlineNode() {
-	return {
-		type: INLINE,
-		structure: "Inline",
-		value: "",
-		id: "",
-		args: {},
-		depth: 0,
-		range: {
-			start: { line: 0, character: 0 },
-			end: { line: 0, character: 0 }
-		}
-	};
-}
-
-// ========================================================================== //
-//  Node Creators                                                             //
-// ========================================================================== //
-/** Creates a new empty AtBlock node. */
-function makeAtBlockNode() {
-	return {
-		type: ATBLOCK,
-		structure: "AtBlock",
-		id: "",
-		args: {},
-		content: "",
-		depth: 0,
-		range: {
-			start: { line: 0, character: 0 },
-			end: { line: 0, character: 0 }
-		}
-	};
-}
-
 /** Creates a new empty Logic node. */
 function makeLogicNode(type = RUNTIME_LOGIC) {
 	return {
@@ -218,53 +175,66 @@ const updateData = (tokens, i) => {
 
 const errorMessage = (tokens, i, expectedValue, behindValue, frontText, filename = null) => {
 	const current = tokens[i] || fallback;
-	const errorLineNumber = current.range.start.line;
-	const errorCharNumber = current.range.start.character;
+	const errorLine = current.range.start.line;
+	const errorColStart = current.range.start.character;
+	const errorColEnd = current.range.end.character;
 	const source = current.source || filename;
-	const sourceLabel = source ? ` [${source}]` : "";
 
+	// Collect all tokens on the error line for the source snippet
 	let lineStartIndex = i;
 	while (
 		lineStartIndex > 0 &&
 		tokens[lineStartIndex - 1] &&
-		tokens[lineStartIndex - 1].range.start.line === errorLineNumber &&
+		tokens[lineStartIndex - 1].range.start.line === errorLine &&
 		(tokens[lineStartIndex - 1].source || filename) === source
 	) {
 		lineStartIndex--;
 	}
-
 	let lineEndIndex = i;
 	while (
 		lineEndIndex < tokens.length - 1 &&
 		tokens[lineEndIndex + 1] &&
-		tokens[lineEndIndex + 1].range.start.line === errorLineNumber &&
+		tokens[lineEndIndex + 1].range.start.line === errorLine &&
 		(tokens[lineEndIndex + 1].source || filename) === source
 	) {
 		lineEndIndex++;
 	}
 
-	// Get all tokens on the error line
-	const lineTokens = tokens.slice(lineStartIndex, lineEndIndex + 1);
-	const lineContent = lineTokens.map(t => t.value).join('');
-
-	// Get content on the line before the error token
-	const tokensBeforeErrorOnLine = tokens.slice(lineStartIndex, i);
-	const contentBeforeErrorOnLine = tokensBeforeErrorOnLine.map(t => t.value).join('');
-
-	const pointerPadding = " ".repeat(contentBeforeErrorOnLine.length);
-	const rangeInfo = current.range.start.line === current.range.end.line
-		? `from column <$yellow:${current.range.start.character}$> to <$yellow:${current.range.end.character}$>`
-		: `from line <$yellow:${current.range.start.line + 1}$>, column <$yellow:${current.range.start.character}$> to line <$yellow:${current.range.end.line + 1}$>, column <$yellow:${current.range.end.character}$>`;
-
-	return [
-		`<$blue:{line}$><$red:Here where error occurred${sourceLabel}:$>{N}${lineContent}{N}${pointerPadding}<$yellow:^$>{N}{N}`,
-		`<$red:${frontText ? frontText : "Expected token"}$>${!frontText ? " <$blue:'" + expectedValue + "'$>" : ""} ${behindValue ? "after <$blue:'" + behindValue + "'$>" : ""} at line <$yellow:${current.range.start.line + 1}$>,`,
-		` ${rangeInfo}`,
-		`{N}<$yellow:Received:$> <$blue:'${current.value === "\n" ? "\\n' (newline)" : current.value}'$>`,
-		` at line <$yellow:${current.range.start.line + 1}$>,`,
-		` ${rangeInfo}{N}`,
-		"<$blue:{line}$>"
-	];
+	const lineContent = tokens.slice(lineStartIndex, lineEndIndex + 1).map(t => t.value).join('');
+	const contentBefore = tokens.slice(lineStartIndex, i).map(t => t.value).join('');
+	const pointerPadding = " ".repeat(contentBefore.length);
+
+	// Location header — file, line, column
+	const lineNum = errorLine + 1;
+	const isMultiLine = current.range.start.line !== current.range.end.line;
+	const colDisplay = isMultiLine
+		? `${errorColStart} → line ${current.range.end.line + 1} col ${errorColEnd}`
+		: errorColStart === errorColEnd ? `${errorColStart}` : `${errorColStart}–${errorColEnd}`;
+
+	// Error description — avoid nested <$color:...$> tags (breaks the non-greedy regex)
+	let errorDesc;
+	if (frontText) {
+		errorDesc = `<$red:${frontText}$>`;
+	} else {
+		errorDesc = `<$red:Expected$> <$blue:'${expectedValue}'$>`;
+		if (behindValue) errorDesc += ` <$red:after$> <$blue:'${behindValue}'$>`;
+	}
+
+	const tokenDisplay = current.value === ""   ? "end of input"
+		: current.value === "\n" ? "newline (\\n)"
+		: `'${current.value}'`;
+
+	const parts = [`{line}`];
+	if (source) parts.push(`<$cyan:File:$> ${source}{N}`);
+	parts.push(`<$cyan:Line:$> <$yellow:${lineNum}$> <$cyan:Col:$> <$yellow:${colDisplay}$>{N}`);
+	parts.push(`{line}`);
+	parts.push(`<$red:Here where error occurred:$>{N}`);
+	parts.push(`  ${lineContent}{N}`);
+	parts.push(`  ${pointerPadding}<$yellow:^$>{N}`);
+	parts.push(`${errorDesc}{N}`);
+	parts.push(`<$yellow:Received:$> <$blue:${tokenDisplay}$>{N}`);
+	parts.push(`{line}`);
+	return parts;
 };
 // ========================================================================== //
 //  Parse Key                                                                 //
@@ -286,6 +256,88 @@ function parseKey(tokens, i) {
 	return [key, i];
 }
 // ========================================================================== //
+//  Read Prefix Key/Fallback from structured p{}/v{} tokens                  //
+// ========================================================================== //
+function readPrefixKeyFallback(tokens, i, prefixType = "p") {
+	if (current_token(tokens, i) && current_token(tokens, i).type === TOKEN_TYPES.PREFIX_OPEN) i++;
+	i = skipJunk(tokens, i);
+
+	let key = "";
+	let fallback = undefined;
+
+	// Read key — must be quoted or unquoted identifier
+	const keyToken = current_token(tokens, i);
+	if (!keyToken || keyToken.type === TOKEN_TYPES.PREFIX_CLOSE) {
+		parserError(errorMessage(tokens, i, "key", "{", 'Prefix requires a key — write p{key} or p{key | "fallback"}'));
+	}
+	if (keyToken.type === TOKEN_TYPES.QUOTE) {
+		i++; // skip opening QUOTE
+		while (current_token(tokens, i) &&
+			current_token(tokens, i).type !== TOKEN_TYPES.QUOTE &&
+			current_token(tokens, i).type !== TOKEN_TYPES.PREFIX_CLOSE &&
+			current_token(tokens, i).type !== TOKEN_TYPES.PIPELINE) {
+			key += current_token(tokens, i).value;
+			i++;
+		}
+		if (current_token(tokens, i) && current_token(tokens, i).type === TOKEN_TYPES.QUOTE) i++;
+	} else if (keyToken.type === TOKEN_TYPES.KEY) {
+		key = keyToken.value.trim();
+		const isValidIdent = /^[a-zA-Z_$][a-zA-Z0-9_$-]*$/.test(key);
+		const isNumeric = /^\d+$/.test(key);
+		// p{} keys must be identifiers; v{} keys may also be positional integers
+		if (!isValidIdent && !(prefixType === "v" && isNumeric)) {
+			parserError(errorMessage(tokens, i, "key", "{", `Invalid prefix key '${key}' — must start with a letter, _ or $`));
+		}
+		i++;
+	} else {
+		parserError(errorMessage(tokens, i, "key", "{", "Invalid prefix key — must be a quoted string or identifier"));
+	}
+
+	i = skipJunk(tokens, i);
+
+	// After key: only | or } is valid
+	const afterKey = current_token(tokens, i);
+	if (!afterKey || (afterKey.type !== TOKEN_TYPES.PIPELINE && afterKey.type !== TOKEN_TYPES.PREFIX_CLOSE)) {
+		parserError(errorMessage(tokens, i, "| or }", key, "Expected '|' or '}' after prefix key"));
+	}
+
+	if (current_token(tokens, i) && current_token(tokens, i).type === TOKEN_TYPES.PIPELINE) {
+		i++; // skip PIPELINE
+		i = skipJunk(tokens, i);
+
+		// Fallback must be a quoted string — any content allowed inside quotes
+		const fallbackToken = current_token(tokens, i);
+		if (!fallbackToken || fallbackToken.type === TOKEN_TYPES.PREFIX_CLOSE) {
+			parserError(errorMessage(tokens, i, '"fallback"', "|", 'Expected a quoted fallback after \'|\' — write p{key | "default"}'));
+		}
+		if (fallbackToken.type === TOKEN_TYPES.QUOTE) {
+			fallback = "";
+			i++; // skip opening QUOTE
+			while (current_token(tokens, i) &&
+				current_token(tokens, i).type !== TOKEN_TYPES.QUOTE &&
+				current_token(tokens, i).type !== TOKEN_TYPES.PREFIX_CLOSE) {
+				fallback += current_token(tokens, i).value;
+				i++;
+			}
+			if (current_token(tokens, i) && current_token(tokens, i).type === TOKEN_TYPES.QUOTE) i++;
+		} else {
+			parserError(errorMessage(tokens, i, '"fallback"', "|", 'Fallback must be a quoted string — write p{key | "default"}'));
+		}
+	}
+
+	i = skipJunk(tokens, i);
+
+	// After key (or fallback): only } is valid
+	const afterFallback = current_token(tokens, i);
+	if (!afterFallback || afterFallback.type !== TOKEN_TYPES.PREFIX_CLOSE) {
+		parserError(errorMessage(tokens, i, "}", key, "Unexpected content inside prefix — only one key and one optional fallback are allowed"));
+	}
+
+	if (current_token(tokens, i) && current_token(tokens, i).type === TOKEN_TYPES.PREFIX_CLOSE) i++;
+
+	return [key, fallback, i];
+}
+// ========================================================================== //
 //  Parse Value                                                               //
 // ========================================================================== //
 function parseValue(tokens, i, placeholders = {}, variables = {}, allowLogic = true) {
@@ -296,7 +348,7 @@ function parseValue(tokens, i, placeholders = {}, variables = {}, allowLogic = t
 		val = "";
 		while (i < tokens.length && current_token(tokens, i).type !== TOKEN_TYPES.QUOTE) {
 			const token = current_token(tokens, i);
-			if (token.type === TOKEN_TYPES.PREFIX_P || token.type === TOKEN_TYPES.PREFIX_JS || token.type === TOKEN_TYPES.PREFIX_V) {
+			if (token.type === TOKEN_TYPES.PREFIX_P || token.type === TOKEN_TYPES.PREFIX_V) {
 				const [resolvedVal, nextI] = parseValue(tokens, i, placeholders, variables, allowLogic);
 				val += resolvedVal;
 				i = nextI;
@@ -312,72 +364,55 @@ function parseValue(tokens, i, placeholders = {}, variables = {}, allowLogic = t
 
 		i++; // consume closing QUOTE
 		return [val, i, true];
-	} else if (current_token(tokens, i).type === TOKEN_TYPES.PREFIX_JS) {
-		val = current_token(tokens, i).value;
-		// V4 NATIVE DATA: Strip js{ } and parse safely
-		if (val.startsWith("js{") && val.endsWith("}")) {
-			const clean = val.slice(3, -1).trim();
-			val = safeDataParse(clean);
-		}
-		i++;
-		return [val, i, false];
-	} else if (current_token(tokens, i).type === TOKEN_TYPES.LOGIC || current_token(tokens, i).type === TOKEN_TYPES.STATIC_KEYWORD || current_token(tokens, i).type === TOKEN_TYPES.RUNTIME_KEYWORD) {
+	} else if (current_token(tokens, i).type === TOKEN_TYPES.STATIC_KEYWORD || current_token(tokens, i).type === TOKEN_TYPES.RUNTIME_KEYWORD) {
 		if (!allowLogic) {
 			parserError(errorMessage(tokens, i, "literal value", "", "Logic blocks are not allowed in this context."));
 		}
 		let isStatic = current_token(tokens, i).type === TOKEN_TYPES.STATIC_KEYWORD;
-		let isRuntimeKeyword = current_token(tokens, i).type === TOKEN_TYPES.RUNTIME_KEYWORD;
-		let nextI = i;
-
-		if (isStatic || isRuntimeKeyword) {
-			nextI = skipJunk(tokens, i + 1);
-			if (!current_token(tokens, nextI) || current_token(tokens, nextI).type !== TOKEN_TYPES.LOGIC) {
-				// Treat as literal text if keyword is not followed by a logic block
-				return [current_token(tokens, i).value, i + 1, false];
-			}
-			i = nextI;
+		let nextI = skipJunk(tokens, i + 1);
+
+		if (!current_token(tokens, nextI) || current_token(tokens, nextI).type !== TOKEN_TYPES.LOGIC_OPEN) {
+			// Keyword not followed by ${ — treat as literal text
+			return [current_token(tokens, i).value, i + 1, false];
 		}
 
-		const logicToken = current_token(tokens, i);
+		// Skip LOGIC_OPEN, read LOGIC body
+		nextI++;
+		const logicToken = current_token(tokens, nextI);
 		const node = makeLogicNode(isStatic ? STATIC_LOGIC : RUNTIME_LOGIC);
-		node.code = logicToken.value;
-		node.range = logicToken.range;
+		node.code = logicToken ? logicToken.value : "";
+		node.range = logicToken ? logicToken.range : current_token(tokens, i).range;
+		nextI++;
+
+		// Consume LOGIC_CLOSE if present
+		if (current_token(tokens, nextI) && current_token(tokens, nextI).type === TOKEN_TYPES.LOGIC_CLOSE) {
+			nextI++;
+		}
 
-		return [node, i + 1, false];
+		return [node, nextI, false];
 	} else if (current_token(tokens, i).type === TOKEN_TYPES.PREFIX_V) {
-		val = current_token(tokens, i).value;
-		// V4.1.0 VARIABLE: Strip v{ } and resolve from local variables
-		if (val.startsWith("v{") && val.endsWith("}")) {
-			const key = val.slice(2, -1).trim();
-			if (variables[key] !== undefined) {
-				val = variables[key];
-				if (!variables.__consumed__) {
-					Object.defineProperty(variables, "__consumed__", {
-						value: new Set(),
-						enumerable: false,
-						configurable: true
-					});
-				}
-				variables.__consumed__.add(key);
-			} else {
-				val = getPrefixValue('v', key);
+		i++; // consume PREFIX_V keyword
+		const [vKey, vFallback, vNextI] = readPrefixKeyFallback(tokens, i, "v");
+		i = vNextI;
+		if (variables[vKey] !== undefined) {
+			val = variables[vKey];
+			if (!variables.__consumed__) {
+				Object.defineProperty(variables, "__consumed__", {
+					value: new Set(),
+					enumerable: false,
+					configurable: true
+				});
 			}
+			variables.__consumed__.add(vKey);
+		} else {
+			val = vFallback !== undefined ? vFallback : getPrefixValue('v', vKey);
 		}
-		i++;
-		return [val, i, false];
-	} else if (current_token(tokens, i).type === TOKEN_TYPES.PREFIX_C) {
-		val = current_token(tokens, i).value;
-		// PREFIX_C is preserved for the resolveModules expansion phase
-		i++;
 		return [val, i, false];
 	} else if (current_token(tokens, i).type === TOKEN_TYPES.PREFIX_P) {
-		val = current_token(tokens, i).value;
-		// V4 PLACEHOLDER: Strip p{ } and resolve from config
-		if (val.startsWith("p{") && val.endsWith("}")) {
-			const key = val.slice(2, -1).trim();
-			val = placeholders[key] !== undefined ? placeholders[key] : getPrefixValue('p', key);
-		}
-		i++;
+		i++; // consume PREFIX_P keyword
+		const [pKey, pFallback, pNextI] = readPrefixKeyFallback(tokens, i);
+		i = pNextI;
+		val = placeholders[pKey] !== undefined ? placeholders[pKey] : (pFallback !== undefined ? pFallback : getPrefixValue('p', pKey));
 		return [val, i, false];
 	} else {
 		val = "";
@@ -390,9 +425,7 @@ function parseValue(tokens, i, placeholders = {}, variables = {}, allowLogic = t
 				token.type === TOKEN_TYPES.COMMA ||
 				token.type === TOKEN_TYPES.CLOSE_BRACKET ||
 				token.type === TOKEN_TYPES.COLON ||
-				token.type === TOKEN_TYPES.SEMICOLON ||
-				token.type === TOKEN_TYPES.EXCLAMATION_MARK ||
-				token.type === TOKEN_TYPES.CLOSE_PAREN) break;
+				token.type === TOKEN_TYPES.EXCLAMATION_MARK) break;
 
 			if (token.type === TOKEN_TYPES.ESCAPE) {
 				// Remove backslash
@@ -425,7 +458,6 @@ function parseComma(tokens, i, beforeChar = "") {
 				current_token(tokens, i).type !== TOKEN_TYPES.IDENTIFIER &&
 				current_token(tokens, i).type !== TOKEN_TYPES.KEY &&
 				current_token(tokens, i).type !== TOKEN_TYPES.QUOTE &&
-				current_token(tokens, i).type !== TOKEN_TYPES.PREFIX_JS &&
 				current_token(tokens, i).type !== TOKEN_TYPES.PREFIX_P)
 		) {
 			parserError(errorMessage(tokens, i, "value", ","));
@@ -460,19 +492,6 @@ function parseColon(tokens, i, afterChar = "") {
 	updateData(tokens, i);
 	return i;
 }
-// ========================================================================== //
-//  Parse ';'                                                                 //
-// ========================================================================== //
-function parseSemiColon(tokens, i, afterChar = "") {
-	i = skipJunk(tokens, i);
-	if (!current_token(tokens, i) || (current_token(tokens, i) && current_token(tokens, i).type !== TOKEN_TYPES.SEMICOLON)) {
-		parserError(errorMessage(tokens, i, ";", afterChar));
-	}
-	i++;
-	i = skipJunk(tokens, i);
-	updateData(tokens, i);
-	return i;
-}
 /**
  * Parses a standard SomMark Block ([id] ... [end]).
  * Blocks are structural elements that can contain nested content.
@@ -495,7 +514,7 @@ function parseBlock(tokens, i, filename = null, placeholders = {}, variables = {
 	updateData(tokens, i);
 
 	const idToken = current_token(tokens, i);
-	if (!idToken || idToken.type === TOKEN_TYPES.EOF) {
+	if (!idToken || idToken.type === TOKEN_TYPES.EOF || idToken.type === TOKEN_TYPES.CLOSE_BRACKET) {
 		parserError(errorMessage(tokens, i, "Block ID", "[", "Missing Block Identifier"));
 	}
 	const id = idToken.value;
@@ -547,10 +566,9 @@ function parseBlock(tokens, i, filename = null, placeholders = {}, variables = {
 				current_token(tokens, i).type !== TOKEN_TYPES.END_KEYWORD &&
 				current_token(tokens, i).type !== TOKEN_TYPES.KEY &&
 				current_token(tokens, i).type !== TOKEN_TYPES.QUOTE &&
-				current_token(tokens, i).type !== TOKEN_TYPES.PREFIX_JS &&
 				current_token(tokens, i).type !== TOKEN_TYPES.PREFIX_V &&
 				current_token(tokens, i).type !== TOKEN_TYPES.PREFIX_P &&
-				current_token(tokens, i).type !== TOKEN_TYPES.LOGIC &&
+				current_token(tokens, i).type !== TOKEN_TYPES.LOGIC_OPEN &&
 				current_token(tokens, i).type !== TOKEN_TYPES.STATIC_KEYWORD &&
 				current_token(tokens, i).type !== TOKEN_TYPES.RUNTIME_KEYWORD)
 		) {
@@ -597,9 +615,9 @@ function parseBlock(tokens, i, filename = null, placeholders = {}, variables = {
 			i = valueIndex;
 
 			// Store Argument
-			blockNode.args[String(argIndex++)] = v;
+			blockNode.props[String(argIndex++)] = v;
 			if (k) {
-				blockNode.args[k] = v;
+				blockNode.props[k] = v;
 			}
 			k = "";
 			v = "";
@@ -700,6 +718,23 @@ function parseBlock(tokens, i, filename = null, placeholders = {}, variables = {
 			i++;
 			i = skipJunk(tokens, i);
 			updateData(tokens, i);
+
+			// Named closing: [end:blockname] — the lexer emits END_KEYWORD "end:name" as one
+			// token because ':' is stripped from stop chars at block-start (XML namespace support).
+			const endValue = current.value.trim();
+			if (endValue.includes(":")) {
+				const closingName = endValue.slice(endValue.indexOf(":") + 1);
+				if (!closingName) {
+					parserError(errorMessage(tokens, i - 1, "block name", "", "Missing block name — write [end:blockname] to name the closing tag"));
+				}
+				const expected = end_stack[end_stack.length - 1];
+				if (expected && closingName !== expected.id) {
+					parserError(errorMessage(tokens, i - 1, closingName, "",
+						`Mismatched closing tag: [end:${closingName}] cannot close '${closingName}' — '${expected.id}' is still open (opened at line ${expected.line}, col ${expected.col})`
+					));
+				}
+			}
+
 			if (
 				!current_token(tokens, i) ||
 				(current_token(tokens, i) && current_token(tokens, i).type !== TOKEN_TYPES.CLOSE_BRACKET)
@@ -734,147 +769,6 @@ function parseBlock(tokens, i, filename = null, placeholders = {}, variables = {
 	}
 	return [blockNode, i];
 }
-/**
- * Parses an Inline Statement ((content) -> (id)).
- * Inlines are fast, non-nesting formatting elements.
- * 
- * @param {Object[]} tokens - Token stream.
- * @param {number} i - Initial index.
- * @param {Object} placeholders - Dynamic public API data.
- * @returns {[Object, number]} The parsed Inline node and new index.
- */
-function parseInline(tokens, i, placeholders = {}, depth = 0) {
-	const inlineNode = makeInlineNode();
-	inlineNode.depth = depth;
-	const openParenToken = current_token(tokens, i);
-	inlineNode.range.start = openParenToken.range.start;
-
-	// consume '('
-	i++;
-	updateData(tokens, i);
-
-	// Phase 1: Content capture (Lexer provides high-level TEXT/ESCAPE tokens here)
-	while (i < tokens.length) {
-		const token = current_token(tokens, i);
-		if (!token || token.type === TOKEN_TYPES.CLOSE_PAREN) break;
-
-		if (token.type === TOKEN_TYPES.ESCAPE) {
-			inlineNode.value += token.value.slice(1);
-		} else if (token.type !== TOKEN_TYPES.COMMENT) {
-			inlineNode.value += token.value;
-		}
-		i++;
-	}
-
-	if (!current_token(tokens, i) || current_token(tokens, i).type !== TOKEN_TYPES.CLOSE_PAREN) {
-		parserError(errorMessage(tokens, i, ")", "inline content"));
-	}
-	i++; // consume ')'
-
-	// Collapse newlines and whitespace for "inline" behavior
-	inlineNode.value = inlineNode.value.replace(/\s+/g, " ").trim();
-
-	i = skipJunk(tokens, i);
-	if (!current_token(tokens, i) || current_token(tokens, i).type !== TOKEN_TYPES.THIN_ARROW) {
-		parserError(errorMessage(tokens, i, "->", ")"));
-	}
-	i++; // consume '->'
-
-	i = skipJunk(tokens, i);
-	if (!current_token(tokens, i) || current_token(tokens, i).type !== TOKEN_TYPES.OPEN_PAREN) {
-		parserError(errorMessage(tokens, i, "(", "->"));
-	}
-	i++; // consume '('
-	i = skipJunk(tokens, i);
-	const idToken = current_token(tokens, i);
-	const allowedInlineIdTypes = new Set([
-		TOKEN_TYPES.IDENTIFIER,
-		TOKEN_TYPES.KEY,
-		TOKEN_TYPES.IMPORT,
-		TOKEN_TYPES.USE_MODULE,
-		TOKEN_TYPES.SLOT_KEYWORD,
-		TOKEN_TYPES.FOR_EACH
-	]);
-	if (!idToken || !allowedInlineIdTypes.has(idToken.type)) {
-		parserError(errorMessage(tokens, i, inline_id, "("));
-	}
-	inlineNode.id = idToken.value.trim();
-	validateName(inlineNode.id);
-
-	i++; // consume ID
-	i = skipJunk(tokens, i);
-
-	const hasArgsTrigger = current_token(tokens, i) && (
-		current_token(tokens, i).type === TOKEN_TYPES.COLON ||
-		current_token(tokens, i).type === TOKEN_TYPES.EQUAL
-	);
-
-	if (hasArgsTrigger) {
-		const separator = current_token(tokens, i).value;
-		i++; // consume ':' or '='
-		i = skipJunk(tokens, i);
-
-		// Ensure there is a value after the separator
-		const nextToken = current_token(tokens, i);
-		if (!nextToken || nextToken.type === TOKEN_TYPES.CLOSE_PAREN || nextToken.type === TOKEN_TYPES.COMMA) {
-			parserError(errorMessage(tokens, i, inline_value, separator, `Missing value after ${separator === "=" ? "equals" : "colon"}`));
-		}
-
-		let k = "";
-		let v = "";
-		let argIndex = 0;
-
-		while (i < tokens.length) {
-			i = skipJunk(tokens, i);
-			const token = current_token(tokens, i);
-			if (!token || token.type === TOKEN_TYPES.CLOSE_PAREN) break;
-
-			if (token.type === TOKEN_TYPES.KEY) {
-				let [key, keyIndex] = parseKey(tokens, i);
-				k = key;
-				i = keyIndex;
-				i = skipJunk(tokens, i);
-				i = parseColon(tokens, i, "inline argument");
-				i = skipJunk(tokens, i);
-
-				// Ensure there is a value after the colon
-				const nextToken = current_token(tokens, i);
-				if (!nextToken || nextToken.type === TOKEN_TYPES.CLOSE_PAREN || nextToken.type === TOKEN_TYPES.COMMA) {
-					parserError(errorMessage(tokens, i, inline_value, ":", "Missing value after colon"));
-				}
-				validateName(k);
-			}
-
-			let [value, valueIndex, isQuoted] = parseValue(tokens, i, placeholders, {}, false);
-			v = value;
-			i = valueIndex;
-
-			inlineNode.args[String(argIndex++)] = v;
-			if (k) {
-				inlineNode.args[k] = v;
-			}
-			k = "";
-			v = "";
-
-			i = skipJunk(tokens, i);
-			if (current_token(tokens, i) && current_token(tokens, i).type === TOKEN_TYPES.COMMA) {
-				i = parseComma(tokens, i, "inline argument");
-			} else {
-				break;
-			}
-		}
-	}
-
-	i = skipJunk(tokens, i);
-	if (!current_token(tokens, i) || current_token(tokens, i).type !== TOKEN_TYPES.CLOSE_PAREN) {
-		parserError(errorMessage(tokens, i, ")", inlineNode.id));
-	}
-	const finalParenToken = current_token(tokens, i);
-	i++; // consume ')'
-	inlineNode.range.end = finalParenToken.range.end;
-
-	return [inlineNode, i];
-}
 /**
  * Parses a stream of text tokens into a single Text node.
  * Handles unescaping and placeholder resolution.
@@ -902,7 +796,7 @@ function parseText(tokens, i, placeholders = {}, variables = {}, depth = 0, opti
 			i++;
 		} else if (token.type === TOKEN_TYPES.STATIC_KEYWORD || token.type === TOKEN_TYPES.RUNTIME_KEYWORD) {
 			const nextIdx = skipJunk(tokens, i + 1);
-			if (tokens[nextIdx] && tokens[nextIdx].type === TOKEN_TYPES.LOGIC) {
+			if (tokens[nextIdx] && tokens[nextIdx].type === TOKEN_TYPES.LOGIC_OPEN) {
 				// Stop consuming text; this is the start of a logic block
 				break;
 			}
@@ -921,44 +815,31 @@ function parseText(tokens, i, placeholders = {}, variables = {}, depth = 0, opti
 			}
 			i++;
 		} else if (token.type === TOKEN_TYPES.PREFIX_P) {
-			const val = token.value;
-			if (val.startsWith("p{") && val.endsWith("}")) {
-				const match = [val.slice(2, -1).trim(), val, 'p'];
-				const key = match[0];
-				const layer = match[2]; // 'p' or 'v'
-
-				if (placeholders[key] !== undefined) {
-					textNode.text += String(placeholders[key]);
-				} else {
-					// Use the unique 'Unresolved Envelope' format via helper
-					textNode.text += getPrefixValue(layer, key);
-				}
+			i++; // consume PREFIX_P keyword
+			const [tpKey, tpFallback, tpNextI] = readPrefixKeyFallback(tokens, i);
+			i = tpNextI;
+			if (placeholders[tpKey] !== undefined) {
+				textNode.text += String(placeholders[tpKey]);
 			} else {
-				textNode.text += val;
+				textNode.text += tpFallback !== undefined ? tpFallback : getPrefixValue('p', tpKey);
 			}
-			i++;
 		} else if (token.type === TOKEN_TYPES.PREFIX_V) {
-			const val = token.value;
-			if (val.startsWith("v{") && val.endsWith("}")) {
-				const key = val.slice(2, -1).trim();
-				if (variables[key] !== undefined) {
-					textNode.text += String(variables[key]);
-					if (!variables.__consumed__) {
-						Object.defineProperty(variables, "__consumed__", {
-							value: new Set(),
-							enumerable: false,
-							configurable: true
-						});
-					}
-					variables.__consumed__.add(key);
-				} else {
-					// Use the unique 'Unresolved Envelope' format via helper
-					textNode.text += getPrefixValue('v', key);
+			i++; // consume PREFIX_V keyword
+			const [tvKey, tvFallback, tvNextI] = readPrefixKeyFallback(tokens, i, "v");
+			i = tvNextI;
+			if (variables[tvKey] !== undefined) {
+				textNode.text += String(variables[tvKey]);
+				if (!variables.__consumed__) {
+					Object.defineProperty(variables, "__consumed__", {
+						value: new Set(),
+						enumerable: false,
+						configurable: true
+					});
 				}
+				variables.__consumed__.add(tvKey);
 			} else {
-				textNode.text += val;
+				textNode.text += tvFallback !== undefined ? tvFallback : getPrefixValue('v', tvKey);
 			}
-			i++;
 		} else {
 			break;
 		}
@@ -968,155 +849,6 @@ function parseText(tokens, i, placeholders = {}, variables = {}, depth = 0, opti
 	}
 	return [textNode, i];
 }
-/**
- * Parses an At-Block (@_id_@: args; content @_end_@).
- * At-Blocks maintain raw content preservation.
- * 
- * @param {Object[]} tokens - Token stream.
- * @param {number} i - Initial index.
- * @param {string|null} filename - Source filename.
- * @param {Object} placeholders - Dynamic public API data.
- * @returns {[Object, number]} The At-Block node and new index.
- */
-function parseAtBlock(tokens, i, filename = null, placeholders = {}, depth = 0) {
-	const atBlockNode = makeAtBlockNode();
-	atBlockNode.depth = depth;
-	const openAtToken = current_token(tokens, i);
-	atBlockNode.range.start = openAtToken.range.start;
-
-	// consume '@_'
-	i++;
-	i = skipJunk(tokens, i);
-	updateData(tokens, i);
-
-	const idToken = current_token(tokens, i);
-	if (!idToken || idToken.type === TOKEN_TYPES.EOF) {
-		parserError(errorMessage(tokens, i, "AtBlock ID", "@_", "Missing AtBlock Identifier"));
-	}
-
-	const id = idToken.value;
-	if (id.trim() === end_keyword) {
-		parserError(errorMessage(tokens, i, id, "", `'${id.trim()}' is a reserved keyword and cannot be used as an identifier.`));
-	}
-
-	atBlockNode.id = id.trim();
-	validateName(atBlockNode.id);
-
-	// consume ID
-	i++;
-	i = skipJunk(tokens, i);
-	updateData(tokens, i);
-
-	if (!current_token(tokens, i) || (current_token(tokens, i) && current_token(tokens, i).type !== TOKEN_TYPES.CLOSE_AT)) {
-		parserError(errorMessage(tokens, i, "_@", "at-block identifier"));
-	}
-	// consume '_@'
-	i++;
-	i = skipJunk(tokens, i);
-	updateData(tokens, i);
-
-	if (current_token(tokens, i) && current_token(tokens, i).type === TOKEN_TYPES.COLON) {
-		// consume ':'
-		i++;
-		i = skipJunk(tokens, i);
-
-		// Ensure there is a value after the colon
-		const nextToken = current_token(tokens, i);
-		if (!nextToken || nextToken.type === TOKEN_TYPES.SEMICOLON || nextToken.type === TOKEN_TYPES.COMMA) {
-			parserError(errorMessage(tokens, i, at_value, ":", "Missing value after colon"));
-		}
-
-		let k = "";
-		let v = "";
-		let argIndex = 0;
-
-		while (i < tokens.length) {
-			i = skipJunk(tokens, i);
-			const token = current_token(tokens, i);
-			if (!token || token.type === TOKEN_TYPES.SEMICOLON) break;
-
-			const isQuotedKey = token.type === TOKEN_TYPES.QUOTE && peek(tokens, i, 1) && (peek(tokens, i, 1).type === TOKEN_TYPES.KEY);
-
-			if (token.type === TOKEN_TYPES.KEY || isQuotedKey) {
-				let [key, keyIndex] = parseKey(tokens, i);
-				k = key;
-				i = keyIndex;
-				i = skipJunk(tokens, i);
-				i = parseColon(tokens, i, "at-block argument");
-				i = skipJunk(tokens, i);
-
-				// Ensure there is a value after the colon
-				const nextToken = current_token(tokens, i);
-				if (!nextToken || nextToken.type === TOKEN_TYPES.SEMICOLON || nextToken.type === TOKEN_TYPES.COMMA) {
-					parserError(errorMessage(tokens, i, at_value, ":", "Missing value after colon"));
-				}
-
-				if (token.type === TOKEN_TYPES.KEY) {
-					validateName(k);
-				}
-			}
-
-			let [value, valueIndex, isQuoted] = parseValue(tokens, i, placeholders, {}, false);
-			v = value;
-			i = valueIndex;
-
-			atBlockNode.args[String(argIndex++)] = v;
-			if (k) {
-				atBlockNode.args[k] = v;
-			}
-			k = "";
-			v = "";
-
-			i = skipJunk(tokens, i);
-			if (current_token(tokens, i) && current_token(tokens, i).type === TOKEN_TYPES.COMMA) {
-				i = parseComma(tokens, i, "at-block argument");
-			} else {
-				break;
-			}
-		}
-	}
-
-	// Semicolon is ALWAYS required after ID or ARGS
-	i = parseSemiColon(tokens, i, "at-block header");
-
-	// Body Capture
-	i = skipJunk(tokens, i);
-	if (current_token(tokens, i) && current_token(tokens, i).type === TOKEN_TYPES.TEXT) {
-		atBlockNode.content = current_token(tokens, i).value;
-		i++;
-	} else {
-		parserError(errorMessage(tokens, i, "content", "at-block body"));
-	}
-
-	// End Marker (@_end_@)
-	i = skipJunk(tokens, i);
-	if (!current_token(tokens, i) || current_token(tokens, i).type !== TOKEN_TYPES.OPEN_AT) {
-		parserError(errorMessage(tokens, i, "@_", "at-block content"));
-	}
-	i++; // consume '@_'
-	i = skipJunk(tokens, i);
-	const endToken = current_token(tokens, i);
-	if (!endToken || (endToken.type !== TOKEN_TYPES.END_KEYWORD && endToken.value.trim() !== end_keyword)) {
-		let extraInfo = "";
-		if (endToken && endToken.value) {
-			const dist = levenshtein(endToken.value.trim().toLowerCase(), "end");
-			if (dist > 0 && dist <= 2) {
-				extraInfo = ` (Did you mean '@_end_@'?)`;
-			}
-		}
-		parserError(errorMessage(tokens, i, "end", "AtBlock Body", extraInfo));
-	}
-	i++; // consume 'end'
-	i = skipJunk(tokens, i);
-	if (!current_token(tokens, i) || current_token(tokens, i).type !== TOKEN_TYPES.CLOSE_AT) {
-		parserError(errorMessage(tokens, i, "_@", "end marker"));
-	}
-	const closeAtToken = current_token(tokens, i);
-	i++; // consume '_@'
-	atBlockNode.range.end = closeAtToken.range.end;
-
-	return [atBlockNode, i];
-}
 // ========================================================================== //
 //  Parse Comments                                                            //
 // ========================================================================== //
@@ -1172,73 +904,38 @@ function parseNode(tokens, i, filename = null, placeholders = {}, variables = {}
 		return parseBlock(tokens, i, filename, placeholders, variables, depth);
 	}
 	// ========================================================================== //
-	//  Inline Statement or Text                                                  //
-	// ========================================================================== //
-	else if (current_token(tokens, i) && current_token(tokens, i).type === TOKEN_TYPES.OPEN_PAREN) {
-		let j = i + 1;
-		let parenCount = 1;
-		let foundArrow = false;
-		while (j < tokens.length) {
-			const token = tokens[j];
-			if (token.type === TOKEN_TYPES.OPEN_PAREN) {
-				parenCount++;
-			} else if (token.type === TOKEN_TYPES.CLOSE_PAREN) {
-				parenCount--;
-			}
-
-			if (parenCount === 0) {
-				const nextIdx = skipJunk(tokens, j + 1);
-				if (tokens[nextIdx] && tokens[nextIdx].type === TOKEN_TYPES.THIN_ARROW) {
-					foundArrow = true;
-				}
-				break;
-			}
-			// Safe-guard: If we hit a [ or @, it's highly unlikely to be an inline statement content
-			// unless it's escaped, but lexer already handles [ and @ as structural tokens if not escaped.
-			if (token.type === TOKEN_TYPES.OPEN_BRACKET || token.type === TOKEN_TYPES.OPEN_AT) break;
-			j++;
-		}
-
-		if (foundArrow) {
-			return parseInline(tokens, i, placeholders, depth);
-		}
-
-		// Treat as text if not an inline
-		const textNode = makeTextNode();
-		textNode.text = current_token(tokens, i).value;
-		textNode.depth = depth;
-		textNode.range = current_token(tokens, i).range;
-		return [textNode, i + 1];
-	}
-	// ========================================================================== //
 	//  Logic Block                                                               //
 	// ========================================================================== //
-	else if (current_token(tokens, i) && (current_token(tokens, i).type === TOKEN_TYPES.STATIC_KEYWORD || current_token(tokens, i).type === TOKEN_TYPES.RUNTIME_KEYWORD || current_token(tokens, i).type === TOKEN_TYPES.LOGIC)) {
+	else if (current_token(tokens, i) && (current_token(tokens, i).type === TOKEN_TYPES.STATIC_KEYWORD || current_token(tokens, i).type === TOKEN_TYPES.RUNTIME_KEYWORD)) {
 		let isStatic = current_token(tokens, i).type === TOKEN_TYPES.STATIC_KEYWORD;
-		let isRuntimeKeyword = current_token(tokens, i).type === TOKEN_TYPES.RUNTIME_KEYWORD;
 		let startRange = current_token(tokens, i).range;
-		let nextI = i;
-
-		if (isStatic || isRuntimeKeyword) {
-			if (isStatic) global_static_logic_count++;
-			nextI = skipJunk(tokens, i + 1);
-			if (!current_token(tokens, nextI) || current_token(tokens, nextI).type !== TOKEN_TYPES.LOGIC) {
-				// Treat as normal text if keyword is not followed by a logic block
-				return parseText(tokens, i, placeholders, variables, depth);
-			}
-			i = nextI;
+		let nextI = skipJunk(tokens, i + 1);
+
+		if (!current_token(tokens, nextI) || current_token(tokens, nextI).type !== TOKEN_TYPES.LOGIC_OPEN) {
+			// Keyword not followed by ${ — treat as normal text
+			return parseText(tokens, i, placeholders, variables, depth);
 		}
 
-		const logicToken = current_token(tokens, i);
+		if (isStatic) global_static_logic_count++;
+
+		// Skip LOGIC_OPEN, read LOGIC body
+		nextI++;
+		const logicToken = current_token(tokens, nextI);
 		const node = makeLogicNode(isStatic ? STATIC_LOGIC : RUNTIME_LOGIC);
-		node.code = logicToken.value;
+		node.code = logicToken ? logicToken.value : "";
 		node.depth = depth;
 		node.range = {
-			start: (isStatic || isRuntimeKeyword) ? startRange.start : logicToken.range.start,
-			end: logicToken.range.end
+			start: startRange.start,
+			end: logicToken ? logicToken.range.end : startRange.end
 		};
+		nextI++;
 
-		return [node, i + 1];
+		// Consume LOGIC_CLOSE if present
+		if (current_token(tokens, nextI) && current_token(tokens, nextI).type === TOKEN_TYPES.LOGIC_CLOSE) {
+			nextI++;
+		}
+
+		return [node, nextI];
 	}
 	// ========================================================================== //
 	//  Text or Placeholder                                                       //
@@ -1253,12 +950,6 @@ function parseNode(tokens, i, filename = null, placeholders = {}, variables = {}
 			current_token(tokens, i).type === TOKEN_TYPES.PREFIX_P)
 	) {
 		return parseText(tokens, i, placeholders, variables, depth);
-	}
-	// ========================================================================== //
-	//  Atblock                                                                   //
-	// ========================================================================== //
-	else if (current_token(tokens, i) && (current_token(tokens, i).type === TOKEN_TYPES.OPEN_AT)) {
-		return parseAtBlock(tokens, i, filename, placeholders, depth);
 	} else {
 		// FALLBACK: Treat any other token as TEXT to avoid infinite loops and allow literal content
 		const textNode = makeTextNode();
@@ -1313,7 +1004,7 @@ function parser(tokens, filename = null, placeholders = {}, variables = {}) {
 				const val = token.value.trim().toLowerCase();
 				if (val === "") return "";
 				const dist = levenshtein(val, "end");
-				if (dist > 0 && dist <= 2) return ` (Did you mean <$cyan:'[end]'$>?)`;
+				if (dist > 0 && dist <= 2) return ` Did you mean '[end]'?`;
 			}
 			return "";
 		};