@svgrid/enterprise 3.0.1 → 3.0.3

package/dist/node/studio.js

@@ -8511,6 +8511,7 @@ var GENERATED_UI_SURFACE = {
 				"key": "data",
 				"label": "Data",
 				"type": "json",
+				"description": "The rows to render. Optional only because `rowModel` can supply them instead; a grid with neither renders empty. When both are present `data` wins.",
 				"group": "common"
 			},
 			{
@@ -8533,6 +8534,13 @@ var GENERATED_UI_SURFACE = {
 				"description": "Scheduler / calendar mode. When set, the grid renders its rows as events on a Month / Week / Day / Agenda calendar instead of a table. See .",
 				"group": "common"
 			},
+			{
+				"key": "gantt",
+				"label": "Gantt",
+				"type": "json",
+				"description": "Gantt mode. When set, the grid renders its rows as a task table beside a time chart: one bar per row by start / end, a work-breakdown tree from `parentField`, and dependency arrows. See . A view of the grid like the board and scheduler; the renderer ships in `@svgrid/enterprise` (call `enableGanttView()`).",
+				"group": "common"
+			},
 			{
 				"key": "chart",
 				"label": "Chart",
@@ -8949,11 +8957,42 @@ var GENERATED_UI_SURFACE = {
 				"description": "Prepend a header row (the column labels) to copied cell ranges, so pasting into Excel / Sheets includes the headers. Applies per copied range.",
 				"group": "common"
 			},
+			{
+				"key": "processCellForFill",
+				"label": "Process Cell For Fill",
+				"type": "json",
+				"description": "Decide what the fill handle writes into one cell, ahead of the grid's own pattern rules (series, weekdays, \"Item 1\"). Receives the source cell's value and how far the target sits from it; return the value to write, or `undefined` to let the pattern decide. A spreadsheet uses it to move a formula's references by the distance filled, which the pattern rules would otherwise mangle (\"=A1+B1\" reads as \"Item 1\").",
+				"code": true,
+				"group": "advanced"
+			},
 			{
 				"key": "processCellForClipboard",
 				"label": "Process Cell For Clipboard",
 				"type": "json",
-				"description": "Transform each cell value on its way to the clipboard - e.g. strip currency symbols, expand codes to labels, or redact. Receives the display value plus the row/column context; return the string (or value) to copy.",
+				"code": true,
+				"group": "advanced"
+			},
+			{
+				"key": "includeCollapsedRows",
+				"label": "Include Collapsed Rows",
+				"type": "json",
+				"description": "Whether a collapsed row still takes part in a copy or a fill that spans it. Left out, both skip every collapsed row, which is what \"filter, copy, paste\" needs and what a fill dragged over a filtered list expects: the series runs over the rows that show. A spreadsheet answers per row: a row hidden by hand is copied and filled, as Excel does, while a row a filter folded away is not.",
+				"code": true,
+				"group": "advanced"
+			},
+			{
+				"key": "clipboardHtml",
+				"label": "Clipboard Html",
+				"type": "json",
+				"description": "An HTML rendering of what Ctrl+C copies, written to the clipboard as `text/html` beside the TSV. Excel and Google Sheets read the HTML first, so a table with inline styles pastes into them with its formats, and the same markup can carry what the text cannot (a formula in a `data-` attribute) for a round trip back into a grid that reads it. Called after every cell has been through `processCellForClipboard`, with the rectangles copied and the text about to be written. Return nothing to write text alone. Runs synchronously inside the key press, which is what the clipboard needs.",
+				"code": true,
+				"group": "advanced"
+			},
+			{
+				"key": "processCellFromClipboard",
+				"label": "Process Cell From Clipboard",
+				"type": "json",
+				"description": "Transform each cell on its way IN from the clipboard, before the grid coerces it for the column's editor. Symmetric with `processCellForClipboard`: the pair is what lets a round trip survive. Receives the raw clipboard text for the cell plus where it is landing. Return the value to write, or `undefined` to leave the cell untouched. This is also the seam a feature pack uses to take over a paste entirely: `@svgrid/enterprise`'s paste-special reads the clipboard's `text/html` for formats and formulas and writes through here.",
 				"code": true,
 				"group": "advanced"
 			},
@@ -8964,6 +9003,13 @@ var GENERATED_UI_SURFACE = {
 				"description": "Inline cell editing: F2 or double-click opens an editor in the active cell, Enter commits, Esc cancels. Off by default. A column still needs an `editorType` to pick its editor (text, number, date, checkbox, list, ...); without one it gets a plain text editor. `editable` is the shortcut alias and wins over this.",
 				"group": "common"
 			},
+			{
+				"key": "editOnSecondClick",
+				"label": "Edit On Second Click",
+				"type": "boolean",
+				"description": "A click on the cell that is already active opens its editor, the way a second click on a selected file name starts renaming it. On by default. A spreadsheet turns it off: Excel edits on double-click or F2 only, and a user clicking the cell they are on to get back to it after a dialog would otherwise find the next shortcut typed into an editor.",
+				"group": "common"
+			},
 			{
 				"key": "fullRowEditing",
 				"label": "Full Row Editing",
@@ -9139,6 +9185,34 @@ var GENERATED_UI_SURFACE = {
 				"description": "Which rows feed the min/max range that `colorScale` / `dataBar` formats scale against. - `filtered` (default): every row that survives the filters, ignoring the page slice. The scale follows what you filtered to but does not shift when you page, so the same value keeps the same colour on page 1 and page 2. - `visible`: only the rows currently on screen. Rescales per page - use it when you want each page's heat map normalized to that page. - `all`: the full unfiltered dataset, for a scale that stays put as you filter.",
 				"group": "common"
 			},
+			{
+				"key": "rowPlaceholder",
+				"label": "Row Placeholder",
+				"type": "json",
+				"description": "Marks a row as one whose data has not arrived: `\"loading\"` draws a shimmer in every cell, `\"failed\"` draws a full-width \"could not load\" row with a Retry button, and `null` (the default for every row) renders normally. Placeholder rows are inert - not selectable, not editable, and skipped by cell navigation - because there is nothing there to act on yet. `createServerDataSource` in `infinite` mode fills the gaps with rows this recognises, so the usual wiring is `rowPlaceholder={rowPlaceholderState}` (or nothing at all, via `rowModel`).",
+				"code": true,
+				"group": "advanced"
+			},
+			{
+				"key": "rowModel",
+				"label": "Row Model",
+				"type": "json",
+				"description": "Drive the grid from a row model instead of wiring a dozen props. `createServerDataSource` returns one, and so does the Enterprise server-side row model, so server-backed grids become: ```svelte <SvGrid rowModel={ctl} {columns} /> ``` The model supplies `data`, `loading`, `getRowId`, the external sort and filter wiring, the visible range, placeholder rows, group accessors, selection and paging - each one only if it implements that part. A prop written explicitly on the grid always wins, so you can adopt it and still override one piece.",
+				"group": "common"
+			},
+			{
+				"key": "pivotResultColumns",
+				"label": "Pivot Result Columns",
+				"type": "json",
+				"description": "Columns that REPLACE `columns` while set. The server-side row model supplies them in pivot mode - one column per pivoted value, grouped under a header per pivot key - and clears them when pivot mode ends, so `columns` stays the app's own list. Rarely set by hand.",
+				"group": "common"
+			},
+			{
+				"key": "rowSelectionModel",
+				"label": "Row Selection Model",
+				"type": "json",
+				"group": "common"
+			},
 			{
 				"key": "isDetailRow",
 				"label": "Is Detail Row",
@@ -9147,11 +9221,41 @@ var GENERATED_UI_SURFACE = {
 				"code": true,
 				"group": "advanced"
 			},
+			{
+				"key": "detailRowHeight",
+				"label": "Detail Row Height",
+				"type": "number",
+				"description": "The height of a detail row, in px, or a function of its data. With it the virtualizer can size detail rows, so master-detail works with `virtualization` on (the panel scrolls inside its cell when taller). Without it a detail row is auto height, which needs `virtualization={false}`.",
+				"group": "common"
+			},
+			{
+				"key": "showDetailToggle",
+				"label": "Show Detail Toggle",
+				"type": "boolean",
+				"description": "A row-header column of chevrons that open and close detail rows. It sits with the row-number and selection columns: sticky at the left, no column menu, not resizable, not reorderable, outside the active cell and the selection. The chevron calls `onDetailToggle` (or, on a server row model, the model's own toggle) and reads `isDetailOpen` for its direction; `hasDetail` hides it on rows that have nothing to open. Detail rows themselves get an empty cell.",
+				"group": "common"
+			},
+			{
+				"key": "isDetailOpen",
+				"label": "Is Detail Open",
+				"type": "json",
+				"description": "Whether the detail under a row is open: the chevron's direction and `aria-expanded`.",
+				"code": true,
+				"group": "advanced"
+			},
+			{
+				"key": "hasDetail",
+				"label": "Has Detail",
+				"type": "json",
+				"description": "Whether a row has a detail to open; the chevron is left out where this returns false.",
+				"code": true,
+				"group": "advanced"
+			},
 			{
 				"key": "serverGroup",
 				"label": "Server Group",
 				"type": "json",
-				"description": "Server-side group / tree keyboard + accessibility, built into the grid. When set, the grid uses the treegrid role and marks matching rows with `aria-level` / `aria-expanded`, and ArrowRight / ArrowLeft expand / collapse the focused group row (no app-level key handling). Pair with `serverGroupRows` + `SvGroupCell` for the visual expander. Every accessor receives the row data.",
+				"description": "Server-side group / tree keyboard + accessibility, built into the grid. When set, the grid uses the treegrid role and marks matching rows with `aria-level` / `aria-expanded`, and ArrowRight / ArrowLeft expand / collapse the focused group row (no app-level key handling). Pair with `serverGroupRows` + `SvGroupCell` from `@svgrid/enterprise` for the visual expander, or drive it from your own tree state. Every accessor receives the row data.",
 				"group": "common"
 			},
 			{
@@ -9169,6 +9273,27 @@ var GENERATED_UI_SURFACE = {
 				"description": "Rows to pin to the TOP of the grid - rendered above the regular rows and sticky-positioned so they stay visible while the user scrolls. Typical use: a \"totals\" or \"headline\" row that should always be in view. Rows are read-only (no inline editing, no row-selection checkbox). They share the column schema with the main grid; field/format/cell/cellClass all apply.",
 				"group": "common"
 			},
+			{
+				"key": "frozenRows",
+				"label": "Frozen Rows",
+				"type": "number",
+				"description": "Freeze the first N rows: they stay under the header while the body scrolls, and unlike `pinnedTopRows` they are the grid's own rows, still editable, selectable and numbered as rows 1..N. Excel's Freeze Panes, for the row half; the column half is `columnPinning`. Under `virtualization` the frozen rows are always rendered and the window skips them.",
+				"group": "common"
+			},
+			{
+				"key": "stickyGroupRows",
+				"label": "Sticky Group Rows",
+				"type": "boolean",
+				"description": "Keep the group a row belongs to in view: while the rows of an open group scroll past, the group's row (and its parents' rows) stay under the header, the way a section heading stays put in a long list, so a screen deep inside a 60,000-row group still says which group it is. Works for server-side groups (`rowModel` / `serverGroup`), client grouping and tree data. Under `virtualization` the band shows a copy of each ancestor row; without it the rows themselves stick. Off by default.",
+				"group": "common"
+			},
+			{
+				"key": "mergedCells",
+				"label": "Merged Cells",
+				"type": "json",
+				"description": "Merged cells: rectangles drawn as one cell, a spreadsheet's Merge & Center. Each entry is the top-left cell (display indices) and how many rows and columns it covers. The origin's td takes the span and shows the origin's value; the covered cells are not drawn, a selection grows to whole merges, the active cell inside a merge is its origin, and the arrow keys step over a merge as one cell. A merge that crosses the frozen boundary or the rendered window is drawn in parts, one per band. The grid does not write into covered cells on its own; a consumer that merges cells keeps them empty or marks them read-only through the column's `editable`.",
+				"group": "common"
+			},
 			{
 				"key": "pinnedBottomRows",
 				"label": "Pinned Bottom Rows",
@@ -9245,6 +9370,24 @@ var GENERATED_UI_SURFACE = {
 				"prop": "onPaginationChange",
 				"description": "Fires when the user changes page or page size while `externalPagination` is on. Fetch that page and update `data` / `rowCount` / `pageIndex`."
 			},
+			{
+				"key": "columnResize",
+				"label": "Column Resize",
+				"prop": "onColumnResize",
+				"description": "The user dragged a column's edge (or double-clicked it to autosize). Programmatic `api.setColumnWidth` does not fire it."
+			},
+			{
+				"key": "rowResize",
+				"label": "Row Resize",
+				"prop": "onRowResize",
+				"description": "The user dragged a row's edge, or double-clicked it: `height` is then `null`, the row back at its declared height. Programmatic `api.setRowHeight` does not fire it."
+			},
+			{
+				"key": "pasteClipboard",
+				"label": "Paste Clipboard",
+				"prop": "onPasteClipboard",
+				"description": "Take over a paste. Receives the clipboard's `text/plain` and, when the source put one there, its `text/html` (Excel's carries formats and formulas; a grid's own `clipboardHtml` carries whatever it chose to). Return `true` to say the paste was applied; anything else lets the grid paste the text as it always has. Runs inside one history group, so every `setCellValue` and `recordUndo` the handler makes is one Ctrl+Z. With this set, Ctrl+V lets the browser's own `paste` event through (that is where the unsanitised HTML is), and the async Clipboard API is the fallback for a browser that does not deliver it. `source` says which path the payload came by."
+			},
 			{
 				"key": "apiReady",
 				"label": "Api Ready",
@@ -9261,7 +9404,7 @@ var GENERATED_UI_SURFACE = {
 				"key": "cellSelectionChange",
 				"label": "Cell Selection Change",
 				"prop": "onCellSelectionChange",
-				"description": "Fires whenever the cell-selection rectangle changes (mouse, keyboard, or `api.selectCells()`). `ranges` matches `api.getSelected()` - `[rowStart, colStart, rowEnd, colEnd]` rectangles in grid coords. Empty array when the user clears the selection."
+				"description": "Fires whenever the cell selection changes (mouse, keyboard, or `api.selectCells()`). `ranges` is every selected rectangle, matching `api.getSelected()`: the ones a Ctrl+click committed and the active one last, each `[rowStart, colStart, rowEnd, colEnd]` in grid coords. Empty array when the user clears the selection."
 			},
 			{
 				"key": "sortingChange",
@@ -9329,6 +9472,24 @@ var GENERATED_UI_SURFACE = {
 				"prop": "onScrollBottomReached",
 				"description": "Fires once each time the body is scrolled to (within ~32px of) the bottom. Re-arms after the user scrolls back up. The canonical hook for infinite / lazy loading - append more rows to `data` when it fires."
 			},
+			{
+				"key": "visibleRangeChange",
+				"label": "Visible Range Change",
+				"prop": "onVisibleRangeChange",
+				"description": "Fires when the range of rows on screen changes, with the first and last row INDEX (not pixels). Coalesced to one call per frame, so it is cheap to wire to something that fetches. This is the hook a block-loading data source needs and `onScrollBottomReached` cannot give it: \"the user is looking at rows 4,000-4,020\" answers which block to fetch and which to keep, while \"they hit the bottom\" only ever means \"append more\". Both are free; use this one with `createServerDataSource({ mode: 'infinite' })`, or let `rowModel` wire it for you. Reports `0, data.length - 1` when virtualization is off, since every row really is rendered."
+			},
+			{
+				"key": "retryRow",
+				"label": "Retry Row",
+				"prop": "onRetryRow",
+				"description": "Called by the Retry button on a `\"failed\"` placeholder row."
+			},
+			{
+				"key": "detailToggle",
+				"label": "Detail Toggle",
+				"prop": "onDetailToggle",
+				"description": "Open or close the detail under a row. The chevron of `showDetailToggle` and Ctrl+Enter on a row call it; you keep the open set and insert or remove the detail row in `data`. A server row model supplies its own (the `rowModel` prop wires `toggleDetail`), so this is the client side."
+			},
 			{
 				"key": "columnOrderChange",
 				"label": "Column Order Change",
@@ -9340,6 +9501,12 @@ var GENERATED_UI_SURFACE = {
 				"label": "Row Drag End",
 				"prop": "onRowDragEnd",
 				"description": "Fires on the TARGET grid after a managed row drag settles, with the moved row, its landing index, whether it stayed in the same grid, and the source / target grid ids. Use it to mirror the move into your own state (persistence, server sync). The grid has already applied the change to its internal data by the time this fires."
+			},
+			{
+				"key": "rowDrop",
+				"label": "Row Drop",
+				"prop": "onRowDrop",
+				"description": "Take the drop yourself. With this set the grid keeps the drag affordance and the drop indicator but does not touch its data: the handler gets the dragged row, the row it landed on (null for the empty space below the rows) and the side - `before` / `after`, or `into` when it landed on the middle of a group or tree row, which makes it that row's child. The path for a `rowModel`, whose rows the grid does not own: hand the move to the model (`moveRow`) or to your server. Only fires within one grid; a drop from another grid stays managed."
 			}
 		]
 	}
@@ -12086,6 +12253,10 @@ var blockPalette = [
 		kind: "detail",
 		label: "Detail page"
 	},
+	{
+		kind: "sheet",
+		label: "Spreadsheet"
+	},
 	{
 		kind: "filter",
 		label: "Filter panel"
@@ -12277,6 +12448,10 @@ function defaultBlockConfig(kind, entity) {
 				...metrics.length ? { metricFields: metrics } : {}
 			};
 		}
+		case "sheet": return {
+			kind,
+			totals: entity.fields.some((f) => f.type === "number" && !f.primaryKey)
+		};
 		case "component": return {
 			kind,
 			component: "",
@@ -12308,6 +12483,7 @@ var DEFAULT_SPAN = {
 	board: 3,
 	calendar: 3,
 	detail: 3,
+	sheet: 3,
 	component: 1
 };
 function makeBlock(kind, entity, taken) {
@@ -13227,6 +13403,7 @@ function dockPaneTitle(block) {
 		accordion: "Accordion",
 		kpi: "KPI",
 		gauge: "Gauge",
+		sheet: "Spreadsheet",
 		component: "Component"
 	}[c.kind] || "Panel";
 }
@@ -15851,7 +16028,7 @@ function hasFieldConditions(schema) {
 *
 * `version.test.ts` asserts this matches `package.json`, so the two cannot drift.
 */
-var SVGRID_VERSION = "3.0.0";
+var SVGRID_VERSION = "3.0.3";
 //#endregion
 //#region src/studio/emit-project.ts
 var has = (blocks, kind) => blocks.some((b) => b.config.kind === kind);
@@ -16189,6 +16366,17 @@ ${panels}
 			const onOpen = openRoute ? ` onOpen={(id) => goto('/${openRoute}?id=' + encodeURIComponent(id))}` : "";
 			return `    <div ${wrapperStyle(block)}${cls}>
       <SvBoard schema={${schemaVar}} rows={allRows} loading={!allRowsReady} groupBy=${JSON.stringify(cfg.groupBy)} titleField=${JSON.stringify(asText(cfg.titleField))}${badge}${sub}${onOpen} height={${h}} onMove={(id, value) => { allRows = allRows.map((r) => String((r as Record<string, unknown>)[idField]) === String(id) ? ({ ...r, ['${cfg.groupBy}']: value }) : r) }} />
+    </div>`;
+		}
+		case "sheet": {
+			const h = block.height ?? 480;
+			const specs = (cfg.fields?.length ? cfg.fields : entity.fields.map((f) => f.field)).map((field) => ({
+				field,
+				label: entity.fields.find((f) => f.field === field)?.label ?? field
+			}));
+			const sheetName = (entity.label ?? entity.name).replace(/[[\]:*?/\\]/g, " ").trim().slice(0, 31) || "Sheet1";
+			return `    <div ${wrapperStyle(block, `min-height: ${h}px`)}${cls}>
+      {#if allRowsReady}<SvSheet data={[{ name: ${JSON.stringify(sheetName)}, cells: sheetCellsFromRows(${rowsExpr}, ${JSON.stringify(specs)}, { totals: ${cfg.totals ? "true" : "false"} }) }]} height={${h}} />{/if}
     </div>`;
 		}
 		case "calendar": {
@@ -17524,7 +17712,7 @@ function screenPage(schema, rawSchema, screen, resolve, rawResolve, accessEnable
 	const apiVarFor = (b) => codeGrid && b.id === codeGridBlockId ? "gridApi" : b.config.kind === "grid" && gridHasExport(b.config) ? `gridApi_${b.id.replace(/-/g, "_")}` : void 0;
 	const exportApiVars = blocks.filter((b) => b.config.kind === "grid" && gridHasExport(b.config) && !(codeGrid && b.id === codeGridBlockId)).map((b) => `gridApi_${b.id.replace(/-/g, "_")}`);
 	const needsGridApiType = codeGrid || exportApiVars.length > 0;
-	const needsAllRows = hasAgg || hasMD || hasPivot || hasBoundComponent || hasGroupedGrid || hasTreeGrid || hasSchedulerGrid || has(allBlocks, "board") || has(allBlocks, "calendar") || has(allBlocks, "detail");
+	const needsAllRows = hasAgg || hasMD || hasPivot || hasBoundComponent || hasGroupedGrid || hasTreeGrid || hasSchedulerGrid || has(allBlocks, "board") || has(allBlocks, "calendar") || has(allBlocks, "detail") || has(allBlocks, "sheet");
 	const gridSpecs = [];
 	if (needsController) gridSpecs.push("SvGrid", "createServerDataSource", ...hasRowActions || hasCellRenderers || hasTreeGrid ? ["renderSnippet", "type CellContext"] : [], "type ServerState");
 	if (usesScheduler) gridSpecs.push("SvGrid");
@@ -17550,6 +17738,7 @@ function screenPage(schema, rawSchema, screen, resolve, rawResolve, accessEnable
 	if (has(allBlocks, "board")) entImports.push("SvBoard");
 	if (has(allBlocks, "calendar")) entImports.push("schemaToColumns");
 	if (has(allBlocks, "detail")) entImports.push("SvRecordDetail");
+	if (has(allBlocks, "sheet")) entImports.push("SvSheet", "sheetCellsFromRows");
 	if (has(allBlocks, "kpi") || has(allBlocks, "gauge") || hasAggregateBinding) entImports.push("reduceValue");
 	const kpiCfgs = allBlocks.filter((b) => b.config.kind === "kpi").map((b) => b.config);
 	if (kpiCfgs.some((c) => c.format && c.format !== "auto")) entImports.push("formatKpiValue");
@@ -41575,21 +41764,26 @@ function parseLicenseExpiry(key) {
 function checkLicenseKey(key, now = /* @__PURE__ */ new Date()) {
 	if (key == null || key === "") return {
 		status: "unset",
-		valid: false
+		valid: false,
+		edition: "suite"
 	};
 	if (!key.startsWith("SVENTERPRISE-")) return {
 		status: "invalid",
-		valid: false
+		valid: false,
+		edition: "suite"
 	};
 	if (REVOKED_KEYS.has(key)) return {
 		status: "revoked",
-		valid: false
+		valid: false,
+		edition: "suite"
 	};
 	const expiresAt = parseLicenseExpiry(key) ?? void 0;
 	const expired = expiresAt ? now.getTime() > expiresAt.getTime() : void 0;
+	const status = key.startsWith("SVENTERPRISE-DEV") ? "dev" : key.startsWith("SVENTERPRISE-EVAL") ? "eval" : "licensed";
 	return {
-		status: key.startsWith("SVENTERPRISE-DEV") ? "dev" : key.startsWith("SVENTERPRISE-EVAL") ? "eval" : "licensed",
+		status,
 		valid: true,
+		edition: status === "licensed" && key.startsWith(`SVENTERPRISE-GRID-`) ? "grid" : "suite",
 		expiresAt,
 		expired
 	};

package/dist/pivot-chart.d.ts

@@ -13,16 +13,40 @@
  *     measure). The grand-total column is excluded unless `includeTotals`.
  *   - values     = each leaf row's aggregated cell for that series column.
  */
-import type { ChartSpec, ChartType, TableFeatures } from '@svgrid/grid';
+import { type CellFormatConfig, type ChartSpec, type ChartType, type TableFeatures } from '@svgrid/grid';
 import type { PivotResult } from './pivot.js';
+/** Options for {@link pivotToChartSpec}: the chart type and stacking, whether totals chart, a category cap, the measure's format and the value-axis name. */
 export type PivotChartOptions = {
     /** Chart type. Default `'bar'`. */
     type?: ChartType;
     /** Stack the series. Default false. */
     stacked?: boolean;
+    /** Stack to 100%. Implies `stacked`. Default false. */
+    stacked100?: boolean;
     /** Include the grand-total column / row as a series / category. Default false. */
     includeTotals?: boolean;
     /** Cap the number of categories (row leaves) charted. */
     maxCategories?: number;
+    /**
+     * The measure's cell format, carried to the chart as `valueFormat` (with
+     * `currency` and `locale`), so a cell the table shows as "$469,662" charts
+     * as "$470k" on the axis and "$469,662" in the tooltip rather than "470k".
+     * The designer passes the first value chip's format; with several
+     * measures in different formats, pass none and the chart formats plainly.
+     */
+    format?: CellFormatConfig;
+    /**
+     * Name the value axis. Default: the measure's label when the layout has
+     * one measure, nothing otherwise.
+     */
+    yAxisTitle?: string | null;
 };
+/**
+ * A computed pivot as a `ChartSpec` for the free chart: row leaves become
+ * categories (nested rows a grouped axis), column leaves the series, totals
+ * left out unless asked for, the measure's format carried over and an empty
+ * cell read as a gap. The designer's Chart view is this function, and the
+ * grid's own Chart panel runs the same mapping (`pivotResultToChartSpec` in
+ * `@svgrid/grid`) in pivot mode.
+ */
 export declare function pivotToChartSpec<TFeatures extends TableFeatures>(result: PivotResult<TFeatures>, opts?: PivotChartOptions): ChartSpec;

package/dist/pivot-chart.js

@@ -1,71 +1,27 @@
+/**
+ * Pivot -> chart bridge.
+ *
+ * Turns a computed {@link PivotResult} (the row/column/value matrix the pivot
+ * engine produces) into a core {@link ChartSpec} the free `SvGridChart` can
+ * render - so one pivot layout drives both a table and a chart (the Excel
+ * PivotTable <-> PivotChart pairing).
+ *
+ * Mapping:
+ *   - categories = the row-axis LEAF rows (deepest grouping; subtotals and the
+ *     grand-total row are skipped). With no row dims, the single total row.
+ *   - series     = the column-axis leaf value columns (one per col-path x
+ *     measure). The grand-total column is excluded unless `includeTotals`.
+ *   - values     = each leaf row's aggregated cell for that series column.
+ */
+import { pivotResultToChartSpec } from '@svgrid/grid';
+/**
+ * A computed pivot as a `ChartSpec` for the free chart: row leaves become
+ * categories (nested rows a grouped axis), column leaves the series, totals
+ * left out unless asked for, the measure's format carried over and an empty
+ * cell read as a gap. The designer's Chart view is this function, and the
+ * grid's own Chart panel runs the same mapping (`pivotResultToChartSpec` in
+ * `@svgrid/grid`) in pivot mode.
+ */
 export function pivotToChartSpec(result, opts = {}) {
-    const type = opts.type ?? 'bar';
-    // Category rows: the row-axis leaves. Fall back to the grand-total (single
-    // "All") row when no row dims are configured, then to every row.
-    let catRows = result.rows.filter((r) => r.__pivotKind === 'leaf');
-    if (!catRows.length)
-        catRows = result.rows.filter((r) => r.__pivotKind === 'grandTotal');
-    if (!catRows.length)
-        catRows = result.rows.slice();
-    if (opts.maxCategories && catRows.length > opts.maxCategories) {
-        catRows = catRows.slice(0, opts.maxCategories);
-    }
-    // Categories are the leaf's OWN label; when rows are nested, emit a parent
-    // tier (categoryGroups) so the axis reads "Americas | Canada · USA ..." as a
-    // grouped axis rather than colliding on a bare repeated leaf label.
-    const byId = new Map(result.rows.map((r) => [r.__pivotId, r]));
-    const ownLabel = (r) => String(r.__pivotLabel ?? '').trim() || '(blank)';
-    const categories = catRows.map(ownLabel);
-    const parentOf = (r) => r.__pivotParentId ? byId.get(r.__pivotParentId) : undefined;
-    const nested = catRows.length > 0 && catRows.every((r) => parentOf(r) !== undefined);
-    let categoryGroups;
-    if (nested) {
-        categoryGroups = [];
-        let prevId;
-        for (const r of catRows) {
-            const pid = r.__pivotParentId;
-            const last = categoryGroups[categoryGroups.length - 1];
-            if (last && pid === prevId)
-                last.span += 1;
-            else {
-                categoryGroups.push({ label: ownLabel(parentOf(r)), span: 1 });
-                prevId = pid;
-            }
-        }
-    }
-    const leaves = [];
-    const walk = (cols, path) => {
-        for (const c of cols ?? []) {
-            if (!c || c.id === '__pivotRowHeader')
-                continue;
-            // Skip the grand-total column group (and its leaves) unless asked for.
-            if (!opts.includeTotals && typeof c.id === 'string' && c.id.startsWith('pv_group__grand'))
-                continue;
-            if (Array.isArray(c.columns))
-                walk(c.columns, [...path, String(c.header ?? '')]);
-            else if (typeof c.id === 'string')
-                leaves.push({ id: c.id, path, header: String(c.header ?? '') });
-        }
-    };
-    walk(result.columns, []);
-    const filtered = opts.includeTotals ? leaves : leaves.filter((l) => !l.id.includes('__total'));
-    const uniqueHeaders = new Set(filtered.map((l) => l.header));
-    const series = filtered.map((l) => ({
-        label: l.path.length === 0
-            ? l.header
-            : uniqueHeaders.size > 1
-                ? [...l.path, l.header].join(' · ')
-                : l.path.join(' · '),
-        values: catRows.map((r) => {
-            const v = r[l.id];
-            return typeof v === 'number' ? v : Number(v) || 0;
-        }),
-    }));
-    return {
-        type,
-        categories,
-        series,
-        ...(categoryGroups && categoryGroups.length > 1 ? { categoryGroups } : {}),
-        ...(opts.stacked ? { stacked: true } : {}),
-    };
+    return pivotResultToChartSpec(result, opts);
 }

package/dist/pivot-enable.js

@@ -6,8 +6,8 @@
  * prop + config types for free and looks the engine up through the
  * `registerPivotEngine` seam.
  *
- * Soft-gated like the rest of Enterprise: it works without a license key but the
- * grid shows the unlicensed watermark + a one-time console nudge.
+ * Like the rest of Enterprise it runs without a license key during the
+ * evaluation; the grid shows the watermark and a one-time console notice.
  *
  * ```ts
  * import { setLicenseKey, enablePivot } from '@svgrid/enterprise'

package/dist/scheduler-dependencies.d.ts

@@ -63,6 +63,12 @@ export declare function hasCycle(deps: ReadonlyArray<SchedulerDependency>): bool
  * FS / SS / FF / SF semantics plus `lag` (minutes).
  */
 export declare function requiredStart(predTimes: EventTimes, dep: SchedulerDependency, successorDurationMs: number): Date;
+/** A hard limit on where one event may be scheduled, from a planning
+ *  constraint (`SNET`, `FNLT` and the rest). Both ends are optional. */
+export type CascadeBound = {
+    minStart?: Date;
+    maxEnd?: Date;
+};
 /** Options for {@link cascade}. */
 export type CascadeOptions = {
     /**
@@ -71,6 +77,35 @@ export type CascadeOptions = {
      * shifts / business hours; omit for calendar-time scheduling).
      */
     snapForward?: (start: Date) => Date;
+    /**
+     * Only what lies downstream of these keys may move: their successors,
+     * transitively, and never the keys themselves. A move passes the moved
+     * task (a phase move its whole subtree), so a task dropped too early for
+     * its predecessor stays where it was dropped with the link drawn as
+     * violated instead of springing forward, and a violation elsewhere in the
+     * plan is left alone until its own task moves. Omitted, every task in the
+     * graph is eligible.
+     */
+    from?: Iterable<string>;
+    /**
+     * Per-key limits the cascade may not push past. A `minStart` raises the floor
+     * (the event cannot begin before it); a `maxEnd` caps the ceiling, and a
+     * cascade that would need to go further stops AT the cap rather than moving
+     * past it. The link is then left unsatisfied, which {@link violations}
+     * reports - the honest outcome, because a constraint and a link that
+     * disagree have no schedule that satisfies both.
+     */
+    bounds?: ReadonlyMap<string, CascadeBound>;
+    /**
+     * The span a pushed event keeps. By default it keeps its calendar length:
+     * `end = start + (end - start)`. A day-granular planner passes working-time
+     * arithmetic here so a five-working-day task pushed over a weekend stays
+     * five working days long instead of shrinking to three. `endFor` gives the
+     * new end for a new start; `startFor` the new start for a capped end (the
+     * ceiling case). Both receive the event's times before the push.
+     */
+    endFor?: (start: Date, original: EventTimes) => Date;
+    startFor?: (end: Date, original: EventTimes) => Date;
 };
 /**
  * Forward-cascade successors so every dependency is satisfied. `times` maps row

package/dist/scheduler-dependencies.js

@@ -120,8 +120,26 @@ export function cascade(times, deps, opts = {}) {
     const cur = new Map();
     for (const [k, v] of times)
         cur.set(k, { start: v.start, end: v.end });
+    // With roots, the eligible set is their downstream closure minus the roots.
+    let eligible = null;
+    if (opts.from) {
+        const roots = new Set(opts.from);
+        eligible = new Set();
+        const stack = [...roots];
+        while (stack.length) {
+            const k = stack.pop();
+            for (const dep of graph.succ.get(k) ?? []) {
+                if (cyclicIds.has(dep.id) || roots.has(dep.to) || eligible.has(dep.to))
+                    continue;
+                eligible.add(dep.to);
+                stack.push(dep.to);
+            }
+        }
+    }
     const changed = new Map();
     for (const key of order) {
+        if (eligible && !eligible.has(key))
+            continue;
         const links = graph.pred.get(key);
         if (!links || !links.length)
             continue;
@@ -140,12 +158,29 @@ export function cascade(times, deps, opts = {}) {
             if (req > minStartMs)
                 minStartMs = req;
         }
+        // A floor constraint applies whether or not a link moved the event.
+        const bound = opts.bounds?.get(key);
+        if (bound?.minStart && bound.minStart.getTime() > minStartMs) {
+            minStartMs = bound.minStart.getTime();
+        }
         if (minStartMs <= self.start.getTime())
             continue; // already legal - never pull earlier
         let newStart = new Date(minStartMs);
         if (opts.snapForward)
             newStart = opts.snapForward(newStart);
-        const newEnd = new Date(newStart.getTime() + durationMs);
+        // A ceiling stops the cascade at the cap instead of pushing past it. The
+        // link stays unsatisfied and `violations` says so, rather than the
+        // constraint being silently overrun.
+        if (bound?.maxEnd) {
+            const latestStart = opts.startFor
+                ? opts.startFor(bound.maxEnd, self).getTime()
+                : bound.maxEnd.getTime() - durationMs;
+            if (newStart.getTime() > latestStart)
+                newStart = new Date(latestStart);
+        }
+        if (newStart.getTime() <= self.start.getTime())
+            continue;
+        const newEnd = opts.endFor ? opts.endFor(newStart, self) : new Date(newStart.getTime() + durationMs);
         const next = { start: newStart, end: newEnd };
         cur.set(key, next);
         changed.set(key, next);

package/dist/scheduler.js

@@ -5,8 +5,8 @@
  * its config types for free; the *renderer* (SvGridScheduler) is Pro and plugs
  * in through the grid's `registerSchedulerView` seam.
  *
- * Soft-gated like the rest of Enterprise: it works without a license key but the
- * grid shows the "unlicensed" watermark + a one-time console nudge.
+ * Like the rest of Enterprise it runs without a license key during the
+ * evaluation; the grid shows the watermark and a one-time console notice.
  *
  * ```ts
  * import { setLicenseKey, enableSchedulerView } from '@svgrid/enterprise'

package/dist/selection-bar.js

@@ -9,8 +9,8 @@
  * `registerSelectionBarView` seam. Without it the grid shows a short upsell
  * note where the bar would be.
  *
- * Soft-gated like the rest of Enterprise: it works without a license key but
- * the grid shows the "unlicensed" watermark + a one-time console nudge.
+ * Like the rest of Enterprise it runs without a license key during the
+ * evaluation; the grid shows the watermark and a one-time console notice.
  *
  * ```ts
  * import { setLicenseKey, enableSelectionBar } from '@svgrid/enterprise'