interlaced 2.8.2__tar.gz → 2.8.3__tar.gz

{interlaced-2.8.2/src/interlaced.egg-info → interlaced-2.8.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: interlaced
-Version: 2.8.2
+Version: 2.8.3
 Summary: Python and SQL models in one DAG. Transformation, orchestration and durable streaming in one process, on DuckDB and Postgres.
 Author-email: Mark <mark@interlace.sh>
 License-Expression: MIT
@@ -110,12 +110,11 @@ pip install 'interlaced[service]'   # the CLI + daemon; core CLI only: pip insta
 # more extras: [adbc] postgres/redshift · [spark] · [polars] · [all]
 ```
 
-> **Platforms.** Developed on Linux; CI runs Linux only. Nothing in the codebase is
-> platform-specific — no `fork`, no signal handling, no POSIX-only calls, no shelling out — and
-> every dependency ships macOS and Windows wheels, so both are expected to work. But
-> **neither is tested**, so treat them as unverified rather than supported. If you run interlace
-> on macOS or Windows, please open an issue either way; that is the fastest route to changing
-> this paragraph.
+> **Platforms.** Developed on Linux. CI runs the full suite on Linux, and a macOS job runs
+> `interlace init` plus `apply` on the quickstart. Nothing in the codebase is platform-specific —
+> no `fork`, no signal handling, no POSIX-only calls, no shelling out — and every dependency
+> ships macOS and Windows wheels. Windows is still unverified. If you run interlace on Windows,
+> please open an issue either way; that is the fastest route to changing this paragraph.
 
 ## Sixty seconds
 

{interlaced-2.8.2 → interlaced-2.8.3}/README.md

@@ -42,12 +42,11 @@ pip install 'interlaced[service]'   # the CLI + daemon; core CLI only: pip insta
 # more extras: [adbc] postgres/redshift · [spark] · [polars] · [all]
 ```
 
-> **Platforms.** Developed on Linux; CI runs Linux only. Nothing in the codebase is
-> platform-specific — no `fork`, no signal handling, no POSIX-only calls, no shelling out — and
-> every dependency ships macOS and Windows wheels, so both are expected to work. But
-> **neither is tested**, so treat them as unverified rather than supported. If you run interlace
-> on macOS or Windows, please open an issue either way; that is the fastest route to changing
-> this paragraph.
+> **Platforms.** Developed on Linux. CI runs the full suite on Linux, and a macOS job runs
+> `interlace init` plus `apply` on the quickstart. Nothing in the codebase is platform-specific —
+> no `fork`, no signal handling, no POSIX-only calls, no shelling out — and every dependency
+> ships macOS and Windows wheels. Windows is still unverified. If you run interlace on Windows,
+> please open an issue either way; that is the fastest route to changing this paragraph.
 
 ## Sixty seconds
 

{interlaced-2.8.2 → interlaced-2.8.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "interlaced"
-version = "2.8.2"
+version = "2.8.3"
 description = "Python and SQL models in one DAG. Transformation, orchestration and durable streaming in one process, on DuckDB and Postgres."
 readme = "README.md"
 requires-python = ">=3.12"
@@ -113,11 +113,11 @@ select = [
     "B",   # flake8-bugbear
     "C4",  # flake8-comprehensions
     "UP",  # pyupgrade
+    "C901",  # mccabe; existing hotspots are allow-listed with noqa
 ]
 ignore = [
     "E501",  # line too long (handled by formatter)
     "B008",  # function calls in argument defaults
-    "C901",  # too complex
 ]
 
 [tool.ruff.lint.per-file-ignores]
@@ -171,6 +171,7 @@ exclude_lines = [
 
 [tool.pytest.ini_options]
 testpaths = ["tests"]
+pythonpath = ["tests"]
 python_files = ["test_*.py", "*_test.py"]
 python_classes = ["Test*"]
 python_functions = ["test_*"]

{interlaced-2.8.2 → interlaced-2.8.3}/src/interlace/cli/build.py

@@ -311,7 +311,7 @@ async def _table_diff(
         engines.close()
 
 
-async def _apply(
+async def _apply(  # noqa: C901
     environment: str,
     path: Path,
     select: list[str],
@@ -420,7 +420,7 @@ def restate(
     asyncio.run(_execute(environment, path, select, start, end, restate=True, parallelism=parallelism))
 
 
-async def _execute(
+async def _execute(  # noqa: C901
     environment: str,
     path: Path,
     select: list[str],

{interlaced-2.8.2 → interlaced-2.8.3}/src/interlace/cli/operate.py

@@ -170,7 +170,14 @@ async def _scheduler(environment: str, path: Path, interval: float, once: bool)
     """Same loops as ``interlace serve``: reload, tick, trim, drain, flush, CDC."""
     from types import SimpleNamespace
 
-    from interlace.scheduler.daemon import cdc_loop, flush_once, flusher_loop, scheduler_loop, source_mtime
+    from interlace.scheduler.daemon import (
+        cdc_loop,
+        flush_once,
+        flusher_loop,
+        remember_runtime,
+        scheduler_loop,
+        source_mtime,
+    )
     from interlace.streaming.materializer import quarantine_stream, stream_consumers
 
     project = Project.load(path)
@@ -209,6 +216,7 @@ async def _scheduler(environment: str, path: Path, interval: float, once: bool)
         stream_consumer_map={name: sorted(stream_consumers(compiled, name)) for name in streams},
     )
     host.flushed_heads = dict(host.log_heads)
+    remember_runtime(host, project.config)
     flusher: asyncio.Task[None] | None = None
     cdc: asyncio.Task[None] | None = None
     try:

{interlaced-2.8.2 → interlaced-2.8.3}/src/interlace/cli/support.py

@@ -243,7 +243,7 @@ def _window(value: str, flag: str) -> datetime | None:
         raise typer.Exit(2) from exc
 
 
-def _render(plan: Plan, environment: str) -> None:
+def _render(plan: Plan, environment: str) -> None:  # noqa: C901
     if not plan.changes and not plan.physical and not plan.transfers and not plan.drift and not plan.warnings:
         console.print(f"No changes for [bold]{environment}[/bold].")
         return

{interlaced-2.8.2 → interlaced-2.8.3}/src/interlace/config/config.py

@@ -13,6 +13,7 @@ left literal so a missing one surfaces as an obvious ``${VAR}`` in errors.
 
 from __future__ import annotations
 
+import datetime
 import os
 import re
 from pathlib import Path
@@ -143,6 +144,9 @@ class InputConfig(BaseModel):
     format: Literal["parquet", "csv", "json", "delta", "iceberg"]
     path: str
     connection: str | None = None  # http connection or an engine secret, for remote paths
+    # Hash the local file bytes into every model that reads this input, so an edit
+    # is a plan change. ``schedule: {watch:}`` only re-runs; it does not do this.
+    watch: bool = False
 
     @model_validator(mode="after")
     def _env_resolved(self) -> InputConfig:
@@ -154,8 +158,9 @@ class EngineConfig(BaseModel):
     """One named execution engine (warehouse gateway).
 
     DuckDB-family types (``duckdb`` / ``ducklake`` / ``quack``) and ``postgres`` are
-    the tested set. ``spark`` is beta; ``motherduck`` / ``redshift`` / ``snowflake`` /
-    ``bigquery`` are alpha (wired and dialect-correct, not yet live-validated).
+    the tested set. ``spark`` is beta. ``snowflake`` is alpha and has been exercised
+    against one account (not in CI). ``motherduck`` / ``redshift`` / ``bigquery`` are
+    alpha (wired and dialect-correct, not yet live-validated).
     """
 
     type: str = "duckdb"
@@ -181,6 +186,60 @@ class EngineConfig(BaseModel):
         return _TYPE_DIALECT.get(self.type, "duckdb")
 
 
+class VarConfig(BaseModel):
+    """A typed value a SQL model reads with ``var('name')``.
+
+    The call is replaced in the AST before fingerprinting, so editing ``value``
+    rebuilds every model that references the name. ``${VAR}`` in the YAML is
+    already expanded by the time this is parsed.
+    """
+
+    type: Literal["string", "int", "float", "bool", "date", "timestamp"]
+    value: str | int | float | bool
+
+    @model_validator(mode="after")
+    def _value_matches_type(self) -> VarConfig:
+        kind = self.type
+        value = self.value
+        if kind == "string":
+            if not isinstance(value, str):
+                raise ValueError("string var value must be a string")
+        elif kind == "int":
+            if type(value) is not int:
+                raise ValueError("int var value must be an integer")
+        elif kind == "float":
+            if type(value) not in (int, float):
+                raise ValueError("float var value must be a number")
+        elif kind == "bool":
+            if type(value) is not bool:
+                raise ValueError("bool var value must be true or false")
+        elif kind == "date":
+            self.value = _as_date(value)
+        else:
+            self.value = _as_timestamp(value)
+        return self
+
+
+def _as_date(value: object) -> str:
+    if isinstance(value, str):
+        try:
+            datetime.date.fromisoformat(value)
+        except ValueError as exc:
+            raise ValueError(f"date var value must be YYYY-MM-DD, got {value!r}") from exc
+        return value
+    raise ValueError("date var value must be a YYYY-MM-DD string")
+
+
+def _as_timestamp(value: object) -> str:
+    if isinstance(value, str):
+        try:
+            datetime.datetime.fromisoformat(value)
+        except ValueError as exc:
+            raise ValueError(f"timestamp var value must be ISO-8601, got {value!r}") from exc
+        return value
+    raise ValueError("timestamp var value must be an ISO-8601 string")
+
+
 class ProjectConfig(BaseModel):
     """Top-level project settings."""
 
@@ -234,10 +293,20 @@ class ProjectConfig(BaseModel):
     connections: dict[str, ConnectionConfig] = Field(default_factory=dict)
     # External files DuckDB scans as relations models can FROM. Other engines reject them.
     inputs: dict[str, InputConfig] = Field(default_factory=dict)
+    # Typed literals SQL models read with var('name'). Expanded into the AST at
+    # compile time, so a changed value is a plan change for the models that use it.
+    vars: dict[str, VarConfig] = Field(default_factory=dict)
     # Postgres logical replication into a declared @stream. Empty means the daemon
     # does not open a replication connection.
     cdc: dict[str, CdcConfig] = Field(default_factory=dict)
 
+    @model_validator(mode="after")
+    def _var_names_are_identifiers(self) -> ProjectConfig:
+        for name in self.vars:
+            if not _ENV_KEY.fullmatch(name):
+                raise ValueError(f"var {name!r} must be an identifier")
+        return self
+
     @model_validator(mode="after")
     def _cdc_uses_postgres(self) -> ProjectConfig:
         for name, source in self.cdc.items():

{interlaced-2.8.2 → interlaced-2.8.3}/src/interlace/dsl/dynamic.py

@@ -95,7 +95,7 @@ def render_model_sql(definition: ModelDef) -> str:
     return f"/*\n{header}\n*/\n{definition.sql.strip()}\n"
 
 
-def model_to_config(definition: ModelDef) -> dict[str, Any]:
+def model_to_config(definition: ModelDef) -> dict[str, Any]:  # noqa: C901
     """The ``interlace:`` mapping ``_sql_model`` reads. Defaults are omitted."""
     config: dict[str, Any] = {"name": definition.name}
     _keep(config, "materialise", definition.materialise, MATERIALISE_DEFAULT)

{interlaced-2.8.2 → interlaced-2.8.3}/src/interlace/engines/adbc.py

@@ -22,11 +22,11 @@ from typing import Any
 import pyarrow as pa
 from sqlglot import exp
 
-from interlace.engines.base import EngineAdapter, EngineCaps, LoadMode, note_statement
+from interlace.engines.base import EngineAdapter, EngineCaps, LoadMode, note_statement, relation_is_absent
 from interlace.ir.relation import TableRef
 
 
-def arrow_type_name(dtype: pa.DataType) -> str:
+def arrow_type_name(dtype: pa.DataType) -> str:  # noqa: C901
     """A canonical SQL type name for an Arrow type, in the vocabulary the planner's
     alignment/widening logic understands (see ``plan.apply``)."""
     if pa.types.is_boolean(dtype):
@@ -162,6 +162,8 @@ class AdbcAdapter(EngineAdapter):
         with self._lock:
             try:
                 schema = self._conn.adbc_get_table_schema(table.name, db_schema_filter=table.schema)
-            except Exception:  # driver raises when the table is absent -> treat as "no columns"
-                return {}
+            except Exception as exc:
+                if relation_is_absent(exc):
+                    return {}
+                raise
         return {field.name: arrow_type_name(field.type) for field in schema}

{interlaced-2.8.2 → interlaced-2.8.3}/src/interlace/engines/base.py

@@ -42,6 +42,19 @@ def note_statement(exc: BaseException, sql: str) -> None:
         return
 
 
+def relation_is_absent(exc: BaseException) -> bool:
+    """Whether ``exc`` means the relation is missing, not that the probe itself failed.
+
+    Catalog helpers treat a missing table as an empty description. Any other
+    error has to surface: swallowing it makes a broken catalog look like no columns.
+    """
+    message = str(exc).casefold()
+    if "table function" in message:
+        return False
+    markers = ("does not exist", "doesn't exist", "not found", "no such table", "undefined table", "unknown table")
+    return any(marker in message for marker in markers)
+
+
 def statement_of(exc: BaseException) -> str | None:
     """The SQL attached to ``exc`` or to the error it was raised from."""
     seen: set[int] = set()
@@ -163,7 +176,9 @@ class EngineAdapter(ABC):
 
     def transpile(self, ast: exp.Expr) -> str:
         """Canonical AST -> this engine's SQL. The one place dialect leaks back in."""
-        return ast.sql(dialect=self.dialect)
+        from interlace.ir.dialect import render_sql
+
+        return render_sql(ast, self.dialect)
 
     def refresh_inputs(self) -> None:
         """Re-expand input views whose paths contain date tokens.
@@ -178,3 +193,7 @@ class EngineAdapter(ABC):
     def attach(self, alias: str, uri: str) -> None:
         """ATTACH another database under ``alias``. Only engines with ``supports_attach``."""
         raise NotImplementedError(f"{type(self).__name__} cannot ATTACH another database")
+
+    @abstractmethod
+    def close(self) -> None:
+        """Release the connection this adapter holds."""

{interlaced-2.8.2 → interlaced-2.8.3}/src/interlace/engines/duckdb.py

@@ -39,7 +39,7 @@ import pyarrow as pa
 import tenacity
 from sqlglot import exp
 
-from interlace.engines.base import EngineAdapter, EngineCaps, LoadMode, note_statement
+from interlace.engines.base import EngineAdapter, EngineCaps, LoadMode, note_statement, relation_is_absent
 from interlace.exceptions import ConfigurationError
 from interlace.ir.relation import TableRef
 
@@ -307,8 +307,10 @@ class DuckDBAdapter(EngineAdapter):
         )
         try:
             reader = await self.fetch_sql(sql)
-        except Exception:
-            return []
+        except Exception as exc:
+            if relation_is_absent(exc):
+                return []
+            raise
         return [str(row[column]) for row in reader.read_all().to_pylist() if row.get(column)]
 
     # --- sync workers (run in a thread) -------------------------------------

{interlaced-2.8.2 → interlaced-2.8.3}/src/interlace/engines/postgres.py

@@ -20,7 +20,7 @@ from __future__ import annotations
 from sqlglot import exp
 
 from interlace.engines.adbc import AdbcAdapter
-from interlace.engines.base import EngineCaps
+from interlace.engines.base import EngineCaps, relation_is_absent
 from interlace.exceptions import ConfigurationError
 from interlace.ir.relation import TableRef
 
@@ -83,8 +83,10 @@ class PostgresAdapter(AdbcAdapter):
             reader = await self.fetch_sql(
                 f"SELECT indexname FROM pg_indexes WHERE schemaname = {schema} AND tablename = {name}"
             )
-        except Exception:
-            return []
+        except Exception as exc:
+            if relation_is_absent(exc):
+                return []
+            raise
         return [str(row["indexname"]) for row in reader.read_all().to_pylist() if row.get("indexname")]
 
     async def list_constraints(self, table: TableRef) -> list[str]:
@@ -97,6 +99,8 @@ class PostgresAdapter(AdbcAdapter):
                 "JOIN pg_namespace nsp ON nsp.oid = rel.relnamespace "
                 f"WHERE nsp.nspname = {schema} AND rel.relname = {name}"
             )
-        except Exception:
-            return []
+        except Exception as exc:
+            if relation_is_absent(exc):
+                return []
+            raise
         return [str(row["name"]) for row in reader.read_all().to_pylist() if row.get("name")]

{interlaced-2.8.2 → interlaced-2.8.3}/src/interlace/engines/registry.py

@@ -33,6 +33,7 @@ class EngineRegistry(Mapping[str, EngineAdapter]):
         *,
         default: str = "default",
         attach_uris: Mapping[str, str] | None = None,
+        sinks: Mapping[str, str] | None = None,
     ) -> None:
         self._names = frozenset(names)
         self._opener = opener
@@ -41,6 +42,9 @@ class EngineRegistry(Mapping[str, EngineAdapter]):
         # engine name -> URI another DuckDB-family engine could ATTACH (transfer
         # fast lane); absent/None = only reachable through its own adapter.
         self.attach_uris: dict[str, str] = dict(attach_uris or {})
+        # reverse-ETL alias -> database URI. A DuckDB warehouse ATTACHes these.
+        # An engine that cannot ATTACH opens the URI and writes the delivery there.
+        self.sinks: dict[str, str] = dict(sinks or {})
         if default not in self._names:
             raise ConfigurationError(
                 f"default_engine {default!r} is not a configured engine",

interlaced-2.8.3/src/interlace/engines/snowflake.py

@@ -0,0 +1,89 @@
+"""Snowflake engine adapter (ALPHA — exercised against one account, not in CI).
+
+An ADBC-transport engine: it inherits all of :class:`~interlace.engines.adbc.AdbcAdapter`
+(execute / fetch → Arrow / ``adbc_ingest`` bulk load / metadata ``describe``) and
+only sets the dialect and capabilities. Snowflake supports the full strategy set:
+``CREATE OR REPLACE TABLE``, ``SELECT * EXCLUDE`` (so scd works with ``SELECT *``),
+and a native ``MERGE``.
+
+Snowflake folds unquoted identifiers to uppercase and returns those names. Fetch
+and describe fold them back, so contracts and Python models keep the names the
+SQL was written with. ``adbc_ingest`` on this driver rejects a target schema, so
+loads ``USE SCHEMA`` first.
+
+Requires the ``adbc-snowflake`` extra. The connection string is the Snowflake ADBC
+URI (``user[:password]@account/database/schema?warehouse=WH&role=R``); key-pair and
+external-browser auth go through ``db_kwargs``.
+"""
+
+from __future__ import annotations
+
+import pyarrow as pa
+from sqlglot import exp
+
+from interlace.engines.adbc import AdbcAdapter
+from interlace.engines.base import EngineCaps, LoadMode
+from interlace.exceptions import ConfigurationError
+from interlace.ir.relation import TableRef
+
+_SNOWFLAKE_CAPS = EngineCaps(
+    supports_create_or_replace=True,
+    supports_star_exclude=True,  # SELECT * EXCLUDE (...)
+    supports_merge=True,
+    supports_transactions=True,
+    # PRIMARY KEY / UNIQUE / FOREIGN KEY are informational. NOT NULL is enforced.
+    enforced_constraints=frozenset({"not_null"}),
+)
+
+
+class SnowflakeAdapter(AdbcAdapter):
+    """Executes canonical ASTs inside Snowflake; Arrow in and out via ADBC."""
+
+    dialect = "snowflake"
+    caps = _SNOWFLAKE_CAPS
+
+    @classmethod
+    def connect(cls, dsn: str) -> SnowflakeAdapter:
+        try:
+            import adbc_driver_snowflake.dbapi as dbapi
+        except ImportError as exc:  # pragma: no cover - import guard
+            raise ConfigurationError(
+                "the snowflake engine needs the 'adbc-snowflake' extra: pip install 'interlaced[adbc-snowflake]'"
+            ) from exc
+        return cls(dbapi.connect(dsn))
+
+    def _fetch_sync(self, sql: str) -> pa.RecordBatchReader:
+        table = super()._fetch_sync(sql).read_all()
+        return table.rename_columns([name.casefold() for name in table.column_names]).to_reader()
+
+    def _describe_sync(self, table: TableRef) -> dict[str, str]:
+        # The driver quotes the name it is given. Unquoted SQL folds to uppercase,
+        # so a lowercase lookup looks for a different table and comes back empty.
+        folded = TableRef(
+            schema=table.schema.upper(),
+            name=table.name.upper(),
+            catalog=table.catalog.upper() if table.catalog else None,
+        )
+        described = super()._describe_sync(folded)
+        return {name.casefold(): kind for name, kind in described.items()}
+
+    def _load_sync(self, table: TableRef, reader: pa.RecordBatchReader, mode: LoadMode) -> int:
+        # This driver rejects adbc.ingest.target_db_schema. The session schema is
+        # the ingest target; unquoted names fold the same way the model's SQL does.
+        ingest_mode = "replace" if mode == "create" else "append"
+        schema = exp.to_identifier(table.schema).sql(dialect=self.dialect) if table.schema else ""
+        # Arrow names are the SQL as written (lowercase). The driver quotes them,
+        # so they must be the uppercase form unquoted SQL folds to.
+        loaded_table = reader.read_all()
+        batch = loaded_table.rename_columns([name.upper() for name in loaded_table.column_names])
+        with self._lock:
+            try:
+                with self._conn.cursor() as cur:
+                    if schema:
+                        cur.execute(f"USE SCHEMA {schema}")
+                    loaded = cur.adbc_ingest(table.name.upper(), batch, mode=ingest_mode)
+                self._conn.commit()
+            except Exception:
+                self._conn.rollback()
+                raise
+        return int(loaded) if isinstance(loaded, int) and loaded > 0 else 0

{interlaced-2.8.2 → interlaced-2.8.3}/src/interlace/graph/project.py

@@ -11,9 +11,9 @@ and build the snapshots it persists.
 from __future__ import annotations
 
 import inspect
-import textwrap
 from collections.abc import Iterable, Mapping
 from dataclasses import dataclass, field
+from typing import Any
 
 from sqlglot import exp
 
@@ -22,9 +22,16 @@ from interlace.dsl.decorators import CheckDef, ModelDef, ModelFn
 from interlace.exceptions import CompilationError, DefinitionError
 from interlace.graph.dag import DependencyGraph
 from interlace.ir.canonicalize import as_query, parse, table_references
-from interlace.ir.fingerprint import canonical_sql, data_fingerprint, metadata_fingerprint, physical_fingerprint
+from interlace.ir.fingerprint import (
+    canonical_sql,
+    data_fingerprint,
+    metadata_fingerprint,
+    physical_fingerprint,
+    python_source,
+)
 from interlace.ir.macros import Macro, expand_macros
 from interlace.ir.relation import TableRef
+from interlace.ir.vars import TypedVar, expand_vars
 from interlace.physical.spec import ConstraintSpec, IndexSpec, SchemaPolicy, physical_payload
 
 # Snapshot tables live in `interlace__<logical schema>` — exclusively owned, never a
@@ -102,7 +109,11 @@ def _physical_table(name: str, fingerprint: str, catalog: str | None) -> TableRe
 
 
 def _resolve_dependencies(
-    model: ModelDef, names: set[str], default_dialect: str, macros: Mapping[str, Macro]
+    model: ModelDef,
+    names: set[str],
+    default_dialect: str,
+    macros: Mapping[str, Macro],
+    variables: Mapping[str, TypedVar],
 ) -> tuple[tuple[str, ...], exp.Query | None, str]:
     dialect = model.dialect or default_dialect
     deps: list[str] = []
@@ -128,6 +139,9 @@ def _resolve_dependencies(
         # here is what makes a macro edit rebuild its callers, and what lets a macro body
         # reference a model and have that count as a dependency.
         ast = as_query(expand_macros(ast, macros, model.name), what=f"model {model.name}")
+        # After macros, so a macro body may call var() and the literal lands in
+        # the fingerprint. An unknown name fails here, before the warehouse sees it.
+        ast = as_query(expand_vars(ast, variables, model.name), what=f"model {model.name}")
         for ref in table_references(ast):
             if ref in names:
                 add(ref)
@@ -149,11 +163,11 @@ def _fingerprint_query(model: ModelDef, ast: exp.Query | None) -> str | exp.Quer
     if ast is not None:
         return ast
     if model.fn is not None:
-        return textwrap.dedent(inspect.getsource(model.fn))
+        return python_source(model.fn)
     raise DefinitionError(f"model {model.name!r} has neither SQL nor a function body")
 
 
-def compile_models(
+def compile_models(  # noqa: C901
     models: Iterable[ModelDef],
     *,
     default_dialect: str = "duckdb",
@@ -163,6 +177,8 @@ def compile_models(
     catalog: str | None = None,
     checks: Iterable[CheckDef] = (),
     macros: Mapping[str, Macro] | None = None,
+    input_hashes: Mapping[str, str] | None = None,
+    variables: Mapping[str, TypedVar] | None = None,
 ) -> CompiledProject:
     """Compile models into a fingerprinted, topologically-ordered project.
 
@@ -170,6 +186,9 @@ def compile_models(
     ``engine_dialects`` maps engine name → sqlglot dialect (used when a model
     omits ``dialect``). ``known_engines`` validates model ``engine`` pins.
     ``macros`` are expanded into every model's AST before it is fingerprinted.
+    ``input_hashes`` are content digests of watched inputs; a model that reads
+    one folds those digests into its fingerprint.
+    ``variables`` replace ``var('name')`` with a typed literal before fingerprinting.
     """
     definitions = {m.name: m for m in models}
     names = set(definitions)
@@ -193,7 +212,9 @@ def compile_models(
             )
         # Authoring dialect: explicit model dialect, else the engine's, else project default.
         model_default_dialect = dialects_by_engine.get(engine, default_dialect)
-        deps, ast, dialect = _resolve_dependencies(definition, names, model_default_dialect, macros or {})
+        deps, ast, dialect = _resolve_dependencies(
+            definition, names, model_default_dialect, macros or {}, variables or {}
+        )
         resolved[name] = (deps, ast, dialect, engine)
         graph.add_node(name)
         for dep in deps:
@@ -223,7 +244,7 @@ def compile_models(
                     f"{compiled[dep].engine!r}; an ephemeral model must share its consumers' engine "
                     f"(see docs/architecture/MULTI_ENGINE.md)"
                 )
-        strategy_config = {
+        strategy_config: dict[str, Any] = {
             "materialise": definition.materialise,
             "strategy": definition.strategy,
             "key": list(definition.key),
@@ -240,6 +261,12 @@ def compile_models(
             "environments": sorted(definition.environments),
             "dialect": dialect,
         }
+        if input_hashes and ast is not None:
+            from interlace.inputs import referenced_inputs
+
+            watched = {name: input_hashes[name] for name in referenced_inputs(ast, set(input_hashes))}
+            if watched:
+                strategy_config["inputs"] = watched
         query = _fingerprint_query(definition, ast)
         # render the canonical SQL once: it feeds both fingerprints and definition_sql
         canonical = canonical_sql(query) if isinstance(query, exp.Expr) else query