Repository navigation
Turns the viewer into the first editable, automatable DashCraft: a typed command registry behind the CLI, a JSON-RPC server, an MCP server for AI agents and the app; revisioned, undoable editing with Power BI Desktop-compatible PBIP saves (M6); DAX, M and TMDL language services, a formula bar with IntelliSense and dashcraft lsp (M7); crash recovery, external-change detection and a semantic diff (M8); and reading-view parity: highlighting, drill, drillthrough, report-page tooltips, bookmarks, synced and range slicers, visual menus and query reduction (M9). Also: the opt-in AI layer, more visuals, calculation groups, row-level security "View as", 299 DAX functions, Power BI Desktop ground-truth testing, arm64 installers, the DashCraft name and the MIT OR Apache-2.0 licence.
Added
- Saving keeps the reading state:
report.state.persistwrites the applied slicer selections and the filters a bookmark changed into the report as one undoable edit (honouring the report's persistent-filters setting), and the app runs it before Save and Save as (M9.11). - Measure filters at report and page level filter each visual's rows; query-reduction options work: Apply buttons on slicers and visible "Apply all slicers" buttons keep slicer selections pending until applied (
canvas.applySlicers, an Apply button in the app), and disabled cross-highlighting stops selected points from filtering by default (M9.10). - Report-level measures (
reportExtensions.json) evaluate in visuals; registered images draw as image visuals, page backgrounds, wallpapers and button images; PBIX, PBIT and PBIR-Legacy reports use their themes in the CLI andrender.*(M9.9). - Visual header and right-click menus (M9.8): focus mode, show as a table, spotlight, sort axis, copy value and selection, and export data (summarized or underlying, CSV); registry commands
canvas.focus,canvas.showAsTable,canvas.setSpotlight,canvas.sortVisual,canvas.contextMenuandexport.visualData; bookmarks in focus mode now apply it. - Range and relative-date slicers are interactive (M9.7):
canvas.setRangeandcanvas.setRelativeDate, slider and picker controls incanvas.render, draggable handles, editable bounds and Last/Next/This pickers in the app; relative date and time filters now apply against the session clock. - Cross-report drillthrough between the reports of the open document (
canvas.drillthroughtargetReport,useCrossReportDrillthroughandreferenceScope: CrossReport), and "Keep all filters" now also carries the source visual's own filters (M9.4). - Bookmarks restore drill state and spotlight (M9.5): a captured visual's
activeProjectionsand drill filters set its drill levels and path, and a spotlighted visual fades the rest of the page. - Data labels of highlighted charts show the highlighted value and their tooltips add a "Highlighted" line (M9.1).
- Slicers honour their
general.selfFilter(M9.6): the filter the newer slicers keep on their own item list narrows that slicer only, not the visuals it filters. - Drill down and up on report visuals (M9.2): charts with several axis fields and matrices with several row fields drill up, down on a data point, to the next level or expand one level, from the visual's header buttons or right-click menu, and through the new
canvas.drillcommand. - Report-page tooltips (M9.3):
canvas.tooltipPagerenders the tooltip page of a hovered data point (the visual'svisualTooltippage, or the first tooltip page whose fields the point has) at the page's size, filtered by the point, the source page's filters, slicers and cross-filter and the source visual's own filters; the app shows it in the hover card. Acme's Store Performance stacked chart uses the Store Tooltip page (expected.jsontooltipPages); perf scenario P13tooltip-page-render. - Drillthrough (M9.4):
canvas.drillthroughTargetslists the drillthrough pages of a data point andcanvas.drillthroughfilters one on the point's (or the selection's) values, keeping the source's filters when "Keep all filters" is on; drillthrough buttons and right-click Drill through on a data point work in the app. The Acme Outfitters Store Detail page is a drillthrough page on Region (Store Performance's table gains a Region column and Store Detail a Back button), with expected values for drilling from a West store. - Synced slicers (M9.6): selecting or clearing in a slicer, or Clear all slicers, copies its selection to every slicer of its sync group (
syncGroup) over the same fields on any page, hidden ones included, so they filter their pages as in Power BI. - Bar and column charts highlight instead of filtering (M9.1): a point selected in another visual dims their bars and draws the selected part solid, as Power BI does by default and for "Highlight" interactions, unless the report's "selections filter other visuals" setting is on; the DataView's
highlightscarry the values. Combo charts highlight their columns, pies and donuts draw the highlighted share as a shorter slice, funnels as a narrower bar and treemaps as the bottom part of the tile. - Bookmarks now set filter cards (M9.5): the report, page and visual filters a bookmark captures (by name, or by field) replace the saved conditions on the canvas, following "selected visuals only" and the Data switch; changed Top N filters are listed as not applied.
- Bookmarks now set visuals' sort order (M9.5): a captured visual's
orderByreplaces its saved sort until another bookmark resets it, following "selected visuals only" and the Display switch. - Bookmarks now show and hide visuals and groups (M9.5): a visual captured as hidden (
display.mode) or a hidden group (visualContainerGroups) disappears from the canvas and is no longer queried, and the visuals it shows reappear, following "selected visuals only" and the Display switch. Spotlight and focus modes are listed as not applied. - Page and bookmark navigators (M9.5) draw one button per page or bookmark instead of one labelled button: hidden and tooltip pages and the bookmark group follow the visual's formatting, buttons are laid out horizontally, vertically or in a grid, and the current page or the bookmark applied last is selected. Clicking a button goes to its page or applies its bookmark, in the app and through
canvas.click(new hit ids<visual>|navItem|<index>). - Bookmarks pane in the app (View → Bookmarks, M9.5): the report's bookmarks and groups in pane order; a click applies one and marks it current. View starts a slideshow, with a bar above the page tabs (Previous, the bookmark's name and position, Next, Exit or Esc) usable by keyboard.
- Bookmarks (M9.5, first part): bookmarks and bookmark groups are read from PBIR (
bookmarks/) and PBIR-Legacy/PBIX reports. The newreport.bookmarkslists them andcanvas.applyBookmarkapplies one. Bookmark buttons on the canvas now work in the app and throughcanvas.click: they go to the bookmark's page and set its slicer selections and cross-filter, honouring "selected visuals only" and the data and display switches. Filters, hidden visuals, sort, drill state and formatting are not applied yet and are listed as such. The Acme Stores report's two bookmarks and their card values are inexpected.json. - External changes in the app (M8.2, M8.3): while a PBIP project is open, DashCraft checks its files every 1.5 seconds; when another program (Git, an editor, Power BI Desktop) adds, changes or deletes one, a notification bar names it and offers Reload (rereads the project; asks first when unsaved edits would be discarded), Keep mine (hides the bar for these changes; Save still asks before overwriting them) and Compare (the document, unsaved edits included, compared object by object with the files on disk: what differs, only here or only on disk, each property's value on both sides, where it is defined, and its TMDL or JSON text with the differing lines marked).
- Compare in the app (M8.3): File → Compare compares the document, unsaved edits included, object by object with its files on disk, another Power BI file or a PBIP or TMDL folder (for example another copy or branch of the project), in the same view as the external changes bar's Compare; nothing is changed.
- Report objects in
doc.diffand Compare as their PBIR files (M8.3): a changed, added or removed page, visual or report shows itspage.json,visual.jsonorreport.jsonas a save would write it, unsaved edits included, instead of the JSON of its properties (legacy layouts keep the properties). - External changes pushed to
serveand MCP clients (M8.2): every 1.5 seconds the open PBIP projects are scanned, and when a document's set of files changed by another program changes,dashcraft servesends adoc/externalChangednotification anddashcraft mcpanoticelog message (data.event: "doc/externalChanged") with the changed paths, empty again after a save or reload; the scan waits its turn among the document's edits, so the server's own saves are never reported. - Auto recovery in the app (M8.1): on by default, every edit of an unsaved document is kept in the per-user data folder; when DashCraft stops before a save, the next start offers Document recovery (Restore reopens the file with the edits, unsaved and undoable; Open saved opens the file as it was last saved and keeps the edits for the next start; Discard deletes them). File → Options → Auto recovery turns it off and shows the folder.
- Recovery journals, headless part (M8.1): when the host turns recovery on, every edit, undo and redo of an unsaved document is journaled in the per-user data folder (never beside the project), and a save, reload or close deletes the journal. After a crash,
doc.recovery.listshows the journals left behind,doc.recovery.restorereopens the document and replays them (unsaved; a step that no longer applies stops the replay and keeps the journal), anddoc.recovery.discarddeletes one. Nothing is restored without a request. - Semantic diff, headless part (M8.3): the registry command
doc.diffcompares a document's current revision with its files on disk (the default), with another open document (againstDocId) or with another file or folder (againstPath). It reports the objects added, removed and changed (tables, columns, measures, relationships, roles, expressions, calculation items, pages, visuals and more) by path, with the changed properties' values before and after, where each side is defined and each side's text (snippet: TMDL for model objects as DashCraft writes it, JSON for report objects; at most 200 lines). Formatting-only changes and object ids are ignored. - External changes, headless part (M8.2): the registry commands
doc.status(revision, unsaved edits, undo/redo, whetherdoc.savecan save in place, and the project files changed on disk by other programs),doc.externalChanges(the files added, changed or removed since the open or last save, whichdoc.saverefuses as a conflict withoutoverwrite) anddoc.reload(rereads the document from disk under the samedocId, dropping its undo history, loaded data and canvas state; unsaved edits need"discardChanges": true; a failed reload changes nothing; not available to agents). A reload advances the revision and sendsdoc/changedwith"reloaded": true. - Screen-reader runs in CI (A6, ADR-0030): the workflow
screen-reader.ymlbuilds the desktop app and walks the M6 editing and M7 formula bar journeys with NVDA on Windows, VoiceOver on macOS and Orca on Linux through Guidepup (scripts/app-checks/screen-reader.mjs), checking what each reader says at 32 steps. NVDA must pass every required step; VoiceOver and Orca are informational. Each run uploads what was spoken, a report per step and screenshots (docs/ci.md). dashcraft lsp(M7.6): a Language Server Protocol server on stdin/stdout, so editors such as Neovim, Helix or VS Code (through a generic LSP client extension) get DashCraft's help in.dax,.mand.tmdlfiles: diagnostics with quick fixes for "did you mean" suggestions, completion, hover, signature help, go to definition, references, highlights and semantic tokens for DAX, and formatting for all three. TMDL files are checked with the rest of theirdefinitionfolder;--model <path>(or themodelinitialization option) checks and completes DAX and M names against a model and reopens it when a file under it is saved. Setup in docs/CLI.md.- Desktop app: the formula bar has Power BI Desktop's formula editor keys (M7.5b): Tab and Shift+Tab or Ctrl+] and Ctrl+[ indent and outdent, Ctrl+M makes Tab move to the next control (and back), Shift+Enter keeps the line's indentation, Ctrl+Shift+Enter inserts a line above, Alt+↑ ↓ move lines, Shift+Alt+↑ ↓ copy them, Ctrl+Shift+K deletes them, Ctrl+L selects a line, Ctrl+X and Ctrl+C without a selection cut and copy the line, Ctrl+Shift+\ jumps to the matching bracket, Shift+Alt+→ ← widen and narrow the selection, and Ctrl+↑ ↓ and Alt+PgUp PgDn scroll. Each is one step of the editor's undo. The formula bar with its suggestion list, parameter info, descriptions and squiggles passes the automated accessibility checks (docs/accessibility/m7-formula-bar.md).
- Desktop app: IntelliSense in the formula bar (M7.5a) for measures, calculated columns and calculated tables. The DAX is coloured and problems are underlined with a wavy line (the one at the caret is read by screen readers); typing a name,
[or', or Ctrl+Space, opens a suggestion list (↑ ↓ PgUp PgDn, Enter or Tab inserts, Esc closes) with each item's description beside it;(and,, or Ctrl+Shift+Space, show the function's parameters with the current one in bold; pointing at a name, or Ctrl+K Ctrl+I, describes it; Shift+Alt+F formats the expression. It usesdax.tokens,dax.diagnostics,dax.complete,dax.signatureHelp,dax.hoveranddax.formaton the open document. The app's bundle splits its dependencies into a separate chunk. - TMDL formatter (M7.4c): the registry command
tmdl.format(andpbi_tmdl::service::format) lays a.tmdlfile out as Power BI Desktop writes it: indentation by depth (tabs, or 1 to 16 spaces),keyword: valueandname = valuespacing, blank lines before named objects and none before properties, expression blocks moved with their own indentation kept, comments and descriptions aligned, one line ending throughout. Only white space changes, and the result is read back and compared before it is returned. Files saved by Desktop and the TOM library come back unchanged, and copies with their layout damaged come back byte for byte. - TMDL completion and hover (M7.4b): the registry commands
tmdl.completeandtmdl.hover(andpbi_tmdl::service::{complete, hover}) work on half-typed TMDL. Completion offers the keywords Microsoft's TMDL reader accepts on the line (those of its object, at the database's compatibility level, without properties already set or after a child object), with:,or=to insert; the values of a property's type (true/false, enumeration names); and the tables, columns, measures, hierarchies, query groups and other objects a reference may name, across the files of the model folder. Hover describes a keyword's forms, value and level, an enumeration value, or a referenced object with its///description and where it is declared. Every keyword, value and reference in the models saved by Power BI Desktop and the TOM library is offered and hovered, and every offered keyword is accepted where it is offered. - TMDL diagnostics (M7.4a): the registry command
tmdl.diagnostics(andpbi_tmdl::service::diagnostics) checks a set of TMDL files the way Microsoft's TMDL reader loads them: unknown or misplaced keywords (with the closest keyword), wrong forms and values, keywords above the compatibility level, duplicate properties, conflicting declarations, references to missing objects across a model folder (including translations), properties after child objects, badreflines and syntax, with positions and a suggestion. The rules come from a catalog recorded from the TMDL reader (ADR-0029): 4,106 of its 4,109 keyword, form, level and value verdicts and all verdicts on 54 edited models match. New fuzz targettmdl_service. - M formatter (M7.3d): the registry command
m.format(andpbi_m::service::format) lays out an M query or section within a line width (default 100) with 4-space, other-width or tab indentation: oneletstep per line, operators leading continuation lines,else ifchains,try … otherwise/catch, and records, lists, calls, types and function bodies broken only when they do not fit. Only whitespace changes: every token and comment is kept, and the output must parse to the same tree; a syntax error is returned as a diagnostic. Formatting the 268 M expressions recorded from Power BI Desktop, at the default width and at width 20 with tabs, gives the same results as before formatting. - M hover, signature help and completion (M7.3c): the registry commands
m.hover,m.signatureHelpandm.complete(andpbi_m::service::{hover, signature_help, complete}) work on half-typed M, scoping names as Power BI Desktop binds them (steps, function parameters,each, record fields, sections,@). Hover shows a step's definition, a parameter's type, a query, parameter, function or table of the document with its description and definition, or a library function's signature, flagging names DashCraft cannot evaluate; signature help follows the active argument of library functions,#constructors, the document's function queries and functions of the text; completion offers the steps in scope, then the document's names, keywords and Desktop's library, ranked by match, with quoted#"…"names and primitive types afteras. Positions in UTF-8, UTF-16 or line and column. All 418 free names and 285 library calls of the queries of the Acme Outfitters example and the Microsoft samples resolve. - M diagnostics (M7.3b): the registry command
m.diagnostics(andpbi_m::service::diagnostics) checks an M query or section without evaluating it: syntax errors, unknown names with a "did you mean" from the document's queries, parameters and the library, wrong argument counts of library functions, and warnings for names DashCraft cannot evaluate (data access, custom connectors), with Power BI Desktop's messages. The M library gainsExpression.Evaluate. Checked against Desktop: 29 new recorded M expressions on name binding and argument counts (268, all matching apart from one by-design decimal case) and the argument-count errors of all 941 library functions (suitem-arity); no false errors on the 44 queries of the Acme Outfitters example and the Microsoft samples. - M library (M7.3, part 2): 49 table functions, checked against Power BI Desktop:
Table.Join(everyJoinKind, several key columns),NestedJoin,AddJoinColumn,Group(local grouping, comparers, typed aggregations),Pivot,Unpivot,UnpivotOtherColumns,ExpandTableColumn,ExpandRecordColumn,ExpandListColumn,AggregateTableColumn,SplitColumn(withExtraValues),CombineColumns,CombineColumnsToRecord,Transpose,Max,Min,MaxN,MinN,AddRankColumn,Schema,ColumnsOfType,FromValue,ToList,Partition,Split,SplitAt,Repeat,AlternateRows,ReverseRows,InsertRows,RemoveRows,ReplaceRows,Contains/ContainsAll/ContainsAny,PositionOf/PositionOfAny,RemoveMatchingRows,ReplaceMatchingRows,FindText,IsDistinct,MatchesAllRows/MatchesAnyRows,SingleRow,FirstValue,PrefixColumns,RemoveLastNandApproximateRowCount. DashCraft now has 514 library names (384 of Desktop's 941 functions), and all 239 recorded M expressions give Desktop's result apart from one by-design decimal case. On the way, conversion errors use Desktop's wording for lists, records, tables, functions, binaries and types, a record missing a column makes its row an error inTable.FromRecords(as in Desktop) instead of failing the table, andTable.TransformColumnTypesrejects structured types. - M library (M7.3): 69 more M functions, checked against Power BI Desktop:
Splitter.SplitTextByAnyDelimiter,ByCharacterTransition,ByLengths,ByPositions,ByRanges,ByRepeatedLengths,ByWhitespace,Text.NewGuid,Text.PositionOfAny,Number.Bitwise*,List.Median/Mode/Modes/StandardDeviation/Covariance/Product/Percentileand list editing (InsertRange,ReplaceRange,MaxN,MinN,TransformMany, …),Date.WeekOfYear/WeekOfMonth/QuarterOfYear, start and end of day, week and quarter,Date.MonthName/DayOfWeekNamein 18 languages,Date.AddWeeks/AddQuarters,Time.StartOfHour/EndOfHour,Date/Time/DateTime/DateTimeZone.ToRecord,Record.TransformFields/ReorderFields,Binary.*(text encodings, lists, ranges, splitting) andJson.FromValue, plus theJoinKind,JoinAlgorithm,JoinSide,PercentileMode,OccurrenceandBinaryOccurrenceconstants and 18 enum types. DashCraft now has 461 library names (335 of Desktop's 941 functions); 191 of 202 recorded M expressions give Desktop's result. Dates outside 0001–9999 now raise Desktop's error. - M ground truth (M7.3): Power BI Desktop's whole M standard library (1,142 names: 941 functions with their parameters and types, 69 types, 132 constants and values) is recorded from its mashup engine and shipped as a catalog (
pbi_m::service::catalog) for the coming M editor features; every M name DashCraft implements matches it. 177 M expressions (literals, operators, errors and every family of the library) are recorded from Desktop and compared value by value with DashCraft (cargo test -p pbi-m --test groundtruth): 149 give the same result, 27 use functions DashCraft does not have yet, and 1 differs by design. dax.format(M7.2): lays out a DAX expression or query: calls that fit stay on one line, longer ones put one argument per line, operator chains break before their operators,VARblocks putRETURNon its own line, queries putDEFINE,EVALUATE,ORDER BYandSTART ATon their own lines. Options for the line width (default 80), indentation (spaces or tabs) and the case of keywords and of built-in function names; comments and single blank lines are kept; names and literals keep their spelling. Formatting is idempotent and never changes meaning: the result is re-parsed and must give the same syntax tree, or the text is left as it is. Text with a syntax error comes back unchanged with the error. Checked on Power BI Desktop: the 2,902 ground-truth queries, reformatted at width 40 with tabs and lower-case keywords and functions, return the same results as the originals.dax.tokensanddax.references(M7.1): every DAX token worth highlighting with its kind (keyword, function, user-defined function, table, column, measure, variable, parameter, query parameter, string, number, date, operator, comment), declarations marked and unknown names flagged; and the symbol at a cursor with its definition (aVAR, a function parameter, a queryDEFINE) and every occurrence in the text, with the model object's id. Checked on the 2,507 queries Power BI Desktop ran without error in the ground-truth corpora: no error diagnostics and no unknown names. On the way,dax.diagnosticsno longer reports a bare[name]as an unknown measure when the text calls anINFOfunction or a user-defined function (it may be a column of that function's table), andNAMEOF's component (PARENT,SELF, …) is a keyword.dax.complete(M7.1): DAX completion at a cursor while the text is being typed: functions (with their signature), tables, columns and measures of the open document, the variables in scope, a query's ownDEFINEs and the keywords that fit there; inside[only columns and measures, inside'only tables and qualified columns, nothing in comments, strings or afterVAR. Matches are ranked exact, prefix, word start (Salfinds[Total Sales]), then contains, and what the parameter being typed takes comes first (tables inSUMX(, columns inSUM(). The result gives the range to replace and the text to insert, capped atmaxItems(default 100) with anincompleteflag.dax.signatureHelpanddax.hover(M7.1): the DAX function call around a cursor (signature, parameters, return type, the parameter being typed) and a description of the function, table, column, measure, variable or keyword under it (data type, expression, format string, the query's ownDEFINEs); both answer while the text does not parse yet. They draw on a new catalog of every DAX function DashCraft evaluates, with DashCraft-written one-line descriptions. Cursors are given as a UTF-8 or UTF-16 offset or a line and column.dax.diagnosticsreports wrong argument counts (argumentCount: "SUMtakes 1 argument but 2 were given: SUM(column)"). The counts are checked against Power BI Desktop: 929 probes recorded from Desktop 2.159 (reference/groundtruth/recordings/dax-arity.json), and DashCraft agrees on all 815 where Desktop's answer is about the argument count.dax.diagnostics(M7.1, the first DAX language-service command) checks a DAX expression or query without loading data: syntax errors, unknown tables, columns and measures with a "did you mean" suggestion, and functions DashCraft cannot evaluate yet (a warning). Positions are given as UTF-8 and UTF-16 offsets and as line and column. With adocIdthe names come from the model and the report-level measures; without one, only syntax and functions are checked. No false errors or warnings on any of the 136 DAX expressions of the Acme Outfitters example and the four committed Microsoft samples.- DAX
NAMEOF: the name of a measure, column or table as DAX text ('Sales'[Qty]), with theTABLE,COLUMN,MEASURE,FULL,SELFandPARENTcomponents and Power BI Desktop's errors; 298 → 299 functions. 17 new cases match Desktop 2.159. - M6 runtime foundation: session-owned revisioned document edits with undo/redo and dirty-state tracking, exposed through
model.setMeasureExpression, atomic groupeddoc.applyEdits, anddoc.undo/doc.redo/doc.history. Dirty documents now require explicit discard to close; conversions reject unsaved edits until writer synchronization is implemented.model.measuresnow includes stable object IDs. - M6 editing commands:
model.object.renamerenames a table, column or measure as one undoable edit. Relationships, hierarchies, sort-by columns and report fields follow, and DAX references are rewritten at token level, keeping formatting and comments. The rewrite covers measures, calculated columns and tables, calculation items, format string expressions, RLS filters and derived columns. The loaded data is kept without a refresh, anddryRunpreviews every rewrite. Also added:model.object.setDescription, plusreport.visual.moveandreport.visual.resize.doc.applyEditsgainsrenameObjectandsetVisualPositionedits. The registry grows from 47 to 56 core commands. report.visual.moveandreport.visual.resizemove and resize visual groups (M6.5): the visuals in a group go with it (offsets stored relative to the group are kept on a move and scaled on a resize unless the group scrolls), results list them asmembers, and a move then a resize of the same visual in onedoc.applyEditscompose. Power BI Desktop saves the same positions for the same edit and shows DashCraft's saved group where it belongs (GT-6).- M-aware rename (M6.7):
model.object.renamewithexpressionrenames an M query, parameter or function. Every M reference to it in table partitions and other expressions is rewritten at token level, quoted as#"…"when the new name needs it, and listed asmRewrites(also in thedryRunpreview). Partitions that read the expression and thePBI_QueryOrderannotation follow, and so does a table rename when the table is an M query. Query names are unique among expressions and M tables, ignoring case. A name M cannot follow is refused: one of the referring query's own steps, parameters or fields, or a library function. Power BI Desktop opens and refreshes the saved project to the same values (GT-6). - Renames follow into report-level measures (M6.7): the measures of a PBIR report's
reportExtensions.jsonmove with a renamed table, their DAX andreferencesare rewritten,model.dependenciesand deletes list them, a rename onto one of their names is refused, anddoc.savewrites them back (only the changed strings). Report fields whose names contain parentheses (Orders.Sales (Scaled)) now follow a table rename. Power BI Desktop loads the renamed report and computes the same card values (GT-6). - M6 measure commands:
model.measure.create,model.measure.updateandmodel.measure.delete, each one undoable edit.- Create checks that the name is unique across the model and does not clash with a column.
- Update patches only the given properties (expression, format string, display folder, description, visibility); an empty text clears one.
- Delete lists what referred to the measure first: DAX expressions, report, page and visual fields and filters.
dryRunonly lists them. - DAX that does not parse is kept, with a warning. Undo restores a deleted measure with its id, and ids are never reused.
doc.applyEditsgainscreateMeasure,updateMeasureanddeleteMeasureedits.
model.dependencieslists what refers to a table, column or measure: DAX, relationships, hierarchy levels, sort-by columns, role permissions, and report, page and visual fields and filters. The registry grows from 56 to 60 core commands.- M6 save:
doc.savewrites the edits into the PBIP project the document was opened from (ADR-0013).- Only files whose content changed are written, each atomically (temporary file, then rename). Everything else keeps its bytes: unknown properties, formatting, untouched numbers.
- A table rename moves its
.tmdlfile; renames are applied to the report JSON (fields, filters, bookmarks), and visual moves patch only thepositionnumbers. - A project file changed on disk since the open or the last save makes the save fail with the new
conflicterror code (exit code 1), listing the files;"overwrite": truesaves anyway. - The project folder must be inside a write root. PBIX, PBIT and
model.bimsources have no in-place save. The registry grows from 60 to 61 core commands.
- M6 Save As:
doc.saveAswrites the document, edits included, as a new PBIP project from any source (PBIP, PBIX, PBIT,model.bim, a semantic model folder) and moves the document there.- Later
doc.savecalls write into the new project; the document is clean and keeps its undo history and object ids. - A PBIX's imported data and a PBIP's
.pbi/cache.abfare not carried over, and a warning says so; data already loaded stays in memory. - The folder must be inside a write root and empty unless
"overwrite": true. Report changes to a legacy-layout report (report.json, a PBIXLayout) are refused. convert.pbipandconvert.pbitnow include unsaved edits (they used to refuse an edited document) and leave the document where it is.- The registry grows from 61 to 62 core commands.
- Later
- New measures get a
lineageTag(a random GUID) when the model already uses lineage tags, as Power BI Desktop does; models without any get none, so nothing is upgraded (ADR-0014). Undo, redo and saves keep the tag. The generator is injectable (SessionOptions::identifiers,SequentialIdentifiersfor reproducible tests). doc/changednotifications (ADR-0012): every committed edit, undo and redo, and a save that clears the dirty flag, announces the document, command, revision, dirty flag and the added, changed, renamed or removed objects.dashcraft servesends it as adoc/changednotification before the response (also for eachcommands.batchstep);dashcraft mcpsends it as aninfolog message (notifications/message,data.event: "doc/changed"). No-op and failed edits announce nothing.- M6 relationship commands:
model.relationship.createandmodel.relationship.delete, each one undoable edit; the engine rebuilds its relationships in the same step, so filters follow at once.- Create takes the from and to columns (names as typed, case-insensitive), cardinalities, cross-filter direction, active flag and an optional name; an unnamed relationship gets a GUID name, as in Power BI Desktop. It refuses a missing column, a relationship within one table, a second relationship on the same columns and a second active relationship between two tables, and returns the engine's warnings for the new relationship (duplicate keys on the one side).
- Delete lists the DAX that uses the relationship (
USERELATIONSHIP,CROSSFILTERnaming both columns) first;dryRunonly lists it. Undo restores a deleted relationship in place with its id, and ids are never reused. model.dependenciesaccepts relationship ids;doc.applyEditsgainscreateRelationshipanddeleteRelationshipedits. The registry grows from 62 to 64 core commands.
model.relationship.updatechanges a relationship's cardinalities, cross-filter direction, security filter direction and active flag as one undoable edit (updateRelationshipindoc.applyEdits); filters follow at once. It refuses a second active relationship between two tables (deactivate the other one in the samedoc.applyEdits) and security filtering in both directions with a one-direction cross filter, as Power BI Desktop does. Saved updates were checked in Power BI Desktop: DashCraft's values on the edited example match Desktop's on all 643 recorded cases. The registry grows from 64 to 65 core commands.- M6 delete commands for calculated columns and tables:
model.column.deleteandmodel.table.delete(deleteColumnanddeleteTableindoc.applyEdits), each one undoable edit. A deleted column or table can no longer be queried; its loaded data is set aside, so undo restores it at once without a refresh.- Refused: data columns (they come from the table's query; editable with the M queries later), the columns of a calculated table, and columns that a relationship, a hierarchy level or another column's sort order uses (change those first).
- A table goes with its relationships and the roles' row filters on it (listed as
removed). Deletes first list the DAX, model structure and report fields that refer to the object (dryRunonly lists them; what goes with a deleted table is left out) and warn about M queries that name a deleted table. - A saved delete removes the column's TMDL block, or the table's file, its
ref tableline, relationships and role filters; undoing saves the original bytes. The registry grows from 65 to 67 core commands.
model.column.create(createColumnindoc.applyEdits) adds a DAX calculated column as one undoable edit. It is computed at once over the loaded data and refreshes with the table; its data type is inferred from the values unlessdataTypeis given (required when the table has no rows loaded or every value is blank). Like Power BI Desktop, it gets a randomlineageTag, numeric columns summarize by sum and the others not. Refused: names taken by a column or measure of the table, unknown tables, DAX that does not parse or fails on a row, calculation groups. A document opened withautoRefreshloads its data before inferring. A saved column is written after the table's columns; undoing saves the original bytes. Checked in Power BI Desktop: it refreshes saved columns with the same types and summarization, and DashCraft's values on the edited example match Desktop's on all 643 recorded cases. The registry grows from 67 to 68 core commands.model.hierarchy.createandmodel.hierarchy.delete(createHierarchyanddeleteHierarchyindoc.applyEdits) add and remove user hierarchies as undoable edits. Levels name a column of the table (a level's name defaults to its column); a name taken by a column, measure or hierarchy, a missing or row-number column and a column used twice are refused. Like Power BI Desktop, the hierarchy and its levels get randomlineageTags and are saved in place, levels in order. Deletes list the report fields on the hierarchy's levels (dryRun;model.dependencieslists them too). Checked in Power BI Desktop: it opens and refreshes saved hierarchies with their levels in order, and DashCraft's values on the edited example match Desktop's on all 643 recorded cases. The registry grows from 68 to 70 core commands.model.table.create(createTableindoc.applyEdits) adds a DAX calculated table as one undoable edit. Its columns, their names and data types come from the expression's result over the loaded data (from the source columns when nothing is loaded; a refresh computes it), and it is computed at once. Like Power BI Desktop, the table and its columns get randomlineageTags, inferred names and types, the result's columns as source columns and sum for numeric columns; it is saved as a new table file and listed inmodel.tmdl. A taken name, an expression that is not a table and duplicate column names are refused. Checked in Power BI Desktop: it opens and refreshes saved calculated tables keeping every column as written (names, types, source columns, summarization), with the same rows, and DashCraft's values on the edited example match Desktop's on all 643 recorded cases. The registry grows from 70 to 71 core commands.- Edits recalculate (M6.4): an edit, undo or redo recomputes over the loaded data, in dependency order and without an M refresh, the calculated tables and columns it reaches: created or changed ones, those using a measure whose expression changed, those reading another table when relationships change, and everything downstream. Renames recompute nothing; measure results follow at once. One that can no longer be calculated (for example
RELATEDover a deactivated relationship) loses its values and reports the error until an edit or a refresh computes it again; undo computes it again. Edit results list what was recomputed (recalculated). model.column.update(updateColumnindoc.applyEdits) changes a calculated column's expression or data type, or any column's format string, display folder, description and visibility, as one undoable edit. WithoutdataTypea new expression's data type is inferred again from its values, and an automatic summarization follows a change between numeric and text. Refused: an expression or data type on a data column, an empty or unparseable expression, an expression that fails or is circular, no change. A saved update rewrites only the changed lines. The registry grows from 71 to 72 core commands.model.table.update(updateTableindoc.applyEdits) changes a calculated table's DAX expression, or any table's description and visibility, as one undoable edit. The table and what depends on it are recomputed at once. A column the new result still has (same source column, else same name) keeps its id, name and properties; its type follows the result only when it was inferred. The result's new columns are added like a created table's (inferred name and type,lineageTag, sum for numbers), and the ones it no longer returns are removed and listed. Refused: an expression on a data table, an empty, unparseable, failing or circular expression, a result that drops a column a relationship, hierarchy or sort order uses, or whose new column takes a measure's name. A saved update rewrites the partition and the changed columns only. Checked in Power BI Desktop with column and table expression updates: it keeps the saved columns as written (types, summarization, order), the values DashCraft recomputes in the session without a refresh equal Desktop's after its refresh, and all 643 recorded cases match. The registry grows from 72 to 73 core commands.- MCP agents can edit and save: the
editcategory (--allow edit) exposes every editing, undo/redo and save tool, and docs/MCP.md lists them. Saving stays confined to--write-root: a project that is only under a read root is refused (pathDenied) and nothing is written, now covered by an MCP test. - Registry property tests (
crates/pbi-ops/tests/property.rs): every command is called with parameters derived from its JSON Schema and mutated (wrong types, missing and unknown fields, out-of-range numbers, escaping paths, odd text) and must answer, with a result or a typed error, without a panic or a hang; random sequences of edits, undo and redo on the Acme example must undo back to the original document, and on loaded data must also save as PBIP, reopen with the same shape and keep every measure value.DASHCRAFT_PROPERTY_STEPSandDASHCRAFT_PROPERTY_SEEDset the length and seed; a nightly CI job runs 10,000 steps with a new seed each night (docs/ci.md). dashcraft run --save(with--doc) saves the document into its PBIP project after a successful command or a batch with no failed step, and notes the files written on stderr; a failed save (conflict,unsupportedfor a PBIX) sets the exit code (docs/CLI.md).- Desktop app editing (M6.8): the formula bar edits
Name = expressionof measures, calculated columns and calculated tables (a rename and the new DAX are one undo step), and the Properties pane edits descriptions, display folders and format strings. Save, Undo and Redo in the Quick Access Toolbar (the tooltips name the step), Ctrl/⌘+S, Ctrl/⌘+Shift+S, Ctrl/⌘+Z and Ctrl/⌘+Y, a*unsaved marker in the title, File → Save and Save as, and an Unsaved changes question before closing the document or the window or opening another file. Every edit runs throughdoc.applyEdits, which gains an optional historylabel(at most 200 characters) and awarningsresult: a measure keeps DAX that does not parse, with a warning toast. Accessibility results (A1–A5 pass, screen readers not run yet) in docs/accessibility/m6-editing.md; macOS Cmd+Q is not intercepted yet. - Power BI Desktop ground truth (ADR-0011, reference/groundtruth): 2,242 DAX queries (every Acme measure per page and filter, every table, metadata, calculation groups and RLS roles, 747
FORMATcases, everyfunctions.rscase on a generateddax-labfixture, three MIT samples) recorded from Desktop 2.159's local engine over ADOMD.NET and compared value by value bycargo test -p pbi-session --test groundtruth; differences must be listed in a deviation ledger that only shrinks (1 entry). Recorder and generators inscripts/groundtruth/,cargo xtask groundtruth [--check]for status,Session::dax_query_tablesfor typed results. - Lint rule
LINT018: a measure with bothformatStringandformatStringDefinition(Power BI Desktop refuses to load it). - M:
List.Dates,List.DateTimes,List.DateTimeZones,List.TimesandList.Durations. - DAX financial functions
PMT,PV,FVandNPER(ordinary annuities and annuities due, rounded payment types, DAX period validation, zero and tiny-rate limits, stable discounting and small growth ratios): 294 → 298 functions (FUNCTIONS.md). - App: opening a file loads what Power BI Desktop shows on open: a PBIX (or ABF, Power Pivot) its saved data, a PBIP its
.pbi/cache.abf, a PBIT a refresh with the template's saved parameter values (DocumentSummary.onOpen); before, a PBIX stayed empty until Refresh. - Command registry (
pbi-ops, ADR-0007): 47 typed commands (doc.*,security.*,model.*,report.*,data.*,dax.*,measures.values,render.*,canvas.*,export.*,convert.*,text.parsePeople) with JSON Schemas for params and output, aWorkspaceof open documents, cancellation, progress events, caller kinds and aPathPolicysandbox (read/write roots,..and symlink escapes refused). Catalog: docs/COMMANDS.md. - CLI:
pbiview commands(catalog as text, JSON, schemas or Markdown),pbiview run <id>(single command or--batchfile with${step.field}references),pbiview serve --stdio(JSON-RPC 2.0 lines,$/cancel, progress notifications,--read-root/--write-root/--agent). pbiview mcp: a Model Context Protocol server on stdio generated from the command registry (no per-tool code): agent-safe commands as tools (doc_open,measures_values, …;--tool-names dotted), JSON Schemas for inputs and outputs, hints from the command flags, PNG renders as image content, progress and cancellation,--allow/--deny, and read/write roots (default read root: the current folder; writes refused without--write-root). Protocol revisions 2024-11-05 to 2025-11-25 and stateless 2026-07-28. See docs/MCP.md.- Opt-in AI layer (
pbi-ai, ADR-0008, docs/AI.md): off by default;ai.explainMeasureandai.generateMeasure(parsed and optionally evaluated locally, never applied) through OpenAI-compatible, Azure OpenAI or Ollama providers, only after a recorded per-provider, per-capability, per-data-class consent;ai.previewshows the exact request with keys redacted; keys only in the OS keychain orDASHCRAFT_AI_API_KEY;cargo xtask layerskeeps HTTP/TLS and keychain crates insidepbi-aiand its dependents. - CLI: the
ai.*commands are available throughpbiview run,serve,mcp(agent-safe ones) andcommands;pbiview ai login --provider <id>stores a key in the OS keychain (prompted without echo, or--stdin),pbiview ai logoutdeletes it. cargo xtask perf(budgets inperf/budgets.toml, baseline inperf/baseline.json) andcargo xtask layers(crate layering and UI-toolkit containment), both in CI.- Carlito (OFL-1.1) bundled as the metric-compatible Calibri substitute.
- Calculation groups: typed
CalculationGroup/CalculationItemin the model, read and written losslessly in TMDL and TMSL; calculation-group tables load their items; measures apply the selected item (precedence, selection expressions, sideways recursion, dynamic format strings) withSELECTEDMEASURE,SELECTEDMEASURENAME,ISSELECTEDMEASUREandSELECTEDMEASUREFORMATSTRING. - Many-to-many relationships are evaluated as limited relationships (filters cross as key values in the cross-filter direction, no blank row,
RELATEDrefused);ENG003is now informational. - Row-level security "View as":
Session::set_view_as/set_effective_rolesrestrict every query to the rows of the chosen roles (DAX row filters, security-direction propagation, union over roles) and set the user forUSERPRINCIPALNAME,USERNAME,USEROBJECTIDandCUSTOMDATA. - View as roles in the desktop app (Modeling → View as: role checkboxes and Other user, a "Now viewing as" bar with Stop viewing; canvas, grid and measures re-query) and the registry commands
security.roles(roles, DAX table filters, members, dynamic) andsecurity.viewAs(apply or stop, visible rows per table; agent-safe). NOTICE: DashCraft is not affiliated with, endorsed or sponsored by Microsoft (Power BI and Microsoft are its trademarks, used only to describe file compatibility), nor with storytold/ArtCraft or other products named "DashCraft". Linked from the README, summarised in the app's About page and shipped with the app (licenses/NOTICE) and the CLI archives.- Report renderer: real
scatterChart(bubbles, legend, numeric axes; first play-axis frame),funnel(conversion-rate labels),gauge(min/max/target, default max = 2 × value),treemap(squarified, group/details) andwaterfallChart(sentiment colors, breakdown top N + Other) visuals with hit ids, replacing their placeholders;Breakdownis queried as a series and waterfalls sort by category by default (docs/VISUALS.md). - DAX function library: 218 → 294 functions: logarithms, exponentials and trigonometry (
LN,LOG,EXP,SIN…ACOTH),FACT/COMBIN/PERMUT/GCD/LCM/QUOTIENT/EVEN/ODD,MROUND/CEILING/FLOOR/ISO.CEILING, deterministicRAND/RANDBETWEEN, the bit functions,GEOMEAN(X),MAXA/MINA/AVERAGEA, theNORM/EXPON/POISSON/BETA/CHISQ/T/CONFIDENCEdistributions (own incomplete gamma/beta and inverses, ~1e-13 relative accuracy),YEARFRAC,NETWORKDAYS,IF.EAGER,ERROR,EVALUATEANDLOG,USERCULTURE,ISAFTER/ISONORAFTER;EDATEnow truncates its months andQUARTER(BLANK())is BLANK (FUNCTIONS.md). - Desktop app: the opt-in AI features (still off by default): File → Options and settings → Options → AI (turn on, providers, write-only API keys in the OS keychain, default provider, sample rows, consents with Revoke), a consent dialog that shows the exact request (
ai.preview) before anything is sent, Explain with AI for measures (Data pane, formula bar, Properties, ribbon; progress, Cancel, safely rendered Markdown) and Home/Modeling → AI → Suggest a measure (DAX with diagnostics, local evaluation, never applied);ai.statusgainssettings; the app's typed client coversai.*(generator moved topbi-ai's tests); debug builds answer from a demo provider withDASHCRAFT_AI_MOCK=1. - Report renderer: conditional formatting of tables and matrices (background and font color by gradient with 2 or 3 colors, rules with ranges, percent-of-range and blanks, or field values; data bars with negatives, axis, direction and "show bar only"; built-in icons by rules or field value, drawn as vector shapes) and of bar, column, pie, donut, treemap, scatter and funnel colors; rule inputs that are not in the visual are queried as hidden fields, unsupported variants render unformatted with a warning (docs/VISUALS.md).
- Report renderer: dynamic format strings: measures under calculation items (or with a
formatStringDefinition) format each cell with its effective format string (aYOY %item shows82.4%next to$960) in cards, tables, matrices and chart labels;pbi-daxgainsEvalContext::evaluate_measure_format_strings(one batch per measure and result set). - Installers for Windows arm64 (NSIS) and Linux arm64 (AppImage, deb, rpm), rpm packages for Linux x64, and
dashcraftCLI archives for both arm64 targets. The Release workflow can be started by hand: it releases the version inCargo.tomlor an override such as0.3.0-rc.1(a pre-release), creates the tag and the draft release, or does a dry run;scripts/set-version.shsets the version in every manifest (docs/packaging.md).
Changed
- A selection of one data point over columns of different tables (Store × Category) now filters each column by its value instead of the rows of a common fact table, which also narrowed every other dimension of that table (such as Date) and so changed measures over other facts.
pbi-model::Historystages edits before publishing them, advances a monotonic revision only when document content changes, and reports the changed flag, revision and events. Undoing back to the saved content clears the dirty state.dax.query,dax.evaluateMeasureandmeasures.valuesreportdocumentRevisioncaptured with the matching model and engine snapshot; DAX result formatting uses that captured model.- Renaming a column now also renames the default label of aggregated report fields (
Sum of Amount→Sum of Revenue), so LINT003 no longer reports it after a rename. - The source-preserving TMDL writer keeps the source's
ref table(or otherref) lines even when only one object of that kind is left; before, such a line was dropped. - The source-preserving TMDL writer keeps, in an edited file, the text of every object whose meaning is unchanged (comments, quoting, spelled-out default values such as
toCardinality: one); before, the whole file was rewritten canonically. Deleting and recreating a relationship and undoing both now saves the original bytes. - Saved TMDL takes Power BI Desktop's form (GT-4, M6 acceptance 14): Desktop's property order for columns, measures and relationships, new measures and columns after the table's last ones, and each edited file keeps its line ends (CRLF in Desktop-saved projects) and blank last line; a new file takes the project's prevailing style. After the same edits, DashCraft's save equals Power BI Desktop 2.159's byte for byte apart from new identifiers and two listed deviations (reference/groundtruth/gt4/deviations.json). The Acme Outfitters example is regenerated in that order.
model.relationshipslists each relationship'srelationshipId.- The results of
model.relationship.createandmodel.relationship.deletealso give the relationship's cardinalities, cross-filter and security filter directions and active flag. dashcraft detect,inspectandlintare thin wrappers over the registry commandsdoc.detect,doc.open+doc.inspectanddoc.lint(ADR-0007 migration plan, M6.10); their output and exit codes are unchanged. Their path must now be valid Unicode.doc.lintfindings gainobject, the offending object's id (as inmodel.dependencies), anddoc.open/doc.detectname a missing input once:cannot open <path>: no such file or directory(naming the missing project file when it is one).- M names are bound when a query is compiled, as in Power BI Desktop: a name that is not a step, parameter, query or library function fails the whole query with Desktop's message (
The name 'X' wasn't recognized. Make sure it's spelled correctly.), even in a step that is never used or insidetry; a step's own name is not in scope in its initializer (let Source = Source in …refers to another query namedSource), so recursion needs@. A misspelled library function (Table.RowCnt) is such an unknown name, while custom-connector functions and library functions DashCraft does not evaluate stay "unsupported". A call with the wrong number of arguments raises Desktop's message, which does not name the function. Renaming a query to the name of the step that references it is now allowed, since the reference still means the query. - Opening and saving a PBIP project fingerprints its files faster: the size and file-count caps are checked before any file is read, and the files are read on up to 8 threads (Acme Outfitters: 8.8 → 5.8 ms per scan).
- CI: content-addressed Rust compiler caching, faster Windows test linking, concurrent test-binary execution with doctests retained, and conservative frontend-only job selection; all three-platform Rust/app checks remain for relevant changes.
- DashCraft everywhere (ADR-0010): the
pbiviewalias binary and thePBIVIEW_*environment variables are removed (usedashcraftandDASHCRAFT_*); the CLI and app crates aredashcraft-clianddashcraft-app; developer and test variables areDASHCRAFT_REFERENCE,DASHCRAFT_BLESSandDASHCRAFT_TEST_RECORD; exported Parquet metadata keys and model annotations aredashcraft.*. - Report rendering caches each visual by a content hash (theme, frame, definition, data, selections, view state); scroll, selection and search re-render only the affected visuals. 50k-row table scroll step p95 25.6 ms → 0.75 ms; small-table scroll steps 86 ms → under 1 ms.
- Text shaping is cached per (text, family, weight, size); grid layout is memoised by content fingerprint.
- DAX engine: one-pass grouped
SUMMARIZECOLUMNSfor plain aggregations (P02 50k-row first render 13.6 s → 0.1 s) and compiled columnar row expressions forSUMX/AVERAGEX/MINX/MAXX/COUNTX/COUNTAX(P04 114 → 22 ms); indexedINfilters and relationship-index propagation speed up the general path (~10×). Differential tests compare fast and general paths on random models. - Golden-image comparison: better text line metrics raise the page SSIM, and a multi-line textbox region is back to the standard 0.85 threshold.
- The desktop app is a thin front end over the command registry: documents live in a
pbi_ops::Workspaceand every domain operation (open/close, refresh with progress and cancel, grid pages, statistics, CSV loads, derived columns, DAX queries, measures, the interactive canvas) runs through one genericops_executeIPC command →Registry::execute, the same commands asdashcraft run/serveand agents; a typed TypeScript client (app/src/lib/ops.gen.ts,npm run gen:ops) is generated from the registry's JSON Schemas and checked bycargo test. The app's duplicated canvas, grid, refresh and DTO code is gone (about 4,400 lines of app Rust, net); its "newest completed render wins" canvas ordering and legacy report themes moved intopbi_ops::canvas. New commandsreport.filtersandtext.previewPeople;data.page/dax.querygainblankAsNull,data.tablescanLoadCsv, refresh statusesoffline. File → Export now writes a PBIP project or PBIT template (convert.pbip/convert.pbit). - Renamed to DashCraft (ADR-0009). The CLI binary is
dashcraft;pbiviewstays as an alias binary (same program; help, usage and messages use the name it was invoked as). The desktop app is "DashCraft" (binarydashcraft-app, bundle identifierio.github.jxck-s.dashcraft).DASHCRAFT_APPandDASHCRAFT_BLOB_MAPreplacePBIVIEW_APPandPBIVIEW_BLOB_MAP, which still work (the new name wins).dashcraft openfindsdashcraft-app/DashCraft.app, then the old names. Release artifacts areDashCraft_<ver>_*installers anddashcraft-<tag>-<target>CLI archives (with both binaries); Linux MIME types areapplication/x-dashcraft-*. The MCP server reportsserverInfo.namedashcraftanddashcraft/…_metakeys. JSON outputs, schemas, command ids and exit codes are unchanged; crate names staypbi-*. - MCP tool hints for commands that run other commands come from a new
CommandMeta::invokes_other_commandsflag (set oncommands.batch) instead of a hard-coded id list; behaviour unchanged. - Scatter-point tooltips (
canvas.tooltip, the app) show the X and Size values around Y, after the Details and Legend values; the last user-facing "pbiview" strings say DashCraft (the hint for unsupported DAX in refresh and derived-column statuses, the derived-column description, the lint rules title, temporary-file prefixes.dashcraft-*.tmp). - Test fixtures replaced by the synthetic Acme Outfitters example (
reference/examples/acme-outfitters/, generated byscripts/examples/gen_acme.py;scripts/examples/check_acme.pychecks DashCraft against its expected values) and MIT-licensed Microsoft sample reports (reference/samples/microsoft/; larger ones throughscripts/fetch-samples.sh). Rendering is checked byinstarender snapshots of every Acme page and the 39 card values of itsexpected.jsonon rendered pages; the golden-image test compares a page only when an optional localreference/golden/<example>/<report>/<page>.pngexists (SSIM ≥ 0.85, no exceptions). - Perf scenarios P03, P06 and P08 run on the Acme Outfitters example and the Microsoft samples.
- Perf scenarios for editing (M6), run through
Registry::executelike the app (crates/pbi-ops/examples/perf_ops.rs): P09 edits a measure and re-renders the Executive Summary page, P10 makes one edit and saves the PBIP, and P11 opens the Acme example, refreshes it from its CSVs and renders the first page in a fresh process. - The desktop app's bundle identifier is
io.github.jxck-s.dashcraft. .gitignorerefuses*.pbix,*.pbitand*.abffiles except the committed Microsoft samples and fuzz seeds.
Fixed
- Desktop app: screen readers announce "Files changed on disk" reliably; the status bar now says it just after the notification bar appears instead of in the same frame, where NVDA sometimes dropped it.
- M evaluator: a value that contains its own lazy slot (
let r = [a = @r] in r,let r = {@r} in r, a shared query that refers to itself inside a record or list, or one that returns#shared) is now freed when the evaluation ends; such values leaked memory. Found by the nightlym_evalfuzz target. - Desktop app, found by the screen-reader runs: pressing Esc in the formula bar after an edit now clears the cancelled formula's problems, which were still underlined and announced; Tab and Shift+Tab stay inside the File backstage, and Esc closes it and returns focus to File; Option+Q (Desktop's Alt+Q) moves to the formula bar on macOS, where Option types a character; and Ctrl+K Ctrl+I works when Ctrl is released between the keys, and announces the description it shows.
- TMDL writer: a table with a second
calculationGroupspelled in another case (calculationgroup), which is kept as an untyped property, is written after the calculation group again; it was written first, so reading the saved file back took it as the calculation group. Found by thetmdlfuzz target. - M numbers as text follow Power BI Desktop (found by the M ground truth):
Text.From,Number.ToTextand error messages give 15 significant digits, or 17 when 15 do not give the number back (0.1 + 0.2is0.30000000000000004), large numbers are written out in full up to 7.9e28 (1e21is1000000000000000000000) and small ones in Desktop's exponent form (1.5E-05); theE,F,N,Pand custom formats round from 15 significant digits (Number.ToText(2.675, "F2")is2.68),Eshows a signed three-digit exponent, andDrefuses a fraction. - M rounding follows Power BI Desktop:
Number.Roundrounds in decimal (Number.Round(2.345, 2)is2.34,Number.RoundDown(0.29, 2)is0.29),RoundingModeonly decides ties, andNumber.RoundUp,RoundDown,RoundAwayFromZeroandRoundTowardZeroalways round in their direction (Number.RoundAwayFromZero(-1.2)is-2). - M conformance with Power BI Desktop: error records (
Error.Record,error [...]) fillMessage.Format's#{n}placeholders fromMessage.Parametersand keepErrorCodeand the other fields throughtry;Splitter.SplitTextByDelimitertreats quotes as CSV by default and takescsvStyle, andSplitter.SplitTextByAnyDelimitertakesstartAtEnd;#datetimezone's offset adds its hours and minutes (-3, 30is-02:30); single-character text ranges ({"a".."c"}) work;Logical.ToText's parameter is named as in Desktop;Number.MaxValueandNumber.MinValue, which Desktop does not have, are gone. - Renames rewrite the DAX of KPIs (target, status and trend expressions) and detail rows (a measure's
detailRowsDefinitionand a table'sdefaultDetailRowsDefinition), andmodel.dependenciesand deletes list the measures whose KPI or detail rows use an object; renaming a measure or column left them pointing at the old name. The TMDL writer saves KPIs, detail rows and dynamic format strings in Power BI Desktop's form (each after a blank line, KPI properties in Desktop's order, multi-line KPI expressions one level below their property), also when converting from TMSL, where a KPI and detail rows were written as JSON text. - Canvas selections follow model renames: a selected data point (cross-filter) or a slicer's range or text condition that names a renamed table, column or measure keeps filtering after the rename, its undo and its redo, instead of being dropped with a "cross-filter not applied" warning;
canvas.resetrestores the saved selections under the new names, and a click on a render made before the rename still toggles the selection. - Calculation items without an
ordinal(as Power BI Desktop saves them) are numbered by position, as Desktop does; theirOrdinalcolumn was -1. model.column.createmarks a data type it inferred withisDataTypeInferred, asmodel.table.createalready did; the saved column read as explicitly typed.- Queries never mix two revisions (M6 acceptance 8): with "View as" active, a query running between an edit, undo or redo and the rebuild of the restricted engine read the new model over the previous revision's rows; the rebuilt engine is now published with the edit. Canvas renders and
render.pageread the report, the page and the data from one revision (Session::revision_snapshot), andcanvas.*results report it asdocumentRevision. - A calculated column or table whose expression names itself (
T[C] + 1in column C,ADDCOLUMNS(T, …)in table T, also through a measure) is a circular dependency: an edit introducing it is refused and a refresh reports it. Before, the dependency planner ignored the self-reference. Bare[Column]references in a calculated table's expression (ADDCOLUMNS(CALENDAR(…), "Year", YEAR([Date]))) still name the columns it iterates. - Save: renaming a table, column or measure that a visual uses and then deleting it no longer makes
doc.saveanddoc.saveAsrefuse with "visual … has changes DashCraft cannot write yet"; the report keeps the new name, as in Power BI Desktop. Found by the registry property tests. - Field parameters: the group-by columns of a column (
relatedColumnDetails, e.g. a field parameter's display column grouped byParameter Fields) are read from PBIX/PBIT metadata, TMDL and TMSL and written to TMDL and TMSL in each format's shape; aggregating such a column alone (DISTINCTCOUNT,MIN,SUM, …) gives Desktop's "part of composite key" error (ground-truth ledger 2 → 1 entry). - DAX context semantics now match Desktop (ground-truth ledger 6 → 2 entries): every iteration starts a new
ALLSELECTEDshadow context (the filters at its start plus the iterated table), soALLSELECTEDinsideSUMX/FILTER/ADDCOLUMNSand the implied relation ofOFFSET/WINDOWgive Desktop's values, and the table formALLSELECTED(T[c])keeps only the shadow's filters onc;KEEPFILTERSaround an iterator's table makes context transition intersect with the existing filters and is an error elsewhere;IGNOREoutside aSUMMARIZECOLUMNSexpression is an error, andSUMMARIZECOLUMNSwith only ignored expressions keeps every combination;CROSSFILTERrefuses a one-way direction from the many side to the one side. - DAX semantics found by the Desktop ground truth:
AND/ORof two BLANKs is FALSE;MIN/MAXwith a BLANK argument;STDEV.S/VAR.Sand their X forms give NaN for one value;MEDIANover dates is an error;EDATErounds its months;REPTwith 0;DISTINCTCOUNTandCOUNTBLANKdo not count the relationship blank row;PERCENTILEX.*count a BLANK result as 0;NETWORKDAYSreads a text weekend as a number;OFFSETwithout a current row;FORMAT(many standard and custom number and date rules, out-of-range dates are errors); case variants of a text value in a computed column take the first spelling (FUNCTIONS.md). - Engine: a table gets its blank row when any relationship, active or inactive, has unmatched rows (BLANK ship dates now show as "(Blank)" on the Acme Year slicer and ship-month chart, as in Desktop); relationships between a Text and a Number key column join
"155"to155. - PBIT export: Power BI Desktop opens the templates DashCraft writes (the
Settingspart no longer has aQueriesSettingswithoutVersion, and hierarchy levels get explicit ordinals); Desktop computes the same values from DashCraft's PBIP (643 of 643 recorded queries) and PBIT (642 of 643; Desktop resets one custom date format on template import). - Acme Outfitters example: measures with a dynamic format string no longer also carry a static
formatString, and theProducts Never Soldtable no longer names a variableCatalog; both made Desktop refuse to load the model. - Dependencies: rusqlite 0.41.1 and libsqlite3-sys 0.39.1; synthetic SQLite fixture builders use the new mutable serialization API, fixing their compilation.
- Dependencies: resvg and usvg 0.49.0 pick up upstream clipping and text-layout fixes; bundled-font and offline image-loading policies are unchanged.
- Dependencies: roxmltree 0.21.2 avoids stack overflow on deeply nested XML; ZIP 9.2.2 and the Tauri dialog plugin 2.8.4 pick up upstream maintenance fixes.
- Dependencies: Arrow and Parquet 59.3.2 maintenance fixes for IPC validity buffers, array offsets and Parquet decoding; DataFusion remains on 55.2.
- CI: replace the yanked transitive
async-executor1.14.0 with 1.14.1; the session unsupported-DAX regression uses a deliberately unknown function now thatPMTis supported. - Skipped entries of a folder (symlinks, ignored and unreadable files) are listed in path order on every OS, like the other entries.
- TMDL ↔ TMSL conversion keeps dynamic format strings: the
formatStringDefinitionobject form is converted in both directions. - One-to-one relationships relate each side's unmatched rows to the other table's blank row.
- The people transform ("Parse people field",
text.parsePeople) accepts plain lists of names as well as lists of person records. kpivisuals use theTrendLinefield as the trend axis (indicator and goal at its last point).- Matrix row and column levels follow each column's sort-by column.
Documentation
- M6.1 decisions: revisioned document state and transactions (ADR-0012), save conflicts and recovery (ADR-0013), serialization and generated identifiers (ADR-0014), and accessibility verification (ADR-0015). Corrected the Desktop plan's provisional ADR numbering to preserve the accepted naming and ground-truth records.
- ADR-0011 (ground-truth recordings from Power BI Desktop) and reference/groundtruth/README.md (recording, the ledger, writer checks, manual visual-query and golden-image steps); AGENTS.md: ground-truth commands, test kind and definition-of-done item; docs/GAPS.md DAX 3.3 → 3.8 (differential testing 0 → 4,
FORMAT3 → 4). - DashCraft is open source under the MIT License or the Apache License 2.0, at your option (
LICENSE-MIT,LICENSE-APACHE,Cargo.toml, NOTICE, installed with the app aslicenses/LICENSE-MITandlicenses/LICENSE-APACHE); the repository isgithub.com/Jxck-S/dashcraft. - docs/DESKTOP-PLAN.md: the milestone plan from the current viewer to a full Power BI Desktop equivalent (M6 to M31, M27 to M30 optional) with steps, registry commands, acceptance criteria, tests, dependencies, blockers, sizes, a dependency graph and 18 proposed ADRs (ADR-0010 to ADR-0027); docs/ROADMAP.md "Next" maps each item to a plan step. README rewritten for the current state (no emoji); command, M library, DAX and performance numbers synced across the docs.
- Test fixtures and doc examples use the synthetic Acme Outfitters example (
reference/examples/acme-outfitters/: PBIP, CSV data, blob map, expected values) and MIT-licensed Microsoft sample reports (reference/samples/microsoft/; larger ones throughscripts/fetch-samples.sh); AGENTS.md gains the rule that real or internal reports and data are never committed or described. - docs/VISUALS.md, README, AGENTS.md and
reference/README.mddescribe render verification (render snapshots, expected values, Microsoft samples, optional local goldens); docs/GAPS.md re-scored without golden images (visuals 2.4 → 2.1, rendering fidelity 3.4 → 3.2). - AGENTS.md is the canonical contributor and AI-agent guide (golden rules, parallel-agent protocol, validation, definition of done, naming and trademark policy), with a gaps scorecard (docs/GAPS.md) and a dev log (docs/DEVLOG.md);
.github/copilot-instructions.mdnow points to it. - Docs synced with the code: v0.2.0 is released and packaging done; golden SSIM results; M library counts;
pbi-ops,pbi-aiand ADR-0007 to ADR-0009 in the README and the crate graphs (the app now depends onpbi-ops, not onpbi-render/pbi-engine); ADR-0007 status (MCP done, workspace dependency); the generated command catalog links docs/MCP.md;inspect_model.rspaths; macOS Finder opens are wired; docs/GAPS.md re-scored (MCP, app on the registry, AI layer, P02/P04, one-pass group-by).
Downloads: macOS .dmg (arm64 and x64), Windows x64 .msi / -setup.exe and arm64 -setup.exe, Linux x64 and arm64 .AppImage / .deb / .rpm, and the dashcraft CLI as .tar.gz / .zip per platform. Every file has a .sha256; SHA256SUMS.txt lists them all. SBOMs (CycloneDX) are in dashcraft-*-sbom.zip; licenses in THIRD_PARTY_NOTICES.md and THIRD_PARTY_LICENSES.txt; trademark and non-affiliation notice in NOTICE.
- macOS builds are not notarized: on first launch, allow it under System Settings → Privacy & Security → Open Anyway, or run
xattr -dr com.apple.quarantine /Applications/DashCraft.app. - Windows installers are unsigned: SmartScreen shows "Windows protected your PC" → More info → Run anyway.