@blueprint-chart/mcp 0.1.1 → 0.1.4

package/dist/tools/describeChartType.js

@@ -0,0 +1,143 @@
+import { z } from 'zod';
+import { getChartOptions, samples } from '@blueprint-chart/lib';
+import { getDoc, listDocs } from '@blueprint-chart/docs';
+import { aliasesFor, canonicalChartType, listCanonicalChartTypes } from '../dsl/chartTypes';
+import { nearestSuggestion } from '../dsl/suggest';
+import { UNIVERSAL_PROPERTIES, UNIVERSAL_PROPERTY_META } from '../dsl/universalProperties';
+import { ErrorCode, toolError, toolOk } from '../errors';
+import { publicDocUrl } from '../resources/docsReader';
+import { lookupCapability, statusOf } from '../dsl/capabilityMatrix';
+export const DescribeChartTypeInputSchema = z.object({
+    chartType: z.string(),
+}).strict();
+function extractDocSections(name) {
+    const entries = listDocs('charts');
+    const entry = entries.find(e => e.slug === name);
+    if (!entry) {
+        return { summary: '', whenToUse: [], whenNotToUse: [], example: '' };
+    }
+    let content;
+    try {
+        content = getDoc('charts', name).content;
+    }
+    catch {
+        return { summary: '', whenToUse: [], whenNotToUse: [], example: '' };
+    }
+    const summary = content.match(/^>\s*(.+)$/m)?.[1]?.trim() ?? '';
+    const sectionBullets = (heading) => {
+        const re = new RegExp(`##\\s+${heading}[\\s\\S]*?(?=^##\\s+|\\Z)`, 'm');
+        const block = content.match(re)?.[0] ?? '';
+        return Array.from(block.matchAll(/^-\s+(.+)$/gm)).map(m => m[1].trim());
+    };
+    const example = content.match(/```bpc\n([\s\S]*?)```/)?.[1]?.trim() ?? '';
+    return {
+        summary,
+        whenToUse: sectionBullets('When to use'),
+        whenNotToUse: sectionBullets('When NOT to use'),
+        example,
+    };
+}
+function mapOption(opt) {
+    const prop = {
+        key: opt.key,
+        type: String(opt.type),
+    };
+    if (opt.label) {
+        prop.description = opt.label;
+    }
+    if (opt.choices !== undefined && opt.choices.length > 0) {
+        prop.choices = opt.choices.map(c => String(c.value));
+    }
+    if (opt.default !== undefined) {
+        prop.default = opt.default;
+    }
+    return prop;
+}
+function buildProperties(canonical) {
+    const registeredOptions = getChartOptions(canonical);
+    const registeredKeys = new Set(registeredOptions.map(o => o.key));
+    const props = registeredOptions.map(mapOption);
+    // Merge in universal properties that are not already present in the
+    // per-type registry. This ensures discoverable properties like `sort`,
+    // `title`, and `colors` appear for every chart type.
+    for (const key of UNIVERSAL_PROPERTIES) {
+        if (!registeredKeys.has(key)) {
+            const meta = UNIVERSAL_PROPERTY_META[key];
+            if (meta) {
+                props.push({ key, ...meta });
+            }
+            else {
+                props.push({ key, type: 'text' });
+            }
+        }
+    }
+    return props;
+}
+function inferDataShape(name, example) {
+    if (example.includes('_series')) {
+        return { kind: 'multi-series', example };
+    }
+    if (example.includes('data')) {
+        return { kind: 'single-series', example };
+    }
+    return { kind: 'unknown', example: 'data {\n  "Label" = 1.0\n}' };
+}
+const DIRECTIVE_DOCS = [
+    { name: 'highlight', description: 'Emphasise one category/series, e.g. `highlight "China"`.' },
+    { name: 'colorize', description: 'Override colour for a category/series, e.g. `colorize "China" { color = "#f00" }`.' },
+    { name: 'annotation', description: 'Attach a callout to a data point, e.g. `annotation "2009" { text = "…" }`.' },
+    { name: 'transform', description: 'Reshape data, e.g. `transform sort { column = "value" direction = descending }`.' },
+    { name: 'scene', description: 'Add a narrative step that overrides data/properties, e.g. `scene "Step 2" { … }`.' },
+];
+function buildDirectives(canonical) {
+    return DIRECTIVE_DOCS.map((d) => {
+        const cell = lookupCapability(canonical, d.name);
+        const directive = {
+            name: d.name,
+            status: statusOf(cell),
+            description: d.description,
+        };
+        if (cell.note) {
+            directive.note = cell.note;
+        }
+        return directive;
+    });
+}
+export function describeChartType(input) {
+    const parsed = DescribeChartTypeInputSchema.safeParse(input);
+    if (!parsed.success) {
+        return toolError(ErrorCode.E_INPUT, parsed.error.issues.map(i => ({ path: i.path.join('.'), message: i.message })));
+    }
+    const canonical = canonicalChartType(parsed.data.chartType);
+    if (!canonical) {
+        const known = listCanonicalChartTypes();
+        return toolError(ErrorCode.E_INPUT, [{
+                code: 'E_UNKNOWN_CHART_TYPE',
+                path: 'chartType',
+                message: `Unknown chart type "${parsed.data.chartType}". Known types: ${known.join(', ')}.`,
+                suggestion: nearestSuggestion(parsed.data.chartType, known),
+                context: { got: parsed.data.chartType, known },
+            }]);
+    }
+    const doc = extractDocSections(canonical);
+    const properties = buildProperties(canonical);
+    const directives = buildDirectives(canonical);
+    const sample = samples.find(s => s.chartType === canonical);
+    const exampleText = doc.example || sample?.dsl || '';
+    const output = {
+        name: canonical,
+        aliases: aliasesFor(canonical),
+        summary: doc.summary,
+        whenToUse: doc.whenToUse,
+        whenNotToUse: doc.whenNotToUse,
+        properties,
+        directives,
+        dataShape: inferDataShape(canonical, exampleText),
+        exampleSlug: sample?.id,
+    };
+    const docsUrl = publicDocUrl('charts', canonical);
+    if (docsUrl) {
+        output.docsUrl = docsUrl;
+    }
+    return toolOk(output);
+}

package/dist/tools/describeChartType.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tools/describeChartType.test.js

@@ -0,0 +1,78 @@
+import { afterEach, describe, expect, it } from 'vitest';
+import { describeChartType } from './describeChartType';
+describe('describe_chart_type', () => {
+    afterEach(() => {
+        delete process.env.BLUEPRINT_CHART_DOCS_URL;
+    });
+    it('returns properties + summary for bar-horizontal', () => {
+        const r = describeChartType({ chartType: 'bar-horizontal' });
+        expect(r.ok).toBe(true);
+        if (r.ok) {
+            expect(r.data.name).toBe('bar-horizontal');
+            expect(r.data.aliases).toContain('horizontal-bar');
+            expect(r.data.summary.length).toBeGreaterThan(0);
+            expect(r.data.properties.length).toBeGreaterThan(0);
+            const sort = r.data.properties.find(p => p.key === 'sort');
+            expect(sort).toBeDefined();
+            expect(sort?.type).toBeDefined();
+        }
+    });
+    it('accepts an alias and normalizes', () => {
+        const r = describeChartType({ chartType: 'horizontal-bar' });
+        expect(r.ok).toBe(true);
+        if (r.ok) {
+            expect(r.data.name).toBe('bar-horizontal');
+        }
+    });
+    it('errors with structured suggestion on unknown name', () => {
+        const r = describeChartType({ chartType: 'bar' });
+        expect(r.ok).toBe(false);
+        if (!r.ok) {
+            expect(r.errors[0].code).toBe('E_UNKNOWN_CHART_TYPE');
+            expect(r.errors[0].suggestion).toMatch(/^bar-/);
+        }
+    });
+    it('includes a starter dataShape example', () => {
+        const r = describeChartType({ chartType: 'bar-vertical' });
+        expect(r.ok).toBe(true);
+        if (r.ok) {
+            expect(r.data.dataShape.kind).toMatch(/single-series|multi-series/);
+            expect(r.data.dataShape.example).toContain('data');
+        }
+    });
+    it('omits docsUrl when docs base is unset', () => {
+        const result = describeChartType({ chartType: 'bar-vertical' });
+        expect(result.ok).toBe(true);
+        if (result.ok) {
+            expect(result.data.docsUrl).toBeUndefined();
+        }
+    });
+    it('includes a top-level docsUrl when docs base is set', () => {
+        process.env.BLUEPRINT_CHART_DOCS_URL = 'https://docs.blueprintchart.com';
+        const result = describeChartType({ chartType: 'bar-vertical' });
+        expect(result.ok).toBe(true);
+        if (result.ok) {
+            expect(result.data.docsUrl).toBe('https://docs.blueprintchart.com/charts/bar-vertical');
+        }
+    });
+});
+describe('describe_chart_type directives', () => {
+    it('lists highlight/colorize/annotation directives with status', () => {
+        const r = describeChartType({ chartType: 'bar-vertical' });
+        expect(r.ok).toBe(true);
+        if (r.ok) {
+            const names = r.data.directives.map(d => d.name);
+            expect(names).toEqual(expect.arrayContaining(['highlight', 'colorize', 'annotation']));
+            const highlight = r.data.directives.find(d => d.name === 'highlight');
+            expect(highlight?.status).toBe('supported');
+        }
+    });
+    it('marks colorize supported on donut (W1c shipped per-slice colorize)', () => {
+        const r = describeChartType({ chartType: 'donut' });
+        expect(r.ok).toBe(true);
+        if (r.ok) {
+            const colorize = r.data.directives.find(d => d.name === 'colorize');
+            expect(colorize?.status).toBe('supported');
+        }
+    });
+});

package/dist/tools/exportChart.d.ts

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+import { type FrameMetadata } from '../render/frame';
+import { type ToolResult } from '../errors';
+export declare const ExportChartInputSchema: z.ZodObject<{
+    source: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    source: string;
+}, {
+    source: string;
+}>;
+export type ExportChartInput = z.infer<typeof ExportChartInputSchema>;
+export interface ExportChartOutput {
+    copyUrl: string;
+    embedUrl: string;
+    frame: FrameMetadata;
+}
+export declare function exportChart(input: unknown): ToolResult<ExportChartOutput>;

package/dist/tools/exportChart.js

@@ -0,0 +1,31 @@
+import { z } from 'zod';
+import { getEditorBaseUrl } from '../links/editorConfig';
+import { buildCopyUrl, buildEmbedUrl } from '../links/buildUrls';
+import { validatePipeline } from '../render/validatePipeline';
+import { extractFrameMetadata } from '../render/frame';
+import { ErrorCode, toolError, toolOk } from '../errors';
+export const ExportChartInputSchema = z.object({
+    source: z.string(),
+}).strict();
+export function exportChart(input) {
+    const parsed = ExportChartInputSchema.safeParse(input);
+    if (!parsed.success) {
+        return toolError(ErrorCode.E_INPUT, parsed.error.issues.map(i => ({ path: i.path.join('.'), message: i.message })));
+    }
+    const editorBase = getEditorBaseUrl();
+    if (!editorBase) {
+        return toolError(ErrorCode.E_CONFIG, [{
+                code: 'E_EDITOR_URL_UNSET',
+                message: 'Link export is not configured. Set BLUEPRINT_CHART_EDITOR_URL to enable.',
+            }]);
+    }
+    const validated = validatePipeline(parsed.data.source);
+    if (!validated.ok) {
+        return validated.error;
+    }
+    return toolOk({
+        copyUrl: buildCopyUrl(parsed.data.source, editorBase),
+        embedUrl: buildEmbedUrl(parsed.data.source, editorBase),
+        frame: extractFrameMetadata(validated.ast),
+    });
+}

package/dist/tools/exportChart.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tools/exportChart.test.js

@@ -0,0 +1,43 @@
+import { describe, it, expect, afterEach } from 'vitest';
+import { exportChart } from './exportChart';
+import { ErrorCode } from '../errors';
+const VALID = 'chart bar-vertical {\n  title = "Hi"\n  data {\n    "A" = 1\n  }\n}\n';
+afterEach(() => {
+    delete process.env.BLUEPRINT_CHART_EDITOR_URL;
+});
+describe('exportChart', () => {
+    it('returns E_CONFIG when the editor base URL is unset', () => {
+        const result = exportChart({ source: VALID });
+        expect(result.ok).toBe(false);
+        if (!result.ok) {
+            expect(result.code).toBe(ErrorCode.E_CONFIG);
+            expect(result.errors[0]?.message).toMatch(/BLUEPRINT_CHART_EDITOR_URL/);
+        }
+    });
+    it('returns E_INPUT when source is missing', () => {
+        process.env.BLUEPRINT_CHART_EDITOR_URL = 'https://blueprintchart.com';
+        const result = exportChart({});
+        expect(result.ok).toBe(false);
+        if (!result.ok) {
+            expect(result.code).toBe(ErrorCode.E_INPUT);
+        }
+    });
+    it('propagates E_PARSE from the shared validation pipeline', () => {
+        process.env.BLUEPRINT_CHART_EDITOR_URL = 'https://blueprintchart.com';
+        const result = exportChart({ source: 'chart bar-vertical {' });
+        expect(result.ok).toBe(false);
+        if (!result.ok) {
+            expect(result.code).toBe(ErrorCode.E_PARSE);
+        }
+    });
+    it('returns copy + embed URLs and frame for a valid source', () => {
+        process.env.BLUEPRINT_CHART_EDITOR_URL = 'https://blueprintchart.com';
+        const result = exportChart({ source: VALID });
+        expect(result.ok).toBe(true);
+        if (result.ok) {
+            expect(result.data.copyUrl).toMatch(/^https:\/\/blueprintchart\.com\/#\/copy\?bpc64=/);
+            expect(result.data.embedUrl).toMatch(/^https:\/\/blueprintchart\.com\/#\/render\?bpc64=/);
+            expect(result.data.frame.title).toBe('Hi');
+        }
+    });
+});

package/dist/tools/getExample.d.ts

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+import { type ToolResult } from '../errors';
+export declare const GetExampleInputSchema: z.ZodObject<{
+    chartType: z.ZodOptional<z.ZodString>;
+    name: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    name?: string | undefined;
+    chartType?: string | undefined;
+}, {
+    name?: string | undefined;
+    chartType?: string | undefined;
+}>;
+export type GetExampleInput = z.infer<typeof GetExampleInputSchema>;
+export interface GetExampleOutput {
+    id: string;
+    title: string;
+    chartType: string;
+    dsl: string;
+}
+export declare function getExample(input: unknown): ToolResult<GetExampleOutput>;

package/dist/tools/getExample.js

@@ -0,0 +1,55 @@
+import { z } from 'zod';
+import { samples } from '@blueprint-chart/lib';
+import { canonicalChartType } from '../dsl/chartTypes';
+import { ErrorCode, toolError, toolOk } from '../errors';
+export const GetExampleInputSchema = z.object({
+    chartType: z.string().optional(),
+    name: z.string().optional(),
+}).strict();
+const STARTER_SAMPLE_ID = 'letter-frequency';
+export function getExample(input) {
+    const parsed = GetExampleInputSchema.safeParse(input);
+    if (!parsed.success) {
+        return toolError(ErrorCode.E_INPUT, parsed.error.issues.map(i => ({ path: i.path.join('.'), message: i.message })));
+    }
+    const { chartType, name } = parsed.data;
+    if (name) {
+        const found = samples.find(s => s.id === name);
+        if (!found) {
+            return toolError(ErrorCode.E_INPUT, [{
+                    code: 'E_UNKNOWN_SAMPLE',
+                    path: 'name',
+                    message: `No sample with id "${name}". Try one of: ${samples.map(s => s.id).join(', ')}.`,
+                    context: { knownIds: samples.map(s => s.id) },
+                }]);
+        }
+        return toolOk({ id: found.id, title: found.title, chartType: found.chartType, dsl: found.dsl });
+    }
+    if (chartType) {
+        const canonical = canonicalChartType(chartType);
+        if (!canonical) {
+            return toolError(ErrorCode.E_INPUT, [{
+                    code: 'E_UNKNOWN_CHART_TYPE',
+                    path: 'chartType',
+                    message: `Unknown chart type "${chartType}".`,
+                    context: { got: chartType },
+                }]);
+        }
+        const found = samples.find(s => s.chartType === canonical);
+        if (!found) {
+            return toolError(ErrorCode.E_INPUT, [{
+                    code: 'E_NO_SAMPLE_FOR_TYPE',
+                    path: 'chartType',
+                    message: `No sample is shipped for chart type "${canonical}".`,
+                }]);
+        }
+        return toolOk({ id: found.id, title: found.title, chartType: found.chartType, dsl: found.dsl });
+    }
+    const starter = samples.find(s => s.id === STARTER_SAMPLE_ID) ?? samples[0];
+    if (!starter) {
+        return toolError(ErrorCode.E_INTERNAL, [{
+                message: 'No samples available — lib export is empty.',
+            }]);
+    }
+    return toolOk({ id: starter.id, title: starter.title, chartType: starter.chartType, dsl: starter.dsl });
+}

package/dist/tools/getExample.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tools/getExample.test.js

@@ -0,0 +1,40 @@
+import { describe, expect, it } from 'vitest';
+import { getExample } from './getExample';
+describe('get_example', () => {
+    it('returns the starter sample when no args', () => {
+        const r = getExample({});
+        expect(r.ok).toBe(true);
+        if (r.ok) {
+            expect(r.data.id).toBe('letter-frequency');
+            expect(r.data.dsl).toContain('chart bar-vertical');
+        }
+    });
+    it('returns a sample by id', () => {
+        const r = getExample({ name: 'letter-frequency' });
+        expect(r.ok).toBe(true);
+        if (r.ok) {
+            expect(r.data.chartType).toBe('bar-vertical');
+        }
+    });
+    it('returns the first matching sample for a chartType', () => {
+        const r = getExample({ chartType: 'bar-horizontal' });
+        expect(r.ok).toBe(true);
+        if (r.ok) {
+            expect(r.data.chartType).toBe('bar-horizontal');
+        }
+    });
+    it('errors with E_INPUT for an unknown id', () => {
+        const r = getExample({ name: 'made-up-sample' });
+        expect(r.ok).toBe(false);
+        if (!r.ok) {
+            expect(r.code).toBe('E_INPUT');
+        }
+    });
+    it('errors with E_INPUT for an unknown chart type', () => {
+        const r = getExample({ chartType: 'bar' });
+        expect(r.ok).toBe(false);
+        if (!r.ok) {
+            expect(r.code).toBe('E_INPUT');
+        }
+    });
+});

package/dist/tools/getGrammar.d.ts

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+import { type ToolResult } from '../errors';
+declare const SectionSchema: z.ZodDefault<z.ZodEnum<["all", "chart", "properties", "scenes", "annotations"]>>;
+export declare const GetGrammarInputSchema: z.ZodObject<{
+    section: z.ZodOptional<z.ZodDefault<z.ZodEnum<["all", "chart", "properties", "scenes", "annotations"]>>>;
+}, "strict", z.ZodTypeAny, {
+    section?: "chart" | "properties" | "all" | "scenes" | "annotations" | undefined;
+}, {
+    section?: "chart" | "properties" | "all" | "scenes" | "annotations" | undefined;
+}>;
+export type GetGrammarInput = z.infer<typeof GetGrammarInputSchema>;
+export interface GetGrammarOutput {
+    section: z.infer<typeof SectionSchema>;
+    text: string;
+}
+export declare function getGrammar(input: unknown): ToolResult<GetGrammarOutput>;
+export {};

package/dist/tools/getGrammar.js

@@ -0,0 +1,38 @@
+import { z } from 'zod';
+import { getDoc, listDocs } from '@blueprint-chart/docs';
+import { ErrorCode, toolError, toolOk } from '../errors';
+const SectionSchema = z.enum(['all', 'chart', 'properties', 'scenes', 'annotations']).default('all');
+export const GetGrammarInputSchema = z.object({
+    section: SectionSchema.optional(),
+}).strict();
+const SECTION_TO_SLUG = {
+    chart: 'properties', // reference/dsl has no standalone chart-block doc; properties.md covers the block + properties
+    properties: 'properties',
+    scenes: 'scenes-and-transforms',
+    annotations: 'annotations',
+};
+export function getGrammar(input) {
+    const parsed = GetGrammarInputSchema.safeParse(input);
+    if (!parsed.success) {
+        return toolError(ErrorCode.E_INPUT, parsed.error.issues.map(i => ({ path: i.path.join('.'), message: i.message })));
+    }
+    const section = parsed.data.section ?? 'all';
+    if (section === 'all') {
+        const pages = listDocs('reference/dsl');
+        const text = pages.map((entry) => {
+            const { content } = getDoc('reference/dsl', entry.slug);
+            return `# ${entry.title}\n\n${content}`;
+        }).join('\n\n---\n\n');
+        return toolOk({ section: 'all', text });
+    }
+    const slug = SECTION_TO_SLUG[section];
+    try {
+        const { content } = getDoc('reference/dsl', slug);
+        return toolOk({ section, text: content });
+    }
+    catch (err) {
+        return toolError(ErrorCode.E_INPUT, [{
+                message: `Grammar section "${section}" not found: ${err instanceof Error ? err.message : String(err)}`,
+            }]);
+    }
+}

package/dist/tools/getGrammar.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tools/getGrammar.test.js

@@ -0,0 +1,35 @@
+import { describe, expect, it } from 'vitest';
+import { getGrammar } from './getGrammar';
+describe('get_grammar', () => {
+    it('returns the full grammar by default', () => {
+        const r = getGrammar({});
+        expect(r.ok).toBe(true);
+        if (r.ok) {
+            expect(r.data.section).toBe('all');
+            expect(r.data.text.length).toBeGreaterThan(100);
+        }
+    });
+    it('returns a single section when requested', () => {
+        const r = getGrammar({ section: 'properties' });
+        expect(r.ok).toBe(true);
+        if (r.ok) {
+            expect(r.data.section).toBe('properties');
+            expect(r.data.text.toLowerCase()).toContain('properties');
+        }
+    });
+    it('errors with E_INPUT for an unknown section', () => {
+        const r = getGrammar({ section: 'totally-made-up' });
+        expect(r.ok).toBe(false);
+    });
+});
+describe('get_grammar section resolution', () => {
+    it('returns non-empty text for every enum section', () => {
+        for (const section of ['all', 'chart', 'properties', 'scenes', 'annotations']) {
+            const r = getGrammar({ section });
+            expect(r.ok, `section ${section} should resolve`).toBe(true);
+            if (r.ok) {
+                expect(r.data.text.length).toBeGreaterThan(0);
+            }
+        }
+    });
+});

package/dist/tools/inspect.d.ts

@@ -13,14 +13,21 @@ export interface SceneSummary {
     name?: string;
     hasTransition: boolean;
 }
+export interface DataSummary {
+    rowCount: number;
+    entryCount: number;
+    labels: string[];
+    seriesNames: string[];
+    multiSeries: boolean;
+}
 export interface InspectOutput {
     chartType: string;
     scenes: SceneSummary[];
+    data: DataSummary;
     hasAnnotations: boolean;
     hasColorizes: boolean;
     hasHighlights: boolean;
     hasAreaFills: boolean;
     seriesCount: number;
-    rowCount: number;
 }
 export declare function inspectDsl(input: InspectInput): ToolResult<InspectOutput>;

package/dist/tools/inspect.js

@@ -2,6 +2,7 @@ import { z } from 'zod';
 import { astToDefinition } from '@blueprint-chart/lib';
 import { parseDsl } from '../parse';
 import { toolOk } from '../errors';
+import { looksLikeQuotedLabel } from '../dsl/dataKey';
 export const InspectInputSchema = z.object({
     source: z.string(),
 });
@@ -13,25 +14,57 @@ function summarizeScenes(ast) {
     return scenes.map((scene, i) => ({
         index: i,
         name: scene.name ?? undefined,
-        // SceneNode has no explicit `transition` field; transforms power animated
-        // transitions in the lib, so non-empty transforms imply a transition.
         hasTransition: (scene.transforms?.length ?? 0) > 0,
     }));
 }
+function summarizeData(ast) {
+    const entries = ast.data?.entries ?? [];
+    const seriesEntry = entries.find(e => e.key === '_series');
+    const seriesValues = seriesEntry
+        ? (seriesEntry.values ?? [seriesEntry.value])
+        : [];
+    const seriesNames = seriesValues.map(v => String(v).trim().replace(/^"|"$/g, ''));
+    const rowEntries = entries.filter(looksLikeQuotedLabel);
+    return {
+        rowCount: rowEntries.length,
+        entryCount: entries.length,
+        labels: rowEntries.map(e => e.key.replace(/^"|"$/g, '')),
+        seriesNames,
+        multiSeries: seriesNames.length > 0,
+    };
+}
+function countHighlights(ast) {
+    // `highlight "X" { … }` parses as ColorizeNode with fromHighlight:true,
+    // `highlight "X"` (no braces) parses as HighlightNode. Count both, at the
+    // chart level AND inside every scene (scenes carry their own highlights).
+    // unknown[]: only .length is read, so element type is irrelevant here
+    const countIn = (node) => {
+        const fromHighlightColorizes = (node.colorizes ?? []).filter(c => c.fromHighlight === true).length;
+        return (node.highlights?.length ?? 0) + fromHighlightColorizes;
+    };
+    const sceneTotal = (ast.scenes ?? []).reduce((sum, s) => sum + countIn(s), 0);
+    return countIn(ast) + sceneTotal;
+}
+function countNonHighlightColorizes(ast) {
+    const countIn = (cs) => (cs ?? []).filter(c => c.fromHighlight !== true).length;
+    const sceneTotal = (ast.scenes ?? []).reduce((sum, s) => sum + countIn(s.colorizes), 0);
+    return countIn(ast.colorizes) + sceneTotal;
+}
 export function inspectDsl(input) {
     const parsed = parseDsl(input.source);
     if (!parsed.ok) {
         return parsed;
     }
-    const def = astToDefinition(parsed.data.ast);
+    const ast = parsed.data.ast;
+    const def = astToDefinition(ast);
     return toolOk({
         chartType: def.chartType,
-        scenes: summarizeScenes(parsed.data.ast),
+        scenes: summarizeScenes(ast),
+        data: summarizeData(ast),
         hasAnnotations: (def.annotations?.length ?? 0) > 0,
-        hasColorizes: (def.colorizes?.length ?? 0) > 0,
-        hasHighlights: (def.highlights?.length ?? 0) > 0,
+        hasColorizes: countNonHighlightColorizes(ast) > 0,
+        hasHighlights: countHighlights(ast) > 0,
         hasAreaFills: (def.areaFills?.length ?? 0) > 0,
         seriesCount: def.data.series?.length ?? 0,
-        rowCount: def.data.labels?.length ?? 0,
     });
 }