Skip to content

DashCraft v0.3.0

Latest

Choose a tag to compare

@github-actions github-actions released this 12 Nov 20:48
· 3 commits to main since this release
993475e

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.persist writes 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 and render.* (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.contextMenu and export.visualData; bookmarks in focus mode now apply it.
  • Range and relative-date slicers are interactive (M9.7): canvas.setRange and canvas.setRelativeDate, slider and picker controls in canvas.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.drillthrough targetReport, useCrossReportDrillthrough and referenceScope: 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 activeProjections and 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.drill command.
  • Report-page tooltips (M9.3): canvas.tooltipPage renders the tooltip page of a hovered data point (the visual's visualTooltip page, 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.json tooltipPages); perf scenario P13 tooltip-page-render.
  • Drillthrough (M9.4): canvas.drillthroughTargets lists the drillthrough pages of a data point and canvas.drillthrough filters 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 highlights carry 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 orderBy replaces 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 new report.bookmarks lists them and canvas.applyBookmark applies one. Bookmark buttons on the canvas now work in the app and through canvas.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 in expected.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.diff and Compare as their PBIR files (M8.3): a changed, added or removed page, visual or report shows its page.json, visual.json or report.json as a save would write it, unsaved edits included, instead of the JSON of its properties (legacy layouts keep the properties).
  • External changes pushed to serve and 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 serve sends a doc/externalChanged notification and dashcraft mcp a notice log 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.list shows the journals left behind, doc.recovery.restore reopens the document and replays them (unsaved; a step that no longer applies stops the replay and keeps the journal), and doc.recovery.discard deletes one. Nothing is restored without a request.
  • Semantic diff, headless part (M8.3): the registry command doc.diff compares 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, whether doc.save can 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, which doc.save refuses as a conflict without overwrite) and doc.reload (rereads the document from disk under the same docId, 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 sends doc/changed with "reloaded": true.
  • Screen-reader runs in CI (A6, ADR-0030): the workflow screen-reader.yml builds 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, .m and .tmdl files: 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 their definition folder; --model <path> (or the model initialization 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 uses dax.tokens, dax.diagnostics, dax.complete, dax.signatureHelp, dax.hover and dax.format on the open document. The app's bundle splits its dependencies into a separate chunk.
  • TMDL formatter (M7.4c): the registry command tmdl.format (and pbi_tmdl::service::format) lays a .tmdl file out as Power BI Desktop writes it: indentation by depth (tabs, or 1 to 16 spaces), keyword: value and name = value spacing, 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.complete and tmdl.hover (and pbi_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 (and pbi_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, bad ref lines 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 target tmdl_service.
  • M formatter (M7.3d): the registry command m.format (and pbi_m::service::format) lays out an M query or section within a line width (default 100) with 4-space, other-width or tab indentation: one let step per line, operators leading continuation lines, else if chains, 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.signatureHelp and m.complete (and pbi_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 after as. 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 (and pbi_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 gains Expression.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 (suite m-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 (every JoinKind, several key columns), NestedJoin, AddJoinColumn, Group (local grouping, comparers, typed aggregations), Pivot, Unpivot, UnpivotOtherColumns, ExpandTableColumn, ExpandRecordColumn, ExpandListColumn, AggregateTableColumn, SplitColumn (with ExtraValues), 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, RemoveLastN and ApproximateRowCount. 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 in Table.FromRecords (as in Desktop) instead of failing the table, and Table.TransformColumnTypes rejects 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/Percentile and list editing (InsertRange, ReplaceRange, MaxN, MinN, TransformMany, …), Date.WeekOfYear/WeekOfMonth/QuarterOfYear, start and end of day, week and quarter, Date.MonthName/DayOfWeekName in 18 languages, Date.AddWeeks/AddQuarters, Time.StartOfHour/EndOfHour, Date/Time/DateTime/DateTimeZone.ToRecord, Record.TransformFields/ReorderFields, Binary.* (text encodings, lists, ranges, splitting) and Json.FromValue, plus the JoinKind, JoinAlgorithm, JoinSide, PercentileMode, Occurrence and BinaryOccurrence constants 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, VAR blocks put RETURN on its own line, queries put DEFINE, EVALUATE, ORDER BY and START AT on 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.tokens and dax.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 (a VAR, a function parameter, a query DEFINE) 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.diagnostics no longer reports a bare [name] as an unknown measure when the text calls an INFO function or a user-defined function (it may be a column of that function's table), and NAMEOF'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 own DEFINEs and the keywords that fit there; inside [ only columns and measures, inside ' only tables and qualified columns, nothing in comments, strings or after VAR. Matches are ranked exact, prefix, word start (Sal finds [Total Sales]), then contains, and what the parameter being typed takes comes first (tables in SUMX(, columns in SUM(). The result gives the range to replace and the text to insert, capped at maxItems (default 100) with an incomplete flag.
  • dax.signatureHelp and dax.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 own DEFINEs); 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.diagnostics reports wrong argument counts (argumentCount: "SUM takes 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 a docId the 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 the TABLE, COLUMN, MEASURE, FULL, SELF and PARENT components 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 grouped doc.applyEdits, and doc.undo/doc.redo/doc.history. Dirty documents now require explicit discard to close; conversions reject unsaved edits until writer synchronization is implemented. model.measures now includes stable object IDs.
  • M6 editing commands: model.object.rename renames 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, and dryRun previews every rewrite. Also added: model.object.setDescription, plus report.visual.move and report.visual.resize. doc.applyEdits gains renameObject and setVisualPosition edits. The registry grows from 47 to 56 core commands.
  • report.visual.move and report.visual.resize move 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 as members, and a move then a resize of the same visual in one doc.applyEdits compose. 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.rename with expression renames 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 as mRewrites (also in the dryRun preview). Partitions that read the expression and the PBI_QueryOrder annotation 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.json move with a renamed table, their DAX and references are rewritten, model.dependencies and deletes list them, a rename onto one of their names is refused, and doc.save writes 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.update and model.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. dryRun only 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.applyEdits gains createMeasure, updateMeasure and deleteMeasure edits.
  • model.dependencies lists 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.save writes 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 .tmdl file; renames are applied to the report JSON (fields, filters, bookmarks), and visual moves patch only the position numbers.
    • A project file changed on disk since the open or the last save makes the save fail with the new conflict error code (exit code 1), listing the files; "overwrite": true saves anyway.
    • The project folder must be inside a write root. PBIX, PBIT and model.bim sources have no in-place save. The registry grows from 60 to 61 core commands.
  • M6 Save As: doc.saveAs writes 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.save calls 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.abf are 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 PBIX Layout) are refused.
    • convert.pbip and convert.pbit now 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.
  • 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, SequentialIdentifiers for reproducible tests).
  • doc/changed notifications (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 serve sends it as a doc/changed notification before the response (also for each commands.batch step); dashcraft mcp sends it as an info log message (notifications/message, data.event: "doc/changed"). No-op and failed edits announce nothing.
  • M6 relationship commands: model.relationship.create and model.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, CROSSFILTER naming both columns) first; dryRun only lists it. Undo restores a deleted relationship in place with its id, and ids are never reused.
    • model.dependencies accepts relationship ids; doc.applyEdits gains createRelationship and deleteRelationship edits. The registry grows from 62 to 64 core commands.
  • model.relationship.update changes a relationship's cardinalities, cross-filter direction, security filter direction and active flag as one undoable edit (updateRelationship in doc.applyEdits); filters follow at once. It refuses a second active relationship between two tables (deactivate the other one in the same doc.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.delete and model.table.delete (deleteColumn and deleteTable in doc.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 (dryRun only 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 table line, relationships and role filters; undoing saves the original bytes. The registry grows from 65 to 67 core commands.
  • model.column.create (createColumn in doc.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 unless dataType is given (required when the table has no rows loaded or every value is blank). Like Power BI Desktop, it gets a random lineageTag, 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 with autoRefresh loads 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.create and model.hierarchy.delete (createHierarchy and deleteHierarchy in doc.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 random lineageTags and are saved in place, levels in order. Deletes list the report fields on the hierarchy's levels (dryRun; model.dependencies lists 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 (createTable in doc.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 random lineageTags, 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 in model.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 RELATED over 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 (updateColumn in doc.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. Without dataType a 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 (updateTable in doc.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 edit category (--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_STEPS and DASHCRAFT_PROPERTY_SEED set 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, unsupported for a PBIX) sets the exit code (docs/CLI.md).
  • Desktop app editing (M6.8): the formula bar edits Name = expression of 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 through doc.applyEdits, which gains an optional history label (at most 200 characters) and a warnings result: 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 FORMAT cases, every functions.rs case on a generated dax-lab fixture, three MIT samples) recorded from Desktop 2.159's local engine over ADOMD.NET and compared value by value by cargo test -p pbi-session --test groundtruth; differences must be listed in a deviation ledger that only shrinks (1 entry). Recorder and generators in scripts/groundtruth/, cargo xtask groundtruth [--check] for status, Session::dax_query_tables for typed results.
  • Lint rule LINT018: a measure with both formatString and formatStringDefinition (Power BI Desktop refuses to load it).
  • M: List.Dates, List.DateTimes, List.DateTimeZones, List.Times and List.Durations.
  • DAX financial functions PMT, PV, FV and NPER (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, a Workspace of open documents, cancellation, progress events, caller kinds and a PathPolicy sandbox (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 --batch file 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.explainMeasure and ai.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.preview shows the exact request with keys redacted; keys only in the OS keychain or DASHCRAFT_AI_API_KEY; cargo xtask layers keeps HTTP/TLS and keychain crates inside pbi-ai and its dependents.
  • CLI: the ai.* commands are available through pbiview run, serve, mcp (agent-safe ones) and commands; pbiview ai login --provider <id> stores a key in the OS keychain (prompted without echo, or --stdin), pbiview ai logout deletes it.
  • cargo xtask perf (budgets in perf/budgets.toml, baseline in perf/baseline.json) and cargo 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/CalculationItem in 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) with SELECTEDMEASURE, SELECTEDMEASURENAME, ISSELECTEDMEASURE and SELECTEDMEASUREFORMATSTRING.
  • Many-to-many relationships are evaluated as limited relationships (filters cross as key values in the cross-filter direction, no blank row, RELATED refused); ENG003 is now informational.
  • Row-level security "View as": Session::set_view_as / set_effective_roles restrict every query to the rows of the chosen roles (DAX row filters, security-direction propagation, union over roles) and set the user for USERPRINCIPALNAME, USERNAME, USEROBJECTID and CUSTOMDATA.
  • 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) and security.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) and waterfallChart (sentiment colors, breakdown top N + Other) visuals with hit ids, replacing their placeholders; Breakdown is 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, deterministic RAND/RANDBETWEEN, the bit functions, GEOMEAN(X), MAXA/MINA/AVERAGEA, the NORM/EXPON/POISSON/BETA/CHISQ/T/CONFIDENCE distributions (own incomplete gamma/beta and inverses, ~1e-13 relative accuracy), YEARFRAC, NETWORKDAYS, IF.EAGER, ERROR, EVALUATEANDLOG, USERCULTURE, ISAFTER/ISONORAFTER; EDATE now truncates its months and QUARTER(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.status gains settings; the app's typed client covers ai.* (generator moved to pbi-ai's tests); debug builds answer from a demo provider with DASHCRAFT_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 (a YOY % item shows 82.4% next to $960) in cards, tables, matrices and chart labels; pbi-dax gains EvalContext::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 dashcraft CLI archives for both arm64 targets. The Release workflow can be started by hand: it releases the version in Cargo.toml or an override such as 0.3.0-rc.1 (a pre-release), creates the tag and the draft release, or does a dry run; scripts/set-version.sh sets 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::History stages 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.evaluateMeasure and measures.values report documentRevision captured 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 other ref) 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.relationships lists each relationship's relationshipId.
  • The results of model.relationship.create and model.relationship.delete also give the relationship's cardinalities, cross-filter and security filter directions and active flag.
  • dashcraft detect, inspect and lint are thin wrappers over the registry commands doc.detect, doc.open + doc.inspect and doc.lint (ADR-0007 migration plan, M6.10); their output and exit codes are unchanged. Their path must now be valid Unicode. doc.lint findings gain object, the offending object's id (as in model.dependencies), and doc.open/doc.detect name 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 inside try; a step's own name is not in scope in its initializer (let Source = Source in … refers to another query named Source), 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 pbiview alias binary and the PBIVIEW_* environment variables are removed (use dashcraft and DASHCRAFT_*); the CLI and app crates are dashcraft-cli and dashcraft-app; developer and test variables are DASHCRAFT_REFERENCE, DASHCRAFT_BLESS and DASHCRAFT_TEST_RECORD; exported Parquet metadata keys and model annotations are dashcraft.*.
  • 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 SUMMARIZECOLUMNS for plain aggregations (P02 50k-row first render 13.6 s → 0.1 s) and compiled columnar row expressions for SUMX/AVERAGEX/MINX/MAXX/COUNTX/COUNTAX (P04 114 → 22 ms); indexed IN filters 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::Workspace and 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 generic ops_execute IPC command → Registry::execute, the same commands as dashcraft run/serve and 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 by cargo 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 into pbi_ops::canvas. New commands report.filters and text.previewPeople; data.page/dax.query gain blankAsNull, data.tables canLoadCsv, refresh statuses offline. File → Export now writes a PBIP project or PBIT template (convert.pbip/convert.pbit).
  • Renamed to DashCraft (ADR-0009). The CLI binary is dashcraft; pbiview stays as an alias binary (same program; help, usage and messages use the name it was invoked as). The desktop app is "DashCraft" (binary dashcraft-app, bundle identifier io.github.jxck-s.dashcraft). DASHCRAFT_APP and DASHCRAFT_BLOB_MAP replace PBIVIEW_APP and PBIVIEW_BLOB_MAP, which still work (the new name wins). dashcraft open finds dashcraft-app / DashCraft.app, then the old names. Release artifacts are DashCraft_<ver>_* installers and dashcraft-<tag>-<target> CLI archives (with both binaries); Linux MIME types are application/x-dashcraft-*. The MCP server reports serverInfo.name dashcraft and dashcraft/… _meta keys. JSON outputs, schemas, command ids and exit codes are unchanged; crate names stay pbi-*.
  • MCP tool hints for commands that run other commands come from a new CommandMeta::invokes_other_commands flag (set on commands.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 by scripts/examples/gen_acme.py; scripts/examples/check_acme.py checks DashCraft against its expected values) and MIT-licensed Microsoft sample reports (reference/samples/microsoft/; larger ones through scripts/fetch-samples.sh). Rendering is checked by insta render snapshots of every Acme page and the 39 card values of its expected.json on rendered pages; the golden-image test compares a page only when an optional local reference/golden/<example>/<report>/<page>.png exists (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::execute like 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.
  • .gitignore refuses *.pbix, *.pbit and *.abf files 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 nightly m_eval fuzz 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 calculationGroup spelled 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 the tmdl fuzz target.
  • M numbers as text follow Power BI Desktop (found by the M ground truth): Text.From, Number.ToText and error messages give 15 significant digits, or 17 when 15 do not give the number back (0.1 + 0.2 is 0.30000000000000004), large numbers are written out in full up to 7.9e28 (1e21 is 1000000000000000000000) and small ones in Desktop's exponent form (1.5E-05); the E, F, N, P and custom formats round from 15 significant digits (Number.ToText(2.675, "F2") is 2.68), E shows a signed three-digit exponent, and D refuses a fraction.
  • M rounding follows Power BI Desktop: Number.Round rounds in decimal (Number.Round(2.345, 2) is 2.34, Number.RoundDown(0.29, 2) is 0.29), RoundingMode only decides ties, and Number.RoundUp, RoundDown, RoundAwayFromZero and RoundTowardZero always round in their direction (Number.RoundAwayFromZero(-1.2) is -2).
  • M conformance with Power BI Desktop: error records (Error.Record, error [...]) fill Message.Format's #{n} placeholders from Message.Parameters and keep ErrorCode and the other fields through try; Splitter.SplitTextByDelimiter treats quotes as CSV by default and takes csvStyle, and Splitter.SplitTextByAnyDelimiter takes startAtEnd; #datetimezone's offset adds its hours and minutes (-3, 30 is -02:30); single-character text ranges ({"a".."c"}) work; Logical.ToText's parameter is named as in Desktop; Number.MaxValue and Number.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 detailRowsDefinition and a table's defaultDetailRowsDefinition), and model.dependencies and 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.reset restores 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; their Ordinal column was -1.
  • model.column.create marks a data type it inferred with isDataTypeInferred, as model.table.create already 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.page read the report, the page and the data from one revision (Session::revision_snapshot), and canvas.* results report it as documentRevision.
  • A calculated column or table whose expression names itself (T[C] + 1 in 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.save and doc.saveAs refuse 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 by Parameter 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 ALLSELECTED shadow context (the filters at its start plus the iterated table), so ALLSELECTED inside SUMX/FILTER/ADDCOLUMNS and the implied relation of OFFSET/WINDOW give Desktop's values, and the table form ALLSELECTED(T[c]) keeps only the shadow's filters on c; KEEPFILTERS around an iterator's table makes context transition intersect with the existing filters and is an error elsewhere; IGNORE outside a SUMMARIZECOLUMNS expression is an error, and SUMMARIZECOLUMNS with only ignored expressions keeps every combination; CROSSFILTER refuses a one-way direction from the many side to the one side.
  • DAX semantics found by the Desktop ground truth: AND/OR of two BLANKs is FALSE; MIN/MAX with a BLANK argument; STDEV.S/VAR.S and their X forms give NaN for one value; MEDIAN over dates is an error; EDATE rounds its months; REPT with 0; DISTINCTCOUNT and COUNTBLANK do not count the relationship blank row; PERCENTILEX.* count a BLANK result as 0; NETWORKDAYS reads a text weekend as a number; OFFSET without 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" to 155.
  • PBIT export: Power BI Desktop opens the templates DashCraft writes (the Settings part no longer has a QueriesSettings without Version, 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 the Products Never Sold table no longer names a variable Catalog; 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-executor 1.14.0 with 1.14.1; the session unsupported-DAX regression uses a deliberately unknown function now that PMT is 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 formatStringDefinition object 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.
  • kpi visuals use the TrendLine field 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, FORMAT 3 → 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 as licenses/LICENSE-MIT and licenses/LICENSE-APACHE); the repository is github.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 through scripts/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.md describe 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.md now 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-ai and ADR-0007 to ADR-0009 in the README and the crate graphs (the app now depends on pbi-ops, not on pbi-render/pbi-engine); ADR-0007 status (MCP done, workspace dependency); the generated command catalog links docs/MCP.md; inspect_model.rs paths; 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.