From 2568b5ccc41f77d020992bb71afcaac4f7c77612 Mon Sep 17 00:00:00 2001
From: Bogdan Abaev <bogdan@zotero.org>
Date: Thu, 13 Aug 2026 12:49:00 -0700
Subject: [PATCH] Semantic search on fulltext of attachments

Add optional pref to index and search fulltext of attachments.
When enabled, attachment IDs are enqueue after regular items,
notes, and annotations.

Added helpers to extract outline and sections from structured
text module. During indexing, the sections of the attachment
are extracted, large sections are broken into chunks, and
small sections are combined to fit into the context window
of the model. Then, each chunk is embedded with its outline
path as the prefix and added to embeddings table.
Each row now contains full text of the chunk
and it's path - a good amount of duplication needed to
ensure that we can reliably connect the embedding of
the chunk to its text for a preview.

On search in Best Match mode, attachment rows get the score
of the highest ranking chunk, so if there is a very relevant
chunk in an attachment, the regular item with a non-relevant
abstract will still rank highly.

When the attachment row is selected, top 5 matching chunks
appear in the new search results collapsible-section of
the item pane, so one can examine matching chunks
without opening the actual reader.
---
 .../content/zotero/collectionViewItemTree.jsx |   9 +-
 chrome/content/zotero/customElements.js       |   2 +
 chrome/content/zotero/elements/itemDetails.js |   2 +
 .../zotero/elements/itemPaneSidenav.js        |   2 +-
 .../zotero/elements/searchResultRow.js        | 131 +++
 .../zotero/elements/searchResultsBox.js       | 192 ++++
 .../preferences/preferences_advanced.js       |  22 +-
 .../preferences/preferences_advanced.xhtml    |   4 +
 chrome/content/zotero/xpcom/embeddings.js     | 821 +++++++++++++++---
 chrome/content/zotero/xpcom/sdt.js            | 267 ++++++
 chrome/locale/en-US/zotero/preferences.ftl    |   2 +
 chrome/locale/en-US/zotero/zotero.ftl         |  11 +
 defaults/preferences/zotero.js                |   2 +
 scss/_zotero.scss                             |   1 +
 scss/abstracts/_variables.scss                |   1 +
 scss/elements/_annotationRow.scss             |   6 +-
 scss/elements/_searchResultsBox.scss          |  75 ++
 test/tests/embeddingsTest.js                  | 687 ++++++++++++++-
 test/tests/sdtTest.js                         | 275 ++++++
 19 files changed, 2397 insertions(+), 115 deletions(-)
 create mode 100644 chrome/content/zotero/elements/searchResultRow.js
 create mode 100644 chrome/content/zotero/elements/searchResultsBox.js
 create mode 100644 scss/elements/_searchResultsBox.scss

diff --git a/chrome/content/zotero/collectionViewItemTree.jsx b/chrome/content/zotero/collectionViewItemTree.jsx
index 1415859e66..b7432fe5cf 100644
--- a/chrome/content/zotero/collectionViewItemTree.jsx
+++ b/chrome/content/zotero/collectionViewItemTree.jsx
@@ -206,8 +206,13 @@ class CollectionViewItemTreeRowProvider extends ItemTreeRowProvider {
 			);
 			let libraries = status.libraries
 				.filter(lib => !libraryIDs.size || libraryIDs.has(lib.libraryID));
-			let indexed = libraries.reduce((sum, lib) => sum + lib.indexed, 0);
-			let total = libraries.reduce((sum, lib) => sum + lib.eligible, 0);
+			// Coverage is coverage: attachment fulltext is reported separately
+			// in the preferences, but an incomplete index is incomplete
+			// whichever part of it is still filling in
+			let indexed = libraries.reduce(
+				(sum, lib) => sum + lib.indexed + lib.indexedAttachments, 0);
+			let total = libraries.reduce(
+				(sum, lib) => sum + lib.eligible + lib.eligibleAttachments, 0);
 			if (indexed >= total) {
 				return null;
 			}
diff --git a/chrome/content/zotero/customElements.js b/chrome/content/zotero/customElements.js
index 59b5b319bc..03f2108a53 100644
--- a/chrome/content/zotero/customElements.js
+++ b/chrome/content/zotero/customElements.js
@@ -74,6 +74,8 @@ Services.scriptloader.loadSubScript('chrome://zotero/content/elements/itemTreeMe
 		['attachment-row', 'chrome://zotero/content/elements/attachmentRow.js'],
 		['attachment-annotations-box', 'chrome://zotero/content/elements/attachmentAnnotationsBox.js'],
 		['annotation-row', 'chrome://zotero/content/elements/annotationRow.js'],
+		['search-results-box', 'chrome://zotero/content/elements/searchResultsBox.js'],
+		['search-result-row', 'chrome://zotero/content/elements/searchResultRow.js'],
 		['annotation-items-pane', 'chrome://zotero/content/elements/annotationItemsPane.js'],
 		['context-notes-list', 'chrome://zotero/content/elements/contextNotesList.js'],
 		['note-row', 'chrome://zotero/content/elements/noteRow.js'],
diff --git a/chrome/content/zotero/elements/itemDetails.js b/chrome/content/zotero/elements/itemDetails.js
index 2e9a705f0a..4fbcd62137 100644
--- a/chrome/content/zotero/elements/itemDetails.js
+++ b/chrome/content/zotero/elements/itemDetails.js
@@ -55,6 +55,8 @@
 						<tags-box id="zotero-editpane-tags" class="zotero-editpane-tags" data-pane="tags"/>
 
 						<related-box id="zotero-editpane-related" class="zotero-editpane-related" data-pane="related"/>
+
+						<search-results-box id="zotero-editpane-search-results" data-pane="search-results" hidden="true"/>
 					</html:div>
 				</html:div>
 			</hbox>
diff --git a/chrome/content/zotero/elements/itemPaneSidenav.js b/chrome/content/zotero/elements/itemPaneSidenav.js
index 8da724e7da..da0b3539e3 100644
--- a/chrome/content/zotero/elements/itemPaneSidenav.js
+++ b/chrome/content/zotero/elements/itemPaneSidenav.js
@@ -102,7 +102,7 @@
 		}
 
 		get _builtInPanes() {
-			return ["info", "abstract", "attachments", "notes", "note-info", "attachment-info", "attachment-annotations", "libraries-collections", "tags", "related"];
+			return ["info", "abstract", "attachments", "notes", "note-info", "attachment-info", "attachment-annotations", "libraries-collections", "tags", "related", "search-results"];
 		}
 
 		get container() {
diff --git a/chrome/content/zotero/elements/searchResultRow.js b/chrome/content/zotero/elements/searchResultRow.js
new file mode 100644
index 0000000000..9cb6a5d778
--- /dev/null
+++ b/chrome/content/zotero/elements/searchResultRow.js
@@ -0,0 +1,131 @@
+/*
+	***** BEGIN LICENSE BLOCK *****
+
+	Copyright © 2026 Corporation for Digital Scholarship
+					 Vienna, Virginia, USA
+					 https://www.zotero.org
+
+	This file is part of Zotero.
+
+	Zotero is free software: you can redistribute it and/or modify
+	it under the terms of the GNU Affero General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	Zotero is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU Affero General Public License for more details.
+
+	You should have received a copy of the GNU Affero General Public License
+	along with Zotero.  If not, see <http://www.gnu.org/licenses/>.
+
+	***** END LICENSE BLOCK *****
+*/
+
+"use strict";
+
+{
+	// A best-match search result card: one fulltext chunk of an attachment
+	// (see Zotero.Embeddings.getMatchingChunks()), presented like an
+	// annotation-row -- where the chunk sits in the document as the head,
+	// its text as the quote. The two share their styling (see
+	// scss/elements/_annotationRow.scss).
+	class SearchResultRow extends XULElementBase {
+		content = MozXULElement.parseXULToFragment(`
+			<html:div class="head">
+				<html:div class="title">
+					<html:span class="path"/>
+					<html:span class="part"/>
+				</html:div>
+				<html:div class="location"/>
+			</html:div>
+			<html:div class="body">
+				<html:div class="quote"/>
+				<html:button class="show-more" data-l10n-id="search-result-row-show-more" hidden="true"/>
+			</html:div>
+		`);
+
+		_chunk = null;
+
+		get chunk() {
+			return this._chunk;
+		}
+
+		set chunk(chunk) {
+			this._chunk = chunk;
+			this.render();
+		}
+
+		init() {
+			this._path = this.querySelector('.path');
+			this._part = this.querySelector('.part');
+			this._location = this.querySelector('.location');
+			this._quote = this.querySelector('.quote');
+			this._showMore = this.querySelector('.show-more');
+			this._showMore.addEventListener('click', (event) => {
+				// The card's activation (open the attachment) shouldn't fire
+				// for the toggle
+				event.stopPropagation();
+				this._toggleExpanded();
+			});
+			this.render();
+		}
+
+		render() {
+			if (!this.initialized || !this._chunk) return;
+
+			// The chunk's outline path says where in the document it came
+			// from; a chunk from a document without an outline falls back to
+			// a generic label
+			if (this._chunk.outlinePath) {
+				this._path.removeAttribute('data-l10n-id');
+				this._path.textContent = this._chunk.outlinePath;
+			}
+			else {
+				document.l10n.setAttributes(this._path, 'search-result-row-fulltext');
+			}
+			// Which piece of a split section this is, so a match reads as
+			// coming from the middle or the end of its section
+			let parts = this._chunk.sectionParts;
+			this._part.hidden = !(parts > 1);
+			if (parts > 1) {
+				this._part.textContent = `${this._chunk.sectionPart}/${parts}`;
+			}
+			// The page the chunk's section starts on, labeled the way
+			// annotation rows label theirs
+			this._location.hidden = !this._chunk.pageLabel;
+			if (this._chunk.pageLabel) {
+				this._location.textContent
+					= Zotero.getString('pdfReader.page') + ' ' + this._chunk.pageLabel;
+			}
+
+			this._quote.textContent = this._chunk.text || '';
+
+			// Offer "Show More" only when the quote is actually clamped,
+			// which is only measurable once the card has a layout
+			this.classList.remove('expanded');
+			this._showMore.hidden = true;
+			requestAnimationFrame(() => {
+				this._showMore.hidden
+					= this._quote.scrollHeight <= this._quote.clientHeight;
+			});
+
+			// A11y - make focusable and describe the card
+			this.setAttribute('tabindex', 0);
+			this.setAttribute('aria-label', [
+				this._chunk.outlinePath,
+				this._location.hidden ? '' : this._location.textContent,
+				this._chunk.text
+			].filter(Boolean).join('. '));
+		}
+
+		_toggleExpanded() {
+			let expanded = this.classList.toggle('expanded');
+			document.l10n.setAttributes(this._showMore,
+				expanded ? 'search-result-row-show-less' : 'search-result-row-show-more');
+		}
+	}
+
+	customElements.define('search-result-row', SearchResultRow);
+}
diff --git a/chrome/content/zotero/elements/searchResultsBox.js b/chrome/content/zotero/elements/searchResultsBox.js
new file mode 100644
index 0000000000..0afa3fde28
--- /dev/null
+++ b/chrome/content/zotero/elements/searchResultsBox.js
@@ -0,0 +1,192 @@
+/*
+	***** BEGIN LICENSE BLOCK *****
+
+	Copyright © 2026 Corporation for Digital Scholarship
+					 Vienna, Virginia, USA
+					 https://www.zotero.org
+
+	This file is part of Zotero.
+
+	Zotero is free software: you can redistribute it and/or modify
+	it under the terms of the GNU Affero General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	Zotero is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU Affero General Public License for more details.
+
+	You should have received a copy of the GNU Affero General Public License
+	along with Zotero.  If not, see <http://www.gnu.org/licenses/>.
+
+	***** END LICENSE BLOCK *****
+*/
+
+{
+	const { ItemPaneSectionElementBase } = ChromeUtils.importESModule(
+		"chrome://zotero/content/elements/itemPaneSectionElementBase.mjs",
+		{ global: "current" }
+	);
+
+	// Most matching chunks shown for an attachment
+	const MAX_RESULTS = 5;
+
+	// Why an attachment matched the active best-match search: cards with the
+	// fulltext chunks most similar to the query, so they can be previewed
+	// without opening the file. Shown only while a best-match search is
+	// active, for attachments with matching indexed chunks.
+	class SearchResultsBox extends ItemPaneSectionElementBase {
+		content = MozXULElement.parseXULToFragment(`
+			<collapsible-section data-l10n-id="section-search-results" data-pane="search-results">
+				<html:div class="body">
+				</html:div>
+			</collapsible-section>
+		`);
+
+		get item() {
+			return this._item;
+		}
+
+		set item(item) {
+			super.item = (item instanceof Zotero.Item && item.isFileAttachment()) ? item : null;
+			// A new item's emptiness isn't known until asyncRender scores it
+			this._count = undefined;
+		}
+
+		get collectionTreeRows() {
+			return super.collectionTreeRows;
+		}
+
+		// The item pane sets collectionTreeRows after item, so this is where
+		// everything visibility depends on is finally known
+		set collectionTreeRows(collectionTreeRows) {
+			super.collectionTreeRows = collectionTreeRows;
+			this._updateHidden();
+		}
+
+		init() {
+			this.initCollapsibleSection();
+			this._body = this.querySelector('.body');
+			// The header's count placeholder needs a value before the first
+			// async render fills in the real one
+			this._section.setCount(0);
+			// Double-click (or Enter on a focused card) opens the attachment
+			// at the chunk
+			this._body.addEventListener('dblclick', this._handleActivate);
+			this._body.addEventListener('keydown', (event) => {
+				if (event.key == 'Enter') {
+					this._handleActivate(event);
+				}
+			});
+		}
+
+		// The query the selected collection rows are ranked by, or false when
+		// no best-match search is active. Rows can be duck-typed stand-ins
+		// (e.g. the citation dialog's), which implement only part of the row
+		// API.
+		get _query() {
+			// Quick-search state (setSearch()) lives on collection tree row
+			// *instances*, and the ones passed down the item pane are
+			// re-fetched from the collections view at item-selection time --
+			// which can have rebuilt its rows since the items view got its
+			// own set. Only the items view's instances are guaranteed to
+			// carry the active search, so prefer those; the passed rows are
+			// the fallback for hosts without an items view.
+			let itemsView = this.closest('item-pane')?.itemsView;
+			let rows = itemsView?.collectionTreeRows?.length
+				? itemsView.collectionTreeRows
+				: this.collectionTreeRows;
+			for (let row of rows || []) {
+				if (typeof row.getBestMatchQuery == 'function') {
+					let query = row.getBestMatchQuery();
+					if (query) {
+						return query;
+					}
+				}
+			}
+			return false;
+		}
+
+		// A query change re-renders even when the item didn't change
+		get _renderDependencies() {
+			return [...super._renderDependencies, this._query];
+		}
+
+		render() {}
+
+		async asyncRender() {
+			if (!this.initialized) return;
+			if (this._isAlreadyRendered("async")) return;
+
+			let item = this.item;
+			let query = this._query;
+			this._body.replaceChildren();
+			if (!item || !query) {
+				return;
+			}
+
+			let chunks = [];
+			try {
+				chunks = await Zotero.Embeddings.getMatchingChunks(query, item.id,
+					{ limit: MAX_RESULTS });
+			}
+			catch (e) {
+				// Nothing to show while the model is still downloading or the
+				// index is being rebuilt
+				if (!(e instanceof Zotero.Embeddings.IndexNotReadyError)) {
+					Zotero.logError(e);
+				}
+			}
+			// Only fulltext chunks carry their own text; anything else about
+			// the item is already visible in the pane
+			chunks = chunks.filter(chunk => chunk.text);
+			// The selection may have moved on while scoring
+			if (this.item !== item) {
+				return;
+			}
+			this._count = chunks.length;
+			this._section.setCount(chunks.length);
+			this._updateHidden();
+			// Left in the order getMatchingChunks() returns them, strongest
+			// match first: with only a handful of cards shown, the best one
+			// earning the top slot matters more than reading them in
+			// document order
+			for (let chunk of chunks) {
+				let row = document.createXULElement('search-result-row');
+				row.chunk = chunk;
+				this._body.append(row);
+			}
+		}
+
+		// Open the attachment where the activated card's chunk is: for a PDF,
+		// scrolled to and highlighting the chunk's section; without a stored
+		// position (EPUB, snapshot, flat-text fallback), just open it
+		_handleActivate = (event) => {
+			let row = event.target.closest('search-result-row');
+			// The Show More toggle isn't an activation
+			if (!row || !this.item || event.target.closest('.show-more')) {
+				return;
+			}
+			if (typeof ZoteroPane == 'undefined') {
+				return;
+			}
+			let position = row.chunk?.position;
+			ZoteroPane.viewAttachment(this.item.id, null, false,
+				position ? { location: { position } } : undefined)
+				.catch(e => Zotero.logError(e));
+		};
+
+		_updateHidden() {
+			// Visible only for a file attachment during a best-match search;
+			// asyncRender hides it again when nothing matched. Deciding
+			// emptiness needs the async scoring, so unlike the annotations
+			// section this one can't know its final state synchronously --
+			// it appears, then empties out, rather than flickering in late.
+			this.hidden = !this.item || !this._query || this.tabType == 'reader'
+				|| this._count === 0;
+		}
+	}
+
+	customElements.define("search-results-box", SearchResultsBox);
+}
diff --git a/chrome/content/zotero/preferences/preferences_advanced.js b/chrome/content/zotero/preferences/preferences_advanced.js
index 69d53c69f4..23097cf7c2 100644
--- a/chrome/content/zotero/preferences/preferences_advanced.js
+++ b/chrome/content/zotero/preferences/preferences_advanced.js
@@ -152,13 +152,17 @@ Zotero_Preferences.Advanced = {
 	updateSemanticSearchUI: function (status) {
 		let statusBox = document.getElementById('semantic-search-status');
 		statusBox.hidden = !status.enabled;
+		// Fulltext indexing only means something with a model selected
+		document.getElementById('semantic-search-index-fulltext').disabled = !status.enabled;
 		if (!status.enabled) {
 			return;
 		}
 
 		// Phase / status message
 		let phaseLabel = document.getElementById('semantic-search-phase');
-		let hasRemaining = status.libraries.some(lib => lib.indexed < lib.eligible);
+		let hasRemaining = status.libraries.some(
+			lib => lib.indexed < lib.eligible
+				|| lib.indexedAttachments < lib.eligibleAttachments);
 		if (status.error) {
 			document.l10n.setAttributes(phaseLabel, 'preferences-advanced-semantic-search-error', { error: status.error });
 		}
@@ -214,10 +218,18 @@ Zotero_Preferences.Advanced = {
 				'value',
 				Zotero.Utilities.Internal.stringWithColon(lib.name)
 			);
-			grid.children[i * 2 + 1].setAttribute(
-				'value',
-				`${lib.indexed.toLocaleString()} / ${lib.eligible.toLocaleString()}`
-			);
+			// Attachment fulltext is reported on its own, since it's a much
+			// larger and much slower job than the rest -- one combined count
+			// would look stalled. With fulltext indexing off, none are
+			// eligible and only the item count is shown.
+			let counts = `${lib.indexed.toLocaleString()} / ${lib.eligible.toLocaleString()}`;
+			if (lib.eligibleAttachments) {
+				counts += ` ${Zotero.getString('general.and')} `
+					+ `${lib.indexedAttachments.toLocaleString()} / `
+					+ `${lib.eligibleAttachments.toLocaleString()} `
+					+ Zotero.getString('itemTypes.attachment');
+			}
+			grid.children[i * 2 + 1].setAttribute('value', counts);
 		});
 	},
 	
diff --git a/chrome/content/zotero/preferences/preferences_advanced.xhtml b/chrome/content/zotero/preferences/preferences_advanced.xhtml
index 7a66fa47d1..3617a6bab2 100644
--- a/chrome/content/zotero/preferences/preferences_advanced.xhtml
+++ b/chrome/content/zotero/preferences/preferences_advanced.xhtml
@@ -307,6 +307,10 @@
 			</hbox>
 			<description id="semantic-search-model-description"
 				data-l10n-id="preferences-advanced-semantic-search-model-description"/>
+			<checkbox id="semantic-search-index-fulltext"
+				data-l10n-id="preferences-advanced-semantic-search-index-fulltext"
+				preference="extensions.zotero.embeddings.indexFulltext"
+				native="true"/>
 			<vbox id="semantic-search-status" hidden="true">
 				<hbox align="center">
 					<label data-l10n-id="preferences-advanced-semantic-search-status"/>
diff --git a/chrome/content/zotero/xpcom/embeddings.js b/chrome/content/zotero/xpcom/embeddings.js
index 6100019982..097871facc 100644
--- a/chrome/content/zotero/xpcom/embeddings.js
+++ b/chrome/content/zotero/xpcom/embeddings.js
@@ -378,12 +378,34 @@ Zotero.Embeddings = new function () {
 			// Zotero.Embeddings.Chunking);
 			// every chunk row carries the hash of the item's full source text,
 			// and scoring takes the item's best chunk.
+			// An attachment fulltext chunk also records what and where it
+			// came from, so a match can be previewed and located without
+			// re-deriving the chunking: its text, its section's outline path,
+			// the top-level block range it covers, the page it starts on
+			// (pageLabel), a reader-navigable position (navPosition, JSON --
+			// see Zotero.SDT.getSections()), and which piece of a split
+			// section it is (sectionPart of sectionParts). All NULL for
+			// chunks of other item types, which are their own preview and
+			// location.
+			// An attachment that yields no text at all (missing file,
+			// password-protected, no text layer) gets a single row with a
+			// NULL embedding: a record that it was processed, so progress
+			// counts it and later passes skip it (via sourceHash) until the
+			// file changes. Scoring reads only rows with an embedding.
 			await Zotero.DB.queryAsync(
 				"CREATE TABLE embeddings.itemEmbeddings (\n"
 				+ "    itemID INTEGER NOT NULL,\n"
 				+ "    chunkIndex INTEGER NOT NULL,\n"
-				+ "    embedding BLOB NOT NULL,\n"
+				+ "    embedding BLOB,\n"
 				+ "    sourceHash TEXT NOT NULL,\n"
+				+ "    chunkText TEXT,\n"
+				+ "    outlinePath TEXT,\n"
+				+ "    startBlock INTEGER,\n"
+				+ "    endBlock INTEGER,\n"
+				+ "    pageLabel TEXT,\n"
+				+ "    navPosition TEXT,\n"
+				+ "    sectionPart INTEGER,\n"
+				+ "    sectionParts INTEGER,\n"
 				+ "    PRIMARY KEY (itemID, chunkIndex)\n"
 				+ ")"
 			);
@@ -1095,6 +1117,39 @@ Zotero.Embeddings = new function () {
 		return new Float32Array(bytes.buffer);
 	}
 
+	// The shared guards of the scoring paths: wait out any in-progress model
+	// switch, so a query isn't embedded with one model and compared against
+	// another's vectors, and confirm the stored vectors were produced by the
+	// active model -- during a switch, or a reindex after a revision bump,
+	// the database isn't stamped for the new model until the indexer starts
+	// filling it. Returns the model's calibration: indexing calibrates the
+	// model before it writes a single vector, so a database stamped for this
+	// model always has one to go with it -- but the numbers still have to be
+	// read into memory, since getScoreFraction() reads them synchronously
+	// while rendering.
+	async function _requireReadyIndex() {
+		await Zotero.Embeddings.Indexing.waitForPendingModelSwitch();
+		await Zotero.Embeddings.initDB();
+		let modelVersion = Zotero.Embeddings.getModelVersion();
+		let indexedVersion = await Zotero.DB.valueQueryAsync(
+			"SELECT value FROM embeddings.itemEmbeddingsMeta WHERE key='modelVersion'"
+		);
+		if (indexedVersion !== modelVersion) {
+			throw new Zotero.Embeddings.IndexNotReadyError(
+				`Embeddings index is for '${indexedVersion || 'no model'}', `
+					+ `but the active model is '${modelVersion}'`
+			);
+		}
+		let calibration = await Zotero.Embeddings.loadCalibration();
+		if (!calibration) {
+			throw new Zotero.Embeddings.IndexNotReadyError(
+				`Embeddings index is stamped for '${modelVersion}' but the model `
+					+ `has no calibration`
+			);
+		}
+		return calibration;
+	}
+
 	/**
 	 * Score a given set of items by similarity to a query. Items scoring below
 	 * the model's measured minimum aren't matches and aren't returned (see
@@ -1120,34 +1175,7 @@ Zotero.Embeddings = new function () {
 		if (!itemIDs.length || !this.isEnabled()) {
 			return scores;
 		}
-		// Wait out any in-progress model switch, so the query isn't embedded
-		// with one model and compared against another's vectors
-		await Zotero.Embeddings.Indexing.waitForPendingModelSwitch();
-		await this.initDB();
-		// The stored vectors must have been produced by the active model.
-		// During a switch, or a reindex after a revision bump, the database
-		// isn't stamped for the new model until the indexer starts filling it.
-		let modelVersion = this.getModelVersion();
-		let indexedVersion = await Zotero.DB.valueQueryAsync(
-			"SELECT value FROM embeddings.itemEmbeddingsMeta WHERE key='modelVersion'"
-		);
-		if (indexedVersion !== modelVersion) {
-			throw new this.IndexNotReadyError(
-				`Embeddings index is for '${indexedVersion || 'no model'}', `
-					+ `but the active model is '${modelVersion}'`
-			);
-		}
-		// Indexing calibrates the model before it writes a single vector, so a
-		// database stamped for this model always has a calibration to go with
-		// it -- but the numbers still have to be read into memory, since
-		// getScoreFraction() reads them synchronously while rendering.
-		let calibration = await this.loadCalibration();
-		if (!calibration) {
-			throw new this.IndexNotReadyError(
-				`Embeddings index is stamped for '${modelVersion}' but the model `
-					+ `has no calibration`
-			);
-		}
+		let calibration = await _requireReadyIndex();
 		let generation = _modelGeneration;
 		let query = _center(await this.embedQuery(queryText));
 		let minScore = calibration.minScore;
@@ -1169,9 +1197,11 @@ Zotero.Embeddings = new function () {
 				throw new this.IndexNotReadyError('Model changed during scoring');
 			}
 			let chunk = itemIDs.slice(i, i + chunkSize);
+			// Rows without an embedding are processed-but-empty markers (see
+			// _setUpDB()), with nothing to score
 			let rows = await Zotero.DB.queryAsync(
 				"SELECT itemID, embedding FROM embeddings.itemEmbeddings WHERE itemID IN ("
-					+ chunk.map(() => '?').join(',') + ")",
+					+ chunk.map(() => '?').join(',') + ") AND embedding IS NOT NULL",
 				chunk
 			);
 			for (let row of rows) {
@@ -1207,6 +1237,55 @@ Zotero.Embeddings = new function () {
 		}
 		return scores;
 	};
+
+	/**
+	 * The chunks of a single item most similar to a query, each with where in
+	 * the item it came from -- for surfacing why an item matched (e.g. which
+	 * section of an attachment's full text). Chunks scoring below the model's
+	 * measured minimum aren't matches and aren't returned.
+	 *
+	 * The text and location fields describe attachment fulltext chunks (see
+	 * the itemEmbeddings table); for other item types they're null, and the
+	 * item itself is the preview and the location.
+	 *
+	 * @param {String} queryText
+	 * @param {Number} itemID
+	 * @param {Object} [options]
+	 * @param {Number} [options.limit=3] - Most chunks to return
+	 * @return {Promise<Object[]>} - [{ chunkIndex, score, text, outlinePath,
+	 *     startBlock, endBlock, pageLabel, position, sectionPart,
+	 *     sectionParts }], best first, ties broken by position in the text.
+	 *     chunkIndex is document order, for callers that want to re-sort.
+	 */
+	this.getMatchingChunks = async function (queryText, itemID, { limit = 3 } = {}) {
+		if (!this.isEnabled()) {
+			return [];
+		}
+		let calibration = await _requireReadyIndex();
+		let query = _center(await this.embedQuery(queryText));
+		let rows = await Zotero.DB.queryAsync(
+			"SELECT chunkIndex, embedding, chunkText, outlinePath, startBlock, endBlock, "
+				+ "pageLabel, navPosition, sectionPart, sectionParts "
+				+ "FROM embeddings.itemEmbeddings WHERE itemID=? AND embedding IS NOT NULL",
+			itemID
+		);
+		return rows
+			.map(row => ({
+				chunkIndex: row.chunkIndex,
+				score: this.dot(query, _center(_blobToVector(row.embedding))),
+				text: row.chunkText,
+				outlinePath: row.outlinePath,
+				startBlock: row.startBlock,
+				endBlock: row.endBlock,
+				pageLabel: row.pageLabel,
+				position: row.navPosition ? JSON.parse(row.navPosition) : null,
+				sectionPart: row.sectionPart,
+				sectionParts: row.sectionParts
+			}))
+			.filter(chunk => chunk.score >= calibration.minScore)
+			.sort((a, b) => (b.score - a.score) || (a.chunkIndex - b.chunkIndex))
+			.slice(0, limit);
+	};
 };
 
 
@@ -1214,9 +1293,9 @@ Zotero.Embeddings = new function () {
  * Zotero.Embeddings.Chunking -- splitting a text into passages small enough to
  * each be embedded on their own, so a long text's later paragraphs are
  * searchable instead of being averaged into one vector or truncated away by the
- * pipeline. The indexer applies this only to notes. Chunk size is bounded by
- * CHUNK_MAX_TOKENS, capped by the model's window, and counted in the model's
- * own tokens.
+ * pipeline. The indexer applies this to notes (chunkText()) and to attachment
+ * full text (chunkSections()). Chunk size is bounded by CHUNK_MAX_TOKENS,
+ * capped by the model's window, and counted in the model's own tokens.
  */
 Zotero.Embeddings.Chunking = new function () {
 	// Tokens carried over from the end of one chunk into the start of the
@@ -1234,6 +1313,14 @@ Zotero.Embeddings.Chunking = new function () {
 	// out paragraph-sized, so this decides only how long a text has to be before
 	// it's split at all, and how far a single oversized paragraph is split.
 	const CHUNK_MAX_TOKENS = 768;
+	// Most characters to feed the tokenizer in one encode() call. The
+	// multilingual models' SentencePiece Unigram tokenizer is quadratic in
+	// input length -- its Metaspace pre-tokenizer doesn't split at whitespace,
+	// so the whole input goes through the Viterbi lattice as one string, and a
+	// single long encode can take seconds. Segments this size keep every call
+	// in the tokenizer's linear regime, and token counts are additive across
+	// whitespace boundaries, so the segmented measurement is exact.
+	const TOKENIZER_SEGMENT_CHARS = 1000;
 
 	// Tokenizer instances by model name. Failures aren't cached, so a later
 	// indexing run retries the load.
@@ -1288,31 +1375,94 @@ Zotero.Embeddings.Chunking = new function () {
 	// chunk's own text may use.
 	//
 	// Counts leave out the special tokens the tokenizer wraps every input in, so
-	// that the counts of several sentences add up to the count of those sentences
-	// joined. The even split in _splitBlockEvenly() depends on that: counting
-	// them per sentence would inflate a piece's measured size in proportion to
-	// how many sentences it holds, while a block is measured in one call, and the
-	// pieces would come out lopsided.
+	// that the counts of several pieces of text add up to the count of those
+	// pieces joined. That additivity is what the whole chunking flow leans on:
+	// a text is tokenized exactly once, at paragraph granularity
+	// (_measureParagraphs()), and every level above -- blocks, sections, groups
+	// of sections -- is sized by summing those counts (_sumTokens()) instead of
+	// re-tokenizing the same text. `joinTokens` is what one '\n\n' join adds
+	// once paragraphs are put back together, measured rather than assumed
+	// (a SentencePiece model can spend a token on collapsed whitespace), so
+	// sums charge it per join.
 	//
 	// Those special tokens come off the window instead, together with the
 	// passage prefix embedPassages() prepends -- neither is part of the text this
 	// code sees, but both take up room once the chunk is embedded.
 	function _getMetrics(tokenizer) {
 		let specialTokens = tokenizer.encode('').length;
-		let count = text => tokenizer.encode(text).length - specialTokens;
+		// Measured in segments (see _splitForTokenizer()), so a long paragraph
+		// never hits the tokenizer's quadratic regime in a single call
+		let count = text => _splitForTokenizer(text).reduce(
+			(sum, segment) => sum + tokenizer.encode(segment).length - specialTokens,
+			0
+		);
 		let prefix = Zotero.Embeddings.getPassagePrefix();
 		return {
 			count,
+			joinTokens: Math.max(0, count('a\n\na') - 2 * count('a')),
 			budget: Math.min(CHUNK_MAX_TOKENS, Zotero.Embeddings.getModelMaxTokens())
 				- specialTokens - (prefix ? count(prefix) : 0)
 		};
 	}
 
+	// The paragraphs of a text, each counted exactly once -- the single place
+	// chunking pays for tokenization
+	function _measureParagraphs(text, count) {
+		return text.split(/\n+/)
+			.map(paragraph => paragraph.trim())
+			.filter(Boolean)
+			.map(paragraph => ({ text: paragraph, tokens: count(paragraph) }));
+	}
+
+	// Tokens of the given paragraphs once joined back together, charging
+	// joinTokens per join (see _getMetrics())
+	function _sumTokens(paragraphs, joinTokens) {
+		if (!paragraphs.length) {
+			return 0;
+		}
+		return paragraphs.reduce((sum, paragraph) => sum + paragraph.tokens, 0)
+			+ joinTokens * (paragraphs.length - 1);
+	}
+
+	// A text in segments of at most TOKENIZER_SEGMENT_CHARS, each ending
+	// right before a whitespace character, so the next segment carries it and
+	// the tokenizer sees every word with its leading space. Text with no
+	// whitespace in a whole window (e.g., unsegmented CJK) is cut mid-run,
+	// which can miscount by a token per boundary -- noise against the budget.
+	function _splitForTokenizer(text) {
+		if (text.length <= TOKENIZER_SEGMENT_CHARS) {
+			return [text];
+		}
+		let segments = [];
+		let start = 0;
+		while (start < text.length) {
+			let end = Math.min(start + TOKENIZER_SEGMENT_CHARS, text.length);
+			if (end < text.length) {
+				for (let i = end; i > start; i--) {
+					if (/\s/.test(text[i])) {
+						end = i;
+						break;
+					}
+				}
+			}
+			segments.push(text.slice(start, end));
+			start = end;
+		}
+		return segments;
+	}
+
 	// Last resort for text with no sentence boundary inside the budget: window
 	// it by tokens.
 	function _hardSplit(text, budget, tokenizer) {
 		let pieces = [];
-		let ids = tokenizer.encode(text);
+		// Encoded in segments for the same reason count() measures in them
+		// (see _splitForTokenizer()). Each segment keeps its special-token
+		// wrapper -- stripping it would mean knowing how the tokenizer splits
+		// it between start and end -- so a window can hold a few interior
+		// special tokens; decode skips them, and a piece just lands a few
+		// tokens under the budget.
+		let ids = _splitForTokenizer(text)
+			.flatMap(segment => [...tokenizer.encode(segment)]);
 		let step = Math.max(1, budget - CHUNK_OVERLAP_TOKENS);
 		for (let start = 0; start < ids.length; start += step) {
 			let piece = tokenizer
@@ -1435,17 +1585,24 @@ Zotero.Embeddings.Chunking = new function () {
 	 */
 	this.chunkText = async function (text) {
 		let tokenizer = await this.getTokenizer();
-		let { count, budget } = _getMetrics(tokenizer);
+		let metrics = _getMetrics(tokenizer);
+		let paragraphs = _measureParagraphs(text, metrics.count);
+		return _chunkParagraphs(text, paragraphs, metrics.budget, metrics, tokenizer);
+	};
+
+	// The paragraph-level chunker behind chunkText(), over paragraphs already
+	// measured by _measureParagraphs() -- everything here is sized by summing
+	// their counts, so no text is tokenized a second time. The budget is the
+	// caller's, so chunkSections() can reserve part of the window for a
+	// section's outline-path prefix. `text` is what a fitting result returns
+	// as its single chunk, joins and all.
+	function _chunkParagraphs(text, paragraphs, budget, metrics, tokenizer) {
+		let { count, joinTokens } = metrics;
 		// Text that fits the window as it stands, which is most of it
-		if (count(text) <= budget) {
+		if (_sumTokens(paragraphs, joinTokens) <= budget) {
 			return [text];
 		}
 
-		let paragraphs = text.split(/\n+/)
-			.map(paragraph => paragraph.trim())
-			.filter(Boolean)
-			.map(paragraph => ({ text: paragraph, tokens: count(paragraph) }));
-
 		// Group paragraphs into blocks, combining any that are too small to
 		// stand alone with the paragraphs that follow them. A paragraph that
 		// reaches the minimum on its own becomes its own block, which is what
@@ -1454,7 +1611,7 @@ Zotero.Embeddings.Chunking = new function () {
 		let pending = [];
 		let pendingTokens = 0;
 		for (let paragraph of paragraphs) {
-			pending.push(paragraph.text);
+			pending.push(paragraph);
 			pendingTokens += paragraph.tokens;
 			if (pendingTokens >= CHUNK_MIN_TOKENS) {
 				groups.push(pending);
@@ -1476,10 +1633,10 @@ Zotero.Embeddings.Chunking = new function () {
 
 		let chunks = [];
 		for (let group of groups) {
-			// Recount rather than summing the paragraphs, so the joins between
-			// them are part of the block's size
-			let blockText = group.join('\n\n');
-			let block = { text: blockText, tokens: count(blockText) };
+			let block = {
+				text: group.map(paragraph => paragraph.text).join('\n\n'),
+				tokens: _sumTokens(group, joinTokens)
+			};
 			if (block.tokens <= budget) {
 				chunks.push(block.text);
 			}
@@ -1488,6 +1645,137 @@ Zotero.Embeddings.Chunking = new function () {
 			}
 		}
 		return chunks.length ? chunks : [text];
+	}
+
+	/**
+	 * Split a document's outline sections (see Zotero.SDT.getSections()) into
+	 * chunks that each fit the active model's context window. Sections play
+	 * the role paragraphs play in chunkText(), one level up: a section is the
+	 * topic unit, so two of them never share a chunk unless one was too small
+	 * to embed on its own, and a section over the window is split by the
+	 * paragraph machinery. Each chunk points back at the section blocks it
+	 * covers, so a match can be located in the document later.
+	 *
+	 * Sections marked `auxiliary` (captions, image descriptions) are exempt
+	 * from the too-small merging in both directions: each becomes exactly
+	 * one chunk (flagged `auxiliary`), so it can surface on its own without
+	 * ever mixing into the running text.
+	 *
+	 * A chunk's `embedText` -- what actually gets embedded -- is its text
+	 * prefixed with its section's outline path (e.g. "Methods >
+	 * Participants"), giving a section fragment the context of its headings;
+	 * the prefix comes out of the chunk's token budget. `text` stays the
+	 * plain piece, for display.
+	 *
+	 * Each chunk carries its section's location (pageIndex, pageLabel,
+	 * position -- see Zotero.SDT.getSections()), and its place within the
+	 * section: sectionPart / sectionParts say which piece of a split section
+	 * this is, so a match can be read as coming from the middle or the end
+	 * of its section. Splitting happens at sentence granularity, blind to
+	 * blocks, so the pieces of one section share its location.
+	 *
+	 * @param {Object[]} sections - [{ text, outlinePath, startBlock, endBlock,
+	 *     pageIndex, pageLabel, position }]
+	 * @return {Promise<Object[]>} - [{ text, embedText, outlinePath,
+	 *     startBlock, endBlock, pageIndex, pageLabel, position,
+	 *     sectionPart, sectionParts }]
+	 */
+	this.chunkSections = async function (sections) {
+		let tokenizer = await this.getTokenizer();
+		let metrics = _getMetrics(tokenizer);
+		let { count, joinTokens, budget } = metrics;
+
+		// Group sections into chunk-worthy units, combining any too small to
+		// stand alone with the sections that follow them -- same policy as
+		// chunkText()'s paragraph grouping. Each section is measured once, at
+		// paragraph granularity, and carries its paragraphs forward, so no
+		// later stage tokenizes the same text again.
+		let groups = [];
+		let pending = null;
+		// Index of the last body group, for the trailing merge below
+		let lastBodyGroup = -1;
+		for (let section of sections) {
+			if (!section.text) {
+				continue;
+			}
+			let paragraphs = _measureParagraphs(section.text, count);
+			let tokens = _sumTokens(paragraphs, joinTokens);
+			// An auxiliary section (caption, image description) is its own
+			// chunk no matter how small: indexed and searchable on its own,
+			// never mixed into the running text. The body sections around it
+			// still merge with each other -- `pending` just carries across.
+			if (section.auxiliary) {
+				groups.push({ sections: [section], paragraphs, auxiliary: true });
+				continue;
+			}
+			if (pending) {
+				pending.sections.push(section);
+				pending.paragraphs.push(...paragraphs);
+				pending.tokens += tokens;
+			}
+			else {
+				pending = { sections: [section], paragraphs, tokens };
+			}
+			if (pending.tokens >= CHUNK_MIN_TOKENS) {
+				lastBodyGroup = groups.length;
+				groups.push(pending);
+				pending = null;
+			}
+		}
+		// A trailing group still under the minimum joins the previous body
+		// group rather than standing alone as a runt chunk -- never an
+		// auxiliary group, which stays exactly its own text
+		if (pending) {
+			if (lastBodyGroup >= 0) {
+				let last = groups[lastBodyGroup];
+				last.sections.push(...pending.sections);
+				last.paragraphs.push(...pending.paragraphs);
+			}
+			else {
+				groups.push(pending);
+			}
+		}
+		// Body sections merge across the auxiliary sections between them, so
+		// a group can close after an auxiliary group whose blocks it
+		// precedes. Chunk indexes are document order (the UI sorts by them),
+		// so restore it here.
+		groups.sort((a, b) => (a.sections[0].startBlock ?? 0) - (b.sections[0].startBlock ?? 0));
+
+		let chunks = [];
+		for (let group of groups) {
+			// A merged group takes its first section's outline path -- the
+			// heading its text starts under
+			let outlinePath = group.sections[0].outlinePath || '';
+			let startBlock = group.sections[0].startBlock;
+			let endBlock = group.sections[group.sections.length - 1].endBlock;
+			let prefix = outlinePath ? outlinePath + '\n\n' : '';
+			let prefixTokens = prefix ? count(prefix) : 0;
+			// A pathological outline path that would eat a real share of the
+			// window hurts more than it helps
+			if (prefixTokens > budget / 4) {
+				prefix = '';
+				prefixTokens = 0;
+			}
+			let text = group.sections.map(section => section.text).join('\n\n');
+			let first = group.sections[0];
+			let pieces = _chunkParagraphs(text, group.paragraphs, budget - prefixTokens, metrics, tokenizer);
+			for (let i = 0; i < pieces.length; i++) {
+				chunks.push({
+					text: pieces[i],
+					embedText: prefix + pieces[i],
+					outlinePath,
+					startBlock,
+					endBlock,
+					pageIndex: first.pageIndex ?? null,
+					pageLabel: first.pageLabel ?? null,
+					position: first.position ?? null,
+					sectionPart: i + 1,
+					sectionParts: pieces.length,
+					auxiliary: !!group.auxiliary
+				});
+			}
+		}
+		return chunks;
 	};
 };
 
@@ -1532,6 +1820,9 @@ Zotero.Embeddings.Indexing = new function () {
 	// Wait longer than the usual debounce before retrying a run that was held
 	// off for memory
 	const LOW_MEMORY_RETRY_DELAY = 5 * 60 * 1000;
+	// Most often the per-library status counts are recomputed during a run,
+	// since each refresh is a pass over the database
+	const STATUS_REFRESH_INTERVAL = 5000;
 	// Debounce before starting the consumer, so a burst of changes (e.g. an
 	// import) is picked up in one pass
 	const KICK_DELAY = 3000;
@@ -1566,6 +1857,14 @@ Zotero.Embeddings.Indexing = new function () {
 			_switchModel();
 		});
 
+		// Toggling fulltext indexing changes what's eligible: on, the newly
+		// eligible attachments get indexed; off, their stored chunks are
+		// pruned. Unlike a model switch, nothing already stored goes stale,
+		// so the rest of the index is left alone.
+		Zotero.Prefs.registerObserver('embeddings.indexFulltext', () => {
+			_onIndexFulltextChange().catch(e => Zotero.logError(e));
+		});
+
 		Zotero.Notifier.registerObserver({
 			notify: async (event, type, ids) => {
 				if (type !== 'item' || !Zotero.Embeddings.isEnabled()) {
@@ -1658,6 +1957,24 @@ Zotero.Embeddings.Indexing = new function () {
 		}
 	}
 
+	async function _onIndexFulltextChange() {
+		if (!Zotero.Embeddings.isEnabled()) {
+			return;
+		}
+		if (_indexFulltextEnabled()) {
+			// Turning fulltext indexing on is a request to index the
+			// attachments, so it also resumes a stopped indexer
+			await Zotero.Embeddings.Indexing.startIndexing();
+		}
+		else {
+			// The attachments are no longer eligible, so the ordinary orphan
+			// pruning drops their chunks -- without restarting a paused indexer
+			await Zotero.Embeddings.initDB();
+			await _pruneOrphanedEmbeddings(await _getEligibleItemIDs());
+			await Zotero.Embeddings.Indexing.refreshStatus();
+		}
+	}
+
 	// Debounce before starting the consumer, so a burst of changes (e.g. an
 	// import) is picked up in one pass. Enqueued ids just sit in the queue
 	// until the consumer runs.
@@ -1745,27 +2062,37 @@ Zotero.Embeddings.Indexing = new function () {
 	// - a note with at least three words in its plain text
 	// - an annotation with at least three words across the passage it marks
 	//   and its comment
+	// - with fulltext indexing enabled, a PDF/EPUB/snapshot attachment. Its
+	//   text lives in a file, so there's no cheap word test here: one that
+	//   yields no text at indexing time is recorded as processed instead
+	//   (see _indexItems()), so the progress counts still converge.
 	// Everything that needs to know what's eligible -- enqueueing, pruning,
 	// progress counts -- works from this result, and _indexItems() skips items
 	// by the same per-type tests (see _getIndexableText()), so the counts and
 	// the index stay in agreement.
 	//
-	// @return {Promise<Map>} - libraryID -> [itemID, ...]
+	// Attachments are kept apart from the rest: their text costs orders of
+	// magnitude more to index, so they're enqueued last, ordered smallest
+	// first, and reported on their own line rather than buried in one total
+	// that barely moves.
+	//
+	// @return {Promise<Map>} - libraryID -> { items: [itemID, ...],
+	//     attachments: [itemID, ...] }
 	async function _getEligibleItemIDs() {
 		let fieldIDs = Zotero.Embeddings.getIndexedFieldIDs();
 		let byLibrary = new Map();
 		let seen = new Set();
-		let add = (row) => {
+		let add = (row, kind = 'items') => {
 			if (seen.has(row.itemID)) {
 				return;
 			}
 			seen.add(row.itemID);
-			let ids = byLibrary.get(row.libraryID);
-			if (!ids) {
-				ids = [];
-				byLibrary.set(row.libraryID, ids);
+			let eligible = byLibrary.get(row.libraryID);
+			if (!eligible) {
+				eligible = { items: [], attachments: [] };
+				byLibrary.set(row.libraryID, eligible);
 			}
-			ids.push(row.itemID);
+			eligible[kind].push(row.itemID);
 		};
 		let rows = await Zotero.DB.queryAsync(
 			"SELECT libraryID, itemID, value FROM itemData "
@@ -1803,9 +2130,55 @@ Zotero.Embeddings.Indexing = new function () {
 				add(row);
 			}
 		}
+		if (_indexFulltextEnabled()) {
+			// Ordering attachments by size compares the
+			// two things the fulltext index records -- characters for EPUBs and
+			// snapshots, pages for PDFs -- so page counts are scaled to roughly the
+			// characters they stand for.
+			const CHARS_PER_PAGE = 3000;
+			const UNKNOWN_ATTACHMENT_SIZE = 99999999;
+			// The SQL mirror of _isIndexableAttachment(): stored or linked
+			// PDFs and EPUBs, and snapshots (which are always stored),
+			// smallest first so that one enormous book doesn't sit at the
+			// head of the queue while the rest of the library waits behind
+			// it. Size is taken from Zotero's own fulltext index, which
+			// already knows it for virtually every attachment -- unlike
+			// measuring the files, which would mean a filesystem call per
+			// attachment every time this runs.
+			rows = await Zotero.DB.queryAsync(
+				"SELECT libraryID, itemID FROM itemAttachments "
+					+ "JOIN items USING (itemID) "
+					+ "LEFT JOIN fulltextItems USING (itemID) "
+					+ "WHERE (contentType IN ('application/pdf', 'application/epub+zip') "
+						+ "AND linkMode!=?) "
+					+ "OR (contentType='text/html' AND linkMode=?) "
+					+ "ORDER BY COALESCE(totalChars, totalPages * ?, ?), itemID",
+				[
+					Zotero.Attachments.LINK_MODE_LINKED_URL,
+					Zotero.Attachments.LINK_MODE_IMPORTED_URL,
+					CHARS_PER_PAGE,
+					UNKNOWN_ATTACHMENT_SIZE
+				]
+			);
+			for (let row of rows) {
+				add(row, 'attachments');
+			}
+		}
 		return byLibrary;
 	}
 
+	// Whether attachment full text is part of the index (see the
+	// embeddings.indexFulltext pref)
+	function _indexFulltextEnabled() {
+		return !!Zotero.Prefs.get('embeddings.indexFulltext');
+	}
+
+	// Whether an item is an attachment whose full text can be indexed --
+	// the types Zotero.SDT can extract structured text from
+	function _isIndexableAttachment(item) {
+		return item.isPDFAttachment() || item.isEPUBAttachment() || item.isSnapshotAttachment();
+	}
+
 	// The stored text an annotation's eligibility is judged by, shared by the
 	// SQL-side eligibility pass and _indexItems() so both test the same thing.
 	// A cheap tag strip -- annotation text and comments carry only simple
@@ -1814,14 +2187,25 @@ Zotero.Embeddings.Indexing = new function () {
 		return [text, comment].filter(Boolean).join(' ').replace(/<\/?[a-z][^>]*>/gi, ' ');
 	}
 
-	// Enqueue every eligible item, library by library, so the queue drains
-	// one library at a time. indexItems() skips items whose stored embedding
-	// is already current (via sourceHash), so re-enqueueing everything on
-	// each start is cheap for already-indexed items.
+	// Enqueue every eligible item in two passes: first every library's items,
+	// notes, and annotations, then every library's attachments. That index is
+	// cheap and immediately useful, so it fills in across all libraries
+	// before the far slower fulltext extraction starts anywhere -- no
+	// library's metadata waits behind another library's documents.
+	//
+	// This governs full passes only. Items the notifier enqueues as they
+	// change go in on arrival, so editing a huge PDF still indexes it now
+	// rather than deferring it behind everything else.
 	function _enqueueAllLibraries(eligibleByLibrary) {
-		for (let library of _indexableLibraries()) {
-			for (let id of eligibleByLibrary.get(library.libraryID) || []) {
-				_queue.add(id);
+		for (let kind of ['items', 'attachments']) {
+			for (let library of _indexableLibraries()) {
+				let eligible = eligibleByLibrary.get(library.libraryID);
+				if (!eligible) {
+					continue;
+				}
+				for (let id of eligible[kind]) {
+					_queue.add(id);
+				}
 			}
 		}
 	}
@@ -1831,8 +2215,11 @@ Zotero.Embeddings.Indexing = new function () {
 	async function _pruneOrphanedEmbeddings(eligibleByLibrary) {
 		await Zotero.Embeddings.initDB();
 		let eligible = new Set();
-		for (let ids of eligibleByLibrary.values()) {
-			for (let id of ids) {
+		for (let { items, attachments } of eligibleByLibrary.values()) {
+			for (let id of items) {
+				eligible.add(id);
+			}
+			for (let id of attachments) {
 				eligible.add(id);
 			}
 		}
@@ -1873,14 +2260,21 @@ Zotero.Embeddings.Indexing = new function () {
 		}
 	}
 
-	// Number of items in a library that have a stored embedding -- the
-	// numerator for indexing progress. An item's chunks count as one item.
-	function _getIndexedCount(libraryID) {
-		return Zotero.DB.valueQueryAsync(
-			"SELECT COUNT(DISTINCT itemID) FROM embeddings.itemEmbeddings "
-				+ "JOIN items USING (itemID) WHERE libraryID=?",
-			libraryID
+	// Items in a library that have a stored embedding -- the numerators for
+	// indexing progress, split the way _getEligibleItemIDs() splits the
+	// denominators. An item's chunks count as one item, and an attachment
+	// recorded as processed-but-empty counts as done (see _indexItems()).
+	async function _getIndexedCounts(libraryID) {
+		let attachmentTypeID = Zotero.ItemTypes.getID('attachment');
+		let row = await Zotero.DB.rowQueryAsync(
+			"SELECT "
+				+ "COUNT(DISTINCT CASE WHEN itemTypeID!=? THEN itemID END) AS items, "
+				+ "COUNT(DISTINCT CASE WHEN itemTypeID=? THEN itemID END) AS attachments "
+				+ "FROM embeddings.itemEmbeddings JOIN items USING (itemID) "
+				+ "WHERE libraryID=?",
+			[attachmentTypeID, attachmentTypeID, libraryID]
 		);
+		return { items: row.items, attachments: row.attachments };
 	}
 
 
@@ -1971,6 +2365,123 @@ Zotero.Embeddings.Indexing = new function () {
 		return title || abstract;
 	}
 
+	// The staleness key for an attachment's stored chunks, standing in for
+	// the text hash other item types use. Derived from the file's identity
+	// (path, size, mtime) rather than its extracted text, so the skip check
+	// every indexing pass runs costs a stat rather than an extraction. A
+	// change to the extraction or chunking logic isn't detected -- rebuild
+	// the index after one. (Nor is a pack regenerated for a processor bump
+	// without the file changing -- the vectors stay derived from the older
+	// extraction until the file changes or the index is rebuilt.)
+	// Returns null when the attachment has no readable file, which also
+	// means there's nothing to extract.
+	async function _getAttachmentSourceHash(item) {
+		try {
+			let path = await item.getFilePathAsync();
+			if (!path) {
+				return null;
+			}
+			let { size, lastModified } = await IOUtils.stat(path);
+			return Zotero.Utilities.Internal.md5([path, size, lastModified].join('|'));
+		}
+		catch (e) {
+			if (e.name !== 'NotFoundError') {
+				Zotero.logError(e);
+			}
+			return null;
+		}
+	}
+
+	// The document's sections (see Zotero.SDT.getSections()) as things to
+	// index. Reference entries are dropped: a bibliography is keyword-dense
+	// but says nothing, so it crowds out real matches, and literal search
+	// still covers it via the fulltext index. Auxiliary blocks (captions,
+	// image descriptions) are lifted out into standalone sections: each is
+	// worth finding on its own, but isn't part of the running text it sits in.
+	function _toIndexableSections(sections) {
+		let indexable = [];
+		for (let section of sections) {
+			let body = [];
+			for (let block of section.blocks) {
+				if (block.reference) {
+					continue;
+				}
+				if (block.flowClass === 'auxiliary') {
+					indexable.push(_toIndexableSection(section, [block], true));
+				}
+				else {
+					body.push(block);
+				}
+			}
+			if (body.length) {
+				indexable.push(_toIndexableSection(section, body, false));
+			}
+		}
+		// A body section is emitted after the auxiliary blocks it surrounds,
+		// and chunk indexes are document order
+		return indexable.sort((a, b) => a.startBlock - b.startBlock);
+	}
+
+	// One run of blocks as a section for the chunker, located where the run
+	// starts
+	function _toIndexableSection(section, blocks, auxiliary) {
+		let first = blocks[0];
+		return {
+			text: blocks.map(block => block.text).join('\n'),
+			outlinePath: section.outlinePath,
+			startBlock: first.index,
+			endBlock: blocks[blocks.length - 1].index,
+			pageIndex: first.pageIndex ?? null,
+			pageLabel: first.pageLabel ?? null,
+			position: first.position ?? null,
+			auxiliary
+		};
+	}
+
+	// The embeddable chunks of an attachment's full text: its outline
+	// sections (extracted and cached by Zotero.SDT), split to fit the model
+	// window. When structured extraction yields nothing, the flat text falls
+	// back to note-style paragraph chunking -- searchable, just without
+	// section locations. Null when there's no embeddable text at all.
+	async function _getAttachmentChunks(item) {
+		let result = await Zotero.SDT.getSections(item.id);
+		let sections = result.ok ? _toIndexableSections(result.sections) : [];
+		// The word minimum applies to the document as a whole, not each
+		// section: short sections are real content that the chunker merges,
+		// but a document without three words anywhere gives the model nothing
+		// to rank
+		if (sections.length
+				&& _hasEmbeddableText(sections.map(section => section.text).join(' '))) {
+			let chunks = await Zotero.Embeddings.Chunking.chunkSections(sections);
+			// An auxiliary chunk stands alone, so it's held to the same word
+			// minimum as any standalone text -- a bare "Figure 1" gives the
+			// model nothing to rank
+			return chunks.filter(chunk => !chunk.auxiliary || _hasEmbeddableText(chunk.text));
+		}
+		Zotero.debug(`Embeddings: no structured text for ${item.libraryKey}`
+			+ (result.ok ? '' : ` (${result.reason})`)
+			+ ' -- falling back to plain text');
+		let text;
+		try {
+			text = await item.attachmentText;
+		}
+		catch (e) {
+			Zotero.logError(e);
+			return null;
+		}
+		if (!text || !_hasEmbeddableText(text)) {
+			return null;
+		}
+		// Flat text has no sections, so the whole document plays that role:
+		// the part numbering says where in it a chunk falls
+		let chunks = await Zotero.Embeddings.Chunking.chunkText(text);
+		return chunks.map((chunkText, index) => ({
+			text: chunkText,
+			sectionPart: index + 1,
+			sectionParts: chunks.length
+		}));
+	}
+
 	// Compute and store embeddings for the given items, skipping any whose
 	// stored embedding is already up to date (via sourceHash). Items with no
 	// embeddable text have any existing embedding removed.
@@ -1982,7 +2493,7 @@ Zotero.Embeddings.Indexing = new function () {
 	// @param {Number} [options.batchCharBudget=12000] - Most characters per
 	//     engine call, counting every text in the batch as long as its longest
 	//     one, since they're padded to that length. Attention memory grows with
-	//     the square of the padded length, so a batch of long abstracts uses
+	//     the square of the padded length, so a batch of long texts uses
 	//     far more memory than the same number of short ones.
 	// @param {Function} [options.shouldStop] - Called before each batch;
 	//     return true to stop early
@@ -2016,6 +2527,23 @@ Zotero.Embeddings.Indexing = new function () {
 		let toEmbed = [];
 		let toDelete = [];
 		for (let item of items) {
+			// An attachment's text lives in a file, so its staleness check is
+			// a file-identity hash rather than a text hash -- reading and
+			// sectioning every attachment on every pass would defeat the
+			// check's purpose
+			if (item.isAttachment()) {
+				let hash = await _getAttachmentSourceHash(item);
+				if (!hash) {
+					if (storedHashes.has(item.id)) {
+						toDelete.push(item.id);
+					}
+					continue;
+				}
+				if (storedHashes.get(item.id) !== hash) {
+					toEmbed.push({ item, hash });
+				}
+				continue;
+			}
 			let text = _getIndexableText(item);
 			if (!text) {
 				if (storedHashes.has(item.id)) {
@@ -2032,32 +2560,75 @@ Zotero.Embeddings.Indexing = new function () {
 			await _deleteEmbeddings(toDelete);
 		}
 
-		// Split note text into chunks that fit the model's context window --
-		// only notes run long enough to need it. A title and abstract, or an
-		// annotation's passage and comment, fit the window in almost all
-		// cases, so they're embedded as a single chunk and the pipeline
-		// truncates the rare outlier.
+		// Derive each entry's chunks. Notes are split to fit the model's
+		// context window; attachments are extracted (see
+		// _getAttachmentChunks()) and split section by section. A title and
+		// abstract, or an annotation's passage and comment, fit the window in
+		// almost all cases, so they're embedded as a single chunk and the
+		// pipeline truncates the rare outlier.
+		let emptyAttachments = [];
 		for (let entry of toEmbed) {
-			// Tokenizing a chunk's worth of long notes takes real time, and a
-			// stop request can be a model switch that's about to clear the
-			// vectors -- so bail out here as well, rather than only between
-			// batches. No embeddings have been written yet at this point,
-			// only the stale-item deletions above, which hold regardless.
+			// Extracting an attachment and tokenizing a chunk's worth of long
+			// notes take real time, and a stop request can be a model switch
+			// that's about to clear the vectors -- so bail out here as well,
+			// rather than only between batches. No embeddings have been
+			// written yet at this point, only the stale-item deletions above,
+			// which hold regardless.
 			if (shouldStop && shouldStop()) {
 				return 0;
 			}
-			entry.chunks = entry.item.isNote()
-				? await Zotero.Embeddings.Chunking.chunkText(entry.text)
-				: [entry.text];
+			if (entry.item.isAttachment()) {
+				entry.chunks = await _getAttachmentChunks(entry.item);
+				// Nothing embeddable anywhere in the attachment (missing
+				// file, password-protected, no text layer). Record the
+				// attempt anyway, so the item counts as processed and isn't
+				// looked at again until the file changes.
+				if (!entry.chunks || !entry.chunks.length) {
+					entry.chunks = [];
+					emptyAttachments.push(entry);
+					continue;
+				}
+			}
+			else if (entry.item.isNote()) {
+				entry.chunks = (await Zotero.Embeddings.Chunking.chunkText(entry.text))
+					.map(text => ({ text }));
+			}
+			else {
+				entry.chunks = [{ text: entry.text }];
+			}
 			entry.vectors = new Array(entry.chunks.length);
 			entry.remaining = entry.chunks.length;
 		}
+		// An attachment with nothing to embed is still processed: replace
+		// whatever an older file left with a single embedding-less row
+		// carrying the current source hash, so the indexed count converges on
+		// the eligible count instead of these items reading as forever
+		// unindexed (see _setUpDB())
+		if (emptyAttachments.length) {
+			await Zotero.DB.executeTransaction(async function () {
+				for (let entry of emptyAttachments) {
+					// The item may have been deleted while we were extracting
+					if (!Zotero.Items.get(entry.item.id)) {
+						continue;
+					}
+					await Zotero.DB.queryAsync(
+						"DELETE FROM embeddings.itemEmbeddings WHERE itemID=?",
+						entry.item.id
+					);
+					await Zotero.DB.queryAsync(
+						"INSERT INTO embeddings.itemEmbeddings "
+							+ "(itemID, chunkIndex, embedding, sourceHash) "
+							+ "VALUES (?, 0, NULL, ?)",
+						[entry.item.id, entry.hash]
+					);
+				}
+			});
+		}
+		toEmbed = toEmbed.filter(entry => entry.chunks.length);
 
-		// Process one library at a time; within it, order by chunk length so
-		// batches pack texts of similar (padded) size
-		let longestChunk = entry => entry.chunks.reduce((max, c) => Math.max(max, c.length), 0);
-		toEmbed.sort((a, b) => (a.item.libraryID - b.item.libraryID)
-			|| (longestChunk(a) - longestChunk(b)));
+		// What gets embedded is the chunk's embedText (its text plus any
+		// outline-path context); plain chunks embed their text as is.
+		let embedText = chunk => chunk.embedText || chunk.text;
 
 		// Batches are packed from the flattened chunks, so an item's chunks
 		// can span batches; its rows are written only once every chunk's
@@ -2069,6 +2640,14 @@ Zotero.Embeddings.Indexing = new function () {
 				units.push({ entry, chunkIndex });
 			}
 		}
+		// Pack batches from chunks of similar size: the engine pads every
+		// text in a batch to its longest one and compute scales with the
+		// padded length, so one long chunk makes a whole mixed batch pay
+		// long-chunk price. Sorting the individual chunks (an item's chunks
+		// legitimately range from captions to window-sized body text) roughly
+		// halves fulltext indexing time versus item-level ordering.
+		units.sort((a, b) => embedText(a.entry.chunks[a.chunkIndex]).length
+			- embedText(b.entry.chunks[b.chunkIndex]).length);
 
 		let done = 0;
 		for (let i = 0; i < units.length;) {
@@ -2081,7 +2660,7 @@ Zotero.Embeddings.Indexing = new function () {
 			let count = 0;
 			while (i + count < units.length && count < maxBatchItems) {
 				let unit = units[i + count];
-				let length = Math.max(longest, unit.entry.chunks[unit.chunkIndex].length);
+				let length = Math.max(longest, embedText(unit.entry.chunks[unit.chunkIndex]).length);
 				if (count && length * (count + 1) > batchCharBudget) {
 					break;
 				}
@@ -2091,7 +2670,7 @@ Zotero.Embeddings.Indexing = new function () {
 			let batch = units.slice(i, i + count);
 			i += count;
 			let vectors = await Zotero.Embeddings.embedPassages(
-				batch.map(unit => unit.entry.chunks[unit.chunkIndex])
+				batch.map(unit => embedText(unit.entry.chunks[unit.chunkIndex]))
 			);
 			let completed = [];
 			for (let j = 0; j < batch.length; j++) {
@@ -2118,15 +2697,35 @@ Zotero.Embeddings.Indexing = new function () {
 						);
 						for (let k = 0; k < entry.vectors.length; k++) {
 							let vector = entry.vectors[k];
+							let chunk = entry.chunks[k];
 							let blob = new Uint8Array(
 								vector.buffer, vector.byteOffset, vector.byteLength
 							);
-							// Keep the embedding blobs out of debug output
+							// The chunk text is stored only for attachments,
+							// whose text lives in a file: it's what the
+							// search-results section previews. Other item
+							// types are their own preview.
+							// Keep the embedding blobs out of debug output.
 							await Zotero.DB.queryAsync(
 								"INSERT INTO embeddings.itemEmbeddings "
-									+ "(itemID, chunkIndex, embedding, sourceHash) "
-									+ "VALUES (?, ?, ?, ?)",
-								[entry.item.id, k, blob, entry.hash],
+									+ "(itemID, chunkIndex, embedding, sourceHash, "
+									+ "chunkText, outlinePath, startBlock, endBlock, "
+									+ "pageLabel, navPosition, sectionPart, sectionParts) "
+									+ "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
+								[
+									entry.item.id,
+									k,
+									blob,
+									entry.hash,
+									entry.item.isAttachment() ? chunk.text : null,
+									chunk.outlinePath || null,
+									chunk.startBlock ?? null,
+									chunk.endBlock ?? null,
+									chunk.pageLabel ?? null,
+									chunk.position ? JSON.stringify(chunk.position) : null,
+									chunk.sectionPart ?? null,
+									chunk.sectionParts ?? null
+								],
 								{ debugParams: false }
 							);
 						}
@@ -2173,6 +2772,11 @@ Zotero.Embeddings.Indexing = new function () {
 
 	/**
 	 * Current runner state, for the preferences UI.
+	 *
+	 * Each library's counts come in two disjoint pairs: `indexed`/`eligible`
+	 * for items, notes, and annotations, and `indexedAttachments`/
+	 * `eligibleAttachments` for attachment fulltext, which is a far bigger and
+	 * slower job. Callers that want whole-library coverage add them up.
 	 */
 	this.getStatus = function () {
 		return {
@@ -2225,10 +2829,18 @@ Zotero.Embeddings.Indexing = new function () {
 		await Zotero.Embeddings.initDB();
 		let eligibleByLibrary = await _getEligibleItemIDs();
 		for (let library of _indexableLibraries()) {
+			let eligible = eligibleByLibrary.get(library.libraryID)
+				|| { items: [], attachments: [] };
+			let indexed = await _getIndexedCounts(library.libraryID);
+			// Attachments are counted separately from everything else, not
+			// included in it -- the two pairs are disjoint, and consumers sum
+			// them when they want the whole library
 			_status.set(library.libraryID, {
 				name: library.name,
-				indexed: await _getIndexedCount(library.libraryID),
-				eligible: (eligibleByLibrary.get(library.libraryID) || []).length
+				indexed: indexed.items,
+				eligible: eligible.items.length,
+				indexedAttachments: indexed.attachments,
+				eligibleAttachments: eligible.attachments.length
 			});
 		}
 		_emitProgress();
@@ -2370,7 +2982,8 @@ Zotero.Embeddings.Indexing = new function () {
 				// Deleted items simply aren't returned; their embeddings are
 				// removed by the delete notifier
 				let items = (await Zotero.Items.getAsync(ids))
-					.filter(item => item.isRegularItem() || item.isNote() || item.isAnnotation());
+					.filter(item => item.isRegularItem() || item.isNote() || item.isAnnotation()
+						|| (_indexFulltextEnabled() && _isIndexableAttachment(item)));
 				if (!items.length) {
 					continue;
 				}
@@ -2411,7 +3024,7 @@ Zotero.Embeddings.Indexing = new function () {
 
 	function _refreshStatusThrottled() {
 		let now = Date.now();
-		if (now - _lastStatusRefresh < 5000) {
+		if (now - _lastStatusRefresh < STATUS_REFRESH_INTERVAL) {
 			return;
 		}
 		_lastStatusRefresh = now;
diff --git a/chrome/content/zotero/xpcom/sdt.js b/chrome/content/zotero/xpcom/sdt.js
index d2a110f5d7..0dc7deb485 100644
--- a/chrome/content/zotero/xpcom/sdt.js
+++ b/chrome/content/zotero/xpcom/sdt.js
@@ -152,6 +152,273 @@ Zotero.SDT = new function () {
 		return _openPack(new Uint8Array(result.bytes));
 	};
 
+	/**
+	 * Get an attachment's text as outline-based sections. Each section runs
+	 * from one outline heading to the next; a document without an outline
+	 * falls back to per-page sections, and to a single section when there are
+	 * no pages either.
+	 *
+	 * Blocks the document marks as excluded flow (running heads, page
+	 * numbers) are left out. The rest is reported as the document describes
+	 * it, for callers to filter as their use calls for: a section lists the
+	 * blocks it's made of, each with its flow class and whether it's a
+	 * reference entry, and `text` is simply those blocks joined.
+	 *
+	 * Sections and blocks carry what the document knows about where they are:
+	 * - pageIndex: 0-based index into the document's pages
+	 * - pageLabel: page label ('ix', '15'), or the ordinal page number for a
+	 *   PDF without labels. An EPUB's synthetic locations produce none.
+	 * - position: for PDFs, a reader-navigable { pageIndex, rects }
+	 * A section's location is that of its first block.
+	 *
+	 * @param {Integer} itemID
+	 * @param {Object} [options] - See getPack()
+	 * @returns {Promise<Object>} { ok: true, sections: [{ text, outlinePath,
+	 *     startBlock, endBlock, pageIndex, pageLabel, position, blocks:
+	 *     [{ index, text, flowClass, reference, pageIndex, pageLabel,
+	 *     position }] }] }, or { ok: false, reason } (see getPack())
+	 */
+	this.getSections = async function (itemID, options = {}) {
+		let result = await this.getPack(itemID, options);
+		if (!result.ok) {
+			return { ok: false, reason: result.reason };
+		}
+		try {
+			let reader = await _openPack(new Uint8Array(result.bytes));
+			let structure = await reader.materialize();
+			return { ok: true, sections: _getStructureSections(structure) };
+		}
+		catch (e) {
+			Zotero.logError(e);
+			return { ok: false, reason: 'failed' };
+		}
+	};
+
+	// The section walk over a materialized structure. Mirrors the outline
+	// handling of the document-worker's own section chunker
+	// (structured-document-text/src/chunker.js), which the bundled reader
+	// module doesn't export; switch to that export if it grows one.
+	function _getStructureSections(structure) {
+		let content = Array.isArray(structure?.content) ? structure.content : [];
+		if (!content.length) {
+			return [];
+		}
+		// Section boundaries: the outline's heading blocks, or page starts for
+		// a document without an outline. Block 0 is always a boundary, so
+		// front matter before the first heading forms a section of its own.
+		let headings = _flattenOutline(structure.catalog?.outline, []);
+		let boundaries = headings.length
+			? headings
+			: _getPageBoundaries(structure.catalog, content.length);
+		// A boundary at block 0 emits no section of its own -- it just seeds
+		// the first section's path
+		boundaries = boundaries
+			.filter(b => b.blockIndex < content.length)
+			.sort((a, b) => a.blockIndex - b.blockIndex);
+		let blockPages = _getBlockPages(structure.catalog, content.length);
+
+		let sections = [];
+		let startBlock = 0;
+		let path = [];
+		let isHeading = false;
+		for (let boundary of [...boundaries, { blockIndex: content.length, path }]) {
+			if (boundary.blockIndex > startBlock) {
+				let endBlock = boundary.blockIndex - 1;
+				let blocks = [];
+				let location = null;
+				// A section that starts at an outline heading skips the
+				// heading block's own text: the heading is already the last
+				// component of the section's outline path
+				for (let i = startBlock + (isHeading ? 1 : 0); i <= endBlock; i++) {
+					let block = content[i];
+					if (!block || block.flowClass === 'excluded') {
+						continue;
+					}
+					let text = _getNestedBlockPlainText(block).trim();
+					if (!text) {
+						continue;
+					}
+					let entry = { index: i, text, reference: _isReferenceBlock(block) };
+					if (block.flowClass) {
+						entry.flowClass = block.flowClass;
+					}
+					let blockLocation = _getBlockLocation(structure, blockPages, i);
+					location = location || blockLocation;
+					blocks.push(Object.assign(entry, blockLocation));
+				}
+				if (blocks.length) {
+					// A section is located where it begins -- at its heading
+					// when it has one, since that's where a reader would land
+					// -- falling back to its first reported block
+					let start = _getBlockLocation(structure, blockPages, startBlock);
+					sections.push(Object.assign({
+						text: blocks.map(block => block.text).join('\n'),
+						outlinePath: path.join(' > '),
+						startBlock,
+						endBlock
+					}, start.pageIndex === undefined ? location : start, { blocks }));
+				}
+			}
+			startBlock = boundary.blockIndex;
+			path = boundary.path;
+			isHeading = !!boundary.isHeading;
+		}
+		return sections;
+	}
+
+	// Where a block sits in the source document, as far as the document says.
+	// Only the fields that are actually known are returned.
+	function _getBlockLocation(structure, blockPages, index) {
+		let location = {};
+		// PDF blocks carry page geometry: [pageIndex, x1, y1, x2, y2] rects,
+		// which the reader can scroll to and highlight
+		let pageRects = structure.content[index]?.anchor?.pageRects;
+		let pageIndex = null;
+		if (Array.isArray(pageRects) && pageRects.length
+				&& Number.isInteger(pageRects[0][0])) {
+			pageIndex = pageRects[0][0];
+			let rects = pageRects
+				.filter(rect => rect[0] === pageIndex && rect.length >= 5)
+				.map(rect => rect.slice(1));
+			if (rects.length) {
+				location.position = { pageIndex, rects };
+			}
+		}
+		// Without geometry (EPUB, snapshot), the catalog's per-page content
+		// ranges still say which page a block falls on
+		if (pageIndex === null) {
+			pageIndex = blockPages[index];
+		}
+		if (pageIndex === null) {
+			return location;
+		}
+		location.pageIndex = pageIndex;
+		// An EPUB's synthetic locations aren't page numbers -- a label from
+		// them would read as one
+		if (structure.catalog?.pageMappingType !== 'locations') {
+			let label = structure.catalog?.pages?.[pageIndex]?.label;
+			if (!label && structure.metadata?.processor?.type === 'pdf') {
+				label = String(pageIndex + 1);
+			}
+			if (label) {
+				location.pageLabel = label;
+			}
+		}
+		return location;
+	}
+
+	// blockIndex -> pageIndex, from the catalog's per-page content ranges: the
+	// last page starting at or before the block. Built in one pass up front,
+	// since every block needs it.
+	function _getBlockPages(catalog, blockCount) {
+		let pages = Array.isArray(catalog?.pages) ? catalog.pages : [];
+		let starts = [];
+		for (let i = 0; i < pages.length; i++) {
+			let start = pages[i]?.contentRange?.[0]?.[0];
+			if (Number.isInteger(start) && start >= 0) {
+				starts.push({ start, pageIndex: i });
+			}
+		}
+		starts.sort((a, b) => a.start - b.start);
+		let blockPages = new Array(blockCount).fill(null);
+		let current = null;
+		let next = 0;
+		for (let i = 0; i < blockCount; i++) {
+			while (next < starts.length && starts[next].start <= i) {
+				current = starts[next].pageIndex;
+				next++;
+			}
+			blockPages[i] = current;
+		}
+		return blockPages;
+	}
+
+	// Whether a block is a bibliography entry: flagged as one by the processor
+	// (from entry structure and the in-text citation graph, so
+	// language-independent), or made up entirely of blocks that are, as a
+	// reference list is.
+	function _isReferenceBlock(node) {
+		if (node.reference) {
+			return true;
+		}
+		let children = Array.isArray(node.content)
+			? node.content.filter(child => child.text === undefined)
+			: [];
+		return children.length > 0 && children.every(_isReferenceBlock);
+	}
+
+	// Outline entries flattened to their top-level block indexes, each with
+	// its full heading path
+	function _flattenOutline(items, ancestors) {
+		let result = [];
+		if (!Array.isArray(items)) {
+			return result;
+		}
+		for (let item of items) {
+			if (!item || typeof item !== 'object' || typeof item.title !== 'string') {
+				continue;
+			}
+			let blockIndex = Array.isArray(item.ref) && Number.isInteger(item.ref[0])
+				? item.ref[0]
+				: null;
+			let path = [...ancestors, item.title];
+			if (blockIndex !== null && blockIndex >= 0) {
+				result.push({ blockIndex, path, isHeading: true });
+			}
+			result.push(..._flattenOutline(item.children, path));
+		}
+		return result;
+	}
+
+	// Page-start block indexes, for sectioning a document with no outline.
+	// A page's contentRange starts with a content point whose first component
+	// is the top-level block index.
+	function _getPageBoundaries(catalog, blockCount) {
+		let pages = Array.isArray(catalog?.pages) ? catalog.pages : [];
+		let boundaries = [];
+		let seen = new Set();
+		for (let page of pages) {
+			let start = page?.contentRange?.[0]?.[0];
+			if (Number.isInteger(start) && start >= 0 && start < blockCount && !seen.has(start)) {
+				seen.add(start);
+				boundaries.push({ blockIndex: start, path: [] });
+			}
+		}
+		return boundaries;
+	}
+
+	// Plain text of a block, recursing into nested blocks. A local copy of the
+	// module's un-exported text helper (structured-document-text/src/text.js).
+	function _getNestedBlockPlainText(node) {
+		if (node.text !== undefined) {
+			return node.text;
+		}
+		if (!node.content) {
+			return '';
+		}
+		let hasChildBlock = node.content.some(child => child.text === undefined);
+		if (!hasChildBlock) {
+			let result = '';
+			for (let child of node.content) {
+				if (child.text !== undefined) {
+					result += child.text;
+				}
+			}
+			return result;
+		}
+		let parts = [];
+		for (let child of node.content) {
+			if (child.text !== undefined) {
+				continue;
+			}
+			let text = _getNestedBlockPlainText(child);
+			if (text) {
+				parts.push(text);
+			}
+		}
+		return parts.join('\n');
+	}
+
 	async function _readValidCache({ sourceHash, cachePath, processorType }, options) {
 		let bytes;
 		try {
diff --git a/chrome/locale/en-US/zotero/preferences.ftl b/chrome/locale/en-US/zotero/preferences.ftl
index 1d8e67b1fd..43b6bce11e 100644
--- a/chrome/locale/en-US/zotero/preferences.ftl
+++ b/chrome/locale/en-US/zotero/preferences.ftl
@@ -103,6 +103,8 @@ preferences-advanced-semantic-search-chinese =
 preferences-advanced-semantic-search-multilingual =
     .label = Multilingual
 preferences-advanced-semantic-search-model-description = “{ preferences-advanced-semantic-search-english.label }” and “{ preferences-advanced-semantic-search-chinese.label }” give the best results for libraries in those languages. “{ preferences-advanced-semantic-search-multilingual.label }” supports searching in and across many languages.
+preferences-advanced-semantic-search-index-fulltext =
+    .label = Search full text of attachment files
 preferences-advanced-semantic-search-downloading = Downloading…
 preferences-advanced-semantic-search-downloading-progress = Downloading… { $percent }%
 preferences-advanced-semantic-search-indexing = Indexing…
diff --git a/chrome/locale/en-US/zotero/zotero.ftl b/chrome/locale/en-US/zotero/zotero.ftl
index 2b0c697970..6264531cbb 100644
--- a/chrome/locale/en-US/zotero/zotero.ftl
+++ b/chrome/locale/en-US/zotero/zotero.ftl
@@ -643,6 +643,7 @@ pane-related = Related
 pane-attachment-info = Attachment Info
 pane-attachment-preview = Preview
 pane-attachment-annotations = Annotations
+pane-search-results = Search Results
 
 pane-header-attachment-associated =
     .label = Rename associated file
@@ -682,6 +683,14 @@ section-related =
     .label = { $count } Related
 section-attachment-info =
     .label = { pane-attachment-info }
+section-search-results =
+    .label = { $count ->
+                 [one] { $count } Search Result
+                 *[other] { $count } Search Results
+             }
+search-result-row-fulltext = Full Text
+search-result-row-show-more = Show More
+search-result-row-show-less = Show Less
 
 section-button-remove =
     .tooltiptext = { general-remove }
@@ -720,6 +729,8 @@ sidenav-attachment-preview =
     .tooltiptext = { pane-attachment-preview }
 sidenav-attachment-annotations =
     .tooltiptext = { pane-attachment-annotations }
+sidenav-search-results =
+    .tooltiptext = { pane-search-results }
 sidenav-libraries-collections =
     .tooltiptext = { pane-libraries-collections }
 sidenav-tags =
diff --git a/defaults/preferences/zotero.js b/defaults/preferences/zotero.js
index cddce4c8ea..8d6f9f671e 100644
--- a/defaults/preferences/zotero.js
+++ b/defaults/preferences/zotero.js
@@ -118,6 +118,8 @@ pref("extensions.zotero.search.useLeftBound", true);
 pref("extensions.zotero.embeddings.model", "");
 // Set when the user stops indexing; nothing is indexed until indexing is started again
 pref("extensions.zotero.embeddings.indexingPaused", false);
+// Also index the full text of PDF/EPUB/snapshot attachments
+pref("extensions.zotero.embeddings.indexFulltext", false);
 
 // Notes
 pref("extensions.zotero.note.fontFamily", "-apple-system, BlinkMacSystemFont, \"Segoe UI\", \"Helvetica Neue\", Helvetica, Arial, sans-serif");
diff --git a/scss/_zotero.scss b/scss/_zotero.scss
index c3f572158f..3ee8226e6d 100644
--- a/scss/_zotero.scss
+++ b/scss/_zotero.scss
@@ -106,6 +106,7 @@
 @import "elements/attachmentRow";
 @import "elements/attachmentAnnotationsBox";
 @import "elements/annotationRow";
+@import "elements/searchResultsBox";
 @import "elements/noteRow";
 @import "elements/librariesCollectionsBox";
 @import "elements/duplicatesMergePane";
diff --git a/scss/abstracts/_variables.scss b/scss/abstracts/_variables.scss
index 895cac65e8..a1b6d0fd63 100644
--- a/scss/abstracts/_variables.scss
+++ b/scss/abstracts/_variables.scss
@@ -95,6 +95,7 @@ $item-pane-sections: (
 	"libraries-collections": var(--accent-teal),
 	"tags": var(--accent-orange),
 	"related": var(--accent-wood),
+	"search-results": var(--accent-gold),
 );
 
 $tagColorsLookup: (
diff --git a/scss/elements/_annotationRow.scss b/scss/elements/_annotationRow.scss
index 87d000fd9f..e0007bc1b3 100644
--- a/scss/elements/_annotationRow.scss
+++ b/scss/elements/_annotationRow.scss
@@ -1,4 +1,8 @@
-annotation-row {
+// search-result-row (the search-results section's chunk cards) shares this
+// structure and look, minus the parts it doesn't have (icon, action, tags):
+// the section already carries the magnifier in its head, so repeating it on
+// every card says nothing
+annotation-row, search-result-row {
 	display: flex;
 	flex-direction: column;
 
diff --git a/scss/elements/_searchResultsBox.scss b/scss/elements/_searchResultsBox.scss
new file mode 100644
index 0000000000..3831309252
--- /dev/null
+++ b/scss/elements/_searchResultsBox.scss
@@ -0,0 +1,75 @@
+// The section's icon is the quick-search magnifier, the same one the search
+// bar uses, rather than a per-size copy of its own. Both the sidenav button
+// and the section head otherwise derive their icon from the pane name (see
+// _itemPaneSidenav.scss and _collapsibleSection.scss), so each needs pointing
+// at the shared file.
+item-pane-sidenav .btn[data-pane="search-results"] {
+	background-image: url("chrome://zotero/skin/20/universal/magnifier.svg");
+}
+
+collapsible-section[data-pane="search-results"] > .head .title::before {
+	background-image: icon-url("16/universal/magnifier.svg");
+}
+
+search-results-box {
+	display: flex;
+	flex-direction: column;
+
+	&[hidden] {
+		display: none;
+	}
+
+	& > collapsible-section {
+		& > .body {
+			display: flex;
+			flex-direction: column;
+			gap: 4px;
+
+			@include comfortable {
+				gap: 8px;
+			}
+		}
+	}
+}
+
+// The parts search-result-row adds on top of the shared annotation-row look
+// (see _annotationRow.scss): the section-part indicator and page label in the
+// head, and the clamp toggle under the quote
+search-result-row {
+	.head {
+		.part {
+			font-weight: 400;
+			color: var(--fill-secondary);
+			margin-inline-start: 4px;
+		}
+
+		.location {
+			margin-inline-start: auto;
+			color: var(--fill-secondary);
+			white-space: nowrap;
+		}
+	}
+
+	&.expanded .body .quote {
+		-webkit-line-clamp: none;
+	}
+
+	.show-more {
+		align-self: flex-start;
+		margin: 0 8px 4px 16px;
+		padding: 0;
+		border: none;
+		background: transparent;
+		color: var(--fill-secondary);
+		font: inherit;
+		cursor: pointer;
+
+		&:hover {
+			text-decoration: underline;
+		}
+
+		&[hidden] {
+			display: none;
+		}
+	}
+}
diff --git a/test/tests/embeddingsTest.js b/test/tests/embeddingsTest.js
index 54d80e1380..11a431c0dd 100644
--- a/test/tests/embeddingsTest.js
+++ b/test/tests/embeddingsTest.js
@@ -21,6 +21,23 @@ describe("Zotero.Embeddings", function () {
 		};
 	}
 
+	// A Zotero.SDT.getSections() section, built from its blocks -- which are
+	// what indexing reads, the section's own text and span being derived.
+	// A block is its text, or an object adding flowClass/reference/location.
+	function sdtSection(outlinePath, start, blocks) {
+		let entries = blocks.map((block, i) => Object.assign(
+			{ index: start + i, reference: false },
+			typeof block == 'string' ? { text: block } : block
+		));
+		return {
+			text: entries.map(entry => entry.text).join('\n'),
+			outlinePath,
+			startBlock: start,
+			endBlock: start + entries.length - 1,
+			blocks: entries
+		};
+	}
+
 	// Stands in for a measured model (see Zotero.Embeddings.ensureCalibration()),
 	// which the test environment has no downloaded model to measure. The mean
 	// is shaped like a real one -- mixed signs, and shorter than unit length,
@@ -335,6 +352,98 @@ describe("Zotero.Embeddings", function () {
 		});
 	});
 
+	describe("#getMatchingChunks()", function () {
+		it("should return an item's matching chunks with their locations, best first", async function () {
+			let axis = (index, scale = 1) => {
+				let vector = Float32Array.from(testMean);
+				vector[index] += scale;
+				return vector;
+			};
+			let store = async (item, chunkIndex, vector, props = {}) => {
+				let blob = new Uint8Array(vector.buffer, vector.byteOffset, vector.byteLength);
+				await Zotero.DB.queryAsync(
+					"REPLACE INTO embeddings.itemEmbeddings "
+						+ "(itemID, chunkIndex, embedding, sourceHash, chunkText, outlinePath, "
+						+ "startBlock, endBlock, pageLabel, navPosition, sectionPart, sectionParts) "
+						+ "VALUES (?, ?, ?, 'hash', ?, ?, ?, ?, ?, ?, ?, ?)",
+					[
+						item.id,
+						chunkIndex,
+						blob,
+						props.text ?? null,
+						props.outlinePath ?? null,
+						props.startBlock ?? null,
+						props.endBlock ?? null,
+						props.pageLabel ?? null,
+						props.navPosition ?? null,
+						props.sectionPart ?? null,
+						props.sectionParts ?? null
+					],
+					{ debugParams: false }
+				);
+			};
+			let item = await createDataObject('item');
+			// A weak match, a strong match, and a chunk below the floor
+			let mixed = axis(0, 0.4);
+			mixed[1] += 1;
+			await store(item, 0, mixed, {
+				text: 'The introduction text', outlinePath: 'Introduction', startBlock: 0, endBlock: 4
+			});
+			await store(item, 1, axis(0), {
+				text: 'The sampling text',
+				outlinePath: 'Methods > Sampling',
+				startBlock: 5,
+				endBlock: 11,
+				pageLabel: '7',
+				navPosition: JSON.stringify({ pageIndex: 6, rects: [[10, 20, 300, 40]] }),
+				sectionPart: 2,
+				sectionParts: 3
+			});
+			await store(item, 2, axis(2), {
+				text: 'The references text', outlinePath: 'References', startBlock: 12, endBlock: 20
+			});
+
+			let query = axis(0, 0.9);
+			query[1] += 0.1;
+			let stubs = [
+				sinon.stub(Zotero.Embeddings, 'isEnabled').returns(true),
+				sinon.stub(Zotero.Embeddings, 'getModelVersion').returns('test-model/1'),
+				sinon.stub(Zotero.Embeddings, 'embedQuery').resolves(query)
+			];
+			await Zotero.DB.queryAsync(
+				"REPLACE INTO embeddings.itemEmbeddingsMeta (key, value) "
+					+ "VALUES ('modelVersion', 'test-model/1')"
+			);
+			try {
+				let chunks = await Zotero.Embeddings.getMatchingChunks('anything', item.id);
+				// The chunk below the model's floor isn't a match
+				assert.lengthOf(chunks, 2);
+				// Best chunk first, each with its text and where it came from
+				assert.equal(chunks[0].chunkIndex, 1);
+				assert.equal(chunks[0].text, 'The sampling text');
+				assert.equal(chunks[0].outlinePath, 'Methods > Sampling');
+				assert.equal(chunks[0].startBlock, 5);
+				assert.equal(chunks[0].endBlock, 11);
+				assert.equal(chunks[0].pageLabel, '7');
+				assert.deepEqual(chunks[0].position,
+					{ pageIndex: 6, rects: [[10, 20, 300, 40]] });
+				assert.equal(chunks[0].sectionPart, 2);
+				assert.equal(chunks[0].sectionParts, 3);
+				assert.equal(chunks[1].chunkIndex, 0);
+				assert.isNull(chunks[1].position);
+				assert.isAbove(chunks[0].score, chunks[1].score);
+				// The limit caps how many come back
+				let limited = await Zotero.Embeddings.getMatchingChunks('anything', item.id,
+					{ limit: 1 });
+				assert.lengthOf(limited, 1);
+				assert.equal(limited[0].chunkIndex, 1);
+			}
+			finally {
+				stubs.forEach(stub => stub.restore());
+			}
+		});
+	});
+
 	describe("#chunkText()", function () {
 		// bge has no passage prefix, so the window less the two special tokens
 		// that wrap every input is what a chunk's own text gets (see MODELS).
@@ -473,6 +582,180 @@ describe("Zotero.Embeddings", function () {
 
 	});
 
+	describe("#chunkSections()", function () {
+		var fakeTokenizer = wordTokenizer();
+		var stubs = [];
+
+		beforeEach(function () {
+			stubs.push(sinon.stub(Zotero.Embeddings, 'getModelName').returns('bge-small-en-v1.5'));
+			stubs.push(sinon.stub(Zotero.Embeddings.Chunking, 'getTokenizer').resolves(fakeTokenizer));
+		});
+
+		afterEach(function () {
+			stubs.forEach(stub => stub.restore());
+			stubs = [];
+		});
+
+		var words = (tag, n) => Array.from({ length: n }, (x, i) => `${tag}${i}`).join(' ');
+
+		it("shouldn't put two substantial sections in one chunk", async function () {
+			let chunks = await Zotero.Embeddings.Chunking.chunkSections([
+				{ text: words('alpha', 200), outlinePath: 'Introduction', startBlock: 0, endBlock: 4 },
+				{ text: words('bravo', 200), outlinePath: 'Methods', startBlock: 5, endBlock: 9 }
+			]);
+			assert.lengthOf(chunks, 2);
+			// Neither chunk mixes the two sections, and each points back at
+			// the blocks it covers
+			assert.include(chunks[0].text, 'alpha0');
+			assert.notInclude(chunks[0].text, 'bravo');
+			assert.equal(chunks[0].startBlock, 0);
+			assert.equal(chunks[0].endBlock, 4);
+			assert.include(chunks[1].text, 'bravo0');
+			assert.notInclude(chunks[1].text, 'alpha0');
+			assert.equal(chunks[1].startBlock, 5);
+			assert.equal(chunks[1].endBlock, 9);
+		});
+
+		it("should prefix the embedded text with the section's outline path", async function () {
+			let chunks = await Zotero.Embeddings.Chunking.chunkSections([
+				{ text: words('alpha', 200), outlinePath: 'Results > Field studies', startBlock: 2, endBlock: 7 }
+			]);
+			assert.lengthOf(chunks, 1);
+			// What gets embedded carries the heading context; the display
+			// text stays the plain piece
+			assert.isTrue(chunks[0].embedText.startsWith('Results > Field studies\n\n'));
+			assert.isTrue(chunks[0].text.startsWith('alpha0'));
+			assert.equal(chunks[0].outlinePath, 'Results > Field studies');
+		});
+
+		it("should combine sections too small to embed on their own", async function () {
+			// Front matter before the first heading rides along with the
+			// section that follows it, the way small paragraphs do in a note
+			let chunks = await Zotero.Embeddings.Chunking.chunkSections([
+				{ text: 'Title page', outlinePath: '', startBlock: 0, endBlock: 0 },
+				{ text: 'Copyright notice', outlinePath: '', startBlock: 1, endBlock: 1 },
+				{ text: words('alpha', 200), outlinePath: 'Introduction', startBlock: 2, endBlock: 9 },
+				{ text: words('bravo', 200), outlinePath: 'Methods', startBlock: 10, endBlock: 19 }
+			]);
+			assert.lengthOf(chunks, 2);
+			assert.include(chunks[0].text, 'Title page');
+			assert.include(chunks[0].text, 'Copyright notice');
+			assert.include(chunks[0].text, 'alpha0');
+			assert.equal(chunks[0].startBlock, 0);
+			assert.equal(chunks[0].endBlock, 9);
+			// The substantial section that follows still gets a chunk of its own
+			assert.include(chunks[1].text, 'bravo0');
+			assert.notInclude(chunks[1].text, 'alpha0');
+		});
+
+		it("should join a trailing small section to the previous chunk", async function () {
+			let chunks = await Zotero.Embeddings.Chunking.chunkSections([
+				{ text: words('alpha', 200), outlinePath: 'Body', startBlock: 0, endBlock: 9 },
+				{ text: 'Short appendix note', outlinePath: 'Appendix', startBlock: 10, endBlock: 11 }
+			]);
+			assert.lengthOf(chunks, 1);
+			assert.include(chunks[0].text, 'Short appendix note');
+			assert.equal(chunks[0].startBlock, 0);
+			assert.equal(chunks[0].endBlock, 11);
+		});
+
+		it("should split an oversized section into numbered pieces sharing its location", async function () {
+			// 60 ten-token sentences: over the window, no paragraph breaks
+			let sentences = Array.from({ length: 60 },
+				(x, i) => `Sentence ${i} has some words about subject number ${i}.`);
+			let position = { pageIndex: 4, rects: [[10, 20, 300, 40]] };
+			let chunks = await Zotero.Embeddings.Chunking.chunkSections([
+				{
+					text: sentences.join(' '),
+					outlinePath: 'Discussion',
+					startBlock: 3,
+					endBlock: 20,
+					pageIndex: 4,
+					pageLabel: '5',
+					position
+				}
+			]);
+			assert.isAbove(chunks.length, 1);
+			// Every piece keeps its section's heading context and location,
+			// and knows which piece of the section it is
+			for (let i = 0; i < chunks.length; i++) {
+				let chunk = chunks[i];
+				assert.isTrue(chunk.embedText.startsWith('Discussion\n\n'));
+				assert.equal(chunk.outlinePath, 'Discussion');
+				assert.equal(chunk.startBlock, 3);
+				assert.equal(chunk.endBlock, 20);
+				assert.equal(chunk.pageLabel, '5');
+				assert.deepEqual(chunk.position, position);
+				assert.equal(chunk.sectionPart, i + 1);
+				assert.equal(chunk.sectionParts, chunks.length);
+			}
+			// No sentence was dropped
+			let joined = chunks.map(chunk => chunk.text).join('\n');
+			for (let sentence of sentences) {
+				assert.include(joined, sentence);
+			}
+		});
+
+		it("should keep auxiliary sections as standalone chunks", async function () {
+			let chunks = await Zotero.Embeddings.Chunking.chunkSections([
+				// A small body section, a tiny caption, then a substantial
+				// body section
+				{ text: 'A short opening paragraph.', outlinePath: 'Results', startBlock: 0, endBlock: 0 },
+				{
+					text: 'Figure 3: Owl migration routes across the Baltic.',
+					outlinePath: 'Results',
+					startBlock: 1,
+					endBlock: 1,
+					auxiliary: true
+				},
+				{ text: words('alpha', 200), outlinePath: 'Results', startBlock: 2, endBlock: 9 }
+			]);
+			assert.lengthOf(chunks, 2);
+			// The caption is a chunk of its own, however small...
+			let caption = chunks.find(chunk => chunk.auxiliary);
+			assert.ok(caption);
+			assert.equal(caption.text, 'Figure 3: Owl migration routes across the Baltic.');
+			assert.equal(caption.sectionParts, 1);
+			// ...and the small body section still merges with the body that
+			// follows, straight across it
+			let body = chunks.find(chunk => !chunk.auxiliary);
+			assert.include(body.text, 'A short opening paragraph.');
+			assert.include(body.text, 'alpha0');
+			assert.notInclude(body.text, 'Figure 3');
+		});
+
+		it("shouldn't fold a trailing small body section into an auxiliary chunk", async function () {
+			let chunks = await Zotero.Embeddings.Chunking.chunkSections([
+				{ text: words('alpha', 200), outlinePath: 'Body', startBlock: 0, endBlock: 9 },
+				{
+					text: 'Figure 1: A caption with enough words to keep.',
+					outlinePath: 'Body',
+					startBlock: 10,
+					endBlock: 10,
+					auxiliary: true
+				},
+				{ text: 'A trailing remnant paragraph.', outlinePath: 'Body', startBlock: 11, endBlock: 11 }
+			]);
+			assert.lengthOf(chunks, 2);
+			// The remnant joins the last body chunk, not the caption
+			let caption = chunks.find(chunk => chunk.auxiliary);
+			assert.equal(caption.text, 'Figure 1: A caption with enough words to keep.');
+			let body = chunks.find(chunk => !chunk.auxiliary);
+			assert.include(body.text, 'A trailing remnant paragraph.');
+		});
+
+		it("should mark an unsplit section as its only piece", async function () {
+			let chunks = await Zotero.Embeddings.Chunking.chunkSections([
+				{ text: words('alpha', 200), outlinePath: 'Body', startBlock: 0, endBlock: 9 }
+			]);
+			assert.lengthOf(chunks, 1);
+			assert.equal(chunks[0].sectionPart, 1);
+			assert.equal(chunks[0].sectionParts, 1);
+			assert.isNull(chunks[0].pageLabel);
+			assert.isNull(chunks[0].position);
+		});
+	});
+
 	describe("#getScoreFraction()", function () {
 		it("should clamp scores into the measured display range", async function () {
 			let stub = sinon.stub(Zotero.Embeddings, 'getModelVersion').returns('test-model/1');
@@ -769,7 +1052,8 @@ describe("Zotero.Embeddings", function () {
 			try {
 				await Zotero.Embeddings.initDB();
 				await Zotero.DB.queryAsync(
-					"REPLACE INTO embeddings.itemEmbeddings VALUES (?, 0, ?, ?)",
+					"REPLACE INTO embeddings.itemEmbeddings "
+						+ "(itemID, chunkIndex, embedding, sourceHash) VALUES (?, 0, ?, ?)",
 					[item.id, new Uint8Array([0, 0, 0, 0]), 'hash']
 				);
 				// The model switch clears the old vectors and announces the
@@ -800,7 +1084,8 @@ describe("Zotero.Embeddings", function () {
 			try {
 				let item = await createDataObject('item');
 				await Zotero.DB.queryAsync(
-					"INSERT INTO embeddings.itemEmbeddings VALUES (?, 0, ?, ?)",
+					"INSERT INTO embeddings.itemEmbeddings "
+						+ "(itemID, chunkIndex, embedding, sourceHash) VALUES (?, 0, ?, ?)",
 					[item.id, new Uint8Array([0, 0, 0, 0]), 'hash']
 				);
 				await item.eraseTx();
@@ -1072,6 +1357,404 @@ describe("Zotero.Embeddings", function () {
 			), 1);
 		});
 
+		it("should index an attachment's sections when fulltext indexing is enabled", async function () {
+			this.timeout(60000);
+			let item = await createDataObject('item', { title: 'Parent of fulltext attachment' });
+			let attachment = await importPDFAttachment(item);
+
+			let vector = new Float32Array(4).fill(0.5);
+			let texts = [];
+			let stubs = [
+				sinon.stub(Zotero.Embeddings, 'embedPassages').callsFake(async (passages) => {
+					texts.push(...passages);
+					return passages.map(() => vector);
+				}),
+				sinon.stub(Zotero.Embeddings, 'isEnabled').returns(true),
+				sinon.stub(Zotero.Embeddings, 'getModelVersion').returns('test-model/1'),
+				sinon.stub(Zotero.Embeddings, 'isDownloaded').resolves(true),
+				sinon.stub(Zotero.Embeddings, 'preloadModel').resolves(),
+				sinon.stub(Zotero.Embeddings, 'ensureCalibration').resolves(),
+				sinon.stub(Zotero.Embeddings, 'getModelName').returns('bge-small-en-v1.5'),
+				sinon.stub(Zotero.Embeddings.Chunking, 'getTokenizer').resolves(wordTokenizer()),
+				// The extraction itself is sdt.js's concern (see sdtTest.js);
+				// what's under test is what indexing does with the sections
+				sinon.stub(Zotero.SDT, 'getSections').resolves({
+					ok: true,
+					sections: [
+						sdtSection('Introduction', 0, [{
+							text: 'Owls migrate south when the winters turn cold.',
+							pageIndex: 0,
+							pageLabel: '2',
+							position: { pageIndex: 0, rects: [[10, 20, 300, 40]] }
+						}]),
+						sdtSection('Methods', 4, [{
+							text: 'Tracking devices recorded the routes of forty owls.',
+							pageIndex: 1,
+							pageLabel: '3',
+							position: { pageIndex: 1, rects: [[10, 20, 300, 40]] }
+						}])
+					]
+				})
+			];
+			try {
+				Zotero.Prefs.set('embeddings.indexFulltext', true);
+				await Zotero.Embeddings.Indexing.startIndexing();
+
+				// Both sections are far too small to embed on their own, so
+				// they land in one chunk, prefixed with the first section's
+				// outline path and covering both sections' blocks
+				let rows = await Zotero.DB.queryAsync(
+					"SELECT chunkIndex, chunkText, outlinePath, startBlock, endBlock, "
+						+ "pageLabel, navPosition, sectionPart, sectionParts "
+						+ "FROM embeddings.itemEmbeddings WHERE itemID=?",
+					attachment.id
+				);
+				assert.lengthOf(rows, 1);
+				assert.equal(rows[0].outlinePath, 'Introduction');
+				assert.equal(rows[0].startBlock, 0);
+				assert.equal(rows[0].endBlock, 4);
+				// The merged chunk takes its first section's page and
+				// position, and is its section's only piece
+				assert.equal(rows[0].pageLabel, '2');
+				assert.deepEqual(JSON.parse(rows[0].navPosition),
+					{ pageIndex: 0, rects: [[10, 20, 300, 40]] });
+				assert.equal(rows[0].sectionPart, 1);
+				assert.equal(rows[0].sectionParts, 1);
+				// The stored preview text is the plain chunk, without the
+				// outline-path context the embedded text carries
+				assert.include(rows[0].chunkText, 'Owls migrate south');
+				assert.include(rows[0].chunkText, 'Tracking devices');
+				assert.isFalse(rows[0].chunkText.startsWith('Introduction\n\n'));
+				let text = texts.find(t => t.includes('Owls migrate south'));
+				assert.ok(text);
+				assert.isTrue(text.startsWith('Introduction\n\n'));
+				assert.include(text, 'Tracking devices');
+			}
+			finally {
+				stubs.forEach(stub => stub.restore());
+				Zotero.Prefs.clear('embeddings.indexFulltext');
+			}
+		});
+
+		it("should drop attachment chunks when fulltext indexing is turned off", async function () {
+			this.timeout(60000);
+			let item = await createDataObject('item', { title: 'Parent of pruned attachment' });
+			let attachment = await importPDFAttachment(item);
+
+			let vector = new Float32Array(4).fill(0.5);
+			let stubs = [
+				sinon.stub(Zotero.Embeddings, 'embedPassages')
+					.callsFake(async texts => texts.map(() => vector)),
+				sinon.stub(Zotero.Embeddings, 'isEnabled').returns(true),
+				sinon.stub(Zotero.Embeddings, 'getModelVersion').returns('test-model/1'),
+				sinon.stub(Zotero.Embeddings, 'isDownloaded').resolves(true),
+				sinon.stub(Zotero.Embeddings, 'preloadModel').resolves(),
+				sinon.stub(Zotero.Embeddings, 'ensureCalibration').resolves(),
+				sinon.stub(Zotero.Embeddings, 'getModelName').returns('bge-small-en-v1.5'),
+				sinon.stub(Zotero.Embeddings.Chunking, 'getTokenizer').resolves(wordTokenizer()),
+				sinon.stub(Zotero.SDT, 'getSections').resolves({
+					ok: true,
+					sections: [
+						sdtSection('', 0, ['A section with enough words to be worth indexing.'])
+					]
+				})
+			];
+			try {
+				Zotero.Prefs.set('embeddings.indexFulltext', true);
+				await Zotero.Embeddings.Indexing.startIndexing();
+				assert.ok(await Zotero.DB.valueQueryAsync(
+					"SELECT COUNT(*) FROM embeddings.itemEmbeddings WHERE itemID=?",
+					attachment.id
+				));
+
+				// Turning the pref off makes attachments ineligible, and the
+				// pref observer prunes their stored chunks. The observer runs
+				// asynchronously, so poll (the test times out on failure).
+				Zotero.Prefs.set('embeddings.indexFulltext', false);
+				while (await Zotero.DB.valueQueryAsync(
+						"SELECT COUNT(*) FROM embeddings.itemEmbeddings WHERE itemID=?",
+						attachment.id)) {
+					await Zotero.Promise.delay(10);
+				}
+			}
+			finally {
+				stubs.forEach(stub => stub.restore());
+				Zotero.Prefs.clear('embeddings.indexFulltext');
+			}
+		});
+
+		it("should index auxiliary chunks with words and drop bare labels", async function () {
+			this.timeout(60000);
+			let item = await createDataObject('item', { title: 'Parent of captioned attachment' });
+			let attachment = await importPDFAttachment(item);
+
+			let vector = new Float32Array(4).fill(0.5);
+			let stubs = [
+				sinon.stub(Zotero.Embeddings, 'embedPassages')
+					.callsFake(async texts => texts.map(() => vector)),
+				sinon.stub(Zotero.Embeddings, 'isEnabled').returns(true),
+				sinon.stub(Zotero.Embeddings, 'getModelVersion').returns('test-model/1'),
+				sinon.stub(Zotero.Embeddings, 'isDownloaded').resolves(true),
+				sinon.stub(Zotero.Embeddings, 'preloadModel').resolves(),
+				sinon.stub(Zotero.Embeddings, 'ensureCalibration').resolves(),
+				sinon.stub(Zotero.Embeddings, 'getModelName').returns('bge-small-en-v1.5'),
+				sinon.stub(Zotero.Embeddings.Chunking, 'getTokenizer').resolves(wordTokenizer()),
+				sinon.stub(Zotero.SDT, 'getSections').resolves({
+					ok: true,
+					sections: [
+						sdtSection('Results', 0, [
+							'Body text about owl migration patterns.',
+							{
+								text: 'Figure 3: Owl migration routes across the Baltic.',
+								flowClass: 'auxiliary'
+							},
+							'More body text about the wintering grounds.',
+							// A standalone label with no words to rank by
+							{ text: 'Figure 4', flowClass: 'auxiliary' }
+						])
+					]
+				})
+			];
+			try {
+				Zotero.Prefs.set('embeddings.indexFulltext', true);
+				await Zotero.Embeddings.Indexing.startIndexing();
+
+				let rows = await Zotero.DB.queryAsync(
+					"SELECT chunkText FROM embeddings.itemEmbeddings WHERE itemID=? "
+						+ "ORDER BY chunkIndex",
+					attachment.id
+				);
+				let texts = rows.map(row => row.chunkText);
+				// The caption is lifted out into its own chunk, and the body
+				// around it reads straight through
+				assert.lengthOf(texts, 2);
+				assert.include(texts[0], 'Body text about owl migration');
+				assert.include(texts[0], 'More body text about the wintering');
+				assert.notInclude(texts[0], 'Figure 3');
+				assert.equal(texts[1], 'Figure 3: Owl migration routes across the Baltic.');
+				// The bare label was dropped
+				assert.notInclude(texts, 'Figure 4');
+			}
+			finally {
+				stubs.forEach(stub => stub.restore());
+				Zotero.Prefs.clear('embeddings.indexFulltext');
+			}
+		});
+
+		it("should skip an attachment's reference entries", async function () {
+			this.timeout(60000);
+			let item = await createDataObject('item', { title: 'Parent of cited attachment' });
+			let attachment = await importPDFAttachment(item);
+
+			let vector = new Float32Array(4).fill(0.5);
+			let stubs = [
+				sinon.stub(Zotero.Embeddings, 'embedPassages')
+					.callsFake(async texts => texts.map(() => vector)),
+				sinon.stub(Zotero.Embeddings, 'isEnabled').returns(true),
+				sinon.stub(Zotero.Embeddings, 'getModelVersion').returns('test-model/1'),
+				sinon.stub(Zotero.Embeddings, 'isDownloaded').resolves(true),
+				sinon.stub(Zotero.Embeddings, 'preloadModel').resolves(),
+				sinon.stub(Zotero.Embeddings, 'ensureCalibration').resolves(),
+				sinon.stub(Zotero.Embeddings, 'getModelName').returns('bge-small-en-v1.5'),
+				sinon.stub(Zotero.Embeddings.Chunking, 'getTokenizer').resolves(wordTokenizer()),
+				sinon.stub(Zotero.SDT, 'getSections').resolves({
+					ok: true,
+					sections: [
+						sdtSection('Discussion', 0, [
+							'Owls migrate south when the winters turn cold.',
+							// An entry cited inline, inside a body section
+							{
+								text: 'Smith, J. (2019). Owls. J. Birds 4, 1-10.',
+								reference: true
+							}
+						]),
+						// A section that's nothing but references
+						sdtSection('References', 2, [
+							{
+								text: 'Doe, A. (2020). Migration. Nature 1, 2-3.',
+								reference: true
+							}
+						])
+					]
+				})
+			];
+			try {
+				Zotero.Prefs.set('embeddings.indexFulltext', true);
+				await Zotero.Embeddings.Indexing.startIndexing();
+
+				let texts = await Zotero.DB.columnQueryAsync(
+					"SELECT chunkText FROM embeddings.itemEmbeddings WHERE itemID=? "
+						+ "ORDER BY chunkIndex",
+					attachment.id
+				);
+				// Only the prose is indexed; a section left with nothing but
+				// references contributes no chunk at all
+				assert.lengthOf(texts, 1);
+				assert.include(texts[0], 'Owls migrate south');
+				assert.notInclude(texts[0], 'Smith, J.');
+				assert.notInclude(texts[0], 'Doe, A.');
+			}
+			finally {
+				stubs.forEach(stub => stub.restore());
+				Zotero.Prefs.clear('embeddings.indexFulltext');
+			}
+		});
+
+		it("should index smaller attachments before larger ones", async function () {
+			this.timeout(60000);
+			let item = await createDataObject('item', { title: 'Parent of sized attachments' });
+			// The big one is created first, so insertion order can't account
+			// for the result on its own
+			let big = await importPDFAttachment(item);
+			let small = await importPDFAttachment(item);
+			// The size the enqueue order goes by comes from Zotero's own
+			// fulltext index
+			await Zotero.DB.queryAsync(
+				"REPLACE INTO fulltextItems (itemID, totalPages) VALUES (?, ?)", [big.id, 800]);
+			await Zotero.DB.queryAsync(
+				"REPLACE INTO fulltextItems (itemID, totalPages) VALUES (?, ?)", [small.id, 2]);
+
+			let extracted = [];
+			let vector = new Float32Array(4).fill(0.5);
+			let stubs = [
+				sinon.stub(Zotero.Embeddings, 'embedPassages')
+					.callsFake(async texts => texts.map(() => vector)),
+				sinon.stub(Zotero.Embeddings, 'isEnabled').returns(true),
+				sinon.stub(Zotero.Embeddings, 'getModelVersion').returns('test-model/1'),
+				sinon.stub(Zotero.Embeddings, 'isDownloaded').resolves(true),
+				sinon.stub(Zotero.Embeddings, 'preloadModel').resolves(),
+				sinon.stub(Zotero.Embeddings, 'ensureCalibration').resolves(),
+				sinon.stub(Zotero.Embeddings, 'getModelName').returns('bge-small-en-v1.5'),
+				sinon.stub(Zotero.Embeddings.Chunking, 'getTokenizer').resolves(wordTokenizer()),
+				sinon.stub(Zotero.SDT, 'getSections').callsFake(async (itemID) => {
+					if (itemID === big.id || itemID === small.id) {
+						extracted.push(itemID);
+					}
+					return {
+						ok: true,
+						sections: [
+							sdtSection('', 0, ['A section with enough words to be worth indexing.'])
+						]
+					};
+				})
+			];
+			try {
+				Zotero.Prefs.set('embeddings.indexFulltext', true);
+				await Zotero.Embeddings.Indexing.startIndexing();
+
+				assert.deepEqual(extracted, [small.id, big.id]);
+			}
+			finally {
+				stubs.forEach(stub => stub.restore());
+				Zotero.Prefs.clear('embeddings.indexFulltext');
+			}
+		});
+
+		it("should fall back to an attachment's plain text when structured extraction fails", async function () {
+			this.timeout(60000);
+			let item = await createDataObject('item', { title: 'Parent of fallback attachment' });
+			let attachment = await importPDFAttachment(item);
+			Object.defineProperty(attachment, 'attachmentText', {
+				get: () => Promise.resolve('A plain paragraph of text about owl migration routes.'),
+				configurable: true
+			});
+
+			let vector = new Float32Array(4).fill(0.5);
+			let stubs = [
+				sinon.stub(Zotero.Embeddings, 'embedPassages')
+					.callsFake(async texts => texts.map(() => vector)),
+				sinon.stub(Zotero.Embeddings, 'isEnabled').returns(true),
+				sinon.stub(Zotero.Embeddings, 'getModelVersion').returns('test-model/1'),
+				sinon.stub(Zotero.Embeddings, 'isDownloaded').resolves(true),
+				sinon.stub(Zotero.Embeddings, 'preloadModel').resolves(),
+				sinon.stub(Zotero.Embeddings, 'ensureCalibration').resolves(),
+				sinon.stub(Zotero.Embeddings, 'getModelName').returns('bge-small-en-v1.5'),
+				sinon.stub(Zotero.Embeddings.Chunking, 'getTokenizer').resolves(wordTokenizer()),
+				sinon.stub(Zotero.SDT, 'getSections').resolves({ ok: false, reason: 'failed' })
+			];
+			try {
+				Zotero.Prefs.set('embeddings.indexFulltext', true);
+				await Zotero.Embeddings.Indexing.startIndexing();
+
+				// The flat text is chunked like a note: embedded, previewable,
+				// but without section locations
+				let rows = await Zotero.DB.queryAsync(
+					"SELECT embedding, chunkText, outlinePath, startBlock, endBlock "
+						+ "FROM embeddings.itemEmbeddings WHERE itemID=?",
+					attachment.id
+				);
+				assert.lengthOf(rows, 1);
+				assert.isNotNull(rows[0].embedding);
+				assert.include(rows[0].chunkText, 'owl migration routes');
+				assert.isNull(rows[0].outlinePath);
+				assert.isNull(rows[0].startBlock);
+			}
+			finally {
+				stubs.forEach(stub => stub.restore());
+				delete attachment.attachmentText;
+				Zotero.Prefs.clear('embeddings.indexFulltext');
+			}
+		});
+
+		it("should record an attachment with no extractable text as processed", async function () {
+			this.timeout(60000);
+			let item = await createDataObject('item', { title: 'Parent of empty attachment' });
+			let attachment = await importPDFAttachment(item);
+			Object.defineProperty(attachment, 'attachmentText', {
+				get: () => Promise.resolve(''),
+				configurable: true
+			});
+
+			let vector = new Float32Array(4).fill(0.5);
+			let getSectionsStub = sinon.stub(Zotero.SDT, 'getSections')
+				.resolves({ ok: false, reason: 'failed' });
+			let ourCalls = () => getSectionsStub.getCalls()
+				.filter(call => call.args[0] === attachment.id).length;
+			let stubs = [
+				sinon.stub(Zotero.Embeddings, 'embedPassages')
+					.callsFake(async texts => texts.map(() => vector)),
+				sinon.stub(Zotero.Embeddings, 'isEnabled').returns(true),
+				sinon.stub(Zotero.Embeddings, 'getModelVersion').returns('test-model/1'),
+				sinon.stub(Zotero.Embeddings, 'isDownloaded').resolves(true),
+				sinon.stub(Zotero.Embeddings, 'preloadModel').resolves(),
+				sinon.stub(Zotero.Embeddings, 'ensureCalibration').resolves(),
+				sinon.stub(Zotero.Embeddings, 'getModelName').returns('bge-small-en-v1.5'),
+				sinon.stub(Zotero.Embeddings.Chunking, 'getTokenizer').resolves(wordTokenizer()),
+				sinon.stub(Zotero.Embeddings, 'embedQuery').resolves(Float32Array.from(testMean)),
+				getSectionsStub
+			];
+			try {
+				Zotero.Prefs.set('embeddings.indexFulltext', true);
+				await Zotero.Embeddings.Indexing.startIndexing();
+
+				// The attempt is recorded as a single embedding-less row, so
+				// the item counts as processed and the progress counts align
+				let rows = await Zotero.DB.queryAsync(
+					"SELECT embedding, sourceHash FROM embeddings.itemEmbeddings WHERE itemID=?",
+					attachment.id
+				);
+				assert.lengthOf(rows, 1);
+				assert.isNull(rows[0].embedding);
+				assert.ok(rows[0].sourceHash);
+				assert.equal(ourCalls(), 1);
+
+				// A processed-but-empty item can't be scored, and doesn't
+				// break scoring for anything else
+				let scores = await Zotero.Embeddings.scoreItemIDs('anything', [attachment.id]);
+				assert.isFalse(scores.has(attachment.id));
+
+				// The record makes later passes skip the attachment without
+				// re-extracting, until the file changes
+				await Zotero.Embeddings.Indexing.startIndexing();
+				assert.equal(ourCalls(), 1);
+			}
+			finally {
+				stubs.forEach(stub => stub.restore());
+				delete attachment.attachmentText;
+				Zotero.Prefs.clear('embeddings.indexFulltext');
+			}
+		});
+
 		it("should look up stored hashes without a query per item", async function () {
 			this.timeout(60000);
 			for (let i = 0; i < 5; i++) {
diff --git a/test/tests/sdtTest.js b/test/tests/sdtTest.js
index a9630bbbcb..7c946fe689 100644
--- a/test/tests/sdtTest.js
+++ b/test/tests/sdtTest.js
@@ -8,6 +8,11 @@ describe("Zotero.SDT", function () {
 	let testSDTPackBytes;
 	let documentWorkerMetadata;
 
+	// A section without its block detail, for asserting the overall shape
+	function summarize({ blocks, ...section }) {
+		return section;
+	}
+
 	before(async function () {
 		let pako = getTestRequire()('pako');
 		documentWorkerMetadata = JSON.parse(await Zotero.File.getContentsFromURLAsync(
@@ -31,6 +36,218 @@ describe("Zotero.SDT", function () {
 		assert.deepEqual(progress, []);
 	});
 
+	it("should return outline-based sections from getSections()", async function () {
+		let item = await importFileAttachment('test.pdf');
+		let pako = getTestRequire()('pako');
+		let bytes = makeTestSDTPackV1WithContent(documentWorkerMetadata, pako, {
+			outline: [
+				{ title: 'Introduction', ref: [1] },
+				{ title: 'Methods', ref: [3] },
+			],
+			blocks: [
+				{ content: [{ text: 'Front matter on the title page' }] },
+				{ content: [{ text: 'Introduction' }] },
+				{ content: [{ text: 'Owls are nocturnal birds of prey.' }] },
+				{ content: [{ text: 'Methods' }] },
+				{ content: [{ text: 'We tracked forty owls with GPS loggers.' }] },
+				{ flowClass: 'excluded', content: [{ text: 'Page 3' }] },
+			],
+		});
+		await writeTestSDTCache(item, bytes);
+
+		let result = await Zotero.SDT.getSections(item.id);
+		assert.isTrue(result.ok);
+		assert.lengthOf(result.sections, 3);
+		// Content before the first heading is a section of its own
+		assert.deepEqual(summarize(result.sections[0]), {
+			text: 'Front matter on the title page',
+			outlinePath: '',
+			startBlock: 0,
+			endBlock: 0,
+		});
+		// A section starting at a heading carries the heading in its path,
+		// not its text, and runs to the next heading
+		assert.deepEqual(summarize(result.sections[1]), {
+			text: 'Owls are nocturnal birds of prey.',
+			outlinePath: 'Introduction',
+			startBlock: 1,
+			endBlock: 2,
+		});
+		assert.deepEqual(result.sections[1].blocks, [
+			{
+				index: 2,
+				text: 'Owls are nocturnal birds of prey.',
+				reference: false,
+			},
+		]);
+		// Excluded blocks (running heads, page numbers) are left out
+		assert.deepEqual(summarize(result.sections[2]), {
+			text: 'We tracked forty owls with GPS loggers.',
+			outlinePath: 'Methods',
+			startBlock: 3,
+			endBlock: 5,
+		});
+	});
+
+	it("should fall back to per-page sections from getSections() when there's no outline", async function () {
+		let item = await importFileAttachment('test.pdf');
+		let pako = getTestRequire()('pako');
+		let bytes = makeTestSDTPackV1WithContent(documentWorkerMetadata, pako, {
+			pages: [
+				{ contentRange: [[0], [1]] },
+				{ contentRange: [[2], [3]] },
+			],
+			blocks: [
+				{ content: [{ text: 'First page first paragraph.' }] },
+				{ content: [{ text: 'First page second paragraph.' }] },
+				{ content: [{ text: 'Second page first paragraph.' }] },
+				{ content: [{ text: 'Second page second paragraph.' }] },
+			],
+		});
+		await writeTestSDTCache(item, bytes);
+
+		let result = await Zotero.SDT.getSections(item.id);
+		assert.isTrue(result.ok);
+		assert.lengthOf(result.sections, 2);
+		assert.equal(result.sections[0].text,
+			'First page first paragraph.\nFirst page second paragraph.');
+		assert.equal(result.sections[0].startBlock, 0);
+		assert.equal(result.sections[0].endBlock, 1);
+		assert.equal(result.sections[1].text,
+			'Second page first paragraph.\nSecond page second paragraph.');
+		assert.equal(result.sections[1].outlinePath, '');
+	});
+
+	it("should flag reference entries in getSections()", async function () {
+		let item = await importFileAttachment('test.pdf');
+		let pako = getTestRequire()('pako');
+		let bytes = makeTestSDTPackV1WithContent(documentWorkerMetadata, pako, {
+			outline: [
+				{ title: 'Discussion', ref: [0] },
+				{ title: 'References', ref: [3] },
+			],
+			blocks: [
+				{ content: [{ text: 'Heading text' }] },
+				{ content: [{ text: 'Prose about owl migration.' }] },
+				// An entry cited inline, footnote-style, inside a body section
+				{ reference: true, content: [{ text: 'Smith, J. (2019). Owls. J. Birds 4, 1-10.' }] },
+				{ content: [{ text: 'References' }] },
+				// A bibliography as a list whose items carry the flag
+				{
+					type: 'list',
+					content: [
+						{
+							type: 'listitem',
+							reference: true,
+							content: [{ text: 'Doe, A. (2020). Migration. Nature 1, 2-3.' }],
+						},
+						{
+							type: 'listitem',
+							reference: true,
+							content: [{ text: 'Roe, B. (2021). Wintering. Science 2, 4-5.' }],
+						},
+					],
+				},
+			],
+		});
+		await writeTestSDTCache(item, bytes);
+
+		let result = await Zotero.SDT.getSections(item.id);
+		assert.isTrue(result.ok);
+		// Reference entries are reported, not dropped -- it's the caller's
+		// call whether they're worth reading
+		assert.lengthOf(result.sections, 2);
+		assert.equal(result.sections[0].outlinePath, 'Discussion');
+		assert.deepEqual(result.sections[0].blocks.map(block => block.reference),
+			[false, true]);
+		// A list whose items all carry the flag is a reference block itself
+		assert.equal(result.sections[1].outlinePath, 'References');
+		assert.lengthOf(result.sections[1].blocks, 1);
+		assert.isTrue(result.sections[1].blocks[0].reference);
+		assert.include(result.sections[1].blocks[0].text, 'Doe, A. (2020)');
+		assert.include(result.sections[1].blocks[0].text, 'Roe, B. (2021)');
+	});
+
+	it("should report each block's flow class in getSections()", async function () {
+		let item = await importFileAttachment('test.pdf');
+		let pako = getTestRequire()('pako');
+		let bytes = makeTestSDTPackV1WithContent(documentWorkerMetadata, pako, {
+			outline: [
+				{ title: 'Results', ref: [0] },
+			],
+			blocks: [
+				{ content: [{ text: 'Results' }] },
+				{ content: [{ text: 'Prose before the figure.' }] },
+				{
+					flowClass: 'auxiliary',
+					content: [{ text: 'Figure 3: Owl migration routes across the Baltic.' }],
+				},
+				{ content: [{ text: 'Prose after the figure.' }] },
+			],
+		});
+		await writeTestSDTCache(item, bytes);
+
+		let result = await Zotero.SDT.getSections(item.id);
+		assert.isTrue(result.ok);
+		// The caption stays where the document put it, marked as auxiliary
+		// flow so a caller can lift it out if that suits them
+		assert.lengthOf(result.sections, 1);
+		assert.equal(result.sections[0].text, 'Prose before the figure.\n'
+			+ 'Figure 3: Owl migration routes across the Baltic.\n'
+			+ 'Prose after the figure.');
+		assert.deepEqual(result.sections[0].blocks.map(block => block.flowClass),
+			[undefined, 'auxiliary', undefined]);
+		assert.deepEqual(result.sections[0].blocks.map(block => block.index), [1, 2, 3]);
+	});
+
+	it("should report page and position info from getSections()", async function () {
+		let item = await importFileAttachment('test.pdf');
+		let pako = getTestRequire()('pako');
+		let bytes = makeTestSDTPackV1WithContent(documentWorkerMetadata, pako, {
+			outline: [
+				{ title: 'Introduction', ref: [1] },
+			],
+			pages: [
+				{ label: 'ix', contentRange: [[0], [1]] },
+				{ label: '10', contentRange: [[1], [3]] },
+			],
+			blocks: [
+				{
+					anchor: { pageRects: [[0, 10, 700, 300, 720]] },
+					content: [{ text: 'Front matter on the title page' }],
+				},
+				{
+					anchor: { pageRects: [[1, 10, 700, 300, 720]] },
+					content: [{ text: 'Introduction' }],
+				},
+				{
+					anchor: { pageRects: [[1, 10, 600, 300, 680], [1, 10, 500, 300, 580]] },
+					content: [{ text: 'Owls are nocturnal birds of prey.' }],
+				},
+			],
+		});
+		await writeTestSDTCache(item, bytes);
+
+		let result = await Zotero.SDT.getSections(item.id);
+		assert.isTrue(result.ok);
+		assert.lengthOf(result.sections, 2);
+		// Page and label come from the section's first anchored block, and
+		// position is that block's page geometry
+		assert.equal(result.sections[0].pageIndex, 0);
+		assert.equal(result.sections[0].pageLabel, 'ix');
+		assert.deepEqual(result.sections[0].position,
+			{ pageIndex: 0, rects: [[10, 700, 300, 720]] });
+		// A heading-started section is anchored at its heading, so the
+		// reader lands on the section start
+		assert.equal(result.sections[1].pageIndex, 1);
+		assert.equal(result.sections[1].pageLabel, '10');
+		assert.deepEqual(result.sections[1].position,
+			{ pageIndex: 1, rects: [[10, 700, 300, 720]] });
+		// Its blocks are located individually, at their own geometry
+		assert.deepEqual(result.sections[1].blocks[0].position,
+			{ pageIndex: 1, rects: [[10, 600, 300, 680], [10, 500, 300, 580]] });
+	});
+
 	it("should generate the pack when missing", async function () {
 		let item = await importFileAttachment('test.pdf');
 		let cachePath = getSDTCachePath(item);
@@ -450,6 +667,64 @@ describe("Zotero.SDT", function () {
 		return bytes;
 	}
 
+	// A v1 pack with real content blocks and catalog, for section/outline
+	// consumers (see makeEmptyTestSDTPackV1() for the layout)
+	function makeTestSDTPackV1WithContent(metadata, pako, { outline = [], pages = [], blocks = [] } = {}) {
+		if (metadata.SDT_PACK_VERSION !== 1) {
+			throw new Error('Unsupported test SDT pack version');
+		}
+		const HEADER_LENGTH = 16;
+		// Two entries each of chunk byte offsets and chunk block starts, after
+		// the metadata and catalog lengths
+		const INDEX_LENGTH = 8 + 2 * 4 + 2 * 4;
+		let encoder = new TextEncoder();
+		let schemaVersion = metadata.SDT_SCHEMA_VERSION.split('.').map(Number);
+		let metadataBytes = pako.deflateRaw(JSON.stringify({
+			processor: {
+				type: 'pdf',
+				version: metadata.SDT_PROCESSOR_VERSIONS.pdf,
+			},
+			dateCreated: '2026-01-01T00:00:00.000Z',
+			source: { hash: TEST_PDF_HASH },
+		}));
+		let catalogBytes = pako.deflateRaw(JSON.stringify({ pages, outline }));
+		// One content chunk: an offset table, then the block JSON back to back
+		let blockByteArrays = blocks.map(block => encoder.encode(JSON.stringify(block)));
+		let chunkBytes = new Uint8Array(
+			blocks.length * 4 + blockByteArrays.reduce((sum, b) => sum + b.byteLength, 0)
+		);
+		let chunkView = new DataView(chunkBytes.buffer);
+		let blockOffset = 0;
+		let writeOffset = blocks.length * 4;
+		for (let i = 0; i < blockByteArrays.length; i++) {
+			chunkView.setUint32(i * 4, blockOffset, true);
+			blockOffset += blockByteArrays[i].byteLength;
+			chunkBytes.set(blockByteArrays[i], writeOffset);
+			writeOffset += blockByteArrays[i].byteLength;
+		}
+		let compressedChunk = pako.deflateRaw(chunkBytes);
+
+		let payloadOffset = HEADER_LENGTH + INDEX_LENGTH;
+		let bytes = new Uint8Array(
+			payloadOffset + metadataBytes.byteLength + catalogBytes.byteLength
+				+ compressedChunk.byteLength
+		);
+		bytes.set(SDT_PACK_MAGIC, 0);
+		bytes.set([metadata.SDT_PACK_VERSION, ...schemaVersion], 8);
+		let view = new DataView(bytes.buffer);
+		view.setUint32(12, INDEX_LENGTH, true);
+		view.setUint32(HEADER_LENGTH, metadataBytes.byteLength, true);
+		view.setUint32(HEADER_LENGTH + 4, catalogBytes.byteLength, true);
+		// chunkByteOffsets [0, byteLength], chunkBlockStarts [0, blockCount]
+		view.setUint32(HEADER_LENGTH + 12, compressedChunk.byteLength, true);
+		view.setUint32(HEADER_LENGTH + 20, blocks.length, true);
+		bytes.set(metadataBytes, payloadOffset);
+		bytes.set(catalogBytes, payloadOffset + metadataBytes.byteLength);
+		bytes.set(compressedChunk,
+			payloadOffset + metadataBytes.byteLength + catalogBytes.byteLength);
+		return bytes;
+	}
+
 	function decodeBase64Bytes(base64) {
 		let binary = atob(base64);
 		let bytes = new Uint8Array(binary.length);