@blogmcp/community 0.0.0-stage → 0.2.0

package/src/core/text.ts

@@ -0,0 +1,174 @@
+/**
+ * Text, and only text (m1-contracts.md §10.4, community.md §7.7): what a member wrote is rendered as text
+ * nodes — never HTML, never markdown. A web address in it becomes a link only through @blogmcp/sanitize's
+ * `sanitizeUrl`, and the view gives every such link `rel="nofollow ugc noopener noreferrer"` and
+ * `target="_blank"`. test/text-only.spec.ts bans `v-html`, `innerHTML` and any HTML parser in src/.
+ */
+import { sanitizeUrl } from '@blogmcp/sanitize/url'
+import { communityMentionSpans } from '@blogmcp/sdk/community'
+
+export type TextSegment =
+  | { readonly kind: 'text'; readonly text: string }
+  | { readonly kind: 'link'; readonly text: string; readonly href: string }
+  /** M2: an `@handle` with the link to the member's profile page on the host's own site (never a member's URL). */
+  | { readonly kind: 'mention'; readonly text: string; readonly href: string }
+
+/** The rel every link to what a member wrote carries (user-generated, no referrer, no opener). */
+export const UGC_LINK_REL = 'nofollow ugc noopener noreferrer'
+
+/** A web address as people write it: `http(s)://` or `www.`, up to a blank or a character no address carries. */
+const URL_RE = /\b(?:https?:\/\/|www\.)[^\s<>"'`{}|\\^]+/gi
+/** Characters that end a sentence more often than an address. */
+const TRAILING = '.,;:!?…\'"»”’]'
+
+/** The address without the punctuation after it; a `)` stays when it closes a `(` inside the address. */
+function trimUrl(raw: string): string {
+  let url = raw
+  while (url.length > 0) {
+    const last = url[url.length - 1]!
+    if (last === ')') {
+      const opens = url.split('(').length - 1
+      const closes = url.split(')').length - 1
+      if (closes <= opens) break
+    } else if (!TRAILING.includes(last)) {
+      break
+    }
+    url = url.slice(0, -1)
+  }
+  return url
+}
+
+/** The link target of an address, or null: only http and https survive sanitizeUrl as a link. */
+function safeHref(url: string): string | null {
+  const candidate = /^www\./i.test(url) ? `https://${url}` : url
+  // A bare scheme is no address.
+  if (/^https?:\/\/$/i.test(candidate)) return null
+  const safe = sanitizeUrl(candidate)
+  return safe !== 'about:blank' && /^https?:\/\//i.test(safe) ? safe : null
+}
+
+/** A member's text as text runs and links. */
+export function linkify(text: string): TextSegment[] {
+  const out: TextSegment[] = []
+  if (typeof text !== 'string' || text === '') return out
+  let at = 0
+  for (const m of text.matchAll(URL_RE)) {
+    const start = m.index ?? 0
+    if (start < at) continue
+    const url = trimUrl(m[0])
+    const href = url ? safeHref(url) : null
+    if (!href) continue
+    if (start > at) out.push({ kind: 'text', text: text.slice(at, start) })
+    out.push({ kind: 'link', text: url, href })
+    at = start + url.length
+  }
+  if (at < text.length) out.push({ kind: 'text', text: text.slice(at) })
+  return out
+}
+
+/**
+ * A member's text as text runs, web-address links and `@handle` mentions (m2-contracts.md §3.3: „the element renders
+ * `@handle` as text with a link to `/u/{handle}`"). The mentions are the SDK's (kb-api's token rule), found only in the
+ * text between addresses — an address's `/@x` stays part of its link; `profileHref` builds the host's profile page
+ * (profilePath) and a handle it gives no page for stays text. Joining every segment's `text` gives the body back.
+ */
+export function linkifyWithMentions(text: string, profileHref: ((handle: string) => string | null) | null): TextSegment[] {
+  const segments = linkify(text)
+  if (!profileHref) return segments
+  const out: TextSegment[] = []
+  for (const s of segments) {
+    if (s.kind !== 'text' || !s.text.includes('@')) {
+      out.push(s)
+      continue
+    }
+    for (const span of communityMentionSpans(s.text)) {
+      const href = span.kind === 'mention' ? profileHref(span.handle) : null
+      if (span.kind === 'mention' && href) out.push({ kind: 'mention', text: span.text, href })
+      else {
+        const last = out[out.length - 1]
+        // Text next to text stays one run (a handle without a page, between two runs).
+        if (last && last.kind === 'text') out[out.length - 1] = { kind: 'text', text: last.text + span.text }
+        else out.push({ kind: 'text', text: span.text })
+      }
+    }
+  }
+  return out
+}
+
+/** Characters in code points, as kb-api counts a body (after NFC and trimming). */
+export function codePointLength(text: string): number {
+  let n = 0
+  for (const _ of text) n++
+  return n
+}
+
+/** A body as kb-api will measure it: NFC, trimmed. */
+export function normalizeBody(text: string): string {
+  return typeof text === 'string' ? text.normalize('NFC').trim() : ''
+}
+
+const ENTITIES: Readonly<Record<string, string>> = Object.freeze({
+  amp: '&',
+  lt: '<',
+  gt: '>',
+  quot: '"',
+  apos: "'",
+  nbsp: ' ',
+  ndash: '–',
+  mdash: '—',
+  hellip: '…',
+  laquo: '«',
+  raquo: '»',
+  bdquo: '„',
+  ldquo: '“',
+  rdquo: '”',
+  lsquo: '‘',
+  rsquo: '’',
+  sbquo: '‚',
+  copy: '©',
+  reg: '®',
+  euro: '€',
+  shy: '',
+})
+
+function decodeEntities(text: string): string {
+  return text.replace(/&(#\d{1,7}|#x[0-9a-f]{1,6}|[a-z]{2,8});/gi, (match, entity: string) => {
+    if (entity[0] === '#') {
+      const hex = entity[1] === 'x' || entity[1] === 'X'
+      const cp = Number.parseInt(entity.slice(hex ? 2 : 1), hex ? 16 : 10)
+      return cp > 0 && cp <= 0x10ffff && !(cp >= 0xd800 && cp <= 0xdfff) ? String.fromCodePoint(cp) : match
+    }
+    return ENTITIES[entity.toLowerCase()] ?? match
+  })
+}
+
+/** Elements whose end closes a paragraph of the text. */
+const BLOCK_END = /<\/(?:p|div|li|h[1-6]|section|article|blockquote|tr|ul|ol|dl|dt|dd|header|footer|table|pre|figure)\s*>/gi
+/** Elements whose start opens one. */
+const BLOCK_START = /<(?:li|tr|dt|dd|h[1-6]|blockquote|pre|figure)\b[^>]*>/gi
+
+/**
+ * The paragraphs of the tenant's own legal text (`legal/current`'s `body` is HTML with anchors) as plain
+ * text, for the art. 9 consent step: tags are dropped and entities decoded AFTER that, so nothing in the
+ * text is ever parsed as markup again. String work only — no HTML parser, no live DOM.
+ */
+export function htmlToParagraphs(html: string): string[] {
+  if (typeof html !== 'string' || html === '') return []
+  const text = html
+    .replace(/<!--[\s\S]*?-->/g, '')
+    .replace(/<(script|style|template|noscript|svg|math)\b[\s\S]*?<\/\1\s*>/gi, '')
+    .replace(/[\t\n\r\f ]+/g, ' ')
+    .replace(/<br\b[^>]*>/gi, '\n')
+    .replace(BLOCK_END, '\n\n')
+    .replace(BLOCK_START, '\n\n')
+    .replace(/<[^>]*>/g, '')
+  return decodeEntities(text)
+    .split(/\n{2,}/)
+    .map((p) =>
+      p
+        .replace(/ *\n */g, '\n')
+        .replace(/[  ]{2,}/g, ' ')
+        .trim(),
+    )
+    .filter((p) => p !== '')
+}

package/src/core/turnstile.ts

@@ -0,0 +1,98 @@
+/**
+ * Cloudflare Turnstile for the notice form, by the storefront's TurnstileWidget rules: rendered explicitly,
+ * the script loaded only when a notice form mounts (no other page sends Cloudflare a byte), the token
+ * one-shot — kb-api spends it on siteverify whatever the answer, so the form asks for a new one after every
+ * failure — and a form whose script did not load cannot be sent.
+ *
+ * The widget is rendered into an element in the custom element's LIGHT DOM (projected through a slot):
+ * Turnstile's iframe then lives in the page's own document, as on any other site.
+ */
+import { COMMUNITY_NOTICE_TURNSTILE_ACTION } from '@blogmcp/sdk/community'
+
+export const TURNSTILE_SCRIPT_SRC = 'https://challenges.cloudflare.com/turnstile/v0/api.js?render=explicit'
+
+interface TurnstileRenderOptions {
+  sitekey: string
+  action?: string
+  language?: string
+  appearance?: 'always' | 'execute' | 'interaction-only'
+  callback?: (token: string) => void
+  'expired-callback'?: () => void
+  'error-callback'?: () => void
+  'timeout-callback'?: () => void
+}
+
+export interface TurnstileApi {
+  render(el: HTMLElement, options: TurnstileRenderOptions): string
+  reset(widgetId: string): void
+  remove(widgetId: string): void
+}
+
+type TurnstileWindow = Window & { turnstile?: TurnstileApi }
+
+let scriptPromise: Promise<TurnstileApi> | null = null
+
+/** One `<script>` per page however many forms mount; a failed load may be tried again later. */
+export function loadTurnstile(nonce?: string): Promise<TurnstileApi> {
+  const w = window as TurnstileWindow
+  if (w.turnstile) return Promise.resolve(w.turnstile)
+  if (scriptPromise) return scriptPromise
+  scriptPromise = new Promise<TurnstileApi>((resolve, reject) => {
+    const script = document.createElement('script')
+    script.src = TURNSTILE_SCRIPT_SRC
+    script.async = true
+    script.defer = true
+    if (nonce) script.nonce = nonce
+    script.onload = () => (w.turnstile ? resolve(w.turnstile) : reject(new Error('[blogmcp-community] the Turnstile script loaded without its API')))
+    script.onerror = () => reject(new Error('[blogmcp-community] the Turnstile script failed to load'))
+    document.head.appendChild(script)
+  }).catch((err: unknown) => {
+    scriptPromise = null
+    throw err
+  })
+  return scriptPromise
+}
+
+export interface TurnstileWidget {
+  /** A fresh token (the last one is spent). */
+  reset(): void
+  remove(): void
+}
+
+export interface RenderTurnstileOptions {
+  siteKey: string
+  language: string
+  /** A new token, or null when it expired or failed (the form cannot be sent until a new one comes). */
+  onToken(token: string | null): void
+  nonce?: string
+}
+
+/** The widget in `container`; rejects when the script cannot load (an ad blocker, the network). */
+export async function renderTurnstile(container: HTMLElement, o: RenderTurnstileOptions): Promise<TurnstileWidget> {
+  const api = await loadTurnstile(o.nonce)
+  const id = api.render(container, {
+    sitekey: o.siteKey,
+    // kb-api refuses a token issued for any other action.
+    action: COMMUNITY_NOTICE_TURNSTILE_ACTION,
+    language: o.language,
+    // Visible only when Cloudflare really wants an interaction.
+    appearance: 'interaction-only',
+    callback: (token) => o.onToken(token),
+    'expired-callback': () => o.onToken(null),
+    'error-callback': () => o.onToken(null),
+    'timeout-callback': () => o.onToken(null),
+  })
+  let removed = false
+  return {
+    reset() {
+      if (removed) return
+      o.onToken(null)
+      api.reset(id)
+    },
+    remove() {
+      if (removed) return
+      removed = true
+      api.remove(id)
+    },
+  }
+}

package/src/element.ts

@@ -0,0 +1,165 @@
+/// <reference path="./shims.d.ts" />
+/**
+ * The custom elements (Vue inside a shadow root each), m1-contracts.md §10.4 and m2-contracts.md §3.10:
+ *
+ *   <blogmcp-discussion>           article-id, api-base, site-base, lang, sign-in-href, routes, poll-ms, nonce
+ *                                  (+ the `realtime` property: a session factory the host passes, M2)
+ *   <blogmcp-notice-form>          api-base, site-base, lang, turnstile-site-key, target | article-id, routes, nonce
+ *   <blogmcp-my-community>         api-base, site-base, lang, decision-id, routes, sign-in-href, nonce
+ *   <blogmcp-notification-centre>  api-base, site-base, lang, routes, sign-in-href, nonce                       (M2)
+ *   <blogmcp-badge>                api-base, site-base, lang, routes, poll-ms, nonce                            (M2)
+ *   <blogmcp-member-settings>      api-base, site-base, lang, sw-path, routes, sign-in-href, nonce              (M2)
+ *   <blogmcp-profile>              handle, api-base, site-base, lang, routes, sign-in-href, nonce               (M2)
+ *   <blogmcp-welcome>              api-base, site-base, lang, routes, sign-in-href, nonce                       (M2)
+ *
+ * Each carries ONE inline stylesheet in its shadow root, with the CSP nonce honoured: the one given when the
+ * elements are defined (the script build passes `document.currentScript.nonce`), else the element's own
+ * `nonce` — read from the property, because a page with a CSP hides the attribute once it is connected.
+ */
+import { defineCustomElement, type Component } from 'vue'
+import BadgeView from './ui/BadgeView.vue'
+import DiscussionView from './ui/DiscussionView.vue'
+import MemberSettingsView from './ui/MemberSettingsView.vue'
+import MyCommunityView from './ui/MyCommunityView.vue'
+import NoticeFormView from './ui/NoticeFormView.vue'
+import NotificationCentreView from './ui/NotificationCentreView.vue'
+import ProfileView from './ui/ProfileView.vue'
+import WelcomeView from './ui/WelcomeView.vue'
+import css from './ui/styles.css?inline'
+
+/**
+ * Vue's ESM build reads three compile-time flags as globals, and only a bundler running Vue's own plugin
+ * defines them. A React site (or any bundler without `@vitejs/plugin-vue`) leaves them undefined, and mounting
+ * the element then throws `__VUE_PROD_DEVTOOLS__ is not defined` (the review layer met it on the drhoubicka
+ * storefront, 2026-10-02). Give them Vue's documented defaults when nothing did; a site that set them keeps
+ * its values.
+ */
+function ensureVueFeatureFlags(): void {
+  const g = globalThis as Record<string, unknown>
+  const defaults: Record<string, boolean> = {
+    __VUE_OPTIONS_API__: true,
+    __VUE_PROD_DEVTOOLS__: false,
+    __VUE_PROD_HYDRATION_MISMATCH_DETAILS__: false,
+  }
+  for (const [flag, value] of Object.entries(defaults)) if (typeof g[flag] === 'undefined') g[flag] = value
+}
+
+export const DISCUSSION_ELEMENT_TAG = 'blogmcp-discussion'
+export const NOTICE_FORM_ELEMENT_TAG = 'blogmcp-notice-form'
+export const MY_COMMUNITY_ELEMENT_TAG = 'blogmcp-my-community'
+/** M2 (m2-contracts.md §3.10). */
+export const NOTIFICATION_CENTRE_ELEMENT_TAG = 'blogmcp-notification-centre'
+export const BADGE_ELEMENT_TAG = 'blogmcp-badge'
+export const MEMBER_SETTINGS_ELEMENT_TAG = 'blogmcp-member-settings'
+export const PROFILE_ELEMENT_TAG = 'blogmcp-profile'
+export const WELCOME_ELEMENT_TAG = 'blogmcp-welcome'
+
+export interface DefineCommunityElementOptions {
+  /** Another tag name for the element. */
+  tag?: string
+  /** CSP nonce for the element's `<style>` (else each element's own `nonce`). */
+  nonce?: string
+}
+
+export interface DefineCommunityElementsOptions {
+  /** CSP nonce for the elements' `<style>`. */
+  nonce?: string
+  tags?: {
+    discussion?: string
+    noticeForm?: string
+    myCommunity?: string
+    notificationCentre?: string
+    badge?: string
+    memberSettings?: string
+    profile?: string
+    welcome?: string
+  }
+}
+
+/** The element's own nonce: the property (a CSP hides the attribute once connected), else the attribute. */
+function ownNonce(el: HTMLElement): string | undefined {
+  const fromProperty = (el as HTMLElement & { nonce?: unknown }).nonce
+  if (typeof fromProperty === 'string' && fromProperty !== '') return fromProperty
+  return el.getAttribute('nonce') || undefined
+}
+
+function communityElement(component: Component, defineNonce: string | undefined): CustomElementConstructor {
+  // No `styles` option: the stylesheet is put in below, so a per-element nonce can be honoured.
+  const Base = defineCustomElement(component as Parameters<typeof defineCustomElement>[0])
+  return class CommunityElement extends Base {
+    override connectedCallback(): void {
+      const own = ownNonce(this)
+      const nonce = defineNonce || own
+      // The element carries the nonce it uses (the IDL property, which a CSP never hides), so what it loads
+      // later — the notice form's Turnstile script — gets the same one, the script build's included.
+      if (nonce && !own) (this as HTMLElement & { nonce: string }).nonce = nonce
+      const root = this.shadowRoot
+      if (root && !root.querySelector('style[data-bcm]')) {
+        const style = document.createElement('style')
+        style.setAttribute('data-bcm', '')
+        if (nonce) style.setAttribute('nonce', nonce)
+        style.textContent = css
+        root.prepend(style)
+      }
+      super.connectedCallback()
+    }
+  }
+}
+
+function define(tag: string, component: Component, nonce: string | undefined): void {
+  if (typeof customElements === 'undefined' || customElements.get(tag)) return
+  ensureVueFeatureFlags()
+  customElements.define(tag, communityElement(component, nonce))
+}
+
+/** Register `<blogmcp-discussion>` (once; later calls are no-ops). Browser only. */
+export function defineDiscussionElement(opts: DefineCommunityElementOptions = {}): void {
+  define(opts.tag ?? DISCUSSION_ELEMENT_TAG, DiscussionView, opts.nonce)
+}
+
+/** Register `<blogmcp-notice-form>` (once). Browser only. */
+export function defineNoticeFormElement(opts: DefineCommunityElementOptions = {}): void {
+  define(opts.tag ?? NOTICE_FORM_ELEMENT_TAG, NoticeFormView, opts.nonce)
+}
+
+/** Register `<blogmcp-my-community>` (once). Browser only. */
+export function defineMyCommunityElement(opts: DefineCommunityElementOptions = {}): void {
+  define(opts.tag ?? MY_COMMUNITY_ELEMENT_TAG, MyCommunityView, opts.nonce)
+}
+
+/** Register `<blogmcp-notification-centre>` (once). Browser only. */
+export function defineNotificationCentreElement(opts: DefineCommunityElementOptions = {}): void {
+  define(opts.tag ?? NOTIFICATION_CENTRE_ELEMENT_TAG, NotificationCentreView, opts.nonce)
+}
+
+/** Register `<blogmcp-badge>` (once). Browser only. */
+export function defineBadgeElement(opts: DefineCommunityElementOptions = {}): void {
+  define(opts.tag ?? BADGE_ELEMENT_TAG, BadgeView, opts.nonce)
+}
+
+/** Register `<blogmcp-member-settings>` (once). Browser only. */
+export function defineMemberSettingsElement(opts: DefineCommunityElementOptions = {}): void {
+  define(opts.tag ?? MEMBER_SETTINGS_ELEMENT_TAG, MemberSettingsView, opts.nonce)
+}
+
+/** Register `<blogmcp-profile>` (once). Browser only. */
+export function defineProfileElement(opts: DefineCommunityElementOptions = {}): void {
+  define(opts.tag ?? PROFILE_ELEMENT_TAG, ProfileView, opts.nonce)
+}
+
+/** Register `<blogmcp-welcome>` (once). Browser only. */
+export function defineWelcomeElement(opts: DefineCommunityElementOptions = {}): void {
+  define(opts.tag ?? WELCOME_ELEMENT_TAG, WelcomeView, opts.nonce)
+}
+
+/** Register all eight (once). Browser only. */
+export function defineCommunityElements(opts: DefineCommunityElementsOptions = {}): void {
+  defineDiscussionElement({ tag: opts.tags?.discussion, nonce: opts.nonce })
+  defineNoticeFormElement({ tag: opts.tags?.noticeForm, nonce: opts.nonce })
+  defineMyCommunityElement({ tag: opts.tags?.myCommunity, nonce: opts.nonce })
+  defineNotificationCentreElement({ tag: opts.tags?.notificationCentre, nonce: opts.nonce })
+  defineBadgeElement({ tag: opts.tags?.badge, nonce: opts.nonce })
+  defineMemberSettingsElement({ tag: opts.tags?.memberSettings, nonce: opts.nonce })
+  defineProfileElement({ tag: opts.tags?.profile, nonce: opts.nonce })
+  defineWelcomeElement({ tag: opts.tags?.welcome, nonce: opts.nonce })
+}

package/src/global.ts

@@ -0,0 +1,26 @@
+/**
+ * The `<script>` build: registers every element — `<blogmcp-discussion>`, `<blogmcp-notice-form>`,
+ * `<blogmcp-my-community>` and (M2) `<blogmcp-notification-centre>`, `<blogmcp-badge>`, `<blogmcp-member-settings>`,
+ * `<blogmcp-profile>`, `<blogmcp-welcome>` — with the script tag's own CSP nonce, and exposes
+ * `window.BlogmcpCommunity`. Live updates are not in it: a site that wants them bundles `@blogmcp/sdk/community/realtime`
+ * and sets the discussion's `realtime` property.
+ */
+import { defineCommunityElements } from './element'
+import { mountBadge, mountDiscussion, mountMemberSettings, mountMyCommunity, mountNoticeForm, mountNotificationCentre, mountProfile, mountWelcome } from './mount'
+import { VERSION } from './version'
+
+const script = typeof document !== 'undefined' ? (document.currentScript as HTMLScriptElement | null) : null
+defineCommunityElements({ nonce: script?.nonce || undefined })
+
+export {
+  defineCommunityElements,
+  mountDiscussion,
+  mountMyCommunity,
+  mountNoticeForm,
+  mountNotificationCentre,
+  mountBadge,
+  mountMemberSettings,
+  mountProfile,
+  mountWelcome,
+  VERSION,
+}

package/src/index.ts

@@ -0,0 +1,70 @@
+/**
+ * @blogmcp/community — the community's elements for a site's own pages (m1-contracts.md §10.4; docs: "Add
+ * discussions to your frontend"), over `@blogmcp/sdk/community`. Every element talks to the HOST's relative
+ * base (`api-base`; default `/api/community` under the site's `site-base`: a headless site's BFF from
+ * `@blogmcp/sdk/community/server`, or with `site-base="/blog"` a managed blog's own proxy), never to kb-api directly.
+ *
+ *   - `<blogmcp-discussion>`   the discussion under an article;
+ *   - `<blogmcp-notice-form>`  the DSA notice form, for anyone;
+ *   - `<blogmcp-my-community>` the reader's „Moje komunita", a statement page, a notifier's status page;
+ *   - M2: `<blogmcp-notification-centre>` the notifications, `<blogmcp-badge>` the header's unread count,
+ *     `<blogmcp-member-settings>` the switches, push and the digest's unsubscribe, `<blogmcp-profile>` a member's
+ *     public profile, `<blogmcp-welcome>` the welcome page; the discussion's `realtime` property (live updates);
+ *   - `defineCommunityElements()` and one `define…Element()` each — the custom elements;
+ *   - `mountDiscussion(…)`, `mountNoticeForm(…)`, `mountMyCommunity(…)` — mount one from code;
+ *   - `@blogmcp/community/vue`, `@blogmcp/community/react` — `<KbDiscussion>`, `<KbNoticeForm>`, `<KbMyCommunity>`;
+ *   - `@blogmcp/community/global` — one `<script>` for sites without a bundler.
+ */
+export {
+  defineCommunityElements,
+  defineDiscussionElement,
+  defineNoticeFormElement,
+  defineMyCommunityElement,
+  defineNotificationCentreElement,
+  defineBadgeElement,
+  defineMemberSettingsElement,
+  defineProfileElement,
+  defineWelcomeElement,
+  DISCUSSION_ELEMENT_TAG,
+  NOTICE_FORM_ELEMENT_TAG,
+  MY_COMMUNITY_ELEMENT_TAG,
+  NOTIFICATION_CENTRE_ELEMENT_TAG,
+  BADGE_ELEMENT_TAG,
+  MEMBER_SETTINGS_ELEMENT_TAG,
+  PROFILE_ELEMENT_TAG,
+  WELCOME_ELEMENT_TAG,
+  type DefineCommunityElementOptions,
+  type DefineCommunityElementsOptions,
+} from './element'
+export {
+  mountDiscussion,
+  mountNoticeForm,
+  mountMyCommunity,
+  mountNotificationCentre,
+  mountBadge,
+  mountMemberSettings,
+  mountProfile,
+  mountWelcome,
+  type MountDiscussionOptions,
+  type MountNoticeFormOptions,
+  type MountMyCommunityOptions,
+  type MountNotificationCentreOptions,
+  type MountBadgeOptions,
+  type MountMemberSettingsOptions,
+  type MountProfileOptions,
+  type MountWelcomeOptions,
+} from './mount'
+export { createNotificationCentre, type NotificationCentreController, type CentreUi } from './core/centre'
+export { createBadge, badgeText, BADGE_INTERVAL_MS, type BadgeController, type BadgeOptions, type BadgeUi } from './core/badge'
+export { createMemberSettings, SETTING_KEYS, type MemberSettingsController, type MemberSettingsOptions, type SettingsUi, type SettingKey } from './core/settings'
+export { createProfile, createWelcome, type ProfileController, type WelcomeController } from './core/profile'
+export type { DiscussionRealtime, DiscussionRealtimeOptions, DiscussionRealtimeSession, DiscussionRealtimeMode } from './core/realtime'
+export { createDiscussionController, type DiscussionController, type DiscussionControllerOptions, type DiscussionUi, type ComposerMode, type Draft } from './core/discussion'
+export { createNoticeForm, type NoticeFormController, type NoticeFormOptions, type NoticeFormUi } from './core/notice'
+export { createPanel, type PanelController, type PanelOptions, type PanelUi } from './core/panel'
+export { createOnboarding, type OnboardingModel, type OnboardingOptions, type OnboardingStep } from './core/onboarding'
+export { pickLang, type Lang } from './core/i18n'
+export { AVATAR_PRESETS, type AvatarPreset } from './core/avatars'
+export { DEFAULT_API_BASE } from './core/client'
+export type { CommunityRoutes } from './core/attrs'
+export { VERSION } from './version'