kire 0.1.3 → 0.1.4

package/dist/cjs/index.js

@@ -230,20 +230,184 @@ function parseParamDefinition(def) {
   };
 }
 
+// core/src/utils/source-map.ts
+var BASE64_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+function encodeVLQ(value) {
+  let res = "";
+  let vlq = value < 0 ? -value << 1 | 1 : value << 1;
+  do {
+    let digit = vlq & 31;
+    vlq >>>= 5;
+    if (vlq > 0)
+      digit |= 32;
+    res += BASE64_CHARS[digit];
+  } while (vlq > 0);
+  return res;
+}
+function decodeVLQ(str, index) {
+  let result = 0;
+  let shift = 0;
+  let continuation = true;
+  let i = index;
+  while (continuation) {
+    const char = str[i++];
+    if (!char)
+      throw new Error("Invalid VLQ");
+    const digit = BASE64_CHARS.indexOf(char);
+    if (digit === -1)
+      throw new Error(`Invalid Base64 char: ${char}`);
+    continuation = (digit & 32) !== 0;
+    result += (digit & 31) << shift;
+    shift += 5;
+  }
+  const value = result & 1 ? -(result >>> 1) : result >>> 1;
+  return [value, i];
+}
+
+class SourceMapGenerator {
+  file;
+  mappings = [];
+  sources = [];
+  constructor(file) {
+    this.file = file;
+  }
+  addSource(source) {
+    const index = this.sources.indexOf(source);
+    if (index === -1) {
+      this.sources.push(source);
+      return this.sources.length - 1;
+    }
+    return index;
+  }
+  addMapping(mapping) {
+    this.mappings.push(mapping);
+  }
+  toString() {
+    let lastGenLine = 1;
+    let lastGenCol = 0;
+    let lastSourceIndex = 0;
+    let lastSourceLine = 0;
+    let lastSourceCol = 0;
+    const encodedMappings = [];
+    let lineMappings = [];
+    this.mappings.sort((a, b) => {
+      if (a.genLine !== b.genLine)
+        return a.genLine - b.genLine;
+      return a.genCol - b.genCol;
+    });
+    for (const m of this.mappings) {
+      while (m.genLine > lastGenLine) {
+        encodedMappings.push(lineMappings.join(","));
+        lineMappings = [];
+        lastGenLine++;
+        lastGenCol = 0;
+      }
+      let segment = "";
+      segment += encodeVLQ(m.genCol - lastGenCol);
+      lastGenCol = m.genCol;
+      if (m.sourceLine !== undefined) {
+        const sourceIndex = m.sourceIndex ?? 0;
+        segment += encodeVLQ(sourceIndex - lastSourceIndex);
+        lastSourceIndex = sourceIndex;
+        segment += encodeVLQ(m.sourceLine - 1 - lastSourceLine);
+        lastSourceLine = m.sourceLine - 1;
+        segment += encodeVLQ(m.sourceCol - 1 - lastSourceCol);
+        lastSourceCol = m.sourceCol - 1;
+      }
+      lineMappings.push(segment);
+    }
+    encodedMappings.push(lineMappings.join(","));
+    const map = {
+      version: 3,
+      file: this.file,
+      sources: this.sources,
+      names: [],
+      mappings: encodedMappings.join(";")
+    };
+    return JSON.stringify(map);
+  }
+  toDataUri() {
+    const base64 = Buffer.from(this.toString()).toString("base64");
+    return `data:application/json;charset=utf-8;base64,${base64}`;
+  }
+}
+function resolveSourceLocation(map, genLine, genCol) {
+  if (!map || !map.mappings)
+    return null;
+  const lines = map.mappings.split(";");
+  if (genLine > lines.length || genLine < 1)
+    return null;
+  let stateGenCol = 0;
+  let stateSourceIndex = 0;
+  let stateSourceLine = 0;
+  let stateSourceCol = 0;
+  let bestMatch = null;
+  for (let l = 0;l < genLine; l++) {
+    const line = lines[l];
+    stateGenCol = 0;
+    if (!line)
+      continue;
+    let i = 0;
+    while (i < line.length) {
+      const [dCol, nextI1] = decodeVLQ(line, i);
+      i = nextI1;
+      stateGenCol += dCol;
+      if (i >= line.length || line[i] === ",") {
+        if (l === genLine - 1 && stateGenCol <= genCol) {}
+      } else {
+        const [dSrcIdx, nextI2] = decodeVLQ(line, i);
+        i = nextI2;
+        stateSourceIndex += dSrcIdx;
+        const [dSrcLine, nextI3] = decodeVLQ(line, i);
+        i = nextI3;
+        stateSourceLine += dSrcLine;
+        const [dSrcCol, nextI4] = decodeVLQ(line, i);
+        i = nextI4;
+        stateSourceCol += dSrcCol;
+        if (i < line.length && line[i] !== ",") {
+          const [_, nextI5] = decodeVLQ(line, i);
+          i = nextI5;
+        }
+        if (l === genLine - 1) {
+          if (stateGenCol <= genCol) {
+            bestMatch = {
+              line: stateSourceLine + 1,
+              column: stateSourceCol + 1,
+              source: map.sources[stateSourceIndex] || ""
+            };
+          } else {
+            break;
+          }
+        }
+      }
+      if (i < line.length && line[i] === ",")
+        i++;
+    }
+  }
+  return bestMatch;
+}
+
 // core/src/compiler.ts
 class Compiler {
   kire;
+  filename;
   preBuffer = [];
   resBuffer = [];
   posBuffer = [];
   usedDirectives = new Set;
-  constructor(kire) {
+  generator;
+  resMappings = [];
+  constructor(kire, filename = "template.kire") {
     this.kire = kire;
+    this.filename = filename;
+    this.generator = new SourceMapGenerator(filename);
+    this.generator.addSource(filename);
   }
   async compile(nodes) {
     this.preBuffer = [];
     this.resBuffer = [];
     this.posBuffer = [];
+    this.resMappings = [];
     this.usedDirectives.clear();
     const varLocals = this.kire.$var_locals || "it";
     await this.compileNodes(nodes);
@@ -253,22 +417,53 @@ class Compiler {
 `);
     const pos = this.posBuffer.join(`
 `);
-    const code = `
-with ($ctx.$globals) {
-	let ${varLocals} = $ctx.$props;
+    const sanitizedKeys = Array.from(this.kire.$globals.keys()).filter((key) => /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(key));
+    const destructuring = sanitizedKeys.length > 0 ? `var { ${sanitizedKeys.join(", ")} } = $ctx.$globals;` : "";
+    const startCode = `
+${destructuring}
+let ${varLocals} = $ctx.$props;
+${pre}
+`;
+    const startCodeLines = startCode.split(`
+`);
+    let currentGenLine = startCodeLines.length;
+    if (!this.kire.production) {
+      const bufferLineOffsets = new Map;
+      for (let i = 0;i < this.resBuffer.length; i++) {
+        bufferLineOffsets.set(i, currentGenLine);
+        const entry = this.resBuffer[i];
+        currentGenLine += (entry.match(/\n/g) || []).length + 1;
+      }
+      for (const mapping of this.resMappings) {
+        const genLine = bufferLineOffsets.get(mapping.index);
+        if (genLine !== undefined) {
+          this.generator.addMapping({
+            genLine,
+            genCol: mapping.col,
+            sourceLine: mapping.node.loc.start.line,
+            sourceCol: mapping.node.loc.start.column
+          });
+        }
+      }
+    }
+    let code = `
+${destructuring}
+let ${varLocals} = $ctx.$props;
 ${pre}
 ${res}
 ${pos}
-}
 return $ctx;
-//# sourceURL=kire-generated.js`;
+//# sourceURL=${this.filename}`;
+    if (!this.kire.production) {
+      code += `
+//# sourceMappingURL=${this.generator.toDataUri()}`;
+    }
     return code;
   }
   async compileNodes(nodes) {
     let i = 0;
     while (i < nodes.length) {
       const node = nodes[i];
-      this.addSourceLine(node);
       switch (node.type) {
         case "text":
           this.compileText(node);
@@ -286,18 +481,31 @@ return $ctx;
       i++;
     }
   }
-  addSourceLine(node) {
-    if (node.loc) {
-      this.resBuffer.push(`// kire-line: ${node.loc.start.line}`);
-    }
-  }
   compileText(node) {
     if (node.content) {
+      if (node.loc) {
+        const currentLine = node.loc.start.line;
+        this.resMappings.push({
+          index: this.resBuffer.length + 1,
+          node,
+          col: this.resBuffer[this.resBuffer.length - 1]?.length || 0
+        });
+        this.resBuffer.push(`// kire-line: ${currentLine}`);
+      }
       this.resBuffer.push(`$ctx.$add(${JSON.stringify(node.content)});`);
     }
   }
   compileVariable(node) {
     if (node.content) {
+      if (node.loc) {
+        const currentLine = node.loc.start.line;
+        this.resMappings.push({
+          index: this.resBuffer.length + 1,
+          node,
+          col: this.resBuffer[this.resBuffer.length - 1]?.length || 0
+        });
+        this.resBuffer.push(`// kire-line: ${currentLine}`);
+      }
       if (node.raw) {
         this.resBuffer.push(`$ctx.$add(${node.content});`);
       } else {
@@ -307,7 +515,30 @@ return $ctx;
   }
   compileJavascript(node) {
     if (node.content) {
-      this.resBuffer.push(node.content);
+      const lines = node.content.split(`
+`);
+      for (let i = 0;i < lines.length; i++) {
+        const lineContent = lines[i];
+        if (node.loc) {
+          const currentLine = node.loc.start.line + i;
+          this.resMappings.push({
+            index: this.resBuffer.length + 1,
+            node: {
+              ...node,
+              loc: {
+                start: {
+                  line: currentLine,
+                  column: i === 0 ? node.loc.start.column + 4 : 1
+                },
+                end: node.loc.end
+              }
+            },
+            col: 0
+          });
+          this.resBuffer.push(`// kire-line: ${currentLine}`);
+        }
+        this.resBuffer.push(lineContent);
+      }
     }
   }
   async processDirective(node) {
@@ -319,6 +550,8 @@ return $ctx;
       console.warn(`Directive @${name} not found.`);
       return;
     }
+    if (node.loc)
+      this.resMappings.push({ index: this.resBuffer.length, node, col: this.resBuffer[this.resBuffer.length - 1]?.length || 0 });
     const compiler = this.createCompilerContext(node, directive);
     await directive.onCall(compiler);
   }
@@ -1008,6 +1241,75 @@ var natives_default = (kire) => {
       compiler.raw(`}`);
     }
   });
+  kire.directive({
+    name: "csrf",
+    type: "html",
+    description: "Renders a CSRF token input field.",
+    onCall(compiler) {
+      compiler.raw(`
+                if (typeof $ctx.$globals.csrf === 'undefined') {
+                    throw new Error("CSRF token not defined. Please define it using kire.$global('csrf', 'token')");
+                }
+                $ctx.$add(\`<input type="hidden" name="_token" value="\${$ctx.$globals.csrf}">\`);
+            `);
+    }
+  });
+  kire.directive({
+    name: "method",
+    params: ["method:string"],
+    type: "html",
+    description: "Spoofs an HTTP method using a hidden input.",
+    onCall(compiler) {
+      const method = compiler.param("method");
+      compiler.res(`<input type="hidden" name="_method" value="${method}">`);
+    }
+  });
+  kire.directive({
+    name: "defer",
+    children: true,
+    type: "html",
+    description: "Defers rendering of a block until the main content is loaded (Out-of-Order Streaming). Falls back to immediate rendering if streaming is disabled.",
+    async onCall(compiler) {
+      compiler.raw(`{`);
+      compiler.raw(`const deferredRender = async ($ctx) => {`);
+      if (compiler.children)
+        await compiler.set(compiler.children);
+      compiler.raw(`};`);
+      compiler.raw(`if ($ctx.$kire.stream) {`);
+      compiler.raw(`  const deferId = 'defer-' + Math.random().toString(36).substr(2, 9);`);
+      compiler.raw(`  $ctx.$add(\`<div id="\${deferId}"></div>\`);`);
+      compiler.raw(`  if (!$ctx.$deferred) $ctx.$deferred = [];`);
+      compiler.raw(`  $ctx.$deferred.push(async () => {`);
+      compiler.raw(`    const $parentCtx = $ctx;`);
+      compiler.raw(`    {`);
+      compiler.raw(`      const $ctx = $parentCtx.$fork();`);
+      compiler.raw(`      let swapScript = '';`);
+      compiler.raw(`      await $ctx.$merge(deferredRender);`);
+      compiler.raw(`      const content = $ctx.$response;`);
+      compiler.raw(`      $ctx.$response = '';`);
+      compiler.raw(`      const templateId = 'tpl-' + deferId;`);
+      compiler.raw(`      swapScript = \`
+                <template id="\${templateId}">\${content}</template>
+                <script>
+                    (function() {
+                        var src = document.getElementById('\${templateId}');
+                        var dest = document.getElementById('\${deferId}');
+                        if (src && dest) {
+                            dest.replaceWith(src.content);
+                            src.remove();
+                        }
+                    })();
+                </script>
+            \`;`);
+      compiler.raw(`      $ctx.$add(swapScript);`);
+      compiler.raw(`    }`);
+      compiler.raw(`  });`);
+      compiler.raw(`} else {`);
+      compiler.raw(`  await deferredRender($ctx);`);
+      compiler.raw(`}`);
+      compiler.raw(`}`);
+    }
+  });
 };
 
 // core/src/directives/index.ts
@@ -1022,6 +1324,7 @@ var KireDirectives = {
       const isProd = kire.production;
       const cachedHash = cached.get(`md5:${resolvedPath}`);
       let compiledFn = cached.get(`js:${resolvedPath}`);
+      let sourceMap = cached.get(`map:${resolvedPath}`);
       let content = "";
       if (!cachedHash || !compiledFn || !isProd) {
         try {
@@ -1037,13 +1340,20 @@ var KireDirectives = {
         }
         const newHash = md5(content);
         if (cachedHash === newHash && compiledFn) {} else {
-          compiledFn = await kire.compileFn(content);
+          compiledFn = await kire.compileFn(content, resolvedPath);
+          sourceMap = compiledFn._map;
           cached.set(`md5:${resolvedPath}`, newHash);
           cached.set(`js:${resolvedPath}`, compiledFn);
+          if (sourceMap) {
+            cached.set(`map:${resolvedPath}`, sourceMap);
+          }
         }
       }
       if (!compiledFn)
         return null;
+      if (sourceMap && !compiledFn._map) {
+        compiledFn._map = sourceMap;
+      }
       return kire.run(compiledFn, locals, true, controller);
     });
     layout_default(kire);
@@ -1114,7 +1424,7 @@ class Parser {
         const inner = this.template.slice(this.cursor + 4, end);
         this.addNode({
           type: "javascript",
-          content: inner.trim(),
+          content: inner,
           start: this.cursor,
           end: end + 2,
           loc: this.getLoc(content)
@@ -1561,6 +1871,78 @@ class Parser {
   }
 }
 
+// core/src/utils/error.ts
+class KireError extends Error {
+  originalError;
+  fileMeta;
+  constructor(message, fileMeta) {
+    const originalError = message instanceof Error ? message : new Error(message);
+    super(originalError.message);
+    this.name = "KireError";
+    this.originalError = originalError;
+    this.fileMeta = fileMeta;
+    const originalStack = originalError.stack || "";
+    this.stack = this.formatStack(originalStack);
+  }
+  formatStack(stack) {
+    const lines = stack.split(`
+`);
+    const messageLine = lines[0] || `${this.name}: ${this.message}`;
+    const mappedLines = [];
+    for (let i = 1;i < lines.length; i++) {
+      const line = lines[i];
+      const mappedLine = this.mapStackLine(line);
+      mappedLines.push(mappedLine);
+    }
+    let finalMessage = messageLine;
+    if (finalMessage.startsWith("Error:")) {
+      finalMessage = `KireError:${finalMessage.slice(6)}`;
+    } else if (!finalMessage.includes("KireError")) {
+      finalMessage = `KireError: ${finalMessage}`;
+    }
+    return `${finalMessage}
+${mappedLines.join(`
+`)}`;
+  }
+  mapStackLine(line) {
+    const match = line.match(/^\s*at\s+(?:(.*?)\s+\()?(.+?):(\d+):(\d+)\)?$/);
+    if (match) {
+      const functionName = match[1];
+      const filename = match[2];
+      const genLine = parseInt(match[3]);
+      const genCol = parseInt(match[4]);
+      if (this.fileMeta) {
+        const isTemplateFile = filename.includes(this.fileMeta.path) || filename.includes("template.kire") || filename.includes("<anonymous>") || filename.includes("eval") || filename.includes("AsyncFunction");
+        if (isTemplateFile) {
+          if (this.fileMeta.code) {
+            const generatedLines = this.fileMeta.code.split(`
+`);
+            const codeGenLine = genLine - 2;
+            for (let offset = 0;offset >= -10; offset--) {
+              const idx = codeGenLine + offset - 1;
+              if (idx >= 0 && idx < generatedLines.length) {
+                const gl = generatedLines[idx];
+                if (gl && gl.trim().startsWith("// kire-line:")) {
+                  const sourceLine = parseInt(gl.split(":")[1].trim());
+                  const finalLine = sourceLine;
+                  return `    at ${functionName ? functionName + " " : ""}(${this.fileMeta.path}:${finalLine}:${genCol})`;
+                }
+              }
+            }
+          }
+          if (this.fileMeta.map) {
+            const resolved = resolveSourceLocation(this.fileMeta.map, genLine, genCol);
+            if (resolved) {
+              return `    at ${functionName ? functionName + " " : ""}(${resolved.source}:${resolved.line}:${resolved.column})`;
+            }
+          }
+        }
+      }
+    }
+    return line;
+  }
+}
+
 // core/src/utils/elements-runner.ts
 var processElements = async ($ctx) => {
   let resultHtml = $ctx.$response;
@@ -1635,7 +2017,7 @@ function escapeHtml(unsafe) {
   if (unsafe === null || unsafe === undefined)
     return "";
   const str = String(unsafe);
-  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;").replace(/`/g, "&#96;");
 }
 
 // core/src/runtime.ts
@@ -1656,6 +2038,7 @@ function runtime_default($kire, locals, meta) {
   $ctx.$hooks.set("before", []);
   $ctx.$hooks.set("after", []);
   $ctx.$hooks.set("end", []);
+  $ctx.$deferred = [];
   $ctx.$on = (ev, cb) => {
     const hooks = $ctx.$hooks.get(ev);
     if (hooks) {
@@ -1692,6 +2075,24 @@ function runtime_default($kire, locals, meta) {
       await fn($ctx);
       $ctx.$response = $pres + $ctx.$response;
     };
+  $ctx.$fork = () => {
+    const newCtx = { ...$ctx };
+    newCtx.$merge = async (fn) => {
+      const originalAdd = newCtx.$add;
+      let buffer = "";
+      newCtx.$add = (str) => {
+        buffer += str;
+        newCtx.$response = (newCtx.$response || "") + str;
+      };
+      const prevRes = newCtx.$response;
+      newCtx.$response = "";
+      await fn(newCtx);
+      newCtx.$add = originalAdd;
+      newCtx.$response = prevRes + buffer;
+    };
+    newCtx.$fork = $ctx.$fork;
+    return newCtx;
+  };
   const execute = async () => {
     if ($ctx.$kire.$directives.size > 0) {
       for (const directive of $ctx.$kire.$directives.values()) {
@@ -1700,13 +2101,14 @@ function runtime_default($kire, locals, meta) {
         }
       }
     }
+    await $ctx.$emit("before");
     try {
       await $ctx.$file.execute.call($ctx.$props, $ctx);
     } catch (e) {
-      console.error(e);
-      return $kire.renderError(e, $ctx);
+      const kireError = new KireError(e, $ctx.$file);
+      console.error(kireError.stack);
+      return $kire.renderError(kireError, $ctx);
     }
-    await $ctx.$emit("before");
     await $ctx.$emit("after");
     await $ctx.$emit("end");
     let resultHtml = $ctx.$response;
@@ -1740,6 +2142,9 @@ function runtime_default($kire, locals, meta) {
           if (typeof result === "string" && result.includes("Kire Runtime Error")) {
             controller.enqueue(encoder.encode(result));
           }
+          if ($ctx.$deferred && $ctx.$deferred.length > 0) {
+            await Promise.all($ctx.$deferred.map((t) => t()));
+          }
           controller.close();
         } catch (e) {
           controller.error(e);
@@ -1854,14 +2259,19 @@ function resolvePath(filepath, namespaces, locals = {}, extension = "kire") {
   let normalized = filepath.replace(/\\/g, "/");
   const sortedNamespaces = Array.from(namespaces.keys()).sort((a, b) => b.length - a.length);
   for (const ns of sortedNamespaces) {
-    if (normalized.startsWith(ns)) {
+    if (normalized.startsWith(ns) || ns === "@") {
       let template = namespaces.get(ns);
       const data = { ...locals };
       template = template.replace(/\{(\w+)\}/g, (_, key) => {
         return data[key] !== undefined ? String(data[key]) : `{${key}}`;
       });
       template = template.replace(/\\/g, "/");
-      let suffix = normalized.slice(ns.length);
+      let suffix = "";
+      if (ns === "@") {
+        suffix = normalized;
+      } else {
+        suffix = normalized.slice(ns.length);
+      }
       if (suffix.startsWith(".") || suffix.startsWith("/")) {
         suffix = suffix.slice(1);
       }
@@ -1905,6 +2315,7 @@ return (${callbackSource}).apply(this, arguments);`);
 // core/src/kire.ts
 class Kire {
   $scoped = scoped;
+  $error = KireError;
   $directives = new Map;
   $elements = new Set;
   $globals = new LayeredMap;
@@ -1989,6 +2400,7 @@ class Kire {
     for (const item of pluginsToLoad) {
       this.plugin(item.p, item.o);
     }
+    this.$error.html = (e, ctx) => this.renderError(e, ctx);
   }
   namespace(name, path) {
     const unixPath = path.replace(/\\/g, "/");
@@ -1996,6 +2408,9 @@ class Kire {
     return this;
   }
   $prop(keyOrObj, value) {
+    if (!this.$parent) {
+      console.warn("Kire Warning: You are setting props on the global instance. This data will be shared across all requests. Use kire.fork() for per-request isolation.");
+    }
     if (typeof keyOrObj === "string") {
       this.$props.set(keyOrObj, value);
     } else if (typeof keyOrObj === "object") {
@@ -2115,45 +2530,71 @@ class Kire {
     const parser = new this.$parser(template, this);
     return parser.parse();
   }
-  async compile(template) {
+  async compile(template, filename) {
     const parser = new this.$parser(template, this);
     const nodes = parser.parse();
-    const compiler = new this.$compiler(this);
+    const compiler = new this.$compiler(this, filename);
     return compiler.compile(nodes);
   }
-  async compileFn(content) {
-    const code = `${await this.compile(content)}`;
+  async compileFn(content, filename = "template.kire") {
+    const code = `${await this.compile(content, filename)}`;
     try {
       const mainFn = this.$executor(code, ["$ctx"]);
       mainFn._code = code;
       mainFn._source = content;
+      mainFn._path = filename;
+      const mapMatch = code.match(/\/\/# sourceMappingURL=data:application\/json;charset=utf-8;base64,(.*)/);
+      if (mapMatch) {
+        try {
+          const json = Buffer.from(mapMatch[1], "base64").toString("utf8");
+          mainFn._map = JSON.parse(json);
+        } catch (e) {}
+      }
       return mainFn;
     } catch (e) {
       console.error("Error creating function from code:", code);
       throw e;
     }
   }
-  async render(template, locals = {}, controller) {
-    const fn = await this.compileFn(template);
+  async render(template, locals = {}, controller, filename = "template.kire") {
+    if (!this.$parent) {
+      console.warn("Kire Warning: You are rendering on the global instance. Use kire.fork() for per-request isolation.");
+    }
+    const fn = await this.compileFn(template, filename);
     return this.run(fn, locals, false, controller);
   }
   renderError(e, ctx) {
     let snippet = "";
     let location = "";
     if (ctx && ctx.$file && ctx.$file.code && e.stack) {
-      const match = e.stack.match(/kire-generated\.js:(\d+):(\d+)/) || e.stack.match(/eval:(\d+):(\d+)/) || e.stack.match(/<anonymous>:(\d+):(\d+)/);
+      const safePath = ctx.$file.path.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      const match = e.stack.match(new RegExp(`${safePath}:(\\d+):(\\d+)`)) || e.stack.match(/kire-generated\.js:(\d+):(\d+)/) || e.stack.match(/eval:(\d+):(\d+)/) || e.stack.match(/<anonymous>:(\d+):(\d+)/);
       if (match) {
         const genLine = parseInt(match[1]) - 1;
+        const genCol = parseInt(match[2]);
         const lines = ctx.$file.code.split(`
 `);
         let sourceLine = -1;
-        for (let i = genLine;i >= 0; i--) {
-          const line = lines[i];
-          if (line && line.trim().startsWith("// kire-line:")) {
-            sourceLine = parseInt(line.split(":")[1].trim()) - 1;
-            break;
+        if (ctx.$file.map) {
+          console.log("Resolving map for", genLine + 1, genCol);
+          const resolved = resolveSourceLocation(ctx.$file.map, genLine + 1, genCol);
+          console.log("Resolved:", resolved);
+          if (resolved) {
+            sourceLine = resolved.line - 1;
+          }
+        }
+        if (sourceLine === -1) {
+          for (let i = genLine;i >= 0; i--) {
+            const line = lines[i];
+            if (line && line.trim().startsWith("// kire-line:")) {
+              sourceLine = parseInt(line.split(":")[1].trim()) - 1;
+              break;
+            }
           }
         }
+        if (sourceLine === -1 && match[0].includes(ctx.$file.path)) {
+          sourceLine = genLine;
+        }
         if (sourceLine !== -1 && ctx.$file.source) {
           location = ` at ${ctx.$file.path}:${sourceLine + 1}`;
           const sourceLines = ctx.$file.source.split(`
@@ -2202,6 +2643,9 @@ class Kire {
 </html>`;
   }
   async view(path, locals = {}, controller) {
+    if (!this.$parent) {
+      console.warn("Kire Warning: You are rendering a view on the global instance. Use kire.fork() for per-request isolation.");
+    }
     let ext = this.extension;
     if (path.endsWith(".md") || path.endsWith(".markdown")) {
       ext = null;
@@ -2215,7 +2659,7 @@ class Kire {
       compiled = this.$files.get(resolvedPath);
     } else {
       const content = await this.$resolver(resolvedPath);
-      compiled = await this.compileFn(content);
+      compiled = await this.compileFn(content, resolvedPath);
       if (this.production) {
         this.$files.set(resolvedPath, compiled);
       }
@@ -2225,7 +2669,7 @@ class Kire {
     return this.run(compiled, locals, false, controller);
   }
   resolvePath(filepath, locals = {}, extension = this.extension) {
-    return resolvePath(filepath, this.$namespaces, { ...this.$props.toObject(), ...locals }, extension === null ? "" : extension);
+    return resolvePath(filepath, this.$namespaces, { ...this.$globals.toObject(), ...this.$props.toObject(), ...locals }, extension === null ? "" : extension);
   }
   async run(mainFn, locals, children = false, controller) {
     return runtime_default(this, locals, {
@@ -2235,6 +2679,7 @@ class Kire {
       name: mainFn.name,
       source: mainFn._source,
       path: mainFn._path,
+      map: mainFn._map,
       controller
     });
   }