@@ -1368,10 +1368,16 @@ exclude-result-prefixes="#all"
              only on the initial load: the answer is a property of the query, so paging, sorting and faceting
              cannot change it. The slot it fills is the card header's, emitted by ac:BlockActions with the
              rest of the block's actions - a view rendered without a card header (a modal-hosted one) has no
-             slot and no @data-for-class to construct from either, so both say the same thing by being absent -->
-        <xsl:if test="$initial-load">
+             slot and no @data-for-class to construct from either, so both say the same thing by being absent.
+             The query spans the whole result set, so it is only asked when its answer could become a button:
+             ldh:view-create-insert needs a class to construct, and an agent who can write - to this document as
+             well, for a forward view. Only the container's own access, which the query has to find first, is
+             left to ldh:view-create-insert -->
+        <xsl:variable name="create-slot" select="$container/ancestor::div[contains-token(@class, 'block')][1]/div[contains-token(@class, 'ldh-block-head')]/div[contains-token(@class, 'actions')]/span[contains-token(@class, 'ldh-view-create')]" as="element()?"/>
+        <xsl:variable name="create-block" select="$create-slot/ancestor::div[contains-token(@class, 'block')][1]" as="element()?"/>
+        <xsl:if test="$initial-load and exists($create-block/@data-for-class) and exists($acl:agent) and (exists($create-block/@data-inverse) or $acl-modes = '&acl;Write')">
             <xsl:call-template name="ldh:ViewContainer">
-                <xsl:with-param name="create-slot" select="$container/ancestor::div[contains-token(@class, 'block')][1]/div[contains-token(@class, 'ldh-block-head')]/div[contains-token(@class, 'actions')]/span[contains-token(@class, 'ldh-view-create')]"/>
+                <xsl:with-param name="create-slot" select="$create-slot"/>
                 <xsl:with-param name="focus-var-name" select="$focus-var-name"/>
                 <xsl:with-param name="acl-modes" select="$acl-modes"/>
                 <xsl:with-param name="endpoint" select="$endpoint"/>
@@ -1847,16 +1853,49 @@ exclude-result-prefixes="#all"
                         'inverse-var-name': 'inverse' || $suffix,
                         'property-metadata': $property-metadata
                       }"/>
+
+                    <!-- discovery runs only while the pivot bar is open, so someone is waiting on it, and the bar
+                         stays hidden until its first chip arrives: the cursor is all that says it is underway -->
+                    <xsl:sequence select="ldh:busy-cursor()"/>
+
                     <ixsl:promise select="ixsl:http-request($context('request')) =>
                         ixsl:then(ldh:rethread-response($context, ?)) =>
                         ixsl:then(ldh:handle-response#1) =>
-                        ixsl:then(ldh:parallax-response#1)"
+                        ixsl:then(ldh:parallax-response#1) =>
+                        ixsl:finally(ldh:reset-cursor#0)"
                         on-failure="ldh:promise-failure(., 'block-query-failed', ?)"/>
                 </xsl:if>
             </xsl:if>
         </xsl:for-each>
     </xsl:template>
-    
+
+    <!-- A view under a collapsed pivot bar renders without discovering its chips (ldh:render-view), so opening
+         the bar is what discovers them, from the result set the view last rendered. The block's own toggle runs
+         first and stays ignorant of views; this rule only reads which bars it left open. A view that has not
+         rendered yet has nothing cached to discover from, and discovers in ldh:render-view instead, where the
+         bar is then found open. Toggling again does not re-query: ldh:ParallaxNav skips an unchanged result set -->
+    <xsl:template match="div[contains-token(@class, 'block')]//button[contains-token(@class, 'tb-controls')]" mode="ixsl:onclick" priority="1">
+        <xsl:variable name="block" select="ancestor::div[contains-token(@class, 'block')][1]" as="element()"/>
+
+        <xsl:next-match/>
+
+        <xsl:for-each select="$block//div[contains-token(@class, 'ldh-pivot-bar')][not(contains-token(@class, 'is-collapsed'))]/div[contains-token(@class, 'ldh-pivot-pills')]">
+            <xsl:variable name="cache" select="ldh:view-cache(.)" as="item()?"/>
+
+            <xsl:if test="exists($cache) and ixsl:contains($cache, 'results') and ixsl:contains($cache, 'focus-var-name')">
+                <xsl:call-template name="ldh:ParallaxNav">
+                    <xsl:with-param name="empty-results" select="empty(ixsl:get($cache, 'results')/rdf:RDF/*)"/>
+                    <xsl:with-param name="select-xml" select="ixsl:get($cache, 'select-xml')"/>
+                    <xsl:with-param name="endpoint" select="ixsl:get($cache, 'endpoint')"/>
+                    <xsl:with-param name="focus-var-name" select="ixsl:get($cache, 'focus-var-name')"/>
+                    <xsl:with-param name="property-metadata" select="if (ixsl:contains($cache, 'property-metadata')) then ixsl:get($cache, 'property-metadata') else ()"/>
+                    <xsl:with-param name="cache" select="$cache"/>
+                    <xsl:with-param name="properties-container-id" select="@id"/>
+                </xsl:call-template>
+            </xsl:if>
+        </xsl:for-each>
+    </xsl:template>
+
     <!-- resolves the view's client-side cache entry: block-hosted views are keyed by the host block's @about, modal-hosted views (geo/latest/search/class instances) by the container's @id -->
     <xsl:function name="ldh:view-cache" as="item()">
         <xsl:param name="container" as="element()"/>
@@ -3096,15 +3135,26 @@ exclude-result-prefixes="#all"
                 </xsl:call-template>
             </xsl:for-each>
 
-            <xsl:call-template name="ldh:ParallaxNav">
-                <xsl:with-param name="empty-results" select="empty($sorted-results/rdf:RDF/*)"/>
-                <xsl:with-param name="select-xml" select="$select-xml"/>
-                <xsl:with-param name="endpoint" select="$endpoint"/>
-                <xsl:with-param name="focus-var-name" select="$focus-var-name"/>
-                <xsl:with-param name="property-metadata" select="$property-metadata"/>
-                <xsl:with-param name="cache" select="$cache"/>
-                <xsl:with-param name="properties-container-id" select="$container-id || '-parallax-properties'"/>
-            </xsl:call-template>
+            <!-- what a pivot bar opened later discovers from, beside the select-xml, endpoint and results the
+                 cache already holds (the tb-controls rule beside ldh:ParallaxNav) -->
+            <ixsl:set-property name="focus-var-name" select="$focus-var-name" object="$cache"/>
+            <xsl:if test="exists($property-metadata)">
+                <ixsl:set-property name="property-metadata" select="$property-metadata" object="$cache"/>
+            </xsl:if>
+
+            <!-- discovery runs over the whole result set and is the costliest query a view sends, so it runs
+                 only while its chips can be seen: a collapsed pivot bar defers it to the controls toggle -->
+            <xsl:if test="($container//div[contains-token(@class, 'ldh-pivot-bar')])[1][not(contains-token(@class, 'is-collapsed'))]">
+                <xsl:call-template name="ldh:ParallaxNav">
+                    <xsl:with-param name="empty-results" select="empty($sorted-results/rdf:RDF/*)"/>
+                    <xsl:with-param name="select-xml" select="$select-xml"/>
+                    <xsl:with-param name="endpoint" select="$endpoint"/>
+                    <xsl:with-param name="focus-var-name" select="$focus-var-name"/>
+                    <xsl:with-param name="property-metadata" select="$property-metadata"/>
+                    <xsl:with-param name="cache" select="$cache"/>
+                    <xsl:with-param name="properties-container-id" select="$container-id || '-parallax-properties'"/>
+                </xsl:call-template>
+            </xsl:if>
 
             <!-- last, so it reads a toolbar whose facet pills and step chips are already current -->
             <xsl:call-template name="ldh:ViewStatus">
 
@@ -0,0 +1,82 @@
+// The two whole-result-set queries a view used to send on every load, asked only when their answer
+// can be seen.
+//
+// Related-results discovery groups every predicate of every solution - not the page, the whole set -
+// and checks that each object is a subject somewhere. The container lookup joins every solution to its
+// document and that document's container. Both scale with the result set rather than the page, and on
+// a view over a few thousand solutions each took 4-12 s of store time per load (measured 2026-10-19 on
+// the LTLOD dataset, a member's votes). Neither shows anything until asked: the pivot chips sit in a
+// bar the card draws collapsed, and the container only becomes a Create button for an agent who could
+// create there. So discovery waits for the controls toggle, and the lookup for a class to construct and
+// an agent who may write.
+//
+// The requests are told apart by the shape of their SPARQL, because nothing else distinguishes one
+// POST to the endpoint from another: discovery is the only query projecting ?objectPredicate (its
+// EXISTS over each object's own triples), the lookup the only one joining documents to a
+// sioc:has_container ?container. The Create button that the lookup leads to is asserted where it is
+// offered, in create.spec.
+import { test, expect } from '../../../../lib/console.mjs';
+import { goto, loaded } from '../../../../lib/settle.mjs';
+import { fixtures, itemTitle } from '../../../../lib/fixtures.mjs';
+import { controlToggle } from '../../../../lib/block.mjs';
+import { fixtureView, listTitles } from '../../../../lib/view.mjs';
+
+const HAS_CONTAINER = 'http://rdfs.org/sioc/ns#has_container';
+const DISCOVERY = /\?objectPredicate/;
+const CONTAINER_LOOKUP = /sioc\/ns#has_container> \?container/;
+
+// Every query the page POSTs to its SPARQL endpoint, recorded from before navigation on.
+function sparqlQueries(page) {
+    const sent = [];
+    page.on('request', request => {
+        if (request.method() === 'POST' && new URL(request.url()).pathname === '/sparql') sent.push(request.postData() ?? '');
+    });
+    return pattern => sent.filter(query => pattern.test(query)).length;
+}
+
+// What a view sends next is decided when its results render, so "nothing was sent" can only be read
+// once the block has finished loading and the requests it fired have had time to leave.
+async function quiet(page) {
+    await loaded(page);
+    await page.waitForLoadState('networkidle');
+}
+
+test.describe('the queries a view defers', { tag: '@owner' }, () => {
+    test('discovers related results only once the controls are opened', async ({ page }) => {
+        const sent = sparqlQueries(page);
+        await goto(page, fixtures.container);
+        const block = fixtureView(page);
+        await expect(listTitles(block).first()).toHaveText(itemTitle(1));
+        await quiet(page);
+
+        // Rendered with the bar collapsed: no discovery, and no chips waiting behind it.
+        await expect(block.locator('.ldh-pivot-bar')).toHaveClass(/\bis-collapsed\b/);
+        expect(sent(DISCOVERY)).toBe(0);
+        await expect(block.locator('.ldh-pivot-pills > *')).toHaveCount(0);
+
+        // Opening the controls discovers, once, and the chips arrive.
+        await controlToggle(block).click();
+        await expect(block.locator(`.ldh-pivot-bar button.ldh-pivot-pill[data-dir="out"][title="${HAS_CONTAINER}"]`)).toBeVisible();
+        expect(sent(DISCOVERY)).toBe(1);
+
+        // Closing and reopening shows the same result set, so it is not discovered again.
+        await controlToggle(block).click();
+        await controlToggle(block).click();
+        await quiet(page);
+        expect(sent(DISCOVERY)).toBe(1);
+        await expect(block.locator(`.ldh-pivot-bar button.ldh-pivot-pill[data-dir="out"][title="${HAS_CONTAINER}"]`)).toBeVisible();
+    });
+
+    test('asks for no container when the view has no class to create', async ({ page }) => {
+        const sent = sparqlQueries(page);
+        await goto(page, fixtures.container);
+        const block = fixtureView(page);
+        await expect(listTitles(block).first()).toHaveText(itemTitle(1));
+        await quiet(page);
+
+        // An authored view names no class to construct - only an ontology view's property range does -
+        // so no answer the lookup could give would become a button.
+        await expect(block).not.toHaveAttribute('data-for-class');
+        expect(sent(CONTAINER_LOOKUP)).toBe(0);
+    });
+});