@malloydata/malloyyo 0.2.15 → 0.2.17

package/dist/index.js

@@ -86,6 +86,11 @@ import path from "node:path";
 import url from "node:url";
 var HOST_ONLY = "host_only";
 var contentFiles = {
+  "dashboards/authoring.md": '---\ndescription: How to author a dashboard \u2014 a self-contained file in the dashboards/ directory that defines its own query; the entry point for dashboard how-to\n---\n\n# Authoring dashboards\n\nA dashboard is a **self-contained `.malloy` file in the `dashboards/`\ndirectory**. The file IS the dashboard: it imports the model parts it needs,\ndefines its query (with the filtering it applies), and tags it. No manifest, and\nfor the basic case no JavaScript. Preview with `malloyyo dashboard dev`; check\nwith `malloyyo lint`. Requires `@malloydata/malloy` 0.0.423+.\n\nRelated: `yo_help dashboards/givens-and-controls` (filter controls),\n`dashboards/grid-layout` (columns/colspan/break), `dashboards/custom-components`\n(a flat `<name>.jsx`), `dashboards/vega-charts` (`<VegaChart>`).\n\n> **Need a chart the `# bar_chart`/`# line_chart`/`# shape_map` tags can\'t do?**\n> Use the `<VegaChart>` COMPONENT (a Vega-Lite spec over query rows) \u2014 NOT a `#`\n> tag; there is no `# vega_lite`. See `yo_help dashboards/vega-charts`.\n\n## The layout\n\n```\nmodel/\n  ecommerce.malloy     # sources, reusable views/measures, # drill tags\n  givens.malloy        # given: declarations (the filter controls)\n  index.malloy         # imports/exports sources \u2014 the MCP/data surface ONLY\n  dashboards/\n    overview.malloy    # one dashboard; the FILENAME is its name/slug\n    overview.jsx       # optional custom component for overview\n```\n\n**The filename is the dashboard\'s name** \u2014 its URL slug, its `# drill` target,\nand the basename of its optional component. Discovery globs\n`dashboards/*.malloy` and compiles EACH as its own entry \u2014 so dashboards are NOT\ndeclared in, or exported through, `index.malloy` (`index.malloy` is just the\n`query`/`describe_source` data surface).\n\n## Preferred: put the query IN the dashboard file\n\nDefine the query right in `dashboards/<name>.malloy` and tag it `# artifact`, so\nthe given mapping (the `where: \u2026 ~ $GIVEN`) is visible next to the dashboard:\n\n```malloy\n// dashboards/overview.malloy\n##! experimental.givens\nimport "../ecommerce.malloy"          // BARE import: source + givens in scope\n\n#" Business health at a glance \u2014 sales, margin, orders.\n# artifact { title="Business Overview" } dashboard {columns=6}\nquery: overview is order_items -> {\n  where:                                            // the given mapping, HERE\n    inventory_items.product_brand ~ $BRAND,         // multi-filter where: is\n    inventory_items.product_category ~ $CATEGORY,   // COMMA separated\n    created_at ~ $PERIOD\n  # colspan=2\n  aggregate: total_sales, total_gross_margin, order_count\n  # colspan=3\n  nest:\n    # line_chart\n    sales_trend is by_month\n    top_brands\n    # shape_map\n    sales_by_state\n}\n```\n\nThat\'s a complete dashboard: the runtime auto-renders a title (the tag\'s\n`title`, else the `#"` doc), a control for every given the query references, and\nthe result panel. `# artifact` DECLARES the dashboard; `# dashboard {columns=6}`\nis the renderer tag that draws it as KPI tiles + a card grid \u2014 partners, on the\nsame line. Grid rules: `yo_help dashboards/grid-layout`.\n\n**You know you\'re doing it right when the `where: foo ~ $FOO` is in the DASHBOARD\nfile, not the model.** Keep the model\'s sources/views reusable and given-free;\neach dashboard decides its own filtering.\n\n**The bare import is required for controls.** A control renders only when the\ngiven\'s DECLARATION is in the dashboard file\'s scope \u2014 a bare\n`import "../ecommerce.malloy"` (or `import "../givens.malloy"`) brings them all;\nthe runtime shows a control for exactly the givens the query references. A\nselective `import { order_items } from \u2026` brings the filter but NOT the control.\n\nKeep the FILENAME as the name \u2014 don\'t set `name=`, so the URL, the\n`# drill { to=\u2026 }`, and the component basename all agree (one source of truth).\n\n## Other forms\n\n- **A view of a source you extend in the file** \u2014 tag the dashboard `view:` with\n  `# artifact` (runs as `<source> -> <view>`). Good when the dashboard needs\n  helper views defined alongside it.\n- **Compose existing views**: a model-level `## artifact { tiles=["a -> b", "c -> d"]\n  dashboard_columns=6 }` (`##`, ONE line) names several views, run separately and\n  combined into one `# dashboard`. Use for multi-tile / cross-source; prefer the\n  inline query whenever a dashboard has its own filtering.\n- A `dashboards/*.malloy` with NO `# artifact`/`## artifact` is a shared INCLUDE\n  (skipped by discovery) \u2014 put helper sources/views there for several dashboards\n  to import.\n\n## Givens (filter controls)\n\nDeclare givens as `filter<T>` in the MODEL (`givens.malloy` or the source file) \u2014\nthey\'re shared and used by the MCP surface too; each dashboard APPLIES them in\nits `where:`. Full control reference: `yo_help dashboards/givens-and-controls`.\nPer-dashboard starting values go in the tag:\n\n```malloy\n# artifact { title="Ford recalls" givens { MANUFACTURER=f\'Ford Motor Company\' } }\n```\n\n## Drill from a dimension\n\n`# drill` on a source `dimension:` (in the model) makes its cells clickable \u2014\nopening another dashboard (seeding the value) or filtering in place:\n\n```malloy\ndimension:\n  # drill { to=[category_explorer, self] }\n  category is inventory_items.product_category\n```\n\n`to` is a list; each is a **dashboard slug** (a `dashboards/<slug>.malloy`\nfilename) \u2192 opens it, seeding the value into the given named like the dimension\nUPPER-cased (`category` \u2192 `CATEGORY`), or **`self`** \u2192 filter the current\ndashboard in place. Add `given=` when the target given differs. `lint` VERIFIES\nevery `to=` slug resolves to a real dashboard file (a typo/renamed dashboard\nfails loudly, not at click time).\n\n> **malloy#2979 (fixed in 0.0.423):** a `# drill` on a bare `group_by: name` was\n> dropped when nested through `+ {\u2026}`. Put it on the source `dimension:`, or use\n> `group_by: name is concat(name,\'\')`.\n\n## Custom component (optional)\n\nFor bespoke layout/charts, add a flat sibling `dashboards/<name>.jsx` (or\n`.tsx`). Only React + `@malloyyo/dashboard` importable (sandboxed). A bare\n`<Panel/>` renders the whole dashboard; a `<Panel query="\u2026"/>` /\n`<VegaChart query="\u2026"/>` runs a query DEFINED in this dashboard file (by name) or\na `source -> view`. `lint` checks each `query="\u2026"` still resolves. See `yo_help\ndashboards/custom-components`.\n\n## Rules\n- Each dashboard is one `dashboards/<name>.malloy`; the filename is the slug.\n  Prefer the inline `query: \u2026 # artifact` form \u2014 the `where: ~ $GIVEN` lives in\n  the dashboard file.\n- Bare-import the model (and/or `givens.malloy`) so the controls render.\n- Givens are `filter<T>` declared in the model; options come from `# suggest {\u2026}`;\n  interactivity = setting given values, not rewriting query text.\n- `index.malloy` is the data surface, NOT where dashboards live.\n- If a query/given you need is missing, add it (check with `describe_source`).\n\n## Preview & validate\n`malloyyo dashboard dev` \u2192 open the URL; `.malloy`/`.jsx` edits hot-reload.\n`malloyyo lint` checks each dashboard file on its own: it compiles as its entry;\neach tile/query and `# suggest` compiles; `dashboard_columns` is a positive int;\nthe component compiles and its `query="\u2026"` resolve; no duplicate names, no\norphaned component; every `# drill { to=\u2026 }` resolves. Tight loop: the local\n`malloyyo mcp --develop` server hot-reloads edits \u2014 `query(execute:false)` to\ncompile-check, `execute:true` to run. Don\'t validate against a hosted/claude.ai\nconnector \u2014 it serves the PUBLISHED model (stale until `malloyyo publish`).\n',
+  "dashboards/custom-components.md": '---\ndescription: Custom dashboard UI \u2014 a flat dashboards/<name>.jsx|tsx sibling composing @malloyyo/dashboard widgets/hooks/helpers with your own React\n---\n\n# Custom dashboard components (`dashboards/<name>.jsx`)\n\nThe default UI (auto-rendered controls + panel) covers most dashboards. When it\nisn\'t enough, add ONE file \u2014 a **flat sibling** `dashboards/<name>.jsx` (or\n`.tsx`) next to the dashboard\'s `dashboards/<name>.malloy` (same basename) \u2014 that\ncomposes the runtime\'s widgets/hooks with your own React. You own layout, copy,\nand theming; the `.malloy` file still owns every query and filter. See also\n`yo_help dashboards/authoring` and `dashboards/vega-charts`.\n\n```tsx\nimport React from "react";\nimport { Controls, Given, Search, Select, TimeRange, Panel, filters, useGiven } from "@malloyyo/dashboard";\n\nexport default function Dashboard({ dashboard, givens }) {\n  return (\n    <div style={{ maxWidth: 860, margin: "0 auto", padding: 24 }}>\n      <h1>{dashboard.title}</h1>\n      <Controls>\n        <Given name="STATE" />          {/* picks the control from the declaration */}\n        <Search given="NAME" />         {/* committing input + typeahead + validation */}\n        <TimeRange given="PERIOD" presets={[\n          { value: "", text: "All time" },\n          { value: filters.lastN(1, "day"), text: "Last day" },\n          { value: filters.lastN(1, "week"), text: "Last week" },\n          { value: filters.lastN(1, "month"), text: "Last month" },\n        ]} />                            {/* "Custom range\u2026" is always appended */}\n        <Select given="MIN_SAMPLE"\n          options={[10, 200, 1000].map(n => ({ value: filters.greaterThan(n), text: `> ${n}` }))} />\n      </Controls>\n      <Panel givens={givens} />         {/* the dashboard itself (its tiles/query) */}\n      <Panel query="baby_names -> births_by_decade" givens={givens} />  {/* a specific query */}\n    </div>\n  );\n}\n```\n\nFrom `@malloyyo/dashboard` (also handed to the component as props):\n- **Widgets** (headless-ish; restyle via className/style or the `--dash-*` CSS\n  vars \u2014 see Theming below): `<Controls/>` (all givens, or compose children;\n  grows Apply/Reset under `autorun=false`), `<Given name/>`,\n  `<Select given [options]/>`, `<Search given/>` (committing input + typeahead +\n  inline \u2715 clear), `<MultiSelect given [options]/>` (chip multi-select for a\n  `filter<string>` \u2014 commits an exact-match list via `filters.oneOf`),\n  `<Range given [min max]/>`, `<TimeRange given [presets]/>` (temporal presets +\n  custom range), `<Checkbox given/>` (bound to a boolean given),\n  `<VegaChart spec query|malloy|data givens/>` (a Vega-Lite chart over query\n  rows \u2014 see `yo_help dashboards/vega-charts`)\n- **Hooks**: `useGiven(name)` \u2192 {value, set, spec};\n  `useOptions(name, typed?)` \u2192 {options, loading} (typeahead);\n  `useQuery({query|malloy, givens})` \u2192 {rows, loading, error} \u2014 plain rows\n  for your own visuals\n- **Helpers**: `filters.oneOf/contains/between/atLeast/\u2026` build\n  filter-expression strings with correct escaping; temporal:\n  `filters.lastN(7, "day")` \u2192 `\'7 days\'`, `filters.dateRange("2026-01-01",\n  "2026-07-01")`, `filters.afterDate/beforeDate`; read back with\n  `filters.values/numberRange/threshold/inLast/temporalRange`;\n  `filters.isValid(type, src)` checks typed input.\n  Never hand-concatenate a filter string.\n  **Escaping rule for custom controls:** a filter given\'s value is an\n  EXPRESSION, so committing a raw column value is wrong the moment it contains\n  a comma/percent/dash (\'Tesla, Inc.\' parses as two alternatives and matches\n  nothing). Commit `filters.oneOf(value)` (exact) or\n  `filters.contains(term)` (substring), and unwrap for display with\n  `filters.values(src)`. The stock `<Select/>` does this automatically;\n  `<Search/>` deliberately commits raw text (its input IS a filter\n  expression).\n- `<Panel/>` runs against the DASHBOARD\'s own file: a bare `<Panel/>` renders\n  the whole dashboard (its tiles); `<Panel query="\u2026"/>` runs a query defined in\n  the dashboard file (by name) or a `source -> view`; `<Panel malloy="\u2026"/>` and\n  `runData(text, givens)` run arbitrary Malloy as a RESTRICTED query (no import /\n  given: / connection.* / raw SQL / ##! flags \u2014 the model\'s governed surface\n  only). `lint` checks each hard-coded `query="\u2026"` still resolves.\n\n## Theming\n\nEvery widget is styled by the runtime\'s **default Malloyyo theme** (system\nfont, neutral grays, blue accent, auto light/dark following the viewer\'s OS) \u2014\na bare component looks styled with zero effort, so DON\'T hand-hardcode\n`fontFamily`/colors. The theme is CSS custom properties; override any subset by\nsetting them on a wrapper element (more specific than the runtime\'s `:root`):\n\n```tsx\n<div style={{ "--dash-accent": "#e11d48", "--dash-controls-bg": "#faf5ff" }}>\n  <Controls /> \u2026\n</div>\n```\n\nVars: `--dash-font`, `--dash-bg`, `--dash-fg`, `--dash-muted`, `--dash-border`,\n`--dash-accent`, `--dash-accent-fg`, `--dash-control-bg`, `--dash-controls-bg`,\n`--dash-chip-bg`, `--dash-chip-fg`, `--dash-panel-bg`, `--dash-radius`,\n`--dash-danger`. `DefaultDashboard` also takes a `theme={{ accent, controlsBg }}`\nprop (camelCase keys \u2192 `--dash-*`). The results `<Panel>` keeps a light surface\nin both light/dark (the Malloy renderer has no dark theme) \u2014 override\n`--dash-panel-bg` if your renderer output is dark-safe.\n\nFor charts beyond the Malloy renderer\'s `#` tags, use `<VegaChart>` \u2014\n`yo_help dashboards/vega-charts`.\n',
+  "dashboards/givens-and-controls.md": "---\ndescription: Dashboard filter controls \u2014 declare filter<T> givens with # label / suggest / control tags; faceted (related) suggestions\n---\n\n# Dashboard givens & controls\n\nA dashboard's filters are `filter<T>` **givens** declared in the model; the\n`#` tags on each declaration drive its control. This is part of authoring a\ndashboard \u2014 see also `yo_help dashboards/authoring`.\n\n**Declare the filters as `filter<T>` givens** \u2014 never raw strings/numbers.\nA `filter<string>` value accepts one value ('NY'), alternatives ('NY, CA'),\nwildcards ('Ann%'), negation ('-NY'); a `filter<number>` accepts ranges\n('[1910 to 1930]') and comparisons ('> 200'); a `filter<timestamp>` /\n`filter<date>` accepts relative windows ('7 days' = the last 7 days, 'today',\n'last month') and literal ranges ('2026-01-01 to 2026-07-01' \u2014 NO `@` in\nfilter literals). Apply with `~`; `f''` = empty = no filter (the natural\n\"All\"/\"all time\" \u2014 just `col ~ $X`, no `$X = '' or \u2026` dance):\n\n```malloy\n##! experimental { givens }\ngiven:\n  # label=\"State\" control=select suggest { source=baby_names dimension=state }\n  STATE :: filter<string> is f'NY'\n  # label=\"Brand\" suggest { query=brand_suggest dimension=product_brand }\n  BRAND :: filter<string> is f''\n  # label=\"Names\" control=multiselect suggest { query=name_suggest dimension=name }\n  NAMES :: filter<string> is f''\n  # label=\"Years\" range_min=1910 range_max=2025\n  YEAR_RANGE :: filter<number> is f'[1910 to 1930]'\n  # label=\"Time period\"\n  PERIOD :: filter<timestamp> is f''\n  # label=\"Include rare names\"\n  INCLUDE_RARE :: boolean is false\n```\n\nTags on the declaration drive the control (tag syntax is `key=\"value\"` \u2014\nequals, not colon):\n- `label` \u2014 control caption (defaults to the given's name)\n- `suggest { \u2026 }` \u2014 where the control's options come from. NO Malloy code in\n  strings \u2014 just names:\n  - `suggest { query=brand_suggest dimension=product_brand }` \u2014 the FIRST\n    COLUMN of a named query (declare the query in the model \u2014 governed and\n    reviewable). PREFER THIS FORM. The query must be in scope where the dashboard\n    runs (bring it in with the dashboard file's bare `import`).\n  - `suggest { source=baby_names dimension=state }` \u2014 the DISTINCT VALUES of\n    a dimension on a source (the source must be in the dashboard's scope)\n  A `dimension` (in either form) is what enables SERVER-SIDE TYPEAHEAD: the\n  runtime refines the base query with what the user has typed\n  (`\u2026 + { where: lower(field) ~ f'll%'; limit: 50 }`, case-insensitive,\n  escaped). Without a dimension the fetched list is filtered client-side.\n  Runs as a restricted query; lint checks the declaration compiles.\n\n  **RELATED (faceted) filters** \u2014 query-form only: a suggest query may\n  reference the OTHER givens, and the runtime runs it with the dashboard's\n  current values (the suggested given itself is excluded, so the list never\n  collapses to the current pick). Brand suggestions narrow when Category is\n  set:\n\n  ```malloy\n  query: brand_suggest is inventory_items -> product_brand + {\n    where:\n      product_category ~ $CATEGORY,      // NOT product_brand ~ $BRAND\n      product_department ~ $DEPARTMENT\n    limit: 500\n  }\n  ```\n\n  Declare one `*_suggest` per filter, each referencing the others; `f''`\n  defaults mean unset filters don't constrain. `source=` suggests can't do\n  this (no place for a `where:`) \u2014 another reason to prefer `query=`.\n- `control=select` \u2014 a fixed dropdown instead of a typeahead search box\n- `control=multiselect` \u2014 a tokenized multi-select for a `filter<string>`:\n  each pick is a removable chip, the committed value is an exact-match list\n  (`Emma, Olivia, Sophia`). Ideal for \"pick several\" filters (names, brands).\n  Suggestions come from the given's `suggest {\u2026}` (server-side typeahead when\n  it names a dimension). Empty (start from `f''`) = no filter (all).\n- `range_min` / `range_max` \u2014 bounds; makes a filter<number> given a\n  dual-thumb range slider\n- anything else passes through in `spec.tags` for custom components\n\nControl picked from the declaration automatically: numeric range tags \u2192\ndual-thumb slider; `filter<timestamp|timestamptz|date>` \u2192 the TimeRange\nwidget (relative presets: Today / Last 7 days / Last 30 days / \u2026 plus a\n\"Custom range\u2026\" from/to date picker); `control=multiselect` \u2192 chip\nmulti-select; suggest + control=select \u2192 dropdown; boolean \u2192 checkbox;\nanything else \u2192 committing search box with typeahead (an inline \u2715 clears it;\na \"Press \u21B5 to apply\" hint shows while the typed draft differs from what's\nrunning \u2014 free text can't safely re-run per keystroke).\nThe suggest-driven options are DATA VALUES only \u2014 options that aren't column\nvalues (custom time presets, threshold buckets) need a custom component\n(`yo_help dashboards/custom-components`) with explicit `{value, text}` options\nwhere value is a filter expression built with `filters.*`.\n\n## When the query re-runs: live (default) vs. Apply\n\nBy default a dashboard is **live** \u2014 every control change re-runs the query\nimmediately (the committing search box is the exception: free text commits on\nEnter/blur, since a half-typed filter is invalid). To batch changes behind an\n**Apply** button instead, set `autorun=false` on the `# artifact` tag:\n\n```malloy\n# artifact { name=\"births-by-name\" title=\"Births by name\" autorun=false }\n```\n\n`autorun=false` makes `<Controls>` grow an Apply/Reset pair \u2014 controls edit a\ndraft and nothing re-runs until Apply. Reach for it when the query is expensive\nor several filters are usually changed together; leave it off (live) otherwise.\n",
+  "dashboards/grid-layout.md": "---\ndescription: Dashboard grid layout \u2014 # dashboard {columns=N} with # colspan and # break to place KPI tiles and charts\n---\n\n# Dashboard grid layout (`# dashboard {columns=N}`)\n\nBy default a `# dashboard` result flows its KPI tiles and cards and wraps.\nAdd `{columns=N}` to place them on a fixed **N-column grid** instead \u2014 use\n`columns=6`, which divides evenly into 2- and 3-wide cards.\n\n**Key mechanic:** a tag placed ABOVE `aggregate:` or `nest:` applies to EVERY\nitem declared in that block. So you set card widths once per block, not per\nfield.\n\n```malloy\n# artifact { title=\"Customer Insights\" } dashboard {columns=6}\nview: customer_insights is {\n  where: created_at ~ $PERIOD\n  # colspan=2\n  aggregate: total_sales, user_count, order_count, average_order_value\n  # colspan=3\n  nest:\n    # break\n    # bar_chart\n    users_by_spend_tier\n    sales_by_traffic_source\n    # shape_map\n    sales_by_state\n    # colspan=6\n    recent_orders                      // wide detail table \u2192 full width\n}\n```\n\n## The conventions\n\n- **`# colspan=2` above `aggregate:`** \u2014 each KPI / measure tile spans 2 of 6\n  columns \u2192 3 tiles per row.\n- **`# colspan=3` above `nest:`** \u2014 each graph or small table spans 3 \u2192 2 per\n  row. Per-item render tags (`# line_chart`, `# bar_chart`, `# shape_map`) still\n  go on the individual nested items.\n- **`# colspan=6`** \u2014 a single wide / many-column table gets its own full-width\n  line. Tag that one item; a per-item `# colspan` overrides the block default.\n- **`# break` on the FIRST nest item** \u2014 starts the graphs on a fresh row, so\n  KPI tiles and charts never share one. The renderer splits fields into a new\n  grid at each `# break`. Just always add it: it's a no-op when the tiles\n  already fill complete rows, and the fix when they don't (e.g. 4 measures\n  leave a lone tile a colspan-3 chart would otherwise pack in beside).\n\n`# colspan` only does anything in columns mode \u2014 without `{columns=N}` the\nlayout is free-flow wrap and colspan is ignored. Clamp colspans to `1..N`.\n\nSee also `yo_help dashboards/vega-charts` for custom charts, and the fuller\nauthoring guide surfaced by the local `malloyyo mcp` server.\n",
+  "dashboards/vega-charts.md": '---\ndescription: Custom dashboard charts with Vega-Lite \u2014 the <VegaChart> component, for charts the # renderer tags can\'t do\n---\n\n# Custom charts with Vega-Lite (`<VegaChart>`)\n\nWhen Malloy\'s renderer tags (`# bar_chart`, `# line_chart`, `# shape_map`, \u2026)\ndon\'t cover the chart you want, a dashboard can draw a **Vega-Lite** spec with\nthe `<VegaChart>` component. The chart engine ships in the dashboard runtime, so\nyou author only a JSON spec + a Malloy query \u2014 no library to load.\n\n**It is a COMPONENT, not a `#` tag.** There is no `# vega_lite` or\n`# scatter_chart` tag. `<VegaChart>` lives in a custom component \u2014 a flat sibling\n`dashboards/<name>.jsx` (or `.tsx`) next to the dashboard\'s\n`dashboards/<name>.malloy` \u2014 a different layer from the `#` renderer tags. (The\ndashboard\'s query is declared in the `.malloy` file; the component only\ncustomizes presentation. Preview with `malloyyo dashboard dev`, validate with\n`malloyyo lint`.)\n\n## The recipe\n\n```tsx\nimport { VegaChart } from "@malloyyo/dashboard";\n\n// Encodings point at the query\'s OUTPUT COLUMN NAMES (here: name, births).\nconst spec = {\n  mark: { type: "bar", tooltip: true },\n  encoding: {\n    y: { field: "name", type: "nominal", sort: "-x" },\n    x: { field: "births", type: "quantitative" },\n  },\n};\n\nexport default function Dashboard({ givens }) {\n  return <VegaChart spec={spec} query="births_by_name" givens={givens} />;\n}\n```\n\nThree ways to feed it data:\n- `<VegaChart spec={spec} query="births_by_name" givens={givens}/>` \u2014 a query\n  defined in the dashboard\'s `.malloy` file (by name), or a `source -> view`\n- `<VegaChart spec={spec} malloy="source -> view" givens={givens}/>` \u2014 restricted\n  Malloy text (same governance as the explore surface: no import / given: /\n  connection.* / raw SQL / ##! flags)\n- `<VegaChart spec={spec} data={rows}/>` \u2014 rows you already have from `useQuery`\n\n## Gotchas (the ones that actually bite)\n\n- **Shape the data in Malloy; return FLAT rows.** Do ranking, share/percent\n  (`all(x, dim)`), and label lookups (a `pick` for month names) in the QUERY.\n  The spec just encodes columns \u2014 it is not the place to reshape data.\n- **Match column names character-for-character.** Run the query once with\n  `query(execute:true)` and read the exact output column names; the spec\'s\n  `field` values must match them exactly.\n- **The spec\'s `data` is ignored / any `url` is stripped.** The frame has no\n  network \u2014 remote data URLs, transform lookups, and remote `image` marks are\n  removed. Adapting a Vega-Lite gallery example = delete its\n  `"data": {"url": \u2026}` and repoint the encodings; the query rows are inlined for\n  you as the dataset.\n- **Nests come back as arrays.** Flatten to plottable rows in the query, or bind\n  a nest to its own chart: `<VegaChart data={row.my_nest}/>`.\n- **Interactivity = setting given values**, never rewriting query text per\n  interaction. Client-side chart interactions (tooltip, zoom, brush) work;\n  anything that calls a server does not.\n- **Reads well:** for normalized/share data use a diverging color scale with\n  `domainMid` (e.g. `1/12` for month-share), and sort a discrete axis by a\n  companion numeric field (`month_name` sorted by `month_num`) rather than\n  alphabetically.\n\n## Validate\n\n`malloyyo lint` checks the query, the givens, AND the component (it compiles,\nand each `query="\u2026"` it references resolves) \u2014 your only pre-browser check. Then\n`malloyyo dashboard dev` to see it render.\n',
   "develop/connection-setup.md": '---\ndescription: Setting up a data connection (malloy-config.json)\n---\n\n# Setting up a data connection\n\nA model reaches its data through a **connection** declared in\n`malloy-config.json` at the **root of the model** (next to `index.malloy`). This\nis Malloy\'s standard connection config \u2014 the full reference, with every\nconnector\'s properties, is at\n<https://docs.malloydata.dev/documentation/setup/config>. The essentials:\n\n## The file\n\n```json\n{\n  "connections": {\n    "mydb": { "is": "duckdb" }\n  }\n}\n```\n\n- A connection has a **name** (the key) and a type (`is`). Sources refer to it by\n  that name \u2014 `source: x is mydb.table("orders")` or `mydb.sql("SELECT \u2026")` \u2014 so\n  the name in the config must match the name in the model.\n- Supported types (`is`): `duckdb` (incl. MotherDuck), `bigquery`, `postgres`,\n  `mysql`, `snowflake`, `databricks`, `trino`, `presto`. Each has its own\n  properties \u2014 see the full docs.\n\n## Default connections (and when they apply)\n\nSetting `"includeDefaultConnections": true` makes one connection available for\n**each registered database type, named by the type** \u2014 a `duckdb` connection\nnamed `duckdb`, a `postgres` named `postgres`, and so on. Each uses that\nconnector\'s default settings, which for several backends means picking up\ncredentials from the environment (e.g. BigQuery\'s application-default\ncredentials \u2014 see the per-connector setup docs). Connections you name explicitly\nin `connections` always win; the defaults only fill in types you didn\'t list.\n\n```json\n{\n  "includeDefaultConnections": true,\n  "connections": { "warehouse": { "is": "postgres", "host": "\u2026" } }\n}\n```\n\nmalloyyo has one rule worth knowing:\n\n- **No `malloy-config.json` at all \u2192 defaults are ON.** `duckdb` just works with\n  zero setup.\n- **Write a `malloy-config.json` and they turn OFF** unless you add\n  `"includeDefaultConnections": true`. A config that only defines, say, a\n  `postgres` connection will report *No connection named "duckdb"* if a source\n  still references `duckdb`.\n\nThis is deliberate \u2014 your local connections then resolve exactly the way the\npublished server\'s will, rather than silently leaning on a default that would not\nexist in production. (It differs from `malloy-cli`, which forces the defaults on\nunconditionally.)\n\nGive a connection a **custom name** \u2014 not the bare type default \u2014 whenever you\nhave more than one connection of the same type, or need non-default parameters.\n\n## DuckDB and local files (the common case)\n\nDuckDB can either open a **DuckDB database file** or read **local data files**\n(CSV, Parquet, \u2026) directly.\n\n**A pre-loaded database file** \u2014 point `databasePath` at a `.duckdb` file and\nreference its tables by name (an absolute path is safest):\n\n```json\n{ "connections": { "warehouse": { "is": "duckdb", "databasePath": "/data/warehouse.duckdb" } } }\n```\n\n**Local files, by path** \u2014 read a CSV or Parquet file straight into a source.\nThese paths are **project-relative** \u2014 resolved against the model root, so they\nsurvive publishing:\n\n    source: my_csv     is duckdb.table(\'data/my_file.csv\')\n    source: my_parquet is duckdb.table(\'data/my_file.parquet\')\n\n`.table()` names a single file. When you need something it can\'t express \u2014 a\nglob, a union, any SQL \u2014 wrap it in `.sql()` (its paths are project-relative too):\n\n    source: payments is duckdb.sql(\n      "SELECT * FROM read_parquet(\'data/payments-*.parquet\')"\n    )\n\nThe default `duckdb` connection is **in-memory** \u2014 nothing persists between runs;\nyour data lives in the files (or the `databasePath` database) you read.\n\n**MotherDuck:** a DuckDB connection against an `md:` database; set the\n`MOTHERDUCK_TOKEN` environment variable.\n\n## Secrets \u2014 keep them out of the file\n\nAny property value may be written as `{ "env": "VAR_NAME" }`. It resolves from\n`process.env.VAR_NAME` when the connection opens, so passwords and tokens never\nget committed:\n\n```json\n{\n  "connections": {\n    "analytics": {\n      "is": "postgres",\n      "host": "db.internal",\n      "databaseName": "analytics",\n      "username": "reader",\n      "password": { "env": "PG_PASSWORD" }\n    }\n  }\n}\n```\n\n(The non-secret property names here are illustrative \u2014 each connector\'s exact\nproperties are in the full docs. The `{ "env": \u2026 }` form is the part that\nmatters: it works for any value.)\n\n## malloyyo specifics\n\n- **One file, one place.** Only the `malloy-config.json` at the model root is\n  read \u2014 there is no walk-up to parent directories.\n- **Local override:** a `malloy-config-local.json` (do **not** commit it)\n  **replaces** `malloy-config.json` entirely when present \u2014 your private variant\n  for local credentials or a different database.\n- **The same file ships to production.** Publishing uploads this exact\n  `malloy-config.json`, so it must resolve the same way locally and on the\n  server \u2014 put anything environment-specific behind `{ "env": \u2026 }` rather than\n  hard-coding it. That is what makes the local test window faithful to\n  production.\n- Edits are picked up **without a restart** \u2014 the server re-reads the file when\n  it changes.\n\n## When a connection will not resolve\n\nFix the connection **first**: a broken connection yields an empty schema and then\na cascade of misleading `field-not-found` errors \u2014 ignore those and fix the\nconnection. A fast check is to compile a probe and see if it alone compiles:\n\n    source: _probe is mydb.sql("SELECT 1 AS one")\n',
   "develop/getting-started.md": '---\ndescription: Getting started \u2014 build a Malloy model step by step\n---\n\n# Building a Malloy model, step by step\n\nA model is a `malloy-config.json` (the connection to the data) and an\n`index.malloy` (the published query surface), optionally with other `.malloy`\nfiles that `index.malloy` imports. You edit these with your own file tools; the\nMCP tools compile, inspect, and test what you wrote. Never read `.malloy` as\ntext \u2014 compiling a bare source is how you read a table\'s schema.\n\n## 1. Verify the connection first\n\nConfirm the connection named in `malloy-config.json` resolves \u2014 compile a\nthrowaway probe inline with `compile` (no file needed):\n\n    source: _probe is CONN.sql("SELECT 1 AS one")\n\nIf it compiles, the connection is good. If not, fix the connection / config\nbefore going further \u2014 a broken connection produces an empty schema and then a\ncascade of misleading `field-not-found` errors; ignore the cascade and fix the\nconnection. Call `yo_help("develop/connection-setup")` for how to set up or repair a connection.\n\n## 2. Identify the tables the model needs\n\nIf you are unsure which tables matter, ask the fox \u2014 they own the data and know\nwhere it lives.\n\n## 3. Get a base source per table\n\nA base is "what\'s in the table and what\'s computable from it" \u2014 no joins.\nDiscover the schema by compiling a bare stub inline with `compile`:\n\n    source: users_base is CONN.table("users")\n\n`compile` returns the full column list + types \u2014 that is your schema browser.\nThen write the base into its own file and iterate with `compile_file`, adding\nonly the dimensions and measures intrinsic to that one table:\n\n    // users_base.malloy\n    source: users_base is CONN.table("users") extend {\n      measure: user_count is count()\n    }\n\nIf the data lives in files rather than database tables \u2014 common when the\nconnection is DuckDB \u2014 DuckDB lets you name a file path as the table (a\nproject-relative path):\n\n    source: users_base is CONN.table(\'data/users.parquet\')\n\nOnly drop to a `.sql()` block when a single file-as-table can\'t express what you\nneed \u2014 e.g. globbing or unioning several files:\n\n    source: users_base is CONN.sql("SELECT * FROM read_parquet(\'data/users-*.parquet\')")\n\n(`read_parquet` there is DuckDB SQL, not Malloy \u2014 see `yo_help("develop/connection-setup")`.)\n\n## 4. Assemble index.malloy \u2014 the published surface\n\nImport the bases, join them into the consumer-facing sources, and explicitly\nexport what consumers may query:\n\n    import "users_base.malloy"\n    import "orders_base.malloy"\n\n    source: users is users_base extend {\n      join_many: orders is orders_base on id = orders.user_id\n    }\n    source: orders is orders_base extend { }\n\n    export { users, orders }\n\n**Export discipline** \u2014 the model is a published artifact, so be deliberate about\nits public surface:\n\n- Imported names are private. Base sources stay internal scaffolding unless you\n  export them.\n- Without an `export` statement, everything you define is public. Add one and the\n  surface becomes explicit: only the names you list \u2014 defined or imported \u2014 are\n  public.\n- Hide intermediates. A staging source you define only so other sources can build\n  on it should not be exported.\n- The export list is the consumer\'s menu \u2014 exactly what the test window and real\n  consumers can query, nothing more.\n\n## The loop\n\nEdit a file \u2192 `compile_file` \u2192 fix `problems[]` \u2192 `query` (pass the model file\'s\npath as `ref`; `execute: false` validates first and reports the givens the query\nneeds, supplied via `givens`). Query text is restricted \u2014 `import`, `given:`\ndeclarations, `connection.table`/`connection.sql`, raw SQL, and `##!` flags\nbelong in the model file, not the query. When `compile`/`compile_file` returns\n`formatted: false`, call `prettify` and save its output. Use project-relative\ndata paths, not absolute \u2014 they resolve against the project root and survive\npublishing the model.\n',
   "develop/working-with-models.md": "---\ndescription: Working with an existing Malloy model\n---\n\n# Working with an existing model\n\nAn existing model is an `index.malloy` (plus any `.malloy` files it imports) and\na `malloy-config.json`.\n\n## Understand the model\n\n- **Read `malloy-config.json` directly** \u2014 it is JSON, so read it as text. It\n  lists the connection(s) the model queries against; `yo_help(\"develop/connection-setup\")` explains\n  the format (and how to set one up or repair it).\n- **Do NOT read `.malloy` as text \u2014 compile it.** `compile_file` returns the\n  structured model: each source with its fields, joins, views, and named queries,\n  plus `problems[]`. That is how you describe what is in the model. (Compiling a\n  bare source \u2014 no `extend` block \u2014 likewise reads a raw table's schema.)\n\n## The loop\n\nEdit a file \u2192 `compile_file` \u2192 fix `problems[]` \u2192 `query`. Pass the model file's\npath as `ref`; `execute: false` validates first and reports the givens the query\nneeds (supplied via `givens`). Query text is restricted \u2014 `import`, `given:`\ndeclarations, `connection.table`/`connection.sql`, raw SQL, and `##!` flags\nbelong in the model file, not the query. When `compile`/`compile_file` returns\n`formatted: false`, run `prettify` and save its output. Use project-relative data\npaths, not absolute.\n",
@@ -1152,6 +1157,23 @@ function docText(t) {
     return void 0;
   }
 }
+function resolveTile(tile, source) {
+  const t = tile.trim();
+  if (source && !t.includes("->")) return `${source} -> ${t}`;
+  return t;
+}
+function readGivens(tag) {
+  const givensTag = tag.tag("artifact", "givens");
+  if (!givensTag) return void 0;
+  const givens = {};
+  for (const [key, t] of Object.entries(givensTag.dict ?? {})) {
+    const eq = t.eq;
+    if (typeof eq === "string" || typeof eq === "number" || typeof eq === "boolean") {
+      givens[key] = eq;
+    }
+  }
+  return Object.keys(givens).length ? givens : void 0;
+}
 function readArtifactTag(ident, q) {
   let tag;
   try {
@@ -1164,33 +1186,51 @@ function readArtifactTag(ident, q) {
   const description = docText(q);
   const name = nested?.text("name") ?? tag.text("name") ?? ident.defaultName;
   const title = nested?.text("title") ?? tag.text("title") ?? description?.split("\n")[0] ?? ident.defaultName;
+  const rawTiles = nested?.textArray("tiles") ?? tag.textArray("tiles");
+  if (rawTiles && rawTiles.length) {
+    const info2 = {
+      name,
+      query: "",
+      title,
+      tiles: rawTiles.map((t) => resolveTile(t, ident.source))
+    };
+    if (ident.source) info2.source = ident.source;
+    if (description) info2.description = description;
+    const cols = nested?.numeric("dashboard_columns") ?? tag.numeric("dashboard_columns");
+    if (typeof cols === "number") info2.dashboard_columns = cols;
+    const autorunText2 = nested?.text("autorun") ?? tag.text("autorun");
+    if (autorunText2 === "false") info2.autorun = false;
+    const givens2 = readGivens(tag);
+    if (givens2) info2.givens = givens2;
+    return info2;
+  }
   const info = { name, query: ident.runExpr, title };
   if (ident.source) info.source = ident.source;
   if (ident.view) info.view = ident.view;
   if (description) info.description = description;
-  const givensTag = tag.tag("artifact", "givens");
-  if (givensTag) {
-    const givens = {};
-    for (const [key, t] of Object.entries(givensTag.dict ?? {})) {
-      const eq = t.eq;
-      if (typeof eq === "string" || typeof eq === "number" || typeof eq === "boolean") {
-        givens[key] = eq;
-      }
-    }
-    if (Object.keys(givens).length) info.givens = givens;
-  }
+  const autorunText = nested?.text("autorun") ?? tag.text("autorun");
+  if (autorunText === "false") info.autorun = false;
+  const givens = readGivens(tag);
+  if (givens) info.givens = givens;
   return info;
 }
 async function artifactQueries(runtime, entry) {
   try {
     const model = await runtime.loadModel(entry).getModel();
     const artifacts = [];
+    const modelComposite = readArtifactTag({ runExpr: "", defaultName: "dashboard" }, model);
+    if (modelComposite?.tiles) artifacts.push(modelComposite);
     for (const queryName of model.queries().named) {
       const pq = model.getPreparedQueryByName(queryName);
       const info = readArtifactTag({ runExpr: queryName, defaultName: queryName }, pq);
       if (info) artifacts.push(info);
     }
     for (const src of model.explores) {
+      const srcComposite = readArtifactTag(
+        { runExpr: "", defaultName: src.name, source: src.name },
+        src
+      );
+      if (srcComposite?.tiles) artifacts.push(srcComposite);
       for (const field of src.allFields) {
         if (!field.isQueryField()) continue;
         const view = field;
@@ -1211,6 +1251,111 @@ async function artifactQueries(runtime, entry) {
     return { ok: false, error: e instanceof Error ? e.message : String(e) };
   }
 }
+async function collectDrillTargets(runtime, entry) {
+  try {
+    const model = await runtime.loadModel(entry).getModel();
+    const targets = /* @__PURE__ */ new Set();
+    for (const src of model.explores) {
+      for (const field of src.allFields) {
+        const tagged = field;
+        let tag;
+        try {
+          tag = tagged.annotations.parseAsTag().tag;
+        } catch {
+          continue;
+        }
+        const drill = tag.tag("drill");
+        if (!drill) continue;
+        const to = drill.textArray("to") ?? (drill.text("to") ? [drill.text("to")] : []);
+        for (const t of to) if (t && t !== "self") targets.add(t);
+      }
+    }
+    return { ok: true, targets: [...targets] };
+  } catch (e) {
+    return { ok: false, error: e instanceof Error ? e.message : String(e) };
+  }
+}
+async function modelArtifact(runtime, entry, defaultName) {
+  try {
+    const model = await runtime.loadModel(entry).getModel();
+    const composite = readArtifactTag({ runExpr: "", defaultName }, model);
+    if (composite?.tiles) return { ok: true, artifact: composite };
+    for (const queryName of model.queries().named) {
+      const pq = model.getPreparedQueryByName(queryName);
+      const info = readArtifactTag({ runExpr: queryName, defaultName }, pq);
+      if (info && !info.tiles) return { ok: true, artifact: { ...info, tiles: [info.query], query: "" } };
+    }
+    for (const src of model.explores) {
+      for (const field of src.allFields) {
+        if (!field.isQueryField()) continue;
+        const view = field;
+        const info = readArtifactTag(
+          { runExpr: `${src.name} -> ${view.name}`, defaultName, source: src.name, view: view.name },
+          view
+        );
+        if (info && !info.tiles) return { ok: true, artifact: { ...info, tiles: [info.query], query: "" } };
+      }
+    }
+    return { ok: true, artifact: void 0 };
+  } catch (e) {
+    return { ok: false, error: e instanceof Error ? e.message : String(e) };
+  }
+}
+function liftRenderTags(annotations) {
+  if (!annotations) return [];
+  return annotations.filter((a) => {
+    const v = a.value;
+    return v.startsWith("# ") && !v.startsWith("# artifact");
+  });
+}
+function tileAsNestField(name, res) {
+  const fields = (res.schema?.fields ?? []).map((f) => ({
+    name: f.name,
+    type: f.type,
+    annotations: f.annotations
+  }));
+  return {
+    kind: "dimension",
+    name,
+    type: {
+      kind: "array_type",
+      element_type: { kind: "record_type", fields }
+    },
+    annotations: liftRenderTags(res.annotations)
+  };
+}
+function uniqueName(name, taken) {
+  if (!taken.has(name)) {
+    taken.add(name);
+    return name;
+  }
+  let i = 2;
+  while (taken.has(`${name}_${i}`)) i++;
+  const out = `${name}_${i}`;
+  taken.add(out);
+  return out;
+}
+function combineTiles(tiles, opts = {}) {
+  const taken = /* @__PURE__ */ new Set();
+  const named = tiles.map((t) => ({ name: uniqueName(t.name, taken), result: t.result }));
+  const columns = typeof opts.columns === "number" && Number.isFinite(opts.columns) ? ` {columns=${Math.trunc(opts.columns)}}` : "";
+  return {
+    // Provenance carried from the first tile; the combined result never runs
+    // SQL itself, so connection_name is cosmetic but the renderer reads it.
+    connection_name: tiles[0]?.result.connection_name ?? "composite",
+    model_annotations: tiles[0]?.result.model_annotations,
+    annotations: [{ value: `# dashboard${columns}
+` }],
+    schema: { fields: named.map((t) => tileAsNestField(t.name, t.result)) },
+    // One dashboard row whose columns are the tiles' data cells (verbatim).
+    data: {
+      kind: "array_cell",
+      array_value: [
+        { kind: "record_cell", record_value: named.map((t) => t.result.data) }
+      ]
+    }
+  };
+}
 var INSTANCE_PLACEHOLDER = "{{INSTANCE_NAME}}";
 function renderInstructions(text, instanceName) {
   return text.replaceAll(INSTANCE_PLACEHOLDER, instanceName);
@@ -1361,6 +1506,17 @@ function refModelProblem(ref, e) {
   const msg = e instanceof Error ? e.message : String(e);
   return codeProblem("model-not-found", `Cannot use model '${ref}': ${msg}`);
 }
+function refNudge(ref, inspect) {
+  const also = inspect.also ? ` and ${inspect.also}=<the source you queried>` : "";
+  return (p) => {
+    if (p.code !== "field-not-found") return p;
+    return {
+      ...p,
+      message: `${p.message} \u2014 call ${inspect.tool} with ${inspect.param}="${ref}"${also} to see what fields, measures, views, and joins exist.`,
+      help_topic: p.help_topic ?? "language/fields"
+    };
+  };
+}
 async function executeQuery(m, args, fix, result) {
   const malloy = argString(args, "malloy");
   const execute = argOptBool(args, "execute") ?? true;
@@ -1374,6 +1530,50 @@ async function executeQuery(m, args, fix, result) {
   const budgeted = await applyResultBudget(full, result, { toolName: "query", args });
   return { ...budgeted, problems: budgeted.problems.map(fix) };
 }
+function queryTool(host, opts = {}) {
+  const inspect = opts.inspect ?? { tool: "describe_source", param: "model_ref", also: "source" };
+  return {
+    name: "query",
+    title: prompts.shared.tools.query.title,
+    description: prompts.shared.tools.query.description,
+    inputSchema: {
+      type: "object",
+      properties: {
+        model_ref: {
+          type: "string",
+          description: "Model ref \u2014 a published model name, or (on a local develop server) the path of the root model file."
+        },
+        malloy: { type: "string", description: "Malloy query text, e.g. `run: orders -> { ... }`." },
+        question: {
+          type: "string",
+          description: "Plain-English description of what this query answers; hosts may record or share it."
+        },
+        givens: {
+          type: "object",
+          description: "Values for $NAME givens, keyed by name (no $). Validate with execute:false to learn which givens the query needs."
+        },
+        execute: { type: "boolean", description: "Default true. false \u2192 compile/validate only (no execution)." },
+        max_rows: { type: "integer", minimum: 1, maximum: 1e4, description: `Row cap (default ${DEFAULT_ROW_LIMIT}).` }
+      },
+      required: ["model_ref", "malloy"],
+      additionalProperties: false
+    },
+    handler: async (args) => {
+      const ref = argString(args, "model_ref");
+      if (!ref.trim()) {
+        return { ok: false, problems: [codeProblem("model-ref-required", prompts.shared.errors["no-model-ref"])] };
+      }
+      try {
+        return await host.withModel(
+          ref,
+          (m) => executeQuery(m, args, refNudge(ref, inspect), opts.result)
+        );
+      } catch (e) {
+        return { ok: false, problems: [refModelProblem(ref, e)] };
+      }
+    }
+  };
+}
 async function resolveModel(host, source, modelRef) {
   if (modelRef) return { model_ref: modelRef };
   if (!host.list) {
@@ -1654,9 +1854,126 @@ function exploreSurface(host, opts = {}) {
     skills: sharedSkills()
   };
 }
+var pathSchema = {
+  type: "string",
+  description: "Path to a .malloy file, relative to the server root. (Absolute paths and file:// URIs are also accepted.)"
+};
+var sourceSchema = { type: "string", description: "Malloy source code." };
+var basePathSchema = {
+  type: "string",
+  description: "Optional path for resolving relative imports in the inline source \u2014 typically the file the snippet will live next to. If omitted, imports must be absolute."
+};
+var expandSchema = {
+  type: "string",
+  enum: ["ref", "inline"],
+  description: "Join rendering: 'ref' (default) references joined sources by name via source_ref; 'inline' recursively inlines the joined schema."
+};
+var emitRunSqlSchema = {
+  type: "boolean",
+  description: "Compile each run: statement to SQL and include it as model.runs[].sql. Default false (large; use query to execute)."
+};
+function developSurface(host, opts = {}) {
+  async function lease(input, fn) {
+    try {
+      return await host.withRuntime(input, fn);
+    } catch (e) {
+      return { ok: false, problems: [errorProblem(e)] };
+    }
+  }
+  const modelHost = {
+    withModel: (ref, fn) => host.withRuntime({ url: ref }, fn)
+  };
+  const tools = [
+    {
+      name: "compile_file",
+      title: prompts.develop.tools.compile_file.title,
+      description: prompts.develop.tools.compile_file.description,
+      inputSchema: {
+        type: "object",
+        properties: { path: pathSchema, expand: expandSchema, emit_run_sql: emitRunSqlSchema },
+        required: ["path"],
+        additionalProperties: false
+      },
+      handler: async (args) => lease(
+        { url: argString(args, "path") },
+        (m) => compile(m.runtime, m.entry, {
+          readSource: m.readSource,
+          expand: argOptString(args, "expand"),
+          emitRunSql: argOptBool(args, "emit_run_sql")
+        })
+      )
+    },
+    {
+      name: "compile",
+      title: prompts.develop.tools.compile.title,
+      description: prompts.develop.tools.compile.description,
+      inputSchema: {
+        type: "object",
+        properties: {
+          source: sourceSchema,
+          base_path: basePathSchema,
+          expand: expandSchema,
+          emit_run_sql: emitRunSqlSchema
+        },
+        required: ["source"],
+        additionalProperties: false
+      },
+      handler: async (args) => lease(
+        { source: argString(args, "source"), baseUrl: argOptString(args, "base_path") },
+        (m) => compile(m.runtime, m.entry, {
+          readSource: m.readSource,
+          expand: argOptString(args, "expand"),
+          emitRunSql: argOptBool(args, "emit_run_sql")
+        })
+      )
+    },
+    queryTool(modelHost, {
+      result: opts.result,
+      inspect: { tool: "compile_file", param: "path" }
+    }),
+    {
+      name: "prettify",
+      title: prompts.develop.tools.prettify.title,
+      description: prompts.develop.tools.prettify.description,
+      inputSchema: {
+        type: "object",
+        properties: { source: sourceSchema },
+        required: ["source"],
+        additionalProperties: false
+      },
+      handler: async (args) => prettify(argString(args, "source"))
+    },
+    yoHelpTool()
+  ];
+  return {
+    tools: tools.map(withHelp),
+    instructions: assembleInstructions("develop"),
+    skills: sharedSkills()
+  };
+}
 
 // src/host.ts
 var ENTRY = "index.malloy";
+function tileName(runExpr) {
+  const arrow = runExpr.lastIndexOf("->");
+  return (arrow >= 0 ? runExpr.slice(arrow + 2) : runExpr).trim();
+}
+async function validateQuery(runtime, entry, runExpr, givens) {
+  try {
+    const q = runtime.loadModel(entry).loadQuery(`run: ${runExpr}`);
+    const has = givens && Object.keys(givens).length > 0;
+    await q.getSQL(has ? { givens } : void 0);
+    return { ok: true };
+  } catch (e) {
+    return { ok: false, error: e instanceof Error ? e.message : String(e) };
+  }
+}
+async function validateRestrictedText(runtime, entry, malloy) {
+  const v = await validateRestricted(runtime, entry, malloy);
+  if (v.ok) return { ok: true };
+  const msg = v.problems.filter((p) => p.severity === "error").map((p) => p.message).join("; ");
+  return { ok: false, error: msg || "restricted query failed to compile" };
+}
 function fsReader() {
   return {
     readURL: async (u) => {
@@ -1677,56 +1994,123 @@ async function makeRunner(root) {
   await import("@malloydata/malloy-connections");
   const abs = path2.resolve(root);
   const rootUrl = url2.pathToFileURL(abs + path2.sep);
-  async function lease(fn) {
-    const reader = fsReader();
-    const config = await loadConfig(rootUrl, reader);
-    const { reader: prepared, entry } = prepareSource(reader, { url: path2.join(abs, ENTRY) });
+  const reader = fsReader();
+  let configPromise = null;
+  const getConfig = () => configPromise ??= loadConfig(rootUrl, reader);
+  let inFlight = 0;
+  async function leaseIn(entryFile, fn) {
+    const config = await getConfig();
+    const { reader: prepared, entry } = prepareSource(reader, { url: path2.join(abs, entryFile) });
     const runtime = new Runtime({ config, urlReader: prepared });
+    inFlight++;
     try {
       return await fn(runtime, entry);
     } finally {
-      await config.shutdown("idle").catch(() => {
+      inFlight--;
+      if (inFlight === 0) await config.shutdown("idle").catch(() => {
       });
     }
   }
+  const lease = (fn) => leaseIn(ENTRY, fn);
   return {
     root: abs,
     entryExists: () => fs.existsSync(path2.join(abs, ENTRY)),
+    async dispose() {
+      if (!configPromise) return;
+      const config = await configPromise.catch(() => null);
+      configPromise = null;
+      if (config) await config.shutdown("close").catch(() => {
+      });
+    },
     run(runExpr, givens) {
       return lease(
         (runtime, entry) => run(runtime, entry, { runExpr, givens, stableResult: true, rowLimit: 5e3 })
       );
     },
+    runIn(entryFile, runExpr, givens) {
+      return leaseIn(
+        entryFile,
+        (runtime, entry) => run(runtime, entry, { runExpr, givens, stableResult: true, rowLimit: 5e3 })
+      );
+    },
     runText(malloy, givens) {
       return lease(
         (runtime, entry) => runRestricted(runtime, entry, malloy, { givens, stableResult: true, rowLimit: 5e3 })
       );
     },
+    runTextIn(entryFile, malloy, givens) {
+      return leaseIn(
+        entryFile,
+        (runtime, entry) => runRestricted(runtime, entry, malloy, { givens, stableResult: true, rowLimit: 5e3 })
+      );
+    },
     validateText(malloy) {
-      return lease(async (runtime, entry) => {
-        const v = await validateRestricted(runtime, entry, malloy);
-        if (v.ok) return { ok: true };
-        const msg = v.problems.filter((p) => p.severity === "error").map((p) => p.message).join("; ");
-        return { ok: false, error: msg || "restricted query failed to compile" };
-      });
+      return lease((runtime, entry) => validateRestrictedText(runtime, entry, malloy));
+    },
+    validateTextIn(entryFile, malloy) {
+      return leaseIn(entryFile, (runtime, entry) => validateRestrictedText(runtime, entry, malloy));
     },
     givensForQuery(runExpr) {
       return lease((runtime, entry) => dashboardGivenSpecs(runtime, entry, runExpr));
     },
+    givensForQueryIn(entryFile, runExpr) {
+      return leaseIn(entryFile, (runtime, entry) => dashboardGivenSpecs(runtime, entry, runExpr));
+    },
     artifacts() {
       return lease((runtime, entry) => artifactQueries(runtime, entry));
     },
-    validate(runExpr, givens) {
-      return lease(async (runtime, entry) => {
-        try {
-          const q = runtime.loadModel(entry).loadQuery(`run: ${runExpr}`);
-          const has = givens && Object.keys(givens).length > 0;
-          await q.getSQL(has ? { givens } : void 0);
-          return { ok: true };
-        } catch (e) {
-          return { ok: false, error: e instanceof Error ? e.message : String(e) };
+    drillTargets() {
+      return lease((runtime, entry) => collectDrillTargets(runtime, entry));
+    },
+    artifactForFile(entryFile, defaultName) {
+      return leaseIn(entryFile, (runtime, entry) => modelArtifact(runtime, entry, defaultName));
+    },
+    runDashboard(entryFile, tiles, opts) {
+      return leaseIn(entryFile, async (runtime, entry) => {
+        const givens = opts.givens ?? {};
+        const ran = [];
+        for (const tile of tiles) {
+          const specs = await dashboardGivenSpecs(runtime, entry, tile);
+          const names = specs.ok ? new Set(specs.givens.map((s) => s.name)) : null;
+          const tileGivens = names ? Object.fromEntries(Object.entries(givens).filter(([k]) => names.has(k))) : givens;
+          const result = await run(runtime, entry, {
+            runExpr: tile,
+            givens: tileGivens,
+            stableResult: true,
+            rowLimit: 5e3
+          });
+          ran.push({ name: tileName(tile), result });
         }
+        const problems = ran.flatMap((t) => t.result.problems ?? []);
+        const good = ran.filter((t) => t.result.ok && t.result.stable_result);
+        if (good.length === 0) return { ok: false, problems };
+        if (good.length === 1) {
+          return { ok: true, stable_result: good[0].result.stable_result, problems };
+        }
+        const combined = combineTiles(
+          good.map((t) => ({ name: t.name, result: t.result.stable_result })),
+          { columns: opts.columns }
+        );
+        return { ok: true, stable_result: combined, problems };
       });
+    },
+    dashboardGivens(entryFile, tiles) {
+      return leaseIn(entryFile, async (runtime, entry) => {
+        const byName = /* @__PURE__ */ new Map();
+        for (const tile of tiles) {
+          const specs = await dashboardGivenSpecs(runtime, entry, tile);
+          if (specs.ok) {
+            for (const s of specs.givens) if (!byName.has(s.name)) byName.set(s.name, s);
+          }
+        }
+        return { ok: true, givens: [...byName.values()] };
+      });
+    },
+    validate(runExpr, givens) {
+      return lease((runtime, entry) => validateQuery(runtime, entry, runExpr, givens));
+    },
+    validateIn(entryFile, runExpr, givens) {
+      return leaseIn(entryFile, (runtime, entry) => validateQuery(runtime, entry, runExpr, givens));
     }
   };
 }
@@ -1754,28 +2138,37 @@ function gatherDirectory(dir) {
   const config = existsSync2(configPath) ? readFileSync2(configPath, "utf8") : void 0;
   return { files, config };
 }
-function listDashboardDirs(dir) {
-  const base = join2(dir, "dashboards");
-  if (!existsSync2(base)) return [];
-  return readdirSync(base).filter((name) => statSync(join2(base, name)).isDirectory()).sort();
-}
 async function gatherDashboards(dir) {
+  const dashDir = join2(dir, "dashboards");
+  if (!existsSync2(dashDir)) return [];
   const runner = await makeRunner(dir);
-  const res = await runner.artifacts();
-  if (!res.ok) throw new Error(`model error: ${res.error}`);
-  return res.artifacts.map((a) => {
-    const tsxPath = join2(dir, "dashboards", a.name, "Dashboard.tsx");
-    const manifest = { title: a.title, query: a.query };
-    if (a.source) manifest.source = a.source;
-    if (a.view) manifest.view = a.view;
-    if (a.description) manifest.description = a.description;
-    if (a.givens) manifest.givens = a.givens;
-    return {
-      name: a.name,
-      manifest,
-      source: existsSync2(tsxPath) ? readFileSync2(tsxPath, "utf8") : ""
-    };
-  });
+  try {
+    const files = readdirSync(dashDir).filter((f) => f.endsWith(".malloy")).sort();
+    const payloads = [];
+    for (const file of files) {
+      const base = file.slice(0, -".malloy".length);
+      const entryFile = `dashboards/${file}`;
+      const res = await runner.artifactForFile(entryFile, base);
+      if (!res.ok) throw new Error(`dashboard ${file}: ${res.error}`);
+      if (!res.artifact) continue;
+      const a = res.artifact;
+      const manifest = { title: a.title, entryFile };
+      if (a.tiles) manifest.tiles = a.tiles;
+      if (a.dashboard_columns !== void 0) manifest.dashboard_columns = a.dashboard_columns;
+      if (a.description) manifest.description = a.description;
+      if (a.givens) manifest.givens = a.givens;
+      if (a.autorun === false) manifest.autorun = false;
+      const component = ["jsx", "tsx"].map((ext) => join2(dashDir, `${base}.${ext}`)).find((p) => existsSync2(p));
+      payloads.push({
+        name: a.name || base,
+        manifest,
+        source: component ? readFileSync2(component, "utf8") : ""
+      });
+    }
+    return payloads;
+  } finally {
+    await runner.dispose();
+  }
 }
 function gitInfo(dir) {
   const git = (args) => execFileSync("git", args, {
@@ -1805,85 +2198,135 @@ function gitInfo(dir) {
 }
 
 // src/lint.ts
-import { existsSync as existsSync3, readFileSync as readFileSync3 } from "node:fs";
+import { existsSync as existsSync3, readdirSync as readdirSync2, readFileSync as readFileSync3 } from "node:fs";
 import { join as join3, resolve } from "node:path";
 import * as esbuild from "esbuild";
 var quoteField = (f) => /^[A-Za-z_]\w*$/.test(f) ? f : `\`${f}\``;
+function componentQueryLiterals(source) {
+  const out = /* @__PURE__ */ new Set();
+  const re = /\bquery\s*=\s*(["'])([^"'\n]+)\1/g;
+  let m;
+  while ((m = re.exec(source)) !== null) out.add(m[2].trim());
+  return [...out];
+}
 async function lintDashboards(root) {
   const abs = resolve(root);
-  const dashboards = [];
   const runner = await makeRunner(abs);
-  if (!runner.entryExists()) {
-    return { ok: false, dashboards: [{ name: "(model)", errors: [`no index.malloy at ${abs}`] }] };
+  try {
+    return await runLint(abs, runner);
+  } finally {
+    await runner.dispose();
   }
-  const arts = await runner.artifacts();
-  if (!arts.ok) {
-    return { ok: false, dashboards: [{ name: "(model)", errors: [arts.error] }] };
+}
+async function runLint(abs, runner) {
+  const dashboards = [];
+  if (runner.entryExists()) {
+    const arts = await runner.artifacts();
+    if (!arts.ok) dashboards.push({ name: "index.malloy", errors: [arts.error], warnings: [] });
+  }
+  const dir = join3(abs, "dashboards");
+  if (!existsSync3(dir)) return { ok: dashboards.every((d) => d.errors.length === 0), dashboards };
+  const entries = readdirSync2(dir);
+  const malloyFiles = entries.filter((f) => f.endsWith(".malloy")).sort();
+  const malloyBases = new Set(malloyFiles.map((f) => f.slice(0, -".malloy".length)));
+  for (const c of entries.filter((f) => /\.(jsx|tsx)$/.test(f)).sort()) {
+    const cbase = c.replace(/\.(jsx|tsx)$/, "");
+    if (!malloyBases.has(cbase)) {
+      dashboards.push({
+        name: c,
+        errors: [`component "${c}" has no matching "${cbase}.malloy" dashboard`],
+        warnings: []
+      });
+    }
   }
-  const artifacts = arts.artifacts;
-  const dirs = listDashboardDirs(abs);
-  if (artifacts.length === 0 && dirs.length === 0) return { ok: true, dashboards };
-  const declared = new Set(artifacts.map((a) => a.name));
-  for (const dir of dirs) {
+  const seenNames = /* @__PURE__ */ new Map();
+  for (const file of malloyFiles) {
+    const base = file.slice(0, -".malloy".length);
+    const entryFile = join3("dashboards", file);
     const errors = [];
-    if (existsSync3(join3(abs, "dashboards", dir, "manifest.json"))) {
-      errors.push(
-        `manifest.json is obsolete \u2014 delete it; the model's \`# artifact title="\u2026"\` tag on the query is the manifest now`
-      );
+    const warnings = [];
+    const res = await runner.artifactForFile(entryFile, base);
+    if (!res.ok) {
+      dashboards.push({ name: base, errors: [res.error], warnings: [] });
+      continue;
     }
-    if (!declared.has(dir)) {
-      errors.push(
-        `no query is tagged for this dashboard \u2014 tag one with \`# artifact\` (or \`# artifact name="${dir}"\`) in the model`
-      );
+    if (!res.artifact) continue;
+    const art = res.artifact;
+    if (seenNames.has(art.name)) {
+      errors.push(`duplicate dashboard name "${art.name}" (also declared by ${seenNames.get(art.name)})`);
+    } else {
+      seenNames.set(art.name, file);
     }
-    if (errors.length) dashboards.push({ name: dir, errors });
-  }
-  for (const artifact of artifacts) {
-    const errors = [];
-    const v = await runner.validate(artifact.query, {});
-    if (!v.ok) errors.push(v.error);
-    const specs = await runner.givensForQuery(artifact.query);
+    if (art.dashboard_columns !== void 0 && (!Number.isInteger(art.dashboard_columns) || art.dashboard_columns < 1)) {
+      errors.push(`dashboard_columns must be a positive integer (got ${JSON.stringify(art.dashboard_columns)})`);
+    }
+    const tiles = art.tiles ?? [];
+    if (tiles.length === 0) errors.push(`\`## artifact\` declares no tiles`);
+    for (const tile of tiles) {
+      const v = await runner.validateIn(entryFile, tile, {});
+      if (!v.ok) errors.push(`tile "${tile}": ${v.error}`);
+    }
+    const specs = await runner.dashboardGivens(entryFile, tiles);
     if (specs.ok) {
       for (const spec of specs.givens) {
-        if (spec.tags?.suggest_query !== void 0) {
-          errors.push(
-            `given "${spec.name}": suggest_query is obsolete \u2014 declare # suggest { source=\u2026 dimension=\u2026 } or # suggest { query=\u2026 }`
-          );
-        }
         const suggest = spec.suggest;
         if (!suggest) continue;
-        const base = suggest.query ? `run: ${suggest.query}` : suggest.source && suggest.dimension ? `run: ${suggest.source} -> ${quoteField(suggest.dimension)}` : null;
-        if (base === null) {
+        const suggestBase = suggest.query ? `run: ${suggest.query}` : suggest.source && suggest.dimension ? `run: ${suggest.source} -> ${quoteField(suggest.dimension)}` : null;
+        if (suggestBase === null) {
           errors.push(
-            `given "${spec.name}": suggest must be \`suggest { source=<source> dimension=<field> }\` or \`suggest { query=<named_query> [dimension=<field>] }\``
+            `given "${spec.name}": suggest must be \`suggest { source=<source> dimension=<field> }\` or \`suggest { query=<query> [dimension=<field>] }\``
           );
           continue;
         }
-        const sv = await runner.validateText(base);
+        const sv = await runner.validateTextIn(entryFile, suggestBase);
         if (!sv.ok) errors.push(`given "${spec.name}": suggest does not compile \u2014 ${sv.error}`);
       }
     }
-    const tsxPath = join3(abs, "dashboards", artifact.name, "Dashboard.tsx");
-    if (existsSync3(tsxPath)) {
+    for (const ext of ["jsx", "tsx"]) {
+      const cp = join3(dir, `${base}.${ext}`);
+      if (!existsSync3(cp)) continue;
+      const source = readFileSync3(cp, "utf8");
       try {
-        await esbuild.transform(readFileSync3(tsxPath, "utf8"), { loader: "tsx", jsx: "automatic" });
+        await esbuild.transform(source, { loader: ext, jsx: "automatic" });
       } catch (e) {
         const msg = e.errors?.map((x) => x.text).join("; ") ?? String(e);
-        errors.push(`Dashboard.tsx: ${msg}`);
+        errors.push(`${base}.${ext}: ${msg}`);
+        continue;
+      }
+      for (const q of componentQueryLiterals(source)) {
+        const v = await runner.validateIn(entryFile, q, {});
+        if (!v.ok) errors.push(`${base}.${ext}: query "${q}" doesn't resolve \u2014 ${v.error}`);
+      }
+    }
+    dashboards.push({ name: art.name, errors, warnings });
+  }
+  const drills = await runner.drillTargets();
+  if (drills.ok) {
+    for (const target of drills.targets) {
+      if (!seenNames.has(target)) {
+        dashboards.push({
+          name: `drill \u2192 ${target}`,
+          errors: [
+            `# drill { to=[${target}] } targets no dashboard \u2014 add dashboards/${target}.malloy, or fix the slug to a real dashboard`
+          ],
+          warnings: []
+        });
       }
     }
-    dashboards.push({ name: artifact.name, errors });
   }
   return { ok: dashboards.every((d) => d.errors.length === 0), dashboards };
 }
 function printLintReport(report) {
   for (const d of report.dashboards) {
-    if (d.errors.length === 0) {
+    const hasErr = d.errors.length > 0;
+    const hasWarn = d.warnings.length > 0;
+    if (!hasErr && !hasWarn) {
       console.log(`  \u2713 ${d.name}`);
-    } else {
-      console.log(`  \u2717 ${d.name}`);
-      for (const e of d.errors) console.log(`      ${e}`);
+      continue;
     }
+    console.log(`  ${hasErr ? "\u2717" : "\u26A0"} ${d.name}`);
+    for (const e of d.errors) console.log(`      ${e}`);
+    for (const w of d.warnings) console.log(`      warning: ${w}`);
   }
 }
 
@@ -2167,278 +2610,12 @@ function attachSurface(server, surface, opts = {}) {
   }
 }
 
-// src/dashboard-guidance.ts
-var DASHBOARD_GUIDANCE = `
-
-# Authoring dashboards
-
-A dashboard is DECLARED IN THE MODEL \u2014 there is no manifest file and, for the
-basic case, no JavaScript at all. Preview with \`malloyyo dashboard dev\`; check
-with \`malloyyo lint\`.
-
-## Make dashboards discoverable: the entry model
-
-**The entry is \`index.malloy\`.** \`dashboard dev\`, \`lint\`, and the hosted
-server only see what that file EXPORTS. Three things must all be surfaced
-(imported AND exported) through it, or the feature looks broken:
-
-1. **Whatever holds each \`# artifact\` tag.** A tag on a \`view:\` rides along
-   with its SOURCE (export the source \u2014 you can't export a view on its own); a
-   tag on a top-level \`query:\` needs that query exported. Not surfaced \u2192
-   \`dashboard dev\` says "No dashboards declared" and \`lint\` says "no dashboards
-   to lint", even though the model compiles clean.
-2. **Every filter given the dashboards reference.** An unexported given
-   silently resolves to its declaration default \u2014 the control still renders
-   but CAN'T CHANGE THE QUERY (the filter looks inert).
-3. **Whatever backs each \`suggest\`** \u2014 the named query (\`suggest {query=\u2026}\`)
-   or source (\`suggest {source=\u2026}\`). Suggestions run against the entry model;
-   an unexported one fails lint with "Reference to undefined object".
-
-\`\`\`malloy
-##! experimental.givens
-import {
-  order_items,                      // the source \u2014 carries its # artifact views
-  BRAND, CATEGORY, PERIOD,          // the filter givens
-  brand_suggest                     // backs a suggest {query=\u2026}
-} from 'ecommerce.malloy'
-export { order_items, BRAND, CATEGORY, PERIOD, brand_suggest }
-\`\`\`
-
-Exporting the source is often the whole job: its \`# artifact\` views, its
-dimensions (for \`suggest {source=\u2026}\`), and its measures all travel with it.
-
-Prefer \`suggest { query=<named-query> \u2026 }\` over \`suggest { source=\u2026 }\` for
-anything beyond a throwaway: you export one small governed query instead of a
-whole base source.
-
-## The model is the whole contract
-
-**1. Tag a \`view:\` inside a source** with \`# artifact\` to declare a dashboard
-(the idiomatic form \u2014 a view is reusable, nestable, and explorable through the
-normal \`query\`/\`describe_source\` surface). For the common overview shape
-(top-level aggregates + nests), ALSO tag it \`# dashboard\` so the result
-renders as KPI tiles + a card grid instead of one flat table \u2014 they're
-partners: \`# artifact\` declares the dashboard, \`# dashboard\` is the renderer
-tag that draws it like one:
-
-\`\`\`malloy
-source: order_items is \u2026 extend {
-  #" Business health at a glance \u2014 sales, margin, orders.
-  # artifact { title="Business Overview" } dashboard
-  view: overview_dashboard is {
-    where:
-      inventory_items.product_brand ~ $BRAND,     // multi-filter where: is
-      inventory_items.product_category ~ $CATEGORY,  // COMMA separated
-      created_at ~ $PERIOD
-    aggregate: total_sales, total_gross_margin, order_count
-    nest:
-      # line_chart
-      sales_trend is by_month
-      top_brands
-      # shape_map
-      sales_by_state
-  }
-}
-\`\`\`
-
-That's a complete dashboard: the runtime auto-renders a title (the tag's
-\`title\`, else the \`#"\` doc comment), a control for every given the view
-references, and the result panel. It runs as \`run: <source> -> <view>\` (here
-\`order_items -> overview_dashboard\`). \`name="slug"\` overrides the
-URL/directory slug (default: the view name). Note the \`where:\` clauses
-applying givens are COMMA-separated \u2014 newline-separated conditions do not
-parse.
-
-Tagging a **top-level \`query:\`** still works and behaves identically (it runs
-as \`run: <name>\`) \u2014 reach for it only when the dashboard query doesn't belong
-to any one source.
-
-**Deep-link a cell** to an external system \u2014 tag any \`group_by:\`/\`select:\`
-field \`# link\` (the value is a full URL) or
-\`# link { url_template="https://\u2026/$$" }\` (\`$$\` = the cell value; add
-\`field=id\` to link on a separate, usually \`# hidden\`, id column). Common in a
-nested detail table so each row jumps to its record. \`# image { url_template=\u2026 }\`
-renders a cell as an inline image. Links open in a new browser tab.
-
-Two dashboards can share a given but start on different values \u2014 a \`givens\`
-block in the tag sets PER-DASHBOARD defaults (given values, i.e. filter
-expressions; URL params still win):
-
-\`\`\`malloy
-# artifact { name="manufacturer" title="Manufacturer Recall Profile" givens { MANUFACTURER="Ford Motor Company" } }
-\`\`\`
-
-This replaces the "declare the given's default per dashboard" role the old
-manifests had: declare the given once with a neutral default (often \`f''\` =
-no filter), and let each tag pick its landing state.
-
-**2. Declare the filters as \`filter<T>\` givens** \u2014 never raw strings/numbers.
-A \`filter<string>\` value accepts one value ('NY'), alternatives ('NY, CA'),
-wildcards ('Ann%'), negation ('-NY'); a \`filter<number>\` accepts ranges
-('[1910 to 1930]') and comparisons ('> 200'); a \`filter<timestamp>\` /
-\`filter<date>\` accepts relative windows ('7 days' = the last 7 days, 'today',
-'last month') and literal ranges ('2026-01-01 to 2026-07-01' \u2014 NO \`@\` in
-filter literals). Apply with \`~\`; \`f''\` = empty = no filter (the natural
-"All"/"all time" \u2014 just \`col ~ $X\`, no \`$X = '' or \u2026\` dance):
-
-\`\`\`malloy
-##! experimental { givens }
-given:
-  # label="State" control=select suggest { source=baby_names dimension=state }
-  STATE :: filter<string> is f'NY'
-  # label="Brand" suggest { query=brand_suggest dimension=product_brand }
-  BRAND :: filter<string> is f''
-  # label="Years" range_min=1910 range_max=2025
-  YEAR_RANGE :: filter<number> is f'[1910 to 1930]'
-  # label="Time period"
-  PERIOD :: filter<timestamp> is f''
-  # label="Include rare names"
-  INCLUDE_RARE :: boolean is false
-\`\`\`
-
-Tags on the declaration drive the control (tag syntax is \`key="value"\` \u2014
-equals, not colon):
-- \`label\` \u2014 control caption (defaults to the given's name)
-- \`suggest { \u2026 }\` \u2014 where the control's options come from. NO Malloy code in
-  strings \u2014 just names:
-  - \`suggest { query=brand_suggest dimension=product_brand }\` \u2014 the FIRST
-    COLUMN of a named query (declare the query in the model \u2014 governed,
-    reviewable, and only that query needs exporting). PREFER THIS FORM.
-  - \`suggest { source=baby_names dimension=state }\` \u2014 the DISTINCT VALUES of
-    a dimension on a source (the whole source must be exported)
-  A \`dimension\` (in either form) is what enables SERVER-SIDE TYPEAHEAD: the
-  runtime refines the base query with what the user has typed
-  (\`\u2026 + { where: lower(field) ~ f'll%'; limit: 50 }\`, case-insensitive,
-  escaped). Without a dimension the fetched list is filtered client-side.
-  Runs as a restricted query; lint checks the declaration compiles.
-
-  **RELATED (faceted) filters** \u2014 query-form only: a suggest query may
-  reference the OTHER givens, and the runtime runs it with the dashboard's
-  current values (the suggested given itself is excluded, so the list never
-  collapses to the current pick). Brand suggestions narrow when Category is
-  set:
-
-  \`\`\`malloy
-  query: brand_suggest is inventory_items -> product_brand + {
-    where:
-      product_category ~ $CATEGORY,      // NOT product_brand ~ $BRAND
-      product_department ~ $DEPARTMENT
-    limit: 500
-  }
-  \`\`\`
-
-  Declare one \`*_suggest\` per filter, each referencing the others; \`f''\`
-  defaults mean unset filters don't constrain. \`source=\` suggests can't do
-  this (no place for a \`where:\`) \u2014 another reason to prefer \`query=\`.
-- \`control=select\` \u2014 a fixed dropdown instead of a typeahead search box
-- \`range_min\` / \`range_max\` \u2014 bounds; makes a filter<number> given a
-  dual-thumb range slider
-- anything else passes through in \`spec.tags\` for custom components
-
-Control picked from the declaration automatically: numeric range tags \u2192
-dual-thumb slider; \`filter<timestamp|timestamptz|date>\` \u2192 the TimeRange
-widget (relative presets: Today / Last 7 days / Last 30 days / \u2026 plus a
-"Custom range\u2026" from/to date picker); suggest + control=select \u2192 dropdown;
-boolean \u2192 checkbox; anything else \u2192 committing search box with typeahead.
-The suggest-driven options are DATA VALUES only \u2014 options that aren't column
-values (custom time presets, threshold buckets) need a custom component
-(below) with explicit \`{value, text}\` options where value is a filter
-expression built with \`filters.*\`.
-
-## Custom components (optional): ./dashboards/<slug>/Dashboard.tsx
-
-When the default UI isn't enough, add ONE file. It composes the runtime's
-widgets/hooks with your own React \u2014 you own layout, copy, and theming; the
-model still owns every query and filter:
-
-\`\`\`tsx
-import React from "react";
-import { Controls, Given, Search, Select, TimeRange, Panel, filters, useGiven } from "@malloyyo/dashboard";
-
-export default function Dashboard({ dashboard, givens }) {
-  return (
-    <div style={{ maxWidth: 860, margin: "0 auto", padding: 24 }}>
-      <h1>{dashboard.title}</h1>
-      <Controls>
-        <Given name="STATE" />          {/* picks the control from the declaration */}
-        <Search given="NAME" />         {/* committing input + typeahead + validation */}
-        <TimeRange given="PERIOD" presets={[
-          { value: "", text: "All time" },
-          { value: filters.lastN(1, "day"), text: "Last day" },
-          { value: filters.lastN(1, "week"), text: "Last week" },
-          { value: filters.lastN(1, "month"), text: "Last month" },
-        ]} />                            {/* "Custom range\u2026" is always appended */}
-        <Select given="MIN_SAMPLE"
-          options={[10, 200, 1000].map(n => ({ value: filters.greaterThan(n), text: \`> \${n}\` }))} />
-      </Controls>
-      <Panel givens={givens} />         {/* the tagged query, Malloy renderer */}
-      <Panel malloy="baby_names -> births_by_decade" givens={givens} />  {/* restricted text */}
-    </div>
-  );
-}
-\`\`\`
-
-From \`@malloyyo/dashboard\` (also handed to the component as props):
-- **Widgets** (headless-ish; restyle via className/style or CSS vars
-  \`--dash-fg/-muted/-border/-accent/-control-bg/-controls-bg\`):
-  \`<Controls/>\` (all givens, or compose children), \`<Given name/>\`,
-  \`<Select given [options]/>\`, \`<Search given/>\`, \`<Range given [min max]/>\`,
-  \`<TimeRange given [presets]/>\` (temporal presets + custom range),
-  \`<Checkbox given/>\` (bound to a boolean given)
-- **Hooks**: \`useGiven(name)\` \u2192 {value, set, spec};
-  \`useOptions(name, typed?)\` \u2192 {options, loading} (typeahead);
-  \`useQuery({query|malloy, givens})\` \u2192 {rows, loading, error} \u2014 plain rows
-  for your own visuals
-- **Helpers**: \`filters.oneOf/contains/between/atLeast/\u2026\` build
-  filter-expression strings with correct escaping; temporal:
-  \`filters.lastN(7, "day")\` \u2192 \`'7 days'\`, \`filters.dateRange("2026-01-01",
-  "2026-07-01")\`, \`filters.afterDate/beforeDate\`; read back with
-  \`filters.values/numberRange/threshold/inLast/temporalRange\`;
-  \`filters.isValid(type, src)\` checks typed input.
-  Never hand-concatenate a filter string.
-  **Escaping rule for custom controls:** a filter given's value is an
-  EXPRESSION, so committing a raw column value is wrong the moment it contains
-  a comma/percent/dash ('Tesla, Inc.' parses as two alternatives and matches
-  nothing). Commit \`filters.oneOf(value)\` (exact) or
-  \`filters.contains(term)\` (substring), and unwrap for display with
-  \`filters.values(src)\`. The stock \`<Select/>\` does this automatically;
-  \`<Search/>\` deliberately commits raw text (its input IS a filter
-  expression).
-- \`<Panel/>\` and \`runData(text, givens)\` \u2014 named queries are the primary
-  form; arbitrary Malloy runs as a RESTRICTED query (no import / given: /
-  connection.* / raw SQL / ##! flags \u2014 the model's published surface only).
-
-## Rules
-- Declare data in the model: givens are \`filter<T>\`, options come from
-  \`# suggest {\u2026}\` declarations, dashboards are \`# artifact\` tags. If a query or given you
-  need is missing, add it to the \`.malloy\` file first (check with
-  \`describe_source\`).
-- Surface everything through the entry model (see the top section).
-- Only React + \`@malloyyo/dashboard\` are importable. No other imports, no
-  network \u2014 the runtime sandboxes the component.
-- Interactivity = setting given values (filter-expression strings), not
-  rewriting query text per interaction.
-
-## Preview & validate
-\`malloyyo dashboard dev\` \u2192 open the printed URL. Edits to \`.malloy\` (tags,
-givens, queries) and \`Dashboard.tsx\` hot-reload. \`malloyyo lint\` validates
-the tagged queries, given \`suggest\` declarations, and any Dashboard.tsx \u2014
-but only for dashboards REACHABLE FROM THE ENTRY: "no dashboards to lint"
-usually means the \`# artifact\` queries aren't exported through
-\`index.malloy\`, not that they don't exist.
-
-Validation loop that works well: the local \`malloyyo mcp\` server hot-reloads
-working-directory edits \u2014 \`query(execute:false)\` to compile-check,
-\`execute:true\` to run. A \`# artifact\` view runs as
-\`run: <source> -> <view>\`; a top-level \`# artifact\` query runs as
-\`run: <name>\`. Either is only visible once surfaced through the entry (export
-the source for a view, the query for a top-level query). Don't validate local
-edits against a hosted/claude.ai connector \u2014 that serves the PUBLISHED model,
-which is stale until \`malloyyo publish\`.
-`;
-
 // src/mcp.ts
 var ENTRY2 = "index.malloy";
+var MODE_STUB = {
+  develop: "\n\n# DEVELOP (author) mode\nYou can author this Malloy model \u2014 compile / compile_file / prettify / query the files in this project (any .malloy path; no index.malloy required). For how-to, call yo_help \u2014 start with `dashboards/authoring`, then `dashboards/grid-layout`, `dashboards/vega-charts`, and the `develop/*` topics. To preview exactly what claude.ai web will see, relaunch as `malloyyo test`.",
+  explore: "\n\n# TEST (explore) mode\nThis mirrors the claude.ai web experience \u2014 the same tools a hosted consumer gets, over this project's published entry model (index.malloy). Call yo_help for guidance. To author the model (compile / edit / dashboards), relaunch as `malloyyo author`."
+};
 function defaultConfig(rootUrl) {
   return new MalloyConfig2({ includeDefaultConnections: true }, {
     rootDirectory: rootUrl.toString()
@@ -2532,16 +2709,21 @@ function makeExploreHost(root, currentConfig) {
     }
   };
 }
+function makeDevelopHost(root, currentConfig) {
+  return { withRuntime: makeWithRuntime(root, currentConfig) };
+}
 async function serveMcp(opts) {
   await import("@malloydata/malloy-connections");
   const root = path3.resolve(opts.root ?? process.cwd());
+  const mode = opts.mode ?? "explore";
   const currentConfig = makeConfigSource(root);
-  const surface = exploreSurface(makeExploreHost(root, currentConfig));
+  const surface = mode === "develop" ? developSurface(makeDevelopHost(root, currentConfig)) : exploreSurface(makeExploreHost(root, currentConfig));
   const instanceName = process.env.INSTANCE_NAME || "Malloyyo";
+  const serverName = mode === "develop" ? "malloyyo-develop" : "malloyyo-explore";
   const server = new McpServer(
-    { name: "malloyyo-explore", version: opts.version },
+    { name: serverName, version: opts.version },
     {
-      instructions: renderInstructions(surface.instructions, instanceName) + DASHBOARD_GUIDANCE,
+      instructions: renderInstructions(surface.instructions, instanceName) + MODE_STUB[mode],
       capabilities: { tools: {}, prompts: {}, resources: {} }
     }
   );
@@ -2595,12 +2777,20 @@ function resolveRuntimeDir() {
 }
 var resolveFrameEntry = () => path4.join(resolveRuntimeDir(), "..", "frame-entry.tsx");
 async function discoverDashboards(root, runner) {
-  const result = await runner.artifacts();
-  if (!result.ok) throw new Error(`model error: ${result.error}`);
-  return result.artifacts.map((a) => {
-    const tsxPath = path4.join(root, "dashboards", a.name, "Dashboard.tsx");
-    return { ...a, tsxPath: fs3.existsSync(tsxPath) ? tsxPath : void 0 };
-  });
+  const dir = path4.join(root, "dashboards");
+  if (!fs3.existsSync(dir)) return [];
+  const files = fs3.readdirSync(dir).filter((f) => f.endsWith(".malloy")).sort();
+  const dashboards = [];
+  for (const file of files) {
+    const base = file.slice(0, -".malloy".length);
+    const entryFile = path4.join("dashboards", file);
+    const res = await runner.artifactForFile(entryFile, base);
+    if (!res.ok) throw new Error(`dashboard ${file}: ${res.error}`);
+    if (!res.artifact) continue;
+    const component = ["jsx", "tsx"].map((ext) => path4.join(dir, `${base}.${ext}`)).find((p) => fs3.existsSync(p));
+    dashboards.push({ ...res.artifact, name: res.artifact.name || base, entryFile, tsxPath: component });
+  }
+  return dashboards;
 }
 var esc = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
 function makeBundler() {
@@ -2675,15 +2865,22 @@ window.addEventListener('message',async(e)=>{
   if(m&&m.type==='givens'){
     const u=new URL(location.href); u.search='';
     u.searchParams.set('d',${d});
-    for(const [k,v] of Object.entries(m.givens)) u.searchParams.set(k,String(v));
+    for(const [k,v] of Object.entries(m.givens)) if(v!=null&&String(v)!=='') u.searchParams.set('$'+k,String(v));
     history.replaceState(null,'',u.pathname+u.search);
     return;
   }
+  if(m&&m.type==='navigate'&&typeof m.dashboard==='string'){
+    const u=new URL(location.href); u.search='';
+    u.searchParams.set('d',m.dashboard);
+    for(const [k,v] of Object.entries(m.givens||{})) if(v!=null&&String(v)!=='') u.searchParams.set('$'+k,String(v));
+    location.href=u.pathname+u.search;
+    return;
+  }
   if(!m||m.type!=='run')return;
   let out;
   try{
     const res=await fetch('/api/run',{method:'POST',headers:{'content-type':'application/json'},
-      body:JSON.stringify({d:${d},query:m.query,malloy:m.malloy,givens:m.givens})});
+      body:JSON.stringify({d:${d},query:m.query,malloy:m.malloy,givens:m.givens,dashboard:m.dashboard})});
     out=await res.json();
   }catch(err){ out={ok:false,problems:[{message:String(err)}]}; }
   f.contentWindow.postMessage({type:'result',id:m.id,...out},${fb});
@@ -2703,7 +2900,10 @@ function frameDoc(dash, givenSpecs, initialGivens) {
     query: dash.query,
     title: dash.title,
     description: dash.description,
-    givens: dash.givens
+    tiles: dash.tiles,
+    dashboard_columns: dash.dashboard_columns,
+    givens: dash.givens,
+    autorun: dash.autorun
   };
   return html(
     `<div id="root"></div><script>window.__DASHBOARD__=${JSON.stringify(info)};window.__GIVENS__=${JSON.stringify(givenSpecs)};window.__INITIAL_GIVENS__=${JSON.stringify(initialGivens)}</script><script src="/bundle.js?d=${encodeURIComponent(dash.name)}"></script>`,
@@ -2767,7 +2967,7 @@ async function serveDashboard(opts) {
       if (onFramePort) {
         if (url4.pathname === "/frame") {
           const dash = pick(url4);
-          const specs = await runner.givensForQuery(dash.query);
+          const specs = dash.tiles && dash.entryFile ? await runner.dashboardGivens(dash.entryFile, dash.tiles) : await runner.givensForQuery(dash.query);
           if (!specs.ok) {
             return send(
               200,
@@ -2793,10 +2993,11 @@ async function serveDashboard(opts) {
         return send(200, "text/html; charset=utf-8", parentShell(pick(url4), frameBase, dashboards, givensFromUrl(url4)));
       }
       if (url4.pathname === "/api/run" && req.method === "POST") {
-        const { d, query, malloy, givens } = JSON.parse(await readBody(req));
+        const { d, query, malloy, givens, dashboard } = JSON.parse(await readBody(req));
         const dash = byName.get(d);
         if (!dash) return send(404, "application/json", JSON.stringify({ ok: false, problems: [{ message: `no dashboard '${d}'` }] }));
-        const out = typeof malloy === "string" ? await runner.runText(malloy, givens ?? {}) : await runner.run(String(query ?? dash.query), givens ?? {});
+        const entry = dash.entryFile;
+        const out = dashboard && dash.tiles && entry ? await runner.runDashboard(entry, dash.tiles, { columns: dash.dashboard_columns, givens: givens ?? {} }) : typeof malloy === "string" ? entry ? await runner.runTextIn(entry, malloy, givens ?? {}) : await runner.runText(malloy, givens ?? {}) : entry ? await runner.runIn(entry, String(query ?? ""), givens ?? {}) : await runner.run(String(query ?? dash.query), givens ?? {});
         return send(200, "application/json", JSON.stringify(out));
       }
       send(404, "text/plain", "not found");
@@ -2821,8 +3022,126 @@ async function serveDashboard(opts) {
   });
 }
 
+// src/init.ts
+import fs4 from "node:fs";
+import path5 from "node:path";
+var AUTHOR_MCP = {
+  mcpServers: {
+    // No -C: the server roots at the launch cwd (the project dir), so this file
+    // is portable/committable — no absolute paths baked in.
+    malloyyo_author: { command: "malloyyo", args: ["mcp", "--develop"] }
+  }
+};
+function exportableNames(src) {
+  const names = /* @__PURE__ */ new Set();
+  const code = src.replace(/\/\/[^\n]*/g, "");
+  for (const m of code.matchAll(/^\s*(?:source|query)\s*:\s*([A-Za-z_]\w*)\s+is\b/gm)) {
+    names.add(m[1]);
+  }
+  for (const m of code.matchAll(/^\s*([A-Za-z_]\w*)\s*::/gm)) {
+    names.add(m[1]);
+  }
+  return [...names];
+}
+function scaffoldIndex(root) {
+  const indexPath = path5.join(root, "index.malloy");
+  if (fs4.existsSync(indexPath)) {
+    return { wrote: false, note: "index.malloy already exists \u2014 left as-is" };
+  }
+  const models = fs4.readdirSync(root).filter((f) => f.endsWith(".malloy") && f !== "index.malloy").sort();
+  if (models.length === 0) {
+    return { wrote: false, note: "no .malloy files found \u2014 skipped index.malloy" };
+  }
+  const blocks = [
+    "// Generated by `malloyyo init` \u2014 the entry model. `dashboard dev`, `lint`,",
+    "// `malloyyo test`, and the hosted app only see what THIS file exports.",
+    "// Review the re-exports below (add givens / suggest queries your dashboards",
+    "// reference), then validate with `malloyyo mcp --develop` or `dashboard dev`.",
+    ""
+  ];
+  let anyNames = false;
+  for (const file of models) {
+    const names = exportableNames(fs4.readFileSync(path5.join(root, file), "utf8"));
+    if (names.length === 0) {
+      blocks.push(`// ${file}: no top-level source/query/given detected \u2014 add exports by hand`);
+      continue;
+    }
+    anyNames = true;
+    const list = names.join(", ");
+    blocks.push(`import { ${list} } from './${file}'`);
+    blocks.push(`export { ${list} }`);
+    blocks.push("");
+  }
+  fs4.writeFileSync(indexPath, blocks.join("\n") + "\n");
+  return {
+    wrote: true,
+    note: anyNames ? `wrote index.malloy re-exporting ${models.length} model file(s) \u2014 REVIEW it` : "wrote index.malloy skeleton \u2014 no exports detected, fill them in by hand"
+  };
+}
+async function initCmd(dir) {
+  const root = path5.resolve(dir);
+  if (!fs4.existsSync(root) || !fs4.statSync(root).isDirectory()) {
+    throw new Error(`not a directory: ${root}`);
+  }
+  const mcpPath = path5.join(root, ".mcp.json");
+  if (fs4.existsSync(mcpPath)) {
+    console.log(`\u2022 .mcp.json exists \u2014 leaving it. For author-by-default it should be:`);
+    console.log(`    ${JSON.stringify(AUTHOR_MCP.mcpServers.malloyyo_author)}`);
+    console.log(`  (server key "malloyyo_author", command "malloyyo mcp --develop").`);
+  } else {
+    fs4.writeFileSync(mcpPath, JSON.stringify(AUTHOR_MCP, null, 2) + "\n");
+    console.log(`\u2713 wrote .mcp.json \u2014 \`cd ${dir} && claude\` now opens in AUTHOR mode`);
+  }
+  const idx = scaffoldIndex(root);
+  console.log(`${idx.wrote ? "\u2713" : "\u2022"} ${idx.note}`);
+  console.log("");
+  console.log("Next:");
+  console.log("  claude              # author mode (mcp__malloyyo_author__* tools)");
+  console.log("  malloyyo test       # preview exactly what claude.ai web will see");
+  console.log("  malloyyo dashboard dev   # see dashboards render in a browser");
+}
+
+// src/launch.ts
+import { spawn as spawn2 } from "node:child_process";
+import fs5 from "node:fs";
+import os from "node:os";
+import path6 from "node:path";
+var SURFACE_FLAG = { author: "--develop", test: "--explore" };
+var SERVER_KEY = { author: "malloyyo_author", test: "malloyyo_test" };
+async function launchCmd(mode, opts) {
+  const root = path6.resolve(opts.root ?? process.cwd());
+  const tmpDir = fs5.mkdtempSync(path6.join(os.tmpdir(), "malloyyo-launch-"));
+  const cfgPath = path6.join(tmpDir, "mcp.json");
+  const cfg = {
+    mcpServers: {
+      // Absolute -C: an ephemeral config, so pinning the root is robust.
+      [SERVER_KEY[mode]]: { command: "malloyyo", args: ["mcp", SURFACE_FLAG[mode], "-C", root] }
+    }
+  };
+  fs5.writeFileSync(cfgPath, JSON.stringify(cfg, null, 2));
+  const label = mode === "author" ? "AUTHOR (compile/edit)" : "TEST (claude.ai web preview)";
+  process.stderr.write(`\u25B6 launching Claude in ${label} mode over ${root}
+`);
+  const child = spawn2("claude", ["--strict-mcp-config", "--mcp-config", cfgPath], {
+    stdio: "inherit",
+    cwd: root
+  });
+  await new Promise((resolve3) => {
+    child.on("error", (e) => {
+      process.stderr.write(
+        `\u2717 could not launch \`claude\`: ${e.message}
+  (is Claude Code installed and on PATH?)
+`
+      );
+      resolve3();
+    });
+    child.on("exit", () => resolve3());
+  });
+  fs5.rmSync(tmpDir, { recursive: true, force: true });
+}
+
 // package.json
-var version = "0.2.15";
+var version = "0.2.17";
 
 // src/index.ts
 function shortSha(sha) {
@@ -2908,10 +3227,26 @@ program.command("lint").argument("[dir]", "directory to lint", ".").description(
   if (!report.ok) process.exit(1);
 });
 program.command("status").argument("<target>", "named target from the `malloyyo` config block").option("--token <token>", "bearer token (overrides login/env)").description("show what's live on <target>: version, commit, compile state").action(status);
-program.command("mcp").option("-C, --root <dir>", "project root (default: current directory)").description(
-  "run a local stdio MCP server (the explore / test-window surface) over the Malloy model in the current directory"
+program.command("mcp").option("-C, --root <dir>", "project root (default: current directory)").option("--develop", "author surface: compile/prettify/query any .malloy in the project").option("--explore", "explore surface: the claude.ai web preview (index.malloy only) [default]").description(
+  "run a local stdio MCP server over the Malloy model in the current directory. --develop for authoring, --explore (default) to preview the web experience"
 ).action(async (opts) => {
-  await serveMcp({ root: opts.root, version });
+  if (opts.develop && opts.explore) {
+    throw new Error("pass only one of --develop / --explore");
+  }
+  await serveMcp({
+    root: opts.root,
+    version,
+    mode: opts.develop ? "develop" : "explore"
+  });
+});
+program.command("init").argument("[dir]", "model repo to set up", ".").description(
+  "set up a model repo: write .mcp.json so `cd <repo> && claude` opens in author mode, and scaffold index.malloy if missing"
+).action(initCmd);
+program.command("author").option("-C, --root <dir>", "project root (default: current directory)").description("launch Claude wired ONLY to the author surface (compile/edit the model)").action(async (opts) => {
+  await launchCmd("author", opts);
+});
+program.command("test").option("-C, --root <dir>", "project root (default: current directory)").description("launch Claude wired ONLY to the explore surface \u2014 the claude.ai web preview").action(async (opts) => {
+  await launchCmd("test", opts);
 });
 program.command("dashboard").argument("<action>", "action to run (currently: dev)").option("-C, --root <dir>", "project root (default: current directory)").option("-p, --port <port>", "port to serve on", "4173").description("preview dashboard artifacts in ./dashboards against the local Malloy model").action(async (action, opts) => {
   if (action !== "dev") throw new Error(`unknown dashboard action '${action}' (expected: dev)`);