@@ -12,9 +12,6 @@
 from ibis.expr.types.relations import Table as IbisTable
 from returns.result import Success, safe
 
-from ._xorq import (
-    Column as XorqColumn,
-)
 from ._xorq import (
     GroupedTable,
     Table,
@@ -35,6 +32,7 @@
     SemanticTableOp,
     SemanticUnnestOp,
     _classify_measure,
+    _collect_struct,
     _exact_filter_fields,
     _extract_columns_from_callable,
     _extract_join_key_columns,
@@ -46,8 +44,6 @@
     _unwrap,
     make_bare_ref_lambda,
 )
-from .query import compare_periods as build_compare_periods
-from .query import query as build_query
 
 logger = logging.getLogger(__name__)
 
@@ -147,10 +143,25 @@ def _flatten_group_keys(keys: tuple) -> tuple:
     return tuple(flat)
 
 
+def _query_module():
+    """Call-time accessor for the query layer (which sits above expr).
+
+    The .query()/.compare_periods() convenience methods dispatch upward the
+    same way .chart() does — resolved at call time so the expression layer
+    holds no import-time dependency on the layers built on top of it.
+    """
+    import importlib
+
+    return importlib.import_module("boring_semantic_layer.query")
+
+
 def to_tagged(expr, aggregate_cache_storage=None):
-    from .serialization import to_tagged as _to_tagged
+    # Serialization sits above the expression layer; resolve at call time
+    # (see _query_module).
+    import importlib
 
-    return _to_tagged(expr, aggregate_cache_storage=aggregate_cache_storage)
+    ser = importlib.import_module("boring_semantic_layer.serialization")
+    return ser.to_tagged(expr, aggregate_cache_storage=aggregate_cache_storage)
 
 
 class SemanticTable(ir.Table):
@@ -355,8 +366,6 @@ def to_untagged(self):
         return self.op().to_untagged()
 
     def to_tagged(self, aggregate_cache_storage=None):
-        from .serialization import to_tagged
-
         return to_tagged(self, aggregate_cache_storage=aggregate_cache_storage)
 
     def execute(self, **kwargs):
@@ -1221,7 +1230,7 @@ def query(
         time_range: dict[str, str] | None = None,
         having: list | None = None,
     ):
-        return build_query(
+        return _query_module().query(
             semantic_table=self,
             dimensions=dimensions,
             measures=measures,
@@ -1247,7 +1256,7 @@ def compare_periods(
         order_by: Sequence[tuple[str, str]] | None = None,
         limit: int | None = None,
     ):
-        return build_compare_periods(
+        return _query_module().compare_periods(
             semantic_table=self,
             dimensions=dimensions,
             measures=measures,
@@ -1412,7 +1421,7 @@ def query(
         time_range: dict[str, str] | None = None,
         having: list | None = None,
     ):
-        return build_query(
+        return _query_module().query(
             semantic_table=self,
             dimensions=dimensions,
             measures=measures,
@@ -1507,10 +1516,10 @@ def join(self, *args, **kwargs):
 
     def group_by(self, *keys: str | Deferred):
         normalized = tuple(_normalize_to_name(k) for k in _flatten_group_keys(keys))
-        return self.op().group_by(*normalized)
+        return SemanticGroupBy(source=self.op(), keys=normalized)
 
     def filter(self, predicate: Callable):
-        return self.op().filter(predicate)
+        return SemanticFilter(source=self.op(), predicate=predicate)
 
 
 class SemanticFilter(SemanticTable):
@@ -1591,7 +1600,7 @@ def query(
         time_range: dict[str, str] | None = None,
         having: list | None = None,
     ):
-        return build_query(
+        return _query_module().query(
             semantic_table=self,
             dimensions=dimensions,
             measures=measures,
@@ -1617,7 +1626,7 @@ def compare_periods(
         order_by: Sequence[tuple[str, str]] | None = None,
         limit: int | None = None,
     ):
-        return build_compare_periods(
+        return _query_module().compare_periods(
             semantic_table=self,
             dimensions=dimensions,
             measures=measures,
@@ -1714,20 +1723,6 @@ def join(self, *args, **kwargs):
         raise TypeError(_JOIN_REMOVED_MESSAGE)
 
 
-def _collect_struct(struct_dict: dict[str, Any], **collect_kwargs):
-    """Build ``struct(...).collect()`` from columns of a single ibis flavor.
-
-    ``ibis.struct`` and ``xorq.vendor.ibis.struct`` are not interchangeable:
-    each can only infer types from columns of its own module.
-    """
-    first_col = next(iter(struct_dict.values()))
-    if isinstance(first_col, XorqColumn):
-        from ._xorq import ibis as xibis
-
-        return xibis.struct(struct_dict).collect(**collect_kwargs)
-    return ibis.struct(struct_dict).collect(**collect_kwargs)
-
-
 def _make_row_struct_collector(columns: tuple[str, ...]) -> Callable:
     """Per-row struct collection for the bare ``group_by`` nest form.
 
 
@@ -19,6 +19,9 @@
 from returns.result import safe
 
 from . import projection_utils
+from ._xorq import (
+    Column as XorqColumn,
+)
 from ._xorq import (
     FrozenDict,
     FrozenOrderedDict,
@@ -455,10 +458,27 @@ def _to_untagged(source: Any) -> ir.Table:
     return source.to_untagged() if hasattr(source, "to_untagged") else source.to_expr()
 
 
-def _semantic_table(*args, **kwargs) -> SemanticTable:
-    from .expr import SemanticModel
+def _expr_module():
+    """Call-time accessor for the expression layer (the layer above ops).
+
+    Fluent convenience methods on op classes construct user-facing wrappers;
+    resolving the module at call time keeps ops free of any import-time
+    dependency on expr. Follow-up: move those methods onto the wrappers.
+    """
+    import importlib
+
+    return importlib.import_module("boring_semantic_layer.expr")
+
+
+def _query_module():
+    """Call-time accessor for the query layer (see ``_expr_module``)."""
+    import importlib
 
-    return SemanticModel(*args, **kwargs)
+    return importlib.import_module("boring_semantic_layer.query")
+
+
+def _semantic_table(*args, **kwargs) -> SemanticTable:
+    return _expr_module().SemanticModel(*args, **kwargs)
 
 
 def _unwrap(wrapped: Any) -> Any:
@@ -576,8 +596,16 @@ def _format_op_summary(op: Relation) -> str:
 
 
 def _format_root(root_op: SemanticTableOp) -> str:
-    """Format a SemanticTableOp root using the fmt registry from format.py."""
-    from boring_semantic_layer.format import fmt
+    """Format a SemanticTableOp root using the ``fmt`` singledispatch registry.
+
+    ``format.py`` (imported by the package ``__init__``) registers the
+    semantic-op handlers on ibis's ``fmt``; import it from the same place
+    so we hit the same registry without depending on the format module.
+    """
+    try:
+        from ibis.expr.format import fmt
+    except ImportError:
+        from ._xorq import fmt
 
     try:
         return fmt(root_op)
@@ -1003,6 +1031,20 @@ def _classify_dependencies(
     }
 
 
+def _collect_struct(struct_dict: dict[str, Any], **collect_kwargs):
+    """Build ``struct(...).collect()`` from columns of a single ibis flavor.
+
+    ``ibis.struct`` and ``xorq.vendor.ibis.struct`` are not interchangeable:
+    each can only infer types from columns of its own module.
+    """
+    first_col = next(iter(struct_dict.values()))
+    if isinstance(first_col, XorqColumn):
+        from ._xorq import ibis as xibis
+
+        return xibis.struct(struct_dict).collect(**collect_kwargs)
+    return ibis.struct(struct_dict).collect(**collect_kwargs)
+
+
 @frozen
 class _CallableWrapper:
     """Hashable wrapper for Callable and Deferred.
@@ -1092,10 +1134,8 @@ def _infer_unnest(fn: Callable, table: Any) -> tuple[str, ...]:
         to_semantic_table(tbl).unnest("hits").with_measures(...) -> ("hits",)
         unnested.unnest("product").with_measures(...) -> ("product",)
     """
-    from .expr import SemanticUnnest
-
-    if isinstance(table, SemanticUnnest):
-        op = table.op()
+    op = table.op() if hasattr(table, "op") else None
+    if isinstance(op, SemanticUnnestOp):
         # SemanticUnnestOp always has column attribute
         return (op.column,)
 
@@ -4058,7 +4098,6 @@ def _to_untagged_with_nest(self, nest_specs: dict[str, NestAggSpec]):
         before collection; ``order_by``/``limit`` order and truncate each
         group's array.
         """
-        from .expr import _collect_struct
 
         plain_aggs = {name: fn for name, fn in self.aggs.items() if name not in nest_specs}
         outer_keys = list(self.keys)
@@ -5791,9 +5830,7 @@ def query(
         time_range: dict[str, str] | None = None,
         having: list | None = None,
     ):
-        from .query import query as build_query
-
-        return build_query(
+        return _query_module().query(
             semantic_table=self,
             dimensions=dimensions,
             measures=measures,
@@ -5842,14 +5879,10 @@ def with_measures(self, **meas) -> SemanticTable:
         )
 
     def group_by(self, *keys: str) -> SemanticGroupBy:
-        from .expr import SemanticGroupBy
-
-        return SemanticGroupBy(source=self, keys=keys)
+        return _expr_module().SemanticGroupBy(source=self, keys=keys)
 
     def filter(self, predicate: Callable) -> SemanticFilter:
-        from .expr import SemanticFilter
-
-        return SemanticFilter(source=self, predicate=predicate)
+        return _expr_module().SemanticFilter(source=self, predicate=predicate)
 
     def join_one(
         self,
@@ -5858,9 +5891,7 @@ def join_one(
         how: str = "left",
     ):
         """Join with one-to-one relationship semantics (left outer join)."""
-        from .expr import _join_one_with_detected_grain
-
-        return _join_one_with_detected_grain(self, other, on, how)
+        return _expr_module()._join_one_with_detected_grain(self, other, on, how)
 
     def join_many(
         self,
@@ -5869,9 +5900,7 @@ def join_many(
         how: str = "left",
     ):
         """Join with one-to-many relationship semantics."""
-        from .expr import SemanticJoin
-
-        return SemanticJoin(
+        return _expr_module().SemanticJoin(
             left=self,
             right=other.op(),
             on=on,
@@ -5881,9 +5910,7 @@ def join_many(
 
     def join_cross(self, other: SemanticTable):
         """Cross join (Cartesian product) with another semantic model."""
-        from .expr import SemanticJoin
-
-        return SemanticJoin(
+        return _expr_module().SemanticJoin(
             left=self,
             right=other.op(),
             on=None,
@@ -6858,19 +6885,13 @@ def build_fragment(field_name: str) -> Any:
         return reduce(lambda acc, frag: acc.union(frag), fragments[1:], fragments[0])
 
     def filter(self, predicate: Callable) -> SemanticFilter:
-        from .expr import SemanticFilter
-
-        return SemanticFilter(source=self, predicate=predicate)
+        return _expr_module().SemanticFilter(source=self, predicate=predicate)
 
     def order_by(self, *keys: str | ir.Value | Callable) -> SemanticOrderBy:
-        from .expr import SemanticOrderBy
-
-        return SemanticOrderBy(source=self, keys=keys)
+        return _expr_module().SemanticOrderBy(source=self, keys=keys)
 
     def limit(self, n: int, offset: int = 0) -> SemanticLimit:
-        from .expr import SemanticLimit
-
-        return SemanticLimit(source=self, n=n, offset=offset)
+        return _expr_module().SemanticLimit(source=self, n=n, offset=offset)
 
     def execute(self):
         return _rebind_to_canonical_backend(self.to_untagged()).execute()
 
@@ -0,0 +1,26 @@
+SELECT
+  "t3"."region",
+  "t3"."revenue",
+  "t3"."revenue" / "t3"."__bsl_totals__revenue" AS "revenue_share"
+FROM (
+  SELECT
+    "t2"."region",
+    SUM("t2"."amount") AS "revenue",
+    ANY_VALUE("t2"."__bsl_totals__revenue") AS "__bsl_totals__revenue"
+  FROM (
+    SELECT
+      "t1"."order_id",
+      "t1"."customer_id",
+      "t1"."region",
+      "t1"."amount",
+      "t1"."ts",
+      SUM("t1"."amount") OVER (ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING) AS "__bsl_totals__revenue"
+    FROM (
+      SELECT
+        *
+      FROM "memory"."main"."orders" AS "t0"
+    ) AS "t1"
+  ) AS "t2"
+  GROUP BY
+    1
+) AS "t3"
@@ -0,0 +1,19 @@
+SELECT
+  *
+FROM (
+  SELECT
+    "t1"."month",
+    COUNT(*) AS "order_count"
+  FROM (
+    SELECT
+      "t0"."order_id",
+      "t0"."customer_id",
+      "t0"."region",
+      "t0"."amount",
+      "t0"."ts",
+      DATE_TRUNC('MONTH', "t0"."ts") AS "month"
+    FROM "memory"."main"."orders" AS "t0"
+  ) AS "t1"
+  GROUP BY
+    1
+) AS "t2"