@@ -10,6 +10,7 @@
 - Views defer their whole-result-set queries until they scroll into sight, and load their metadata in parallel with the document's
 - Discovering a view's link predicates is faster
 - The `ldh` plugin is named LinkedDataHub, has an icon and documents where it sends data
+- `ldh add result-set-chart` takes `--series-var-name` more than once, for charts with several series
 
 ### Fixed
 - An external document whose RDF could not be retrieved opens as a page instead of an error
 
@@ -19,6 +19,7 @@
 import com.atomgraph.linkeddatahub.cli.BaseCommand;
 import com.atomgraph.linkeddatahub.rdf.Views;
 import java.net.URI;
+import java.util.List;
 import picocli.CommandLine.Command;
 import picocli.CommandLine.Option;
 import picocli.CommandLine.Parameters;
@@ -50,16 +51,16 @@ public class AddResultSetChart extends BaseCommand
     @Option(names = "--category-var-name", required = true, paramLabel = "VAR_NAME", description = "Name of the category variable")
     private String categoryVarName;
 
-    @Option(names = "--series-var-name", required = true, paramLabel = "VAR_NAME", description = "Name of the series variable")
-    private String seriesVarName;
+    @Option(names = "--series-var-name", required = true, paramLabel = "VAR_NAME", description = "Name of a series variable (repeatable; the chart orders them as the query projects them)")
+    private List<String> seriesVarNames;
 
     @Parameters(paramLabel = "TARGET_URI", description = "URI of the document")
     private URI target;
 
     @Override
     public Integer call() throws Exception
     {
-        post(getClient(), target, Views.resultSetChart(target, uri, title, query, chartType, categoryVarName, seriesVarName, description));
+        post(getClient(), target, Views.resultSetChart(target, uri, title, query, chartType, categoryVarName, seriesVarNames, description));
         print(target);
 
         return 0;
 
@@ -121,6 +121,8 @@ ORDER BY DESC(?productCount)""" .
   resources need `geo:lat`/`geo:long`), `ac:GraphMode`.
 - Chart types (`ldh:chartType`): `ac:BarChart`, `ac:LineChart`, `ac:ScatterChart`.
   `ldh:categoryVarName` and `ldh:seriesVarName` name the query's variables, without `?`.
+  `ldh:seriesVarName` may repeat (`--series-var-name` too); the series are drawn in the order the
+  query's `SELECT` projects them.
 - A query runs against the dataspace's own endpoint unless it names a service:
   `<#q> ldh:service <#dbpedia>` with `<#dbpedia> a sd:Service ; dct:title "DBpedia" ;
   sd:endpoint <https://dbpedia.org/sparql> ; sd:supportedLanguage sd:SPARQL11Query`. Time a remote
 
@@ -20,6 +20,7 @@
 import com.atomgraph.linkeddatahub.rdf.vocabulary.LDH;
 import com.atomgraph.linkeddatahub.rdf.vocabulary.SPIN;
 import java.net.URI;
+import java.util.List;
 import org.apache.jena.rdf.model.Model;
 import org.apache.jena.rdf.model.ModelFactory;
 import org.apache.jena.rdf.model.Resource;
@@ -76,6 +77,26 @@ public static Model view(URI target, String uri, URI query, String title, String
      * @return chart model
      */
     public static Model resultSetChart(URI target, String uri, String title, URI query, URI chartType, String categoryVarName, String seriesVarName, String description)
+    {
+        return resultSetChart(target, uri, title, query, chartType, categoryVarName, List.of(seriesVarName), description);
+    }
+
+    /**
+     * Builds a chart of a SELECT query's result set with one or more series. The values of
+     * <code>ldh:seriesVarName</code> are unordered, so the chart orders its series by the query's
+     * projection, not by this list.
+     *
+     * @param target target document URI
+     * @param uri chart URI, relative or absolute (optional, blank node when absent)
+     * @param title chart title
+     * @param query URI of the query the chart runs
+     * @param chartType chart type URI
+     * @param categoryVarName result-set variable name providing the categories
+     * @param seriesVarNames result-set variable names providing the series
+     * @param description chart description (optional)
+     * @return chart model
+     */
+    public static Model resultSetChart(URI target, String uri, String title, URI query, URI chartType, String categoryVarName, List<String> seriesVarNames, String description)
     {
         Model model = ModelFactory.createDefaultModel();
 
@@ -84,8 +105,8 @@ public static Model resultSetChart(URI target, String uri, String title, URI que
             addProperty(DCTerms.title, title).
             addProperty(SPIN.query, model.createResource(query.toString())).
             addProperty(LDH.chartType, model.createResource(chartType.toString())).
-            addProperty(LDH.categoryVarName, categoryVarName).
-            addProperty(LDH.seriesVarName, seriesVarName);
+            addProperty(LDH.categoryVarName, categoryVarName);
+        for (String seriesVarName : seriesVarNames) chart.addProperty(LDH.seriesVarName, seriesVarName);
         if (description != null) chart.addProperty(DCTerms.description, description);
 
         return model;
 
@@ -73,6 +73,13 @@ export const fixtures = {
     // hold; a sibling of the container, so the document tree's item count does too.
     remoteHost: `${endUserBase}${slug}-remote/`,
     remoteBlock: `${endUserBase}${slug}-remote/#remote-block`,
+    // A chart of several series, in a document of its own so the container's block count holds.
+    // ldh:seriesVarName is multi-valued and RDF keeps no order among the values, so the chart has to
+    // take its column order from the query's projection; see seriesQuery below.
+    seriesDocument: `${endUserBase}${slug}-series/`,
+    seriesQuery: `${endUserBase}${slug}-series/#measures-query`,
+    seriesChart: `${endUserBase}${slug}-series/#measures-chart`,
+    seriesBlock: `${endUserBase}${slug}-series/#measures-block`,
 };
 
 // The embedded resource itself, in the second end-user dataspace the preflight resolved. Functions
@@ -191,6 +198,24 @@ WHERE
 GROUP BY ?kind
 ORDER BY ?kind`;
 
+// Four series, so that a chart ordering them by anything but the projection matches it by chance
+// one time in 24 rather than one in two. Projected in this order, declared in the reverse.
+export const seriesProjection = ['items', 'chars', 'shortest', 'longest'];
+
+const seriesQuery = `PREFIX  sioc: <http://rdfs.org/sioc/ns#>
+PREFIX  dct:  <http://purl.org/dc/terms/>
+
+SELECT  ?kind (COUNT(?item) AS ?items) (SUM(STRLEN(?title)) AS ?chars) (MIN(STRLEN(?title)) AS ?shortest) (MAX(STRLEN(?title)) AS ?longest)
+WHERE
+  { GRAPH ?g
+      { ?item  sioc:has_container  <${fixtures.container}> ;
+               dct:title           ?title ;
+               dct:description     ?kind
+      }
+  }
+GROUP BY ?kind
+ORDER BY ?kind`;
+
 export async function seed() {
     const container = await ldh(['create', 'container',
         '--parent', endUserBase, '--title', containerTitle, '--slug', slug]);
@@ -242,6 +267,25 @@ export async function seed() {
     await ldh(['add', 'object-block', '--title', 'Fixture query block', '--uri', fixtures.queryBlock,
         '--value', fixtures.query, fixtures.queryDocument]);
 
+    await ldh(['create', 'item',
+        '--container', endUserBase,
+        '--title', 'Fixture series',
+        '--slug', `${slug}-series`]);
+    const seriesQueryFile = join(mkdtempSync(join(tmpdir(), 'ui-tests-')), 'measures.rq');
+    writeFileSync(seriesQueryFile, seriesQuery);
+    await ldh(['add', 'select', '--title', 'Fixture item measures',
+        '--uri', fixtures.seriesQuery, '--query-file', seriesQueryFile, fixtures.seriesDocument]);
+    // A Table, because its header row IS the column order: a chart type draws the same columns as
+    // bars and legend entries, which say nothing about position.
+    await ldh(['add', 'result-set-chart', '--title', 'Fixture measures chart',
+        '--uri', fixtures.seriesChart, '--query', fixtures.seriesQuery,
+        '--chart-type', 'https://w3id.org/atomgraph/client#Table',
+        '--category-var-name', 'kind',
+        ...seriesProjection.toReversed().flatMap(name => ['--series-var-name', name]),
+        fixtures.seriesDocument]);
+    await ldh(['add', 'object-block', '--title', 'Fixture measures block', '--uri', fixtures.seriesBlock,
+        '--value', fixtures.seriesChart, fixtures.seriesDocument]);
+
     // The cross-origin pair: a document in the other dataspace, created by the same owner (the root
     // owner owns every dataspace of the stack, the entrypoint sees to that), and the host here that
     // embeds it. The remote grant is what makes the embedded rendering an anonymous reader's to
@@ -275,6 +319,7 @@ export async function seed() {
         '--to', fixtures.container,
         '--to', fixtures.readable,
         '--to', fixtures.remoteHost,
+        '--to', fixtures.seriesDocument,
         '--read',
         adminBase]);
 
@@ -305,6 +350,7 @@ export async function teardown() {
     }
     await ldh(['delete', fixtures.private], { allowFailure: true });
     await ldh(['delete', fixtures.queryDocument], { allowFailure: true });
+    await ldh(['delete', fixtures.seriesDocument], { allowFailure: true });
     await ldh(['delete', fixtures.remoteHost], { allowFailure: true });
     // Only once the preflight has resolved the remote dataspace: a teardown that runs before it
     // (UI_TESTS_SKIP_SEED, or a run that failed earlier in the preflight) has nothing to remove there.
 
@@ -0,0 +1,28 @@
+// The chart block's series, in the order the query projects them.
+//
+// ldh:seriesVarName is multi-valued, and RDF keeps no order among a property's values, so the page
+// lists the series in whatever order the server happened to serialize them. Some charts read their
+// columns by position: a Timeline is row label, bar label, start, end. LTLOD's timeline declared
+// "seats", "start", "end", was served end, start, seats, and Google Charts refused it with "Invalid
+// data table format: column #1 must be of type 'string'" - in production, with nothing here to
+// notice, because every fixture chart had a single series.
+//
+// The fixture declares four series in the reverse of the order its query projects them, and draws
+// them as a Table, whose header row is the DataTable's column order read straight off the page.
+// Four, because a chart ordering by anything but the projection still matches it by chance one
+// time in 24; with two it would pass half the time without the fix.
+import { test, expect } from '../../../../lib/console.mjs';
+import { goto } from '../../../../lib/settle.mjs';
+import { fixtures, seriesProjection } from '../../../../lib/fixtures.mjs';
+import { canvas, chartBlock } from '../../../../lib/chart.mjs';
+
+test('takes its series in the order the query projects them, not the order they are declared in', async ({ page }) => {
+    await goto(page, fixtures.seriesDocument);
+
+    const block = chartBlock(page, fixtures.seriesChart);
+    const table = canvas(block).locator('.google-visualization-table');
+    await expect(table).toBeVisible({ timeout: 30_000 });
+
+    // The category first, then the series as SELECT lists them.
+    await expect(table.locator('tr').first().locator('th')).toHaveText(['kind', ...seriesProjection]);
+});