@blogmcp/community 0.1.0 → 0.3.0

package/src/core/forum-state.ts

@@ -0,0 +1,59 @@
+/**
+ * What every forum element reads out of `me/get` beside its own operation (m3-contracts.md §3.5, §4.8, §4.9, §5.3):
+ * the team's away mode (one sentence, `state.away`), the pause of the forum's writes — the module's brake (both
+ * surfaces: `state.braked`) or the forum's own (`state.forumBraked`; the article discussions go on) —, the module's
+ * `read_only` (the forum is one of its features), and what a `membersOnly` refusal asks of the viewer.
+ */
+import {
+  communityAwayOf,
+  isKnownModuleState,
+  isKnownNeed,
+  surfaceInfoOf,
+  type CommunityFailure,
+  type CommunityMessageKey,
+  type KnownNeed,
+  type MyState,
+} from '@blogmcp/sdk/community'
+
+export interface ForumNotices {
+  /** The team is away: new topics wait for review (`state.away`). */
+  away: boolean
+  /** The forum's writes are paused — the module's brake, or the forum's own — or not. */
+  paused: 'module' | 'forum' | null
+  /** The module is `read_only`: the forum takes no writes meanwhile (`error.readOnly`). */
+  readOnly: boolean
+}
+
+/** The notices of `me/get`'s module block, at `now`. */
+export function forumNoticesOf(me: MyState | null | undefined, now: number = Date.now()): ForumNotices {
+  const module = me?.module
+  if (!module) return { away: false, paused: null, readOnly: false }
+  const state = isKnownModuleState(module.state) ? module.state : 'dark'
+  const forumBrake = surfaceInfoOf(module, 'forum')?.brake ?? null
+  const forumBraked = forumBrake !== null && Date.parse(forumBrake.until) > now
+  return {
+    away: communityAwayOf(module, now) !== null,
+    paused: module.brake !== undefined || state === 'braked' ? 'module' : forumBraked ? 'forum' : null,
+    readOnly: state === 'read_only',
+  }
+}
+
+/** The sentence of a pause of the forum's writes. */
+export const pausedKey = (paused: ForumNotices['paused']): CommunityMessageKey | null =>
+  paused === 'module' ? 'state.braked' : paused === 'forum' ? 'state.forumBraked' : null
+
+/**
+ * What a `membersOnly` refusal asks of the viewer (§3.1 step 3): to join — a member session that has not finished its
+ * onboarding (`needs` `onboarding` or `reconsent_rules`) — or to sign in (a visitor, or a session the tenant does not
+ * admit as a member: `sign_in`, or no needs at all).
+ */
+export function membersOnlyAsk(failure: Pick<CommunityFailure, 'needs'> | null | undefined): 'join' | 'signIn' {
+  const needs: KnownNeed[] = (failure?.needs ?? []).filter(isKnownNeed)
+  return !needs.includes('sign_in') && (needs.includes('onboarding') || needs.includes('reconsent_rules')) ? 'join' : 'signIn'
+}
+
+/**
+ * Whether the viewer is a member who may take part (an onboarded member's session): me/get names a member and no
+ * need to sign in. The team at the keyboard reads the forum but writes through the KB admin.
+ */
+export const isForumMember = (me: MyState | null | undefined): boolean => !!me?.member && !me.needs.includes('sign_in')

package/src/core/forum-words.ts

@@ -0,0 +1,38 @@
+/**
+ * The forum's words for the discussion's components (m3-contracts.md §5.3): a topic's thread reuses the discussion's
+ * view — the same messages, composer, dialogs and refusals — and reads it with these keys in place of the
+ * discussion's, so a forum reads „příspěvek" (a post) where an article's discussion reads „komentář" (a comment). Every
+ * key is the SDK catalogue's in both languages; a plural maps by its name (test/forum-elements.spec.ts checks both).
+ */
+import type { CommunityMessageKey } from '@blogmcp/sdk/community'
+
+export const FORUM_WORDS: Readonly<Partial<Record<CommunityMessageKey, CommunityMessageKey>>> = Object.freeze({
+  'composer.label': 'forumText.composer.label',
+  'composer.editLabel': 'forumText.composer.editLabel',
+  'composer.placeholder': 'forumText.composer.placeholder',
+  'composer.tooLong': 'forumText.composer.tooLong',
+  'composer.linksNote': 'forumText.composer.linksNote',
+  'composer.posted': 'forumText.composer.posted',
+  'composer.held': 'forumText.composer.held',
+  'composer.cooldown': 'forumText.composer.cooldown',
+  'discussion.empty': 'forumText.discussion.empty',
+  'discussion.deleteTitle': 'forumText.discussion.deleteTitle',
+  'discussion.deleteExplain': 'forumText.discussion.deleteExplain',
+  'discussion.collapsed': 'forumText.discussion.collapsed',
+  'discussion.heldNote': 'forumText.discussion.heldNote',
+  'discussion.hiddenUntilConsentNote': 'forumText.discussion.hiddenUntilConsentNote',
+  'discussion.removedNote': 'forumText.discussion.removedNote',
+  'discussion.placeholderHeld': 'forumText.discussion.placeholderHeld',
+  'discussion.placeholderRemoved': 'forumText.discussion.placeholderRemoved',
+  'discussion.placeholderDeleted': 'forumText.discussion.placeholderDeleted',
+  'report.title': 'forumText.report.title',
+  'report.category': 'forumText.report.category',
+  'error.links': 'forumText.error.links',
+  'error.blocked': 'forumText.error.blocked',
+  'error.confirm': 'forumText.error.confirm',
+  'confirm.other': 'forumText.confirm.other',
+  'warning.identifier': 'forumText.warning.identifier',
+  'warning.other': 'forumText.warning.other',
+  'need.onboarding': 'forumText.need.onboarding',
+  'need.art9_consent': 'forumText.need.art9_consent',
+})

package/src/core/forum.ts

@@ -0,0 +1,83 @@
+/**
+ * `<blogmcp-forum>`'s brain (m3-contracts.md §3.2, §5.3): the listed categories in the team's order
+ * (`forum/categories/list`), each with its latest topics (`forum/topics/list`, the activity order, a few rows of the
+ * first categories), and `me/get` for the notices (away mode, the forum's pause). The forum is for its members:
+ * anyone else gets `membersOnly` (with `needs` for a member session short of its onboarding); a forum switched off
+ * renders nothing.
+ */
+import { reactive } from 'vue'
+import {
+  knownTopicItemsOf,
+  type CommunityCallOptions,
+  type CommunityClient,
+  type CommunityFailure,
+  type ForumCategory,
+  type KnownTopicItem,
+  type MyState,
+} from '@blogmcp/sdk/community'
+
+export type ForumPhase = 'loading' | 'ready' | 'failed' | 'hidden' | 'membersOnly'
+
+/** The categories whose latest topics the index shows, and how many of each (one request a category). */
+export const FORUM_LATEST_CATEGORIES = 10
+export const FORUM_LATEST_PER_CATEGORY = 3
+
+export interface ForumUi {
+  phase: ForumPhase
+  failure: CommunityFailure | null
+  me: MyState | null
+  categories: ForumCategory[]
+  /** The latest rows of a category, by its id (a category whose list failed has none). */
+  latest: Record<string, KnownTopicItem[]>
+}
+
+export interface ForumController {
+  readonly state: ForumUi
+  load(): Promise<void>
+  dispose(): void
+}
+
+export function createForum(o: { client: CommunityClient }): ForumController {
+  const { client } = o
+  const abort = new AbortController()
+  const call: CommunityCallOptions = { signal: abort.signal }
+  let disposed = false
+  let ticket = 0
+  const state = reactive<ForumUi>({ phase: 'loading', failure: null, me: null, categories: [], latest: {} }) as ForumUi
+
+  async function load(): Promise<void> {
+    const mine = ++ticket
+    state.phase = 'loading'
+    state.failure = null
+    const [me, list] = await Promise.all([client.me.get(call), client.forum.categories.list(call)])
+    if (disposed || mine !== ticket) return
+    if (me.ok) state.me = me.value
+    if (!list.ok) {
+      state.failure = list
+      state.phase = list.code === 'surfaceOff' ? 'hidden' : list.code === 'membersOnly' ? 'membersOnly' : 'failed'
+      return
+    }
+    state.categories = [...list.value.categories].sort((a, b) => a.position - b.position)
+    state.latest = {}
+    state.phase = 'ready'
+    // The latest rows of the first categories, side by side; a category whose list fails just shows none.
+    const first = state.categories.slice(0, FORUM_LATEST_CATEGORIES)
+    const pages = await Promise.all(first.map((c) => client.forum.topics.list({ categoryId: c.id, sort: 'activity', limit: FORUM_LATEST_PER_CATEGORY }, call)))
+    if (disposed || mine !== ticket) return
+    const latest: Record<string, KnownTopicItem[]> = {}
+    first.forEach((c, i) => {
+      const page = pages[i]
+      if (page?.ok) latest[c.id] = knownTopicItemsOf(page.value.items).slice(0, FORUM_LATEST_PER_CATEGORY)
+    })
+    state.latest = latest
+  }
+
+  return {
+    state,
+    load,
+    dispose() {
+      disposed = true
+      abort.abort()
+    },
+  }
+}

package/src/core/moderation.ts

@@ -0,0 +1,414 @@
+/**
+ * `<blogmcp-forum-moderation>`'s brain (m3-contracts.md §3.4, §4.2, §4.5, §5.3; D-M3-6): a category moderator's queue —
+ * the cases of category `rules` in their categories (open ones, and decided ones a `system` decision still holds:
+ * `caseStatus`) and the messages waiting in pre-moderation — and what they do with them:
+ *
+ *   - a case: its package as written (text only; no reporter, note or contact), then a decision through the engine —
+ *     restore (`no_action`), hide (`visibility_restricted`) or remove — with the facts and the rule it rests on (the
+ *     case's own by default: a restriction without one is `invalid` on `contractualGround`, and the rule is asked for),
+ *     the statement previewed first (`dryRun`), decided after; or passed to the team (`moderation/escalate`, a category
+ *     of the illegal line);
+ *   - a pre-moderated message: published (no statement: nothing was restricted) or refused (a rule and the facts: a
+ *     removal with its statement) — M3 FX (R3): the queue carries its text (rendered as text) and its `rev`, and the
+ *     review sends the `rev` back: kb-api decides that text only. A refusal other than `notFound` (STALE_REVISION is
+ *     `submit`) re-reads the item: its author edited it meanwhile → the new text is shown with `moderation.textChanged`
+ *     and the moderator decides again; gone → it leaves the queue.
+ *
+ * A member who moderates nothing now (me/get's `moderator` null or empty) gets nothing at all: the element renders
+ * nothing. kb-api re-checks the appointment on every call — anything outside the moderator's scope is `notFound`, and
+ * the row leaves the queue.
+ */
+import { reactive } from 'vue'
+import {
+  ESCALATION_CATEGORIES,
+  communityRulesOf,
+  type CaseCategory,
+  type CommunityCallOptions,
+  type CommunityClient,
+  type CommunityFailure,
+  type CommunityRule,
+  type ForumCategory,
+  type ModerationCase,
+  type ModerationItem,
+  type ModerationRestriction,
+  type MyState,
+} from '@blogmcp/sdk/community'
+import type { Lang, TextRef } from './i18n'
+import { failureText } from './outcomes'
+import { codePointLength, normalizeBody } from './text'
+
+export type ModerationPhase = 'loading' | 'ready' | 'none' | 'failed' | 'hidden' | 'membersOnly'
+
+/** The facts' bound here (kb-api checks its own). */
+const FACTS_MAX = 4000
+
+/** A case opened from the queue: its package and the decision being made. */
+export interface OpenCase {
+  item: ModerationItem
+  kase: ModerationCase | null
+  loading: boolean
+  restriction: ModerationRestriction | ''
+  facts: string
+  /** The rule the restriction rests on ('' the case's own). */
+  ground: string
+  /** kb-api asked for the rule (`invalid` on `contractualGround`): the rule must be chosen. */
+  needsRule: boolean
+  /** The statement of the previewed decision, for the same choice. */
+  preview: string | null
+  previewing: boolean
+  deciding: boolean
+  failure: CommunityFailure | null
+  decided: boolean
+  escalation: { category: CaseCategory | ''; sending: boolean; failure: CommunityFailure | null; done: boolean } | null
+}
+
+/** A pre-moderated message being reviewed. */
+export interface PremodReview {
+  item: ModerationItem
+  outcome: 'approve' | 'reject' | ''
+  ruleId: string
+  facts: string
+  sending: boolean
+  failure: CommunityFailure | null
+  statement: string | null
+  done: 'approved' | 'rejected' | null
+  /** M3 FX (R3): the author edited the text while it was being reviewed — `item` holds the new one; decide again. */
+  changed: boolean
+}
+
+/** How far a review's re-read pages the queue for its item (50 a page): the queue is oldest first and the item is old. */
+const REREAD_PAGES = 20
+
+export interface ModerationUi {
+  phase: ModerationPhase
+  failure: CommunityFailure | null
+  me: MyState | null
+  /** '' every category of the moderator's. */
+  categoryId: string
+  /** The moderator's categories (their names), in the forum's order. */
+  categories: ForumCategory[]
+  items: ModerationItem[]
+  nextCursor: string | null
+  loadingMore: boolean
+  rules: CommunityRule[] | null
+  open: OpenCase | null
+  review: PremodReview | null
+  announcement: TextRef | null
+  announceId: number
+}
+
+export interface ModerationController {
+  readonly state: ModerationUi
+  load(): Promise<void>
+  loadMore(): Promise<void>
+  setCategory(categoryId: string): Promise<void>
+  openCase(item: ModerationItem): Promise<void>
+  closeCase(): void
+  /** Whether the case's decision may be previewed now (a restriction, facts, a rule where one is needed). */
+  canPreview(): boolean
+  preview(): Promise<void>
+  decide(): Promise<void>
+  startEscalation(): void
+  escalate(): Promise<void>
+  openReview(item: ModerationItem, outcome: 'approve' | 'reject'): void
+  closeReview(): void
+  review(): Promise<void>
+  dispose(): void
+}
+
+export function createModeration(o: { client: CommunityClient; lang: Lang; categoryId?: string | null }): ModerationController {
+  const { client, lang } = o
+  const abort = new AbortController()
+  const call: CommunityCallOptions = { signal: abort.signal }
+  let disposed = false
+  let ticket = 0
+  const state = reactive<ModerationUi>({
+    phase: 'loading',
+    failure: null,
+    me: null,
+    categoryId: o.categoryId?.toLowerCase() ?? '',
+    categories: [],
+    items: [],
+    nextCursor: null,
+    loadingMore: false,
+    rules: null,
+    open: null,
+    review: null,
+    announcement: null,
+    announceId: 0,
+  }) as ModerationUi
+
+  const announce = (text: TextRef): void => {
+    state.announcement = text
+    state.announceId += 1
+  }
+
+  /** The moderator's categories now (me/get), or none. */
+  const categoryIds = (): string[] => [...(state.me?.moderator?.categoryIds ?? [])].map((id) => id.toLowerCase())
+
+  /** A row the moderator may no longer act on (another moderator decided it, the appointment ended): out of the queue. */
+  function gone(item: ModerationItem): void {
+    state.items = state.items.filter((i) => i !== item)
+    announce({ key: 'moderation.gone' })
+  }
+
+  const queueInput = (cursor: string | null) => ({ ...(state.categoryId !== '' ? { categoryId: state.categoryId } : {}), ...(cursor ? { cursor } : {}) })
+
+  async function readQueue(mine: number): Promise<void> {
+    const r = await client.moderation.queue(queueInput(null), call)
+    if (disposed || mine !== ticket) return
+    if (!r.ok) {
+      state.failure = r
+      // Not (or no longer) a moderator of what was asked: nothing to show.
+      state.phase = r.code === 'notFound' ? 'none' : r.code === 'surfaceOff' ? 'hidden' : r.code === 'membersOnly' ? 'membersOnly' : 'failed'
+      return
+    }
+    state.items = [...r.value.items]
+    state.nextCursor = r.value.nextCursor
+    state.phase = 'ready'
+  }
+
+  async function loadRules(): Promise<void> {
+    if (state.rules !== null) return
+    const r = await client.legal.current({ kind: 'rules', locale: lang }, call)
+    if (!disposed && r.ok) state.rules = communityRulesOf(r.value.bodyJson)
+  }
+
+  async function load(): Promise<void> {
+    const mine = ++ticket
+    state.phase = 'loading'
+    state.failure = null
+    const me = await client.me.get(call)
+    if (disposed || mine !== ticket) return
+    if (!me.ok) {
+      state.failure = me
+      state.phase = 'failed'
+      return
+    }
+    state.me = me.value
+    // A member who moderates nothing now: nothing at all (not even a heading).
+    if (categoryIds().length === 0) {
+      state.phase = 'none'
+      return
+    }
+    const list = await client.forum.categories.list(call)
+    if (disposed || mine !== ticket) return
+    if (list.ok) state.categories = list.value.categories.filter((c) => categoryIds().includes(c.id.toLowerCase()))
+    // The rules' titles name a queued case's rule (and the decision's choices).
+    void loadRules()
+    if (state.categoryId !== '' && !categoryIds().includes(state.categoryId)) state.categoryId = ''
+    await readQueue(mine)
+  }
+
+  const decisionInput = (dryRun: boolean) => {
+    const c = state.open!
+    return {
+      caseId: c.item.caseId!,
+      restriction: c.restriction as ModerationRestriction,
+      // A member's report is a notice (DSA art. 16); the filters' and the team's cases are the provider's initiative.
+      basis: c.item.source === 'member_report' ? ('notice' as const) : ('own_initiative' as const),
+      facts: normalizeBody(c.facts),
+      ...(c.ground !== '' ? { contractualGround: c.ground } : {}),
+      locale: lang,
+      dryRun,
+    }
+  }
+
+  function canPreview(): boolean {
+    const c = state.open
+    if (!c || !c.kase || c.restriction === '' || c.previewing || c.deciding || c.decided) return false
+    const facts = normalizeBody(c.facts)
+    if (facts === '' || codePointLength(facts) > FACTS_MAX) return false
+    // A restriction rests on a rule: the case's own, else one chosen (kb-api asks for it when the case has none).
+    return c.restriction === 'no_action' || c.ground !== '' || (c.kase.ruleId !== null && !c.needsRule)
+  }
+
+  /**
+   * R3: after a review's refusal, the item as the queue holds it now. Its text changed (a newer rev) — the review shows
+   * the new text (`changed`) and asks again; it is no longer queued — it leaves; unchanged — the refusal stands.
+   */
+  async function reread(v: PremodReview): Promise<void> {
+    const same = (i: ModerationItem): boolean => i.kind === 'premod' && i.conversationId === v.item.conversationId && i.seq === v.item.seq
+    let cursor: string | null = null
+    for (let page = 0; page < REREAD_PAGES; page++) {
+      const r = await client.moderation.queue(queueInput(cursor), call)
+      if (disposed || state.review !== v || !r.ok) return
+      const now = r.value.items.find(same)
+      if (now) {
+        if (now.rev === v.item.rev) return
+        state.items = state.items.map((i) => (same(i) ? now : i))
+        v.item = now
+        v.failure = null
+        v.changed = true
+        announce({ key: 'moderation.textChanged' })
+        return
+      }
+      cursor = r.value.nextCursor
+      if (cursor === null) break
+    }
+    state.review = null
+    gone(v.item)
+  }
+
+  function caseRefused(c: OpenCase, f: CommunityFailure): void {
+    c.failure = f
+    if (f.code === 'invalid' && f.fields?.includes('contractualGround')) {
+      c.needsRule = true
+      void loadRules()
+      return
+    }
+    if (f.code === 'notFound') {
+      state.open = null
+      gone(c.item)
+    }
+  }
+
+  return {
+    state,
+    load,
+    async loadMore() {
+      if (state.loadingMore || state.nextCursor === null || state.phase !== 'ready') return
+      const mine = ticket
+      state.loadingMore = true
+      const r = await client.moderation.queue(queueInput(state.nextCursor), call)
+      state.loadingMore = false
+      if (disposed || mine !== ticket) return
+      if (!r.ok) return announce(failureText(r, lang))
+      state.items = [...state.items, ...r.value.items]
+      state.nextCursor = r.value.nextCursor
+    },
+    async setCategory(categoryId) {
+      const id = categoryId.toLowerCase()
+      if (id === state.categoryId || (id !== '' && !categoryIds().includes(id))) return
+      state.categoryId = id
+      const mine = ++ticket
+      await readQueue(mine)
+    },
+    async openCase(item) {
+      if (item.kind !== 'case' || !item.caseId) return
+      state.review = null
+      state.open = {
+        item,
+        kase: null,
+        loading: true,
+        restriction: '',
+        facts: '',
+        ground: '',
+        needsRule: false,
+        preview: null,
+        previewing: false,
+        deciding: false,
+        failure: null,
+        decided: false,
+        escalation: null,
+      }
+      // The reactive one: what is compared and changed below is what the view reads.
+      const c = state.open
+      void loadRules()
+      const r = await client.moderation.getCase({ caseId: item.caseId }, call)
+      if (disposed || state.open !== c) return
+      c.loading = false
+      if (r.ok) c.kase = r.value.case
+      else caseRefused(c, r)
+    },
+    closeCase() {
+      state.open = null
+    },
+    canPreview,
+    async preview() {
+      const c = state.open
+      if (!c || !canPreview()) return
+      c.previewing = true
+      c.failure = null
+      const r = await client.moderation.decide(decisionInput(true), call)
+      c.previewing = false
+      if (disposed || state.open !== c) return
+      if (r.ok) c.preview = r.value.statement
+      else caseRefused(c, r)
+    },
+    async decide() {
+      const c = state.open
+      // Only what was previewed is decided: the moderator saw the statement the author gets.
+      if (!c || c.preview === null || c.deciding || c.decided) return
+      c.deciding = true
+      c.failure = null
+      const r = await client.moderation.decide(decisionInput(false), call)
+      c.deciding = false
+      if (disposed || state.open !== c) return
+      if (!r.ok) return caseRefused(c, r)
+      c.decided = true
+      c.preview = r.value.statement
+      state.items = state.items.filter((i) => i !== c.item)
+      announce({ key: 'moderation.decided' })
+    },
+    startEscalation() {
+      const c = state.open
+      if (c && !c.escalation) c.escalation = { category: '', sending: false, failure: null, done: false }
+    },
+    async escalate() {
+      const c = state.open
+      const e = c?.escalation
+      if (!c || !e || e.sending || e.done || e.category === '' || !ESCALATION_CATEGORIES.includes(e.category)) return
+      e.sending = true
+      e.failure = null
+      const r = await client.moderation.escalate({ conversationId: c.item.conversationId, seq: c.item.seq, category: e.category }, call)
+      e.sending = false
+      if (disposed || state.open !== c) return
+      if (r.ok) {
+        e.done = true
+        announce({ key: 'moderation.escalated' })
+        return
+      }
+      e.failure = r
+      if (r.code === 'notFound') {
+        state.open = null
+        gone(c.item)
+      }
+    },
+    openReview(item, outcome) {
+      if (item.kind !== 'premod') return
+      state.open = null
+      state.review = { item, outcome, ruleId: '', facts: '', sending: false, failure: null, statement: null, done: null, changed: false }
+      if (outcome === 'reject') void loadRules()
+    },
+    closeReview() {
+      state.review = null
+    },
+    async review() {
+      const v = state.review
+      if (!v || v.sending || v.done || v.outcome === '') return
+      const facts = normalizeBody(v.facts)
+      if (v.outcome === 'reject' && (v.ruleId === '' || facts === '' || codePointLength(facts) > FACTS_MAX)) return
+      v.sending = true
+      v.failure = null
+      v.changed = false
+      // R3: the rev of the text shown — kb-api decides that text only (a newer one is STALE_REVISION, nothing written).
+      const ref = { conversationId: v.item.conversationId, seq: v.item.seq, rev: v.item.rev ?? 1 }
+      const r =
+        v.outcome === 'approve'
+          ? await client.moderation.reviewPremod({ ...ref, outcome: 'approve' }, call)
+          : // The statement of a rejection in the reader's language, as decide's and remove's (kb-api's schema takes it).
+            await client.moderation.reviewPremod({ ...ref, outcome: 'reject', ruleId: v.ruleId, facts, locale: lang }, call)
+      v.sending = false
+      if (disposed || state.review !== v) return
+      if (!r.ok) {
+        v.failure = r
+        if (r.code === 'notFound') {
+          state.review = null
+          gone(v.item)
+          return
+        }
+        await reread(v)
+        return
+      }
+      v.done = v.outcome === 'approve' ? 'approved' : 'rejected'
+      if ('statement' in r.value) v.statement = r.value.statement
+      state.items = state.items.filter((i) => i !== v.item)
+      announce({ key: v.done === 'approved' ? 'moderation.approved' : 'moderation.rejected' })
+    },
+    dispose() {
+      disposed = true
+      abort.abort()
+    },
+  }
+}