f8-engine 0.2.0__tar.gz → 0.3.0__tar.gz

{f8_engine-0.2.0 → f8_engine-0.3.0}/Cargo.lock

@@ -37,7 +37,7 @@ checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f"
 
 [[package]]
 name = "f8-core"
-version = "0.2.0"
+version = "0.3.0"
 dependencies = [
  "indexmap",
  "petgraph",
@@ -50,7 +50,7 @@ dependencies = [
 
 [[package]]
 name = "f8-python"
-version = "0.2.0"
+version = "0.3.0"
 dependencies = [
  "f8-core",
  "pyo3",

{f8_engine-0.2.0 → f8_engine-0.3.0}/Cargo.toml

@@ -3,7 +3,7 @@ resolver = "3"
 members = ["crates/f8-core", "crates/f8-python"]
 
 [workspace.package]
-version = "0.2.0"
+version = "0.3.0"
 edition = "2024"
 description = "Financial modeling engine with compiler verification and live Excel formulas"
 authors = ["Michael (Chencheng) Hu, CFA"]

{f8_engine-0.2.0 → f8_engine-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: f8-engine
-Version: 0.2.0
+Version: 0.3.0
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Financial and Insurance Industry
@@ -26,7 +26,7 @@ Project-URL: Repository, https://github.com/mhcfa/f8
 
 # f8
 
-Financial modeling engine with compiler verification and live Excel formulas.
+Author, verify, and automate financial models with code and AI agents, compiled into live Excel workbooks.
 
 ## Who is f8 for
 
@@ -71,35 +71,36 @@ f8 guide --all   # streams the full DSL, function, and auditing guide to stdout
 ```python
 from f8 import Model
 
+years = ["2025A", "2026E", "2027E"]
+capex = {"2025A": 25.0, "2026E": 30.0, "2027E": 35.0}
+depr = {"2025A": -15.0, "2026E": -18.0, "2027E": -22.0}
+
 model = Model("Operating Forecast")
 sheet = model.add_sheet("Summary")
 
-pnl = sheet.add_table("PnL", "Three-Year Projection", "($ in millions)")
-pnl.add_column("item", role="descriptor", header="Line Item")
-for year in ["2025A", "2026E", "2027E"]:
-    pnl.add_column(year, header=year, format="currency", decimals=1)
+ppe = sheet.add_table("PPE", "PP&E Corkscrew Schedule", "($ in millions)")
+ppe.add_column("item", role="descriptor", header="Line Item")
+for year in years:
+    ppe.add_column(year, header=year, format="currency", decimals=1)
 
-pnl.add_row(
-    "revenue",
-    cells={"item": "Revenue", "2025A": 100.0},
-    expr='PnL["revenue", col.prev] * 1.25',
-)
-pnl.add_row(
-    "cogs",
-    cells={"item": "Cost of Revenue"},
-    expr='PnL["revenue", @col] * 0.30',
+ppe.add_row(
+    "beg_balance",
+    cells={"item": "Beginning Balance", "2025A": 100.0},
+    expr='PPE["end_balance", col.prev]',
 )
-pnl.add_row(
-    "gross_profit",
-    cells={"item": "Gross Profit"},
-    expr='PnL["revenue", @col] - PnL["cogs", @col]',
+ppe.add_row("capex", cells={"item": "Capital Expenditures", **capex})
+ppe.add_row("depreciation", cells={"item": "Depreciation", **depr})
+ppe.add_row(
+    "end_balance",
+    cells={"item": "Ending Balance"},
+    expr='SUM(PPE["beg_balance".."depreciation", @col])',
     style="total",
 )
 
 compiled = model.compile()
 
 # Audit evaluated values in memory (or pass view="formulas" to inspect lowered Excel formulas)
-print(compiled.table("PnL").to_markdown())
+print(compiled.table("PPE").to_markdown())
 
 # Emit a live .xlsx workbook with native Excel formulas and styling (you don't have to)
 compiled.save("forecast.xlsx")
@@ -108,11 +109,12 @@ compiled.save("forecast.xlsx")
 Output:
 
 ```markdown
-| Line Item        |     2025A |     2026E |      2027E |
-| :--------------- | --------: | --------: | ---------: |
-| Revenue          |    $100.0 |    $125.0 |     $156.2 |
-| Cost of Revenue  |     $30.0 |     $37.5 |      $46.9 |
-| **Gross Profit** | **$70.0** | **$87.5** | **$109.4** |
+| Line Item            |      2025A |      2026E |      2027E |
+| :------------------- | ---------: | ---------: | ---------: |
+| Beginning Balance    |     $100.0 |     $110.0 |     $122.0 |
+| Capital Expenditures |      $25.0 |      $30.0 |      $35.0 |
+| Depreciation         |    ($15.0) |    ($18.0) |    ($22.0) |
+| **Ending Balance**   | **$110.0** | **$122.0** | **$135.0** |
 ```
 
 ## Sample deliverables

{f8_engine-0.2.0 → f8_engine-0.3.0}/README.md

@@ -1,6 +1,6 @@
 # f8
 
-Financial modeling engine with compiler verification and live Excel formulas.
+Author, verify, and automate financial models with code and AI agents, compiled into live Excel workbooks.
 
 ## Who is f8 for
 
@@ -45,35 +45,36 @@ f8 guide --all   # streams the full DSL, function, and auditing guide to stdout
 ```python
 from f8 import Model
 
+years = ["2025A", "2026E", "2027E"]
+capex = {"2025A": 25.0, "2026E": 30.0, "2027E": 35.0}
+depr = {"2025A": -15.0, "2026E": -18.0, "2027E": -22.0}
+
 model = Model("Operating Forecast")
 sheet = model.add_sheet("Summary")
 
-pnl = sheet.add_table("PnL", "Three-Year Projection", "($ in millions)")
-pnl.add_column("item", role="descriptor", header="Line Item")
-for year in ["2025A", "2026E", "2027E"]:
-    pnl.add_column(year, header=year, format="currency", decimals=1)
+ppe = sheet.add_table("PPE", "PP&E Corkscrew Schedule", "($ in millions)")
+ppe.add_column("item", role="descriptor", header="Line Item")
+for year in years:
+    ppe.add_column(year, header=year, format="currency", decimals=1)
 
-pnl.add_row(
-    "revenue",
-    cells={"item": "Revenue", "2025A": 100.0},
-    expr='PnL["revenue", col.prev] * 1.25',
-)
-pnl.add_row(
-    "cogs",
-    cells={"item": "Cost of Revenue"},
-    expr='PnL["revenue", @col] * 0.30',
+ppe.add_row(
+    "beg_balance",
+    cells={"item": "Beginning Balance", "2025A": 100.0},
+    expr='PPE["end_balance", col.prev]',
 )
-pnl.add_row(
-    "gross_profit",
-    cells={"item": "Gross Profit"},
-    expr='PnL["revenue", @col] - PnL["cogs", @col]',
+ppe.add_row("capex", cells={"item": "Capital Expenditures", **capex})
+ppe.add_row("depreciation", cells={"item": "Depreciation", **depr})
+ppe.add_row(
+    "end_balance",
+    cells={"item": "Ending Balance"},
+    expr='SUM(PPE["beg_balance".."depreciation", @col])',
     style="total",
 )
 
 compiled = model.compile()
 
 # Audit evaluated values in memory (or pass view="formulas" to inspect lowered Excel formulas)
-print(compiled.table("PnL").to_markdown())
+print(compiled.table("PPE").to_markdown())
 
 # Emit a live .xlsx workbook with native Excel formulas and styling (you don't have to)
 compiled.save("forecast.xlsx")
@@ -82,11 +83,12 @@ compiled.save("forecast.xlsx")
 Output:
 
 ```markdown
-| Line Item        |     2025A |     2026E |      2027E |
-| :--------------- | --------: | --------: | ---------: |
-| Revenue          |    $100.0 |    $125.0 |     $156.2 |
-| Cost of Revenue  |     $30.0 |     $37.5 |      $46.9 |
-| **Gross Profit** | **$70.0** | **$87.5** | **$109.4** |
+| Line Item            |      2025A |      2026E |      2027E |
+| :------------------- | ---------: | ---------: | ---------: |
+| Beginning Balance    |     $100.0 |     $110.0 |     $122.0 |
+| Capital Expenditures |      $25.0 |      $30.0 |      $35.0 |
+| Depreciation         |    ($15.0) |    ($18.0) |    ($22.0) |
+| **Ending Balance**   | **$110.0** | **$122.0** | **$135.0** |
 ```
 
 ## Sample deliverables

{f8_engine-0.2.0 → f8_engine-0.3.0}/crates/f8-core/src/compiler/eval/model.rs

@@ -144,6 +144,7 @@ mod tests {
             subtitle: None,
             currency: None,
             collapsible: false,
+            placement: crate::model::table::PlacementSpec::default(),
             columns: vec![
                 ColumnSpec::new("c1"),
                 ColumnSpec::new("c2"),

{f8_engine-0.2.0 → f8_engine-0.3.0}/crates/f8-core/src/compiler/graph/resolve.rs

@@ -4,7 +4,9 @@ use super::error::ResolveError;
 use crate::compiler::ir::cell::{CellGrid, CellPayload};
 use crate::compiler::ir::id::CellId;
 use crate::compiler::ir::symbol::{SymbolTable, TableMetadata};
-use crate::expr::ast::{ColSelector, Expr, RelativeOffset, RowSelector, TableRef};
+use crate::expr::ast::{
+    ColEndpoint, ColSelector, Expr, RelativeOffset, RowEndpoint, RowSelector, TableRef,
+};
 use crate::model::id::{ColId, RowId};
 
 /// Recursively collects all table references present within a formula expression AST.
@@ -32,6 +34,70 @@ fn collect_refs_recursive<'a>(expr: &'a Expr, out: &mut Vec<&'a TableRef>) {
     }
 }
 
+/// Resolves an explicit row key to its 0-based index and canonical [`RowId`] in `target_table.rows`.
+fn resolve_row_key<'a>(
+    origin: &CellId,
+    target_table: &'a TableMetadata,
+    row_id: &RowId,
+) -> Result<(usize, &'a RowId), ResolveError> {
+    target_table.rows.get_full(row_id).ok_or_else(|| {
+        ResolveError::unknown_row(origin, target_table.table_id.clone(), row_id.clone())
+    })
+}
+
+/// Resolves a relative row offset (`row.prev`, `row.next`) to its 0-based index and [`RowId`] in `target_table.rows`.
+fn resolve_row_offset<'a>(
+    origin: &CellId,
+    target_table: &'a TableMetadata,
+    origin_table: &TableMetadata,
+    offset: RelativeOffset,
+) -> Result<(usize, &'a RowId), ResolveError> {
+    let origin_idx = origin_table.rows.get_index_of(&origin.row).ok_or_else(|| {
+        ResolveError::unknown_row(origin, origin_table.table_id.clone(), origin.row.clone())
+    })?;
+
+    let signed_offset = match offset {
+        RelativeOffset::Prev(k) => -(k as i32),
+        RelativeOffset::Next(k) => k as i32,
+    };
+    let target_idx = match offset {
+        RelativeOffset::Prev(k) => origin_idx
+            .checked_sub(k as usize)
+            .ok_or_else(|| ResolveError::temporal_offset_out_of_bounds(origin, signed_offset))?,
+        RelativeOffset::Next(k) => origin_idx
+            .checked_add(k as usize)
+            .ok_or_else(|| ResolveError::temporal_offset_out_of_bounds(origin, signed_offset))?,
+    };
+
+    let target_row_id = origin_table
+        .rows
+        .get_index(target_idx)
+        .ok_or_else(|| ResolveError::temporal_offset_out_of_bounds(origin, signed_offset))?;
+    resolve_row_key(origin, target_table, target_row_id)
+}
+
+/// Resolves a single row endpoint to its 0-based index and canonical [`RowId`] in `target_table.rows`.
+fn resolve_row_endpoint<'a>(
+    origin: &CellId,
+    target_table: &'a TableMetadata,
+    origin_table: &TableMetadata,
+    endpoint: &RowEndpoint,
+) -> Result<(usize, &'a RowId), ResolveError> {
+    match endpoint {
+        RowEndpoint::Active => target_table.rows.get_full(&origin.row).ok_or_else(|| {
+            ResolveError::active_row_mismatch(
+                origin,
+                target_table.table_id.clone(),
+                origin.row.clone(),
+            )
+        }),
+        RowEndpoint::Key(row_id) => resolve_row_key(origin, target_table, row_id),
+        RowEndpoint::Offset(offset) => {
+            resolve_row_offset(origin, target_table, origin_table, *offset)
+        }
+    }
+}
+
 /// Resolves a row selector against target and origin table metadata.
 pub(crate) fn resolve_row_selector(
     origin: &CellId,
@@ -41,110 +107,134 @@ pub(crate) fn resolve_row_selector(
 ) -> Result<Vec<RowId>, ResolveError> {
     match row_selector {
         RowSelector::Active => {
-            if !target_table.rows.contains(&origin.row) {
-                return Err(ResolveError::active_row_mismatch(
-                    origin,
-                    target_table.table_id.clone(),
-                    origin.row.clone(),
-                ));
-            }
-            Ok(vec![origin.row.clone()])
+            let (_, id) =
+                resolve_row_endpoint(origin, target_table, origin_table, &RowEndpoint::Active)?;
+            Ok(vec![id.clone()])
         }
         RowSelector::Key(row_id) => {
-            if !target_table.rows.contains(row_id) {
-                return Err(ResolveError::unknown_row(
-                    origin,
-                    target_table.table_id.clone(),
-                    row_id.clone(),
-                ));
-            }
-            Ok(vec![row_id.clone()])
+            let (_, id) = resolve_row_key(origin, target_table, row_id)?;
+            Ok(vec![id.clone()])
+        }
+        RowSelector::Offset(offset) => {
+            let (_, id) = resolve_row_offset(origin, target_table, origin_table, *offset)?;
+            Ok(vec![id.clone()])
         }
         RowSelector::Range(start, end) => {
-            let start_idx = target_table.rows.get_index_of(start).ok_or_else(|| {
-                ResolveError::unknown_row(origin, target_table.table_id.clone(), start.clone())
-            })?;
-            let end_idx = target_table.rows.get_index_of(end).ok_or_else(|| {
-                ResolveError::unknown_row(origin, target_table.table_id.clone(), end.clone())
-            })?;
+            let (start_idx, start_id) =
+                resolve_row_endpoint(origin, target_table, origin_table, start)?;
+            let (end_idx, end_id) = resolve_row_endpoint(origin, target_table, origin_table, end)?;
 
             if start_idx > end_idx {
                 return Err(ResolveError::inverted_range(
                     origin,
                     target_table.table_id.clone(),
-                    start.to_string(),
-                    end.to_string(),
+                    start_id.to_string(),
+                    end_id.to_string(),
                 ));
             }
 
-            Ok(target_table.rows[start_idx..=end_idx]
-                .iter()
-                .cloned()
-                .collect())
-        }
-        RowSelector::Offset(offset) => match offset {
-            RelativeOffset::Prev(k) => {
-                let origin_idx = origin_table.rows.get_index_of(&origin.row).ok_or_else(|| {
-                    ResolveError::unknown_row(
+            let slice = target_table
+                .rows
+                .get_range(start_idx..=end_idx)
+                .ok_or_else(|| {
+                    ResolveError::inverted_range(
                         origin,
-                        origin_table.table_id.clone(),
-                        origin.row.clone(),
+                        target_table.table_id.clone(),
+                        start_id.to_string(),
+                        end_id.to_string(),
                     )
                 })?;
 
-                let k_usize = *k as usize;
-                if origin_idx < k_usize {
-                    return Err(ResolveError::temporal_offset_out_of_bounds(
-                        origin,
-                        -(*k as i32),
-                    ));
-                }
+            Ok(slice.iter().cloned().collect())
+        }
+    }
+}
 
-                let target_idx = origin_idx - k_usize;
-                let target_row_id = origin_table.rows[target_idx].clone();
+/// Resolves an explicit column key to its 0-based index and canonical [`ColId`] in `target_table.columns`.
+fn resolve_col_key<'a>(
+    origin: &CellId,
+    target_table: &'a TableMetadata,
+    col_id: &ColId,
+) -> Result<(usize, &'a ColId), ResolveError> {
+    let idx = target_table
+        .column_index
+        .get(col_id)
+        .copied()
+        .ok_or_else(|| {
+            ResolveError::unknown_column(origin, target_table.table_id.clone(), col_id.clone())
+        })?;
+    let col = target_table.columns.get(idx).ok_or_else(|| {
+        ResolveError::unknown_column(origin, target_table.table_id.clone(), col_id.clone())
+    })?;
+    Ok((idx, &col.id))
+}
 
-                if !target_table.rows.contains(&target_row_id) {
-                    return Err(ResolveError::unknown_row(
-                        origin,
-                        target_table.table_id.clone(),
-                        target_row_id,
-                    ));
-                }
+/// Resolves a relative column offset (`col.prev`, `col.next`) to its 0-based index and [`ColId`] in `target_table.columns`.
+fn resolve_col_offset<'a>(
+    origin: &CellId,
+    target_table: &'a TableMetadata,
+    origin_table: &TableMetadata,
+    offset: RelativeOffset,
+) -> Result<(usize, &'a ColId), ResolveError> {
+    let signed_offset = match offset {
+        RelativeOffset::Prev(k) => -(k as i32),
+        RelativeOffset::Next(k) => k as i32,
+    };
+    let origin_measure_idx = origin_table
+        .measure_columns
+        .iter()
+        .position(|c| c == &origin.col)
+        .ok_or_else(|| ResolveError::temporal_offset_out_of_bounds(origin, signed_offset))?;
+
+    let target_measure_idx = match offset {
+        RelativeOffset::Prev(k) => origin_measure_idx
+            .checked_sub(k as usize)
+            .ok_or_else(|| ResolveError::temporal_offset_out_of_bounds(origin, signed_offset))?,
+        RelativeOffset::Next(k) => origin_measure_idx
+            .checked_add(k as usize)
+            .ok_or_else(|| ResolveError::temporal_offset_out_of_bounds(origin, signed_offset))?,
+    };
+
+    let target_col_id = origin_table
+        .measure_columns
+        .get(target_measure_idx)
+        .ok_or_else(|| ResolveError::temporal_offset_out_of_bounds(origin, signed_offset))?;
+    resolve_col_key(origin, target_table, target_col_id)
+}
 
-                Ok(vec![target_row_id])
-            }
-            RelativeOffset::Next(k) => {
-                let origin_idx = origin_table.rows.get_index_of(&origin.row).ok_or_else(|| {
-                    ResolveError::unknown_row(
+/// Resolves a single column endpoint to its 0-based index and canonical [`ColId`] in `target_table.columns`.
+fn resolve_col_endpoint<'a>(
+    origin: &CellId,
+    target_table: &'a TableMetadata,
+    origin_table: &TableMetadata,
+    endpoint: &ColEndpoint,
+) -> Result<(usize, &'a ColId), ResolveError> {
+    match endpoint {
+        ColEndpoint::Active => {
+            let idx = target_table
+                .column_index
+                .get(&origin.col)
+                .copied()
+                .ok_or_else(|| {
+                    ResolveError::active_column_mismatch(
                         origin,
-                        origin_table.table_id.clone(),
-                        origin.row.clone(),
+                        target_table.table_id.clone(),
+                        origin.col.clone(),
                     )
                 })?;
-
-                let k_usize = *k as usize;
-                let target_idx = match origin_idx.checked_add(k_usize) {
-                    Some(idx) if idx < origin_table.rows.len() => idx,
-                    _ => {
-                        return Err(ResolveError::temporal_offset_out_of_bounds(
-                            origin, *k as i32,
-                        ));
-                    }
-                };
-
-                let target_row_id = origin_table.rows[target_idx].clone();
-
-                if !target_table.rows.contains(&target_row_id) {
-                    return Err(ResolveError::unknown_row(
-                        origin,
-                        target_table.table_id.clone(),
-                        target_row_id,
-                    ));
-                }
-
-                Ok(vec![target_row_id])
-            }
-        },
+            let col = target_table.columns.get(idx).ok_or_else(|| {
+                ResolveError::active_column_mismatch(
+                    origin,
+                    target_table.table_id.clone(),
+                    origin.col.clone(),
+                )
+            })?;
+            Ok((idx, &col.id))
+        }
+        ColEndpoint::Key(col_id) => resolve_col_key(origin, target_table, col_id),
+        ColEndpoint::Offset(offset) => {
+            resolve_col_offset(origin, target_table, origin_table, *offset)
+        }
     }
 }
 
@@ -157,119 +247,46 @@ pub(crate) fn resolve_col_selector(
 ) -> Result<Vec<ColId>, ResolveError> {
     match col_selector {
         ColSelector::Active => {
-            if !target_table.column_index.contains_key(&origin.col) {
-                return Err(ResolveError::active_column_mismatch(
-                    origin,
-                    target_table.table_id.clone(),
-                    origin.col.clone(),
-                ));
-            }
-            Ok(vec![origin.col.clone()])
+            let (_, id) =
+                resolve_col_endpoint(origin, target_table, origin_table, &ColEndpoint::Active)?;
+            Ok(vec![id.clone()])
         }
         ColSelector::Key(col_id) => {
-            if !target_table.column_index.contains_key(col_id) {
-                return Err(ResolveError::unknown_column(
-                    origin,
-                    target_table.table_id.clone(),
-                    col_id.clone(),
-                ));
-            }
-            Ok(vec![col_id.clone()])
+            let (_, id) = resolve_col_key(origin, target_table, col_id)?;
+            Ok(vec![id.clone()])
+        }
+        ColSelector::Offset(offset) => {
+            let (_, id) = resolve_col_offset(origin, target_table, origin_table, *offset)?;
+            Ok(vec![id.clone()])
         }
         ColSelector::Range(start, end) => {
-            let start_idx = target_table
-                .column_index
-                .get(start)
-                .copied()
-                .ok_or_else(|| {
-                    ResolveError::unknown_column(
-                        origin,
-                        target_table.table_id.clone(),
-                        start.clone(),
-                    )
-                })?;
-            let end_idx = target_table.column_index.get(end).copied().ok_or_else(|| {
-                ResolveError::unknown_column(origin, target_table.table_id.clone(), end.clone())
-            })?;
+            let (start_idx, start_id) =
+                resolve_col_endpoint(origin, target_table, origin_table, start)?;
+            let (end_idx, end_id) = resolve_col_endpoint(origin, target_table, origin_table, end)?;
 
             if start_idx > end_idx {
                 return Err(ResolveError::inverted_range(
                     origin,
                     target_table.table_id.clone(),
-                    start.to_string(),
-                    end.to_string(),
+                    start_id.to_string(),
+                    end_id.to_string(),
                 ));
             }
 
-            let cols = target_table.columns[start_idx..=end_idx]
-                .iter()
-                .map(|c| c.id.clone())
-                .collect();
-            Ok(cols)
-        }
-        ColSelector::Offset(offset) => match offset {
-            RelativeOffset::Prev(k) => {
-                let origin_measure_idx = origin_table
-                    .measure_columns
-                    .iter()
-                    .position(|c| c == &origin.col)
-                    .ok_or_else(|| {
-                        ResolveError::temporal_offset_out_of_bounds(origin, -(*k as i32))
-                    })?;
-
-                let k_usize = *k as usize;
-                if origin_measure_idx < k_usize {
-                    return Err(ResolveError::temporal_offset_out_of_bounds(
-                        origin,
-                        -(*k as i32),
-                    ));
-                }
-
-                let target_measure_idx = origin_measure_idx - k_usize;
-                let target_col_id = origin_table.measure_columns[target_measure_idx].clone();
-
-                if !target_table.column_index.contains_key(&target_col_id) {
-                    return Err(ResolveError::unknown_column(
-                        origin,
-                        target_table.table_id.clone(),
-                        target_col_id,
-                    ));
-                }
-
-                Ok(vec![target_col_id])
-            }
-            RelativeOffset::Next(k) => {
-                let origin_measure_idx = origin_table
-                    .measure_columns
-                    .iter()
-                    .position(|c| c == &origin.col)
-                    .ok_or_else(|| {
-                        ResolveError::temporal_offset_out_of_bounds(origin, *k as i32)
-                    })?;
-
-                let k_usize = *k as usize;
-                let target_measure_idx = match origin_measure_idx.checked_add(k_usize) {
-                    Some(idx) if idx < origin_table.measure_columns.len() => idx,
-                    _ => {
-                        return Err(ResolveError::temporal_offset_out_of_bounds(
-                            origin, *k as i32,
-                        ));
-                    }
-                };
-
-                let target_col_id = origin_table.measure_columns[target_measure_idx].clone();
-
-                if !target_table.column_index.contains_key(&target_col_id) {
-                    return Err(ResolveError::unknown_column(
+            let slice = target_table
+                .columns
+                .get(start_idx..=end_idx)
+                .ok_or_else(|| {
+                    ResolveError::inverted_range(
                         origin,
                         target_table.table_id.clone(),
-                        target_col_id,
-                    ));
-                }
+                        start_id.to_string(),
+                        end_id.to_string(),
+                    )
+                })?;
 
-                Ok(vec![target_col_id])
-            }
-        },
+            Ok(slice.iter().map(|c| c.id.clone()).collect())
+        }
     }
 }
 
@@ -425,6 +442,7 @@ mod tests {
             subtitle: None,
             currency: None,
             collapsible: false,
+            placement: crate::model::table::PlacementSpec::default(),
             columns: vec![ColumnSpec::new("2024E")],
             rows: vec![RowSpec::new("rev")],
         };