@linxin666/dsh-client-ui-task-board 0.4.4 → 0.4.6

package/src/client/schedule-zone.ts

@@ -7,8 +7,9 @@
  * the Host schedules with (`core/schedule.ts`), so the preview a user sees is
  * computed by the code that will actually arm the rule.
  */
-import { isValidTimeZone } from '../core/schedule.ts'
-import { t } from './locales.ts'
+import { isValidTimeZone, partsInZone, resolveHostTimeZone, zonedEpoch } from '../core/schedule.ts'
+import { scheduleRunBudget, type ScheduleRule, type ScheduleStopReason } from '../core/tasks.ts'
+import { t, type TaskBoardKey } from './locales.ts'
 
 /** One selectable zone, in the order the picker shows it. */
 export interface ZoneChoice {
@@ -112,6 +113,103 @@ export function relativeTimeLabel(targetMs: number, now: number): string {
   return `${durationParts(delta)}`
 }
 
+/** Zero-pad a calendar/clock field for a `datetime-local` value. */
+function pad(value: number): string {
+  return String(value).padStart(2, '0')
+}
+
+/**
+ * The `datetime-local` input value for an instant, read in an explicit zone:
+ * `YYYY-MM-DDTHH:mm`. Uses the shared engine's zone reader, so the editor
+ * shows the same wall clock the Host schedules by.
+ * @param epochMs - the instant to render.
+ * @param timeZone - zone to read it in; absent uses the Host zone.
+ * @returns the input value.
+ */
+export function zonedInputValue(epochMs: number, timeZone?: string): string {
+  const parts = partsInZone(usableZone(timeZone), epochMs)
+  return `${parts.year}-${pad(parts.month)}-${pad(parts.day)}T${pad(parts.hour)}:${pad(parts.minute)}`
+}
+
+/**
+ * Parse a `datetime-local` input value back to an instant, read in an explicit
+ * zone. Returns undefined when the text is not a whole calendar wall clock or
+ * names one the zone skips (a spring-forward gap), so the editor can refuse an
+ * unusable instant instead of silently moving it.
+ * @param value - the input text.
+ * @param timeZone - zone to interpret it in; absent uses the Host zone.
+ * @returns the instant, or undefined when it is not a usable wall clock.
+ */
+export function parseZonedInput(value: string, timeZone?: string): number | undefined {
+  const match = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2})/.exec(value.trim())
+  if (match === null) return undefined
+  const [year, month, day, hour, minute] = match.slice(1).map(Number)
+  if (month < 1 || month > 12 || day < 1 || day > 31 || hour > 23 || minute > 59) return undefined
+  return zonedEpoch(usableZone(timeZone), year, month, day, hour, minute)
+}
+
+/**
+ * The default instant a new one-shot editor opens on: the next whole hour,
+ * rendered in the zone the rule will be read in.
+ * @param now - reference instant.
+ * @param timeZone - zone the rule is read in.
+ * @returns the input value for a near-future default.
+ */
+export function defaultZonedInputValue(now: number, timeZone?: string): string {
+  const nextHour = Math.ceil(now / 3_600_000) * 3_600_000
+  return zonedInputValue(nextHour, timeZone)
+}
+
+/** The zone the input helpers resolve against: an explicit resolved zone, or the Host zone. */
+function usableZone(timeZone: string | undefined): string {
+  return timeZone !== undefined && isValidTimeZone(timeZone) ? timeZone : resolveHostTimeZone()
+}
+
+/**
+ * The editor's run-cap option for a stored cap: the two named presets, the
+ * unlimited entry, or a custom value the editor shows in its own field.
+ * @param maxRuns - the stored cap, when any.
+ * @returns the select option value.
+ */
+export function runCapOption(maxRuns: number | undefined): string {
+  if (maxRuns === undefined) return 'unlimited'
+  if (maxRuns === 1) return '1'
+  if (maxRuns === 2) return '2'
+  return 'custom'
+}
+
+/** The locale key describing why a rule stopped or skipped an occurrence. */
+export function stopReasonKey(reason: ScheduleStopReason): TaskBoardKey {
+  return `detail.schedule.stop.${reason}` as TaskBoardKey
+}
+
+/**
+ * The run-budget line: how many scheduled executions the Host opened and how
+ * many remain. Derived from the counter and the cap rather than stored, so the
+ * display cannot drift from the ledger.
+ * @param rule - the schedule rule.
+ * @returns localized wording.
+ */
+export function budgetLabel(rule: ScheduleRule): string {
+  const budget = scheduleRunBudget(rule)
+  const done = String(rule.runCount)
+  if (budget === undefined) return t('detail.schedule.runsUnlimited', { done })
+  const remaining = Math.max(budget - rule.runCount, 0)
+  return `${t('detail.schedule.runs', { done, total: String(budget) })} · ${t('detail.schedule.remaining', { count: String(remaining) })}`
+}
+
+/** The line describing a rule that stopped itself, or undefined while it may still fire. */
+export function endedLabel(rule: ScheduleRule): string | undefined {
+  if (rule.endedReason === undefined) return undefined
+  return t('detail.schedule.ended', { reason: t(stopReasonKey(rule.endedReason)) })
+}
+
+/** The line describing the last skipped occurrence, or undefined when none. */
+export function skippedLabel(rule: ScheduleRule): string | undefined {
+  if (rule.skippedReason === undefined) return undefined
+  return t('detail.schedule.skipped', { reason: t(stopReasonKey(rule.skippedReason)) })
+}
+
 /**
  * The full next-run label: the absolute wall clock in the schedule's own zone,
  * plus the relative distance in parentheses. Showing both matters because a

package/src/client/seats.tsx

@@ -0,0 +1,58 @@
+/**
+ * The board's child seats, threaded from the slot registration that declares
+ * them down to the components that consume them.
+ *
+ * The framework hands the declaring component a `renderSlot` binding; the board
+ * wraps that binding in a React context so a provider's contribution can render
+ * deep inside TaskDetail, the card, or the settings card without those
+ * components knowing which providers exist.
+ *
+ * @module dsh-task-board/client/seats
+ */
+import { createContext, useContext } from 'react'
+import type { ReactNode } from 'react'
+import {
+  TASK_BOARD_CARD_DECORATION,
+  TASK_BOARD_DETAIL_SECTION,
+  TASK_BOARD_SETTINGS_SECTION,
+  type TaskBoardCardDecorationProps,
+  type TaskBoardDetailSectionProps,
+  type TaskBoardSettingsSectionProps,
+} from '../core/extension.ts'
+
+/** The three provider seats, adapted to plain render functions. */
+export interface TaskBoardSeats {
+  detailSection: (props: TaskBoardDetailSectionProps) => ReactNode
+  settingsSection: (props: TaskBoardSettingsSectionProps) => ReactNode
+  cardDecoration: (props: TaskBoardCardDecorationProps) => ReactNode
+}
+
+/** Nothing registered: every seat renders empty. */
+export const EMPTY_TASK_BOARD_SEATS: TaskBoardSeats = {
+  detailSection: () => null,
+  settingsSection: () => null,
+  cardDecoration: () => null,
+}
+
+/** The framework `renderSlot` binding shape (key + owner props share). */
+export type SlotRenderBinding = (key: string, owner: Record<string, unknown>) => ReactNode
+
+/** Adapt one framework renderSlot binding to the board's seat interface. */
+export function seatsFromRenderSlot(renderSlot: SlotRenderBinding | undefined): TaskBoardSeats {
+  if (renderSlot === undefined) return EMPTY_TASK_BOARD_SEATS
+  return {
+    detailSection: props => renderSlot(TASK_BOARD_DETAIL_SECTION, props as unknown as Record<string, unknown>),
+    settingsSection: props => renderSlot(TASK_BOARD_SETTINGS_SECTION, props as unknown as Record<string, unknown>),
+    cardDecoration: props => renderSlot(TASK_BOARD_CARD_DECORATION, props as unknown as Record<string, unknown>),
+  }
+}
+
+const TaskBoardSeatsContext = createContext<TaskBoardSeats>(EMPTY_TASK_BOARD_SEATS)
+
+/** Provider the board's registered components wrap their subtree in. */
+export const TaskBoardSeatsProvider = TaskBoardSeatsContext.Provider
+
+/** Read the current seat set (empty when no board registration is above). */
+export function useTaskBoardSeats(): TaskBoardSeats {
+  return useContext(TaskBoardSeatsContext)
+}

package/src/client/service.ts

@@ -0,0 +1,94 @@
+/**
+ * The board's browser-half extension service (`taskBoard`).
+ *
+ * It gives a provider's browser half the client capability face from the
+ * contract: dispatch over the board's same-origin action channel, card
+ * visibility predicates, and a subscription to the board mirror. The board
+ * controller is attached and detached as the master switch mounts and unmounts
+ * the UI, so the service can be provided before any controller exists.
+ *
+ * @module dsh-task-board/client/service
+ */
+import type { BoardController } from '../core/controller.ts'
+import type {
+  TaskBoardClientFace,
+  TaskBoardClientMirror,
+  TaskBoardExtensionActionRequest,
+  TaskBoardVisibilityPredicate,
+} from '../core/extension.ts'
+import type { TaskRecord } from '../core/tasks.ts'
+
+export class TaskBoardClientService implements TaskBoardClientFace {
+  private controller: BoardController | undefined
+  private enabled = false
+  private unsubscribeController: (() => void) | undefined
+  /** Predicates registered before the controller exists, replayed on attach. */
+  private readonly pendingVisibility: TaskBoardVisibilityPredicate[] = []
+  private readonly listeners = new Set<(mirror: TaskBoardClientMirror) => void>()
+
+  /** Bind the live board controller (called when the UI mounts). */
+  attach(controller: BoardController): void {
+    if (this.controller === controller) return
+    this.detach()
+    this.controller = controller
+    this.unsubscribeController = controller.subscribe(() => { this.notify() })
+    for (const predicate of this.pendingVisibility.splice(0)) controller.registerVisibility(predicate)
+    this.notify()
+  }
+
+  /** Release the current controller (called when the UI unmounts). */
+  detach(): void {
+    if (this.controller === undefined) return
+    this.unsubscribeController?.()
+    this.unsubscribeController = undefined
+    this.controller = undefined
+    this.notify()
+  }
+
+  /** Apply the board's master switch. */
+  setEnabled(enabled: boolean): void {
+    if (this.enabled === enabled) return
+    this.enabled = enabled
+    this.notify()
+  }
+
+  dispatch(request: TaskBoardExtensionActionRequest): Promise<boolean> {
+    if (this.controller === undefined) return Promise.resolve(false)
+    return this.controller.dispatchExtension(request)
+  }
+
+  registerVisibility(predicate: TaskBoardVisibilityPredicate): () => void {
+    if (this.controller !== undefined) return this.controller.registerVisibility(predicate)
+    this.pendingVisibility.push(predicate)
+    return () => {
+      const index = this.pendingVisibility.indexOf(predicate)
+      if (index !== -1) this.pendingVisibility.splice(index, 1)
+    }
+  }
+
+  subscribe(callback: (mirror: TaskBoardClientMirror) => void): () => void {
+    this.listeners.add(callback)
+    return () => { this.listeners.delete(callback) }
+  }
+
+  snapshot(): TaskBoardClientMirror {
+    const state = this.controller?.getSnapshot()
+    return {
+      enabled: this.enabled,
+      tasks: (state?.tasks ?? []) as readonly TaskRecord[],
+      extensions: state?.extensions ?? {},
+    }
+  }
+
+  private notify(): void {
+    const mirror = this.snapshot()
+    for (const listener of [...this.listeners]) {
+      try {
+        listener(mirror)
+      } catch (error) {
+        // A provider's mirror callback must never break the board.
+        console.error('[dsh-task-board] extension mirror callback failed', error)
+      }
+    }
+  }
+}

package/src/client/settings-card.module.css

@@ -36,8 +36,8 @@
   border: 0;
   border-radius: 12px;
   align-items: center;
-  gap: 12px;
-  padding: 14px 16px;
+  gap: 13px;
+  padding: 16px;
   display: flex;
 }
 
@@ -51,8 +51,8 @@
   box-sizing: border-box;
   border-radius: 12px;
   align-items: center;
-  gap: 12px;
-  padding: 14px 16px;
+  gap: 13px;
+  padding: 16px;
   display: flex;
 }
 
@@ -64,6 +64,25 @@
   display: flex;
 }
 
+/* Optional leading plugin mark: a quiet tile that takes the ink color on
+   hover and while the card is open, so the whole row reads as one control. */
+.mark {
+  flex: none;
+  display: grid;
+  place-items: center;
+  width: 34px;
+  height: 34px;
+  border-radius: 10px;
+  background: var(--dsw-alias-bg-module-platform);
+  color: var(--dsw-alias-label-secondary);
+  transition: color 0.16s;
+}
+
+.header:hover .mark,
+.cardOpen .mark {
+  color: var(--dsw-alias-label-primary);
+}
+
 .name {
   color: var(--dsw-alias-label-primary);
   font-size: 15px;
@@ -95,7 +114,13 @@
 .chevron {
   color: var(--dsw-alias-label-tertiary);
   flex: none;
-  transition: transform 0.16s;
+  width: 16px;
+  height: 16px;
+  transition: transform 0.16s, color 0.16s;
+}
+
+.header:hover .chevron {
+  color: var(--dsw-alias-label-secondary);
 }
 
 .chevronOpen {
@@ -406,6 +431,7 @@
 @media (prefers-reduced-motion: reduce) {
   .card,
   .header,
+  .mark,
   .chevron,
   .chevronOpen,
   .discard,

package/src/client/settings-form.ts

@@ -215,6 +215,8 @@ export class CardForm<T> {
   private readonly disposeForm: () => void
   private disposed = false
   private saving = false
+  /** A save asked for while one was in flight; it runs once the first settles (#1754). */
+  private saveQueued = false
   private failed = false
   private failedReason: string | undefined
 
@@ -283,7 +285,7 @@ export class CardForm<T> {
       resetField: (field) => {
         this.stage(field, { text: this.specOf(field).format(this.baseValue(field)), clear: true })
       },
-      save: () => { void this.save() },
+      save: () => { void this.requestSave() },
       discard: () => {
         if (this.staged.size === 0 && !this.failed) return
         this.staged.clear()
@@ -310,6 +312,30 @@ export class CardForm<T> {
    * the user can correct them instead of retyping.
    * @returns settlement after the mutation and the read-back.
    */
+  /**
+   * Run one save, and re-run it once if another was asked for while this one
+   * was still in flight.
+   *
+   * A save is a Host round trip that also drives the profile reconcile, and
+   * the Host runs that write inside one exclusive transaction. Answering a
+   * press that arrives mid-flight by returning immediately dropped the edit
+   * with no explanation, which is the "the save button stops working after a
+   * few rounds" report (#1754). Serializing instead means a save pressed while
+   * another is still settling runs against the settled state - which is what
+   * the operator meant by pressing it again.
+   * @returns settlement after the mutation and the read-back.
+   */
+  async requestSave(): Promise<void> {
+    if (this.saving) {
+      this.saveQueued = true
+      return
+    }
+    await this.save()
+    if (!this.saveQueued) return
+    this.saveQueued = false
+    await this.requestSave()
+  }
+
   async save(): Promise<void> {
     const plan = this.plan()
     const valid = plan.filter((item): item is PlannedWrite & { judge: () => boolean } => item.judge !== undefined)

package/src/core/controller.ts

@@ -12,13 +12,14 @@
  * owns only the orchestration seam (state, persistence, notify, navigation).
  */
 import type { TaskStore } from './store.ts'
-import { withStatus, type NewTaskInput, type TaskRecord, type TaskStatus } from './tasks.ts'
+import { hasOpenExecution, withStatus, type NewTaskInput, type TaskRecord, type TaskStatus } from './tasks.ts'
 import { applyArchiveTask, applyRestoreTask } from './use-cases/task-archive.ts'
 import { applyCreateTask } from './use-cases/task-create.ts'
 import { applyDeleteTask } from './use-cases/task-delete.ts'
-import { applyScheduleNextRun as applyScheduleRollForward, applySetSchedule } from './use-cases/task-schedule.ts'
+import { applyScheduleNextRun as applyScheduleRollForward, applySetSchedule, type SetSchedulePatch } from './use-cases/task-schedule.ts'
 import { resolveHostTimeZone } from './schedule.ts'
 import { applySetParent } from './use-cases/task-parent.ts'
+import { applyDeleteTag, applyRenameTag } from './use-cases/task-tag.ts'
 import { applyUpdateTask, type TaskUpdatePatch } from './use-cases/task-update.ts'
 import { DEFAULT_SUBTASK_DEPTH } from './subtask.ts'
 import type {
@@ -28,6 +29,10 @@ import type {
   TaskBoardParseRequest,
   TaskBoardSnapshot,
 } from '../protocol.ts'
+import type {
+  TaskBoardExtensionActionRequest,
+  TaskBoardVisibilityPredicate,
+} from './extension.ts'
 
 export interface TaskBoardTransport {
   bootstrap(legacy: readonly TaskRecord[]): Promise<TaskBoardSnapshot>
@@ -136,7 +141,7 @@ export interface ExecutionOptionsSnapshot {
  * (revision/scheduler/power); a full snapshot also carries the deployment
  * constants the UI reads (session default permission, subtask depth).
  */
-export type HostMirror = Pick<TaskBoardSnapshot, 'revision' | 'scheduler' | 'power' | 'sessionDefaultPermission' | 'maxSubtaskDepth' | 'teamRunAvailable'>
+export type HostMirror = Pick<TaskBoardSnapshot, 'revision' | 'scheduler' | 'power' | 'sessionDefaultPermission' | 'maxSubtaskDepth' | 'teamRunAvailable' | 'goalRunEnabled' | 'extensions'>
 
 /** Immutable controller snapshot for UI subscriptions. */
 export interface ControllerSnapshot {
@@ -154,6 +159,15 @@ export interface ControllerSnapshot {
   canParseTask?: boolean
   transportError?: string
   host?: HostMirror
+  /**
+   * Provider card-visibility predicates, in registration order. A task shows
+   * only while every predicate accepts it; providers hide their own off-board
+   * cards here instead of the board hard-coding a provider rule. Optional so a
+   * hand-built snapshot (tests, a shell-less composition) defaults to visible.
+   */
+  visibility?: readonly TaskBoardVisibilityPredicate[]
+  /** Read-only summaries published by running extensions, keyed by extension id. */
+  extensions?: Readonly<Record<string, unknown>>
 }
 
 /** The selected task (resolved from the ledger), or undefined. */
@@ -201,6 +215,8 @@ export class BoardController {
   private readonly taskQueues = new Map<string, Promise<void>>()
   private transportError: string | undefined
   private hostState: HostMirror | undefined
+  /** Provider visibility predicates (immutable array; replaced on change). */
+  private visibility: readonly TaskBoardVisibilityPredicate[] = []
   private remoteSubscribed = false
   private remoteInitialization: Promise<boolean> | undefined
 
@@ -251,9 +267,42 @@ export class BoardController {
       ...(typeof this.deps.transport?.parseDraft === 'function' ? { canParseTask: true } : {}),
       ...(this.transportError === undefined ? {} : { transportError: this.transportError }),
       ...(this.hostState === undefined ? {} : { host: this.hostState }),
+      visibility: this.visibility,
+      ...(this.hostState?.extensions === undefined ? {} : { extensions: this.hostState.extensions }),
+    }
+  }
+
+  /**
+   * Register one card-visibility predicate. The returned disposer removes it;
+   * both changes notify subscribers so the board re-renders.
+   */
+  registerVisibility(predicate: TaskBoardVisibilityPredicate): () => void {
+    this.visibility = [...this.visibility, predicate]
+    this.notify()
+    return () => {
+      const next = this.visibility.filter(candidate => candidate !== predicate)
+      if (next.length === this.visibility.length) return
+      this.visibility = next
+      this.notify()
     }
   }
 
+  /**
+   * Deliver one provider action through the board's same-origin channel. A
+   * board without a Host transport (the legacy in-memory path) refuses it.
+   */
+  async dispatchExtension(request: TaskBoardExtensionActionRequest): Promise<boolean> {
+    if (this.deps.transport === undefined) return false
+    const action: TaskBoardAction = {
+      kind: 'extension-action',
+      extensionId: request.extensionId,
+      action: request.action,
+      ...(request.taskId === undefined ? {} : { taskId: request.taskId }),
+      ...(request.payload === undefined ? {} : { payload: request.payload }),
+    }
+    return await this.commitRemote(action, request.taskId)
+  }
+
   subscribe(fn: () => void): () => void {
     this.listeners.add(fn)
     return () => { this.listeners.delete(fn) }
@@ -507,18 +556,58 @@ export class BoardController {
     return true
   }
 
+  /**
+   * Rename one label across the whole ledger; a name already in use merges the
+   * two labels. Host-backed: the ledger owns the transition and confirms it, so
+   * the board's label row reflects whether the Host accepted the edit.
+   * @returns true when the edit was accepted by the authority.
+   */
+  async renameTag(from: string, to: string): Promise<boolean> {
+    if (this.deps.transport !== undefined) {
+      return await this.commitRemote({ kind: 'rename-tag', from, to })
+    }
+    const result = applyRenameTag(this.tasks, from, to, this.now())
+    if (result.error !== undefined) return false
+    if (result.changed) {
+      this.tasks = [...result.tasks]
+      this.persistAndNotify()
+    }
+    return true
+  }
+
+  /**
+   * Remove one label from every task that carries it, board and archive alike —
+   * the board's label row is drawn from the whole ledger, so a label left on an
+   * archived card would come straight back.
+   * @returns true when the edit was accepted by the authority.
+   */
+  async deleteTag(name: string): Promise<boolean> {
+    if (this.deps.transport !== undefined) {
+      return await this.commitRemote({ kind: 'delete-tag', name })
+    }
+    const result = applyDeleteTag(this.tasks, name, this.now())
+    if (result.error !== undefined) return false
+    if (result.changed) {
+      this.tasks = [...result.tasks]
+      this.persistAndNotify()
+    }
+    return true
+  }
+
   // --- scheduling ---------------------------------------------------------------
 
   /**
-   * Update a task's schedule rule. A blank or invalid cron expression is
-   * rejected (returns false, state untouched). When the rule ends up enabled
-   * the next run instant is computed immediately; a disabled rule carries no
-   * next-run instant. Delegates the domain transition to the schedule use case.
+   * Update a task's schedule rule. An unusable plan (blank or invalid cron, a
+   * one-shot with no future instant, a non-positive run cap) is rejected
+   * (returns false, state untouched). When the rule ends up enabled the next
+   * run instant is computed immediately — a one-shot's next instant IS its
+   * planned instant — and a disabled rule carries none. Delegates the domain
+   * transition to the schedule use case.
    * @param id - the task to schedule.
    * @param patch - fields to change (absent fields keep their current value).
-   * @returns true when applied, false when rejected (invalid cron / unknown task).
+   * @returns true when applied, false when rejected (unknown task / unusable plan).
    */
-  setSchedule(id: string, patch: { enabled?: boolean; cron?: string; timeZone?: string | null }): boolean {
+  setSchedule(id: string, patch: SetSchedulePatch): boolean {
     // The Host zone is the fallback a rule with no stored zone follows: the
     // mirrored snapshot carries it, and a controller without a Host mirror
     // (pure client tests) falls back to the process zone.
@@ -572,7 +661,9 @@ export class BoardController {
    */
   async runTask(id: string): Promise<boolean> {
     const task = this.tasks.find(candidate => candidate.id === id)
-    if (task === undefined || task.archivedAt !== undefined || task.status === 'running') return false
+    // Only an open execution blocks a second launch; the 'running' column is a
+    // board statement and a card parked there by hand still runs on request.
+    if (task === undefined || task.archivedAt !== undefined || hasOpenExecution(task)) return false
     if (this.deps.transport === undefined) return false
     return await this.commitRemote({ kind: 'run', taskId: id }, id, currentOf(this.deps.sessions))
   }
@@ -724,6 +815,8 @@ export class BoardController {
     const sessionDefaultPermission = snapshot.sessionDefaultPermission ?? this.hostState?.sessionDefaultPermission
     const maxSubtaskDepth = snapshot.maxSubtaskDepth ?? this.hostState?.maxSubtaskDepth
     const teamRunAvailable = snapshot.teamRunAvailable ?? this.hostState?.teamRunAvailable
+    const goalRunEnabled = snapshot.goalRunEnabled ?? this.hostState?.goalRunEnabled
+    const extensions = snapshot.extensions ?? this.hostState?.extensions
     return {
       revision: snapshot.revision,
       scheduler: snapshot.scheduler,
@@ -731,6 +824,8 @@ export class BoardController {
       ...(sessionDefaultPermission === undefined ? {} : { sessionDefaultPermission }),
       ...(maxSubtaskDepth === undefined ? {} : { maxSubtaskDepth }),
       ...(teamRunAvailable === undefined ? {} : { teamRunAvailable }),
+      ...(goalRunEnabled === undefined ? {} : { goalRunEnabled }),
+      ...(extensions === undefined ? {} : { extensions }),
     }
   }