sommark 4.5.3 → 5.0.1

package/dist/sommark.parser.js

@@ -8,16 +8,10 @@
  * @property {string} END_KEYWORD - 'end' value.
  * @property {string} IDENTIFIER - Block or inline name (e.g. 'Person', 'import', '$use-module').
  * @property {string} EQUAL - '=' char.
- * @property {string} VALUE - Data values. Encapsulates Quoted Strings ("...") and Prefix Layers (js{}, p{}).
+ * @property {string} VALUE - Data values. Encapsulates Quoted Strings ("...") and Prefix Layers (p{}, v{}).
  * @property {string} TEXT - Plain unformatted text content.
- * @property {string} THIN_ARROW - '->' sequence.
- * @property {string} OPEN_PAREN - '(' char.
- * @property {string} CLOSE_PAREN - ')' char.
- * @property {string} OPEN_AT - '@_' sequence (At-Block start).
- * @property {string} CLOSE_AT - '_@' sequence (At-Header end).
  * @property {string} COLON - ':' char.
  * @property {string} COMMA - ',' char.
- * @property {string} SEMICOLON - ';' char (At-Block separator).
  * @property {string} COMMENT - '#' comments.
  * @property {string} COMMENT_BLOCK - '###' comments.
  * @property {string} ESCAPE - '\' char. Used for literalizing structural chars like '\"' or '\['.
@@ -25,7 +19,6 @@
  * @property {string} EXCLAMATION_MARK - '!' char.
  * @property {string} IMPORT - 'import' keyword.
  * @property {string} USE_MODULE - '$use-module' keyword.
- * @property {string} PREFIX_JS - 'js{}' prefix layer.
  * @property {string} PREFIX_P - 'p{}' placeholder layer.
  * @property {string} PREFIX_V - 'v{}' local variable layer.
  * @property {string} EOF - End of File indicator.
@@ -40,18 +33,11 @@ const TOKEN_TYPES = {
   EQUAL: "EQUAL",
   VALUE: "VALUE",
   QUOTE: "QUOTE",
-  PREFIX_JS: "PREFIX_JS",
   PREFIX_P: "PREFIX_P",
   PREFIX_V: "PREFIX_V",
   TEXT: "TEXT",
-  THIN_ARROW: "THIN_ARROW",
-  OPEN_PAREN: "OPEN_PAREN",
-  CLOSE_PAREN: "CLOSE_PAREN",
-  OPEN_AT: "OPEN_AT",
-  CLOSE_AT: "CLOSE_AT",
   COLON: "COLON",
   COMMA: "COMMA",
-  SEMICOLON: "SEMICOLON",
   COMMENT: "COMMENT",
   COMMENT_BLOCK: "COMMENT_BLOCK",
   ESCAPE: "ESCAPE",
@@ -61,8 +47,13 @@ const TOKEN_TYPES = {
   WHITESPACE: "WHITESPACE",
   STATIC_KEYWORD: "STATIC_KEYWORD",
   RUNTIME_KEYWORD: "RUNTIME_KEYWORD",
+  LOGIC_OPEN: "LOGIC_OPEN",
   LOGIC: "LOGIC",
+  LOGIC_CLOSE: "LOGIC_CLOSE",
   FOR_EACH: "FOR_EACH",
+  PREFIX_OPEN: "PREFIX_OPEN",
+  PREFIX_CLOSE: "PREFIX_CLOSE",
+  PIPELINE: "PIPELINE",
   EOF: "EOF"
 };
 
@@ -93,8 +84,6 @@ function peek(input, index, offset) {
  */
 const BLOCK = "Block",
 	TEXT = "Text",
-	INLINE = "Inline",
-	ATBLOCK = "AtBlock",
 	COMMENT = "Comment",
 	COMMENT_BLOCK = "CommentBlock",
 	IMPORT = "Import",
@@ -107,13 +96,8 @@ const BLOCK = "Block",
 /**
  * Names for symbols used to separate parts of the code (like commas and colons).
  */
-const SEMICOLON = "Semicolon",
-	BLOCKCOMMA = "Block-comma",
-	ATBLOCKCOMMA = "Atblock-comma",
-	INLINECOMMA = "Inline-comma",
-	BLOCKCOLON = "Block-colon",
-	ATBLOCKCOLON = "Atblock-colon",
-	INLINECOLON = "Inline-colon";
+const BLOCKCOMMA = "Block-comma",
+	BLOCKCOLON = "Block-colon";
 
 /**
  * These names are used in error messages to tell you exactly which part 
@@ -123,12 +107,6 @@ const block_id = "Block Identifier",
 	block_value = "Block Value",
 	block_key = "Block Key",
 	block_end = "Block end",
-	inline_id = "Inline Identifier",
-	inline_text = "Inline Text",
-	at_id = "At Identifier",
-	at_value = "At Value",
-	atblock_key = "AtBlock Key",
-	at_end = "Atblock End",
 	/** Reserved keyword for closing blocks */
 	end_keyword = "end",
 	slot_keyword = "slot",
@@ -136,9 +114,6 @@ const block_id = "Block Identifier",
 
 var labels = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  ATBLOCK: ATBLOCK,
-  ATBLOCKCOLON: ATBLOCKCOLON,
-  ATBLOCKCOMMA: ATBLOCKCOMMA,
   BLOCK: BLOCK,
   BLOCKCOLON: BLOCKCOLON,
   BLOCKCOMMA: BLOCKCOMMA,
@@ -146,225 +121,20 @@ var labels = /*#__PURE__*/Object.freeze({
   COMMENT_BLOCK: COMMENT_BLOCK,
   FOR_EACH: FOR_EACH,
   IMPORT: IMPORT,
-  INLINE: INLINE,
-  INLINECOLON: INLINECOLON,
-  INLINECOMMA: INLINECOMMA,
   RUNTIME_LOGIC: RUNTIME_LOGIC,
-  SEMICOLON: SEMICOLON,
   SLOT: SLOT,
   STATIC_LOGIC: STATIC_LOGIC,
   TEXT: TEXT,
   USE_MODULE: USE_MODULE,
-  at_end: at_end,
-  at_id: at_id,
-  at_value: at_value,
-  atblock_key: atblock_key,
   block_end: block_end,
   block_id: block_id,
   block_key: block_key,
   block_value: block_value,
   end_keyword: end_keyword,
   for_each_keyword: for_each_keyword,
-  inline_id: inline_id,
-  inline_text: inline_text,
   slot_keyword: slot_keyword
 });
 
-/**
- * Wraps your text in a color if colors are turned on.
- * 
- * @param {string} color - The color to use (red, green, yellow, blue, magenta, or cyan).
- * @param {string} text - The text you want to color.
- * @returns {string} - The colored text, or plain text if colors are off.
- * @throws {Error} - Fails if you forget to provide the text.
- */
-function colorize(color, text) {
-        if (!text) throw new Error("argument 'text' is not defined.");
-        return text;
-}
-
-/**
- * SomMark Errors
- * Handles formatting and throwing errors with beautiful CLI coloring and pointers.
- */
-
-// ========================================================================== //
-//  Message Formatting                                                       //
-// ========================================================================== //
-
-/**
- * Processes a message by applying colors and formatting.
- * Supports:
- * - {line} : Adds a horizontal line
- * - {N} : Adds a new line
- * - <$color: Text$> : Adds color (red, yellow, green, blue, magenta, cyan)
- * 
- * @param {string|string[]} text - The message or list of message parts to format.
- * @returns {string} - The final formatted and colored string.
- */
-function formatMessage(text) {
-	const horizontal_rule = "\n----------------------------------------------------------------------------------------------\n";
-	const pattern = /<\$([^:]+):([\s\S]*?)\$>/g;
-
-	if (Array.isArray(text)) {
-		text = text.join("");
-	}
-
-	text = text.replace(pattern, (match, color, content) => {
-		return colorize(color, content.trim());
-	});
-	text = text.replaceAll("{line}", horizontal_rule);
-	text = text.replaceAll("{N}", "\n");
-
-	text = text
-		.split("\n")
-		.filter(value => value !== "")
-		.join("\n")
-		.trim();
-
-	return text;
-}
-
-/**
- * Creates a detailed error message showing where the error happened in the code.
- * It adds a line number, a snippet of the code, and a pointer (^) to the exact spot.
- * 
- * @param {string} src - The original code being parsed.
- * @param {Object} range - The location of the error (line and character).
- * @param {string|null} filename - The name of the file (optional).
- * @param {string|string[]} message - The error message to show.
- * @param {string} typeName - The type of error (e.g., "Lexer" or "Parser").
- * @returns {string[]} - A list of message parts that make up the final error report.
- */
-function formatErrorWithContext(src, range, filename, message, typeName) {
-	if (!src || !range || !range.start) return message;
-
-	const lines = src.split("\n");
-	const lineIndex = range.start.line;
-	const lineContent = lines[lineIndex] || "";
-	const pointerPadding = " ".repeat(range.start.character);
-	const sourceLabel = filename ? ` [${filename}]` : "";
-
-	const rangeInfo =
-		range.start.line === range.end.line
-			? `from column <$yellow:${range.start.character}$> to <$yellow:${range.end.character}$>`
-			: `from line <$yellow:${range.start.line + 1}$>, column <$yellow:${range.start.character}$> to line <$yellow:${range.end.line + 1}$>, column <$yellow:${range.end.character}$>`;
-
-	const formattedMessage = [
-		`<$blue:{line}$><$red:Here where error occurred${sourceLabel}:$>{N}${lineContent}{N}${pointerPadding}<$yellow:^$>{N}{N}`,
-		`<$red:${typeName} Error:$> `,
-		...(Array.isArray(message) ? message : [message]),
-		`{N}at line <$yellow:${range.start.line + 1}$>, ${rangeInfo}{N}`,
-		"<$blue:{line}$>"
-	];
-
-	return formattedMessage;
-}
-
-// ========================================================================== //
-//  Error Classes                                                            //
-// ========================================================================== //
-
-/** Base class for all SomMark errors that automatically formats messages for the terminal. */
-class CustomError extends Error {
-	/**
-	 * Creates a new error.
-	 * 
-	 * @param {string|string[]} message - The text describing what went wrong.
-	 * @param {string} name - The name of the error type.
-	 */
-	constructor(message, name) {
-		super(message);
-		this.name = name;
-		this.message = formatMessage(`<$cyan:[${this.name}]$>:`) + "\n" + formatMessage(message);
-		if (Error.captureStackTrace) {
-			Error.captureStackTrace(this, this.constructor);
-		}
-	}
-}
-
-class ParserError extends CustomError {
-	constructor(message) { super(message, "Parser Error"); }
-}
-
-class LexerError extends CustomError {
-	constructor(message) { super(message, "Lexer Error"); }
-}
-
-class TranspilerError extends CustomError {
-	constructor(message) { super(message, "Transpiler Error"); }
-}
-
-class CLIError extends CustomError {
-	constructor(message) { super(message, "CLI Error"); }
-}
-
-class RuntimeError extends CustomError {
-	constructor(message) { super(message, "Runtime Error"); }
-}
-
-class SommarkError extends CustomError {
-	constructor(message) { super(message, "SomMark Error"); }
-}
-
-// ========================================================================== //
-//  Error Dispatcher (Helper)                                               //
-// ========================================================================== //
-
-/**
- * A helper that creates an error "dispatcher" for a specific category.
- * 
- * @param {string} type - The category of error (e.g., 'lexer', 'parser').
- * @returns {Function} - A function that throws the formatted error.
- */
-function getError(type) {
-	const validate_msg = msg => (Array.isArray(msg) && msg.length > 0) || typeof msg === "string";
-	const typeNames = {
-		parser: "Parser",
-		transpiler: "Transpiler",
-		lexer: "Lexer",
-		cli: "CLI",
-		runtime: "Runtime",
-		sommark: "SomMark"
-	};
-	const ErrorClasses = {
-		parser: ParserError,
-		transpiler: TranspilerError,
-		lexer: LexerError,
-		cli: CLIError,
-		runtime: RuntimeError,
-		sommark: SommarkError
-	};
-
-	return (errorMessage, context = null) => {
-		if (validate_msg(errorMessage)) {
-			let finalMessage = errorMessage;
-			if (context && context.src && context.range) {
-				finalMessage = formatErrorWithContext(
-					context.src,
-					context.range,
-					context.filename,
-					errorMessage,
-					typeNames[type]
-				);
-			}
-			throw new ErrorClasses[type](finalMessage).message;
-		}
-	};
-}
-
-/** Helper to throw Lexer errors. */
-const lexerError = getError("lexer");
-
-/** Helper to throw Parser errors. */
-const parserError = getError("parser");
-
-/** Helper to throw Runtime or Module errors. */
-const runtimeError = getError("runtime");
-
-/** Helper to throw general internal SomMark errors. */
-const sommarkError = getError("sommark");
-
 /**
  * SomMark Lexer
  * 
@@ -384,12 +154,12 @@ function lexer(src, filename = "anonymous") {
 	let line = 0, character = 0;
 
 	// State Variables
-	let isInAtBlockBody = false;
 	let isInQuote = false;
-	let isInHeader = false; // Tracks if we are in a structural header context
-	let isInAtBlockHeader = false; // Specific for At-Block headers (@_ ... _@)
-	let isInInlineHead = false; // Specific for (key:val) after ->
-	let parenDepth = 0; // To track balanced parentheses in inlines
+	let isInHeader = false;      // Tracks if we are in a structural header context
+	let isInPVPrefix = false;    // Tracks if we are scanning inside a p{} or v{} prefix
+	let pendingSmarkRaw = false; // Set when KEY "smark-raw" is seen — waiting for value
+	let hasSmarkRaw = false;     // Set when smark-raw: true is confirmed in header
+	let isRawContent = false;    // Set when inside a smark-raw block — content collected as-is, not parsed
 
 	/**
 	 * Adds a token to the stream and updates the scanner's position tracking.
@@ -453,35 +223,63 @@ function lexer(src, filename = "anonymous") {
 	}
 
 	while (i < src.length) {
-		// --- PHASE 1: AT-BLOCK BODY MODE ---
-		// In this mode, we consume everything as raw text until we hit the @_ marker.
-		if (isInAtBlockBody) {
-			if (src[i] === "@" && src[i + 1] === "_") {
-				isInAtBlockBody = false;
-			} else {
-				let body = "";
+		const char = src[i];
+		const next = src[i + 1];
+
+		// --- RAW CONTENT MODE ---
+		// Collect everything as-is until [end] or [end:name]. \[ escapes a literal [.
+		if (isRawContent) {
+			let raw = "";
+			while (i < src.length) {
+				if (src[i] === "\\" && src[i + 1] === "[") {
+					raw += "[";
+					i += 2;
+					continue;
+				}
+				if (src[i] === "[") {
+					if (src.startsWith(`[${end_keyword}]`, i) || src.startsWith(`[${end_keyword}:`, i)) break;
+				}
+				raw += src[i];
+				i++;
+			}
+			if (raw) addToken(TOKEN_TYPES.TEXT, raw);
+			isRawContent = false;
+			continue;
+		}
+
+		// --- PHASE 1.5: PV PREFIX CONTENT MODE ---
+		// Handles structured content inside p{} and v{} prefixes.
+		if (isInPVPrefix && !isInQuote) {
+			if (char === '"' || char === "'") {
+				addToken(TOKEN_TYPES.QUOTE, char);
+				i++;
+				isInQuote = true;
+				continue;
+			}
+			if (char === '|') {
+				addToken(TOKEN_TYPES.PIPELINE, "|");
+				i++;
+				continue;
+			}
+			if (char === '}') {
+				addToken(TOKEN_TYPES.PREFIX_CLOSE, "}");
+				isInPVPrefix = false;
+				i++;
+				continue;
+			}
+			if (char !== ' ' && char !== '\t' && char !== '\n' && char !== '\r') {
+				let word = '';
 				while (i < src.length) {
-					// Handle escapes in At-Block Body
-					if (src[i] === "\\" && i + 1 < src.length) {
-						body += src[i + 1];
-						i += 2;
-						continue;
-					}
-					// Stop at end marker
-					if (src[i] === "@" && src[i + 1] === "_") {
-						break;
-					}
-					body += src[i];
+					const c = src[i];
+					if (c === '}' || c === '|' || c === '"' || c === "'" || c === ' ' || c === '\t' || c === '\n' || c === '\r') break;
+					word += c;
 					i++;
 				}
-				if (body.length > 0) {
-					addToken(TOKEN_TYPES.TEXT, body);
-				}
+				if (word) addToken(TOKEN_TYPES.KEY, word);
 				continue;
 			}
+			// Whitespace: fall through to PHASE 3 whitespace handling
 		}
-		const char = src[i];
-		const next = src[i + 1];
 
 		// --- PHASE 2: QUOTE MODE ---
 		// Handles balanced strings and allows prefix layers (js{}, p{}) inside them.
@@ -499,50 +297,57 @@ function lexer(src, filename = "anonymous") {
 				}
 
 				// Support Prefix Layers inside quotes!
-				if ((src[i] === "j" && src[i + 1] === "s" && src[i + 2] === "{") || (src[i] === "p" && src[i + 1] === "{") || (src[i] === "v" && src[i + 1] === "{")) {
-					const isJS = (src[i] === "j");
+				if ((src[i] === "p" && src[i + 1] === "{") || (src[i] === "v" && src[i + 1] === "{")) {
 					const isV = (src[i] === "v");
 					if (quoteValue.length > 0) {
 						addToken(TOKEN_TYPES.VALUE, quoteValue);
 						quoteValue = "";
 					}
 
-					let braceDepth = 1;
-					let prefixValue = isJS ? "js{" : (isV ? "v{" : "p{");
-					i += isJS ? 3 : 2;
-
-					let internalString = null;
-					while (i < src.length && braceDepth > 0) {
-						const c = src[i];
-						const n = src[i + 1];
-						if (internalString) {
-							if (c === "\\" && (n === internalString || n === "\\")) {
-								prefixValue += c + n;
-								i += 2;
-								continue;
+					{
+						// p{} or v{}: keyword + PREFIX_OPEN + unquoted key + optional PIPELINE + fallback + PREFIX_CLOSE
+						addToken(isV ? TOKEN_TYPES.PREFIX_V : TOKEN_TYPES.PREFIX_P, isV ? "v" : "p");
+						addToken(TOKEN_TYPES.PREFIX_OPEN, "{");
+						i += 2;
+						// Scan unquoted key (cannot use same quote char as outer string)
+						let key = "";
+						while (i < src.length && src[i] !== "|" && src[i] !== "}" && src[i] !== quoteChar) {
+							key += src[i];
+							i++;
+						}
+						if (key.trim()) addToken(TOKEN_TYPES.KEY, key.trim());
+						// Optional PIPELINE + fallback
+						if (i < src.length && src[i] === "|") {
+							addToken(TOKEN_TYPES.PIPELINE, "|");
+							i++;
+							let fallback = "";
+							while (i < src.length && src[i] !== "}" && src[i] !== quoteChar) {
+								fallback += src[i];
+								i++;
 							}
-							if (c === internalString) internalString = null;
-						} else {
-							if (c === "\"" || c === "'") internalString = c;
-							else if (c === "{") braceDepth++;
-							else if (c === "}") braceDepth--;
+							if (fallback.trim()) addToken(TOKEN_TYPES.VALUE, fallback.trim());
+						}
+						// PREFIX_CLOSE
+						if (i < src.length && src[i] === "}") {
+							addToken(TOKEN_TYPES.PREFIX_CLOSE, "}");
+							i++;
 						}
-						prefixValue += c;
-						i++;
 					}
-					let tokenType = isJS ? TOKEN_TYPES.PREFIX_JS : (isV ? TOKEN_TYPES.PREFIX_V : TOKEN_TYPES.PREFIX_P);
-					addToken(tokenType, prefixValue);
 					continue;
 				}
 
 				if (src[i] === quoteChar) {
 					// Guess role based on next structural character
 					let nextStructural = peekStructural(i + 1);
-					let tokenType = (isInHeader || isInInlineHead) && (nextStructural === ":" || nextStructural === "=")
+					let tokenType = isInHeader && (nextStructural === ":" || nextStructural === "=")
 						? TOKEN_TYPES.KEY
 						: TOKEN_TYPES.VALUE;
 
 					if (quoteValue.length > 0) addToken(tokenType, quoteValue);
+					if (pendingSmarkRaw && tokenType === TOKEN_TYPES.VALUE && quoteValue === "true") {
+						hasSmarkRaw = true;
+						pendingSmarkRaw = false;
+					}
 					addToken(TOKEN_TYPES.QUOTE, quoteChar);
 					isInQuote = false;
 					i++;
@@ -610,84 +415,37 @@ function lexer(src, filename = "anonymous") {
 			continue;
 		}
 
-		// PREFIX LAYERS (js{...} or p{...} or v{...})
-		if ((char === "j" && next === "s" && src[i + 2] === "{") || (char === "p" && next === "{") || (char === "v" && next === "{")) {
-			const isJS = (char === "j");
+		// PREFIX LAYERS (p{...} or v{...})
+		if ((char === "p" && next === "{") || (char === "v" && next === "{")) {
 			const isP = (char === "p");
 			const isV = (char === "v");
 
 			// Context Check
-			const isBlockHeader = isInHeader && !isInAtBlockHeader;
-			const isNormalText = !isInHeader && !isInInlineHead && !isInAtBlockBody && parenDepth === 0;
+			const isBlockHeader = isInHeader;
+			const isNormalText = !isInHeader;
 
 			let allowed = false;
-			if (isJS && isBlockHeader) allowed = true;
 			if (isP && (isBlockHeader || isNormalText)) allowed = true;
 			if (isV && (isBlockHeader || isNormalText)) allowed = true;
 
 			if (allowed) {
-				let braceDepth = 1;
-				let prefixValue = isJS ? "js{" : (isV ? "v{" : "p{");
-				i += isJS ? 3 : 2;
-
-				let inString = null; // Track if we are inside " " or ' '
-				while (i < src.length && braceDepth > 0) {
-					const c = src[i];
-					const n = src[i + 1];
-
-					if (inString) {
-						if (c === "\\" && (n === inString || n === "\\")) {
-							prefixValue += c + n;
-							i += 2;
-							continue;
-						}
-						if (c === inString) inString = null;
-					} else {
-						if (c === "\"" || c === "'") inString = c;
-						else if (c === "{") braceDepth++;
-						else if (c === "}") braceDepth--;
-					}
-					prefixValue += c;
-					i++;
-				}
-				let tokenType = isJS ? TOKEN_TYPES.PREFIX_JS : (isV ? TOKEN_TYPES.PREFIX_V : TOKEN_TYPES.PREFIX_P);
-				addToken(tokenType, prefixValue);
+				// p{} or v{}: emit keyword + PREFIX_OPEN, enter structured content mode
+				addToken(isV ? TOKEN_TYPES.PREFIX_V : TOKEN_TYPES.PREFIX_P, isV ? "v" : "p");
+				addToken(TOKEN_TYPES.PREFIX_OPEN, "{");
+				i += 2; // skip "p{" or "v{"
+				isInPVPrefix = true;
 				continue;
 			}
 			// If not allowed, it will fall through to normal word scanning
 		}
 
-		// MULTI-CHAR MARKERS
-		if (char === "@" && next === "_") {
-			addToken(TOKEN_TYPES.OPEN_AT, "@_");
-			i += 2;
-			isInHeader = true; // At-Blocks start with a header part
-			isInAtBlockHeader = true;
-			continue;
-		}
-		if (char === "-" && next === ">") {
-			if (isInAtBlockBody || (parenDepth > 0 && !isInInlineHead)) {
-				addToken(TOKEN_TYPES.TEXT, "-");
-				i++; // Swallowed one char
-			} else {
-				addToken(TOKEN_TYPES.THIN_ARROW, "->");
-				i += 2;
-				isInInlineHead = true; // The following ( ) will be structural
-			}
-			continue;
-		}
-
 		// STATIC KEYWORD
 		if (char === "s" && src.slice(i, i + 6) === "static") {
 			const afterStatic = src.slice(i + 6);
 			const hasSpace = afterStatic.startsWith(" ");
 			const hasLogic = hasSpace ? afterStatic.slice(1).startsWith("${") : afterStatic.startsWith("${");
 
-			const isMainIdentifier = (
-				last_non_junk_type === TOKEN_TYPES.OPEN_BRACKET ||
-				last_non_junk_type === TOKEN_TYPES.OPEN_AT ||
-				(last_non_junk_type === TOKEN_TYPES.OPEN_PAREN && isInInlineHead)
-			);
+			const isMainIdentifier = last_non_junk_type === TOKEN_TYPES.OPEN_BRACKET;
 
 			if ((hasLogic || isInHeader) && !isMainIdentifier) {
 				addToken(TOKEN_TYPES.STATIC_KEYWORD, hasSpace ? "static " : "static");
@@ -702,11 +460,7 @@ function lexer(src, filename = "anonymous") {
 			const hasSpace = afterRuntime.startsWith(" ");
 			const hasLogic = hasSpace ? afterRuntime.slice(1).startsWith("${") : afterRuntime.startsWith("${");
 
-			const isMainIdentifier = (
-				last_non_junk_type === TOKEN_TYPES.OPEN_BRACKET ||
-				last_non_junk_type === TOKEN_TYPES.OPEN_AT ||
-				(last_non_junk_type === TOKEN_TYPES.OPEN_PAREN && isInInlineHead)
-			);
+			const isMainIdentifier = last_non_junk_type === TOKEN_TYPES.OPEN_BRACKET;
 
 			if ((hasLogic || isInHeader) && !isMainIdentifier) {
 				addToken(TOKEN_TYPES.RUNTIME_KEYWORD, hasSpace ? "runtime " : "runtime");
@@ -715,213 +469,126 @@ function lexer(src, filename = "anonymous") {
 			}
 		}
 
-		// LOGIC BLOCKS (${ ... }$)
-		if (char === "$" && next === "{" && (last_non_junk_type === TOKEN_TYPES.STATIC_KEYWORD || last_non_junk_type === TOKEN_TYPES.RUNTIME_KEYWORD)) {
-			const startLine = line;
-			const startCharacter = character;
-			i += 2;
-			let logicCode = "";
-			let braceDepth = 1;
-			let internalString = null;
-			let foundClosing = false;
+		// LOGIC BLOCKS (${ ... }$) — explicit: static/runtime ${ }$  shorthand: ${ }$ = static ${ }$
+		if (char === "$" && next === "{") {
+			{
+				const hasExplicitKeyword = last_non_junk_type === TOKEN_TYPES.STATIC_KEYWORD || last_non_junk_type === TOKEN_TYPES.RUNTIME_KEYWORD;
+				if (!hasExplicitKeyword) addToken(TOKEN_TYPES.STATIC_KEYWORD, "static");
+				addToken(TOKEN_TYPES.LOGIC_OPEN, "${");
+				i += 2;
 
-			while (i < src.length) {
-				const c = src[i];
-				const n = src[i + 1];
+				let logicCode = "";
+				let depth = 0;
+				let internalString = null;
 
-				// Stop condition: }$ (only if not inside a JS string and at top-level brace depth)
-				if (c === "}" && n === "$" && !internalString && braceDepth === 1) {
-					i += 2;
-					braceDepth = 0;
-					foundClosing = true;
-					break;
-				}
+				while (i < src.length) {
+					const c = src[i];
+					const n = src[i + 1];
 
-				if (internalString) {
-					if (c === "\\" && (n === internalString || n === "\\")) {
-						logicCode += c + n;
-						i += 2;
-						continue;
+					// Close condition: }$ at depth 0, not followed by { (}${ is a template expression boundary)
+					if (c === "}" && n === "$" && !internalString && depth === 0 && src[i + 2] !== "{") {
+						break;
 					}
-					if (c === internalString) internalString = null;
-				} else {
-					if (c === "/" && n === "/") {
-						logicCode += c + n;
-						i += 2;
-						while (i < src.length && src[i] !== "\n" && src[i] !== "\r") {
-							logicCode += src[i];
-							i++;
+
+					if (internalString) {
+						if (c === "\\" && (n === internalString || n === "\\")) {
+							logicCode += c + n;
+							i += 2;
+							continue;
 						}
-						continue;
-					}
-					if (c === "/" && n === "*") {
-						logicCode += c + n;
-						i += 2;
-						while (i < src.length) {
-							if (src[i] === "*" && src[i + 1] === "/") {
-								logicCode += "*/";
-								i += 2;
-								break;
+						if (c === internalString) internalString = null;
+					} else {
+						if (c === "/" && n === "/") {
+							logicCode += c + n;
+							i += 2;
+							while (i < src.length && src[i] !== "\n" && src[i] !== "\r") {
+								logicCode += src[i];
+								i++;
 							}
-							logicCode += src[i];
-							i++;
+							continue;
+						}
+						if (c === "/" && n === "*") {
+							logicCode += c + n;
+							i += 2;
+							while (i < src.length) {
+								if (src[i] === "*" && src[i + 1] === "/") {
+									logicCode += "*/";
+									i += 2;
+									break;
+								}
+								logicCode += src[i];
+								i++;
+							}
+							continue;
 						}
-						continue;
+
+						if (c === "\"" || c === "'" || c === "`") internalString = c;
+						else if (c === "{") depth++;
+						else if (c === "}") depth--;
 					}
 
-					if (c === "\"" || c === "'" || c === "`") internalString = c;
-					else if (c === "{") braceDepth++;
-					else if (c === "}") braceDepth--;
+					logicCode += c;
+					i++;
 				}
 
-				logicCode += c;
-				i++;
-			}
+				addToken(TOKEN_TYPES.LOGIC, logicCode);
 
-			if (!foundClosing) {
-				lexerError("Unclosed logic block. Expected '}$' to close the block starting with '${'.", {
-					src,
-					filename,
-					range: {
-						start: { line: startLine, character: startCharacter },
-						end: { line: startLine, character: startCharacter + 2 }
-					}
-				});
-			}
+				if (i < src.length && src[i] === "}" && src[i + 1] === "$") {
+					addToken(TOKEN_TYPES.LOGIC_CLOSE, "}$");
+					i += 2;
+				}
 
-			addToken(TOKEN_TYPES.LOGIC, logicCode);
-			continue;
+				continue;
+			}
 		}
 
 		// SINGLE-CHAR MARKERS
 		if (char === "[") {
-			if (isInAtBlockBody || (parenDepth > 0 && !isInInlineHead)) {
-				addToken(TOKEN_TYPES.TEXT, "[");
-			} else {
-				addToken(TOKEN_TYPES.OPEN_BRACKET, "[");
-				isInHeader = true;
-			}
+			addToken(TOKEN_TYPES.OPEN_BRACKET, "[");
+			isInHeader = true;
+			pendingSmarkRaw = false;
+			hasSmarkRaw = false;
 			i++;
 			continue;
 		}
-		if (char === "_" && next === "@") {
-			if (isInAtBlockBody || (parenDepth > 0 && !isInInlineHead)) {
-				addToken(TOKEN_TYPES.TEXT, "_@");
-			} else {
-				const lastRealType = last_non_junk_type;
-				addToken(TOKEN_TYPES.CLOSE_AT, "_@");
-				// Removed delimiter stack check
-				if (lastRealType === TOKEN_TYPES.END_KEYWORD) {
-					isInAtBlockBody = false;
-					isInHeader = false;
-					isInAtBlockHeader = false;
-				}
-			}
-			i += 2;
-			continue;
-		}
 		if (char === "]") {
-			if (isInAtBlockBody || (parenDepth > 0 && !isInInlineHead)) {
-				addToken(TOKEN_TYPES.TEXT, "]");
-			} else {
-				addToken(TOKEN_TYPES.CLOSE_BRACKET, "]");
-				isInHeader = false;
-			}
-			i++;
-			continue;
-		}
-		if (char === "(") {
-			if (isInAtBlockBody || (parenDepth > 0 && !isInInlineHead)) {
-				addToken(TOKEN_TYPES.TEXT, "(");
-				parenDepth++;
-			} else {
-				addToken(TOKEN_TYPES.OPEN_PAREN, "(");
-				parenDepth++;
-			}
-			i++;
-			continue;
-		}
-		if (char === ")") {
-			if (isInAtBlockBody || (parenDepth > 1 && !isInInlineHead)) {
-				addToken(TOKEN_TYPES.TEXT, ")");
-				parenDepth--;
-			} else if (parenDepth > 0) {
-				// This ends the content part if depth drops to 0
-				parenDepth--;
-				if (parenDepth === 0) {
-					addToken(TOKEN_TYPES.CLOSE_PAREN, ")");
-					if (isInInlineHead) {
-						isInInlineHead = false;
-						isInHeader = false;
-					}
-				} else {
-					addToken(TOKEN_TYPES.TEXT, ")");
-				}
-			} else {
-				addToken(TOKEN_TYPES.TEXT, ")");
+			addToken(TOKEN_TYPES.CLOSE_BRACKET, "]");
+			isInHeader = false;
+			if (hasSmarkRaw) {
+				isRawContent = true;
+				hasSmarkRaw = false;
 			}
+			pendingSmarkRaw = false;
 			i++;
 			continue;
 		}
 		if (char === ":") {
-			if (isInAtBlockBody || (parenDepth > 0 && !isInInlineHead)) {
-				addToken(TOKEN_TYPES.TEXT, ":");
+			const colonAllowed = [TOKEN_TYPES.IDENTIFIER, TOKEN_TYPES.KEY, TOKEN_TYPES.VALUE, TOKEN_TYPES.ESCAPE, TOKEN_TYPES.QUOTE, TOKEN_TYPES.PREFIX_V, TOKEN_TYPES.PREFIX_P, TOKEN_TYPES.PREFIX_CLOSE, TOKEN_TYPES.IMPORT, TOKEN_TYPES.USE_MODULE, TOKEN_TYPES.END_KEYWORD, TOKEN_TYPES.TEXT, TOKEN_TYPES.LOGIC, TOKEN_TYPES.LOGIC_CLOSE, TOKEN_TYPES.STATIC_KEYWORD, TOKEN_TYPES.RUNTIME_KEYWORD, TOKEN_TYPES.FOR_EACH];
+			if (colonAllowed.includes(last_non_junk_type)) {
+				addToken(TOKEN_TYPES.COLON, ":");
+				isInHeader = true;
 			} else {
-				const allowed = [TOKEN_TYPES.IDENTIFIER, TOKEN_TYPES.KEY, TOKEN_TYPES.CLOSE_AT, TOKEN_TYPES.VALUE, TOKEN_TYPES.ESCAPE, TOKEN_TYPES.QUOTE, TOKEN_TYPES.PREFIX_JS, TOKEN_TYPES.PREFIX_V, TOKEN_TYPES.PREFIX_P, TOKEN_TYPES.IMPORT, TOKEN_TYPES.USE_MODULE, TOKEN_TYPES.END_KEYWORD, TOKEN_TYPES.TEXT, TOKEN_TYPES.LOGIC, TOKEN_TYPES.STATIC_KEYWORD, TOKEN_TYPES.RUNTIME_KEYWORD, TOKEN_TYPES.FOR_EACH];
-				if (allowed.includes(last_non_junk_type)) {
-					addToken(TOKEN_TYPES.COLON, ":");
-					isInHeader = true;
-				} else {
-					addToken(TOKEN_TYPES.TEXT, ":");
-				}
+				addToken(TOKEN_TYPES.TEXT, ":");
 			}
 			i++;
 			continue;
 		}
 		if (char === "=") {
-			if (isInAtBlockBody || (parenDepth > 0 && !isInInlineHead)) {
-				addToken(TOKEN_TYPES.TEXT, "=");
+			const eqAllowed = [TOKEN_TYPES.IDENTIFIER, TOKEN_TYPES.KEY, TOKEN_TYPES.ESCAPE, TOKEN_TYPES.QUOTE, TOKEN_TYPES.PREFIX_V, TOKEN_TYPES.PREFIX_P, TOKEN_TYPES.PREFIX_CLOSE, TOKEN_TYPES.IMPORT, TOKEN_TYPES.USE_MODULE, TOKEN_TYPES.END_KEYWORD, TOKEN_TYPES.TEXT, TOKEN_TYPES.LOGIC, TOKEN_TYPES.LOGIC_CLOSE, TOKEN_TYPES.STATIC_KEYWORD, TOKEN_TYPES.RUNTIME_KEYWORD, TOKEN_TYPES.FOR_EACH];
+			if (eqAllowed.includes(last_non_junk_type)) {
+				addToken(TOKEN_TYPES.EQUAL, "=");
 			} else {
-				const allowed = [TOKEN_TYPES.IDENTIFIER, TOKEN_TYPES.KEY, TOKEN_TYPES.ESCAPE, TOKEN_TYPES.QUOTE, TOKEN_TYPES.PREFIX_JS, TOKEN_TYPES.PREFIX_V, TOKEN_TYPES.PREFIX_P, TOKEN_TYPES.IMPORT, TOKEN_TYPES.USE_MODULE, TOKEN_TYPES.END_KEYWORD, TOKEN_TYPES.TEXT, TOKEN_TYPES.LOGIC, TOKEN_TYPES.STATIC_KEYWORD, TOKEN_TYPES.RUNTIME_KEYWORD, TOKEN_TYPES.FOR_EACH];
-				if (allowed.includes(last_non_junk_type)) {
-					addToken(TOKEN_TYPES.EQUAL, "=");
-				} else {
-					addToken(TOKEN_TYPES.TEXT, "=");
-				}
+				addToken(TOKEN_TYPES.TEXT, "=");
 			}
 			i++;
 			continue;
 		}
 		if (char === ",") {
-			if (isInAtBlockBody || (parenDepth > 0 && !isInInlineHead)) {
-				addToken(TOKEN_TYPES.TEXT, ",");
+			const commaAllowed = [TOKEN_TYPES.VALUE, TOKEN_TYPES.IDENTIFIER, TOKEN_TYPES.QUOTE, TOKEN_TYPES.ESCAPE, TOKEN_TYPES.PREFIX_V, TOKEN_TYPES.PREFIX_P, TOKEN_TYPES.PREFIX_CLOSE, TOKEN_TYPES.IMPORT, TOKEN_TYPES.USE_MODULE, TOKEN_TYPES.END_KEYWORD, TOKEN_TYPES.TEXT, TOKEN_TYPES.LOGIC, TOKEN_TYPES.LOGIC_CLOSE, TOKEN_TYPES.STATIC_KEYWORD, TOKEN_TYPES.RUNTIME_KEYWORD, TOKEN_TYPES.FOR_EACH];
+			if (commaAllowed.includes(last_non_junk_type)) {
+				addToken(TOKEN_TYPES.COMMA, ",");
 			} else {
-				const allowed = [TOKEN_TYPES.VALUE, TOKEN_TYPES.IDENTIFIER, TOKEN_TYPES.QUOTE, TOKEN_TYPES.ESCAPE, TOKEN_TYPES.PREFIX_JS, TOKEN_TYPES.PREFIX_V, TOKEN_TYPES.PREFIX_P, TOKEN_TYPES.IMPORT, TOKEN_TYPES.USE_MODULE, TOKEN_TYPES.END_KEYWORD, TOKEN_TYPES.TEXT, TOKEN_TYPES.LOGIC, TOKEN_TYPES.STATIC_KEYWORD, TOKEN_TYPES.RUNTIME_KEYWORD, TOKEN_TYPES.FOR_EACH];
-				if (allowed.includes(last_non_junk_type)) {
-					addToken(TOKEN_TYPES.COMMA, ",");
-				} else {
-					addToken(TOKEN_TYPES.TEXT, ",");
-				}
-			}
-			i++;
-			continue;
-		}
-		if (char === ";") {
-			if (isInAtBlockBody || (parenDepth > 0 && !isInInlineHead)) {
-				addToken(TOKEN_TYPES.TEXT, ";");
-			} else {
-				const allowed = [TOKEN_TYPES.IDENTIFIER, TOKEN_TYPES.VALUE, TOKEN_TYPES.CLOSE_AT, TOKEN_TYPES.CLOSE_PAREN, TOKEN_TYPES.ESCAPE, TOKEN_TYPES.QUOTE, TOKEN_TYPES.PREFIX_JS, TOKEN_TYPES.PREFIX_V, TOKEN_TYPES.PREFIX_P, TOKEN_TYPES.IMPORT, TOKEN_TYPES.USE_MODULE, TOKEN_TYPES.END_KEYWORD, TOKEN_TYPES.TEXT, TOKEN_TYPES.LOGIC, TOKEN_TYPES.STATIC_KEYWORD, TOKEN_TYPES.RUNTIME_KEYWORD, TOKEN_TYPES.FOR_EACH];
-				if (allowed.includes(last_non_junk_type)) {
-					addToken(TOKEN_TYPES.SEMICOLON, ";");
-					// ONLY trigger body mode if we were actually in an At-Block header
-					if (isInAtBlockHeader) {
-						isInHeader = false;
-						isInAtBlockHeader = false;
-						isInAtBlockBody = true;
-					}
-				} else {
-					addToken(TOKEN_TYPES.TEXT, ";");
-				}
+				addToken(TOKEN_TYPES.TEXT, ",");
 			}
 			i++;
 			continue;
@@ -934,7 +601,7 @@ function lexer(src, filename = "anonymous") {
 			}
 		}
 		if (char === "\"" || char === "'") {
-			const valTriggers = [TOKEN_TYPES.COLON, TOKEN_TYPES.EQUAL, TOKEN_TYPES.COMMA, TOKEN_TYPES.ESCAPE, TOKEN_TYPES.OPEN_BRACKET, TOKEN_TYPES.OPEN_AT];
+			const valTriggers = [TOKEN_TYPES.COLON, TOKEN_TYPES.EQUAL, TOKEN_TYPES.COMMA, TOKEN_TYPES.ESCAPE, TOKEN_TYPES.OPEN_BRACKET];
 			const wasValueTrigger = valTriggers.includes(last_non_junk_type);
 			addToken(TOKEN_TYPES.QUOTE, char);
 			i++;
@@ -950,28 +617,22 @@ function lexer(src, filename = "anonymous") {
 		// This is the "Fallback" mode where we scan for identifiers, keys, or values.
 		// It uses lookahead and context variables to guess the role of a word.
 		let word = "";
-		// Only Blocks ([ ]) allow ':' in their main identifier.
-		// At-Blocks (@_) and Inlines (->( )) do NOT allow ':' in the ID.
 		const isStartOfBlockId = (last_non_junk_type === TOKEN_TYPES.OPEN_BRACKET);
+		const isInNormalText = !isInHeader;
 
-		let stopChars = "[](){}:=;,@>\"'#\\ \t\n\r!";
-		if (isStartOfBlockId || (parenDepth > 0 && !isInInlineHead)) {
+		let stopChars = "[]{}:=,\"'#\\ \t\n\r!";
+		if (isStartOfBlockId) {
 			stopChars = stopChars.replace(":", "");
 		}
-		const isInNormalText = !isInHeader && !isInInlineHead && !isInAtBlockBody;
 		if (isInNormalText) {
-			stopChars = "[]@()>_()\\#\n\r"; // In normal text, stop at markers, comments and newlines
+			stopChars = "[]\\#\n\r"; // In normal text, stop only at block markers, escapes, comments and newlines
 		}
 
 		while (i < src.length && !stopChars.includes(src[i])) {
 			// Stop ONLY if $ is followed by { (Logic block start)
 			if (src[i] === "$" && src[i + 1] === "{") break;
 
-			// Lookahead for At-Block markers (_@ or @_)
-			if (src[i] === "_" && src[i + 1] === "@") break;
-			if (src[i] === "@" && src[i + 1] === "_") break;
-
-			// Lookahead for 'static ${' or 'runtime ${' (only if we're not at the very start of the word scanning)
+			// Lookahead for 'static ${' or 'runtime ${' mid-word
 			if (word.length > 0) {
 				if (src[i] === "s" && src.slice(i, i + 7) === "static " && src[i + 7] === "$" && src[i + 8] === "{") break;
 				if (src[i] === "s" && src.slice(i, i + 6) === "static" && src[i + 6] === "$" && src[i + 7] === "{") break;
@@ -979,53 +640,47 @@ function lexer(src, filename = "anonymous") {
 				if (src[i] === "r" && src.slice(i, i + 7) === "runtime" && src[i + 7] === "$" && src[i + 8] === "{") break;
 			}
 
-			// Lookahead for -> marker in normal text
-			if (!isInHeader && src[i] === "-" && src[i + 1] === ">") break;
-
 			// Stop if we hit an ALLOWED prefix trigger
 			if ((src[i] === "p" && src[i + 1] === "{") || (src[i] === "v" && src[i + 1] === "{")) {
 				if (isInHeader || isInNormalText) break;
 			}
-			if (src[i] === "j" && src[i + 1] === "s" && src[i + 2] === "{") {
-				if (isInHeader) break;
-			}
 			word += src[i];
 			i++;
 		}
 
 		if (word.length > 0) {
 			// Guess role based on context
-			if (parenDepth > 0 && !isInInlineHead) {
-				// Inside Inline Content (raw text)
-				addToken(TOKEN_TYPES.TEXT, word);
-			} else if (isInHeader || isInInlineHead) {
+			if (isInHeader) {
 				// Inside a structural header context
-				const isMainIdentifier = (
-					last_non_junk_type === TOKEN_TYPES.OPEN_BRACKET ||
-					last_non_junk_type === TOKEN_TYPES.OPEN_AT ||
-					(last_non_junk_type === TOKEN_TYPES.OPEN_PAREN && isInInlineHead)
-				);
+				const isMainIdentifier = last_non_junk_type === TOKEN_TYPES.OPEN_BRACKET;
 
 				if (isMainIdentifier) {
-					if (word === end_keyword) {
+					if (word === end_keyword || word.startsWith(end_keyword + ":")) {
 						addToken(TOKEN_TYPES.END_KEYWORD, word);
 					}
 					else if (word === "import") addToken(TOKEN_TYPES.IMPORT, word);
 					else if (word === "$use-module") addToken(TOKEN_TYPES.USE_MODULE, word);
 					else if (word === "slot") addToken(TOKEN_TYPES.SLOT_KEYWORD, word);
 					else if (word === "for-each") addToken(TOKEN_TYPES.FOR_EACH, word);
-					else addToken(TOKEN_TYPES.IDENTIFIER, word);
+					else {
+						addToken(TOKEN_TYPES.IDENTIFIER, word);
+					}
 				} else {
 					// Use lookahead to distinguish KEY from VALUE
 					const p = peekStructural(i);
 					if (p === ":") {
 						addToken(TOKEN_TYPES.KEY, word);
+						if (word === "smark-raw") pendingSmarkRaw = true;
 					} else if (word === "static") {
 						addToken(TOKEN_TYPES.STATIC_KEYWORD, word);
 					} else if (word === "runtime") {
 						addToken(TOKEN_TYPES.RUNTIME_KEYWORD, word);
 					} else {
 						addToken(TOKEN_TYPES.VALUE, word);
+						if (pendingSmarkRaw) {
+							if (word === "true") hasSmarkRaw = true;
+							pendingSmarkRaw = false;
+						}
 					}
 				}
 			} else {
@@ -1052,120 +707,198 @@ function lexer(src, filename = "anonymous") {
 }
 
 /**
- * A safe parser that turns Javascript-like strings into real objects and arrays.
- * It is built to handle data structures without running any dangerous code or
- * accessing other parts of your project.
+ * Wraps your text in a color if colors are turned on.
  * 
- * It supports: 
- * - Standard JSON: {"key": "val"}
- * - Javascript-style: { key: 'val' }
- * - Basic data: true, false, null, numbers, and strings
+ * @param {string} color - The color to use (red, green, yellow, blue, magenta, or cyan).
+ * @param {string} text - The text you want to color.
+ * @returns {string} - The colored text, or plain text if colors are off.
+ * @throws {Error} - Fails if you forget to provide the text.
+ */
+function colorize(color, text) {
+        if (!text) throw new Error("argument 'text' is not defined.");
+        return text;
+}
+
+/**
+ * SomMark Errors
+ * Handles formatting and throwing errors with beautiful CLI coloring and pointers.
  */
-function safeDataParse(str) {
-    if (typeof str !== "string") return str;
-    const s = str.trim();
-    if (!s) return null;
 
-    let index = 0;
+// ========================================================================== //
+//  Message Formatting                                                       //
+// ========================================================================== //
 
-    function skipWhitespace() {
-        while (index < s.length && /\s/.test(s[index])) {
-            index++;
-        }
-    }
+/**
+ * Processes a message by applying colors and formatting.
+ * Supports:
+ * - {line} : Adds a horizontal line
+ * - {N} : Adds a new line
+ * - <$color: Text$> : Adds color (red, yellow, green, blue, magenta, cyan)
+ * 
+ * @param {string|string[]} text - The message or list of message parts to format.
+ * @returns {string} - The final formatted and colored string.
+ */
+function formatMessage(text) {
+	const horizontal_rule = "\n" + colorize("blue", "-".repeat(90)) + "\n";
+	const pattern = /<\$([^:]+):([\s\S]*?)\$>/g;
 
-    function parseValue() {
-        skipWhitespace();
-        const char = s[index];
+	if (Array.isArray(text)) {
+		text = text.join("");
+	}
 
-        if (char === '{') return parseObject();
-        if (char === '[') return parseArray();
-        if (char === '"' || char === "'") return parseString();
+	// Apply {line} before color tags so the rule is never nested inside a color wrapper.
+	text = text.replaceAll("{line}", horizontal_rule);
+	text = text.replace(pattern, (match, color, content) => {
+		return colorize(color, content.trim());
+	});
+	text = text.replaceAll("{N}", "\n");
 
-        // Primitives or Unquoted identifiers
-        return parsePrimitiveOrIdentifier();
-    }
+	text = text
+		.split("\n")
+		.filter(value => value !== "")
+		.join("\n")
+		.trim();
 
-    function parseString() {
-        const quote = s[index++];
-        let result = "";
-        while (index < s.length && s[index] !== quote) {
-            if (s[index] === '\\') index++; // Skip escape
-            result += s[index++];
-        }
-        index++; // Skip closing quote
-        return result;
-    }
+	return text;
+}
 
-    function parseObject() {
-        index++; // Skip {
-        const obj = {};
-        skipWhitespace();
-
-        while (index < s.length && s[index] !== '}') {
-            skipWhitespace();
-            // Key can be unquoted, quoted "key", or quoted 'key'
-            let key;
-            if (s[index] === '"' || s[index] === "'") {
-                key = parseString();
-            } else {
-                let keyMatch = s.slice(index).match(/^[a-zA-Z_$][a-zA-Z0-9_$]*/);
-                if (!keyMatch) break;
-                key = keyMatch[0];
-                index += key.length;
-            }
-
-            skipWhitespace();
-            if (s[index] !== ':') break;
-            index++; // Skip :
-
-            obj[key] = parseValue();
-
-            skipWhitespace();
-            if (s[index] === ',') index++; // Skip optional comma
-            skipWhitespace();
-        }
-        index++; // Skip }
-        return obj;
-    }
+/**
+ * Creates a detailed error message showing where the error happened in the code.
+ * It adds a line number, a snippet of the code, and a pointer (^) to the exact spot.
+ * 
+ * @param {string} src - The original code being parsed.
+ * @param {Object} range - The location of the error (line and character).
+ * @param {string|null} filename - The name of the file (optional).
+ * @param {string|string[]} message - The error message to show.
+ * @param {string} typeName - The type of error (e.g., "Lexer" or "Parser").
+ * @returns {string[]} - A list of message parts that make up the final error report.
+ */
+function formatErrorWithContext(src, range, filename, message, typeName) {
+	if (!src || !range || !range.start) return message;
 
-    function parseArray() {
-        index++; // Skip [
-        const arr = [];
-        skipWhitespace();
+	const lines = src.split("\n");
+	const lineIndex = range.start.line;
+	const lineContent = lines[lineIndex] || "";
+	const pointerPadding = " ".repeat(range.start.character);
+	const sourceLabel = filename ? ` [${filename}]` : "";
 
-        while (index < s.length && s[index] !== ']') {
-            arr.push(parseValue());
-            skipWhitespace();
-            if (s[index] === ',') index++; // Skip optional comma
-            skipWhitespace();
-        }
-        index++; // Skip ]
-        return arr;
-    }
+	const rangeInfo =
+		range.start.line === range.end.line
+			? `from column <$yellow:${range.start.character}$> to <$yellow:${range.end.character}$>`
+			: `from line <$yellow:${range.start.line + 1}$>, column <$yellow:${range.start.character}$> to line <$yellow:${range.end.line + 1}$>, column <$yellow:${range.end.character}$>`;
 
-    function parsePrimitiveOrIdentifier() {
-        const start = index;
-        while (index < s.length && /[a-zA-Z0-9_$+\-.]/.test(s[index])) {
-            index++;
-        }
-        const token = s.slice(start, index);
+	const formattedMessage = [
+		`{line}<$red:Here where error occurred${sourceLabel}:$>{N}${lineContent}{N}${pointerPadding}<$yellow:^$>{N}`,
+		`<$red:${typeName} Error:$> `,
+		...(Array.isArray(message) ? message : [message]),
+		`{N}at line <$yellow:${range.start.line + 1}$>, ${rangeInfo}{N}`,
+		`{line}`
+	];
 
-        if (token === "true") return true;
-        if (token === "false") return false;
-        if (token === "null") return null;
-        if (!isNaN(Number(token))) return Number(token);
+	return formattedMessage;
+}
 
-        return token; // Fallback to string if it looks like an identifier
-    }
+// ========================================================================== //
+//  Error Classes                                                            //
+// ========================================================================== //
 
-    try {
-        return parseValue();
-    } catch (e) {
-        return str; // Fallback to raw string if parsing fails
-    }
+/** Base class for all SomMark errors that automatically formats messages for the terminal. */
+class CustomError extends Error {
+	/**
+	 * Creates a new error.
+	 * 
+	 * @param {string|string[]} message - The text describing what went wrong.
+	 * @param {string} name - The name of the error type.
+	 */
+	constructor(message, name) {
+		super(message);
+		this.name = name;
+		this.message = formatMessage(`<$cyan:[${this.name}]$>:`) + "\n" + formatMessage(message);
+		if (Error.captureStackTrace) {
+			Error.captureStackTrace(this, this.constructor);
+		}
+	}
+}
+
+class ParserError extends CustomError {
+	constructor(message) { super(message, "Parser Error"); }
+}
+
+class LexerError extends CustomError {
+	constructor(message) { super(message, "Lexer Error"); }
+}
+
+class TranspilerError extends CustomError {
+	constructor(message) { super(message, "Transpiler Error"); }
+}
+
+class CLIError extends CustomError {
+	constructor(message) { super(message, "CLI Error"); }
 }
 
+class RuntimeError extends CustomError {
+	constructor(message) { super(message, "Runtime Error"); }
+}
+
+class SommarkError extends CustomError {
+	constructor(message) { super(message, "SomMark Error"); }
+}
+
+// ========================================================================== //
+//  Error Dispatcher (Helper)                                               //
+// ========================================================================== //
+
+/**
+ * A helper that creates an error "dispatcher" for a specific category.
+ * 
+ * @param {string} type - The category of error (e.g., 'lexer', 'parser').
+ * @returns {Function} - A function that throws the formatted error.
+ */
+function getError(type) {
+	const validate_msg = msg => (Array.isArray(msg) && msg.length > 0) || typeof msg === "string";
+	const typeNames = {
+		parser: "Parser",
+		transpiler: "Transpiler",
+		lexer: "Lexer",
+		cli: "CLI",
+		runtime: "Runtime",
+		sommark: "SomMark"
+	};
+	const ErrorClasses = {
+		parser: ParserError,
+		transpiler: TranspilerError,
+		lexer: LexerError,
+		cli: CLIError,
+		runtime: RuntimeError,
+		sommark: SommarkError
+	};
+
+	return (errorMessage, context = null) => {
+		if (validate_msg(errorMessage)) {
+			let finalMessage = errorMessage;
+			if (context && context.src && context.range) {
+				finalMessage = formatErrorWithContext(
+					context.src,
+					context.range,
+					context.filename,
+					errorMessage,
+					typeNames[type]
+				);
+			}
+			throw new ErrorClasses[type](finalMessage).message;
+		}
+	};
+}
+
+/** Helper to throw Parser errors. */
+const parserError = getError("parser");
+
+/** Helper to throw Runtime or Module errors. */
+const runtimeError = getError("runtime");
+
+/** Helper to throw general internal SomMark errors. */
+const sommarkError = getError("sommark");
+
 /**
  * Calculates the Levenshtein distance between two strings.
  * Used for "Did you mean?" suggestions and fuzzy matching in validation.
@@ -1287,7 +1020,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}.$>`]);
 	}
 }
 
@@ -1297,7 +1030,7 @@ function makeBlockNode() {
 		type: BLOCK,
 		structure: "Block",
 		id: "",
-		args: {},
+		props: {},
 		body: [],
 		depth: 0,
 		range: {
@@ -1332,41 +1065,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 {
@@ -1399,53 +1097,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;
-	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                                                                 //
@@ -1467,6 +1178,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) {
@@ -1477,7 +1270,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;
@@ -1492,73 +1285,56 @@ 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) {
+		return [val, i, true];
+	} 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 = "";
@@ -1571,9 +1347,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
@@ -1589,34 +1363,6 @@ function parseValue(tokens, i, placeholders = {}, variables = {}, allowLogic = t
 	return [val, i, false];
 }
 // ========================================================================== //
-//  Parse ','                                                                 //
-// ========================================================================== //
-function parseComma(tokens, i, beforeChar = "") {
-	i = skipJunk(tokens, i);
-	if (current_token(tokens, i) && current_token(tokens, i).type === TOKEN_TYPES.COMMA) {
-		i++;
-		i = skipJunk(tokens, i);
-		updateData(tokens, i);
-
-		if (
-			!current_token(tokens, i) ||
-			(current_token(tokens, i) &&
-				current_token(tokens, i).type !== TOKEN_TYPES.VALUE &&
-				current_token(tokens, i).type !== TOKEN_TYPES.ESCAPE &&
-				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", ","));
-		}
-	} else {
-		parserError(errorMessage(tokens, i, ",", beforeChar));
-	}
-	return i;
-}
-// ========================================================================== //
 //  Parse ':'                                                                 //
 // ========================================================================== //
 function parseColon(tokens, i, afterChar = "") {
@@ -1629,19 +1375,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.
@@ -1664,7 +1397,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;
@@ -1716,10 +1449,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)
 		) {
@@ -1766,9 +1498,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 = "";
@@ -1869,6 +1601,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)
@@ -1903,147 +1652,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.
@@ -2071,7 +1679,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;
 			}
@@ -2090,44 +1698,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;
 		}
@@ -2137,155 +1732,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                                                            //
 // ========================================================================== //
@@ -2341,72 +1787,36 @@ 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;
+		let nextI = skipJunk(tokens, i + 1);
 
-		if (isStatic || isRuntimeKeyword) {
-			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;
+		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);
+		// 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++;
+
+		// Consume LOGIC_CLOSE if present
+		if (current_token(tokens, nextI) && current_token(tokens, nextI).type === TOKEN_TYPES.LOGIC_CLOSE) {
+			nextI++;
+		}
 
-		return [node, i + 1];
+		return [node, nextI];
 	}
 	// ========================================================================== //
 	//  Text or Placeholder                                                       //
@@ -2421,12 +1831,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();
@@ -2474,7 +1878,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 "";
 		};