Monorepo: consolidate 7 repos into one

Combines shared, blog, market, cart, events, federation, and account
into a single repository. Eliminates submodule sync, sibling model
copying at build time, and per-app CI orchestration.

Changes:
- Remove per-app .git, .gitmodules, .gitea, submodule shared/ dirs
- Remove stale sibling model copies from each app
- Update all 6 Dockerfiles for monorepo build context (root = .)
- Add build directives to docker-compose.yml
- Add single .gitea/workflows/ci.yml with change detection
- Add .dockerignore for monorepo build context
- Create __init__.py for federation and account (cross-app imports)

events/bp/markets/routes.py

@@ -0,0 +1,65 @@
+from __future__ import annotations
+
+from quart import (
+    request, render_template, make_response, Blueprint, g
+)
+
+from .services.markets import (
+    create_market as svc_create_market,
+    soft_delete as svc_soft_delete,
+)
+
+from shared.browser.app.redis_cacher import cache_page, clear_cache
+from shared.browser.app.authz import require_admin
+from shared.browser.app.utils.htmx import is_htmx_request
+
+
+def register():
+    bp = Blueprint("markets", __name__, url_prefix='/markets')
+
+    @bp.context_processor
+    async def inject_root():
+        return {}
+
+    @bp.get("/")
+    async def home(**kwargs):
+        if not is_htmx_request():
+            html = await render_template("_types/markets/index.html")
+        else:
+            html = await render_template("_types/markets/_oob_elements.html")
+        return await make_response(html)
+
+    @bp.post("/new/")
+    @require_admin
+    async def create_market(**kwargs):
+        form = await request.form
+        name = (form.get("name") or "").strip()
+
+        post_data = getattr(g, "post_data", None)
+        post_id = (post_data.get("post") or {}).get("id") if post_data else None
+
+        if not post_id:
+            post_id = form.get("post_id")
+            if post_id:
+                post_id = int(post_id)
+
+        try:
+            await svc_create_market(g.s, post_id, name)
+        except Exception as e:
+            return await make_response(f'<div class="text-red-600 text-sm">{e}</div>', 422)
+
+        html = await render_template("_types/markets/index.html")
+        return await make_response(html)
+
+    @bp.delete("/<market_slug>/")
+    @require_admin
+    async def delete_market(market_slug: str, **kwargs):
+        post_slug = getattr(g, "post_slug", None)
+        deleted = await svc_soft_delete(g.s, post_slug, market_slug)
+        if not deleted:
+            return await make_response("Market not found", 404)
+
+        html = await render_template("_types/markets/index.html")
+        return await make_response(html)
+
+    return bp

events/bp/markets/services/markets.py

@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+import re
+import unicodedata
+
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from shared.contracts.dtos import MarketPlaceDTO
+from shared.services.registry import services
+
+
+class MarketError(ValueError):
+    """Base error for market service operations."""
+
+
+def slugify(value: str, max_len: int = 255) -> str:
+    if value is None:
+        value = ""
+    value = unicodedata.normalize("NFKD", value)
+    value = value.encode("ascii", "ignore").decode("ascii")
+    value = value.lower()
+    value = value.replace("/", "-")
+    value = re.sub(r"[^a-z0-9]+", "-", value)
+    value = re.sub(r"-{2,}", "-", value)
+    value = value.strip("-")[:max_len].strip("-")
+    return value or "market"
+
+
+async def create_market(sess: AsyncSession, post_id: int, name: str) -> MarketPlaceDTO:
+    """
+    Create a market for a page. Name must be unique per page.
+    If a market with the same (post_id, slug) exists but is soft-deleted,
+    it will be revived.
+    """
+    name = (name or "").strip()
+    if not name:
+        raise MarketError("Market name must not be empty.")
+    slug = slugify(name)
+
+    post = await services.blog.get_post_by_id(sess, post_id)
+    if not post:
+        raise MarketError(f"Post {post_id} does not exist.")
+    if not post.is_page:
+        raise MarketError("Markets can only be created on pages, not posts.")
+
+    try:
+        return await services.market.create_marketplace(sess, "page", post_id, name, slug)
+    except ValueError as e:
+        raise MarketError(str(e)) from e
+
+
+async def soft_delete(sess: AsyncSession, post_slug: str, market_slug: str) -> bool:
+    post = await services.blog.get_post_by_slug(sess, post_slug)
+    if not post:
+        return False
+
+    return await services.market.soft_delete_marketplace(sess, "page", post.id, market_slug)