Orca is the place for working with a fleet of agents (e.g. Grok Bot, Claude Code). Run any coding agent with your own subscription. Available on desktop, mobile and remote runtime.
TypeScript adeagent-ideai-agentsautomationbotclaude-codecodexghosttygrok-bothermes-agentmobile-appmuseopenclawopencodeorchestrationpiruntimeterminalworktreesyc-backed
import { describe, expect, it } from 'vitest'
import { createGenerationStore, MAX_CACHED_HOSTS } from './generation-store'
import { deriveHostCacheKey } from './host-cache-key'
import type { MobileWebBundleFetchResult } from '../transport/mobile-web-bundle-fetch'
import { computeMobileWebBundleId } from '../../../src/shared/mobile-web-bundle/manifest-contract'
import {
createFakeGenerationFileSystem as createFakeFileSystem,
FAKE_GENERATION_ROOT,
type FakeGenerationFileSystem as FakeFileSystem
} from './generation-file-system-fake'
const ROOT = FAKE_GENERATION_ROOT
const HOST = deriveHostCacheKey('host-a')
function buildResult(options: {
buildId?: string
assets?: readonly { path: string; byteLength: number }[]
bytes?: ReadonlyMap<string, Uint8Array>
}): MobileWebBundleFetchResult {
const listed = options.assets ?? [
{ path: 'index.html', byteLength: 4 },
{ path: 'assets/app.js', byteLength: 2 }
]
const assets = listed.map((asset, index) => ({
path: asset.path,
sha256: String(index).repeat(64).slice(0, 64),
byteLength: asset.byteLength,
contentType: 'text/html; charset=utf-8'
}))
const totalBytes = assets.reduce((sum, asset) => sum + asset.byteLength, 0)
return {
manifest: {
schemaVersion: 1,
buildId: options.buildId ?? computeMobileWebBundleId(assets),
minCompatibleRuntimeProtocolVersion: 2,
runtimeProtocolVersion: 2,
entrypoint: 'index.html',
totalBytes,
assets
},
assets:
options.bytes ??
new Map(assets.map((asset) => [asset.path, new Uint8Array(asset.byteLength).fill(7)])),
reused: [],
totalBytes,
elapsedMs: 1
}
}
// Derive ids from assets so the cached manifest passes its digest check.
const BUILD = buildResult({}).manifest.buildId
const SECOND = { assets: [{ path: 'index.html', byteLength: 8 }] }
const SECOND_BUILD = buildResult(SECOND).manifest.buildId
async function activate(
store: ReturnType<typeof createGenerationStore>,
hostKey: string,
result = buildResult({})
): Promise<void> {
await store.commitGeneration(await store.stageGeneration(hostKey, result))
}
function hostKeys(count: number): string[] {
return Array.from({ length: count }, (_, index) => deriveHostCacheKey(`host-${index}`))
}
describe('generation store', () => {
it('stages and commits exactly the manifest, with the manifest written last', async () => {
const fs = createFakeFileSystem()
const store = createGenerationStore({ fileSystem: fs })
await activate(store, HOST)
const build = BUILD
expect(fs.paths()).toEqual([
HOST,
`${HOST}/generations`,
`${HOST}/generations/${build}`,
`${HOST}/generations/${build}/assets`,
`${HOST}/generations/${build}/assets/app.js`,
`${HOST}/generations/${build}/index.html`,
`${HOST}/generations/${build}/manifest.json`,
`${HOST}/tmp`,
'hosts.json'
])
const staged = fs.writes.filter((path) => path.includes('/tmp/'))
expect(staged.at(-1)).toBe(`${HOST}/tmp/${build}/manifest.json`)
expect(staged).toHaveLength(3)
expect(fs.text('hosts.json')).toBe(JSON.stringify([HOST]))
})
it('reads back the activation it committed', async () => {
const fs = createFakeFileSystem()
const store = createGenerationStore({ fileSystem: fs })
await activate(store, HOST)
const active = await store.readActiveGeneration(HOST)
expect(active?.buildId).toBe(BUILD)
expect(active?.directory).toBe(`${ROOT}/${HOST}/generations/${BUILD}`)
expect(active?.manifest.entrypoint).toBe('index.html')
expect(await store.readActiveGeneration(deriveHostCacheKey('never-opened'))).toBeNull()
})
it('refuses an asset that is missing or the wrong length, leaving no generation', async () => {
const fs = createFakeFileSystem()
const store = createGenerationStore({ fileSystem: fs })
const missing = buildResult({ bytes: new Map([['index.html', new Uint8Array(4)]]) })
const short = buildResult({
bytes: new Map([
['index.html', new Uint8Array(4)],
['assets/app.js', new Uint8Array(1)]
])
})
await expect(store.stageGeneration(HOST, missing)).rejects.toThrow('assets/app.js is absent')
await expect(store.stageGeneration(HOST, short)).rejects.toThrow("not the manifest's 2")
expect(fs.paths()).toEqual([])
expect(await store.readActiveGeneration(HOST)).toBeNull()
})
it('drops the staged tree when a write fails', async () => {
const fs = createFakeFileSystem()
const store = createGenerationStore({ fileSystem: fs })
fs.failWritesAt(`${HOST}/tmp/${BUILD}/assets/app.js`)
await expect(store.stageGeneration(HOST, buildResult({}))).rejects.toThrow('disk-full')
expect(fs.paths().some((path) => path.includes(`tmp/${BUILD}`))).toBe(false)
expect(await store.readActiveGeneration(HOST)).toBeNull()
})
it('leaves no generation and no tmp for any host when a download is interrupted', async () => {
const fs = createFakeFileSystem()
const store = createGenerationStore({ fileSystem: fs })
const other = deriveHostCacheKey('host-b')
await store.stageGeneration(HOST, buildResult({}))
await store.stageGeneration(other, buildResult({}))
await store.sweepStagedGenerations()
expect(fs.paths().some((path) => path.includes('/tmp'))).toBe(false)
expect(await store.readActiveGeneration(HOST)).toBeNull()
expect(await store.readActiveGeneration(other)).toBeNull()
})
it('treats a second commit of the same build as a no-op', async () => {
const fs = createFakeFileSystem()
const store = createGenerationStore({ fileSystem: fs })
await activate(store, HOST)
const before = fs.paths()
const staged = await store.stageGeneration(HOST, buildResult({}))
const active = await store.commitGeneration(staged)
expect(active.buildId).toBe(BUILD)
expect(fs.paths()).toEqual(before)
})
it('replaces the previous generation when the build id changes', async () => {
const fs = createFakeFileSystem()
const store = createGenerationStore({ fileSystem: fs })
await activate(store, HOST)
await activate(store, HOST, buildResult(SECOND))
expect(fs.paths().some((path) => path.includes(BUILD))).toBe(false)
expect((await store.readActiveGeneration(HOST))?.buildId).toBe(SECOND_BUILD)
})
it('reads two generations as no activation and drops the host tree', async () => {
const fs = createFakeFileSystem()
const store = createGenerationStore({ fileSystem: fs })
await activate(store, HOST)
fs.seed(`${HOST}/generations/${'c'.repeat(64)}/manifest.json`, {
kind: 'file',
bytes: new TextEncoder().encode('{}')
})
expect(await store.readActiveGeneration(HOST)).toBeNull()
expect(fs.paths().some((path) => path.startsWith(HOST))).toBe(false)
})
it('reads an unparseable or mismatched manifest as no activation and drops the host tree', async () => {
for (const body of [
'not json',
JSON.stringify({ ...buildResult({}).manifest, buildId: 'd'.repeat(64) })
]) {
const fs = createFakeFileSystem()
const store = createGenerationStore({ fileSystem: fs })
await activate(store, HOST)
fs.seed(`${HOST}/generations/${BUILD}/manifest.json`, {
kind: 'file',
bytes: new TextEncoder().encode(body)
})
expect(await store.readActiveGeneration(HOST)).toBeNull()
expect(fs.paths().some((path) => path.startsWith(HOST))).toBe(false)
}
})
it('evicts the least recently activated host past the ceiling', async () => {
const fs = createFakeFileSystem()
const store = createGenerationStore({ fileSystem: fs })
const hosts = hostKeys(MAX_CACHED_HOSTS + 1)
for (const host of hosts) {
await activate(store, host)
}
expect(await store.readActiveGeneration(hosts[0])).toBeNull()
expect(fs.paths().some((path) => path.startsWith(hosts[0]))).toBe(false)
for (const host of hosts.slice(1)) {
expect((await store.readActiveGeneration(host))?.buildId).toBe(BUILD)
}
expect(fs.text('hosts.json')).toBe(JSON.stringify(hosts.slice(1)))
})
it('evicts a host with no index entry before the least recently activated one', async () => {
const fs = createFakeFileSystem()
const store = createGenerationStore({ fileSystem: fs })
const [oldest, ...rest] = hostKeys(MAX_CACHED_HOSTS - 1)
const orphan = deriveHostCacheKey('orphan')
for (const host of [oldest, ...rest]) {
await activate(store, host)
}
await activate(store, orphan)
const order = [oldest, ...rest]
fs.seed('hosts.json', { kind: 'file', bytes: new TextEncoder().encode(JSON.stringify(order)) })
await activate(store, deriveHostCacheKey('one-too-many'))
expect(fs.paths().some((path) => path.startsWith(orphan))).toBe(false)
expect((await store.readActiveGeneration(oldest))?.buildId).toBe(BUILD)
})
it('counts a recommit of the build a host already has as use of that host', async () => {
const fs = createFakeFileSystem()
const store = createGenerationStore({ fileSystem: fs })
const hosts = hostKeys(MAX_CACHED_HOSTS)
const [kept, evicted] = hosts
for (const host of hosts) {
await activate(store, host)
}
await activate(store, kept)
await activate(store, deriveHostCacheKey('one-too-many'))
expect(fs.paths().some((path) => path.startsWith(evicted))).toBe(false)
expect((await store.readActiveGeneration(kept))?.buildId).toBe(BUILD)
})
it('counts opening a cached generation as use of that host', async () => {
const fs = createFakeFileSystem()
const store = createGenerationStore({ fileSystem: fs })
const hosts = hostKeys(MAX_CACHED_HOSTS)
for (const host of hosts) {
await activate(store, host)
}
expect((await store.readActiveGeneration(hosts[0]))?.buildId).toBe(BUILD)
await activate(store, deriveHostCacheKey('one-too-many'))
expect((await store.readActiveGeneration(hosts[0]))?.buildId).toBe(BUILD)
expect(fs.paths().some((path) => path.startsWith(hosts[1]))).toBe(false)
})
it('writes nothing when a read finds no active generation', async () => {
const fs = createFakeFileSystem()
const store = createGenerationStore({ fileSystem: fs })
await activate(store, HOST)
const writesBefore = fs.writes.length
expect(await store.readActiveGeneration(deriveHostCacheKey('never-opened'))).toBeNull()
expect(fs.writes).toHaveLength(writesBefore)
expect(fs.text('hosts.json')).toBe(JSON.stringify([HOST]))
})
it('returns the generation when an open cannot write the index', async () => {
const fs = createFakeFileSystem()
const store = createGenerationStore({ fileSystem: fs })
const other = deriveHostCacheKey('other')
await activate(store, HOST)
await activate(store, other)
fs.failWritesAt('hosts.json')
expect((await store.readActiveGeneration(HOST))?.buildId).toBe(BUILD)
expect(fs.text('hosts.json')).toBe(JSON.stringify([HOST, other]))
})
it('rewrites the index on an open only when the host is not already the newest', async () => {
const fs = createFakeFileSystem()
const store = createGenerationStore({ fileSystem: fs })
const [older, newest] = hostKeys(2)
await activate(store, older)
await activate(store, newest)
const before = { text: fs.text('hosts.json'), writes: fs.writes.length }
expect((await store.readActiveGeneration(newest))?.buildId).toBe(BUILD)
expect({ text: fs.text('hosts.json'), writes: fs.writes.length }).toEqual(before)
expect((await store.readActiveGeneration(older))?.buildId).toBe(BUILD)
expect(fs.text('hosts.json')).toBe(JSON.stringify([newest, older]))
})
it('reads the timestamp record earlier builds wrote as an empty order', async () => {
const fs = createFakeFileSystem()
const store = createGenerationStore({ fileSystem: fs })
const other = deriveHostCacheKey('other')
fs.seed('hosts.json', {
kind: 'file',
bytes: new TextEncoder().encode(JSON.stringify({ [HOST]: 1, [other]: 2 }))
})
await activate(store, other)
expect(fs.text('hosts.json')).toBe(JSON.stringify([other]))
})
it('never counts or evicts a host that is only mid-download', async () => {
const fs = createFakeFileSystem()
const store = createGenerationStore({ fileSystem: fs })
const hosts = hostKeys(MAX_CACHED_HOSTS)
const oldest = hosts[0]
const downloading = deriveHostCacheKey('downloading')
for (const host of hosts) {
await activate(store, host)
}
const staged = await store.stageGeneration(downloading, buildResult({}))
await activate(store, deriveHostCacheKey('one-too-many'))
// Count activations only; eviction must leave staged downloads intact.
expect(fs.paths().some((path) => path.startsWith(oldest))).toBe(false)
expect(fs.text(`${staged.directory.slice(ROOT.length + 1)}/manifest.json`)).not.toBeNull()
await store.commitGeneration(staged)
expect((await store.readActiveGeneration(downloading))?.buildId).toBe(BUILD)
})
it('serializes two stage calls for one host and build', async () => {
const fs = createFakeFileSystem()
const store = createGenerationStore({ fileSystem: fs })
// Give one build id conflicting asset lists to expose interleaved writes into the same staging directory.
const staging = `${HOST}/tmp/${BUILD}`
const earlier = buildResult({
buildId: BUILD,
assets: [{ path: 'assets/earlier.js', byteLength: 2 }]
})
const later = buildResult({
buildId: BUILD,
assets: [{ path: 'assets/later.js', byteLength: 3 }]
})
const [first, second] = await Promise.all([
store.stageGeneration(HOST, earlier),
store.stageGeneration(HOST, later)
])
expect(first.directory).toBe(second.directory)
expect(fs.writes).toEqual([
`${staging}/assets/earlier.js`,
`${staging}/manifest.json`,
`${staging}/assets/later.js`,
`${staging}/manifest.json`
])
expect(fs.paths().filter((path) => path.startsWith(`${staging}/assets/`))).toEqual([
`${staging}/assets/later.js`
])
})
it('drops residue from an earlier attempt instead of staging over it', async () => {
const fs = createFakeFileSystem()
const store = createGenerationStore({ fileSystem: fs })
const staging = `${HOST}/tmp/${BUILD}`
fs.seed(`${staging}/assets/orphan.js`, { kind: 'file', bytes: new Uint8Array(1) })
await store.stageGeneration(HOST, buildResult({}))
expect(fs.paths().some((path) => path.endsWith('orphan.js'))).toBe(false)
})
it('refuses a path that escapes the staged tree, and a host key that is not one', async () => {
const fs = createFakeFileSystem()
const store = createGenerationStore({ fileSystem: fs })
const escapes = [
'../outside.js',
'assets/../../outside.js',
'/etc/passwd',
'assets//app.js',
'manifest.json',
'Manifest.JSON'
]
for (const path of escapes) {
const result = buildResult({ assets: [{ path, byteLength: 1 }] })
await expect(store.stageGeneration(HOST, result)).rejects.toThrow('refuses to stage')
}
await expect(store.stageGeneration('host-a', buildResult({}))).rejects.toThrow(
'not a host cache key'
)
expect(fs.paths()).toEqual([])
})
it('deletes one host tree without touching another', async () => {
const fs = createFakeFileSystem()
const other = deriveHostCacheKey('host-b')
const store = createGenerationStore({ fileSystem: fs })
await activate(store, HOST)
await activate(store, other)
await store.deleteHostCache(HOST)
expect(await store.readActiveGeneration(HOST)).toBeNull()
expect((await store.readActiveGeneration(other))?.buildId).toBe(BUILD)
expect(fs.text('hosts.json')).toBe(JSON.stringify([other]))
})
it('refuses a rename that did not carry the tree, as Android below API 26 can', async () => {
const fs = createFakeFileSystem()
const store = createGenerationStore({ fileSystem: fs })
fs.loseContentsOnMove()
const staged = await store.stageGeneration(HOST, buildResult({}))
await expect(store.commitGeneration(staged)).rejects.toThrow('did not carry its manifest')
expect(await store.readActiveGeneration(HOST)).toBeNull()
expect(fs.paths().some((path) => path.includes('generations/'))).toBe(false)
})
it('keeps the host tree when the manifest read fails, and drops it when it is missing', async () => {
const fs = createFakeFileSystem()
const store = createGenerationStore({ fileSystem: fs })
const manifest = `${HOST}/generations/${BUILD}/manifest.json`
await activate(store, HOST)
const before = fs.paths()
fs.failReadsAt(manifest)
expect(await store.readActiveGeneration(HOST)).toBeNull()
expect(fs.paths()).toEqual(before)
fs.failReadsAt(null)
await fs.delete(`${ROOT}/${manifest}`)
expect(await store.readActiveGeneration(HOST)).toBeNull()
expect(fs.paths().some((path) => path.startsWith(HOST))).toBe(false)
})
it('activates normally when the recency index cannot be read', async () => {
const fs = createFakeFileSystem()
const store = createGenerationStore({ fileSystem: fs })
fs.seed('hosts.json', { kind: 'file', bytes: new TextEncoder().encode('[]') })
fs.failReadsAt('hosts.json')
await activate(store, HOST)
expect((await store.readActiveGeneration(HOST))?.buildId).toBe(BUILD)
})
it('replaces an entry named for the build id that is not a readable generation', async () => {
const build = BUILD
// Model a crash between rename and the post-rename manifest check.
for (const seeded of [
{ kind: 'directory' },
{ kind: 'file', bytes: new Uint8Array(1) }
] as const) {
const fs = createFakeFileSystem()
const store = createGenerationStore({ fileSystem: fs })
fs.seed(`${HOST}/generations/${build}`, seeded)
await activate(store, HOST)
expect((await store.readActiveGeneration(HOST))?.buildId).toBe(build)
expect(fs.text(`${HOST}/generations/${build}/index.html`)).not.toBeNull()
}
})
it('drops an aborted staging without touching the activation', async () => {
const fs = createFakeFileSystem()
const store = createGenerationStore({ fileSystem: fs })
await activate(store, HOST)
const staged = await store.stageGeneration(HOST, buildResult(SECOND))
await store.abortStagedGeneration(staged)
expect(fs.paths().some((path) => path.includes(SECOND_BUILD))).toBe(false)
expect((await store.readActiveGeneration(HOST))?.buildId).toBe(BUILD)
})
it('returns the activation even when the recency index cannot be written', async () => {
const fs = createFakeFileSystem()
const store = createGenerationStore({ fileSystem: fs })
fs.failWritesAt('hosts.json')
const staged = await store.stageGeneration(HOST, buildResult({}))
const active = await store.commitGeneration(staged)
expect(active.buildId).toBe(BUILD)
expect((await store.readActiveGeneration(HOST))?.buildId).toBe(BUILD)
expect(fs.text('hosts.json')).toBeNull()
})
it('refuses a handle whose staged tree is gone without touching the activation', async () => {
const fs = createFakeFileSystem()
const store = createGenerationStore({ fileSystem: fs })
await activate(store, HOST)
const staged = await store.stageGeneration(HOST, buildResult(SECOND))
await store.abortStagedGeneration(staged)
await expect(store.commitGeneration(staged)).rejects.toThrow('no longer on disk')
expect((await store.readActiveGeneration(HOST))?.buildId).toBe(BUILD)
})
it('prunes an index entry whose host tree is gone', async () => {
const fs = createFakeFileSystem()
const store = createGenerationStore({ fileSystem: fs })
const stale = deriveHostCacheKey('uninstalled')
fs.seed('hosts.json', {
kind: 'file',
bytes: new TextEncoder().encode(JSON.stringify([stale]))
})
await activate(store, HOST)
expect(fs.text('hosts.json')).toBe(JSON.stringify([HOST]))
})
it('refuses a staged handle it did not issue', async () => {
const fs = createFakeFileSystem()
const store = createGenerationStore({ fileSystem: fs })
await activate(store, HOST)
const before = fs.paths()
const forged = {
hostKey: HOST,
buildId: SECOND_BUILD,
directory: `${ROOT}/${HOST}/generations/${BUILD}`,
manifest: buildResult({}).manifest
}
await expect(store.commitGeneration(forged)).rejects.toThrow('did not issue')
await expect(store.abortStagedGeneration(forged)).rejects.toThrow('did not issue')
expect(fs.paths()).toEqual(before)
expect((await store.readActiveGeneration(HOST))?.buildId).toBe(BUILD)
})
it('ignores a directory under the cache root that is not a host key', async () => {
const fs = createFakeFileSystem()
const store = createGenerationStore({ fileSystem: fs })
fs.seed('not-a-host-key/stray.txt', { kind: 'file', bytes: new Uint8Array(1) })
const hosts = ['a', 'b', 'c', 'd'].map((name) => deriveHostCacheKey(name))
for (const host of hosts) {
await activate(store, host)
}
await store.sweepStagedGenerations()
expect(fs.paths()).toContain('not-a-host-key/stray.txt')
for (const host of hosts) {
expect((await store.readActiveGeneration(host))?.buildId).toBe(BUILD)
}
})
})
describe('reusable assets for the next download', () => {
const NEXT = buildResult({
assets: [
{ path: 'index.html', byteLength: 8 },
{ path: 'assets/app-2.js', byteLength: 2 }
]
})
const NEXT_BUILD = NEXT.manifest.buildId
const [PAGE, SCRIPT] = NEXT.manifest.assets
const DOWNLOADED = new Map([['index.html', new Uint8Array(8).fill(9)]])
const LEFT_TO_STAGE = { ...NEXT, assets: DOWNLOADED, reused: ['assets/app-2.js'] }
it('matches cached assets by content, and checks them without reading them', async () => {
const fs = createFakeFileSystem()
const store = createGenerationStore({ fileSystem: fs })
expect((await store.openReusableAssets(HOST)).has(SCRIPT!)).toBe(false)
await activate(store, HOST)
const reusable = await store.openReusableAssets(HOST)
expect(reusable.has(SCRIPT!)).toBe(true)
expect(reusable.has(PAGE!)).toBe(false)
expect(await reusable.check(SCRIPT!)).toBe(true)
fs.seed(`${HOST}/generations/${BUILD}/assets/app.js`, {
kind: 'file',
bytes: new Uint8Array(1)
})
expect(await reusable.check(SCRIPT!)).toBe(false)
})
it('copies the reused assets beside the downloaded ones and commits the whole build', async () => {
const fs = createFakeFileSystem()
const store = createGenerationStore({ fileSystem: fs })
await activate(store, HOST)
await activate(store, HOST, LEFT_TO_STAGE)
const generation = `${HOST}/generations/${NEXT_BUILD}`
expect(fs.bytes(`${generation}/index.html`)).toEqual(new Uint8Array(8).fill(9))
expect(fs.bytes(`${generation}/assets/app-2.js`)).toEqual(new Uint8Array(2).fill(7))
expect((await store.readActiveGeneration(HOST))?.buildId).toBe(NEXT_BUILD)
})
it('refuses to stage a reused asset the active generation no longer holds', async () => {
const fs = createFakeFileSystem()
const store = createGenerationStore({ fileSystem: fs })
await activate(store, HOST)
fs.failReadsAt(`${HOST}/generations/${BUILD}/assets/app.js`)
await expect(store.stageGeneration(HOST, LEFT_TO_STAGE)).rejects.toThrow('unreadable')
await store.deleteHostCache(HOST)
fs.failReadsAt(null)
await expect(store.stageGeneration(HOST, LEFT_TO_STAGE)).rejects.toThrow(
'no longer holds the reused asset assets/app-2.js'
)
expect(fs.paths().some((path) => path.includes(`tmp/${NEXT_BUILD}`))).toBe(false)
})
})
// Older builds could leave manifest-next.json after an interrupted rewrite; this reader must ignore it.
describe('a pending manifest left by an older build', () => {
const MANIFEST_PATH = `${HOST}/generations/${BUILD}/manifest.json`
const NEXT_PATH = `${HOST}/generations/${BUILD}/manifest-next.json`
function seedPending(fs: FakeFileSystem): void {
const body = JSON.stringify({ ...buildResult({}).manifest, routes: [] })
fs.seed(NEXT_PATH, { kind: 'file', bytes: new TextEncoder().encode(body) })
}
it('reads the manifest beside it and leaves it inert', async () => {
const fs = createFakeFileSystem()
const store = createGenerationStore({ fileSystem: fs })
await activate(store, HOST)
const stored = fs.text(MANIFEST_PATH)
seedPending(fs)
expect((await store.readActiveGeneration(HOST))?.buildId).toBe(BUILD)
expect(fs.text(MANIFEST_PATH)).toBe(stored)
})
it('drops the host tree for a redownload when it is the only manifest left', async () => {
const fs = createFakeFileSystem()
const store = createGenerationStore({ fileSystem: fs })
await activate(store, HOST)
seedPending(fs)
await fs.delete(`${ROOT}/${MANIFEST_PATH}`)
expect(await store.readActiveGeneration(HOST)).toBeNull()
expect(fs.paths().some((path) => path.startsWith(`${HOST}/generations`))).toBe(false)
})
})