@cat-factory/app 0.259.3 → 0.261.0

package/app/utils/edgeSegments.spec.ts

@@ -0,0 +1,49 @@
+import { describe, it, expect } from 'vitest'
+import { shallowRef } from 'vue'
+import { commitSegments, sameSegments, type EdgeSegment } from './edgeSegments'
+
+const line = (over: Partial<EdgeSegment> = {}): EdgeSegment => ({
+  id: 'a__b',
+  x1: 0,
+  y1: 0,
+  x2: 10,
+  y2: 10,
+  ...over,
+})
+
+describe('sameSegments', () => {
+  it('accepts a freshly measured list that resolved to the same overlay', () => {
+    expect(sameSegments([line()], [line()])).toBe(true)
+  })
+
+  it('rejects a moved endpoint, however slightly', () => {
+    expect(sameSegments([line()], [line({ y2: 10.5 })])).toBe(false)
+  })
+
+  it('rejects a changed link set', () => {
+    expect(sameSegments([line()], [])).toBe(false)
+    expect(sameSegments([line()], [line({ id: 'a__c' })])).toBe(false)
+  })
+
+  it('rejects a dependency whose source finished, since it restyles the arrow', () => {
+    expect(sameSegments([line({ done: false })], [line({ done: true })])).toBe(false)
+  })
+})
+
+describe('commitSegments', () => {
+  it('publishes a changed list and reports it', () => {
+    const target = shallowRef<EdgeSegment[]>([line()])
+    const next = [line({ x2: 20 })]
+    expect(commitSegments(target, next)).toBe(true)
+    expect(target.value).toBe(next)
+  })
+
+  it('leaves the published array untouched when nothing moved', () => {
+    const published = [line()]
+    const target = shallowRef<EdgeSegment[]>(published)
+    // Identity has to survive, not just the values: reassigning an equal-but-new array is
+    // what re-rendered the whole overlay on every frame of an idle board.
+    expect(commitSegments(target, [line()])).toBe(false)
+    expect(target.value).toBe(published)
+  })
+})

package/app/utils/edgeSegments.ts

@@ -0,0 +1,49 @@
+import type { Ref } from 'vue'
+
+/**
+ * One drawable link on the board's screen-space overlay: a border-to-border line between two
+ * block cards. `done` rides only on dependency edges, where it picks the stroke and arrowhead.
+ */
+export type EdgeSegment = {
+  id: string
+  x1: number
+  y1: number
+  x2: number
+  y2: number
+  done?: boolean
+}
+
+/** Whether two resolved segment lists would draw exactly the same overlay. */
+export function sameSegments(a: readonly EdgeSegment[], b: readonly EdgeSegment[]): boolean {
+  if (a.length !== b.length) return false
+  for (let i = 0; i < a.length; i++) {
+    const left = a[i]!
+    const right = b[i]!
+    if (
+      left.id !== right.id ||
+      left.x1 !== right.x1 ||
+      left.y1 !== right.y1 ||
+      left.x2 !== right.x2 ||
+      left.y2 !== right.y2 ||
+      left.done !== right.done
+    ) {
+      return false
+    }
+  }
+  return true
+}
+
+/**
+ * Publish a freshly measured list, and report whether it moved anything. Writing an
+ * equal-but-new array every frame is what re-rendered the whole overlay 60 times a second on
+ * a board where nothing was moving, and it is also the signal the settling frame loop reads
+ * to decide it can park.
+ *
+ * The target is a `shallowRef`: the lists are replaced wholesale, so deep-proxying every
+ * segment object would be pure overhead.
+ */
+export function commitSegments(target: Ref<EdgeSegment[]>, next: EdgeSegment[]): boolean {
+  if (sameSegments(target.value, next)) return false
+  target.value = next
+  return true
+}

package/app/utils/monorepoImport.spec.ts

@@ -0,0 +1,120 @@
+import { describe, expect, it } from 'vitest'
+import type { CreatedMonorepoFrame } from './monorepoImport'
+import {
+  canDesignateFrontend,
+  planFrontendConfigPatches,
+  planMonorepoImport,
+} from './monorepoImport'
+
+/** Pair a plan with block ids, the way the modal does as each create call returns. */
+function created(entries: ReturnType<typeof planMonorepoImport>): CreatedMonorepoFrame[] {
+  return entries.map((entry, i) => ({ blockId: `blk_${i}`, entry }))
+}
+
+describe('canDesignateFrontend', () => {
+  it('offers the mark for two or more backend services', () => {
+    expect(canDesignateFrontend('service', 2)).toBe(true)
+    expect(canDesignateFrontend('service', 5)).toBe(true)
+  })
+
+  it('withholds it below two directories: there is no rest to bind to', () => {
+    expect(canDesignateFrontend('service', 1)).toBe(false)
+    expect(canDesignateFrontend('service', 0)).toBe(false)
+  })
+
+  it('withholds it for roles a backend binding cannot point at', () => {
+    // A binding's `service` source names a `service` frame; a library/document frame is not one,
+    // and when everything is already a frontend the mark divides nothing.
+    expect(canDesignateFrontend('library', 3)).toBe(false)
+    expect(canDesignateFrontend('document', 3)).toBe(false)
+    expect(canDesignateFrontend('frontend', 3)).toBe(false)
+  })
+})
+
+describe('planMonorepoImport', () => {
+  it('creates the marked directory as a frontend and the rest with the picked role', () => {
+    expect(
+      planMonorepoImport(['apps/web', 'services/api', 'services/auth'], 'service', 'apps/web'),
+    ).toEqual([
+      { directory: 'apps/web', type: 'frontend', designatedFrontend: true },
+      { directory: 'services/api', type: 'service', designatedFrontend: false },
+      { directory: 'services/auth', type: 'service', designatedFrontend: false },
+    ])
+  })
+
+  it('keeps the picked order, wherever the marked directory sits in it', () => {
+    const plan = planMonorepoImport(['services/api', 'apps/web'], 'service', 'apps/web')
+    expect(plan.map((e) => e.directory)).toEqual(['services/api', 'apps/web'])
+    expect(plan[1]?.type).toBe('frontend')
+  })
+
+  it('gives every directory the picked role when nothing is marked', () => {
+    expect(planMonorepoImport(['a', 'b'], 'service', undefined)).toEqual([
+      { directory: 'a', type: 'service', designatedFrontend: false },
+      { directory: 'b', type: 'service', designatedFrontend: false },
+    ])
+  })
+
+  it('ignores a mark on a directory that is not being created', () => {
+    // The cart entry was removed (or was already on the board and got filtered out) after being
+    // marked. Designating nothing is right; promoting some other frame to frontend would not be.
+    expect(planMonorepoImport(['a', 'b'], 'service', 'apps/web')).toEqual([
+      { directory: 'a', type: 'service', designatedFrontend: false },
+      { directory: 'b', type: 'service', designatedFrontend: false },
+    ])
+  })
+
+  it('designates nobody when the whole cart is imported under the frontend role', () => {
+    // Every entry is `type: 'frontend'` here, so the flag is the ONLY thing that separates
+    // "the app the others talk to" from "a cart of frontends". A mark is never on offer for this
+    // role (`canDesignateFrontend`), and one carried over from a role change must not act.
+    const plan = planMonorepoImport(['apps/web', 'apps/admin'], 'frontend', 'apps/web')
+    expect(plan.every((e) => e.type === 'frontend')).toBe(true)
+    expect(plan.some((e) => e.designatedFrontend)).toBe(false)
+  })
+})
+
+describe('planFrontendConfigPatches', () => {
+  it('binds the designated frontend to every other frame created beside it', () => {
+    const plan = planMonorepoImport(
+      ['apps/web', 'services/api', 'services/auth'],
+      'service',
+      'apps/web',
+    )
+    expect(planFrontendConfigPatches(created(plan))).toEqual([
+      {
+        blockId: 'blk_0',
+        config: {
+          directory: 'apps/web',
+          backendBindings: [
+            { envVar: '', source: { kind: 'service', serviceBlockId: 'blk_1' } },
+            { envVar: '', source: { kind: 'service', serviceBlockId: 'blk_2' } },
+          ],
+        },
+      },
+    ])
+  })
+
+  it('leaves every env var name empty rather than inventing one', () => {
+    const plan = planMonorepoImport(['apps/web', 'services/api'], 'service', 'apps/web')
+    const [patch] = planFrontendConfigPatches(created(plan))
+    expect(patch?.config.backendBindings.every((b) => b.envVar === '')).toBe(true)
+  })
+
+  it('carries the subdirectory to every frontend frame, designated or not', () => {
+    // `frontendConfig.directory` is what the harness's install/build/serve reads; the service-level
+    // directory that scopes an agent's checkout is a different field and does not stand in. A cart
+    // imported under the `frontend` role has no designated frame, and every frame in it would
+    // otherwise build the repo root.
+    const plan = planMonorepoImport(['apps/web', 'apps/admin'], 'frontend', undefined)
+    expect(planFrontendConfigPatches(created(plan))).toEqual([
+      { blockId: 'blk_0', config: { directory: 'apps/web', backendBindings: [] } },
+      { blockId: 'blk_1', config: { directory: 'apps/admin', backendBindings: [] } },
+    ])
+  })
+
+  it('patches nothing when the import creates no frontend frame', () => {
+    const plan = planMonorepoImport(['services/api', 'services/auth'], 'service', undefined)
+    expect(planFrontendConfigPatches(created(plan))).toEqual([])
+  })
+})

package/app/utils/monorepoImport.ts

@@ -0,0 +1,154 @@
+import type { FrameRepoType, FrontendBackendBinding, FrontendConfig } from '~/types/domain'
+
+/**
+ * Planning rules for a monorepo import: turning the picked subdirectories into the frames to
+ * create, and the `frontendConfig` patches those frames owe once they have ids.
+ *
+ * The relationship model already exists: a `frontend` frame's `backendBindings` ARE the
+ * frontend→service board link (`@cat-factory/contracts`'s `frontendBackendBindingSchema`), the
+ * frontend counterpart of a service frame's `serviceConnections`. All this adds is declaring it
+ * at IMPORT time, while the user still has the whole selection in front of them, instead of
+ * making them open the frontend's inspector afterwards and re-pick services one row at a time.
+ *
+ * Pure and frontend-only: the modal is the sole caller, so these rules stay here rather than in
+ * contracts (nothing on the backend has to agree about them, since it sees ordinary frame creates
+ * and ordinary `frontendConfig` patches).
+ */
+
+/**
+ * Whether the import may offer a frontend mark for the directories it is about to create.
+ *
+ * Two conditions, both about the mark meaning something:
+ *
+ * - The picked role is `service`. A backend binding may only point at a `service` frame, so
+ *   marking a frontend among libraries or document repos would wire nothing, and when the role
+ *   already IS `frontend`, every frame is one and singling one out says nothing.
+ * - At least two directories are being CREATED. The mark divides that set into "the frontend" and
+ *   "the backends it talks to"; with one there is no rest to bind to, and the role select above
+ *   already covers importing a lone frontend. The count is of what the add will actually create,
+ *   never of the raw cart: a cart entry whose frame already exists (a retry after a partial
+ *   failure) is filtered out of the import, so counting it would offer a mark that binds nothing.
+ */
+export function canDesignateFrontend(type: FrameRepoType, directoryCount: number): boolean {
+  return type === 'service' && directoryCount >= 2
+}
+
+/** One frame the import will create: its repo subdirectory and the role it takes. */
+export interface MonorepoImportEntry {
+  /** Repo-root-relative subdirectory the frame is pinned to. */
+  directory: string
+  /** The frame's repo role: `frontend` for the marked directory, the picked role for the rest. */
+  type: FrameRepoType
+  /**
+   * Whether this is the ONE directory marked as the frontend for the others, so its config binds
+   * every other frame the import creates.
+   *
+   * Stated here rather than left to be re-derived from `type`, because `type === 'frontend'` does
+   * NOT identify it: when the picked ROLE is `frontend`, every entry carries that type and no mark
+   * was ever on offer (see {@link canDesignateFrontend}), so a type test picks an arbitrary frame
+   * and binds it to a backend set that does not exist.
+   */
+  designatedFrontend: boolean
+}
+
+/**
+ * The frames to create for a monorepo import, in the order the user picked them.
+ *
+ * A `frontendDirectory` is honoured only when the mark would MEAN something, and this is the one
+ * place that decides. Two ways it can be stale, both of which designate nothing rather than
+ * promoting some other frame:
+ *
+ * - The role or the size of the import no longer admits a mark ({@link canDesignateFrontend}), so
+ *   the picker is not even on screen. Enforced here rather than trusted to the caller, because a
+ *   caller that re-derives the condition can drift from it.
+ * - The marked directory is not among the ones being created: it was removed from the cart, or an
+ *   earlier add already created it.
+ */
+export function planMonorepoImport(
+  directories: readonly string[],
+  backendType: FrameRepoType,
+  frontendDirectory: string | undefined,
+): MonorepoImportEntry[] {
+  const marked =
+    canDesignateFrontend(backendType, directories.length) && frontendDirectory !== undefined
+  const frontend = marked && directories.includes(frontendDirectory) ? frontendDirectory : undefined
+  return directories.map((directory) => ({
+    directory,
+    type: directory === frontend ? 'frontend' : backendType,
+    designatedFrontend: directory === frontend,
+  }))
+}
+
+/** A frame the import created, paired with the plan entry it was created from. */
+export interface CreatedMonorepoFrame {
+  /** Id of the block the create call minted. */
+  blockId: string
+  /** The entry that produced it, carrying its role and whether it is the designated frontend. */
+  entry: MonorepoImportEntry
+}
+
+/** One `frontendConfig` write the import owes a frame it created. */
+export interface FrontendConfigPatch {
+  blockId: string
+  config: FrontendConfig
+}
+
+/**
+ * The `frontendConfig` each created `frontend` frame needs, once the create calls have minted
+ * their ids.
+ *
+ * EVERY frontend frame gets one, not only a designated one, because the patch carries two
+ * separable facts:
+ *
+ * - **`directory`, for all of them.** A frame's monorepo subdirectory is a SERVICE-level fact (the
+ *   repo projection's `directory`, which scopes an agent's checkout); the harness's frontend
+ *   install/build/serve reads `frontendConfig.directory` instead, and defaults to the repo root
+ *   when it is absent. So a monorepo frontend whose config does not repeat it builds the wrong
+ *   tree, silently. That is true of every frontend frame an import creates, including a whole cart
+ *   imported under the `frontend` role, where no mark is ever offered. The user picked the
+ *   directory, so it is copied, never guessed.
+ * - **`backendBindings`, for the designated one only.** The mark is what says "these other frames
+ *   are the backends this app talks to"; an undesignated frontend frame is bound to nothing, which
+ *   is the same empty list the inspector would have shown.
+ */
+export function planFrontendConfigPatches(
+  created: readonly CreatedMonorepoFrame[],
+): FrontendConfigPatch[] {
+  const designated = created.find((frame) => frame.entry.designatedFrontend)
+  const backendBlockIds = designated
+    ? created.filter((frame) => frame !== designated).map((frame) => frame.blockId)
+    : []
+  return created
+    .filter((frame) => frame.entry.type === 'frontend')
+    .map((frame) => ({
+      blockId: frame.blockId,
+      config: frontendConfigForImport(
+        frame.entry.directory,
+        frame === designated ? backendBlockIds : [],
+      ),
+    }))
+}
+
+/**
+ * The `frontendConfig` for one created frontend frame: where the app lives in the repo, and one
+ * backend binding per frame it was marked the frontend for.
+ *
+ * **`envVar` is left EMPTY.** The env var a frontend reads for an upstream URL is a fact about the
+ * frontend's own source, which an import that never looks inside the repo cannot know, and
+ * inventing a plausible name (`PUB_API_URL`) would inject a variable nothing reads while looking
+ * configured. Empty is the contract's designed inert state: the job-body builder filters those
+ * bindings out of the injected env, `duplicateBindingEnvVars` ignores them, `frontendOriginsForService`
+ * skips them, and the board still draws the frontend→service edge. What the import DOES know (which
+ * services this frontend talks to) is recorded; the names are left for the inspector's "Detect from
+ * repo" (which reads the repo's dotenv examples) or the user, and the modal says so.
+ */
+function frontendConfigForImport(
+  directory: string,
+  backendBlockIds: readonly string[],
+): FrontendConfig {
+  const backendBindings: FrontendBackendBinding[] = backendBlockIds.map((serviceBlockId) => ({
+    envVar: '',
+    source: { kind: 'service', serviceBlockId },
+  }))
+  return { directory, backendBindings }
+}

package/app/utils/postSignIn.spec.ts

@@ -0,0 +1,29 @@
+import { describe, expect, it } from 'vitest'
+import { postSignInUrl } from './postSignIn'
+
+// The regression this exists for: every sign-in path reloaded to `location.pathname`, so a flow
+// whose subject rides the query string lost it the moment a person signed in. The MCP consent
+// screen is the one that fails hardest, and signing in first is the ordinary way a first connect
+// goes, so the loss is on the common path rather than an edge of it.
+
+describe('postSignInUrl', () => {
+  it('keeps the query string the destination needs', () => {
+    expect(postSignInUrl({ pathname: '/mcp-authorize', search: '?request=sealed-value' })).toBe(
+      '/mcp-authorize?request=sealed-value',
+    )
+  })
+
+  it('drops the invite token, which the signup call already spent', () => {
+    // Not a matter of tidiness: a consumed invite left in the address bar is a token in every
+    // place a URL gets pasted, and it buys the reader nothing because it no longer works.
+    expect(postSignInUrl({ pathname: '/', search: '?invite=tok_1' })).toBe('/')
+    expect(postSignInUrl({ pathname: '/', search: '?invite=tok_1&ws=ws_9' })).toBe('/?ws=ws_9')
+  })
+
+  it('answers a bare path unchanged, and drops a fragment', () => {
+    expect(postSignInUrl({ pathname: '/', search: '' })).toBe('/')
+    // The fragment is absent by construction: it is never read here, so a stale one would only
+    // scroll the freshly booted app to an anchor the previous screen owned.
+    expect(postSignInUrl({ pathname: '/boards', search: '?a=1' })).toBe('/boards?a=1')
+  })
+})

package/app/utils/postSignIn.ts

@@ -0,0 +1,29 @@
+/**
+ * Where the browser reloads to once a sign-in succeeds.
+ *
+ * Every sign-in path reloads rather than routing, because the app has to boot with the new session
+ * rather than patch itself around it. What it reloads TO is the question this answers, and the
+ * naive `location.pathname` gets it wrong: the login screen renders at whatever URL the person
+ * arrived at, so the query string belongs to the destination, not to the sign-in. Dropping it
+ * silently strands any flow that carries its subject there. The MCP consent screen is the case that
+ * bites hardest (`/mcp-authorize?request=<sealed>`): signing in first is the COMMON path for a
+ * first connect, and landing back with no `request` leaves a person looking at "this page was
+ * opened without an authorization request" with no way forward except restarting from the host.
+ *
+ * `invite` is the one parameter dropped, and it is dropped because it has already been SPENT: the
+ * signup call consumed it, so keeping it would leave a consumed token in the address bar and in
+ * every place a URL gets pasted. Everything else is the destination's business, not this module's,
+ * which is why the rule is a named exception rather than an allowlist nobody remembers to extend.
+ */
+const SPENT_PARAMS = ['invite']
+
+/**
+ * The post-sign-in URL for one location: its path, its query minus the spent parameters, and no
+ * fragment (nothing in this app puts state there, and a stale one would scroll to nowhere).
+ */
+export function postSignInUrl(location: { pathname: string; search: string }): string {
+  const params = new URLSearchParams(location.search)
+  for (const spent of SPENT_PARAMS) params.delete(spent)
+  const query = params.toString()
+  return query ? `${location.pathname}?${query}` : location.pathname
+}

package/app/utils/settlingLoop.spec.ts

@@ -0,0 +1,236 @@
+import { describe, it, expect } from 'vitest'
+import { createSettlingLoop, type FrameScheduler } from './settlingLoop'
+
+/** A hand-driven frame clock: `flush()` runs exactly one scheduled frame. */
+function fakeScheduler() {
+  let nextHandle = 1
+  const pending = new Map<number, () => void>()
+  const scheduler: FrameScheduler = {
+    schedule(run) {
+      const handle = nextHandle++
+      pending.set(handle, run)
+      return handle
+    },
+    cancel(handle) {
+      pending.delete(handle)
+    },
+  }
+  return {
+    scheduler,
+    pending: () => pending.size,
+    /** Run every currently scheduled frame; frames they schedule wait for the next flush. */
+    flush() {
+      const due = [...pending.entries()]
+      pending.clear()
+      for (const [, run] of due) run()
+    },
+  }
+}
+
+describe('createSettlingLoop', () => {
+  it('does not run until poked', () => {
+    const clock = fakeScheduler()
+    let frames = 0
+    const loop = createSettlingLoop({
+      compute: () => {
+        frames++
+        return false
+      },
+      scheduler: clock.scheduler,
+      settleFrames: 3,
+    })
+
+    expect(loop.awake()).toBe(false)
+    clock.flush()
+    expect(frames).toBe(0)
+  })
+
+  it('keeps running while the output changes, and parks once it holds still', () => {
+    const clock = fakeScheduler()
+    let changed = true
+    let frames = 0
+    const loop = createSettlingLoop({
+      compute: () => {
+        frames++
+        return changed
+      },
+      scheduler: clock.scheduler,
+      settleFrames: 3,
+    })
+
+    loop.poke()
+    for (let i = 0; i < 10; i++) clock.flush()
+    expect(frames).toBe(10)
+    expect(loop.awake()).toBe(true)
+
+    // The animation ends: three unchanged frames later the loop is parked and the frame
+    // count stops moving no matter how many times the clock ticks.
+    changed = false
+    clock.flush()
+    clock.flush()
+    expect(loop.awake()).toBe(true)
+    clock.flush()
+    expect(loop.awake()).toBe(false)
+
+    const settledAt = frames
+    for (let i = 0; i < 10; i++) clock.flush()
+    expect(frames).toBe(settledAt)
+  })
+
+  it('runs the settle tail after a poke that changed nothing, then parks', () => {
+    const clock = fakeScheduler()
+    let frames = 0
+    const loop = createSettlingLoop({
+      compute: () => {
+        frames++
+        return false
+      },
+      scheduler: clock.scheduler,
+      settleFrames: 3,
+    })
+
+    // A signal fires one frame BEFORE the transition it starts produces geometry, so a wake
+    // that measures no change still owes the tail rather than parking immediately.
+    loop.poke()
+    clock.flush()
+    expect(loop.awake()).toBe(true)
+    clock.flush()
+    clock.flush()
+    expect(frames).toBe(3)
+    expect(loop.awake()).toBe(false)
+  })
+
+  it('wakes a parked loop again on the next poke', () => {
+    const clock = fakeScheduler()
+    let frames = 0
+    const loop = createSettlingLoop({
+      compute: () => {
+        frames++
+        return false
+      },
+      scheduler: clock.scheduler,
+      settleFrames: 1,
+    })
+
+    loop.poke()
+    clock.flush()
+    expect(loop.awake()).toBe(false)
+
+    loop.poke()
+    clock.flush()
+    expect(frames).toBe(2)
+  })
+
+  it('restarts the countdown on a poke without scheduling a second frame', () => {
+    const clock = fakeScheduler()
+    let frames = 0
+    const loop = createSettlingLoop({
+      compute: () => {
+        frames++
+        return false
+      },
+      scheduler: clock.scheduler,
+      settleFrames: 2,
+    })
+
+    loop.poke()
+    loop.poke()
+    loop.poke()
+    expect(clock.pending()).toBe(1)
+    clock.flush()
+    expect(frames).toBe(1)
+  })
+
+  it('does not schedule a second frame when the compute itself pokes', () => {
+    const clock = fakeScheduler()
+    let frames = 0
+    // A compute that writes to a store can wake watchers that poke back synchronously. That
+    // must reset the countdown, not double the frame rate.
+    const loop = createSettlingLoop({
+      compute: () => {
+        frames++
+        loop.poke()
+        return false
+      },
+      scheduler: clock.scheduler,
+      settleFrames: 2,
+    })
+
+    loop.poke()
+    for (let i = 0; i < 5; i++) {
+      expect(clock.pending()).toBe(1)
+      clock.flush()
+    }
+    expect(frames).toBe(5)
+  })
+
+  it('parks a throwing compute so a later poke still wakes it', () => {
+    const clock = fakeScheduler()
+    let frames = 0
+    let broken = true
+    const loop = createSettlingLoop({
+      compute: () => {
+        frames++
+        if (broken) throw new Error('measured a card that just unmounted')
+        return false
+      },
+      scheduler: clock.scheduler,
+      settleFrames: 3,
+    })
+
+    // The frame the throw escaped from is already spent. Staying awake would leave the loop
+    // holding a stream it can never schedule on again, and every later poke a no-op.
+    loop.poke()
+    expect(() => clock.flush()).toThrow('measured a card that just unmounted')
+    expect(loop.awake()).toBe(false)
+    expect(clock.pending()).toBe(0)
+
+    broken = false
+    loop.poke()
+    clock.flush()
+    expect(frames).toBe(2)
+    expect(loop.awake()).toBe(true)
+  })
+
+  it('stays parked when the compute stops the loop', () => {
+    const clock = fakeScheduler()
+    let frames = 0
+    // A compute whose store write unmounts the board runs `stop()` from inside the frame it
+    // is halfway through. The frame it was about to schedule must not resurrect it.
+    const loop = createSettlingLoop({
+      compute: () => {
+        frames++
+        loop.stop()
+        return true
+      },
+      scheduler: clock.scheduler,
+      settleFrames: 3,
+    })
+
+    loop.poke()
+    clock.flush()
+    expect(loop.awake()).toBe(false)
+    expect(clock.pending()).toBe(0)
+    clock.flush()
+    expect(frames).toBe(1)
+  })
+
+  it('drops the pending frame on stop', () => {
+    const clock = fakeScheduler()
+    let frames = 0
+    const loop = createSettlingLoop({
+      compute: () => {
+        frames++
+        return true
+      },
+      scheduler: clock.scheduler,
+      settleFrames: 3,
+    })
+
+    loop.poke()
+    loop.stop()
+    expect(loop.awake()).toBe(false)
+    clock.flush()
+    expect(frames).toBe(0)
+  })
+})