Fix _aser_call and sx_call list serialization: use (list ...) for data arrays

Data lists (dicts, strings, numbers) were wrapped in (<> ...) fragments which the client rendered as empty DocumentFragments instead of iterable arrays. This broke map/filter over cards, tag_groups, and authors in blog index and similar components. - _aser_call: data lists → (list ...), rendered content (SxExpr) → (<> ...) - sx_call: all list kwargs → (list ...) Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
Remove render_to_sx from public API: enforce sx_call for all service code
2026-03-04 20:11:11 +00:00 · 2026-03-04 19:30:45 +00:00 · 2026-03-04 18:29:14 +00:00 · 2026-03-04 18:20:57 +00:00 · 2026-03-04 17:13:50 +00:00 · 2026-03-04 17:13:45 +00:00
223 changed files with 20121 additions and 15388 deletions
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -108,6 +108,26 @@ cd artdag/l1 && mypy app/types.py app/routers/recipes.py tests/
 - Silent SSO: `prompt=none` OAuth flow for automatic cross-app login
 - ActivityPub: RSA signatures, per-app virtual actor projections sharing same keypair

+### SX Rendering Pipeline
+
+The SX system renders component trees defined in s-expressions. The same AST can be evaluated in different modes depending on where the server/client rendering boundary is drawn:
+
+- `render_to_html(name, **kw)` — server-side, produces HTML. Used by route handlers returning full HTML.
+- `render_to_sx(name, **kw)` — server-side, produces SX wire format. Component calls stay **unexpanded** (serialized for client-side rendering by sx.js).
+- `render_to_sx_with_env(name, env, **kw)` — server-side, **expands the top-level component** then serializes children as SX wire format. Used by layout components that need Python context (auth state, fragments, URLs) resolved server-side.
+- `sx_page(ctx, page_sx)` — produces the full HTML shell (`<!doctype html>...`) with component definitions, CSS, and page SX inlined for client-side boot.
+
+See the docstring in `shared/sx/async_eval.py` for the full evaluation modes table.
+
+### Service SX Directory Convention
+
+Each service has two SX-related directories:
+
+- **`{service}/sx/`** — service-specific component definitions (`.sx` files with `defcomp`). Loaded at startup by `load_service_components()`. These define layout components, reusable UI fragments, etc.
+- **`{service}/sxc/`** — page definitions and Python rendering logic. Contains `defpage` definitions (client-routed pages) and the Python functions that compose headers, layouts, and page content.
+
+Shared components live in `shared/sx/templates/` and are loaded by `load_shared_components()` in the app factory.
+
 ### Art DAG

 - **3-Phase Execution:** Analyze → Plan → Execute (tasks in `artdag/l1/tasks/`)
@@ -130,6 +150,10 @@ cd artdag/l1 && mypy app/types.py app/routers/recipes.py tests/
 | likes | (internal only) | 8009 |
 | orders | orders.rose-ash.com | 8010 |

+## Dev Container Mounts
+
+Dev bind mounts in `docker-compose.dev.yml` must mirror the Docker image's COPY paths. When adding a new directory to a service (e.g. `{service}/sx/`), add a corresponding volume mount (`./service/sx:/app/sx`) or the directory won't be visible inside the dev container. Hypercorn `--reload` watches for Python file changes; `.sx` file hot-reload is handled by `reload_if_changed()` in `shared/sx/jinja_bridge.py`.
+
 ## Key Config Files

 - `docker-compose.yml` / `docker-compose.dev.yml` — service definitions, env vars, volumes
--- a/account/actions.sx
+++ b/account/actions.sx
@@ -0,0 +1,4 @@
+;; Account service — inter-service action endpoints
+;;
+;; ghost-sync-member and ghost-push-member use local service imports —
+;; remain as Python fallbacks.
--- a/account/app.py
+++ b/account/app.py
@@ -1,6 +1,5 @@
 from __future__ import annotations
 import path_setup  # noqa: F401  # adds shared/ to sys.path
-import sx.sx_components as sx_components  # noqa: F401  # ensure Hypercorn --reload watches this file
 from pathlib import Path

 from quart import g, request
@@ -72,8 +71,9 @@ def create_app() -> "Quart":
        app.jinja_loader,
    ])

-    # Setup defpage routes
-    import sx.sx_components  # noqa: F811 — ensure components loaded
+    # Load .sx component files and setup defpage routes
+    from shared.sx.jinja_bridge import load_service_components
+    load_service_components(str(Path(__file__).resolve().parent), service_name="account")
    from sxc.pages import setup_account_pages
    setup_account_pages()

--- a/account/bp/account/routes.py
+++ b/account/bp/account/routes.py
@@ -7,14 +7,13 @@ from __future__ import annotations

 from quart import (
    Blueprint,
-    request,
    g,
 )
 from sqlalchemy import select

 from shared.models import UserNewsletter
 from shared.infrastructure.fragments import fetch_fragments
-from shared.sx.helpers import sx_response
+from shared.sx.helpers import sx_response, sx_call


 def register(url_prefix="/"):
@@ -55,7 +54,26 @@ def register(url_prefix="/"):

        await g.s.flush()

-        from sx.sx_components import render_newsletter_toggle
-        return sx_response(render_newsletter_toggle(un))
+        # Render toggle directly — no sx_components intermediary
+        from shared.browser.app.csrf import generate_csrf_token
+        from shared.infrastructure.urls import account_url
+
+        nid = un.newsletter_id
+        url_fn = getattr(g, "_account_url", None) or account_url
+        toggle_url = url_fn(f"/newsletter/{nid}/toggle/")
+        csrf = generate_csrf_token()
+        bg = "bg-emerald-500" if un.subscribed else "bg-stone-300"
+        translate = "translate-x-6" if un.subscribed else "translate-x-1"
+        checked = "true" if un.subscribed else "false"
+
+        return sx_response(sx_call(
+            "account-newsletter-toggle",
+            id=f"nl-{nid}", url=toggle_url,
+            hdrs=f'{{"X-CSRFToken": "{csrf}"}}',
+            target=f"#nl-{nid}",
+            cls=f"relative inline-flex h-6 w-11 items-center rounded-full transition-colors focus:outline-none focus:ring-2 focus:ring-emerald-500 focus:ring-offset-2 {bg}",
+            checked=checked,
+            knob_cls=f"inline-block h-4 w-4 rounded-full bg-white shadow transform transition-transform {translate}",
+        ))

    return account_bp
--- a/account/bp/actions/routes.py
+++ b/account/bp/actions/routes.py
@@ -1,63 +1,33 @@
 """Account app action endpoints.

-Exposes write operations at ``/internal/actions/<action_name>`` for
-cross-app callers (blog webhooks) via the internal action client.
+All actions remain as Python fallbacks (local service imports).
 """
 from __future__ import annotations

-from quart import Blueprint, g, jsonify, request
+from quart import Blueprint, g, request

-from shared.infrastructure.actions import ACTION_HEADER
+from shared.infrastructure.query_blueprint import create_action_blueprint


 def register() -> Blueprint:
-    bp = Blueprint("actions", __name__, url_prefix="/internal/actions")
+    bp, _handlers = create_action_blueprint("account")

-    @bp.before_request
-    async def _require_action_header():
-        if not request.headers.get(ACTION_HEADER):
-            return jsonify({"error": "forbidden"}), 403
-        from shared.infrastructure.internal_auth import validate_internal_request
-        if not validate_internal_request():
-            return jsonify({"error": "forbidden"}), 403
-
-    _handlers: dict[str, object] = {}
-
-    @bp.post("/<action_name>")
-    async def handle_action(action_name: str):
-        handler = _handlers.get(action_name)
-        if handler is None:
-            return jsonify({"error": "unknown action"}), 404
-        try:
-            result = await handler()
-            return jsonify(result)
-        except Exception as exc:
-            import logging
-            logging.getLogger(__name__).exception("Action %s failed", action_name)
-            return jsonify({"error": str(exc)}), 500
-
-    # --- ghost-sync-member ---
    async def _ghost_sync_member():
-        """Sync a single Ghost member into db_account."""
        data = await request.get_json()
        ghost_id = data.get("ghost_id")
        if not ghost_id:
            return {"error": "ghost_id required"}, 400
-
        from services.ghost_membership import sync_single_member
        await sync_single_member(g.s, ghost_id)
        return {"ok": True}

    _handlers["ghost-sync-member"] = _ghost_sync_member

-    # --- ghost-push-member ---
    async def _ghost_push_member():
-        """Push a local user's membership data to Ghost."""
        data = await request.get_json()
        user_id = data.get("user_id")
        if not user_id:
            return {"error": "user_id required"}, 400
-
        from services.ghost_membership import sync_member_to_ghost
        result_id = await sync_member_to_ghost(g.s, int(user_id))
        return {"ok": True, "ghost_id": result_id}
--- a/account/bp/auth/routes.py
+++ b/account/bp/auth/routes.py
@@ -44,6 +44,17 @@ from .services import (
 SESSION_USER_KEY = "uid"
 ACCOUNT_SESSION_KEY = "account_sid"

+
+async def _render_auth_page(component: str, title: str, **kwargs) -> str:
+    """Render an auth page with root layout — replaces sx_components helpers."""
+    from shared.sx.helpers import sx_call, full_page_sx, root_header_sx
+    from shared.sx.page import get_template_context
+    ctx = await get_template_context()
+    hdr = await root_header_sx(ctx)
+    content = sx_call(component, **{k: v for k, v in kwargs.items() if v})
+    return await full_page_sx(ctx, header_rows=hdr, content=content,
+                              meta_html=f"<title>{title}</title>")
+
 ALLOWED_CLIENTS = {"blog", "market", "cart", "events", "federation", "orders", "test", "sx", "artdag", "artdag_l2"}


@@ -275,10 +286,7 @@ def register(url_prefix="/auth"):
            redirect_url = pop_login_redirect_target()
            return redirect(redirect_url)

-        from shared.sx.page import get_template_context
-        from sx.sx_components import render_login_page
-        ctx = await get_template_context()
-        return await render_login_page(ctx)
+        return await _render_auth_page("account-login-content", "Login \u2014 Rose Ash")

    @rate_limit(
        key_func=lambda: request.headers.get("X-Forwarded-For", request.remote_addr),
@@ -291,20 +299,20 @@ def register(url_prefix="/auth"):

        is_valid, email = validate_email(email_input)
        if not is_valid:
-            from shared.sx.page import get_template_context
-            from sx.sx_components import render_login_page
-            ctx = await get_template_context(error="Please enter a valid email address.", email=email_input)
-            return await render_login_page(ctx), 400
+            return await _render_auth_page(
+                "account-login-content", "Login \u2014 Rose Ash",
+                error="Please enter a valid email address.", email=email_input,
+            ), 400

        # Per-email rate limit: 5 magic links per 15 minutes
        from shared.infrastructure.rate_limit import _check_rate_limit
        try:
            allowed, _ = await _check_rate_limit(f"magic_email:{email}", 5, 900)
            if not allowed:
-                from shared.sx.page import get_template_context
-                from sx.sx_components import render_check_email_page
-                ctx = await get_template_context(email=email, email_error=None)
-                return await render_check_email_page(ctx), 200
+                return await _render_auth_page(
+                    "account-check-email-content", "Check your email \u2014 Rose Ash",
+                    email=email,
+                ), 200
        except Exception:
            pass  # Redis down — allow the request

@@ -324,10 +332,10 @@ def register(url_prefix="/auth"):
                "Please try again in a moment."
            )

-        from shared.sx.page import get_template_context
-        from sx.sx_components import render_check_email_page
-        ctx = await get_template_context(email=email, email_error=email_error)
-        return await render_check_email_page(ctx)
+        return await _render_auth_page(
+            "account-check-email-content", "Check your email \u2014 Rose Ash",
+            email=email, email_error=email_error,
+        )

    @auth_bp.get("/magic/<token>/")
    async def magic(token: str):
@@ -340,17 +348,17 @@ def register(url_prefix="/auth"):
                    user, error = await validate_magic_link(s, token)

                    if error:
-                        from shared.sx.page import get_template_context
-                        from sx.sx_components import render_login_page
-                        ctx = await get_template_context(error=error)
-                        return await render_login_page(ctx), 400
+                        return await _render_auth_page(
+                            "account-login-content", "Login \u2014 Rose Ash",
+                            error=error,
+                        ), 400
                    user_id = user.id

        except Exception:
-            from shared.sx.page import get_template_context
-            from sx.sx_components import render_login_page
-            ctx = await get_template_context(error="Could not sign you in right now. Please try again.")
-            return await render_login_page(ctx), 502
+            return await _render_auth_page(
+                "account-login-content", "Login \u2014 Rose Ash",
+                error="Could not sign you in right now. Please try again.",
+            ), 502

        assert user_id is not None

@@ -679,11 +687,11 @@ def register(url_prefix="/auth"):
    @auth_bp.get("/device/")
    async def device_form():
        """Browser form where user enters the code displayed in terminal."""
-        from shared.sx.page import get_template_context
-        from sx.sx_components import render_device_page
        code = request.args.get("code", "")
-        ctx = await get_template_context(code=code)
-        return await render_device_page(ctx)
+        return await _render_auth_page(
+            "account-device-content", "Authorize Device \u2014 Rose Ash",
+            code=code,
+        )

    @auth_bp.post("/device")
    @auth_bp.post("/device/")
@@ -693,20 +701,20 @@ def register(url_prefix="/auth"):
        user_code = (form.get("code") or "").strip().replace("-", "").upper()

        if not user_code or len(user_code) != 8:
-            from shared.sx.page import get_template_context
-            from sx.sx_components import render_device_page
-            ctx = await get_template_context(error="Please enter a valid 8-character code.", code=form.get("code", ""))
-            return await render_device_page(ctx), 400
+            return await _render_auth_page(
+                "account-device-content", "Authorize Device \u2014 Rose Ash",
+                error="Please enter a valid 8-character code.", code=form.get("code", ""),
+            ), 400

        from shared.infrastructure.auth_redis import get_auth_redis

        r = await get_auth_redis()
        device_code = await r.get(f"devflow_uc:{user_code}")
        if not device_code:
-            from shared.sx.page import get_template_context
-            from sx.sx_components import render_device_page
-            ctx = await get_template_context(error="Code not found or expired. Please try again.", code=form.get("code", ""))
-            return await render_device_page(ctx), 400
+            return await _render_auth_page(
+                "account-device-content", "Authorize Device \u2014 Rose Ash",
+                error="Code not found or expired. Please try again.", code=form.get("code", ""),
+            ), 400

        if isinstance(device_code, bytes):
            device_code = device_code.decode()
@@ -720,23 +728,19 @@ def register(url_prefix="/auth"):
        # Logged in — approve immediately
        ok = await _approve_device(device_code, g.user)
        if not ok:
-            from shared.sx.page import get_template_context
-            from sx.sx_components import render_device_page
-            ctx = await get_template_context(error="Code expired or already used.")
-            return await render_device_page(ctx), 400
+            return await _render_auth_page(
+                "account-device-content", "Authorize Device \u2014 Rose Ash",
+                error="Code expired or already used.",
+            ), 400

-        from shared.sx.page import get_template_context
-        from sx.sx_components import render_device_approved_page
-        ctx = await get_template_context()
-        return await render_device_approved_page(ctx)
+        return await _render_auth_page(
+            "account-device-approved", "Device Authorized \u2014 Rose Ash",
+        )

    @auth_bp.get("/device/complete")
    @auth_bp.get("/device/complete/")
    async def device_complete():
        """Post-login redirect — completes approval after magic link auth."""
-        from shared.sx.page import get_template_context
-        from sx.sx_components import render_device_page, render_device_approved_page
-
        device_code = request.args.get("code", "")

        if not device_code:
@@ -748,12 +752,13 @@ def register(url_prefix="/auth"):

        ok = await _approve_device(device_code, g.user)
        if not ok:
-            ctx = await get_template_context(
+            return await _render_auth_page(
+                "account-device-content", "Authorize Device \u2014 Rose Ash",
                error="Code expired or already used. Please start the login process again in your terminal.",
-            )
-            return await render_device_page(ctx), 400
+            ), 400

-        ctx = await get_template_context()
-        return await render_device_approved_page(ctx)
+        return await _render_auth_page(
+            "account-device-approved", "Device Authorized \u2014 Rose Ash",
+        )

    return auth_bp
--- a/account/bp/data/routes.py
+++ b/account/bp/data/routes.py
@@ -1,67 +1,14 @@
 """Account app data endpoints.

-Exposes read-only JSON queries at ``/internal/data/<query_name>`` for
-cross-app callers via the internal data client.
+All queries are defined in ``account/queries.sx``.
 """
 from __future__ import annotations

-from quart import Blueprint, g, jsonify, request
+from quart import Blueprint

-from shared.infrastructure.data_client import DATA_HEADER
-from sqlalchemy import select
-from shared.models import User
+from shared.infrastructure.query_blueprint import create_data_blueprint


 def register() -> Blueprint:
-    bp = Blueprint("data", __name__, url_prefix="/internal/data")
-
-    @bp.before_request
-    async def _require_data_header():
-        if not request.headers.get(DATA_HEADER):
-            return jsonify({"error": "forbidden"}), 403
-        from shared.infrastructure.internal_auth import validate_internal_request
-        if not validate_internal_request():
-            return jsonify({"error": "forbidden"}), 403
-
-    _handlers: dict[str, object] = {}
-
-    @bp.get("/<query_name>")
-    async def handle_query(query_name: str):
-        handler = _handlers.get(query_name)
-        if handler is None:
-            return jsonify({"error": "unknown query"}), 404
-        result = await handler()
-        return jsonify(result)
-
-    # --- user-by-email ---
-    async def _user_by_email():
-        """Return user_id for a given email address."""
-        email = request.args.get("email", "").strip().lower()
-        if not email:
-            return None
-        result = await g.s.execute(
-            select(User.id).where(User.email.ilike(email))
-        )
-        row = result.first()
-        if not row:
-            return None
-        return {"user_id": row[0]}
-
-    _handlers["user-by-email"] = _user_by_email
-
-    # --- newsletters ---
-    async def _newsletters():
-        """Return all Ghost newsletters (for blog post editor)."""
-        from shared.models.ghost_membership_entities import GhostNewsletter
-        result = await g.s.execute(
-            select(GhostNewsletter.id, GhostNewsletter.ghost_id, GhostNewsletter.name, GhostNewsletter.slug)
-            .order_by(GhostNewsletter.name)
-        )
-        return [
-            {"id": row[0], "ghost_id": row[1], "name": row[2], "slug": row[3]}
-            for row in result.all()
-        ]
-
-    _handlers["newsletters"] = _newsletters
-
+    bp, _handlers = create_data_blueprint("account")
    return bp
--- a/account/queries.sx
+++ b/account/queries.sx
@@ -0,0 +1,9 @@
+;; Account service — inter-service data queries
+
+(defquery user-by-email (&key email)
+  "Return user_id for a given email address."
+  (service "account" "user-by-email" :email email))
+
+(defquery newsletters ()
+  "Return all Ghost newsletters."
+  (service "account" "newsletters"))
--- a/account/services/init.py
+++ b/account/services/init.py
@@ -3,9 +3,10 @@ from __future__ import annotations


 def register_domain_services() -> None:
-    """Register services for the account app.
+    """Register services for the account app."""
+    from shared.services.registry import services
+    from .account_page import AccountPageService
+    services.register("account_page", AccountPageService())

-    Account is a consumer-only dashboard app. It has no own domain.
-    All cross-app data comes via fragments and HTTP data endpoints.
-    """
-    pass
+    from shared.services.account_impl import SqlAccountDataService
+    services.register("account", SqlAccountDataService())
--- a/account/services/account_page.py
+++ b/account/services/account_page.py
@@ -0,0 +1,40 @@
+"""Account page data service — provides serialized dicts for .sx defpages."""
+from __future__ import annotations
+
+
+class AccountPageService:
+    """Service for account page data, callable via (service "account-page" ...)."""
+
+    async def newsletters_data(self, session, **kw):
+        """Return newsletter list with user subscription status."""
+        from quart import g
+        from sqlalchemy import select
+        from shared.models import UserNewsletter
+        from shared.models.ghost_membership_entities import GhostNewsletter
+
+        result = await session.execute(
+            select(GhostNewsletter).order_by(GhostNewsletter.name)
+        )
+        all_newsletters = result.scalars().all()
+
+        sub_result = await session.execute(
+            select(UserNewsletter).where(
+                UserNewsletter.user_id == g.user.id,
+            )
+        )
+        user_subs = {un.newsletter_id: un for un in sub_result.scalars().all()}
+
+        newsletter_list = []
+        for nl in all_newsletters:
+            un = user_subs.get(nl.id)
+            newsletter_list.append({
+                "newsletter": {"id": nl.id, "name": nl.name, "description": nl.description},
+                "un": {"newsletter_id": un.newsletter_id, "subscribed": un.subscribed} if un else None,
+                "subscribed": un.subscribed if un else False,
+            })
+
+        from shared.infrastructure.urls import account_url
+        return {
+            "newsletter_list": newsletter_list,
+            "account_url": account_url(""),
+        }
--- a/account/sx/auth.sx
+++ b/account/sx/auth.sx
@@ -27,3 +27,25 @@
    (h1 :class "text-2xl font-bold mb-4" "Device authorized")
    (p :class "text-stone-600" "You can close this window and return to your terminal.")))

+;; Assembled auth page content — replaces Python _login_page_content etc.
+
+(defcomp ~account-login-content (&key error email)
+  (~auth-login-form
+    :error (when error (~auth-error-banner :error error))
+    :action (url-for "auth.start_login")
+    :csrf-token (csrf-token)
+    :email (or email "")))
+
+(defcomp ~account-device-content (&key error code)
+  (~account-device-form
+    :error (when error (~account-device-error :error error))
+    :action (url-for "auth.device_submit")
+    :csrf-token (csrf-token)
+    :code (or code "")))
+
+(defcomp ~account-check-email-content (&key email email-error)
+  (~auth-check-email
+    :email (escape (or email ""))
+    :error (when email-error
+             (~auth-check-email-error :error (escape email-error)))))
+
--- a/account/sx/dashboard.sx
+++ b/account/sx/dashboard.sx
@@ -41,3 +41,20 @@
          name)
        logout)
      labels)))
+
+;; Assembled dashboard content — replaces Python _account_main_panel_sx
+(defcomp ~account-dashboard-content (&key error)
+  (let* ((user (current-user))
+         (csrf (csrf-token)))
+    (~account-main-panel
+      :error (when error (~account-error-banner :error error))
+      :email (when (get user "email")
+               (~account-user-email :email (get user "email")))
+      :name (when (get user "name")
+              (~account-user-name :name (get user "name")))
+      :logout (~account-logout-form :csrf-token csrf)
+      :labels (when (not (empty? (or (get user "labels") (list))))
+                (~account-labels-section
+                  :items (map (lambda (label)
+                    (~account-label-item :name (get label "name")))
+                    (get user "labels")))))))
--- a/account/sx/layouts.sx
+++ b/account/sx/layouts.sx
@@ -0,0 +1,20 @@
+;; Account layout defcomps — fully self-contained via IO primitives.
+;; Registered via register_sx_layout("account", ...) in __init__.py.
+
+;; Full page: root header + auth header row in header-child
+(defcomp ~account-layout-full ()
+  (<> (~root-header-auto)
+    (~header-child-sx
+      :inner (~auth-header-row-auto))))
+
+;; OOB (HTMX): auth row + root header, both with oob=true
+(defcomp ~account-layout-oob ()
+  (<> (~auth-header-row-auto true)
+    (~root-header-auto true)))
+
+;; Mobile menu: auth section + root nav
+(defcomp ~account-layout-mobile ()
+  (<> (~mobile-menu-section
+        :label "account" :href "/" :level 1 :colour "sky"
+        :items (~auth-nav-items-auto))
+    (~root-mobile-auto)))
--- a/account/sx/newsletters.sx
+++ b/account/sx/newsletters.sx
@@ -29,3 +29,34 @@
    (div :class "bg-white/70 backdrop-blur rounded-2xl shadow border border-stone-200 p-6 sm:p-8 space-y-6"
      (h1 :class "text-xl font-semibold tracking-tight" "Newsletters")
      list)))
+
+;; Assembled newsletters content — replaces Python _newsletters_panel_sx
+;; Takes pre-fetched newsletter-list from page helper
+(defcomp ~account-newsletters-content (&key newsletter-list account-url)
+  (let* ((csrf (csrf-token)))
+    (if (empty? newsletter-list)
+      (~account-newsletter-empty)
+      (~account-newsletters-panel
+        :list (~account-newsletter-list
+          :items (map (lambda (item)
+            (let* ((nl (get item "newsletter"))
+                   (un (get item "un"))
+                   (nid (get nl "id"))
+                   (subscribed (get item "subscribed"))
+                   (toggle-url (str (or account-url "") "/newsletter/" nid "/toggle/"))
+                   (bg (if subscribed "bg-emerald-500" "bg-stone-300"))
+                   (translate (if subscribed "translate-x-6" "translate-x-1"))
+                   (checked (if subscribed "true" "false")))
+              (~account-newsletter-item
+                :name (get nl "name")
+                :desc (when (get nl "description")
+                        (~account-newsletter-desc :description (get nl "description")))
+                :toggle (~account-newsletter-toggle
+                  :id (str "nl-" nid)
+                  :url toggle-url
+                  :hdrs (str "{\"X-CSRFToken\": \"" csrf "\"}")
+                  :target (str "#nl-" nid)
+                  :cls (str "relative inline-flex h-6 w-11 items-center rounded-full transition-colors focus:outline-none focus:ring-2 focus:ring-emerald-500 focus:ring-offset-2 " bg)
+                  :checked checked
+                  :knob-cls (str "inline-block h-4 w-4 rounded-full bg-white shadow transform transition-transform " translate)))))
+            newsletter-list))))))
--- a/account/sx/sx_components.py
+++ b/account/sx/sx_components.py
@@ -1,339 +0,0 @@
-"""
-Account service s-expression page components.
-
-Renders account dashboard, newsletters, fragment pages, login, and device
-auth pages.  Called from route handlers in place of ``render_template()``.
-"""
-from __future__ import annotations
-
-import os
-from typing import Any
-
-from shared.sx.jinja_bridge import load_service_components
-from shared.sx.helpers import (
-    call_url, sx_call, SxExpr,
-    root_header_sx, full_page_sx,
-)
-
-# Load account-specific .sx components + handlers at import time
-load_service_components(os.path.dirname(os.path.dirname(__file__)),
-                        service_name="account")
-
-
-# ---------------------------------------------------------------------------
-# Header helpers
-# ---------------------------------------------------------------------------
-
-def _auth_nav_sx(ctx: dict) -> str:
-    """Auth section desktop nav items."""
-    parts = [
-        sx_call("nav-link",
-            href=call_url(ctx, "account_url", "/newsletters/"),
-            label="newsletters",
-            select_colours=ctx.get("select_colours", ""),
-        )
-    ]
-    account_nav = ctx.get("account_nav")
-    if account_nav:
-        parts.append(account_nav)
-    return "(<> " + " ".join(parts) + ")"
-
-
-def _auth_header_sx(ctx: dict, *, oob: bool = False) -> str:
-    """Build the account section header row."""
-    return sx_call(
-        "menu-row-sx",
-        id="auth-row", level=1, colour="sky",
-        link_href=call_url(ctx, "account_url", "/"),
-        link_label="account", icon="fa-solid fa-user",
-        nav=SxExpr(_auth_nav_sx(ctx)),
-        child_id="auth-header-child", oob=oob,
-    )
-
-
-def _auth_nav_mobile_sx(ctx: dict) -> str:
-    """Mobile nav menu for auth section."""
-    parts = [
-        sx_call("nav-link",
-            href=call_url(ctx, "account_url", "/newsletters/"),
-            label="newsletters",
-            select_colours=ctx.get("select_colours", ""),
-        )
-    ]
-    account_nav = ctx.get("account_nav")
-    if account_nav:
-        parts.append(account_nav)
-    return "(<> " + " ".join(parts) + ")"
-
-
-# ---------------------------------------------------------------------------
-# Account dashboard (GET /)
-# ---------------------------------------------------------------------------
-
-def _account_main_panel_sx(ctx: dict) -> str:
-    """Account info panel with user details and logout."""
-    from quart import g
-    from shared.browser.app.csrf import generate_csrf_token
-
-    user = getattr(g, "user", None)
-    error = ctx.get("error", "")
-
-    error_sx = sx_call("account-error-banner", error=error) if error else ""
-
-    user_email_sx = ""
-    user_name_sx = ""
-    if user:
-        user_email_sx = sx_call("account-user-email", email=user.email)
-        if user.name:
-            user_name_sx = sx_call("account-user-name", name=user.name)
-
-    logout_sx = sx_call("account-logout-form", csrf_token=generate_csrf_token())
-
-    labels_sx = ""
-    if user and hasattr(user, "labels") and user.labels:
-        label_items = " ".join(
-            sx_call("account-label-item", name=label.name)
-            for label in user.labels
-        )
-        labels_sx = sx_call("account-labels-section",
-                                items=SxExpr("(<> " + label_items + ")"))
-
-    return sx_call(
-        "account-main-panel",
-        error=SxExpr(error_sx) if error_sx else None,
-        email=SxExpr(user_email_sx) if user_email_sx else None,
-        name=SxExpr(user_name_sx) if user_name_sx else None,
-        logout=SxExpr(logout_sx),
-        labels=SxExpr(labels_sx) if labels_sx else None,
-    )
-
-
-# ---------------------------------------------------------------------------
-# Newsletters (GET /newsletters/)
-# ---------------------------------------------------------------------------
-
-def _newsletter_toggle_sx(un: Any, account_url_fn: Any, csrf_token: str) -> str:
-    """Render a single newsletter toggle switch."""
-    nid = un.newsletter_id
-    toggle_url = account_url_fn(f"/newsletter/{nid}/toggle/")
-    if un.subscribed:
-        bg = "bg-emerald-500"
-        translate = "translate-x-6"
-        checked = "true"
-    else:
-        bg = "bg-stone-300"
-        translate = "translate-x-1"
-        checked = "false"
-    return sx_call(
-        "account-newsletter-toggle",
-        id=f"nl-{nid}", url=toggle_url,
-        hdrs=f'{{"X-CSRFToken": "{csrf_token}"}}',
-        target=f"#nl-{nid}",
-        cls=f"relative inline-flex h-6 w-11 items-center rounded-full transition-colors focus:outline-none focus:ring-2 focus:ring-emerald-500 focus:ring-offset-2 {bg}",
-        checked=checked,
-        knob_cls=f"inline-block h-4 w-4 rounded-full bg-white shadow transform transition-transform {translate}",
-    )
-
-
-def _newsletter_toggle_off_sx(nid: int, toggle_url: str, csrf_token: str) -> str:
-    """Render an unsubscribed newsletter toggle (no subscription record yet)."""
-    return sx_call(
-        "account-newsletter-toggle",
-        id=f"nl-{nid}", url=toggle_url,
-        hdrs=f'{{"X-CSRFToken": "{csrf_token}"}}',
-        target=f"#nl-{nid}",
-        cls="relative inline-flex h-6 w-11 items-center rounded-full transition-colors focus:outline-none focus:ring-2 focus:ring-emerald-500 focus:ring-offset-2 bg-stone-300",
-        checked="false",
-        knob_cls="inline-block h-4 w-4 rounded-full bg-white shadow transform transition-transform translate-x-1",
-    )
-
-
-def _newsletters_panel_sx(ctx: dict, newsletter_list: list) -> str:
-    """Newsletters management panel."""
-    from shared.browser.app.csrf import generate_csrf_token
-
-    account_url_fn = ctx.get("account_url") or (lambda p: p)
-    csrf = generate_csrf_token()
-
-    if newsletter_list:
-        items = []
-        for item in newsletter_list:
-            nl = item["newsletter"]
-            un = item.get("un")
-
-            desc_sx = sx_call(
-                "account-newsletter-desc", description=nl.description
-            ) if nl.description else ""
-
-            if un:
-                toggle = _newsletter_toggle_sx(un, account_url_fn, csrf)
-            else:
-                toggle_url = account_url_fn(f"/newsletter/{nl.id}/toggle/")
-                toggle = _newsletter_toggle_off_sx(nl.id, toggle_url, csrf)
-
-            items.append(sx_call(
-                "account-newsletter-item",
-                name=nl.name,
-                desc=SxExpr(desc_sx) if desc_sx else None,
-                toggle=SxExpr(toggle),
-            ))
-        list_sx = sx_call(
-            "account-newsletter-list",
-            items=SxExpr("(<> " + " ".join(items) + ")"),
-        )
-    else:
-        list_sx = sx_call("account-newsletter-empty")
-
-    return sx_call("account-newsletters-panel", list=SxExpr(list_sx))
-
-
-# ---------------------------------------------------------------------------
-# Auth pages (login, device, check_email)
-# ---------------------------------------------------------------------------
-
-def _login_page_content(ctx: dict) -> str:
-    """Login form content."""
-    from shared.browser.app.csrf import generate_csrf_token
-    from quart import url_for
-
-    error = ctx.get("error", "")
-    email = ctx.get("email", "")
-    action = url_for("auth.start_login")
-
-    error_sx = sx_call("auth-error-banner", error=error) if error else ""
-
-    return sx_call(
-        "auth-login-form",
-        error=SxExpr(error_sx) if error_sx else None,
-        action=action,
-        csrf_token=generate_csrf_token(), email=email,
-    )
-
-
-def _device_page_content(ctx: dict) -> str:
-    """Device authorization form content."""
-    from shared.browser.app.csrf import generate_csrf_token
-    from quart import url_for
-
-    error = ctx.get("error", "")
-    code = ctx.get("code", "")
-    action = url_for("auth.device_submit")
-
-    error_sx = sx_call("account-device-error", error=error) if error else ""
-
-    return sx_call(
-        "account-device-form",
-        error=SxExpr(error_sx) if error_sx else None,
-        action=action,
-        csrf_token=generate_csrf_token(), code=code,
-    )
-
-
-def _device_approved_content() -> str:
-    """Device approved success content."""
-    return sx_call("account-device-approved")
-
-
-# ---------------------------------------------------------------------------
-# Public API: Account dashboard
-# ---------------------------------------------------------------------------
-
-
-
-
-
-def _fragment_content(frag: object) -> str:
-    """Convert a fragment response to sx content string.
-
-    SxExpr (from text/sx responses) is embedded as-is; plain strings
-    (from text/html) are wrapped in ``~rich-text``.
-    """
-    from shared.sx.parser import SxExpr
-    if isinstance(frag, SxExpr):
-        return frag.source
-    s = str(frag) if frag else ""
-    if not s:
-        return ""
-    return f'(~rich-text :html "{_sx_escape(s)}")'
-
-
-# ---------------------------------------------------------------------------
-# Public API: Auth pages (login, device)
-# ---------------------------------------------------------------------------
-
-async def render_login_page(ctx: dict) -> str:
-    """Full page: login form."""
-    hdr = root_header_sx(ctx)
-    return full_page_sx(ctx, header_rows=hdr,
-                          content=_login_page_content(ctx),
-                          meta_html='<title>Login \u2014 Rose Ash</title>')
-
-
-async def render_device_page(ctx: dict) -> str:
-    """Full page: device authorization form."""
-    hdr = root_header_sx(ctx)
-    return full_page_sx(ctx, header_rows=hdr,
-                          content=_device_page_content(ctx),
-                          meta_html='<title>Authorize Device \u2014 Rose Ash</title>')
-
-
-async def render_device_approved_page(ctx: dict) -> str:
-    """Full page: device approved."""
-    hdr = root_header_sx(ctx)
-    return full_page_sx(ctx, header_rows=hdr,
-                          content=_device_approved_content(),
-                          meta_html='<title>Device Authorized \u2014 Rose Ash</title>')
-
-
-# ---------------------------------------------------------------------------
-# Public API: Check email page (POST /start/ success)
-# ---------------------------------------------------------------------------
-
-def _check_email_content(email: str, email_error: str | None = None) -> str:
-    """Check email confirmation content."""
-    from markupsafe import escape
-
-    error_sx = sx_call(
-        "auth-check-email-error", error=str(escape(email_error))
-    ) if email_error else ""
-
-    return sx_call(
-        "auth-check-email",
-        email=str(escape(email)),
-        error=SxExpr(error_sx) if error_sx else None,
-    )
-
-
-async def render_check_email_page(ctx: dict) -> str:
-    """Full page: check email after magic link sent."""
-    email = ctx.get("email", "")
-    email_error = ctx.get("email_error")
-    hdr = root_header_sx(ctx)
-    return full_page_sx(ctx, header_rows=hdr,
-                          content=_check_email_content(email, email_error),
-                          meta_html='<title>Check your email \u2014 Rose Ash</title>')
-
-
-# ---------------------------------------------------------------------------
-# Public API: Fragment renderers for POST handlers
-# ---------------------------------------------------------------------------
-
-
-def render_newsletter_toggle(un) -> str:
-    """Render a newsletter toggle switch for POST response (uses account_url)."""
-    from shared.browser.app.csrf import generate_csrf_token
-    from quart import g
-    account_url_fn = getattr(g, "_account_url", None)
-    if account_url_fn is None:
-        from shared.infrastructure.urls import account_url
-        account_url_fn = account_url
-    return _newsletter_toggle_sx(un, account_url_fn, generate_csrf_token())
-
-
-# ---------------------------------------------------------------------------
-# Internal helpers
-# ---------------------------------------------------------------------------
-
-def _sx_escape(s: str) -> str:
-    """Escape a string for embedding in sx string literals."""
-    return s.replace("\\", "\\\\").replace('"', '\\"')
--- a/account/sxc/pages/init.py
+++ b/account/sxc/pages/init.py
@@ -1,13 +1,10 @@
-"""Account defpage setup — registers layouts, page helpers, and loads .sx pages."""
+"""Account defpage setup — registers layouts and loads .sx pages."""
 from __future__ import annotations

-from typing import Any
-

 def setup_account_pages() -> None:
-    """Register account-specific layouts, page helpers, and load page definitions."""
+    """Register account-specific layouts and load page definitions."""
    _register_account_layouts()
-    _register_account_helpers()
    _load_account_page_files()


@@ -17,118 +14,6 @@ def _load_account_page_files() -> None:
    load_page_dir(os.path.dirname(__file__), "account")


-# ---------------------------------------------------------------------------
-# Layouts
-# ---------------------------------------------------------------------------
-
 def _register_account_layouts() -> None:
-    from shared.sx.layouts import register_custom_layout
-    register_custom_layout("account", _account_full, _account_oob, _account_mobile)
-
-
-def _account_full(ctx: dict, **kw: Any) -> str:
-    from shared.sx.helpers import root_header_sx, header_child_sx
-    from sx.sx_components import _auth_header_sx
-
-    root_hdr = root_header_sx(ctx)
-    hdr_child = header_child_sx(_auth_header_sx(ctx))
-    return "(<> " + root_hdr + " " + hdr_child + ")"
-
-
-def _account_oob(ctx: dict, **kw: Any) -> str:
-    from shared.sx.helpers import root_header_sx
-    from sx.sx_components import _auth_header_sx
-
-    return "(<> " + _auth_header_sx(ctx, oob=True) + " " + root_header_sx(ctx, oob=True) + ")"
-
-
-def _account_mobile(ctx: dict, **kw: Any) -> str:
-    from shared.sx.helpers import mobile_menu_sx, mobile_root_nav_sx, sx_call, SxExpr
-    from sx.sx_components import _auth_nav_mobile_sx
-    ctx = _inject_account_nav(ctx)
-    auth_section = sx_call("mobile-menu-section",
-        label="account", href="/", level=1, colour="sky",
-        items=SxExpr(_auth_nav_mobile_sx(ctx)))
-    return mobile_menu_sx(auth_section, mobile_root_nav_sx(ctx))
-
-
-def _inject_account_nav(ctx: dict) -> dict:
-    """Ensure account_nav is in ctx from g.account_nav."""
-    if "account_nav" not in ctx:
-        from quart import g
-        ctx = dict(ctx)
-        ctx["account_nav"] = getattr(g, "account_nav", "")
-    return ctx
-
-
-# ---------------------------------------------------------------------------
-# Page helpers
-# ---------------------------------------------------------------------------
-
-def _register_account_helpers() -> None:
-    from shared.sx.pages import register_page_helpers
-
-    register_page_helpers("account", {
-        "account-content": _h_account_content,
-        "newsletters-content": _h_newsletters_content,
-        "fragment-content": _h_fragment_content,
-    })
-
-
-def _h_account_content(**kw):
-    from sx.sx_components import _account_main_panel_sx
-    return _account_main_panel_sx({})
-
-
-async def _h_newsletters_content(**kw):
-    from quart import g
-    from sqlalchemy import select
-    from shared.models import UserNewsletter
-    from shared.models.ghost_membership_entities import GhostNewsletter
-
-    result = await g.s.execute(
-        select(GhostNewsletter).order_by(GhostNewsletter.name)
-    )
-    all_newsletters = result.scalars().all()
-
-    sub_result = await g.s.execute(
-        select(UserNewsletter).where(
-            UserNewsletter.user_id == g.user.id,
-        )
-    )
-    user_subs = {un.newsletter_id: un for un in sub_result.scalars().all()}
-
-    newsletter_list = []
-    for nl in all_newsletters:
-        un = user_subs.get(nl.id)
-        newsletter_list.append({
-            "newsletter": nl,
-            "un": un,
-            "subscribed": un.subscribed if un else False,
-        })
-
-    if not newsletter_list:
-        from shared.sx.helpers import sx_call
-        return sx_call("account-newsletter-empty")
-    from sx.sx_components import _newsletters_panel_sx
-    ctx = {"account_url": getattr(g, "_account_url", None)}
-    if ctx["account_url"] is None:
-        from shared.infrastructure.urls import account_url
-        ctx["account_url"] = account_url
-    return _newsletters_panel_sx(ctx, newsletter_list)
-
-
-async def _h_fragment_content(slug=None, **kw):
-    from quart import g, abort
-    from shared.infrastructure.fragments import fetch_fragment
-
-    if not slug or not g.get("user"):
-        return ""
-    fragment_html = await fetch_fragment(
-        "events", "account-page",
-        params={"slug": slug, "user_id": str(g.user.id)},
-    )
-    if not fragment_html:
-        abort(404)
-    from sx.sx_components import _fragment_content
-    return _fragment_content(fragment_html)
+    from shared.sx.layouts import register_sx_layout
+    register_sx_layout("account", "account-layout-full", "account-layout-oob", "account-layout-mobile")
--- a/account/sxc/pages/account.sx
+++ b/account/sxc/pages/account.sx
@@ -8,7 +8,7 @@
  :path "/"
  :auth :login
  :layout :account
-  :content (account-content))
+  :content (~account-dashboard-content))

 ;; ---------------------------------------------------------------------------
 ;; Newsletters
@@ -18,7 +18,10 @@
  :path "/newsletters/"
  :auth :login
  :layout :account
-  :content (newsletters-content))
+  :data (service "account-page" "newsletters-data")
+  :content (~account-newsletters-content
+    :newsletter-list newsletter-list
+    :account-url account-url))

 ;; ---------------------------------------------------------------------------
 ;; Fragment pages (tickets, bookings, etc. from events service)
@@ -28,4 +31,10 @@
  :path "/<slug>/"
  :auth :login
  :layout :account
-  :content (fragment-content slug))
+  :content (let* ((user (current-user))
+                  (result (frag "events" "account-page"
+                            :slug slug
+                            :user-id (str (get user "id")))))
+             (if (or (nil? result) (empty? result))
+               (abort 404)
+               result)))
--- a/blog/actions.sx
+++ b/blog/actions.sx
@@ -0,0 +1,12 @@
+;; Blog service — inter-service action endpoints
+
+(defaction update-page-config (&key container-type container-id
+                                features sumup-merchant-code
+                                sumup-checkout-prefix sumup-api-key)
+  "Create or update a PageConfig with features and SumUp settings."
+  (service "page-config" "update"
+    :container-type container-type :container-id container-id
+    :features features
+    :sumup-merchant-code sumup-merchant-code
+    :sumup-checkout-prefix sumup-checkout-prefix
+    :sumup-api-key sumup-api-key))
--- a/blog/app.py
+++ b/blog/app.py
@@ -1,6 +1,5 @@
 from __future__ import annotations
 import path_setup  # noqa: F401  # adds shared/ to sys.path
-import sx.sx_components as sx_components  # noqa: F401  # ensure Hypercorn --reload watches this file
 from pathlib import Path

 from quart import g, request
--- a/blog/bp/actions/routes.py
+++ b/blog/bp/actions/routes.py
@@ -1,96 +1,14 @@
 """Blog app action endpoints.

-Exposes write operations at ``/internal/actions/<action_name>`` for
-cross-app callers via the internal action client.
+All actions are defined in ``blog/actions.sx``.
 """
 from __future__ import annotations

-from quart import Blueprint, g, jsonify, request
+from quart import Blueprint

-from shared.infrastructure.actions import ACTION_HEADER
+from shared.infrastructure.query_blueprint import create_action_blueprint


 def register() -> Blueprint:
-    bp = Blueprint("actions", __name__, url_prefix="/internal/actions")
-
-    @bp.before_request
-    async def _require_action_header():
-        if not request.headers.get(ACTION_HEADER):
-            return jsonify({"error": "forbidden"}), 403
-        from shared.infrastructure.internal_auth import validate_internal_request
-        if not validate_internal_request():
-            return jsonify({"error": "forbidden"}), 403
-
-    _handlers: dict[str, object] = {}
-
-    @bp.post("/<action_name>")
-    async def handle_action(action_name: str):
-        handler = _handlers.get(action_name)
-        if handler is None:
-            return jsonify({"error": "unknown action"}), 404
-        result = await handler()
-        return jsonify(result or {"ok": True})
-
-    # --- update-page-config ---
-    async def _update_page_config():
-        """Create or update a PageConfig (page_configs now lives in db_blog)."""
-        from shared.models.page_config import PageConfig
-        from sqlalchemy import select
-        from sqlalchemy.orm.attributes import flag_modified
-
-        data = await request.get_json(force=True)
-        container_type = data.get("container_type", "page")
-        container_id = data.get("container_id")
-        if container_id is None:
-            return {"error": "container_id required"}, 400
-
-        pc = (await g.s.execute(
-            select(PageConfig).where(
-                PageConfig.container_type == container_type,
-                PageConfig.container_id == container_id,
-            )
-        )).scalar_one_or_none()
-
-        if pc is None:
-            pc = PageConfig(
-                container_type=container_type,
-                container_id=container_id,
-                features=data.get("features", {}),
-            )
-            g.s.add(pc)
-            await g.s.flush()
-
-        if "features" in data:
-            features = dict(pc.features or {})
-            for key, val in data["features"].items():
-                if isinstance(val, bool):
-                    features[key] = val
-                elif val in ("true", "1", "on"):
-                    features[key] = True
-                elif val in ("false", "0", "off", None):
-                    features[key] = False
-            pc.features = features
-            flag_modified(pc, "features")
-
-        if "sumup_merchant_code" in data:
-            pc.sumup_merchant_code = data["sumup_merchant_code"] or None
-        if "sumup_checkout_prefix" in data:
-            pc.sumup_checkout_prefix = data["sumup_checkout_prefix"] or None
-        if "sumup_api_key" in data:
-            pc.sumup_api_key = data["sumup_api_key"] or None
-
-        await g.s.flush()
-
-        return {
-            "id": pc.id,
-            "container_type": pc.container_type,
-            "container_id": pc.container_id,
-            "features": pc.features or {},
-            "sumup_merchant_code": pc.sumup_merchant_code,
-            "sumup_checkout_prefix": pc.sumup_checkout_prefix,
-            "sumup_configured": bool(pc.sumup_api_key),
-        }
-
-    _handlers["update-page-config"] = _update_page_config
-
+    bp, _handlers = create_action_blueprint("blog")
    return bp
--- a/blog/bp/blog/routes.py
+++ b/blog/bp/blog/routes.py
@@ -21,7 +21,7 @@ from .services.pages_data import pages_data
 from shared.browser.app.redis_cacher import cache_page, invalidate_tag_cache
 from shared.browser.app.utils.htmx import is_htmx_request
 from shared.browser.app.authz import require_admin
-from shared.sx.helpers import sx_response
+from shared.sx.helpers import sx_response, sx_call
 from shared.utils import host_url

 def register(url_prefix, title):
@@ -62,6 +62,19 @@ def register(url_prefix, title):
        "unsplash_api_key": os.environ.get("UNSPLASH_ACCESS_KEY", ""),
      }

+    async def _render_new_post_page(tctx):
+        """Compose a full page with blog header for new post/page creation."""
+        from shared.sx.helpers import root_header_sx, full_page_sx
+        from shared.sx.parser import SxExpr
+        root_hdr = await root_header_sx(tctx)
+        blog_hdr = sx_call("menu-row-sx",
+            id="blog-row", level=1,
+            link_label_content=SxExpr("(div)"),
+            child_id="blog-header-child")
+        header_rows = "(<> " + root_hdr + " " + blog_hdr + ")"
+        content = tctx.get("editor_html", "")
+        return await full_page_sx(tctx, header_rows=header_rows, content=content)
+
    SORT_MAP = {
      "newest":   "published_at DESC",
      "oldest":   "published_at ASC",
@@ -118,100 +131,83 @@ def register(url_prefix, title):
          ctx["page_cart_total"] = float(page_summary.total + page_summary.calendar_total + page_summary.ticket_total)

      from shared.sx.page import get_template_context
-      from sx.sx_components import render_home_page, render_home_oob
+      from shared.sx.helpers import (
+          sx_call, root_header_sx, full_page_sx, oob_page_sx,
+          post_header_sx, oob_header_sx, mobile_menu_sx,
+          post_mobile_nav_sx, mobile_root_nav_sx,
+      )
+      from shared.sx.parser import SxExpr
+      from shared.services.registry import services

      tctx = await get_template_context()
      tctx.update(ctx)
+
+      post = ctx.get("post", {})
+      content = sx_call("blog-home-main",
+          html_content=post.get("html", ""),
+          sx_content=SxExpr(post.get("sx_content", "")) if post.get("sx_content") else None)
+      meta_data = services.blog_page.post_meta_data(post, ctx.get("base_title", ""))
+      meta = sx_call("blog-meta", **meta_data)
+
      if not is_htmx_request():
-          html = await render_home_page(tctx)
+          root_hdr = await root_header_sx(tctx)
+          post_hdr = await post_header_sx(tctx)
+          header_rows = "(<> " + root_hdr + " " + post_hdr + ")"
+          menu = mobile_menu_sx(await post_mobile_nav_sx(tctx), await mobile_root_nav_sx(tctx))
+          html = await full_page_sx(tctx, header_rows=header_rows, content=content,
+                                    meta=meta, menu=menu)
          return await make_response(html)
      else:
-          sx_src = await render_home_oob(tctx)
+          root_hdr = await root_header_sx(tctx)
+          post_hdr = await post_header_sx(tctx)
+          rows = "(<> " + root_hdr + " " + post_hdr + ")"
+          header_oob = await oob_header_sx("root-header-child", "post-header-child", rows)
+          sx_src = await oob_page_sx(oobs=header_oob, content=content)
          return sx_response(sx_src)

    @blogs_bp.get("/index")
    @blogs_bp.get("/index/")
    async def index():
      """Blog listing — moved from / to /index."""
-
-      q = decode()
-      content_type = request.args.get("type", "posts")
-
-      if content_type == "pages":
-          data = await pages_data(g.s, q.page, q.search)
-          context = {
-              **data,
-              "content_type": "pages",
-              "search": q.search,
-              "selected_tags": (),
-              "selected_authors": (),
-              "selected_groups": (),
-              "sort": None,
-              "view": None,
-              "drafts": None,
-              "draft_count": 0,
-              "tags": [],
-              "authors": [],
-              "tag_groups": [],
-              "posts": data.get("pages", []),
-          }
-          from shared.sx.page import get_template_context
-          from sx.sx_components import render_blog_page, render_blog_oob, render_blog_page_cards
-
-          tctx = await get_template_context()
-          tctx.update(context)
-          if not is_htmx_request():
-              html = await render_blog_page(tctx)
-              return await make_response(html)
-          elif q.page > 1:
-              sx_src = await render_blog_page_cards(tctx)
-              return sx_response(sx_src)
-          else:
-              sx_src = await render_blog_oob(tctx)
-              return sx_response(sx_src)
-
-      # Default: posts listing
-      # Drafts filter requires login; ignore if not logged in
-      show_drafts = bool(q.drafts and g.user)
-      is_admin = bool((g.get("rights") or {}).get("admin"))
-      drafts_user_id = None if (not show_drafts or is_admin) else g.user.id
-
-      # For the draft count badge: admin sees all drafts, non-admin sees own
-      count_drafts_uid = None if (g.user and is_admin) else (g.user.id if g.user else False)
-
-      data = await posts_data(
-          g.s, q.page, q.search, q.sort, q.selected_tags, q.selected_authors, q.liked,
-          drafts=show_drafts, drafts_user_id=drafts_user_id,
-          count_drafts_for_user_id=count_drafts_uid,
-          selected_groups=q.selected_groups,
+      from shared.services.registry import services
+      from shared.sx.helpers import (
+          sx_call, root_header_sx, full_page_sx, oob_page_sx, oob_header_sx,
      )
+      from shared.sx.parser import SxExpr

-      context = {
-          **data,
-          "content_type": "posts",
-          "selected_tags": q.selected_tags,
-          "selected_authors": q.selected_authors,
-          "selected_groups": q.selected_groups,
-          "sort": q.sort,
-          "search": q.search,
-          "view": q.view,
-          "drafts": q.drafts if show_drafts else None,
-      }
+      def _blog_hdr(ctx, oob=False):
+          return sx_call("menu-row-sx",
+              id="blog-row", level=1,
+              link_label_content=SxExpr("(div)"),
+              child_id="blog-header-child", oob=oob)
+
+      data = await services.blog_page.index_data(g.s)
+
+      # Render content, aside, and filter via .sx defcomps
+      content = sx_call("blog-index-main-content", **data)
+      aside = sx_call("blog-index-aside-content", **data)
+      filter_sx = sx_call("blog-index-filter-content", **data)

      from shared.sx.page import get_template_context
-      from sx.sx_components import render_blog_page, render_blog_oob, render_blog_cards
-
      tctx = await get_template_context()
-      tctx.update(context)
+
      if not is_htmx_request():
-          html = await render_blog_page(tctx)
+          root_hdr = await root_header_sx(tctx)
+          blog_hdr = _blog_hdr(tctx)
+          header_rows = "(<> " + root_hdr + " " + blog_hdr + ")"
+          html = await full_page_sx(tctx, header_rows=header_rows,
+                                    content=content, aside=aside, filter=filter_sx)
          return await make_response(html)
-      elif q.page > 1:
-          # Sx wire format — client renders blog cards
-          sx_src = await render_blog_cards(tctx)
-          return sx_response(sx_src)
+      elif data.get("page", 1) > 1:
+          # Pagination — return just the cards
+          return sx_response(content)
      else:
-          sx_src = await render_blog_oob(tctx)
+          root_hdr = await root_header_sx(tctx)
+          blog_hdr = _blog_hdr(tctx)
+          rows = "(<> " + root_hdr + " " + blog_hdr + ")"
+          header_oob = await oob_header_sx("root-header-child", "blog-header-child", rows)
+          sx_src = await oob_page_sx(oobs=header_oob, content=content,
+                                     aside=aside, filter=filter_sx)
          return sx_response(sx_src)

    @blogs_bp.post("/new/")
@@ -233,19 +229,19 @@ def register(url_prefix, title):
        lexical_doc = json.loads(lexical_raw)
      except (json.JSONDecodeError, TypeError):
        from shared.sx.page import get_template_context
-        from sx.sx_components import render_new_post_page, render_editor_panel
+        from sxc.pages.renders import render_editor_panel
        tctx = await get_template_context()
        tctx["editor_html"] = render_editor_panel(save_error="Invalid JSON in editor content.")
-        html = await render_new_post_page(tctx)
+        html = await _render_new_post_page(tctx)
        return await make_response(html, 400)

      ok, reason = validate_lexical(lexical_doc)
      if not ok:
        from shared.sx.page import get_template_context
-        from sx.sx_components import render_new_post_page, render_editor_panel
+        from sxc.pages.renders import render_editor_panel
        tctx = await get_template_context()
        tctx["editor_html"] = render_editor_panel(save_error=reason)
-        html = await render_new_post_page(tctx)
+        html = await _render_new_post_page(tctx)
        return await make_response(html, 400)

      # Create directly in db_blog
@@ -289,21 +285,21 @@ def register(url_prefix, title):
        lexical_doc = json.loads(lexical_raw)
      except (json.JSONDecodeError, TypeError):
        from shared.sx.page import get_template_context
-        from sx.sx_components import render_new_post_page, render_editor_panel
+        from sxc.pages.renders import render_editor_panel
        tctx = await get_template_context()
        tctx["editor_html"] = render_editor_panel(save_error="Invalid JSON in editor content.", is_page=True)
        tctx["is_page"] = True
-        html = await render_new_post_page(tctx)
+        html = await _render_new_post_page(tctx)
        return await make_response(html, 400)

      ok, reason = validate_lexical(lexical_doc)
      if not ok:
        from shared.sx.page import get_template_context
-        from sx.sx_components import render_new_post_page, render_editor_panel
+        from sxc.pages.renders import render_editor_panel
        tctx = await get_template_context()
        tctx["editor_html"] = render_editor_panel(save_error=reason, is_page=True)
        tctx["is_page"] = True
-        html = await render_new_post_page(tctx)
+        html = await _render_new_post_page(tctx)
        return await make_response(html, 400)

      # Create directly in db_blog
--- a/blog/bp/data/routes.py
+++ b/blog/bp/data/routes.py
@@ -1,185 +1,14 @@
 """Blog app data endpoints.

-Exposes read-only JSON queries at ``/internal/data/<query_name>`` for
-cross-app callers via the internal data client.
+All queries are defined in ``blog/queries.sx``.
 """
 from __future__ import annotations

-from quart import Blueprint, g, jsonify, request
+from quart import Blueprint

-from shared.infrastructure.data_client import DATA_HEADER
-from shared.contracts.dtos import dto_to_dict
-from services import blog_service
+from shared.infrastructure.query_blueprint import create_data_blueprint


 def register() -> Blueprint:
-    bp = Blueprint("data", __name__, url_prefix="/internal/data")
-
-    @bp.before_request
-    async def _require_data_header():
-        if not request.headers.get(DATA_HEADER):
-            return jsonify({"error": "forbidden"}), 403
-        from shared.infrastructure.internal_auth import validate_internal_request
-        if not validate_internal_request():
-            return jsonify({"error": "forbidden"}), 403
-
-    _handlers: dict[str, object] = {}
-
-    @bp.get("/<query_name>")
-    async def handle_query(query_name: str):
-        handler = _handlers.get(query_name)
-        if handler is None:
-            return jsonify({"error": "unknown query"}), 404
-        result = await handler()
-        return jsonify(result)
-
-    # --- post-by-slug ---
-    async def _post_by_slug():
-        slug = request.args.get("slug", "")
-        post = await blog_service.get_post_by_slug(g.s, slug)
-        if not post:
-            return None
-        return dto_to_dict(post)
-
-    _handlers["post-by-slug"] = _post_by_slug
-
-    # --- post-by-id ---
-    async def _post_by_id():
-        post_id = int(request.args.get("id", 0))
-        post = await blog_service.get_post_by_id(g.s, post_id)
-        if not post:
-            return None
-        return dto_to_dict(post)
-
-    _handlers["post-by-id"] = _post_by_id
-
-    # --- posts-by-ids ---
-    async def _posts_by_ids():
-        ids_raw = request.args.get("ids", "")
-        if not ids_raw:
-            return []
-        ids = [int(x.strip()) for x in ids_raw.split(",") if x.strip()]
-        posts = await blog_service.get_posts_by_ids(g.s, ids)
-        return [dto_to_dict(p) for p in posts]
-
-    _handlers["posts-by-ids"] = _posts_by_ids
-
-    # --- search-posts ---
-    async def _search_posts():
-        query = request.args.get("query", "")
-        page = int(request.args.get("page", 1))
-        per_page = int(request.args.get("per_page", 10))
-        posts, total = await blog_service.search_posts(g.s, query, page, per_page)
-        return {"posts": [dto_to_dict(p) for p in posts], "total": total}
-
-    _handlers["search-posts"] = _search_posts
-
-    # --- page-config-ensure ---
-    async def _page_config_ensure():
-        """Get or create a PageConfig for a container_type + container_id."""
-        from sqlalchemy import select
-        from shared.models.page_config import PageConfig
-
-        container_type = request.args.get("container_type", "page")
-        container_id = request.args.get("container_id", type=int)
-        if container_id is None:
-            return {"error": "container_id required"}, 400
-
-        row = (await g.s.execute(
-            select(PageConfig).where(
-                PageConfig.container_type == container_type,
-                PageConfig.container_id == container_id,
-            )
-        )).scalar_one_or_none()
-
-        if row is None:
-            row = PageConfig(
-                container_type=container_type,
-                container_id=container_id,
-                features={},
-            )
-            g.s.add(row)
-            await g.s.flush()
-
-        return {
-            "id": row.id,
-            "container_type": row.container_type,
-            "container_id": row.container_id,
-        }
-
-    _handlers["page-config-ensure"] = _page_config_ensure
-
-    # --- page-config ---
-    async def _page_config():
-        """Return a single PageConfig by container_type + container_id."""
-        from sqlalchemy import select
-        from shared.models.page_config import PageConfig
-
-        ct = request.args.get("container_type", "page")
-        cid = request.args.get("container_id", type=int)
-        if cid is None:
-            return None
-        pc = (await g.s.execute(
-            select(PageConfig).where(
-                PageConfig.container_type == ct,
-                PageConfig.container_id == cid,
-            )
-        )).scalar_one_or_none()
-        if not pc:
-            return None
-        return _page_config_dict(pc)
-
-    _handlers["page-config"] = _page_config
-
-    # --- page-config-by-id ---
-    async def _page_config_by_id():
-        """Return a single PageConfig by its primary key."""
-        from shared.models.page_config import PageConfig
-
-        pc_id = request.args.get("id", type=int)
-        if pc_id is None:
-            return None
-        pc = await g.s.get(PageConfig, pc_id)
-        if not pc:
-            return None
-        return _page_config_dict(pc)
-
-    _handlers["page-config-by-id"] = _page_config_by_id
-
-    # --- page-configs-batch ---
-    async def _page_configs_batch():
-        """Return PageConfigs for multiple container_ids (comma-separated)."""
-        from sqlalchemy import select
-        from shared.models.page_config import PageConfig
-
-        ct = request.args.get("container_type", "page")
-        ids_raw = request.args.get("ids", "")
-        if not ids_raw:
-            return []
-        ids = [int(x.strip()) for x in ids_raw.split(",") if x.strip()]
-        if not ids:
-            return []
-        result = await g.s.execute(
-            select(PageConfig).where(
-                PageConfig.container_type == ct,
-                PageConfig.container_id.in_(ids),
-            )
-        )
-        return [_page_config_dict(pc) for pc in result.scalars().all()]
-
-    _handlers["page-configs-batch"] = _page_configs_batch
-
+    bp, _handlers = create_data_blueprint("blog")
    return bp
-
-
-def _page_config_dict(pc) -> dict:
-    """Serialize PageConfig to a JSON-safe dict."""
-    return {
-        "id": pc.id,
-        "container_type": pc.container_type,
-        "container_id": pc.container_id,
-        "features": pc.features or {},
-        "sumup_merchant_code": pc.sumup_merchant_code,
-        "sumup_api_key": pc.sumup_api_key,
-        "sumup_checkout_prefix": pc.sumup_checkout_prefix,
-    }
--- a/blog/bp/menu_items/routes.py
+++ b/blog/bp/menu_items/routes.py
@@ -1,6 +1,6 @@
 from __future__ import annotations

-from quart import Blueprint, make_response, request, jsonify, g
+from quart import Blueprint, make_response, request, jsonify, g, url_for

 from shared.browser.app.authz import require_admin
 from .services.menu_items import (
@@ -12,22 +12,217 @@ from .services.menu_items import (
    search_pages,
    MenuItemError,
 )
-from shared.sx.helpers import sx_response
+from markupsafe import escape
+from shared.sx.helpers import sx_response, sx_call
+from shared.sx.parser import SxExpr
+from shared.browser.app.csrf import generate_csrf_token
+
+
+def _render_menu_items_list(menu_items):
+    """Serialize ORM menu items and render via .sx defcomp."""
+    csrf = generate_csrf_token()
+    items = []
+    for item in menu_items:
+        items.append({
+            "feature_image": getattr(item, "feature_image", None),
+            "label": getattr(item, "label", "") or "",
+            "url": getattr(item, "url", "") or "",
+            "sort_order": getattr(item, "position", 0) or 0,
+            "edit_url": url_for("menu_items.edit_menu_item", item_id=item.id),
+            "delete_url": url_for("menu_items.delete_menu_item_route", item_id=item.id),
+        })
+    new_url = url_for("menu_items.new_menu_item")
+    return sx_call("blog-menu-items-content",
+                    menu_items=items, new_url=new_url, csrf=csrf)
+
+
+def _render_menu_item_form(menu_item=None) -> str:
+    """Render menu item add/edit form."""
+    csrf = generate_csrf_token()
+    search_url = url_for("menu_items.search_pages_route")
+    is_edit = menu_item is not None
+
+    if is_edit:
+        action_url = url_for("menu_items.update_menu_item_route", item_id=menu_item.id)
+        action_attr = f'sx-put="{action_url}"'
+        post_id = str(menu_item.container_id) if menu_item.container_id else ""
+        label = getattr(menu_item, "label", "") or ""
+        slug = getattr(menu_item, "slug", "") or ""
+        fi = getattr(menu_item, "feature_image", None) or ""
+    else:
+        action_url = url_for("menu_items.create_menu_item_route")
+        action_attr = f'sx-post="{action_url}"'
+        post_id = ""
+        label = ""
+        slug = ""
+        fi = ""
+
+    if post_id:
+        img_html = (f'<img src="{fi}" alt="{label}" class="w-10 h-10 rounded-full object-cover" />'
+                    if fi else '<div class="w-10 h-10 rounded-full bg-stone-200"></div>')
+        selected = (f'<div id="selected-page-display" class="mb-3 p-3 bg-stone-50 rounded flex items-center gap-3">'
+                    f'{img_html}<div class="flex-1"><div class="font-medium">{label}</div>'
+                    f'<div class="text-xs text-stone-500">{slug}</div></div></div>')
+    else:
+        selected = '<div id="selected-page-display" class="mb-3 hidden"></div>'
+
+    close_js = "document.getElementById('menu-item-form').innerHTML = ''"
+    title = "Edit Menu Item" if is_edit else "Add Menu Item"
+
+    html = f'''<div class="bg-white rounded-lg shadow p-6 mb-6" id="menu-item-form-container">
+  <div class="flex justify-between items-center mb-4">
+    <h2 class="text-xl font-semibold">{title}</h2>
+    <button type="button" onclick="{close_js}" class="text-stone-400 hover:text-stone-600">
+      <i class="fa fa-times"></i></button>
+  </div>
+  <input type="hidden" name="post_id" id="selected-post-id" value="{post_id}" />
+  {selected}
+  <form {action_attr} sx-target="#menu-items-list" sx-swap="innerHTML"
+    sx-include="#selected-post-id"
+    sx-on:afterRequest="if(event.detail.successful) {{ {close_js} }}"
+    class="space-y-4">
+    <input type="hidden" name="csrf_token" value="{csrf}">
+    <div class="flex gap-2 pb-3 border-b">
+      <button type="submit" class="px-4 py-2 bg-blue-600 text-white rounded hover:bg-blue-700">
+        <i class="fa fa-save"></i> Save</button>
+      <button type="button" onclick="{close_js}"
+        class="px-4 py-2 border border-stone-300 rounded hover:bg-stone-50">Cancel</button>
+    </div>
+  </form>
+  <div class="mt-4">
+    <label class="block text-sm font-medium text-stone-700 mb-2">Select Page</label>
+    <input type="text" placeholder="Search for a page... (or leave blank for all)"
+      sx-get="{search_url}" sx-trigger="keyup changed delay:300ms, focus once"
+      sx-target="#page-search-results" sx-swap="innerHTML"
+      name="q" id="page-search-input"
+      class="w-full px-3 py-2 border border-stone-300 rounded-md focus:outline-none focus:ring-2 focus:ring-blue-500" />
+    <div id="page-search-results" class="mt-2"></div>
+  </div>
+</div>
+<script>
+document.addEventListener('click', function(e) {{
+  var pageOption = e.target.closest('[data-page-id]');
+  if (pageOption) {{
+    var postId = pageOption.dataset.pageId;
+    var postTitle = pageOption.dataset.pageTitle;
+    var postSlug = pageOption.dataset.pageSlug;
+    var postImage = pageOption.dataset.pageImage;
+    document.getElementById('selected-post-id').value = postId;
+    var display = document.getElementById('selected-page-display');
+    display.innerHTML = '<div class="p-3 bg-stone-50 rounded flex items-center gap-3">' +
+      (postImage ? '<img src="' + postImage + '" alt="' + postTitle + '" class="w-10 h-10 rounded-full object-cover" />' : '<div class="w-10 h-10 rounded-full bg-stone-200"></div>') +
+      '<div class="flex-1"><div class="font-medium">' + postTitle + '</div><div class="text-xs text-stone-500">' + postSlug + '</div></div></div>';
+    display.classList.remove('hidden');
+    document.getElementById('page-search-results').innerHTML = '';
+  }}
+}});
+</script>'''
+    return html
+
+
+def _render_page_search_results(pages, query, page, has_more) -> str:
+    """Render page search results."""
+    if not pages and query:
+        return sx_call("page-search-empty", query=query)
+    if not pages:
+        return ""
+
+    items = []
+    for post in pages:
+        items.append(sx_call("page-search-item",
+                             id=post.id, title=post.title,
+                             slug=post.slug,
+                             feature_image=post.feature_image or None))
+
+    sentinel = ""
+    if has_more:
+        search_url = url_for("menu_items.search_pages_route")
+        sentinel = sx_call("page-search-sentinel",
+                          url=search_url, query=query,
+                          next_page=page + 1)
+
+    items_sx = "(<> " + " ".join(items) + ")"
+    return sx_call("page-search-results",
+                   items=SxExpr(items_sx),
+                   sentinel=SxExpr(sentinel) if sentinel else None)
+
+
+def _render_menu_items_nav_oob(menu_items) -> str:
+    """Render OOB nav update for menu items."""
+    from quart import request as qrequest
+
+    if not menu_items:
+        return sx_call("blog-nav-empty", wrapper_id="menu-items-nav-wrapper")
+
+    first_seg = qrequest.path.strip("/").split("/")[0] if qrequest else ""
+
+    select_colours = (
+        "[.hover-capable_&]:hover:bg-yellow-300"
+        " aria-selected:bg-stone-500 aria-selected:text-white"
+        " [.hover-capable_&[aria-selected=true]:hover]:bg-orange-500"
+    )
+    nav_button_cls = (
+        f"justify-center cursor-pointer flex flex-row items-center gap-2"
+        f" rounded bg-stone-200 text-black {select_colours} p-3"
+    )
+
+    container_id = "menu-items-container"
+    arrow_cls = f"scrolling-menu-arrow-{container_id}"
+
+    scroll_hs = (
+        f"on load or scroll"
+        f" if window.innerWidth >= 640 and my.scrollWidth > my.clientWidth"
+        f" remove .hidden from .{arrow_cls} add .flex to .{arrow_cls}"
+        f" else add .hidden to .{arrow_cls} remove .flex from .{arrow_cls} end"
+    )
+
+    item_parts = []
+    for item in menu_items:
+        item_slug = getattr(item, "slug", "") if hasattr(item, "slug") else item.get("slug", "")
+        label = getattr(item, "label", "") if hasattr(item, "label") else item.get("label", "")
+        fi = getattr(item, "feature_image", None) if hasattr(item, "feature_image") else item.get("feature_image")
+
+        href = f"/{item_slug}/"
+        selected = "true" if item_slug == first_seg else "false"
+
+        img_sx = sx_call("img-or-placeholder", src=fi, alt=label,
+            size_cls="w-8 h-8 rounded-full object-cover flex-shrink-0")
+
+        if item_slug != "cart":
+            item_parts.append(sx_call("blog-nav-item-link",
+                href=href, hx_get=f"/{item_slug}/", selected=selected,
+                nav_cls=nav_button_cls, img=SxExpr(img_sx), label=label,
+            ))
+        else:
+            item_parts.append(sx_call("blog-nav-item-plain",
+                href=href, selected=selected, nav_cls=nav_button_cls,
+                img=SxExpr(img_sx), label=label,
+            ))
+
+    items_sx = "(<> " + " ".join(item_parts) + ")" if item_parts else ""
+
+    return sx_call("scroll-nav-wrapper",
+        wrapper_id="menu-items-nav-wrapper", container_id=container_id,
+        arrow_cls=arrow_cls,
+        left_hs=f"on click set #{container_id}.scrollLeft to #{container_id}.scrollLeft - 200",
+        scroll_hs=scroll_hs,
+        right_hs=f"on click set #{container_id}.scrollLeft to #{container_id}.scrollLeft + 200",
+        items=SxExpr(items_sx) if items_sx else None, oob=True,
+    )
+

 def register():
    bp = Blueprint("menu_items", __name__, url_prefix='/settings/menu_items')

    def get_menu_items_nav_oob_sync(menu_items):
        """Helper to generate OOB update for root nav menu items"""
-        from sx.sx_components import render_menu_items_nav_oob
-        return render_menu_items_nav_oob(menu_items)
+        return _render_menu_items_nav_oob(menu_items)

    @bp.get("/new/")
    @require_admin
    async def new_menu_item():
        """Show form to create new menu item"""
-        from sx.sx_components import render_menu_item_form
-        return sx_response(render_menu_item_form())
+        return sx_response(_render_menu_item_form())

    @bp.post("/")
    @require_admin
@@ -50,8 +245,7 @@ def register():

            # Get updated list and nav OOB
            menu_items = await get_all_menu_items(g.s)
-            from sx.sx_components import render_menu_items_list
-            html = render_menu_items_list(menu_items)
+            html = _render_menu_items_list(menu_items)
            nav_oob = get_menu_items_nav_oob_sync(menu_items)
            return sx_response(html + nav_oob)

@@ -66,8 +260,7 @@ def register():
        if not menu_item:
            return await make_response("Menu item not found", 404)

-        from sx.sx_components import render_menu_item_form
-        return sx_response(render_menu_item_form(menu_item=menu_item))
+        return sx_response(_render_menu_item_form(menu_item=menu_item))

    @bp.put("/<int:item_id>/")
    @require_admin
@@ -90,8 +283,7 @@ def register():

            # Get updated list and nav OOB
            menu_items = await get_all_menu_items(g.s)
-            from sx.sx_components import render_menu_items_list
-            html = render_menu_items_list(menu_items)
+            html = _render_menu_items_list(menu_items)
            nav_oob = get_menu_items_nav_oob_sync(menu_items)
            return sx_response(html + nav_oob)

@@ -111,8 +303,7 @@ def register():

        # Get updated list and nav OOB
        menu_items = await get_all_menu_items(g.s)
-        from sx.sx_components import render_menu_items_list
-        html = render_menu_items_list(menu_items)
+        html = _render_menu_items_list(menu_items)
        nav_oob = get_menu_items_nav_oob_sync(menu_items)
        return sx_response(html + nav_oob)

@@ -127,8 +318,7 @@ def register():
        pages, total = await search_pages(g.s, query, page, per_page)
        has_more = (page * per_page) < total

-        from sx.sx_components import render_page_search_results
-        return sx_response(render_page_search_results(pages, query, page, has_more))
+        return sx_response(_render_page_search_results(pages, query, page, has_more))

    @bp.post("/reorder/")
    @require_admin
@@ -152,8 +342,7 @@ def register():

        # Get updated list and nav OOB
        menu_items = await get_all_menu_items(g.s)
-        from sx.sx_components import render_menu_items_list
-        html = render_menu_items_list(menu_items)
+        html = _render_menu_items_list(menu_items)
        nav_oob = get_menu_items_nav_oob_sync(menu_items)
        return sx_response(html + nav_oob)

--- a/blog/bp/post/admin/routes.py
+++ b/blog/bp/post/admin/routes.py
@@ -10,9 +10,18 @@ from quart import (
    url_for,
 )
 from shared.browser.app.authz import require_admin, require_post_author
-from shared.sx.helpers import sx_response
+from markupsafe import escape
+from shared.sx.helpers import sx_response, sx_call
+from shared.sx.parser import SxExpr, serialize as sx_serialize
 from shared.utils import host_url

+
+def _raw_html_sx(html: str) -> str:
+    """Wrap raw HTML in (raw! "...") so it's valid inside sx source."""
+    if not html:
+        return ""
+    return "(raw! " + sx_serialize(html) + ")"
+
 def _post_to_edit_dict(post) -> dict:
    """Convert an ORM Post to a dict matching the shape templates expect.

@@ -51,6 +60,262 @@ def _post_to_edit_dict(post) -> dict:
    return d


+def _render_features(features, post, result):
+    """Render features panel via .sx defcomp."""
+    slug = post.get("slug", "")
+    return sx_call("blog-features-panel-content",
+        features_url=host_url(url_for("blog.post.admin.update_features", slug=slug)),
+        calendar_checked=bool(features.get("calendar")),
+        market_checked=bool(features.get("market")),
+        show_sumup=bool(features.get("calendar") or features.get("market")),
+        sumup_url=host_url(url_for("blog.post.admin.update_sumup", slug=slug)),
+        merchant_code=result.get("sumup_merchant_code") or "",
+        placeholder="\u2022" * 8 if result.get("sumup_configured") else "sup_sk_...",
+        sumup_configured=result.get("sumup_configured", False),
+        checkout_prefix=result.get("sumup_checkout_prefix") or "",
+    )
+
+
+def _serialize_markets(markets, slug):
+    """Serialize ORM/DTO market objects to dicts for .sx defcomp."""
+    result = []
+    for m in markets:
+        m_name = getattr(m, "name", "") if hasattr(m, "name") else m.get("name", "")
+        m_slug = getattr(m, "slug", "") if hasattr(m, "slug") else m.get("slug", "")
+        result.append({
+            "name": m_name, "slug": m_slug,
+            "delete_url": host_url(url_for("blog.post.admin.delete_market",
+                                           slug=slug, market_slug=m_slug)),
+        })
+    return result
+
+
+def _render_calendar_view(
+    calendar, year, month, month_name, weekday_names, weeks,
+    prev_month, prev_month_year, next_month, next_month_year,
+    prev_year, next_year, month_entries, associated_entry_ids,
+    post_slug: str,
+) -> str:
+    """Build calendar month grid HTML."""
+    from quart import url_for as qurl
+    from shared.browser.app.csrf import generate_csrf_token
+    esc = escape
+
+    csrf = generate_csrf_token()
+    cal_id = calendar.id
+
+    def cal_url(y, m):
+        return esc(host_url(qurl("blog.post.admin.calendar_view", slug=post_slug, calendar_id=cal_id, year=y, month=m)))
+
+    cur_url = cal_url(year, month)
+    toggle_url_fn = lambda eid: esc(host_url(qurl("blog.post.admin.toggle_entry", slug=post_slug, entry_id=eid)))
+
+    nav = (
+        f'<header class="flex items-center justify-center mb-4">'
+        f'<nav class="flex items-center gap-2 text-xl">'
+        f'<a class="px-2 py-1 hover:bg-stone-100 rounded" sx-get="{cal_url(prev_year, month)}" sx-target="#calendar-view-{cal_id}" sx-swap="outerHTML">&laquo;</a>'
+        f'<a class="px-2 py-1 hover:bg-stone-100 rounded" sx-get="{cal_url(prev_month_year, prev_month)}" sx-target="#calendar-view-{cal_id}" sx-swap="outerHTML">&lsaquo;</a>'
+        f'<div class="px-3 font-medium">{esc(month_name)} {year}</div>'
+        f'<a class="px-2 py-1 hover:bg-stone-100 rounded" sx-get="{cal_url(next_month_year, next_month)}" sx-target="#calendar-view-{cal_id}" sx-swap="outerHTML">&rsaquo;</a>'
+        f'<a class="px-2 py-1 hover:bg-stone-100 rounded" sx-get="{cal_url(next_year, month)}" sx-target="#calendar-view-{cal_id}" sx-swap="outerHTML">&raquo;</a>'
+        f'</nav></header>'
+    )
+
+    wd_cells = "".join(f'<div class="py-2">{esc(wd)}</div>' for wd in weekday_names)
+    wd_row = f'<div class="hidden sm:grid grid-cols-7 text-center text-xs font-semibold text-stone-700 bg-stone-50 border-b">{wd_cells}</div>'
+
+    cells: list[str] = []
+    for week in weeks:
+        for day in week:
+            extra_cls = " bg-stone-50 text-stone-400" if not day.in_month else ""
+            day_date = day.date
+
+            entry_btns: list[str] = []
+            for e in month_entries:
+                e_start = getattr(e, "start_at", None)
+                if not e_start or e_start.date() != day_date:
+                    continue
+                e_id = getattr(e, "id", None)
+                e_name = esc(getattr(e, "name", ""))
+                t_url = toggle_url_fn(e_id)
+                hx_hdrs = f'{{"X-CSRFToken": "{csrf}"}}'
+
+                if e_id in associated_entry_ids:
+                    entry_btns.append(
+                        f'<div class="flex items-center gap-1 text-[10px] rounded px-1 py-0.5 bg-green-200 text-green-900">'
+                        f'<span class="truncate flex-1">{e_name}</span>'
+                        f'<button type="button" class="flex-shrink-0 hover:text-red-600"'
+                        f' data-confirm data-confirm-title="Remove entry?"'
+                        f' data-confirm-text="Remove {e_name} from this post?"'
+                        f' data-confirm-icon="warning" data-confirm-confirm-text="Yes, remove it"'
+                        f' data-confirm-cancel-text="Cancel" data-confirm-event="confirmed"'
+                        f' sx-post="{t_url}" sx-trigger="confirmed"'
+                        f' sx-target="#associated-entries-list" sx-swap="outerHTML"'
+                        f""" sx-headers='{hx_hdrs}'"""
+                        f' sx-on:afterSwap="document.body.dispatchEvent(new CustomEvent(\'entryToggled\'))"'
+                        f'><i class="fa fa-times"></i></button></div>'
+                    )
+                else:
+                    entry_btns.append(
+                        f'<button type="button" class="w-full text-left text-[10px] rounded px-1 py-0.5 bg-stone-100 text-stone-700 hover:bg-stone-200"'
+                        f' data-confirm data-confirm-title="Add entry?"'
+                        f' data-confirm-text="Add {e_name} to this post?"'
+                        f' data-confirm-icon="question" data-confirm-confirm-text="Yes, add it"'
+                        f' data-confirm-cancel-text="Cancel" data-confirm-event="confirmed"'
+                        f' sx-post="{t_url}" sx-trigger="confirmed"'
+                        f' sx-target="#associated-entries-list" sx-swap="outerHTML"'
+                        f""" sx-headers='{hx_hdrs}'"""
+                        f' sx-on:afterSwap="document.body.dispatchEvent(new CustomEvent(\'entryToggled\'))"'
+                        f'><span class="truncate block">{e_name}</span></button>'
+                    )
+
+            entries_html = '<div class="space-y-0.5">' + "".join(entry_btns) + '</div>' if entry_btns else ''
+            cells.append(
+                f'<div class="min-h-20 bg-white px-2 py-2 text-xs{extra_cls}">'
+                f'<div class="font-medium mb-1">{day_date.day}</div>{entries_html}</div>'
+            )
+
+    grid = f'<div class="grid grid-cols-1 sm:grid-cols-7 gap-px bg-stone-200">{"".join(cells)}</div>'
+
+    html = (
+        f'<div id="calendar-view-{cal_id}"'
+        f' sx-get="{cur_url}" sx-trigger="entryToggled from:body" sx-swap="outerHTML">'
+        f'{nav}'
+        f'<div class="rounded border bg-white">{wd_row}{grid}</div>'
+        f'</div>'
+    )
+    return _raw_html_sx(html)
+
+
+def _render_associated_entries(all_calendars, associated_entry_ids, post_slug: str) -> str:
+    """Render the associated entries panel."""
+    from shared.browser.app.csrf import generate_csrf_token
+    from quart import url_for as qurl
+
+    csrf = generate_csrf_token()
+
+    has_entries = False
+    entry_items: list[str] = []
+    for calendar in all_calendars:
+        entries = getattr(calendar, "entries", []) or []
+        cal_name = getattr(calendar, "name", "")
+        cal_post = getattr(calendar, "post", None)
+        cal_fi = getattr(cal_post, "feature_image", None) if cal_post else None
+        cal_title = getattr(cal_post, "title", "") if cal_post else ""
+
+        for entry in entries:
+            e_id = getattr(entry, "id", None)
+            if e_id not in associated_entry_ids:
+                continue
+            if getattr(entry, "deleted_at", None) is not None:
+                continue
+            has_entries = True
+            e_name = getattr(entry, "name", "")
+            e_start = getattr(entry, "start_at", None)
+            e_end = getattr(entry, "end_at", None)
+
+            toggle_url = host_url(qurl("blog.post.admin.toggle_entry", slug=post_slug, entry_id=e_id))
+
+            img_sx = sx_call("blog-entry-image", src=cal_fi, title=cal_title)
+
+            date_str = e_start.strftime("%A, %B %d, %Y at %H:%M") if e_start else ""
+            if e_end:
+                date_str += f" \u2013 {e_end.strftime('%H:%M')}"
+
+            entry_items.append(sx_call("blog-associated-entry",
+                confirm_text=f"This will remove {e_name} from this post",
+                toggle_url=toggle_url,
+                hx_headers=f'{{"X-CSRFToken": "{csrf}"}}',
+                img=SxExpr(img_sx), name=e_name,
+                date_str=f"{cal_name} \u2022 {date_str}",
+            ))
+
+    if has_entries:
+        content_sx = sx_call("blog-associated-entries-content",
+            items=SxExpr("(<> " + " ".join(entry_items) + ")"),
+        )
+    else:
+        content_sx = sx_call("blog-associated-entries-empty")
+
+    return sx_call("blog-associated-entries-panel", content=SxExpr(content_sx))
+
+
+def _render_nav_entries_oob(associated_entries, calendars, post: dict) -> str:
+    """Render the OOB nav entries swap."""
+    entries_list = []
+    if associated_entries and hasattr(associated_entries, "entries"):
+        entries_list = associated_entries.entries or []
+
+    has_items = bool(entries_list or calendars)
+
+    if not has_items:
+        return sx_call("blog-nav-entries-empty")
+
+    select_colours = (
+        "[.hover-capable_&]:hover:bg-yellow-300"
+        " aria-selected:bg-stone-500 aria-selected:text-white"
+        " [.hover-capable_&[aria-selected=true]:hover]:bg-orange-500"
+    )
+    nav_cls = (
+        f"justify-center cursor-pointer flex flex-row items-center gap-2"
+        f" rounded bg-stone-200 text-black {select_colours} p-2"
+    )
+
+    post_slug = post.get("slug", "")
+
+    scroll_hs = (
+        "on load or scroll"
+        " if window.innerWidth >= 640 and my.scrollWidth > my.clientWidth"
+        " remove .hidden from .entries-nav-arrow add .flex to .entries-nav-arrow"
+        " else add .hidden to .entries-nav-arrow remove .flex from .entries-nav-arrow end"
+    )
+
+    item_parts = []
+
+    for entry in entries_list:
+        e_name = getattr(entry, "name", "")
+        e_start = getattr(entry, "start_at", None)
+        e_end = getattr(entry, "end_at", None)
+        cal_slug = getattr(entry, "calendar_slug", "")
+
+        if e_start:
+            entry_path = (
+                f"/{post_slug}/{cal_slug}/"
+                f"{e_start.year}/{e_start.month}/{e_start.day}"
+                f"/entries/{getattr(entry, 'id', '')}/"
+            )
+            date_str = e_start.strftime("%b %d, %Y at %H:%M")
+            if e_end:
+                date_str += f" \u2013 {e_end.strftime('%H:%M')}"
+        else:
+            entry_path = f"/{post_slug}/{cal_slug}/"
+            date_str = ""
+
+        item_parts.append(sx_call("calendar-entry-nav",
+            href=entry_path, nav_class=nav_cls, name=e_name, date_str=date_str,
+        ))
+
+    for calendar in (calendars or []):
+        cal_name = getattr(calendar, "name", "")
+        cal_slug = getattr(calendar, "slug", "")
+        cal_path = f"/{post_slug}/{cal_slug}/"
+
+        item_parts.append(sx_call("blog-nav-calendar-item",
+            href=cal_path, nav_cls=nav_cls, name=cal_name,
+        ))
+
+    items_sx = "(<> " + " ".join(item_parts) + ")" if item_parts else ""
+
+    return sx_call("scroll-nav-wrapper",
+        wrapper_id="entries-calendars-nav-wrapper", container_id="associated-items-container",
+        arrow_cls="entries-nav-arrow",
+        left_hs="on click set #associated-items-container.scrollLeft to #associated-items-container.scrollLeft - 200",
+        scroll_hs=scroll_hs,
+        right_hs="on click set #associated-items-container.scrollLeft to #associated-items-container.scrollLeft + 200",
+        items=SxExpr(items_sx) if items_sx else None, oob=True,
+    )
+
+
 def register():
  bp = Blueprint("admin", __name__, url_prefix='/admin')

@@ -88,14 +353,7 @@ def register():
    })

    features = result.get("features", {})
-
-    from sx.sx_components import render_features_panel
-    html = render_features_panel(
-        features, post,
-        sumup_configured=result.get("sumup_configured", False),
-        sumup_merchant_code=result.get("sumup_merchant_code") or "",
-        sumup_checkout_prefix=result.get("sumup_checkout_prefix") or "",
-    )
+    html = _render_features(features, post, result)
    return sx_response(html)

  @bp.put("/admin/sumup/")
@@ -128,13 +386,7 @@ def register():
    result = await call_action("blog", "update-page-config", payload=payload)

    features = result.get("features", {})
-    from sx.sx_components import render_features_panel
-    html = render_features_panel(
-        features, post,
-        sumup_configured=result.get("sumup_configured", False),
-        sumup_merchant_code=result.get("sumup_merchant_code") or "",
-        sumup_checkout_prefix=result.get("sumup_checkout_prefix") or "",
-    )
+    html = _render_features(features, post, result)
    return sx_response(html)

  @bp.get("/entries/calendar/<int:calendar_id>/")
@@ -203,8 +455,7 @@ def register():
    post_id = g.post_data["post"]["id"]
    associated_entry_ids = await get_post_entry_ids(post_id)

-    from sx.sx_components import render_calendar_view
-    html = render_calendar_view(
+    html = _render_calendar_view(
      calendar_obj, year, month, month_name, weekday_names, weeks,
      prev_month, prev_month_year, next_month, next_month_year,
      prev_year, next_year, month_entries, associated_entry_ids,
@@ -256,11 +507,9 @@ def register():
    ).scalars().all()

    # Return the associated entries admin list + OOB update for nav entries
-    from sx.sx_components import render_associated_entries, render_nav_entries_oob
-
    post = g.post_data["post"]
-    admin_list = render_associated_entries(all_calendars, associated_entry_ids, post["slug"])
-    nav_entries_html = render_nav_entries_oob(associated_entries, calendars, post)
+    admin_list = _render_associated_entries(all_calendars, associated_entry_ids, post["slug"])
+    nav_entries_html = _render_nav_entries_oob(associated_entries, calendars, post)

    return sx_response(admin_list + nav_entries_html)

@@ -435,8 +684,11 @@ def register():

    page_markets = await _fetch_page_markets(post_id)

-    from sx.sx_components import render_markets_panel
-    return sx_response(render_markets_panel(page_markets, post))
+    slug = post.get("slug", "")
+    create_url = host_url(url_for("blog.post.admin.create_market", slug=slug))
+    html = sx_call("blog-markets-panel-content",
+        markets=_serialize_markets(page_markets, slug), create_url=create_url)
+    return sx_response(html)

  @bp.post("/markets/new/")
  @require_admin
@@ -461,8 +713,11 @@ def register():
    # Return updated markets list
    page_markets = await _fetch_page_markets(post_id)

-    from sx.sx_components import render_markets_panel
-    return sx_response(render_markets_panel(page_markets, post))
+    slug = post.get("slug", "")
+    create_url = host_url(url_for("blog.post.admin.create_market", slug=slug))
+    html = sx_call("blog-markets-panel-content",
+        markets=_serialize_markets(page_markets, slug), create_url=create_url)
+    return sx_response(html)

  @bp.delete("/markets/<market_slug>/")
  @require_admin
@@ -481,7 +736,10 @@ def register():
    # Return updated markets list
    page_markets = await _fetch_page_markets(post_id)

-    from sx.sx_components import render_markets_panel
-    return sx_response(render_markets_panel(page_markets, post))
+    slug = post.get("slug", "")
+    create_url = host_url(url_for("blog.post.admin.create_market", slug=slug))
+    html = sx_call("blog-markets-panel-content",
+        markets=_serialize_markets(page_markets, slug), create_url=create_url)
+    return sx_response(html)

  return bp
--- a/blog/bp/post/routes.py
+++ b/blog/bp/post/routes.py
@@ -105,27 +105,68 @@ def register():
  @cache_page(tag="post.post_detail")
  async def post_detail(slug: str):
    from shared.sx.page import get_template_context
-    from sx.sx_components import render_post_page, render_post_oob
+    from shared.sx.helpers import (
+        sx_call, root_header_sx, full_page_sx, oob_page_sx,
+        post_header_sx, oob_header_sx, mobile_menu_sx,
+        post_mobile_nav_sx, mobile_root_nav_sx,
+    )
+    from shared.services.registry import services
+    from shared.browser.app.csrf import generate_csrf_token
+    from shared.utils import host_url

    tctx = await get_template_context()
+
+    # Render post content via .sx defcomp
+    post = tctx.get("post") or {}
+    user = getattr(g, "user", None)
+    rights = tctx.get("rights") or {}
+    blog_url_base = host_url(url_for("blog.index")).rstrip("/index").rstrip("/")
+    csrf = generate_csrf_token()
+    svc = services.blog_page
+    detail_data = svc.post_detail_data(post, user, rights, csrf, blog_url_base)
+    content = sx_call("blog-post-detail-content", **detail_data)
+    meta_data = svc.post_meta_data(post, tctx.get("base_title", ""))
+    meta = sx_call("blog-meta", **meta_data)
+
    if not is_htmx_request():
-        html = await render_post_page(tctx)
+        root_hdr = await root_header_sx(tctx)
+        post_hdr = await post_header_sx(tctx)
+        header_rows = "(<> " + root_hdr + " " + post_hdr + ")"
+        menu = mobile_menu_sx(await post_mobile_nav_sx(tctx), await mobile_root_nav_sx(tctx))
+        html = await full_page_sx(tctx, header_rows=header_rows, content=content,
+                                  meta=meta, menu=menu)
        return await make_response(html)
    else:
-        sx_src = await render_post_oob(tctx)
+        root_hdr = await root_header_sx(tctx)
+        post_hdr = await post_header_sx(tctx)
+        rows = "(<> " + root_hdr + " " + post_hdr + ")"
+        header_oob = await oob_header_sx("root-header-child", "post-header-child", rows)
+        sx_src = await oob_page_sx(oobs=header_oob, content=content, menu=
+            mobile_menu_sx(await post_mobile_nav_sx(tctx), await mobile_root_nav_sx(tctx)))
        return sx_response(sx_src)

  @bp.post("/like/toggle/")
  @clear_cache(tag="post.post_detail", tag_scope="user")
  async def like_toggle(slug: str):
      from shared.utils import host_url
-      from sx.sx_components import render_like_toggle_button
+      from shared.sx.helpers import sx_call
+      from shared.browser.app.csrf import generate_csrf_token

      like_url = host_url(url_for('blog.post.like_toggle', slug=slug))
+      csrf = generate_csrf_token()
+
+      def _like_btn(liked):
+          if liked:
+              colour, icon, label = "text-red-600", "fa-solid fa-heart", "Unlike this post"
+          else:
+              colour, icon, label = "text-stone-300", "fa-regular fa-heart", "Like this post"
+          return sx_call("market-like-toggle-button",
+              colour=colour, action=like_url,
+              hx_headers=f'{{"X-CSRFToken": "{csrf}"}}',
+              label=label, icon_cls=icon)

-      # Get post_id from g.post_data
      if not g.user:
-          return sx_response(render_like_toggle_button(slug, False, like_url), status=403)
+          return sx_response(_like_btn(False), status=403)

      post_id = g.post_data["post"]["id"]
      user_id = g.user.id
@@ -133,9 +174,8 @@ def register():
      result = await call_action("likes", "toggle", payload={
          "user_id": user_id, "target_type": "post", "target_id": post_id,
      })
-      liked = result["liked"]

-      return sx_response(render_like_toggle_button(slug, liked, like_url))
+      return sx_response(_like_btn(result["liked"]))

  @bp.get("/w/<widget_domain>/")
  async def widget_paginate(slug: str, widget_domain: str):
--- a/blog/bp/snippets/routes.py
+++ b/blog/bp/snippets/routes.py
@@ -1,30 +1,20 @@
 from __future__ import annotations

 from quart import Blueprint, request, g, abort
-from sqlalchemy import select, or_

 from shared.browser.app.authz import require_login
-from shared.sx.helpers import sx_response
+from shared.sx.helpers import sx_response, sx_call
 from models import Snippet


 VALID_VISIBILITY = frozenset({"private", "shared", "admin"})


-async def _visible_snippets(session):
-    """Return snippets visible to the current user (own + shared + admin-if-admin)."""
-    uid = g.user.id
-    is_admin = g.rights.get("admin")
-
-    filters = [Snippet.user_id == uid, Snippet.visibility == "shared"]
-    if is_admin:
-        filters.append(Snippet.visibility == "admin")
-
-    rows = (await session.execute(
-        select(Snippet).where(or_(*filters)).order_by(Snippet.name)
-    )).scalars().all()
-
-    return rows
+async def _render_snippets():
+    """Render snippets list via service data + .sx defcomp."""
+    from shared.services.registry import services
+    data = await services.blog_page.snippets_data(g.s)
+    return sx_call("blog-snippets-content", **data)


 def register():
@@ -45,9 +35,7 @@ def register():
        await g.s.delete(snippet)
        await g.s.flush()

-        snippets = await _visible_snippets(g.s)
-        from sx.sx_components import render_snippets_list
-        return sx_response(render_snippets_list(snippets, is_admin))
+        return sx_response(await _render_snippets())

    @bp.patch("/<int:snippet_id>/visibility/")
    @require_login
@@ -69,8 +57,6 @@ def register():
        snippet.visibility = visibility
        await g.s.flush()

-        snippets = await _visible_snippets(g.s)
-        from sx.sx_components import render_snippets_list
-        return sx_response(render_snippets_list(snippets, True))
+        return sx_response(await _render_snippets())

    return bp
--- a/blog/queries.sx
+++ b/blog/queries.sx
@@ -0,0 +1,38 @@
+;; Blog service — inter-service data queries
+
+(defquery post-by-slug (&key slug)
+  "Fetch a single blog post by its URL slug."
+  (service "blog" "get-post-by-slug" :slug slug))
+
+(defquery post-by-id (&key id)
+  "Fetch a single blog post by its primary key."
+  (service "blog" "get-post-by-id" :id id))
+
+(defquery posts-by-ids (&key ids)
+  "Fetch multiple blog posts by comma-separated IDs."
+  (service "blog" "get-posts-by-ids" :ids (split-ids ids)))
+
+(defquery search-posts (&key query page per-page)
+  "Search blog posts by text query, paginated."
+  (let ((result (service "blog" "search-posts"
+                  :query query :page page :per-page per-page)))
+    {"posts" (nth result 0) "total" (nth result 1)}))
+
+(defquery page-config-ensure (&key container-type container-id)
+  "Get or create a PageConfig for a container."
+  (service "page-config" "ensure"
+    :container-type container-type :container-id container-id))
+
+(defquery page-config (&key container-type container-id)
+  "Return a single PageConfig by container type + id."
+  (service "page-config" "get-by-container"
+    :container-type container-type :container-id container-id))
+
+(defquery page-config-by-id (&key id)
+  "Return a single PageConfig by primary key."
+  (service "page-config" "get-by-id" :id id))
+
+(defquery page-configs-batch (&key container-type ids)
+  "Return PageConfigs for multiple container IDs (comma-separated)."
+  (service "page-config" "get-batch"
+    :container-type container-type :ids (split-ids ids)))
--- a/blog/services/init.py
+++ b/blog/services/init.py
@@ -71,8 +71,16 @@ def register_domain_services() -> None:
    Blog owns: Post, Tag, Author, PostAuthor, PostTag.
    Cross-app calls go over HTTP via call_action() / fetch_data().
    """
-    # Federation needed for AP shared infrastructure (activitypub blueprint)
    from shared.services.registry import services
+    services.register("blog", blog_service)
+
+    from shared.services.page_config_impl import SqlPageConfigService
+    services.register("page_config", SqlPageConfigService())
+
+    # Federation needed for AP shared infrastructure (activitypub blueprint)
    if not services.has("federation"):
        from shared.services.federation_impl import SqlFederationService
        services.federation = SqlFederationService()
+
+    from .blog_page import BlogPageService
+    services.register("blog_page", BlogPageService())
--- a/blog/services/blog_page.py
+++ b/blog/services/blog_page.py
@@ -0,0 +1,465 @@
+"""Blog page data service — provides serialized dicts for .sx defpages."""
+from __future__ import annotations
+
+
+class BlogPageService:
+    """Service for blog page data, callable via (service "blog-page" ...)."""
+
+    async def cache_data(self, session, **kw):
+        from quart import url_for as qurl
+        from shared.browser.app.csrf import generate_csrf_token
+        return {
+            "clear_url": qurl("settings.cache_clear"),
+            "csrf": generate_csrf_token(),
+        }
+
+    async def snippets_data(self, session, **kw):
+        from quart import g, url_for as qurl
+        from sqlalchemy import select, or_
+        from models import Snippet
+        from shared.browser.app.csrf import generate_csrf_token
+
+        uid = g.user.id
+        is_admin = g.rights.get("admin")
+        csrf = generate_csrf_token()
+        filters = [Snippet.user_id == uid, Snippet.visibility == "shared"]
+        if is_admin:
+            filters.append(Snippet.visibility == "admin")
+        rows = (await session.execute(
+            select(Snippet).where(or_(*filters)).order_by(Snippet.name)
+        )).scalars().all()
+
+        snippets = []
+        for s in rows:
+            s_id = s.id
+            s_vis = s.visibility or "private"
+            s_uid = s.user_id
+            owner = "You" if s_uid == uid else f"User #{s_uid}"
+            can_delete = s_uid == uid or is_admin
+            d = {
+                "id": s_id,
+                "name": s.name or "",
+                "visibility": s_vis,
+                "owner": owner,
+                "can_delete": can_delete,
+            }
+            if is_admin:
+                d["patch_url"] = qurl("snippets.patch_visibility", snippet_id=s_id)
+            if can_delete:
+                d["delete_url"] = qurl("snippets.delete_snippet", snippet_id=s_id)
+            snippets.append(d)
+        return {
+            "snippets": snippets,
+            "is_admin": bool(is_admin),
+            "csrf": csrf,
+        }
+
+    async def menu_items_data(self, session, **kw):
+        from quart import url_for as qurl
+        from bp.menu_items.services.menu_items import get_all_menu_items
+        from shared.browser.app.csrf import generate_csrf_token
+
+        menu_items = await get_all_menu_items(session)
+        csrf = generate_csrf_token()
+        items = []
+        for mi in menu_items:
+            i_id = mi.id
+            label = mi.label or ""
+            fi = getattr(mi, "feature_image", None)
+            sort = mi.position or 0
+            items.append({
+                "id": i_id,
+                "label": label,
+                "url": mi.url or "",
+                "sort_order": sort,
+                "feature_image": fi,
+                "edit_url": qurl("menu_items.edit_menu_item", item_id=i_id),
+                "delete_url": qurl("menu_items.delete_menu_item_route", item_id=i_id),
+            })
+        return {
+            "menu_items": items,
+            "new_url": qurl("menu_items.new_menu_item"),
+            "csrf": csrf,
+        }
+
+    async def tag_groups_data(self, session, **kw):
+        from quart import url_for as qurl
+        from sqlalchemy import select
+        from models.tag_group import TagGroup
+        from bp.blog.admin.routes import _unassigned_tags
+        from shared.browser.app.csrf import generate_csrf_token
+
+        groups_rows = list(
+            (await session.execute(
+                select(TagGroup).order_by(TagGroup.sort_order, TagGroup.name)
+            )).scalars()
+        )
+        unassigned = await _unassigned_tags(session)
+
+        groups = []
+        for g in groups_rows:
+            groups.append({
+                "id": g.id,
+                "name": g.name or "",
+                "slug": getattr(g, "slug", "") or "",
+                "feature_image": getattr(g, "feature_image", None),
+                "colour": getattr(g, "colour", None),
+                "sort_order": getattr(g, "sort_order", 0) or 0,
+                "edit_href": qurl("blog.tag_groups_admin.defpage_tag_group_edit", id=g.id),
+            })
+
+        unassigned_tags = []
+        for t in unassigned:
+            unassigned_tags.append({
+                "name": getattr(t, "name", "") if hasattr(t, "name") else t.get("name", ""),
+            })
+
+        return {
+            "groups": groups,
+            "unassigned_tags": unassigned_tags,
+            "create_url": qurl("blog.tag_groups_admin.create"),
+            "csrf": generate_csrf_token(),
+        }
+
+    async def tag_group_edit_data(self, session, *, id=None, **kw):
+        from quart import abort, url_for as qurl
+        from sqlalchemy import select
+        from models.tag_group import TagGroup, TagGroupTag
+        from models.ghost_content import Tag
+        from shared.browser.app.csrf import generate_csrf_token
+
+        tg = await session.get(TagGroup, id)
+        if not tg:
+            abort(404)
+
+        assigned_rows = list(
+            (await session.execute(
+                select(TagGroupTag.tag_id).where(TagGroupTag.tag_group_id == id)
+            )).scalars()
+        )
+        assigned_set = set(assigned_rows)
+
+        all_tags_rows = list(
+            (await session.execute(
+                select(Tag).where(
+                    Tag.deleted_at.is_(None),
+                    (Tag.visibility == "public") | (Tag.visibility.is_(None)),
+                ).order_by(Tag.name)
+            )).scalars()
+        )
+
+        all_tags = []
+        for t in all_tags_rows:
+            all_tags.append({
+                "id": t.id,
+                "name": getattr(t, "name", "") or "",
+                "feature_image": getattr(t, "feature_image", None),
+                "checked": t.id in assigned_set,
+            })
+
+        return {
+            "group": {
+                "id": tg.id,
+                "name": tg.name or "",
+                "colour": getattr(tg, "colour", "") or "",
+                "sort_order": getattr(tg, "sort_order", 0) or 0,
+                "feature_image": getattr(tg, "feature_image", "") or "",
+            },
+            "all_tags": all_tags,
+            "save_url": qurl("blog.tag_groups_admin.save", id=tg.id),
+            "delete_url": qurl("blog.tag_groups_admin.delete_group", id=tg.id),
+            "csrf": generate_csrf_token(),
+        }
+
+    async def index_data(self, session, **kw):
+        """Blog index page data — posts or pages listing with filters."""
+        from quart import g, request, url_for as qurl
+        from bp.blog.services.posts_data import posts_data
+        from bp.blog.services.pages_data import pages_data
+        from bp.blog.filters.qs import decode
+        from shared.utils import host_url
+        from shared.browser.app.csrf import generate_csrf_token
+
+        q = decode()
+        content_type = request.args.get("type", "posts")
+        is_admin = bool((g.get("rights") or {}).get("admin"))
+        user = getattr(g, "user", None)
+        csrf = generate_csrf_token()
+
+        blog_url_base = host_url(qurl("blog.index")).rstrip("/index").rstrip("/")
+
+        if content_type == "pages":
+            data = await pages_data(session, q.page, q.search)
+            posts_list = data.get("pages", [])
+            tag_groups_raw = []
+            authors_raw = []
+            draft_count = 0
+            selected_tags = ()
+            selected_authors = ()
+            selected_groups = ()
+        else:
+            show_drafts = bool(q.drafts and user)
+            drafts_user_id = None if (not show_drafts or is_admin) else user.id
+            count_drafts_uid = None if (user and is_admin) else (user.id if user else False)
+            data = await posts_data(
+                session, q.page, q.search, q.sort, q.selected_tags,
+                q.selected_authors, q.liked,
+                drafts=show_drafts, drafts_user_id=drafts_user_id,
+                count_drafts_for_user_id=count_drafts_uid,
+                selected_groups=q.selected_groups,
+            )
+            posts_list = data.get("posts", [])
+            tag_groups_raw = data.get("tag_groups", [])
+            authors_raw = data.get("authors", [])
+            draft_count = data.get("draft_count", 0)
+            selected_tags = q.selected_tags
+            selected_authors = q.selected_authors
+            selected_groups = q.selected_groups
+
+        page_num = data.get("page", q.page)
+        total_pages = data.get("total_pages", 1)
+        card_widgets = data.get("card_widgets_html", {})
+
+        current_local_href = f"{blog_url_base}/index"
+        if content_type == "pages":
+            current_local_href += "?type=pages"
+        hx_select = "#main-panel"
+
+        # Serialize posts for cards
+        def _format_ts(dt):
+            if not dt:
+                return ""
+            return dt.strftime("%-d %b %Y at %H:%M") if hasattr(dt, "strftime") else str(dt)
+
+        cards = []
+        for p in posts_list:
+            slug = p.get("slug", "")
+            href = f"{blog_url_base}/{slug}/"
+            status = p.get("status", "published")
+            is_draft = status == "draft"
+            ts = _format_ts(p.get("updated_at") if is_draft else p.get("published_at"))
+            tags = []
+            for t in (p.get("tags") or []):
+                name = t.get("name") or getattr(t, "name", "")
+                fi = t.get("feature_image") or getattr(t, "feature_image", None)
+                tags.append({"name": name, "src": fi or "", "initial": name[:1] if name else ""})
+            authors = []
+            for a in (p.get("authors") or []):
+                name = a.get("name") or getattr(a, "name", "")
+                img = a.get("profile_image") or getattr(a, "profile_image", None)
+                authors.append({"name": name, "image": img or ""})
+            card = {
+                "slug": slug, "href": href, "hx_select": hx_select,
+                "title": p.get("title", ""), "feature_image": p.get("feature_image"),
+                "excerpt": p.get("custom_excerpt") or p.get("excerpt", ""),
+                "is_draft": is_draft,
+                "publish_requested": p.get("publish_requested", False) if is_draft else False,
+                "status_timestamp": ts,
+                "tags": tags, "authors": authors,
+                "has_like": bool(user),
+            }
+            if user:
+                card["liked"] = p.get("is_liked", False)
+                card["like_url"] = f"{blog_url_base}/{slug}/like/toggle/"
+                card["csrf_token"] = csrf
+            widget = card_widgets.get(str(p.get("id", "")), "")
+            if widget:
+                card["widget"] = widget
+            # Page-specific fields
+            features = p.get("features") or {}
+            if content_type == "pages":
+                card["has_calendar"] = features.get("calendar", False)
+                card["has_market"] = features.get("market", False)
+                card["pub_timestamp"] = ts
+            cards.append(card)
+
+        # Serialize tag groups for filter
+        tag_groups = []
+        for grp in tag_groups_raw:
+            g_slug = grp.get("slug", "") if isinstance(grp, dict) else getattr(grp, "slug", "")
+            g_name = grp.get("name", "") if isinstance(grp, dict) else getattr(grp, "name", "")
+            g_fi = grp.get("feature_image") if isinstance(grp, dict) else getattr(grp, "feature_image", None)
+            g_colour = grp.get("colour") if isinstance(grp, dict) else getattr(grp, "colour", None)
+            g_count = grp.get("post_count", 0) if isinstance(grp, dict) else getattr(grp, "post_count", 0)
+            if g_count <= 0 and g_slug not in selected_groups:
+                continue
+            tag_groups.append({
+                "slug": g_slug, "name": g_name, "feature_image": g_fi,
+                "colour": g_colour, "post_count": g_count,
+                "is_selected": g_slug in selected_groups,
+            })
+
+        # Serialize authors for filter
+        authors_list = []
+        for a in authors_raw:
+            a_slug = a.get("slug", "") if isinstance(a, dict) else getattr(a, "slug", "")
+            a_name = a.get("name", "") if isinstance(a, dict) else getattr(a, "name", "")
+            a_img = a.get("profile_image") if isinstance(a, dict) else getattr(a, "profile_image", None)
+            a_count = a.get("published_post_count", 0) if isinstance(a, dict) else getattr(a, "published_post_count", 0)
+            authors_list.append({
+                "slug": a_slug, "name": a_name, "profile_image": a_img,
+                "published_post_count": a_count,
+                "is_selected": a_slug in selected_authors,
+            })
+
+        # Filter summary names
+        tg_summary_names = [grp["name"] for grp in tag_groups if grp["is_selected"]]
+        au_summary_names = [a["name"] for a in authors_list if a["is_selected"]]
+
+        return {
+            "content_type": content_type,
+            "view": q.view,
+            "cards": cards,
+            "page": page_num,
+            "total_pages": total_pages,
+            "current_local_href": current_local_href,
+            "hx_select": hx_select,
+            "is_admin": is_admin,
+            "has_user": bool(user),
+            "draft_count": draft_count,
+            "drafts": bool(q.drafts) if user else False,
+            "new_post_href": f"{blog_url_base}/new/",
+            "new_page_href": f"{blog_url_base}/new-page/",
+            "tag_groups": tag_groups,
+            "authors": authors_list,
+            "is_any_group": len(selected_groups) == 0 and len(selected_tags) == 0,
+            "is_any_author": len(selected_authors) == 0,
+            "tg_summary": ", ".join(tg_summary_names) if tg_summary_names else "",
+            "au_summary": ", ".join(au_summary_names) if au_summary_names else "",
+            "blog_url_base": blog_url_base,
+            "csrf": csrf,
+        }
+
+    async def post_admin_data(self, session, *, slug=None, **kw):
+        """Post admin panel — just needs post loaded into context."""
+        from quart import g
+        from sqlalchemy import select
+        from shared.models.page_config import PageConfig
+
+        # _ensure_post_data is called by before_request in defpage context
+        post = (g.post_data or {}).get("post", {})
+        features = {}
+        sumup_configured = False
+        if post.get("is_page"):
+            pc = (await session.execute(
+                select(PageConfig).where(
+                    PageConfig.container_type == "page",
+                    PageConfig.container_id == post["id"],
+                )
+            )).scalar_one_or_none()
+            if pc:
+                features = pc.features or {}
+                sumup_configured = bool(pc.sumup_api_key)
+        return {
+            "features": features,
+            "sumup_configured": sumup_configured,
+        }
+
+    def post_meta_data(self, post, base_title):
+        """Compute SEO meta tag values from post dict."""
+        import re
+        from quart import request as req
+
+        is_public = post.get("visibility") == "public"
+        is_published = post.get("status") == "published"
+        email_only = post.get("email_only", False)
+        robots = "index,follow" if (is_public and is_published and not email_only) else "noindex,nofollow"
+
+        desc = (post.get("meta_description") or post.get("og_description") or
+                post.get("twitter_description") or post.get("custom_excerpt") or
+                post.get("excerpt") or "")
+        if not desc and post.get("html"):
+            desc = re.sub(r'<[^>]+>', '', post["html"])
+        desc = desc.replace("\n", " ").replace("\r", " ").strip()[:160]
+
+        image = (post.get("og_image") or post.get("twitter_image") or post.get("feature_image") or "")
+        canonical = post.get("canonical_url") or (req.url if req else "")
+
+        post_title = post.get("meta_title") or post.get("title") or ""
+        page_title = f"{post_title} \u2014 {base_title}" if post_title else base_title
+        og_title = post.get("og_title") or page_title
+        tw_title = post.get("twitter_title") or page_title
+        is_article = not post.get("is_page")
+
+        return {
+            "robots": robots, "page_title": page_title, "desc": desc,
+            "canonical": canonical,
+            "og_type": "article" if is_article else "website",
+            "og_title": og_title, "image": image,
+            "twitter_card": "summary_large_image" if image else "summary",
+            "twitter_title": tw_title,
+        }
+
+    def post_detail_data(self, post, user, rights, csrf, blog_url_base):
+        """Serialize post detail view data for ~blog-post-detail-content defcomp."""
+        slug = post.get("slug", "")
+        is_admin = rights.get("admin") if isinstance(rights, dict) else getattr(rights, "admin", False)
+        user_id = getattr(user, "id", None) if user else None
+
+        # Tags and authors
+        tags = []
+        for t in (post.get("tags") or []):
+            name = t.get("name") or getattr(t, "name", "")
+            fi = t.get("feature_image") or getattr(t, "feature_image", None)
+            tags.append({"name": name, "src": fi or "", "initial": name[:1] if name else ""})
+        authors = []
+        for a in (post.get("authors") or []):
+            name = a.get("name") or getattr(a, "name", "")
+            img = a.get("profile_image") or getattr(a, "profile_image", None)
+            authors.append({"name": name, "image": img or ""})
+
+        return {
+            "slug": slug,
+            "is_draft": post.get("status") == "draft",
+            "publish_requested": post.get("publish_requested", False),
+            "can_edit": is_admin or (user_id is not None and post.get("user_id") == user_id),
+            "edit_href": f"{blog_url_base}/{slug}/admin/edit/",
+            "is_page": bool(post.get("is_page")),
+            "has_user": bool(user),
+            "liked": post.get("is_liked", False),
+            "like_url": f"{blog_url_base}/{slug}/like/toggle/",
+            "csrf": csrf,
+            "custom_excerpt": post.get("custom_excerpt") or "",
+            "tags": tags,
+            "authors": authors,
+            "feature_image": post.get("feature_image"),
+            "html_content": post.get("html", ""),
+            "sx_content": post.get("sx_content", ""),
+        }
+
+    async def preview_data(self, session, *, slug=None, **kw):
+        """Build preview data with prettified/rendered content."""
+        from quart import g
+        from models.ghost_content import Post
+        from sqlalchemy import select as sa_select
+
+        post_id = g.post_data["post"]["id"]
+        post = (await session.execute(
+            sa_select(Post).where(Post.id == post_id)
+        )).scalar_one_or_none()
+
+        result = {}
+        sx_content = getattr(post, "sx_content", None) or ""
+        if sx_content:
+            from shared.sx.prettify import sx_to_pretty_sx
+            result["sx_pretty"] = sx_to_pretty_sx(sx_content)
+        lexical_raw = getattr(post, "lexical", None) or ""
+        if lexical_raw:
+            from shared.sx.prettify import json_to_pretty_sx
+            result["json_pretty"] = json_to_pretty_sx(lexical_raw)
+        if sx_content:
+            from shared.sx.parser import parse as sx_parse
+            from shared.sx.html import render as sx_html_render
+            from shared.sx.jinja_bridge import _COMPONENT_ENV
+            try:
+                parsed = sx_parse(sx_content)
+                result["sx_rendered"] = sx_html_render(parsed, dict(_COMPONENT_ENV))
+            except Exception:
+                result["sx_rendered"] = "<em>Error rendering sx</em>"
+        if lexical_raw:
+            from bp.blog.ghost.lexical_renderer import render_lexical
+            try:
+                result["lex_rendered"] = render_lexical(lexical_raw)
+            except Exception:
+                result["lex_rendered"] = "<em>Error rendering lexical</em>"
+        return result
--- a/blog/sx/admin.sx
+++ b/blog/sx/admin.sx
@@ -169,3 +169,126 @@
  (details :class "border rounded bg-white"
    (summary :class "cursor-pointer px-4 py-3 font-medium text-sm bg-stone-100 hover:bg-stone-200 select-none" title)
    (div :class "p-4 overflow-x-auto text-xs" content)))
+
+(defcomp ~blog-preview-rendered (&key html)
+  (div :class "blog-content prose max-w-none" (raw! html)))
+
+(defcomp ~blog-preview-empty ()
+  (div :class "p-8 text-stone-500" "No content to preview."))
+
+(defcomp ~blog-admin-placeholder ()
+  (div :class "pb-8"))
+
+;; ---------------------------------------------------------------------------
+;; Data-driven content defcomps (called from defpages with service data)
+;; ---------------------------------------------------------------------------
+
+;; Snippets — receives serialized snippet dicts from service
+(defcomp ~blog-snippets-content (&key snippets is-admin csrf)
+  (~blog-snippets-panel
+    :list (if (empty? (or snippets (list)))
+      (~empty-state :icon "fa fa-puzzle-piece"
+        :message "No snippets yet. Create one from the blog editor.")
+      (~blog-snippets-list
+        :rows (map (lambda (s)
+          (let* ((badge-colours (dict
+                   "private" "bg-stone-200 text-stone-700"
+                   "shared" "bg-blue-100 text-blue-700"
+                   "admin" "bg-amber-100 text-amber-700"))
+                 (vis (or (get s "visibility") "private"))
+                 (badge-cls (or (get badge-colours vis) "bg-stone-200 text-stone-700"))
+                 (name (get s "name"))
+                 (owner (get s "owner"))
+                 (can-delete (get s "can_delete")))
+            (~blog-snippet-row
+              :name name :owner owner :badge-cls badge-cls :visibility vis
+              :extra (<>
+                (when is-admin
+                  (~blog-snippet-visibility-select
+                    :patch-url (get s "patch_url")
+                    :hx-headers (str "{\"X-CSRFToken\": \"" csrf "\"}")
+                    :options (<>
+                      (~blog-snippet-option :value "private" :selected (= vis "private") :label "private")
+                      (~blog-snippet-option :value "shared" :selected (= vis "shared") :label "shared")
+                      (~blog-snippet-option :value "admin" :selected (= vis "admin") :label "admin"))))
+                (when can-delete
+                  (~delete-btn
+                    :url (get s "delete_url")
+                    :trigger-target "#snippets-list"
+                    :title "Delete snippet?"
+                    :text (str "Delete \u201c" name "\u201d?")
+                    :sx-headers (str "{\"X-CSRFToken\": \"" csrf "\"}")
+                    :cls "px-3 py-1 text-sm bg-red-200 hover:bg-red-300 rounded text-red-800 flex-shrink-0"))))))
+          (or snippets (list)))))))
+
+;; Menu Items — receives serialized menu item dicts from service
+(defcomp ~blog-menu-items-content (&key menu-items new-url csrf)
+  (~blog-menu-items-panel
+    :new-url new-url
+    :list (if (empty? (or menu-items (list)))
+      (~empty-state :icon "fa fa-inbox"
+        :message "No menu items yet. Add one to get started!")
+      (~blog-menu-items-list
+        :rows (map (lambda (mi)
+          (~blog-menu-item-row
+            :img (~img-or-placeholder
+              :src (get mi "feature_image") :alt (get mi "label")
+              :size-cls "w-12 h-12 rounded-full object-cover flex-shrink-0")
+            :label (get mi "label")
+            :slug (get mi "url")
+            :sort-order (str (or (get mi "sort_order") 0))
+            :edit-url (get mi "edit_url")
+            :delete-url (get mi "delete_url")
+            :confirm-text (str "Remove " (get mi "label") " from the menu?")
+            :hx-headers (str "{\"X-CSRFToken\": \"" csrf "\"}")))
+          (or menu-items (list)))))))
+
+;; Tag Groups — receives serialized tag group data from service
+(defcomp ~blog-tag-groups-content (&key groups unassigned-tags create-url csrf)
+  (~blog-tag-groups-main
+    :form (~blog-tag-groups-create-form :create-url create-url :csrf csrf)
+    :groups (if (empty? (or groups (list)))
+      (~empty-state :icon "fa fa-tags" :message "No tag groups yet.")
+      (~blog-tag-groups-list
+        :items (map (lambda (g)
+          (let* ((fi (get g "feature_image"))
+                 (colour (get g "colour"))
+                 (name (get g "name"))
+                 (initial (slice (or name "?") 0 1))
+                 (icon (if fi
+                   (~blog-tag-group-icon-image :src fi :name name)
+                   (~blog-tag-group-icon-color
+                     :style (if colour (str "background:" colour) "background:#e7e5e4")
+                     :initial initial))))
+            (~blog-tag-group-li
+              :icon icon
+              :edit-href (get g "edit_href")
+              :name name
+              :slug (or (get g "slug") "")
+              :sort-order (or (get g "sort_order") 0))))
+          (or groups (list)))))
+    :unassigned (when (not (empty? (or unassigned-tags (list))))
+      (~blog-unassigned-tags
+        :heading (str (len (or unassigned-tags (list))) " Unassigned Tags")
+        :spans (map (lambda (t)
+          (~blog-unassigned-tag :name (get t "name")))
+          (or unassigned-tags (list)))))))
+
+;; Tag Group Edit — receives serialized tag group + tags from service
+(defcomp ~blog-tag-group-edit-content (&key group all-tags save-url delete-url csrf)
+  (~blog-tag-group-edit-main
+    :edit-form (~blog-tag-group-edit-form
+      :save-url save-url :csrf csrf
+      :name (get group "name")
+      :colour (get group "colour")
+      :sort-order (get group "sort_order")
+      :feature-image (get group "feature_image")
+      :tags (map (lambda (t)
+        (~blog-tag-checkbox
+          :tag-id (get t "id")
+          :checked (get t "checked")
+          :img (when (get t "feature_image")
+            (~blog-tag-checkbox-image :src (get t "feature_image")))
+          :name (get t "name")))
+        (or all-tags (list))))
+    :delete-form (~blog-tag-group-delete-form :delete-url delete-url :csrf csrf)))
--- a/blog/sx/detail.sx
+++ b/blog/sx/detail.sx
@@ -36,6 +36,37 @@
      (when html-content (div :class "blog-content p-2" (~rich-text :html html-content)))))
    (div :class "pb-8")))

+;; ---------------------------------------------------------------------------
+;; Data-driven composition — replaces _post_main_panel_sx
+;; ---------------------------------------------------------------------------
+
+(defcomp ~blog-post-detail-content (&key slug is-draft publish-requested can-edit edit-href
+                                         is-page has-user liked like-url csrf
+                                         custom-excerpt tags authors
+                                         feature-image html-content sx-content)
+  (let* ((hx-select "#main-panel")
+         (draft-sx (when is-draft
+           (~blog-detail-draft
+             :publish-requested publish-requested
+             :edit (when can-edit
+               (~blog-detail-edit-link :href edit-href :hx-select hx-select)))))
+         (chrome-sx (when (not is-page)
+           (~blog-detail-chrome
+             :like (when has-user
+               (~blog-detail-like
+                 :like-url like-url
+                 :hx-headers (str "{\"X-CSRFToken\": \"" csrf "\"}")
+                 :heart (if liked "\u2764\ufe0f" "\U0001f90d")))
+             :excerpt (when (not (= custom-excerpt ""))
+               (~blog-detail-excerpt :excerpt custom-excerpt))
+             :at-bar (~blog-at-bar :tags tags :authors authors)))))
+    (~blog-detail-main
+      :draft draft-sx
+      :chrome chrome-sx
+      :feature-image feature-image
+      :html-content html-content
+      :sx-content sx-content)))
+
 (defcomp ~blog-meta (&key robots page-title desc canonical og-type og-title image twitter-card twitter-title)
  (<>
    (meta :name "robots" :content robots)
--- a/blog/sx/index.sx
+++ b/blog/sx/index.sx
@@ -30,3 +30,224 @@
      tag-groups-filter
      authors-filter)
    (div :id "filter-summary-desktop" :hxx-swap-oob "outerHTML")))
+
+;; ---------------------------------------------------------------------------
+;; Data-driven composition defcomps — replace Python sx_components functions
+;; ---------------------------------------------------------------------------
+
+;; Helper: CSS class for filter item based on selection state
+(defcomp ~blog-filter-cls (&key is-on)
+  ;; Returns nothing — use inline (if is-on ...) instead
+  nil)
+
+;; Blog index main content — replaces _blog_main_panel_sx
+(defcomp ~blog-index-main-content (&key content-type view cards page total-pages
+                                        current-local-href hx-select blog-url-base)
+  (let* ((posts-href (str blog-url-base "/index"))
+         (pages-href (str posts-href "?type=pages"))
+         (posts-cls (if (not (= content-type "pages"))
+           "bg-stone-700 text-white" "bg-stone-100 text-stone-600 hover:bg-stone-200"))
+         (pages-cls (if (= content-type "pages")
+           "bg-stone-700 text-white" "bg-stone-100 text-stone-600 hover:bg-stone-200")))
+    (if (= content-type "pages")
+      ;; Pages listing
+      (~blog-main-panel-pages
+        :tabs (~blog-content-type-tabs
+          :posts-href posts-href :pages-href pages-href
+          :hx-select hx-select :posts-cls posts-cls :pages-cls pages-cls)
+        :cards (<>
+          (map (lambda (card)
+            (~blog-page-card
+              :href (get card "href") :hx-select hx-select
+              :title (get card "title")
+              :has-calendar (get card "has_calendar")
+              :has-market (get card "has_market")
+              :pub-timestamp (get card "pub_timestamp")
+              :feature-image (get card "feature_image")
+              :excerpt (get card "excerpt")))
+            (or cards (list)))
+          (if (< page total-pages)
+            (~sentinel-simple
+              :id (str "sentinel-" page "-d")
+              :next-url (str current-local-href
+                (if (contains? current-local-href "?") "&" "?")
+                "page=" (+ page 1)))
+            (if (not (empty? (or cards (list))))
+              (~end-of-results)
+              (~blog-no-pages)))))
+      ;; Posts listing
+      (let* ((grid-cls (if (= view "tile")
+               "max-w-full px-3 py-3 grid grid-cols-1 sm:grid-cols-2 md:grid-cols-3 gap-4"
+               "max-w-full px-3 py-3 space-y-3"))
+             (list-href current-local-href)
+             (tile-href (str current-local-href
+               (if (contains? current-local-href "?") "&" "?") "view=tile"))
+             (list-cls (if (not (= view "tile"))
+               "bg-stone-200 text-stone-800"
+               "text-stone-400 hover:text-stone-600"))
+             (tile-cls (if (= view "tile")
+               "bg-stone-200 text-stone-800"
+               "text-stone-400 hover:text-stone-600")))
+        (~blog-main-panel-posts
+          :tabs (~blog-content-type-tabs
+            :posts-href posts-href :pages-href pages-href
+            :hx-select hx-select :posts-cls posts-cls :pages-cls pages-cls)
+          :toggle (~view-toggle
+            :list-href list-href :tile-href tile-href :hx-select hx-select
+            :list-cls list-cls :tile-cls tile-cls :storage-key "blog_view"
+            :list-svg (~list-svg) :tile-svg (~tile-svg))
+          :grid-cls grid-cls
+          :cards (<>
+            (map (lambda (card)
+              (if (= view "tile")
+                (~blog-card-tile
+                  :href (get card "href") :hx-select hx-select
+                  :feature-image (get card "feature_image")
+                  :title (get card "title") :is-draft (get card "is_draft")
+                  :publish-requested (get card "publish_requested")
+                  :status-timestamp (get card "status_timestamp")
+                  :excerpt (get card "excerpt")
+                  :tags (get card "tags") :authors (get card "authors"))
+                (~blog-card
+                  :slug (get card "slug") :href (get card "href") :hx-select hx-select
+                  :title (get card "title") :feature-image (get card "feature_image")
+                  :excerpt (get card "excerpt") :is-draft (get card "is_draft")
+                  :publish-requested (get card "publish_requested")
+                  :status-timestamp (get card "status_timestamp")
+                  :has-like (get card "has_like") :liked (get card "liked")
+                  :like-url (get card "like_url") :csrf-token (get card "csrf_token")
+                  :tags (get card "tags") :authors (get card "authors")
+                  :widget (get card "widget"))))
+              (or cards (list)))
+            (~blog-index-sentinel
+              :page page :total-pages total-pages
+              :current-local-href current-local-href)))))))
+
+;; Sentinel for blog index infinite scroll
+(defcomp ~blog-index-sentinel (&key page total-pages current-local-href)
+  (when (< page total-pages)
+    (let* ((next-url (str current-local-href "?page=" (+ page 1))))
+      (~sentinel-desktop
+        :id (str "sentinel-" page "-d")
+        :next-url next-url
+        :hyperscript "init if not me.dataset.retryMs then set me.dataset.retryMs to 1000 end on htmx:beforeRequest(event) add .hidden to .js-neterr in me remove .hidden from .js-loading in me remove .opacity-100 from me add .opacity-0 to me set trig to null if event.detail and event.detail.triggeringEvent then set trig to event.detail.triggeringEvent end if trig and trig.type is 'intersect' set scroller to the closest .js-grid-viewport if scroller is null then halt end if scroller.scrollTop < 20 then halt end end def backoff() set ms to me.dataset.retryMs if ms > 30000 then set ms to 30000 end add .hidden to .js-loading in me remove .hidden from .js-neterr in me remove .opacity-0 from me add .opacity-100 to me wait ms ms trigger sentinel:retry set ms to ms * 2 if ms > 30000 then set ms to 30000 end set me.dataset.retryMs to ms end on htmx:sendError call backoff() on htmx:responseError call backoff() on htmx:timeout call backoff()"))))
+
+;; Blog index action buttons — replaces _action_buttons_sx
+(defcomp ~blog-index-actions (&key is-admin has-user hx-select draft-count drafts
+                                   new-post-href new-page-href current-local-href)
+  (~blog-action-buttons-wrapper
+    :inner (<>
+      (when is-admin
+        (<>
+          (~blog-action-button
+            :href new-post-href :hx-select hx-select
+            :btn-class "px-3 py-1 rounded bg-stone-700 text-white text-sm hover:bg-stone-800 transition-colors"
+            :title "New Post" :icon-class "fa fa-plus mr-1" :label " New Post")
+          (~blog-action-button
+            :href new-page-href :hx-select hx-select
+            :btn-class "px-3 py-1 rounded bg-blue-600 text-white text-sm hover:bg-blue-700 transition-colors"
+            :title "New Page" :icon-class "fa fa-plus mr-1" :label " New Page")))
+      (when (and has-user (or draft-count drafts))
+        (if drafts
+          (~blog-drafts-button
+            :href current-local-href :hx-select hx-select
+            :btn-class "px-3 py-1 rounded bg-stone-700 text-white text-sm hover:bg-stone-800 transition-colors"
+            :title "Hide Drafts" :label " Drafts " :draft-count (str draft-count))
+          (let* ((on-href (str current-local-href
+                   (if (contains? current-local-href "?") "&" "?") "drafts=1")))
+            (~blog-drafts-button-amber
+              :href on-href :hx-select hx-select
+              :btn-class "px-3 py-1 rounded bg-amber-600 text-white text-sm hover:bg-amber-700 transition-colors"
+              :title "Show Drafts" :label " Drafts " :draft-count (str draft-count))))))))
+
+;; Tag groups filter — replaces _tag_groups_filter_sx
+(defcomp ~blog-index-tag-groups-filter (&key tag-groups is-any-group hx-select)
+  (~blog-filter-nav
+    :items (<>
+      (~blog-filter-any-topic
+        :cls (if is-any-group
+          "bg-stone-900 text-white border-stone-900"
+          "bg-white text-stone-600 border-stone-300 hover:bg-stone-50")
+        :hx-select hx-select)
+      (map (lambda (grp)
+        (let* ((is-on (get grp "is_selected"))
+               (cls (if is-on
+                 "bg-stone-900 text-white border-stone-900"
+                 "bg-white text-stone-600 border-stone-300 hover:bg-stone-50"))
+               (fi (get grp "feature_image"))
+               (colour (get grp "colour"))
+               (name (get grp "name"))
+               (icon (if fi
+                 (~blog-filter-group-icon-image :src fi :name name)
+                 (~blog-filter-group-icon-color
+                   :style (if colour
+                     (str "background-color: " colour "; color: white;")
+                     "background-color: #e7e5e4; color: #57534e;")
+                   :initial (slice (or name "?") 0 1)))))
+          (~blog-filter-group-li
+            :cls cls :hx-get (str "?group=" (get grp "slug") "&page=1")
+            :hx-select hx-select :icon icon
+            :name name :count (str (get grp "post_count")))))
+        (or tag-groups (list))))))
+
+;; Authors filter — replaces _authors_filter_sx
+(defcomp ~blog-index-authors-filter (&key authors is-any-author hx-select)
+  (~blog-filter-nav
+    :items (<>
+      (~blog-filter-any-author
+        :cls (if is-any-author
+          "bg-stone-900 text-white border-stone-900"
+          "bg-white text-stone-600 border-stone-300 hover:bg-stone-50")
+        :hx-select hx-select)
+      (map (lambda (a)
+        (let* ((is-on (get a "is_selected"))
+               (cls (if is-on
+                 "bg-stone-900 text-white border-stone-900"
+                 "bg-white text-stone-600 border-stone-300 hover:bg-stone-50"))
+               (img (get a "profile_image")))
+          (~blog-filter-author-li
+            :cls cls :hx-get (str "?author=" (get a "slug") "&page=1")
+            :hx-select hx-select
+            :icon (when img (~blog-filter-author-icon :src img :name (get a "name")))
+            :name (get a "name")
+            :count (str (get a "published_post_count")))))
+        (or authors (list))))))
+
+;; Blog index aside — replaces _blog_aside_sx
+(defcomp ~blog-index-aside-content (&key is-admin has-user hx-select draft-count drafts
+                                         new-post-href new-page-href current-local-href
+                                         tag-groups authors is-any-group is-any-author)
+  (~blog-aside
+    :search (~search-desktop)
+    :action-buttons (~blog-index-actions
+      :is-admin is-admin :has-user has-user :hx-select hx-select
+      :draft-count draft-count :drafts drafts
+      :new-post-href new-post-href :new-page-href new-page-href
+      :current-local-href current-local-href)
+    :tag-groups-filter (~blog-index-tag-groups-filter
+      :tag-groups tag-groups :is-any-group is-any-group :hx-select hx-select)
+    :authors-filter (~blog-index-authors-filter
+      :authors authors :is-any-author is-any-author :hx-select hx-select)))
+
+;; Blog index mobile filter — replaces _blog_filter_sx
+(defcomp ~blog-index-filter-content (&key is-admin has-user hx-select draft-count drafts
+                                          new-post-href new-page-href current-local-href
+                                          tag-groups authors is-any-group is-any-author
+                                          tg-summary au-summary)
+  (~mobile-filter
+    :filter-summary (<>
+      (~search-mobile)
+      (when (not (= tg-summary ""))
+        (~blog-filter-summary :text tg-summary))
+      (when (not (= au-summary ""))
+        (~blog-filter-summary :text au-summary)))
+    :action-buttons (~blog-index-actions
+      :is-admin is-admin :has-user has-user :hx-select hx-select
+      :draft-count draft-count :drafts drafts
+      :new-post-href new-post-href :new-page-href new-page-href
+      :current-local-href current-local-href)
+    :filter-details (<>
+      (~blog-index-tag-groups-filter
+        :tag-groups tag-groups :is-any-group is-any-group :hx-select hx-select)
+      (~blog-index-authors-filter
+        :authors authors :is-any-author is-any-author :hx-select hx-select))))
--- a/blog/sx/layouts.sx
+++ b/blog/sx/layouts.sx
@@ -0,0 +1,51 @@
+;; Blog layout defcomps — fully self-contained via IO primitives.
+
+;; --- Blog header (invisible row for blog-header-child swap target) ---
+
+(defcomp ~blog-header (&key oob)
+  (~menu-row-sx :id "blog-row" :level 1
+    :link-label-content (div)
+    :child-id "blog-header-child" :oob oob))
+
+;; --- Blog layout (root + blog header) ---
+
+(defcomp ~blog-layout-full ()
+  (<> (~root-header-auto)
+    (~blog-header)))
+
+;; --- Settings layout (root + settings header) ---
+
+(defcomp ~settings-layout-full (&key settings-header)
+  (<> (~root-header-auto)
+    settings-header))
+
+;; --- Sub-settings layout (root + settings + sub row) ---
+
+(defcomp ~sub-settings-layout-full (&key settings-header sub-header)
+  (<> (~root-header-auto)
+    settings-header sub-header))
+
+(defcomp ~sub-settings-layout-oob (&key settings-header-oob sub-header-oob)
+  (<> settings-header-oob sub-header-oob))
+
+;; --- Settings nav links — uses (select-colours) IO primitive ---
+
+(defcomp ~blog-settings-nav ()
+  (let* ((sc (select-colours))
+         (links (list
+           (dict :endpoint "menu_items.defpage_menu_items_page" :icon "fa fa-bars" :label "Menu Items")
+           (dict :endpoint "snippets.defpage_snippets_page" :icon "fa fa-puzzle-piece" :label "Snippets")
+           (dict :endpoint "blog.tag_groups_admin.defpage_tag_groups_page" :icon "fa fa-tags" :label "Tag Groups")
+           (dict :endpoint "settings.defpage_cache_page" :icon "fa fa-refresh" :label "Cache"))))
+    (<> (map (lambda (lnk)
+      (~nav-link
+        :href (url-for (get lnk "endpoint"))
+        :icon (get lnk "icon")
+        :label (get lnk "label")
+        :select-colours (or sc "")))
+      links))))
+
+;; --- Editor panel wrapper ---
+
+(defcomp ~blog-editor-panel (&key parts)
+  (<> parts))
--- a/blog/sx/settings.sx
+++ b/blog/sx/settings.sx
@@ -54,6 +54,43 @@
      (button :type "submit"
        :class "bg-stone-800 text-white px-4 py-1.5 rounded text-sm hover:bg-stone-700" "Create"))))

+;; ---------------------------------------------------------------------------
+;; Data-driven composition defcomps — replace Python render_* functions
+;; ---------------------------------------------------------------------------
+
+;; Features panel composition — replaces render_features_panel
+(defcomp ~blog-features-panel-content (&key features-url calendar-checked market-checked
+                                            show-sumup sumup-url merchant-code placeholder
+                                            sumup-configured checkout-prefix)
+  (~blog-features-panel
+    :form (~blog-features-form
+      :features-url features-url
+      :calendar-checked calendar-checked
+      :market-checked market-checked
+      :hs-trigger "on change trigger submit on closest <form/>")
+    :sumup (when show-sumup
+      (~blog-sumup-form
+        :sumup-url sumup-url
+        :merchant-code merchant-code
+        :placeholder placeholder
+        :sumup-configured sumup-configured
+        :checkout-prefix checkout-prefix))))
+
+;; Markets panel composition — replaces render_markets_panel
+(defcomp ~blog-markets-panel-content (&key markets create-url)
+  (~blog-markets-panel
+    :list (if (empty? (or markets (list)))
+      (~blog-markets-empty)
+      (~blog-markets-list
+        :items (map (lambda (m)
+          (~blog-market-item
+            :name (get m "name")
+            :slug (get m "slug")
+            :delete-url (get m "delete_url")
+            :confirm-text (str "Delete market '" (get m "name") "'?")))
+          (or markets (list)))))
+    :create-url create-url))
+
 ;; Associated entries

 (defcomp ~blog-entry-image (&key src title)
--- a/blog/sx/sx_components.py
+++ b/blog/sx/sx_components.py
--- a/blog/sxc/pages/init.py
+++ b/blog/sxc/pages/init.py
@@ -1,11 +1,11 @@
 """Blog defpage setup — registers layouts, page helpers, and loads .sx pages."""
 from __future__ import annotations

-from typing import Any
-

 def setup_blog_pages() -> None:
    """Register blog-specific layouts, page helpers, and load page definitions."""
+    from .layouts import _register_blog_layouts
+    from .helpers import _register_blog_helpers
    _register_blog_layouts()
    _register_blog_helpers()
    _load_blog_page_files()
@@ -14,561 +14,7 @@ def setup_blog_pages() -> None:
 def _load_blog_page_files() -> None:
    import os
    from shared.sx.pages import load_page_dir
+    from shared.sx.jinja_bridge import load_service_components
+    blog_dir = os.path.dirname(os.path.dirname(os.path.dirname(__file__)))
+    load_service_components(blog_dir, service_name="blog")
    load_page_dir(os.path.dirname(__file__), "blog")
-
-
-# ---------------------------------------------------------------------------
-# Shared hydration helpers
-# ---------------------------------------------------------------------------
-
-def _add_to_defpage_ctx(**kwargs: Any) -> None:
-    from quart import g
-    if not hasattr(g, '_defpage_ctx'):
-        g._defpage_ctx = {}
-    g._defpage_ctx.update(kwargs)
-
-
-async def _ensure_post_data(slug: str | None) -> None:
-    """Load post data and set g.post_data + defpage context.
-
-    Replicates post bp's hydrate_post_data + context_processor.
-    """
-    from quart import g, abort
-
-    if hasattr(g, 'post_data') and g.post_data:
-        await _inject_post_context(g.post_data)
-        return
-
-    if not slug:
-        abort(404)
-
-    from bp.post.services.post_data import post_data
-
-    is_admin = bool((g.get("rights") or {}).get("admin"))
-    p_data = await post_data(slug, g.s, include_drafts=True)
-    if not p_data:
-        abort(404)
-
-    # Draft access control
-    if p_data["post"].get("status") != "published":
-        if is_admin:
-            pass
-        elif g.user and p_data["post"].get("user_id") == g.user.id:
-            pass
-        else:
-            abort(404)
-
-    g.post_data = p_data
-    g.post_slug = slug
-    await _inject_post_context(p_data)
-
-
-async def _inject_post_context(p_data: dict) -> None:
-    """Add post context_processor data to defpage context."""
-    from shared.config import config
-    from shared.infrastructure.fragments import fetch_fragment
-    from shared.infrastructure.data_client import fetch_data
-    from shared.contracts.dtos import CartSummaryDTO, dto_from_dict
-    from shared.infrastructure.cart_identity import current_cart_identity
-
-    db_post_id = p_data["post"]["id"]
-    post_slug = p_data["post"]["slug"]
-
-    container_nav = await fetch_fragment("relations", "container-nav", params={
-        "container_type": "page",
-        "container_id": str(db_post_id),
-        "post_slug": post_slug,
-    })
-
-    ctx: dict = {
-        **p_data,
-        "base_title": config()["title"],
-        "container_nav": container_nav,
-    }
-
-    if p_data["post"].get("is_page"):
-        ident = current_cart_identity()
-        summary_params: dict = {"page_slug": post_slug}
-        if ident["user_id"] is not None:
-            summary_params["user_id"] = ident["user_id"]
-        if ident["session_id"] is not None:
-            summary_params["session_id"] = ident["session_id"]
-        raw_summary = await fetch_data(
-            "cart", "cart-summary", params=summary_params, required=False,
-        )
-        page_summary = dto_from_dict(CartSummaryDTO, raw_summary) if raw_summary else CartSummaryDTO()
-        ctx["page_cart_count"] = (
-            page_summary.count + page_summary.calendar_count + page_summary.ticket_count
-        )
-        ctx["page_cart_total"] = float(
-            page_summary.total + page_summary.calendar_total + page_summary.ticket_total
-        )
-
-    _add_to_defpage_ctx(**ctx)
-
-
-# ---------------------------------------------------------------------------
-# Layouts
-# ---------------------------------------------------------------------------
-
-def _register_blog_layouts() -> None:
-    from shared.sx.layouts import register_custom_layout
-    # :blog — root + blog header (for new-post, new-page)
-    register_custom_layout("blog", _blog_full, _blog_oob)
-    # :blog-settings — root + settings header (with settings nav menu)
-    register_custom_layout("blog-settings", _settings_full, _settings_oob,
-                           mobile_fn=_settings_mobile)
-    # Sub-settings layouts (root + settings + sub header)
-    register_custom_layout("blog-cache", _cache_full, _cache_oob)
-    register_custom_layout("blog-snippets", _snippets_full, _snippets_oob)
-    register_custom_layout("blog-menu-items", _menu_items_full, _menu_items_oob)
-    register_custom_layout("blog-tag-groups", _tag_groups_full, _tag_groups_oob)
-    register_custom_layout("blog-tag-group-edit",
-                           _tag_group_edit_full, _tag_group_edit_oob)
-
-
-# --- Blog layout (root + blog header) ---
-
-def _blog_full(ctx: dict, **kw: Any) -> str:
-    from shared.sx.helpers import root_header_sx
-    from sx.sx_components import _blog_header_sx
-    root_hdr = root_header_sx(ctx)
-    blog_hdr = _blog_header_sx(ctx)
-    return "(<> " + root_hdr + " " + blog_hdr + ")"
-
-
-def _blog_oob(ctx: dict, **kw: Any) -> str:
-    from shared.sx.helpers import root_header_sx, oob_header_sx
-    from sx.sx_components import _blog_header_sx
-    root_hdr = root_header_sx(ctx)
-    blog_hdr = _blog_header_sx(ctx)
-    rows = "(<> " + root_hdr + " " + blog_hdr + ")"
-    return oob_header_sx("root-header-child", "blog-header-child", rows)
-
-
-# --- Settings layout (root + settings header) ---
-
-def _settings_full(ctx: dict, **kw: Any) -> str:
-    from shared.sx.helpers import root_header_sx
-    from sx.sx_components import _settings_header_sx
-    root_hdr = root_header_sx(ctx)
-    settings_hdr = _settings_header_sx(ctx)
-    return "(<> " + root_hdr + " " + settings_hdr + ")"
-
-
-def _settings_oob(ctx: dict, **kw: Any) -> str:
-    from shared.sx.helpers import root_header_sx, oob_header_sx
-    from sx.sx_components import _settings_header_sx
-    root_hdr = root_header_sx(ctx)
-    settings_hdr = _settings_header_sx(ctx)
-    rows = "(<> " + root_hdr + " " + settings_hdr + ")"
-    return oob_header_sx("root-header-child", "root-settings-header-child", rows)
-
-
-def _settings_mobile(ctx: dict, **kw: Any) -> str:
-    from sx.sx_components import _settings_nav_sx
-    return _settings_nav_sx(ctx)
-
-
-# --- Sub-settings helpers ---
-
-def _sub_settings_full(ctx: dict, row_id: str, child_id: str,
-                       endpoint: str, icon: str, label: str) -> str:
-    from shared.sx.helpers import root_header_sx
-    from sx.sx_components import _settings_header_sx, _sub_settings_header_sx
-    from quart import url_for as qurl
-    root_hdr = root_header_sx(ctx)
-    settings_hdr = _settings_header_sx(ctx)
-    sub_hdr = _sub_settings_header_sx(row_id, child_id,
-                                       qurl(endpoint), icon, label, ctx)
-    return "(<> " + root_hdr + " " + settings_hdr + " " + sub_hdr + ")"
-
-
-def _sub_settings_oob(ctx: dict, row_id: str, child_id: str,
-                      endpoint: str, icon: str, label: str) -> str:
-    from shared.sx.helpers import oob_header_sx
-    from sx.sx_components import _settings_header_sx, _sub_settings_header_sx
-    from quart import url_for as qurl
-    settings_hdr_oob = _settings_header_sx(ctx, oob=True)
-    sub_hdr = _sub_settings_header_sx(row_id, child_id,
-                                       qurl(endpoint), icon, label, ctx)
-    sub_oob = oob_header_sx("root-settings-header-child", child_id, sub_hdr)
-    return "(<> " + settings_hdr_oob + " " + sub_oob + ")"
-
-
-# --- Cache ---
-
-def _cache_full(ctx: dict, **kw: Any) -> str:
-    return _sub_settings_full(ctx, "cache-row", "cache-header-child",
-                              "defpage_cache_page", "refresh", "Cache")
-
-
-def _cache_oob(ctx: dict, **kw: Any) -> str:
-    return _sub_settings_oob(ctx, "cache-row", "cache-header-child",
-                             "defpage_cache_page", "refresh", "Cache")
-
-
-# --- Snippets ---
-
-def _snippets_full(ctx: dict, **kw: Any) -> str:
-    return _sub_settings_full(ctx, "snippets-row", "snippets-header-child",
-                              "defpage_snippets_page", "puzzle-piece", "Snippets")
-
-
-def _snippets_oob(ctx: dict, **kw: Any) -> str:
-    return _sub_settings_oob(ctx, "snippets-row", "snippets-header-child",
-                             "defpage_snippets_page", "puzzle-piece", "Snippets")
-
-
-# --- Menu Items ---
-
-def _menu_items_full(ctx: dict, **kw: Any) -> str:
-    return _sub_settings_full(ctx, "menu_items-row", "menu_items-header-child",
-                              "defpage_menu_items_page", "bars", "Menu Items")
-
-
-def _menu_items_oob(ctx: dict, **kw: Any) -> str:
-    return _sub_settings_oob(ctx, "menu_items-row", "menu_items-header-child",
-                             "defpage_menu_items_page", "bars", "Menu Items")
-
-
-# --- Tag Groups ---
-
-def _tag_groups_full(ctx: dict, **kw: Any) -> str:
-    return _sub_settings_full(ctx, "tag-groups-row", "tag-groups-header-child",
-                              "defpage_tag_groups_page", "tags", "Tag Groups")
-
-
-def _tag_groups_oob(ctx: dict, **kw: Any) -> str:
-    return _sub_settings_oob(ctx, "tag-groups-row", "tag-groups-header-child",
-                             "defpage_tag_groups_page", "tags", "Tag Groups")
-
-
-# --- Tag Group Edit ---
-
-def _tag_group_edit_full(ctx: dict, **kw: Any) -> str:
-    from quart import request
-    g_id = (request.view_args or {}).get("id")
-    from quart import url_for as qurl
-    from shared.sx.helpers import root_header_sx
-    from sx.sx_components import _settings_header_sx, _sub_settings_header_sx
-    root_hdr = root_header_sx(ctx)
-    settings_hdr = _settings_header_sx(ctx)
-    sub_hdr = _sub_settings_header_sx("tag-groups-row", "tag-groups-header-child",
-                                       qurl("defpage_tag_group_edit", id=g_id),
-                                       "tags", "Tag Groups", ctx)
-    return "(<> " + root_hdr + " " + settings_hdr + " " + sub_hdr + ")"
-
-
-def _tag_group_edit_oob(ctx: dict, **kw: Any) -> str:
-    from quart import request
-    g_id = (request.view_args or {}).get("id")
-    from quart import url_for as qurl
-    from shared.sx.helpers import oob_header_sx
-    from sx.sx_components import _settings_header_sx, _sub_settings_header_sx
-    settings_hdr_oob = _settings_header_sx(ctx, oob=True)
-    sub_hdr = _sub_settings_header_sx("tag-groups-row", "tag-groups-header-child",
-                                       qurl("defpage_tag_group_edit", id=g_id),
-                                       "tags", "Tag Groups", ctx)
-    sub_oob = oob_header_sx("root-settings-header-child", "tag-groups-header-child", sub_hdr)
-    return "(<> " + settings_hdr_oob + " " + sub_oob + ")"
-
-
-# ---------------------------------------------------------------------------
-# Page helpers (async functions available in .sx defpage expressions)
-# ---------------------------------------------------------------------------
-
-def _register_blog_helpers() -> None:
-    from shared.sx.pages import register_page_helpers
-    register_page_helpers("blog", {
-        "editor-content": _h_editor_content,
-        "editor-page-content": _h_editor_page_content,
-        "post-admin-content": _h_post_admin_content,
-        "post-data-content": _h_post_data_content,
-        "post-preview-content": _h_post_preview_content,
-        "post-entries-content": _h_post_entries_content,
-        "post-settings-content": _h_post_settings_content,
-        "post-edit-content": _h_post_edit_content,
-        "settings-content": _h_settings_content,
-        "cache-content": _h_cache_content,
-        "snippets-content": _h_snippets_content,
-        "menu-items-content": _h_menu_items_content,
-        "tag-groups-content": _h_tag_groups_content,
-        "tag-group-edit-content": _h_tag_group_edit_content,
-    })
-
-
-# --- Editor helpers ---
-
-async def _h_editor_content(**kw):
-    from sx.sx_components import render_editor_panel
-    return render_editor_panel()
-
-
-async def _h_editor_page_content(**kw):
-    from sx.sx_components import render_editor_panel
-    return render_editor_panel(is_page=True)
-
-
-# --- Post admin helpers ---
-
-async def _h_post_admin_content(slug=None, **kw):
-    await _ensure_post_data(slug)
-    from quart import g
-    from sqlalchemy import select
-    from shared.models.page_config import PageConfig
-    post = (g.post_data or {}).get("post", {})
-    features = {}
-    sumup_configured = False
-    sumup_merchant_code = ""
-    sumup_checkout_prefix = ""
-    if post.get("is_page"):
-        pc = (await g.s.execute(
-            select(PageConfig).where(
-                PageConfig.container_type == "page",
-                PageConfig.container_id == post["id"],
-            )
-        )).scalar_one_or_none()
-        if pc:
-            features = pc.features or {}
-            sumup_configured = bool(pc.sumup_api_key)
-            sumup_merchant_code = pc.sumup_merchant_code or ""
-            sumup_checkout_prefix = pc.sumup_checkout_prefix or ""
-    from shared.sx.page import get_template_context
-    from sx.sx_components import _post_admin_main_panel_sx
-    tctx = await get_template_context()
-    tctx.update({
-        "features": features,
-        "sumup_configured": sumup_configured,
-        "sumup_merchant_code": sumup_merchant_code,
-        "sumup_checkout_prefix": sumup_checkout_prefix,
-    })
-    return _post_admin_main_panel_sx(tctx)
-
-
-async def _h_post_data_content(slug=None, **kw):
-    await _ensure_post_data(slug)
-    from shared.sx.page import get_template_context
-    from sx.sx_components import _post_data_content_sx
-    tctx = await get_template_context()
-    return _post_data_content_sx(tctx)
-
-
-async def _h_post_preview_content(slug=None, **kw):
-    await _ensure_post_data(slug)
-    from quart import g
-    from models.ghost_content import Post
-    from sqlalchemy import select as sa_select
-    post_id = g.post_data["post"]["id"]
-    post = (await g.s.execute(
-        sa_select(Post).where(Post.id == post_id)
-    )).scalar_one_or_none()
-    preview_ctx: dict = {}
-    sx_content = getattr(post, "sx_content", None) or ""
-    if sx_content:
-        from shared.sx.prettify import sx_to_pretty_sx
-        preview_ctx["sx_pretty"] = sx_to_pretty_sx(sx_content)
-    lexical_raw = getattr(post, "lexical", None) or ""
-    if lexical_raw:
-        from shared.sx.prettify import json_to_pretty_sx
-        preview_ctx["json_pretty"] = json_to_pretty_sx(lexical_raw)
-    if sx_content:
-        from shared.sx.parser import parse as sx_parse
-        from shared.sx.html import render as sx_html_render
-        from shared.sx.jinja_bridge import _COMPONENT_ENV
-        try:
-            parsed = sx_parse(sx_content)
-            preview_ctx["sx_rendered"] = sx_html_render(parsed, dict(_COMPONENT_ENV))
-        except Exception:
-            preview_ctx["sx_rendered"] = "<em>Error rendering sx</em>"
-    if lexical_raw:
-        from bp.blog.ghost.lexical_renderer import render_lexical
-        try:
-            preview_ctx["lex_rendered"] = render_lexical(lexical_raw)
-        except Exception:
-            preview_ctx["lex_rendered"] = "<em>Error rendering lexical</em>"
-    from shared.sx.page import get_template_context
-    from sx.sx_components import _preview_main_panel_sx
-    tctx = await get_template_context()
-    tctx.update(preview_ctx)
-    return _preview_main_panel_sx(tctx)
-
-
-async def _h_post_entries_content(slug=None, **kw):
-    await _ensure_post_data(slug)
-    from quart import g
-    from sqlalchemy import select
-    from shared.models.calendars import Calendar
-    from bp.post.services.entry_associations import get_post_entry_ids
-    post_id = g.post_data["post"]["id"]
-    associated_entry_ids = await get_post_entry_ids(post_id)
-    result = await g.s.execute(
-        select(Calendar)
-        .where(Calendar.deleted_at.is_(None))
-        .order_by(Calendar.name.asc())
-    )
-    all_calendars = result.scalars().all()
-    for calendar in all_calendars:
-        await g.s.refresh(calendar, ["entries", "post"])
-    from shared.sx.page import get_template_context
-    from sx.sx_components import _post_entries_content_sx
-    tctx = await get_template_context()
-    tctx["all_calendars"] = all_calendars
-    tctx["associated_entry_ids"] = associated_entry_ids
-    return _post_entries_content_sx(tctx)
-
-
-async def _h_post_settings_content(slug=None, **kw):
-    await _ensure_post_data(slug)
-    from quart import g, request
-    from models.ghost_content import Post
-    from sqlalchemy import select as sa_select
-    from sqlalchemy.orm import selectinload
-    from bp.post.admin.routes import _post_to_edit_dict
-    post_id = g.post_data["post"]["id"]
-    post = (await g.s.execute(
-        sa_select(Post)
-        .where(Post.id == post_id)
-        .options(selectinload(Post.tags))
-    )).scalar_one_or_none()
-    ghost_post = _post_to_edit_dict(post) if post else {}
-    save_success = request.args.get("saved") == "1"
-    from shared.sx.page import get_template_context
-    from sx.sx_components import _post_settings_content_sx
-    tctx = await get_template_context()
-    tctx["ghost_post"] = ghost_post
-    tctx["save_success"] = save_success
-    return _post_settings_content_sx(tctx)
-
-
-async def _h_post_edit_content(slug=None, **kw):
-    await _ensure_post_data(slug)
-    from quart import g, request
-    from models.ghost_content import Post
-    from sqlalchemy import select as sa_select
-    from sqlalchemy.orm import selectinload
-    from shared.infrastructure.data_client import fetch_data
-    from bp.post.admin.routes import _post_to_edit_dict
-    post_id = g.post_data["post"]["id"]
-    post = (await g.s.execute(
-        sa_select(Post)
-        .where(Post.id == post_id)
-        .options(selectinload(Post.tags))
-    )).scalar_one_or_none()
-    ghost_post = _post_to_edit_dict(post) if post else {}
-    save_success = request.args.get("saved") == "1"
-    save_error = request.args.get("error", "")
-    raw_newsletters = await fetch_data("account", "newsletters", required=False) or []
-    from types import SimpleNamespace
-    newsletters = [SimpleNamespace(**nl) for nl in raw_newsletters]
-    from shared.sx.page import get_template_context
-    from sx.sx_components import _post_edit_content_sx
-    tctx = await get_template_context()
-    tctx["ghost_post"] = ghost_post
-    tctx["save_success"] = save_success
-    tctx["save_error"] = save_error
-    tctx["newsletters"] = newsletters
-    return _post_edit_content_sx(tctx)
-
-
-# --- Settings helpers ---
-
-async def _h_settings_content(**kw):
-    from shared.sx.page import get_template_context
-    from sx.sx_components import _settings_main_panel_sx
-    tctx = await get_template_context()
-    return _settings_main_panel_sx(tctx)
-
-
-async def _h_cache_content(**kw):
-    from shared.sx.page import get_template_context
-    from sx.sx_components import _cache_main_panel_sx
-    tctx = await get_template_context()
-    return _cache_main_panel_sx(tctx)
-
-
-# --- Snippets helper ---
-
-async def _h_snippets_content(**kw):
-    from quart import g
-    from sqlalchemy import select, or_
-    from models import Snippet
-    uid = g.user.id
-    is_admin = g.rights.get("admin")
-    filters = [Snippet.user_id == uid, Snippet.visibility == "shared"]
-    if is_admin:
-        filters.append(Snippet.visibility == "admin")
-    rows = (await g.s.execute(
-        select(Snippet).where(or_(*filters)).order_by(Snippet.name)
-    )).scalars().all()
-    from shared.sx.page import get_template_context
-    from sx.sx_components import _snippets_main_panel_sx
-    tctx = await get_template_context()
-    tctx["snippets"] = rows
-    tctx["is_admin"] = is_admin
-    return _snippets_main_panel_sx(tctx)
-
-
-# --- Menu Items helper ---
-
-async def _h_menu_items_content(**kw):
-    from quart import g
-    from bp.menu_items.services.menu_items import get_all_menu_items
-    menu_items = await get_all_menu_items(g.s)
-    from shared.sx.page import get_template_context
-    from sx.sx_components import _menu_items_main_panel_sx
-    tctx = await get_template_context()
-    tctx["menu_items"] = menu_items
-    return _menu_items_main_panel_sx(tctx)
-
-
-# --- Tag Groups helpers ---
-
-async def _h_tag_groups_content(**kw):
-    from quart import g
-    from sqlalchemy import select
-    from models.tag_group import TagGroup
-    from bp.blog.admin.routes import _unassigned_tags
-    groups = list(
-        (await g.s.execute(
-            select(TagGroup).order_by(TagGroup.sort_order, TagGroup.name)
-        )).scalars()
-    )
-    unassigned = await _unassigned_tags(g.s)
-    from shared.sx.page import get_template_context
-    from sx.sx_components import _tag_groups_main_panel_sx
-    tctx = await get_template_context()
-    tctx.update({"groups": groups, "unassigned_tags": unassigned})
-    return _tag_groups_main_panel_sx(tctx)
-
-
-async def _h_tag_group_edit_content(id=None, **kw):
-    from quart import g, abort
-    from sqlalchemy import select
-    from models.tag_group import TagGroup, TagGroupTag
-    from models.ghost_content import Tag
-    tg = await g.s.get(TagGroup, id)
-    if not tg:
-        abort(404)
-    assigned_rows = list(
-        (await g.s.execute(
-            select(TagGroupTag.tag_id).where(TagGroupTag.tag_group_id == id)
-        )).scalars()
-    )
-    all_tags = list(
-        (await g.s.execute(
-            select(Tag).where(
-                Tag.deleted_at.is_(None),
-                (Tag.visibility == "public") | (Tag.visibility.is_(None)),
-            ).order_by(Tag.name)
-        )).scalars()
-    )
-    from shared.sx.page import get_template_context
-    from sx.sx_components import _tag_groups_edit_main_panel_sx
-    tctx = await get_template_context()
-    tctx.update({
-        "group": tg,
-        "all_tags": all_tags,
-        "assigned_tag_ids": set(assigned_rows),
-    })
-    return _tag_groups_edit_main_panel_sx(tctx)
--- a/blog/sxc/pages/blog.sx
+++ b/blog/sxc/pages/blog.sx
@@ -59,13 +59,14 @@
  :path "/settings/"
  :auth :admin
  :layout :blog-settings
-  :content (settings-content))
+  :content (div :class "max-w-2xl mx-auto px-4 py-6"))

 (defpage cache-page
  :path "/settings/cache/"
  :auth :admin
  :layout :blog-cache
-  :content (cache-content))
+  :data (service "blog-page" "cache-data")
+  :content (~blog-cache-panel :clear-url clear-url :csrf csrf))

 ; --- Snippets ---

@@ -73,7 +74,9 @@
  :path "/settings/snippets/"
  :auth :login
  :layout :blog-snippets
-  :content (snippets-content))
+  :data (service "blog-page" "snippets-data")
+  :content (~blog-snippets-content
+    :snippets snippets :is-admin is-admin :csrf csrf))

 ; --- Menu Items ---

@@ -81,7 +84,9 @@
  :path "/settings/menu_items/"
  :auth :admin
  :layout :blog-menu-items
-  :content (menu-items-content))
+  :data (service "blog-page" "menu-items-data")
+  :content (~blog-menu-items-content
+    :menu-items menu-items :new-url new-url :csrf csrf))

 ; --- Tag Groups ---

@@ -89,10 +94,16 @@
  :path "/settings/tag-groups/"
  :auth :admin
  :layout :blog-tag-groups
-  :content (tag-groups-content))
+  :data (service "blog-page" "tag-groups-data")
+  :content (~blog-tag-groups-content
+    :groups groups :unassigned-tags unassigned-tags
+    :create-url create-url :csrf csrf))

 (defpage tag-group-edit
  :path "/settings/tag-groups/<int:id>/"
  :auth :admin
  :layout :blog-tag-group-edit
-  :content (tag-group-edit-content id))
+  :data (service "blog-page" "tag-group-edit-data" :id id)
+  :content (~blog-tag-group-edit-content
+    :group group :all-tags all-tags
+    :save-url save-url :delete-url delete-url :csrf csrf))
--- a/blog/sxc/pages/helpers.py
+++ b/blog/sxc/pages/helpers.py
@@ -0,0 +1,714 @@
+"""Blog page helpers — async functions available in .sx defpage expressions."""
+from __future__ import annotations
+
+from typing import Any
+
+
+# ---------------------------------------------------------------------------
+# Shared hydration helpers
+# ---------------------------------------------------------------------------
+
+def _add_to_defpage_ctx(**kwargs: Any) -> None:
+    from quart import g
+    if not hasattr(g, '_defpage_ctx'):
+        g._defpage_ctx = {}
+    g._defpage_ctx.update(kwargs)
+
+
+async def _ensure_post_data(slug: str | None) -> None:
+    """Load post data and set g.post_data + defpage context.
+
+    Replicates post bp's hydrate_post_data + context_processor.
+    """
+    from quart import g, abort
+
+    if hasattr(g, 'post_data') and g.post_data:
+        await _inject_post_context(g.post_data)
+        return
+
+    if not slug:
+        abort(404)
+
+    from bp.post.services.post_data import post_data
+
+    is_admin = bool((g.get("rights") or {}).get("admin"))
+    p_data = await post_data(slug, g.s, include_drafts=True)
+    if not p_data:
+        abort(404)
+
+    # Draft access control
+    if p_data["post"].get("status") != "published":
+        if is_admin:
+            pass
+        elif g.user and p_data["post"].get("user_id") == g.user.id:
+            pass
+        else:
+            abort(404)
+
+    g.post_data = p_data
+    g.post_slug = slug
+    await _inject_post_context(p_data)
+
+
+async def _inject_post_context(p_data: dict) -> None:
+    """Add post context_processor data to defpage context."""
+    from shared.config import config
+    from shared.infrastructure.fragments import fetch_fragment
+    from shared.infrastructure.data_client import fetch_data
+    from shared.contracts.dtos import CartSummaryDTO, dto_from_dict
+    from shared.infrastructure.cart_identity import current_cart_identity
+
+    db_post_id = p_data["post"]["id"]
+    post_slug = p_data["post"]["slug"]
+
+    container_nav = await fetch_fragment("relations", "container-nav", params={
+        "container_type": "page",
+        "container_id": str(db_post_id),
+        "post_slug": post_slug,
+    })
+
+    ctx: dict = {
+        **p_data,
+        "base_title": config()["title"],
+        "container_nav": container_nav,
+    }
+
+    if p_data["post"].get("is_page"):
+        ident = current_cart_identity()
+        summary_params: dict = {"page_slug": post_slug}
+        if ident["user_id"] is not None:
+            summary_params["user_id"] = ident["user_id"]
+        if ident["session_id"] is not None:
+            summary_params["session_id"] = ident["session_id"]
+        raw_summary = await fetch_data(
+            "cart", "cart-summary", params=summary_params, required=False,
+        )
+        page_summary = dto_from_dict(CartSummaryDTO, raw_summary) if raw_summary else CartSummaryDTO()
+        ctx["page_cart_count"] = (
+            page_summary.count + page_summary.calendar_count + page_summary.ticket_count
+        )
+        ctx["page_cart_total"] = float(
+            page_summary.total + page_summary.calendar_total + page_summary.ticket_total
+        )
+
+    _add_to_defpage_ctx(**ctx)
+
+
+# ---------------------------------------------------------------------------
+# Rendering helpers (moved from sx_components)
+# ---------------------------------------------------------------------------
+
+def _raw_html_sx(html: str) -> str:
+    """Wrap raw HTML in (raw! "...") so it's valid inside sx source."""
+    from shared.sx.parser import serialize as sx_serialize
+    if not html:
+        return ""
+    return "(raw! " + sx_serialize(html) + ")"
+
+
+# ---------------------------------------------------------------------------
+# Page helpers (async functions available in .sx defpage expressions)
+# ---------------------------------------------------------------------------
+
+def _register_blog_helpers() -> None:
+    from shared.sx.pages import register_page_helpers
+    register_page_helpers("blog", {
+        "editor-content": _h_editor_content,
+        "editor-page-content": _h_editor_page_content,
+        "post-admin-content": _h_post_admin_content,
+        "post-data-content": _h_post_data_content,
+        "post-preview-content": _h_post_preview_content,
+        "post-entries-content": _h_post_entries_content,
+        "post-settings-content": _h_post_settings_content,
+        "post-edit-content": _h_post_edit_content,
+    })
+
+
+# --- Editor helpers ---
+
+def _h_editor_content(**kw):
+    from .renders import render_editor_panel
+    return render_editor_panel()
+
+
+def _h_editor_page_content(**kw):
+    from .renders import render_editor_panel
+    return render_editor_panel(is_page=True)
+
+
+# --- Post admin helpers ---
+
+async def _h_post_admin_content(slug=None, **kw):
+    await _ensure_post_data(slug)
+    from shared.sx.helpers import sx_call
+    return sx_call("blog-admin-placeholder")
+
+
+async def _h_post_data_content(slug=None, **kw):
+    await _ensure_post_data(slug)
+    from quart import g
+    from markupsafe import escape as esc
+
+    original_post = getattr(g, "post_data", {}).get("original_post")
+    if original_post is None:
+        return _raw_html_sx('<div class="px-4 py-8 text-stone-400">No post data available.</div>')
+
+    tablename = getattr(original_post, "__tablename__", "?")
+
+    def _render_scalar_table(obj):
+        rows = []
+        for col in obj.__mapper__.columns:
+            key = col.key
+            if key == "_sa_instance_state":
+                continue
+            val = getattr(obj, key, None)
+            if val is None:
+                val_html = '<span class="text-neutral-400">\u2014</span>'
+            elif hasattr(val, "isoformat"):
+                val_html = f'<pre class="whitespace-pre-wrap break-words break-all text-xs"><code>{esc(val.isoformat())}</code></pre>'
+            elif isinstance(val, str):
+                val_html = f'<pre class="whitespace-pre-wrap break-words break-all text-xs">{esc(val)}</pre>'
+            else:
+                val_html = f'<pre class="whitespace-pre-wrap break-words break-all text-xs"><code>{esc(str(val))}</code></pre>'
+            rows.append(
+                f'<tr class="border-t border-neutral-200 align-top">'
+                f'<td class="px-3 py-2 whitespace-nowrap text-neutral-600 align-top">{esc(key)}</td>'
+                f'<td class="px-3 py-2 align-top">{val_html}</td></tr>'
+            )
+        return (
+            '<div class="w-full overflow-x-auto sm:overflow-visible">'
+            '<table class="w-full table-fixed text-sm border border-neutral-200 rounded-xl overflow-hidden">'
+            '<thead class="bg-neutral-50/70"><tr>'
+            '<th class="px-3 py-2 text-left font-medium w-40 sm:w-56">Field</th>'
+            '<th class="px-3 py-2 text-left font-medium">Value</th>'
+            '</tr></thead><tbody>' + "".join(rows) + '</tbody></table></div>'
+        )
+
+    def _render_model(obj, depth=0, max_depth=2):
+        parts = [_render_scalar_table(obj)]
+        rel_parts = []
+        for rel in obj.__mapper__.relationships:
+            rel_name = rel.key
+            loaded = rel_name in obj.__dict__
+            value = getattr(obj, rel_name, None) if loaded else None
+            cardinality = "many" if rel.uselist else "one"
+            cls_name = rel.mapper.class_.__name__
+            loaded_label = "" if loaded else " \u2022 <em>not loaded</em>"
+
+            inner = ""
+            if value is None:
+                inner = '<span class="text-neutral-400">\u2014</span>'
+            elif rel.uselist:
+                items = list(value) if value else []
+                inner = f'<div class="text-neutral-500 mb-2">{len(items)} item{"" if len(items) == 1 else "s"}</div>'
+                if items and depth < max_depth:
+                    sub_rows = []
+                    for i, it in enumerate(items, 1):
+                        ident_parts = []
+                        for k in ("id", "ghost_id", "uuid", "slug", "name", "title"):
+                            if k in it.__mapper__.c:
+                                v = getattr(it, k, "")
+                                ident_parts.append(f"{k}={v}")
+                        summary = " \u2022 ".join(ident_parts) if ident_parts else str(it)
+                        child_html = ""
+                        if depth < max_depth:
+                            child_html = f'<div class="mt-2 pl-3 border-l border-neutral-200">{_render_model(it, depth + 1, max_depth)}</div>'
+                        else:
+                            child_html = '<div class="mt-1 text-xs text-neutral-500">\u2026max depth reached\u2026</div>'
+                        sub_rows.append(
+                            f'<tr class="border-t border-neutral-200 align-top">'
+                            f'<td class="px-2 py-1 whitespace-nowrap align-top">{i}</td>'
+                            f'<td class="px-2 py-1 align-top"><pre class="whitespace-pre-wrap break-words break-all text-xs"><code>{esc(summary)}</code></pre>{child_html}</td></tr>'
+                        )
+                    inner += (
+                        '<div class="w-full overflow-x-auto sm:overflow-visible">'
+                        '<table class="w-full table-fixed text-sm border border-neutral-200 rounded-lg overflow-hidden">'
+                        '<thead class="bg-neutral-50/70"><tr><th class="px-2 py-1 text-left w-10">#</th>'
+                        '<th class="px-2 py-1 text-left">Summary</th></tr></thead><tbody>'
+                        + "".join(sub_rows) + '</tbody></table></div>'
+                    )
+            else:
+                child = value
+                ident_parts = []
+                for k in ("id", "ghost_id", "uuid", "slug", "name", "title"):
+                    if k in child.__mapper__.c:
+                        v = getattr(child, k, "")
+                        ident_parts.append(f"{k}={v}")
+                summary = " \u2022 ".join(ident_parts) if ident_parts else str(child)
+                inner = f'<pre class="whitespace-pre-wrap break-words break-all text-xs mb-2"><code>{esc(summary)}</code></pre>'
+                if depth < max_depth:
+                    inner += f'<div class="pl-3 border-l border-neutral-200">{_render_model(child, depth + 1, max_depth)}</div>'
+                else:
+                    inner += '<div class="text-xs text-neutral-500">\u2026max depth reached\u2026</div>'
+
+            rel_parts.append(
+                f'<div class="rounded-xl border border-neutral-200">'
+                f'<div class="px-3 py-2 bg-neutral-50/70 text-sm font-medium">'
+                f'Relationship: <span class="font-semibold">{esc(rel_name)}</span>'
+                f' <span class="ml-2 text-xs text-neutral-500">{cardinality} \u2192 {esc(cls_name)}{loaded_label}</span></div>'
+                f'<div class="p-3 text-sm">{inner}</div></div>'
+            )
+        if rel_parts:
+            parts.append('<div class="space-y-3">' + "".join(rel_parts) + '</div>')
+        return '<div class="space-y-4">' + "".join(parts) + '</div>'
+
+    html = (
+        f'<div class="px-4 py-8">'
+        f'<div class="mb-6 text-sm text-neutral-500">Model: <code>Post</code> \u2022 Table: <code>{esc(tablename)}</code></div>'
+        f'{_render_model(original_post, 0, 2)}</div>'
+    )
+    return _raw_html_sx(html)
+
+
+async def _h_post_preview_content(slug=None, **kw):
+    await _ensure_post_data(slug)
+    from quart import g
+    from shared.services.registry import services
+    from shared.sx.helpers import sx_call
+    from shared.sx.parser import SxExpr
+
+    preview = await services.blog_page.preview_data(g.s)
+
+    sections: list[str] = []
+    if preview.get("sx_pretty"):
+        sections.append(sx_call("blog-preview-section",
+            title="S-Expression Source", content=SxExpr(preview["sx_pretty"])))
+    if preview.get("json_pretty"):
+        sections.append(sx_call("blog-preview-section",
+            title="Lexical JSON", content=SxExpr(preview["json_pretty"])))
+    if preview.get("sx_rendered"):
+        rendered_sx = sx_call("blog-preview-rendered", html=preview["sx_rendered"])
+        sections.append(sx_call("blog-preview-section",
+            title="SX Rendered", content=SxExpr(rendered_sx)))
+    if preview.get("lex_rendered"):
+        rendered_sx = sx_call("blog-preview-rendered", html=preview["lex_rendered"])
+        sections.append(sx_call("blog-preview-section",
+            title="Lexical Rendered", content=SxExpr(rendered_sx)))
+
+    if not sections:
+        return sx_call("blog-preview-empty")
+
+    inner = " ".join(sections)
+    return sx_call("blog-preview-panel", sections=SxExpr(f"(<> {inner})"))
+
+
+async def _h_post_entries_content(slug=None, **kw):
+    await _ensure_post_data(slug)
+    from quart import g, url_for as qurl
+    from sqlalchemy import select
+    from markupsafe import escape as esc
+    from shared.models.calendars import Calendar
+    from shared.utils import host_url
+    from bp.post.services.entry_associations import get_post_entry_ids
+    from bp.post.admin.routes import _render_associated_entries
+
+    post_id = g.post_data["post"]["id"]
+    post_slug = g.post_data["post"]["slug"]
+    associated_entry_ids = await get_post_entry_ids(post_id)
+    result = await g.s.execute(
+        select(Calendar)
+        .where(Calendar.deleted_at.is_(None))
+        .order_by(Calendar.name.asc())
+    )
+    all_calendars = result.scalars().all()
+    for calendar in all_calendars:
+        await g.s.refresh(calendar, ["entries", "post"])
+
+    # Associated entries list
+    assoc_html = _render_associated_entries(all_calendars, associated_entry_ids, post_slug)
+
+    # Calendar browser
+    cal_items: list[str] = []
+    for cal in all_calendars:
+        cal_post = getattr(cal, "post", None)
+        cal_fi = getattr(cal_post, "feature_image", None) if cal_post else None
+        cal_title = esc(getattr(cal_post, "title", "")) if cal_post else ""
+        cal_name = esc(getattr(cal, "name", ""))
+        cal_view_url = host_url(qurl("blog.post.admin.calendar_view", slug=post_slug, calendar_id=cal.id))
+
+        img_html = (
+            f'<img src="{esc(cal_fi)}" alt="{cal_title}" class="w-12 h-12 rounded object-cover flex-shrink-0" />'
+            if cal_fi else
+            '<div class="w-12 h-12 rounded bg-stone-200 flex-shrink-0"></div>'
+        )
+        cal_items.append(
+            f'<details class="border rounded-lg bg-white" data-toggle-group="calendar-browser">'
+            f'<summary class="p-4 cursor-pointer hover:bg-stone-50 flex items-center gap-3">'
+            f'{img_html}'
+            f'<div class="flex-1">'
+            f'<div class="font-semibold flex items-center gap-2"><i class="fa fa-calendar text-stone-500"></i> {cal_name}</div>'
+            f'<div class="text-sm text-stone-600">{cal_title}</div>'
+            f'</div></summary>'
+            f'<div class="p-4 border-t" sx-get="{esc(cal_view_url)}" sx-trigger="intersect once" sx-swap="innerHTML">'
+            f'<div class="text-sm text-stone-400">Loading calendar...</div>'
+            f'</div></details>'
+        )
+
+    if cal_items:
+        browser_html = (
+            '<div class="space-y-3"><h3 class="text-lg font-semibold">Browse Calendars</h3>'
+            + "".join(cal_items) + '</div>'
+        )
+    else:
+        browser_html = '<div class="space-y-3"><h3 class="text-lg font-semibold">Browse Calendars</h3><div class="text-sm text-stone-400">No calendars found.</div></div>'
+
+    return (
+        _raw_html_sx('<div id="post-entries-content" class="space-y-6 p-4">')
+        + assoc_html
+        + _raw_html_sx(browser_html + '</div>')
+    )
+
+
+async def _h_post_settings_content(slug=None, **kw):
+    await _ensure_post_data(slug)
+    from quart import g, request
+    from markupsafe import escape as esc
+    from models.ghost_content import Post
+    from sqlalchemy import select as sa_select
+    from sqlalchemy.orm import selectinload
+    from shared.browser.app.csrf import generate_csrf_token
+    from bp.post.admin.routes import _post_to_edit_dict
+
+    post_id = g.post_data["post"]["id"]
+    post = (await g.s.execute(
+        sa_select(Post)
+        .where(Post.id == post_id)
+        .options(selectinload(Post.tags))
+    )).scalar_one_or_none()
+    ghost_post = _post_to_edit_dict(post) if post else {}
+    save_success = request.args.get("saved") == "1"
+    csrf = generate_csrf_token()
+
+    p = g.post_data.get("post", {}) if hasattr(g, "post_data") else {}
+    is_page = p.get("is_page", False)
+    gp = ghost_post
+
+    def field_label(text, field_for=None):
+        for_attr = f' for="{field_for}"' if field_for else ''
+        return f'<label{for_attr} class="block text-[13px] font-medium text-stone-500 mb-[4px]">{esc(text)}</label>'
+
+    input_cls = ('w-full text-[14px] rounded-[6px] border border-stone-200 px-[10px] py-[7px] '
+                 'bg-white text-stone-700 placeholder:text-stone-300 '
+                 'focus:outline-none focus:border-stone-400 focus:ring-1 focus:ring-stone-300')
+    textarea_cls = input_cls + ' resize-y'
+
+    def text_input(name, value='', placeholder='', input_type='text', maxlength=None):
+        ml = f' maxlength="{maxlength}"' if maxlength else ''
+        return (f'<input type="{input_type}" name="{name}" id="settings-{name}" value="{esc(value)}"'
+                f' placeholder="{esc(placeholder)}"{ml} class="{input_cls}">')
+
+    def textarea_input(name, value='', placeholder='', rows=3, maxlength=None):
+        ml = f' maxlength="{maxlength}"' if maxlength else ''
+        return (f'<textarea name="{name}" id="settings-{name}" rows="{rows}"'
+                f' placeholder="{esc(placeholder)}"{ml} class="{textarea_cls}">{esc(value)}</textarea>')
+
+    def checkbox_input(name, checked=False, label=''):
+        chk = ' checked' if checked else ''
+        return (f'<label class="inline-flex items-center gap-[8px] cursor-pointer">'
+                f'<input type="checkbox" name="{name}" id="settings-{name}"{chk}'
+                f' class="rounded border-stone-300 text-stone-600 focus:ring-stone-300">'
+                f'<span class="text-[14px] text-stone-600">{esc(label)}</span></label>')
+
+    def section(title, content, is_open=False):
+        open_attr = ' open' if is_open else ''
+        return (f'<details class="border border-stone-200 rounded-[8px] overflow-hidden"{open_attr}>'
+                f'<summary class="px-[16px] py-[10px] bg-stone-50 text-[14px] font-medium text-stone-600 cursor-pointer select-none hover:bg-stone-100 transition-colors">{esc(title)}</summary>'
+                f'<div class="px-[16px] py-[12px] space-y-[12px]">{content}</div></details>')
+
+    # General section
+    slug_placeholder = 'page-slug' if is_page else 'post-slug'
+    pub_at = gp.get("published_at") or ""
+    pub_at_val = pub_at[:16] if pub_at else ""
+    vis = gp.get("visibility") or "public"
+    vis_opts = "".join(
+        f'<option value="{v}"{" selected" if vis == v else ""}>{l}</option>'
+        for v, l in [("public", "Public"), ("members", "Members"), ("paid", "Paid")]
+    )
+
+    general = (
+        f'<div>{field_label("Slug", "settings-slug")}{text_input("slug", gp.get("slug") or "", slug_placeholder)}</div>'
+        f'<div>{field_label("Published at", "settings-published_at")}'
+        f'<input type="datetime-local" name="published_at" id="settings-published_at" value="{esc(pub_at_val)}" class="{input_cls}"></div>'
+        f'<div>{checkbox_input("featured", gp.get("featured"), "Featured page" if is_page else "Featured post")}</div>'
+        f'<div>{field_label("Visibility", "settings-visibility")}'
+        f'<select name="visibility" id="settings-visibility" class="{input_cls}">{vis_opts}</select></div>'
+        f'<div>{checkbox_input("email_only", gp.get("email_only"), "Email only")}</div>'
+    )
+
+    # Tags
+    tags = gp.get("tags") or []
+    if tags:
+        tag_names = ", ".join(getattr(t, "name", t.get("name", "") if isinstance(t, dict) else str(t)) for t in tags)
+    else:
+        tag_names = ""
+    tags_sec = (
+        f'<div>{field_label("Tags (comma-separated)", "settings-tags")}'
+        f'{text_input("tags", tag_names, "news, updates, featured")}'
+        f'<p class="text-[12px] text-stone-400 mt-[4px]">Unknown tags will be created automatically.</p></div>'
+    )
+
+    fi_sec = f'<div>{field_label("Alt text", "settings-feature_image_alt")}{text_input("feature_image_alt", gp.get("feature_image_alt") or "", "Describe the feature image")}</div>'
+
+    seo_sec = (
+        f'<div>{field_label("Meta title", "settings-meta_title")}{text_input("meta_title", gp.get("meta_title") or "", "SEO title", maxlength=300)}'
+        f'<p class="text-[12px] text-stone-400 mt-[2px]">Recommended: 70 characters. Max: 300.</p></div>'
+        f'<div>{field_label("Meta description", "settings-meta_description")}{textarea_input("meta_description", gp.get("meta_description") or "", "SEO description", rows=2, maxlength=500)}'
+        f'<p class="text-[12px] text-stone-400 mt-[2px]">Recommended: 156 characters.</p></div>'
+        f'<div>{field_label("Canonical URL", "settings-canonical_url")}{text_input("canonical_url", gp.get("canonical_url") or "", "https://example.com/original-post", input_type="url")}</div>'
+    )
+
+    og_sec = (
+        f'<div>{field_label("OG title", "settings-og_title")}{text_input("og_title", gp.get("og_title") or "")}</div>'
+        f'<div>{field_label("OG description", "settings-og_description")}{textarea_input("og_description", gp.get("og_description") or "", rows=2)}</div>'
+        f'<div>{field_label("OG image URL", "settings-og_image")}{text_input("og_image", gp.get("og_image") or "", "https://...", input_type="url")}</div>'
+    )
+
+    tw_sec = (
+        f'<div>{field_label("Twitter title", "settings-twitter_title")}{text_input("twitter_title", gp.get("twitter_title") or "")}</div>'
+        f'<div>{field_label("Twitter description", "settings-twitter_description")}{textarea_input("twitter_description", gp.get("twitter_description") or "", rows=2)}</div>'
+        f'<div>{field_label("Twitter image URL", "settings-twitter_image")}{text_input("twitter_image", gp.get("twitter_image") or "", "https://...", input_type="url")}</div>'
+    )
+
+    tmpl_placeholder = 'custom-page.hbs' if is_page else 'custom-post.hbs'
+    adv_sec = f'<div>{field_label("Custom template", "settings-custom_template")}{text_input("custom_template", gp.get("custom_template") or "", tmpl_placeholder)}</div>'
+
+    sections = (
+        section("General", general, is_open=True)
+        + section("Tags", tags_sec)
+        + section("Feature Image", fi_sec)
+        + section("SEO / Meta", seo_sec)
+        + section("Facebook / OpenGraph", og_sec)
+        + section("X / Twitter", tw_sec)
+        + section("Advanced", adv_sec)
+    )
+
+    saved_html = '<span class="text-[14px] text-green-600">Saved.</span>' if save_success else ''
+
+    html = (
+        f'<form method="post" class="max-w-[640px] mx-auto pb-[48px] px-[16px]">'
+        f'<input type="hidden" name="csrf_token" value="{csrf}">'
+        f'<input type="hidden" name="updated_at" value="{esc(gp.get("updated_at") or "")}">'
+        f'<div class="space-y-[12px] mt-[16px]">{sections}</div>'
+        f'<div class="flex items-center gap-[16px] mt-[24px] pt-[16px] border-t border-stone-200">'
+        f'<button type="submit" class="px-[20px] py-[6px] bg-stone-700 text-white text-[14px] rounded-[8px] hover:bg-stone-800 transition-colors cursor-pointer">Save settings</button>'
+        f'{saved_html}</div></form>'
+    )
+    return _raw_html_sx(html)
+
+
+async def _h_post_edit_content(slug=None, **kw):
+    await _ensure_post_data(slug)
+    import os
+    from quart import g, request as qrequest, url_for as qurl, current_app
+    from models.ghost_content import Post
+    from sqlalchemy import select as sa_select
+    from sqlalchemy.orm import selectinload
+    from shared.infrastructure.data_client import fetch_data
+    from shared.browser.app.csrf import generate_csrf_token
+    from shared.sx.helpers import sx_call
+    from shared.sx.parser import SxExpr, serialize as sx_serialize
+    from bp.post.admin.routes import _post_to_edit_dict
+
+    post_id = g.post_data["post"]["id"]
+    db_post = (await g.s.execute(
+        sa_select(Post)
+        .where(Post.id == post_id)
+        .options(selectinload(Post.tags))
+    )).scalar_one_or_none()
+    ghost_post = _post_to_edit_dict(db_post) if db_post else {}
+    save_success = qrequest.args.get("saved") == "1"
+    save_error = qrequest.args.get("error", "")
+    raw_newsletters = await fetch_data("account", "newsletters", required=False) or []
+    from types import SimpleNamespace
+    newsletters = [SimpleNamespace(**nl) for nl in raw_newsletters]
+
+    csrf = generate_csrf_token()
+    asset_url_fn = current_app.jinja_env.globals.get("asset_url", lambda p: "")
+    editor_css = asset_url_fn("scripts/editor.css")
+    editor_js = asset_url_fn("scripts/editor.js")
+    sx_editor_js = asset_url_fn("scripts/sx-editor.js")
+
+    upload_image_url = qurl("blog.editor_api.upload_image")
+    upload_media_url = qurl("blog.editor_api.upload_media")
+    upload_file_url = qurl("blog.editor_api.upload_file")
+    oembed_url = qurl("blog.editor_api.oembed_proxy")
+    snippets_url = qurl("blog.editor_api.list_snippets")
+    unsplash_key = os.environ.get("UNSPLASH_ACCESS_KEY", "")
+
+    post = g.post_data.get("post", {}) if hasattr(g, "post_data") else {}
+    is_page = post.get("is_page", False)
+
+    feature_image = ghost_post.get("feature_image") or ""
+    feature_image_caption = ghost_post.get("feature_image_caption") or ""
+    title_val = ghost_post.get("title") or ""
+    excerpt_val = ghost_post.get("custom_excerpt") or ""
+    updated_at = ghost_post.get("updated_at") or ""
+    status = ghost_post.get("status") or "draft"
+    lexical_json = ghost_post.get("lexical") or '{"root":{"children":[{"children":[],"direction":null,"format":"","indent":0,"type":"paragraph","version":1}],"direction":null,"format":"","indent":0,"type":"root","version":1}}'
+    sx_content = ghost_post.get("sx_content") or ""
+    has_sx = bool(sx_content)
+
+    already_emailed = bool(ghost_post and ghost_post.get("email") and (ghost_post["email"] if isinstance(ghost_post["email"], dict) else {}).get("status"))
+    email_obj = ghost_post.get("email")
+    if email_obj and not isinstance(email_obj, dict):
+        already_emailed = bool(getattr(email_obj, "status", None))
+
+    title_placeholder = "Page title..." if is_page else "Post title..."
+
+    # Newsletter options as SX fragment
+    nl_parts = ['(option :value "" "Select newsletter\u2026")']
+    for nl in newsletters:
+        nl_slug = sx_serialize(getattr(nl, "slug", ""))
+        nl_name = sx_serialize(getattr(nl, "name", ""))
+        nl_parts.append(f"(option :value {nl_slug} {nl_name})")
+    nl_opts_sx = SxExpr("(<> " + " ".join(nl_parts) + ")")
+
+    # Footer extra badges as SX fragment
+    badge_parts: list[str] = []
+    if save_success:
+        badge_parts.append('(span :class "text-[14px] text-green-600" "Saved.")')
+    publish_requested = qrequest.args.get("publish_requested") if hasattr(qrequest, 'args') else None
+    if publish_requested:
+        badge_parts.append('(span :class "text-[14px] text-blue-600" "Publish requested \u2014 an admin will review.")')
+    if post.get("publish_requested"):
+        badge_parts.append('(span :class "inline-block px-2 py-0.5 rounded-full text-xs font-semibold bg-blue-100 text-blue-800" "Publish requested")')
+    if already_emailed:
+        nl_name = ""
+        newsletter = ghost_post.get("newsletter")
+        if newsletter:
+            nl_name = getattr(newsletter, "name", "") if not isinstance(newsletter, dict) else newsletter.get("name", "")
+        suffix = f" to {nl_name}" if nl_name else ""
+        badge_parts.append(f'(span :class "inline-block px-2 py-0.5 rounded-full text-xs font-semibold bg-green-100 text-green-800" "Emailed{suffix}")')
+    footer_extra_sx = SxExpr("(<> " + " ".join(badge_parts) + ")") if badge_parts else None
+
+    parts: list[str] = []
+
+    if save_error:
+        parts.append(sx_call("blog-editor-error", error=save_error))
+
+    parts.append(sx_call("blog-editor-edit-form",
+        csrf=csrf,
+        updated_at=str(updated_at),
+        title_val=title_val,
+        excerpt_val=excerpt_val,
+        feature_image=feature_image,
+        feature_image_caption=feature_image_caption,
+        sx_content_val=sx_content,
+        lexical_json=lexical_json,
+        has_sx=has_sx,
+        title_placeholder=title_placeholder,
+        status=status,
+        already_emailed=already_emailed,
+        newsletter_options=nl_opts_sx,
+        footer_extra=footer_extra_sx,
+    ))
+
+    parts.append(sx_call("blog-editor-publish-js", already_emailed=already_emailed))
+    parts.append(sx_call("blog-editor-styles", css_href=editor_css))
+    parts.append(sx_call("sx-editor-styles"))
+
+    init_js = (
+        '(function() {'
+        "  function applyEditorFontSize() {"
+        "    document.documentElement.style.fontSize = '62.5%';"
+        "    document.body.style.fontSize = '1.6rem';"
+        '  }'
+        "  function restoreDefaultFontSize() {"
+        "    document.documentElement.style.fontSize = '';"
+        "    document.body.style.fontSize = '';"
+        '  }'
+        '  applyEditorFontSize();'
+        "  document.body.addEventListener('htmx:beforeSwap', function cleanup(e) {"
+        "    if (e.detail.target && e.detail.target.id === 'main-panel') {"
+        '      restoreDefaultFontSize();'
+        "      document.body.removeEventListener('htmx:beforeSwap', cleanup);"
+        '    }'
+        '  });'
+        '  function init() {'
+        "    var csrfToken = document.querySelector('input[name=\"csrf_token\"]').value;"
+        f"    var uploadUrl = '{upload_image_url}';"
+        '    var uploadUrls = {'
+        '      image: uploadUrl,'
+        f"      media: '{upload_media_url}',"
+        f"      file: '{upload_file_url}',"
+        '    };'
+        "    var fileInput = document.getElementById('feature-image-file');"
+        "    var addBtn = document.getElementById('feature-image-add-btn');"
+        "    var deleteBtn = document.getElementById('feature-image-delete-btn');"
+        "    var preview = document.getElementById('feature-image-preview');"
+        "    var emptyState = document.getElementById('feature-image-empty');"
+        "    var filledState = document.getElementById('feature-image-filled');"
+        "    var hiddenUrl = document.getElementById('feature-image-input');"
+        "    var hiddenCaption = document.getElementById('feature-image-caption-input');"
+        "    var captionInput = document.getElementById('feature-image-caption');"
+        "    var uploading = document.getElementById('feature-image-uploading');"
+        '    function showFilled(url) {'
+        '      preview.src = url; hiddenUrl.value = url;'
+        "      emptyState.classList.add('hidden'); filledState.classList.remove('hidden'); uploading.classList.add('hidden');"
+        '    }'
+        '    function showEmpty() {'
+        "      preview.src = ''; hiddenUrl.value = ''; hiddenCaption.value = ''; captionInput.value = '';"
+        "      emptyState.classList.remove('hidden'); filledState.classList.add('hidden'); uploading.classList.add('hidden');"
+        '    }'
+        '    function uploadFile(file) {'
+        "      emptyState.classList.add('hidden'); uploading.classList.remove('hidden');"
+        "      var fd = new FormData(); fd.append('file', file);"
+        "      fetch(uploadUrl, { method: 'POST', body: fd, headers: { 'X-CSRFToken': csrfToken } })"
+        "      .then(function(r) { if (!r.ok) throw new Error('Upload failed (' + r.status + ')'); return r.json(); })"
+        '      .then(function(data) {'
+        '        var url = data.images && data.images[0] && data.images[0].url;'
+        "        if (url) showFilled(url); else { showEmpty(); alert('Upload succeeded but no image URL returned.'); }"
+        '      })'
+        '      .catch(function(e) { showEmpty(); alert(e.message); });'
+        '    }'
+        "    addBtn.addEventListener('click', function() { fileInput.click(); });"
+        "    preview.addEventListener('click', function() { fileInput.click(); });"
+        "    deleteBtn.addEventListener('click', function(e) { e.stopPropagation(); showEmpty(); });"
+        "    fileInput.addEventListener('change', function() {"
+        '      if (fileInput.files && fileInput.files[0]) { uploadFile(fileInput.files[0]); fileInput.value = \'\'; }'
+        '    });'
+        "    captionInput.addEventListener('input', function() { hiddenCaption.value = captionInput.value; });"
+        "    var excerpt = document.querySelector('textarea[name=\"custom_excerpt\"]');"
+        "    function autoResize() { excerpt.style.height = 'auto'; excerpt.style.height = excerpt.scrollHeight + 'px'; }"
+        "    excerpt.addEventListener('input', autoResize); autoResize();"
+        '    var dataEl = document.getElementById(\'lexical-initial-data\');'
+        '    var initialJson = dataEl ? dataEl.textContent.trim() : null;'
+        '    if (initialJson) { var hidden = document.getElementById(\'lexical-json-input\'); if (hidden) hidden.value = initialJson; }'
+        "    window.mountEditor('lexical-editor', {"
+        '      initialJson: initialJson,'
+        '      csrfToken: csrfToken,'
+        '      uploadUrls: uploadUrls,'
+        f"      oembedUrl: '{oembed_url}',"
+        f"      unsplashApiKey: '{unsplash_key}',"
+        f"      snippetsUrl: '{snippets_url}',"
+        '    });'
+        "    if (typeof SxEditor !== 'undefined') {"
+        "      SxEditor.mount('sx-editor', {"
+        "        initialSx: (document.getElementById('sx-content-input') || {}).value || null,"
+        '        csrfToken: csrfToken,'
+        '        uploadUrls: uploadUrls,'
+        f"        oembedUrl: '{oembed_url}',"
+        '        onChange: function(sx) {'
+        "          document.getElementById('sx-content-input').value = sx;"
+        '        }'
+        '      });'
+        '    }'
+        "    document.addEventListener('keydown', function(e) {"
+        "      if ((e.ctrlKey || e.metaKey) && e.key === 's') {"
+        "        e.preventDefault(); document.getElementById('post-edit-form').requestSubmit();"
+        '      }'
+        '    });'
+        '  }'
+        "  if (typeof window.mountEditor === 'function') { init(); }"
+        '  else { var _t = setInterval(function() {'
+        "    if (typeof window.mountEditor === 'function') { clearInterval(_t); init(); }"
+        '  }, 50); }'
+        '})();'
+    )
+    parts.append(sx_call("blog-editor-scripts",
+                         js_src=editor_js,
+                         sx_editor_js_src=sx_editor_js,
+                         init_js=init_js))
+
+    return sx_call("blog-editor-panel",
+        parts=SxExpr("(<> " + " ".join(parts) + ")"))
--- a/blog/sxc/pages/layouts.py
+++ b/blog/sxc/pages/layouts.py
@@ -0,0 +1,203 @@
+"""Blog layout functions for defpage rendering."""
+from __future__ import annotations
+
+from typing import Any
+
+
+# ---------------------------------------------------------------------------
+# Header helpers (moved from sx_components — thin sx_call wrappers)
+# ---------------------------------------------------------------------------
+
+def _settings_header_sx(ctx: dict, *, oob: bool = False) -> str:
+    from shared.sx.helpers import sx_call
+    from shared.sx.parser import SxExpr
+    from quart import url_for as qurl
+
+    settings_href = qurl("settings.defpage_settings_home")
+    label_sx = sx_call("blog-admin-label")
+    nav_sx = _settings_nav_sx(ctx)
+
+    return sx_call("menu-row-sx",
+        id="root-settings-row", level=1,
+        link_href=settings_href,
+        link_label_content=SxExpr(label_sx),
+        nav=SxExpr(nav_sx) if nav_sx else None,
+        child_id="root-settings-header-child", oob=oob)
+
+
+def _settings_nav_sx(ctx: dict) -> str:
+    from shared.sx.helpers import sx_call
+    return sx_call("blog-settings-nav")
+
+
+def _sub_settings_header_sx(row_id: str, child_id: str, href: str,
+                             icon: str, label: str, ctx: dict,
+                             *, oob: bool = False, nav_sx: str = "") -> str:
+    from shared.sx.helpers import sx_call
+    from shared.sx.parser import SxExpr
+
+    label_sx = sx_call("blog-sub-settings-label",
+        icon=f"fa fa-{icon}", label=label)
+    return sx_call("menu-row-sx",
+        id=row_id, level=2,
+        link_href=href,
+        link_label_content=SxExpr(label_sx),
+        nav=SxExpr(nav_sx) if nav_sx else None,
+        child_id=child_id, oob=oob)
+
+
+# ---------------------------------------------------------------------------
+# Layouts
+# ---------------------------------------------------------------------------
+
+def _register_blog_layouts() -> None:
+    from shared.sx.layouts import register_custom_layout
+    register_custom_layout("blog", _blog_full, _blog_oob)
+    register_custom_layout("blog-settings", _settings_full, _settings_oob,
+                           mobile_fn=_settings_mobile)
+    register_custom_layout("blog-cache", _cache_full, _cache_oob)
+    register_custom_layout("blog-snippets", _snippets_full, _snippets_oob)
+    register_custom_layout("blog-menu-items", _menu_items_full, _menu_items_oob)
+    register_custom_layout("blog-tag-groups", _tag_groups_full, _tag_groups_oob)
+    register_custom_layout("blog-tag-group-edit",
+                           _tag_group_edit_full, _tag_group_edit_oob)
+
+
+# --- Blog layout (root + blog header) ---
+
+async def _blog_full(ctx: dict, **kw: Any) -> str:
+    from shared.sx.helpers import render_to_sx_with_env
+    return await render_to_sx_with_env("blog-layout-full", {})
+
+
+async def _blog_oob(ctx: dict, **kw: Any) -> str:
+    from shared.sx.helpers import render_to_sx_with_env, oob_header_sx
+    rows = await render_to_sx_with_env("blog-layout-full", {})
+    return await oob_header_sx("root-header-child", "blog-header-child", rows)
+
+
+# --- Settings layout (root + settings header) ---
+
+async def _settings_full(ctx: dict, **kw: Any) -> str:
+    from shared.sx.helpers import render_to_sx_with_env
+    from shared.sx.parser import SxExpr
+    return await render_to_sx_with_env("settings-layout-full", {},
+        settings_header=SxExpr(_settings_header_sx(ctx)))
+
+
+async def _settings_oob(ctx: dict, **kw: Any) -> str:
+    from shared.sx.helpers import render_to_sx_with_env, oob_header_sx
+    from shared.sx.parser import SxExpr
+    rows = await render_to_sx_with_env("settings-layout-full", {},
+        settings_header=SxExpr(_settings_header_sx(ctx)))
+    return await oob_header_sx("root-header-child", "root-settings-header-child", rows)
+
+
+def _settings_mobile(ctx: dict, **kw: Any) -> str:
+    return _settings_nav_sx(ctx)
+
+
+# --- Sub-settings helpers ---
+
+async def _sub_settings_full(ctx: dict, row_id: str, child_id: str,
+                       endpoint: str, icon: str, label: str) -> str:
+    from shared.sx.helpers import render_to_sx_with_env
+    from shared.sx.parser import SxExpr
+    from quart import url_for as qurl
+    return await render_to_sx_with_env("sub-settings-layout-full", {},
+        settings_header=SxExpr(_settings_header_sx(ctx)),
+        sub_header=SxExpr(_sub_settings_header_sx(
+            row_id, child_id, qurl(endpoint), icon, label, ctx)))
+
+
+async def _sub_settings_oob(ctx: dict, row_id: str, child_id: str,
+                      endpoint: str, icon: str, label: str) -> str:
+    from shared.sx.helpers import oob_header_sx, sx_call
+    from shared.sx.parser import SxExpr
+    from quart import url_for as qurl
+    settings_hdr_oob = _settings_header_sx(ctx, oob=True)
+    sub_hdr = _sub_settings_header_sx(
+        row_id, child_id, qurl(endpoint), icon, label, ctx)
+    sub_oob = await oob_header_sx("root-settings-header-child", child_id, sub_hdr)
+    return sx_call("sub-settings-layout-oob",
+        settings_header_oob=SxExpr(settings_hdr_oob),
+        sub_header_oob=SxExpr(sub_oob))
+
+
+# --- Cache ---
+
+async def _cache_full(ctx: dict, **kw: Any) -> str:
+    return await _sub_settings_full(ctx, "cache-row", "cache-header-child",
+                              "defpage_cache_page", "refresh", "Cache")
+
+
+async def _cache_oob(ctx: dict, **kw: Any) -> str:
+    return await _sub_settings_oob(ctx, "cache-row", "cache-header-child",
+                             "defpage_cache_page", "refresh", "Cache")
+
+
+# --- Snippets ---
+
+async def _snippets_full(ctx: dict, **kw: Any) -> str:
+    return await _sub_settings_full(ctx, "snippets-row", "snippets-header-child",
+                              "defpage_snippets_page", "puzzle-piece", "Snippets")
+
+
+async def _snippets_oob(ctx: dict, **kw: Any) -> str:
+    return await _sub_settings_oob(ctx, "snippets-row", "snippets-header-child",
+                             "defpage_snippets_page", "puzzle-piece", "Snippets")
+
+
+# --- Menu Items ---
+
+async def _menu_items_full(ctx: dict, **kw: Any) -> str:
+    return await _sub_settings_full(ctx, "menu_items-row", "menu_items-header-child",
+                              "defpage_menu_items_page", "bars", "Menu Items")
+
+
+async def _menu_items_oob(ctx: dict, **kw: Any) -> str:
+    return await _sub_settings_oob(ctx, "menu_items-row", "menu_items-header-child",
+                             "defpage_menu_items_page", "bars", "Menu Items")
+
+
+# --- Tag Groups ---
+
+async def _tag_groups_full(ctx: dict, **kw: Any) -> str:
+    return await _sub_settings_full(ctx, "tag-groups-row", "tag-groups-header-child",
+                              "defpage_tag_groups_page", "tags", "Tag Groups")
+
+
+async def _tag_groups_oob(ctx: dict, **kw: Any) -> str:
+    return await _sub_settings_oob(ctx, "tag-groups-row", "tag-groups-header-child",
+                             "defpage_tag_groups_page", "tags", "Tag Groups")
+
+
+# --- Tag Group Edit ---
+
+async def _tag_group_edit_full(ctx: dict, **kw: Any) -> str:
+    from quart import request, url_for as qurl
+    from shared.sx.helpers import render_to_sx_with_env
+    from shared.sx.parser import SxExpr
+    g_id = (request.view_args or {}).get("id")
+    return await render_to_sx_with_env("sub-settings-layout-full", {},
+        settings_header=SxExpr(_settings_header_sx(ctx)),
+        sub_header=SxExpr(_sub_settings_header_sx(
+            "tag-groups-row", "tag-groups-header-child",
+            qurl("defpage_tag_group_edit", id=g_id),
+            "tags", "Tag Groups", ctx)))
+
+
+async def _tag_group_edit_oob(ctx: dict, **kw: Any) -> str:
+    from quart import request, url_for as qurl
+    from shared.sx.helpers import oob_header_sx, sx_call
+    from shared.sx.parser import SxExpr
+    g_id = (request.view_args or {}).get("id")
+    settings_hdr_oob = _settings_header_sx(ctx, oob=True)
+    sub_hdr = _sub_settings_header_sx(
+        "tag-groups-row", "tag-groups-header-child",
+        qurl("defpage_tag_group_edit", id=g_id),
+        "tags", "Tag Groups", ctx)
+    sub_oob = await oob_header_sx("root-settings-header-child", "tag-groups-header-child", sub_hdr)
+    return sx_call("sub-settings-layout-oob",
+        settings_header_oob=SxExpr(settings_hdr_oob),
+        sub_header_oob=SxExpr(sub_oob))
--- a/blog/sxc/pages/renders.py
+++ b/blog/sxc/pages/renders.py
@@ -0,0 +1,177 @@
+"""Blog editor panel rendering."""
+from __future__ import annotations
+
+
+def render_editor_panel(save_error: str | None = None, is_page: bool = False) -> str:
+    """Build the WYSIWYG editor panel HTML for new post/page creation."""
+    import os
+    from quart import url_for as qurl, current_app
+    from shared.browser.app.csrf import generate_csrf_token
+    from shared.sx.helpers import sx_call
+
+    csrf = generate_csrf_token()
+    asset_url_fn = current_app.jinja_env.globals.get("asset_url", lambda p: "")
+    editor_css = asset_url_fn("scripts/editor.css")
+    editor_js = asset_url_fn("scripts/editor.js")
+    sx_editor_js = asset_url_fn("scripts/sx-editor.js")
+
+    upload_image_url = qurl("blog.editor_api.upload_image")
+    upload_media_url = qurl("blog.editor_api.upload_media")
+    upload_file_url = qurl("blog.editor_api.upload_file")
+    oembed_url = qurl("blog.editor_api.oembed_proxy")
+    snippets_url = qurl("blog.editor_api.list_snippets")
+    unsplash_key = os.environ.get("UNSPLASH_ACCESS_KEY", "")
+
+    title_placeholder = "Page title..." if is_page else "Post title..."
+    create_label = "Create Page" if is_page else "Create Post"
+
+    parts: list[str] = []
+
+    if save_error:
+        parts.append(sx_call("blog-editor-error", error=str(save_error)))
+
+    parts.append(sx_call("blog-editor-form",
+        csrf=csrf, title_placeholder=title_placeholder,
+        create_label=create_label,
+    ))
+
+    parts.append(sx_call("blog-editor-styles", css_href=editor_css))
+    parts.append(sx_call("sx-editor-styles"))
+
+    init_js = (
+        "console.log('[EDITOR-DEBUG] init script running');\n"
+        "(function() {\n"
+        "  console.log('[EDITOR-DEBUG] IIFE entered, mountEditor=', typeof window.mountEditor);\n"
+        "  function init() {\n"
+        "    var csrfToken = document.querySelector('input[name=\"csrf_token\"]').value;\n"
+        f"    var uploadUrl = '{upload_image_url}';\n"
+        "    var uploadUrls = {\n"
+        "      image: uploadUrl,\n"
+        f"      media: '{upload_media_url}',\n"
+        f"      file:  '{upload_file_url}',\n"
+        "    };\n"
+        "\n"
+        "    var fileInput     = document.getElementById('feature-image-file');\n"
+        "    var addBtn        = document.getElementById('feature-image-add-btn');\n"
+        "    var deleteBtn     = document.getElementById('feature-image-delete-btn');\n"
+        "    var preview       = document.getElementById('feature-image-preview');\n"
+        "    var emptyState    = document.getElementById('feature-image-empty');\n"
+        "    var filledState   = document.getElementById('feature-image-filled');\n"
+        "    var hiddenUrl     = document.getElementById('feature-image-input');\n"
+        "    var hiddenCaption = document.getElementById('feature-image-caption-input');\n"
+        "    var captionInput  = document.getElementById('feature-image-caption');\n"
+        "    var uploading     = document.getElementById('feature-image-uploading');\n"
+        "\n"
+        "    function showFilled(url) {\n"
+        "      preview.src = url;\n"
+        "      hiddenUrl.value = url;\n"
+        "      emptyState.classList.add('hidden');\n"
+        "      filledState.classList.remove('hidden');\n"
+        "      uploading.classList.add('hidden');\n"
+        "    }\n"
+        "\n"
+        "    function showEmpty() {\n"
+        "      preview.src = '';\n"
+        "      hiddenUrl.value = '';\n"
+        "      hiddenCaption.value = '';\n"
+        "      captionInput.value = '';\n"
+        "      emptyState.classList.remove('hidden');\n"
+        "      filledState.classList.add('hidden');\n"
+        "      uploading.classList.add('hidden');\n"
+        "    }\n"
+        "\n"
+        "    function uploadFile(file) {\n"
+        "      emptyState.classList.add('hidden');\n"
+        "      uploading.classList.remove('hidden');\n"
+        "      var fd = new FormData();\n"
+        "      fd.append('file', file);\n"
+        "      fetch(uploadUrl, {\n"
+        "        method: 'POST',\n"
+        "        body: fd,\n"
+        "        headers: { 'X-CSRFToken': csrfToken },\n"
+        "      })\n"
+        "      .then(function(r) {\n"
+        "        if (!r.ok) throw new Error('Upload failed (' + r.status + ')');\n"
+        "        return r.json();\n"
+        "      })\n"
+        "      .then(function(data) {\n"
+        "        var url = data.images && data.images[0] && data.images[0].url;\n"
+        "        if (url) showFilled(url);\n"
+        "        else { showEmpty(); alert('Upload succeeded but no image URL returned.'); }\n"
+        "      })\n"
+        "      .catch(function(e) {\n"
+        "        showEmpty();\n"
+        "        alert(e.message);\n"
+        "      });\n"
+        "    }\n"
+        "\n"
+        "    addBtn.addEventListener('click', function() { fileInput.click(); });\n"
+        "    preview.addEventListener('click', function() { fileInput.click(); });\n"
+        "    deleteBtn.addEventListener('click', function(e) {\n"
+        "      e.stopPropagation();\n"
+        "      showEmpty();\n"
+        "    });\n"
+        "    fileInput.addEventListener('change', function() {\n"
+        "      if (fileInput.files && fileInput.files[0]) {\n"
+        "        uploadFile(fileInput.files[0]);\n"
+        "        fileInput.value = '';\n"
+        "      }\n"
+        "    });\n"
+        "    captionInput.addEventListener('input', function() {\n"
+        "      hiddenCaption.value = captionInput.value;\n"
+        "    });\n"
+        "\n"
+        "    var excerpt = document.querySelector('textarea[name=\"custom_excerpt\"]');\n"
+        "    function autoResize() {\n"
+        "      excerpt.style.height = 'auto';\n"
+        "      excerpt.style.height = excerpt.scrollHeight + 'px';\n"
+        "    }\n"
+        "    excerpt.addEventListener('input', autoResize);\n"
+        "    autoResize();\n"
+        "\n"
+        "    window.mountEditor('lexical-editor', {\n"
+        "      initialJson: null,\n"
+        "      csrfToken: csrfToken,\n"
+        "      uploadUrls: uploadUrls,\n"
+        f"      oembedUrl: '{oembed_url}',\n"
+        f"      unsplashApiKey: '{unsplash_key}',\n"
+        f"      snippetsUrl: '{snippets_url}',\n"
+        "    });\n"
+        "\n"
+        "    if (typeof SxEditor !== 'undefined') {\n"
+        "      SxEditor.mount('sx-editor', {\n"
+        "        initialSx: (document.getElementById('sx-content-input') || {}).value || null,\n"
+        "        csrfToken: csrfToken,\n"
+        "        uploadUrls: uploadUrls,\n"
+        f"        oembedUrl: '{oembed_url}',\n"
+        "        onChange: function(sx) {\n"
+        "          document.getElementById('sx-content-input').value = sx;\n"
+        "        }\n"
+        "      });\n"
+        "    }\n"
+        "\n"
+        "    document.addEventListener('keydown', function(e) {\n"
+        "      if ((e.ctrlKey || e.metaKey) && e.key === 's') {\n"
+        "        e.preventDefault();\n"
+        "        document.getElementById('post-new-form').requestSubmit();\n"
+        "      }\n"
+        "    });\n"
+        "  }\n"
+        "\n"
+        "  if (typeof window.mountEditor === 'function') {\n"
+        "    init();\n"
+        "  } else {\n"
+        "    var _t = setInterval(function() {\n"
+        "      if (typeof window.mountEditor === 'function') { clearInterval(_t); init(); }\n"
+        "    }, 50);\n"
+        "  }\n"
+        "})();\n"
+    )
+    parts.append(sx_call("blog-editor-scripts",
+                         js_src=editor_js,
+                         sx_editor_js_src=sx_editor_js,
+                         init_js=init_js))
+
+    from shared.sx.parser import SxExpr
+    return sx_call("blog-editor-panel",
+        parts=SxExpr("(<> " + " ".join(parts) + ")")) if parts else ""
--- a/cart/actions.sx
+++ b/cart/actions.sx
@@ -0,0 +1,10 @@
+;; Cart service — inter-service action endpoints
+
+(defaction adopt-cart-for-user (&key user-id session-id)
+  "Transfer anonymous cart items to a logged-in user."
+  (do
+    (service "cart" "adopt-cart-for-user"
+      :user-id user-id :session-id session-id)
+    {"ok" true}))
+
+;; clear-cart-for-order: remains as Python fallback (complex object construction)
--- a/cart/app.py
+++ b/cart/app.py
@@ -1,6 +1,6 @@
 from __future__ import annotations
 import path_setup  # noqa: F401  # adds shared/ to sys.path
-import sx.sx_components as sx_components  # noqa: F401  # ensure Hypercorn --reload watches this file
+from shared.sx.jinja_bridge import load_service_components  # noqa: F401

 from decimal import Decimal
 from pathlib import Path
@@ -140,6 +140,9 @@ def create_app() -> "Quart":
    app.jinja_env.globals["cart_quantity_url"] = lambda product_id: f"/quantity/{product_id}/"
    app.jinja_env.globals["cart_delete_url"] = lambda product_id: f"/delete/{product_id}/"

+    import os as _os
+    load_service_components(_os.path.dirname(_os.path.abspath(__file__)), service_name="cart")
+
    from shared.sx.handlers import auto_mount_fragment_handlers
    auto_mount_fragment_handlers(app, "cart")

--- a/cart/bp/actions/routes.py
+++ b/cart/bp/actions/routes.py
@@ -1,64 +1,26 @@
 """Cart app action endpoints.

-Exposes write operations at ``/internal/actions/<action_name>`` for
-cross-app callers (login handler) via the internal action client.
+adopt-cart-for-user is defined in ``cart/actions.sx``.
+clear-cart-for-order remains as a Python fallback (complex object construction).
 """
 from __future__ import annotations

-from quart import Blueprint, g, jsonify, request
+from quart import Blueprint, g, request

-from shared.infrastructure.actions import ACTION_HEADER
-from shared.services.registry import services
+from shared.infrastructure.query_blueprint import create_action_blueprint


 def register() -> Blueprint:
-    bp = Blueprint("actions", __name__, url_prefix="/internal/actions")
+    bp, _handlers = create_action_blueprint("cart")

-    @bp.before_request
-    async def _require_action_header():
-        if not request.headers.get(ACTION_HEADER):
-            return jsonify({"error": "forbidden"}), 403
-        from shared.infrastructure.internal_auth import validate_internal_request
-        if not validate_internal_request():
-            return jsonify({"error": "forbidden"}), 403
-
-    _handlers: dict[str, object] = {}
-
-    @bp.post("/<action_name>")
-    async def handle_action(action_name: str):
-        handler = _handlers.get(action_name)
-        if handler is None:
-            return jsonify({"error": "unknown action"}), 404
-        try:
-            result = await handler()
-            return jsonify(result)
-        except Exception as exc:
-            import logging
-            logging.getLogger(__name__).exception("Action %s failed", action_name)
-            return jsonify({"error": str(exc)}), 500
-
-    # --- adopt-cart-for-user ---
-    async def _adopt_cart():
-        data = await request.get_json()
-        await services.cart.adopt_cart_for_user(
-            g.s, data["user_id"], data["session_id"],
-        )
-        return {"ok": True}
-
-    _handlers["adopt-cart-for-user"] = _adopt_cart
-
-    # --- clear-cart-for-order ---
    async def _clear_cart_for_order():
-        """Soft-delete cart items after an order is paid. Called by orders service."""
        from bp.cart.services.clear_cart_for_order import clear_cart_for_order
-        from shared.models.order import Order

        data = await request.get_json()
        user_id = data.get("user_id")
        session_id = data.get("session_id")
        page_post_id = data.get("page_post_id")

-        # Build a minimal order-like object with the fields clear_cart_for_order needs
        order = type("_Order", (), {
            "user_id": user_id,
            "session_id": session_id,
--- a/cart/bp/cart/global_routes.py
+++ b/cart/bp/cart/global_routes.py
@@ -151,7 +151,7 @@ def register(url_prefix: str) -> Blueprint:
            page_config = await resolve_page_config(g.s, cart, calendar_entries, tickets)
        except ValueError as e:
            from shared.sx.page import get_template_context
-            from sx.sx_components import render_checkout_error_page
+            from sxc.pages.renders import render_checkout_error_page
            tctx = await get_template_context()
            html = await render_checkout_error_page(tctx, error=str(e))
            return await make_response(html, 400)
@@ -208,7 +208,7 @@ def register(url_prefix: str) -> Blueprint:

        if not hosted_url:
            from shared.sx.page import get_template_context
-            from sx.sx_components import render_checkout_error_page
+            from sxc.pages.renders import render_checkout_error_page
            tctx = await get_template_context()
            html = await render_checkout_error_page(tctx, error="No hosted checkout URL returned from SumUp.")
            return await make_response(html, 500)
--- a/cart/bp/cart/page_routes.py
+++ b/cart/bp/cart/page_routes.py
@@ -73,7 +73,7 @@ def register(url_prefix: str) -> Blueprint:

        if not hosted_url:
            from shared.sx.page import get_template_context
-            from sx.sx_components import render_checkout_error_page
+            from sxc.pages.renders import render_checkout_error_page
            tctx = await get_template_context()
            html = await render_checkout_error_page(tctx, error="No hosted checkout URL returned from SumUp.")
            return await make_response(html, 500)
--- a/cart/bp/data/routes.py
+++ b/cart/bp/data/routes.py
@@ -1,79 +1,14 @@
 """Cart app data endpoints.

-Exposes read-only JSON queries at ``/internal/data/<query_name>`` for
-cross-app callers via the internal data client.
+All queries are defined in ``cart/queries.sx``.
 """
 from __future__ import annotations

-from quart import Blueprint, g, jsonify, request
+from quart import Blueprint

-from shared.infrastructure.data_client import DATA_HEADER
-from shared.contracts.dtos import dto_to_dict
-from shared.services.registry import services
+from shared.infrastructure.query_blueprint import create_data_blueprint


 def register() -> Blueprint:
-    bp = Blueprint("data", __name__, url_prefix="/internal/data")
-
-    @bp.before_request
-    async def _require_data_header():
-        if not request.headers.get(DATA_HEADER):
-            return jsonify({"error": "forbidden"}), 403
-        from shared.infrastructure.internal_auth import validate_internal_request
-        if not validate_internal_request():
-            return jsonify({"error": "forbidden"}), 403
-
-    _handlers: dict[str, object] = {}
-
-    @bp.get("/<query_name>")
-    async def handle_query(query_name: str):
-        handler = _handlers.get(query_name)
-        if handler is None:
-            return jsonify({"error": "unknown query"}), 404
-        result = await handler()
-        return jsonify(result)
-
-    # --- cart-summary ---
-    async def _cart_summary():
-        user_id = request.args.get("user_id", type=int)
-        session_id = request.args.get("session_id")
-        page_slug = request.args.get("page_slug")
-        summary = await services.cart.cart_summary(
-            g.s, user_id=user_id, session_id=session_id, page_slug=page_slug,
-        )
-        return dto_to_dict(summary)
-
-    _handlers["cart-summary"] = _cart_summary
-
-    # --- cart-items (product slugs + quantities for template rendering) ---
-    async def _cart_items():
-        from sqlalchemy import select
-        from shared.models.market import CartItem
-
-        user_id = request.args.get("user_id", type=int)
-        session_id = request.args.get("session_id")
-
-        filters = [CartItem.deleted_at.is_(None)]
-        if user_id is not None:
-            filters.append(CartItem.user_id == user_id)
-        elif session_id is not None:
-            filters.append(CartItem.session_id == session_id)
-        else:
-            return []
-
-        result = await g.s.execute(
-            select(CartItem).where(*filters)
-        )
-        items = result.scalars().all()
-        return [
-            {
-                "product_id": item.product_id,
-                "product_slug": item.product_slug,
-                "quantity": item.quantity,
-            }
-            for item in items
-        ]
-
-    _handlers["cart-items"] = _cart_items
-
+    bp, _handlers = create_data_blueprint("cart")
    return bp
--- a/cart/bp/order/routes.py
+++ b/cart/bp/order/routes.py
@@ -57,7 +57,7 @@ def register() -> Blueprint:
        if not order:
            return await make_response("Order not found", 404)
        from shared.sx.page import get_template_context
-        from sx.sx_components import render_order_page, render_order_oob
+        from sxc.pages.renders import render_order_page, render_order_oob

        ctx = await get_template_context()
        calendar_entries = ctx.get("calendar_entries")
@@ -122,7 +122,7 @@ def register() -> Blueprint:

        if not hosted_url:
            from shared.sx.page import get_template_context
-            from sx.sx_components import render_checkout_error_page
+            from sxc.pages.renders import render_checkout_error_page
            tctx = await get_template_context()
            html = await render_checkout_error_page(tctx, error="No hosted checkout URL returned from SumUp when trying to reopen payment.", order=order)
            return await make_response(html, 500)
--- a/cart/bp/orders/routes.py
+++ b/cart/bp/orders/routes.py
@@ -138,7 +138,7 @@ def register(url_prefix: str) -> Blueprint:
        orders = result.scalars().all()

        from shared.sx.page import get_template_context
-        from sx.sx_components import (
+        from sxc.pages.renders import (
            render_orders_page,
            render_orders_rows,
            render_orders_oob,
@@ -154,7 +154,7 @@ def register(url_prefix: str) -> Blueprint:
            )
            resp = await make_response(html)
        elif page > 1:
-            sx_src = await render_orders_rows(
+            sx_src = render_orders_rows(
                ctx, orders, page, total_pages, url_for, qs_fn,
            )
            resp = sx_response(sx_src)
--- a/cart/bp/page_admin/routes.py
+++ b/cart/bp/page_admin/routes.py
@@ -47,7 +47,7 @@ def register():
        g.page_config = SimpleNamespace(**raw_pc) if raw_pc else None

        from shared.sx.page import get_template_context
-        from sx.sx_components import render_cart_payments_panel
+        from sxc.pages.renders import render_cart_payments_panel
        ctx = await get_template_context()
        html = render_cart_payments_panel(ctx)
        return sx_response(html)
--- a/cart/queries.sx
+++ b/cart/queries.sx
@@ -0,0 +1,11 @@
+;; Cart service — inter-service data queries
+
+(defquery cart-summary (&key user-id session-id page-slug)
+  "Cart summary for a user or session, optionally filtered by page."
+  (service "cart" "cart-summary"
+    :user-id user-id :session-id session-id :page-slug page-slug))
+
+(defquery cart-items (&key user-id session-id)
+  "Product slugs and quantities in the cart."
+  (service "cart-data" "cart-items"
+    :user-id user-id :session-id session-id))
--- a/cart/services/init.py
+++ b/cart/services/init.py
@@ -12,3 +12,9 @@ def register_domain_services() -> None:
    from shared.services.cart_impl import SqlCartService

    services.cart = SqlCartService()
+
+    from shared.services.cart_items_impl import SqlCartItemsService
+    services.register("cart_data", SqlCartItemsService())
+
+    from .cart_page import CartPageService
+    services.register("cart_page", CartPageService())
--- a/cart/services/cart_page.py
+++ b/cart/services/cart_page.py
@@ -0,0 +1,187 @@
+"""Cart page data service — provides serialized dicts for .sx defpages."""
+from __future__ import annotations
+
+from typing import Any
+
+
+def _serialize_cart_item(item: Any) -> dict:
+    from quart import url_for
+    from shared.infrastructure.urls import market_product_url
+
+    p = item.product if hasattr(item, "product") else item
+    slug = p.slug if hasattr(p, "slug") else ""
+    unit_price = getattr(p, "special_price", None) or getattr(p, "regular_price", None)
+    currency = getattr(p, "regular_price_currency", "GBP") or "GBP"
+    return {
+        "slug": slug,
+        "title": p.title if hasattr(p, "title") else "",
+        "image": p.image if hasattr(p, "image") else None,
+        "brand": getattr(p, "brand", None),
+        "is_deleted": getattr(item, "is_deleted", False),
+        "unit_price": float(unit_price) if unit_price else None,
+        "special_price": float(p.special_price) if getattr(p, "special_price", None) else None,
+        "regular_price": float(p.regular_price) if getattr(p, "regular_price", None) else None,
+        "currency": currency,
+        "quantity": item.quantity,
+        "product_id": p.id,
+        "product_url": market_product_url(slug),
+        "qty_url": url_for("cart_global.update_quantity", product_id=p.id),
+    }
+
+
+def _serialize_cal_entry(e: Any) -> dict:
+    name = getattr(e, "name", None) or getattr(e, "calendar_name", "")
+    start = e.start_at if hasattr(e, "start_at") else ""
+    end = getattr(e, "end_at", None)
+    cost = getattr(e, "cost", 0) or 0
+    end_str = f" \u2013 {end}" if end else ""
+    return {
+        "name": name,
+        "date_str": f"{start}{end_str}",
+        "cost": float(cost),
+    }
+
+
+def _serialize_ticket_group(tg: Any) -> dict:
+    name = tg.entry_name if hasattr(tg, "entry_name") else tg.get("entry_name", "")
+    tt_name = tg.ticket_type_name if hasattr(tg, "ticket_type_name") else tg.get("ticket_type_name", "")
+    price = tg.price if hasattr(tg, "price") else tg.get("price", 0)
+    quantity = tg.quantity if hasattr(tg, "quantity") else tg.get("quantity", 0)
+    line_total = tg.line_total if hasattr(tg, "line_total") else tg.get("line_total", 0)
+    entry_id = tg.entry_id if hasattr(tg, "entry_id") else tg.get("entry_id", "")
+    tt_id = tg.ticket_type_id if hasattr(tg, "ticket_type_id") else tg.get("ticket_type_id", "")
+    start_at = tg.entry_start_at if hasattr(tg, "entry_start_at") else tg.get("entry_start_at")
+    end_at = tg.entry_end_at if hasattr(tg, "entry_end_at") else tg.get("entry_end_at")
+
+    date_str = start_at.strftime("%-d %b %Y, %H:%M") if start_at else ""
+    if end_at:
+        date_str += f" \u2013 {end_at.strftime('%-d %b %Y, %H:%M')}"
+
+    return {
+        "entry_name": name,
+        "ticket_type_name": tt_name or None,
+        "price": float(price or 0),
+        "quantity": quantity,
+        "line_total": float(line_total or 0),
+        "entry_id": entry_id,
+        "ticket_type_id": tt_id or None,
+        "date_str": date_str,
+    }
+
+
+def _serialize_page_group(grp: Any) -> dict | None:
+    post = grp.get("post") if isinstance(grp, dict) else getattr(grp, "post", None)
+    cart_items = grp.get("cart_items", []) if isinstance(grp, dict) else getattr(grp, "cart_items", [])
+    cal_entries = grp.get("calendar_entries", []) if isinstance(grp, dict) else getattr(grp, "calendar_entries", [])
+    tickets = grp.get("tickets", []) if isinstance(grp, dict) else getattr(grp, "tickets", [])
+
+    if not cart_items and not cal_entries and not tickets:
+        return None
+
+    post_data = None
+    if post:
+        post_data = {
+            "slug": post.slug if hasattr(post, "slug") else post.get("slug", ""),
+            "title": post.title if hasattr(post, "title") else post.get("title", ""),
+            "feature_image": post.feature_image if hasattr(post, "feature_image") else post.get("feature_image"),
+        }
+    market_place = grp.get("market_place") if isinstance(grp, dict) else getattr(grp, "market_place", None)
+    mp_data = None
+    if market_place:
+        mp_data = {"name": market_place.name if hasattr(market_place, "name") else market_place.get("name", "")}
+
+    return {
+        "post": post_data,
+        "product_count": grp.get("product_count", 0) if isinstance(grp, dict) else getattr(grp, "product_count", 0),
+        "calendar_count": grp.get("calendar_count", 0) if isinstance(grp, dict) else getattr(grp, "calendar_count", 0),
+        "ticket_count": grp.get("ticket_count", 0) if isinstance(grp, dict) else getattr(grp, "ticket_count", 0),
+        "total": float(grp.get("total", 0) if isinstance(grp, dict) else getattr(grp, "total", 0)),
+        "market_place": mp_data,
+    }
+
+
+class CartPageService:
+    """Service for cart page data, callable via (service "cart-page" ...)."""
+
+    async def overview_data(self, session, **kw):
+        from shared.infrastructure.urls import cart_url
+        from bp.cart.services import get_cart_grouped_by_page
+
+        page_groups = await get_cart_grouped_by_page(session)
+        grp_dicts = [d for d in (_serialize_page_group(grp) for grp in page_groups) if d]
+        return {
+            "page_groups": grp_dicts,
+            "cart_url_base": cart_url(""),
+        }
+
+    async def page_cart_data(self, session, **kw):
+        from quart import g, request, url_for
+        from shared.infrastructure.urls import login_url
+        from shared.utils import route_prefix
+        from bp.cart.services import total, calendar_total, ticket_total
+        from bp.cart.services.page_cart import (
+            get_cart_for_page, get_calendar_entries_for_page, get_tickets_for_page,
+        )
+        from bp.cart.services.ticket_groups import group_tickets
+
+        post = g.page_post
+        cart = await get_cart_for_page(session, post.id)
+        cal_entries = await get_calendar_entries_for_page(session, post.id)
+        page_tickets = await get_tickets_for_page(session, post.id)
+        ticket_groups = group_tickets(page_tickets)
+
+        # Build summary data
+        product_qty = sum(ci.quantity for ci in cart) if cart else 0
+        ticket_qty = len(page_tickets) if page_tickets else 0
+        item_count = product_qty + ticket_qty
+
+        product_total = total(cart) or 0
+        cal_total = calendar_total(cal_entries) or 0
+        tk_total = ticket_total(page_tickets) or 0
+        grand = float(product_total) + float(cal_total) + float(tk_total)
+
+        symbol = "\u00a3"
+        if cart and hasattr(cart[0], "product") and getattr(cart[0].product, "regular_price_currency", None):
+            cur = cart[0].product.regular_price_currency
+            symbol = "\u00a3" if cur == "GBP" else cur
+
+        user = getattr(g, "user", None)
+        page_post = getattr(g, "page_post", None)
+
+        summary = {
+            "item_count": item_count,
+            "grand_total": grand,
+            "symbol": symbol,
+            "is_logged_in": bool(user),
+        }
+
+        if user:
+            if page_post:
+                action = url_for("page_cart.page_checkout")
+            else:
+                action = url_for("cart_global.checkout")
+            summary["checkout_action"] = route_prefix() + action
+            summary["user_email"] = user.email
+        else:
+            summary["login_href"] = login_url(request.url)
+
+        return {
+            "cart_items": [_serialize_cart_item(i) for i in cart],
+            "cal_entries": [_serialize_cal_entry(e) for e in cal_entries],
+            "ticket_groups": [_serialize_ticket_group(tg) for tg in ticket_groups],
+            "summary": summary,
+        }
+
+    async def payments_data(self, session, **kw):
+        from shared.sx.page import get_template_context
+
+        ctx = await get_template_context()
+        page_config = ctx.get("page_config")
+        pc_data = None
+        if page_config:
+            pc_data = {
+                "sumup_api_key": bool(getattr(page_config, "sumup_api_key", None)),
+                "sumup_merchant_code": getattr(page_config, "sumup_merchant_code", None) or "",
+                "sumup_checkout_prefix": getattr(page_config, "sumup_checkout_prefix", None) or "",
+            }
+        return {"page_config": pc_data}
--- a/cart/sx/header.sx
+++ b/cart/sx/header.sx
@@ -3,6 +3,11 @@
 (defcomp ~cart-page-label-img (&key src)
  (img :src src :class "h-8 w-8 rounded-full object-cover border border-stone-300 flex-shrink-0"))

+(defcomp ~cart-page-label (&key feature-image title)
+  (<> (when feature-image
+        (~cart-page-label-img :src feature-image))
+    (span title)))
+
 (defcomp ~cart-all-carts-link (&key href)
  (a :href href :class "inline-flex items-center gap-1.5 px-3 py-1.5 text-sm rounded-full border border-stone-300 bg-white hover:bg-stone-50 transition"
    (i :class "fa fa-arrow-left text-xs" :aria-hidden "true") "All carts"))
--- a/cart/sx/items.sx
+++ b/cart/sx/items.sx
@@ -52,3 +52,114 @@
    (div :id "cart"
      (div (section :class "space-y-3 sm:space-y-4" items cal tickets)
        summary))))
+
+;; Assembled cart item from serialized data — replaces Python _cart_item_sx
+(defcomp ~cart-item-from-data (&key item)
+  (let* ((slug (or (get item "slug") ""))
+         (title (or (get item "title") ""))
+         (image (get item "image"))
+         (brand (get item "brand"))
+         (is-deleted (get item "is_deleted"))
+         (unit-price (get item "unit_price"))
+         (special-price (get item "special_price"))
+         (regular-price (get item "regular_price"))
+         (currency (or (get item "currency") "GBP"))
+         (symbol (if (= currency "GBP") "\u00a3" currency))
+         (quantity (or (get item "quantity") 1))
+         (product-id (get item "product_id"))
+         (prod-url (or (get item "product_url") ""))
+         (qty-url (or (get item "qty_url") ""))
+         (csrf (csrf-token))
+         (line-total (when unit-price (* unit-price quantity))))
+    (~cart-item
+      :id (str "cart-item-" slug)
+      :img (if image
+             (~cart-item-img :src image :alt title)
+             (~img-or-placeholder :src nil
+               :size-cls "w-24 h-24 sm:w-32 sm:h-28 rounded-xl border border-dashed border-stone-300"
+               :placeholder-text "No image"))
+      :prod-url prod-url
+      :title title
+      :brand (when brand (~cart-item-brand :brand brand))
+      :deleted (when is-deleted (~cart-item-deleted))
+      :price (if unit-price
+               (<>
+                 (~cart-item-price :text (str symbol (format-decimal unit-price 2)))
+                 (when (and special-price (!= special-price regular-price))
+                   (~cart-item-price-was :text (str symbol (format-decimal regular-price 2)))))
+               (~cart-item-no-price))
+      :qty-url qty-url :csrf csrf
+      :minus (str (- quantity 1))
+      :qty (str quantity)
+      :plus (str (+ quantity 1))
+      :line-total (when line-total
+        (~cart-item-line-total :text (str "Line total: " symbol (format-decimal line-total 2)))))))
+
+;; Assembled calendar entries section — replaces Python _calendar_entries_sx
+(defcomp ~cart-cal-section-from-data (&key entries)
+  (when (not (empty? entries))
+    (~cart-cal-section
+      :items (map (lambda (e)
+        (let* ((name (or (get e "name") ""))
+               (date-str (or (get e "date_str") "")))
+          (~cart-cal-entry
+            :name name :date-str date-str
+            :cost (str "\u00a3" (format-decimal (or (get e "cost") 0) 2)))))
+        entries))))
+
+;; Assembled ticket groups section — replaces Python _ticket_groups_sx
+(defcomp ~cart-tickets-section-from-data (&key ticket-groups)
+  (when (not (empty? ticket-groups))
+    (let* ((csrf (csrf-token))
+           (qty-url (url-for "cart_global.update_ticket_quantity")))
+      (~cart-tickets-section
+        :items (map (lambda (tg)
+          (let* ((name (or (get tg "entry_name") ""))
+                 (tt-name (get tg "ticket_type_name"))
+                 (price (or (get tg "price") 0))
+                 (quantity (or (get tg "quantity") 0))
+                 (line-total (or (get tg "line_total") 0))
+                 (entry-id (str (or (get tg "entry_id") "")))
+                 (tt-id (get tg "ticket_type_id"))
+                 (date-str (or (get tg "date_str") "")))
+            (~cart-ticket-article
+              :name name
+              :type-name (when tt-name (~cart-ticket-type-name :name tt-name))
+              :date-str date-str
+              :price (str "\u00a3" (format-decimal price 2))
+              :qty-url qty-url :csrf csrf
+              :entry-id entry-id
+              :type-hidden (when tt-id (~cart-ticket-type-hidden :value (str tt-id)))
+              :minus (str (max (- quantity 1) 0))
+              :qty (str quantity)
+              :plus (str (+ quantity 1))
+              :line-total (str "Line total: \u00a3" (format-decimal line-total 2)))))
+          ticket-groups)))))
+
+;; Assembled cart summary — replaces Python _cart_summary_sx
+(defcomp ~cart-summary-from-data (&key item-count grand-total symbol is-logged-in checkout-action login-href user-email)
+  (~cart-summary-panel
+    :item-count (str item-count)
+    :subtotal (str symbol (format-decimal grand-total 2))
+    :checkout (if is-logged-in
+      (~cart-checkout-form
+        :action checkout-action :csrf (csrf-token)
+        :label (str " Checkout as " user-email))
+      (~cart-checkout-signin :href login-href))))
+
+;; Assembled page cart content — replaces Python _page_cart_main_panel_sx
+(defcomp ~cart-page-cart-content (&key cart-items cal-entries ticket-groups summary)
+  (if (and (empty? (or cart-items (list)))
+           (empty? (or cal-entries (list)))
+           (empty? (or ticket-groups (list))))
+    (div :class "max-w-full px-3 py-3 space-y-3"
+      (div :id "cart"
+        (div :class "rounded-2xl border border-dashed border-stone-300 bg-white/80 p-6 sm:p-8 text-center"
+          (~empty-state :icon "fa fa-shopping-cart" :message "Your cart is empty" :cls "text-center"))))
+    (~cart-page-panel
+      :items (map (lambda (item) (~cart-item-from-data :item item)) (or cart-items (list)))
+      :cal (when (not (empty? (or cal-entries (list))))
+        (~cart-cal-section-from-data :entries cal-entries))
+      :tickets (when (not (empty? (or ticket-groups (list))))
+        (~cart-tickets-section-from-data :ticket-groups ticket-groups))
+      :summary summary)))
--- a/cart/sx/layouts.sx
+++ b/cart/sx/layouts.sx
@@ -0,0 +1,63 @@
+;; Cart layout defcomps — fully self-contained via IO primitives.
+
+;; --- cart-page layout: root + cart row + page-cart row ---
+
+(defcomp ~cart-page-layout-full (&key cart-row page-cart-row)
+  (<> (~root-header-auto)
+    (~header-child-sx
+      :inner (<> cart-row
+               (~header-child-sx :id "cart-header-child" :inner page-cart-row)))))
+
+(defcomp ~cart-page-layout-oob (&key root-header-oob cart-row-oob page-cart-row)
+  (<> (~oob-header-sx :parent-id "cart-header-child" :row page-cart-row)
+    cart-row-oob
+    root-header-oob))
+
+;; --- cart-admin layout: root + post header + admin header ---
+
+(defcomp ~cart-admin-layout-full (&key post-header admin-header)
+  (<> (~root-header-auto)
+    post-header admin-header))
+
+;; --- orders-within-cart: root + auth-simple + orders ---
+
+(defcomp ~cart-orders-layout-full (&key list-url)
+  (<> (~root-header-auto)
+    (~header-child-sx
+      :inner (<> (~auth-header-row-simple-auto)
+               (~header-child-sx :id "auth-header-child"
+                 :inner (~orders-header-row :list-url list-url))))))
+
+(defcomp ~cart-orders-layout-oob (&key list-url)
+  (<> (~auth-header-row-simple-auto true)
+    (~oob-header-sx
+      :parent-id "auth-header-child"
+      :row (~orders-header-row :list-url list-url))
+    (~root-header-auto true)))
+
+;; --- order-detail-within-cart: root + auth-simple + orders + order ---
+
+(defcomp ~cart-order-detail-layout-full (&key list-url detail-url order-label)
+  (<> (~root-header-auto)
+    (~header-child-sx
+      :inner (<> (~auth-header-row-simple-auto)
+               (~header-child-sx :id "auth-header-child"
+                 :inner (<> (~orders-header-row :list-url list-url)
+                          (~header-child-sx :id "orders-header-child"
+                            :inner (~menu-row-sx :id "order-row" :level 3 :colour "sky"
+                                     :link-href detail-url
+                                     :link-label order-label
+                                     :icon "fa fa-gbp"))))))))
+
+(defcomp ~cart-order-detail-layout-oob (&key detail-url order-label)
+  (<> (~oob-header-sx
+        :parent-id "orders-header-child"
+        :row (~menu-row-sx :id "order-row" :level 3 :colour "sky"
+               :link-href detail-url :link-label order-label
+               :icon "fa fa-gbp" :oob true))
+    (~root-header-auto true)))
+
+;; --- orders rows wrapper (for infinite scroll) ---
+
+(defcomp ~cart-orders-rows (&key rows next-scroll)
+  (<> rows next-scroll))
--- a/cart/sx/overview.sx
+++ b/cart/sx/overview.sx
@@ -39,3 +39,56 @@
 (defcomp ~cart-overview-panel (&key cards)
  (div :class "max-w-full px-3 py-3 space-y-3"
    (div :class "space-y-4" cards)))
+
+(defcomp ~cart-empty ()
+  (div :class "max-w-full px-3 py-3 space-y-3"
+    (div :class "rounded-2xl border border-dashed border-stone-300 bg-white/80 p-6 sm:p-8 text-center"
+      (~empty-state :icon "fa fa-shopping-cart" :message "Your cart is empty" :cls "text-center"))))
+
+;; Assembled page group card — replaces Python _page_group_card_sx
+(defcomp ~cart-page-group-card-from-data (&key grp cart-url-base)
+  (let* ((post (get grp "post"))
+         (product-count (or (get grp "product_count") 0))
+         (calendar-count (or (get grp "calendar_count") 0))
+         (ticket-count (or (get grp "ticket_count") 0))
+         (total (or (get grp "total") 0))
+         (market-place (get grp "market_place"))
+         (badges (<>
+           (when (> product-count 0)
+             (~cart-badge :icon "fa fa-box-open"
+               :text (str product-count " item" (pluralize product-count))))
+           (when (> calendar-count 0)
+             (~cart-badge :icon "fa fa-calendar"
+               :text (str calendar-count " booking" (pluralize calendar-count))))
+           (when (> ticket-count 0)
+             (~cart-badge :icon "fa fa-ticket"
+               :text (str ticket-count " ticket" (pluralize ticket-count)))))))
+    (if post
+      (let* ((slug (or (get post "slug") ""))
+             (title (or (get post "title") ""))
+             (feature-image (get post "feature_image"))
+             (mp-name (if market-place (or (get market-place "name") "") ""))
+             (display-title (if (!= mp-name "") mp-name title)))
+        (~cart-group-card
+          :href (str cart-url-base "/" slug "/")
+          :img (if feature-image
+                 (~cart-group-card-img :src feature-image :alt title)
+                 (~img-or-placeholder :src nil :size-cls "h-16 w-16 rounded-xl"
+                   :placeholder-icon "fa fa-store text-xl"))
+          :display-title display-title
+          :subtitle (when (!= mp-name "")
+            (~cart-mp-subtitle :title title))
+          :badges (~cart-badges-wrap :badges badges)
+          :total (str "\u00a3" (format-decimal total 2))))
+      (~cart-orphan-card
+        :badges (~cart-badges-wrap :badges badges)
+        :total (str "\u00a3" (format-decimal total 2))))))
+
+;; Assembled cart overview content — replaces Python _overview_main_panel_sx
+(defcomp ~cart-overview-content (&key page-groups cart-url-base)
+  (if (empty? page-groups)
+    (~cart-empty)
+    (~cart-overview-panel
+      :cards (map (lambda (grp)
+        (~cart-page-group-card-from-data :grp grp :cart-url-base cart-url-base))
+        page-groups))))
--- a/cart/sx/payments.sx
+++ b/cart/sx/payments.sx
@@ -5,3 +5,27 @@
    (~sumup-settings-form :update-url update-url :csrf csrf :merchant-code merchant-code
      :placeholder placeholder :input-cls input-cls :sumup-configured sumup-configured
      :checkout-prefix checkout-prefix :sx-select "#payments-panel")))
+
+;; Assembled cart admin overview content
+(defcomp ~cart-admin-content ()
+  (let* ((payments-href (url-for "defpage_cart_payments")))
+    (div :id "main-panel"
+      (div :class "flex items-center justify-between p-3 border-b"
+        (span :class "font-medium" (i :class "fa fa-credit-card text-purple-600 mr-1") " Payments")
+        (a :href payments-href :class "text-sm underline" "configure")))))
+
+;; Assembled cart payments content
+(defcomp ~cart-payments-content (&key page-config)
+  (let* ((sumup-configured (and page-config (get page-config "sumup_api_key")))
+         (merchant-code (or (get page-config "sumup_merchant_code") ""))
+         (checkout-prefix (or (get page-config "sumup_checkout_prefix") ""))
+         (placeholder (if sumup-configured "--------" "sup_sk_..."))
+         (input-cls "w-full px-3 py-1.5 text-sm border border-stone-300 rounded focus:ring-purple-500 focus:border-purple-500"))
+    (~cart-payments-panel
+      :update-url (url-for "page_admin.update_sumup")
+      :csrf (csrf-token)
+      :merchant-code merchant-code
+      :placeholder placeholder
+      :input-cls input-cls
+      :sumup-configured sumup-configured
+      :checkout-prefix checkout-prefix)))
--- a/cart/sx/sx_components.py
+++ b/cart/sx/sx_components.py
@@ -1,807 +0,0 @@
-"""
-Cart service s-expression page components.
-
-Renders cart overview, page cart, orders list, and single order detail.
-Called from route handlers in place of ``render_template()``.
-"""
-from __future__ import annotations
-
-import os
-from typing import Any
-from markupsafe import escape
-
-from shared.sx.jinja_bridge import load_service_components
-from shared.sx.helpers import (
-    call_url, root_header_sx, post_admin_header_sx,
-    post_header_sx as _shared_post_header_sx,
-    search_desktop_sx, search_mobile_sx,
-    full_page_sx, oob_page_sx, header_child_sx,
-    sx_call, SxExpr,
-)
-from shared.infrastructure.urls import market_product_url, cart_url
-
-# Load cart-specific .sx components + handlers at import time
-load_service_components(os.path.dirname(os.path.dirname(__file__)),
-                        service_name="cart")
-
-
-# ---------------------------------------------------------------------------
-# Header helpers
-# ---------------------------------------------------------------------------
-
-def _ensure_post_ctx(ctx: dict, page_post: Any) -> dict:
-    """Ensure ctx has a 'post' dict from page_post DTO (for shared post_header_sx)."""
-    if ctx.get("post") or not page_post:
-        return ctx
-    ctx = {**ctx, "post": {
-        "id": getattr(page_post, "id", None),
-        "slug": getattr(page_post, "slug", ""),
-        "title": getattr(page_post, "title", ""),
-        "feature_image": getattr(page_post, "feature_image", None),
-    }}
-    return ctx
-
-
-async def _ensure_container_nav(ctx: dict) -> dict:
-    """Fetch container_nav if not already present (for post header row)."""
-    if ctx.get("container_nav"):
-        return ctx
-    post = ctx.get("post") or {}
-    post_id = post.get("id")
-    slug = post.get("slug", "")
-    if not post_id:
-        return ctx
-    from shared.infrastructure.fragments import fetch_fragments
-    nav_params = {
-        "container_type": "page",
-        "container_id": str(post_id),
-        "post_slug": slug,
-    }
-    events_nav, market_nav = await fetch_fragments([
-        ("events", "container-nav", nav_params),
-        ("market", "container-nav", nav_params),
-    ], required=False)
-    return {**ctx, "container_nav": events_nav + market_nav}
-
-
-async def _post_header_sx(ctx: dict, page_post: Any, *, oob: bool = False) -> str:
-    """Build post-level header row from page_post DTO, using shared helper."""
-    ctx = _ensure_post_ctx(ctx, page_post)
-    ctx = await _ensure_container_nav(ctx)
-    return _shared_post_header_sx(ctx, oob=oob)
-
-
-def _cart_header_sx(ctx: dict, *, oob: bool = False) -> str:
-    """Build the cart section header row."""
-    return sx_call(
-        "menu-row-sx",
-        id="cart-row", level=1, colour="sky",
-        link_href=call_url(ctx, "cart_url", "/"),
-        link_label="cart", icon="fa fa-shopping-cart",
-        child_id="cart-header-child", oob=oob,
-    )
-
-
-def _page_cart_header_sx(ctx: dict, page_post: Any, *, oob: bool = False) -> str:
-    """Build the per-page cart header row."""
-    slug = page_post.slug if page_post else ""
-    title = ((page_post.title if page_post else None) or "")[:160]
-    label_parts = []
-    if page_post and page_post.feature_image:
-        label_parts.append(sx_call("cart-page-label-img", src=page_post.feature_image))
-    label_parts.append(f'(span "{escape(title)}")')
-    label_sx = "(<> " + " ".join(label_parts) + ")"
-    nav_sx = sx_call("cart-all-carts-link", href=call_url(ctx, "cart_url", "/"))
-    return sx_call(
-        "menu-row-sx",
-        id="page-cart-row", level=2, colour="sky",
-        link_href=call_url(ctx, "cart_url", f"/{slug}/"),
-        link_label_content=SxExpr(label_sx),
-        nav=SxExpr(nav_sx), oob=oob,
-    )
-
-
-def _auth_header_sx(ctx: dict, *, oob: bool = False) -> str:
-    """Build the account section header row (for orders)."""
-    return sx_call(
-        "menu-row-sx",
-        id="auth-row", level=1, colour="sky",
-        link_href=call_url(ctx, "account_url", "/"),
-        link_label="account", icon="fa-solid fa-user",
-        child_id="auth-header-child", oob=oob,
-    )
-
-
-def _orders_header_sx(ctx: dict, list_url: str) -> str:
-    """Build the orders section header row."""
-    return sx_call(
-        "menu-row-sx",
-        id="orders-row", level=2, colour="sky",
-        link_href=list_url, link_label="Orders", icon="fa fa-gbp",
-        child_id="orders-header-child",
-    )
-
-
-# ---------------------------------------------------------------------------
-# Cart overview
-# ---------------------------------------------------------------------------
-
-def _badge_sx(icon: str, count: int, label: str) -> str:
-    """Render a count badge."""
-    s = "s" if count != 1 else ""
-    return sx_call("cart-badge", icon=icon, text=f"{count} {label}{s}")
-
-
-def _page_group_card_sx(grp: Any, ctx: dict) -> str:
-    """Render a single page group card for cart overview."""
-    post = grp.get("post") if isinstance(grp, dict) else getattr(grp, "post", None)
-    cart_items = grp.get("cart_items", []) if isinstance(grp, dict) else getattr(grp, "cart_items", [])
-    cal_entries = grp.get("calendar_entries", []) if isinstance(grp, dict) else getattr(grp, "calendar_entries", [])
-    tickets = grp.get("tickets", []) if isinstance(grp, dict) else getattr(grp, "tickets", [])
-    product_count = grp.get("product_count", 0) if isinstance(grp, dict) else getattr(grp, "product_count", 0)
-    calendar_count = grp.get("calendar_count", 0) if isinstance(grp, dict) else getattr(grp, "calendar_count", 0)
-    ticket_count = grp.get("ticket_count", 0) if isinstance(grp, dict) else getattr(grp, "ticket_count", 0)
-    total = grp.get("total", 0) if isinstance(grp, dict) else getattr(grp, "total", 0)
-    market_place = grp.get("market_place") if isinstance(grp, dict) else getattr(grp, "market_place", None)
-
-    if not cart_items and not cal_entries and not tickets:
-        return ""
-
-    # Count badges
-    badge_parts = []
-    if product_count > 0:
-        badge_parts.append(_badge_sx("fa fa-box-open", product_count, "item"))
-    if calendar_count > 0:
-        badge_parts.append(_badge_sx("fa fa-calendar", calendar_count, "booking"))
-    if ticket_count > 0:
-        badge_parts.append(_badge_sx("fa fa-ticket", ticket_count, "ticket"))
-    badges_sx = "(<> " + " ".join(badge_parts) + ")" if badge_parts else '""'
-    badges_wrap = sx_call("cart-badges-wrap", badges=SxExpr(badges_sx))
-
-    if post:
-        slug = post.slug if hasattr(post, "slug") else post.get("slug", "")
-        title = post.title if hasattr(post, "title") else post.get("title", "")
-        feature_image = post.feature_image if hasattr(post, "feature_image") else post.get("feature_image")
-        cart_href = call_url(ctx, "cart_url", f"/{slug}/")
-
-        if feature_image:
-            img = sx_call("cart-group-card-img", src=feature_image, alt=title)
-        else:
-            img = sx_call("img-or-placeholder", src=None,
-                          size_cls="h-16 w-16 rounded-xl",
-                          placeholder_icon="fa fa-store text-xl")
-
-        mp_sub = ""
-        if market_place:
-            mp_name = market_place.name if hasattr(market_place, "name") else market_place.get("name", "")
-            mp_sub = sx_call("cart-mp-subtitle", title=title)
-        else:
-            mp_name = ""
-        display_title = mp_name or title
-
-        return sx_call(
-            "cart-group-card",
-            href=cart_href, img=SxExpr(img), display_title=display_title,
-            subtitle=SxExpr(mp_sub) if mp_sub else None,
-            badges=SxExpr(badges_wrap),
-            total=f"\u00a3{total:.2f}",
-        )
-    else:
-        # Orphan items
-        return sx_call(
-            "cart-orphan-card",
-            badges=SxExpr(badges_wrap),
-            total=f"\u00a3{total:.2f}",
-        )
-
-
-def _empty_cart_sx() -> str:
-    """Empty cart state."""
-    empty = sx_call("empty-state", icon="fa fa-shopping-cart",
-                    message="Your cart is empty", cls="text-center")
-    return (
-        '(div :class "max-w-full px-3 py-3 space-y-3"'
-        ' (div :class "rounded-2xl border border-dashed border-stone-300 bg-white/80 p-6 sm:p-8 text-center"'
-        f' {empty}))'
-    )
-
-
-def _overview_main_panel_sx(page_groups: list, ctx: dict) -> str:
-    """Cart overview main panel."""
-    if not page_groups:
-        return _empty_cart_sx()
-
-    cards = [_page_group_card_sx(grp, ctx) for grp in page_groups]
-    has_items = any(c for c in cards)
-    if not has_items:
-        return _empty_cart_sx()
-
-    cards_sx = "(<> " + " ".join(c for c in cards if c) + ")"
-    return sx_call("cart-overview-panel", cards=SxExpr(cards_sx))
-
-
-# ---------------------------------------------------------------------------
-# Page cart
-# ---------------------------------------------------------------------------
-
-def _cart_item_sx(item: Any, ctx: dict) -> str:
-    """Render a single product cart item."""
-    from shared.browser.app.csrf import generate_csrf_token
-    from quart import url_for
-
-    p = item.product if hasattr(item, "product") else item
-    slug = p.slug if hasattr(p, "slug") else ""
-    unit_price = getattr(p, "special_price", None) or getattr(p, "regular_price", None)
-    currency = getattr(p, "regular_price_currency", "GBP") or "GBP"
-    symbol = "\u00a3" if currency == "GBP" else currency
-    csrf = generate_csrf_token()
-    qty_url = url_for("cart_global.update_quantity", product_id=p.id)
-    prod_url = market_product_url(slug)
-
-    if p.image:
-        img = sx_call("cart-item-img", src=p.image, alt=p.title)
-    else:
-        img = sx_call("img-or-placeholder", src=None,
-                      size_cls="w-24 h-24 sm:w-32 sm:h-28 rounded-xl border border-dashed border-stone-300",
-                      placeholder_text="No image")
-
-    price_parts = []
-    if unit_price:
-        price_parts.append(sx_call("cart-item-price", text=f"{symbol}{unit_price:.2f}"))
-        if p.special_price and p.special_price != p.regular_price:
-            price_parts.append(sx_call("cart-item-price-was", text=f"{symbol}{p.regular_price:.2f}"))
-    else:
-        price_parts.append(sx_call("cart-item-no-price"))
-    price_sx = "(<> " + " ".join(price_parts) + ")" if len(price_parts) > 1 else price_parts[0]
-
-    deleted_sx = sx_call("cart-item-deleted") if getattr(item, "is_deleted", False) else None
-
-    brand_sx = sx_call("cart-item-brand", brand=p.brand) if getattr(p, "brand", None) else None
-
-    line_total_sx = None
-    if unit_price:
-        lt = unit_price * item.quantity
-        line_total_sx = sx_call("cart-item-line-total", text=f"Line total: {symbol}{lt:.2f}")
-
-    return sx_call(
-        "cart-item",
-        id=f"cart-item-{slug}", img=SxExpr(img), prod_url=prod_url, title=p.title,
-        brand=SxExpr(brand_sx) if brand_sx else None,
-        deleted=SxExpr(deleted_sx) if deleted_sx else None,
-        price=SxExpr(price_sx),
-        qty_url=qty_url, csrf=csrf, minus=str(item.quantity - 1),
-        qty=str(item.quantity), plus=str(item.quantity + 1),
-        line_total=SxExpr(line_total_sx) if line_total_sx else None,
-    )
-
-
-def _calendar_entries_sx(entries: list) -> str:
-    """Render calendar booking entries in cart."""
-    if not entries:
-        return ""
-    parts = []
-    for e in entries:
-        name = getattr(e, "name", None) or getattr(e, "calendar_name", "")
-        start = e.start_at if hasattr(e, "start_at") else ""
-        end = getattr(e, "end_at", None)
-        cost = getattr(e, "cost", 0) or 0
-        end_str = f" \u2013 {end}" if end else ""
-        parts.append(sx_call(
-            "cart-cal-entry",
-            name=name, date_str=f"{start}{end_str}", cost=f"\u00a3{cost:.2f}",
-        ))
-    items_sx = "(<> " + " ".join(parts) + ")"
-    return sx_call("cart-cal-section", items=SxExpr(items_sx))
-
-
-def _ticket_groups_sx(ticket_groups: list, ctx: dict) -> str:
-    """Render ticket groups in cart."""
-    if not ticket_groups:
-        return ""
-    from shared.browser.app.csrf import generate_csrf_token
-    from quart import url_for
-
-    csrf = generate_csrf_token()
-    qty_url = url_for("cart_global.update_ticket_quantity")
-    parts = []
-
-    for tg in ticket_groups:
-        name = tg.entry_name if hasattr(tg, "entry_name") else tg.get("entry_name", "")
-        tt_name = tg.ticket_type_name if hasattr(tg, "ticket_type_name") else tg.get("ticket_type_name", "")
-        price = tg.price if hasattr(tg, "price") else tg.get("price", 0)
-        quantity = tg.quantity if hasattr(tg, "quantity") else tg.get("quantity", 0)
-        line_total = tg.line_total if hasattr(tg, "line_total") else tg.get("line_total", 0)
-        entry_id = tg.entry_id if hasattr(tg, "entry_id") else tg.get("entry_id", "")
-        tt_id = tg.ticket_type_id if hasattr(tg, "ticket_type_id") else tg.get("ticket_type_id", "")
-        start_at = tg.entry_start_at if hasattr(tg, "entry_start_at") else tg.get("entry_start_at")
-        end_at = tg.entry_end_at if hasattr(tg, "entry_end_at") else tg.get("entry_end_at")
-
-        date_str = start_at.strftime("%-d %b %Y, %H:%M") if start_at else ""
-        if end_at:
-            date_str += f" \u2013 {end_at.strftime('%-d %b %Y, %H:%M')}"
-
-        tt_name_sx = sx_call("cart-ticket-type-name", name=tt_name) if tt_name else None
-        tt_hidden_sx = sx_call("cart-ticket-type-hidden", value=str(tt_id)) if tt_id else None
-
-        parts.append(sx_call(
-            "cart-ticket-article",
-            name=name,
-            type_name=SxExpr(tt_name_sx) if tt_name_sx else None,
-            date_str=date_str,
-            price=f"\u00a3{price or 0:.2f}", qty_url=qty_url, csrf=csrf,
-            entry_id=str(entry_id),
-            type_hidden=SxExpr(tt_hidden_sx) if tt_hidden_sx else None,
-            minus=str(max(quantity - 1, 0)), qty=str(quantity),
-            plus=str(quantity + 1), line_total=f"Line total: \u00a3{line_total:.2f}",
-        ))
-
-    items_sx = "(<> " + " ".join(parts) + ")"
-    return sx_call("cart-tickets-section", items=SxExpr(items_sx))
-
-
-def _cart_summary_sx(ctx: dict, cart: list, cal_entries: list, tickets: list,
-                       total_fn: Any, cal_total_fn: Any, ticket_total_fn: Any) -> str:
-    """Render the order summary sidebar."""
-    from shared.browser.app.csrf import generate_csrf_token
-    from quart import g, url_for, request
-    from shared.infrastructure.urls import login_url
-
-    csrf = generate_csrf_token()
-    product_qty = sum(ci.quantity for ci in cart) if cart else 0
-    ticket_qty = len(tickets) if tickets else 0
-    item_count = product_qty + ticket_qty
-
-    product_total = total_fn(cart) or 0
-    cal_total = cal_total_fn(cal_entries) or 0
-    tk_total = ticket_total_fn(tickets) or 0
-    grand = float(product_total) + float(cal_total) + float(tk_total)
-
-    symbol = "\u00a3"
-    if cart and hasattr(cart[0], "product") and getattr(cart[0].product, "regular_price_currency", None):
-        cur = cart[0].product.regular_price_currency
-        symbol = "\u00a3" if cur == "GBP" else cur
-
-    user = getattr(g, "user", None)
-    page_post = ctx.get("page_post")
-
-    if user:
-        if page_post:
-            action = url_for("page_cart.page_checkout")
-        else:
-            action = url_for("cart_global.checkout")
-        from shared.utils import route_prefix
-        action = route_prefix() + action
-        checkout_sx = sx_call(
-            "cart-checkout-form",
-            action=action, csrf=csrf, label=f" Checkout as {user.email}",
-        )
-    else:
-        href = login_url(request.url)
-        checkout_sx = sx_call("cart-checkout-signin", href=href)
-
-    return sx_call(
-        "cart-summary-panel",
-        item_count=str(item_count), subtotal=f"{symbol}{grand:.2f}",
-        checkout=SxExpr(checkout_sx),
-    )
-
-
-def _page_cart_main_panel_sx(ctx: dict, cart: list, cal_entries: list,
-                                tickets: list, ticket_groups: list,
-                                total_fn: Any, cal_total_fn: Any,
-                                ticket_total_fn: Any) -> str:
-    """Page cart main panel."""
-    if not cart and not cal_entries and not tickets:
-        empty = sx_call("empty-state", icon="fa fa-shopping-cart",
-                        message="Your cart is empty", cls="text-center")
-        return (
-            '(div :class "max-w-full px-3 py-3 space-y-3"'
-            ' (div :id "cart"'
-            ' (div :class "rounded-2xl border border-dashed border-stone-300 bg-white/80 p-6 sm:p-8 text-center"'
-            f' {empty})))'
-        )
-
-    item_parts = [_cart_item_sx(item, ctx) for item in cart]
-    items_sx = "(<> " + " ".join(item_parts) + ")" if item_parts else '""'
-    cal_sx = _calendar_entries_sx(cal_entries)
-    tickets_sx = _ticket_groups_sx(ticket_groups, ctx)
-    summary_sx = _cart_summary_sx(ctx, cart, cal_entries, tickets, total_fn, cal_total_fn, ticket_total_fn)
-
-    return sx_call(
-        "cart-page-panel",
-        items=SxExpr(items_sx),
-        cal=SxExpr(cal_sx) if cal_sx else None,
-        tickets=SxExpr(tickets_sx) if tickets_sx else None,
-        summary=SxExpr(summary_sx),
-    )
-
-
-# ---------------------------------------------------------------------------
-# Orders list (same pattern as orders service)
-# ---------------------------------------------------------------------------
-
-def _order_row_sx(order: Any, detail_url: str) -> str:
-    """Render a single order as desktop table row + mobile card."""
-    status = order.status or "pending"
-    sl = status.lower()
-    pill = (
-        "border-emerald-300 bg-emerald-50 text-emerald-700" if sl == "paid"
-        else "border-rose-300 bg-rose-50 text-rose-700" if sl in ("failed", "cancelled")
-        else "border-stone-300 bg-stone-50 text-stone-700"
-    )
-    pill_cls = f"inline-flex items-center rounded-full border px-2 py-0.5 text-[11px] sm:text-xs {pill}"
-    created = order.created_at.strftime("%-d %b %Y, %H:%M") if order.created_at else "\u2014"
-    total = f"{order.currency or 'GBP'} {order.total_amount or 0:.2f}"
-
-    desktop = sx_call(
-        "order-row-desktop",
-        oid=f"#{order.id}", created=created, desc=order.description or "",
-        total=total, pill=pill_cls, status=status, url=detail_url,
-    )
-
-    mobile_pill = f"inline-flex items-center rounded-full border px-2 py-0.5 text-[11px] {pill}"
-    mobile = sx_call(
-        "order-row-mobile",
-        oid=f"#{order.id}", pill=mobile_pill, status=status,
-        created=created, total=total, url=detail_url,
-    )
-
-    return "(<> " + desktop + " " + mobile + ")"
-
-
-def _orders_rows_sx(orders: list, page: int, total_pages: int,
-                      url_for_fn: Any, qs_fn: Any) -> str:
-    """Render order rows + infinite scroll sentinel."""
-    from shared.utils import route_prefix
-    pfx = route_prefix()
-
-    parts = [
-        _order_row_sx(o, pfx + url_for_fn("orders.order.order_detail", order_id=o.id))
-        for o in orders
-    ]
-
-    if page < total_pages:
-        next_url = pfx + url_for_fn("orders.list_orders") + qs_fn(page=page + 1)
-        parts.append(sx_call(
-            "infinite-scroll",
-            url=next_url, page=page, total_pages=total_pages,
-            id_prefix="orders", colspan=5,
-        ))
-    else:
-        parts.append(sx_call("order-end-row"))
-
-    return "(<> " + " ".join(parts) + ")"
-
-
-def _orders_main_panel_sx(orders: list, rows_sx: str) -> str:
-    """Main panel for orders list."""
-    if not orders:
-        return sx_call("order-empty-state")
-    return sx_call("order-table", rows=SxExpr(rows_sx))
-
-
-def _orders_summary_sx(ctx: dict) -> str:
-    """Filter section for orders list."""
-    return sx_call("order-list-header", search_mobile=SxExpr(search_mobile_sx(ctx)))
-
-
-# ---------------------------------------------------------------------------
-# Single order detail
-# ---------------------------------------------------------------------------
-
-def _order_items_sx(order: Any) -> str:
-    """Render order items list."""
-    if not order or not order.items:
-        return ""
-    parts = []
-    for item in order.items:
-        prod_url = market_product_url(item.product_slug)
-        if item.product_image:
-            img = sx_call(
-                "order-item-image",
-                src=item.product_image, alt=item.product_title or "Product image",
-            )
-        else:
-            img = sx_call("order-item-no-image")
-        parts.append(sx_call(
-            "order-item-row",
-            href=prod_url, img=SxExpr(img),
-            title=item.product_title or "Unknown product",
-            pid=f"Product ID: {item.product_id}",
-            qty=f"Qty: {item.quantity}",
-            price=f"{item.currency or order.currency or 'GBP'} {item.unit_price or 0:.2f}",
-        ))
-    items_sx = "(<> " + " ".join(parts) + ")"
-    return sx_call("order-items-panel", items=SxExpr(items_sx))
-
-
-def _order_summary_sx(order: Any) -> str:
-    """Order summary card."""
-    return sx_call(
-        "order-summary-card",
-        order_id=order.id,
-        created_at=order.created_at.strftime("%-d %b %Y, %H:%M") if order.created_at else None,
-        description=order.description, status=order.status, currency=order.currency,
-        total_amount=f"{order.total_amount:.2f}" if order.total_amount else None,
-    )
-
-
-def _order_calendar_items_sx(calendar_entries: list | None) -> str:
-    """Render calendar bookings for an order."""
-    if not calendar_entries:
-        return ""
-    parts = []
-    for e in calendar_entries:
-        st = e.state or ""
-        pill = (
-            "bg-emerald-100 text-emerald-800" if st == "confirmed"
-            else "bg-amber-100 text-amber-800" if st == "provisional"
-            else "bg-blue-100 text-blue-800" if st == "ordered"
-            else "bg-stone-100 text-stone-700"
-        )
-        pill_cls = f"inline-flex items-center rounded-full px-2 py-0.5 text-[11px] font-medium {pill}"
-        ds = e.start_at.strftime("%-d %b %Y, %H:%M") if e.start_at else ""
-        if e.end_at:
-            ds += f" \u2013 {e.end_at.strftime('%-d %b %Y, %H:%M')}"
-        parts.append(sx_call(
-            "order-calendar-entry",
-            name=e.name, pill=pill_cls, status=st.capitalize(),
-            date_str=ds, cost=f"\u00a3{e.cost or 0:.2f}",
-        ))
-    items_sx = "(<> " + " ".join(parts) + ")"
-    return sx_call("order-calendar-section", items=SxExpr(items_sx))
-
-
-def _order_main_sx(order: Any, calendar_entries: list | None) -> str:
-    """Main panel for single order detail."""
-    summary = _order_summary_sx(order)
-    items = _order_items_sx(order)
-    cal = _order_calendar_items_sx(calendar_entries)
-    return sx_call(
-        "order-detail-panel",
-        summary=SxExpr(summary),
-        items=SxExpr(items) if items else None,
-        calendar=SxExpr(cal) if cal else None,
-    )
-
-
-def _order_filter_sx(order: Any, list_url: str, recheck_url: str,
-                       pay_url: str, csrf_token: str) -> str:
-    """Filter section for single order detail."""
-    created = order.created_at.strftime("%-d %b %Y, %H:%M") if order.created_at else "\u2014"
-    status = order.status or "pending"
-
-    pay_sx = None
-    if status != "paid":
-        pay_sx = sx_call("order-pay-btn", url=pay_url)
-
-    return sx_call(
-        "order-detail-filter",
-        info=f"Placed {created} \u00b7 Status: {status}",
-        list_url=list_url, recheck_url=recheck_url, csrf=csrf_token,
-        pay=SxExpr(pay_sx) if pay_sx else None,
-    )
-
-
-# ---------------------------------------------------------------------------
-# Public API: Cart overview
-# ---------------------------------------------------------------------------
-
-
-
-# ---------------------------------------------------------------------------
-# Public API: Orders list
-# ---------------------------------------------------------------------------
-
-async def render_orders_page(ctx: dict, orders: list, page: int,
-                              total_pages: int, search: str | None,
-                              search_count: int, url_for_fn: Any,
-                              qs_fn: Any) -> str:
-    """Full page: orders list."""
-    from shared.utils import route_prefix
-
-    ctx["search"] = search
-    ctx["search_count"] = search_count
-    list_url = route_prefix() + url_for_fn("orders.list_orders")
-
-    rows = _orders_rows_sx(orders, page, total_pages, url_for_fn, qs_fn)
-    main = _orders_main_panel_sx(orders, rows)
-
-    hdr = root_header_sx(ctx)
-    auth = _auth_header_sx(ctx)
-    orders_hdr = _orders_header_sx(ctx, list_url)
-    auth_child = sx_call(
-        "header-child-sx",
-        inner=SxExpr("(<> " + auth + " " + sx_call("header-child-sx", id="auth-header-child", inner=SxExpr(orders_hdr)) + ")"),
-    )
-    header_rows = "(<> " + hdr + " " + auth_child + ")"
-
-    return full_page_sx(ctx, header_rows=header_rows,
-                          filter=_orders_summary_sx(ctx),
-                          aside=search_desktop_sx(ctx),
-                          content=main)
-
-
-async def render_orders_rows(ctx: dict, orders: list, page: int,
-                              total_pages: int, url_for_fn: Any,
-                              qs_fn: Any) -> str:
-    """Pagination: just the table rows."""
-    return _orders_rows_sx(orders, page, total_pages, url_for_fn, qs_fn)
-
-
-async def render_orders_oob(ctx: dict, orders: list, page: int,
-                             total_pages: int, search: str | None,
-                             search_count: int, url_for_fn: Any,
-                             qs_fn: Any) -> str:
-    """OOB response for orders list."""
-    from shared.utils import route_prefix
-
-    ctx["search"] = search
-    ctx["search_count"] = search_count
-    list_url = route_prefix() + url_for_fn("orders.list_orders")
-
-    rows = _orders_rows_sx(orders, page, total_pages, url_for_fn, qs_fn)
-    main = _orders_main_panel_sx(orders, rows)
-
-    auth_oob = _auth_header_sx(ctx, oob=True)
-    auth_child_oob = sx_call(
-        "oob-header-sx",
-        parent_id="auth-header-child",
-        row=SxExpr(_orders_header_sx(ctx, list_url)),
-    )
-    root_oob = root_header_sx(ctx, oob=True)
-    oobs = "(<> " + auth_oob + " " + auth_child_oob + " " + root_oob + ")"
-
-    return oob_page_sx(oobs=oobs,
-                         filter=_orders_summary_sx(ctx),
-                         aside=search_desktop_sx(ctx),
-                         content=main)
-
-
-# ---------------------------------------------------------------------------
-# Public API: Single order detail
-# ---------------------------------------------------------------------------
-
-async def render_order_page(ctx: dict, order: Any,
-                             calendar_entries: list | None,
-                             url_for_fn: Any) -> str:
-    """Full page: single order detail."""
-    from shared.utils import route_prefix
-    from shared.browser.app.csrf import generate_csrf_token
-
-    pfx = route_prefix()
-    detail_url = pfx + url_for_fn("orders.order.order_detail", order_id=order.id)
-    list_url = pfx + url_for_fn("orders.list_orders")
-    recheck_url = pfx + url_for_fn("orders.order.order_recheck", order_id=order.id)
-    pay_url = pfx + url_for_fn("orders.order.order_pay", order_id=order.id)
-
-    main = _order_main_sx(order, calendar_entries)
-    filt = _order_filter_sx(order, list_url, recheck_url, pay_url, generate_csrf_token())
-
-    hdr = root_header_sx(ctx)
-    order_row = sx_call(
-        "menu-row-sx",
-        id="order-row", level=3, colour="sky",
-        link_href=detail_url, link_label=f"Order {order.id}", icon="fa fa-gbp",
-    )
-    order_child = sx_call(
-        "header-child-sx",
-        inner=SxExpr("(<> " + _auth_header_sx(ctx) + " " + sx_call("header-child-sx", id="auth-header-child", inner=SxExpr(
-            "(<> " + _orders_header_sx(ctx, list_url) + " " + sx_call("header-child-sx", id="orders-header-child", inner=SxExpr(order_row)) + ")"
-        )) + ")"),
-    )
-    header_rows = "(<> " + hdr + " " + order_child + ")"
-
-    return full_page_sx(ctx, header_rows=header_rows, filter=filt, content=main)
-
-
-async def render_order_oob(ctx: dict, order: Any,
-                            calendar_entries: list | None,
-                            url_for_fn: Any) -> str:
-    """OOB response for single order detail."""
-    from shared.utils import route_prefix
-    from shared.browser.app.csrf import generate_csrf_token
-
-    pfx = route_prefix()
-    detail_url = pfx + url_for_fn("orders.order.order_detail", order_id=order.id)
-    list_url = pfx + url_for_fn("orders.list_orders")
-    recheck_url = pfx + url_for_fn("orders.order.order_recheck", order_id=order.id)
-    pay_url = pfx + url_for_fn("orders.order.order_pay", order_id=order.id)
-
-    main = _order_main_sx(order, calendar_entries)
-    filt = _order_filter_sx(order, list_url, recheck_url, pay_url, generate_csrf_token())
-
-    order_row_oob = sx_call(
-        "menu-row-sx",
-        id="order-row", level=3, colour="sky",
-        link_href=detail_url, link_label=f"Order {order.id}", icon="fa fa-gbp",
-        oob=True,
-    )
-    orders_child_oob = sx_call("oob-header-sx",
-                                  parent_id="orders-header-child",
-                                  row=SxExpr(order_row_oob))
-    root_oob = root_header_sx(ctx, oob=True)
-    oobs = "(<> " + orders_child_oob + " " + root_oob + ")"
-
-    return oob_page_sx(oobs=oobs, filter=filt, content=main)
-
-
-# ---------------------------------------------------------------------------
-# Public API: Checkout error
-# ---------------------------------------------------------------------------
-
-def _checkout_error_filter_sx() -> str:
-    return sx_call("checkout-error-header")
-
-
-def _checkout_error_content_sx(error: str | None, order: Any | None) -> str:
-    err_msg = error or "Unexpected error while creating the hosted checkout session."
-    order_sx = None
-    if order:
-        order_sx = sx_call("checkout-error-order-id", oid=f"#{order.id}")
-    back_url = cart_url("/")
-    return sx_call(
-        "checkout-error-content",
-        msg=err_msg,
-        order=SxExpr(order_sx) if order_sx else None,
-        back_url=back_url,
-    )
-
-
-async def render_checkout_error_page(ctx: dict, error: str | None = None, order: Any | None = None) -> str:
-    """Full page: checkout error."""
-    hdr = root_header_sx(ctx)
-    filt = _checkout_error_filter_sx()
-    content = _checkout_error_content_sx(error, order)
-    return full_page_sx(ctx, header_rows=hdr, filter=filt, content=content)
-
-
-# ---------------------------------------------------------------------------
-# Page admin (/<page_slug>/admin/)
-# ---------------------------------------------------------------------------
-
-def _cart_page_admin_header_sx(ctx: dict, page_post: Any, *, oob: bool = False,
-                                  selected: str = "") -> str:
-    """Build the page-level admin header row -- delegates to shared helper."""
-    slug = page_post.slug if page_post else ""
-    ctx = _ensure_post_ctx(ctx, page_post)
-    return post_admin_header_sx(ctx, slug, oob=oob, selected=selected)
-
-
-def _cart_admin_main_panel_sx(ctx: dict) -> str:
-    """Admin overview panel -- links to sub-admin pages."""
-    from quart import url_for
-    payments_href = url_for("defpage_cart_payments")
-    return (
-        '(div :id "main-panel"'
-        ' (div :class "flex items-center justify-between p-3 border-b"'
-        ' (span :class "font-medium" (i :class "fa fa-credit-card text-purple-600 mr-1") " Payments")'
-        f' (a :href "{payments_href}" :class "text-sm underline" "configure")))'
-    )
-
-
-def _cart_payments_main_panel_sx(ctx: dict) -> str:
-    """Render SumUp payment config form."""
-    from quart import url_for
-    csrf_token = ctx.get("csrf_token")
-    csrf = csrf_token() if callable(csrf_token) else (csrf_token or "")
-    page_config = ctx.get("page_config")
-    sumup_configured = bool(page_config and getattr(page_config, "sumup_api_key", None))
-    merchant_code = (getattr(page_config, "sumup_merchant_code", None) or "") if page_config else ""
-    checkout_prefix = (getattr(page_config, "sumup_checkout_prefix", None) or "") if page_config else ""
-    update_url = url_for("page_admin.update_sumup")
-
-    placeholder = "--------" if sumup_configured else "sup_sk_..."
-    input_cls = "w-full px-3 py-1.5 text-sm border border-stone-300 rounded focus:ring-purple-500 focus:border-purple-500"
-
-    return sx_call("cart-payments-panel",
-                     update_url=update_url, csrf=csrf,
-                     merchant_code=merchant_code, placeholder=placeholder,
-                     input_cls=input_cls, sumup_configured=sumup_configured,
-                     checkout_prefix=checkout_prefix)
-
-
-
-def render_cart_payments_panel(ctx: dict) -> str:
-    """Render the payments config panel for PUT response."""
-    return _cart_payments_main_panel_sx(ctx)
--- a/cart/sxc/pages/init.py
+++ b/cart/sxc/pages/init.py
@@ -1,13 +1,11 @@
-"""Cart defpage setup — registers layouts, page helpers, and loads .sx pages."""
+"""Cart defpage setup — registers layouts and loads .sx pages."""
 from __future__ import annotations

-from typing import Any
-

 def setup_cart_pages() -> None:
-    """Register cart-specific layouts, page helpers, and load page definitions."""
+    """Register cart-specific layouts and load page definitions."""
+    from .layouts import _register_cart_layouts
    _register_cart_layouts()
-    _register_cart_helpers()
    _load_cart_page_files()


@@ -15,123 +13,3 @@ def _load_cart_page_files() -> None:
    import os
    from shared.sx.pages import load_page_dir
    load_page_dir(os.path.dirname(__file__), "cart")
-
-
-# ---------------------------------------------------------------------------
-# Layouts
-# ---------------------------------------------------------------------------
-
-def _register_cart_layouts() -> None:
-    from shared.sx.layouts import register_custom_layout
-    register_custom_layout("cart-page", _cart_page_full, _cart_page_oob)
-    register_custom_layout("cart-admin", _cart_admin_full, _cart_admin_oob)
-
-
-def _cart_page_full(ctx: dict, **kw: Any) -> str:
-    from shared.sx.helpers import root_header_sx, sx_call, SxExpr
-    from sx.sx_components import _cart_header_sx, _page_cart_header_sx
-
-    page_post = ctx.get("page_post")
-    root_hdr = root_header_sx(ctx)
-    child = _cart_header_sx(ctx)
-    page_hdr = _page_cart_header_sx(ctx, page_post)
-    nested = sx_call(
-        "header-child-sx",
-        inner=SxExpr("(<> " + child + " " + sx_call("header-child-sx", id="cart-header-child", inner=SxExpr(page_hdr)) + ")"),
-    )
-    return "(<> " + root_hdr + " " + nested + ")"
-
-
-def _cart_page_oob(ctx: dict, **kw: Any) -> str:
-    from shared.sx.helpers import root_header_sx, sx_call, SxExpr
-    from sx.sx_components import _cart_header_sx, _page_cart_header_sx
-
-    page_post = ctx.get("page_post")
-    child_oob = sx_call("oob-header-sx",
-                           parent_id="cart-header-child",
-                           row=SxExpr(_page_cart_header_sx(ctx, page_post)))
-    cart_hdr_oob = _cart_header_sx(ctx, oob=True)
-    root_hdr_oob = root_header_sx(ctx, oob=True)
-    return "(<> " + child_oob + " " + cart_hdr_oob + " " + root_hdr_oob + ")"
-
-
-async def _cart_admin_full(ctx: dict, **kw: Any) -> str:
-    from shared.sx.helpers import root_header_sx
-    from sx.sx_components import _post_header_sx, _cart_page_admin_header_sx
-
-    page_post = ctx.get("page_post")
-    selected = kw.get("selected", "")
-    root_hdr = root_header_sx(ctx)
-    post_hdr = await _post_header_sx(ctx, page_post)
-    admin_hdr = _cart_page_admin_header_sx(ctx, page_post, selected=selected)
-    return "(<> " + root_hdr + " " + post_hdr + " " + admin_hdr + ")"
-
-
-async def _cart_admin_oob(ctx: dict, **kw: Any) -> str:
-    from sx.sx_components import _cart_page_admin_header_sx
-
-    page_post = ctx.get("page_post")
-    selected = kw.get("selected", "")
-    return _cart_page_admin_header_sx(ctx, page_post, oob=True, selected=selected)
-
-
-# ---------------------------------------------------------------------------
-# Page helpers
-# ---------------------------------------------------------------------------
-
-def _register_cart_helpers() -> None:
-    from shared.sx.pages import register_page_helpers
-
-    register_page_helpers("cart", {
-        "overview-content": _h_overview_content,
-        "page-cart-content": _h_page_cart_content,
-        "cart-admin-content": _h_cart_admin_content,
-        "cart-payments-content": _h_cart_payments_content,
-    })
-
-
-async def _h_overview_content(**kw):
-    from quart import g
-    from shared.sx.page import get_template_context
-    from sx.sx_components import _overview_main_panel_sx
-    from bp.cart.services import get_cart_grouped_by_page
-    page_groups = await get_cart_grouped_by_page(g.s)
-    ctx = await get_template_context()
-    return _overview_main_panel_sx(page_groups, ctx)
-
-
-async def _h_page_cart_content(page_slug=None, **kw):
-    from quart import g
-    from shared.sx.page import get_template_context
-    from sx.sx_components import _page_cart_main_panel_sx
-    from bp.cart.services import total, calendar_total, ticket_total
-    from bp.cart.services.page_cart import (
-        get_cart_for_page, get_calendar_entries_for_page, get_tickets_for_page,
-    )
-    from bp.cart.services.ticket_groups import group_tickets
-
-    post = g.page_post
-    cart = await get_cart_for_page(g.s, post.id)
-    cal_entries = await get_calendar_entries_for_page(g.s, post.id)
-    page_tickets = await get_tickets_for_page(g.s, post.id)
-    ticket_groups = group_tickets(page_tickets)
-
-    ctx = await get_template_context()
-    return _page_cart_main_panel_sx(
-        ctx, cart, cal_entries, page_tickets, ticket_groups,
-        total, calendar_total, ticket_total,
-    )
-
-
-async def _h_cart_admin_content(page_slug=None, **kw):
-    from shared.sx.page import get_template_context
-    from sx.sx_components import _cart_admin_main_panel_sx
-    ctx = await get_template_context()
-    return _cart_admin_main_panel_sx(ctx)
-
-
-async def _h_cart_payments_content(page_slug=None, **kw):
-    from shared.sx.page import get_template_context
-    from sx.sx_components import _cart_payments_main_panel_sx
-    ctx = await get_template_context()
-    return _cart_payments_main_panel_sx(ctx)
--- a/cart/sxc/pages/cart.sx
+++ b/cart/sxc/pages/cart.sx
@@ -1,25 +1,43 @@
 ;; Cart app defpage declarations.
+;; All data fetching via (service ...) IO primitives, no Python helpers.

 (defpage cart-overview
  :path "/"
  :auth :public
  :layout :root
-  :content (overview-content))
+  :data (service "cart-page" "overview-data")
+  :content (~cart-overview-content
+    :page-groups page-groups
+    :cart-url-base cart-url-base))

 (defpage page-cart-view
  :path "/<page_slug>/"
  :auth :public
  :layout :cart-page
-  :content (page-cart-content))
+  :data (service "cart-page" "page-cart-data")
+  :content (~cart-page-cart-content
+    :cart-items cart-items
+    :cal-entries cal-entries
+    :ticket-groups ticket-groups
+    :summary (~cart-summary-from-data
+      :item-count (get summary "item_count")
+      :grand-total (get summary "grand_total")
+      :symbol (get summary "symbol")
+      :is-logged-in (get summary "is_logged_in")
+      :checkout-action (get summary "checkout_action")
+      :login-href (get summary "login_href")
+      :user-email (get summary "user_email"))))

 (defpage cart-admin
  :path "/<page_slug>/admin/"
  :auth :admin
  :layout :cart-admin
-  :content (cart-admin-content))
+  :content (~cart-admin-content))

 (defpage cart-payments
  :path "/<page_slug>/admin/payments/"
  :auth :admin
  :layout (:cart-admin :selected "payments")
-  :content (cart-payments-content))
+  :data (service "cart-page" "payments-data")
+  :content (~cart-payments-content
+    :page-config page-config))
--- a/cart/sxc/pages/layouts.py
+++ b/cart/sxc/pages/layouts.py
@@ -0,0 +1,135 @@
+"""Cart layout registration and header builders."""
+from __future__ import annotations
+
+from typing import Any
+
+from shared.sx.parser import SxExpr
+
+
+def _register_cart_layouts() -> None:
+    from shared.sx.layouts import register_custom_layout
+    register_custom_layout("cart-page", _cart_page_full, _cart_page_oob)
+    register_custom_layout("cart-admin", _cart_admin_full, _cart_admin_oob)
+
+
+# ---------------------------------------------------------------------------
+# Header helpers
+# ---------------------------------------------------------------------------
+
+def _ensure_post_ctx(ctx: dict, page_post: Any) -> dict:
+    """Ensure ctx has a 'post' dict from page_post DTO."""
+    if ctx.get("post") or not page_post:
+        return ctx
+    return {**ctx, "post": {
+        "id": getattr(page_post, "id", None),
+        "slug": getattr(page_post, "slug", ""),
+        "title": getattr(page_post, "title", ""),
+        "feature_image": getattr(page_post, "feature_image", None),
+    }}
+
+
+async def _ensure_container_nav(ctx: dict) -> dict:
+    """Fetch container_nav if not already present."""
+    if ctx.get("container_nav"):
+        return ctx
+    post = ctx.get("post") or {}
+    post_id = post.get("id")
+    if not post_id:
+        return ctx
+    slug = post.get("slug", "")
+    from shared.infrastructure.fragments import fetch_fragments
+    nav_params = {
+        "container_type": "page",
+        "container_id": str(post_id),
+        "post_slug": slug,
+    }
+    events_nav, market_nav = await fetch_fragments([
+        ("events", "container-nav", nav_params),
+        ("market", "container-nav", nav_params),
+    ], required=False)
+    return {**ctx, "container_nav": events_nav + market_nav}
+
+
+async def _post_header_sx(ctx: dict, page_post: Any, *, oob: bool = False) -> str:
+    from shared.sx.helpers import post_header_sx as _shared_post_header_sx
+    ctx = _ensure_post_ctx(ctx, page_post)
+    ctx = await _ensure_container_nav(ctx)
+    return await _shared_post_header_sx(ctx, oob=oob)
+
+
+def _cart_header_sx(ctx: dict, *, oob: bool = False) -> str:
+    from shared.sx.helpers import sx_call, call_url
+    return sx_call(
+        "menu-row-sx",
+        id="cart-row", level=1, colour="sky",
+        link_href=call_url(ctx, "cart_url", "/"),
+        link_label="cart", icon="fa fa-shopping-cart",
+        child_id="cart-header-child", oob=oob,
+    )
+
+
+def _page_cart_header_sx(ctx: dict, page_post: Any, *, oob: bool = False) -> str:
+    from shared.sx.helpers import sx_call, call_url
+    slug = page_post.slug if page_post else ""
+    title = ((page_post.title if page_post else None) or "")[:160]
+    label_sx = sx_call("cart-page-label",
+        feature_image=page_post.feature_image if page_post else None,
+        title=title)
+    nav_sx = sx_call("cart-all-carts-link", href=call_url(ctx, "cart_url", "/"))
+    return sx_call(
+        "menu-row-sx",
+        id="page-cart-row", level=2, colour="sky",
+        link_href=call_url(ctx, "cart_url", f"/{slug}/"),
+        link_label_content=SxExpr(label_sx),
+        nav=SxExpr(nav_sx), oob=oob,
+    )
+
+
+async def _cart_page_admin_header_sx(ctx: dict, page_post: Any, *, oob: bool = False,
+                                  selected: str = "") -> str:
+    from shared.sx.helpers import post_admin_header_sx
+    slug = page_post.slug if page_post else ""
+    ctx = _ensure_post_ctx(ctx, page_post)
+    return await post_admin_header_sx(ctx, slug, oob=oob, selected=selected)
+
+
+# ---------------------------------------------------------------------------
+# Layout functions
+# ---------------------------------------------------------------------------
+
+async def _cart_page_full(ctx: dict, **kw: Any) -> str:
+    from shared.sx.helpers import render_to_sx_with_env
+    page_post = ctx.get("page_post")
+    env = {}
+    return await render_to_sx_with_env("cart-page-layout-full", env,
+        cart_row=SxExpr(_cart_header_sx(ctx)),
+        page_cart_row=SxExpr(_page_cart_header_sx(ctx, page_post)),
+    )
+
+
+async def _cart_page_oob(ctx: dict, **kw: Any) -> str:
+    from shared.sx.helpers import render_to_sx_with_env, root_header_sx
+    page_post = ctx.get("page_post")
+    env = {}
+    return await render_to_sx_with_env("cart-page-layout-oob", env,
+        root_header_oob=SxExpr(await root_header_sx(ctx, oob=True)),
+        cart_row_oob=SxExpr(_cart_header_sx(ctx, oob=True)),
+        page_cart_row=SxExpr(_page_cart_header_sx(ctx, page_post)),
+    )
+
+
+async def _cart_admin_full(ctx: dict, **kw: Any) -> str:
+    from shared.sx.helpers import render_to_sx_with_env
+    page_post = ctx.get("page_post")
+    selected = kw.get("selected", "")
+    env = {}
+    return await render_to_sx_with_env("cart-admin-layout-full", env,
+        post_header=SxExpr(await _post_header_sx(ctx, page_post)),
+        admin_header=SxExpr(await _cart_page_admin_header_sx(ctx, page_post, selected=selected)),
+    )
+
+
+async def _cart_admin_oob(ctx: dict, **kw: Any) -> str:
+    page_post = ctx.get("page_post")
+    selected = kw.get("selected", "")
+    return await _cart_page_admin_header_sx(ctx, page_post, oob=True, selected=selected)
--- a/cart/sxc/pages/renders.py
+++ b/cart/sxc/pages/renders.py
@@ -0,0 +1,133 @@
+"""Cart render functions — called from bp routes."""
+from __future__ import annotations
+
+from shared.sx.parser import SxExpr
+
+from .utils import _serialize_order, _serialize_calendar_entry
+
+
+async def render_orders_page(ctx, orders, page, total_pages, search, search_count, url_for_fn, qs_fn):
+    from shared.sx.helpers import sx_call, render_to_sx_with_env, search_desktop_sx, search_mobile_sx, full_page_sx
+    from shared.utils import route_prefix
+    ctx["search"] = search
+    ctx["search_count"] = search_count
+    pfx = route_prefix()
+    list_url = pfx + url_for_fn("orders.list_orders")
+    detail_url_prefix = pfx + url_for_fn("orders.order.order_detail", order_id=0).rsplit("0/", 1)[0]
+    order_dicts = [_serialize_order(o) for o in orders]
+    content = sx_call("orders-list-content", orders=order_dicts,
+        page=page, total_pages=total_pages, rows_url=list_url, detail_url_prefix=detail_url_prefix)
+    header_rows = await render_to_sx_with_env("cart-orders-layout-full", {},
+        list_url=list_url,
+    )
+    filt = sx_call("order-list-header", search_mobile=SxExpr(await search_mobile_sx(ctx)))
+    return await full_page_sx(ctx, header_rows=header_rows, filter=filt,
+                          aside=await search_desktop_sx(ctx), content=content)
+
+
+def render_orders_rows(ctx, orders, page, total_pages, url_for_fn, qs_fn):
+    from shared.sx.helpers import sx_call
+    from shared.utils import route_prefix
+    pfx = route_prefix()
+    list_url = pfx + url_for_fn("orders.list_orders")
+    detail_url_prefix = pfx + url_for_fn("orders.order.order_detail", order_id=0).rsplit("0/", 1)[0]
+    order_dicts = [_serialize_order(o) for o in orders]
+    parts = []
+    for od in order_dicts:
+        parts.append(sx_call("order-row-pair", order=od, detail_url_prefix=detail_url_prefix))
+    next_scroll = ""
+    if page < total_pages:
+        next_url = list_url + qs_fn(page=page + 1)
+        next_scroll = sx_call("infinite-scroll", url=next_url, page=page,
+            total_pages=total_pages, id_prefix="orders", colspan=5)
+    else:
+        next_scroll = sx_call("order-end-row")
+    return sx_call("cart-orders-rows",
+        rows=SxExpr("(<> " + " ".join(parts) + ")"),
+        next_scroll=SxExpr(next_scroll),
+    )
+
+
+async def render_orders_oob(ctx, orders, page, total_pages, search, search_count, url_for_fn, qs_fn):
+    from shared.sx.helpers import sx_call, render_to_sx_with_env, search_desktop_sx, search_mobile_sx, oob_page_sx
+    from shared.utils import route_prefix
+    ctx["search"] = search
+    ctx["search_count"] = search_count
+    pfx = route_prefix()
+    list_url = pfx + url_for_fn("orders.list_orders")
+    detail_url_prefix = pfx + url_for_fn("orders.order.order_detail", order_id=0).rsplit("0/", 1)[0]
+    order_dicts = [_serialize_order(o) for o in orders]
+    content = sx_call("orders-list-content", orders=order_dicts,
+        page=page, total_pages=total_pages, rows_url=list_url, detail_url_prefix=detail_url_prefix)
+    oobs = await render_to_sx_with_env("cart-orders-layout-oob", {},
+        list_url=list_url,
+    )
+    filt = sx_call("order-list-header", search_mobile=SxExpr(await search_mobile_sx(ctx)))
+    return await oob_page_sx(oobs=oobs, filter=filt, aside=await search_desktop_sx(ctx), content=content)
+
+
+async def render_order_page(ctx, order, calendar_entries, url_for_fn):
+    from shared.sx.helpers import sx_call, render_to_sx_with_env, full_page_sx
+    from shared.utils import route_prefix
+    from shared.browser.app.csrf import generate_csrf_token
+    pfx = route_prefix()
+    detail_url = pfx + url_for_fn("orders.order.order_detail", order_id=order.id)
+    list_url = pfx + url_for_fn("orders.list_orders")
+    recheck_url = pfx + url_for_fn("orders.order.order_recheck", order_id=order.id)
+    pay_url = pfx + url_for_fn("orders.order.order_pay", order_id=order.id)
+    order_data = _serialize_order(order)
+    cal_data = [_serialize_calendar_entry(e) for e in (calendar_entries or [])]
+    main = sx_call("order-detail-content", order=order_data, calendar_entries=cal_data)
+    filt = sx_call("order-detail-filter-content", order=order_data,
+        list_url=list_url, recheck_url=recheck_url, pay_url=pay_url, csrf=generate_csrf_token())
+    header_rows = await render_to_sx_with_env("cart-order-detail-layout-full", {},
+        list_url=list_url, detail_url=detail_url,
+        order_label=f"Order {order.id}",
+    )
+    return await full_page_sx(ctx, header_rows=header_rows, filter=filt, content=main)
+
+
+async def render_order_oob(ctx, order, calendar_entries, url_for_fn):
+    from shared.sx.helpers import sx_call, render_to_sx_with_env, oob_page_sx
+    from shared.utils import route_prefix
+    from shared.browser.app.csrf import generate_csrf_token
+    pfx = route_prefix()
+    detail_url = pfx + url_for_fn("orders.order.order_detail", order_id=order.id)
+    list_url = pfx + url_for_fn("orders.list_orders")
+    recheck_url = pfx + url_for_fn("orders.order.order_recheck", order_id=order.id)
+    pay_url = pfx + url_for_fn("orders.order.order_pay", order_id=order.id)
+    order_data = _serialize_order(order)
+    cal_data = [_serialize_calendar_entry(e) for e in (calendar_entries or [])]
+    main = sx_call("order-detail-content", order=order_data, calendar_entries=cal_data)
+    filt = sx_call("order-detail-filter-content", order=order_data,
+        list_url=list_url, recheck_url=recheck_url, pay_url=pay_url, csrf=generate_csrf_token())
+    oobs = await render_to_sx_with_env("cart-order-detail-layout-oob", {},
+        detail_url=detail_url,
+        order_label=f"Order {order.id}",
+    )
+    return await oob_page_sx(oobs=oobs, filter=filt, content=main)
+
+
+async def render_checkout_error_page(ctx, error=None, order=None):
+    from shared.sx.helpers import sx_call, render_to_sx_with_env, full_page_sx
+    from shared.infrastructure.urls import cart_url
+    err_msg = error or "Unexpected error while creating the hosted checkout session."
+    order_sx = sx_call("checkout-error-order-id", oid=f"#{order.id}") if order else None
+    hdr = await render_to_sx_with_env("layout-root-full", {})
+    filt = sx_call("checkout-error-header")
+    content = sx_call("checkout-error-content", msg=err_msg,
+        order=SxExpr(order_sx) if order_sx else None, back_url=cart_url("/"))
+    return await full_page_sx(ctx, header_rows=hdr, filter=filt, content=content)
+
+
+def render_cart_payments_panel(ctx):
+    from shared.sx.helpers import sx_call
+    page_config = ctx.get("page_config")
+    pc_data = None
+    if page_config:
+        pc_data = {
+            "sumup_api_key": bool(getattr(page_config, "sumup_api_key", None)),
+            "sumup_merchant_code": getattr(page_config, "sumup_merchant_code", None) or "",
+            "sumup_checkout_prefix": getattr(page_config, "sumup_checkout_prefix", None) or "",
+        }
+    return sx_call("cart-payments-content", page_config=pc_data)
--- a/cart/sxc/pages/utils.py
+++ b/cart/sxc/pages/utils.py
@@ -0,0 +1,40 @@
+"""Cart page utilities — serializers and formatters."""
+from __future__ import annotations
+
+from typing import Any
+
+
+def _serialize_order(order: Any) -> dict:
+    from shared.infrastructure.urls import market_product_url
+    created = order.created_at.strftime("%-d %b %Y, %H:%M") if order.created_at else "\u2014"
+    items = []
+    if order.items:
+        for item in order.items:
+            items.append({
+                "product_image": item.product_image,
+                "product_title": item.product_title or "Unknown product",
+                "product_id": item.product_id,
+                "product_slug": item.product_slug,
+                "product_url": market_product_url(item.product_slug),
+                "quantity": item.quantity,
+                "unit_price_formatted": f"{item.unit_price or 0:.2f}",
+                "currency": item.currency or order.currency or "GBP",
+            })
+    return {
+        "id": order.id,
+        "status": order.status or "pending",
+        "created_at_formatted": created,
+        "description": order.description or "",
+        "total_formatted": f"{order.total_amount or 0:.2f}",
+        "total_amount": float(order.total_amount or 0),
+        "currency": order.currency or "GBP",
+        "items": items,
+    }
+
+
+def _serialize_calendar_entry(e: Any) -> dict:
+    st = e.state or ""
+    ds = e.start_at.strftime("%-d %b %Y, %H:%M") if e.start_at else ""
+    if e.end_at:
+        ds += f" \u2013 {e.end_at.strftime('%-d %b %Y, %H:%M')}"
+    return {"name": e.name, "state": st, "date_str": ds, "cost_formatted": f"{e.cost or 0:.2f}"}
--- a/docker-compose.dev.yml
+++ b/docker-compose.dev.yml
@@ -46,6 +46,7 @@ services:
      - ./blog/alembic:/app/blog/alembic:ro
      - ./blog/app.py:/app/app.py
      - ./blog/sx:/app/sx
+      - ./blog/sxc:/app/sxc
      - ./blog/bp:/app/bp
      - ./blog/services:/app/services
      - ./blog/templates:/app/templates
@@ -84,6 +85,7 @@ services:
      - ./market/alembic:/app/market/alembic:ro
      - ./market/app.py:/app/app.py
      - ./market/sx:/app/sx
+      - ./market/sxc:/app/sxc
      - ./market/bp:/app/bp
      - ./market/services:/app/services
      - ./market/templates:/app/templates
@@ -121,6 +123,7 @@ services:
      - ./cart/alembic:/app/cart/alembic:ro
      - ./cart/app.py:/app/app.py
      - ./cart/sx:/app/sx
+      - ./cart/sxc:/app/sxc
      - ./cart/bp:/app/bp
      - ./cart/services:/app/services
      - ./cart/templates:/app/templates
@@ -158,6 +161,7 @@ services:
      - ./events/alembic:/app/events/alembic:ro
      - ./events/app.py:/app/app.py
      - ./events/sx:/app/sx
+      - ./events/sxc:/app/sxc
      - ./events/bp:/app/bp
      - ./events/services:/app/services
      - ./events/templates:/app/templates
@@ -195,6 +199,7 @@ services:
      - ./federation/alembic:/app/federation/alembic:ro
      - ./federation/app.py:/app/app.py
      - ./federation/sx:/app/sx
+      - ./federation/sxc:/app/sxc
      - ./federation/bp:/app/bp
      - ./federation/services:/app/services
      - ./federation/templates:/app/templates
@@ -232,6 +237,7 @@ services:
      - ./account/alembic:/app/account/alembic:ro
      - ./account/app.py:/app/app.py
      - ./account/sx:/app/sx
+      - ./account/sxc:/app/sxc
      - ./account/bp:/app/bp
      - ./account/services:/app/services
      - ./account/templates:/app/templates
@@ -331,6 +337,7 @@ services:
      - ./orders/alembic:/app/orders/alembic:ro
      - ./orders/app.py:/app/app.py
      - ./orders/sx:/app/sx
+      - ./orders/sxc:/app/sxc
      - ./orders/bp:/app/bp
      - ./orders/services:/app/services
      - ./orders/templates:/app/templates
@@ -392,6 +399,7 @@ services:
      - ./sx/bp:/app/bp
      - ./sx/services:/app/services
      - ./sx/content:/app/content
+      - ./sx/sx:/app/sx
      - ./sx/path_setup.py:/app/path_setup.py
      - ./sx/entrypoint.sh:/usr/local/bin/entrypoint.sh
      - ./sx/__init__.py:/app/__init__.py:ro
--- a/docs/cssx.md
+++ b/docs/cssx.md
@@ -105,9 +105,458 @@ Call `load_css_registry()` in `setup_sx_bridge()` after loading components.
 5. Inspect `<style id="sx-css">` — should grow as new pages introduce new classes
 6. Check non-sx pages still render correctly (full CSS dump fallback)

-## Phase 2 (Future)
+## Phase 2: S-Expression Styles — Native SX Style Primitives

- **Component-level pre-computation:** Pre-scan classes per component at registration time
- **Own rule generator:** Replace tw.css parsing with a Python rule engine (no Tailwind dependency at all)
- **Header compression:** Use bitfield or hash instead of full class list
- **Critical CSS:** Only inline above-fold CSS, lazy-load rest
+### Context
+
+SX eliminated the HTML/JS divide — code is data is DOM. But one foreign language remains: CSS. Components are full of `:class "flex gap-4 items-center p-2 bg-sky-100 rounded"` — opaque strings from a separate language (Tailwind) that requires a separate build step (Tailwind v3 CLI), a separate parser (css_registry.py parsing tw.css), and a separate delivery mechanism (hash-based dedup).
+
+**Goal:** Make styles first-class SX expressions. `(css :flex :gap-4 :items-center :p-2 :bg-sky-100 :rounded)` replaces `"flex gap-4 items-center p-2 bg-sky-100 rounded"`. Same mental model as Tailwind — atomic utility keywords — but native to the language. No build step. No external CSS framework. Code = data = DOM = styles.
+
+### Surface Syntax
+
+```lisp
+;; Before (Tailwind class strings)
+(div :class "flex gap-4 items-center p-2 bg-sky-100 rounded" ...)
+
+;; After (SX style expressions)
+(div :style (css :flex :gap-4 :items-center :p-2 :bg-sky-100 :rounded) ...)
+
+;; Responsive + pseudo-classes (variant:atom, parsed as single keyword)
+(div :style (css :flex :gap-2 :sm:gap-4 :sm:flex-row :hover:bg-sky-200) ...)
+
+;; Named styles
+(defstyle card-base (css :rounded-xl :bg-white :shadow :hover:shadow-md :transition))
+(div :style card-base ...)
+
+;; Composition
+(div :style (merge-styles card-base (css :p-4 :border :border-stone-200)) ...)
+
+;; Conditional
+(div :style (if active (css :bg-sky-500 :text-white) (css :bg-stone-100)) ...)
+
+;; Both :class and :style coexist during migration
+(div :class "prose" :style (css :p-4 :max-w-3xl) ...)
+```
+
+**Why `(css :flex :gap-4)` not `(flex :gap 4)` or `(style :display :flex :gap "1rem")`?**
+- Keywords mirror Tailwind class names 1:1 — migration is mechanical search-replace
+- Single `css` primitive, no namespace pollution (hundreds of functions like `flex`, `p`, `bg`)
+- Parser already handles `:hover:bg-sky-200` as one keyword (regex `:[a-zA-Z_][a-zA-Z0-9_>:-]*`)
+
+### Architecture
+
+#### Three layers
+
+1. **Style Dictionary** (`style_dict.py`) — maps keyword atoms to CSS declarations. Pure data. Replaces tw.css.
+2. **Style Resolver** (`style_resolver.py`) — `(css :flex :gap-4)` → `StyleValue(class_name="sx-a3f2c1", declarations="display:flex;gap:1rem")`. Memoized.
+3. **Style Registry** — generated CSS rules registered into the existing `css_registry.py` delivery system. Same hash-based dedup, same `<style data-sx-css>`, same `SX-Css` header.
+
+#### Output: generated classes (not inline styles)
+
+Inline `style="..."` can't express `:hover`, `:focus`, `@media` breakpoints, or combinators. Generated classes preserve all Tailwind functionality. The `css` primitive produces a `StyleValue` with a content-addressed class name. The renderer emits `class="sx-a3f2c1"` and registers the CSS rule for on-demand delivery.
+
+### @ Rules (Animations, Keyframes, Containers)
+
+`@media` breakpoints are handled via responsive variants (`:sm:flex-row`), but CSS has other @ rules that need first-class support:
+
+#### `@keyframes` — via `defkeyframes`
+
+```lisp
+;; Define a keyframes animation
+(defkeyframes fade-in
+  (from (css :opacity-0))
+  (to (css :opacity-100)))
+
+(defkeyframes slide-up
+  ("0%" (css :translate-y-4 :opacity-0))
+  ("100%" (css :translate-y-0 :opacity-100)))
+
+;; Use it — animate-[name] atom references the keyframes
+(div :style (css :animate-fade-in :duration-300) ...)
+```
+
+**Implementation:** `defkeyframes` is a special form that:
+1. Evaluates each step's `(css ...)` body to get declarations
+2. Builds a `@keyframes fade-in { from { opacity:0 } to { opacity:1 } }` rule
+3. Registers the `@keyframes` rule in `css_registry.py` via `register_generated_rule()`
+4. Binds the name so `animate-fade-in` can reference it
+
+**Built-in animations** in `style_dict.py`:
+```python
+# Keyframes registered at dictionary load time
+KEYFRAMES: dict[str, str] = {
+    "spin": "@keyframes spin{to{transform:rotate(360deg)}}",
+    "ping": "@keyframes ping{75%,100%{transform:scale(2);opacity:0}}",
+    "pulse": "@keyframes pulse{50%{opacity:.5}}",
+    "bounce": "@keyframes bounce{0%,100%{transform:translateY(-25%);animation-timing-function:cubic-bezier(0.8,0,1,1)}50%{transform:none;animation-timing-function:cubic-bezier(0,0,0.2,1)}}",
+}
+
+# Animation atoms reference keyframes by name
+STYLE_ATOMS |= {
+    "animate-spin": "animation:spin 1s linear infinite",
+    "animate-ping": "animation:ping 1s cubic-bezier(0,0,0.2,1) infinite",
+    "animate-pulse": "animation:pulse 2s cubic-bezier(0.4,0,0.6,1) infinite",
+    "animate-bounce": "animation:bounce 1s infinite",
+    "animate-none": "animation:none",
+    "duration-75": "animation-duration:75ms",
+    "duration-100": "animation-duration:100ms",
+    "duration-150": "animation-duration:150ms",
+    "duration-200": "animation-duration:200ms",
+    "duration-300": "animation-duration:300ms",
+    "duration-500": "animation-duration:500ms",
+    "duration-700": "animation-duration:700ms",
+    "duration-1000": "animation-duration:1000ms",
+}
+```
+
+When the resolver encounters `animate-spin`, it emits both the class rule AND ensures the `@keyframes spin` rule is registered. The `@keyframes` rules flow through the same `_REGISTRY` → `lookup_rules()` → `SX-Css` delta pipeline.
+
+#### `@container` queries
+
+```lisp
+;; Container context
+(div :style (css :container :container-name-sidebar) ...)
+
+;; Container query variant (like responsive but scoped to container)
+(div :style (css :flex-col :@sm/sidebar:flex-row) ...)
+```
+
+Variant prefix `@sm/sidebar` → `@container sidebar (min-width: 640px)`. Parsed the same way as responsive variants but emits `@container` instead of `@media`.
+
+#### `@font-face`
+
+Not needed as atoms — font loading stays in `basics.css` or a dedicated `(load-font ...)` primitive. Fonts are infrastructure, not component styles.
+
+### Dynamic Class Generation
+
+#### Static atoms (common case)
+
+```lisp
+(css :flex :gap-4 :bg-sky-100)
+```
+
+All atoms are keywords known at parse time. Server and client both resolve from the dictionary. No issues.
+
+#### Dynamic atoms (runtime-computed)
+
+```lisp
+;; Color from data
+(let ((color (get item "color")))
+  (div :style (css :p-4 :rounded (str "bg-" color "-100")) ...))
+
+;; Numeric from computation
+(div :style (css :flex (str "gap-" (if compact "1" "4"))) ...)
+```
+
+The `css` primitive accepts both keywords and strings. When it receives a string like `"bg-sky-100"`, it looks it up in `STYLE_ATOMS` the same way. This works on both server and client because both have the full dictionary in memory.
+
+**No server round-trip needed** — the client has the complete style dictionary cached in localStorage. Dynamic atom lookup is a local hash table read, same as static atoms.
+
+#### Arbitrary values (escape hatch)
+
+For values not in the dictionary — truly custom measurements, colors, etc.:
+
+```lisp
+;; Arbitrary value syntax (mirrors Tailwind's bracket notation)
+(css :w-[347px] :h-[calc(100vh-4rem)] :bg-[#ff6b35])
+```
+
+**Pattern-based generator** in the resolver (both server and client):
+```python
+ARBITRARY_PATTERNS: list[tuple[re.Pattern, Callable]] = [
+    # w-[value] → width:value
+    (re.compile(r"w-\[(.+)\]"), lambda v: f"width:{v}"),
+    # h-[value] → height:value
+    (re.compile(r"h-\[(.+)\]"), lambda v: f"height:{v}"),
+    # bg-\[value] → background-color:value
+    (re.compile(r"bg-\[(.+)\]"), lambda v: f"background-color:{v}"),
+    # p-[value] → padding:value
+    (re.compile(r"p-\[(.+)\]"), lambda v: f"padding:{v}"),
+    # text-[value] → font-size:value
+    (re.compile(r"text-\[(.+)\]"), lambda v: f"font-size:{v}"),
+    # top/right/bottom/left-[value]
+    (re.compile(r"(top|right|bottom|left)-\[(.+)\]"), lambda d, v: f"{d}:{v}"),
+    # grid-cols-[value] → grid-template-columns:value
+    (re.compile(r"grid-cols-\[(.+)\]"), lambda v: f"grid-template-columns:{v}"),
+    # min/max-w/h-[value]
+    (re.compile(r"(min|max)-(w|h)-\[(.+)\]"),
+     lambda mm, dim, v: f"{'width' if dim=='w' else 'height'}:{v}" if mm=='max' else f"min-{'width' if dim=='w' else 'height'}:{v}"),
+]
+```
+
+Resolution order: dictionary lookup → pattern match → error (unknown atom).
+
+The generator runs client-side too (it's just regex + string formatting), so arbitrary values never cause a server round-trip. The generated class and CSS rule are injected into `<style id="sx-css">` on the client, same as dictionary-resolved atoms.
+
+#### Fully dynamic (data-driven colors/sizes)
+
+For cases where the CSS property and value are both runtime data (e.g., user-chosen brand colors stored in the database):
+
+```lisp
+;; Inline style fallback — when value is truly unknown
+(div :style (str "background-color:" brand-color) ...)
+
+;; Or a raw-css escape hatch
+(div :style (raw-css "background-color" brand-color) ...)
+```
+
+These emit inline `style="..."` attributes, bypassing the class generation system. This is correct — these values are unique per-entity, so generating a class would be wasteful (class never reused). Inline styles are the right tool for truly unique values.
+
+### Style Delivery & Caching
+
+#### Current system (CSS classes)
+
+1. **Full page load**: Server scans rendered SX for class names → `lookup_rules()` gets CSS for those classes → embeds in `<style id="sx-css">` + stores hash in `<meta name="sx-css-classes">`
+2. **Subsequent SX requests**: Client sends `SX-Css: {8-char-hash}` header → server resolves hash to known class set → computes delta (new classes only) → sends `<style data-sx-css>{new rules}</style>` inline in response + `SX-Css-Hash` response header with updated cumulative hash
+3. **Client accumulates**: `sx.js` extracts `<style data-sx-css>` blocks, appends rules to `<style id="sx-css">`, updates its `_sxCssHash`
+
+#### Current system (components)
+
+- Components cached in **localStorage** by content hash
+- Server checks `sx-comp-hash` cookie → if client has current hash, omits component source from response body
+- Client loads from localStorage on cache hit, downloads on miss
+
+#### New system (SX styles) — same pattern as components
+
+**Key insight**: The style dictionary (`STYLE_ATOMS`) is a fixed dataset, like component definitions. It changes only on deployment, not per-request. Cache it in localStorage like components, not per-request like CSS class deltas.
+
+**Server side:**
+- At startup, hash the full style dictionary → `sx-style-dict-hash`
+- Check `sx-style-hash` cookie on each request
+- If client has current hash: omit dictionary from response
+- If client is stale/missing: include `<script type="text/sx-styles" data-hash="{hash}">{serialized dict}</script>` in full-page response
+- Generated CSS rules (from `(css ...)` evaluation) are tracked the same way current CSS classes are — server sends only new rules client doesn't have
+
+**Client side (`sx.js`):**
+- On full page load: check `<script type="text/sx-styles" data-hash="{hash}">`
+- If hash matches localStorage `sx-styles-hash`: load from localStorage (skip download)
+- If hash differs or no cache: parse inline dict, store in localStorage, set cookie
+- Style dictionary lives in memory as a JS object for `css` primitive lookups
+- Generated CSS rules injected into `<style id="sx-css">` (same as current system)
+
+**Per-request style delivery** (for SX responses after initial page):
+- `(css ...)` produces `StyleValue` on server → renderer emits `class="sx-a3f2c1"`
+- Server registers generated rule in `_REGISTRY` → `lookup_rules()` picks it up
+- Existing `SX-Css` hash mechanism sends only new CSS rules to client
+- No change needed to the delta delivery pipeline — generated class names flow through `lookup_rules()` exactly like Tailwind class names do today
+
+**Server-side session tracking** (optimization):
+- Server maintains `dict[client_id, set[str]]` mapping client IDs to known style rule hashes
+- Client ID = session cookie or device ID (already exists in rose-ash auth system)
+- On each response, server records which style rules were sent to this client
+- On subsequent requests, server checks its record before computing delta
+- Falls back to hash-based negotiation if server-side record is missing (restart, eviction)
+- This avoids the round-trip cost of the client needing to tell the server what it knows — the server already knows
+
+**Data transfer optimization:**
+- Style dictionary: ~15-20KB serialized, sent once, cached in localStorage indefinitely (until hash changes on deploy)
+- Per-request: only delta CSS rules (typically 0-500 bytes for navigation to a new page type)
+- Preamble (resets, FontAwesome, basics.css): sent once on full page load, same as today
+- Total initial download actually decreases: style dict (~20KB) < tw.css sent as rules (~40KB+ for pages using many classes)
+
+### Implementation Phases
+
+#### Phase 2.0: Style Dictionary
+
+**New file: `shared/sx/style_dict.py`**
+
+Pure data mapping ~500 keyword atoms (the ones actually used across the codebase) to CSS declarations:
+
+```python
+STYLE_ATOMS: dict[str, str] = {
+    "flex": "display:flex",
+    "hidden": "display:none",
+    "block": "display:block",
+    "flex-col": "flex-direction:column",
+    "flex-row": "flex-direction:row",
+    "items-center": "align-items:center",
+    "justify-between": "justify-content:space-between",
+    "gap-1": "gap:0.25rem",
+    "gap-2": "gap:0.5rem",
+    "gap-4": "gap:1rem",
+    "p-2": "padding:0.5rem",
+    "px-4": "padding-left:1rem;padding-right:1rem",
+    "bg-sky-100": "background-color:rgb(224 242 254)",
+    "rounded": "border-radius:0.25rem",
+    "rounded-xl": "border-radius:0.75rem",
+    "text-sm": "font-size:0.875rem;line-height:1.25rem",
+    "font-semibold": "font-weight:600",
+    "shadow": "box-shadow:0 1px 3px 0 rgb(0 0 0/0.1),0 1px 2px -1px rgb(0 0 0/0.1)",
+    "transition": "transition-property:color,background-color,border-color,text-decoration-color,fill,stroke,opacity,box-shadow,transform,filter,backdrop-filter;transition-timing-function:cubic-bezier(0.4,0,0.2,1);transition-duration:150ms",
+    # ... ~500 entries total
+}
+
+PSEUDO_VARIANTS: dict[str, str] = {
+    "hover": ":hover", "focus": ":focus", "active": ":active",
+    "disabled": ":disabled", "first": ":first-child", "last": ":last-child",
+    "group-hover": ":is(.group:hover) &",
+}
+
+RESPONSIVE_BREAKPOINTS: dict[str, str] = {
+    "sm": "(min-width:640px)", "md": "(min-width:768px)",
+    "lg": "(min-width:1024px)", "xl": "(min-width:1280px)",
+}
+
+KEYFRAMES: dict[str, str] = {
+    "spin": "@keyframes spin{to{transform:rotate(360deg)}}",
+    "ping": "@keyframes ping{75%,100%{transform:scale(2);opacity:0}}",
+    "pulse": "@keyframes pulse{50%{opacity:.5}}",
+    "bounce": "@keyframes bounce{0%,100%{transform:translateY(-25%);animation-timing-function:cubic-bezier(0.8,0,1,1)}50%{transform:none;animation-timing-function:cubic-bezier(0,0,0.2,1)}}",
+}
+
+# Arbitrary value patterns — fallback when atom not in STYLE_ATOMS
+ARBITRARY_PATTERNS: list[tuple[str, str]] = [
+    # pattern → CSS template ({0} = captured value)
+    (r"w-\[(.+)\]", "width:{0}"),
+    (r"h-\[(.+)\]", "height:{0}"),
+    (r"bg-\[(.+)\]", "background-color:{0}"),
+    (r"p-\[(.+)\]", "padding:{0}"),
+    (r"m-\[(.+)\]", "margin:{0}"),
+    (r"text-\[(.+)\]", "font-size:{0}"),
+    (r"(top|right|bottom|left)-\[(.+)\]", "{0}:{1}"),
+    (r"(min|max)-(w|h)-\[(.+)\]", "{0}-{1}:{2}"),
+    (r"grid-cols-\[(.+)\]", "grid-template-columns:{0}"),
+    (r"gap-\[(.+)\]", "gap:{0}"),
+]
+```
+
+Generated by: scanning all `:class "..."` across 64 .sx files to find used atoms, then extracting their CSS from the existing tw.css via `css_registry.py`'s parsed `_REGISTRY`.
+
+#### Phase 2.1: StyleValue type + `css` primitive + resolver
+
+**Modify: `shared/sx/types.py`** — add StyleValue:
+```python
+@dataclass(frozen=True)
+class StyleValue:
+    class_name: str           # "sx-a3f2c1"
+    declarations: str         # "display:flex;gap:1rem"
+    media_rules: tuple = ()   # ((query, decls), ...)
+    pseudo_rules: tuple = ()  # ((selector, decls), ...)
+    keyframes: tuple = ()     # (("spin", "@keyframes spin{...}"), ...)
+    container_rules: tuple = ()  # (("sidebar (min-width:640px)", decls), ...)
+```
+
+**New file: `shared/sx/style_resolver.py`** — memoized resolver:
+- Takes tuple of atom strings (e.g., `("flex", "gap-4", "hover:bg-sky-200", "sm:flex-row")`)
+- Splits variant prefixes (`hover:bg-sky-200` → variant=`hover`, atom=`bg-sky-200`)
+- Looks up declarations in STYLE_ATOMS
+- Falls back to `ARBITRARY_PATTERNS` for bracket notation (`w-[347px]` → `width:347px`)
+- Detects `animate-*` atoms → includes associated `@keyframes` rules
+- Groups into base / pseudo / media / keyframes / container
+- Hashes declarations → deterministic class name `sx-{hash[:6]}`
+- Returns `StyleValue`
+- Dict cache keyed on input tuple
+- Accepts both keywords and runtime strings (for dynamic atom construction)
+
+**Modify: `shared/sx/primitives.py`** — add `css` and `merge-styles`:
+```python
+@register_primitive("css")
+def prim_css(*args):
+    from .style_resolver import resolve_style
+    return resolve_style(tuple(str(a) for a in args if a))
+
+@register_primitive("merge-styles")
+def prim_merge_styles(*styles):
+    from .style_resolver import merge_styles
+    return merge_styles([s for s in styles if isinstance(s, StyleValue)])
+```
+
+#### Phase 2.2: Server-side rendering + delivery integration
+
+**Modify: `shared/sx/html.py`** — in `_render_element()` (line ~482):
+- When `:style` evaluates to a `StyleValue`: emit its `class_name` as a CSS class (appended to any existing `:class`), register the rule with `register_generated_rule()`, don't emit `:style` attribute
+- When `:style` is a string: existing behavior (inline style attribute)
+
+**Modify: `shared/sx/async_eval.py`** — same change in `_arender_element()` (line ~641)
+
+**Modify: `shared/sx/css_registry.py`** — add `register_generated_rule(style_val)`:
+- Builds CSS rule: `.sx-a3f2c1{display:flex;gap:1rem}`
+- Plus pseudo rules: `.sx-a3f2c1:hover{background-color:...}`
+- Plus media rules: `@media(min-width:640px){.sx-a3f2c1{flex-direction:row}}`
+- Inserts into `_REGISTRY` so existing `lookup_rules()` works transparently
+- Generated rules flow through the same `SX-Css` hash delta mechanism — no new delivery protocol needed
+
+**Modify: `shared/sx/helpers.py`** — style dictionary delivery:
+- In `sx_page_shell()` (full page): include style dictionary as `<script type="text/sx-styles" data-hash="{hash}">` with localStorage caching (same pattern as component caching)
+- Check `sx-style-hash` cookie: if client has current hash, omit dictionary source
+- In `sx_response()` (SX fragment responses): no change — generated CSS rules already flow through `<style data-sx-css>`
+
+**Modify: `shared/infrastructure/factory.py`** — add `sx-style-hash` to allowed headers in CORS config
+
+#### Phase 2.3: Client-side (sx.js)
+
+**Modify: `shared/static/scripts/sx.js`**:
+- Add `StyleValue` type (`{_style: true, className, declarations, pseudoRules, mediaRules}`)
+- Add `css` primitive to PRIMITIVES (accepts both keywords and dynamic strings)
+- Add resolver logic (split variants, lookup from in-memory dict, arbitrary pattern fallback, hash, memoize)
+- In `renderElement()`: when `:style` value is StyleValue, add className to element and inject CSS rule into `<style id="sx-css">` (same target as server-sent rules)
+- Add `merge-styles` primitive
+- Add `defstyle` to SPECIAL_FORMS
+- Add style dictionary localStorage caching (same pattern as components):
+  - On init: check `<script type="text/sx-styles" data-hash="{hash}">`
+  - Cache hit (hash matches localStorage): load dict from localStorage, skip inline parse
+  - Cache miss: parse inline dict, store in localStorage, set `sx-style-hash` cookie
+  - Dict lives in `_styleAtoms` var for `css` primitive to look up at render time
+
+**No separate `sx-styles.js`** — the style dictionary is delivered inline in the full-page shell (like components) and cached in localStorage. No extra HTTP request.
+
+#### Phase 2.4: `defstyle` and `defkeyframes` special forms
+
+**Modify: `shared/sx/evaluator.py`** — add `defstyle` and `defkeyframes`:
+```lisp
+(defstyle card-base (css :rounded-xl :bg-white :shadow))
+
+(defkeyframes fade-in
+  (from (css :opacity-0))
+  (to (css :opacity-100)))
+```
+
+`defstyle`: evaluates the body → StyleValue, binds to name in env. Essentially `define` but semantically distinct for tooling.
+
+`defkeyframes`: evaluates each step's `(css ...)` body, builds a `@keyframes` CSS rule, registers it via `register_generated_rule()`, and binds the animation name so `animate-[name]` atoms can reference it.
+
+**Mirror in `shared/sx/async_eval.py`** and `sx.js`.
+
+#### Phase 2.5: Migration tooling + gradual conversion
+
+**New: `shared/sx/tools/class_to_css.py`** — converter script:
+- `:class "flex gap-4 p-2"` → `:style (css :flex :gap-4 :p-2)`
+- `(str "base " conditional)` → leave as `:class` or split into static `:style` + dynamic `:class`
+- `(if cond "classes-a" "classes-b")` → `(if cond (css :classes-a) (css :classes-b))`
+
+**Dynamic class construction** (2-3 occurrences in `layout.sx`):
+- `(str "bg-" c "-" shade)` → `(css (str "bg-" c "-" shade))` — `css` accepts runtime strings, resolves from dictionary client-side (no server round-trip)
+- Truly unique values (user brand colors from DB) → inline `style="..."` or `(raw-css "background-color" brand-color)`
+
+#### Phase 2.6: Remove Tailwind
+
+- Delete `tailwind.config.js`, remove tw.css build step
+- Remove tw.css parsing from `load_css_registry()`
+- Keep extra CSS (basics.css, cards.css, blog-content.css, FontAwesome)
+- `css_registry.py` becomes pure runtime registry for generated + extra CSS
+
+### Phase 2 Files
+
+| File | Change |
+|------|--------|
+| `shared/sx/style_dict.py` | **New** — keyword → CSS declaration mapping (~500 atoms) |
+| `shared/sx/style_resolver.py` | **New** — resolve (css ...) → StyleValue, memoized |
+| `shared/sx/types.py` | Add `StyleValue` dataclass |
+| `shared/sx/primitives.py` | Add `css`, `merge-styles` primitives |
+| `shared/sx/html.py` | Handle StyleValue in `:style` attribute rendering |
+| `shared/sx/async_eval.py` | Same StyleValue handling in async render path |
+| `shared/sx/css_registry.py` | Add `register_generated_rule()` |
+| `shared/sx/helpers.py` | Style dict delivery in page shell, cookie check, localStorage caching protocol |
+| `shared/sx/evaluator.py` | Add `defstyle` special form |
+| `shared/infrastructure/factory.py` | Add `sx-style-hash` cookie/header to CORS |
+| `shared/static/scripts/sx.js` | StyleValue, css/merge-styles, defstyle, dict caching, style injection |
+| `shared/sx/tools/class_to_css.py` | **New** — migration converter |
+
+### Phase 2 Verification
+
+- **Phase 2.1**: Unit test — `(css :flex :gap-4 :p-2)` returns correct StyleValue
+- **Phase 2.2**: Render test — `(div :style (css :flex :gap-4))` → `<div class="sx-a3f2c1">` + CSS rule registered
+- **Phase 2.3**: Browser test — client renders `:style (css ...)` with injected `<style>` rules
+- **Phase 2.5**: Convert one .sx file, diff HTML output to verify identical rendering
+- **Throughout**: existing `:class "..."` continues to work unchanged
--- a/events/actions.sx
+++ b/events/actions.sx
@@ -0,0 +1,65 @@
+;; Events service — inter-service action endpoints
+;;
+;; Each defaction replaces a Python handler in bp/actions/routes.py.
+;; The (service ...) primitive calls the registered CalendarService method
+;; with g.s (async session) + keyword args.
+
+(defaction adjust-ticket-quantity (&key entry-id count user-id session-id ticket-type-id)
+  "Add or remove tickets for a calendar entry."
+  (do
+    (service "calendar" "adjust-ticket-quantity"
+      :entry-id entry-id :count count
+      :user-id user-id :session-id session-id
+      :ticket-type-id ticket-type-id)
+    {"ok" true}))
+
+(defaction claim-entries-for-order (&key order-id user-id session-id page-post-id)
+  "Claim pending calendar entries for an order."
+  (do
+    (service "calendar" "claim-entries-for-order"
+      :order-id order-id :user-id user-id
+      :session-id session-id :page-post-id page-post-id)
+    {"ok" true}))
+
+(defaction claim-tickets-for-order (&key order-id user-id session-id page-post-id)
+  "Claim pending tickets for an order."
+  (do
+    (service "calendar" "claim-tickets-for-order"
+      :order-id order-id :user-id user-id
+      :session-id session-id :page-post-id page-post-id)
+    {"ok" true}))
+
+(defaction confirm-entries-for-order (&key order-id user-id session-id)
+  "Confirm calendar entries after payment."
+  (do
+    (service "calendar" "confirm-entries-for-order"
+      :order-id order-id :user-id user-id :session-id session-id)
+    {"ok" true}))
+
+(defaction confirm-tickets-for-order (&key order-id)
+  "Confirm tickets after payment."
+  (do
+    (service "calendar" "confirm-tickets-for-order" :order-id order-id)
+    {"ok" true}))
+
+(defaction toggle-entry-post (&key entry-id content-type content-id)
+  "Toggle association between a calendar entry and a content item."
+  (let ((is-associated (service "calendar" "toggle-entry-post"
+                         :entry-id entry-id
+                         :content-type content-type
+                         :content-id content-id)))
+    {"is_associated" is-associated}))
+
+(defaction adopt-entries-for-user (&key user-id session-id)
+  "Transfer anonymous calendar entries to a logged-in user."
+  (do
+    (service "calendar" "adopt-entries-for-user"
+      :user-id user-id :session-id session-id)
+    {"ok" true}))
+
+(defaction adopt-tickets-for-user (&key user-id session-id)
+  "Transfer anonymous tickets to a logged-in user."
+  (do
+    (service "calendar" "adopt-tickets-for-user"
+      :user-id user-id :session-id session-id)
+    {"ok" true}))
--- a/events/app.py
+++ b/events/app.py
@@ -1,7 +1,6 @@
 from __future__ import annotations

 import path_setup  # noqa: F401  # adds shared/ to sys.path
-import sx.sx_components as sx_components  # noqa: F401  # ensure Hypercorn --reload watches this file
 from pathlib import Path

 from quart import g, abort, request
--- a/events/bp/actions/routes.py
+++ b/events/bp/actions/routes.py
@@ -1,139 +1,15 @@
 """Events app action endpoints.

-Exposes write operations at ``/internal/actions/<action_name>`` for
-cross-app callers (cart, blog) via the internal action client.
+All actions are defined declaratively in ``events/actions.sx`` and
+dispatched via the sx query registry.  No Python fallbacks needed.
 """
 from __future__ import annotations

-from quart import Blueprint, g, jsonify, request
+from shared.infrastructure.query_blueprint import create_action_blueprint

-from shared.infrastructure.actions import ACTION_HEADER
-from shared.services.registry import services
+from quart import Blueprint


 def register() -> Blueprint:
-    bp = Blueprint("actions", __name__, url_prefix="/internal/actions")
-
-    @bp.before_request
-    async def _require_action_header():
-        if not request.headers.get(ACTION_HEADER):
-            return jsonify({"error": "forbidden"}), 403
-        from shared.infrastructure.internal_auth import validate_internal_request
-        if not validate_internal_request():
-            return jsonify({"error": "forbidden"}), 403
-
-    _handlers: dict[str, object] = {}
-
-    @bp.post("/<action_name>")
-    async def handle_action(action_name: str):
-        handler = _handlers.get(action_name)
-        if handler is None:
-            return jsonify({"error": "unknown action"}), 404
-        try:
-            result = await handler()
-            return jsonify(result)
-        except Exception as exc:
-            import logging
-            logging.getLogger(__name__).exception("Action %s failed", action_name)
-            return jsonify({"error": str(exc)}), 500
-
-    # --- adjust-ticket-quantity ---
-    async def _adjust_ticket_quantity():
-        data = await request.get_json()
-        await services.calendar.adjust_ticket_quantity(
-            g.s,
-            data["entry_id"],
-            data["count"],
-            user_id=data.get("user_id"),
-            session_id=data.get("session_id"),
-            ticket_type_id=data.get("ticket_type_id"),
-        )
-        return {"ok": True}
-
-    _handlers["adjust-ticket-quantity"] = _adjust_ticket_quantity
-
-    # --- claim-entries-for-order ---
-    async def _claim_entries():
-        data = await request.get_json()
-        await services.calendar.claim_entries_for_order(
-            g.s,
-            data["order_id"],
-            data.get("user_id"),
-            data.get("session_id"),
-            data.get("page_post_id"),
-        )
-        return {"ok": True}
-
-    _handlers["claim-entries-for-order"] = _claim_entries
-
-    # --- claim-tickets-for-order ---
-    async def _claim_tickets():
-        data = await request.get_json()
-        await services.calendar.claim_tickets_for_order(
-            g.s,
-            data["order_id"],
-            data.get("user_id"),
-            data.get("session_id"),
-            data.get("page_post_id"),
-        )
-        return {"ok": True}
-
-    _handlers["claim-tickets-for-order"] = _claim_tickets
-
-    # --- confirm-entries-for-order ---
-    async def _confirm_entries():
-        data = await request.get_json()
-        await services.calendar.confirm_entries_for_order(
-            g.s,
-            data["order_id"],
-            data.get("user_id"),
-            data.get("session_id"),
-        )
-        return {"ok": True}
-
-    _handlers["confirm-entries-for-order"] = _confirm_entries
-
-    # --- confirm-tickets-for-order ---
-    async def _confirm_tickets():
-        data = await request.get_json()
-        await services.calendar.confirm_tickets_for_order(
-            g.s, data["order_id"],
-        )
-        return {"ok": True}
-
-    _handlers["confirm-tickets-for-order"] = _confirm_tickets
-
-    # --- toggle-entry-post ---
-    async def _toggle_entry_post():
-        data = await request.get_json()
-        is_associated = await services.calendar.toggle_entry_post(
-            g.s,
-            data["entry_id"],
-            data["content_type"],
-            data["content_id"],
-        )
-        return {"is_associated": is_associated}
-
-    _handlers["toggle-entry-post"] = _toggle_entry_post
-
-    # --- adopt-entries-for-user ---
-    async def _adopt_entries():
-        data = await request.get_json()
-        await services.calendar.adopt_entries_for_user(
-            g.s, data["user_id"], data["session_id"],
-        )
-        return {"ok": True}
-
-    _handlers["adopt-entries-for-user"] = _adopt_entries
-
-    # --- adopt-tickets-for-user ---
-    async def _adopt_tickets():
-        data = await request.get_json()
-        await services.calendar.adopt_tickets_for_user(
-            g.s, data["user_id"], data["session_id"],
-        )
-        return {"ok": True}
-
-    _handlers["adopt-tickets-for-user"] = _adopt_tickets
-
+    bp, _handlers = create_action_blueprint("events")
    return bp
--- a/events/bp/all_events/routes.py
+++ b/events/bp/all_events/routes.py
@@ -67,7 +67,7 @@ def register() -> Blueprint:
        entries, has_more, pending_tickets, page_info = await _load_entries(page)

        from shared.sx.page import get_template_context
-        from sx.sx_components import render_all_events_page, render_all_events_oob
+        from sxc.pages.renders import render_all_events_page, render_all_events_oob

        ctx = await get_template_context()
        if is_htmx_request():
@@ -84,8 +84,8 @@ def register() -> Blueprint:

        entries, has_more, pending_tickets, page_info = await _load_entries(page)

-        from sx.sx_components import render_all_events_cards
-        sx_src = await render_all_events_cards(entries, has_more, pending_tickets, page_info, page, view)
+        from sxc.pages.renders import render_all_events_cards
+        sx_src = render_all_events_cards(entries, has_more, pending_tickets, page_info, page, view)
        return sx_response(sx_src)

    @bp.post("/all-tickets/adjust")
@@ -125,7 +125,7 @@ def register() -> Blueprint:
        if ident["session_id"] is not None:
            frag_params["session_id"] = ident["session_id"]

-        from sx.sx_components import render_ticket_widget
+        from sxc.pages.tickets import render_ticket_widget
        widget_html = render_ticket_widget(entry, qty, "/all-tickets/adjust")
        mini_html = await fetch_fragment("cart", "cart-mini", params=frag_params, required=False)
        return sx_response(widget_html + (mini_html or ""))
--- a/events/bp/calendar/admin/routes.py
+++ b/events/bp/calendar/admin/routes.py
@@ -18,7 +18,7 @@ def register():
    @bp.get("/description/")
    @require_admin
    async def calendar_description_edit(calendar_slug: str, **kwargs):
-        from sx.sx_components import render_calendar_description_edit
+        from sxc.pages.renders import render_calendar_description_edit
        html = render_calendar_description_edit(g.calendar)
        return sx_response(html)

@@ -34,7 +34,7 @@ def register():
        g.calendar.description = description
        await g.s.flush()

-        from sx.sx_components import render_calendar_description
+        from sxc.pages.renders import render_calendar_description
        html = render_calendar_description(g.calendar, oob=True)
        return sx_response(html)

@@ -42,7 +42,7 @@ def register():
    @bp.get("/description/view/")
    @require_admin
    async def calendar_description_view(calendar_slug: str, **kwargs):
-        from sx.sx_components import render_calendar_description
+        from sxc.pages.renders import render_calendar_description
        html = render_calendar_description(g.calendar)
        return sx_response(html)
    
--- a/events/bp/calendar/routes.py
+++ b/events/bp/calendar/routes.py
@@ -158,7 +158,7 @@ def register():
        confirmed_entries = visible.confirmed_entries

        from shared.sx.page import get_template_context
-        from sx.sx_components import render_calendar_page, render_calendar_oob
+        from sxc.pages.renders import render_calendar_page, render_calendar_oob

        tctx = await get_template_context()
        tctx.update(dict(
@@ -199,7 +199,7 @@ def register():

        await update_calendar_description(g.calendar, description)
        from shared.sx.page import get_template_context
-        from sx.sx_components import _calendar_admin_main_panel_html
+        from sxc.pages.calendar import _calendar_admin_main_panel_html
        ctx = await get_template_context()
        html = _calendar_admin_main_panel_html(ctx)
        return sx_response(html)
@@ -218,13 +218,13 @@ def register():
        # If we have post context (blog-embedded mode), update nav
        post_data = getattr(g, "post_data", None)
        from shared.sx.page import get_template_context
-        from sx.sx_components import render_calendars_list_panel
+        from sxc.pages.renders import render_calendars_list_panel
        ctx = await get_template_context()
        html = render_calendars_list_panel(ctx)

        if post_data:
            from shared.services.entry_associations import get_associated_entries
-            from sx.sx_components import render_post_nav_entries_oob
+            from sxc.pages.entries import render_post_nav_entries_oob

            post_id = (post_data.get("post") or {}).get("id")
            cals = (
--- a/events/bp/calendar_entries/routes.py
+++ b/events/bp/calendar_entries/routes.py
@@ -258,7 +258,7 @@ def register():
            "styles": styles,
        }

-        from sx.sx_components import render_day_main_panel
+        from sxc.pages.renders import render_day_main_panel
        html = render_day_main_panel(ctx)
        mini_html = await fetch_fragment("cart", "cart-mini", params=frag_params, required=False)
        return sx_response(html + (mini_html or ""))
@@ -279,12 +279,12 @@ def register():
        result = await g.s.execute(stmt)
        day_slots = list(result.scalars())

-        from sx.sx_components import render_entry_add_form
+        from sxc.pages.entries import render_entry_add_form
        return sx_response(render_entry_add_form(g.calendar, day, month, year, day_slots))

    @bp.get("/add-button/")
    async def add_button(day: int, month: int, year: int, **kwargs):
-        from sx.sx_components import render_entry_add_button
+        from sxc.pages.entries import render_entry_add_button
        return sx_response(render_entry_add_button(g.calendar, day, month, year))


--- a/events/bp/calendar_entry/routes.py
+++ b/events/bp/calendar_entry/routes.py
@@ -111,7 +111,7 @@ def register():
        )

        # Render OOB nav
-        from sx.sx_components import render_day_entries_nav_oob
+        from sxc.pages.entries import render_day_entries_nav_oob
        return render_day_entries_nav_oob(visible.confirmed_entries, calendar, day_date)

    async def get_post_nav_oob(entry_id: int):
@@ -148,7 +148,7 @@ def register():
            ).scalars().all()

            # Render OOB nav for this post
-            from sx.sx_components import render_post_nav_entries_oob
+            from sxc.pages.entries import render_post_nav_entries_oob
            nav_oob = render_post_nav_entries_oob(associated_entries, calendars, post)
            nav_oobs.append(nav_oob)

@@ -256,7 +256,7 @@ def register():
        result = await g.s.execute(stmt)
        day_slots = list(result.scalars())

-        from sx.sx_components import render_entry_edit_form
+        from sxc.pages.entries import render_entry_edit_form
        return sx_response(render_entry_edit_form(g.entry, g.calendar, day, month, year, day_slots))

    @bp.put("/")
@@ -420,7 +420,7 @@ def register():
        nav_oob = await get_day_nav_oob(year, month, day)

        from shared.sx.page import get_template_context
-        from sx.sx_components import _entry_main_panel_html
+        from sxc.pages.entries import _entry_main_panel_html

        tctx = await get_template_context()
        html = _entry_main_panel_html(tctx)
@@ -448,7 +448,7 @@ def register():

        # Re-read entry to get updated state
        await g.s.refresh(g.entry)
-        from sx.sx_components import render_entry_optioned
+        from sxc.pages.entries import render_entry_optioned
        html = render_entry_optioned(g.entry, g.calendar, day, month, year)
        return sx_response(html + day_nav_oob + post_nav_oob)

@@ -473,7 +473,7 @@ def register():

        # Re-read entry to get updated state
        await g.s.refresh(g.entry)
-        from sx.sx_components import render_entry_optioned
+        from sxc.pages.entries import render_entry_optioned
        html = render_entry_optioned(g.entry, g.calendar, day, month, year)
        return sx_response(html + day_nav_oob + post_nav_oob)

@@ -498,7 +498,7 @@ def register():

        # Re-read entry to get updated state
        await g.s.refresh(g.entry)
-        from sx.sx_components import render_entry_optioned
+        from sxc.pages.entries import render_entry_optioned
        html = render_entry_optioned(g.entry, g.calendar, day, month, year)
        return sx_response(html + day_nav_oob + post_nav_oob)

@@ -542,7 +542,7 @@ def register():

        # Return just the tickets fragment (targeted by hx-target="#entry-tickets-...")
        await g.s.refresh(g.entry)
-        from sx.sx_components import render_entry_tickets_config
+        from sxc.pages.entries import render_entry_tickets_config
        html = render_entry_tickets_config(g.entry, g.calendar, request.view_args.get("day"), request.view_args.get("month"), request.view_args.get("year"))
        return sx_response(html)

@@ -558,7 +558,7 @@ def register():
        total_pages = math.ceil(total / per_page) if total > 0 else 0

        va = request.view_args or {}
-        from sx.sx_components import render_post_search_results
+        from sxc.pages.entries import render_post_search_results
        return sx_response(render_post_search_results(
            search_posts, query, page, total_pages,
            g.entry, g.calendar,
@@ -592,7 +592,7 @@ def register():
        entry_posts = await get_entry_posts(g.s, entry_id)

        # Return updated posts list + OOB nav update
-        from sx.sx_components import render_entry_posts_panel, render_entry_posts_nav_oob
+        from sxc.pages.entries import render_entry_posts_panel, render_entry_posts_nav_oob
        va = request.view_args or {}
        html = render_entry_posts_panel(entry_posts, g.entry, g.calendar, va.get("day"), va.get("month"), va.get("year"))
        nav_oob = render_entry_posts_nav_oob(entry_posts)
@@ -614,7 +614,7 @@ def register():
        entry_posts = await get_entry_posts(g.s, entry_id)

        # Return updated posts list + OOB nav update
-        from sx.sx_components import render_entry_posts_panel, render_entry_posts_nav_oob
+        from sxc.pages.entries import render_entry_posts_panel, render_entry_posts_nav_oob
        va = request.view_args or {}
        html = render_entry_posts_panel(entry_posts, g.entry, g.calendar, va.get("day"), va.get("month"), va.get("year"))
        nav_oob = render_entry_posts_nav_oob(entry_posts)
--- a/events/bp/calendars/routes.py
+++ b/events/bp/calendars/routes.py
@@ -32,7 +32,7 @@ def register():
    @cache_page(tag="calendars")
    async def home(**kwargs):
        from shared.sx.page import get_template_context
-        from sx.sx_components import render_calendars_page, render_calendars_oob
+        from sxc.pages.renders import render_calendars_page, render_calendars_oob

        ctx = await get_template_context()
        if not is_htmx_request():
@@ -67,14 +67,14 @@ def register():
            return await make_response(render_comp("error-inline", message=str(e)), 422)

        from shared.sx.page import get_template_context
-        from sx.sx_components import render_calendars_list_panel
+        from sxc.pages.renders import render_calendars_list_panel
        ctx = await get_template_context()
        html = render_calendars_list_panel(ctx)

        # Blog-embedded mode: also update post nav
        if post_data:
            from shared.services.entry_associations import get_associated_entries
-            from sx.sx_components import render_post_nav_entries_oob
+            from sxc.pages.entries import render_post_nav_entries_oob

            cals = (
                await g.s.execute(
--- a/events/bp/data/routes.py
+++ b/events/bp/data/routes.py
@@ -1,148 +1,14 @@
 """Events app data endpoints.

-Exposes read-only JSON queries at ``/internal/data/<query_name>`` for
-cross-app callers via the internal data client.
+All queries are defined in ``events/queries.sx``.
 """
 from __future__ import annotations

-from quart import Blueprint, g, jsonify, request
+from quart import Blueprint

-from shared.infrastructure.data_client import DATA_HEADER
-from shared.contracts.dtos import dto_to_dict
-from shared.services.registry import services
+from shared.infrastructure.query_blueprint import create_data_blueprint


 def register() -> Blueprint:
-    bp = Blueprint("data", __name__, url_prefix="/internal/data")
-
-    @bp.before_request
-    async def _require_data_header():
-        if not request.headers.get(DATA_HEADER):
-            return jsonify({"error": "forbidden"}), 403
-        from shared.infrastructure.internal_auth import validate_internal_request
-        if not validate_internal_request():
-            return jsonify({"error": "forbidden"}), 403
-
-    _handlers: dict[str, object] = {}
-
-    @bp.get("/<query_name>")
-    async def handle_query(query_name: str):
-        handler = _handlers.get(query_name)
-        if handler is None:
-            return jsonify({"error": "unknown query"}), 404
-        result = await handler()
-        return jsonify(result)
-
-    # --- pending-entries ---
-    async def _pending_entries():
-        user_id = request.args.get("user_id", type=int)
-        session_id = request.args.get("session_id")
-        entries = await services.calendar.pending_entries(
-            g.s, user_id=user_id, session_id=session_id,
-        )
-        return [dto_to_dict(e) for e in entries]
-
-    _handlers["pending-entries"] = _pending_entries
-
-    # --- pending-tickets ---
-    async def _pending_tickets():
-        user_id = request.args.get("user_id", type=int)
-        session_id = request.args.get("session_id")
-        tickets = await services.calendar.pending_tickets(
-            g.s, user_id=user_id, session_id=session_id,
-        )
-        return [dto_to_dict(t) for t in tickets]
-
-    _handlers["pending-tickets"] = _pending_tickets
-
-    # --- entries-for-page ---
-    async def _entries_for_page():
-        page_id = request.args.get("page_id", type=int)
-        user_id = request.args.get("user_id", type=int)
-        session_id = request.args.get("session_id")
-        entries = await services.calendar.entries_for_page(
-            g.s, page_id, user_id=user_id, session_id=session_id,
-        )
-        return [dto_to_dict(e) for e in entries]
-
-    _handlers["entries-for-page"] = _entries_for_page
-
-    # --- tickets-for-page ---
-    async def _tickets_for_page():
-        page_id = request.args.get("page_id", type=int)
-        user_id = request.args.get("user_id", type=int)
-        session_id = request.args.get("session_id")
-        tickets = await services.calendar.tickets_for_page(
-            g.s, page_id, user_id=user_id, session_id=session_id,
-        )
-        return [dto_to_dict(t) for t in tickets]
-
-    _handlers["tickets-for-page"] = _tickets_for_page
-
-    # --- entries-for-order ---
-    async def _entries_for_order():
-        order_id = request.args.get("order_id", type=int)
-        entries = await services.calendar.get_entries_for_order(g.s, order_id)
-        return [dto_to_dict(e) for e in entries]
-
-    _handlers["entries-for-order"] = _entries_for_order
-
-    # --- tickets-for-order ---
-    async def _tickets_for_order():
-        order_id = request.args.get("order_id", type=int)
-        tickets = await services.calendar.get_tickets_for_order(g.s, order_id)
-        return [dto_to_dict(t) for t in tickets]
-
-    _handlers["tickets-for-order"] = _tickets_for_order
-
-    # --- entry-ids-for-content ---
-    async def _entry_ids_for_content():
-        content_type = request.args.get("content_type", "")
-        content_id = request.args.get("content_id", type=int)
-        ids = await services.calendar.entry_ids_for_content(g.s, content_type, content_id)
-        return list(ids)
-
-    _handlers["entry-ids-for-content"] = _entry_ids_for_content
-
-    # --- associated-entries ---
-    async def _associated_entries():
-        content_type = request.args.get("content_type", "")
-        content_id = request.args.get("content_id", type=int)
-        page = request.args.get("page", 1, type=int)
-        entries, has_more = await services.calendar.associated_entries(
-            g.s, content_type, content_id, page,
-        )
-        return {"entries": [dto_to_dict(e) for e in entries], "has_more": has_more}
-
-    _handlers["associated-entries"] = _associated_entries
-
-    # --- calendars-for-container ---
-    async def _calendars_for_container():
-        container_type = request.args.get("type", "")
-        container_id = request.args.get("id", type=int)
-        calendars = await services.calendar.calendars_for_container(
-            g.s, container_type, container_id,
-        )
-        return [dto_to_dict(c) for c in calendars]
-
-    _handlers["calendars-for-container"] = _calendars_for_container
-
-    # --- visible-entries-for-period ---
-    async def _visible_entries_for_period():
-        from datetime import datetime
-        calendar_id = request.args.get("calendar_id", type=int)
-        period_start = datetime.fromisoformat(request.args.get("period_start", ""))
-        period_end = datetime.fromisoformat(request.args.get("period_end", ""))
-        user_id = request.args.get("user_id", type=int)
-        session_id = request.args.get("session_id")
-        # is_admin determined server-side, never from client params
-        is_admin = False
-        entries = await services.calendar.visible_entries_for_period(
-            g.s, calendar_id, period_start, period_end,
-            user_id=user_id, is_admin=is_admin, session_id=session_id,
-        )
-        return [dto_to_dict(e) for e in entries]
-
-    _handlers["visible-entries-for-period"] = _visible_entries_for_period
-
+    bp, _handlers = create_data_blueprint("events")
    return bp
--- a/events/bp/day/routes.py
+++ b/events/bp/day/routes.py
@@ -123,7 +123,7 @@ def register():
            - pending only for current user/session
        """
        from shared.sx.page import get_template_context
-        from sx.sx_components import render_day_page, render_day_oob
+        from sxc.pages.renders import render_day_page, render_day_oob

        tctx = await get_template_context()
        if not is_htmx_request():
--- a/events/bp/markets/routes.py
+++ b/events/bp/markets/routes.py
@@ -42,7 +42,7 @@ def register():
            return await make_response(render_comp("error-inline", message=str(e)), 422)

        from shared.sx.page import get_template_context
-        from sx.sx_components import render_markets_list_panel
+        from sxc.pages.renders import render_markets_list_panel
        ctx = await get_template_context()
        return sx_response(render_markets_list_panel(ctx))

@@ -55,7 +55,7 @@ def register():
            return await make_response("Market not found", 404)

        from shared.sx.page import get_template_context
-        from sx.sx_components import render_markets_list_panel
+        from sxc.pages.renders import render_markets_list_panel
        ctx = await get_template_context()
        return sx_response(render_markets_list_panel(ctx))

--- a/events/bp/page/routes.py
+++ b/events/bp/page/routes.py
@@ -47,7 +47,7 @@ def register() -> Blueprint:
        entries, has_more, pending_tickets = await _load_entries(post["id"], page)

        from shared.sx.page import get_template_context
-        from sx.sx_components import render_page_summary_page, render_page_summary_oob
+        from sxc.pages.renders import render_page_summary_page, render_page_summary_oob

        ctx = await get_template_context()
        if is_htmx_request():
@@ -65,8 +65,8 @@ def register() -> Blueprint:

        entries, has_more, pending_tickets = await _load_entries(post["id"], page)

-        from sx.sx_components import render_page_summary_cards
-        sx_src = await render_page_summary_cards(entries, has_more, pending_tickets, {}, page, view, post)
+        from sxc.pages.renders import render_page_summary_cards
+        sx_src = render_page_summary_cards(entries, has_more, pending_tickets, {}, page, view, post)
        return sx_response(sx_src)

    @bp.post("/tickets/adjust")
@@ -106,7 +106,7 @@ def register() -> Blueprint:
        if ident["session_id"] is not None:
            frag_params["session_id"] = ident["session_id"]

-        from sx.sx_components import render_ticket_widget
+        from sxc.pages.tickets import render_ticket_widget
        widget_html = render_ticket_widget(entry, qty, f"/{g.post_slug}/tickets/adjust")
        mini_html = await fetch_fragment("cart", "cart-mini", params=frag_params, required=False)
        return sx_response(widget_html + (mini_html or ""))
--- a/events/bp/slot/routes.py
+++ b/events/bp/slot/routes.py
@@ -35,7 +35,7 @@ def register():
        slot = await svc_get_slot(g.s, slot_id)
        if not slot:
            return await make_response("Not found", 404)
-        from sx.sx_components import render_slot_edit_form
+        from sxc.pages.slots import render_slot_edit_form
        return sx_response(render_slot_edit_form(slot, g.calendar))

    @bp.get("/view/")
@@ -44,7 +44,7 @@ def register():
        slot = await svc_get_slot(g.s, slot_id)
        if not slot:
            return await make_response("Not found", 404)
-        from sx.sx_components import render_slot_main_panel
+        from sxc.pages.slots import render_slot_main_panel
        return sx_response(render_slot_main_panel(slot, g.calendar))

    @bp.delete("/")
@@ -53,7 +53,7 @@ def register():
    async def slot_delete(slot_id: int, **kwargs):
        await svc_delete_slot(g.s, slot_id)
        slots = await svc_list_slots(g.s, g.calendar.id)
-        from sx.sx_components import render_slots_table
+        from sxc.pages.slots import render_slots_table
        return sx_response(render_slots_table(slots, g.calendar))

    @bp.put("/")
@@ -135,7 +135,7 @@ def register():
                }
            ), 422

-        from sx.sx_components import render_slot_main_panel
+        from sxc.pages.slots import render_slot_main_panel
        return sx_response(render_slot_main_panel(slot, g.calendar, oob=True))

    
--- a/events/bp/slots/routes.py
+++ b/events/bp/slots/routes.py
@@ -110,20 +110,20 @@ def register():

        # Success → re-render the slots table
        slots = await svc_list_slots(g.s, g.calendar.id)
-        from sx.sx_components import render_slots_table
+        from sxc.pages.slots import render_slots_table
        return sx_response(render_slots_table(slots, g.calendar))

        
    @bp.get("/add")
    @require_admin
    async def add_form(**kwargs):
-        from sx.sx_components import render_slot_add_form
+        from sxc.pages.slots import render_slot_add_form
        return sx_response(render_slot_add_form(g.calendar))

    @bp.get("/add-button")
    @require_admin
    async def add_button(**kwargs):
-        from sx.sx_components import render_slot_add_button
+        from sxc.pages.slots import render_slot_add_button
        return sx_response(render_slot_add_button(g.calendar))

    return bp
--- a/events/bp/ticket_admin/routes.py
+++ b/events/bp/ticket_admin/routes.py
@@ -53,7 +53,7 @@ def register() -> Blueprint:

        tickets = await get_tickets_for_entry(g.s, entry_id)

-        from sx.sx_components import render_entry_tickets_admin
+        from sxc.pages.tickets import render_entry_tickets_admin
        html = render_entry_tickets_admin(entry, tickets)
        return sx_response(html)

@@ -69,7 +69,7 @@ def register() -> Blueprint:
            )

        ticket = await get_ticket_by_code(g.s, code)
-        from sx.sx_components import render_lookup_result
+        from sxc.pages.tickets import render_lookup_result
        if not ticket:
            return sx_response(render_lookup_result(None, "Ticket not found"))

@@ -82,7 +82,7 @@ def register() -> Blueprint:
        """Check in a ticket by its code."""
        success, error = await checkin_ticket(g.s, code)

-        from sx.sx_components import render_checkin_result
+        from sxc.pages.tickets import render_checkin_result
        if not success:
            return sx_response(render_checkin_result(False, error, None))

--- a/events/bp/ticket_type/routes.py
+++ b/events/bp/ticket_type/routes.py
@@ -30,7 +30,7 @@ def register():
        if not ticket_type:
            return await make_response("Not found", 404)

-        from sx.sx_components import render_ticket_type_edit_form
+        from sxc.pages.tickets import render_ticket_type_edit_form
        va = request.view_args or {}
        return sx_response(render_ticket_type_edit_form(
            ticket_type, g.entry, g.calendar,
@@ -45,7 +45,7 @@ def register():
        if not ticket_type:
            return await make_response("Not found", 404)

-        from sx.sx_components import render_ticket_type_main_panel
+        from sxc.pages.tickets import render_ticket_type_main_panel
        va = request.view_args or {}
        return sx_response(render_ticket_type_main_panel(
            ticket_type, g.entry, g.calendar,
@@ -112,7 +112,7 @@ def register():
            return await make_response("Not found", 404)

        # Return updated view with OOB flag
-        from sx.sx_components import render_ticket_type_main_panel
+        from sxc.pages.tickets import render_ticket_type_main_panel
        va = request.view_args or {}
        return sx_response(render_ticket_type_main_panel(
            ticket_type, g.entry, g.calendar,
@@ -131,7 +131,7 @@ def register():

        # Re-render the ticket types list
        ticket_types = await svc_list_ticket_types(g.s, g.entry.id)
-        from sx.sx_components import render_ticket_types_table
+        from sxc.pages.tickets import render_ticket_types_table
        va = request.view_args or {}
        return sx_response(render_ticket_types_table(
            ticket_types, g.entry, g.calendar,
--- a/events/bp/ticket_types/routes.py
+++ b/events/bp/ticket_types/routes.py
@@ -93,7 +93,7 @@ def register():

        # Success → re-render the ticket types table
        ticket_types = await svc_list_ticket_types(g.s, g.entry.id)
-        from sx.sx_components import render_ticket_types_table
+        from sxc.pages.tickets import render_ticket_types_table
        va = request.view_args or {}
        return sx_response(render_ticket_types_table(
            ticket_types, g.entry, g.calendar,
@@ -104,7 +104,7 @@ def register():
    @require_admin
    async def add_form(**kwargs):
        """Show the add ticket type form."""
-        from sx.sx_components import render_ticket_type_add_form
+        from sxc.pages.tickets import render_ticket_type_add_form
        va = request.view_args or {}
        return sx_response(render_ticket_type_add_form(
            g.entry, g.calendar,
@@ -115,7 +115,7 @@ def register():
    @require_admin
    async def add_button(**kwargs):
        """Show the add ticket type button."""
-        from sx.sx_components import render_ticket_type_add_button
+        from sxc.pages.tickets import render_ticket_type_add_button
        va = request.view_args or {}
        return sx_response(render_ticket_type_add_button(
            g.entry, g.calendar,
--- a/events/bp/tickets/routes.py
+++ b/events/bp/tickets/routes.py
@@ -126,7 +126,7 @@ def register() -> Blueprint:
        summary = dto_from_dict(CartSummaryDTO, raw_summary) if raw_summary else CartSummaryDTO()
        cart_count = summary.count + summary.calendar_count + summary.ticket_count

-        from sx.sx_components import render_buy_result
+        from sxc.pages.tickets import render_buy_result
        return sx_response(render_buy_result(entry, created, remaining, cart_count))

    @bp.post("/adjust/")
@@ -249,7 +249,7 @@ def register() -> Blueprint:
        summary = dto_from_dict(CartSummaryDTO, raw_summary) if raw_summary else CartSummaryDTO()
        cart_count = summary.count + summary.calendar_count + summary.ticket_count

-        from sx.sx_components import render_adjust_response
+        from sxc.pages.tickets import render_adjust_response
        return sx_response(render_adjust_response(
            entry, ticket_remaining, ticket_sold_count,
            user_ticket_count, user_ticket_counts_by_type, cart_count,
--- a/events/queries.sx
+++ b/events/queries.sx
@@ -0,0 +1,57 @@
+;; Events service — inter-service data queries
+;;
+;; Each defquery replaces a Python handler in bp/data/routes.py.
+;; The (service ...) primitive calls the registered CalendarService method
+;; with g.s (async session) + keyword args, and auto-converts DTOs to dicts.
+
+(defquery pending-entries (&key user-id session-id)
+  "Calendar entries in pending state for a user or session."
+  (service "calendar" "pending-entries"
+    :user-id user-id :session-id session-id))
+
+(defquery pending-tickets (&key user-id session-id)
+  "Tickets in pending state for a user or session."
+  (service "calendar" "pending-tickets"
+    :user-id user-id :session-id session-id))
+
+(defquery entries-for-page (&key page-id user-id session-id)
+  "Calendar entries for a specific page."
+  (service "calendar" "entries-for-page"
+    :page-id page-id :user-id user-id :session-id session-id))
+
+(defquery tickets-for-page (&key page-id user-id session-id)
+  "Tickets for a specific page."
+  (service "calendar" "tickets-for-page"
+    :page-id page-id :user-id user-id :session-id session-id))
+
+(defquery entries-for-order (&key order-id)
+  "Calendar entries claimed by an order."
+  (service "calendar" "get-entries-for-order" :order-id order-id))
+
+(defquery tickets-for-order (&key order-id)
+  "Tickets claimed by an order."
+  (service "calendar" "get-tickets-for-order" :order-id order-id))
+
+(defquery entry-ids-for-content (&key content-type content-id)
+  "Entry IDs associated with a content item."
+  (service "calendar" "entry-ids-for-content"
+    :content-type content-type :content-id content-id))
+
+(defquery associated-entries (&key content-type content-id page)
+  "Entries associated with content, paginated."
+  (let ((result (service "calendar" "associated-entries"
+                  :content-type content-type :content-id content-id :page page)))
+    {"entries" (nth result 0) "has_more" (nth result 1)}))
+
+(defquery calendars-for-container (&key type id)
+  "Calendars attached to a container (page, marketplace, etc)."
+  (service "calendar" "calendars-for-container"
+    :container-type type :container-id id))
+
+(defquery visible-entries-for-period (&key calendar-id period-start period-end user-id session-id)
+  "Visible entries within a date range for a calendar."
+  (service "calendar" "visible-entries-for-period"
+    :calendar-id calendar-id
+    :period-start (parse-datetime period-start)
+    :period-end (parse-datetime period-end)
+    :user-id user-id :is-admin false :session-id session-id))
--- a/events/sx/header.sx
+++ b/events/sx/header.sx
@@ -24,3 +24,10 @@
  (div :id (str "entry-title-" entry-id) :class "flex gap-1 items-center"
    title times))

+(defcomp ~events-slot-label (&key name description)
+  (div :class "flex flex-col md:flex-row md:gap-2 items-center"
+    (div :class "flex flex-row items-center gap-2"
+      (i :class "fa fa-clock")
+      (div :class "shrink-0" name))
+    (p :class "text-stone-500 whitespace-pre-line break-all w-full" description)))
+
--- a/events/sx/layouts.sx
+++ b/events/sx/layouts.sx
@@ -0,0 +1,96 @@
+;; Events layout defcomps — root header via ~root-header-auto,
+;; events-specific headers passed as &key params.
+
+;; --- Calendar admin layout: root + post + child(admin + cal + cal-admin) ---
+
+(defcomp ~events-cal-admin-layout-full (&key post-header admin-header
+                                              calendar-header calendar-admin-header)
+  (<> (~root-header-auto)
+    post-header
+    (~header-child-sx :inner (<> admin-header calendar-header calendar-admin-header))))
+
+(defcomp ~events-cal-admin-layout-oob (&key admin-oob cal-oob cal-admin-oob-wrap clear-oob)
+  (<> admin-oob cal-oob cal-admin-oob-wrap clear-oob))
+
+;; --- Slots layout: same full as cal-admin ---
+
+(defcomp ~events-slots-layout-oob (&key admin-oob cal-admin-oob clear-oob)
+  (<> admin-oob cal-admin-oob clear-oob))
+
+;; --- Slot detail layout: root + post + child(admin + cal + cal-admin + slot) ---
+
+(defcomp ~events-slot-layout-full (&key post-header admin-header
+                                         calendar-header calendar-admin-header slot-header)
+  (<> (~root-header-auto)
+    post-header
+    (~header-child-sx :inner (<> admin-header calendar-header calendar-admin-header slot-header))))
+
+(defcomp ~events-slot-layout-oob (&key admin-oob cal-admin-oob slot-oob-wrap clear-oob)
+  (<> admin-oob cal-admin-oob slot-oob-wrap clear-oob))
+
+;; --- Day admin layout: root + post + child(admin + cal + day + day-admin) ---
+
+(defcomp ~events-day-admin-layout-full (&key post-header admin-header
+                                              calendar-header day-header day-admin-header)
+  (<> (~root-header-auto)
+    post-header
+    (~header-child-sx :inner (<> admin-header calendar-header day-header day-admin-header))))
+
+(defcomp ~events-day-admin-layout-oob (&key admin-oob cal-oob day-admin-oob-wrap clear-oob)
+  (<> admin-oob cal-oob day-admin-oob-wrap clear-oob))
+
+;; --- Entry layout: root + child(post + cal + day + entry) ---
+
+(defcomp ~events-entry-layout-full (&key post-header calendar-header day-header entry-header)
+  (<> (~root-header-auto)
+    (~header-child-sx :inner (<> post-header calendar-header day-header entry-header))))
+
+(defcomp ~events-entry-layout-oob (&key day-oob entry-oob-wrap clear-oob)
+  (<> day-oob entry-oob-wrap clear-oob))
+
+;; --- Entry admin layout: root + post + child(admin + cal + day + entry + entry-admin) ---
+
+(defcomp ~events-entry-admin-layout-full (&key post-header admin-header
+                                                calendar-header day-header
+                                                entry-header entry-admin-header)
+  (<> (~root-header-auto)
+    post-header
+    (~header-child-sx :inner (<> admin-header calendar-header day-header
+                                entry-header entry-admin-header))))
+
+(defcomp ~events-entry-admin-layout-oob (&key admin-oob entry-oob entry-admin-oob-wrap clear-oob)
+  (<> admin-oob entry-oob entry-admin-oob-wrap clear-oob))
+
+;; --- Ticket types layout: root + child(post + cal + day + entry + entry-admin + ticket-types) ---
+
+(defcomp ~events-ticket-types-layout-full (&key post-header calendar-header day-header
+                                                 entry-header entry-admin-header
+                                                 ticket-types-header)
+  (<> (~root-header-auto)
+    (~header-child-sx :inner (<> post-header calendar-header day-header
+                                entry-header entry-admin-header ticket-types-header))))
+
+(defcomp ~events-ticket-types-layout-oob (&key entry-admin-oob ticket-types-oob-wrap)
+  (<> entry-admin-oob ticket-types-oob-wrap))
+
+;; --- Ticket type detail layout: root + child(post + cal + day + entry + entry-admin + types + type) ---
+
+(defcomp ~events-ticket-type-layout-full (&key post-header calendar-header day-header
+                                                entry-header entry-admin-header
+                                                ticket-types-header ticket-type-header)
+  (<> (~root-header-auto)
+    (~header-child-sx :inner (<> post-header calendar-header day-header
+                                entry-header entry-admin-header
+                                ticket-types-header ticket-type-header))))
+
+(defcomp ~events-ticket-type-layout-oob (&key ticket-types-oob ticket-type-oob-wrap)
+  (<> ticket-types-oob ticket-type-oob-wrap))
+
+;; --- Markets layout: root + child(post + markets) ---
+
+(defcomp ~events-markets-layout-full (&key post-header markets-header)
+  (<> (~root-header-auto)
+    (~header-child-sx :inner (<> post-header markets-header))))
+
+(defcomp ~events-markets-layout-oob (&key post-oob markets-oob-wrap)
+  (<> post-oob markets-oob-wrap))
--- a/events/sx/sx_components.py
+++ b/events/sx/sx_components.py
--- a/events/sxc/pages/init.py
+++ b/events/sxc/pages/init.py
@@ -1,11 +1,10 @@
 """Events defpage setup — registers layouts, page helpers, and loads .sx pages."""
 from __future__ import annotations

-from typing import Any
-

 def setup_events_pages() -> None:
    """Register events-specific layouts, page helpers, and load page definitions."""
+    from .helpers import _register_events_layouts, _register_events_helpers
    _register_events_layouts()
    _register_events_helpers()
    _load_events_page_files()
@@ -14,690 +13,8 @@ def setup_events_pages() -> None:
 def _load_events_page_files() -> None:
    import os
    from shared.sx.pages import load_page_dir
+    from shared.sx.jinja_bridge import load_service_components
+    sxc_dir = os.path.dirname(os.path.dirname(__file__))         # events/sxc/
+    service_root = os.path.dirname(sxc_dir)                       # events/
+    load_service_components(service_root, service_name="events")
    load_page_dir(os.path.dirname(__file__), "events")
-
-
-# ---------------------------------------------------------------------------
-# Layouts
-# ---------------------------------------------------------------------------
-
-def _register_events_layouts() -> None:
-    from shared.sx.layouts import register_custom_layout
-    register_custom_layout("events-calendar-admin", _cal_admin_full, _cal_admin_oob)
-    register_custom_layout("events-slots", _slots_full, _slots_oob)
-    register_custom_layout("events-slot", _slot_full, _slot_oob)
-    register_custom_layout("events-day-admin", _day_admin_full, _day_admin_oob)
-    register_custom_layout("events-entry", _entry_full, _entry_oob)
-    register_custom_layout("events-entry-admin", _entry_admin_full, _entry_admin_oob)
-    register_custom_layout("events-ticket-types", _ticket_types_full, _ticket_types_oob)
-    register_custom_layout("events-ticket-type", _ticket_type_full, _ticket_type_oob)
-    register_custom_layout("events-markets", _markets_full, _markets_oob)
-
-
-# --- Calendar admin layout (root + post + child(post-admin + calendar + cal-admin)) ---
-
-async def _cal_admin_full(ctx: dict, **kw: Any) -> str:
-    from shared.sx.helpers import root_header_sx, post_admin_header_sx, header_child_sx
-    from sx.sx_components import (
-        _ensure_container_nav, _post_header_sx,
-        _calendar_header_sx, _calendar_admin_header_sx,
-    )
-    ctx = await _ensure_container_nav(ctx)
-    slug = (ctx.get("post") or {}).get("slug", "")
-    root_hdr = root_header_sx(ctx)
-    post_hdr = _post_header_sx(ctx)
-    admin_hdr = post_admin_header_sx(ctx, slug, selected="calendars")
-    child = admin_hdr + _calendar_header_sx(ctx) + _calendar_admin_header_sx(ctx)
-    return root_hdr + post_hdr + header_child_sx(child)
-
-
-async def _cal_admin_oob(ctx: dict, **kw: Any) -> str:
-    from shared.sx.helpers import post_admin_header_sx, oob_header_sx
-    from sx.sx_components import (
-        _ensure_container_nav, _calendar_header_sx,
-        _calendar_admin_header_sx, _clear_deeper_oob,
-    )
-    ctx = await _ensure_container_nav(ctx)
-    slug = (ctx.get("post") or {}).get("slug", "")
-    oobs = (post_admin_header_sx(ctx, slug, oob=True, selected="calendars")
-            + _calendar_header_sx(ctx, oob=True))
-    oobs += oob_header_sx("calendar-header-child", "calendar-admin-header-child",
-                              _calendar_admin_header_sx(ctx))
-    oobs += _clear_deeper_oob("post-row", "post-header-child",
-                               "post-admin-row", "post-admin-header-child",
-                               "calendar-row", "calendar-header-child",
-                               "calendar-admin-row", "calendar-admin-header-child")
-    return oobs
-
-
-# --- Slots layout (same full as cal-admin but different OOB) ---
-
-async def _slots_full(ctx: dict, **kw: Any) -> str:
-    return await _cal_admin_full({**ctx, "is_admin_section": True}, **kw)
-
-
-async def _slots_oob(ctx: dict, **kw: Any) -> str:
-    from shared.sx.helpers import post_admin_header_sx
-    from sx.sx_components import (
-        _ensure_container_nav, _calendar_admin_header_sx, _clear_deeper_oob,
-    )
-    ctx = await _ensure_container_nav({**ctx, "is_admin_section": True})
-    slug = (ctx.get("post") or {}).get("slug", "")
-    oobs = (post_admin_header_sx(ctx, slug, oob=True, selected="calendars")
-            + _calendar_admin_header_sx(ctx, oob=True))
-    oobs += _clear_deeper_oob("post-row", "post-header-child",
-                               "post-admin-row", "post-admin-header-child",
-                               "calendar-row", "calendar-header-child",
-                               "calendar-admin-row", "calendar-admin-header-child")
-    return oobs
-
-
-# --- Slot detail layout (extends cal-admin with slot header) ---
-
-async def _slot_full(ctx: dict, **kw: Any) -> str:
-    from shared.sx.helpers import root_header_sx, post_admin_header_sx, header_child_sx
-    from sx.sx_components import (
-        _ensure_container_nav, _post_header_sx,
-        _calendar_header_sx, _calendar_admin_header_sx, _slot_header_html,
-    )
-    ctx = await _ensure_container_nav({**ctx, "is_admin_section": True})
-    slug = (ctx.get("post") or {}).get("slug", "")
-    root_hdr = root_header_sx(ctx)
-    post_hdr = _post_header_sx(ctx)
-    admin_hdr = post_admin_header_sx(ctx, slug, selected="calendars")
-    child = (admin_hdr + _calendar_header_sx(ctx)
-             + _calendar_admin_header_sx(ctx) + _slot_header_html(ctx))
-    return root_hdr + post_hdr + header_child_sx(child)
-
-
-async def _slot_oob(ctx: dict, **kw: Any) -> str:
-    from shared.sx.helpers import post_admin_header_sx, oob_header_sx
-    from sx.sx_components import (
-        _ensure_container_nav, _calendar_admin_header_sx,
-        _slot_header_html, _clear_deeper_oob,
-    )
-    ctx = await _ensure_container_nav({**ctx, "is_admin_section": True})
-    slug = (ctx.get("post") or {}).get("slug", "")
-    oobs = (post_admin_header_sx(ctx, slug, oob=True, selected="calendars")
-            + _calendar_admin_header_sx(ctx, oob=True))
-    oobs += oob_header_sx("calendar-admin-header-child", "slot-header-child",
-                              _slot_header_html(ctx))
-    oobs += _clear_deeper_oob("post-row", "post-header-child",
-                               "post-admin-row", "post-admin-header-child",
-                               "calendar-row", "calendar-header-child",
-                               "calendar-admin-row", "calendar-admin-header-child",
-                               "slot-row", "slot-header-child")
-    return oobs
-
-
-# --- Day admin layout (root + post + post-admin + child(cal + day + day-admin)) ---
-
-async def _day_admin_full(ctx: dict, **kw: Any) -> str:
-    from shared.sx.helpers import root_header_sx, post_admin_header_sx, header_child_sx
-    from sx.sx_components import (
-        _ensure_container_nav, _post_header_sx,
-        _calendar_header_sx, _day_header_sx, _day_admin_header_sx,
-    )
-    ctx = await _ensure_container_nav(ctx)
-    slug = (ctx.get("post") or {}).get("slug", "")
-    root_hdr = root_header_sx(ctx)
-    post_hdr = _post_header_sx(ctx)
-    admin_hdr = post_admin_header_sx(ctx, slug, selected="calendars")
-    child = (admin_hdr + _calendar_header_sx(ctx) + _day_header_sx(ctx)
-             + _day_admin_header_sx(ctx))
-    return root_hdr + post_hdr + header_child_sx(child)
-
-
-async def _day_admin_oob(ctx: dict, **kw: Any) -> str:
-    from shared.sx.helpers import post_admin_header_sx, oob_header_sx
-    from sx.sx_components import (
-        _ensure_container_nav, _calendar_header_sx,
-        _day_admin_header_sx, _clear_deeper_oob,
-    )
-    ctx = await _ensure_container_nav(ctx)
-    slug = (ctx.get("post") or {}).get("slug", "")
-    oobs = (post_admin_header_sx(ctx, slug, oob=True, selected="calendars")
-            + _calendar_header_sx(ctx, oob=True))
-    oobs += oob_header_sx("day-header-child", "day-admin-header-child",
-                              _day_admin_header_sx(ctx))
-    oobs += _clear_deeper_oob("post-row", "post-header-child",
-                               "post-admin-row", "post-admin-header-child",
-                               "calendar-row", "calendar-header-child",
-                               "day-row", "day-header-child",
-                               "day-admin-row", "day-admin-header-child")
-    return oobs
-
-
-# --- Entry layout (root + child(post + cal + day + entry), + menu) ---
-
-def _entry_full(ctx: dict, **kw: Any) -> str:
-    from shared.sx.helpers import root_header_sx, header_child_sx
-    from sx.sx_components import (
-        _post_header_sx, _calendar_header_sx,
-        _day_header_sx, _entry_header_html,
-    )
-    root_hdr = root_header_sx(ctx)
-    child = (_post_header_sx(ctx) + _calendar_header_sx(ctx)
-             + _day_header_sx(ctx) + _entry_header_html(ctx))
-    return root_hdr + header_child_sx(child)
-
-
-def _entry_oob(ctx: dict, **kw: Any) -> str:
-    from shared.sx.helpers import oob_header_sx
-    from sx.sx_components import (
-        _day_header_sx, _entry_header_html, _clear_deeper_oob,
-    )
-    oobs = _day_header_sx(ctx, oob=True)
-    oobs += oob_header_sx("day-header-child", "entry-header-child",
-                              _entry_header_html(ctx))
-    oobs += _clear_deeper_oob("post-row", "post-header-child",
-                               "calendar-row", "calendar-header-child",
-                               "day-row", "day-header-child",
-                               "entry-row", "entry-header-child")
-    return oobs
-
-
-# --- Entry admin layout (root + post + child(post-admin + cal + day + entry + entry-admin), + menu) ---
-
-async def _entry_admin_full(ctx: dict, **kw: Any) -> str:
-    from shared.sx.helpers import root_header_sx, post_admin_header_sx, header_child_sx
-    from sx.sx_components import (
-        _ensure_container_nav, _post_header_sx,
-        _calendar_header_sx, _day_header_sx,
-        _entry_header_html, _entry_admin_header_html,
-    )
-    ctx = await _ensure_container_nav(ctx)
-    slug = (ctx.get("post") or {}).get("slug", "")
-    root_hdr = root_header_sx(ctx)
-    post_hdr = _post_header_sx(ctx)
-    admin_hdr = post_admin_header_sx(ctx, slug, selected="calendars")
-    child = (admin_hdr + _calendar_header_sx(ctx) + _day_header_sx(ctx)
-             + _entry_header_html(ctx) + _entry_admin_header_html(ctx))
-    return root_hdr + post_hdr + header_child_sx(child)
-
-
-async def _entry_admin_oob(ctx: dict, **kw: Any) -> str:
-    from shared.sx.helpers import post_admin_header_sx, oob_header_sx
-    from sx.sx_components import (
-        _ensure_container_nav, _entry_header_html,
-        _entry_admin_header_html, _clear_deeper_oob,
-    )
-    ctx = await _ensure_container_nav(ctx)
-    slug = (ctx.get("post") or {}).get("slug", "")
-    oobs = (post_admin_header_sx(ctx, slug, oob=True, selected="calendars")
-            + _entry_header_html(ctx, oob=True))
-    oobs += oob_header_sx("entry-header-child", "entry-admin-header-child",
-                              _entry_admin_header_html(ctx))
-    oobs += _clear_deeper_oob("post-row", "post-header-child",
-                               "post-admin-row", "post-admin-header-child",
-                               "calendar-row", "calendar-header-child",
-                               "day-row", "day-header-child",
-                               "entry-row", "entry-header-child",
-                               "entry-admin-row", "entry-admin-header-child")
-    return oobs
-
-
-# --- Ticket types layout (extends entry admin with ticket-types header, + menu) ---
-
-def _ticket_types_full(ctx: dict, **kw: Any) -> str:
-    from shared.sx.helpers import root_header_sx, header_child_sx
-    from sx.sx_components import (
-        _post_header_sx, _calendar_header_sx, _day_header_sx,
-        _entry_header_html, _entry_admin_header_html,
-        _ticket_types_header_html,
-    )
-    root_hdr = root_header_sx(ctx)
-    child = (_post_header_sx(ctx) + _calendar_header_sx(ctx)
-             + _day_header_sx(ctx) + _entry_header_html(ctx)
-             + _entry_admin_header_html(ctx) + _ticket_types_header_html(ctx))
-    return root_hdr + header_child_sx(child)
-
-
-def _ticket_types_oob(ctx: dict, **kw: Any) -> str:
-    from shared.sx.helpers import oob_header_sx
-    from sx.sx_components import (
-        _entry_admin_header_html, _ticket_types_header_html, _clear_deeper_oob,
-    )
-    oobs = _entry_admin_header_html(ctx, oob=True)
-    oobs += oob_header_sx("entry-admin-header-child", "ticket_types-header-child",
-                              _ticket_types_header_html(ctx))
-    return oobs
-
-
-# --- Ticket type detail layout (extends ticket types with ticket-type header, + menu) ---
-
-def _ticket_type_full(ctx: dict, **kw: Any) -> str:
-    from shared.sx.helpers import root_header_sx, header_child_sx
-    from sx.sx_components import (
-        _post_header_sx, _calendar_header_sx, _day_header_sx,
-        _entry_header_html, _entry_admin_header_html,
-        _ticket_types_header_html, _ticket_type_header_html,
-    )
-    root_hdr = root_header_sx(ctx)
-    child = (_post_header_sx(ctx) + _calendar_header_sx(ctx)
-             + _day_header_sx(ctx) + _entry_header_html(ctx)
-             + _entry_admin_header_html(ctx) + _ticket_types_header_html(ctx)
-             + _ticket_type_header_html(ctx))
-    return root_hdr + header_child_sx(child)
-
-
-def _ticket_type_oob(ctx: dict, **kw: Any) -> str:
-    from shared.sx.helpers import oob_header_sx
-    from sx.sx_components import (
-        _ticket_types_header_html, _ticket_type_header_html,
-    )
-    oobs = _ticket_types_header_html(ctx, oob=True)
-    oobs += oob_header_sx("ticket_types-header-child", "ticket_type-header-child",
-                              _ticket_type_header_html(ctx))
-    return oobs
-
-
-# --- Markets layout (root + child(post + markets)) ---
-
-def _markets_full(ctx: dict, **kw: Any) -> str:
-    from shared.sx.helpers import root_header_sx, header_child_sx
-    from sx.sx_components import _post_header_sx, _markets_header_sx
-    root_hdr = root_header_sx(ctx)
-    child = _post_header_sx(ctx) + _markets_header_sx(ctx)
-    return root_hdr + header_child_sx(child)
-
-
-def _markets_oob(ctx: dict, **kw: Any) -> str:
-    from shared.sx.helpers import oob_header_sx
-    from sx.sx_components import _post_header_sx, _markets_header_sx
-    oobs = _post_header_sx(ctx, oob=True)
-    oobs += oob_header_sx("post-header-child", "markets-header-child",
-                              _markets_header_sx(ctx))
-    return oobs
-
-
-# ---------------------------------------------------------------------------
-# Shared hydration helpers
-# ---------------------------------------------------------------------------
-
-def _add_to_defpage_ctx(**kwargs: Any) -> None:
-    """Add data to g._defpage_ctx for the app-level context_processor."""
-    from quart import g
-    if not hasattr(g, '_defpage_ctx'):
-        g._defpage_ctx = {}
-    g._defpage_ctx.update(kwargs)
-
-
-async def _ensure_calendar(calendar_slug: str | None) -> None:
-    """Load calendar into g.calendar if not already present."""
-    from quart import g, abort
-    if hasattr(g, 'calendar'):
-        _add_to_defpage_ctx(calendar=g.calendar)
-        return
-    from bp.calendar.services.calendar_view import (
-        get_calendar_by_post_and_slug, get_calendar_by_slug,
-    )
-    post_data = getattr(g, "post_data", None)
-    if post_data:
-        post_id = (post_data.get("post") or {}).get("id")
-        cal = await get_calendar_by_post_and_slug(g.s, post_id, calendar_slug)
-    else:
-        cal = await get_calendar_by_slug(g.s, calendar_slug)
-    if not cal:
-        abort(404)
-    g.calendar = cal
-    g.calendar_slug = calendar_slug
-    _add_to_defpage_ctx(calendar=cal)
-
-
-async def _ensure_entry(entry_id: int | None) -> None:
-    """Load calendar entry into g.entry if not already present."""
-    from quart import g, abort
-    if hasattr(g, 'entry'):
-        _add_to_defpage_ctx(entry=g.entry)
-        return
-    from sqlalchemy import select
-    from models.calendars import CalendarEntry
-    result = await g.s.execute(
-        select(CalendarEntry).where(
-            CalendarEntry.id == entry_id,
-            CalendarEntry.deleted_at.is_(None),
-        )
-    )
-    entry = result.scalar_one_or_none()
-    if entry is None:
-        abort(404)
-    g.entry = entry
-    _add_to_defpage_ctx(entry=entry)
-
-
-async def _ensure_entry_context(entry_id: int | None) -> None:
-    """Load full entry context (ticket data, posts) into g.* and _defpage_ctx."""
-    from quart import g
-    from sqlalchemy import select
-    from sqlalchemy.orm import selectinload
-    from models.calendars import CalendarEntry
-    from bp.tickets.services.tickets import (
-        get_available_ticket_count,
-        get_sold_ticket_count,
-        get_user_reserved_count,
-    )
-    from shared.infrastructure.cart_identity import current_cart_identity
-    from bp.calendar_entry.services.post_associations import get_entry_posts
-
-    await _ensure_entry(entry_id)
-
-    # Reload with ticket_types eagerly loaded
-    stmt = (
-        select(CalendarEntry)
-        .where(CalendarEntry.id == entry_id, CalendarEntry.deleted_at.is_(None))
-        .options(selectinload(CalendarEntry.ticket_types))
-    )
-    result = await g.s.execute(stmt)
-    calendar_entry = result.scalar_one_or_none()
-
-    if calendar_entry and getattr(g, "calendar", None):
-        if calendar_entry.calendar_id != g.calendar.id:
-            calendar_entry = None
-
-    if calendar_entry:
-        await g.s.refresh(calendar_entry, ['slot'])
-        g.entry = calendar_entry
-        entry_posts = await get_entry_posts(g.s, calendar_entry.id)
-        ticket_remaining = await get_available_ticket_count(g.s, calendar_entry.id)
-        ticket_sold_count = await get_sold_ticket_count(g.s, calendar_entry.id)
-        ident = current_cart_identity()
-        user_ticket_count = await get_user_reserved_count(
-            g.s, calendar_entry.id,
-            user_id=ident["user_id"],
-            session_id=ident["session_id"],
-        )
-        user_ticket_counts_by_type = {}
-        if calendar_entry.ticket_types:
-            for tt in calendar_entry.ticket_types:
-                if tt.deleted_at is None:
-                    user_ticket_counts_by_type[tt.id] = await get_user_reserved_count(
-                        g.s, calendar_entry.id,
-                        user_id=ident["user_id"],
-                        session_id=ident["session_id"],
-                        ticket_type_id=tt.id,
-                    )
-        _add_to_defpage_ctx(
-            entry=calendar_entry,
-            entry_posts=entry_posts,
-            ticket_remaining=ticket_remaining,
-            ticket_sold_count=ticket_sold_count,
-            user_ticket_count=user_ticket_count,
-            user_ticket_counts_by_type=user_ticket_counts_by_type,
-        )
-
-
-async def _ensure_day_data(year: int, month: int, day: int) -> None:
-    """Load day-specific data for layout header functions."""
-    from quart import g, session as qsession
-    if hasattr(g, 'day_date'):
-        return
-    from datetime import date as date_cls, datetime, timezone, timedelta
-    from sqlalchemy import select
-    from bp.calendar.services import get_visible_entries_for_period
-    from models.calendars import CalendarSlot
-
-    calendar = getattr(g, "calendar", None)
-    if not calendar:
-        return
-
-    try:
-        day_date = date_cls(year, month, day)
-    except (ValueError, TypeError):
-        return
-
-    period_start = datetime(year, month, day, tzinfo=timezone.utc)
-    period_end = period_start + timedelta(days=1)
-
-    user = getattr(g, "user", None)
-    session_id = qsession.get("calendar_sid")
-
-    visible = await get_visible_entries_for_period(
-        sess=g.s,
-        calendar_id=calendar.id,
-        period_start=period_start,
-        period_end=period_end,
-        user=user,
-        session_id=session_id,
-    )
-
-    weekday_attr = ["mon", "tue", "wed", "thu", "fri", "sat", "sun"][day_date.weekday()]
-    stmt = (
-        select(CalendarSlot)
-        .where(
-            CalendarSlot.calendar_id == calendar.id,
-            getattr(CalendarSlot, weekday_attr) == True,  # noqa: E712
-            CalendarSlot.deleted_at.is_(None),
-        )
-        .order_by(CalendarSlot.time_start.asc(), CalendarSlot.id.asc())
-    )
-    result = await g.s.execute(stmt)
-    day_slots = list(result.scalars())
-
-    g.day_date = day_date
-    _add_to_defpage_ctx(
-        qsession=qsession,
-        day_date=day_date,
-        day=day,
-        year=year,
-        month=month,
-        day_entries=visible.merged_entries,
-        user_entries=visible.user_entries,
-        confirmed_entries=visible.confirmed_entries,
-        day_slots=day_slots,
-    )
-
-
-# ---------------------------------------------------------------------------
-# Page helpers
-# ---------------------------------------------------------------------------
-
-def _register_events_helpers() -> None:
-    from shared.sx.pages import register_page_helpers
-
-    register_page_helpers("events", {
-        "calendar-admin-content": _h_calendar_admin_content,
-        "day-admin-content": _h_day_admin_content,
-        "slots-content": _h_slots_content,
-        "slot-content": _h_slot_content,
-        "entry-content": _h_entry_content,
-        "entry-menu": _h_entry_menu,
-        "entry-admin-content": _h_entry_admin_content,
-        "admin-menu": _h_admin_menu,
-        "ticket-types-content": _h_ticket_types_content,
-        "ticket-type-content": _h_ticket_type_content,
-        "tickets-content": _h_tickets_content,
-        "ticket-detail-content": _h_ticket_detail_content,
-        "ticket-admin-content": _h_ticket_admin_content,
-        "markets-content": _h_markets_content,
-    })
-
-
-async def _h_calendar_admin_content(calendar_slug=None, **kw):
-    await _ensure_calendar(calendar_slug)
-    from shared.sx.page import get_template_context
-    from sx.sx_components import _calendar_admin_main_panel_html
-    ctx = await get_template_context()
-    return _calendar_admin_main_panel_html(ctx)
-
-
-async def _h_day_admin_content(calendar_slug=None, year=None, month=None, day=None, **kw):
-    await _ensure_calendar(calendar_slug)
-    if year is not None:
-        await _ensure_day_data(int(year), int(month), int(day))
-    from sx.sx_components import _day_admin_main_panel_html
-    return _day_admin_main_panel_html({})
-
-
-async def _h_slots_content(calendar_slug=None, **kw):
-    from quart import g
-    await _ensure_calendar(calendar_slug)
-    calendar = getattr(g, "calendar", None)
-    from bp.slots.services.slots import list_slots as svc_list_slots
-    slots = await svc_list_slots(g.s, calendar.id) if calendar else []
-    _add_to_defpage_ctx(slots=slots)
-    from sx.sx_components import render_slots_table
-    return render_slots_table(slots, calendar)
-
-
-async def _h_slot_content(calendar_slug=None, slot_id=None, **kw):
-    from quart import g, abort
-    await _ensure_calendar(calendar_slug)
-    from bp.slot.services.slot import get_slot as svc_get_slot
-    slot = await svc_get_slot(g.s, slot_id) if slot_id else None
-    if not slot:
-        abort(404)
-    g.slot = slot
-    _add_to_defpage_ctx(slot=slot)
-    calendar = getattr(g, "calendar", None)
-    from sx.sx_components import render_slot_main_panel
-    return render_slot_main_panel(slot, calendar)
-
-
-async def _h_entry_content(calendar_slug=None, entry_id=None, **kw):
-    await _ensure_calendar(calendar_slug)
-    await _ensure_entry_context(entry_id)
-    from shared.sx.page import get_template_context
-    from sx.sx_components import _entry_main_panel_html
-    ctx = await get_template_context()
-    return _entry_main_panel_html(ctx)
-
-
-async def _h_entry_menu(calendar_slug=None, entry_id=None, **kw):
-    await _ensure_calendar(calendar_slug)
-    await _ensure_entry_context(entry_id)
-    from shared.sx.page import get_template_context
-    from sx.sx_components import _entry_nav_html
-    ctx = await get_template_context()
-    return _entry_nav_html(ctx)
-
-
-async def _h_entry_admin_content(calendar_slug=None, entry_id=None, **kw):
-    await _ensure_calendar(calendar_slug)
-    await _ensure_entry_context(entry_id)
-    from shared.sx.page import get_template_context
-    from sx.sx_components import _entry_admin_main_panel_html
-    ctx = await get_template_context()
-    return _entry_admin_main_panel_html(ctx)
-
-
-def _h_admin_menu():
-    from shared.sx.helpers import sx_call
-    return sx_call("events-admin-placeholder-nav")
-
-
-async def _h_ticket_types_content(calendar_slug=None, entry_id=None,
-                                   year=None, month=None, day=None, **kw):
-    from quart import g
-    await _ensure_calendar(calendar_slug)
-    await _ensure_entry(entry_id)
-    entry = getattr(g, "entry", None)
-    calendar = getattr(g, "calendar", None)
-    from bp.ticket_types.services.tickets import list_ticket_types as svc_list_ticket_types
-    ticket_types = await svc_list_ticket_types(g.s, entry.id) if entry else []
-    _add_to_defpage_ctx(ticket_types=ticket_types)
-    from sx.sx_components import render_ticket_types_table
-    return render_ticket_types_table(ticket_types, entry, calendar, day, month, year)
-
-
-async def _h_ticket_type_content(calendar_slug=None, entry_id=None,
-                                  ticket_type_id=None, year=None, month=None, day=None, **kw):
-    from quart import g, abort
-    await _ensure_calendar(calendar_slug)
-    await _ensure_entry(entry_id)
-    from bp.ticket_type.services.ticket import get_ticket_type as svc_get_ticket_type
-    ticket_type = await svc_get_ticket_type(g.s, ticket_type_id) if ticket_type_id else None
-    if not ticket_type:
-        abort(404)
-    g.ticket_type = ticket_type
-    _add_to_defpage_ctx(ticket_type=ticket_type)
-    entry = getattr(g, "entry", None)
-    calendar = getattr(g, "calendar", None)
-    from sx.sx_components import render_ticket_type_main_panel
-    return render_ticket_type_main_panel(ticket_type, entry, calendar, day, month, year)
-
-
-async def _h_tickets_content(**kw):
-    from quart import g
-    from shared.infrastructure.cart_identity import current_cart_identity
-    from bp.tickets.services.tickets import get_user_tickets
-    ident = current_cart_identity()
-    tickets = await get_user_tickets(
-        g.s,
-        user_id=ident["user_id"],
-        session_id=ident["session_id"],
-    )
-    from shared.sx.page import get_template_context
-    from sx.sx_components import _tickets_main_panel_html
-    ctx = await get_template_context()
-    return _tickets_main_panel_html(ctx, tickets)
-
-
-async def _h_ticket_detail_content(code=None, **kw):
-    from quart import g, abort
-    from shared.infrastructure.cart_identity import current_cart_identity
-    from bp.tickets.services.tickets import get_ticket_by_code
-    ticket = await get_ticket_by_code(g.s, code) if code else None
-    if not ticket:
-        abort(404)
-    # Verify ownership
-    ident = current_cart_identity()
-    if ident["user_id"] is not None:
-        if ticket.user_id != ident["user_id"]:
-            abort(404)
-    elif ident["session_id"] is not None:
-        if ticket.session_id != ident["session_id"]:
-            abort(404)
-    else:
-        abort(404)
-    from shared.sx.page import get_template_context
-    from sx.sx_components import _ticket_detail_panel_html
-    ctx = await get_template_context()
-    return _ticket_detail_panel_html(ctx, ticket)
-
-
-async def _h_ticket_admin_content(**kw):
-    from quart import g
-    from sqlalchemy import select, func
-    from sqlalchemy.orm import selectinload
-    from models.calendars import CalendarEntry, Ticket
-
-    result = await g.s.execute(
-        select(Ticket)
-        .options(
-            selectinload(Ticket.entry).selectinload(CalendarEntry.calendar),
-            selectinload(Ticket.ticket_type),
-        )
-        .order_by(Ticket.created_at.desc())
-        .limit(50)
-    )
-    tickets = result.scalars().all()
-
-    total = await g.s.scalar(select(func.count(Ticket.id)))
-    confirmed = await g.s.scalar(
-        select(func.count(Ticket.id)).where(Ticket.state == "confirmed")
-    )
-    checked_in = await g.s.scalar(
-        select(func.count(Ticket.id)).where(Ticket.state == "checked_in")
-    )
-    reserved = await g.s.scalar(
-        select(func.count(Ticket.id)).where(Ticket.state == "reserved")
-    )
-    stats = {
-        "total": total or 0,
-        "confirmed": confirmed or 0,
-        "checked_in": checked_in or 0,
-        "reserved": reserved or 0,
-    }
-
-    from shared.sx.page import get_template_context
-    from sx.sx_components import _ticket_admin_main_panel_html
-    ctx = await get_template_context()
-    return _ticket_admin_main_panel_html(ctx, tickets, stats)
-
-
-async def _h_markets_content(**kw):
-    from shared.sx.page import get_template_context
-    from sx.sx_components import _markets_main_panel_html
-    ctx = await get_template_context()
-    return _markets_main_panel_html(ctx)
--- a/events/sxc/pages/calendar.py
+++ b/events/sxc/pages/calendar.py
@@ -0,0 +1,678 @@
+"""Calendar grid, day panels, month navigation, calendar-specific helpers."""
+from __future__ import annotations
+
+from shared.sx.helpers import (
+    call_url, sx_call, render_to_sx_with_env,
+    post_admin_header_sx,
+)
+from shared.sx.parser import SxExpr
+
+from .utils import (
+    _clear_deeper_oob, _ensure_container_nav,
+    _entry_state_badge_html, _list_container,
+)
+
+
+# ---------------------------------------------------------------------------
+# Post header helpers
+# ---------------------------------------------------------------------------
+
+async def _post_header_sx(ctx: dict, *, oob: bool = False) -> str:
+    """Build the post-level header row — delegates to shared sx helper."""
+    from shared.sx.helpers import post_header_sx
+    return await post_header_sx(ctx, oob=oob)
+
+
+def _post_nav_sx(ctx: dict) -> str:
+    """Post desktop nav: calendar links + container nav (markets, etc.)."""
+    from quart import url_for, g
+
+    calendars = ctx.get("calendars") or []
+    select_colours = ctx.get("select_colours", "")
+    current_cal_slug = getattr(g, "calendar_slug", None)
+
+    parts = []
+    for cal in calendars:
+        cal_slug = getattr(cal, "slug", "") if hasattr(cal, "slug") else cal.get("slug", "")
+        cal_name = getattr(cal, "name", "") if hasattr(cal, "name") else cal.get("name", "")
+        href = url_for("calendar.get", calendar_slug=cal_slug)
+        is_sel = (cal_slug == current_cal_slug)
+        parts.append(sx_call("nav-link", href=href, icon="fa fa-calendar",
+                            label=cal_name, select_colours=select_colours,
+                            is_selected=is_sel))
+    # Container nav fragments (markets, etc.)
+    container_nav = ctx.get("container_nav", "")
+    if container_nav:
+        parts.append(container_nav)
+
+    # Admin cog → blog admin for this post (cross-domain, no HTMX)
+    rights = ctx.get("rights") or {}
+    has_admin = rights.get("admin") if isinstance(rights, dict) else getattr(rights, "admin", False)
+    if has_admin:
+        post = ctx.get("post") or {}
+        slug = post.get("slug", "")
+        styles = ctx.get("styles") or {}
+        nav_btn = styles.get("nav_button", "") if isinstance(styles, dict) else getattr(styles, "nav_button", "")
+        select_colours = ctx.get("select_colours", "")
+        admin_href = call_url(ctx, "blog_url", f"/{slug}/admin/")
+        aclass = f"{nav_btn} {select_colours}".strip() or (
+            "justify-center cursor-pointer flex flex-row items-center gap-2 "
+            "rounded bg-stone-200 text-black p-3"
+        )
+        parts.append(
+            f'<div class="relative nav-group">'
+            f'<a href="{admin_href}" class="{aclass}">'
+            f'<i class="fa fa-cog" aria-hidden="true"></i></a></div>'
+        )
+
+    return "".join(parts)
+
+
+# ---------------------------------------------------------------------------
+# Calendars header
+# ---------------------------------------------------------------------------
+
+def _calendars_header_sx(ctx: dict, *, oob: bool = False) -> str:
+    """Build the calendars section header row."""
+    from quart import url_for
+    link_href = url_for("calendars.home")
+    return sx_call("menu-row-sx", id="calendars-row", level=3,
+                  link_href=link_href,
+                  link_label_content=SxExpr(sx_call("events-calendars-label")),
+                  child_id="calendars-header-child", oob=oob)
+
+
+# ---------------------------------------------------------------------------
+# Calendar header
+# ---------------------------------------------------------------------------
+
+def _calendar_header_sx(ctx: dict, *, oob: bool = False) -> str:
+    """Build a single calendar's header row."""
+    from quart import url_for
+    calendar = ctx.get("calendar")
+    if not calendar:
+        return ""
+    cal_slug = getattr(calendar, "slug", "")
+    cal_name = getattr(calendar, "name", "")
+    cal_desc = getattr(calendar, "description", "") or ""
+
+    link_href = url_for("calendar.get", calendar_slug=cal_slug)
+    label_html = sx_call("events-calendar-label",
+                        name=cal_name, description=cal_desc)
+
+    # Desktop nav: slots + admin
+    nav_html = _calendar_nav_sx(ctx)
+
+    return sx_call("menu-row-sx", id="calendar-row", level=3,
+                  link_href=link_href, link_label_content=SxExpr(label_html),
+                  nav=SxExpr(nav_html) if nav_html else None, child_id="calendar-header-child", oob=oob)
+
+
+def _calendar_nav_sx(ctx: dict) -> str:
+    """Calendar desktop nav: Slots + admin link."""
+    from quart import url_for
+    calendar = ctx.get("calendar")
+    if not calendar:
+        return ""
+    cal_slug = getattr(calendar, "slug", "")
+    rights = ctx.get("rights") or {}
+    is_admin = getattr(rights, "admin", False) if hasattr(rights, "admin") else rights.get("admin", False)
+    select_colours = ctx.get("select_colours", "")
+
+    parts = []
+    slots_href = url_for("defpage_slots_listing", calendar_slug=cal_slug)
+    parts.append(sx_call("nav-link", href=slots_href, icon="fa fa-clock",
+                        label="Slots", select_colours=select_colours))
+    if is_admin:
+        admin_href = url_for("defpage_calendar_admin", calendar_slug=cal_slug)
+        parts.append(sx_call("nav-link", href=admin_href, icon="fa fa-cog",
+                            select_colours=select_colours))
+    return "(<> " + " ".join(parts) + ")" if parts else ""
+
+
+# ---------------------------------------------------------------------------
+# Day header
+# ---------------------------------------------------------------------------
+
+def _day_header_sx(ctx: dict, *, oob: bool = False) -> str:
+    """Build day detail header row."""
+    from quart import url_for
+    calendar = ctx.get("calendar")
+    if not calendar:
+        return ""
+    cal_slug = getattr(calendar, "slug", "")
+    day_date = ctx.get("day_date")
+    if not day_date:
+        return ""
+
+    link_href = url_for(
+        "calendar.day.show_day",
+        calendar_slug=cal_slug,
+        year=day_date.year,
+        month=day_date.month,
+        day=day_date.day,
+    )
+    label_html = sx_call("events-day-label",
+                        date_str=day_date.strftime("%A %d %B %Y"))
+
+    nav_html = _day_nav_sx(ctx)
+
+    return sx_call("menu-row-sx", id="day-row", level=4,
+                  link_href=link_href, link_label_content=SxExpr(label_html),
+                  nav=SxExpr(nav_html) if nav_html else None, child_id="day-header-child", oob=oob)
+
+
+def _day_nav_sx(ctx: dict) -> str:
+    """Day desktop nav: confirmed entries scrolling menu + admin link."""
+    from quart import url_for
+    calendar = ctx.get("calendar")
+    if not calendar:
+        return ""
+    cal_slug = getattr(calendar, "slug", "")
+    day_date = ctx.get("day_date")
+    confirmed_entries = ctx.get("confirmed_entries") or []
+    rights = ctx.get("rights") or {}
+    is_admin = getattr(rights, "admin", False) if hasattr(rights, "admin") else rights.get("admin", False)
+
+    parts = []
+    # Confirmed entries nav (scrolling menu)
+    if confirmed_entries:
+        entry_links = []
+        for entry in confirmed_entries:
+            href = url_for(
+                "calendar.day.calendar_entries.calendar_entry.get",
+                calendar_slug=cal_slug,
+                year=day_date.year,
+                month=day_date.month,
+                day=day_date.day,
+                entry_id=entry.id,
+            )
+            start = entry.start_at.strftime("%H:%M") if entry.start_at else ""
+            end = f" \u2013 {entry.end_at.strftime('%H:%M')}" if entry.end_at else ""
+            entry_links.append(sx_call("events-day-entry-link",
+                                      href=href, name=entry.name,
+                                      time_str=f"{start}{end}"))
+        inner = "".join(entry_links)
+        parts.append(sx_call("events-day-entries-nav", inner=SxExpr(inner)))
+
+    if is_admin and day_date:
+        admin_href = url_for(
+            "calendar.day.admin.admin",
+            calendar_slug=cal_slug,
+            year=day_date.year,
+            month=day_date.month,
+            day=day_date.day,
+        )
+        parts.append(sx_call("nav-link", href=admin_href, icon="fa fa-cog"))
+    return "".join(parts)
+
+
+# ---------------------------------------------------------------------------
+# Day admin header
+# ---------------------------------------------------------------------------
+
+def _day_admin_header_sx(ctx: dict, *, oob: bool = False) -> str:
+    """Build day admin header row."""
+    from quart import url_for
+    calendar = ctx.get("calendar")
+    if not calendar:
+        return ""
+    cal_slug = getattr(calendar, "slug", "")
+    day_date = ctx.get("day_date")
+    if not day_date:
+        return ""
+
+    link_href = url_for(
+        "calendar.day.admin.admin",
+        calendar_slug=cal_slug,
+        year=day_date.year,
+        month=day_date.month,
+        day=day_date.day,
+    )
+    return sx_call("menu-row-sx", id="day-admin-row", level=5,
+                  link_href=link_href, link_label="admin", icon="fa fa-cog",
+                  child_id="day-admin-header-child", oob=oob)
+
+
+# ---------------------------------------------------------------------------
+# Calendar admin header
+# ---------------------------------------------------------------------------
+
+def _calendar_admin_header_sx(ctx: dict, *, oob: bool = False) -> str:
+    """Build calendar admin header row with nav links."""
+    from quart import url_for
+    calendar = ctx.get("calendar")
+    cal_slug = getattr(calendar, "slug", "") if calendar else ""
+    select_colours = ctx.get("select_colours", "")
+
+    nav_parts = []
+    if cal_slug:
+        for endpoint, label in [
+            ("defpage_slots_listing", "slots"),
+            ("calendar.admin.calendar_description_edit", "description"),
+        ]:
+            href = url_for(endpoint, calendar_slug=cal_slug)
+            nav_parts.append(sx_call("nav-link", href=href, label=label,
+                                    select_colours=select_colours))
+
+    nav_html = "".join(nav_parts)
+    return sx_call("menu-row-sx", id="calendar-admin-row", level=4,
+                  link_label="admin", icon="fa fa-cog",
+                  nav=SxExpr(nav_html) if nav_html else None, child_id="calendar-admin-header-child", oob=oob)
+
+
+# ---------------------------------------------------------------------------
+# Markets header
+# ---------------------------------------------------------------------------
+
+def _markets_header_sx(ctx: dict, *, oob: bool = False) -> str:
+    """Build the markets section header row."""
+    from quart import url_for
+    link_href = url_for("defpage_events_markets")
+    return sx_call("menu-row-sx", id="markets-row", level=3,
+                  link_href=link_href,
+                  link_label_content=SxExpr(sx_call("events-markets-label")),
+                  child_id="markets-header-child", oob=oob)
+
+
+# ---------------------------------------------------------------------------
+# Calendars main panel
+# ---------------------------------------------------------------------------
+
+def _calendars_main_panel_sx(ctx: dict) -> str:
+    """Render the calendars list + create form panel."""
+    from quart import url_for
+    rights = ctx.get("rights") or {}
+    is_admin = getattr(rights, "admin", False) if hasattr(rights, "admin") else rights.get("admin", False)
+    has_access = ctx.get("has_access")
+    can_create = has_access("calendars.create_calendar") if callable(has_access) else is_admin
+    csrf_token = ctx.get("csrf_token")
+    csrf = csrf_token() if callable(csrf_token) else (csrf_token or "")
+
+    calendars = ctx.get("calendars") or []
+
+    form_html = ""
+    if can_create:
+        create_url = url_for("calendars.create_calendar")
+        form_html = sx_call("crud-create-form",
+                           create_url=create_url, csrf=csrf,
+                           errors_id="cal-create-errors", list_id="calendars-list",
+                           placeholder="e.g. Events, Gigs, Meetings", btn_label="Add calendar")
+
+    list_html = _calendars_list_sx(ctx, calendars)
+    return sx_call("crud-panel",
+                  form=SxExpr(form_html), list=SxExpr(list_html),
+                  list_id="calendars-list")
+
+
+def _calendars_list_sx(ctx: dict, calendars: list) -> str:
+    """Render the calendars list items."""
+    from quart import url_for
+    from shared.utils import route_prefix
+    csrf_token = ctx.get("csrf_token")
+    csrf = csrf_token() if callable(csrf_token) else (csrf_token or "")
+    prefix = route_prefix()
+
+    if not calendars:
+        return sx_call("empty-state", message="No calendars yet. Create one above.",
+                      cls="text-gray-500 mt-4")
+
+    parts = []
+    for cal in calendars:
+        cal_slug = getattr(cal, "slug", "")
+        cal_name = getattr(cal, "name", "")
+        href = prefix + url_for("calendar.get", calendar_slug=cal_slug)
+        del_url = url_for("calendar.delete", calendar_slug=cal_slug)
+        csrf_hdr = f'{{"X-CSRFToken":"{csrf}"}}'
+        parts.append(sx_call("crud-item",
+                            href=href, name=cal_name, slug=cal_slug,
+                            del_url=del_url, csrf_hdr=csrf_hdr,
+                            list_id="calendars-list",
+                            confirm_title="Delete calendar?",
+                            confirm_text="Entries will be hidden (soft delete)"))
+    return "".join(parts)
+
+
+# ---------------------------------------------------------------------------
+# Calendar month grid
+# ---------------------------------------------------------------------------
+
+def _calendar_main_panel_html(ctx: dict) -> str:
+    """Render the calendar month grid."""
+    from quart import url_for
+    from quart import session as qsession
+
+    calendar = ctx.get("calendar")
+    if not calendar:
+        return ""
+    cal_slug = getattr(calendar, "slug", "")
+    hx_select = ctx.get("hx_select_search", "#main-panel")
+    styles = ctx.get("styles") or {}
+    pill_cls = getattr(styles, "pill", "") if hasattr(styles, "pill") else styles.get("pill", "")
+
+    year = ctx.get("year", 2024)
+    month = ctx.get("month", 1)
+    month_name = ctx.get("month_name", "")
+    weekday_names = ctx.get("weekday_names", [])
+    weeks = ctx.get("weeks", [])
+    prev_month = ctx.get("prev_month", 1)
+    prev_month_year = ctx.get("prev_month_year", year)
+    next_month = ctx.get("next_month", 1)
+    next_month_year = ctx.get("next_month_year", year)
+    prev_year = ctx.get("prev_year", year - 1)
+    next_year = ctx.get("next_year", year + 1)
+    month_entries = ctx.get("month_entries") or []
+    user = ctx.get("user")
+    qs = qsession if "qsession" not in ctx else ctx["qsession"]
+
+    def nav_link(y, m):
+        return url_for("calendar.get", calendar_slug=cal_slug, year=y, month=m)
+
+    # Month navigation arrows
+    nav_arrows = []
+    for label, yr, mn in [
+        ("\u00ab", prev_year, month),
+        ("\u2039", prev_month_year, prev_month),
+    ]:
+        href = nav_link(yr, mn)
+        nav_arrows.append(sx_call("events-calendar-nav-arrow",
+                                 pill_cls=pill_cls, href=href, label=label))
+
+    nav_arrows.append(sx_call("events-calendar-month-label",
+                             month_name=month_name, year=str(year)))
+
+    for label, yr, mn in [
+        ("\u203a", next_month_year, next_month),
+        ("\u00bb", next_year, month),
+    ]:
+        href = nav_link(yr, mn)
+        nav_arrows.append(sx_call("events-calendar-nav-arrow",
+                                 pill_cls=pill_cls, href=href, label=label))
+
+    # Weekday headers
+    wd_parts = []
+    for wd in weekday_names:
+        wd_parts.append(sx_call("events-calendar-weekday", name=wd))
+    wd_html = "".join(wd_parts)
+
+    # Day cells
+    cells = []
+    for week in weeks:
+        for day_cell in week:
+            if isinstance(day_cell, dict):
+                in_month = day_cell.get("in_month", True)
+                is_today = day_cell.get("is_today", False)
+                day_date = day_cell.get("date")
+            else:
+                in_month = getattr(day_cell, "in_month", True)
+                is_today = getattr(day_cell, "is_today", False)
+                day_date = getattr(day_cell, "date", None)
+
+            cell_cls = "min-h-20 sm:min-h-24 bg-white px-3 py-2 text-xs"
+            if not in_month:
+                cell_cls += " bg-stone-50 text-stone-400"
+            if is_today:
+                cell_cls += " ring-2 ring-blue-500 z-10 relative"
+
+            # Day number link
+            day_num_html = ""
+            day_short_html = ""
+            if day_date:
+                day_href = url_for(
+                    "calendar.day.show_day",
+                    calendar_slug=cal_slug,
+                    year=day_date.year, month=day_date.month, day=day_date.day,
+                )
+                day_short_html = sx_call("events-calendar-day-short",
+                                        day_str=day_date.strftime("%a"))
+                day_num_html = sx_call("events-calendar-day-num",
+                                      pill_cls=pill_cls, href=day_href,
+                                      num=str(day_date.day))
+
+            # Entry badges for this day
+            entry_badges = []
+            if day_date:
+                for e in month_entries:
+                    if e.start_at and e.start_at.date() == day_date:
+                        is_mine = (
+                            (user and e.user_id == user.id)
+                            or (not user and e.session_id == qs.get("calendar_sid"))
+                        )
+                        if e.state == "confirmed":
+                            bg_cls = "bg-emerald-200 text-emerald-900" if is_mine else "bg-emerald-100 text-emerald-800"
+                        else:
+                            bg_cls = "bg-sky-100 text-sky-800" if is_mine else "bg-stone-100 text-stone-700"
+                        state_label = (e.state or "pending").replace("_", " ")
+                        entry_badges.append(sx_call("events-calendar-entry-badge",
+                                                   bg_cls=bg_cls, name=e.name,
+                                                   state_label=state_label))
+
+            badges_html = "(<> " + "".join(entry_badges) + ")" if entry_badges else ""
+            cells.append(sx_call("events-calendar-cell",
+                                cell_cls=cell_cls, day_short=SxExpr(day_short_html),
+                                day_num=SxExpr(day_num_html),
+                                badges=SxExpr(badges_html) if badges_html else None))
+
+    cells_html = "(<> " + "".join(cells) + ")"
+    arrows_html = "(<> " + "".join(nav_arrows) + ")"
+    wd_html = "(<> " + wd_html + ")"
+    return sx_call("events-calendar-grid",
+                  arrows=SxExpr(arrows_html), weekdays=SxExpr(wd_html),
+                  cells=SxExpr(cells_html))
+
+
+# ---------------------------------------------------------------------------
+# Day main panel
+# ---------------------------------------------------------------------------
+
+def _day_main_panel_html(ctx: dict) -> str:
+    """Render the day entries table + add button."""
+    from quart import url_for
+
+    calendar = ctx.get("calendar")
+    if not calendar:
+        return ""
+    cal_slug = getattr(calendar, "slug", "")
+    day_entries = ctx.get("day_entries") or []
+    day = ctx.get("day")
+    month = ctx.get("month")
+    year = ctx.get("year")
+    hx_select = ctx.get("hx_select_search", "#main-panel")
+    styles = ctx.get("styles") or {}
+    list_container = getattr(styles, "list_container", "") if hasattr(styles, "list_container") else styles.get("list_container", "")
+    pill_cls = getattr(styles, "pill", "") if hasattr(styles, "pill") else styles.get("pill", "")
+    tr_cls = getattr(styles, "tr", "") if hasattr(styles, "tr") else styles.get("tr", "")
+    pre_action = getattr(styles, "pre_action_button", "") if hasattr(styles, "pre_action_button") else styles.get("pre_action_button", "")
+
+    rows_html = ""
+    if day_entries:
+        row_parts = []
+        for entry in day_entries:
+            row_parts.append(_day_row_html(ctx, entry))
+        rows_html = "".join(row_parts)
+    else:
+        rows_html = sx_call("events-day-empty-row")
+
+    add_url = url_for(
+        "calendar.day.calendar_entries.add_form",
+        calendar_slug=cal_slug,
+        day=day, month=month, year=year,
+    )
+
+    return sx_call("events-day-table",
+                  list_container=list_container, rows=SxExpr(rows_html),
+                  pre_action=pre_action, add_url=add_url)
+
+
+def _day_row_html(ctx: dict, entry) -> str:
+    """Render a single day table row."""
+    from quart import url_for
+    calendar = ctx.get("calendar")
+    cal_slug = getattr(calendar, "slug", "")
+    day = ctx.get("day")
+    month = ctx.get("month")
+    year = ctx.get("year")
+    hx_select = ctx.get("hx_select_search", "#main-panel")
+    styles = ctx.get("styles") or {}
+    pill_cls = getattr(styles, "pill", "") if hasattr(styles, "pill") else styles.get("pill", "")
+    tr_cls = getattr(styles, "tr", "") if hasattr(styles, "tr") else styles.get("tr", "")
+
+    entry_href = url_for(
+        "calendar.day.calendar_entries.calendar_entry.get",
+        calendar_slug=cal_slug, day=day, month=month, year=year, entry_id=entry.id,
+    )
+
+    # Name
+    name_html = sx_call("events-day-row-name",
+                       href=entry_href, pill_cls=pill_cls, name=entry.name)
+
+    # Slot/Time
+    slot = getattr(entry, "slot", None)
+    if slot:
+        slot_href = url_for("defpage_slot_detail", calendar_slug=cal_slug, slot_id=slot.id)
+        time_start = slot.time_start.strftime("%H:%M") if slot.time_start else ""
+        time_end = f" \u2192 {slot.time_end.strftime('%H:%M')}" if slot.time_end else ""
+        slot_html = sx_call("events-day-row-slot",
+                           href=slot_href, pill_cls=pill_cls, slot_name=slot.name,
+                           time_str=f"({time_start}{time_end})")
+    else:
+        start = entry.start_at.strftime("%H:%M") if entry.start_at else ""
+        end = f" \u2192 {entry.end_at.strftime('%H:%M')}" if entry.end_at else ""
+        slot_html = sx_call("events-day-row-time", start=start, end=end)
+
+    # State
+    state = getattr(entry, "state", "pending") or "pending"
+    state_badge = _entry_state_badge_html(state)
+    state_td = sx_call("events-day-row-state",
+                      state_id=f"entry-state-{entry.id}", badge=SxExpr(state_badge))
+
+    # Cost
+    cost = getattr(entry, "cost", None)
+    cost_str = f"\u00a3{cost:.2f}" if cost is not None else "\u00a30.00"
+    cost_td = sx_call("events-day-row-cost", cost_str=cost_str)
+
+    # Tickets
+    tp = getattr(entry, "ticket_price", None)
+    if tp is not None:
+        tc = getattr(entry, "ticket_count", None)
+        tc_str = f"{tc} tickets" if tc is not None else "Unlimited"
+        tickets_td = sx_call("events-day-row-tickets",
+                            price_str=f"\u00a3{tp:.2f}", count_str=tc_str)
+    else:
+        tickets_td = sx_call("events-day-row-no-tickets")
+
+    actions_td = sx_call("events-day-row-actions")
+
+    return sx_call("events-day-row",
+                  tr_cls=tr_cls, name=SxExpr(name_html), slot=SxExpr(slot_html),
+                  state=SxExpr(state_td), cost=SxExpr(cost_td),
+                  tickets=SxExpr(tickets_td), actions=SxExpr(actions_td))
+
+
+# ---------------------------------------------------------------------------
+# Day admin main panel
+# ---------------------------------------------------------------------------
+
+def _day_admin_main_panel_html(ctx: dict) -> str:
+    """Render day admin panel (placeholder nav)."""
+    return sx_call("events-day-admin-panel")
+
+
+# ---------------------------------------------------------------------------
+# Calendar admin main panel
+# ---------------------------------------------------------------------------
+
+def _calendar_admin_main_panel_html(ctx: dict) -> str:
+    """Render calendar admin config panel with description editor."""
+    from quart import url_for
+    calendar = ctx.get("calendar")
+    if not calendar:
+        return ""
+    csrf_token = ctx.get("csrf_token")
+    csrf = csrf_token() if callable(csrf_token) else (csrf_token or "")
+    cal_slug = getattr(calendar, "slug", "")
+    desc = getattr(calendar, "description", "") or ""
+    hx_select = ctx.get("hx_select_search", "#main-panel")
+
+    desc_edit_url = url_for("calendar.admin.calendar_description_edit", calendar_slug=cal_slug)
+    description_html = _calendar_description_display_html(calendar, desc_edit_url)
+
+    return sx_call("events-calendar-admin-panel",
+                  description_content=SxExpr(description_html), csrf=csrf,
+                  description=desc)
+
+
+def _calendar_description_display_html(calendar, edit_url: str) -> str:
+    """Render calendar description display with edit button."""
+    desc = getattr(calendar, "description", "") or ""
+    return sx_call("events-calendar-description-display",
+                  description=desc, edit_url=edit_url)
+
+
+# ---------------------------------------------------------------------------
+# Markets main panel
+# ---------------------------------------------------------------------------
+
+def _markets_main_panel_html(ctx: dict) -> str:
+    """Render markets list + create form panel."""
+    from quart import url_for
+    rights = ctx.get("rights") or {}
+    is_admin = getattr(rights, "admin", False) if hasattr(rights, "admin") else rights.get("admin", False)
+    has_access = ctx.get("has_access")
+    can_create = has_access("markets.create_market") if callable(has_access) else is_admin
+    csrf_token = ctx.get("csrf_token")
+    csrf = csrf_token() if callable(csrf_token) else (csrf_token or "")
+    markets = ctx.get("markets") or []
+
+    form_html = ""
+    if can_create:
+        create_url = url_for("markets.create_market")
+        form_html = sx_call("crud-create-form",
+                           create_url=create_url, csrf=csrf,
+                           errors_id="market-create-errors", list_id="markets-list",
+                           placeholder="e.g. Farm Shop, Bakery", btn_label="Add market")
+
+    list_html = _markets_list_html(ctx, markets)
+    return sx_call("crud-panel",
+                  form=SxExpr(form_html), list=SxExpr(list_html),
+                  list_id="markets-list")
+
+
+def _markets_list_html(ctx: dict, markets: list) -> str:
+    """Render markets list items."""
+    from quart import url_for
+    csrf_token = ctx.get("csrf_token")
+    csrf = csrf_token() if callable(csrf_token) else (csrf_token or "")
+    post = ctx.get("post") or {}
+    slug = post.get("slug", "")
+
+    if not markets:
+        return sx_call("empty-state", message="No markets yet. Create one above.",
+                      cls="text-gray-500 mt-4")
+
+    parts = []
+    for m in markets:
+        m_slug = getattr(m, "slug", "") if hasattr(m, "slug") else m.get("slug", "")
+        m_name = getattr(m, "name", "") if hasattr(m, "name") else m.get("name", "")
+        market_href = call_url(ctx, "market_url", f"/{slug}/{m_slug}/")
+        del_url = url_for("markets.delete_market", market_slug=m_slug)
+        csrf_hdr = f'{{"X-CSRFToken":"{csrf}"}}'
+        parts.append(sx_call("crud-item",
+                            href=market_href, name=m_name,
+                            slug=m_slug, del_url=del_url,
+                            csrf_hdr=csrf_hdr,
+                            list_id="markets-list",
+                            confirm_title="Delete market?",
+                            confirm_text="Products will be hidden (soft delete)"))
+    return "".join(parts)
+
+
+# ---------------------------------------------------------------------------
+# Calendar admin helper
+# ---------------------------------------------------------------------------
+
+async def _events_post_admin_header_sx(ctx: dict, *, oob: bool = False,
+                                    selected: str = "") -> str:
+    """Post-level admin row for events — delegates to shared helper."""
+    slug = (ctx.get("post") or {}).get("slug", "")
+    return await post_admin_header_sx(ctx, slug, oob=oob, selected=selected)
--- a/events/sxc/pages/entries.py
+++ b/events/sxc/pages/entries.py
--- a/events/sxc/pages/helpers.py
+++ b/events/sxc/pages/helpers.py
@@ -0,0 +1,682 @@
+"""Layout registrations, page helpers, and shared hydration helpers."""
+from __future__ import annotations
+
+from typing import Any
+
+from shared.sx.helpers import sx_call
+
+from .utils import _clear_deeper_oob, _ensure_container_nav
+from .calendar import (
+    _post_header_sx, _calendar_header_sx,
+    _calendar_admin_header_sx, _day_header_sx,
+    _day_admin_header_sx, _markets_header_sx,
+    _calendars_main_panel_sx,
+    _calendar_admin_main_panel_html,
+    _day_admin_main_panel_html,
+    _markets_main_panel_html,
+)
+from .entries import (
+    _entry_header_html, _entry_main_panel_html,
+    _entry_nav_html,
+    _entry_admin_header_html, _entry_admin_main_panel_html,
+)
+from .tickets import (
+    _tickets_main_panel_html, _ticket_detail_panel_html,
+    _ticket_admin_main_panel_html,
+    _ticket_types_header_html, _ticket_type_header_html,
+    render_ticket_type_main_panel, render_ticket_types_table,
+)
+from .slots import (
+    _slot_header_html, render_slot_main_panel, render_slots_table,
+)
+
+
+# ---------------------------------------------------------------------------
+# Shared hydration helpers
+# ---------------------------------------------------------------------------
+
+def _add_to_defpage_ctx(**kwargs: Any) -> None:
+    """Add data to g._defpage_ctx for the app-level context_processor."""
+    from quart import g
+    if not hasattr(g, '_defpage_ctx'):
+        g._defpage_ctx = {}
+    g._defpage_ctx.update(kwargs)
+
+
+async def _ensure_calendar(calendar_slug: str | None) -> None:
+    """Load calendar into g.calendar if not already present."""
+    from quart import g, abort
+    if hasattr(g, 'calendar'):
+        _add_to_defpage_ctx(calendar=g.calendar)
+        return
+    from bp.calendar.services.calendar_view import (
+        get_calendar_by_post_and_slug, get_calendar_by_slug,
+    )
+    post_data = getattr(g, "post_data", None)
+    if post_data:
+        post_id = (post_data.get("post") or {}).get("id")
+        cal = await get_calendar_by_post_and_slug(g.s, post_id, calendar_slug)
+    else:
+        cal = await get_calendar_by_slug(g.s, calendar_slug)
+    if not cal:
+        abort(404)
+    g.calendar = cal
+    g.calendar_slug = calendar_slug
+    _add_to_defpage_ctx(calendar=cal)
+
+
+async def _ensure_entry(entry_id: int | None) -> None:
+    """Load calendar entry into g.entry if not already present."""
+    from quart import g, abort
+    if hasattr(g, 'entry'):
+        _add_to_defpage_ctx(entry=g.entry)
+        return
+    from sqlalchemy import select
+    from models.calendars import CalendarEntry
+    result = await g.s.execute(
+        select(CalendarEntry).where(
+            CalendarEntry.id == entry_id,
+            CalendarEntry.deleted_at.is_(None),
+        )
+    )
+    entry = result.scalar_one_or_none()
+    if entry is None:
+        abort(404)
+    g.entry = entry
+    _add_to_defpage_ctx(entry=entry)
+
+
+async def _ensure_entry_context(entry_id: int | None) -> None:
+    """Load full entry context (ticket data, posts) into g.* and _defpage_ctx."""
+    from quart import g
+    from sqlalchemy import select
+    from sqlalchemy.orm import selectinload
+    from models.calendars import CalendarEntry
+    from bp.tickets.services.tickets import (
+        get_available_ticket_count,
+        get_sold_ticket_count,
+        get_user_reserved_count,
+    )
+    from shared.infrastructure.cart_identity import current_cart_identity
+    from bp.calendar_entry.services.post_associations import get_entry_posts
+
+    await _ensure_entry(entry_id)
+
+    # Reload with ticket_types eagerly loaded
+    stmt = (
+        select(CalendarEntry)
+        .where(CalendarEntry.id == entry_id, CalendarEntry.deleted_at.is_(None))
+        .options(selectinload(CalendarEntry.ticket_types))
+    )
+    result = await g.s.execute(stmt)
+    calendar_entry = result.scalar_one_or_none()
+
+    if calendar_entry and getattr(g, "calendar", None):
+        if calendar_entry.calendar_id != g.calendar.id:
+            calendar_entry = None
+
+    if calendar_entry:
+        await g.s.refresh(calendar_entry, ['slot'])
+        g.entry = calendar_entry
+        entry_posts = await get_entry_posts(g.s, calendar_entry.id)
+        ticket_remaining = await get_available_ticket_count(g.s, calendar_entry.id)
+        ticket_sold_count = await get_sold_ticket_count(g.s, calendar_entry.id)
+        ident = current_cart_identity()
+        user_ticket_count = await get_user_reserved_count(
+            g.s, calendar_entry.id,
+            user_id=ident["user_id"],
+            session_id=ident["session_id"],
+        )
+        user_ticket_counts_by_type = {}
+        if calendar_entry.ticket_types:
+            for tt in calendar_entry.ticket_types:
+                if tt.deleted_at is None:
+                    user_ticket_counts_by_type[tt.id] = await get_user_reserved_count(
+                        g.s, calendar_entry.id,
+                        user_id=ident["user_id"],
+                        session_id=ident["session_id"],
+                        ticket_type_id=tt.id,
+                    )
+        _add_to_defpage_ctx(
+            entry=calendar_entry,
+            entry_posts=entry_posts,
+            ticket_remaining=ticket_remaining,
+            ticket_sold_count=ticket_sold_count,
+            user_ticket_count=user_ticket_count,
+            user_ticket_counts_by_type=user_ticket_counts_by_type,
+        )
+
+
+async def _ensure_day_data(year: int, month: int, day: int) -> None:
+    """Load day-specific data for layout header functions."""
+    from quart import g, session as qsession
+    if hasattr(g, 'day_date'):
+        return
+    from datetime import date as date_cls, datetime, timezone, timedelta
+    from sqlalchemy import select
+    from bp.calendar.services import get_visible_entries_for_period
+    from models.calendars import CalendarSlot
+
+    calendar = getattr(g, "calendar", None)
+    if not calendar:
+        return
+
+    try:
+        day_date = date_cls(year, month, day)
+    except (ValueError, TypeError):
+        return
+
+    period_start = datetime(year, month, day, tzinfo=timezone.utc)
+    period_end = period_start + timedelta(days=1)
+
+    user = getattr(g, "user", None)
+    session_id = qsession.get("calendar_sid")
+
+    visible = await get_visible_entries_for_period(
+        sess=g.s,
+        calendar_id=calendar.id,
+        period_start=period_start,
+        period_end=period_end,
+        user=user,
+        session_id=session_id,
+    )
+
+    weekday_attr = ["mon", "tue", "wed", "thu", "fri", "sat", "sun"][day_date.weekday()]
+    stmt = (
+        select(CalendarSlot)
+        .where(
+            CalendarSlot.calendar_id == calendar.id,
+            getattr(CalendarSlot, weekday_attr) == True,  # noqa: E712
+            CalendarSlot.deleted_at.is_(None),
+        )
+        .order_by(CalendarSlot.time_start.asc(), CalendarSlot.id.asc())
+    )
+    result = await g.s.execute(stmt)
+    day_slots = list(result.scalars())
+
+    g.day_date = day_date
+    _add_to_defpage_ctx(
+        qsession=qsession,
+        day_date=day_date,
+        day=day,
+        year=year,
+        month=month,
+        day_entries=visible.merged_entries,
+        user_entries=visible.user_entries,
+        confirmed_entries=visible.confirmed_entries,
+        day_slots=day_slots,
+    )
+
+
+# ---------------------------------------------------------------------------
+# Layouts
+# ---------------------------------------------------------------------------
+
+def _register_events_layouts() -> None:
+    from shared.sx.layouts import register_custom_layout
+    register_custom_layout("events-calendar-admin", _cal_admin_full, _cal_admin_oob)
+    register_custom_layout("events-slots", _slots_full, _slots_oob)
+    register_custom_layout("events-slot", _slot_full, _slot_oob)
+    register_custom_layout("events-day-admin", _day_admin_full, _day_admin_oob)
+    register_custom_layout("events-entry", _entry_full, _entry_oob)
+    register_custom_layout("events-entry-admin", _entry_admin_full, _entry_admin_oob)
+    register_custom_layout("events-ticket-types", _ticket_types_full, _ticket_types_oob)
+    register_custom_layout("events-ticket-type", _ticket_type_full, _ticket_type_oob)
+    register_custom_layout("events-markets", _markets_full, _markets_oob)
+
+
+# --- Calendar admin layout (root + post + child(post-admin + calendar + cal-admin)) ---
+
+async def _cal_admin_full(ctx: dict, **kw: Any) -> str:
+    from shared.sx.helpers import render_to_sx_with_env, post_admin_header_sx
+    from shared.sx.parser import SxExpr
+    ctx = await _ensure_container_nav(ctx)
+    slug = (ctx.get("post") or {}).get("slug", "")
+    return await render_to_sx_with_env("events-cal-admin-layout-full", {},
+        post_header=SxExpr(await _post_header_sx(ctx)),
+        admin_header=SxExpr(await post_admin_header_sx(ctx, slug, selected="calendars")),
+        calendar_header=SxExpr(_calendar_header_sx(ctx)),
+        calendar_admin_header=SxExpr(_calendar_admin_header_sx(ctx)),
+    )
+
+
+async def _cal_admin_oob(ctx: dict, **kw: Any) -> str:
+    from shared.sx.helpers import render_to_sx_with_env, post_admin_header_sx, oob_header_sx
+    from shared.sx.parser import SxExpr
+    ctx = await _ensure_container_nav(ctx)
+    slug = (ctx.get("post") or {}).get("slug", "")
+    return await render_to_sx_with_env("events-cal-admin-layout-oob", {},
+        admin_oob=SxExpr(await post_admin_header_sx(ctx, slug, oob=True, selected="calendars")),
+        cal_oob=SxExpr(_calendar_header_sx(ctx, oob=True)),
+        cal_admin_oob_wrap=SxExpr(await oob_header_sx("calendar-header-child",
+            "calendar-admin-header-child", _calendar_admin_header_sx(ctx))),
+        clear_oob=SxExpr(_clear_deeper_oob("post-row", "post-header-child",
+            "post-admin-row", "post-admin-header-child",
+            "calendar-row", "calendar-header-child",
+            "calendar-admin-row", "calendar-admin-header-child")),
+    )
+
+
+# --- Slots layout (same full as cal-admin but different OOB) ---
+
+async def _slots_full(ctx: dict, **kw: Any) -> str:
+    return await _cal_admin_full({**ctx, "is_admin_section": True}, **kw)
+
+
+async def _slots_oob(ctx: dict, **kw: Any) -> str:
+    from shared.sx.helpers import render_to_sx_with_env, post_admin_header_sx
+    from shared.sx.parser import SxExpr
+    ctx = await _ensure_container_nav({**ctx, "is_admin_section": True})
+    slug = (ctx.get("post") or {}).get("slug", "")
+    return await render_to_sx_with_env("events-slots-layout-oob", {},
+        admin_oob=SxExpr(await post_admin_header_sx(ctx, slug, oob=True, selected="calendars")),
+        cal_admin_oob=SxExpr(_calendar_admin_header_sx(ctx, oob=True)),
+        clear_oob=SxExpr(_clear_deeper_oob("post-row", "post-header-child",
+            "post-admin-row", "post-admin-header-child",
+            "calendar-row", "calendar-header-child",
+            "calendar-admin-row", "calendar-admin-header-child")),
+    )
+
+
+# --- Slot detail layout (extends cal-admin with slot header) ---
+
+async def _slot_full(ctx: dict, **kw: Any) -> str:
+    from shared.sx.helpers import render_to_sx_with_env, post_admin_header_sx
+    from shared.sx.parser import SxExpr
+    ctx = await _ensure_container_nav({**ctx, "is_admin_section": True})
+    slug = (ctx.get("post") or {}).get("slug", "")
+    return await render_to_sx_with_env("events-slot-layout-full", {},
+        post_header=SxExpr(await _post_header_sx(ctx)),
+        admin_header=SxExpr(await post_admin_header_sx(ctx, slug, selected="calendars")),
+        calendar_header=SxExpr(_calendar_header_sx(ctx)),
+        calendar_admin_header=SxExpr(_calendar_admin_header_sx(ctx)),
+        slot_header=SxExpr(_slot_header_html(ctx)),
+    )
+
+
+async def _slot_oob(ctx: dict, **kw: Any) -> str:
+    from shared.sx.helpers import render_to_sx_with_env, post_admin_header_sx, oob_header_sx
+    from shared.sx.parser import SxExpr
+    ctx = await _ensure_container_nav({**ctx, "is_admin_section": True})
+    slug = (ctx.get("post") or {}).get("slug", "")
+    return await render_to_sx_with_env("events-slot-layout-oob", {},
+        admin_oob=SxExpr(await post_admin_header_sx(ctx, slug, oob=True, selected="calendars")),
+        cal_admin_oob=SxExpr(_calendar_admin_header_sx(ctx, oob=True)),
+        slot_oob_wrap=SxExpr(await oob_header_sx("calendar-admin-header-child",
+            "slot-header-child", _slot_header_html(ctx))),
+        clear_oob=SxExpr(_clear_deeper_oob("post-row", "post-header-child",
+            "post-admin-row", "post-admin-header-child",
+            "calendar-row", "calendar-header-child",
+            "calendar-admin-row", "calendar-admin-header-child",
+            "slot-row", "slot-header-child")),
+    )
+
+
+# --- Day admin layout (root + post + post-admin + child(cal + day + day-admin)) ---
+
+async def _day_admin_full(ctx: dict, **kw: Any) -> str:
+    from shared.sx.helpers import render_to_sx_with_env, post_admin_header_sx
+    from shared.sx.parser import SxExpr
+    ctx = await _ensure_container_nav(ctx)
+    slug = (ctx.get("post") or {}).get("slug", "")
+    return await render_to_sx_with_env("events-day-admin-layout-full", {},
+        post_header=SxExpr(await _post_header_sx(ctx)),
+        admin_header=SxExpr(await post_admin_header_sx(ctx, slug, selected="calendars")),
+        calendar_header=SxExpr(_calendar_header_sx(ctx)),
+        day_header=SxExpr(_day_header_sx(ctx)),
+        day_admin_header=SxExpr(_day_admin_header_sx(ctx)),
+    )
+
+
+async def _day_admin_oob(ctx: dict, **kw: Any) -> str:
+    from shared.sx.helpers import render_to_sx_with_env, post_admin_header_sx, oob_header_sx
+    from shared.sx.parser import SxExpr
+    ctx = await _ensure_container_nav(ctx)
+    slug = (ctx.get("post") or {}).get("slug", "")
+    return await render_to_sx_with_env("events-day-admin-layout-oob", {},
+        admin_oob=SxExpr(await post_admin_header_sx(ctx, slug, oob=True, selected="calendars")),
+        cal_oob=SxExpr(_calendar_header_sx(ctx, oob=True)),
+        day_admin_oob_wrap=SxExpr(await oob_header_sx("day-header-child",
+            "day-admin-header-child", _day_admin_header_sx(ctx))),
+        clear_oob=SxExpr(_clear_deeper_oob("post-row", "post-header-child",
+            "post-admin-row", "post-admin-header-child",
+            "calendar-row", "calendar-header-child",
+            "day-row", "day-header-child",
+            "day-admin-row", "day-admin-header-child")),
+    )
+
+
+# --- Entry layout (root + child(post + cal + day + entry), + menu) ---
+
+async def _entry_full(ctx: dict, **kw: Any) -> str:
+    from shared.sx.helpers import render_to_sx_with_env
+    from shared.sx.parser import SxExpr
+    return await render_to_sx_with_env("events-entry-layout-full", {},
+        post_header=SxExpr(await _post_header_sx(ctx)),
+        calendar_header=SxExpr(_calendar_header_sx(ctx)),
+        day_header=SxExpr(_day_header_sx(ctx)),
+        entry_header=SxExpr(_entry_header_html(ctx)),
+    )
+
+
+async def _entry_oob(ctx: dict, **kw: Any) -> str:
+    from shared.sx.helpers import render_to_sx_with_env, oob_header_sx
+    from shared.sx.parser import SxExpr
+    return await render_to_sx_with_env("events-entry-layout-oob", {},
+        day_oob=SxExpr(_day_header_sx(ctx, oob=True)),
+        entry_oob_wrap=SxExpr(await oob_header_sx("day-header-child",
+            "entry-header-child", _entry_header_html(ctx))),
+        clear_oob=SxExpr(_clear_deeper_oob("post-row", "post-header-child",
+            "calendar-row", "calendar-header-child",
+            "day-row", "day-header-child",
+            "entry-row", "entry-header-child")),
+    )
+
+
+# --- Entry admin layout (root + post + child(post-admin + cal + day + entry + entry-admin), + menu) ---
+
+async def _entry_admin_full(ctx: dict, **kw: Any) -> str:
+    from shared.sx.helpers import render_to_sx_with_env, post_admin_header_sx
+    from shared.sx.parser import SxExpr
+    ctx = await _ensure_container_nav(ctx)
+    slug = (ctx.get("post") or {}).get("slug", "")
+    return await render_to_sx_with_env("events-entry-admin-layout-full", {},
+        post_header=SxExpr(await _post_header_sx(ctx)),
+        admin_header=SxExpr(await post_admin_header_sx(ctx, slug, selected="calendars")),
+        calendar_header=SxExpr(_calendar_header_sx(ctx)),
+        day_header=SxExpr(_day_header_sx(ctx)),
+        entry_header=SxExpr(_entry_header_html(ctx)),
+        entry_admin_header=SxExpr(_entry_admin_header_html(ctx)),
+    )
+
+
+async def _entry_admin_oob(ctx: dict, **kw: Any) -> str:
+    from shared.sx.helpers import render_to_sx_with_env, post_admin_header_sx, oob_header_sx
+    from shared.sx.parser import SxExpr
+    ctx = await _ensure_container_nav(ctx)
+    slug = (ctx.get("post") or {}).get("slug", "")
+    return await render_to_sx_with_env("events-entry-admin-layout-oob", {},
+        admin_oob=SxExpr(await post_admin_header_sx(ctx, slug, oob=True, selected="calendars")),
+        entry_oob=SxExpr(_entry_header_html(ctx, oob=True)),
+        entry_admin_oob_wrap=SxExpr(await oob_header_sx("entry-header-child",
+            "entry-admin-header-child", _entry_admin_header_html(ctx))),
+        clear_oob=SxExpr(_clear_deeper_oob("post-row", "post-header-child",
+            "post-admin-row", "post-admin-header-child",
+            "calendar-row", "calendar-header-child",
+            "day-row", "day-header-child",
+            "entry-row", "entry-header-child",
+            "entry-admin-row", "entry-admin-header-child")),
+    )
+
+
+# --- Ticket types layout (extends entry admin with ticket-types header, + menu) ---
+
+async def _ticket_types_full(ctx: dict, **kw: Any) -> str:
+    from shared.sx.helpers import render_to_sx_with_env
+    from shared.sx.parser import SxExpr
+    return await render_to_sx_with_env("events-ticket-types-layout-full", {},
+        post_header=SxExpr(await _post_header_sx(ctx)),
+        calendar_header=SxExpr(_calendar_header_sx(ctx)),
+        day_header=SxExpr(_day_header_sx(ctx)),
+        entry_header=SxExpr(_entry_header_html(ctx)),
+        entry_admin_header=SxExpr(_entry_admin_header_html(ctx)),
+        ticket_types_header=SxExpr(_ticket_types_header_html(ctx)),
+    )
+
+
+async def _ticket_types_oob(ctx: dict, **kw: Any) -> str:
+    from shared.sx.helpers import render_to_sx_with_env, oob_header_sx
+    from shared.sx.parser import SxExpr
+    return await render_to_sx_with_env("events-ticket-types-layout-oob", {},
+        entry_admin_oob=SxExpr(_entry_admin_header_html(ctx, oob=True)),
+        ticket_types_oob_wrap=SxExpr(await oob_header_sx("entry-admin-header-child",
+            "ticket_types-header-child", _ticket_types_header_html(ctx))),
+    )
+
+
+# --- Ticket type detail layout (extends ticket types with ticket-type header, + menu) ---
+
+async def _ticket_type_full(ctx: dict, **kw: Any) -> str:
+    from shared.sx.helpers import render_to_sx_with_env
+    from shared.sx.parser import SxExpr
+    return await render_to_sx_with_env("events-ticket-type-layout-full", {},
+        post_header=SxExpr(await _post_header_sx(ctx)),
+        calendar_header=SxExpr(_calendar_header_sx(ctx)),
+        day_header=SxExpr(_day_header_sx(ctx)),
+        entry_header=SxExpr(_entry_header_html(ctx)),
+        entry_admin_header=SxExpr(_entry_admin_header_html(ctx)),
+        ticket_types_header=SxExpr(_ticket_types_header_html(ctx)),
+        ticket_type_header=SxExpr(_ticket_type_header_html(ctx)),
+    )
+
+
+async def _ticket_type_oob(ctx: dict, **kw: Any) -> str:
+    from shared.sx.helpers import render_to_sx_with_env, oob_header_sx
+    from shared.sx.parser import SxExpr
+    return await render_to_sx_with_env("events-ticket-type-layout-oob", {},
+        ticket_types_oob=SxExpr(_ticket_types_header_html(ctx, oob=True)),
+        ticket_type_oob_wrap=SxExpr(await oob_header_sx("ticket_types-header-child",
+            "ticket_type-header-child", _ticket_type_header_html(ctx))),
+    )
+
+
+# --- Markets layout (root + child(post + markets)) ---
+
+async def _markets_full(ctx: dict, **kw: Any) -> str:
+    from shared.sx.helpers import render_to_sx_with_env
+    from shared.sx.parser import SxExpr
+    return await render_to_sx_with_env("events-markets-layout-full", {},
+        post_header=SxExpr(await _post_header_sx(ctx)),
+        markets_header=SxExpr(_markets_header_sx(ctx)),
+    )
+
+
+async def _markets_oob(ctx: dict, **kw: Any) -> str:
+    from shared.sx.helpers import render_to_sx_with_env, oob_header_sx
+    from shared.sx.parser import SxExpr
+    return await render_to_sx_with_env("events-markets-layout-oob", {},
+        post_oob=SxExpr(await _post_header_sx(ctx, oob=True)),
+        markets_oob_wrap=SxExpr(await oob_header_sx("post-header-child",
+            "markets-header-child", _markets_header_sx(ctx))),
+    )
+
+
+# ---------------------------------------------------------------------------
+# Page helpers
+# ---------------------------------------------------------------------------
+
+def _register_events_helpers() -> None:
+    from shared.sx.pages import register_page_helpers
+
+    register_page_helpers("events", {
+        "calendar-admin-content": _h_calendar_admin_content,
+        "day-admin-content": _h_day_admin_content,
+        "slots-content": _h_slots_content,
+        "slot-content": _h_slot_content,
+        "entry-content": _h_entry_content,
+        "entry-menu": _h_entry_menu,
+        "entry-admin-content": _h_entry_admin_content,
+        "admin-menu": _h_admin_menu,
+        "ticket-types-content": _h_ticket_types_content,
+        "ticket-type-content": _h_ticket_type_content,
+        "tickets-content": _h_tickets_content,
+        "ticket-detail-content": _h_ticket_detail_content,
+        "ticket-admin-content": _h_ticket_admin_content,
+        "markets-content": _h_markets_content,
+    })
+
+
+async def _h_calendar_admin_content(calendar_slug=None, **kw):
+    await _ensure_calendar(calendar_slug)
+    from shared.sx.page import get_template_context
+    ctx = await get_template_context()
+    return _calendar_admin_main_panel_html(ctx)
+
+
+async def _h_day_admin_content(calendar_slug=None, year=None, month=None, day=None, **kw):
+    await _ensure_calendar(calendar_slug)
+    if year is not None:
+        await _ensure_day_data(int(year), int(month), int(day))
+    return _day_admin_main_panel_html({})
+
+
+async def _h_slots_content(calendar_slug=None, **kw):
+    from quart import g
+    await _ensure_calendar(calendar_slug)
+    calendar = getattr(g, "calendar", None)
+    from bp.slots.services.slots import list_slots as svc_list_slots
+    slots = await svc_list_slots(g.s, calendar.id) if calendar else []
+    _add_to_defpage_ctx(slots=slots)
+    return render_slots_table(slots, calendar)
+
+
+async def _h_slot_content(calendar_slug=None, slot_id=None, **kw):
+    from quart import g, abort
+    await _ensure_calendar(calendar_slug)
+    from bp.slot.services.slot import get_slot as svc_get_slot
+    slot = await svc_get_slot(g.s, slot_id) if slot_id else None
+    if not slot:
+        abort(404)
+    g.slot = slot
+    _add_to_defpage_ctx(slot=slot)
+    calendar = getattr(g, "calendar", None)
+    return render_slot_main_panel(slot, calendar)
+
+
+async def _h_entry_content(calendar_slug=None, entry_id=None, **kw):
+    await _ensure_calendar(calendar_slug)
+    await _ensure_entry_context(entry_id)
+    from shared.sx.page import get_template_context
+    ctx = await get_template_context()
+    return _entry_main_panel_html(ctx)
+
+
+async def _h_entry_menu(calendar_slug=None, entry_id=None, **kw):
+    await _ensure_calendar(calendar_slug)
+    await _ensure_entry_context(entry_id)
+    from shared.sx.page import get_template_context
+    ctx = await get_template_context()
+    return _entry_nav_html(ctx)
+
+
+async def _h_entry_admin_content(calendar_slug=None, entry_id=None, **kw):
+    await _ensure_calendar(calendar_slug)
+    await _ensure_entry_context(entry_id)
+    from shared.sx.page import get_template_context
+    ctx = await get_template_context()
+    return _entry_admin_main_panel_html(ctx)
+
+
+def _h_admin_menu():
+    return sx_call("events-admin-placeholder-nav")
+
+
+async def _h_ticket_types_content(calendar_slug=None, entry_id=None,
+                                   year=None, month=None, day=None, **kw):
+    from quart import g
+    await _ensure_calendar(calendar_slug)
+    await _ensure_entry(entry_id)
+    entry = getattr(g, "entry", None)
+    calendar = getattr(g, "calendar", None)
+    from bp.ticket_types.services.tickets import list_ticket_types as svc_list_ticket_types
+    ticket_types = await svc_list_ticket_types(g.s, entry.id) if entry else []
+    _add_to_defpage_ctx(ticket_types=ticket_types)
+    return render_ticket_types_table(ticket_types, entry, calendar, day, month, year)
+
+
+async def _h_ticket_type_content(calendar_slug=None, entry_id=None,
+                                  ticket_type_id=None, year=None, month=None, day=None, **kw):
+    from quart import g, abort
+    await _ensure_calendar(calendar_slug)
+    await _ensure_entry(entry_id)
+    from bp.ticket_type.services.ticket import get_ticket_type as svc_get_ticket_type
+    ticket_type = await svc_get_ticket_type(g.s, ticket_type_id) if ticket_type_id else None
+    if not ticket_type:
+        abort(404)
+    g.ticket_type = ticket_type
+    _add_to_defpage_ctx(ticket_type=ticket_type)
+    entry = getattr(g, "entry", None)
+    calendar = getattr(g, "calendar", None)
+    return render_ticket_type_main_panel(ticket_type, entry, calendar, day, month, year)
+
+
+async def _h_tickets_content(**kw):
+    from quart import g
+    from shared.infrastructure.cart_identity import current_cart_identity
+    from bp.tickets.services.tickets import get_user_tickets
+    ident = current_cart_identity()
+    tickets = await get_user_tickets(
+        g.s,
+        user_id=ident["user_id"],
+        session_id=ident["session_id"],
+    )
+    from shared.sx.page import get_template_context
+    ctx = await get_template_context()
+    return _tickets_main_panel_html(ctx, tickets)
+
+
+async def _h_ticket_detail_content(code=None, **kw):
+    from quart import g, abort
+    from shared.infrastructure.cart_identity import current_cart_identity
+    from bp.tickets.services.tickets import get_ticket_by_code
+    ticket = await get_ticket_by_code(g.s, code) if code else None
+    if not ticket:
+        abort(404)
+    # Verify ownership
+    ident = current_cart_identity()
+    if ident["user_id"] is not None:
+        if ticket.user_id != ident["user_id"]:
+            abort(404)
+    elif ident["session_id"] is not None:
+        if ticket.session_id != ident["session_id"]:
+            abort(404)
+    else:
+        abort(404)
+    from shared.sx.page import get_template_context
+    ctx = await get_template_context()
+    return _ticket_detail_panel_html(ctx, ticket)
+
+
+async def _h_ticket_admin_content(**kw):
+    from quart import g
+    from sqlalchemy import select, func
+    from sqlalchemy.orm import selectinload
+    from models.calendars import CalendarEntry, Ticket
+
+    result = await g.s.execute(
+        select(Ticket)
+        .options(
+            selectinload(Ticket.entry).selectinload(CalendarEntry.calendar),
+            selectinload(Ticket.ticket_type),
+        )
+        .order_by(Ticket.created_at.desc())
+        .limit(50)
+    )
+    tickets = result.scalars().all()
+
+    total = await g.s.scalar(select(func.count(Ticket.id)))
+    confirmed = await g.s.scalar(
+        select(func.count(Ticket.id)).where(Ticket.state == "confirmed")
+    )
+    checked_in = await g.s.scalar(
+        select(func.count(Ticket.id)).where(Ticket.state == "checked_in")
+    )
+    reserved = await g.s.scalar(
+        select(func.count(Ticket.id)).where(Ticket.state == "reserved")
+    )
+    stats = {
+        "total": total or 0,
+        "confirmed": confirmed or 0,
+        "checked_in": checked_in or 0,
+        "reserved": reserved or 0,
+    }
+
+    from shared.sx.page import get_template_context
+    ctx = await get_template_context()
+    return _ticket_admin_main_panel_html(ctx, tickets, stats)
+
+
+async def _h_markets_content(**kw):
+    from shared.sx.page import get_template_context
+    ctx = await get_template_context()
+    return _markets_main_panel_html(ctx)
--- a/events/sxc/pages/layouts.py
+++ b/events/sxc/pages/layouts.py
@@ -0,0 +1,288 @@
+"""Layout registration + header builders."""
+from __future__ import annotations
+
+from typing import Any
+
+from shared.sx.parser import SxExpr
+
+from .utils import _clear_deeper_oob, _ensure_container_nav
+from .calendar import (
+    _post_header_sx, _calendar_header_sx, _calendar_admin_header_sx,
+    _day_header_sx, _day_admin_header_sx, _markets_header_sx,
+)
+from .entries import _entry_header_html, _entry_admin_header_html
+from .slots import _slot_header_html
+from .tickets import _ticket_types_header_html, _ticket_type_header_html
+
+
+# ---------------------------------------------------------------------------
+# Layouts
+# ---------------------------------------------------------------------------
+
+def _register_events_layouts() -> None:
+    from shared.sx.layouts import register_custom_layout
+    register_custom_layout("events-calendar-admin", _cal_admin_full, _cal_admin_oob)
+    register_custom_layout("events-slots", _slots_full, _slots_oob)
+    register_custom_layout("events-slot", _slot_full, _slot_oob)
+    register_custom_layout("events-day-admin", _day_admin_full, _day_admin_oob)
+    register_custom_layout("events-entry", _entry_full, _entry_oob)
+    register_custom_layout("events-entry-admin", _entry_admin_full, _entry_admin_oob)
+    register_custom_layout("events-ticket-types", _ticket_types_full, _ticket_types_oob)
+    register_custom_layout("events-ticket-type", _ticket_type_full, _ticket_type_oob)
+    register_custom_layout("events-markets", _markets_full, _markets_oob)
+
+
+# --- Calendar admin layout (root + post + child(post-admin + calendar + cal-admin)) ---
+
+async def _cal_admin_full(ctx: dict, **kw: Any) -> str:
+    from shared.sx.helpers import render_to_sx_with_env, post_admin_header_sx
+    from shared.sx.parser import SxExpr
+    ctx = await _ensure_container_nav(ctx)
+    slug = (ctx.get("post") or {}).get("slug", "")
+    return await render_to_sx_with_env("events-cal-admin-layout-full", {},
+        post_header=SxExpr(await _post_header_sx(ctx)),
+        admin_header=SxExpr(await post_admin_header_sx(ctx, slug, selected="calendars")),
+        calendar_header=SxExpr(_calendar_header_sx(ctx)),
+        calendar_admin_header=SxExpr(_calendar_admin_header_sx(ctx)),
+    )
+
+
+async def _cal_admin_oob(ctx: dict, **kw: Any) -> str:
+    from shared.sx.helpers import render_to_sx_with_env, post_admin_header_sx, oob_header_sx
+    from shared.sx.parser import SxExpr
+    ctx = await _ensure_container_nav(ctx)
+    slug = (ctx.get("post") or {}).get("slug", "")
+    return await render_to_sx_with_env("events-cal-admin-layout-oob", {},
+        admin_oob=SxExpr(await post_admin_header_sx(ctx, slug, oob=True, selected="calendars")),
+        cal_oob=SxExpr(_calendar_header_sx(ctx, oob=True)),
+        cal_admin_oob_wrap=SxExpr(await oob_header_sx("calendar-header-child",
+            "calendar-admin-header-child", _calendar_admin_header_sx(ctx))),
+        clear_oob=SxExpr(_clear_deeper_oob("post-row", "post-header-child",
+            "post-admin-row", "post-admin-header-child",
+            "calendar-row", "calendar-header-child",
+            "calendar-admin-row", "calendar-admin-header-child")),
+    )
+
+
+# --- Slots layout (same full as cal-admin but different OOB) ---
+
+async def _slots_full(ctx: dict, **kw: Any) -> str:
+    return await _cal_admin_full({**ctx, "is_admin_section": True}, **kw)
+
+
+async def _slots_oob(ctx: dict, **kw: Any) -> str:
+    from shared.sx.helpers import render_to_sx_with_env, post_admin_header_sx
+    from shared.sx.parser import SxExpr
+    ctx = await _ensure_container_nav({**ctx, "is_admin_section": True})
+    slug = (ctx.get("post") or {}).get("slug", "")
+    return await render_to_sx_with_env("events-slots-layout-oob", {},
+        admin_oob=SxExpr(await post_admin_header_sx(ctx, slug, oob=True, selected="calendars")),
+        cal_admin_oob=SxExpr(_calendar_admin_header_sx(ctx, oob=True)),
+        clear_oob=SxExpr(_clear_deeper_oob("post-row", "post-header-child",
+            "post-admin-row", "post-admin-header-child",
+            "calendar-row", "calendar-header-child",
+            "calendar-admin-row", "calendar-admin-header-child")),
+    )
+
+
+# --- Slot detail layout (extends cal-admin with slot header) ---
+
+async def _slot_full(ctx: dict, **kw: Any) -> str:
+    from shared.sx.helpers import render_to_sx_with_env, post_admin_header_sx
+    from shared.sx.parser import SxExpr
+    ctx = await _ensure_container_nav({**ctx, "is_admin_section": True})
+    slug = (ctx.get("post") or {}).get("slug", "")
+    return await render_to_sx_with_env("events-slot-layout-full", {},
+        post_header=SxExpr(await _post_header_sx(ctx)),
+        admin_header=SxExpr(await post_admin_header_sx(ctx, slug, selected="calendars")),
+        calendar_header=SxExpr(_calendar_header_sx(ctx)),
+        calendar_admin_header=SxExpr(_calendar_admin_header_sx(ctx)),
+        slot_header=SxExpr(_slot_header_html(ctx)),
+    )
+
+
+async def _slot_oob(ctx: dict, **kw: Any) -> str:
+    from shared.sx.helpers import render_to_sx_with_env, post_admin_header_sx, oob_header_sx
+    from shared.sx.parser import SxExpr
+    ctx = await _ensure_container_nav({**ctx, "is_admin_section": True})
+    slug = (ctx.get("post") or {}).get("slug", "")
+    return await render_to_sx_with_env("events-slot-layout-oob", {},
+        admin_oob=SxExpr(await post_admin_header_sx(ctx, slug, oob=True, selected="calendars")),
+        cal_admin_oob=SxExpr(_calendar_admin_header_sx(ctx, oob=True)),
+        slot_oob_wrap=SxExpr(await oob_header_sx("calendar-admin-header-child",
+            "slot-header-child", _slot_header_html(ctx))),
+        clear_oob=SxExpr(_clear_deeper_oob("post-row", "post-header-child",
+            "post-admin-row", "post-admin-header-child",
+            "calendar-row", "calendar-header-child",
+            "calendar-admin-row", "calendar-admin-header-child",
+            "slot-row", "slot-header-child")),
+    )
+
+
+# --- Day admin layout (root + post + post-admin + child(cal + day + day-admin)) ---
+
+async def _day_admin_full(ctx: dict, **kw: Any) -> str:
+    from shared.sx.helpers import render_to_sx_with_env, post_admin_header_sx
+    from shared.sx.parser import SxExpr
+    ctx = await _ensure_container_nav(ctx)
+    slug = (ctx.get("post") or {}).get("slug", "")
+    return await render_to_sx_with_env("events-day-admin-layout-full", {},
+        post_header=SxExpr(await _post_header_sx(ctx)),
+        admin_header=SxExpr(await post_admin_header_sx(ctx, slug, selected="calendars")),
+        calendar_header=SxExpr(_calendar_header_sx(ctx)),
+        day_header=SxExpr(_day_header_sx(ctx)),
+        day_admin_header=SxExpr(_day_admin_header_sx(ctx)),
+    )
+
+
+async def _day_admin_oob(ctx: dict, **kw: Any) -> str:
+    from shared.sx.helpers import render_to_sx_with_env, post_admin_header_sx, oob_header_sx
+    from shared.sx.parser import SxExpr
+    ctx = await _ensure_container_nav(ctx)
+    slug = (ctx.get("post") or {}).get("slug", "")
+    return await render_to_sx_with_env("events-day-admin-layout-oob", {},
+        admin_oob=SxExpr(await post_admin_header_sx(ctx, slug, oob=True, selected="calendars")),
+        cal_oob=SxExpr(_calendar_header_sx(ctx, oob=True)),
+        day_admin_oob_wrap=SxExpr(await oob_header_sx("day-header-child",
+            "day-admin-header-child", _day_admin_header_sx(ctx))),
+        clear_oob=SxExpr(_clear_deeper_oob("post-row", "post-header-child",
+            "post-admin-row", "post-admin-header-child",
+            "calendar-row", "calendar-header-child",
+            "day-row", "day-header-child",
+            "day-admin-row", "day-admin-header-child")),
+    )
+
+
+# --- Entry layout (root + child(post + cal + day + entry), + menu) ---
+
+async def _entry_full(ctx: dict, **kw: Any) -> str:
+    from shared.sx.helpers import render_to_sx_with_env
+    from shared.sx.parser import SxExpr
+    return await render_to_sx_with_env("events-entry-layout-full", {},
+        post_header=SxExpr(await _post_header_sx(ctx)),
+        calendar_header=SxExpr(_calendar_header_sx(ctx)),
+        day_header=SxExpr(_day_header_sx(ctx)),
+        entry_header=SxExpr(_entry_header_html(ctx)),
+    )
+
+
+async def _entry_oob(ctx: dict, **kw: Any) -> str:
+    from shared.sx.helpers import render_to_sx_with_env, oob_header_sx
+    from shared.sx.parser import SxExpr
+    return await render_to_sx_with_env("events-entry-layout-oob", {},
+        day_oob=SxExpr(_day_header_sx(ctx, oob=True)),
+        entry_oob_wrap=SxExpr(await oob_header_sx("day-header-child",
+            "entry-header-child", _entry_header_html(ctx))),
+        clear_oob=SxExpr(_clear_deeper_oob("post-row", "post-header-child",
+            "calendar-row", "calendar-header-child",
+            "day-row", "day-header-child",
+            "entry-row", "entry-header-child")),
+    )
+
+
+# --- Entry admin layout (root + post + child(post-admin + cal + day + entry + entry-admin), + menu) ---
+
+async def _entry_admin_full(ctx: dict, **kw: Any) -> str:
+    from shared.sx.helpers import render_to_sx_with_env, post_admin_header_sx
+    from shared.sx.parser import SxExpr
+    ctx = await _ensure_container_nav(ctx)
+    slug = (ctx.get("post") or {}).get("slug", "")
+    return await render_to_sx_with_env("events-entry-admin-layout-full", {},
+        post_header=SxExpr(await _post_header_sx(ctx)),
+        admin_header=SxExpr(await post_admin_header_sx(ctx, slug, selected="calendars")),
+        calendar_header=SxExpr(_calendar_header_sx(ctx)),
+        day_header=SxExpr(_day_header_sx(ctx)),
+        entry_header=SxExpr(_entry_header_html(ctx)),
+        entry_admin_header=SxExpr(_entry_admin_header_html(ctx)),
+    )
+
+
+async def _entry_admin_oob(ctx: dict, **kw: Any) -> str:
+    from shared.sx.helpers import render_to_sx_with_env, post_admin_header_sx, oob_header_sx
+    from shared.sx.parser import SxExpr
+    ctx = await _ensure_container_nav(ctx)
+    slug = (ctx.get("post") or {}).get("slug", "")
+    return await render_to_sx_with_env("events-entry-admin-layout-oob", {},
+        admin_oob=SxExpr(await post_admin_header_sx(ctx, slug, oob=True, selected="calendars")),
+        entry_oob=SxExpr(_entry_header_html(ctx, oob=True)),
+        entry_admin_oob_wrap=SxExpr(await oob_header_sx("entry-header-child",
+            "entry-admin-header-child", _entry_admin_header_html(ctx))),
+        clear_oob=SxExpr(_clear_deeper_oob("post-row", "post-header-child",
+            "post-admin-row", "post-admin-header-child",
+            "calendar-row", "calendar-header-child",
+            "day-row", "day-header-child",
+            "entry-row", "entry-header-child",
+            "entry-admin-row", "entry-admin-header-child")),
+    )
+
+
+# --- Ticket types layout (extends entry admin with ticket-types header, + menu) ---
+
+async def _ticket_types_full(ctx: dict, **kw: Any) -> str:
+    from shared.sx.helpers import render_to_sx_with_env
+    from shared.sx.parser import SxExpr
+    return await render_to_sx_with_env("events-ticket-types-layout-full", {},
+        post_header=SxExpr(await _post_header_sx(ctx)),
+        calendar_header=SxExpr(_calendar_header_sx(ctx)),
+        day_header=SxExpr(_day_header_sx(ctx)),
+        entry_header=SxExpr(_entry_header_html(ctx)),
+        entry_admin_header=SxExpr(_entry_admin_header_html(ctx)),
+        ticket_types_header=SxExpr(_ticket_types_header_html(ctx)),
+    )
+
+
+async def _ticket_types_oob(ctx: dict, **kw: Any) -> str:
+    from shared.sx.helpers import render_to_sx_with_env, oob_header_sx
+    from shared.sx.parser import SxExpr
+    return await render_to_sx_with_env("events-ticket-types-layout-oob", {},
+        entry_admin_oob=SxExpr(_entry_admin_header_html(ctx, oob=True)),
+        ticket_types_oob_wrap=SxExpr(await oob_header_sx("entry-admin-header-child",
+            "ticket_types-header-child", _ticket_types_header_html(ctx))),
+    )
+
+
+# --- Ticket type detail layout (extends ticket types with ticket-type header, + menu) ---
+
+async def _ticket_type_full(ctx: dict, **kw: Any) -> str:
+    from shared.sx.helpers import render_to_sx_with_env
+    from shared.sx.parser import SxExpr
+    return await render_to_sx_with_env("events-ticket-type-layout-full", {},
+        post_header=SxExpr(await _post_header_sx(ctx)),
+        calendar_header=SxExpr(_calendar_header_sx(ctx)),
+        day_header=SxExpr(_day_header_sx(ctx)),
+        entry_header=SxExpr(_entry_header_html(ctx)),
+        entry_admin_header=SxExpr(_entry_admin_header_html(ctx)),
+        ticket_types_header=SxExpr(_ticket_types_header_html(ctx)),
+        ticket_type_header=SxExpr(_ticket_type_header_html(ctx)),
+    )
+
+
+async def _ticket_type_oob(ctx: dict, **kw: Any) -> str:
+    from shared.sx.helpers import render_to_sx_with_env, oob_header_sx
+    from shared.sx.parser import SxExpr
+    return await render_to_sx_with_env("events-ticket-type-layout-oob", {},
+        ticket_types_oob=SxExpr(_ticket_types_header_html(ctx, oob=True)),
+        ticket_type_oob_wrap=SxExpr(await oob_header_sx("ticket_types-header-child",
+            "ticket_type-header-child", _ticket_type_header_html(ctx))),
+    )
+
+
+# --- Markets layout (root + child(post + markets)) ---
+
+async def _markets_full(ctx: dict, **kw: Any) -> str:
+    from shared.sx.helpers import render_to_sx_with_env
+    from shared.sx.parser import SxExpr
+    return await render_to_sx_with_env("events-markets-layout-full", {},
+        post_header=SxExpr(await _post_header_sx(ctx)),
+        markets_header=SxExpr(_markets_header_sx(ctx)),
+    )
+
+
+async def _markets_oob(ctx: dict, **kw: Any) -> str:
+    from shared.sx.helpers import render_to_sx_with_env, oob_header_sx
+    from shared.sx.parser import SxExpr
+    return await render_to_sx_with_env("events-markets-layout-oob", {},
+        post_oob=SxExpr(await _post_header_sx(ctx, oob=True)),
+        markets_oob_wrap=SxExpr(await oob_header_sx("post-header-child",
+            "markets-header-child", _markets_header_sx(ctx))),
+    )
--- a/events/sxc/pages/renders.py
+++ b/events/sxc/pages/renders.py
@@ -0,0 +1,287 @@
+"""Top-level render_* functions — public API called from route handlers."""
+from __future__ import annotations
+
+from shared.sx.helpers import (
+    render_to_sx_with_env,
+    post_admin_header_sx, oob_header_sx,
+    header_child_sx, full_page_sx, oob_page_sx,
+)
+
+from .utils import _clear_deeper_oob, _ensure_container_nav
+from .calendar import (
+    _post_header_sx, _calendars_header_sx,
+    _calendar_header_sx, _day_header_sx,
+    _calendars_main_panel_sx,
+    _calendar_main_panel_html, _day_main_panel_html,
+    _calendar_admin_main_panel_html,
+    _calendar_description_display_html,
+    _markets_main_panel_html,
+)
+from .entries import (
+    _events_main_panel_html, _entry_cards_html,
+    _entry_main_panel_html,
+)
+from .tickets import render_buy_form
+
+
+# ---------------------------------------------------------------------------
+# All events
+# ---------------------------------------------------------------------------
+
+async def render_all_events_page(ctx: dict, entries, has_more, pending_tickets,
+                                  page_info, page, view) -> str:
+    """Full page: all events listing."""
+    from quart import url_for
+    from shared.utils import route_prefix
+    from shared.infrastructure.urls import events_url
+
+    prefix = route_prefix()
+    view_param = f"&view={view}" if view != "list" else ""
+    ticket_url = url_for("all_events.adjust_ticket")
+    next_url = prefix + url_for("all_events.entries_fragment", page=page + 1) + (f"?view={view}" if view != "list" else "")
+
+    content = _events_main_panel_html(
+        ctx, entries, has_more, pending_tickets, page_info,
+        page, view, ticket_url, next_url, events_url,
+    )
+    hdr = await render_to_sx_with_env("layout-root-full", {})
+    return await full_page_sx(ctx, header_rows=hdr, content=content)
+
+
+async def render_all_events_oob(ctx: dict, entries, has_more, pending_tickets,
+                                 page_info, page, view) -> str:
+    """OOB response: all events listing (htmx nav)."""
+    from quart import url_for
+    from shared.utils import route_prefix
+    from shared.infrastructure.urls import events_url
+
+    prefix = route_prefix()
+    ticket_url = url_for("all_events.adjust_ticket")
+    next_url = prefix + url_for("all_events.entries_fragment", page=page + 1) + (f"?view={view}" if view != "list" else "")
+
+    content = _events_main_panel_html(
+        ctx, entries, has_more, pending_tickets, page_info,
+        page, view, ticket_url, next_url, events_url,
+    )
+    return await oob_page_sx(content=content)
+
+
+def render_all_events_cards(entries, has_more, pending_tickets,
+                            page_info, page, view) -> str:
+    """Pagination fragment: all events cards only."""
+    from quart import url_for
+    from shared.utils import route_prefix
+    from shared.infrastructure.urls import events_url
+
+    prefix = route_prefix()
+    ticket_url = url_for("all_events.adjust_ticket")
+    next_url = prefix + url_for("all_events.entries_fragment", page=page + 1) + (f"?view={view}" if view != "list" else "")
+
+    return _entry_cards_html(
+        entries, page_info, pending_tickets, ticket_url, events_url,
+        view, page, has_more, next_url,
+    )
+
+
+# ---------------------------------------------------------------------------
+# Page summary
+# ---------------------------------------------------------------------------
+
+async def render_page_summary_page(ctx: dict, entries, has_more, pending_tickets,
+                                    page_info, page, view) -> str:
+    """Full page: page-scoped events listing."""
+    from quart import url_for
+    from shared.utils import route_prefix
+    from shared.infrastructure.urls import events_url
+
+    prefix = route_prefix()
+    post = ctx.get("post") or {}
+    ticket_url = url_for("page_summary.adjust_ticket")
+    next_url = prefix + url_for("page_summary.entries_fragment", page=page + 1) + (f"?view={view}" if view != "list" else "")
+
+    content = _events_main_panel_html(
+        ctx, entries, has_more, pending_tickets, page_info,
+        page, view, ticket_url, next_url, events_url,
+        is_page_scoped=True, post=post,
+    )
+
+    hdr = await render_to_sx_with_env("layout-root-full", {})
+    hdr += await header_child_sx(await _post_header_sx(ctx))
+    return await full_page_sx(ctx, header_rows=hdr, content=content)
+
+
+async def render_page_summary_oob(ctx: dict, entries, has_more, pending_tickets,
+                                   page_info, page, view) -> str:
+    """OOB response: page-scoped events (htmx nav)."""
+    from quart import url_for
+    from shared.utils import route_prefix
+    from shared.infrastructure.urls import events_url
+
+    prefix = route_prefix()
+    post = ctx.get("post") or {}
+    ticket_url = url_for("page_summary.adjust_ticket")
+    next_url = prefix + url_for("page_summary.entries_fragment", page=page + 1) + (f"?view={view}" if view != "list" else "")
+
+    content = _events_main_panel_html(
+        ctx, entries, has_more, pending_tickets, page_info,
+        page, view, ticket_url, next_url, events_url,
+        is_page_scoped=True, post=post,
+    )
+
+    oobs = await _post_header_sx(ctx, oob=True)
+    oobs += _clear_deeper_oob("post-row", "post-header-child")
+    return await oob_page_sx(oobs=oobs, content=content)
+
+
+def render_page_summary_cards(entries, has_more, pending_tickets,
+                              page_info, page, view, post) -> str:
+    """Pagination fragment: page-scoped events cards only."""
+    from quart import url_for
+    from shared.utils import route_prefix
+    from shared.infrastructure.urls import events_url
+
+    prefix = route_prefix()
+    ticket_url = url_for("page_summary.adjust_ticket")
+    next_url = prefix + url_for("page_summary.entries_fragment", page=page + 1) + (f"?view={view}" if view != "list" else "")
+
+    return _entry_cards_html(
+        entries, page_info, pending_tickets, ticket_url, events_url,
+        view, page, has_more, next_url,
+        is_page_scoped=True, post=post,
+    )
+
+
+# ---------------------------------------------------------------------------
+# Calendars home
+# ---------------------------------------------------------------------------
+
+async def render_calendars_page(ctx: dict) -> str:
+    """Full page: calendars listing."""
+    content = _calendars_main_panel_sx(ctx)
+    ctx = await _ensure_container_nav(ctx)
+    slug = (ctx.get("post") or {}).get("slug", "")
+    root_hdr = await render_to_sx_with_env("layout-root-full", {})
+    post_hdr = await _post_header_sx(ctx)
+    admin_hdr = await post_admin_header_sx(ctx, slug, selected="calendars")
+    return await full_page_sx(ctx, header_rows=root_hdr + post_hdr + admin_hdr, content=content)
+
+
+async def render_calendars_oob(ctx: dict) -> str:
+    """OOB response: calendars listing."""
+    content = _calendars_main_panel_sx(ctx)
+    ctx = await _ensure_container_nav(ctx)
+    slug = (ctx.get("post") or {}).get("slug", "")
+    oobs = await post_admin_header_sx(ctx, slug, oob=True, selected="calendars")
+    oobs += _clear_deeper_oob("post-row", "post-header-child",
+                               "post-admin-row", "post-admin-header-child")
+    return await oob_page_sx(oobs=oobs, content=content)
+
+
+# ---------------------------------------------------------------------------
+# Calendar month view
+# ---------------------------------------------------------------------------
+
+async def render_calendar_page(ctx: dict) -> str:
+    """Full page: calendar month view."""
+    content = _calendar_main_panel_html(ctx)
+    hdr = await render_to_sx_with_env("layout-root-full", {})
+    child = await _post_header_sx(ctx) + _calendar_header_sx(ctx)
+    hdr += await header_child_sx(child)
+    return await full_page_sx(ctx, header_rows=hdr, content=content)
+
+
+async def render_calendar_oob(ctx: dict) -> str:
+    """OOB response: calendar month view."""
+    content = _calendar_main_panel_html(ctx)
+    oobs = await _post_header_sx(ctx, oob=True)
+    oobs += await oob_header_sx("post-header-child", "calendar-header-child",
+                              _calendar_header_sx(ctx))
+    oobs += _clear_deeper_oob("post-row", "post-header-child",
+                               "calendar-row", "calendar-header-child")
+    return await oob_page_sx(oobs=oobs, content=content)
+
+
+# ---------------------------------------------------------------------------
+# Day detail
+# ---------------------------------------------------------------------------
+
+async def render_day_page(ctx: dict) -> str:
+    """Full page: day detail."""
+    content = _day_main_panel_html(ctx)
+    hdr = await render_to_sx_with_env("layout-root-full", {})
+    child = (await _post_header_sx(ctx)
+             + _calendar_header_sx(ctx) + _day_header_sx(ctx))
+    hdr += await header_child_sx(child)
+    return await full_page_sx(ctx, header_rows=hdr, content=content)
+
+
+async def render_day_oob(ctx: dict) -> str:
+    """OOB response: day detail."""
+    content = _day_main_panel_html(ctx)
+    oobs = _calendar_header_sx(ctx, oob=True)
+    oobs += await oob_header_sx("calendar-header-child", "day-header-child",
+                              _day_header_sx(ctx))
+    oobs += _clear_deeper_oob("post-row", "post-header-child",
+                               "calendar-row", "calendar-header-child",
+                               "day-row", "day-header-child")
+    return await oob_page_sx(oobs=oobs, content=content)
+
+
+# ---------------------------------------------------------------------------
+# Day main panel -- public API
+# ---------------------------------------------------------------------------
+
+def render_day_main_panel(ctx: dict) -> str:
+    """Public wrapper for day main panel rendering."""
+    return _day_main_panel_html(ctx)
+
+
+# ---------------------------------------------------------------------------
+# Calendar description display + edit form
+# ---------------------------------------------------------------------------
+
+def render_calendar_description(calendar, *, oob: bool = False) -> str:
+    """Render calendar description display with edit button, optionally with OOB title."""
+    from quart import url_for
+    from shared.sx.helpers import sx_call
+
+    cal_slug = getattr(calendar, "slug", "")
+    edit_url = url_for("calendar.admin.calendar_description_edit", calendar_slug=cal_slug)
+    html = _calendar_description_display_html(calendar, edit_url)
+
+    if oob:
+        desc = getattr(calendar, "description", "") or ""
+        html += sx_call("events-calendar-description-title-oob",
+                       description=desc)
+    return html
+
+
+def render_calendar_description_edit(calendar) -> str:
+    """Render calendar description edit form."""
+    from quart import url_for
+    from shared.browser.app.csrf import generate_csrf_token
+    from shared.sx.helpers import sx_call
+    csrf = generate_csrf_token()
+    cal_slug = getattr(calendar, "slug", "")
+    desc = getattr(calendar, "description", "") or ""
+
+    save_url = url_for("calendar.admin.calendar_description_save", calendar_slug=cal_slug)
+    cancel_url = url_for("calendar.admin.calendar_description_view", calendar_slug=cal_slug)
+
+    return sx_call("events-calendar-description-edit-form",
+                  save_url=save_url, cancel_url=cancel_url,
+                  csrf=csrf, description=desc)
+
+
+# ---------------------------------------------------------------------------
+# Calendars / Markets list panels (for POST create / DELETE)
+# ---------------------------------------------------------------------------
+
+def render_calendars_list_panel(ctx: dict) -> str:
+    """Render the calendars main panel HTML for POST/DELETE response."""
+    return _calendars_main_panel_sx(ctx)
+
+
+def render_markets_list_panel(ctx: dict) -> str:
+    """Render the markets main panel HTML for POST/DELETE response."""
+    return _markets_main_panel_html(ctx)
--- a/events/sxc/pages/slots.py
+++ b/events/sxc/pages/slots.py
@@ -0,0 +1,372 @@
+"""Slot panels, forms, edit/add, slot picker JS."""
+from __future__ import annotations
+
+
+from shared.sx.helpers import sx_call
+from shared.sx.parser import SxExpr
+
+
+# ===========================================================================
+# SLOT PICKER JS — shared by entry edit + entry add forms
+# ===========================================================================
+
+_SLOT_PICKER_JS = """\
+<script>
+  (function () {
+    function timeToMinutes(timeStr) {
+      if (!timeStr) return 0;
+      const [hours, minutes] = timeStr.split(':').map(Number);
+      return hours * 60 + minutes;
+    }
+
+    function calculateCost(slotCost, slotStart, slotEnd, actualStart, actualEnd, flexible) {
+      if (!flexible) {
+        return parseFloat(slotCost);
+      }
+      if (!actualStart || !actualEnd) return 0;
+      const slotStartMin = timeToMinutes(slotStart);
+      const slotEndMin = timeToMinutes(slotEnd);
+      const actualStartMin = timeToMinutes(actualStart);
+      const actualEndMin = timeToMinutes(actualEnd);
+      const slotDuration = slotEndMin - slotStartMin;
+      const actualDuration = actualEndMin - actualStartMin;
+      if (slotDuration <= 0 || actualDuration <= 0) return 0;
+      const ratio = actualDuration / slotDuration;
+      return parseFloat(slotCost) * ratio;
+    }
+
+    function initEntrySlotPicker(root, applyInitial) {
+      if (applyInitial === undefined) applyInitial = false;
+      const select = root.querySelector('[data-slot-picker]');
+      if (!select) return;
+      const timeFields = root.querySelector('[data-time-fields]');
+      const startInput = root.querySelector('[data-entry-start]');
+      const endInput = root.querySelector('[data-entry-end]');
+      const helper = root.querySelector('[data-slot-boundary]');
+      const costDisplay = root.querySelector('[data-cost-display]');
+      const costRow = root.querySelector('[data-cost-row]');
+      const fixedSummary = root.querySelector('[data-fixed-summary]');
+      if (!startInput || !endInput) return;
+
+      function updateCost() {
+        const opt = select.selectedOptions[0];
+        if (!opt || !opt.value) {
+          if (costDisplay) costDisplay.textContent = '\\u00a30.00';
+          return;
+        }
+        const cost = opt.dataset.cost || '0';
+        const s = opt.dataset.start || '';
+        const e = opt.dataset.end || '';
+        const flexible = opt.dataset.flexible === '1';
+        const calculatedCost = calculateCost(cost, s, e, startInput.value, endInput.value, flexible);
+        if (costDisplay) costDisplay.textContent = '\\u00a3' + calculatedCost.toFixed(2);
+      }
+
+      function applyFromOption(opt) {
+        if (!opt || !opt.value) {
+          if (timeFields) timeFields.classList.add('hidden');
+          if (costRow) costRow.classList.add('hidden');
+          if (fixedSummary) fixedSummary.classList.add('hidden');
+          return;
+        }
+        const s = opt.dataset.start || '';
+        const e = opt.dataset.end || '';
+        const flexible = opt.dataset.flexible === '1';
+        if (!flexible) {
+          if (s) startInput.value = s;
+          if (e) endInput.value = e;
+          if (timeFields) timeFields.classList.add('hidden');
+          if (fixedSummary) {
+            fixedSummary.classList.remove('hidden');
+            fixedSummary.textContent = e ? s + ' \\u2013 ' + e : 'From ' + s + ' (open-ended)';
+          }
+          if (costRow) costRow.classList.remove('hidden');
+        } else {
+          if (timeFields) timeFields.classList.remove('hidden');
+          if (fixedSummary) fixedSummary.classList.add('hidden');
+          if (costRow) costRow.classList.remove('hidden');
+          if (helper) {
+            helper.textContent = e ? 'Times must be between ' + s + ' and ' + e + '.' : 'Start at or after ' + s + '.';
+          }
+        }
+        updateCost();
+      }
+
+      if (applyInitial) applyFromOption(select.selectedOptions[0]);
+
+      if (select._slotChangeHandler) select.removeEventListener('change', select._slotChangeHandler);
+      select._slotChangeHandler = () => applyFromOption(select.selectedOptions[0]);
+      select.addEventListener('change', select._slotChangeHandler);
+      startInput.addEventListener('input', updateCost);
+      endInput.addEventListener('input', updateCost);
+    }
+
+    document.addEventListener('DOMContentLoaded', () => initEntrySlotPicker(document, true));
+    if (window.htmx) htmx.onLoad((content) => initEntrySlotPicker(content, true));
+  })();
+</script>"""
+
+
+# ---------------------------------------------------------------------------
+# Slot options (shared by entry edit + add forms)
+# ---------------------------------------------------------------------------
+
+def _slot_options_html(day_slots, selected_slot_id=None) -> str:
+    """Build slot <option> elements."""
+    parts = []
+    for slot in day_slots:
+        start = slot.time_start.strftime("%H:%M") if slot.time_start else ""
+        end = slot.time_end.strftime("%H:%M") if slot.time_end else ""
+        flexible = getattr(slot, "flexible", False)
+        cost = getattr(slot, "cost", None)
+        cost_str = str(cost) if cost is not None else "0"
+        label_parts = [slot.name, f"({start}"]
+        if end:
+            label_parts.append(f"\u2013{end})")
+        else:
+            label_parts.append("\u2013open-ended)")
+        if flexible:
+            label_parts.append("[flexible]")
+        label = " ".join(label_parts)
+
+        parts.append(sx_call("events-slot-option",
+                            value=str(slot.id),
+                            data_start=start, data_end=end,
+                            data_flexible="1" if flexible else "0",
+                            data_cost=cost_str,
+                            selected="selected" if selected_slot_id == slot.id else None,
+                            label=label))
+    return "".join(parts)
+
+
+# ---------------------------------------------------------------------------
+# Slot header row
+# ---------------------------------------------------------------------------
+
+def _slot_header_html(ctx: dict, *, oob: bool = False) -> str:
+    """Build the slot detail header row."""
+    from quart import url_for
+
+    calendar = ctx.get("calendar")
+    if not calendar:
+        return ""
+    cal_slug = getattr(calendar, "slug", "")
+    slot = ctx.get("slot")
+    if not slot:
+        return ""
+
+    desc = getattr(slot, "description", "") or ""
+    label_sx = sx_call("events-slot-label",
+                                  name=slot.name, description=desc)
+
+    return sx_call("menu-row-sx", id="slot-row", level=5,
+                  link_label_content=SxExpr(label_sx),
+                  child_id="slot-header-child", oob=oob)
+
+
+# ---------------------------------------------------------------------------
+# Slot main panel
+# ---------------------------------------------------------------------------
+
+def render_slot_main_panel(slot, calendar, *, oob: bool = False) -> str:
+    """Render slot detail view."""
+    from quart import url_for, g
+
+    styles = getattr(g, "styles", None) or {}
+    list_container = getattr(styles, "list_container", "") if hasattr(styles, "list_container") else styles.get("list_container", "")
+    pre_action = getattr(styles, "pre_action_button", "") if hasattr(styles, "pre_action_button") else styles.get("pre_action_button", "")
+    cal_slug = getattr(calendar, "slug", "")
+
+    days_display = getattr(slot, "days_display", "\u2014")
+    days = days_display.split(", ")
+    flexible = getattr(slot, "flexible", False)
+    time_start = slot.time_start.strftime("%H:%M") if slot.time_start else ""
+    time_end = slot.time_end.strftime("%H:%M") if slot.time_end else ""
+    cost = getattr(slot, "cost", None)
+    cost_str = f"{cost:.2f}" if cost is not None else ""
+    desc = getattr(slot, "description", "") or ""
+
+    edit_url = url_for("calendar.slots.slot.get_edit", slot_id=slot.id, calendar_slug=cal_slug)
+
+    # Days pills
+    if days and days[0] != "\u2014":
+        days_inner = "".join(
+            sx_call("events-slot-day-pill", day=d) for d in days
+        )
+        days_html = sx_call("events-slot-days-pills", days_inner=SxExpr(days_inner))
+    else:
+        days_html = sx_call("events-slot-no-days")
+
+    sid = str(slot.id)
+
+    result = sx_call("events-slot-panel",
+                    slot_id=sid, list_container=list_container,
+                    days=SxExpr(days_html),
+                    flexible="yes" if flexible else "no",
+                    time_str=f"{time_start} \u2014 {time_end}",
+                    cost_str=cost_str,
+                    pre_action=pre_action, edit_url=edit_url)
+
+    if oob:
+        result += sx_call("events-slot-description-oob", description=desc)
+
+    return result
+
+
+# ---------------------------------------------------------------------------
+# Slots table
+# ---------------------------------------------------------------------------
+
+def render_slots_table(slots, calendar) -> str:
+    """Render slots table with rows and add button."""
+    from quart import url_for, g
+    from shared.browser.app.csrf import generate_csrf_token
+    csrf = generate_csrf_token()
+
+    styles = getattr(g, "styles", None) or {}
+    list_container = getattr(styles, "list_container", "") if hasattr(styles, "list_container") else styles.get("list_container", "")
+    tr_cls = getattr(styles, "tr", "") if hasattr(styles, "tr") else styles.get("tr", "")
+    pill_cls = getattr(styles, "pill", "") if hasattr(styles, "pill") else styles.get("pill", "")
+    action_btn = getattr(styles, "action_button", "") if hasattr(styles, "action_button") else styles.get("action_button", "")
+    pre_action = getattr(styles, "pre_action_button", "") if hasattr(styles, "pre_action_button") else styles.get("pre_action_button", "")
+    hx_select = getattr(g, "hx_select_search", "#main-panel")
+    cal_slug = getattr(calendar, "slug", "")
+
+    rows_html = ""
+    if slots:
+        for s in slots:
+            slot_href = url_for("defpage_slot_detail", calendar_slug=cal_slug, slot_id=s.id)
+            del_url = url_for("calendar.slots.slot.slot_delete", calendar_slug=cal_slug, slot_id=s.id)
+            desc = getattr(s, "description", "") or ""
+
+            days_display = getattr(s, "days_display", "\u2014")
+            day_list = days_display.split(", ")
+            if day_list and day_list[0] != "\u2014":
+                days_inner = "".join(
+                    sx_call("events-slot-day-pill", day=d) for d in day_list
+                )
+                days_html = sx_call("events-slot-days-pills", days_inner=SxExpr(days_inner))
+            else:
+                days_html = sx_call("events-slot-no-days")
+
+            time_start = s.time_start.strftime("%H:%M") if s.time_start else ""
+            time_end = s.time_end.strftime("%H:%M") if s.time_end else ""
+            cost = getattr(s, "cost", None)
+            cost_str = f"{cost:.2f}" if cost is not None else ""
+
+            rows_html += sx_call("events-slots-row",
+                                tr_cls=tr_cls, slot_href=slot_href,
+                                pill_cls=pill_cls, hx_select=hx_select,
+                                slot_name=s.name, description=desc,
+                                flexible="yes" if s.flexible else "no",
+                                days=SxExpr(days_html),
+                                time_str=f"{time_start} - {time_end}",
+                                cost_str=cost_str, action_btn=action_btn,
+                                del_url=del_url,
+                                csrf_hdr=f'{{"X-CSRFToken": "{csrf}"}}')
+    else:
+        rows_html = sx_call("events-slots-empty-row")
+
+    add_url = url_for("calendar.slots.add_form", calendar_slug=cal_slug)
+
+    return sx_call("events-slots-table",
+                  list_container=list_container, rows=SxExpr(rows_html),
+                  pre_action=pre_action, add_url=add_url)
+
+
+# ---------------------------------------------------------------------------
+# Slot edit form
+# ---------------------------------------------------------------------------
+
+def render_slot_edit_form(slot, calendar) -> str:
+    """Render slot edit form (replaces _types/slot/_edit.html)."""
+    from quart import url_for, g
+    from shared.browser.app.csrf import generate_csrf_token
+    csrf = generate_csrf_token()
+
+    styles = getattr(g, "styles", None) or {}
+    list_container = styles.get("list_container", "") if isinstance(styles, dict) else getattr(styles, "list_container", "")
+    action_btn = styles.get("action_button", "") if isinstance(styles, dict) else getattr(styles, "action_button", "")
+    cancel_btn = styles.get("cancel_button", "") if isinstance(styles, dict) else getattr(styles, "cancel_button", "")
+    cal_slug = getattr(calendar, "slug", "")
+    sid = slot.id
+
+    put_url = url_for("calendar.slots.slot.put", calendar_slug=cal_slug, slot_id=sid)
+    cancel_url = url_for("calendar.slots.slot.get_view", calendar_slug=cal_slug, slot_id=sid)
+
+    cost = getattr(slot, "cost", None)
+    cost_val = f"{cost:.2f}" if cost is not None else ""
+    start_val = slot.time_start.strftime("%H:%M") if slot.time_start else ""
+    end_val = slot.time_end.strftime("%H:%M") if slot.time_end else ""
+    desc_val = getattr(slot, "description", "") or ""
+
+    # Days checkboxes
+    day_keys = [("mon", "Mon"), ("tue", "Tue"), ("wed", "Wed"), ("thu", "Thu"),
+                ("fri", "Fri"), ("sat", "Sat"), ("sun", "Sun")]
+    all_checked = all(getattr(slot, k, False) for k, _ in day_keys)
+
+    days_parts = [sx_call("events-day-all-checkbox",
+                         checked="checked" if all_checked else None)]
+    for key, label in day_keys:
+        checked = getattr(slot, key, False)
+        days_parts.append(sx_call("events-day-checkbox",
+                                 name=key, label=label,
+                                 checked="checked" if checked else None))
+    days_html = "".join(days_parts)
+
+    flexible = getattr(slot, "flexible", False)
+
+    return sx_call("events-slot-edit-form",
+                  slot_id=str(sid), list_container=list_container,
+                  put_url=put_url, cancel_url=cancel_url, csrf=csrf,
+                  name_val=slot.name or "", cost_val=cost_val,
+                  start_val=start_val, end_val=end_val,
+                  desc_val=desc_val, days=SxExpr(days_html),
+                  flexible_checked="checked" if flexible else None,
+                  action_btn=action_btn, cancel_btn=cancel_btn)
+
+
+# ---------------------------------------------------------------------------
+# Slot add form / button
+# ---------------------------------------------------------------------------
+
+def render_slot_add_form(calendar) -> str:
+    """Render slot add form (replaces _types/slots/_add.html)."""
+    from quart import url_for, g
+    from shared.browser.app.csrf import generate_csrf_token
+    csrf = generate_csrf_token()
+
+    styles = getattr(g, "styles", None) or {}
+    action_btn = styles.get("action_button", "") if isinstance(styles, dict) else getattr(styles, "action_button", "")
+    cancel_btn = styles.get("cancel_button", "") if isinstance(styles, dict) else getattr(styles, "cancel_button", "")
+    cal_slug = getattr(calendar, "slug", "")
+
+    post_url = url_for("calendar.slots.post", calendar_slug=cal_slug)
+    cancel_url = url_for("calendar.slots.add_button", calendar_slug=cal_slug)
+    csrf_hdr = f'{{"X-CSRFToken": "{csrf}"}}'
+
+    # Days checkboxes (all unchecked for add)
+    day_keys = [("mon", "Mon"), ("tue", "Tue"), ("wed", "Wed"), ("thu", "Thu"),
+                ("fri", "Fri"), ("sat", "Sat"), ("sun", "Sun")]
+    days_parts = [sx_call("events-day-all-checkbox", checked=None)]
+    for key, label in day_keys:
+        days_parts.append(sx_call("events-day-checkbox", name=key, label=label, checked=None))
+    days_html = "".join(days_parts)
+
+    return sx_call("events-slot-add-form",
+                  post_url=post_url, csrf=csrf_hdr,
+                  days=SxExpr(days_html),
+                  action_btn=action_btn, cancel_btn=cancel_btn,
+                  cancel_url=cancel_url)
+
+
+def render_slot_add_button(calendar) -> str:
+    """Render slot add button (replaces _types/slots/_add_button.html)."""
+    from quart import url_for, g
+
+    styles = getattr(g, "styles", None) or {}
+    pre_action = styles.get("pre_action_button", "") if isinstance(styles, dict) else getattr(styles, "pre_action_button", "")
+    cal_slug = getattr(calendar, "slug", "")
+    add_url = url_for("calendar.slots.add_form", calendar_slug=cal_slug)
+
+    return sx_call("events-slot-add-button", pre_action=pre_action, add_url=add_url)
--- a/events/sxc/pages/tickets.py
+++ b/events/sxc/pages/tickets.py
@@ -0,0 +1,723 @@
+"""Ticket panels, forms, admin views, buy/adjust controls."""
+from __future__ import annotations
+
+from markupsafe import escape
+
+from shared.sx.helpers import sx_call
+from shared.sx.parser import SxExpr
+
+from .utils import (
+    _ticket_state_badge_html, _list_container, _cart_icon_oob,
+)
+
+
+# ---------------------------------------------------------------------------
+# Ticket widget (inline +/- for entry cards)
+# ---------------------------------------------------------------------------
+
+def _ticket_widget_html(entry, qty: int, ticket_url: str, *, ctx: dict) -> str:
+    """Render the inline +/- ticket widget."""
+    csrf_token_val = ""
+    if ctx:
+        ct = ctx.get("csrf_token")
+        csrf_token_val = ct() if callable(ct) else (ct or "")
+    else:
+        try:
+            from flask_wtf.csrf import generate_csrf
+            csrf_token_val = generate_csrf()
+        except Exception:
+            pass
+
+    eid = entry.id
+    tp = getattr(entry, "ticket_price", 0) or 0
+    tgt = f"#page-ticket-{eid}"
+
+    def _tw_form(count_val, btn_html):
+        return sx_call("events-tw-form",
+                      ticket_url=ticket_url, target=tgt,
+                      csrf=csrf_token_val, entry_id=str(eid),
+                      count_val=str(count_val), btn=SxExpr(btn_html))
+
+    if qty == 0:
+        inner = _tw_form(1, sx_call("events-tw-cart-plus"))
+    else:
+        minus = _tw_form(qty - 1, sx_call("events-tw-minus"))
+        cart_icon = sx_call("events-tw-cart-icon", qty=str(qty))
+        plus = _tw_form(qty + 1, sx_call("events-tw-plus"))
+        inner = minus + cart_icon + plus
+
+    return sx_call("events-tw-widget",
+                  entry_id=str(eid), price=f"\u00a3{tp:.2f}",
+                  inner=SxExpr(inner))
+
+
+# ---------------------------------------------------------------------------
+# Tickets main panel (my tickets)
+# ---------------------------------------------------------------------------
+
+def _tickets_main_panel_html(ctx: dict, tickets: list) -> str:
+    """Render my tickets list."""
+    from quart import url_for
+
+    ticket_cards = []
+    if tickets:
+        for ticket in tickets:
+            href = url_for("defpage_ticket_detail", code=ticket.code)
+            entry = getattr(ticket, "entry", None)
+            entry_name = entry.name if entry else "Unknown event"
+            tt = getattr(ticket, "ticket_type", None)
+            state = getattr(ticket, "state", "")
+            cal = getattr(entry, "calendar", None) if entry else None
+
+            time_str = ""
+            if entry and entry.start_at:
+                time_str = entry.start_at.strftime("%A, %B %d, %Y at %H:%M")
+                if entry.end_at:
+                    time_str += f" \u2013 {entry.end_at.strftime('%H:%M')}"
+
+            ticket_cards.append(sx_call("events-ticket-card",
+                                       href=href, entry_name=entry_name,
+                                       type_name=tt.name if tt else None,
+                                       time_str=time_str or None,
+                                       cal_name=cal.name if cal else None,
+                                       badge=SxExpr(_ticket_state_badge_html(state)),
+                                       code_prefix=ticket.code[:8]))
+
+    cards_html = "".join(ticket_cards)
+    return sx_call("events-tickets-panel",
+                  list_container=_list_container(ctx),
+                  has_tickets=bool(tickets), cards=SxExpr(cards_html))
+
+
+# ---------------------------------------------------------------------------
+# Ticket detail panel
+# ---------------------------------------------------------------------------
+
+def _ticket_detail_panel_html(ctx: dict, ticket) -> str:
+    """Render a single ticket detail with QR code."""
+    from quart import url_for
+
+    entry = getattr(ticket, "entry", None)
+    tt = getattr(ticket, "ticket_type", None)
+    state = getattr(ticket, "state", "")
+    code = ticket.code
+    cal = getattr(entry, "calendar", None) if entry else None
+    checked_in_at = getattr(ticket, "checked_in_at", None)
+
+    bg_map = {"confirmed": "bg-emerald-50", "checked_in": "bg-blue-50", "reserved": "bg-amber-50"}
+    header_bg = bg_map.get(state, "bg-stone-50")
+    entry_name = entry.name if entry else "Ticket"
+    back_href = url_for("defpage_my_tickets")
+
+    # Badge with larger sizing
+    badge = (_ticket_state_badge_html(state)).replace('px-2 py-0.5 text-xs', 'px-3 py-1 text-sm')
+
+    # Time info
+    time_date = entry.start_at.strftime("%A, %B %d, %Y") if entry and entry.start_at else None
+    time_range = entry.start_at.strftime("%H:%M") if entry and entry.start_at else None
+    if time_range and entry.end_at:
+        time_range += f" \u2013 {entry.end_at.strftime('%H:%M')}"
+
+    tt_desc = f"{tt.name} \u2014 \u00a3{tt.cost:.2f}" if tt and getattr(tt, "cost", None) else None
+    checkin_str = checked_in_at.strftime("Checked in: %B %d, %Y at %H:%M") if checked_in_at else None
+
+    qr_script = (
+        f"(function(){{var c=document.getElementById('ticket-qr-{code}');"
+        "if(c&&typeof QRCode!=='undefined'){"
+        "var cv=document.createElement('canvas');"
+        f"QRCode.toCanvas(cv,'{code}',{{width:200,margin:2,color:{{dark:'#1c1917',light:'#ffffff'}}}},function(e){{if(!e)c.appendChild(cv)}});"
+        "}})()"
+    )
+
+    return sx_call("events-ticket-detail",
+                  list_container=_list_container(ctx), back_href=back_href,
+                  header_bg=header_bg, entry_name=entry_name,
+                  badge=SxExpr(badge), type_name=tt.name if tt else None,
+                  code=code, time_date=time_date, time_range=time_range,
+                  cal_name=cal.name if cal else None,
+                  type_desc=tt_desc, checkin_str=checkin_str,
+                  qr_script=qr_script)
+
+
+# ---------------------------------------------------------------------------
+# Ticket admin main panel
+# ---------------------------------------------------------------------------
+
+def _ticket_admin_main_panel_html(ctx: dict, tickets: list, stats: dict) -> str:
+    """Render ticket admin dashboard."""
+    from quart import url_for
+    csrf_token = ctx.get("csrf_token")
+    csrf = csrf_token() if callable(csrf_token) else (csrf_token or "")
+    lookup_url = url_for("ticket_admin.lookup")
+
+    # Stats cards
+    stats_html = ""
+    for label, key, border, bg, text_cls in [
+        ("Total", "total", "border-stone-200", "", "text-stone-900"),
+        ("Confirmed", "confirmed", "border-emerald-200", "bg-emerald-50", "text-emerald-700"),
+        ("Checked In", "checked_in", "border-blue-200", "bg-blue-50", "text-blue-700"),
+        ("Reserved", "reserved", "border-amber-200", "bg-amber-50", "text-amber-700"),
+    ]:
+        val = stats.get(key, 0)
+        lbl_cls = text_cls.replace("700", "600").replace("900", "500") if "stone" not in text_cls else "text-stone-500"
+        stats_html += sx_call("events-ticket-admin-stat",
+                             border=border, bg=bg, text_cls=text_cls,
+                             label_cls=lbl_cls, value=str(val), label=label)
+
+    # Ticket rows
+    rows_html = ""
+    for ticket in tickets:
+        entry = getattr(ticket, "entry", None)
+        tt = getattr(ticket, "ticket_type", None)
+        state = getattr(ticket, "state", "")
+        code = ticket.code
+
+        date_html = ""
+        if entry and entry.start_at:
+            date_html = sx_call("events-ticket-admin-date",
+                               date_str=entry.start_at.strftime("%d %b %Y, %H:%M"))
+
+        action_html = ""
+        if state in ("confirmed", "reserved"):
+            checkin_url = url_for("ticket_admin.do_checkin", code=code)
+            action_html = sx_call("events-ticket-admin-checkin-form",
+                                 checkin_url=checkin_url, code=code, csrf=csrf)
+        elif state == "checked_in":
+            checked_in_at = getattr(ticket, "checked_in_at", None)
+            t_str = checked_in_at.strftime("%H:%M") if checked_in_at else ""
+            action_html = sx_call("events-ticket-admin-checked-in",
+                                 time_str=t_str)
+
+        rows_html += sx_call("events-ticket-admin-row",
+                            code=code, code_short=code[:12] + "...",
+                            entry_name=entry.name if entry else "\u2014",
+                            date=SxExpr(date_html),
+                            type_name=tt.name if tt else "\u2014",
+                            badge=SxExpr(_ticket_state_badge_html(state)),
+                            action=SxExpr(action_html))
+
+    return sx_call("events-ticket-admin-panel",
+                  list_container=_list_container(ctx), stats=SxExpr(stats_html),
+                  lookup_url=lookup_url, has_tickets=bool(tickets),
+                  rows=SxExpr(rows_html))
+
+
+# ---------------------------------------------------------------------------
+# Public render: ticket widget
+# ---------------------------------------------------------------------------
+
+def render_ticket_widget(entry, qty: int, ticket_url: str) -> str:
+    """Render the +/- ticket widget for page_summary / all_events adjust_ticket."""
+    return _ticket_widget_html(entry, qty, ticket_url, ctx={})
+
+
+# ---------------------------------------------------------------------------
+# Ticket admin: checkin result
+# ---------------------------------------------------------------------------
+
+def render_checkin_result(success: bool, error: str | None, ticket) -> str:
+    """Render checkin result: table row on success, error div on failure."""
+    if not success:
+        return sx_call("events-checkin-error",
+                      message=error or "Check-in failed")
+    if not ticket:
+        return ""
+    code = ticket.code
+    entry = getattr(ticket, "entry", None)
+    tt = getattr(ticket, "ticket_type", None)
+    checked_in_at = getattr(ticket, "checked_in_at", None)
+    time_str = checked_in_at.strftime("%H:%M") if checked_in_at else "Just now"
+
+    date_html = ""
+    if entry and entry.start_at:
+        date_html = sx_call("events-ticket-admin-date",
+                           date_str=entry.start_at.strftime("%d %b %Y, %H:%M"))
+
+    return sx_call("events-checkin-success-row",
+                  code=code, code_short=code[:12] + "...",
+                  entry_name=entry.name if entry else "\u2014",
+                  date=SxExpr(date_html),
+                  type_name=tt.name if tt else "\u2014",
+                  badge=SxExpr(_ticket_state_badge_html("checked_in")),
+                  time_str=time_str)
+
+
+# ---------------------------------------------------------------------------
+# Ticket admin: lookup result
+# ---------------------------------------------------------------------------
+
+def render_lookup_result(ticket, error: str | None) -> str:
+    """Render ticket lookup result: error div or ticket info card."""
+    from quart import url_for
+    from shared.browser.app.csrf import generate_csrf_token
+
+    if error:
+        return sx_call("events-lookup-error", message=error)
+    if not ticket:
+        return ""
+
+    entry = getattr(ticket, "entry", None)
+    tt = getattr(ticket, "ticket_type", None)
+    state = getattr(ticket, "state", "")
+    code = ticket.code
+    checked_in_at = getattr(ticket, "checked_in_at", None)
+    csrf = generate_csrf_token()
+
+    # Info section
+    info_html = sx_call("events-lookup-info",
+                       entry_name=entry.name if entry else "Unknown event")
+    if tt:
+        info_html += sx_call("events-lookup-type", type_name=tt.name)
+    if entry and entry.start_at:
+        info_html += sx_call("events-lookup-date",
+                            date_str=entry.start_at.strftime("%A, %B %d, %Y at %H:%M"))
+    cal = getattr(entry, "calendar", None) if entry else None
+    if cal:
+        info_html += sx_call("events-lookup-cal", cal_name=cal.name)
+    info_html += sx_call("events-lookup-status",
+                        badge=SxExpr(_ticket_state_badge_html(state)), code=code)
+    if checked_in_at:
+        info_html += sx_call("events-lookup-checkin-time",
+                            date_str=checked_in_at.strftime("%B %d, %Y at %H:%M"))
+
+    # Action area
+    action_html = ""
+    if state in ("confirmed", "reserved"):
+        checkin_url = url_for("ticket_admin.do_checkin", code=code)
+        action_html = sx_call("events-lookup-checkin-btn",
+                             checkin_url=checkin_url, code=code, csrf=csrf)
+    elif state == "checked_in":
+        action_html = sx_call("events-lookup-checked-in")
+    elif state == "cancelled":
+        action_html = sx_call("events-lookup-cancelled")
+
+    return sx_call("events-lookup-card",
+                  info=SxExpr(info_html), code=code, action=SxExpr(action_html))
+
+
+# ---------------------------------------------------------------------------
+# Ticket admin: entry tickets table
+# ---------------------------------------------------------------------------
+
+def render_entry_tickets_admin(entry, tickets: list) -> str:
+    """Render admin ticket table for a specific entry."""
+    from quart import url_for
+    from shared.browser.app.csrf import generate_csrf_token
+    csrf = generate_csrf_token()
+
+    count = len(tickets)
+    suffix = "s" if count != 1 else ""
+
+    rows_html = ""
+    for ticket in tickets:
+        tt = getattr(ticket, "ticket_type", None)
+        state = getattr(ticket, "state", "")
+        code = ticket.code
+        checked_in_at = getattr(ticket, "checked_in_at", None)
+
+        action_html = ""
+        if state in ("confirmed", "reserved"):
+            checkin_url = url_for("ticket_admin.do_checkin", code=code)
+            action_html = sx_call("events-entry-tickets-admin-checkin",
+                                 checkin_url=checkin_url, code=code, csrf=csrf)
+        elif state == "checked_in":
+            t_str = checked_in_at.strftime("%H:%M") if checked_in_at else ""
+            action_html = sx_call("events-ticket-admin-checked-in",
+                                 time_str=t_str)
+
+        rows_html += sx_call("events-entry-tickets-admin-row",
+                            code=code, code_short=code[:12] + "...",
+                            type_name=tt.name if tt else "\u2014",
+                            badge=SxExpr(_ticket_state_badge_html(state)),
+                            action=SxExpr(action_html))
+
+    if tickets:
+        body_html = sx_call("events-entry-tickets-admin-table",
+                           rows=SxExpr(rows_html))
+    else:
+        body_html = sx_call("events-entry-tickets-admin-empty")
+
+    return sx_call("events-entry-tickets-admin-panel",
+                  entry_name=entry.name,
+                  count_label=f"{count} ticket{suffix}",
+                  body=SxExpr(body_html))
+
+
+# ---------------------------------------------------------------------------
+# Ticket type main panel
+# ---------------------------------------------------------------------------
+
+def render_ticket_type_main_panel(ticket_type, entry, calendar, day, month, year, *, oob: bool = False) -> str:
+    """Render ticket type detail view."""
+    from quart import url_for, g
+
+    styles = getattr(g, "styles", None) or {}
+    list_container = getattr(styles, "list_container", "") if hasattr(styles, "list_container") else styles.get("list_container", "")
+    pre_action = getattr(styles, "pre_action_button", "") if hasattr(styles, "pre_action_button") else styles.get("pre_action_button", "")
+    cal_slug = getattr(calendar, "slug", "")
+
+    cost = getattr(ticket_type, "cost", None)
+    cost_str = f"\u00a3{cost:.2f}" if cost is not None else "\u00a30.00"
+    count = getattr(ticket_type, "count", 0)
+    tid = str(ticket_type.id)
+
+    edit_url = url_for(
+        "calendar.day.calendar_entries.calendar_entry.ticket_types.ticket_type.get_edit",
+        ticket_type_id=ticket_type.id, calendar_slug=cal_slug,
+        year=year, month=month, day=day, entry_id=entry.id,
+    )
+
+    def _col(label, val):
+        return sx_call("events-ticket-type-col", label=label, value=val)
+
+    return sx_call("events-ticket-type-panel",
+                  ticket_id=tid, list_container=list_container,
+                  c1=_col("Name", ticket_type.name),
+                  c2=_col("Cost", cost_str),
+                  c3=_col("Count", str(count)),
+                  pre_action=pre_action, edit_url=edit_url)
+
+
+# ---------------------------------------------------------------------------
+# Ticket types table
+# ---------------------------------------------------------------------------
+
+def render_ticket_types_table(ticket_types, entry, calendar, day, month, year) -> str:
+    """Render ticket types table with rows and add button."""
+    from quart import url_for, g
+    from shared.browser.app.csrf import generate_csrf_token
+    csrf = generate_csrf_token()
+
+    styles = getattr(g, "styles", None) or {}
+    list_container = getattr(styles, "list_container", "") if hasattr(styles, "list_container") else styles.get("list_container", "")
+    tr_cls = getattr(styles, "tr", "") if hasattr(styles, "tr") else styles.get("tr", "")
+    pill_cls = getattr(styles, "pill", "") if hasattr(styles, "pill") else styles.get("pill", "")
+    action_btn = getattr(styles, "action_button", "") if hasattr(styles, "action_button") else styles.get("action_button", "")
+    hx_select = getattr(g, "hx_select_search", "#main-panel")
+    cal_slug = getattr(calendar, "slug", "")
+    eid = entry.id
+
+    rows_html = ""
+    if ticket_types:
+        for tt in ticket_types:
+            tt_href = url_for(
+                "calendar.day.calendar_entries.calendar_entry.ticket_types.ticket_type.get",
+                calendar_slug=cal_slug, year=year, month=month, day=day,
+                entry_id=eid, ticket_type_id=tt.id,
+            )
+            del_url = url_for(
+                "calendar.day.calendar_entries.calendar_entry.ticket_types.ticket_type.delete",
+                calendar_slug=cal_slug, year=year, month=month, day=day,
+                entry_id=eid, ticket_type_id=tt.id,
+            )
+            cost = getattr(tt, "cost", None)
+            cost_str = f"\u00a3{cost:.2f}" if cost is not None else "\u00a30.00"
+
+            rows_html += sx_call("events-ticket-types-row",
+                                tr_cls=tr_cls, tt_href=tt_href,
+                                pill_cls=pill_cls, hx_select=hx_select,
+                                tt_name=tt.name, cost_str=cost_str,
+                                count=str(tt.count), action_btn=action_btn,
+                                del_url=del_url,
+                                csrf_hdr=f'{{"X-CSRFToken": "{csrf}"}}')
+    else:
+        rows_html = sx_call("events-ticket-types-empty-row")
+
+    add_url = url_for(
+        "calendar.day.calendar_entries.calendar_entry.ticket_types.add_form",
+        calendar_slug=cal_slug, entry_id=eid, year=year, month=month, day=day,
+    )
+
+    return sx_call("events-ticket-types-table",
+                  list_container=list_container, rows=SxExpr(rows_html),
+                  action_btn=action_btn, add_url=add_url)
+
+
+# ---------------------------------------------------------------------------
+# Buy result (ticket purchase confirmation)
+# ---------------------------------------------------------------------------
+
+def render_buy_result(entry, created_tickets, remaining, cart_count) -> str:
+    """Render buy result card with created tickets + OOB cart icon."""
+    from quart import url_for
+
+    cart_html = _cart_icon_oob(cart_count)
+
+    count = len(created_tickets)
+    suffix = "s" if count != 1 else ""
+
+    tickets_html = ""
+    for ticket in created_tickets:
+        href = url_for("defpage_ticket_detail", code=ticket.code)
+        tickets_html += sx_call("events-buy-result-ticket",
+                               href=href, code_short=ticket.code[:12] + "...")
+
+    remaining_html = ""
+    if remaining is not None:
+        r_suffix = "s" if remaining != 1 else ""
+        remaining_html = sx_call("events-buy-result-remaining",
+                                text=f"{remaining} ticket{r_suffix} remaining")
+
+    my_href = url_for("defpage_my_tickets")
+
+    return cart_html + sx_call("events-buy-result",
+                              entry_id=str(entry.id),
+                              count_label=f"{count} ticket{suffix} reserved",
+                              tickets=SxExpr(tickets_html),
+                              remaining=SxExpr(remaining_html),
+                              my_tickets_href=my_href)
+
+
+# ---------------------------------------------------------------------------
+# Buy form (ticket +/- controls)
+# ---------------------------------------------------------------------------
+
+def render_buy_form(entry, ticket_remaining, ticket_sold_count,
+                    user_ticket_count, user_ticket_counts_by_type) -> str:
+    """Render the ticket buy/adjust form with +/- controls."""
+    from quart import url_for
+    from shared.browser.app.csrf import generate_csrf_token
+    csrf = generate_csrf_token()
+
+    eid = entry.id
+    eid_s = str(eid)
+    tp = getattr(entry, "ticket_price", None)
+    state = getattr(entry, "state", "")
+    ticket_types = getattr(entry, "ticket_types", None) or []
+
+    if tp is None:
+        return ""
+
+    if state != "confirmed":
+        return sx_call("events-buy-not-confirmed", entry_id=eid_s)
+
+    adjust_url = url_for("tickets.adjust_quantity")
+    target = f"#ticket-buy-{eid}"
+
+    # Info line
+    info_html = ""
+    info_items = ""
+    if ticket_sold_count:
+        info_items += sx_call("events-buy-info-sold",
+                             count=str(ticket_sold_count))
+    if ticket_remaining is not None:
+        info_items += sx_call("events-buy-info-remaining",
+                             count=str(ticket_remaining))
+    if user_ticket_count:
+        info_items += sx_call("events-buy-info-basket",
+                             count=str(user_ticket_count))
+    if info_items:
+        info_html = sx_call("events-buy-info-bar", items=SxExpr(info_items))
+
+    active_types = [tt for tt in ticket_types if getattr(tt, "deleted_at", None) is None]
+
+    body_html = ""
+    if active_types:
+        type_items = ""
+        for tt in active_types:
+            type_count = user_ticket_counts_by_type.get(tt.id, 0) if user_ticket_counts_by_type else 0
+            cost_str = f"\u00a3{tt.cost:.2f}" if tt.cost is not None else "\u00a30.00"
+            type_items += sx_call("events-buy-type-item",
+                                 type_name=tt.name, cost_str=cost_str,
+                                 adjust_controls=SxExpr(_ticket_adjust_controls(csrf, adjust_url, target, eid, type_count, ticket_type_id=tt.id)))
+        body_html = sx_call("events-buy-types-wrapper", items=SxExpr(type_items))
+    else:
+        qty = user_ticket_count or 0
+        body_html = sx_call("events-buy-default",
+                           price_str=f"\u00a3{tp:.2f}",
+                           adjust_controls=SxExpr(_ticket_adjust_controls(csrf, adjust_url, target, eid, qty)))
+
+    return sx_call("events-buy-panel",
+                  entry_id=eid_s, info=SxExpr(info_html), body=SxExpr(body_html))
+
+
+def _ticket_adjust_controls(csrf, adjust_url, target, entry_id, count, *, ticket_type_id=None):
+    """Render +/- ticket controls for buy form."""
+    from quart import url_for
+
+    tt_html = sx_call("events-adjust-tt-hidden",
+                     ticket_type_id=str(ticket_type_id)) if ticket_type_id else ""
+    eid_s = str(entry_id)
+
+    def _adj_form(count_val, btn_html, *, extra_cls=""):
+        return sx_call("events-adjust-form",
+                      adjust_url=adjust_url, target=target,
+                      extra_cls=extra_cls, csrf=csrf,
+                      entry_id=eid_s, tt=SxExpr(tt_html) if tt_html else None,
+                      count_val=str(count_val), btn=SxExpr(btn_html))
+
+    if count == 0:
+        return _adj_form(1, sx_call("events-adjust-cart-plus"),
+                         extra_cls="flex items-center")
+
+    my_tickets_href = url_for("defpage_my_tickets")
+    minus = _adj_form(count - 1, sx_call("events-adjust-minus"))
+    cart_icon = sx_call("events-adjust-cart-icon",
+                       href=my_tickets_href, count=str(count))
+    plus = _adj_form(count + 1, sx_call("events-adjust-plus"))
+
+    return sx_call("events-adjust-controls",
+                  minus=SxExpr(minus), cart_icon=SxExpr(cart_icon), plus=SxExpr(plus))
+
+
+# ---------------------------------------------------------------------------
+# Adjust response (OOB cart icon + buy form)
+# ---------------------------------------------------------------------------
+
+def render_adjust_response(entry, ticket_remaining, ticket_sold_count,
+                           user_ticket_count, user_ticket_counts_by_type,
+                           cart_count) -> str:
+    """Render ticket adjust response: OOB cart icon + buy form."""
+    cart_html = _cart_icon_oob(cart_count)
+    form_html = render_buy_form(
+        entry, ticket_remaining, ticket_sold_count,
+        user_ticket_count, user_ticket_counts_by_type,
+    )
+    return cart_html + form_html
+
+
+# ---------------------------------------------------------------------------
+# Ticket types header rows
+# ---------------------------------------------------------------------------
+
+def _ticket_types_header_html(ctx: dict, *, oob: bool = False) -> str:
+    """Build the ticket types header row."""
+    from quart import url_for
+
+    calendar = ctx.get("calendar")
+    entry = ctx.get("entry")
+    if not calendar or not entry:
+        return ""
+    cal_slug = getattr(calendar, "slug", "")
+    day = ctx.get("day")
+    month = ctx.get("month")
+    year = ctx.get("year")
+
+    link_href = url_for("calendar.day.calendar_entries.calendar_entry.ticket_types.get",
+                         calendar_slug=cal_slug, entry_id=entry.id,
+                         year=year, month=month, day=day)
+
+    label_html = '<i class="fa fa-ticket"></i><div class="shrink-0">ticket types</div>'
+
+    nav_html = sx_call("events-admin-placeholder-nav")
+
+    return sx_call("menu-row-sx", id="ticket_types-row", level=7,
+                  link_href=link_href, link_label_content=SxExpr(label_html),
+                  nav=SxExpr(nav_html) if nav_html else None, child_id="ticket_type-header-child", oob=oob)
+
+
+
+def _ticket_type_header_html(ctx: dict, *, oob: bool = False) -> str:
+    """Build the single ticket type header row."""
+    from quart import url_for
+
+    calendar = ctx.get("calendar")
+    entry = ctx.get("entry")
+    ticket_type = ctx.get("ticket_type")
+    if not calendar or not entry or not ticket_type:
+        return ""
+    cal_slug = getattr(calendar, "slug", "")
+    day = ctx.get("day")
+    month = ctx.get("month")
+    year = ctx.get("year")
+
+    link_href = url_for(
+        "calendar.day.calendar_entries.calendar_entry.ticket_types.ticket_type.get",
+        calendar_slug=cal_slug, year=year, month=month, day=day,
+        entry_id=entry.id, ticket_type_id=ticket_type.id,
+    )
+
+    label_html = (
+        f'<div class="flex flex-col md:flex-row md:gap-2 items-center">'
+        f'<div class="flex flex-row items-center gap-2">'
+        f'<i class="fa fa-ticket"></i>'
+        f'<div class="shrink-0">{escape(ticket_type.name)}</div>'
+        f'</div></div>'
+    )
+
+    nav_html = sx_call("events-admin-placeholder-nav")
+
+    return sx_call("menu-row-sx", id="ticket_type-row", level=8,
+                  link_href=link_href, link_label_content=SxExpr(label_html),
+                  nav=SxExpr(nav_html) if nav_html else None, child_id="ticket_type-header-child-inner", oob=oob)
+
+
+# ---------------------------------------------------------------------------
+# Ticket type edit form
+# ---------------------------------------------------------------------------
+
+def render_ticket_type_edit_form(ticket_type, entry, calendar, day, month, year) -> str:
+    """Render ticket type edit form (replaces _types/ticket_type/_edit.html)."""
+    from quart import url_for, g
+    from shared.browser.app.csrf import generate_csrf_token
+    csrf = generate_csrf_token()
+
+    styles = getattr(g, "styles", None) or {}
+    list_container = styles.get("list_container", "") if isinstance(styles, dict) else getattr(styles, "list_container", "")
+    action_btn = styles.get("action_button", "") if isinstance(styles, dict) else getattr(styles, "action_button", "")
+    cancel_btn = styles.get("cancel_button", "") if isinstance(styles, dict) else getattr(styles, "cancel_button", "")
+    cal_slug = getattr(calendar, "slug", "")
+    tid = ticket_type.id
+
+    put_url = url_for("calendar.day.calendar_entries.calendar_entry.ticket_types.ticket_type.put",
+                       calendar_slug=cal_slug, year=year, month=month, day=day,
+                       entry_id=entry.id, ticket_type_id=tid)
+    cancel_url = url_for("calendar.day.calendar_entries.calendar_entry.ticket_types.ticket_type.get_view",
+                          calendar_slug=cal_slug, entry_id=entry.id,
+                          year=year, month=month, day=day, ticket_type_id=tid)
+
+    cost = getattr(ticket_type, "cost", None)
+    cost_val = f"{cost:.2f}" if cost is not None else ""
+    count = getattr(ticket_type, "count", 0)
+
+    return sx_call("events-ticket-type-edit-form",
+                  ticket_id=str(tid), list_container=list_container,
+                  put_url=put_url, cancel_url=cancel_url, csrf=csrf,
+                  name_val=ticket_type.name or "",
+                  cost_val=cost_val, count_val=str(count),
+                  action_btn=action_btn, cancel_btn=cancel_btn)
+
+
+# ---------------------------------------------------------------------------
+# Ticket type add form / button
+# ---------------------------------------------------------------------------
+
+def render_ticket_type_add_form(entry, calendar, day, month, year) -> str:
+    """Render ticket type add form (replaces _types/ticket_types/_add.html)."""
+    from quart import url_for, g
+    from shared.browser.app.csrf import generate_csrf_token
+    csrf = generate_csrf_token()
+
+    styles = getattr(g, "styles", None) or {}
+    action_btn = styles.get("action_button", "") if isinstance(styles, dict) else getattr(styles, "action_button", "")
+    cancel_btn = styles.get("cancel_button", "") if isinstance(styles, dict) else getattr(styles, "cancel_button", "")
+    cal_slug = getattr(calendar, "slug", "")
+
+    post_url = url_for("calendar.day.calendar_entries.calendar_entry.ticket_types.post",
+                        calendar_slug=cal_slug, entry_id=entry.id,
+                        year=year, month=month, day=day)
+    cancel_url = url_for("calendar.day.calendar_entries.calendar_entry.ticket_types.add_button",
+                          calendar_slug=cal_slug, entry_id=entry.id,
+                          year=year, month=month, day=day)
+    csrf_hdr = f'{{"X-CSRFToken": "{csrf}"}}'
+
+    return sx_call("events-ticket-type-add-form",
+                  post_url=post_url, csrf=csrf_hdr,
+                  action_btn=action_btn, cancel_btn=cancel_btn,
+                  cancel_url=cancel_url)
+
+
+def render_ticket_type_add_button(entry, calendar, day, month, year) -> str:
+    """Render ticket type add button (replaces _types/ticket_types/_add_button.html)."""
+    from quart import url_for, g
+
+    styles = getattr(g, "styles", None) or {}
+    action_btn = styles.get("action_button", "") if isinstance(styles, dict) else getattr(styles, "action_button", "")
+    cal_slug = getattr(calendar, "slug", "")
+
+    add_url = url_for("calendar.day.calendar_entries.calendar_entry.ticket_types.add_form",
+                       calendar_slug=cal_slug, entry_id=entry.id,
+                       year=year, month=month, day=day)
+
+    return sx_call("events-ticket-type-add-button",
+                  action_btn=action_btn, add_url=add_url)
--- a/events/sxc/pages/utils.py
+++ b/events/sxc/pages/utils.py
@@ -0,0 +1,171 @@
+"""Badge helpers, OOB helpers, formatting utilities, list containers."""
+from __future__ import annotations
+
+from shared.sx.helpers import sx_call
+from shared.sx.parser import SxExpr
+
+
+# ---------------------------------------------------------------------------
+# OOB header helper — delegates to shared
+# ---------------------------------------------------------------------------
+
+
+
+# ---------------------------------------------------------------------------
+# Post header helpers — thin wrapper over shared post_header_sx
+# ---------------------------------------------------------------------------
+
+def _clear_oob(*ids: str) -> str:
+    """Generate OOB swaps to remove orphaned header rows/children."""
+    from shared.sx.helpers import sx_call
+    return "".join(sx_call("clear-oob-div", id=i) for i in ids)
+
+
+# All possible header row/child IDs at each depth (deepest first)
+_EVENTS_DEEP_IDS = [
+    "entry-admin-row", "entry-admin-header-child",
+    "entry-row", "entry-header-child",
+    "day-admin-row", "day-admin-header-child",
+    "day-row", "day-header-child",
+    "calendar-admin-row", "calendar-admin-header-child",
+    "calendar-row", "calendar-header-child",
+    "calendars-row", "calendars-header-child",
+    "post-admin-row", "post-admin-header-child",
+]
+
+
+def _clear_deeper_oob(*keep_ids: str) -> str:
+    """Clear all events header rows/children NOT in keep_ids."""
+    to_clear = [i for i in _EVENTS_DEEP_IDS if i not in keep_ids]
+    return _clear_oob(*to_clear)
+
+
+async def _ensure_container_nav(ctx: dict) -> dict:
+    """Fetch container_nav if not already present (for post header row)."""
+    if ctx.get("container_nav"):
+        return ctx
+    post = ctx.get("post") or {}
+    post_id = post.get("id")
+    slug = post.get("slug", "")
+    if not post_id:
+        return ctx
+    from quart import g
+    from shared.infrastructure.fragments import fetch_fragments
+    current_cal = getattr(g, "calendar_slug", "") or ""
+    nav_params = {
+        "container_type": "page",
+        "container_id": str(post_id),
+        "post_slug": slug,
+        "current_calendar": current_cal,
+    }
+    events_nav, market_nav = await fetch_fragments([
+        ("events", "container-nav", nav_params),
+        ("market", "container-nav", nav_params),
+    ], required=False)
+    return {**ctx, "container_nav": events_nav + market_nav}
+
+
+# ---------------------------------------------------------------------------
+# Utility
+# ---------------------------------------------------------------------------
+
+def _list_container(ctx: dict) -> str:
+    styles = ctx.get("styles") or {}
+    return getattr(styles, "list_container", "") if hasattr(styles, "list_container") else styles.get("list_container", "")
+
+
+def _entry_state_badge_html(state: str) -> str:
+    """Render an entry state badge."""
+    state_classes = {
+        "confirmed": "bg-emerald-100 text-emerald-800",
+        "provisional": "bg-amber-100 text-amber-800",
+        "ordered": "bg-sky-100 text-sky-800",
+        "pending": "bg-stone-100 text-stone-700",
+        "declined": "bg-red-100 text-red-800",
+    }
+    cls = state_classes.get(state, "bg-stone-100 text-stone-700")
+    label = state.replace("_", " ").capitalize()
+    return sx_call("badge", cls=cls, label=label)
+
+
+def _ticket_state_badge_html(state: str) -> str:
+    """Render a ticket state badge."""
+    cls_map = {
+        "confirmed": "bg-emerald-100 text-emerald-800",
+        "checked_in": "bg-blue-100 text-blue-800",
+        "reserved": "bg-amber-100 text-amber-800",
+        "cancelled": "bg-red-100 text-red-800",
+    }
+    cls = cls_map.get(state, "bg-stone-100 text-stone-700")
+    label = (state or "").replace("_", " ").capitalize()
+    return sx_call("badge", cls=cls, label=label)
+
+
+# ---------------------------------------------------------------------------
+# View toggle + SVG caching
+# ---------------------------------------------------------------------------
+
+_LIST_SVG = None
+_TILE_SVG = None
+
+
+def _get_list_svg():
+    global _LIST_SVG
+    if _LIST_SVG is None:
+        _LIST_SVG = sx_call("list-svg")
+    return _LIST_SVG
+
+
+def _get_tile_svg():
+    global _TILE_SVG
+    if _TILE_SVG is None:
+        _TILE_SVG = sx_call("tile-svg")
+    return _TILE_SVG
+
+
+def _view_toggle_html(ctx: dict, view: str) -> str:
+    """Render the list/tile view toggle bar."""
+    from shared.utils import route_prefix
+    prefix = route_prefix()
+    clh = ctx.get("current_local_href", "/")
+    hx_select = ctx.get("hx_select_search", "#main-panel")
+
+    list_href = prefix + str(clh)
+    tile_href = prefix + str(clh)
+    if "?" in list_href:
+        list_href = list_href.split("?")[0]
+    if "?" in tile_href:
+        tile_href = tile_href.split("?")[0] + "?view=tile"
+    else:
+        tile_href = tile_href + "?view=tile"
+
+    list_active = 'bg-stone-200 text-stone-800' if view != 'tile' else 'text-stone-400 hover:text-stone-600'
+    tile_active = 'bg-stone-200 text-stone-800' if view == 'tile' else 'text-stone-400 hover:text-stone-600'
+
+    return sx_call("view-toggle",
+                  list_href=list_href, tile_href=tile_href,
+                  hx_select=hx_select, list_cls=list_active,
+                  tile_cls=tile_active, storage_key="events_view",
+                  list_svg=SxExpr(_get_list_svg()), tile_svg=SxExpr(_get_tile_svg()))
+
+
+def _cart_icon_oob(count: int) -> str:
+    """Render the OOB cart icon/badge swap."""
+    from quart import g
+
+    blog_url_fn = getattr(g, "blog_url", None)
+    cart_url_fn = getattr(g, "cart_url", None)
+    site_fn = getattr(g, "site", None)
+    logo = ""
+    if site_fn:
+        site_obj = site_fn() if callable(site_fn) else site_fn
+        logo = getattr(site_obj, "logo", "") if site_obj else ""
+
+    if count == 0:
+        blog_href = blog_url_fn("/") if blog_url_fn else "/"
+        return sx_call("events-cart-icon-logo",
+                      blog_href=blog_href, logo=logo)
+
+    cart_href = cart_url_fn("/") if cart_url_fn else "/"
+    return sx_call("events-cart-icon-badge",
+                  cart_href=cart_href, count=str(count))
--- a/federation/app.py
+++ b/federation/app.py
@@ -1,6 +1,5 @@
 from __future__ import annotations
 import path_setup  # noqa: F401  # adds shared/ to sys.path
-import sx.sx_components as sx_components  # noqa: F401  # ensure Hypercorn --reload watches this file
 from pathlib import Path

 from quart import g, request
@@ -83,7 +82,9 @@ def create_app() -> "Quart":
        app.jinja_loader,
    ])

-    # --- defpage setup ---
+    # Load .sx component files and setup defpage routes
+    from shared.sx.jinja_bridge import load_service_components
+    load_service_components(str(Path(__file__).resolve().parent), service_name="federation")
    from sxc.pages import setup_federation_pages
    setup_federation_pages()

@@ -106,10 +107,11 @@ def create_app() -> "Quart":
    async def home():
        from quart import make_response
        from shared.sx.page import get_template_context
-        from sx.sx_components import render_federation_home
+        from shared.sx.helpers import root_header_sx, full_page_sx

        ctx = await get_template_context()
-        html = await render_federation_home(ctx)
+        hdr = await root_header_sx(ctx)
+        html = await full_page_sx(ctx, header_rows=hdr)
        return await make_response(html)

    return app
--- a/federation/bp/auth/routes.py
+++ b/federation/bp/auth/routes.py
@@ -42,6 +42,16 @@ SESSION_USER_KEY = "uid"
 ALLOWED_CLIENTS = {"blog", "market", "cart", "events", "account"}


+async def _render_social_auth_page(component: str, title: str, **kwargs) -> str:
+    """Render an auth page with social layout — replaces sx_components helpers."""
+    from shared.sx.helpers import sx_call
+    from shared.sx.page import get_template_context
+    from sxc.pages.utils import _social_page
+    ctx = await get_template_context()
+    content = sx_call(component, **{k: v for k, v in kwargs.items() if v})
+    return await _social_page(ctx, None, content=content, title=title)
+
+
 def register(url_prefix="/auth"):
    auth_bp = Blueprint("auth", __name__, url_prefix=url_prefix)

@@ -99,10 +109,7 @@ def register(url_prefix="/auth"):
            # If there's a pending redirect (e.g. OAuth authorize), follow it
            redirect_url = pop_login_redirect_target()
            return redirect(redirect_url)
-        from shared.sx.page import get_template_context
-        from sx.sx_components import render_login_page
-        ctx = await get_template_context()
-        return await render_login_page(ctx)
+        return await _render_social_auth_page("account-login-content", "Login \u2014 Rose Ash")

    @auth_bp.post("/start/")
    async def start_login():
@@ -111,10 +118,10 @@ def register(url_prefix="/auth"):

        is_valid, email = validate_email(email_input)
        if not is_valid:
-            from shared.sx.page import get_template_context
-            from sx.sx_components import render_login_page
-            ctx = await get_template_context(error="Please enter a valid email address.", email=email_input)
-            return await render_login_page(ctx), 400
+            return await _render_social_auth_page(
+                "account-login-content", "Login \u2014 Rose Ash",
+                error="Please enter a valid email address.", email=email_input,
+            ), 400

        user = await find_or_create_user(g.s, email)
        token, expires = await create_magic_link(g.s, user.id)
@@ -132,10 +139,10 @@ def register(url_prefix="/auth"):
                "Please try again in a moment."
            )

-        from shared.sx.page import get_template_context
-        from sx.sx_components import render_check_email_page
-        ctx = await get_template_context(email=email, email_error=email_error)
-        return await render_check_email_page(ctx)
+        return await _render_social_auth_page(
+            "account-check-email-content", "Check your email \u2014 Rose Ash",
+            email=email, email_error=email_error,
+        )

    @auth_bp.get("/magic/<token>/")
    async def magic(token: str):
@@ -148,17 +155,17 @@ def register(url_prefix="/auth"):
                    user, error = await validate_magic_link(s, token)

                    if error:
-                        from shared.sx.page import get_template_context
-                        from sx.sx_components import render_login_page
-                        ctx = await get_template_context(error=error)
-                        return await render_login_page(ctx), 400
+                        return await _render_social_auth_page(
+                            "account-login-content", "Login \u2014 Rose Ash",
+                            error=error,
+                        ), 400
                    user_id = user.id

        except Exception:
-            from shared.sx.page import get_template_context
-            from sx.sx_components import render_login_page
-            ctx = await get_template_context(error="Could not sign you in right now. Please try again.")
-            return await render_login_page(ctx), 502
+            return await _render_social_auth_page(
+                "account-login-content", "Login \u2014 Rose Ash",
+                error="Could not sign you in right now. Please try again.",
+            ), 502

        assert user_id is not None

--- a/federation/bp/identity/routes.py
+++ b/federation/bp/identity/routes.py
@@ -26,6 +26,33 @@ RESERVED = frozenset({
 })


+async def _render_choose_username(*, actor=None, error="", username=""):
+    """Render choose-username page — replaces sx_components helper."""
+    from shared.browser.app.csrf import generate_csrf_token
+    from shared.config import config
+    from shared.sx.helpers import sx_call
+    from shared.sx.parser import SxExpr
+    from shared.sx.page import get_template_context
+    from sxc.pages.utils import _social_page
+    from markupsafe import escape
+
+    ctx = await get_template_context()
+    csrf = generate_csrf_token()
+    ap_domain = config().get("ap_domain", "rose-ash.com")
+    check_url = url_for("identity.check_username")
+
+    error_sx = sx_call("auth-error-banner", error=error) if error else ""
+    content = sx_call(
+        "federation-choose-username",
+        domain=str(escape(ap_domain)),
+        error=SxExpr(error_sx) if error_sx else None,
+        csrf=csrf, username=str(escape(username)),
+        check_url=check_url,
+    )
+    return await _social_page(ctx, actor, content=content,
+                        title="Choose Username \u2014 Rose Ash")
+
+
 def register(url_prefix="/identity"):
    bp = Blueprint("identity", __name__, url_prefix=url_prefix)

@@ -39,11 +66,7 @@ def register(url_prefix="/identity"):
        if actor:
            return redirect(url_for("activitypub.actor_profile", username=actor.preferred_username))

-        from shared.sx.page import get_template_context
-        from sx.sx_components import render_choose_username_page
-        ctx = await get_template_context()
-        ctx["actor"] = actor
-        return await render_choose_username_page(ctx)
+        return await _render_choose_username(actor=actor)

    @bp.post("/choose-username")
    async def choose_username():
@@ -71,11 +94,7 @@ def register(url_prefix="/identity"):
            error = "This username is already taken."

        if error:
-            from shared.sx.page import get_template_context
-            from sx.sx_components import render_choose_username_page
-            ctx = await get_template_context(error=error, username=username)
-            ctx["actor"] = None
-            return await render_choose_username_page(ctx), 400
+            return await _render_choose_username(error=error, username=username), 400

        # Create ActorProfile with RSA keys
        display_name = g.user.name or username
--- a/Show More
+++ b/Show More