release: v0.3.0

Bump all package versions to 0.3.0 and update documentation.

Changes:
- CHANGELOG.md: Add v0.3.0 release notes with all new features
- Cargo.toml: Bump workspace version and dependencies to 0.3.0
- Package versions: core, react, wasm packages updated to 0.3.0
- docs/api_schema.json: Regenerate schema for new TemplateConfig types
- READMEs: Document dbt/Jinja templating, template CLI flags, expanded dialect support

Author: melonamin

CHANGELOG.md

@@ -7,23 +7,69 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.3.0] - 2026-01-22
+
 ### Added
 
 #### Core Engine (flowscope-core)
+- **Jinja/dbt templating support**: MiniJinja-based preprocessing for dbt projects
+  - Built-in dbt macros: `ref()`, `source()`, `config()`, `var()`, `is_incremental()`
+  - RelationEmulator for dbt Relation object attribute access (`.schema`, `.identifier`)
+  - `this` global variable and `execute` flag for templates
+  - Custom macro passthrough stubs for graceful handling
+- **COPY statement lineage**: Track source/target tables in COPY/COPY INTO (PostgreSQL, Snowflake)
+- **ALTER TABLE RENAME lineage**: Track table renames as dataflow edges
+- **UNLOAD statement lineage**: Track source tables from Redshift UNLOAD statements
+- **Lateral column alias support**: Resolve aliases in same SELECT list (BigQuery, Snowflake, DuckDB, etc.)
+- **Backward column inference**: Infer columns for SELECT * without schema from downstream usage
 - Type inference for SQL expressions with comprehensive type checking
 - New `TYPE_MISMATCH` warning code for detecting incompatible type comparisons and operations
 - Schema-aware column type lookup - column references now resolve types from provided schema metadata
 - CTE column type propagation to outer queries
 - Dialect-aware type compatibility rules (e.g., Boolean/Integer comparison allowed in MySQL but not PostgreSQL)
 - NULL comparison anti-pattern detection (`= NULL` warns to use `IS NULL` instead)
 
+#### Completion API
+- Smart function completions with signature metadata (params, return types, categories)
+- Context-aware scoring: boost aggregates in GROUP BY, window functions in OVER clauses
+- Lateral column alias extraction with proper scope isolation
+- Type-aware column scoring in comparison contexts
+- Dialect-aware keyword parsing using sqlparser tokenizer
+- CASE expression type inference from THEN/ELSE branches
+
+#### CLI (flowscope-cli)
+- `--template jinja|dbt` flag for templated SQL preprocessing
+- `--template-var KEY=VALUE` for template variable injection
+- `--metadata-url` for live database schema introspection (PostgreSQL, MySQL, SQLite)
+- `--metadata-schema` for schema filtering during introspection
+
+#### React Package (@pondpilot/flowscope-react)
+- Web workers for graph/matrix/layout computations (improved UI responsiveness)
+- LayoutProgressIndicator component for visual layout feedback
+- Debug flags (GRAPH_DEBUG, LAYOUT_DEBUG) for performance diagnostics
+
+#### Web App (app/)
+- Template mode selector for dbt/Jinja SQL preprocessing in the toolbar
+- Issue-to-editor navigation: click issues to jump to source location
+- Issues tab filtering: filter by severity, error code, and file
+- Stats popover: complexity dots trigger dropdown with table/column/join counts
+- Clear analysis cache option in project menu
+- Bundled "dbt Jaffle Shop" demo project showcasing ref/source/config/var
+
 ### Changed
 
 #### Core Engine (flowscope-core)
 - Unified type system: `CanonicalType` replaces internal `SqlType` enum with broader coverage (Time, Binary, Json, Array)
 - `OutputColumn.data_type` now populated with inferred types for SELECT expressions
 - Type checking now accepts dialect parameter for dialect-specific rules
 
+### Fixed
+
+#### Core Engine (flowscope-core)
+- dbt model cross-statement linking with proper case normalization for Snowflake
+- DDL-seeded schema preservation (schemas no longer overwritten by later queries)
+- UTF-8 safety in `should_show_for_cursor` when cursor offset is mid-character
+
 ### Known Limitations
 
 #### Type Inference

Cargo.toml

@@ -8,15 +8,15 @@ members = [
 resolver = "2"
 
 [workspace.package]
-version = "0.2.0"
+version = "0.3.0"
 authors = ["PondPilot Team"]
 edition = "2021"
 license = "Apache-2.0"
 repository = "https://github.com/pondpilot/flowscope"
 
 [workspace.dependencies]
-flowscope-core = { version = "0.2.0", path = "crates/flowscope-core", default-features = false }
-flowscope-export = { version = "0.2.0", path = "crates/flowscope-export", default-features = false }
+flowscope-core = { version = "0.3.0", path = "crates/flowscope-core", default-features = false }
+flowscope-export = { version = "0.3.0", path = "crates/flowscope-export", default-features = false }
 sqlparser = "0.59"
 serde = { version = "1.0", features = ["derive", "rc"] }
 serde_json = "1.0"

README.md

@@ -30,6 +30,7 @@ Features:
 - Drag and drop SQL files or paste queries directly
 - Interactive lineage graph with table and column-level views
 - Multi-file project support with schema DDL
+- dbt/Jinja template preprocessing for dbt models
 - Export to Mermaid, JSON, CSV, Excel, or HTML reports
 - All processing happens in your browser — your SQL never leaves your machine
 
@@ -67,7 +68,8 @@ See [CLI documentation](crates/flowscope-cli/README.md) for all options.
 ## Key Features
 
 - Client-side analysis with zero data egress
-- Multi-dialect coverage (PostgreSQL, Snowflake, BigQuery, DuckdDB and more)
+- Multi-dialect coverage (PostgreSQL, Snowflake, BigQuery, DuckDB, Redshift, and more)
+- dbt and Jinja templating support with built-in macro stubs (`ref()`, `source()`, `var()`)
 - Table and column lineage with schema-aware wildcard expansion
 - Structured diagnostics with spans for precise highlighting
 - Completion API for SQL authoring workflows

crates/flowscope-cli/README.md

@@ -62,6 +62,9 @@ Options:
                            (e.g., postgres://user:pass@host/db, mysql://..., sqlite://...)
       --metadata-schema <SCHEMA>
                            Schema name to filter when using --metadata-url
+      --template <MODE>    Template preprocessing mode [possible values: jinja, dbt]
+      --template-var <KEY=VALUE>
+                           Template variable (can be repeated)
   -o, --output <FILE>      Output file (defaults to stdout)
       --project-name <PROJECT_NAME>
                            Project name used for default export filenames [default: lineage]
@@ -70,7 +73,7 @@ Options:
   -v, --view <VIEW>        Graph detail level for mermaid output [default: table]
                            [possible values: script, table, column, hybrid]
   -q, --quiet              Suppress warnings on stderr
-      --compact            Compact JSON output (no pretty-printing)
+  -c, --compact            Compact JSON output (no pretty-printing)
   -h, --help               Print help
   -V, --version            Print version
 ```
@@ -132,3 +135,27 @@ This feature requires the `metadata-provider` feature flag (enabled by default).
 ```bash
 cargo build -p flowscope-cli --no-default-features
 ```
+
+### dbt and Jinja Templating
+
+FlowScope can preprocess SQL files that use Jinja or dbt-style templating before analysis. This enables lineage extraction from dbt models without running dbt itself.
+
+```bash
+# Analyze a dbt model with ref() and source() macros
+flowscope --template dbt models/orders.sql
+
+# Pass variables to templates
+flowscope --template dbt --template-var target_schema=prod models/*.sql
+
+# Plain Jinja templating (strict mode - undefined variables cause errors)
+flowscope --template jinja --template-var env=production query.sql
+```
+
+**dbt mode** includes stub implementations of common macros:
+- `ref('model')` / `ref('project', 'model')` - model references
+- `source('schema', 'table')` - source table references
+- `config(...)` - model configuration (returns empty string)
+- `var('name')` / `var('name', 'default')` - variable access
+- `is_incremental()` - always returns false for static analysis
+
+Variables passed via `--template-var` are accessible in dbt mode through `var()` and in Jinja mode directly as template variables.

crates/flowscope-core/README.md

@@ -8,12 +8,15 @@ Core SQL lineage analysis engine for FlowScope.
 
 ## Features
 
-- **Multi-Dialect Parsing:** Built on `sqlparser-rs`, supporting PostgreSQL, Snowflake, BigQuery, and Generic ANSI SQL.
+- **Multi-Dialect Parsing:** Built on `sqlparser-rs`, supporting PostgreSQL, Snowflake, BigQuery, DuckDB, Redshift, MySQL, SQLite, Databricks, ClickHouse, and Generic ANSI SQL.
 - **Deep Lineage Extraction:**
-  - Table-level dependencies (SELECT, INSERT, UPDATE, MERGE, etc.)
+  - Table-level dependencies (SELECT, INSERT, UPDATE, MERGE, COPY, UNLOAD, etc.)
   - Column-level data flow (including transformations)
-- **Complex SQL Support:** Handles CTEs (Common Table Expressions), Subqueries, Joins, Unions, and Window Functions.
-- **Schema Awareness:** Can utilize provided schema metadata to validate column references and resolve wildcards (`SELECT *`).
+  - Cross-statement lineage tracking (CREATE TABLE AS, INSERT INTO ... SELECT)
+- **dbt/Jinja Templating:** Preprocess SQL with Jinja or dbt-style templates before analysis, with built-in stubs for `ref()`, `source()`, `config()`, `var()`, and `is_incremental()`.
+- **Complex SQL Support:** Handles CTEs (Common Table Expressions), Subqueries, Joins, Unions, Window Functions, and lateral column aliases.
+- **Schema Awareness:** Utilize provided schema metadata to validate column references and resolve wildcards (`SELECT *`).
+- **Type Inference:** Infer expression types with dialect-aware type compatibility checking.
 - **Diagnostics:** Returns structured issues (errors, warnings) with source spans for precise highlighting.
 
 ## Structure