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/calendars/routes.py

@@ -0,0 +1,99 @@
+from __future__ import annotations
+
+from quart import (
+    request, render_template, make_response, Blueprint, g
+)
+from sqlalchemy import select
+
+from models.calendars import Calendar
+
+
+from .services.calendars import (
+    create_calendar as svc_create_calendar,
+)
+
+from ..calendar.routes import register as register_calendar
+
+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("calendars", __name__, url_prefix='/calendars')
+    bp.register_blueprint(
+      register_calendar(),
+    )
+    @bp.context_processor
+    async def inject_root():
+        # Must always return a dict
+        return {}
+
+    # ---------- Pages ----------
+
+    @bp.get("/")
+    @cache_page(tag="calendars")
+    async def home(**kwargs):
+        if not is_htmx_request():
+            html = await render_template(
+                "_types/calendars/index.html",
+            )
+        else:
+            html = await render_template(
+                "_types/calendars/_oob_elements.html",
+            )
+        return await make_response(html)
+
+
+    @bp.post("/new/")
+    @require_admin
+    @clear_cache(tag="calendars", tag_scope="all")
+    async def create_calendar(**kwargs):
+        form = await request.form
+        name = (form.get("name") or "").strip()
+
+        # Get post_id from context if available (blog-embedded mode)
+        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:
+            # Standalone mode: post_id from form (or None — calendar without post)
+            post_id = form.get("post_id")
+            if post_id:
+                post_id = int(post_id)
+
+        try:
+            await svc_create_calendar(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/calendars/index.html",
+        )
+
+        # Blog-embedded mode: also update post nav
+        if post_data:
+            from ..post.services.entry_associations import get_associated_entries
+
+            cals = (
+                await g.s.execute(
+                    select(Calendar)
+                    .where(Calendar.container_type == "page", Calendar.container_id == post_id, Calendar.deleted_at.is_(None))
+                    .order_by(Calendar.name.asc())
+                )
+            ).scalars().all()
+
+            associated_entries = await get_associated_entries(g.s, post_id)
+
+            nav_oob = await render_template(
+                "_types/post/admin/_nav_entries_oob.html",
+                associated_entries=associated_entries,
+                calendars=cals,
+                post=post_data["post"],
+            )
+
+            html = html + nav_oob
+
+        return await make_response(html)
+    return bp

events/bp/calendars/services/calendars.py

@@ -0,0 +1,115 @@
+from __future__ import annotations
+
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from models.calendars import Calendar
+from shared.services.registry import services
+from shared.services.relationships import attach_child, detach_child
+import unicodedata
+import re
+
+
+class CalendarError(ValueError):
+    """Base error for calendar service operations."""
+
+from shared.browser.app.utils import (
+    utcnow
+)
+
+def slugify(value: str, max_len: int = 255) -> str:
+    """
+    Make a URL-friendly slug:
+    - lowercase
+    - remove accents
+    - replace any non [a-z0-9]+ with '-'
+    - no forward slashes
+    - collapse multiple dashes
+    - trim leading/trailing dashes
+    """
+    if value is None:
+        value = ""
+    # normalize accents -> ASCII
+    value = unicodedata.normalize("NFKD", value)
+    value = value.encode("ascii", "ignore").decode("ascii")
+    value = value.lower()
+
+    # explicitly block forward slashes
+    value = value.replace("/", "-")
+
+    # replace non-alnum with hyphen
+    value = re.sub(r"[^a-z0-9]+", "-", value)
+    # collapse multiple hyphens
+    value = re.sub(r"-{2,}", "-", value)
+    # trim hyphens and enforce length
+    value = value.strip("-")[:max_len].strip("-")
+
+    # fallback if empty
+    return value or "calendar"
+
+
+async def soft_delete(sess: AsyncSession, post_slug: str, calendar_slug: str) -> bool:
+    post = await services.blog.get_post_by_slug(sess, post_slug)
+    if not post:
+        return False
+
+    cal = (
+        await sess.execute(
+            select(Calendar).where(
+                Calendar.container_type == "page",
+                Calendar.container_id == post.id,
+                Calendar.slug == calendar_slug,
+                Calendar.deleted_at.is_(None),
+            )
+        )
+    ).scalar_one_or_none()
+
+    if not cal:
+        return False
+
+    cal.deleted_at = utcnow()
+    await sess.flush()
+    await detach_child(sess, "page", cal.container_id, "calendar", cal.id)
+    return True
+
+async def create_calendar(sess: AsyncSession, post_id: int, name: str) -> Calendar:
+    """
+    Create a calendar for a post. Name must be unique per post.
+    If a calendar with the same (post_id, name) exists but is soft-deleted,
+    it will be revived (deleted_at=None).
+    """
+    name = (name or "").strip()
+    if not name:
+        raise CalendarError("Calendar name must not be empty.")
+    slug=slugify(name)
+
+    # Ensure post exists (avoid silent FK errors in some DBs)
+    post = await services.blog.get_post_by_id(sess, post_id)
+    if not post:
+        raise CalendarError(f"Post {post_id} does not exist.")
+
+    # Enforce: calendars can only be created on pages with the calendar feature
+    if not post.is_page:
+        raise CalendarError("Calendars can only be created on pages, not posts.")
+
+    # Look for existing (including soft-deleted)
+    q = await sess.execute(
+        select(Calendar).where(Calendar.container_type == "page", Calendar.container_id == post_id, Calendar.name == name)
+    )
+    existing = q.scalar_one_or_none()
+
+    if existing:
+        if existing.deleted_at is not None:
+            existing.deleted_at = None  # revive
+            await sess.flush()
+            await attach_child(sess, "page", post_id, "calendar", existing.id)
+            return existing
+        raise CalendarError(f'Calendar with slug "{slug}" already exists for post {post_id}.')
+
+    cal = Calendar(container_type="page", container_id=post_id, name=name, slug=slug)
+    sess.add(cal)
+    await sess.flush()
+    await attach_child(sess, "page", post_id, "calendar", cal.id)
+    return cal
+
+