diff --git a/client/src/utils.ts b/client/src/utils.ts
index 9cfa4be3..6476231a 100644
--- a/client/src/utils.ts
+++ b/client/src/utils.ts
@@ -165,10 +165,20 @@ export function launchLanguageServer(context: vscode.ExtensionContext): Language
     documentSelector: [{ scheme: 'file', language: 'xml' }],
     synchronize: {
       fileEvents: [
+        // FIXME: media, modules, collections, etc. should not be hardcoded here
+        // NOTE: these patterns do not support matching directories without matching files
+        // '**/*/' and '**/**/' both match all directories AND files
+        // Additionally, events are sent for each pattern that matches. This can cause
+        // massively degraded performance if there are many overlapping patterns
+        // It is a known issue and a completely new watcher system is being created to address
+        // the shortcomings of this one
+        // See: https://github.com/microsoft/vscode/wiki/File-Watcher-Internals
         vscode.workspace.createFileSystemWatcher('**/META-INF/books.xml'),
         vscode.workspace.createFileSystemWatcher('**/media/**'),
-        vscode.workspace.createFileSystemWatcher('**/*.cnxml'),
-        vscode.workspace.createFileSystemWatcher('**/*.collection.xml')
+        vscode.workspace.createFileSystemWatcher('**/modules/**'),
+        vscode.workspace.createFileSystemWatcher('**/*.collection.xml'),
+        vscode.workspace.createFileSystemWatcher('**/interactives/*/'),
+        vscode.workspace.createFileSystemWatcher('**/interactives/*/h5p.json')
       ]
     }
   }
diff --git a/server/src/model-manager.spec.ts b/server/src/model-manager.spec.ts
index cd3a1666..800af9bc 100644
--- a/server/src/model-manager.spec.ts
+++ b/server/src/model-manager.spec.ts
@@ -10,13 +10,14 @@ import xmlFormat from 'xml-formatter'
 import { expectValue, type Opt, join, PathKind } from './model/utils'
 import { Bundle, BundleValidationKind } from './model/bundle'
 import { ModelManager } from './model-manager'
-import { bookMaker, bundleMaker, first, FS_PATH_HELPER, ignoreConsoleWarnings, loadSuccess, makeBundle, type PageInfo, pageMaker } from './model/spec-helpers.spec'
+import { bookMaker, bundleMaker, first, FS_PATH_HELPER, ignoreConsoleWarnings, loadSuccess, makeBundle, type PageInfo, pageMaker, newH5PPath } from './model/spec-helpers.spec'
 import { type Job, JobRunner } from './job-runner'
 
 import { PageNode, PageValidationKind } from './model/page'
 import { type TocModification, TocModificationKind, TocNodeKind } from '../../common/src/toc'
 import { type BooksAndOrphans, DiagnosticSource } from '../../common/src/requests'
 import { URI, Utils } from 'vscode-uri'
+import { H5PExercise } from './model/h5p-exercise'
 
 ModelManager.debug = () => {} // Turn off logging
 JobRunner.debug = () => {} // Turn off logging
@@ -293,6 +294,7 @@ describe('processFilesystemChange()', () => {
     expect((await fireChange(FileChangeType.Created, 'modules/m1234/index.cnxml')).size).toBe(1)
     expect((await fireChange(FileChangeType.Created, 'media/newpic.png')).size).toBe(1)
     expect((await fireChange(FileChangeType.Created, 'media/does-not-exist.png')).size).toBe(1)
+    expect((await fireChange(FileChangeType.Created, `${manager.bundle.paths.publicRoot}/does-not-exist/h5p.json`)).size).toBe(1)
   })
   it('does not create things it does not understand', async () => {
     expect((await fireChange(FileChangeType.Created, 'README.md')).toArray()).toEqual([])
@@ -309,6 +311,7 @@ describe('processFilesystemChange()', () => {
     expect(sendDiagnosticsStub.callCount).toBe(1)
 
     expect((await fireChange(FileChangeType.Changed, 'media/newpic.png')).toArray()).toEqual([]) // Since the model was not aware of the file yet
+    expect((await fireChange(FileChangeType.Changed, `${manager.bundle.paths.publicRoot}/does-not-exist/h5p.json`)).toArray()).toEqual([]) // Since the model was not aware of the file yet
   })
   it('deletes Files and directories', async () => {
     // Load the Bundle, Book, and Page
@@ -434,6 +437,71 @@ describe('Image Autocomplete', () => {
   })
 })
 
+describe('URL Autocomplete', () => {
+  const sinon = SinonRoot.createSandbox()
+  const h5pName = 'abc'
+  const orphanedH5PName = '123'
+  let manager = null as unknown as ModelManager
+  let page: PageNode
+  let h5p: H5PExercise
+  let orphanedH5P: H5PExercise
+
+  beforeEach(() => {
+    const bundle = makeBundle()
+    manager = new ModelManager(bundle, conn)
+    page = first(loadSuccess(first(loadSuccess(manager.bundle).books)).pages)
+    h5p = manager.bundle.allH5P.getOrAdd(newH5PPath(manager.bundle, h5pName))
+    h5p.load('any-string')
+    orphanedH5P = manager.bundle.allH5P.getOrAdd(newH5PPath(manager.bundle, orphanedH5PName))
+    orphanedH5P.load('any-string')
+    manager.updateFileContents(page.absPath, pageMaker({ pageLinks: [{ url: `${H5PExercise.PLACEHOLDER}/abc` }] }))
+  })
+
+  afterEach(() => {
+    sinon.restore()
+  })
+
+  it('Returns orphaned H5P interactives', () => {
+    expect(page.validationErrors.nodesToLoad.toArray()).toEqual([])
+    expect(page.validationErrors.errors.toArray()).toEqual([])
+
+    expect(page.pageLinks.size).toBe(1)
+    const firstLink = first(page.pageLinks)
+    const results = manager.autocompleteUrls(
+      page,
+      {
+        line: firstLink.range.start.line,
+        character: firstLink.range.start.character + '<link url="X'.length
+      }
+    )
+    expect(results).not.toEqual([])
+    expect(results[0].label).toBe(`${H5PExercise.PLACEHOLDER}/${orphanedH5PName}`)
+  })
+
+  it('Returns no results outside url tag', () => {
+    expect(page.validationErrors.nodesToLoad.toArray()).toEqual([])
+    expect(page.validationErrors.errors.toArray()).toEqual([])
+
+    const cursor = { line: 0, character: 0 }
+    const results = manager.autocompleteResources(page, cursor)
+    expect(results).toEqual([])
+  })
+
+  it('Returns no results outside replacement range', () => {
+    expect(page.validationErrors.nodesToLoad.toArray()).toEqual([])
+    expect(page.validationErrors.errors.toArray()).toEqual([])
+
+    const firstLink = first(page.pageLinks)
+    const results = manager.autocompleteResources(
+      page, {
+        line: firstLink.range.start.line,
+        character: firstLink.range.start.character + '<url'.length
+      }
+    )
+    expect(results).toEqual([])
+  })
+})
+
 describe('documentLinks()', () => {
   let manager = null as unknown as ModelManager
 
@@ -452,6 +520,7 @@ describe('documentLinks()', () => {
     const nonexistentButLoadedPath = FS_PATH_HELPER.join(FS_PATH_HELPER.dirname(FS_PATH_HELPER.dirname(page.absPath)), nonexistentButLoadedId, 'index.cnxml')
     const otherPage = manager.bundle.allPages.getOrAdd(otherPagePath)
     const nonexistentButLoadedPage = manager.bundle.allPages.getOrAdd(nonexistentButLoadedPath)
+    const h5p = manager.bundle.allH5P.getOrAdd(newH5PPath(manager.bundle, 'abcd'))
 
     otherPage.load(pageMaker({
       elementIds: ['other-el-id']
@@ -482,6 +551,14 @@ describe('documentLinks()', () => {
     await testPageLink({ pageLinks: [{ targetPage: otherId, targetId: 'nonexistent-id' }] }, `modules/${otherId}/index.cnxml`)
     await testPageLink({ pageLinks: [{ targetPage: otherId, targetId: 'other-el-id' }] }, `modules/${otherId}/index.cnxml#9:0`)
     await testPageLink({ pageLinks: [{ targetPage: nonexistentButLoadedId }] }, undefined)
+    await testPageLink(
+      {
+        pageLinks: [
+          { url: `${H5PExercise.PLACEHOLDER}/abcd` }
+        ]
+      },
+      path.relative(URI.parse(manager.bundle.workspaceRootUri).fsPath, h5p.absPath)
+    )
   })
 })
 
diff --git a/server/src/model-manager.ts b/server/src/model-manager.ts
index 3d28b7c3..d9e41b51 100644
--- a/server/src/model-manager.ts
+++ b/server/src/model-manager.ts
@@ -18,6 +18,7 @@ import { type BooksAndOrphans, DiagnosticSource, ExtensionServerNotification } f
 import { type BookNode, type TocSubbookWithRange } from './model/book'
 import { mkdirp } from 'fs-extra'
 import { DOMParser, XMLSerializer } from 'xmldom'
+import { H5PExercise } from './model/h5p-exercise'
 
 // Note: `[^/]+` means "All characters except slash"
 const IMAGE_RE = /\/media\/[^/]+\.[^.]+$/
@@ -27,6 +28,11 @@ const BOOK_RE = /\/collections\/[^/]+\.collection\.xml$/
 const PATH_SEP = path.sep
 
 interface NodeAndParent { node: ClientTocNode, parent: BookToc | ClientTocNode }
+interface Autocompleter {
+  hasLinkNearCursor: (page: PageNode, cursor: Position) => boolean
+  getRange: (cursor: Position, content: string) => Range | undefined
+  getCompletionItems: (page: PageNode, range: Range) => CompletionItem[]
+}
 function childrenOf(n: ClientTocNode) {
   /* istanbul ignore else */
   if (n.type === TocNodeKind.Subbook) {
@@ -49,7 +55,10 @@ function findOrCreateNode(bundle: Bundle, absPath: string) {
     return bundle.allPages.getOrAdd(absPath)
   } else if (BOOK_RE.test(absPath)) {
     return bundle.allBooks.getOrAdd(absPath)
+  } else if (absPath.endsWith('h5p.json')) {
+    return bundle.allH5P.getOrAdd(absPath)
   }
+  return undefined
 }
 
 function findNode(bundle: Bundle, absPath: string) {
@@ -58,7 +67,8 @@ function findNode(bundle: Bundle, absPath: string) {
     : (
         bundle.allBooks.get(absPath) ??
         bundle.allPages.get(absPath) ??
-        bundle.allResources.get(absPath))
+        bundle.allResources.get(absPath)) ??
+        bundle.allH5P.get(absPath)
 }
 
 export function pageToModuleId(page: PageNode) {
@@ -176,6 +186,12 @@ export class ModelManager {
     return this.bundle.allResources.all.filter(loadedAndExists).subtract(pages.flatMap(p => p.resources))
   }
 
+  public get orphanedH5P() {
+    const books = this.bundle.books.filter(loadedAndExists)
+    const pages = books.flatMap(b => b.pages)
+    return this.bundle.allH5P.all.filter(loadedAndExists).subtract(pages.flatMap(p => p.h5p))
+  }
+
   public async loadEnoughForToc() {
     // The only reason this is not implemented as a Job is because we need to send a timely response to the client
     // and there is no code for being notified when a Job completes
@@ -191,8 +207,9 @@ export class ModelManager {
   public async loadEnoughForOrphans() {
     if (this.didLoadOrphans) return
     await this.loadEnoughForToc()
+    const { pagesRoot, mediaRoot, booksRoot, publicRoot } = this.bundle.paths
     // Add all the orphaned Images/Pages/Books dangling around in the filesystem without loading them
-    const files = glob.sync('{modules/*/index.cnxml,media/*.*,collections/*.collection.xml}', { cwd: URI.parse(this.bundle.workspaceRootUri).fsPath, absolute: true })
+    const files = glob.sync(`{${pagesRoot}/*/*.cnxml,${mediaRoot}/*.*,${booksRoot}/*.collection.xml,${publicRoot}/*/h5p.json}`, { cwd: URI.parse(this.bundle.workspaceRootUri).fsPath, absolute: true })
     Quarx.batch(() => {
       files.forEach(absPath => expectValue(findOrCreateNode(this.bundle, this.bundle.pathHelper.canonicalize(absPath)), `BUG? We found files that the bundle did not recognize: ${absPath}`))
     })
@@ -258,13 +275,15 @@ export class ModelManager {
         // Remove if it was a file
         const removedNode = bundle.allBooks.remove(uri) ??
                   bundle.allPages.remove(uri) ??
-                  bundle.allResources.remove(uri)
+                  bundle.allResources.remove(uri) ??
+                  bundle.allH5P.remove(uri)
         if (removedNode !== undefined) s.add(removedNode)
         // Remove if it was a directory
         const filePathDir = `${uri}${PATH_SEP}`
         s.union(bundle.allBooks.removeByKeyPrefix(filePathDir))
         s.union(bundle.allPages.removeByKeyPrefix(filePathDir))
         s.union(bundle.allResources.removeByKeyPrefix(filePathDir))
+        s.union(bundle.allH5P.removeByKeyPrefix(filePathDir))
       })
       // Unload all removed nodes so users do not think the files still exist
       removedNodes.forEach(n => {
@@ -353,6 +372,7 @@ export class ModelManager {
       { slow: true, type: 'INITIAL_LOAD_ALL_BOOK_ERRORS', context: this.bundle, fn: () => { this.bundle.allBooks.all.forEach(b => { this.sendFileDiagnostics(b) }) } },
       { slow: true, type: 'INITIAL_LOAD_ALL_PAGES', context: this.bundle, fn: () => this.bundle.allPages.all.forEach(enqueueLoadJob) },
       { slow: true, type: 'INITIAL_LOAD_ALL_RESOURCES', context: this.bundle, fn: () => this.bundle.allResources.all.forEach(enqueueLoadJob) },
+      { slow: true, type: 'INITIAL_LOAD_ALL_H5P', context: this.bundle, fn: () => this.bundle.allH5P.all.forEach(enqueueLoadJob) },
       { slow: true, type: 'INITIAL_LOAD_REPORT_VALIDATION', context: this.bundle, fn: async () => this.bundle.allNodes.forEach(f => { this.sendFileDiagnostics(f) }) }
     ]
     jobs.reverse().forEach(j => { this.jobRunner.enqueue(j) })
@@ -382,26 +402,53 @@ export class ModelManager {
     jobs.reverse().forEach(j => { this.jobRunner.enqueue(j) })
   }
 
-  public autocompleteResources(page: PageNode, cursor: Position) {
-    const foundLinks = page.resourceLinks.toArray().filter((l) => {
-      return inRange(l.range, cursor)
-    })
+  private autocomplete(
+    page: PageNode,
+    cursor: Position,
+    autocompleter: Autocompleter
+  ) {
+    if (!autocompleter.hasLinkNearCursor(page, cursor)) { return [] }
 
-    if (foundLinks.length === 0) { return [] }
-
-    // We're inside an <image> or <iframe> element.
-    // Now check and see if we are right at the src=" point
-    const content = expectValue(this.getOpenDocContents(page.absPath), 'BUG: This file should be open and have been sent from the vscode client').split('\n')
-    const beforeCursor = content[cursor.line].substring(0, cursor.character)
-    const afterCursor = content[cursor.line].substring(cursor.character)
-    const startQuoteOffset = beforeCursor.lastIndexOf('src="')
-    const endQuoteOffset = afterCursor.indexOf('"')
-    if (startQuoteOffset >= 0 && endQuoteOffset >= 0) {
-      const range: Range = {
-        start: { line: cursor.line, character: startQuoteOffset + 'src="'.length },
-        end: { line: cursor.line, character: endQuoteOffset + cursor.character }
-      }
-      const ret = this.orphanedResources.toArray().map(i => {
+    const content = expectValue(
+      this.getOpenDocContents(page.absPath),
+      'BUG: This file should be open and have been sent from the vscode client'
+    )
+
+    const range = autocompleter.getRange(cursor, content)
+    if (range === undefined) { return [] }
+
+    return autocompleter.getCompletionItems(page, range)
+  }
+
+  private rangeFinderFactory(start: string, end: string) {
+    return (cursor: Position, content: string) => {
+      const lines = content.split('\n')
+      // We're in an autocomplete context
+      // Now check and see if we are right at the start of the thing we
+      // want to autocomplete (src, url, etc.)
+      const beforeCursor = lines[cursor.line].substring(0, cursor.character)
+      const afterCursor = lines[cursor.line].substring(cursor.character)
+      const startOffset = beforeCursor.lastIndexOf(start)
+      const endOffset = afterCursor.indexOf(end)
+      return startOffset < 0 || endOffset < 0
+        ? undefined
+        : {
+            start: { line: cursor.line, character: startOffset + start.length },
+            end: { line: cursor.line, character: endOffset + cursor.character }
+          }
+    }
+  }
+
+  public autocompleteResources(page: PageNode, cursor: Position) {
+    const resourceAutocompleter: Autocompleter = {
+      hasLinkNearCursor: (page, cursor) => {
+        return page.resourceLinks
+          .toArray()
+          .filter((l) => inRange(l.range, cursor))
+          .length > 0
+      },
+      getRange: this.rangeFinderFactory('src="', '"'),
+      getCompletionItems: (page, range) => this.orphanedResources.toArray().map(i => {
         const insertText = path.relative(path.dirname(page.absPath), i.absPath)
         const item = CompletionItem.create(insertText)
         item.textEdit = TextEdit.replace(range, insertText)
@@ -409,9 +456,34 @@ export class ModelManager {
         item.detail = 'Orphaned Resource'
         return item
       })
-      return ret
     }
-    return []
+    return this.autocomplete(page, cursor, resourceAutocompleter)
+  }
+
+  public autocompleteUrls(page: PageNode, cursor: Position) {
+    const urlAutocompleter: Autocompleter = {
+      hasLinkNearCursor: (page, cursor) => {
+        return page.pageLinks
+          .toArray()
+          .filter((l) => inRange(l.range, cursor))
+          .length > 0
+      },
+      getRange: this.rangeFinderFactory('url="', '"'),
+      getCompletionItems: (_page, range) => {
+        return this.orphanedH5P.toArray().filter((h) => h.exists)
+          .map((h) => path.dirname(h.absPath))
+          .map((p) => path.basename(p))
+          .map((name) => {
+            const text = `${H5PExercise.PLACEHOLDER}/${name}`
+            const item = CompletionItem.create(text)
+            item.textEdit = TextEdit.replace(range, text)
+            item.kind = CompletionItemKind.File
+            item.detail = 'H5P interactive'
+            return item
+          })
+      }
+    }
+    return this.autocomplete(page, cursor, urlAutocompleter)
   }
 
   async getDocumentLinks(page: PageNode) {
@@ -424,6 +496,8 @@ export class ModelManager {
       }
       if (pageLink.type === PageLinkKind.URL) {
         ret.push(DocumentLink.create(pageLink.range, pageLink.url))
+      } else if (pageLink.type === PageLinkKind.H5P) {
+        ret.push(DocumentLink.create(pageLink.range, pageLink.h5p.absPath))
       } else {
         const targetPage = pageLink.page
         if (targetPage.isLoaded && !targetPage.exists) {
diff --git a/server/src/model/bundle.ts b/server/src/model/bundle.ts
index 46e40e39..37d7b2fe 100644
--- a/server/src/model/bundle.ts
+++ b/server/src/model/bundle.ts
@@ -6,14 +6,24 @@ import { PageNode } from './page'
 import { BookNode } from './book'
 import { Fileish, type ValidationCheck, ValidationKind } from './fileish'
 import { ResourceNode } from './resource'
+import { H5PExercise } from './h5p-exercise'
 
 export class Bundle extends Fileish implements Bundleish {
   public readonly allResources: Factory<ResourceNode> = new Factory<ResourceNode>((absPath: string) => new ResourceNode(this, this.pathHelper, absPath), (x) => this.pathHelper.canonicalize(x))
   public readonly allPages: Factory<PageNode> = new Factory<PageNode>((absPath: string) => new PageNode(this, this.pathHelper, absPath), (x) => this.pathHelper.canonicalize(x))
+  public readonly allH5P: Factory<H5PExercise> = new Factory<H5PExercise>((absPath: string) => new H5PExercise(this, this.pathHelper, absPath), (x) => this.pathHelper.canonicalize(x))
   public readonly allBooks = new Factory((absPath: string) => new BookNode(this, this.pathHelper, absPath), (x) => this.pathHelper.canonicalize(x))
   private readonly _books = Quarx.observable.box<Opt<I.Set<WithRange<BookNode>>>>(undefined)
   private readonly _duplicateResourcePaths = Quarx.observable.box<I.Set<string>>(I.Set<string>())
   private readonly _duplicateUUIDs = Quarx.observable.box<I.Set<string>>(I.Set<string>())
+  // TODO: parse these from META-INF/books.xml
+  public readonly paths = {
+    publicRoot: 'interactives',
+    privateRoot: 'private',
+    booksRoot: 'collections',
+    pagesRoot: 'modules',
+    mediaRoot: 'media'
+  }
 
   constructor(pathHelper: PathHelper<string>, public readonly workspaceRootUri: string) {
     super(undefined, pathHelper, pathHelper.join(workspaceRootUri, 'META-INF/books.xml'))
@@ -53,7 +63,7 @@ export class Bundle extends Fileish implements Bundleish {
   }
 
   public get allNodes() {
-    return I.Set([this]).union(this.allBooks.all).union(this.allPages.all).union(this.allResources.all)
+    return I.Set([this]).union(this.allBooks.all).union(this.allPages.all).union(this.allResources.all).union(this.allH5P.all)
   }
 
   public get books() {
diff --git a/server/src/model/h5p-exercise.spec.ts b/server/src/model/h5p-exercise.spec.ts
new file mode 100644
index 00000000..9db49476
--- /dev/null
+++ b/server/src/model/h5p-exercise.spec.ts
@@ -0,0 +1,12 @@
+import { ResourceValidationKind } from './resource'
+import { bundleMaker, expectErrors, makeBundle, newH5PPath } from './spec-helpers.spec'
+
+describe('H5P validations', () => {
+  it(ResourceValidationKind.DUPLICATE_RESOURCES.title, () => {
+    const bundle = makeBundle()
+    bundle.load(bundleMaker({}))
+    const h5p = bundle.allH5P.getOrAdd(newH5PPath(bundle, 'abc'))
+    h5p.load('bits-dont-matter')
+    expectErrors(h5p, [])
+  })
+})
diff --git a/server/src/model/h5p-exercise.ts b/server/src/model/h5p-exercise.ts
new file mode 100644
index 00000000..d55c8220
--- /dev/null
+++ b/server/src/model/h5p-exercise.ts
@@ -0,0 +1,9 @@
+import { Fileish, type ValidationCheck } from './fileish'
+
+export class H5PExercise extends Fileish {
+  public static readonly PLACEHOLDER = '{INTERACTIVES_ROOT}'
+
+  protected getValidationChecks(): ValidationCheck[] {
+    return []
+  }
+}
diff --git a/server/src/model/page.spec.ts b/server/src/model/page.spec.ts
index de6b5a24..a23f50a6 100644
--- a/server/src/model/page.spec.ts
+++ b/server/src/model/page.spec.ts
@@ -1,7 +1,8 @@
 import { expect } from '@jest/globals'
 import * as path from 'path'
 import { ELEMENT_TO_PREFIX, PageNode, PageValidationKind, UNTITLED_FILE } from './page'
-import { expectErrors, first, FS_PATH_HELPER, makeBundle, pageMaker } from './spec-helpers.spec'
+import { expectErrors, first, FS_PATH_HELPER, makeBundle, newH5PPath, pageMaker } from './spec-helpers.spec'
+import { H5PExercise } from './h5p-exercise'
 
 describe('Page', () => {
   let page = null as unknown as PageNode
@@ -74,6 +75,7 @@ describe('Page validations', () => {
     const bundle = makeBundle()
     const page = bundle.allPages.getOrAdd('modules/m123/index.cnxml')
     const target = bundle.allPages.getOrAdd('modules/m234/index.cnxml')
+    const h5p = bundle.allH5P.getOrAdd(newH5PPath(bundle, 'abc'))
 
     // Url (always ok)
     page.load(pageMaker({ pageLinks: [{ url: 'https://openstax.org' }] }))
@@ -105,6 +107,18 @@ describe('Page validations', () => {
     expect(page.validationErrors.errors.size).toBe(1)
     page.load(pageMaker({ pageLinks: [{ targetPage: 'm234', targetId: 'elementId1' }] }))
     expect(page.validationErrors.errors.size).toBe(0)
+
+    // Test h5p missing target error
+    page.load(pageMaker({ pageLinks: [{ url: `${H5PExercise.PLACEHOLDER}/abc` }] }))
+    // At first it should not be loaded and should be queued to be loaded
+    expect(h5p.isLoaded).toBe(false)
+    expect(first(page.validationErrors.nodesToLoad)).toBe(h5p)
+    // Then we simulate h5p not existing
+    h5p.load(undefined)
+    expect(first(page.validationErrors.errors).title).toBe(PageValidationKind.MISSING_TARGET.title)
+    // Finally, we simulate h5p existing
+    h5p.load('any-string')
+    expect(page.validationErrors.errors.size).toBe(0)
   })
   it(PageValidationKind.EMPTY_LINK.title, () => {
     const bundle = makeBundle()
diff --git a/server/src/model/page.ts b/server/src/model/page.ts
index cb8ff02d..ad2c0b69 100644
--- a/server/src/model/page.ts
+++ b/server/src/model/page.ts
@@ -3,6 +3,7 @@ import * as Quarx from 'quarx'
 import { type Opt, type Position, PathKind, type WithRange, textWithRange, select, selectOne, calculateElementPositions, expectValue, type HasRange, NOWHERE, join, equalsOpt, equalsWithRange, tripleEq, type Range } from './utils'
 import { Fileish, type ValidationCheck, ValidationKind, ValidationSeverity } from './fileish'
 import { type ResourceNode } from './resource'
+import { H5PExercise } from './h5p-exercise'
 
 enum ResourceLinkKind {
   Image,
@@ -20,6 +21,7 @@ export interface IFrameLink extends HasRange {
 
 export enum PageLinkKind {
   URL,
+  H5P,
   PAGE,
   PAGE_ELEMENT,
   UNKNOWN
@@ -36,6 +38,10 @@ export type PageLink = HasRange & ({
   targetElementId: string
 } | {
   type: PageLinkKind.UNKNOWN
+} | {
+  type: PageLinkKind.H5P
+  url: string
+  h5p: H5PExercise
 })
 
 function convertToPos(str: string, cursor: number): Position {
@@ -59,7 +65,17 @@ const equalsOptWithRange = equalsOpt(equalsWithRange(tripleEq))
 
 const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-5][0-9a-f]{3}-[089ab][0-9a-f]{3}-[0-9a-f]{12}$/i
 
-const URL_RE = /^(#(exercise|ost\/api\/ex)\/[A-Za-z0-9\-_]+|(https?:\/\/|www.)[^\s$.?#].[^\s]*)$/i
+const URL_RE = /^(https?:\/\/|www\.)[^\s$.?#].[^\s]*$/i
+
+// NOTE: These should be case sensitive because matching is case sensitive during exercise injection
+// Match exercise nickname or exercise tag, respectively
+const EXERCISES_RE = /^#(exercise|ost\/api\/ex)\/[A-Za-z0-9\-_]+[^\s$.?#].[^\s]*$/
+// Match placeholder followed by any valid path name
+const H5P_RE = new RegExp(`^${H5PExercise.PLACEHOLDER}/[^\\?/:*"<>#|\0]+$`)
+
+const isWebPath = URL_RE.test.bind(URL_RE)
+const isExercisePath = EXERCISES_RE.test.bind(EXERCISES_RE)
+const isH5PPath = H5P_RE.test.bind(H5P_RE)
 
 export const ELEMENT_TO_PREFIX = new Map<string, string>()
 ELEMENT_TO_PREFIX.set('para', 'para')
@@ -139,6 +155,12 @@ export class PageNode extends Fileish {
     return this.resourceLinks.map(l => l.target)
   }
 
+  public get h5p() {
+    return this.pageLinks
+      .filter((l): l is PageLink & { type: PageLinkKind.H5P } => l.type === PageLinkKind.H5P)
+      .map((l) => l.h5p)
+  }
+
   public get resourceLinks() {
     return this.ensureLoaded(this._resourceLinks)
   }
@@ -187,6 +209,15 @@ export class PageNode extends Fileish {
       const toTargetId = changeEmptyToNull(linkNode.getAttribute('target-id'))
       const toUrl = changeEmptyToNull(linkNode.getAttribute('url'))
       if (toUrl !== undefined) {
+        if (isH5PPath(toUrl)) {
+          const absPath = this.pathHelper.join(
+            super.bundle.workspaceRootUri,
+            toUrl.replace(H5PExercise.PLACEHOLDER, super.bundle.paths.publicRoot),
+            'h5p.json'
+          )
+          const target = super.bundle.allH5P.getOrAdd(absPath)
+          return { range, type: PageLinkKind.H5P, url: toUrl, h5p: target }
+        }
         return { range, type: PageLinkKind.URL, url: toUrl }
       }
       if (toDocument === undefined && toTargetId === undefined && toUrl === undefined) {
@@ -228,6 +259,9 @@ export class PageNode extends Fileish {
       {
         message: PageValidationKind.MISSING_TARGET,
         nodesToLoad: filterNull(pageLinks.map(l => {
+          if (l.type === PageLinkKind.H5P) {
+            return l.h5p
+          }
           if (l.type !== PageLinkKind.URL && l.type !== PageLinkKind.UNKNOWN && l.page !== this) {
             return l.page
           }
@@ -236,6 +270,7 @@ export class PageNode extends Fileish {
         fn: () => pageLinks.filter(l => {
           if (l.type === PageLinkKind.UNKNOWN) return false // unknown links are bad (but we can't check them)
           if (l.type === PageLinkKind.URL) return false // URL links are ok
+          if (l.type === PageLinkKind.H5P) return !l.h5p.exists
           if (!l.page.exists) return true // link to non-existent page are bad
           if (l.type === PageLinkKind.PAGE) return false // linking to the whole page and it exists is ok
           return !l.page.hasElementId(l.targetElementId)
@@ -279,7 +314,9 @@ export class PageNode extends Fileish {
         message: PageValidationKind.INVALID_URL,
         nodesToLoad: I.Set(),
         fn: () => this.pageLinks.filter(l => {
-          return l.type === PageLinkKind.URL && !URL_RE.test(l.url)
+          return l.type === PageLinkKind.URL && !(
+            isWebPath(l.url) || isExercisePath(l.url) || isH5PPath(l.url)
+          )
         }).map(l => l.range)
       }
     ]
diff --git a/server/src/model/spec-helpers.spec.ts b/server/src/model/spec-helpers.spec.ts
index dba6bc5c..76c3801b 100644
--- a/server/src/model/spec-helpers.spec.ts
+++ b/server/src/model/spec-helpers.spec.ts
@@ -169,3 +169,9 @@ export function bundleMaker(info: BundleMakerInfo) {
 ${i.books.map(({ slug, href }) => `<book slug="${slug}" href="${href}" />`).join('\n')}
 </container>`
 }
+
+export function newH5PPath(bundle: Bundle, nickname: string) {
+  return bundle.pathHelper.join(
+    bundle.workspaceRootUri, bundle.paths.publicRoot, nickname, 'h5p.json'
+  )
+}
diff --git a/server/src/model/utils.ts b/server/src/model/utils.ts
index 9e6f08f6..caeaf19e 100644
--- a/server/src/model/utils.ts
+++ b/server/src/model/utils.ts
@@ -4,6 +4,7 @@ import * as xpath from 'xpath-ts'
 import { type PageNode } from './page'
 import { type Factory } from './factory'
 import { type ResourceNode } from './resource'
+import { type H5PExercise } from './h5p-exercise'
 
 export const NS_COLLECTION = 'http://cnx.rice.edu/collxml'
 const NS_CNXML = 'http://cnx.rice.edu/cnxml'
@@ -66,12 +67,22 @@ export type TocNode<T> = TocSubbook<T> | TocPage<T>
 export interface TocSubbook<T> { type: TocNodeKind.Subbook, readonly title: string, readonly children: Array<TocNode<T>> }
 export interface TocPage<T> { type: TocNodeKind.Page, readonly page: T }
 
+export interface Paths {
+  booksRoot: string
+  pagesRoot: string
+  mediaRoot: string
+  privateRoot: string
+  publicRoot: string
+}
+
 export interface Bundleish {
   allPages: Factory<PageNode>
   allResources: Factory<ResourceNode>
+  allH5P: Factory<H5PExercise>
   workspaceRootUri: string
   isDuplicateUuid: (uuid: string) => boolean
   isDuplicateResourcePath: (path: string) => boolean
+  paths: Paths
 }
 
 export enum PathKind {
diff --git a/server/src/server-handler.ts b/server/src/server-handler.ts
index ac40d9fc..543d00f4 100644
--- a/server/src/server-handler.ts
+++ b/server/src/server-handler.ts
@@ -45,13 +45,16 @@ export function bundleGetSubmoduleConfig(): (request: BundleGetSubmoduleConfigPa
   }
 }
 
-export async function resourceAutocompleteHandler(documentPosition: CompletionParams, manager: ModelManager): Promise<CompletionItem[]> {
+export async function autocompleteHandler(documentPosition: CompletionParams, manager: ModelManager): Promise<CompletionItem[]> {
   await manager.loadEnoughForOrphans()
   const cursor = documentPosition.position
   const page = manager.bundle.allPages.get(documentPosition.textDocument.uri)
 
   if (page !== undefined) {
-    return manager.autocompleteResources(page, cursor)
+    return [
+      ...manager.autocompleteResources(page, cursor),
+      ...manager.autocompleteUrls(page, cursor)
+    ]
   }
   return []
 }
diff --git a/server/src/server.ts b/server/src/server.ts
index 01d4a505..811f6485 100644
--- a/server/src/server.ts
+++ b/server/src/server.ts
@@ -15,7 +15,7 @@ import { URI, Utils } from 'vscode-uri'
 import { expectValue } from './model/utils'
 
 import { ExtensionServerRequest } from '../../common/src/requests'
-import { bundleEnsureIdsHandler, bundleGenerateReadme, bundleGetSubmoduleConfig, resourceAutocompleteHandler } from './server-handler'
+import { bundleEnsureIdsHandler, bundleGenerateReadme, bundleGetSubmoduleConfig, autocompleteHandler } from './server-handler'
 
 import * as sourcemaps from 'source-map-support'
 import { Bundle } from './model/bundle'
@@ -160,7 +160,7 @@ connection.onCompletionResolve((a: CompletionItem, token: CancellationToken): Co
 
 connection.onCompletion(async (params: CompletionParams): Promise<CompletionItem[]> => {
   const manager = getBundleForUri(params.textDocument.uri)
-  return await resourceAutocompleteHandler(params, manager)
+  return await autocompleteHandler(params, manager)
 })
 connection.onDocumentLinks(async ({ textDocument }) => {
   const { uri } = textDocument