@cat-factory/app 0.300.1 → 0.301.0

package/app/components/panels/inspector/ServiceTestingContext.vue

@@ -0,0 +1,141 @@
+<script setup lang="ts">
+import { computed, ref, watch } from 'vue'
+import { TESTING_CONTEXT_MAX_LENGTH } from '@cat-factory/contracts'
+import type { Block } from '~/types/domain'
+import InspectorSection from '~/components/panels/inspector/InspectorSection.vue'
+import { rehydratedDraft } from '~/components/panels/inspector/ServiceTestingContext.logic'
+import { showOverrideField } from '~/utils/uiMode'
+
+// Per-service (frame) TESTING CONTEXT: freeform prose about how this service is tested, which
+// the engine injects verbatim into every tester prompt for it: the pipeline testers and the
+// environment dry run's prober alike. It sits beside the sealed test credentials because the
+// two are halves of one answer: the credentials are the material, this is what to do with it.
+//
+// Non-sensitive by contract: it is rendered INTO the prompt, so a real secret belongs one panel
+// up, in the sealed store, and this prose refers to it by variable name. The banner says so.
+//
+// It is a plain block field (like the provisioning config), so it saves through the board store's
+// `updateBlock` rather than a store of its own, and the draft below is what makes it an explicit
+// save instead of a keystroke-per-request.
+const props = defineProps<{ block: Block }>()
+
+const board = useBoardStore()
+const uiMode = useUiModeStore()
+const toast = useToast()
+const { t } = useI18n()
+
+const busy = ref(false)
+const draft = ref(props.block.testingContext ?? '')
+
+// Re-hydrate from the block when the persisted value moves, but never over what the operator has
+// typed (`rehydratedDraft` owns the rule and its spec states each case). The board store patches
+// optimistically and ROLLS BACK on a rejected write, so a failed save arrives here looking exactly
+// like a teammate's edit; taking it would erase the prose the toast is telling the operator to try
+// saving again.
+watch(
+  () => props.block.testingContext ?? '',
+  (incoming, previous) => {
+    draft.value = rehydratedDraft({ draft: draft.value, previous, incoming, saving: busy.value })
+  },
+)
+
+const saved = computed(() => props.block.testingContext ?? '')
+// What a save would SEND, which is what the server would store: the request trims before it caps,
+// so trailing whitespace is neither length spent nor a change worth a request.
+const outgoing = computed(() => draft.value.trim())
+const tooLong = computed(() => outgoing.value.length > TESTING_CONTEXT_MAX_LENGTH)
+const dirty = computed(() => outgoing.value !== saved.value)
+const canSave = computed(() => !busy.value && dirty.value && !tooLong.value)
+
+// Standing per-service configuration, not part of the everyday delivery loop: a service is briefed
+// once and every task then ships without anyone opening this. Absent, every tester prompt is
+// byte-identical to one written before the field existed, which is what makes hiding it honest at
+// the basic tier. `showOverrideField` (not a bare `isAdvanced`) because a service that HAS been
+// briefed must show its prose to whoever opens the inspector: nothing else in the SPA surfaces
+// what the testers are being told, so hiding a filled box would leave a basic-tier user unable to
+// read, correct or clear it. The ROLE axis needs no separate answer: `intake` is capped at basic
+// and never configures the platform, so this reaches the same people the tier bar admits.
+const show = computed(() => showOverrideField(uiMode.isAdvanced, saved.value))
+
+async function save() {
+  busy.value = true
+  try {
+    // `updateBlock` reports its own failure (it rolls back and toasts), so only the success
+    // needs saying here; announcing it unconditionally would claim a save the rollback undid.
+    const persisted = await board.updateBlock(props.block.id, { testingContext: outgoing.value })
+    if (persisted) {
+      toast.add({
+        title: t('inspector.testingContext.savedToast'),
+        icon: 'i-lucide-check',
+        color: 'success',
+      })
+    }
+  } finally {
+    busy.value = false
+  }
+}
+
+function revert() {
+  draft.value = saved.value
+}
+</script>
+
+<template>
+  <InspectorSection
+    v-if="show"
+    :title="t('inspector.testingContext.title')"
+    :hint="t('inspector.testingContext.sectionHint')"
+    data-testid="service-testing-context"
+  >
+    <!-- This text reaches the model in the prompt, so it must never hold a real secret. -->
+    <div
+      class="flex items-start gap-2 rounded-md border border-slate-700 bg-slate-800/40 px-2.5 py-2 text-[11px] leading-snug text-slate-300"
+    >
+      <UIcon name="i-lucide-info" class="mt-0.5 h-4 w-4 shrink-0 text-slate-400" />
+      <span>{{ t('inspector.testingContext.notSecret') }}</span>
+    </div>
+
+    <UTextarea
+      v-model="draft"
+      :rows="8"
+      :placeholder="t('inspector.testingContext.placeholder')"
+      class="w-full"
+      data-testid="testing-context-input"
+    />
+
+    <div class="flex items-center justify-between gap-2">
+      <p class="text-[11px] text-slate-500" :class="{ 'text-error-400': tooLong }">
+        {{
+          t('inspector.testingContext.length', {
+            count: outgoing.length,
+            max: TESTING_CONTEXT_MAX_LENGTH,
+          })
+        }}
+      </p>
+      <div class="flex items-center gap-2">
+        <UButton
+          v-if="dirty"
+          color="neutral"
+          variant="ghost"
+          size="xs"
+          data-testid="testing-context-revert"
+          @click="revert"
+        >
+          {{ t('inspector.testingContext.revert') }}
+        </UButton>
+        <UButton
+          color="primary"
+          variant="soft"
+          size="xs"
+          icon="i-lucide-save"
+          :loading="busy"
+          :disabled="!canSave"
+          data-testid="testing-context-save"
+          @click="save"
+        >
+          {{ t('inspector.testingContext.save') }}
+        </UButton>
+      </div>
+    </div>
+  </InspectorSection>
+</template>

package/app/components/pipeline/PipelineBuilder.vue

@@ -1,5 +1,5 @@
 <script setup lang="ts">
-import { computed, ref, watch } from 'vue'
+import { computed, ref } from 'vue'
 import { DEPLOYER_AGENT_KIND } from '@cat-factory/contracts'
 import type { AgentKind, Pipeline } from '~/types/domain'
 import AgentPalette from '~/components/palettes/AgentPalette.vue'
@@ -247,20 +247,20 @@ const open = computed({
 // Refresh the observability-integration state whenever the builder opens so the palette
 // knows whether to offer the post-release-health gate (it's loaded on demand, not from
 // the snapshot). Best-effort: a failure just leaves the gate hidden.
-watch(open, (isOpen) => {
-  if (isOpen) releaseHealth.load().catch(() => {})
+onModalOpen(open, () => {
+  releaseHealth.load().catch(() => {})
   // The prompt-override index badges the steps whose agent no longer runs the shipped prompt.
   // Best-effort: the builder is fully usable without it, and a deployment that wires no
   // override store answers 503 here.
-  if (isOpen) agentPrompts.loadIndex().catch(() => {})
+  agentPrompts.loadIndex().catch(() => {})
   // The workspace's per-kind output ceilings, which the per-step field shows as its inherited
   // placeholder and the prompt editor edits. Best-effort on the same terms as the prompt index.
-  if (isOpen) agentSettings.load().catch(() => {})
+  agentSettings.load().catch(() => {})
   // The resolved foundational-services catalog, which the binary-output picker offers from.
   // Single-flighted per workspace, so this shares the panel's load rather than adding one. A
   // failure is not swallowed into an empty picker: the store records `available: false`, and
   // the picker says the catalog is unreachable rather than "no services exist".
-  if (isOpen) void foundational.ensureProbed()
+  void foundational.ensureProbed()
 })
 
 function add(kind: AgentKind) {

package/app/components/providers/PersonalCredentialModal.vue

@@ -4,7 +4,7 @@
 // personalSubscriptions store's `pending` state, which is set when the server replies 428
 // credential_required. On submit it transparently retries the gated action and caches the
 // password. The copy follows the pending vendor (Claude / GLM / ChatGPT-Codex).
-import { computed, ref, watch } from 'vue'
+import { computed, ref } from 'vue'
 import SecretInput from '~/components/common/SecretInput.vue'
 
 const { t } = useI18n()
@@ -45,8 +45,8 @@ const vendorLabel = computed(() => {
   }
 })
 
-watch(open, (isOpen) => {
-  if (isOpen) password.value = ''
+onModalOpen(open, () => {
+  password.value = ''
 })
 
 const title = computed(() => {

package/app/components/tasks/BugHuntModal.vue

@@ -229,8 +229,7 @@ const request = computed(() =>
 )
 const canHunt = computed(() => request.value !== null)
 
-watch(open, (isOpen) => {
-  if (!isOpen) return
+onModalOpen(open, () => {
   hunt.reset()
   boardId.value = ''
   issueType.value = ''

package/app/components/tasks/TaskImportModal.vue

@@ -70,13 +70,11 @@ const title = computed(() =>
   pinnedContainer.value ? t('tasks.import.titleCreate') : t('tasks.import.titleBrowse'),
 )
 
-watch(open, (isOpen) => {
-  if (isOpen) {
-    ref_.value = ''
-    source.value = ui.taskImport?.source ?? tasks.offeredSources[0]?.source ?? undefined
-    resetContainer()
-    tasks.loadTasks().catch(() => {})
-  }
+onModalOpen(open, () => {
+  ref_.value = ''
+  source.value = ui.taskImport?.source ?? tasks.offeredSources[0]?.source ?? undefined
+  resetContainer()
+  tasks.loadTasks().catch(() => {})
 })
 
 // Choosing an issue in the picker hands off to the add-task form, prefilled with the

package/app/components/tasks/TaskSourceConnectModal.vue

@@ -45,8 +45,8 @@ const values = ref<Record<string, string>>({})
 const saving = ref(false)
 const togglingEnabled = ref(false)
 
-watch(open, (isOpen) => {
-  if (isOpen) values.value = {}
+onModalOpen(open, () => {
+  values.value = {}
 })
 
 const canSubmit = computed(() => {

package/app/composables/api/assistant.ts

@@ -6,9 +6,11 @@ import type { ApiContext } from './context'
 export function assistantApi({ send, ws }: ApiContext) {
   return {
     // Whether a model is wired and which actions this deployment offers. Read before the prompt
-    // box is shown, so an unconfigured deployment says so instead of failing on submit.
-    getAssistantCapability: (workspaceId: string) =>
-      send(getAssistantCapabilityContract, { pathPrefix: ws(workspaceId) }),
+    // box is shown, so an unconfigured deployment says so instead of failing on submit. `signal`
+    // is what lets the store put a deadline on it: the client sets no timeout of its own, and a
+    // read that never settles is a modal with no answer, no failure and so no retry either.
+    getAssistantCapability: (workspaceId: string, signal?: AbortSignal) =>
+      send(getAssistantCapabilityContract, { pathPrefix: ws(workspaceId), signal }),
 
     // Run one turn. A live model call plus a board write, so it can take a couple of seconds:
     // the modal shows progress and the outcome is rendered from the returned data.

package/app/composables/useArtifactBlobs.ts

@@ -1,4 +1,5 @@
 import { reactive } from 'vue'
+import type { LoadState } from '~/types/load-state'
 import { useWorkspaceStore } from '~/stores/workspace'
 
 /**
@@ -15,7 +16,7 @@ import { useWorkspaceStore } from '~/stores/workspace'
  * Both the visual-confirmation gate and the test-report window use this, so neither has to
  * own blob plumbing or depend on the other's Pinia store.
  */
-export type ArtifactBlobStatus = 'idle' | 'loading' | 'ready' | 'error'
+export type ArtifactBlobStatus = LoadState
 
 export function useArtifactBlobs() {
   const ws = useWorkspaceStore()

package/app/composables/useModalOpen.spec.ts

@@ -0,0 +1,51 @@
+import { describe, expect, it, vi } from 'vitest'
+import { effectScope, nextTick, ref } from 'vue'
+import { onModalOpen } from './useModalOpen'
+
+/**
+ * Register `onModalOpen` with `open` already at `mountedOpen`, which is what a modal's setup does.
+ * That first value is the whole point: the page mounts most panels only WHILE their flag is set,
+ * so a modal's `open` is already `true` by the time its own setup runs.
+ */
+function register(mountedOpen: boolean) {
+  const open = ref(mountedOpen)
+  const ran = vi.fn()
+  const scope = effectScope()
+  scope.run(() => onModalOpen(open, ran))
+  return { open, ran, stop: () => scope.stop() }
+}
+
+describe('onModalOpen', () => {
+  it('runs on the render the panel MOUNTS on, when it mounts already open', () => {
+    // The bug this exists to make unrepresentable: a change-only `watch(open)` never fires for a
+    // `v-if`-mounted modal, so whatever the body seeds (a picker's default, the read that fills a
+    // catalog) never happens and the panel opens with an unselected control and a dead confirm.
+    const { ran, stop } = register(true)
+
+    expect(ran).toHaveBeenCalledTimes(1)
+    stop()
+  })
+
+  it('does not run for a panel that is mounted CLOSED', () => {
+    // The always-mounted half of the SPA. The same call has to be correct there, or this could not
+    // be the one thing every site uses and each author would be back to deciding per site.
+    const { ran, stop } = register(false)
+
+    expect(ran).not.toHaveBeenCalled()
+    stop()
+  })
+
+  it('runs again on each later open, and never on a close', async () => {
+    const { open, ran, stop } = register(false)
+
+    open.value = true
+    await nextTick()
+    open.value = false
+    await nextTick()
+    open.value = true
+    await nextTick()
+
+    expect(ran).toHaveBeenCalledTimes(2)
+    stop()
+  })
+})

package/app/composables/useModalOpen.ts

@@ -0,0 +1,31 @@
+import { watch } from 'vue'
+import type { WatchSource } from 'vue'
+
+/**
+ * Run `fn` whenever a modal opens, INCLUDING the render it mounts on.
+ *
+ * This exists because `watch(open, (isOpen) => { if (isOpen) … })` is wrong in this SPA and reads
+ * as right. The page mounts most panels only WHILE their open flag is set
+ * (`<AssistantModal v-if="ui.assistantOpen" />`), so `open` is already `true` when the component
+ * sets up and a change-only watcher never fires at all: whatever the body seeds (a picker's
+ * default, the read that fills a catalog) never happens, and the panel opens with an unselected
+ * control and a confirm button that cannot be pressed. Nothing throws, which is why it survived in
+ * several modals at once.
+ *
+ * `{ immediate: true }` is the whole fix, and a shared helper is how it stops being per-site
+ * knowledge: a panel that IS always mounted passes a `false` on that first run and the body is
+ * skipped, so this is correct either way and nobody has to know which kind they are writing.
+ *
+ * Only for work done on the way IN. A watcher acting on the CLOSE edge (emitting `close`, revoking
+ * object URLs) stays a plain `watch`: it has nothing to do at mount, and running it there would
+ * announce a close that never happened.
+ */
+export function onModalOpen(open: WatchSource<boolean>, fn: () => void): void {
+  watch(
+    open,
+    (isOpen) => {
+      if (isOpen) fn()
+    },
+    { immediate: true },
+  )
+}

package/app/modular/panels/inspector.logic.spec.ts

@@ -39,6 +39,7 @@ describe('inspector panel group', () => {
       'service-connections',
       'service-test-config',
       'service-test-secrets',
+      'service-testing-context',
       'service-fragments',
       'service-release-health',
       'service-validation-checks',
@@ -58,6 +59,7 @@ describe('inspector panel group', () => {
       'container-summary',
       'service-test-config',
       'service-test-secrets',
+      'service-testing-context',
       'service-fragments',
       'service-release-health',
       'service-validation-checks',
@@ -70,6 +72,7 @@ describe('inspector panel group', () => {
       'frontend-config',
       'service-test-config',
       'service-test-secrets',
+      'service-testing-context',
       'service-fragments',
       'service-release-health',
       'service-validation-checks',

package/app/modular/panels/inspector.logic.ts

@@ -53,6 +53,7 @@ export const INSPECTOR_PANEL_IDS = [
   'service-connections',
   'service-test-config',
   'service-test-secrets',
+  'service-testing-context',
   'service-fragments',
   'service-release-health',
   'service-validation-checks',
@@ -146,6 +147,10 @@ export const INSPECTOR_PANEL_SPECS: readonly InspectorPanelSpec[] = [
   { id: 'service-connections', order: 130, when: (b) => isFrame(b) && b.type === 'service' },
   { id: 'service-test-config', order: 140, when: isDeployableFrame },
   { id: 'service-test-secrets', order: 150, when: isDeployableFrame },
+  // Immediately after the credentials: the prose that says what to DO with them, and the other
+  // half of what a tester is handed about this service. Same gate for the same reason (a doc
+  // repo runs no tester at all).
+  { id: 'service-testing-context', order: 155, when: isDeployableFrame },
   { id: 'service-fragments', order: 160, when: isFrame },
   { id: 'service-release-health', order: 170, when: isDeployableFrame },
   // Pre-PR validation checks: the commands the harness runs before opening this service's PRs.

package/app/modular/panels/inspector.ts

@@ -28,6 +28,7 @@ import FrontendConfig from '~/components/panels/inspector/FrontendConfig.vue'
 import ServiceConnections from '~/components/panels/inspector/ServiceConnections.vue'
 import ServiceTestConfig from '~/components/panels/inspector/ServiceTestConfig.vue'
 import ServiceTestSecrets from '~/components/panels/inspector/ServiceTestSecrets.vue'
+import ServiceTestingContext from '~/components/panels/inspector/ServiceTestingContext.vue'
 import ServiceFragments from '~/components/panels/inspector/ServiceFragments.vue'
 import ServiceReleaseHealthConfig from '~/components/panels/inspector/ServiceReleaseHealthConfig.vue'
 import ServiceValidationConfig from '~/components/panels/inspector/ServiceValidationConfig.vue'
@@ -83,6 +84,7 @@ const COMPONENTS: Record<InspectorPanelId, Component> = {
   'service-connections': ServiceConnections,
   'service-test-config': ServiceTestConfig,
   'service-test-secrets': ServiceTestSecrets,
+  'service-testing-context': ServiceTestingContext,
   'service-fragments': ServiceFragments,
   'service-release-health': ServiceReleaseHealthConfig,
   'service-validation-checks': ServiceValidationConfig,

package/app/stores/assistant.spec.ts

@@ -0,0 +1,183 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest'
+import { useAssistantStore } from '~/stores/assistant'
+import { useWorkspaceStore } from '~/stores/workspace'
+import { ApiError } from '~/composables/api/errors'
+import type { AssistantCapability } from '~/types/domain'
+
+// What the modal reads to decide whether it may offer the prompt box, and whether that box may be
+// submitted. The capability's own ANSWER is two independent bits (is a model wired, and is there
+// anything for it to do); on their own they cannot say whether anyone has asked yet, which is a
+// third fact the modal has to render differently from both.
+
+/**
+ * Stub `useApi` ONCE, behind a handler the test can swap. The store resolves `useApi()` at setup,
+ * so re-stubbing after `useAssistantStore()` would leave it holding the first stub for ever.
+ *
+ * The handler is given the abort signal the store attaches its deadline to, so a test can assert
+ * on what a timed-out read does to the request as well as to the state.
+ */
+function stubApi(): {
+  store: ReturnType<typeof useAssistantStore>
+  serve: (fn: (signal: AbortSignal) => Promise<AssistantCapability>) => void
+} {
+  let handler: (signal: AbortSignal) => Promise<AssistantCapability> = () =>
+    Promise.resolve({ available: true, actions: ['declare-service-dependency'] })
+  vi.stubGlobal('useApi', () => ({
+    getAssistantCapability: (_ws: string, signal: AbortSignal) => handler(signal),
+  }))
+  return {
+    store: useAssistantStore(),
+    serve: (fn) => {
+      handler = fn
+    },
+  }
+}
+
+const failing = (status = 503) =>
+  Promise.reject(new ApiError(status, { error: { code: 'unavailable', message: 'nope' } }))
+
+describe('assistant store: the capability read', () => {
+  beforeEach(() => {
+    useWorkspaceStore().workspaceId = 'ws1'
+  })
+
+  it('starts idle, which is not the same fact as unavailable', () => {
+    const { store } = stubApi()
+
+    expect(store.capabilityRead).toBe('idle')
+    expect(store.capability).toBeNull()
+    expect(store.available).toBe(false)
+  })
+
+  it('holds `loading` while the read is in flight', async () => {
+    const { store, serve } = stubApi()
+    let answer!: (capability: AssistantCapability) => void
+    serve(() => new Promise((resolve) => (answer = resolve)))
+
+    const inFlight = store.loadCapability()
+    expect(store.capabilityRead).toBe('loading')
+
+    answer({ available: true, actions: ['declare-service-dependency'] })
+    await inFlight
+
+    expect(store.capabilityRead).toBe('ready')
+    expect(store.actions).toEqual(['declare-service-dependency'])
+  })
+
+  it('KEEPS the answer it holds while a re-read is in flight', async () => {
+    // Re-opening the modal re-reads. Clearing the answer for the duration would replace the box
+    // with a waiting state on every open, for a fact the store can already state.
+    const { store, serve } = stubApi()
+    await store.loadCapability()
+
+    serve(() => new Promise(() => {}))
+    void store.loadCapability()
+
+    expect(store.capabilityRead).toBe('loading')
+    expect(store.available).toBe(true)
+    expect(store.actions).toEqual(['declare-service-dependency'])
+  })
+
+  it('records a read that answered "no model" as read, so it can be told from an outage', async () => {
+    const { store, serve } = stubApi()
+    serve(() => Promise.resolve({ available: false, actions: [] }))
+
+    await store.loadCapability()
+
+    expect(store.capabilityRead).toBe('ready')
+    expect(store.available).toBe(false)
+  })
+
+  it('marks a FAILED read as failed and does not throw', async () => {
+    // The failure is REPORTED by the panel this state puts on screen, which is where the retry
+    // lives too. Throwing it as well would have the modal toast a second, non-dismissing copy of
+    // the same sentence over that panel, once per retry.
+    const { store, serve } = stubApi()
+    serve(() => failing())
+
+    await expect(store.loadCapability()).resolves.toBeUndefined()
+
+    expect(store.capabilityRead).toBe('error')
+    expect(store.capability).toBeNull()
+    expect(store.available).toBe(false)
+  })
+
+  it('drops a previous answer when a later read fails', async () => {
+    // A retry that fails must not leave the box open on the strength of the read before it: the
+    // deployment's model may have gone away with whatever took the endpoint down.
+    const { store, serve } = stubApi()
+    serve(() => Promise.resolve({ available: true, actions: ['add-service-from-repo'] }))
+    await store.loadCapability()
+
+    serve(() => failing(500))
+    await store.loadCapability()
+
+    expect(store.capability).toBeNull()
+    expect(store.actions).toEqual([])
+  })
+
+  it('recovers on a retry that answers', async () => {
+    const { store, serve } = stubApi()
+    serve(() => failing(502))
+    await store.loadCapability()
+
+    serve(() => Promise.resolve({ available: true, actions: ['create-task-from-issue'] }))
+    await store.loadCapability()
+
+    expect(store.capabilityRead).toBe('ready')
+    expect(store.available).toBe(true)
+  })
+
+  it('settles overlapping reads in the order they STARTED, not the order they answer', async () => {
+    // A slow success that lands after the fast failure which superseded it would otherwise
+    // re-offer the box on an answer older than the failure that replaced it.
+    const { store, serve } = stubApi()
+    let answerSlow!: (capability: AssistantCapability) => void
+    serve(() => new Promise((resolve) => (answerSlow = resolve)))
+    const slow = store.loadCapability()
+
+    serve(() => failing())
+    await store.loadCapability()
+    expect(store.capabilityRead).toBe('error')
+
+    answerSlow({ available: true, actions: ['declare-service-dependency'] })
+    await slow
+
+    expect(store.capabilityRead).toBe('error')
+    expect(store.capability).toBeNull()
+  })
+})
+
+describe('assistant store: the capability read deadline', () => {
+  beforeEach(() => {
+    useWorkspaceStore().workspaceId = 'ws1'
+    vi.useFakeTimers()
+  })
+  afterEach(() => {
+    vi.useRealTimers()
+  })
+
+  it('fails a read that never settles, and ABORTS the request it gave up on', async () => {
+    // The shared client sets no timeout, so a connection accepted and never answered would leave
+    // the modal waiting for ever: no answer, no failure, and so no retry either, since the retry
+    // is what a failed read puts on screen.
+    const { store, serve } = stubApi()
+    let aborted = false
+    serve(
+      (signal) =>
+        new Promise((_resolve, reject) => {
+          signal.addEventListener('abort', () => {
+            aborted = true
+            reject(new Error('aborted'))
+          })
+        }),
+    )
+
+    const read = store.loadCapability()
+    await vi.advanceTimersByTimeAsync(10_000)
+    await read
+
+    expect(aborted).toBe(true)
+    expect(store.capabilityRead).toBe('error')
+  })
+})