diff --git a/crates/djls-ide/src/diagnostics.rs b/crates/djls-ide/src/diagnostics.rs
index a47c2ddb..a7b31509 100644
--- a/crates/djls-ide/src/diagnostics.rs
+++ b/crates/djls-ide/src/diagnostics.rs
@@ -1,7 +1,7 @@
 use djls_semantic::ValidationError;
 use djls_source::File;
+use djls_source::LineIndex;
 use djls_source::Span;
-use djls_templates::LineOffsets;
 use djls_templates::TemplateError;
 use djls_templates::TemplateErrorAccumulator;
 use tower_lsp_server::lsp_types;
@@ -56,21 +56,17 @@ impl DiagnosticError for ValidationError {
 }
 
 /// Convert a Span to an LSP Range using line offsets.
-fn span_to_lsp_range(span: Span, line_offsets: &LineOffsets) -> lsp_types::Range {
-    let start_pos = span.start as usize;
-    let end_pos = (span.start + span.length) as usize;
-
-    let (start_line, start_char) = line_offsets.position_to_line_col(start_pos);
-    let (end_line, end_char) = line_offsets.position_to_line_col(end_pos);
+fn span_to_lsp_range(span: Span, line_index: &LineIndex) -> lsp_types::Range {
+    let (start_pos, end_pos) = span.to_line_col(line_index);
 
     lsp_types::Range {
         start: lsp_types::Position {
-            line: u32::try_from(start_line - 1).unwrap_or(u32::MAX), // LSP is 0-based, LineOffsets is 1-based
-            character: u32::try_from(start_char).unwrap_or(u32::MAX),
+            line: start_pos.line(),
+            character: start_pos.column(),
         },
         end: lsp_types::Position {
-            line: u32::try_from(end_line - 1).unwrap_or(u32::MAX),
-            character: u32::try_from(end_char).unwrap_or(u32::MAX),
+            line: end_pos.line(),
+            character: end_pos.column(),
         },
     }
 }
@@ -78,13 +74,13 @@ fn span_to_lsp_range(span: Span, line_offsets: &LineOffsets) -> lsp_types::Range
 /// Convert any error implementing `DiagnosticError` to an LSP diagnostic.
 fn error_to_diagnostic(
     error: &impl DiagnosticError,
-    line_offsets: &LineOffsets,
+    line_index: &LineIndex,
 ) -> lsp_types::Diagnostic {
     let range = error
         .span()
         .map(|(start, length)| {
             let span = Span::new(start, length);
-            span_to_lsp_range(span, line_offsets)
+            span_to_lsp_range(span, line_index)
         })
         .unwrap_or_default();
 
@@ -134,13 +130,10 @@ pub fn collect_diagnostics(
     let template_errors =
         djls_templates::parse_template::accumulated::<TemplateErrorAccumulator>(db, file);
 
-    let line_offsets = nodelist
-        .as_ref()
-        .map(|nl| nl.line_offsets(db).clone())
-        .unwrap_or_default();
+    let line_index = file.line_index(db);
 
     for error_acc in template_errors {
-        diagnostics.push(error_to_diagnostic(&error_acc.0, &line_offsets));
+        diagnostics.push(error_to_diagnostic(&error_acc.0, line_index));
     }
 
     if let Some(nodelist) = nodelist {
@@ -149,7 +142,7 @@ pub fn collect_diagnostics(
         >(db, nodelist);
 
         for error_acc in validation_errors {
-            diagnostics.push(error_to_diagnostic(&error_acc.0, &line_offsets));
+            diagnostics.push(error_to_diagnostic(&error_acc.0, line_index));
         }
     }
 
diff --git a/crates/djls-source/src/file.rs b/crates/djls-source/src/file.rs
index 0dca4f6e..c6a42869 100644
--- a/crates/djls-source/src/file.rs
+++ b/crates/djls-source/src/file.rs
@@ -5,6 +5,7 @@ use camino::Utf8Path;
 use camino::Utf8PathBuf;
 
 use crate::db::Db;
+use crate::position::LineIndex;
 
 #[salsa::input]
 pub struct File {
@@ -27,14 +28,7 @@ impl File {
     #[salsa::tracked(returns(ref))]
     pub fn line_index(self, db: &dyn Db) -> LineIndex {
         let text = self.source(db);
-        let mut starts = Vec::with_capacity(256);
-        starts.push(0);
-        for (i, b) in text.0.source.bytes().enumerate() {
-            if b == b'\n' {
-                starts.push(u32::try_from(i).unwrap_or_default() + 1);
-            }
-        }
-        LineIndex(starts)
+        LineIndex::from_text(text.0.source.as_str())
     }
 }
 
@@ -123,6 +117,3 @@ impl FileKind {
         }
     }
 }
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct LineIndex(Vec<u32>);
diff --git a/crates/djls-source/src/lib.rs b/crates/djls-source/src/lib.rs
index ed035339..b2227aef 100644
--- a/crates/djls-source/src/lib.rs
+++ b/crates/djls-source/src/lib.rs
@@ -1,8 +1,11 @@
 mod db;
 mod file;
-mod span;
+mod position;
 
 pub use db::Db;
 pub use file::File;
 pub use file::FileKind;
-pub use span::Span;
+pub use position::ByteOffset;
+pub use position::LineCol;
+pub use position::LineIndex;
+pub use position::Span;
diff --git a/crates/djls-source/src/position.rs b/crates/djls-source/src/position.rs
new file mode 100644
index 00000000..385d6ef7
--- /dev/null
+++ b/crates/djls-source/src/position.rs
@@ -0,0 +1,167 @@
+use serde::Serialize;
+
+/// A byte offset within a text document.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize)]
+pub struct ByteOffset(pub u32);
+
+/// A line and column position within a text document.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct LineCol(pub (u32, u32));
+
+impl LineCol {
+    #[must_use]
+    pub fn line(&self) -> u32 {
+        self.0 .0
+    }
+
+    #[must_use]
+    pub fn column(&self) -> u32 {
+        self.0 .1
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize)]
+pub struct Span {
+    pub start: u32,
+    pub length: u32,
+}
+
+impl Span {
+    #[must_use]
+    pub fn new(start: u32, length: u32) -> Self {
+        Self { start, length }
+    }
+
+    #[must_use]
+    pub fn start_offset(&self) -> ByteOffset {
+        ByteOffset(self.start)
+    }
+
+    #[must_use]
+    pub fn end_offset(&self) -> ByteOffset {
+        ByteOffset(self.start.saturating_add(self.length))
+    }
+
+    /// Convert this span to start and end line/column positions using the given line index.
+    #[must_use]
+    pub fn to_line_col(&self, line_index: &LineIndex) -> (LineCol, LineCol) {
+        let start = line_index.to_line_col(self.start_offset());
+        let end = line_index.to_line_col(self.end_offset());
+        (start, end)
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct LineIndex(Vec<u32>);
+
+impl LineIndex {
+    #[must_use]
+    pub fn from_text(text: &str) -> Self {
+        let mut starts = Vec::with_capacity(256);
+        starts.push(0);
+
+        let bytes = text.as_bytes();
+        let mut i = 0;
+        while i < bytes.len() {
+            match bytes[i] {
+                b'\n' => {
+                    // LF - Unix style line ending
+                    starts.push(u32::try_from(i + 1).unwrap_or_default());
+                    i += 1;
+                }
+                b'\r' => {
+                    // CR - check if followed by LF for Windows style
+                    if i + 1 < bytes.len() && bytes[i + 1] == b'\n' {
+                        // CRLF - Windows style line ending
+                        starts.push(u32::try_from(i + 2).unwrap_or_default());
+                        i += 2;
+                    } else {
+                        // Just CR - old Mac style line ending
+                        starts.push(u32::try_from(i + 1).unwrap_or_default());
+                        i += 1;
+                    }
+                }
+                _ => i += 1,
+            }
+        }
+
+        LineIndex(starts)
+    }
+
+    #[must_use]
+    pub fn to_line_col(&self, offset: ByteOffset) -> LineCol {
+        if self.0.is_empty() {
+            return LineCol((0, 0));
+        }
+
+        let line = match self.0.binary_search(&offset.0) {
+            Ok(exact) => exact,
+            Err(0) => 0,
+            Err(next) => next - 1,
+        };
+
+        let line_start = self.0[line];
+        let column = offset.0.saturating_sub(line_start);
+
+        LineCol((u32::try_from(line).unwrap_or_default(), column))
+    }
+
+    #[must_use]
+    pub fn line_start(&self, line: u32) -> Option<u32> {
+        self.0.get(line as usize).copied()
+    }
+
+    #[must_use]
+    pub fn lines(&self) -> &[u32] {
+        &self.0
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_line_index_unix_endings() {
+        let text = "line1\nline2\nline3";
+        let index = LineIndex::from_text(text);
+        assert_eq!(index.lines(), &[0, 6, 12]);
+    }
+
+    #[test]
+    fn test_line_index_windows_endings() {
+        let text = "line1\r\nline2\r\nline3";
+        let index = LineIndex::from_text(text);
+        // After "line1\r\n" (7 bytes), next line starts at byte 7
+        // After "line2\r\n" (7 bytes), next line starts at byte 14
+        assert_eq!(index.lines(), &[0, 7, 14]);
+    }
+
+    #[test]
+    fn test_line_index_mixed_endings() {
+        let text = "line1\nline2\r\nline3\rline4";
+        let index = LineIndex::from_text(text);
+        // "line1\n" -> next at 6
+        // "line2\r\n" -> next at 13
+        // "line3\r" -> next at 19
+        assert_eq!(index.lines(), &[0, 6, 13, 19]);
+    }
+
+    #[test]
+    fn test_line_index_empty() {
+        let text = "";
+        let index = LineIndex::from_text(text);
+        assert_eq!(index.lines(), &[0]);
+    }
+
+    #[test]
+    fn test_to_line_col_with_crlf() {
+        let text = "hello\r\nworld";
+        let index = LineIndex::from_text(text);
+
+        // "hello" is 5 bytes, then \r\n, so "world" starts at byte 7
+        assert_eq!(index.to_line_col(ByteOffset(0)), LineCol((0, 0)));
+        assert_eq!(index.to_line_col(ByteOffset(7)), LineCol((1, 0)));
+        assert_eq!(index.to_line_col(ByteOffset(8)), LineCol((1, 1)));
+    }
+}
diff --git a/crates/djls-source/src/span.rs b/crates/djls-source/src/span.rs
deleted file mode 100644
index e91fbfd7..00000000
--- a/crates/djls-source/src/span.rs
+++ /dev/null
@@ -1,14 +0,0 @@
-use serde::Serialize;
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize)]
-pub struct Span {
-    pub start: u32,
-    pub length: u32,
-}
-
-impl Span {
-    #[must_use]
-    pub fn new(start: u32, length: u32) -> Self {
-        Self { start, length }
-    }
-}
diff --git a/crates/djls-templates/src/lexer.rs b/crates/djls-templates/src/lexer.rs
index fadb4d0e..efc005e8 100644
--- a/crates/djls-templates/src/lexer.rs
+++ b/crates/djls-templates/src/lexer.rs
@@ -1,5 +1,4 @@
 use crate::db::Db as TemplateDb;
-use crate::nodelist::LineOffsets;
 use crate::tokens::Token;
 use crate::tokens::TokenContent;
 
@@ -28,9 +27,8 @@ impl<'db> Lexer<'db> {
         }
     }
 
-    pub fn tokenize(&mut self) -> (Vec<Token<'db>>, LineOffsets) {
+    pub fn tokenize(&mut self) -> Vec<Token<'db>> {
         let mut tokens = Vec::new();
-        let mut line_offsets = LineOffsets::default();
 
         while !self.is_at_end() {
             self.start = self.current;
@@ -52,23 +50,12 @@ impl<'db> Lexer<'db> {
                 _ => self.lex_text(),
             };
 
-            match self.peek_previous() {
-                '\n' => line_offsets.add_line(u32::try_from(self.current).unwrap_or(u32::MAX)),
-                '\r' => {
-                    line_offsets.add_line(u32::try_from(self.current).unwrap_or(u32::MAX));
-                    if self.peek() == '\n' {
-                        self.current += 1;
-                    }
-                }
-                _ => {}
-            }
-
             tokens.push(token);
         }
 
         tokens.push(Token::Eof);
 
-        (tokens, line_offsets)
+        tokens
     }
 
     fn lex_django_construct(
@@ -149,17 +136,6 @@ impl<'db> Lexer<'db> {
         chars.next().unwrap_or('\0')
     }
 
-    fn peek_previous(&self) -> char {
-        if self.current == 0 {
-            return '\0';
-        }
-        let mut pos = self.current - 1;
-        while !self.source.is_char_boundary(pos) && pos > 0 {
-            pos -= 1;
-        }
-        self.source[pos..].chars().next().unwrap_or('\0')
-    }
-
     #[inline]
     fn is_at_end(&self) -> bool {
         self.current >= self.source.len()
@@ -244,7 +220,7 @@ mod tests {
         let db = TestDatabase::new();
         let source = r#"<div class="container" id="main" disabled></div>"#;
         let mut lexer = Lexer::new(&db, source);
-        let (tokens, _) = lexer.tokenize();
+        let tokens = lexer.tokenize();
         let snapshot = TokenSnapshotVec(tokens).to_snapshot(&db);
         insta::assert_yaml_snapshot!(snapshot);
     }
@@ -254,7 +230,7 @@ mod tests {
         let db = TestDatabase::new();
         let source = "{{ user.name|default:\"Anonymous\"|title }}";
         let mut lexer = Lexer::new(&db, source);
-        let (tokens, _) = lexer.tokenize();
+        let tokens = lexer.tokenize();
         let snapshot = TokenSnapshotVec(tokens).to_snapshot(&db);
         insta::assert_yaml_snapshot!(snapshot);
     }
@@ -264,7 +240,7 @@ mod tests {
         let db = TestDatabase::new();
         let source = "{% if user.is_staff %}Admin{% else %}User{% endif %}";
         let mut lexer = Lexer::new(&db, source);
-        let (tokens, _) = lexer.tokenize();
+        let tokens = lexer.tokenize();
         let snapshot = TokenSnapshotVec(tokens).to_snapshot(&db);
         insta::assert_yaml_snapshot!(snapshot);
     }
@@ -283,7 +259,7 @@ mod tests {
     /* CSS comment */
 </style>";
         let mut lexer = Lexer::new(&db, source);
-        let (tokens, _) = lexer.tokenize();
+        let tokens = lexer.tokenize();
         let snapshot = TokenSnapshotVec(tokens).to_snapshot(&db);
         insta::assert_yaml_snapshot!(snapshot);
     }
@@ -299,7 +275,7 @@ mod tests {
     console.log(x);
 </script>"#;
         let mut lexer = Lexer::new(&db, source);
-        let (tokens, _) = lexer.tokenize();
+        let tokens = lexer.tokenize();
         let snapshot = TokenSnapshotVec(tokens).to_snapshot(&db);
         insta::assert_yaml_snapshot!(snapshot);
     }
@@ -314,7 +290,7 @@ mod tests {
     }
 </style>"#;
         let mut lexer = Lexer::new(&db, source);
-        let (tokens, _) = lexer.tokenize();
+        let tokens = lexer.tokenize();
         let snapshot = TokenSnapshotVec(tokens).to_snapshot(&db);
         insta::assert_yaml_snapshot!(snapshot);
     }
@@ -328,7 +304,7 @@ mod tests {
 <!-- html comment -->
 <div>text</div>";
         let mut lexer = Lexer::new(&db, source);
-        let (tokens, _) = lexer.tokenize();
+        let tokens = lexer.tokenize();
         let snapshot = TokenSnapshotVec(tokens).to_snapshot(&db);
         insta::assert_yaml_snapshot!(snapshot);
     }
@@ -367,7 +343,7 @@ mod tests {
 </body>
 </html>"#;
         let mut lexer = Lexer::new(&db, source);
-        let (tokens, _) = lexer.tokenize();
+        let tokens = lexer.tokenize();
         let snapshot = TokenSnapshotVec(tokens).to_snapshot(&db);
         insta::assert_yaml_snapshot!(snapshot);
     }
@@ -377,7 +353,7 @@ mod tests {
         let db = TestDatabase::new();
         let source = "<style>body { color: blue; ";
         let mut lexer = Lexer::new(&db, source);
-        let (tokens, _) = lexer.tokenize();
+        let tokens = lexer.tokenize();
         let snapshot = TokenSnapshotVec(tokens).to_snapshot(&db);
         insta::assert_yaml_snapshot!(snapshot);
     }
diff --git a/crates/djls-templates/src/lib.rs b/crates/djls-templates/src/lib.rs
index e8683d0a..d1122f7a 100644
--- a/crates/djls-templates/src/lib.rs
+++ b/crates/djls-templates/src/lib.rs
@@ -58,7 +58,6 @@ use djls_source::File;
 use djls_source::FileKind;
 pub use error::TemplateError;
 pub use lexer::Lexer;
-pub use nodelist::LineOffsets;
 pub use nodelist::NodeList;
 pub use parser::ParseError;
 pub use parser::Parser;
@@ -70,11 +69,11 @@ use tokens::TokenStream;
 fn lex_template(db: &dyn Db, file: File) -> TokenStream<'_> {
     let source = file.source(db);
     if *source.kind() != FileKind::Template {
-        return TokenStream::new(db, vec![], LineOffsets::default());
+        return TokenStream::new(db, vec![]);
     }
     let text = source.as_ref();
-    let (tokens, line_offsets) = Lexer::new(db, text).tokenize();
-    TokenStream::new(db, tokens, line_offsets)
+    let tokens = Lexer::new(db, text).tokenize();
+    TokenStream::new(db, tokens)
 }
 
 /// Parse a Django template file and accumulate diagnostics.
@@ -95,8 +94,7 @@ pub fn parse_template(db: &dyn Db, file: File) -> Option<NodeList<'_>> {
 
     if token_stream.stream(db).is_empty() {
         let empty_nodelist = Vec::new();
-        let empty_offsets = LineOffsets::default();
-        return Some(NodeList::new(db, empty_nodelist, empty_offsets));
+        return Some(NodeList::new(db, empty_nodelist));
     }
 
     let nodelist = match Parser::new(db, token_stream).parse() {
@@ -107,8 +105,7 @@ pub fn parse_template(db: &dyn Db, file: File) -> Option<NodeList<'_>> {
             TemplateErrorAccumulator(template_error).accumulate(db);
 
             let empty_nodelist = Vec::new();
-            let empty_offsets = LineOffsets::default();
-            NodeList::new(db, empty_nodelist, empty_offsets)
+            NodeList::new(db, empty_nodelist)
         }
     };
 
diff --git a/crates/djls-templates/src/nodelist.rs b/crates/djls-templates/src/nodelist.rs
index c9d3934b..d729cb62 100644
--- a/crates/djls-templates/src/nodelist.rs
+++ b/crates/djls-templates/src/nodelist.rs
@@ -1,5 +1,4 @@
 use djls_source::Span;
-use serde::Serialize;
 
 use crate::db::Db as TemplateDb;
 
@@ -8,50 +7,6 @@ pub struct NodeList<'db> {
     #[tracked]
     #[returns(ref)]
     pub nodelist: Vec<Node<'db>>,
-    #[tracked]
-    #[returns(ref)]
-    pub line_offsets: LineOffsets,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize)]
-pub struct LineOffsets(pub Vec<u32>);
-
-impl LineOffsets {
-    pub fn add_line(&mut self, offset: u32) {
-        self.0.push(offset);
-    }
-
-    #[must_use]
-    pub fn position_to_line_col(&self, position: usize) -> (usize, usize) {
-        let position = u32::try_from(position).unwrap_or_default();
-        let line = match self.0.binary_search(&position) {
-            Ok(exact_line) => exact_line,    // Position is at start of this line
-            Err(0) => 0,                     // Before first line start
-            Err(next_line) => next_line - 1, // We're on the previous line
-        };
-
-        // Calculate column as offset from line start
-        let col = if line == 0 {
-            position as usize
-        } else {
-            (position - self.0[line]) as usize
-        };
-
-        // Convert to 1-based line number
-        (line + 1, col)
-    }
-
-    #[must_use]
-    pub fn line_col_to_position(&self, line: u32, col: u32) -> u32 {
-        // line is 1-based, so subtract 1 to get the index
-        self.0[(line - 1) as usize] + col
-    }
-}
-
-impl Default for LineOffsets {
-    fn default() -> Self {
-        Self(vec![0])
-    }
 }
 
 #[derive(Clone, Debug, PartialEq, Eq, salsa::Update)]
@@ -142,64 +97,3 @@ pub struct VariableName<'db> {
 pub struct FilterName<'db> {
     pub text: String,
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    mod line_offsets {
-        use super::*;
-
-        #[test]
-        fn test_new_starts_at_zero() {
-            let offsets = LineOffsets::default();
-            assert_eq!(offsets.position_to_line_col(0), (1, 0)); // Line 1, column 0
-        }
-
-        #[test]
-        fn test_start_of_lines() {
-            let mut offsets = LineOffsets::default();
-            offsets.add_line(10); // Line 2 starts at offset 10
-            offsets.add_line(25); // Line 3 starts at offset 25
-
-            assert_eq!(offsets.position_to_line_col(0), (1, 0)); // Line 1, start
-            assert_eq!(offsets.position_to_line_col(10), (2, 0)); // Line 2, start
-            assert_eq!(offsets.position_to_line_col(25), (3, 0)); // Line 3, start
-        }
-    }
-
-    mod spans_and_positions {
-
-        #[test]
-        fn test_variable_spans() {
-            // let template = "Hello\n{{ user.name }}\nWorld";
-            // Tests will need to be updated to work with the new db parameter
-            // For now, comment out to allow compilation
-            // let tokens = Lexer::new(template).tokenize().unwrap();
-            // let mut parser = Parser::new(tokens);
-            // let (nodelist, errors) = parser.parse().unwrap();
-            // assert!(errors.is_empty());
-
-            // // Find the variable node
-            // let nodes = nodelist.nodelist();
-            // let var_node = nodes
-            //     .iter()
-            //     .find(|n| matches!(n, Node::Variable { .. }))
-            //     .unwrap();
-
-            // if let Node::Variable { span, .. } = var_node {
-            //     // Variable starts after newline + "{{"
-            //     let (line, col) = nodelist
-            //         .line_offsets()
-            //         .position_to_line_col(span.start() as usize);
-            //     assert_eq!(
-            //         (line, col),
-            //         (2, 0),
-            //         "Variable should start at line 2, col 3"
-            //     );
-
-            //     assert_eq!(span.length(), 9, "Variable span should cover 'user.name'");
-            // }
-        }
-    }
-}
diff --git a/crates/djls-templates/src/parser.rs b/crates/djls-templates/src/parser.rs
index 95b04003..a83d9101 100644
--- a/crates/djls-templates/src/parser.rs
+++ b/crates/djls-templates/src/parser.rs
@@ -7,7 +7,6 @@ use crate::db::Db as TemplateDb;
 use crate::db::TemplateErrorAccumulator;
 use crate::error::TemplateError;
 use crate::nodelist::FilterName;
-use crate::nodelist::LineOffsets;
 use crate::nodelist::Node;
 use crate::nodelist::NodeList;
 use crate::nodelist::TagBit;
@@ -20,7 +19,6 @@ use crate::tokens::TokenStream;
 pub struct Parser<'db> {
     db: &'db dyn TemplateDb,
     tokens: Vec<Token<'db>>,
-    line_offsets: LineOffsets,
     current: usize,
 }
 
@@ -30,7 +28,6 @@ impl<'db> Parser<'db> {
         Self {
             db,
             tokens: tokens.stream(db).clone(),
-            line_offsets: tokens.line_offsets(db).clone(),
             current: 0,
         }
     }
@@ -52,7 +49,7 @@ impl<'db> Parser<'db> {
             }
         }
 
-        let nodelist = NodeList::new(self.db, nodelist, self.line_offsets.clone());
+        let nodelist = NodeList::new(self.db, nodelist);
 
         Ok(nodelist)
     }
@@ -346,8 +343,8 @@ mod tests {
     #[salsa::tracked]
     fn parse_test_template(db: &dyn TemplateDb, template: TestTemplate) -> NodeList<'_> {
         let source = template.source(db);
-        let (tokens, line_offsets) = Lexer::new(db, source).tokenize();
-        let token_stream = TokenStream::new(db, tokens, line_offsets);
+        let tokens = Lexer::new(db, source).tokenize();
+        let token_stream = TokenStream::new(db, tokens);
         let mut parser = Parser::new(db, token_stream);
         let nodelist = parser.parse().unwrap();
         nodelist
@@ -356,7 +353,6 @@ mod tests {
     #[derive(Debug, Clone, PartialEq, Serialize)]
     struct TestNodeList {
         nodelist: Vec<TestNode>,
-        line_offsets: Vec<u32>,
     }
 
     #[derive(Debug, Clone, PartialEq, Serialize)]
@@ -411,7 +407,6 @@ mod tests {
     ) -> TestNodeList {
         TestNodeList {
             nodelist: convert_nodelist_for_testing(nodelist.nodelist(db), db),
-            line_offsets: nodelist.line_offsets(db).0.clone(),
         }
     }
 
@@ -784,20 +779,4 @@ mod tests {
             insta::assert_yaml_snapshot!(test_nodelist);
         }
     }
-
-    mod line_tracking {
-        use super::*;
-
-        #[test]
-        fn test_parser_tracks_line_offsets() {
-            let db = TestDatabase::new();
-            let source = "line1\nline2".to_string();
-            let template = TestTemplate::new(&db, source);
-            let nodelist = parse_test_template(&db, template);
-
-            let offsets = nodelist.line_offsets(&db);
-            assert_eq!(offsets.position_to_line_col(0), (1, 0)); // Start of line 1
-            assert_eq!(offsets.position_to_line_col(6), (2, 0)); // Start of line 2
-        }
-    }
 }
diff --git a/crates/djls-templates/src/snapshots/djls_templates__parser__tests__comments__parse_comments.snap b/crates/djls-templates/src/snapshots/djls_templates__parser__tests__comments__parse_comments.snap
index 30064c3b..eda8732c 100644
--- a/crates/djls-templates/src/snapshots/djls_templates__parser__tests__comments__parse_comments.snap
+++ b/crates/djls-templates/src/snapshots/djls_templates__parser__tests__comments__parse_comments.snap
@@ -12,5 +12,3 @@ nodelist:
     span:
       - 24
       - 14
-line_offsets:
-  - 0
diff --git a/crates/djls-templates/src/snapshots/djls_templates__parser__tests__django__parse_complex_if_elif.snap b/crates/djls-templates/src/snapshots/djls_templates__parser__tests__django__parse_complex_if_elif.snap
index 1e679a64..06a521df 100644
--- a/crates/djls-templates/src/snapshots/djls_templates__parser__tests__django__parse_complex_if_elif.snap
+++ b/crates/djls-templates/src/snapshots/djls_templates__parser__tests__django__parse_complex_if_elif.snap
@@ -45,5 +45,3 @@ nodelist:
     span:
       - 63
       - 5
-line_offsets:
-  - 0
diff --git a/crates/djls-templates/src/snapshots/djls_templates__parser__tests__django__parse_django_for_block.snap b/crates/djls-templates/src/snapshots/djls_templates__parser__tests__django__parse_django_for_block.snap
index c5c967d1..bd522177 100644
--- a/crates/djls-templates/src/snapshots/djls_templates__parser__tests__django__parse_django_for_block.snap
+++ b/crates/djls-templates/src/snapshots/djls_templates__parser__tests__django__parse_django_for_block.snap
@@ -34,5 +34,3 @@ nodelist:
     span:
       - 55
       - 6
-line_offsets:
-  - 0
diff --git a/crates/djls-templates/src/snapshots/djls_templates__parser__tests__django__parse_django_if_block.snap b/crates/djls-templates/src/snapshots/djls_templates__parser__tests__django__parse_django_if_block.snap
index f1215f8f..9578810d 100644
--- a/crates/djls-templates/src/snapshots/djls_templates__parser__tests__django__parse_django_if_block.snap
+++ b/crates/djls-templates/src/snapshots/djls_templates__parser__tests__django__parse_django_if_block.snap
@@ -20,5 +20,3 @@ nodelist:
     span:
       - 40
       - 5
-line_offsets:
-  - 0
diff --git a/crates/djls-templates/src/snapshots/djls_templates__parser__tests__django__parse_django_tag_assignment.snap b/crates/djls-templates/src/snapshots/djls_templates__parser__tests__django__parse_django_tag_assignment.snap
index 047ebfee..564baf47 100644
--- a/crates/djls-templates/src/snapshots/djls_templates__parser__tests__django__parse_django_tag_assignment.snap
+++ b/crates/djls-templates/src/snapshots/djls_templates__parser__tests__django__parse_django_tag_assignment.snap
@@ -12,5 +12,3 @@ nodelist:
     span:
       - 3
       - 23
-line_offsets:
-  - 0
diff --git a/crates/djls-templates/src/snapshots/djls_templates__parser__tests__django__parse_django_variable.snap b/crates/djls-templates/src/snapshots/djls_templates__parser__tests__django__parse_django_variable.snap
index 0809d53b..6a0bdc5f 100644
--- a/crates/djls-templates/src/snapshots/djls_templates__parser__tests__django__parse_django_variable.snap
+++ b/crates/djls-templates/src/snapshots/djls_templates__parser__tests__django__parse_django_variable.snap
@@ -9,5 +9,3 @@ nodelist:
     span:
       - 3
       - 9
-line_offsets:
-  - 0
diff --git a/crates/djls-templates/src/snapshots/djls_templates__parser__tests__django__parse_django_variable_with_filter.snap b/crates/djls-templates/src/snapshots/djls_templates__parser__tests__django__parse_django_variable_with_filter.snap
index f13999f9..bba6ac50 100644
--- a/crates/djls-templates/src/snapshots/djls_templates__parser__tests__django__parse_django_variable_with_filter.snap
+++ b/crates/djls-templates/src/snapshots/djls_templates__parser__tests__django__parse_django_variable_with_filter.snap
@@ -10,5 +10,3 @@ nodelist:
     span:
       - 3
       - 15
-line_offsets:
-  - 0
diff --git a/crates/djls-templates/src/snapshots/djls_templates__parser__tests__django__parse_filter_chains.snap b/crates/djls-templates/src/snapshots/djls_templates__parser__tests__django__parse_filter_chains.snap
index d2edb38b..a4ea6c90 100644
--- a/crates/djls-templates/src/snapshots/djls_templates__parser__tests__django__parse_filter_chains.snap
+++ b/crates/djls-templates/src/snapshots/djls_templates__parser__tests__django__parse_filter_chains.snap
@@ -12,5 +12,3 @@ nodelist:
     span:
       - 3
       - 35
-line_offsets:
-  - 0
diff --git a/crates/djls-templates/src/snapshots/djls_templates__parser__tests__django__parse_mixed_content.snap b/crates/djls-templates/src/snapshots/djls_templates__parser__tests__django__parse_mixed_content.snap
index 31c5baac..a108299f 100644
--- a/crates/djls-templates/src/snapshots/djls_templates__parser__tests__django__parse_mixed_content.snap
+++ b/crates/djls-templates/src/snapshots/djls_templates__parser__tests__django__parse_mixed_content.snap
@@ -153,17 +153,3 @@ nodelist:
     span:
       - 359
       - 1
-line_offsets:
-  - 0
-  - 40
-  - 82
-  - 117
-  - 160
-  - 185
-  - 232
-  - 274
-  - 290
-  - 310
-  - 327
-  - 338
-  - 348
diff --git a/crates/djls-templates/src/snapshots/djls_templates__parser__tests__django__parse_nested_for_if.snap b/crates/djls-templates/src/snapshots/djls_templates__parser__tests__django__parse_nested_for_if.snap
index 67c6d518..08e07e93 100644
--- a/crates/djls-templates/src/snapshots/djls_templates__parser__tests__django__parse_nested_for_if.snap
+++ b/crates/djls-templates/src/snapshots/djls_templates__parser__tests__django__parse_nested_for_if.snap
@@ -37,5 +37,3 @@ nodelist:
     span:
       - 72
       - 6
-line_offsets:
-  - 0
diff --git a/crates/djls-templates/src/snapshots/djls_templates__parser__tests__errors__parse_error_recovery.snap b/crates/djls-templates/src/snapshots/djls_templates__parser__tests__errors__parse_error_recovery.snap
index 97efc3e6..5ccedc8c 100644
--- a/crates/djls-templates/src/snapshots/djls_templates__parser__tests__errors__parse_error_recovery.snap
+++ b/crates/djls-templates/src/snapshots/djls_templates__parser__tests__errors__parse_error_recovery.snap
@@ -13,16 +13,3 @@ nodelist:
       span:
         start: 28
         length: 15
-line_offsets:
-  - 0
-  - 24
-  - 44
-  - 54
-  - 106
-  - 145
-  - 159
-  - 219
-  - 251
-  - 287
-  - 308
-  - 341
diff --git a/crates/djls-templates/src/snapshots/djls_templates__parser__tests__errors__parse_unclosed_django_for.snap b/crates/djls-templates/src/snapshots/djls_templates__parser__tests__errors__parse_unclosed_django_for.snap
index c1e37d77..4b1ef566 100644
--- a/crates/djls-templates/src/snapshots/djls_templates__parser__tests__errors__parse_unclosed_django_for.snap
+++ b/crates/djls-templates/src/snapshots/djls_templates__parser__tests__errors__parse_unclosed_django_for.snap
@@ -18,5 +18,3 @@ nodelist:
     span:
       - 26
       - 9
-line_offsets:
-  - 0
diff --git a/crates/djls-templates/src/snapshots/djls_templates__parser__tests__errors__parse_unclosed_django_if.snap b/crates/djls-templates/src/snapshots/djls_templates__parser__tests__errors__parse_unclosed_django_if.snap
index fdc1c663..908c2a70 100644
--- a/crates/djls-templates/src/snapshots/djls_templates__parser__tests__errors__parse_unclosed_django_if.snap
+++ b/crates/djls-templates/src/snapshots/djls_templates__parser__tests__errors__parse_unclosed_django_if.snap
@@ -14,5 +14,3 @@ nodelist:
     span:
       - 30
       - 7
-line_offsets:
-  - 0
diff --git a/crates/djls-templates/src/snapshots/djls_templates__parser__tests__errors__parse_unclosed_html_tag.snap b/crates/djls-templates/src/snapshots/djls_templates__parser__tests__errors__parse_unclosed_html_tag.snap
index e208d4e0..b6ded27c 100644
--- a/crates/djls-templates/src/snapshots/djls_templates__parser__tests__errors__parse_unclosed_html_tag.snap
+++ b/crates/djls-templates/src/snapshots/djls_templates__parser__tests__errors__parse_unclosed_html_tag.snap
@@ -7,5 +7,3 @@ nodelist:
     span:
       - 0
       - 5
-line_offsets:
-  - 0
diff --git a/crates/djls-templates/src/snapshots/djls_templates__parser__tests__errors__parse_unclosed_script.snap b/crates/djls-templates/src/snapshots/djls_templates__parser__tests__errors__parse_unclosed_script.snap
index 2db81e2f..79983b6e 100644
--- a/crates/djls-templates/src/snapshots/djls_templates__parser__tests__errors__parse_unclosed_script.snap
+++ b/crates/djls-templates/src/snapshots/djls_templates__parser__tests__errors__parse_unclosed_script.snap
@@ -7,5 +7,3 @@ nodelist:
     span:
       - 0
       - 28
-line_offsets:
-  - 0
diff --git a/crates/djls-templates/src/snapshots/djls_templates__parser__tests__errors__parse_unclosed_style.snap b/crates/djls-templates/src/snapshots/djls_templates__parser__tests__errors__parse_unclosed_style.snap
index d8331cd3..01cbafec 100644
--- a/crates/djls-templates/src/snapshots/djls_templates__parser__tests__errors__parse_unclosed_style.snap
+++ b/crates/djls-templates/src/snapshots/djls_templates__parser__tests__errors__parse_unclosed_style.snap
@@ -7,5 +7,3 @@ nodelist:
     span:
       - 0
       - 27
-line_offsets:
-  - 0
diff --git a/crates/djls-templates/src/snapshots/djls_templates__parser__tests__full_templates__parse_full.snap b/crates/djls-templates/src/snapshots/djls_templates__parser__tests__full_templates__parse_full.snap
index 17d43474..65d1364b 100644
--- a/crates/djls-templates/src/snapshots/djls_templates__parser__tests__full_templates__parse_full.snap
+++ b/crates/djls-templates/src/snapshots/djls_templates__parser__tests__full_templates__parse_full.snap
@@ -80,34 +80,3 @@ nodelist:
     span:
       - 800
       - 34
-line_offsets:
-  - 0
-  - 16
-  - 23
-  - 34
-  - 66
-  - 97
-  - 134
-  - 151
-  - 191
-  - 215
-  - 241
-  - 270
-  - 298
-  - 313
-  - 331
-  - 343
-  - 354
-  - 386
-  - 451
-  - 494
-  - 532
-  - 605
-  - 644
-  - 683
-  - 710
-  - 748
-  - 776
-  - 800
-  - 815
-  - 827
diff --git a/crates/djls-templates/src/snapshots/djls_templates__parser__tests__html__parse_html_doctype.snap b/crates/djls-templates/src/snapshots/djls_templates__parser__tests__html__parse_html_doctype.snap
index 34e9fde1..d820d66d 100644
--- a/crates/djls-templates/src/snapshots/djls_templates__parser__tests__html__parse_html_doctype.snap
+++ b/crates/djls-templates/src/snapshots/djls_templates__parser__tests__html__parse_html_doctype.snap
@@ -7,5 +7,3 @@ nodelist:
     span:
       - 0
       - 15
-line_offsets:
-  - 0
diff --git a/crates/djls-templates/src/snapshots/djls_templates__parser__tests__html__parse_html_tag.snap b/crates/djls-templates/src/snapshots/djls_templates__parser__tests__html__parse_html_tag.snap
index 77effe41..e184abf4 100644
--- a/crates/djls-templates/src/snapshots/djls_templates__parser__tests__html__parse_html_tag.snap
+++ b/crates/djls-templates/src/snapshots/djls_templates__parser__tests__html__parse_html_tag.snap
@@ -7,5 +7,3 @@ nodelist:
     span:
       - 0
       - 34
-line_offsets:
-  - 0
diff --git a/crates/djls-templates/src/snapshots/djls_templates__parser__tests__html__parse_html_void.snap b/crates/djls-templates/src/snapshots/djls_templates__parser__tests__html__parse_html_void.snap
index d3f38660..8704a2dc 100644
--- a/crates/djls-templates/src/snapshots/djls_templates__parser__tests__html__parse_html_void.snap
+++ b/crates/djls-templates/src/snapshots/djls_templates__parser__tests__html__parse_html_void.snap
@@ -7,5 +7,3 @@ nodelist:
     span:
       - 0
       - 21
-line_offsets:
-  - 0
diff --git a/crates/djls-templates/src/snapshots/djls_templates__parser__tests__script__parse_script.snap b/crates/djls-templates/src/snapshots/djls_templates__parser__tests__script__parse_script.snap
index d29d0f75..952fc356 100644
--- a/crates/djls-templates/src/snapshots/djls_templates__parser__tests__script__parse_script.snap
+++ b/crates/djls-templates/src/snapshots/djls_templates__parser__tests__script__parse_script.snap
@@ -7,11 +7,3 @@ nodelist:
     span:
       - 0
       - 142
-line_offsets:
-  - 0
-  - 32
-  - 59
-  - 76
-  - 94
-  - 113
-  - 133
diff --git a/crates/djls-templates/src/snapshots/djls_templates__parser__tests__style__parse_style.snap b/crates/djls-templates/src/snapshots/djls_templates__parser__tests__style__parse_style.snap
index 110e8abb..0503b9bb 100644
--- a/crates/djls-templates/src/snapshots/djls_templates__parser__tests__style__parse_style.snap
+++ b/crates/djls-templates/src/snapshots/djls_templates__parser__tests__style__parse_style.snap
@@ -7,10 +7,3 @@ nodelist:
     span:
       - 0
       - 97
-line_offsets:
-  - 0
-  - 24
-  - 48
-  - 62
-  - 83
-  - 89
diff --git a/crates/djls-templates/src/snapshots/djls_templates__parser__tests__whitespace__parse_with_leading_whitespace.snap b/crates/djls-templates/src/snapshots/djls_templates__parser__tests__whitespace__parse_with_leading_whitespace.snap
index 98c26e78..a7b82987 100644
--- a/crates/djls-templates/src/snapshots/djls_templates__parser__tests__whitespace__parse_with_leading_whitespace.snap
+++ b/crates/djls-templates/src/snapshots/djls_templates__parser__tests__whitespace__parse_with_leading_whitespace.snap
@@ -7,5 +7,3 @@ nodelist:
     span:
       - 0
       - 10
-line_offsets:
-  - 0
diff --git a/crates/djls-templates/src/snapshots/djls_templates__parser__tests__whitespace__parse_with_leading_whitespace_newline.snap b/crates/djls-templates/src/snapshots/djls_templates__parser__tests__whitespace__parse_with_leading_whitespace_newline.snap
index 23fe703f..e06419d6 100644
--- a/crates/djls-templates/src/snapshots/djls_templates__parser__tests__whitespace__parse_with_leading_whitespace_newline.snap
+++ b/crates/djls-templates/src/snapshots/djls_templates__parser__tests__whitespace__parse_with_leading_whitespace_newline.snap
@@ -7,6 +7,3 @@ nodelist:
     span:
       - 1
       - 10
-line_offsets:
-  - 0
-  - 1
diff --git a/crates/djls-templates/src/snapshots/djls_templates__parser__tests__whitespace__parse_with_trailing_whitespace.snap b/crates/djls-templates/src/snapshots/djls_templates__parser__tests__whitespace__parse_with_trailing_whitespace.snap
index 98c26e78..a7b82987 100644
--- a/crates/djls-templates/src/snapshots/djls_templates__parser__tests__whitespace__parse_with_trailing_whitespace.snap
+++ b/crates/djls-templates/src/snapshots/djls_templates__parser__tests__whitespace__parse_with_trailing_whitespace.snap
@@ -7,5 +7,3 @@ nodelist:
     span:
       - 0
       - 10
-line_offsets:
-  - 0
diff --git a/crates/djls-templates/src/snapshots/djls_templates__parser__tests__whitespace__parse_with_trailing_whitespace_newline.snap b/crates/djls-templates/src/snapshots/djls_templates__parser__tests__whitespace__parse_with_trailing_whitespace_newline.snap
index 3c11edaf..828d8187 100644
--- a/crates/djls-templates/src/snapshots/djls_templates__parser__tests__whitespace__parse_with_trailing_whitespace_newline.snap
+++ b/crates/djls-templates/src/snapshots/djls_templates__parser__tests__whitespace__parse_with_trailing_whitespace_newline.snap
@@ -7,6 +7,3 @@ nodelist:
     span:
       - 0
       - 11
-line_offsets:
-  - 0
-  - 11
diff --git a/crates/djls-templates/src/tokens.rs b/crates/djls-templates/src/tokens.rs
index ab57ffc7..1d2dda8b 100644
--- a/crates/djls-templates/src/tokens.rs
+++ b/crates/djls-templates/src/tokens.rs
@@ -1,7 +1,6 @@
 use djls_source::Span;
 
 use crate::db::Db as TemplateDb;
-use crate::nodelist::LineOffsets;
 
 #[derive(Clone, Debug, PartialEq, Hash, salsa::Update)]
 pub enum Token<'db> {
@@ -162,9 +161,6 @@ pub struct TokenStream<'db> {
     #[tracked]
     #[returns(ref)]
     pub stream: Vec<Token<'db>>,
-    #[tracked]
-    #[returns(ref)]
-    pub line_offsets: LineOffsets,
 }
 
 impl<'db> TokenStream<'db> {
diff --git a/crates/djls-workspace/src/document.rs b/crates/djls-workspace/src/document.rs
index 5f22d332..2d538a26 100644
--- a/crates/djls-workspace/src/document.rs
+++ b/crates/djls-workspace/src/document.rs
@@ -5,6 +5,7 @@
 //! performance when handling frequent position-based operations like hover, completion,
 //! and diagnostics.
 
+use djls_source::LineIndex;
 use tower_lsp_server::lsp_types::Position;
 use tower_lsp_server::lsp_types::Range;
 
@@ -31,7 +32,7 @@ pub struct TextDocument {
 impl TextDocument {
     #[must_use]
     pub fn new(content: String, version: i32, language_id: LanguageId) -> Self {
-        let line_index = LineIndex::new(&content);
+        let line_index = LineIndex::from_text(&content);
         Self {
             content,
             version,
@@ -62,21 +63,23 @@ impl TextDocument {
 
     #[must_use]
     pub fn get_line(&self, line: u32) -> Option<String> {
-        let line_start = *self.line_index.line_starts.get(line as usize)?;
+        let line_start = *self.line_index.lines().get(line as usize)?;
         let line_end = self
             .line_index
-            .line_starts
+            .lines()
             .get(line as usize + 1)
             .copied()
-            .unwrap_or(self.line_index.length);
+            .unwrap_or_else(|| u32::try_from(self.content.len()).unwrap_or(u32::MAX));
 
         Some(self.content[line_start as usize..line_end as usize].to_string())
     }
 
     #[must_use]
     pub fn get_text_range(&self, range: Range, encoding: PositionEncoding) -> Option<String> {
-        let start_offset = self.line_index.offset(range.start, &self.content, encoding) as usize;
-        let end_offset = self.line_index.offset(range.end, &self.content, encoding) as usize;
+        let start_offset =
+            self.offset_for_position_with_text(range.start, &self.content, encoding)? as usize;
+        let end_offset =
+            self.offset_for_position_with_text(range.end, &self.content, encoding)? as usize;
 
         Some(self.content[start_offset..end_offset].to_string())
     }
@@ -95,35 +98,49 @@ impl TextDocument {
         // Fast path: single change without range = full document replacement
         if changes.len() == 1 && changes[0].range.is_none() {
             self.content.clone_from(&changes[0].text);
-            self.line_index = LineIndex::new(&self.content);
+            self.line_index = LineIndex::from_text(&self.content);
             self.version = version;
             return;
         }
 
         // Incremental path: apply changes to rebuild the document
+        // We need to track both content and line index together as we apply changes
         let mut new_content = self.content.clone();
+        let mut new_line_index = self.line_index.clone();
 
         for change in changes {
             if let Some(range) = change.range {
-                // Convert LSP range to byte offsets using the negotiated encoding
-                let start_offset =
-                    self.line_index.offset(range.start, &new_content, encoding) as usize;
-                let end_offset = self.line_index.offset(range.end, &new_content, encoding) as usize;
+                // Convert LSP range to byte offsets using the current line index
+                // that matches the current state of new_content
+                let start_offset = Self::position_to_offset_with(
+                    &new_line_index,
+                    range.start,
+                    &new_content,
+                    encoding,
+                )
+                .unwrap_or(0) as usize;
+                let end_offset = Self::position_to_offset_with(
+                    &new_line_index,
+                    range.end,
+                    &new_content,
+                    encoding,
+                )
+                .unwrap_or(0) as usize;
 
                 // Apply change
                 new_content.replace_range(start_offset..end_offset, &change.text);
-
-                // Rebuild line index after each change since positions shift
-                // This is necessary for subsequent changes to have correct offsets
-                self.line_index = LineIndex::new(&new_content);
             } else {
                 // No range means full replacement
                 new_content = change.text;
-                self.line_index = LineIndex::new(&new_content);
             }
+
+            // Rebuild line index to match the new content state
+            new_line_index = LineIndex::from_text(&new_content);
         }
 
+        // Update all document state at once
         self.content = new_content;
+        self.line_index = new_line_index;
         self.version = version;
     }
 
@@ -133,83 +150,43 @@ impl TextDocument {
         position: Position,
         encoding: PositionEncoding,
     ) -> Option<u32> {
-        Some(self.line_index.offset(position, &self.content, encoding))
-    }
-
-    #[must_use]
-    pub fn offset_to_position(&self, offset: u32) -> Position {
-        self.line_index.position(offset)
-    }
-}
-
-/// Pre-computed line start positions for efficient position/offset conversion.
-///
-/// Computing line positions on every lookup would be O(n) where n is the document size.
-/// By pre-computing during document creation/updates, we get O(1) lookups for line starts
-/// and O(log n) for position-to-offset conversions via binary search.
-#[derive(Clone, Debug)]
-pub struct LineIndex {
-    pub line_starts: Vec<u32>,
-    pub length: u32,
-    pub kind: IndexKind,
-}
-
-impl LineIndex {
-    #[must_use]
-    pub fn new(text: &str) -> Self {
-        let kind = if text.is_ascii() {
-            IndexKind::Ascii
-        } else {
-            IndexKind::Utf8
-        };
-
-        let mut line_starts = vec![0];
-        let mut pos_utf8 = 0;
-
-        for c in text.chars() {
-            pos_utf8 += u32::try_from(c.len_utf8()).unwrap_or(0);
-            if c == '\n' {
-                line_starts.push(pos_utf8);
-            }
-        }
-
-        Self {
-            line_starts,
-            length: pos_utf8,
-            kind,
-        }
+        self.offset_for_position_with_text(position, &self.content, encoding)
     }
 
-    /// Convert position to text offset using the specified encoding
+    /// Convert position to text offset using a specific line index.
     ///
-    /// Returns a valid offset, clamping out-of-bounds positions to document/line boundaries
-    pub fn offset(&self, position: Position, text: &str, encoding: PositionEncoding) -> u32 {
+    /// This is used during incremental updates where we have a temporary line index
+    /// that matches the temporary content state.
+    fn position_to_offset_with(
+        line_index: &LineIndex,
+        position: Position,
+        text: &str,
+        encoding: PositionEncoding,
+    ) -> Option<u32> {
         // Handle line bounds - if line > line_count, return document length
-        let line_start_utf8 = match self.line_starts.get(position.line as usize) {
+        let line_start_utf8 = match line_index.lines().get(position.line as usize) {
             Some(start) => *start,
-            None => return self.length, // Past end of document
+            None => return Some(u32::try_from(text.len()).unwrap_or(u32::MAX)), // Past end of document
         };
 
         if position.character == 0 {
-            return line_start_utf8;
+            return Some(line_start_utf8);
         }
 
-        let next_line_start = self
-            .line_starts
+        let next_line_start = line_index
+            .lines()
             .get(position.line as usize + 1)
             .copied()
-            .unwrap_or(self.length);
+            .unwrap_or_else(|| u32::try_from(text.len()).unwrap_or(u32::MAX));
 
-        let Some(line_text) = text.get(line_start_utf8 as usize..next_line_start as usize) else {
-            return line_start_utf8;
-        };
+        let line_text = text.get(line_start_utf8 as usize..next_line_start as usize)?;
 
         // Fast path optimization for ASCII text, all encodings are equivalent to byte offsets
-        if matches!(self.kind, IndexKind::Ascii) {
+        if line_text.is_ascii() {
             let char_offset = position
                 .character
                 .min(u32::try_from(line_text.len()).unwrap_or(u32::MAX));
-            return line_start_utf8 + char_offset;
+            return Some(line_start_utf8 + char_offset);
         }
 
         match encoding {
@@ -218,7 +195,7 @@ impl LineIndex {
                 let char_offset = position
                     .character
                     .min(u32::try_from(line_text.len()).unwrap_or(u32::MAX));
-                line_start_utf8 + char_offset
+                Some(line_start_utf8 + char_offset)
             }
             PositionEncoding::Utf16 => {
                 // UTF-16: count UTF-16 code units
@@ -234,7 +211,7 @@ impl LineIndex {
                 }
 
                 // If character position exceeds line length, clamp to line end
-                line_start_utf8 + utf8_pos
+                Some(line_start_utf8 + utf8_pos)
             }
             PositionEncoding::Utf32 => {
                 // UTF-32: count Unicode code points (characters)
@@ -248,35 +225,25 @@ impl LineIndex {
                 }
 
                 // If character position exceeds line length, clamp to line end
-                line_start_utf8 + utf8_pos
+                Some(line_start_utf8 + utf8_pos)
             }
         }
     }
 
-    #[allow(dead_code)]
-    #[must_use]
-    pub fn position(&self, offset: u32) -> Position {
-        let line = match self.line_starts.binary_search(&offset) {
-            Ok(line) => line,
-            Err(line) => line - 1,
-        };
-
-        let line_start = self.line_starts[line];
-        let character = offset - line_start;
-
-        Position::new(u32::try_from(line).unwrap_or(0), character)
+    /// Convert position to text offset using the specified encoding.
+    ///
+    /// Returns a valid offset, clamping out-of-bounds positions to document/line boundaries.
+    /// This method uses the document's current line index and content.
+    fn offset_for_position_with_text(
+        &self,
+        position: Position,
+        text: &str,
+        encoding: PositionEncoding,
+    ) -> Option<u32> {
+        Self::position_to_offset_with(&self.line_index, position, text, encoding)
     }
 }
 
-/// Index kind for ASCII optimization
-#[derive(Clone, Debug)]
-pub enum IndexKind {
-    /// Document contains only ASCII characters - enables fast path optimization
-    Ascii,
-    /// Document contains multi-byte UTF-8 characters - requires full UTF-8 processing
-    Utf8,
-}
-
 #[cfg(test)]
 mod tests {
     use tower_lsp_server::lsp_types::TextDocumentContentChangeEvent;
@@ -473,23 +440,4 @@ mod tests {
             .expect("Should get text range");
         assert_eq!(text, " 🌍");
     }
-
-    #[test]
-    fn test_line_index_utf16_conversion() {
-        let text = "Hello 🌍!\nWorld 行 test";
-        let line_index = LineIndex::new(text);
-
-        // Test position conversion with emoji on first line
-        let pos_emoji = Position::new(0, 7); // After emoji
-        let offset = line_index.offset(pos_emoji, text, PositionEncoding::Utf16);
-        assert_eq!(&text[(offset as usize)..=(offset as usize)], "!");
-
-        // Test position conversion with CJK on second line
-        // "World 行 test"
-        // W(1) o(1) r(1) l(1) d(1) space(1) 行(1) space(1) t(1)...
-        // Position after CJK character should be at UTF-16 position 7
-        let pos_cjk = Position::new(1, 7);
-        let offset_cjk = line_index.offset(pos_cjk, text, PositionEncoding::Utf16);
-        assert_eq!(&text[(offset_cjk as usize)..=(offset_cjk as usize)], " ");
-    }
 }
diff --git a/crates/djls-workspace/src/workspace.rs b/crates/djls-workspace/src/workspace.rs
index 371fddb7..500be313 100644
--- a/crates/djls-workspace/src/workspace.rs
+++ b/crates/djls-workspace/src/workspace.rs
@@ -99,9 +99,7 @@ impl Workspace {
     ) -> Option<WorkspaceFileEvent> {
         self.buffers.open(url.clone(), document);
         self.ensure_file_for_url(db, url).inspect(|event| {
-            if let WorkspaceFileEvent::Updated { file, .. } = event {
-                db.touch_file(*file);
-            }
+            db.touch_file(event.file());
         })
     }
 
@@ -153,6 +151,7 @@ impl Workspace {
     /// Touch the tracked file when the client saves the document.
     pub fn save_document(&self, db: &mut dyn Db, url: &Url) -> Option<WorkspaceFileEvent> {
         let path = paths::url_to_path(url)?;
+
         let event = self.track_file(db, path.as_path());
         db.touch_file(event.file());
         Some(event)
@@ -160,13 +159,15 @@ impl Workspace {
 
     /// Close a document, removing it from buffers and touching the tracked file.
     pub fn close_document(&mut self, db: &mut dyn Db, url: &Url) -> Option<TextDocument> {
+        let closed = self.buffers.close(url);
+
         if let Some(path) = paths::url_to_path(url) {
             if let Some(file) = self.files.get(&path) {
                 db.touch_file(*file);
             }
         }
 
-        self.buffers.close(url)
+        closed
     }
 
     /// Get a document from the buffer if it's open.
@@ -202,12 +203,12 @@ mod tests {
     use std::sync::Arc;
 
     use camino::Utf8Path;
+    use camino::Utf8PathBuf;
     use tempfile::tempdir;
     use url::Url;
 
     use super::*;
     use crate::encoding::PositionEncoding;
-    use crate::InMemoryFileSystem;
     use crate::LanguageId;
 
     #[salsa::db]
@@ -218,10 +219,10 @@ mod tests {
     }
 
     impl TestDb {
-        fn new() -> Self {
+        fn new(fs: Arc<dyn FileSystem>) -> Self {
             Self {
                 storage: salsa::Storage::default(),
-                fs: Arc::new(InMemoryFileSystem::new()),
+                fs,
             }
         }
     }
@@ -231,8 +232,8 @@ mod tests {
 
     #[salsa::db]
     impl djls_source::Db for TestDb {
-        fn read_file_source(&self, _path: &Utf8Path) -> std::io::Result<String> {
-            Ok(String::new())
+        fn read_file_source(&self, path: &Utf8Path) -> std::io::Result<String> {
+            self.fs.read_to_string(path)
         }
     }
 
@@ -246,7 +247,7 @@ mod tests {
     #[test]
     fn test_open_document() {
         let mut workspace = Workspace::new();
-        let mut db = TestDb::new();
+        let mut db = TestDb::new(workspace.file_system());
         let url = Url::parse("file:///test.py").unwrap();
 
         let document = TextDocument::new("print('hello')".to_string(), 1, LanguageId::Python);
@@ -264,7 +265,7 @@ mod tests {
     #[test]
     fn test_update_document() {
         let mut workspace = Workspace::new();
-        let mut db = TestDb::new();
+        let mut db = TestDb::new(workspace.file_system());
         let url = Url::parse("file:///test.py").unwrap();
 
         let document = TextDocument::new("initial".to_string(), 1, LanguageId::Python);
@@ -288,7 +289,7 @@ mod tests {
     #[test]
     fn test_close_document() {
         let mut workspace = Workspace::new();
-        let mut db = TestDb::new();
+        let mut db = TestDb::new(workspace.file_system());
         let url = Url::parse("file:///test.py").unwrap();
 
         let document = TextDocument::new("content".to_string(), 1, LanguageId::Python);
@@ -306,7 +307,7 @@ mod tests {
         std::fs::write(&file_path, "disk content").unwrap();
 
         let mut workspace = Workspace::new();
-        let mut db = TestDb::new();
+        let mut db = TestDb::new(workspace.file_system());
         let url = Url::from_file_path(&file_path).unwrap();
 
         let document = TextDocument::new("buffer content".to_string(), 1, LanguageId::Python);
@@ -318,4 +319,83 @@ mod tests {
             .unwrap();
         assert_eq!(content, "buffer content");
     }
+
+    #[test]
+    fn test_file_source_reads_from_buffer() {
+        let mut workspace = Workspace::new();
+        let mut db = TestDb::new(workspace.file_system());
+
+        let temp_dir = tempdir().unwrap();
+        let file_path = Utf8PathBuf::from_path_buf(temp_dir.path().join("template.html")).unwrap();
+        std::fs::write(file_path.as_std_path(), "disk template").unwrap();
+        let url = Url::from_file_path(file_path.as_std_path()).unwrap();
+
+        let document = TextDocument::new("line1\nline2".to_string(), 1, LanguageId::HtmlDjango);
+        let event = workspace
+            .open_document(&mut db, &url, document.clone())
+            .unwrap();
+        let file = event.file();
+
+        let source = file.source(&db);
+        assert_eq!(source.as_str(), document.content());
+
+        let line_index = file.line_index(&db);
+        assert_eq!(
+            line_index.to_line_col(djls_source::ByteOffset(0)),
+            djls_source::LineCol((0, 0))
+        );
+        assert_eq!(
+            line_index.to_line_col(djls_source::ByteOffset(6)),
+            djls_source::LineCol((1, 0))
+        );
+    }
+
+    #[test]
+    fn test_update_document_updates_source() {
+        let mut workspace = Workspace::new();
+        let mut db = TestDb::new(workspace.file_system());
+
+        let temp_dir = tempdir().unwrap();
+        let file_path = Utf8PathBuf::from_path_buf(temp_dir.path().join("buffer.py")).unwrap();
+        std::fs::write(file_path.as_std_path(), "disk").unwrap();
+        let url = Url::from_file_path(file_path.as_std_path()).unwrap();
+
+        let document = TextDocument::new("initial".to_string(), 1, LanguageId::Python);
+        let event = workspace.open_document(&mut db, &url, document).unwrap();
+        let file = event.file();
+
+        let changes = vec![TextDocumentContentChangeEvent {
+            range: None,
+            range_length: None,
+            text: "updated".to_string(),
+        }];
+        workspace
+            .update_document(&mut db, &url, changes, 2, PositionEncoding::Utf16)
+            .unwrap();
+
+        let source = file.source(&db);
+        assert_eq!(source.as_str(), "updated");
+    }
+
+    #[test]
+    fn test_close_document_reverts_to_disk() {
+        let mut workspace = Workspace::new();
+        let mut db = TestDb::new(workspace.file_system());
+
+        let temp_dir = tempdir().unwrap();
+        let file_path = Utf8PathBuf::from_path_buf(temp_dir.path().join("close.py")).unwrap();
+        std::fs::write(file_path.as_std_path(), "disk content").unwrap();
+        let url = Url::from_file_path(file_path.as_std_path()).unwrap();
+
+        let document = TextDocument::new("buffer content".to_string(), 1, LanguageId::Python);
+        let event = workspace.open_document(&mut db, &url, document).unwrap();
+        let file = event.file();
+
+        assert_eq!(file.source(&db).as_str(), "buffer content");
+
+        workspace.close_document(&mut db, &url);
+
+        let source_after = file.source(&db);
+        assert_eq!(source_after.as_str(), "disk content");
+    }
 }