sommark 5.0.5 → 5.2.0

package/async-hooks.js

@@ -0,0 +1,19 @@
+export class AsyncLocalStorage {
+  #store = undefined;
+  run(store, fn) {
+    const prev = this.#store;
+    this.#store = store;
+    try { return fn(); }
+    finally { this.#store = prev; }
+  }
+  getStore() { return this.#store; }
+  exit(fn) { return fn(); }
+  enterWith(store) { this.#store = store; }
+  disable() {}
+}
+
+export class AsyncResource {
+  static bind(fn) { return fn; }
+  bind(fn) { return fn; }
+  runInAsyncScope(fn) { return fn(); }
+}

package/core/evaluator.js

@@ -1,18 +1,25 @@
-import { AsyncLocalStorage } from "node:async_hooks";
 import { getQuickJS } from "quickjs-emscripten";
 import path from "pathe";
 import * as acorn from "acorn";
 import SomMark, { registerHostCompile, registerHostSettings } from "./helpers/lib.js";
 import { formatMessage } from "./errors.js";
+import { patheBundleCode } from "./pathe-bundle.js";
+import lexer from "./lexer.js";
+import parser from "./parser.js";
 
-// Each transpile() call gets its own isolated EvaluatorState stack via async context.
-const evaluatorStorage = new AsyncLocalStorage();
+// Set by index.js (Node.js) or index.browser.js (shim) — never imported directly.
+let evaluatorStorage = null;
+
+export function setDefaultAsyncLocalStorage(cls) {
+    evaluatorStorage = cls ? new cls() : null;
+}
 
 /**
  * Runs fn inside an isolated evaluator context.
  * Concurrent transpile() calls each get their own stack — no cross-contamination.
  */
 export function withEvaluator(fn) {
+    if (!evaluatorStorage) return fn();
     return evaluatorStorage.run([], fn);
 }
 
@@ -141,7 +148,7 @@ const customFetchAdapter = async (input, init, security = {}) => {
     };
 };
 
-const customCompileAdapter = async (src, options, parentSecurity = {}) => {
+const customCompileAdapter = async (src, options, parentSecurity = {}, parentFs = null, parentBaseDir = null) => {
     const maxDepth = parentSecurity?.maxDepth ?? 5;
     if (globalCompilationDepth >= maxDepth) {
         throw new Error(`Recursion Guard: Maximum Smark compilation depth exceeded (limit is ${maxDepth}).`);
@@ -157,7 +164,9 @@ const customCompileAdapter = async (src, options, parentSecurity = {}) => {
             ...cleanOptions,
             src,
             format: cleanOptions.format || "html",
-            security: parentSecurity
+            security: parentSecurity,
+            fs: parentFs ?? undefined,
+            baseDir: cleanOptions.baseDir || parentBaseDir || undefined,
         };
         const sm = new compilerClass(compilerOptions);
         return await sm.transpile();
@@ -170,6 +179,7 @@ const customCompileAdapter = async (src, options, parentSecurity = {}) => {
 registerHostCompile(customCompileAdapter);
 
 let defaultFs = null;
+let defaultEnv = null;
 let quickJSInstance = null;
 async function getQuickJSModule() {
     if (!quickJSInstance) {
@@ -193,6 +203,16 @@ function objectToHandle(context, obj) {
     return result.unwrap();
 }
 
+function isPlainData(value, seen = new Set()) {
+    if (value === null || value === undefined) return true;
+    if (typeof value === "function") return false;
+    if (typeof value !== "object") return true;
+    if (seen.has(value)) return false;
+    seen.add(value);
+    if (Array.isArray(value)) return value.every(v => isPlainData(v, seen));
+    return Object.values(value).every(v => isPlainData(v, seen));
+}
+
 function expose(context, vars, pendingDeferreds) {
     for (const [key, value] of Object.entries(vars)) {
         let handle;
@@ -287,6 +307,7 @@ class EvaluatorState {
         } else {
             this.baseDir = "/";
         }
+        this.rootDir = settings?.instance?.cwd || this.baseDir;
         this.scopes = [{}];
         this.dynamicTagsStack = [new Map()];
         this.security = security;
@@ -313,15 +334,39 @@ class EvaluatorState {
         });
 
         this.expose({
+            __hostEnv: (key) => {
+                if (defaultEnv === null) {
+                    throw new Error(
+                        "[SomMark] SomMark.env() is not available in browser mode.\n" +
+                        "Environment variables are a server-side concept.\n" +
+                        "Read env values at build time and pass them as placeholders instead."
+                    );
+                }
+                const allowlist = this.security?.env;
+                if (!Array.isArray(allowlist) || !allowlist.includes(key)) return undefined;
+                return defaultEnv[key] ?? undefined;
+            },
             __hostSomMarkVersion: SomMark.version,
             __hostSomMarkSettings: () => {
-                const clean = { ...SomMark.settings };
-                delete clean.instance;
-                delete clean.fs;
-                return JSON.stringify(clean);
-            }, 
+                const s = SomMark.settings;
+                return JSON.stringify({
+                    format:        s.format        ?? null,
+                    dev:           s.dev           ?? false,
+                    removeComments:s.removeComments ?? false,
+                    allowRaw:      s.allowRaw      ?? true,
+                    dualOutput:    s.dualOutput     ?? false,
+                    webOutputs:    s.webOutputs     ?? false,
+                });
+            },
             __hostCompile: async (src, options) => {
-                return await customCompileAdapter(src, options, this.security);
+                return await customCompileAdapter(src, options, this.security, this.nodeFs, this.baseDir);
+            },
+            __hostLexer: (src, filename) => {
+                return JSON.stringify(lexer(src, filename || "anonymous"));
+            },
+            __hostParser: (src, filename) => {
+                const tokens = lexer(src, filename || "anonymous");
+                return JSON.stringify(parser(tokens, filename || "anonymous"));
             },
             __hostFetch: async (input, initStr) => {
                 const init = initStr ? JSON.parse(initStr) : undefined;
@@ -349,6 +394,59 @@ class EvaluatorState {
                 const payload = JSON.parse(payloadStr);
                 return await target.render.call(this.mapperFile, payload);
             },
+            __hostFileRead: async (filePath) => {
+                if (!this.nodeFs) {
+                    throw new Error(
+                        "[SomMark] fileHandler is not available in browser mode.\n" +
+                        "File access is a server-side concept."
+                    );
+                }
+                const abs = path.resolve(this.rootDir, filePath);
+                if (!abs.startsWith(this.rootDir)) {
+                    throw new Error(
+                        `[SomMark] fileHandler.read: path traversal outside project root is not allowed.\n` +
+                        `Attempted path: ${abs}`
+                    );
+                }
+                return this.nodeFs.readFile(abs, "utf-8");
+            },
+            __hostFileExists: async (filePath) => {
+                if (!this.nodeFs) return false;
+                const abs = path.resolve(this.rootDir, filePath);
+                if (!abs.startsWith(this.rootDir)) return false;
+                return this.nodeFs.exists(abs);
+            },
+            __hostFileGlob: async (pattern) => {
+                if (!this.nodeFs) throw new Error("[SomMark] fileHandler.glob is not available in browser mode.\nFile access is a server-side concept.");
+                if (!this.nodeFs.glob) throw new Error("[SomMark] fileHandler.glob requires Node.js 22 or later.");
+                const files = await this.nodeFs.glob(pattern, { cwd: this.rootDir });
+                return JSON.stringify(files);
+            },
+            __hostFileLastModified: async (filePath) => {
+                if (!this.nodeFs) throw new Error("[SomMark] fileHandler.lastModified is not available in browser mode.");
+                const abs = path.resolve(this.rootDir, filePath);
+                if (!abs.startsWith(this.rootDir)) throw new Error("[SomMark] fileHandler.lastModified: path traversal outside project root is not allowed.");
+                const stat = await this.nodeFs.stat(abs);
+                return stat.mtimeMs;
+            },
+            __hostFileStat: async (filePath) => {
+                if (!this.nodeFs) throw new Error("[SomMark] fileHandler.stat is not available in browser mode.\nFile access is a server-side concept.");
+                const abs = path.resolve(this.rootDir, filePath);
+                if (!abs.startsWith(this.rootDir)) throw new Error(`[SomMark] fileHandler.stat: path traversal outside project root is not allowed.\nAttempted path: ${abs}`);
+                try {
+                    const s = await this.nodeFs.stat(abs);
+                    return JSON.stringify({
+                        size: s.size,
+                        mtime: s.mtimeMs,
+                        ctime: s.ctimeMs,
+                        atime: s.atimeMs,
+                        isFile: s.isFile(),
+                        isDirectory: s.isDirectory(),
+                    });
+                } catch {
+                    return null;
+                }
+            },
             __allowRaw: this.security.allowRaw !== false
         });
 
@@ -501,6 +599,18 @@ class EvaluatorState {
                     }
                     return await __hostCompile(src, options);
                 },
+                lexer: (src, filename) => {
+                    if (typeof src !== "string") {
+                        throw new Error("SomMark.lexer Error: Source must be a string.");
+                    }
+                    return JSON.parse(__hostLexer(src, filename));
+                },
+                parser: (src, filename) => {
+                    if (typeof src !== "string") {
+                        throw new Error("SomMark.parser Error: Source must be a string.");
+                    }
+                    return JSON.parse(__hostParser(src, filename));
+                },
                 raw: (html) => {
                     if (typeof __allowRaw !== "undefined" && !__allowRaw) {
                         throw new Error("Security Error: SomMark.raw is disabled in this environment.");
@@ -524,6 +634,12 @@ class EvaluatorState {
                         throw new Error("SomMark.static Error: Argument must be a string.");
                     }
                     return globalThis.eval(expr);
+                },
+                env: (key) => {
+                    if (typeof key !== "string" || !key) {
+                        throw new Error("SomMark.env Error: Key must be a non-empty string.");
+                    }
+                    return __hostEnv(key);
                 }
             };
 
@@ -535,6 +651,20 @@ class EvaluatorState {
                 configurable: false
             });
 
+            Object.defineProperty(globalThis, "Smark", {
+                value: SomMark,
+                writable: false,
+                configurable: false
+            });
+
+            globalThis.fileHandler = Object.freeze({
+                read: async (path) => await __hostFileRead(path),
+                exists: async (path) => await __hostFileExists(path),
+                glob: async (pattern) => JSON.parse(await __hostFileGlob(pattern)),
+                lastModified: async (path) => await __hostFileLastModified(path),
+                stat: async (path) => { const r = await __hostFileStat(path); return r ? JSON.parse(r) : null; },
+            });
+
             delete globalThis.fetch;
             delete globalThis.process;
         `);
@@ -546,15 +676,27 @@ class EvaluatorState {
         }
         setupRes.value.dispose();
 
-        // Configure module loader using virtual FS implementation
+        const patheRes = this.context.evalCode(patheBundleCode);
+        if (patheRes.error) {
+            patheRes.error.dispose();
+        } else {
+            patheRes.value.dispose();
+        }
+
+        // Configure module loader using virtual FS implementation.
+        // The normalizer resolves every import to an absolute path so the module
+        // cache key is always absolute — <smark> (the eval module name) can never
+        // be reached by any user import regardless of what the file is named.
         this.runtime.setModuleLoader((moduleName) => {
             try {
                 const isRaw = moduleName.endsWith("?raw");
                 const cleanModuleName = isRaw ? moduleName.slice(0, -4) : moduleName;
-                const resolvedPath = /^https?:\/\//.test(this.baseDir)
-                    ? new URL(cleanModuleName, this.baseDir.endsWith("/") ? this.baseDir : this.baseDir + "/").href
+                // moduleName is already an absolute path (supplied by the normalizer below),
+                // so resolve() is a no-op for absolute paths and a safe fallback for URLs.
+                const resolvedPath = /^https?:\/\//.test(cleanModuleName)
+                    ? cleanModuleName
                     : path.resolve(this.baseDir, cleanModuleName);
-                
+
                 const fsImpl = this.settings?.fs || this.settings?.instance?.fs || this.nodeFs;
                 if (!fsImpl) {
                     throw new Error("No filesystem implementation available.");
@@ -587,6 +729,22 @@ class EvaluatorState {
             } catch (err) {
                 throw err;
             }
+        }, (baseName, moduleName) => {
+            // Resolve every import to an absolute path so no user import can ever
+            // normalize to <smark> (or any other virtual eval module name).
+            const isRaw = moduleName.endsWith("?raw");
+            const clean = isRaw ? moduleName.slice(0, -4) : moduleName;
+            if (/^https?:\/\//.test(clean)) return moduleName;
+            const baseDir = (baseName === "<smark>" || !path.isAbsolute(baseName))
+                ? this.baseDir
+                : (/^https?:\/\//.test(baseName) ? baseName : path.dirname(baseName));
+            let resolved;
+            if (/^https?:\/\//.test(baseDir)) {
+                resolved = new URL(clean, baseDir).href;
+            } else {
+                resolved = path.resolve(baseDir, clean);
+            }
+            return isRaw ? resolved + "?raw" : resolved;
         });
     }
 
@@ -737,9 +895,24 @@ class EvaluatorState {
 
     inject(vars) {
         if (!this.context) return;
+        const safe = {};
+        for (const [key, value] of Object.entries(vars)) {
+            if (typeof value === "function") {
+                const src = value.toString();
+                if (src.includes("SomMark.")) {
+                    console.warn(`[SomMark] variables.${key}: references 'SomMark' which bundlers may rename. Use 'Smark' instead.`);
+                }
+                const res = this.context.evalCode(`globalThis[${JSON.stringify(key)}] = ${src}`);
+                if (res.error) res.error.dispose();
+                else res.value.dispose();
+                continue;
+            }
+            if (!isPlainData(value)) continue;
+            safe[key] = value;
+        }
         const currentScope = this.scopes[this.scopes.length - 1];
-        Object.assign(currentScope, vars);
-        this.expose(vars);
+        Object.assign(currentScope, safe);
+        this.expose(safe);
     }
 
     async execute(code, baseDir = null) {
@@ -809,7 +982,16 @@ class EvaluatorState {
                     }
                 }
             } catch (err) {
-                // Ignore parsing errors and fallback to raw code
+                // Parse failed as a statement — try as a parenthesised expression.
+                // This handles object/array literals like {a: 1} or [1, 2] which are
+                // ambiguous in statement context but valid when wrapped in parens.
+                try {
+                    const trimmed = code.trim();
+                    acorn.parse(`(${trimmed})`, { ecmaVersion: 'latest', sourceType: 'module' });
+                    finalCode = `export default (${trimmed});`;
+                } catch {
+                    // Give up — let QuickJS surface the error.
+                }
             }
 
             if (autoExportedNames.length > 0 && !hasExplicitExports) {
@@ -823,7 +1005,7 @@ class EvaluatorState {
 
             let result;
             if (isModule) {
-                const evalRes = this.context.evalCode(finalCode, "main.js", { type: 'module' });
+                const evalRes = this.context.evalCode(finalCode, "<smark>", { type: 'module' });
                 if (evalRes.error) {
                     const err = this.context.dump(evalRes.error);
                     evalRes.error.dispose();
@@ -892,7 +1074,7 @@ class EvaluatorState {
                 }
 
                 const defaultValue = this.context.dump(resolvedDefaultHandle);
-                
+
                 if (isPromise) {
                     resolvedDefaultHandle.dispose();
                 }
@@ -932,7 +1114,7 @@ class EvaluatorState {
                     result = res;
                 }
             } else {
-                const evalRes = this.context.evalCode(code, "main.js");
+                const evalRes = this.context.evalCode(code, "<smark>");
                 if (evalRes.error) {
                     const err = this.context.dump(evalRes.error);
                     evalRes.error.dispose();
@@ -968,7 +1150,7 @@ class EvaluatorState {
             return result;
         } catch (error) {
             const stack = error.stack || "";
-            const match = stack.match(/main\.js:(\d+):(\d+)/) || stack.match(/:(\d+):(\d+)/);
+            const match = stack.match(/__smark__\.js:(\d+):(\d+)/) || stack.match(/:(\d+):(\d+)/);
 
             const err = new Error(error.message || error);
             if (match) {
@@ -1031,6 +1213,14 @@ class Evaluator {
         defaultFs = fs;
     }
 
+    setDefaultEnv(env) {
+        defaultEnv = env;
+    }
+
+    setDefaultAsyncLocalStorage(cls) {
+        setDefaultAsyncLocalStorage(cls);
+    }
+
     get active() {
         const stack = this._getStack();
         if (stack.length === 0) {

package/core/helpers/config-loader.js

@@ -52,19 +52,24 @@ export async function findAndLoadConfig(targetPath) {
 		}
 	}
 
-	// 2. Check the Target Directory (Highest Priority)
+	// 2. Walk up from startDir looking for the config file
 	if (!configPath) {
-		const targetConfig = path.join(startDir, CONFIG_FILE_NAME);
-		try {
-			await fs.access(targetConfig);
-			configPath = targetConfig;
-		} catch {
-			// No config found in target dir
+		let dir = startDir;
+		const root = path.parse(dir).root;
+		while (dir !== root) {
+			const candidate = path.join(dir, CONFIG_FILE_NAME);
+			try {
+				await fs.access(candidate);
+				configPath = candidate;
+				break;
+			} catch {
+				dir = path.dirname(dir);
+			}
 		}
 	}
 
 	// 3. Check the Current Working Directory (Fallback)
-	// We only check CWD if it's different from the Target Directory
+	// We only check CWD if it's different from the Target Directory and walk didn't find anything
 	if (!configPath && startDir !== cwd) {
 		const cwdConfig = path.join(cwd, CONFIG_FILE_NAME);
 		try {
@@ -102,10 +107,25 @@ export async function findAndLoadConfig(targetPath) {
 				mapperFile: finalMapper,
 				resolvedConfigPath: configPath
 			};
+
+			const configDir = path.dirname(configPath);
+
 			if (loadedConfig.outputDir) {
-				const configDir = path.dirname(configPath);
 				finalConfig.outputDir = path.resolve(configDir, loadedConfig.outputDir);
 			}
+
+			// Resolve relative alias paths against the config file's directory so that
+			// "./node_modules/..." in a nested config resolves correctly regardless of cwd
+			if (loadedConfig.importAliases) {
+				const resolved = {};
+				for (const [key, val] of Object.entries(loadedConfig.importAliases)) {
+					resolved[key] = (val.startsWith("./") || val.startsWith("../"))
+						? path.resolve(configDir, val)
+						: val;
+				}
+				finalConfig.importAliases = resolved;
+			}
+
 			return finalConfig;
 		}
 	}

package/core/helpers/lib.js

@@ -18,7 +18,7 @@ export function registerHostSettings(settings) {
     hostSettings = settings || {};
 }
 
-const version = "5.0.5";
+const version = "5.2.0";
 
 const SomMark = {
     version,

package/core/helpers/preprocessor.js

@@ -140,8 +140,27 @@ export async function preprocessRuntimeLogic(code, filename = null, security = {
 				if (filename && filename !== "anonymous") {
 					baseDir = path.dirname(path.resolve(filename));
 				}
+
+				// Block absolute paths — path.resolve would ignore baseDir entirely
+				if (path.isAbsolute(argValue)) {
+					transpilerError([
+						`<$red:Security Error:$> Absolute import paths are not allowed: <$magenta:${argValue}$>{line}`,
+						`<$yellow:Use a path relative to the template file, e.g.$> <$green:SomMark.import("./data.json")$> <$yellow:or$> <$green:SomMark.import("../shared/data.json")$><$yellow:.$>{line}`,
+						`<$yellow:Base directory:$> <$blue:${baseDir}$>{line}`
+					]);
+				}
+
 				const resolvedPath = path.resolve(baseDir, argValue);
 
+				// Block path traversal — resolved path must stay inside baseDir
+				const safeBases = baseDir.endsWith(path.sep) ? baseDir : baseDir + path.sep;
+				if (!resolvedPath.startsWith(safeBases) && resolvedPath !== baseDir) {
+					transpilerError([
+						`<$red:Security Error:$> Import path escapes the project directory: <$magenta:${argValue}$>{line}`,
+						`<$yellow:Resolved Path:$> <$blue:${resolvedPath}$>{line}`
+					]);
+				}
+
 				const fsImpl = instance?.fs || await getNodeFs();
 
 				// File presence validation

package/core/modules.js

@@ -192,34 +192,48 @@ export async function resolveModules(ast, context) {
 	const baseDir = context.instance.baseDir || ((filename === "anonymous") ? absFilename : path.dirname(absFilename));
 
 	// 1. Helper: Trim AST to remove file-boundary whitespace and "ghost" newlines
-	const trimAst = (nodes) => {
+	const trimAst = (nodes, trimBoundaries = true) => {
 		if (!nodes) return [];
 
-		// 1. Filter out internal whitespace-only nodes that are adjacent to non-rendering nodes
-		// (Comments, Imports, etc. shouldn't leave "ghost" newlines)
+		// 1. Filter out whitespace-only text nodes adjacent (directly or through other whitespace)
+		// to non-rendering nodes (Comments, Imports, USE_MODULE).
 		const nonRenderingTypes = [COMMENT, IMPORT, USE_MODULE];
 		let res = nodes.filter((node, idx) => {
 			if (node.type !== TEXT || node.text.trim() !== "") return true;
 
-			const prev = nodes[idx - 1];
-			const next = nodes[idx + 1];
-			const isAdjacentToNonRendering =
-				(prev && nonRenderingTypes.includes(prev.type)) ||
-				(next && nonRenderingTypes.includes(next.type));
+			// Walk backwards through consecutive whitespace nodes to find prev non-whitespace
+			let prevIsNonRendering = false;
+			for (let j = idx - 1; j >= 0; j--) {
+				if (nodes[j].type === TEXT && nodes[j].text.trim() === "") continue;
+				prevIsNonRendering = nonRenderingTypes.includes(nodes[j].type);
+				break;
+			}
+
+			// Walk forwards through consecutive whitespace nodes to find next non-whitespace
+			let nextIsNonRendering = false;
+			for (let j = idx + 1; j < nodes.length; j++) {
+				if (nodes[j].type === TEXT && nodes[j].text.trim() === "") continue;
+				nextIsNonRendering = nonRenderingTypes.includes(nodes[j].type);
+				break;
+			}
 
-			return !isAdjacentToNonRendering;
+			return !(prevIsNonRendering || nextIsNonRendering);
 		});
 
-		// 2. Final pass: trim leading/trailing newlines from the remaining boundary text nodes
-		if (res.length > 0 && res[0].type === TEXT) {
-			res[0].text = res[0].text.replace(/^[\r\n]+/, "");
-		}
-		if (res.length > 0 && res[res.length - 1].type === TEXT) {
-			res[res.length - 1].text = res[res.length - 1].text.replace(/[\r\n]+\s*$/, "");
+		if (trimBoundaries) {
+			// 2. Final pass: trim leading/trailing newlines from the remaining boundary text nodes
+			if (res.length > 0 && res[0].type === TEXT) {
+				res[0].text = res[0].text.replace(/^[\r\n]+/, "");
+			}
+			if (res.length > 0 && res[res.length - 1].type === TEXT) {
+				res[res.length - 1].text = res[res.length - 1].text.replace(/[\r\n]+\s*$/, "");
+			}
+
+			// 3. Remove any nodes that became purely empty after trimming
+			res = res.filter(node => node.type !== TEXT || node.text !== "");
 		}
 
-		// 3. Remove any nodes that became purely empty after trimming
-		return res.filter(node => node.type !== TEXT || node.text !== "");
+		return res;
 	};
 
 	// 2. Helper: Inject Slots with Indentation Propagation
@@ -282,13 +296,38 @@ export async function resolveModules(ast, context) {
 				let resolvedPath = filePath;
 				for (const [prefix, replacement] of Object.entries(importAliases)) {
 					if (filePath.startsWith(prefix)) {
-						resolvedPath = path.resolve(context.instance.cwd || "/", filePath.replace(prefix, replacement));
+						const replaced = filePath.replace(prefix, replacement);
+						// Preserve scheme prefixes (pkg:, http:, etc.) — don't path.resolve them
+						resolvedPath = replaced.startsWith("pkg:") || replaced.startsWith("http://") || replaced.startsWith("https://")
+							? replaced
+							: path.resolve(context.instance.cwd || "/", replaced);
 						break;
 					}
 				}
 
-				// 1b. Resolve relative to current base (FS)
-				const absolutePath = resolveModulePath(resolvedPath, currentBaseDir);
+				// 1b. pkg: — resolve from node_modules at project root
+				let absolutePath;
+				if (resolvedPath.startsWith("pkg:")) {
+					if (!context.instance.fs?.__isNodeFs) {
+						runtimeError([`<$red:Module Error:$> <$cyan:pkg:$> imports are not supported in browser or virtual filesystem mode at line <$yellow:${node.range.start.line + 1}$>`]);
+					}
+					const pkgPath = resolvedPath.slice(4);
+					if (!pkgPath || pkgPath.trim() === "") {
+						runtimeError([`<$red:Module Error:$> <$cyan:pkg:$> path cannot be empty at line <$yellow:${node.range.start.line + 1}$>`]);
+					}
+					const nodeModulesRoot = path.resolve(context.instance.cwd || "/", "node_modules");
+					absolutePath = path.resolve(nodeModulesRoot, pkgPath);
+					if (!absolutePath.startsWith(nodeModulesRoot + path.sep) && absolutePath !== nodeModulesRoot) {
+						runtimeError([`<$red:Module Security Error:$> <$cyan:pkg:${pkgPath}$> resolves outside node_modules — path traversal is not allowed at line <$yellow:${node.range.start.line + 1}$>`]);
+					}
+				} else {
+					// 1c. Resolve relative to current base (FS)
+					absolutePath = resolveModulePath(resolvedPath, currentBaseDir);
+				}
+
+				if (!context.instance.fs) {
+					runtimeError([`<$red:Module Error:$> Cannot import <$magenta:${filePath}$> — no filesystem is available.{N}In browser mode, pass a URL-based <$cyan:baseDir$> or a <$cyan:files$> map to enable module loading.`]);
+				}
 
 				// Local Path Resolution with Auto-Extension
 				let localPath = absolutePath;
@@ -441,7 +480,6 @@ export async function resolveModules(ast, context) {
 						Object.entries(node.props).filter(([key]) => {
 							if (key === "__consumed__") return false;
 							if (consumed.has(key)) return false; // THE FIX: Filter if hit by v{}
-							if (key === "smark-raw") return false; // directive — must not leak onto root element
 							return true;
 						})
 					);

package/core/parser.js

@@ -96,6 +96,7 @@ function makeBlockNode() {
 		structure: "Block",
 		id: "",
 		props: {},
+		directives: {},
 		body: [],
 		depth: 0,
 		range: {
@@ -633,9 +634,11 @@ function parseBlock(tokens, i, filename = null, placeholders = {}, variables = {
 			i = valueIndex;
 
 			// Store Argument
-			blockNode.props[String(argIndex++)] = v;
-			if (k) {
-				blockNode.props[k] = v;
+			if (k && k.startsWith("smark-")) {
+				blockNode.directives[k.slice(6)] = v; // strip "smark-" prefix
+			} else {
+				blockNode.props[String(argIndex++)] = v;
+				if (k) blockNode.props[k] = v;
 			}
 			k = "";
 			v = "";