@finos/legend-cube-builder 0.0.4 → 0.0.6

package/docs/hosting.md

@@ -1,8 +1,16 @@
 # Hosting the Cube page
 
-A Legend application hosts the page by giving it a `CubeHost` and contributing its shortcuts. Legend Query is the
-host today: `LegendQueryCubeHost` (`src/stores/cube/`), and the lazy route and page (`src/components/cube/`) of
-`@finos/legend-application-query`.
+A Legend application hosts the page by giving it a `CubeHost` and contributing its shortcuts. Three applications
+host it today:
+
+- **Legend Query**, at `/query/cube`: `LegendQueryCubeHost` (`src/stores/cube/`), and the lazy route and page
+  (`src/components/cube/`) of `@finos/legend-application-query`.
+- **Legend Analytics**, at `/analytics/`, an application of its own: `createLegendAnalyticsCubeHost`
+  (`src/stores/`) and the page at its root (`src/components/`) of `@finos/legend-application-analytics`, with its
+  bootstrap and deployment (PLAN §11.19).
+- **Legend Studio**, from an ingest definition's editor (see [Legend Studio](#legend-studio-create-matview)).
+
+Legend Query and Legend Analytics build their hosts on one `LegendCubeHost` (below).
 
 ## The host
 
@@ -15,9 +23,24 @@ interface CubeHost {
   readonly dataProductCatalog?: CubeDataProductCatalog | undefined;
   readonly ingestCatalog?: CubeIngestCatalog | undefined;
   readonly projectCatalog?: CubeProjectCatalog | undefined;
+  readonly serviceCatalog?: CubeServiceCatalog | undefined;
+  /** False to leave out the Sample Data tab and the Examples, as Studio does */
+  readonly offersSampleData?: boolean | undefined;
+  readonly engineClientSettings?: CubeEngineClientSettings | undefined;
 }
 ```
 
+**A Legend deployment's host:** `new LegendCubeHost(applicationStore, config, parts?)` builds every part below from
+a plain `LegendCubeHostConfig`, the deployment's servers: `engine` (a `CubeEngineConfig`), and `depotServerUrl`,
+`lakehouseContractUrl`, `lakehousePlatformUrl`, `marketplaceServerUrl`, `marketplaceApplicationUrl`,
+`marketplaceProductionParallelUrl`, `enterpriseStereotype` and `getPreferredEnvironment`, each only where the
+deployment has it. It offers each source by the rules below (no lakehouse, no data products; no platform, no ingest
+data sets; no depot, no projects), links data products to the marketplace of their deployment's class, and registers
+every engine client with its `engineClientSettings`, which Dev Settings changes. Tests give an engine, a connection
+explorer or a project catalog as `parts`. Legend Query passes `buildLegendQueryCubeHostConfig`, Legend Analytics
+`buildLegendAnalyticsCubeHostConfig`; a host whose sources are its own builds its parts
+with the functions below instead.
+
 - **The application store** gives the page its commands, user data, clipboard, theme, notifications and alerts, and
   its telemetry service, which Cube doesn't use yet: it sends no events. Cube keeps no auth or config of its own.
 - **The engine:** `buildCubeEngine(config, tracerService)` builds Legend's implementation of the `CubeEngine` port.
@@ -25,7 +48,10 @@ interface CubeHost {
   and options, so Cube talks to the engine its query editor uses.
 - **The models:** `new LocalModelCatalog(engine)`. It offers `BUNDLED_MODELS` (the Northwind, Sports and Trades datasets of the Sample Data tab)
   and caches each model's outline: its tables, for the source picker, and its runtimes' connections with their
-  database types, which Drop, Slice, Limit and Distinct need on some databases (PLAN §11.4). Users can also paste a Pure
+  database types, which Drop, Slice, Limit and Distinct need on some databases (PLAN §11.4), and which tell DuckDB's
+  refusal of `%` and `_` in filter patterns (PLAN §8.2) and where Pivot can run (PLAN §11.12). A data product or
+  ingest cube's database is the one its lakehouse runtime routes to, from one table in `CubeLakehouseRuntime.ts`
+  (Snowflake for now). Users can also paste a Pure
   model.
 - **Direct database connections (optional):** `buildCubeConnectionExplorer(config, tracerService)` builds the explorer
   that reads the database behind a connection through the engine's schema exploration
@@ -58,6 +84,9 @@ interface CubeHost {
   dialog's Project tab (PLAN §6.3). It reads nothing until the tab opens. Project cubes save the engine's pointer, so
   the engine must fetch from the same depot. Legend Query builds it from `depot.url`.
 
+Legend Analytics mounts the page at its root with no flag: deploying the application is the opt-in. Its config takes
+the keys below as Legend Query's does, with `depot` optional too, and only `engine` required.
+
 Legend Query mounts the Cube page at `/query/cube` only where its config turns on non-production features,
 since Cube is still a proof of concept: `"extensions": { "core": { "NonProductionFeatureFlag": true } }`. Without
 it, as in production, the address shows nothing. To see it locally, add it to the deployment's
@@ -108,6 +137,48 @@ lives as long as the page; Legend Query makes a new host on each visit.
 in-memory H2 database through its connection's `testDataSetupSqls`. On an engine that forbids LocalH2, its queries don't
 run.
 
+## Legend Studio: Create MatView
+
+An ingest definition's editor in Studio offers **Create MatView** in every deployment: unlike Legend Query's
+`/query/cube`, it doesn't depend on `NonProductionFeatureFlag` (`EmbeddedCubeState`, `src/stores/editor/embedded-cube/` of `@finos/legend-application-studio`). The page opens full
+screen over the editor, as the embedded query builder does, with `LegendStudioCubeHost`:
+
+- **The project:** `CubeHost.project` (`LegendStudioCubeWorkspace`) says the page reads one project's own sources. The
+  source dialog's Ingest and Data Product tabs then list that project's definitions and products by name, each path
+  muted beside it, with no class, producer deployment, search or warehouse to pick, and name the lakehouse runtime
+  its runs use: the project's first, the one Studio's own queries of an ingest definition or a data product pick.
+  Without one, the tabs say to add one. No sample data or examples (`offersSampleData: false`), databases or
+  services; one kind of source per cube, as in Legend Query.
+- **Ingest data sets:** `LegendStudioCubeIngestCatalog` lists the workspace's definitions under one producer that
+  stands for the project, names each by the URN it would have if the project deployed it (`formatCubeIngestUrn`),
+  and types their data sets from their content (`readCubeIngestDataSets`), with no engine call.
+- **Data products:** `LegendStudioCubeDataProductCatalog` lists the workspace's products, as version `workspace`, and
+  types their lakehouse access points with the engine (`#P{product.accessPoint}#`), a product's in one call.
+- **The model typing and runs read:** the workspace, as Studio's own queries send it: the ingest catalog's
+  `getModelElements` (`ingestDefinitionSource` on `buildCubeEngine`) and the workspace's `getProjectModel`
+  (`dataProductModelSource`), in place of the deployed definitions and the project's deployed version. A run adds
+  Cube's lakehouse runtime, in the project runtime's environment (`lakehouseEnvironment`), on the cube's warehouse,
+  which starts as the runtime's.
+- **Add MatView:** a button the host adds to the header (`headerActions` on `CubeEditor`) takes the step that runs
+  as a lambda with no runtime and no row limit (`buildCubeRunningStepLambda`), asks for a name, a classification of
+  its data and a primary key among the step's columns (`analysis.schemas` of the selected step), but the
+  milestoning columns a write mode adds (`LAKE_IN_ID`, `LAKE_DIGEST`, …), and appends a
+  `FunctionSource` data set to the definition. Studio sees it as a local change; Lineage and View SQL work on it.
+- **Edit MatView:** the button's menu lists the definition's materialized views. Cube opens on one, read back into
+  its steps (`initialLambda` on `CubeEditor`, Import Pure, PLAN §11.18): the host binds its sources as the source
+  dialog would add them, and a banner says when Cube writes the view another way. The header button is then
+  **Save MatView**, which replaces that view's lambda in place, keeping its name, place and other keys, and adding
+  the empty lists the engine reads that it lacks. When the view has no classification of its data, or its primary
+  key has a column the step no longer has or a milestoning one, Save MatView first asks for them again in Add
+  MatView's dialog.
+- **Loading:** Studio loads Cube with the dialog, on its first opening (`React.lazy`), so Cube's code stays out of
+  Studio's main bundle.
+
+While the page is open, Studio's own shortcuts are off (its F9 compiles), and Cube's are on: Studio's core plugin
+contributes `LEGEND_CUBE_COMMAND_CONFIG`. The floating step editor is placed in the dialog that hosts the page, so the
+dialog doesn't hide it. In a light theme, Cube's dialogs draw their primary button as an accent button
+(`CubeDialogTheme.ts`): legend-art's light variant draws it grey.
+
 ## Shortcuts
 
 A Legend application binds keys only through its plugins. The host returns the page's commands from one of its
@@ -129,6 +200,11 @@ The page registers the commands while it is open: F9 runs the query, and Ctrl+Z
   scans `../legend-*/src/**/*.tsx`. So Tailwind classes go in `.tsx` files only.
 - React Flow's stylesheet comes with the canvas. Load the page lazily, as Legend Query does, to keep it and the page's
   libraries out of the host's main bundle.
+- In the legacy light theme, the legend-art components the page uses (dialogs, menus, form fields, inputs, tooltips,
+  notifications) take their light look from the application's own stylesheet: Legend Query's light mode
+  (`legend-application-query/style/light-mode.scss`), whose matching rules Legend Analytics copies into
+  `legend-application-analytics-bootstrap/style/light-mode.scss`, imported after every other style. A new host
+  defaulting to the light theme needs the same.
 
 ## The dev loop
 
@@ -137,7 +213,9 @@ The page registers the commands while it is open: F9 runs the query, and Ctrl+Z
    (`fixtures/legend-docker-setup/grammar-test-setup/grammar-test-setup-docker-compose.yml`). Check it with
    `curl -s localhost:6300/api/server/v1/info`.
 2. Run `yarn build` once: `yarn dev:ts` doesn't build the stylesheets.
-3. Run `yarn dev:ts` and `yarn dev:query`, and open `http://localhost:9001/query/cube`.
+3. Run `yarn dev:ts` and `yarn dev:query`, and open `http://localhost:9001/query/cube`; or `yarn dev:analytics`, and
+   open `http://localhost:9009/analytics/` (run `yarn workspace @finos/legend-application-analytics-deployment setup`
+   once for its local config).
 4. Run `yarn workspace @finos/legend-cube-builder dev:sass` to rebuild the stylesheet as you change it (the root
    `yarn dev:ts` already rebuilds the TypeScript).
 

package/docs/testing.md

@@ -127,6 +127,24 @@ would serve it.
   failing column found and located, a plan that fails, and a run. A test that needs a typed Extend without the engine
   builds one with `TEST__typedExtend` (`src/__test-utils__/CubeExpressionTestUtils.ts`), whose types the conformance
   cases check against the engine.
+- **Filter by Expression** (PLAN §11.11). `CubeExpressionFilter.engine-roundtrip-test.ts` checks conditions through the
+  adapter (the cube model's function, a nullable comparison without `->toOne()`, a condition's type named when it
+  isn't one Boolean, an unknown column located, `&&` without parentheses refused) and runs them on H2: the late
+  orders, an empty value kept by a negation compared directly and by neither after `->toOne()`, a window column after
+  a Partition, an Extend's column. The plan-only test pins the condition in the `WHERE` on every type, and a window
+  column's filter after the window, never `QUALIFY`; the direct connection runs the empty values and the window on H2
+  and DuckDB. A test that needs a checked filter without the engine builds one with `TEST__checkedExpressionFilter`.
+- **Pivot** (PLAN §11.12). `CubePivot.engine-roundtrip-test.ts` runs Cube's pivot on a DuckDB direct connection
+  (H2 can't run it): sums, counts with 0 where no rows are, averages and minimums, no row column, string values with a
+  space, a quote and a bar, a date and a Boolean pivot column, and later steps over the value columns; and Cube
+  refusing H2 and Trino. The plan-only test pins a PIVOT on Snowflake, Databricks, MemSQL and DuckDB whose names the
+  outer select reads, Trino and Athena planning none, and the other 14 refusing it: when the engine changes, it fails,
+  and `PIVOT_UNSUPPORTED_DATABASE_TYPES` can change. Two conformance cases pin the cast's types and emptiness.
+- **The operations cleanup** (PLAN §11.14). `CubeOperationsCleanup.engine-roundtrip-test.ts` runs, on H2 and DuckDB
+  direct connections, a String's and a Boolean's Min and Max in a Group and a window, a String's Max in a Pivot
+  (DuckDB), the grid's float rule finding a `REAL` value (DuckDB; H2's is CubeDrilldown's), and a Join of `ID` and
+  `id` reported and fixed (DuckDB, which keeps their case). The plan-only test pins a pattern that isn't a literal:
+  `contains(a, b)` on Snowflake, the column's own SQL as the text on the others, which Cube refuses (a canary).
 - `src/__tests__/CubeExamples.engine-roundtrip-test.ts` compiles the Sports and Trades sample models and opens every
   example cube (PLAN §6.9) as the Examples dialog does: it types its tables, checks every node types as Cube infers it
   (Sum outputs nullable to Cube only, PLAN §5.7) and runs it, counting rows.
@@ -186,3 +204,17 @@ The engine tests in `src/__tests__/` import `V1_*` classes there, as an exceptio
 - **Changing the sample projects:** edit `fixtures/legend-mock-server/scripts/generate-cube-depot.mjs` and run it with
   the engine up (`node scripts/generate-cube-depot.mjs`). The engine caches a pointer's project per version, so restart
   it after changing a version it has fetched.
+
+### The results grid
+
+- **Server-side mode in jsdom.** ag-grid's server-side row model renders in jsdom, group rows and their expansion
+  included, so the region's tests drive it as a user would (`CubeGridRegion.test.tsx`). The logic sits below it, in
+  `CubeGridFetcher` and `CubeGridState` (store tests on the fake engine) and the core's `deriveDrilldownLevel`.
+- **Each level on the engine:** `src/__tests__/CubeDrilldown.engine-roundtrip-test.ts` runs drill-down levels on H2
+  and compares their groups with groups counted and summed from the run's own rows, keys of every type included (a
+  32-bit `REAL` key needs `In [v, fround(v)]`), and over a Partition and a Limit run.
+- **Around the databases:** the plan-only dialect test plans each level shape on every database type, and the
+  conformance suite checks the derived Groups' types against the engine's.
+- **Export:** `src/__tests__/CubeExport.engine-roundtrip-test.ts` reads the engine's CSV. The engine test client sends
+  the serialization format the client asks for (Studio's CSV is the engine's `CSV_TRANSFORMED`). jsdom has no
+  `URL.createObjectURL`, so a test that saves a file stubs it (`CubeExportState.test.ts`).

package/lib/__lib__/LegendCubeCommand.d.ts

@@ -17,6 +17,7 @@ import type { CommandConfigData } from '@finos/legend-application';
 export declare enum LEGEND_CUBE_COMMAND_KEY {
     EXECUTE = "legend-cube.execute",
     UNDO = "legend-cube.undo",
+    REDO = "legend-cube.redo",
     VALIDATE_EXPRESSIONS = "legend-cube.validate-expressions"
 }
 /** Keys as `KeyboardEvent.code` names */
@@ -24,4 +25,5 @@ export declare const LEGEND_CUBE_COMMAND_CONFIG: CommandConfigData;
 /** How the buttons' tooltips name the shortcuts */
 export declare const EXECUTE_SHORTCUT_LABEL = "F9";
 export declare const UNDO_SHORTCUT_LABEL = "Ctrl+Z / Cmd+Z";
+export declare const REDO_SHORTCUT_LABEL = "Ctrl+Shift+Z / Cmd+Shift+Z";
 //# sourceMappingURL=LegendCubeCommand.d.ts.map

package/lib/__lib__/LegendCubeCommand.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"LegendCubeCommand.d.ts","sourceRoot":"","sources":["../../src/__lib__/LegendCubeCommand.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAOnE,oBAAY,uBAAuB;IACjC,OAAO,wBAAwB;IAC/B,IAAI,qBAAqB;IACzB,oBAAoB,qCAAqC;CAC1D;AAED,yCAAyC;AACzC,eAAO,MAAM,0BAA0B,EAAE,iBAcxC,CAAC;AAEF,mDAAmD;AACnD,eAAO,MAAM,sBAAsB,OAAO,CAAC;AAC3C,eAAO,MAAM,mBAAmB,mBAAmB,CAAC"}
+{"version":3,"file":"LegendCubeCommand.d.ts","sourceRoot":"","sources":["../../src/__lib__/LegendCubeCommand.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAOnE,oBAAY,uBAAuB;IACjC,OAAO,wBAAwB;IAC/B,IAAI,qBAAqB;IACzB,IAAI,qBAAqB;IACzB,oBAAoB,qCAAqC;CAC1D;AAED,yCAAyC;AACzC,eAAO,MAAM,0BAA0B,EAAE,iBAmBxC,CAAC;AAEF,mDAAmD;AACnD,eAAO,MAAM,sBAAsB,OAAO,CAAC;AAC3C,eAAO,MAAM,mBAAmB,mBAAmB,CAAC;AACpD,eAAO,MAAM,mBAAmB,+BAA+B,CAAC"}

package/lib/__lib__/LegendCubeCommand.js

@@ -21,6 +21,7 @@ export var LEGEND_CUBE_COMMAND_KEY;
 (function (LEGEND_CUBE_COMMAND_KEY) {
     LEGEND_CUBE_COMMAND_KEY["EXECUTE"] = "legend-cube.execute";
     LEGEND_CUBE_COMMAND_KEY["UNDO"] = "legend-cube.undo";
+    LEGEND_CUBE_COMMAND_KEY["REDO"] = "legend-cube.redo";
     LEGEND_CUBE_COMMAND_KEY["VALIDATE_EXPRESSIONS"] = "legend-cube.validate-expressions";
 })(LEGEND_CUBE_COMMAND_KEY || (LEGEND_CUBE_COMMAND_KEY = {}));
 /** Keys as `KeyboardEvent.code` names */
@@ -34,6 +35,11 @@ export const LEGEND_CUBE_COMMAND_CONFIG = {
         defaultKeyboardShortcut: 'Control+KeyZ',
         additionalKeyboardShortcuts: ['Meta+KeyZ'],
     },
+    [LEGEND_CUBE_COMMAND_KEY.REDO]: {
+        title: 'Redo the last change undone',
+        defaultKeyboardShortcut: 'Control+Shift+KeyZ',
+        additionalKeyboardShortcuts: ['Meta+Shift+KeyZ', 'Control+KeyY'],
+    },
     [LEGEND_CUBE_COMMAND_KEY.VALIDATE_EXPRESSIONS]: {
         title: "Validate the Extend's expressions",
         defaultKeyboardShortcut: 'F10',
@@ -42,4 +48,5 @@ export const LEGEND_CUBE_COMMAND_CONFIG = {
 /** How the buttons' tooltips name the shortcuts */
 export const EXECUTE_SHORTCUT_LABEL = 'F9';
 export const UNDO_SHORTCUT_LABEL = 'Ctrl+Z / Cmd+Z';
+export const REDO_SHORTCUT_LABEL = 'Ctrl+Shift+Z / Cmd+Shift+Z';
 //# sourceMappingURL=LegendCubeCommand.js.map

package/lib/__lib__/LegendCubeCommand.js.map

@@ -1 +1 @@
-{"version":3,"file":"LegendCubeCommand.js","sourceRoot":"","sources":["../../src/__lib__/LegendCubeCommand.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAIH,wEAAwE;AACxE,2EAA2E;AAC3E,6EAA6E;AAC7E,oDAAoD;AAEpD,MAAM,CAAN,IAAY,uBAIX;AAJD,WAAY,uBAAuB;IACjC,0DAA+B,CAAA;IAC/B,oDAAyB,CAAA;IACzB,oFAAyD,CAAA;AAC3D,CAAC,EAJW,uBAAuB,KAAvB,uBAAuB,QAIlC;AAED,yCAAyC;AACzC,MAAM,CAAC,MAAM,0BAA0B,GAAsB;IAC3D,CAAC,uBAAuB,CAAC,OAAO,CAAC,EAAE;QACjC,KAAK,EAAE,mBAAmB;QAC1B,uBAAuB,EAAE,IAAI;KAC9B;IACD,CAAC,uBAAuB,CAAC,IAAI,CAAC,EAAE;QAC9B,KAAK,EAAE,sBAAsB;QAC7B,uBAAuB,EAAE,cAAc;QACvC,2BAA2B,EAAE,CAAC,WAAW,CAAC;KAC3C;IACD,CAAC,uBAAuB,CAAC,oBAAoB,CAAC,EAAE;QAC9C,KAAK,EAAE,mCAAmC;QAC1C,uBAAuB,EAAE,KAAK;KAC/B;CACF,CAAC;AAEF,mDAAmD;AACnD,MAAM,CAAC,MAAM,sBAAsB,GAAG,IAAI,CAAC;AAC3C,MAAM,CAAC,MAAM,mBAAmB,GAAG,gBAAgB,CAAC"}
+{"version":3,"file":"LegendCubeCommand.js","sourceRoot":"","sources":["../../src/__lib__/LegendCubeCommand.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAIH,wEAAwE;AACxE,2EAA2E;AAC3E,6EAA6E;AAC7E,oDAAoD;AAEpD,MAAM,CAAN,IAAY,uBAKX;AALD,WAAY,uBAAuB;IACjC,0DAA+B,CAAA;IAC/B,oDAAyB,CAAA;IACzB,oDAAyB,CAAA;IACzB,oFAAyD,CAAA;AAC3D,CAAC,EALW,uBAAuB,KAAvB,uBAAuB,QAKlC;AAED,yCAAyC;AACzC,MAAM,CAAC,MAAM,0BAA0B,GAAsB;IAC3D,CAAC,uBAAuB,CAAC,OAAO,CAAC,EAAE;QACjC,KAAK,EAAE,mBAAmB;QAC1B,uBAAuB,EAAE,IAAI;KAC9B;IACD,CAAC,uBAAuB,CAAC,IAAI,CAAC,EAAE;QAC9B,KAAK,EAAE,sBAAsB;QAC7B,uBAAuB,EAAE,cAAc;QACvC,2BAA2B,EAAE,CAAC,WAAW,CAAC;KAC3C;IACD,CAAC,uBAAuB,CAAC,IAAI,CAAC,EAAE;QAC9B,KAAK,EAAE,6BAA6B;QACpC,uBAAuB,EAAE,oBAAoB;QAC7C,2BAA2B,EAAE,CAAC,iBAAiB,EAAE,cAAc,CAAC;KACjE;IACD,CAAC,uBAAuB,CAAC,oBAAoB,CAAC,EAAE;QAC9C,KAAK,EAAE,mCAAmC;QAC1C,uBAAuB,EAAE,KAAK;KAC/B;CACF,CAAC;AAEF,mDAAmD;AACnD,MAAM,CAAC,MAAM,sBAAsB,GAAG,IAAI,CAAC;AAC3C,MAAM,CAAC,MAAM,mBAAmB,GAAG,gBAAgB,CAAC;AACpD,MAAM,CAAC,MAAM,mBAAmB,GAAG,4BAA4B,CAAC"}

package/lib/__lib__/LegendCubeFunctionLabels.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Copyright (c) 2026-present, Goldman Sachs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import type { SchemaDiff } from '@finos/legend-cube';
+export declare const getFunctionDriftWarning: (diff: SchemaDiff) => string;
+export declare const getFunctionRecheckWarning: (firstLine: string) => string;
+export declare const CUBE_FUNCTION_MESSAGE: {
+    readonly NO_ANSWER: "The engine gave no columns for this function";
+    /** Under a function with its own runtime */
+    readonly RUNS_ON: (runtime: string) => string;
+    /** A function with its own runtime, on a cube that runs on another */
+    readonly OTHER_RUNTIME: (runtime: string, cubeRuntime: string) => string;
+    readonly NONE: "This version has no function that returns a relation.";
+    readonly NO_MATCH: "No function matches the search.";
+    readonly CUBE_CHANGED: "The cube changed while the function was being added; pick it again.";
+};
+//# sourceMappingURL=LegendCubeFunctionLabels.d.ts.map

package/lib/__lib__/LegendCubeFunctionLabels.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LegendCubeFunctionLabels.d.ts","sourceRoot":"","sources":["../../src/__lib__/LegendCubeFunctionLabels.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAMrD,eAAO,MAAM,uBAAuB,GAAI,MAAM,UAAU,KAAG,MAC+B,CAAC;AAE3F,eAAO,MAAM,yBAAyB,GAAI,WAAW,MAAM,KAAG,MACmB,CAAC;AAElF,eAAO,MAAM,qBAAqB;;IAEhC,4CAA4C;gCACzB,MAAM,KAAG,MAAM;IAElC,sEAAsE;sCAC7C,MAAM,eAAe,MAAM,KAAG,MAAM;;;;CAMrD,CAAC"}

package/lib/__lib__/LegendCubeFunctionLabels.js

@@ -0,0 +1,31 @@
+/**
+ * Copyright (c) 2026-present, Goldman Sachs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { getSchemaChangeList } from './LegendCubeLabels.js';
+// The text of function sources (PLAN §6.5): the source dialog's Project
+// tab, when it reads functions, and a function's panel
+export const getFunctionDriftWarning = (diff) => `This function's columns changed since the cube was saved: ${getSchemaChangeList(diff)}`;
+export const getFunctionRecheckWarning = (firstLine) => `Could not re-check this function, so it keeps its saved columns: ${firstLine}`;
+export const CUBE_FUNCTION_MESSAGE = {
+    NO_ANSWER: 'The engine gave no columns for this function',
+    /** Under a function with its own runtime */
+    RUNS_ON: (runtime) => `Runs on ${runtime}, set by the function`,
+    /** A function with its own runtime, on a cube that runs on another */
+    OTHER_RUNTIME: (runtime, cubeRuntime) => `It reads through ${runtime}, but the cube runs on ${cubeRuntime}`,
+    NONE: 'This version has no function that returns a relation.',
+    NO_MATCH: 'No function matches the search.',
+    CUBE_CHANGED: 'The cube changed while the function was being added; pick it again.',
+};
+//# sourceMappingURL=LegendCubeFunctionLabels.js.map

package/lib/__lib__/LegendCubeFunctionLabels.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"LegendCubeFunctionLabels.js","sourceRoot":"","sources":["../../src/__lib__/LegendCubeFunctionLabels.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAGH,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAE5D,wEAAwE;AACxE,uDAAuD;AAEvD,MAAM,CAAC,MAAM,uBAAuB,GAAG,CAAC,IAAgB,EAAU,EAAE,CAClE,6DAA6D,mBAAmB,CAAC,IAAI,CAAC,EAAE,CAAC;AAE3F,MAAM,CAAC,MAAM,yBAAyB,GAAG,CAAC,SAAiB,EAAU,EAAE,CACrE,oEAAoE,SAAS,EAAE,CAAC;AAElF,MAAM,CAAC,MAAM,qBAAqB,GAAG;IACnC,SAAS,EAAE,8CAA8C;IACzD,4CAA4C;IAC5C,OAAO,EAAE,CAAC,OAAe,EAAU,EAAE,CACnC,WAAW,OAAO,uBAAuB;IAC3C,sEAAsE;IACtE,aAAa,EAAE,CAAC,OAAe,EAAE,WAAmB,EAAU,EAAE,CAC9D,oBAAoB,OAAO,0BAA0B,WAAW,EAAE;IACpE,IAAI,EAAE,uDAAuD;IAC7D,QAAQ,EAAE,iCAAiC;IAC3C,YAAY,EACV,qEAAqE;CAC/D,CAAC"}

package/lib/__lib__/LegendCubeHelpText.d.ts

@@ -15,5 +15,9 @@
  */
 export declare const CUBE_NODE_HELP_TEXT: Readonly<Record<string, string>>;
 /** The tooltip of the editor's Select link (spec §17.9) */
-export declare const SELECT_NODE_TOOLTIP = "Selects this node as active and its output will be shown in the grid once query is executed.";
+export declare const SELECT_NODE_TOOLTIP = "Make this the step that runs: Execute shows its rows in the grid.";
+/** The marker on the step that runs, on the canvas and in its editor */
+export declare const RUNNING_NODE_LABEL = "Runs";
+/** What a node's menu and editor call making it the step that runs */
+export declare const RUN_THIS_STEP_LABEL = "Run this step";
 //# sourceMappingURL=LegendCubeHelpText.d.ts.map

package/lib/__lib__/LegendCubeHelpText.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"LegendCubeHelpText.d.ts","sourceRoot":"","sources":["../../src/__lib__/LegendCubeHelpText.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AA4BH,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAmChE,CAAC;AAEF,2DAA2D;AAC3D,eAAO,MAAM,mBAAmB,iGACgE,CAAC"}
+{"version":3,"file":"LegendCubeHelpText.d.ts","sourceRoot":"","sources":["../../src/__lib__/LegendCubeHelpText.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAiCH,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAkDhE,CAAC;AAEF,2DAA2D;AAC3D,eAAO,MAAM,mBAAmB,sEACqC,CAAC;AAEtE,wEAAwE;AACxE,eAAO,MAAM,kBAAkB,SAAS,CAAC;AAEzC,sEAAsE;AACtE,eAAO,MAAM,mBAAmB,kBAAkB,CAAC"}

package/lib/__lib__/LegendCubeHelpText.js

@@ -13,24 +13,34 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { Concat, DataProductAccessPointSource, Difference, IngestDatasetSource, Distinct, Drop, Extend, Filter, Group, Join, Limit, Partition, RelationalTableSource, Rename, Restrict, Slice, Sort, UnknownNode, } from '@finos/legend-cube';
+import { Concat, DataProductAccessPointSource, Difference, IngestDatasetSource, Distinct, Drop, ExpressionFilter, Explode, Extend, Filter, FunctionSource, Group, Join, Limit, Partition, Pivot, RelationalTableSource, Rename, Restrict, ServiceSource, Slice, Sort, UnknownNode, } from '@finos/legend-cube';
 // The node editor's help text, verbatim from the original (spec §17.9), but
 // Slice's, which counts rows from 0 and leaves the stop row out (D5, PLAN
 // §11.4), and Concat's, which matches columns by position (PLAN §11.5, Q8).
 // A new node type adds its entry here.
 export const CUBE_NODE_HELP_TEXT = {
     [RelationalTableSource.TYPE]: 'Sources data from relational database table.',
+    /** Added by Cube: the original's PURE Native Function source (PLAN §6.5) */
+    [FunctionSource.TYPE]: 'Sources data from a function of the model that returns a relation, called with a value for each parameter.',
     /** Added by Cube: the original has no data product source (PLAN §6.8) */
     [DataProductAccessPointSource.TYPE]: 'Sources data from an access point of a deployed data product.',
     /** Added by Cube: the original has no ingest data set source (PLAN §6.7) */
     [IngestDatasetSource.TYPE]: 'Sources data from a data set of a deployed ingest definition.',
+    /** Added by Cube: the original's service source is read another way, still to come (PLAN §6.4) */
+    [ServiceSource.TYPE]: "Sources data from a deployed service. In progress: Cube can't read services yet.",
     [Concat.TYPE]: 'Combines the rows of the two previous data sets, keeping duplicates, in no particular order. Both must have the same columns: the same names, in the same order, with the same types.',
     [Difference.TYPE]: 'Compares numeric values of specified columns from two previous data sets.',
     [Distinct.TYPE]: 'Removes duplicate rows from the previous data set.',
     [Drop.TYPE]: 'Reduces the number of rows in the previous data set, removing the specified number of rows from the beginning of the data set.',
     [Extend.TYPE]: 'Extends outgoing data set with new columns produced by expressions.',
+    /** Added by Cube: the original has no JSON operations (PLAN §11.20) */
+    [Explode.TYPE]: 'Makes a row for each element of an array in a JSON (Variant) column of the previous data set, keeping its columns and adding the element as a new column. A row whose array is empty, or missing, is kept once, with an empty element.',
     [Filter.TYPE]: 'Reduces the number of rows in the previous data set, keeping only rows matching the specified criteria.',
+    /** Added by Cube: the original has no filter by expression (PLAN §11.11) */
+    [ExpressionFilter.TYPE]: 'Reduces the number of rows in the previous data set, keeping only rows for which the expression is true.',
     [Group.TYPE]: 'Aggregates the data from the previous data set using the specified columns and aggregation functions.',
+    /** Added by Cube: the original has pivot only in the grid (PLAN §11.12) */
+    [Pivot.TYPE]: 'Turns the values of a column of the previous data set into columns: a row for each combination of the row columns that has a picked value, and a column for each picked value, holding its aggregate.',
     [Join.TYPE]: 'Joins two previous data sets using specified columns as join keys.',
     [Partition.TYPE]: 'Adds new columns with outputs of window functions for optional window partition and order.',
     [Limit.TYPE]: 'Reduces the number of rows in the previous data set, keeping the specified number of rows from the beginning of the data set.',
@@ -41,5 +51,9 @@ export const CUBE_NODE_HELP_TEXT = {
     [UnknownNode.TYPE]: 'Source or transformation unknown to the application.',
 };
 /** The tooltip of the editor's Select link (spec §17.9) */
-export const SELECT_NODE_TOOLTIP = 'Selects this node as active and its output will be shown in the grid once query is executed.';
+export const SELECT_NODE_TOOLTIP = 'Make this the step that runs: Execute shows its rows in the grid.';
+/** The marker on the step that runs, on the canvas and in its editor */
+export const RUNNING_NODE_LABEL = 'Runs';
+/** What a node's menu and editor call making it the step that runs */
+export const RUN_THIS_STEP_LABEL = 'Run this step';
 //# sourceMappingURL=LegendCubeHelpText.js.map

package/lib/__lib__/LegendCubeHelpText.js.map

@@ -1 +1 @@
-{"version":3,"file":"LegendCubeHelpText.js","sourceRoot":"","sources":["../../src/__lib__/LegendCubeHelpText.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EACL,MAAM,EACN,4BAA4B,EAC5B,UAAU,EACV,mBAAmB,EACnB,QAAQ,EACR,IAAI,EACJ,MAAM,EACN,MAAM,EACN,KAAK,EACL,IAAI,EACJ,KAAK,EACL,SAAS,EACT,qBAAqB,EACrB,MAAM,EACN,QAAQ,EACR,KAAK,EACL,IAAI,EACJ,WAAW,GACZ,MAAM,oBAAoB,CAAC;AAE5B,4EAA4E;AAC5E,0EAA0E;AAC1E,4EAA4E;AAC5E,uCAAuC;AAEvC,MAAM,CAAC,MAAM,mBAAmB,GAAqC;IACnE,CAAC,qBAAqB,CAAC,IAAI,CAAC,EAAE,8CAA8C;IAC5E,yEAAyE;IACzE,CAAC,4BAA4B,CAAC,IAAI,CAAC,EACjC,+DAA+D;IACjE,4EAA4E;IAC5E,CAAC,mBAAmB,CAAC,IAAI,CAAC,EACxB,+DAA+D;IACjE,CAAC,MAAM,CAAC,IAAI,CAAC,EACX,uLAAuL;IACzL,CAAC,UAAU,CAAC,IAAI,CAAC,EACf,2EAA2E;IAC7E,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,oDAAoD;IACrE,CAAC,IAAI,CAAC,IAAI,CAAC,EACT,gIAAgI;IAClI,CAAC,MAAM,CAAC,IAAI,CAAC,EACX,qEAAqE;IACvE,CAAC,MAAM,CAAC,IAAI,CAAC,EACX,yGAAyG;IAC3G,CAAC,KAAK,CAAC,IAAI,CAAC,EACV,uGAAuG;IACzG,CAAC,IAAI,CAAC,IAAI,CAAC,EACT,oEAAoE;IACtE,CAAC,SAAS,CAAC,IAAI,CAAC,EACd,4FAA4F;IAC9F,CAAC,KAAK,CAAC,IAAI,CAAC,EACV,+HAA+H;IACjI,CAAC,MAAM,CAAC,IAAI,CAAC,EACX,kEAAkE;IACpE,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,4DAA4D;IAC7E,CAAC,KAAK,CAAC,IAAI,CAAC,EACV,8JAA8J;IAChK,CAAC,IAAI,CAAC,IAAI,CAAC,EACT,oHAAoH;IACtH,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE,sDAAsD;CAC3E,CAAC;AAEF,2DAA2D;AAC3D,MAAM,CAAC,MAAM,mBAAmB,GAC9B,8FAA8F,CAAC"}
+{"version":3,"file":"LegendCubeHelpText.js","sourceRoot":"","sources":["../../src/__lib__/LegendCubeHelpText.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EACL,MAAM,EACN,4BAA4B,EAC5B,UAAU,EACV,mBAAmB,EACnB,QAAQ,EACR,IAAI,EACJ,gBAAgB,EAChB,OAAO,EACP,MAAM,EACN,MAAM,EACN,cAAc,EACd,KAAK,EACL,IAAI,EACJ,KAAK,EACL,SAAS,EACT,KAAK,EACL,qBAAqB,EACrB,MAAM,EACN,QAAQ,EACR,aAAa,EACb,KAAK,EACL,IAAI,EACJ,WAAW,GACZ,MAAM,oBAAoB,CAAC;AAE5B,4EAA4E;AAC5E,0EAA0E;AAC1E,4EAA4E;AAC5E,uCAAuC;AAEvC,MAAM,CAAC,MAAM,mBAAmB,GAAqC;IACnE,CAAC,qBAAqB,CAAC,IAAI,CAAC,EAAE,8CAA8C;IAC5E,4EAA4E;IAC5E,CAAC,cAAc,CAAC,IAAI,CAAC,EACnB,4GAA4G;IAC9G,yEAAyE;IACzE,CAAC,4BAA4B,CAAC,IAAI,CAAC,EACjC,+DAA+D;IACjE,4EAA4E;IAC5E,CAAC,mBAAmB,CAAC,IAAI,CAAC,EACxB,+DAA+D;IACjE,kGAAkG;IAClG,CAAC,aAAa,CAAC,IAAI,CAAC,EAClB,kFAAkF;IACpF,CAAC,MAAM,CAAC,IAAI,CAAC,EACX,uLAAuL;IACzL,CAAC,UAAU,CAAC,IAAI,CAAC,EACf,2EAA2E;IAC7E,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,oDAAoD;IACrE,CAAC,IAAI,CAAC,IAAI,CAAC,EACT,gIAAgI;IAClI,CAAC,MAAM,CAAC,IAAI,CAAC,EACX,qEAAqE;IACvE,uEAAuE;IACvE,CAAC,OAAO,CAAC,IAAI,CAAC,EACZ,wOAAwO;IAC1O,CAAC,MAAM,CAAC,IAAI,CAAC,EACX,yGAAyG;IAC3G,4EAA4E;IAC5E,CAAC,gBAAgB,CAAC,IAAI,CAAC,EACrB,0GAA0G;IAC5G,CAAC,KAAK,CAAC,IAAI,CAAC,EACV,uGAAuG;IACzG,2EAA2E;IAC3E,CAAC,KAAK,CAAC,IAAI,CAAC,EACV,uMAAuM;IACzM,CAAC,IAAI,CAAC,IAAI,CAAC,EACT,oEAAoE;IACtE,CAAC,SAAS,CAAC,IAAI,CAAC,EACd,4FAA4F;IAC9F,CAAC,KAAK,CAAC,IAAI,CAAC,EACV,+HAA+H;IACjI,CAAC,MAAM,CAAC,IAAI,CAAC,EACX,kEAAkE;IACpE,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,4DAA4D;IAC7E,CAAC,KAAK,CAAC,IAAI,CAAC,EACV,8JAA8J;IAChK,CAAC,IAAI,CAAC,IAAI,CAAC,EACT,oHAAoH;IACtH,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE,sDAAsD;CAC3E,CAAC;AAEF,2DAA2D;AAC3D,MAAM,CAAC,MAAM,mBAAmB,GAC9B,mEAAmE,CAAC;AAEtE,wEAAwE;AACxE,MAAM,CAAC,MAAM,kBAAkB,GAAG,MAAM,CAAC;AAEzC,sEAAsE;AACtE,MAAM,CAAC,MAAM,mBAAmB,GAAG,eAAe,CAAC"}

package/lib/__lib__/LegendCubeLabels.d.ts

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import type { SchemaColumn, SchemaDiff } from '@finos/legend-cube';
+import { type SchemaColumn, type SchemaDiff } from '@finos/legend-cube';
 import { CubeTableFlag } from '../graph-manager/CubeEngine.js';
 /** The rows a run returns by default (PLAN §9, Settled before M1.8) */
 export declare const DEFAULT_ROW_LIMIT = 1000;
@@ -25,7 +25,11 @@ export declare enum LEGEND_CUBE_USER_DATA_KEY {
     ROW_LIMIT = "legend-cube.row-limit",
     PALETTE_COLLAPSED = "legend-cube.palette-collapsed",
     /** The warehouse the viewer last picked for a data product cube (PLAN §6.8) */
-    DATA_PRODUCT_WAREHOUSE = "legend-cube.data-product-warehouse"
+    DATA_PRODUCT_WAREHOUSE = "legend-cube.data-product-warehouse",
+    /** Server-side or local (PLAN §11.10) */
+    GRID_MODE = "legend-cube.grid-mode",
+    /** Engine requests sent uncompressed, for the browser's Network tab (PLAN §11.16) */
+    UNCOMPRESSED_REQUESTS = "legend-cube.uncompressed-requests"
 }
 export declare const UNSAVED_CUBE_NAME = "Unsaved Query";
 /** Why a source is disabled on a cube: it reads database tables or data products, never both (PLAN §6.8) */
@@ -36,23 +40,50 @@ export declare const UNSERVED_SOURCE_KIND_TITLE = "This Legend deployment doesn'
 export declare const READ_ONLY_CUBE_TITLE = "This cube was saved by a newer version of Legend Cube, so it can't be changed or exported";
 /** How a SQL NULL shows in the grid, distinct from an empty string */
 export declare const NULL_CELL_TEXT = "(null)";
+/** What the Runs panel calls a run (PLAN §11.10, §11.16); a fetch of the grid's rows is described by its level */
+export declare const CUBE_RUN_LABEL: {
+    EXECUTE: string;
+    EXPORT_CSV: string;
+    pivotValues: (column: string) => string;
+};
+/**
+ * Above a run's Pure (PLAN §11.16): unlike Show Pure, it shows the limit a
+ * grid run adds, one more than the row limit, to tell whether there are more
+ */
+export declare const CUBE_RUN_PURE_NOTE = "As it ran, with any row limit Cube added to it.";
 /** Pending labels: lower-case gerunds, shown as they are (spec §17.13) */
 export declare enum CUBE_PENDING_LABEL {
     LOADING_MODEL = "loading model",
     RESOLVING_SOURCE = "resolving source",
     EXECUTING_QUERY = "executing query",
+    FETCHING_ROWS = "fetching rows",
+    EXPORTING_CSV = "exporting CSV",
     RENDERING_QUERY = "rendering query",
     REFRESHING_SOURCE = "refreshing source",
-    TYPING_COLUMNS = "typing new columns"
+    CHECKING_EXPRESSIONS = "checking expressions"
 }
-export declare const getRowLimitError: (text: string) => string | undefined;
+/**
+ * Why a row limit can't be taken: the number its text holds
+ * (`parseWholeNumberText`, so `0x10`, `1e3` and `1.0` hold none, PLAN
+ * §11.14) isn't a safe whole number of at least 1
+ */
+export declare const getRowLimitError: (value: number | undefined) => string | undefined;
 export declare const getTruncationMessage: (rowLimit: number) => string;
+/** In server-side mode, when a drill-down level or a sorted level was cut at the row limit (PLAN §11.10) */
+export declare const getLevelTruncationMessage: (rowLimit: number) => string;
 /** How the picker shows a table's problem, and why (PLAN §6.2.6) */
 export declare const CUBE_TABLE_FLAG_LABELS: Readonly<Record<CubeTableFlag, {
     label: string;
     description: string;
 }>>;
-/** A column's type as the editors show it: its display name, `?` when it takes NULL, e.g. `Varchar(5)?` */
+/** A column's exact type: its display name, `?` when it takes NULL, e.g. `Varchar(5)?`; for hover and type messages */
+export declare const getExactColumnTypeLabel: (column: SchemaColumn) => string;
+/**
+ * A column's type as the editors show it: the kind of value, and whether it
+ * is optional (can be empty), e.g. `Text, optional`; an enumeration, or a
+ * type Cube doesn't know, by its name. The exact type
+ * (`getExactColumnTypeLabel`) is on hover.
+ */
 export declare const getColumnTypeLabel: (column: SchemaColumn) => string;
 /** Why Execute (and Show Pure) can't run, one reason a line, for a tooltip */
 export declare const formatDisabledReasons: (reasons: readonly string[]) => string;
@@ -66,15 +97,31 @@ export declare const CUBE_SORT_COLUMN_DISABLED_REASON: {
     TAKEN: string;
 };
 /** Why the grid's quick actions (spec §12.4) can't be used */
+/** Why a Variant cell's Open JSON can't be used (PLAN §11.20) */
+export declare const CUBE_JSON_DISABLED_REASON: {
+    NOT_A_ROW: string;
+    EMPTY: string;
+};
 export declare const CUBE_QUICK_ACTION_DISABLED_REASON: {
     STALE_ROWS: string;
     RUNNING: string;
     EDITING: string;
     UNREADABLE_VALUE: string;
+    /** On a group row's cell that holds its aggregation (PLAN §11.10) */
+    AGGREGATE_VALUE: string;
+    /** On a group row's cell that shows nothing */
+    NO_VALUE: string;
     notSortable: (typeName: string) => string;
     notGroupable: (typeName: string) => string;
     notComparable: (typeName: string) => string;
 };
+/** Why 'Format Column' can't be used on a column (spec §13.1) */
+export declare const CUBE_FORMAT_NOT_A_NUMBER = "Only number columns can be formatted.";
+/** Why 'Drilldown by' can't be used on a column (PLAN §11.10) */
+export declare const CUBE_DRILLDOWN_BLOCKER: {
+    ALREADY_A_LEVEL: string;
+    notGroupable: (typeName: string) => string;
+};
 /** Beside a condition comparing a floating-point column for equality (R133) */
 export declare const FILTER_FLOAT_COMPARISON_HINT = "exact comparison on floating-point columns may not match";
 /** The Filter and Join editors' warning on a column that can hold both dates and timestamps (PLAN §11.5) */
@@ -117,6 +164,55 @@ export declare const getConcatUntypedWarning: (columns: readonly string[]) => st
 export declare const CUBE_GROUP_COLUMN_DISABLED_REASON = "can't be grouped";
 /** What the Group editor says about its aggregations (PLAN §11.5; Count counts non-empty values, D4) */
 export declare const GROUP_EDITOR_NOTES: string[];
+/** Why the Pivot editor won't take a column (PLAN §11.12), shown after the column's type */
+export declare const PIVOT_COLUMN_DISABLED_REASON: {
+    /** a row column that can't be compared */
+    readonly NOT_GROUPABLE: "can't be grouped";
+    /** a pivot column of another type than a String, an integer, a StrictDate or a Boolean */
+    readonly NOT_PIVOTABLE: "can't be pivoted";
+    /** a column the pivot uses for another part */
+    readonly PIVOT_COLUMN: "the pivot column";
+    readonly ROW_COLUMN: "a row column";
+    readonly AGGREGATED: "the aggregated column";
+};
+/** Why the Pivot editor won't tick a value (PLAN §11.12) */
+export declare const PIVOT_VALUE_DISABLED_REASON: {
+    readonly NOT_A_COLUMN_NAME: "can't name a column";
+    /** another value ticked has the same text in another case */
+    readonly DIFFERS_ONLY_IN_CASE: "only its case differs from a ticked value";
+    /** as many values are ticked as a Pivot takes */
+    readonly TOO_MANY: "as many values as a Pivot takes are ticked";
+};
+/** What the Pivot editor says (PLAN §11.12) */
+export declare const PIVOT_EDITOR_NOTES: readonly ["Each picked value becomes a column, named by the value, holding the aggregation of its rows; each combination of the row columns with a picked value becomes a row. Values not picked, and combinations holding only them, are left out.", "Load values lists the pivot column's values, each once, up to 100. An empty value can't be pivoted, nor one that can't name a column; of two values that differ only in case, one can be ticked, as some databases would mix up their columns.", "Pivot runs on Snowflake, Databricks, SingleStore and DuckDB; other databases, such as H2 and Postgres, can't run it."];
+/** Why the Explode Array editor won't pick a column (PLAN §11.20) */
+export declare const EXPLODE_COLUMN_DISABLED_REASON: {
+    /** a column of another type than Variant */
+    readonly NOT_JSON: "not JSON";
+};
+/** Under the Explode Array editor (PLAN §11.20) */
+export declare const EXPLODE_EDITOR_NOTES: readonly ["One row per element of the array, the other columns repeated on each. A row whose array is empty, or that has none, is kept once, with an empty element.", "Find arrays reads the column's first values, as Explore JSON does, and lists the arrays they hold. Keys can be typed too: none when the column is the array.", "The element is JSON: Explore JSON, in its column menu, makes columns of its fields. Explode Array runs on Snowflake, Databricks, Postgres and DuckDB."];
+/** Explore JSON's one row per element offer, as its tooltip explains it (PLAN §11.20) */
+export declare const CUBE_JSON_EXPLODE_OFFER_TITLE = "Adds an Explode Array node: a row for each element, the element as a new JSON column. One array at a time.";
+/** The tooltips of a Variant column's fields in an expression editor (PLAN §11.20, V.9) */
+export declare const CUBE_JSON_FIELDS_TITLE: {
+    readonly OPEN: "Show its fields, read from its first values just before this step: listed in Runs; a field clicked is written into the expression";
+    readonly FORMS: "Other forms of the field: counts, lists, the first element, totals, as JSON";
+    readonly EXPLODE: "One row per element is a step of its own: add Explode Array from the palette, or from Explore JSON in the grid";
+    readonly READ_AGAIN: "Read the column again";
+    readonly EVERY_ROW: "Read every value of the column, for the shape of the whole column: listed in Runs, and it can be stopped";
+};
+/** What a Variant column's fields were read from, in an expression editor (PLAN §11.20, V.9) */
+export declare const getCubeJsonFieldsStatus: (sample: {
+    readonly rows: number;
+    readonly complete: boolean;
+}) => string;
+/** Says that Find arrays found none in the values read (PLAN §11.20) */
+export declare const EXPLODE_NO_ARRAYS_NOTICE = "No array in the values read: type the keys to one.";
+/** Says that Load values found no value to list (PLAN §11.12) */
+export declare const PIVOT_NO_VALUES_NOTICE = "The pivot column has no value to list: its rows are all empty, or there are none.";
+/** Says that the engine has more values than the Pivot editor lists (PLAN §11.12) */
+export declare const getPivotValuesCutNotice: (shown: number) => string;
 /** Why the Partition editor won't tick a column that can't be compared (PLAN §11.6) */
 export declare const CUBE_PARTITION_COLUMN_DISABLED_REASON = "can't be partitioned by";
 /** What a Partition row shows in the column's place for a function that takes none (PLAN §11.6) */
@@ -141,20 +237,45 @@ export declare const EXTEND_APPLY_DISABLED_REASON: Readonly<{
 }>;
 /** The warning on an Extend whose saved types the engine couldn't check again, e.g. offline (PLAN §11.7) */
 export declare const getExtendRetypeWarning: (firstLine: string) => string;
+/** The warning on a Filter by Expression whose condition the engine couldn't check again, e.g. offline (PLAN §11.11) */
+export declare const getConditionRecheckWarning: (firstLine: string) => string;
 /** The notice of a node editor kept open, since its changes can't be applied yet, e.g. an Extend's expressions not validated */
 export declare const getEditorKeptOpenNotice: (nodeId: string, waiting: string) => string;
+/** Why the Filter by Expression editor's Apply waits (PLAN §11.11) */
+export declare const EXPRESSION_FILTER_APPLY_DISABLED_REASON: Readonly<{
+    NOT_VALIDATED: "Validate the condition first (F10)";
+    VALIDATING: "Validating the condition";
+}>;
+/**
+ * The hint after an engine error on `and`, `or` or `not` given something
+ * other than a Boolean, which Pure's precedence usually causes: comparisons
+ * bind no tighter than `&&`, `||` and `!` (PLAN §11.11)
+ */
+export declare const EXPRESSION_FILTER_PARENTHESES_HINT = "Put each comparison in parentheses: ($x.A > 1) && ($x.B > 3).";
+/** What the Filter by Expression editor says about conditions (PLAN §11.11) */
+export declare const EXPRESSION_FILTER_EDITOR_NOTES: readonly ["A condition of one row, written as in Query's text mode: x | $x.SHIPPED_DATE > $x.REQUIRED_DATE. The rows for which it is true are kept, in their order.", "Put each comparison in parentheses when you combine them: ($x.A > 1) && ($x.B > 3). In Pure, &&, || and ! bind as tightly as >, <, >= and <=; == binds tighter.", "An optional column, compared directly ($x.A > 6), fails the condition when it is empty and passes its negation. After ->toOne(), an empty value fails both.", "Validate (F10) checks the condition with the engine and plans it for the cube's database.", "startsWith, endsWith and contains can't take a value with a backslash (\\) yet, nor, on DuckDB, one with % or _.", "A JSON (Variant) column’s {} opens its fields, read from its first values just before this step: a field clicked is written into the condition."];
 /** The hint after an engine error on a column that can be empty, in arithmetic (PLAN §11.7) */
-export declare const EXTEND_TO_ONE_HINT = "A column that can be empty needs ->toOne() first, such as $x.QTY->toOne() + 1.";
-/** The problem a database refusing an Extend's plan gives (PLAN §11.7) */
+export declare const EXTEND_TO_ONE_HINT = "An optional column needs ->toOne() first, such as $x.QTY->toOne() + 1.";
+/** The problem a database refusing an Extend's or a Filter by Expression's plan gives (PLAN §11.7, §11.11) */
 export declare const getExtendPlanProblem: (databaseType: string | undefined, detail: string) => string;
 /** Under the Rename editor's rows: the rule for new column names (PLAN §11.4) */
 export declare const COLUMN_NAME_RULES_HINT = "Names can't start or end with a space, or contain \" or \\ or control characters, and have at most 128 characters.";
 /**
  * A node type's label as the node editor's title shows it, each word
- * capitalised (QUESTIONS.md U1(a)), e.g. 'Take First <x> Rows'; the registry
- * keeps its own wording
+ * capitalised but `a`, `an` and `of` (QUESTIONS.md U1(a)), e.g. 'Take a Range
+ * of Rows'; the registry keeps its own wording
  */
 export declare const toEditorTitle: (label: string) => string;
 /** The source dialog's body until a tab is chosen, opened from the empty canvas (spec §17.8, U4(b)) */
 export declare const SELECT_SOURCE_TYPE_PROMPT = "Select source type above";
+/** Why the source dialog's Add is disabled: nothing picked yet, or not ready */
+export declare const CUBE_PICK_TO_ADD_TITLE = "Pick what to add first";
+/**
+ * The badge a node type shows beside its name: WIP for one that doesn't
+ * work yet (a service, PLAN §6.4), else BETA for one in beta, else none
+ */
+export declare const getCubeNodeBadge: (definition: {
+    readonly beta: boolean;
+    readonly wip?: boolean | undefined;
+}) => "WIP" | "BETA" | undefined;
 //# sourceMappingURL=LegendCubeLabels.d.ts.map