@blogmcp/community 0.1.0 → 0.3.0

package/src/core/onboarding.ts

@@ -7,7 +7,13 @@
  *            minimum kb-api stores nothing and the reader is told from what age the discussion is open;
  *   rules    the rules' summary (`legal/current` → `bodyJson`, text only) with a link to the full text, and
  *            the acceptance;
- *   art9     the art. 9 consent's text and the acceptance, when the tenant asks for it;
+ *   art9     the art. 9 consent's text and the acceptance, when the tenant asks for it — or, M3, before a forum write,
+ *            whatever the tenant's setting says (`forceArt9`: m3-contracts.md §3.1 step 5, U14) — (M2 T9, m2-contracts.md §3.8:
+ *            the layout from me/get's `settings.art9ConsentLayout` — `joint` one consent, `split` one per controller of
+ *            the text's `bodyJson.controllers` when it names two, all of them required, the text itself shown once —
+ *            and, where `settings.art9Refusal` is `public_write`, a refusal that joins without the consent: kb-api then
+ *            opens the public discussion to the member, so `art9Refused` goes instead of the text id; under `read_only`
+ *            no refusal is offered and a reader who closes the step keeps reading);
  *   profile  the display name, the handle (kb-api makes one when none is given; the element shows what it
  *            would be), an avatar preset.
  *
@@ -21,9 +27,14 @@
  */
 import { reactive } from 'vue'
 import {
+  art9ConsentLayoutOf,
+  art9ControllersOf,
+  art9RefusalOf,
   communityRulesOf,
   isKnownNeed,
   type AgeBand,
+  type Art9ConsentLayout,
+  type Art9Refusal,
   type CommunityCallOptions,
   type CommunityClient,
   type CommunityFailure,
@@ -32,7 +43,8 @@ import {
   type MyState,
   type OnboardInput,
 } from '@blogmcp/sdk/community'
-import type { Lang } from './i18n'
+import type { Lang, TextRef } from './i18n'
+import { failureText } from './outcomes'
 import { isDisplayNameOk, isHandleOk, normalizeHandle, normalizeName, suggestedHandle } from './names'
 import { htmlToParagraphs } from './text'
 
@@ -40,6 +52,15 @@ export type OnboardingStep = 'age' | 'rules' | 'art9' | 'profile'
 
 export type OnboardingPhase = 'loading' | 'ready' | 'sending' | 'done' | 'failed' | 'refused'
 
+/** One consent of the art. 9 step: a controller the text names (or the tenant, when it names none) and its tick. */
+export interface Art9Consent {
+  /** The controller's registry ref from the text's `bodyJson`; empty for the tenant of a text that names none. */
+  readonly entity: string
+  /** The name the reader sees; empty for the tenant of a text that names none (the step's own sentence then). */
+  readonly label: string
+  accepted: boolean
+}
+
 export interface OnboardingState {
   /** `refused`: the age band is below the minimum — nothing was stored, the reader may go on reading. */
   phase: OnboardingPhase
@@ -50,10 +71,24 @@ export interface OnboardingState {
   rules: CommunityRule[]
   art9Text: CurrentLegalText | null
   art9Paragraphs: string[]
+  /** me/get's `settings.art9ConsentLayout` (absent: `joint`). */
+  art9Layout: Art9ConsentLayout
+  /** me/get's `settings.art9Refusal` (absent: `read_only`). */
+  art9Refusal: Art9Refusal
+  /**
+   * The consents the step asks for, each ticked on its own: one under `joint` (or a text naming fewer than two
+   * controllers), the text's two controllers under `split`. Empty while there is no art. 9 text.
+   */
+  art9Controllers: Art9Consent[]
+  /** The reader chose „Nesouhlasím" (only where the refusal is offered). */
+  art9Refused: boolean
+  /** The me/onboard kb-api took carried the refusal (the done note says what it leaves). */
+  art9RefusedSent: boolean
   /** The member accepted an older rules text; this one asks again. */
   reconsent: boolean
   ageBand: AgeBand | null
   rulesAccepted: boolean
+  /** Every consent of the step ticked (setting it ticks or unticks them all). */
   art9Accepted: boolean
   displayName: string
   handle: string
@@ -76,6 +111,15 @@ export interface OnboardingModel {
   back(): void
   suggestedHandle(): string | null
   hasFieldError(field: string): boolean
+  /**
+   * The tenant takes a refusal of the art. 9 consent here (`art9Refusal = public_write`, not the give-consent flow): the
+   * step's lede then does not make writing depend on the consent (community.md §9.8 q8, art. 9(2)(a) — freely given).
+   */
+  refusalOffered(): boolean
+  /** The art. 9 step offers „Nesouhlasím" (`art9Refusal = public_write`, never in the give-consent flow). */
+  canRefuse(): boolean
+  /** „Nesouhlasím": the step is answered without the consent; the next step, or — on the last one — `me/onboard`. */
+  refuse(): Promise<void>
 }
 
 export interface OnboardingOptions {
@@ -87,22 +131,61 @@ export interface OnboardingOptions {
   onSignIn(): void
   /** The age band was below the tenant's minimum (AGE_BELOW_MINIMUM): kb-api kept nothing, the element keeps this. */
   onRefused?(minAge: number): void
+  /**
+   * The give-consent flow („Moje komunita", M2 T9): the art. 9 step is asked also when `needs` does not name it — a
+   * member who refused it, or has not given it, where the tenant asks for it — and no refusal is offered.
+   */
+  offerArt9?: boolean
+  /**
+   * M3 (m3-contracts.md §3.1 step 5, U14): a forum write needs the art. 9 consent whatever the tenant's
+   * `require_art9_consent` says, so the step is asked whenever the consent is not in force — me/get names no
+   * `art9_consent` need (and may report the consent as null) where the tenant does not ask for it elsewhere. A refusal
+   * is offered as for the discussion (`art9Refusal = public_write`), and a member who refused there is not asked again.
+   */
+  forceArt9?: boolean
   signal?: AbortSignal
 }
 
 const PROFILE_FIELDS = new Set(['displayName', 'handle', 'avatarPreset'])
 const TEXT_FIELDS = new Set(['rulesTextId', 'art9TextId'])
+/** kb-api's issue code for a refusal the tenant does not take (`art9Refusal = read_only`, §3.8). */
+export const ART9_REFUSAL_READ_ONLY = 'art9_refusal_read_only'
+
+/**
+ * A refusal of the art. 9 refusal itself: the tenant's setting is `read_only` (changed meanwhile, or a stale page) —
+ * kb-api's issue code, never the path alone. A path-only `art9Refused` is kb-api's „a consent is already in force"
+ * (given in another tab): a plain reread with the generic sentence.
+ */
+const refusalRefused = (f: Pick<CommunityFailure, 'code' | 'issueCodes'>): boolean =>
+  f.code === 'invalid' && f.issueCodes?.includes(ART9_REFUSAL_READ_ONLY) === true
+
+/** The sentence a refusal of the onboarding shows: a refused refusal says the consent is needed to write. */
+export function onboardingFailureText(failure: Pick<CommunityFailure, 'code' | 'until' | 'fields' | 'issueCodes'>, lang: Lang): TextRef {
+  return refusalRefused(failure) ? { key: 'onboarding.art9RequiredToWrite' } : failureText(failure, lang)
+}
 
 /** What is still missing for this member, in order (MyState and its known needs). */
-function stepsOf(me: MyState, needs: readonly string[]): OnboardingStep[] {
+function stepsOf(me: MyState, needs: readonly string[], offerArt9: boolean, forceArt9: boolean): OnboardingStep[] {
   const steps: OnboardingStep[] = []
   if (!me.member?.ageBand) steps.push('age')
   if (me.acceptances.rules !== 'accepted') steps.push('rules')
-  if (needs.includes('art9_consent')) steps.push('art9')
+  const art9 = me.acceptances.art9Consent
+  // A forum write: the consent, unless it is in force or refused where a refusal leaves public writes (kb-api's needs).
+  const refusedOpen = me.acceptances.art9Refused === true && art9RefusalOf(me.settings?.art9Refusal) === 'public_write'
+  const forced = forceArt9 && art9 !== 'accepted' && !refusedOpen
+  if (needs.includes('art9_consent') || (offerArt9 && art9 !== null && art9 !== 'accepted') || forced) steps.push('art9')
   if (!me.profile) steps.push('profile')
   return steps
 }
 
+/** The consents the step asks for: the text's two controllers under `split`, else one (its first, or the tenant). */
+function consentsOf(text: CurrentLegalText | null, layout: Art9ConsentLayout): Array<{ entity: string; label: string }> {
+  if (!text) return []
+  const listed = art9ControllersOf(text.bodyJson)
+  if (layout === 'split' && listed.length > 1) return listed.map((c) => ({ entity: c.entity, label: c.label }))
+  return [{ entity: listed[0]?.entity ?? '', label: listed.length > 1 ? '' : (listed[0]?.label ?? '') }]
+}
+
 /** The texts of the steps shown. */
 interface Texts {
   rules: CurrentLegalText | null
@@ -118,6 +201,8 @@ interface Read {
 
 export function createOnboarding(o: OnboardingOptions): OnboardingModel {
   const call: CommunityCallOptions = o.signal ? { signal: o.signal } : {}
+  const offerArt9 = o.offerArt9 === true
+  const forceArt9 = o.forceArt9 === true && !offerArt9
   const state = reactive<OnboardingState>({
     phase: 'loading',
     steps: [],
@@ -127,10 +212,21 @@ export function createOnboarding(o: OnboardingOptions): OnboardingModel {
     rules: [],
     art9Text: null,
     art9Paragraphs: [],
+    art9Layout: 'joint',
+    art9Refusal: 'read_only',
+    art9Controllers: [],
+    art9Refused: false,
+    art9RefusedSent: false,
     reconsent: false,
     ageBand: null,
     rulesAccepted: false,
-    art9Accepted: false,
+    // Read through the reactive proxy (`this`), so a view's v-model ticks every consent and the guard sees them all.
+    get art9Accepted(): boolean {
+      return this.art9Controllers.length > 0 && this.art9Controllers.every((c) => c.accepted)
+    },
+    set art9Accepted(value: boolean) {
+      for (const c of this.art9Controllers) c.accepted = value
+    },
     displayName: '',
     handle: '',
     avatarPreset: null,
@@ -171,15 +267,27 @@ export function createOnboarding(o: OnboardingOptions): OnboardingModel {
       o.onSignIn()
       return null
     }
-    const steps = stepsOf(me.value, needs)
+    const steps = stepsOf(me.value, needs, offerArt9, forceArt9)
     const texts = await textsFor(steps)
     return texts ? { me: me.value, steps, texts } : null
   }
 
+  /** The refusal is offered: the tenant takes it (`public_write`), and this is not the give-consent flow. */
+  const refusalOffered = (): boolean => !offerArt9 && state.art9Refusal === 'public_write'
+
   /** What was read, shown at once; an acceptance holds only for the very text it was given to. */
   function apply(r: Read): void {
     if (r.texts.rules?.textId !== state.rulesText?.textId) state.rulesAccepted = false
-    if (r.texts.art9?.textId !== state.art9Text?.textId) state.art9Accepted = false
+    const layout = art9ConsentLayoutOf(r.me.settings?.art9ConsentLayout)
+    const sameText = r.texts.art9 !== null && r.texts.art9.textId === state.art9Text?.textId
+    // A tick holds for the same controller of the same text; anything else is asked again.
+    state.art9Controllers = consentsOf(r.texts.art9, layout).map((c, i) => {
+      const before = state.art9Controllers[i]
+      return { ...c, accepted: sameText && before?.entity === c.entity && before.accepted === true }
+    })
+    state.art9Layout = layout
+    state.art9Refusal = art9RefusalOf(r.me.settings?.art9Refusal)
+    if (!sameText || !refusalOffered()) state.art9Refused = false
     state.me = r.me
     state.steps = r.steps
     state.reconsent = r.me.acceptances.rules === 'reconsent_required'
@@ -196,8 +304,17 @@ export function createOnboarding(o: OnboardingOptions): OnboardingModel {
     if (!r) return
     apply(r)
     state.index = 0
-    // Nothing left to ask (another tab finished it): kb-api's answer settles the needs.
-    if (r.steps.length === 0) return submit()
+    if (r.steps.length === 0) {
+      // The give-consent flow with no consent left to ask (given in another tab, or the tenant stopped asking for it):
+      // nothing is sent — an empty me/onboard would be no consent — and the caller reads the state it is handed.
+      if (offerArt9) {
+        state.phase = 'done'
+        o.onDone(r.me)
+        return
+      }
+      // Nothing left to ask (another tab finished it): kb-api's answer settles the needs.
+      return submit()
+    }
     state.phase = 'ready'
   }
 
@@ -211,7 +328,7 @@ export function createOnboarding(o: OnboardingOptions): OnboardingModel {
       case 'rules':
         return state.rulesAccepted && state.rulesText !== null
       case 'art9':
-        return state.art9Accepted && state.art9Text !== null
+        return state.art9Text !== null && (state.art9Accepted || (state.art9Refused && refusalOffered()))
       case 'profile':
         return isDisplayNameOk(state.displayName) && isHandleOk(state.handle)
     }
@@ -219,7 +336,11 @@ export function createOnboarding(o: OnboardingOptions): OnboardingModel {
 
   function canContinue(): boolean {
     const s = step()
-    return state.phase === 'ready' && s !== null && answered(s)
+    if (state.phase !== 'ready' || s === null) return false
+    // „Pokračovat" on the art. 9 step means the consent: a refusal goes only through „Nesouhlasím" (refuse()), never
+    // silently through the primary button.
+    if (s === 'art9') return state.art9Text !== null && state.art9Accepted
+    return answered(s)
   }
 
   function goTo(s: OnboardingStep): void {
@@ -246,7 +367,15 @@ export function createOnboarding(o: OnboardingOptions): OnboardingModel {
       ageBand: state.ageBand ?? state.me?.member?.ageBand ?? '18_plus',
       rulesTextId: state.steps.includes('rules') && state.rulesText ? state.rulesText.textId : '',
     }
-    if (state.steps.includes('art9') && state.art9Text) input.art9TextId = state.art9Text.textId
+    // A consent ticked wins over a refusal chosen before (the reader came back and ticked it).
+    let refusing = false
+    if (state.steps.includes('art9') && state.art9Text) {
+      if (state.art9Accepted) input.art9TextId = state.art9Text.textId
+      else if (state.art9Refused && refusalOffered()) {
+        input.art9Refused = true
+        refusing = true
+      }
+    }
     if (state.steps.includes('profile')) {
       input.displayName = normalizeName(state.displayName)
       const handle = normalizeHandle(state.handle)
@@ -255,6 +384,7 @@ export function createOnboarding(o: OnboardingOptions): OnboardingModel {
     }
     const r = await o.client.me.onboard(input, call)
     if (r.ok) {
+      state.art9RefusedSent = refusing
       state.phase = 'done'
       o.onDone(r.value)
       return
@@ -276,6 +406,16 @@ export function createOnboarding(o: OnboardingOptions): OnboardingModel {
         return goTo('profile')
       case 'invalid': {
         state.fields = r.fields ?? []
+        // The tenant takes no refusal (now): the settings are read again, the consent asked, the reader told why.
+        if (refusalRefused(r)) {
+          state.art9Refused = false
+          return reread(r)
+        }
+        // A refusal kb-api did not take because a consent is in force already (another tab): read again.
+        if (state.fields.includes('art9Refused')) {
+          state.art9Refused = false
+          return reread(r)
+        }
         if (state.fields.some((f) => PROFILE_FIELDS.has(f))) return goTo('profile')
         if (state.fields.some((f) => TEXT_FIELDS.has(f))) return reread(r)
         if (state.fields.includes('ageBand')) return goTo('age')
@@ -319,6 +459,18 @@ export function createOnboarding(o: OnboardingOptions): OnboardingModel {
     fail(refusal)
   }
 
+  /** On to the next step, or — on the last one — `me/onboard`. */
+  async function advance(): Promise<void> {
+    state.failure = null
+    if (state.index < state.steps.length - 1) {
+      state.index += 1
+      return
+    }
+    await submit()
+  }
+
+  const canRefuse = (): boolean => state.phase === 'ready' && step() === 'art9' && state.art9Text !== null && refusalOffered()
+
   return {
     state,
     load,
@@ -327,17 +479,24 @@ export function createOnboarding(o: OnboardingOptions): OnboardingModel {
     canContinue,
     async next() {
       if (!canContinue()) return
-      state.failure = null
-      if (state.index < state.steps.length - 1) {
-        state.index += 1
-        return
-      }
-      await submit()
+      // The consent given: a refusal chosen before on this step no longer stands.
+      if (step() === 'art9' && state.art9Accepted) state.art9Refused = false
+      await advance()
+    },
+    canRefuse,
+    async refuse() {
+      if (!canRefuse()) return
+      state.art9Accepted = false
+      state.art9Refused = true
+      await advance()
     },
+    refusalOffered,
     back() {
       if (state.phase !== 'ready' || state.index === 0) return
       state.failure = null
       state.index -= 1
+      // Back on the art. 9 step: the reader chooses again — a refusal chosen before does not stand unseen.
+      if (step() === 'art9') state.art9Refused = false
     },
     suggestedHandle: () => (normalizeHandle(state.handle) === '' ? suggestedHandle(state.displayName) : null),
     hasFieldError: (field) => state.fields.includes(field),

package/src/core/outcomes.ts

@@ -36,7 +36,8 @@ export const COUNTDOWN_MAX_S = 120
  *   - `onboard`  the inline onboarding opens (ONBOARDING_REQUIRED);
  *   - `reload`   the discussion is read again (the viewer's state changed: a sanction, a session);
  *   - `notMoved` the discussion does not take writes yet: one sentence instead of the composer;
- *   - `hide`     discussions are switched off: the element renders nothing;
+ *   - `hide`     discussions are switched off: the element renders nothing (`realtimeOff`: only live updates are —
+ *                the element keeps polling and never hides the discussion for it);
  *   - `retry`    nothing was decided (no answer, the ledger): the same write may go again as it is;
  *   - `show`     anything else: the sentence, the text stays for the author to change.
  */
@@ -66,6 +67,27 @@ const EFFECTS: Readonly<Record<CommunityUiCode, FailureEffect>> = Object.freeze(
   surfaceOff: 'hide',
   notMoved: 'notMoved',
   ledger: 'retry',
+  // M2 (m2-contracts.md §3.1): a pause refuses every member write until it ends (`until`) — the write waits and the
+  // composer gives way to `state.braked`, and me/get is read again for the brake's end (reads go on).
+  braked: 'wait',
+  // A Pro feature of a module that went read_only: the member's state changed under the page — read it again.
+  readOnly: 'reload',
+  // Too many @mentions for the member's level: the sentence, and the text stays for the author to trim.
+  mentionLimit: 'show',
+  // A browser whose push service kb-api will not send to: the sentence; the switch stays off (the settings element).
+  pushRefused: 'show',
+  // Live updates are off here: nothing to show the reader — the discussion keeps polling (the realtime session's fallback).
+  realtimeOff: 'hide',
+  // M3 (m3-contracts.md §1.2): the forum is not open to this viewer — read again, and the read's answer is the
+  // members-only state with its sign-in or onboarding (`needs`); no write of a topic answers it (a topic id's refusals
+  // are its `notFound`, A11).
+  membersOnly: 'reload',
+  // The topic was closed meanwhile: read again — the topic's state closes the composer (`error.topicLocked` until then).
+  topicLocked: 'reload',
+  // A category that takes no topic from the member: the sentence, and the category's composer goes.
+  topicCreationClosed: 'show',
+  // Following as much as one member may: the sentence (the member unfollows something first).
+  followLimit: 'show',
   submit: 'show',
 } satisfies Record<CommunityUiCode, FailureEffect>)
 

package/src/core/panel.ts

@@ -1,13 +1,13 @@
 /**
  * `<blogmcp-my-community>`'s brain (m1-contracts.md §7.4, §8.3, §10.4; community.md §5): the reader's
  * „Moje komunita" — the statements of reasons about their content (the art. 17(3) fields, the appeal within
- * its window, an open appeal's state), their reports, their notifications, the art. 9 consent's withdrawal,
- * their blocks, the export (a JSON download) and the profile's deletion with its grace and cancel.
+ * its window, an open appeal's state), their reports, their notifications, the art. 9 consent's withdrawal (and,
+ * M2 T9, a refused one given after all — the onboarding's art. 9 step, opened here), their blocks, the export (a JSON download) and the profile's deletion with its grace and cancel.
  *
  * With a decision id it shows that one statement (the host's statement page). With a notifier's receipt it
  * shows that notice's status and appeal — `notices/status`, `notices/appeal`: no session needed for that.
  */
-import { reactive } from 'vue'
+import { reactive, shallowRef, type ShallowRef } from 'vue'
 import {
   COMMUNITY_APPEAL_MAX,
   isKnownNotificationCode,
@@ -25,7 +25,8 @@ import {
   type ReportItem,
   type Statement,
 } from '@blogmcp/sdk/community'
-import type { TextRef } from './i18n'
+import { pickLang, type TextRef } from './i18n'
+import { createOnboarding, type OnboardingModel } from './onboarding'
 import { isDisplayNameOk, isHandleOk, normalizeHandle, normalizeName } from './names'
 import { codePointLength, normalizeBody } from './text'
 
@@ -71,6 +72,8 @@ export interface PanelUi {
 
 export interface PanelController {
   readonly state: PanelUi
+  /** The give-consent flow (the onboarding's art. 9 step), while it is open. */
+  readonly consent: ShallowRef<OnboardingModel | null>
   /** The member's sections (me/get and the lists). */
   loadMember(): Promise<void>
   loadStatement(decisionId: string): Promise<void>
@@ -82,6 +85,9 @@ export interface PanelController {
   fileNoticeAppeal(): Promise<void>
   withdrawNoticeAppeal(): Promise<void>
   withdrawConsent(): Promise<boolean>
+  /** A refused art. 9 consent (`acceptances.art9Refused`): opens its step to give it after all. */
+  giveConsent(): void
+  closeConsent(): void
   unblock(memberId: string): Promise<void>
   editProfile(): void
   cancelProfile(): void
@@ -127,6 +133,7 @@ export function createPanel(o: PanelOptions): PanelController {
     announceId: 0,
   }) as PanelUi
   let disposed = false
+  const consent = shallowRef<OnboardingModel | null>(null)
 
   const announce = (text: TextRef): void => {
     state.announcement = text
@@ -225,8 +232,35 @@ export function createPanel(o: PanelOptions): PanelController {
   const appealLength = (d: AppealDraft): number => codePointLength(normalizeBody(d.body))
   const canAppealWith = (d: AppealDraft): boolean => !d.sending && appealLength(d) > 0 && appealLength(d) <= COMMUNITY_APPEAL_MAX
 
+  function giveConsent(): void {
+    if (consent.value || disposed || !state.me?.member || state.me.acceptances.art9Refused !== true) return
+    const model = createOnboarding({
+      client,
+      lang: pickLang(o.lang),
+      signal: abort.signal,
+      offerArt9: true,
+      onDone: (me) => {
+        state.me = me
+        consent.value = null
+        // Only a consent in force is announced: the flow also closes when no step was left to ask (nothing sent).
+        if (me.acceptances.art9Consent === 'accepted') announce({ key: 'panel.art9Given' })
+      },
+      onSignIn: () => {
+        consent.value = null
+        state.phase = 'signIn'
+      },
+    })
+    consent.value = model
+    void model.load()
+  }
+
   return {
     state,
+    consent,
+    giveConsent,
+    closeConsent() {
+      consent.value = null
+    },
     loadMember,
     loadStatement,
     async loadNotice(receipt) {
@@ -406,6 +440,7 @@ export function createPanel(o: PanelOptions): PanelController {
     dispose() {
       disposed = true
       abort.abort()
+      consent.value = null
     },
   }
 }

package/src/core/profile.ts

@@ -0,0 +1,155 @@
+/**
+ * `<blogmcp-profile handle>`'s and `<blogmcp-welcome>`'s brains (m2-contracts.md §3.2, §3.10).
+ *
+ *   - The profile: `profile/get { handle }` — the public projection (the author, `memberSince` as `YYYY-MM`, the bio
+ *     as text, the trust level as its LABEL, never the number). kb-api answers a signed-in host session only; an
+ *     unknown handle, an erased member and one hidden from the viewer are the same `notFound`.
+ *   - The welcome page: the tenant's current rules (`legal/current`, their summary from `bodyJson` as the onboarding
+ *     shows it) and who is viewing (`me/get`: the profile link needs the member's handle).
+ */
+import { reactive } from 'vue'
+import {
+  COMMUNITY_HANDLE_RE,
+  communityRulesOf,
+  isKnownAuthor,
+  trustLabelMessageKey,
+  type CommunityCallOptions,
+  type CommunityClient,
+  type CommunityFailure,
+  type CommunityMessageKey,
+  type CommunityRule,
+  type ForumCategoryRef,
+  type KnownAuthor,
+  type PublicProfile,
+} from '@blogmcp/sdk/community'
+
+export type LoadPhase = 'idle' | 'loading' | 'ready' | 'failed' | 'signIn' | 'notFound'
+
+export interface ProfileUi {
+  phase: LoadPhase
+  failure: CommunityFailure | null
+  author: KnownAuthor | null
+  memberSince: string | null
+  bio: string | null
+  /** The trust level's catalogue key (`trust.<n>`), or null for a label this SDK does not know. */
+  trustKey: CommunityMessageKey | null
+  /**
+   * M3 (m3-contracts.md §3.5, §4.5; D-M3-7): the categories the member moderates now — „Moderátor" names this
+   * appointment on the profile, never a trust level; kb-api sends it to a forum member only (else none).
+   */
+  moderates: ForumCategoryRef[]
+}
+
+export interface ProfileController {
+  readonly state: ProfileUi
+  load(handle: string): Promise<void>
+  dispose(): void
+}
+
+/** A handle as an attribute may give it (`@jana_n`, `Jana_N`): lower case, without the `@`; null for none. */
+export function handleOf(value: unknown): string | null {
+  if (typeof value !== 'string') return null
+  const h = value.trim().replace(/^@/, '').toLowerCase()
+  return COMMUNITY_HANDLE_RE.test(h) ? h : null
+}
+
+export function createProfile(o: { client: CommunityClient }): ProfileController {
+  const { client } = o
+  const abort = new AbortController()
+  const call: CommunityCallOptions = { signal: abort.signal }
+  let disposed = false
+  let ticket = 0
+  const state = reactive<ProfileUi>({ phase: 'idle', failure: null, author: null, memberSince: null, bio: null, trustKey: null, moderates: [] }) as ProfileUi
+
+  return {
+    state,
+    async load(handle) {
+      const mine = ++ticket
+      state.failure = null
+      state.author = null
+      state.memberSince = null
+      state.bio = null
+      state.trustKey = null
+      state.moderates = []
+      const h = handleOf(handle)
+      if (h === null) {
+        state.phase = 'notFound'
+        return
+      }
+      state.phase = 'loading'
+      const r = await client.profile.get({ handle: h }, call)
+      if (disposed || mine !== ticket) return
+      if (!r.ok) {
+        state.phase = r.code === 'signIn' ? 'signIn' : r.code === 'notFound' ? 'notFound' : 'failed'
+        state.failure = r
+        return
+      }
+      const p: PublicProfile = r.value
+      // A profile is a member's; an author of another kind (or one a newer kb-api added) is no profile to show.
+      if (!isKnownAuthor(p.author) || p.author.kind !== 'member' || p.author.memberId === null) {
+        state.phase = 'notFound'
+        return
+      }
+      state.author = p.author
+      state.memberSince = typeof p.memberSince === 'string' ? p.memberSince : null
+      state.bio = typeof p.bio === 'string' && p.bio.trim() !== '' ? p.bio : null
+      state.trustKey = trustLabelMessageKey(p.trustLabel)
+      // M3: the appointments acting now (a category's slug and name each; anything else is skipped).
+      state.moderates = Array.isArray(p.moderates)
+        ? p.moderates.filter((c): c is ForumCategoryRef => typeof c?.slug === 'string' && typeof c?.name === 'string').map((c) => ({ slug: c.slug, name: c.name }))
+        : []
+      state.phase = 'ready'
+    },
+    dispose() {
+      disposed = true
+      abort.abort()
+    },
+  }
+}
+
+export interface WelcomeUi {
+  phase: 'idle' | 'loading' | 'ready'
+  rules: CommunityRule[]
+  /** The rules could not be read: the page still links them. */
+  rulesFailed: boolean
+  /** The signed-in member's handle (the profile link), or null for a visitor and a reader who never joined. */
+  handle: string | null
+  /** Nobody is signed in: the sign-in link takes the profile link's place. */
+  visitor: boolean
+}
+
+export interface WelcomeController {
+  readonly state: WelcomeUi
+  load(): Promise<void>
+  dispose(): void
+}
+
+export function createWelcome(o: { client: CommunityClient; lang: string }): WelcomeController {
+  const { client } = o
+  const abort = new AbortController()
+  const call: CommunityCallOptions = { signal: abort.signal }
+  let disposed = false
+  const state = reactive<WelcomeUi>({ phase: 'idle', rules: [], rulesFailed: false, handle: null, visitor: false }) as WelcomeUi
+
+  return {
+    state,
+    async load() {
+      state.phase = 'loading'
+      const [rules, me] = await Promise.all([client.legal.current({ kind: 'rules', locale: o.lang }, call), client.me.get(call)])
+      if (disposed) return
+      if (rules.ok) state.rules = communityRulesOf(rules.value.bodyJson)
+      else state.rulesFailed = true
+      if (me.ok) {
+        state.visitor = me.value.needs.includes('sign_in')
+        state.handle = me.value.member ? handleOf(me.value.profile?.handle) : null
+      } else {
+        state.visitor = me.code === 'signIn'
+      }
+      state.phase = 'ready'
+    },
+    dispose() {
+      disposed = true
+      abort.abort()
+    },
+  }
+}