diff --git a/e2e/specs/console-line-logs.spec.ts b/e2e/specs/console-line-logs.spec.ts
new file mode 100644
index 0000000000..d9ac23ec71
--- /dev/null
+++ b/e2e/specs/console-line-logs.spec.ts
@@ -0,0 +1,500 @@
+import { expect, type Frame, type Page } from '@playwright/test';
+import type { UrlQueryParams } from '../../src/livecodes/models';
+import { getLoadedApp } from '../helpers';
+import { test } from '../test-fixtures';
+
+interface ConsoleEntry {
+  text: string;
+  sourceLine: string | null;
+}
+
+const getConsoleEntries = async (app: Frame): Promise<ConsoleEntry[]> =>
+  app.evaluate(() =>
+    [...document.querySelectorAll('#console-container .luna-console-log-item')]
+      .map((item) => ({
+        text: item.querySelector('.luna-console-log-content')?.textContent?.trim() ?? '',
+        sourceLine: item.querySelector('.console-line-number')?.textContent?.trim() ?? null,
+      }))
+      .filter((entry) => entry.text !== 'Console was cleared'),
+  );
+
+const waitForConsoleEntries = async (app: Frame, expectedCount: number) => {
+  await app.waitForFunction(
+    (count) =>
+      [...document.querySelectorAll('#console-container .luna-console-log-item')]
+        .map((item) => item.querySelector('.luna-console-log-content')?.textContent?.trim() ?? '')
+        .filter((text) => text !== '' && text !== 'Console was cleared').length >= count,
+    expectedCount,
+  );
+};
+
+const openWithCode = async (
+  page: Page,
+  getTestUrl: (config?: UrlQueryParams) => string,
+  {
+    markup,
+    script,
+    language = 'js',
+  }: { markup: string; script: string; language?: string; filename?: string },
+) => {
+  const scriptParam = language === 'ts' ? 'ts' : language === 'js' ? 'js' : language;
+  await page.goto(
+    getTestUrl({
+      tools: 'console|open',
+      active: 'script',
+      html: encodeURIComponent(markup),
+      [scriptParam]: encodeURIComponent(script),
+    }),
+  );
+  const { app, waitForResultUpdate } = await getLoadedApp(page);
+  await waitForResultUpdate();
+  await app.click('#tools-pane-titles > .console');
+  return { app, waitForResultUpdate };
+};
+
+test.describe('Console line logs', () => {
+  test('shows script line for JavaScript template log', async ({ page, getTestUrl }) => {
+    // Arrange
+    const markup = [
+      '<div class="container">',
+      '  <h1>Hello, <span id="title">World</span>!</h1>',
+      '  <img class="logo" alt="logo" src="http://127.0.0.1:8080/livecodes/assets/templates/javascript.svg" />',
+      '  <p>You clicked <span id="counter">0</span> times.</p>',
+      '  <button id="counter-button">Click me</button>',
+      '</div>',
+    ].join('\n');
+    const script = [
+      'const title = document.querySelector("#title");',
+      'const counter = document.querySelector("#counter");',
+      'const button = document.querySelector("#counter-button");',
+      '',
+      'title.innerText = "JavaScript";',
+      'let count = 0;',
+      'console.log("line 7 in js template")',
+      'button.addEventListener("click", () => {',
+      '  count++;',
+      '  counter.innerText = count;',
+      '});',
+    ].join('\n');
+
+    // Act
+    const { app } = await openWithCode(page, getTestUrl, { markup, script });
+    await waitForConsoleEntries(app, 1);
+    const entries = await getConsoleEntries(app);
+
+    // Assert
+    expect(entries.find((e) => e.text === 'line 7 in js template')?.sourceLine).toBe('script:7');
+  });
+
+  test('groups repeated logs from same line into one entry', async ({ page, getTestUrl }) => {
+    // Arrange
+    const { app } = await openWithCode(page, getTestUrl, {
+      markup: '<div>console test</div>',
+      script: 'for (let i = 0; i < 5; i++) console.log("zew");',
+    });
+
+    // Act
+    await waitForConsoleEntries(app, 1);
+    await app.waitForTimeout(300);
+    const zewEntries = (await getConsoleEntries(app)).filter((e) => e.text === 'zew');
+
+    // Assert
+    expect(zewEntries).toHaveLength(1);
+    expect(zewEntries[0].sourceLine).toBe('script:1');
+  });
+
+  test('shows markup line for inline script logs', async ({ page, getTestUrl }) => {
+    // Arrange
+    const { app } = await openWithCode(page, getTestUrl, {
+      markup: '<div>inline</div>\n<script>\n  console.log("inline markup log")\n</script>',
+      script: 'document.body.dataset.ready = "1";',
+    });
+
+    // Act
+    await waitForConsoleEntries(app, 1);
+    await app.waitForTimeout(300);
+    const entries = await getConsoleEntries(app);
+
+    // Assert
+    const sourceLine = entries.find((e) => e.text === 'inline markup log')?.sourceLine;
+    expect(sourceLine).toMatch(/^markup:\d+$/);
+    const lineNum = Number(sourceLine!.split(':')[1]);
+    expect(lineNum).toBeGreaterThanOrEqual(2);
+    expect(lineNum).toBeLessThanOrEqual(4);
+  });
+
+  test('groups same-line loop logs and regroups after interruption', async ({
+    page,
+    getTestUrl,
+  }) => {
+    // Arrange
+    const { app } = await openWithCode(page, getTestUrl, {
+      markup: '<div>test</div>',
+      script: [
+        'for (let i = 0; i < 3; i++) console.log("looping");',
+        'console.log("break");',
+        'for (let i = 0; i < 2; i++) console.log("looping");',
+      ].join('\n'),
+    });
+
+    // Act
+    await waitForConsoleEntries(app, 3);
+    await app.waitForTimeout(300);
+    const entries = await getConsoleEntries(app);
+
+    // Assert
+    expect(entries).toHaveLength(3);
+    expect(entries[0]).toEqual({ text: 'looping', sourceLine: 'script:1' });
+    expect(entries[1]).toEqual({ text: 'break', sourceLine: 'script:2' });
+    expect(entries[2]).toEqual({ text: 'looping', sourceLine: 'script:3' });
+  });
+
+  test('does not merge same text from markup and script', async ({ page, getTestUrl }) => {
+    // Arrange
+    const { app } = await openWithCode(page, getTestUrl, {
+      markup: '<div>mixed</div>\n<script>\n  console.log("same text")\n</script>',
+      script: 'console.log("same text")',
+    });
+
+    // Act
+    await waitForConsoleEntries(app, 1);
+    await app.waitForTimeout(300);
+    const entries = await getConsoleEntries(app);
+
+    // Assert
+    const sameTextEntries = entries.filter((e) => e.text === 'same text');
+    expect(sameTextEntries).toHaveLength(2);
+    const sourceLines = sameTextEntries.map((e) => e.sourceLine).sort();
+    expect(sourceLines[0]).toMatch(/^markup:\d+$/);
+    expect(sourceLines[1]).toMatch(/^script:\d+$/);
+  });
+
+  test('console.time does not shift badge queue', async ({ page, getTestUrl }) => {
+    // Arrange
+    const { app } = await openWithCode(page, getTestUrl, {
+      markup: '',
+      script: ["console.log('before');", "console.time('t');", "console.log('after');"].join('\n'),
+    });
+
+    // Act
+    await waitForConsoleEntries(app, 2);
+    await app.waitForTimeout(300);
+    const entries = await getConsoleEntries(app);
+
+    // Assert
+    expect(entries.find((e) => e.text === 'before')?.sourceLine).toBe('script:1');
+    expect(entries.find((e) => e.text === 'after')?.sourceLine).toBe('script:3');
+  });
+
+  test('console.assert(true) does not shift badge queue', async ({ page, getTestUrl }) => {
+    // Arrange
+    const { app } = await openWithCode(page, getTestUrl, {
+      markup: '',
+      script: [
+        "console.log('before');",
+        'console.assert(1 === 1, "should not appear");',
+        "console.log('after');",
+      ].join('\n'),
+    });
+
+    // Act
+    await waitForConsoleEntries(app, 2);
+    await app.waitForTimeout(300);
+    const entries = await getConsoleEntries(app);
+
+    // Assert
+    expect(entries.find((e) => e.text === 'before')?.sourceLine).toBe('script:1');
+    expect(entries.find((e) => e.text === 'after')?.sourceLine).toBe('script:3');
+  });
+
+  test('console.countReset does not shift badge queue', async ({ page, getTestUrl }) => {
+    // Arrange
+    const { app } = await openWithCode(page, getTestUrl, {
+      markup: '',
+      script: [
+        "console.log('before');",
+        "console.count('x');",
+        "console.countReset('x');",
+        "console.log('after');",
+      ].join('\n'),
+    });
+
+    // Act
+    await waitForConsoleEntries(app, 3);
+    await app.waitForTimeout(300);
+    const entries = await getConsoleEntries(app);
+
+    // Assert
+    expect(entries.find((e) => e.text === 'before')?.sourceLine).toBe('script:1');
+    expect(entries.find((e) => e.text === 'after')?.sourceLine).toBe('script:4');
+  });
+
+  test('does not group identical logs from different lines (same source)', async ({
+    page,
+    getTestUrl,
+  }) => {
+    // Arrange
+    const { app } = await openWithCode(page, getTestUrl, {
+      markup: '',
+      script: ['console.log("same");', 'console.log("same");'].join('\n'),
+    });
+
+    // Act
+    await waitForConsoleEntries(app, 2);
+    await app.waitForTimeout(300);
+    const entries = (await getConsoleEntries(app)).filter((e) => e.text === 'same');
+
+    // Assert
+    expect(entries).toHaveLength(2);
+    expect(entries[0].sourceLine).toBe('script:1');
+    expect(entries[1].sourceLine).toBe('script:2');
+  });
+
+  test('groups logs from the same source line called from multiple call sites', async ({
+    page,
+    getTestUrl,
+  }) => {
+    // Arrange
+    const { app } = await openWithCode(page, getTestUrl, {
+      markup: '',
+      script: ['const greet = () => console.log("hi");', 'greet();', 'greet();', 'greet();'].join(
+        '\n',
+      ),
+    });
+
+    // Act
+    await waitForConsoleEntries(app, 1);
+    await app.waitForTimeout(300);
+    const entries = (await getConsoleEntries(app)).filter((e) => e.text === 'hi');
+
+    // Assert
+    expect(entries).toHaveLength(1);
+    expect(entries[0].sourceLine).toBe('script:1');
+  });
+
+  test('markup inline script: different lines do not group, loop lines do', async ({
+    page,
+    getTestUrl,
+  }) => {
+    // Arrange
+    const markup = [
+      '<script>',
+      'console.log("bye")',
+      'console.log("bye")',
+      'console.time("bye")',
+      '',
+      '',
+      'for(let i=0;i<5;i++){',
+      'console.log("bye")',
+      '}',
+      '</script>',
+    ].join('\n');
+    const { app } = await openWithCode(page, getTestUrl, {
+      markup,
+      script: '',
+    });
+
+    // Act
+    await waitForConsoleEntries(app, 3);
+    await app.waitForTimeout(300);
+    const entries = await getConsoleEntries(app);
+    const byeEntries = entries.filter((e) => e.text === 'bye');
+
+    // Assert
+    expect(byeEntries).toHaveLength(3);
+    for (const entry of byeEntries) {
+      expect(entry.sourceLine).toMatch(/^markup:\d+$/);
+    }
+    const lines = byeEntries.map((e) => Number(e.sourceLine!.split(':')[1]));
+    expect(lines[1]).toBe(lines[0] + 1);
+    expect(lines[2]).toBeGreaterThan(lines[1]);
+  });
+
+  test('markup inline script: line numbers correct when TypeScript is active', async ({
+    page,
+    getTestUrl,
+  }) => {
+    // Arrange
+    const markup = [
+      '<div class="container">',
+      '  <h1>Hello</h1>',
+      '  <p>paragraph</p>',
+      '  <button>click</button>',
+      '</div>',
+      '',
+      '<script>',
+      '  console.log("ts-markup-a")',
+      '  console.log("ts-markup-b")',
+      '</script>',
+    ].join('\n');
+    const { app } = await openWithCode(page, getTestUrl, {
+      markup,
+      script: 'const greeting: string = "hello";',
+      language: 'ts',
+    });
+
+    // Act
+    await waitForConsoleEntries(app, 2);
+    await app.waitForTimeout(300);
+    const entries = await getConsoleEntries(app);
+    const lineA = entries.find((e) => e.text === 'ts-markup-a')?.sourceLine;
+    const lineB = entries.find((e) => e.text === 'ts-markup-b')?.sourceLine;
+
+    // Assert
+    expect(lineA).toMatch(/^markup:\d+$/);
+    expect(lineB).toMatch(/^markup:\d+$/);
+    const numA = Number(lineA!.split(':')[1]);
+    const numB = Number(lineB!.split(':')[1]);
+    expect(numA).toBeGreaterThanOrEqual(7);
+    expect(numB).toBe(numA + 1);
+  });
+
+  test('markup runtime errors should map to markup line numbers', async ({ page, getTestUrl }) => {
+    // Arrange
+    const { app } = await openWithCode(page, getTestUrl, {
+      markup: [
+        'some text',
+        '',
+        '<script>',
+        '  console.log("line-number-bug-log")',
+        '',
+        '',
+        '  throw new Error("line-number-bug-error")',
+        '</script>',
+      ].join('\n'),
+      script: '',
+    });
+
+    // Act
+    await waitForConsoleEntries(app, 2);
+    await app.waitForTimeout(300);
+    const entries = await getConsoleEntries(app);
+    const logLine = entries.find((e) => e.text.includes('line-number-bug-log'))?.sourceLine;
+    const errLine = entries.find((e) => e.text.includes('line-number-bug-error'))?.sourceLine;
+
+    // Assert
+    expect(logLine).toMatch(/^markup:\d+$/);
+    expect(errLine).toMatch(/^markup:\d+$/);
+    const logNum = Number(logLine?.split(':')[1]);
+    const errNum = Number(errLine?.split(':')[1]);
+    expect(logNum).toBeGreaterThanOrEqual(3);
+    expect(logNum).toBeLessThanOrEqual(5);
+    expect(errNum).toBeGreaterThanOrEqual(6);
+    expect(errNum).toBeLessThanOrEqual(8);
+  });
+
+  test('markup inline script: same-value logs keep exact lines in JS/TS/React', async ({
+    page,
+    getTestUrl,
+  }) => {
+    // Arrange
+    const markup = [
+      '<div class="container">',
+      '  <h1>Hello, <span id="title">World</span>!</h1>',
+      '  <img class="logo" alt="logo" src="http://127.0.0.1:8080/livecodes/assets/templates/javascript.svg" />',
+      '  <p>You clicked <span id="counter">0</span> times.</p>',
+      '  <button id="counter-button">Click me</button>',
+      '</div>',
+      '',
+      '<script>',
+      '  console.log("same value")',
+      '  console.log("same value")',
+      '  console.time("ignored")',
+      '</script>',
+    ].join('\n');
+
+    const cases = [
+      {
+        label: 'JavaScript',
+        language: 'js',
+        script: 'document.body.dataset.ready = "js";',
+      },
+      {
+        label: 'TypeScript',
+        language: 'ts',
+        script: 'const ready: string = "ts"; document.body.dataset.ready = ready;',
+      },
+      {
+        label: 'React',
+        language: 'react',
+        script: 'export default function App() { return null; }',
+      },
+    ] as const;
+
+    for (const testCase of cases) {
+      // Arrange
+      const { app } = await openWithCode(page, getTestUrl, {
+        markup,
+        script: testCase.script,
+        language: testCase.language,
+      });
+
+      // Act
+      await waitForConsoleEntries(app, 2);
+      await app.waitForTimeout(300);
+      const entries = await getConsoleEntries(app);
+      const sameValueEntries = entries.filter((e) => e.text === 'same value');
+
+      // Assert
+      expect(sameValueEntries).toHaveLength(2);
+      const firstLine = sameValueEntries[0].sourceLine;
+      const secondLine = sameValueEntries[1].sourceLine;
+      expect(firstLine).toMatch(/^markup:\d+$/);
+      expect(secondLine).toMatch(/^markup:\d+$/);
+      const firstNum = Number(firstLine?.split(':')[1]);
+      const secondNum = Number(secondLine?.split(':')[1]);
+      expect(firstNum).toBeGreaterThanOrEqual(8);
+      expect(firstNum).toBeLessThanOrEqual(10);
+      expect(secondNum).toBeGreaterThanOrEqual(9);
+      expect(secondNum).toBeLessThanOrEqual(11);
+      expect(secondNum).toBeGreaterThan(firstNum);
+    }
+  });
+
+  test('TypeScript source map maps compiled lines to original TS lines', async ({
+    page,
+    getTestUrl,
+  }) => {
+    // Arrange
+    const { app } = await openWithCode(page, getTestUrl, {
+      markup: '',
+      script: [
+        'interface Greeter { name: string; }',
+        'interface Config { debug: boolean; }',
+        'interface Options { timeout: number; }',
+        '',
+        'const msg = "ts source map works";',
+        'console.log(msg);',
+      ].join('\n'),
+      language: 'ts',
+    });
+
+    // Act
+    await waitForConsoleEntries(app, 1);
+    await app.waitForTimeout(300);
+    const entries = await getConsoleEntries(app);
+
+    // Assert
+    expect(entries.find((e) => e.text === 'ts source map works')?.sourceLine).toBe('script:6');
+  });
+
+  test('badge queue resets correctly after page re-run', async ({ page, getTestUrl }) => {
+    // Arrange
+    const { app, waitForResultUpdate } = await openWithCode(page, getTestUrl, {
+      markup: '',
+      script: ["console.time('t');", "console.log('hello');"].join('\n'),
+    });
+    await waitForConsoleEntries(app, 1);
+
+    // Act & Assert — first run
+    let entries = await getConsoleEntries(app);
+    expect(entries.find((e) => e.text === 'hello')?.sourceLine).toBe('script:2');
+
+    // Act & Assert — after re-run, queue should reset
+    await waitForResultUpdate();
+    await waitForConsoleEntries(app, 1);
+    await app.waitForTimeout(300);
+    entries = await getConsoleEntries(app);
+    expect(entries.find((e) => e.text === 'hello')?.sourceLine).toBe('script:2');
+  });
+});
diff --git a/src/livecodes/compiler/__tests__/source-maps.spec.ts b/src/livecodes/compiler/__tests__/source-maps.spec.ts
new file mode 100644
index 0000000000..a4b1107ecd
--- /dev/null
+++ b/src/livecodes/compiler/__tests__/source-maps.spec.ts
@@ -0,0 +1,247 @@
+import { buildSourceLineMap, decodeVlq, toPositiveLineNumber } from '../source-maps';
+
+describe('toPositiveLineNumber', () => {
+  test('returns the integer for a positive number', () => {
+    // Arrange
+    const input = 7;
+
+    // Act
+    const result = toPositiveLineNumber(input);
+
+    // Assert
+    expect(result).toBe(7);
+  });
+
+  test('truncates a positive float to its integer part', () => {
+    // Arrange
+    const input = 3.9;
+
+    // Act
+    const result = toPositiveLineNumber(input);
+
+    // Assert
+    expect(result).toBe(3);
+  });
+
+  test('returns undefined for zero', () => {
+    expect(toPositiveLineNumber(0)).toBeUndefined();
+  });
+
+  test('returns undefined for a negative number', () => {
+    expect(toPositiveLineNumber(-1)).toBeUndefined();
+  });
+
+  test('returns undefined for NaN', () => {
+    expect(toPositiveLineNumber(NaN)).toBeUndefined();
+  });
+
+  test('returns undefined for Infinity', () => {
+    expect(toPositiveLineNumber(Infinity)).toBeUndefined();
+  });
+
+  test('returns undefined for a string', () => {
+    expect(toPositiveLineNumber('7')).toBeUndefined();
+  });
+
+  test('returns undefined for undefined', () => {
+    expect(toPositiveLineNumber(undefined)).toBeUndefined();
+  });
+
+  test('returns undefined for null', () => {
+    expect(toPositiveLineNumber(null)).toBeUndefined();
+  });
+});
+
+describe('decodeVlq', () => {
+  test('decodes a single positive value', () => {
+    // Arrange
+    // 'A' = 0 in base64, VLQ value 0
+    const input = 'A';
+    const startPos = 0;
+
+    // Act
+    const result = decodeVlq(input, startPos);
+
+    // Assert
+    expect(result).toEqual([0, 1]);
+  });
+
+  test('decodes a positive single-digit VLQ', () => {
+    // Arrange
+    // 'C' = 2 in base64. VLQ: low bit = sign (0 = positive), remaining = 1 → value 1
+    const input = 'C';
+    const startPos = 0;
+
+    // Act
+    const result = decodeVlq(input, startPos);
+
+    // Assert
+    expect(result).toEqual([1, 1]);
+  });
+
+  test('decodes a negative single-digit VLQ', () => {
+    // Arrange
+    // 'D' = 3 in base64. VLQ: low bit = 1 (negative), remaining = 1 → value -1
+    const input = 'D';
+    const startPos = 0;
+
+    // Act
+    const result = decodeVlq(input, startPos);
+
+    // Assert
+    expect(result).toEqual([-1, 1]);
+  });
+
+  test('decodes a multi-character VLQ (continuation bit set)', () => {
+    // Arrange
+    // 'yB' encodes value 25:
+    // 'y' = 50 = 0b110010 → continuation bit set, low 5 bits = 0b10010 = 18
+    // 'B' = 1  = 0b000001 → continuation bit clear, value = 1
+    // combined: (1 << 5) | 18 = 50, sign bit (low) = 0 → positive → 50 >> 1 = 25
+    const input = 'yB';
+    const startPos = 0;
+
+    // Act
+    const result = decodeVlq(input, startPos);
+
+    // Assert
+    expect(result).toEqual([25, 2]);
+  });
+
+  test('advances position correctly when starting mid-string', () => {
+    // Arrange
+    const input = 'AAA';
+    const startPos = 1;
+
+    // Act
+    const [value, nextPos] = decodeVlq(input, startPos);
+
+    // Assert
+    expect(value).toBe(0);
+    expect(nextPos).toBe(2);
+  });
+
+  test('stops at invalid character', () => {
+    // Arrange
+    // '!' is not a base64 VLQ character → indexOf returns -1 → loop breaks immediately
+    const input = '!';
+    const startPos = 0;
+
+    // Act
+    const [value, nextPos] = decodeVlq(input, startPos);
+
+    // Assert
+    expect(value).toBe(0);
+    expect(nextPos).toBe(1); // pos was incremented before the break
+  });
+});
+
+describe('buildSourceLineMap', () => {
+  test('returns empty map for invalid JSON', () => {
+    // Arrange
+    const input = 'not json';
+
+    // Act
+    const map = buildSourceLineMap(input);
+
+    // Assert
+    expect(map.size).toBe(0);
+  });
+
+  test('returns empty map for missing mappings field', () => {
+    // Arrange
+    const input = JSON.stringify({ version: 3 });
+
+    // Act
+    const map = buildSourceLineMap(input);
+
+    // Assert
+    expect(map.size).toBe(0);
+  });
+
+  test('returns empty map for empty mappings string', () => {
+    // Arrange
+    const input = JSON.stringify({ mappings: '' });
+
+    // Act
+    const map = buildSourceLineMap(input);
+
+    // Assert
+    expect(map.size).toBe(0);
+  });
+
+  test('maps compiled line 1 to original line 1 for identity mapping', () => {
+    // Arrange
+    // Minimal source map: one segment on compiled line 1
+    // Segment "AAAA": col=0, sources=0, line=0, col=0 → originalLine delta=0 → line 1
+    const input = JSON.stringify({ mappings: 'AAAA' });
+
+    // Act
+    const map = buildSourceLineMap(input);
+
+    // Assert
+    expect(map.get(1)).toBe(1);
+  });
+
+  test('maps compiled lines to correct original lines across multiple compiled lines', () => {
+    // Arrange
+    // TypeScript-like: 2 preamble compiled lines (no mapping), then user code starts
+    // mappings: ";;AACA" → compiled line 1 empty, line 2 empty, line 3 → original line 2
+    // "AACA": col=0, sources=0, line delta=+1 (from 0) → originalLine=1 → line 2 (1-indexed)
+    const input = JSON.stringify({ mappings: ';;AACA' });
+
+    // Act
+    const map = buildSourceLineMap(input);
+
+    // Assert
+    expect(map.get(1)).toBeUndefined();
+    expect(map.get(2)).toBeUndefined();
+    expect(map.get(3)).toBe(2);
+  });
+
+  test('only records the first segment per compiled line', () => {
+    // Arrange
+    // Two segments on compiled line 1: first maps to original line 1, second to line 3
+    // "AAAA,AAEA": first=line 1, second=line delta +2 → original line 3
+    const input = JSON.stringify({ mappings: 'AAAA,AAEA' });
+
+    // Act
+    const map = buildSourceLineMap(input);
+
+    // Assert
+    // First segment wins
+    expect(map.get(1)).toBe(1);
+  });
+
+  test('handles a realistic TypeScript source map structure', () => {
+    // Arrange
+    // Simulate: TS source has 3 lines, compiled output has 3 lines starting at the same positions
+    // Each compiled line maps back to the corresponding original line
+    // mappings: "AAAA;AACA;AACA"
+    // Line 1: AAAA → delta=0 → original line 1
+    // Line 2: AACA → delta=+1 → original line 2
+    // Line 3: AACA → delta=+1 → original line 3
+    const input = JSON.stringify({ mappings: 'AAAA;AACA;AACA' });
+
+    // Act
+    const map = buildSourceLineMap(input);
+
+    // Assert
+    expect(map.get(1)).toBe(1);
+    expect(map.get(2)).toBe(2);
+    expect(map.get(3)).toBe(3);
+  });
+
+  test('skips segments with only one field (no source info)', () => {
+    // Arrange
+    // A segment with only a generated column (no sources index, no line) should be skipped
+    // "A" = only generated column field, no further fields
+    const input = JSON.stringify({ mappings: 'A' });
+
+    // Act
+    const map = buildSourceLineMap(input);
+
+    // Assert
+    expect(map.get(1)).toBeUndefined();
+  });
+});
diff --git a/src/livecodes/compiler/import-map.ts b/src/livecodes/compiler/import-map.ts
index a915cd0040..3084cd5a19 100644
--- a/src/livecodes/compiler/import-map.ts
+++ b/src/livecodes/compiler/import-map.ts
@@ -286,9 +286,9 @@ export const cjs2esm = (code: string) => {
       [
         `import * as __requires_${i} from '${id}';`,
         `const __requires_${i}_default = __requires_${i}.default;`,
-      ].join('\n'),
+      ].join(' '),
     )
-    .join('\n');
+    .join(' ');
   const lookup = `const __requires_lookup = { ${requires
     .map((id, i) => `'${id}': __requires_${i}_default || __requires_${i}`)
     .join(', ')} };`;
@@ -296,7 +296,7 @@ export const cjs2esm = (code: string) => {
   const require = `window.require = window.require || ((id) => {
 	if (id in __requires_lookup) return __requires_lookup[id];
 	throw new Error(\`Cannot require modules dynamically (\${id})\`);
-});`;
+});`.replaceAll('\n', '');
 
   return [
     imports,
@@ -304,8 +304,8 @@ export const cjs2esm = (code: string) => {
     require,
     `const exports = {}; const module = { exports };`,
     code,
-    `export default module.exports;`,
-  ].join('\n\n');
+    `\nexport default module.exports;`,
+  ].join(' ');
 };
 
 export const createCSSModulesImportMap = (
diff --git a/src/livecodes/compiler/source-maps.ts b/src/livecodes/compiler/source-maps.ts
new file mode 100644
index 0000000000..e1b2898c73
--- /dev/null
+++ b/src/livecodes/compiler/source-maps.ts
@@ -0,0 +1,237 @@
+// ─── Types ────────────────────────────────────────────────────────────────────
+
+export type ConsoleSource = 'markup' | 'script';
+
+export type ConsoleDisplaySource = ConsoleSource | 'style';
+
+export interface ConsoleCallSite {
+  lineNumber?: number;
+  source: ConsoleSource;
+  callerFrame?: string;
+  markupOffset?: number;
+  scriptOffset?: number;
+  externalScriptFrame?: boolean;
+}
+
+export const isConsoleDisplaySource = (source: unknown): source is ConsoleDisplaySource =>
+  source === 'markup' || source === 'style' || source === 'script';
+
+// ─── Line number utilities ─────────────────────────────────────────────────────
+
+export const toPositiveLineNumber = (line: unknown): number | undefined => {
+  if (typeof line !== 'number' || !Number.isFinite(line) || line <= 0) return undefined;
+  return Math.trunc(line);
+};
+
+// ─── Source map decoder ────────────────────────────────────────────────────────
+
+const BASE64_CHARS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+
+export const decodeVlq = (str: string, pos: number): [value: number, nextPos: number] => {
+  let result = 0;
+  let shift = 0;
+  let digit: number;
+  do {
+    digit = BASE64_CHARS.indexOf(str[pos++]);
+    if (digit < 0) break;
+    result += (digit % 32) * 2 ** shift; // low 5 bits, shifted into position
+    shift += 5;
+  } while (digit >= 32); // bit 5 is the continuation flag
+  const value = result % 2 === 1 ? -Math.floor(result / 2) : Math.floor(result / 2);
+  return [value, pos];
+};
+
+// Returns the original line delta for a segment, or null if the segment lacks source info.
+// Source map segments have up to 5 VLQ fields: generatedCol, sourcesIndex, originalLine,
+// originalCol, namesIndex. We need at least 3 fields to get the original line.
+const decodeOriginalLineDelta = (segment: string): number | null => {
+  if (!segment) return null;
+  let pos = 0;
+  [, pos] = decodeVlq(segment, pos); // skip: generated column
+  if (pos >= segment.length) return null;
+  [, pos] = decodeVlq(segment, pos); // skip: sources index
+  if (pos >= segment.length) return null;
+  return decodeVlq(segment, pos)[0]; // original line delta
+};
+
+export const buildSourceLineMap = /* @__PURE__ */ (sourceMapStr: string): Map<number, number> => {
+  const lineMap = new Map<number, number>();
+
+  let mappings: string;
+  try {
+    mappings = JSON.parse(sourceMapStr).mappings;
+  } catch {
+    return lineMap; // invalid JSON — nothing to map
+  }
+  if (!mappings || typeof mappings !== 'string') return lineMap;
+
+  let originalLine = 0;
+  mappings.split(';').forEach((group, compiledLine) => {
+    for (const segment of group.split(',')) {
+      const delta = decodeOriginalLineDelta(segment);
+      if (delta === null) continue;
+      originalLine += delta; // delta is relative to previous segment across all lines
+      if (!lineMap.has(compiledLine + 1)) {
+        lineMap.set(compiledLine + 1, originalLine + 1); // convert 0-indexed to 1-indexed
+      }
+    }
+  });
+
+  return lineMap;
+};
+
+// ─── Markup inline-script line resolver ───────────────────────────────────────
+
+const toUserLine = (docLine: number, offset: number): number | undefined => {
+  if (!offset) return undefined;
+  return toPositiveLineNumber(docLine - offset);
+};
+
+const getMarkupInlineScriptStartLines = () => {
+  const scriptTags = Array.from(
+    document.body?.querySelectorAll<HTMLScriptElement>(
+      'script[data-livecodes-markup-script-line]',
+    ) ?? [],
+  );
+  return scriptTags
+    .map((script) => Number(script.dataset.livecodesMarkupScriptLine))
+    .filter((line) => Number.isFinite(line) && line > 0)
+    .sort((a, b) => a - b);
+};
+
+const getCurrentMarkupScriptStartLine = () => {
+  const script = document.currentScript;
+  if (!script) return undefined;
+  const startLine = Number(script.dataset.livecodesMarkupScriptLine);
+  return toPositiveLineNumber(startLine);
+};
+
+const getCurrentMarkupScriptStackBase = (): number => {
+  const script = document.currentScript;
+  if (!script) return 1;
+  return Number(script.dataset.livecodesMarkupScriptStackBase) || 1;
+};
+
+const getMarkupInlineScriptLine = (docLine: number, markupOffset: number): number | undefined => {
+  const currentScriptStartLine = getCurrentMarkupScriptStartLine();
+  if (currentScriptStartLine) {
+    const stackBase = getCurrentMarkupScriptStackBase();
+    return toPositiveLineNumber(currentScriptStartLine + docLine - stackBase);
+  }
+
+  if (docLine < markupOffset) {
+    const firstScriptStartLine = getMarkupInlineScriptStartLines()[0];
+    if (firstScriptStartLine) {
+      return toPositiveLineNumber(firstScriptStartLine + docLine - 1);
+    }
+  }
+
+  return toUserLine(docLine, markupOffset);
+};
+
+// ─── Console call-site detector ───────────────────────────────────────────────
+
+const getOffsets = () => ({
+  markup: Number(document.body?.dataset?.livecodesMarkupLineOffset ?? 0),
+  script: Number(document.body?.dataset?.livecodesScriptLineOffset ?? 0),
+});
+
+const isExternalScriptFrame = (frame: string) =>
+  /data:text\/javascript/i.test(frame) ||
+  /blob:/i.test(frame) ||
+  /\.[cm]?js(?:[?#][^)\s]*)?:\d+:\d+\)?[\s]*$/i.test(frame);
+
+const getCandidateFrame = (stack: string) => {
+  const frames = stack.split('\n').filter(Boolean);
+  const codeFrames = frames.filter(
+    (frame, index) =>
+      index > 0 &&
+      !/result-utils(?:\.[\w-]+)?\.js/i.test(frame) &&
+      frame.match(/:(\d+):\d+\)?[\s]*$/),
+  );
+  return codeFrames.find(isExternalScriptFrame) ?? codeFrames[0] ?? '';
+};
+
+const getLineNumberFromFrame = (callerFrame: string): number | undefined => {
+  const match = callerFrame.match(/:(\d+):\d+\)?[\s]*$/);
+  return toPositiveLineNumber(Number(match?.[1]));
+};
+
+const resolveConsoleCallSiteFromDocLine = (
+  docLine: number,
+  callerFrame?: string,
+): ConsoleCallSite => {
+  const { markup, script } = getOffsets();
+  const externalScriptFrame = isExternalScriptFrame(callerFrame ?? '');
+
+  if (externalScriptFrame || (!markup && !script)) {
+    return {
+      lineNumber: docLine,
+      source: 'script',
+      callerFrame,
+      markupOffset: markup,
+      scriptOffset: script,
+      externalScriptFrame,
+    };
+  }
+
+  if (script > 0) {
+    const source: ConsoleSource = docLine >= script ? 'script' : 'markup';
+    const lineNumber =
+      source === 'script'
+        ? toUserLine(docLine, script) ?? docLine
+        : getMarkupInlineScriptLine(docLine, markup) ?? docLine;
+    return {
+      lineNumber,
+      source,
+      callerFrame,
+      markupOffset: markup,
+      scriptOffset: script,
+      externalScriptFrame,
+    };
+  }
+
+  if (markup > 0) {
+    return {
+      lineNumber: getMarkupInlineScriptLine(docLine, markup) ?? docLine,
+      source: 'markup',
+      callerFrame,
+      markupOffset: markup,
+      scriptOffset: script,
+      externalScriptFrame,
+    };
+  }
+
+  return {
+    lineNumber: docLine,
+    source: 'script',
+    callerFrame,
+    markupOffset: markup,
+    scriptOffset: script,
+    externalScriptFrame,
+  };
+};
+
+export const getConsoleCallSiteFromError = (
+  lineNumber: unknown,
+  stack?: string,
+): ConsoleCallSite => {
+  const callerFrame = stack ? getCandidateFrame(stack) : undefined;
+  const docLine = getLineNumberFromFrame(callerFrame ?? '') ?? toPositiveLineNumber(lineNumber);
+  if (!docLine) return { source: 'script', callerFrame };
+
+  return resolveConsoleCallSiteFromDocLine(docLine, callerFrame);
+};
+
+export const getConsoleCallSite = (): ConsoleCallSite => {
+  try {
+    const stack = new Error().stack ?? '';
+    const callerFrame = getCandidateFrame(stack);
+    const docLine = getLineNumberFromFrame(callerFrame);
+    if (!docLine) return { source: 'script', callerFrame };
+
+    return resolveConsoleCallSiteFromDocLine(docLine, callerFrame);
+  } catch {
+    return { source: 'script' };
+  }
+};
diff --git a/src/livecodes/core.ts b/src/livecodes/core.ts
index a5300e7f7d..6348a26fdc 100644
--- a/src/livecodes/core.ts
+++ b/src/livecodes/core.ts
@@ -999,6 +999,10 @@ const getResultPage = async ({
   });
   const compiledScript = scriptCompileResult.code;
 
+  const { sourceMaps } = scriptCompileResult.info ?? {};
+  const consoleSourceMaps = sourceMaps ?? (scriptLanguage === 'javascript' ? null : undefined);
+  toolsPane?.console?.setSourceMap?.(consoleSourceMaps);
+
   let compileInfo: CompileInfo = {
     ...markupCompileResult.info,
     ...scriptCompileResult.info,
@@ -1009,6 +1013,10 @@ const getResultPage = async ({
       ...scriptCompileResult.info.imports,
       ...markupCompileResult.info.imports,
     },
+    sourceMaps: {
+      ...markupCompileResult.info.sourceMaps,
+      ...scriptCompileResult.info.sourceMaps,
+    },
   };
 
   const [styleCompileResult, testsCompileResult] = await Promise.all([
@@ -5475,6 +5483,10 @@ const createApi = (): API => {
     }
   };
 
+  eventsManager.addEventListener(window, customEvents.consoleNavigate, (e: any) => {
+    apiShow(e.detail.editorId, { line: e.detail.line });
+  });
+
   const apiRunTests: API['runTests'] = () =>
     new Promise((resolve) => {
       const watcher = sdkWatchers.tests.subscribe((testResults) => {
diff --git a/src/livecodes/editor/codemirror/codemirror.ts b/src/livecodes/editor/codemirror/codemirror.ts
index a947789215..07762e687b 100644
--- a/src/livecodes/editor/codemirror/codemirror.ts
+++ b/src/livecodes/editor/codemirror/codemirror.ts
@@ -496,11 +496,11 @@ export const createEditor = async (options: EditorOptions): Promise<CodeEditor>
     return { lineNumber, column };
   };
 
-  const setPosition = ({ lineNumber, column = 1 }: EditorPosition) => {
-    const col = column - 1; // columns in codemirror start at 0
-    const line = view.state.doc.lines > lineNumber ? lineNumber : view.state.doc.lines;
+  const setPosition = ({ lineNumber, column }: EditorPosition) => {
+    const col = column && column > 0 ? column : 1;
+    const line = Math.max(1, Math.min(lineNumber, view.state.doc.lines));
     const lineInfo = view.state.doc.line(line);
-    const columnNumber = lineInfo.length > col ? col : lineInfo.length;
+    const columnNumber = Math.max(0, Math.min(col - 1, lineInfo.length));
     const position = lineInfo.from + columnNumber;
     view.dispatch({
       selection: { anchor: position },
diff --git a/src/livecodes/editor/monaco/monaco.ts b/src/livecodes/editor/monaco/monaco.ts
index 473e0dc253..90a5df0c98 100644
--- a/src/livecodes/editor/monaco/monaco.ts
+++ b/src/livecodes/editor/monaco/monaco.ts
@@ -605,7 +605,7 @@ export const createEditor = async (options: EditorOptions): Promise<CodeEditor>
   const setPosition = (position: EditorPosition) => {
     const newPosition = {
       lineNumber: position.lineNumber,
-      column: position.column ?? 1,
+      column: position.column && position.column > 0 ? position.column : 1,
     };
     editor.setPosition(newPosition);
     setTimeout(() => editor.revealPositionInCenter(newPosition, 0), 50);
diff --git a/src/livecodes/events/custom-events.ts b/src/livecodes/events/custom-events.ts
index 80b2713b07..b18e1305a7 100644
--- a/src/livecodes/events/custom-events.ts
+++ b/src/livecodes/events/custom-events.ts
@@ -11,6 +11,7 @@ export const customEvents: CustomEvents = {
   run: 'livecodes-run',
   testResults: 'livecodes-test-results',
   console: 'livecodes-console',
+  consoleNavigate: 'livecodes-console-navigate',
   destroy: 'livecodes-destroy',
   resizeEditor: 'livecodes-resize-editor',
   apiResponse: 'livecodes-api-response',
diff --git a/src/livecodes/languages/react/lang-react.ts b/src/livecodes/languages/react/lang-react.ts
index 01e843923b..42b214deb3 100644
--- a/src/livecodes/languages/react/lang-react.ts
+++ b/src/livecodes/languages/react/lang-react.ts
@@ -26,7 +26,7 @@ export const react: LanguageSpecs = {
           'babel-plugin-react-compiler' as any,
           config,
         );
-        return (window as any).Babel.transform(code, {
+        const result = (window as any).Babel.transform(code, {
           filename: 'script.tsx',
           presets: [
             ['env', { modules: false, ...presetEnvConfig }],
@@ -35,7 +35,14 @@ export const react: LanguageSpecs = {
           ],
           plugins: [[(window as any).reactCompiler.reactCompiler, reactCompilerConfig]],
           ...babelConfig,
-        }).code;
+          sourceMaps: true,
+        });
+        return {
+          code: result.code,
+          info: {
+            sourceMaps: result.map ? { script: JSON.stringify(result.map) } : undefined,
+          },
+        };
       },
   },
   extensions: ['react.jsx', 'react-jsx'],
diff --git a/src/livecodes/languages/typescript/lang-typescript.ts b/src/livecodes/languages/typescript/lang-typescript.ts
index bb0053a6da..2800b994a8 100644
--- a/src/livecodes/languages/typescript/lang-typescript.ts
+++ b/src/livecodes/languages/typescript/lang-typescript.ts
@@ -37,15 +37,33 @@ export const typescript: LanguageSpecs = {
     url: typescriptUrl,
     factory:
       () =>
-      async (code, { config }) =>
-        (window as any).ts.transpile(code, {
+      async (code, { config }) => {
+        const ts = (window as any).ts;
+        const rawOptions = {
           ...typescriptOptions,
           ...(['jsx', 'tsx'].includes(config.script.language) && !hasCustomJsxRuntime(code, config)
             ? { jsx: 'react-jsx' }
             : {}),
           ...getLanguageCustomSettings('typescript', config),
           ...getLanguageCustomSettings(config.script.language, config),
-        }),
+          sourceMap: true,
+        };
+        const { options: compilerOptions, errors } = ts.convertCompilerOptionsFromJson(
+          rawOptions,
+          '',
+        );
+        if (errors?.length) {
+          // eslint-disable-next-line no-console
+          console.warn('TypeScript compiler option errors:', errors);
+        }
+        const result = ts.transpileModule(code, { compilerOptions });
+        return {
+          code: result.outputText.replace(/\n?\/\/# sourceMappingURL=\S+/m, ''),
+          info: {
+            sourceMaps: result.sourceMapText ? { script: result.sourceMapText } : undefined,
+          },
+        };
+      },
   },
   extensions: ['ts', 'mts', 'typescript'],
   editor: 'script',
diff --git a/src/livecodes/models.ts b/src/livecodes/models.ts
index 4663bc8ad3..26b24e20fd 100644
--- a/src/livecodes/models.ts
+++ b/src/livecodes/models.ts
@@ -142,6 +142,7 @@ export interface CompileInfo {
   importedContent?: string;
   imports?: Record<string, string>;
   errors?: string[];
+  sourceMaps?: Record<string, string>;
 }
 
 export interface CompileResult {
@@ -292,6 +293,7 @@ export interface Console extends Tool {
   evaluate: (code: string) => void;
   reloadEditor: (config: Config) => Promise<void>;
   setTheme?: (theme: Theme) => void;
+  setSourceMap?: (sourceMaps: Record<string, string> | null | undefined) => void;
 }
 
 export interface CompiledCodeViewer extends Tool {
diff --git a/src/livecodes/result/result-page.ts b/src/livecodes/result/result-page.ts
index c269305b90..2640584be4 100644
--- a/src/livecodes/result/result-page.ts
+++ b/src/livecodes/result/result-page.ts
@@ -115,6 +115,19 @@ export const createResultPage = async ({
   // editor markup
   const markup = code.markup.compiled;
   dom.body.innerHTML += markup;
+  const consoleEnabled =
+    !forExport &&
+    (config.tools?.enabled === 'all' ||
+      config.tools?.enabled == null ||
+      config.tools?.enabled.includes('console'));
+  const markupInlineScripts = dom.body.querySelectorAll<HTMLScriptElement>('script:not([src])');
+  const shouldMarkInlineScripts = consoleEnabled && markupInlineScripts.length > 0;
+  if (shouldMarkInlineScripts) {
+    // Mark inline scripts from markup so runtime can recover absolute markup line numbers.
+    markupInlineScripts.forEach((script, index) => {
+      script.dataset.livecodesMarkupScriptId = String(index + 1);
+    });
+  }
 
   // user-defined import map in <script type="importmap">
   type ImportMap = Partial<{ [key in 'imports' | 'scopes']: Record<string, string> }>;
@@ -425,24 +438,33 @@ export const createResultPage = async ({
     // editor script
     const script = code.script.compiled;
     const scriptElement = dom.createElement('script');
+    scriptElement.dataset.livecodesScript = 'editor';
+
+    const languageScriptType = getLanguageCompiler(code.script.language)?.scriptType;
+    const scriptType =
+      languageScriptType ??
+      (config.customSettings.scriptType != null
+        ? config.customSettings.scriptType || undefined
+        : isModuleScript(script)
+          ? 'module'
+          : undefined);
+
+    const supportsSourceUrl =
+      !scriptType || scriptType === 'module' || /(java|ecma)script/i.test(scriptType);
+    const scriptContent = supportsSourceUrl
+      ? `${script}\n//# sourceURL=livecodes-script.js`
+      : script;
+
     if (singleFile) {
-      scriptElement.innerHTML = escapeScript(script);
+      scriptElement.innerHTML = escapeScript(scriptContent);
     } else {
       scriptElement.src = './script.js';
     }
     dom.body.appendChild(scriptElement);
 
     // script type
-    const scriptType = getLanguageCompiler(code.script.language)?.scriptType;
     if (scriptType) {
       scriptElement.type = scriptType;
-    } else if (config.customSettings.scriptType != null) {
-      // do not add type if scriptType === ''
-      if (config.customSettings.scriptType) {
-        scriptElement.type = config.customSettings.scriptType;
-      }
-    } else if (isModuleScript(script)) {
-      scriptElement.type = 'module';
     }
   }
 
@@ -485,6 +507,57 @@ window.browserJest.run().then(results => {
     dom.body.appendChild(testScript);
   }
 
+  if (shouldMarkInlineScripts) {
+    const tempHtml = '<!DOCTYPE html>\n' + dom.documentElement.outerHTML;
+    const bodyTagMatch = /<body[^>]*>/.exec(tempHtml);
+    let markupLineOffset = 0;
+    if (bodyTagMatch) {
+      const afterBodyTag = bodyTagMatch.index + bodyTagMatch[0].length;
+      const bodyContentStart = tempHtml[afterBodyTag] === '\n' ? afterBodyTag + 1 : afterBodyTag;
+      markupLineOffset = (tempHtml.slice(0, bodyContentStart).match(/\n/g) ?? []).length;
+    }
+
+    let scriptLineOffset = 0;
+    const editorScriptMatch = /\bdata-livecodes-script=(['"])editor\1/.exec(tempHtml);
+    if (editorScriptMatch) {
+      const scriptTagEnd = tempHtml.indexOf('>', editorScriptMatch.index);
+      if (scriptTagEnd >= 0) {
+        const scriptContentStartRaw = scriptTagEnd + 1;
+        const scriptContentStart =
+          tempHtml[scriptContentStartRaw] === '\n'
+            ? scriptContentStartRaw + 1
+            : scriptContentStartRaw;
+        scriptLineOffset = (tempHtml.slice(0, scriptContentStart).match(/\n/g) ?? []).length;
+      }
+    }
+
+    const markupScriptTagMatches = tempHtml.matchAll(
+      /<script\b[^>]*data-livecodes-markup-script-id=(['"])(\d+)\1[^>]*>/gi,
+    );
+    for (const match of markupScriptTagMatches) {
+      const scriptId = match[2];
+      const tagIndex = match.index;
+      if (tagIndex == null) continue;
+      const scriptTagLine = (tempHtml.slice(0, tagIndex).match(/\n/g) ?? []).length + 1;
+      const scriptElement = dom.body.querySelector<HTMLScriptElement>(
+        `script[data-livecodes-markup-script-id="${scriptId}"]`,
+      );
+      if (scriptElement) {
+        scriptElement.dataset.livecodesMarkupScriptLine = String(scriptTagLine - markupLineOffset);
+        const startsWithNewLine = /^(\r\n|\n|\r)/.test(scriptElement.textContent ?? '');
+        scriptElement.dataset.livecodesMarkupScriptStackBase = startsWithNewLine ? '2' : '1';
+      }
+    }
+    dom.body
+      .querySelectorAll<HTMLScriptElement>('script[data-livecodes-markup-script-id]')
+      .forEach((scriptElement) => {
+        delete scriptElement.dataset.livecodesMarkupScriptId;
+      });
+
+    dom.body.dataset.livecodesMarkupLineOffset = String(markupLineOffset);
+    dom.body.dataset.livecodesScriptLineOffset = String(scriptLineOffset);
+  }
+
   return '<!DOCTYPE html>\n' + dom.documentElement.outerHTML;
 };
 
diff --git a/src/livecodes/result/utils.ts b/src/livecodes/result/utils.ts
index 0c3e6e3384..af3872e41a 100644
--- a/src/livecodes/result/utils.ts
+++ b/src/livecodes/result/utils.ts
@@ -1,3 +1,5 @@
+import { getConsoleCallSite, getConsoleCallSiteFromError } from '../compiler/source-maps';
+
 // modified from https://github.com/alexindigo/precise-typeof/blob/master/index.js
 export const typeOf = (obj: any) => {
   function isElement(o: any) {
@@ -128,17 +130,41 @@ export const proxyConsole = () => {
           return;
         }
         (target[method as keyof typeof console] as any)(...args);
-        parent.postMessage({ type: 'console', method, args: consoleArgs(args) }, '*');
+        const callSite = getConsoleCallSite();
+        // Methods that produce no visual output in Luna (don't fire the 'insert' event):
+        // - 'time' always silent (stores start time, no DOM entry)
+        // - 'countReset' always silent (resets counter in memory, no DOM entry)
+        // - 'assert' when assertion passes (first arg truthy = no failure shown)
+        // - 'table' with no args (nothing to render)
+        const silent =
+          method === 'time' ||
+          method === 'countReset' ||
+          (method === 'assert' && !!args[0]) ||
+          (method === 'table' && args.length === 0);
+        parent.postMessage(
+          {
+            type: 'console',
+            method,
+            args: consoleArgs(args),
+            lineNumber: callSite.lineNumber,
+            source: callSite.source,
+            silent,
+          },
+          '*',
+        );
       };
     },
   });
 
   window.addEventListener('error', (error) => {
+    const callSite = getConsoleCallSiteFromError(error.lineno, error.error?.stack);
     parent.postMessage(
       {
         type: 'console',
         method: 'error',
         args: consoleArgs([error.message]),
+        lineNumber: callSite.lineNumber,
+        source: callSite.source,
       },
       '*',
     );
diff --git a/src/livecodes/styles/app.scss b/src/livecodes/styles/app.scss
index 9ae8781911..9a2d5c7001 100644
--- a/src/livecodes/styles/app.scss
+++ b/src/livecodes/styles/app.scss
@@ -1242,6 +1242,23 @@ a.tools-pane-title {
   .luna-console-count {
     color: #fff;
   }
+
+  .luna-console-log-item {
+    .console-line-number {
+      flex-shrink: 0;
+      padding: 3px 8px 3px 4px;
+      opacity: 0.45;
+      font-size: 0.8em;
+      white-space: nowrap;
+      cursor: pointer;
+      user-select: none;
+
+      &:hover {
+        opacity: 0.8;
+        text-decoration: underline;
+      }
+    }
+  }
 }
 
 #console-input-indicator {
diff --git a/src/livecodes/toolspane/console.ts b/src/livecodes/toolspane/console.ts
index f846c2172b..18672f87c7 100644
--- a/src/livecodes/toolspane/console.ts
+++ b/src/livecodes/toolspane/console.ts
@@ -1,7 +1,14 @@
 import LunaConsole from 'luna-console';
 import { getToolspaneButtons, getToolspaneElement, getToolspaneTitles } from '../UI';
+import {
+  buildSourceLineMap,
+  isConsoleDisplaySource,
+  toPositiveLineNumber,
+  type ConsoleDisplaySource,
+} from '../compiler/source-maps';
 import { getEditorConfig } from '../config';
 import { createEditor, getFontFamily } from '../editor';
+import { customEvents } from '../events/custom-events';
 import { getLanguageExtension, mapLanguage } from '../languages';
 import type {
   CodeEditor,
@@ -25,6 +32,24 @@ export const createConsole = (
 ): Console => {
   let consoleEmulator: InstanceType<typeof LunaConsole>;
   let editor: CodeEditor;
+  let sourceMapsRecord: Record<string, string> | null | undefined;
+  // Lazy-decoded cache: source map key → decoded line map.
+  // Keyed by filename today ('script'), by actual filename in multi-file future ('tax-calculator.ts').
+  const sourceLineMapsCache = new Map<string, Map<number, number>>();
+  let lineNumbersEnabled = false;
+
+  const getSourceLineMap = (key: string): Map<number, number> | null => {
+    if (!sourceMapsRecord) return null;
+    if (sourceLineMapsCache.has(key)) return sourceLineMapsCache.get(key)!;
+    const raw = sourceMapsRecord[key];
+    if (!raw) return null;
+    const decoded = buildSourceLineMap(raw);
+    sourceLineMapsCache.set(key, decoded);
+    return decoded;
+  };
+  const lineNumberQueue: Array<string | null> = [];
+  let lastProcessedSource: string | null = null;
+  let lastProcessedLine: number | undefined;
 
   let consoleElement: HTMLElement;
   const sourceSelector = '#result > iframe';
@@ -68,14 +93,53 @@ export const createConsole = (
       return arg.content;
     });
 
+  const getSource = (source: unknown): ConsoleDisplaySource =>
+    isConsoleDisplaySource(source) ? source : 'script';
+
+  const setupInsertListener = () => {
+    (consoleEmulator as any).on('insert', (log: any) => {
+      const logItem = log?.container?.querySelector?.('.luna-console-log-item');
+      if (!logItem) return;
+      const sourceLine = lineNumberQueue.shift() ?? null;
+      // If badge already exists: Luna re-emitted 'insert' for a dedup (addCount) on the same
+      // source+line entry. The queue slot is consumed above; keep the existing badge unchanged.
+      if (logItem.querySelector('.console-line-number')) return;
+      if (!sourceLine) return;
+      const badge = document.createElement('span');
+      badge.className = 'console-line-number';
+      badge.textContent = sourceLine;
+      // Parse "label:line" — anything other than 'markup' maps to the script editor.
+      const colonIdx = sourceLine.lastIndexOf(':');
+      const sourceLabel = sourceLine.slice(0, colonIdx);
+      const lineNumber = parseInt(sourceLine.slice(colonIdx + 1), 10);
+      if (!isNaN(lineNumber)) {
+        const editorId = sourceLabel === 'markup' ? 'markup' : 'script';
+        badge.addEventListener('click', (e) => {
+          e.stopPropagation();
+          window.dispatchEvent(
+            new CustomEvent(customEvents.consoleNavigate, {
+              detail: { editorId, line: lineNumber },
+            }),
+          );
+        });
+      }
+      (logItem as HTMLElement).appendChild(badge);
+    });
+  };
+
   const createConsoleEmulator = () => {
     if (consoleEmulator) {
       consoleEmulator.destroy();
-      consoleEmulator = new LunaConsole(consoleElement);
+      // asyncRender: false is required so that Luna's lastLog dedup check runs synchronously
+      // before we reset it for the next message. With async rendering, the reset races the check.
+      consoleEmulator = new LunaConsole(consoleElement, { asyncRender: false });
+      setupInsertListener();
       return consoleEmulator;
     }
 
-    consoleEmulator = new LunaConsole(consoleElement, { theme: config.theme });
+    consoleEmulator = new LunaConsole(consoleElement, { theme: config.theme, asyncRender: false });
+    setupInsertListener();
+
     eventsManager.addEventListener(window, 'message', (event: any) => {
       if (
         !consoleElement ||
@@ -107,9 +171,55 @@ export const createConsole = (
       if (api.includes(message.method)) {
         if (message.method === 'clear') {
           // prevent passing args (silent) to `clear` method
+          lineNumberQueue.length = 0;
+          lastProcessedSource = null;
+          lastProcessedLine = undefined;
           consoleEmulator.clear();
         } else {
-          (consoleEmulator as any)[message.method](...convertTypes(message.args));
+          const args = convertTypes(message.args);
+          // groupEnd modifies an existing log entry — no 'insert' event fires, skip queue
+          if (message.method !== 'groupEnd') {
+            const lineDisplayMethods = ['log', 'error', 'warn', 'info', 'output'];
+            if (
+              lineNumbersEnabled &&
+              message.lineNumber !== undefined &&
+              lineDisplayMethods.includes(message.method)
+            ) {
+              const source = getSource(message.source);
+              const rawLineNumber = toPositiveLineNumber(message.lineNumber);
+              if (!rawLineNumber) {
+                lineNumberQueue.push(null);
+                (consoleEmulator as any)[message.method](...args);
+                updateMark();
+                return;
+              }
+              // Console messages have no filename, so use first source-map key.
+              const mapKey =
+                source === 'script' && sourceMapsRecord
+                  ? Object.keys(sourceMapsRecord)[0] ?? 'script'
+                  : source;
+              const lineNumber =
+                source === 'script'
+                  ? toPositiveLineNumber(getSourceLineMap(mapKey)?.get(rawLineNumber)) ??
+                    rawLineNumber
+                  : rawLineNumber;
+              lineNumberQueue.push(`${mapKey}:${lineNumber}`);
+              // Break Luna's deduplication when source OR line changes.
+              // Only identical messages from the exact same source+line (e.g. a loop) are grouped.
+              if (lastProcessedSource !== source || lastProcessedLine !== lineNumber) {
+                (consoleEmulator as any).lastLog = null;
+                lastProcessedSource = source;
+                lastProcessedLine = lineNumber;
+              }
+            } else if (!message.silent) {
+              // Non-display methods that DO produce a Luna DOM entry (group, count, dir, etc.)
+              // still need a queue slot so the FIFO stays aligned.
+              // Silent methods (time, assert(true), table with no args) produce no DOM entry
+              // and must not push — otherwise the queue drifts.
+              lineNumberQueue.push(null);
+            }
+          }
+          (consoleEmulator as any)[message.method](...args);
         }
         updateMark();
       }
@@ -310,12 +420,31 @@ export const createConsole = (
     getEditor: () => editor,
     reloadEditor,
     setTheme: (theme: Theme) => exec(() => consoleEmulator?.setOption('theme', theme)),
+    setSourceMap: (sourceMaps: Record<string, string> | null | undefined) => {
+      // null  = plain JS (accurate raw lines, no mapping needed) → enable line numbers
+      // undefined = suppress (Python, Ruby, WASM, etc.)          → disable line numbers
+      // Record   = compiled language with source maps            → enable + map lines
+      // Keys today: { script: '...' }. Multi-file future: { 'tax-calculator.ts': '...', 'test.js': '...' }
+      sourceMapsRecord = sourceMaps;
+      sourceLineMapsCache.clear();
+      lineNumbersEnabled = sourceMaps !== undefined;
+      // Reset queue state on each run so stale slots from the previous run
+      // (e.g. a 'time' call that was later removed) don't shift badges.
+      lineNumberQueue.length = 0;
+      lastProcessedSource = null;
+      lastProcessedLine = undefined;
+    },
     log: (...args) => exec(() => consoleEmulator?.log(...args)),
     info: (...args) => exec(() => consoleEmulator?.info(...args)),
     table: (...args) => exec(() => consoleEmulator?.table(...args)),
     warn: (...args) => exec(() => consoleEmulator?.warn(...args)),
     error: (...args) => exec(() => consoleEmulator?.error(...args)),
-    clear: (silent) => exec(() => consoleEmulator?.clear(silent)),
+    clear: (silent) => {
+      lineNumberQueue.length = 0;
+      lastProcessedSource = null;
+      lastProcessedLine = undefined;
+      exec(() => consoleEmulator?.clear(silent));
+    },
     // filterLog: (filter) => exec(() => consoleEmulator?.filterLog(filter)),
     evaluate: (code) => exec(() => consoleEmulator?.evaluate(code)),
   };
diff --git a/src/sdk/internal.ts b/src/sdk/internal.ts
index da5f9ad3ff..57e12a07d0 100644
--- a/src/sdk/internal.ts
+++ b/src/sdk/internal.ts
@@ -23,6 +23,7 @@ export interface CustomEvents {
   run: 'livecodes-run';
   testResults: 'livecodes-test-results';
   console: 'livecodes-console';
+  consoleNavigate: 'livecodes-console-navigate';
   destroy: 'livecodes-destroy';
   resizeEditor: 'livecodes-resize-editor';
   apiResponse: 'livecodes-api-response';