@finos/legend-cube-builder 0.0.4 → 0.0.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@finos/legend-cube-builder",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "description": "Legend Cube builder: the canvas UI and the Legend engine adapter of the Legend Cube query builder",
   "keywords": [
     "legend",
@@ -45,14 +45,14 @@
   },
   "dependencies": {
     "@dagrejs/dagre": "1.1.4",
-    "@finos/legend-application": "16.0.128",
-    "@finos/legend-art": "7.1.168",
-    "@finos/legend-cube": "0.0.4",
-    "@finos/legend-graph": "32.7.6",
-    "@finos/legend-lego": "2.0.230",
+    "@finos/legend-application": "16.0.129",
+    "@finos/legend-art": "7.1.169",
+    "@finos/legend-cube": "0.0.6",
+    "@finos/legend-graph": "32.8.0",
+    "@finos/legend-lego": "2.0.231",
     "@finos/legend-server-depot": "6.1.24",
-    "@finos/legend-server-lakehouse": "0.3.90",
-    "@finos/legend-server-marketplace": "0.2.17",
+    "@finos/legend-server-lakehouse": "0.4.0",
+    "@finos/legend-server-marketplace": "0.2.18",
     "@finos/legend-shared": "11.0.32",
     "@finos/legend-storage": "3.0.154",
     "@types/react": "19.0.10",
@@ -63,7 +63,8 @@
     "react": "19.0.1",
     "react-dnd": "16.0.1",
     "react-dom": "19.0.1",
-    "serializr": "3.0.3"
+    "serializr": "3.0.3",
+    "sql-formatter": "15.4.11"
   },
   "devDependencies": {
     "@finos/legend-dev-utils": "2.2.9",

package/src/__lib__/LegendCubeCommand.ts

@@ -24,6 +24,7 @@ import type { CommandConfigData } from '@finos/legend-application';
 export enum LEGEND_CUBE_COMMAND_KEY {
   EXECUTE = 'legend-cube.execute',
   UNDO = 'legend-cube.undo',
+  REDO = 'legend-cube.redo',
   VALIDATE_EXPRESSIONS = 'legend-cube.validate-expressions',
 }
 
@@ -38,6 +39,11 @@ export const LEGEND_CUBE_COMMAND_CONFIG: CommandConfigData = {
     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',
@@ -47,3 +53,4 @@ export const LEGEND_CUBE_COMMAND_CONFIG: CommandConfigData = {
 /** 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';

package/src/__lib__/LegendCubeFunctionLabels.ts

@@ -0,0 +1,41 @@
+/**
+ * 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';
+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: SchemaDiff): string =>
+  `This function's columns changed since the cube was saved: ${getSchemaChangeList(diff)}`;
+
+export const getFunctionRecheckWarning = (firstLine: string): string =>
+  `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: string): string =>
+    `Runs on ${runtime}, set by the function`,
+  /** A function with its own runtime, on a cube that runs on another */
+  OTHER_RUNTIME: (runtime: string, cubeRuntime: string): string =>
+    `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.',
+} as const;

package/src/__lib__/LegendCubeHelpText.ts

@@ -21,15 +21,20 @@ import {
   IngestDatasetSource,
   Distinct,
   Drop,
+  ExpressionFilter,
+  Explode,
   Extend,
   Filter,
+  FunctionSource,
   Group,
   Join,
   Limit,
   Partition,
+  Pivot,
   RelationalTableSource,
   Rename,
   Restrict,
+  ServiceSource,
   Slice,
   Sort,
   UnknownNode,
@@ -42,12 +47,18 @@ import {
 
 export const CUBE_NODE_HELP_TEXT: Readonly<Record<string, string>> = {
   [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]:
@@ -57,10 +68,19 @@ export const CUBE_NODE_HELP_TEXT: Readonly<Record<string, string>> = {
     '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]:
@@ -79,4 +99,10 @@ export const CUBE_NODE_HELP_TEXT: Readonly<Record<string, string>> = {
 
 /** 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.';
+  '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';

package/src/__lib__/LegendCubeLabels.ts

@@ -14,7 +14,11 @@
  * limitations under the License.
  */
 
-import type { SchemaColumn, SchemaDiff } from '@finos/legend-cube';
+import {
+  type SchemaColumn,
+  type SchemaDiff,
+  TypeFamily,
+} from '@finos/legend-cube';
 import { CubeTableFlag } from '../graph-manager/CubeEngine.js';
 
 // The page's own text and settings; validation messages live in the core's
@@ -32,6 +36,10 @@ export enum LEGEND_CUBE_USER_DATA_KEY {
   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',
+  /** 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 const UNSAVED_CUBE_NAME = 'Unsaved Query';
@@ -49,26 +57,51 @@ export const READ_ONLY_CUBE_TITLE =
 /** How a SQL NULL shows in the grid, distinct from an empty string */
 export 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 const CUBE_RUN_LABEL = {
+  EXECUTE: 'Execute',
+  EXPORT_CSV: 'Export CSV',
+  pivotValues: (column: string): string => `Values of ${column}`,
+};
+
+/**
+ * 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 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 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 const getRowLimitError = (text: string): string | undefined => {
-  const value = Number(text.trim());
-  return text.trim() === '' || !Number.isSafeInteger(value) || value < 1
+/**
+ * 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 const getRowLimitError = (
+  value: number | undefined,
+): string | undefined =>
+  value === undefined || !Number.isSafeInteger(value) || value < 1
     ? 'The row limit must be a whole number of at least 1.'
     : undefined;
-};
 
 export const getTruncationMessage = (rowLimit: number): string =>
   `Showing the first ${rowLimit.toLocaleString('en-US')} rows; the query returned more.`;
 
+/** In server-side mode, when a drill-down level or a sorted level was cut at the row limit (PLAN §11.10) */
+export const getLevelTruncationMessage = (rowLimit: number): string =>
+  `Some levels show only their first ${rowLimit.toLocaleString('en-US')} rows or groups.`;
+
 /** How the picker shows a table's problem, and why (PLAN §6.2.6) */
 export const CUBE_TABLE_FLAG_LABELS: Readonly<
   Record<CubeTableFlag, { label: string; description: string }>
@@ -87,10 +120,36 @@ export const CUBE_TABLE_FLAG_LABELS: Readonly<
   },
 };
 
-/** A column's type as the editors show it: its display name, `?` when it takes NULL, e.g. `Varchar(5)?` */
-export const getColumnTypeLabel = (column: SchemaColumn): string =>
+/** A column's exact type: its display name, `?` when it takes NULL, e.g. `Varchar(5)?`; for hover and type messages */
+export const getExactColumnTypeLabel = (column: SchemaColumn): string =>
   `${column.type.displayName}${column.nullable ? '?' : ''}`;
 
+/** The kind of value a type family holds, as the editors name it (the review of the demo, 2026-10-13) */
+const TYPE_FAMILY_LABELS: Partial<Record<TypeFamily, string>> = {
+  [TypeFamily.BOOLEAN]: 'True or false',
+  [TypeFamily.STRING]: 'Text',
+  [TypeFamily.INTEGER]: 'Whole number',
+  [TypeFamily.FLOAT]: 'Number',
+  [TypeFamily.DECIMAL]: 'Decimal',
+  [TypeFamily.NUMBER]: 'Number',
+  [TypeFamily.STRICT_DATE]: 'Date',
+  [TypeFamily.DATETIME]: 'Date and time',
+  [TypeFamily.DATE]: 'Date',
+  [TypeFamily.STRICT_TIME]: 'Time',
+  [TypeFamily.VARIANT]: 'Variant',
+};
+
+/**
+ * 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 const getColumnTypeLabel = (column: SchemaColumn): string =>
+  `${TYPE_FAMILY_LABELS[column.type.family] ?? column.type.displayName}${
+    column.nullable ? ', optional' : ''
+  }`;
+
 const listColumns = (columns: readonly SchemaColumn[]): string =>
   columns.map((column) => column.name).join(', ');
 
@@ -108,7 +167,7 @@ export const getSchemaChangeList = (diff: SchemaDiff): string => {
           `changed ${diff.changed
             .map(
               (change) =>
-                `${change.after.name} (${getColumnTypeLabel(change.before)} to ${getColumnTypeLabel(change.after)})`,
+                `${change.after.name} (${getExactColumnTypeLabel(change.before)} to ${getExactColumnTypeLabel(change.after)})`,
             )
             .join(', ')}`,
         ]
@@ -129,6 +188,12 @@ export const CUBE_SORT_COLUMN_DISABLED_REASON = {
 };
 
 /** 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 const CUBE_JSON_DISABLED_REASON = {
+  NOT_A_ROW: "A group row's cell holds no row's document.",
+  EMPTY: 'This cell is empty.',
+};
+
 export const CUBE_QUICK_ACTION_DISABLED_REASON = {
   STALE_ROWS:
     'Execute again: these rows are from an earlier version of the query.',
@@ -136,6 +201,11 @@ export const CUBE_QUICK_ACTION_DISABLED_REASON = {
   EDITING:
     "Close the node editor first: these rows don't show the changes in it.",
   UNREADABLE_VALUE: "This value can't be used in a filter.",
+  /** On a group row's cell that holds its aggregation (PLAN §11.10) */
+  AGGREGATE_VALUE:
+    "This cell holds its group's aggregation, not a row's value, so it can't be used in a filter.",
+  /** On a group row's cell that shows nothing */
+  NO_VALUE: 'This cell has no value to filter by.',
   notSortable: (typeName: string): string =>
     `Values of type ${typeName} can't be sorted.`,
   notGroupable: (typeName: string): string =>
@@ -144,6 +214,16 @@ export const CUBE_QUICK_ACTION_DISABLED_REASON = {
     `Values of type ${typeName} can't be compared.`,
 };
 
+/** Why 'Format Column' can't be used on a column (spec §13.1) */
+export 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 const CUBE_DRILLDOWN_BLOCKER = {
+  ALREADY_A_LEVEL: 'The results already drill down by this column.',
+  notGroupable: (typeName: string): string =>
+    `Values of type ${typeName} can't be grouped.`,
+};
+
 /** Beside a condition comparing a floating-point column for equality (R133) */
 export const FILTER_FLOAT_COMPARISON_HINT =
   'exact comparison on floating-point columns may not match';
@@ -241,6 +321,86 @@ export const GROUP_EDITOR_NOTES = [
   'With no group column, the result is one row, even when there are no rows.',
 ];
 
+/** Why the Pivot editor won't take a column (PLAN §11.12), shown after the column's type */
+export const PIVOT_COLUMN_DISABLED_REASON = {
+  /** a row column that can't be compared */
+  NOT_GROUPABLE: "can't be grouped",
+  /** a pivot column of another type than a String, an integer, a StrictDate or a Boolean */
+  NOT_PIVOTABLE: "can't be pivoted",
+  /** a column the pivot uses for another part */
+  PIVOT_COLUMN: 'the pivot column',
+  ROW_COLUMN: 'a row column',
+  AGGREGATED: 'the aggregated column',
+} as const;
+
+/** Why the Pivot editor won't tick a value (PLAN §11.12) */
+export const PIVOT_VALUE_DISABLED_REASON = {
+  NOT_A_COLUMN_NAME: "can't name a column",
+  /** another value ticked has the same text in another case */
+  DIFFERS_ONLY_IN_CASE: 'only its case differs from a ticked value',
+  /** as many values are ticked as a Pivot takes */
+  TOO_MANY: 'as many values as a Pivot takes are ticked',
+} as const;
+
+/** What the Pivot editor says (PLAN §11.12) */
+export const PIVOT_EDITOR_NOTES = [
+  '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.",
+] as const;
+
+/** Why the Explode Array editor won't pick a column (PLAN §11.20) */
+export const EXPLODE_COLUMN_DISABLED_REASON = {
+  /** a column of another type than Variant */
+  NOT_JSON: 'not JSON',
+} as const;
+
+/** Under the Explode Array editor (PLAN §11.20) */
+export const EXPLODE_EDITOR_NOTES = [
+  '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.',
+] as const;
+
+/** Explore JSON's one row per element offer, as its tooltip explains it (PLAN §11.20) */
+export 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 const CUBE_JSON_FIELDS_TITLE = {
+  OPEN: 'Show its fields, read from its first values just before this step: listed in Runs; a field clicked is written into the expression',
+  FORMS:
+    'Other forms of the field: counts, lists, the first element, totals, as JSON',
+  EXPLODE:
+    'One row per element is a step of its own: add Explode Array from the palette, or from Explore JSON in the grid',
+  READ_AGAIN: 'Read the column again',
+  EVERY_ROW:
+    'Read every value of the column, for the shape of the whole column: listed in Runs, and it can be stopped',
+} as const;
+
+/** What a Variant column's fields were read from, in an expression editor (PLAN §11.20, V.9) */
+export const getCubeJsonFieldsStatus = (sample: {
+  readonly rows: number;
+  readonly complete: boolean;
+}): string => {
+  const count = sample.rows.toLocaleString('en-US');
+  return sample.complete
+    ? `All ${count} values read, just before this step`
+    : `The first ${count} values read, just before this step`;
+};
+
+/** Says that Find arrays found none in the values read (PLAN §11.20) */
+export 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 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 const getPivotValuesCutNotice = (shown: number): string =>
+  `Only the first ${shown} values are listed.`;
+
 /** Why the Partition editor won't tick a column that can't be compared (PLAN §11.6) */
 export const CUBE_PARTITION_COLUMN_DISABLED_REASON = "can't be partitioned by";
 
@@ -254,7 +414,7 @@ export const PARTITION_EDITOR_NOTES = [
   "Rank, Dense Rank and Row Number need a sort column. Tied rows share a rank: Rank then skips numbers and Dense Rank doesn't. Row Number numbers every row, and rows tied on this node's sort columns get their numbers in no set order: add a sort column that tells them apart, such as an id, for a stable top N.",
   'NTile, Percent Rank and Cumulative Distribution need a sort column too. NTile splits each partition into buckets of near-equal size, numbered from 1 in the sort order; Percent Rank and Cumulative Distribution give each row its place in its partition, from 0 to 1.',
   "Lag and Lead read a column from the row so many rows before or after in the sort order, and are empty at the partition's edges. First and Last read it from the partition's first and last rows, the same on every row. They need a sort column, and rows tied on it may give any of them.",
-  "On ClickHouse, First and Last skip empty values, and Lag and Lead show a column's default, such as 0, at the partition's edges instead of empty, unless the column can be empty there.",
+  "On ClickHouse, First and Last skip empty values, and Lag and Lead show a column's default, such as 0, at the partition's edges instead of empty, unless the column is optional there.",
   "Their sort columns also make this node's other functions run. For totals over the whole partition, add another Apply Window Functions without sort columns.",
   'Empty sort values come last when ascending and first when descending on H2; other databases may differ.',
   "A Sort before this node doesn't order the window: its sort columns do. The rows keep the order they came in.",
@@ -281,8 +441,9 @@ export const DIFFERENCE_EDITOR_NOTES = [
 /** What the Extend editor says about its expressions (PLAN §11.7) */
 export const EXTEND_EDITOR_NOTES = [
   'Write each expression as a lambda of one row, such as x | $x.PRICE * $x.QTY: $x.PRICE reads the column PRICE. A column can use the new columns above it.',
-  'A column that can be empty needs ->toOne() before arithmetic, such as $x.QTY->toOne() * 2; an empty value still gives an empty result. Every new column can be empty.',
+  'An optional column needs ->toOne() before arithmetic, such as $x.QTY->toOne() * 2; an empty value still gives an empty result. Every new column is optional.',
   "Validate (F10) checks the expressions with the engine, types them, and plans them for this cube's database: some functions type, but not every database runs them.",
+  'A JSON (Variant) column’s {} opens its fields, read from its first values just before this step: a field clicked is written into the expression last used, and + column adds it as a new column.',
 ];
 
 /** Why the Extend editor's Apply waits (PLAN §11.7) */
@@ -295,6 +456,10 @@ export const EXTEND_APPLY_DISABLED_REASON = Object.freeze({
 export const getExtendRetypeWarning = (firstLine: string): string =>
   `Could not check these columns' types again, so they keep their saved ones: ${firstLine}`;
 
+/** The warning on a Filter by Expression whose condition the engine couldn't check again, e.g. offline (PLAN §11.11) */
+export const getConditionRecheckWarning = (firstLine: string): string =>
+  `Could not check this condition again, so it keeps its last check: ${firstLine}`;
+
 /** 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 const getEditorKeptOpenNotice = (
   nodeId: string,
@@ -302,11 +467,35 @@ export const getEditorKeptOpenNotice = (
 ): string =>
   `The editor of ${nodeId} stays open, since its changes can't be applied yet: ${waiting}, or Cancel to drop them.`;
 
+/** Why the Filter by Expression editor's Apply waits (PLAN §11.11) */
+export const EXPRESSION_FILTER_APPLY_DISABLED_REASON = Object.freeze({
+  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 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 const EXPRESSION_FILTER_EDITOR_NOTES = [
+  "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.',
+] as const;
+
 /** The hint after an engine error on a column that can be empty, in arithmetic (PLAN §11.7) */
 export const EXTEND_TO_ONE_HINT =
-  'A column that can be empty needs ->toOne() first, such as $x.QTY->toOne() + 1.';
+  'An optional column needs ->toOne() first, such as $x.QTY->toOne() + 1.';
 
-/** The problem a database refusing an Extend's plan gives (PLAN §11.7) */
+/** The problem a database refusing an Extend's or a Filter by Expression's plan gives (PLAN §11.7, §11.11) */
 export const getExtendPlanProblem = (
   databaseType: string | undefined,
   detail: string,
@@ -317,13 +506,33 @@ export const getExtendPlanProblem = (
 export 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.';
 
+/** Words a title leaves in lower case, but first */
+const TITLE_SMALL_WORDS = new Set(['a', 'an', 'of']);
+
 /**
  * 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 const toEditorTitle = (label: string): string =>
-  label.replace(/(?<=^|\s)[a-z]/gu, (letter) => letter.toUpperCase());
+  label.replace(/(?<=^|\s)[a-z]+/gu, (word, offset: number) =>
+    offset > 0 && TITLE_SMALL_WORDS.has(word)
+      ? word
+      : `${word[0]?.toUpperCase() ?? ''}${word.slice(1)}`,
+  );
 
 /** The source dialog's body until a tab is chosen, opened from the empty canvas (spec §17.8, U4(b)) */
 export const SELECT_SOURCE_TYPE_PROMPT = 'Select source type above';
+
+/** Why the source dialog's Add is disabled: nothing picked yet, or not ready */
+export 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 const getCubeNodeBadge = (definition: {
+  readonly beta: boolean;
+  readonly wip?: boolean | undefined;
+}): 'WIP' | 'BETA' | undefined =>
+  definition.wip ? 'WIP' : definition.beta ? 'BETA' : undefined;

package/src/__lib__/LegendCubeNavigation.ts

@@ -0,0 +1,48 @@
+/**
+ * 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.
+ */
+
+/**
+ * The anchor Legend Marketplace's data product viewer gives an access point
+ * group, which it reads from the URL hash on load: as Legend Query writes it
+ * (`EXTERNAL_APPLICATION_NAVIGATION__generateMarketplaceDataProductUrl`)
+ *
+ * @external_application_navigation This depends on Legend Marketplace routing and is hardcoded so it's potentially brittle
+ */
+const EXTERNAL_APPLICATION_NAVIGATION__generateCubeAccessPointGroupAnchor = (
+  accessPointGroupId: string,
+): string =>
+  encodeURIComponent(
+    `apg-${accessPointGroupId}`.trim().toLowerCase().replace(/\s+/gu, '-'),
+  );
+
+/**
+ * A deployed data product's page in Legend Marketplace, at its access point
+ * group when one is given, as Legend Query links to it (PLAN §11.18)
+ *
+ * @external_application_navigation This depends on Legend Marketplace routing and is hardcoded so it's potentially brittle
+ */
+export const EXTERNAL_APPLICATION_NAVIGATION__generateCubeMarketplaceDataProductUrl =
+  (
+    marketplaceApplicationUrl: string,
+    dataProductId: string,
+    deploymentId: string,
+    accessPointGroupId?: string | undefined,
+  ): string =>
+    `${marketplaceApplicationUrl}/dataProduct/deployed/${dataProductId}/${deploymentId}${
+      accessPointGroupId
+        ? `#${EXTERNAL_APPLICATION_NAVIGATION__generateCubeAccessPointGroupAnchor(accessPointGroupId)}`
+        : ''
+    }`;

package/src/__lib__/LegendCubeProjectSourceLabels.ts

@@ -0,0 +1,26 @@
+/**
+ * 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.
+ */
+
+/**
+ * What the source dialog says on a host that reads one project's own
+ * sources (`CubeHost.project`), e.g. Studio
+ */
+export const CUBE_PROJECT_SOURCE_LABEL = {
+  RUNS_ON: (runtime: string): string => `Runs on ${runtime}`,
+  READING_RUNTIME: "reading the project's lakehouse runtime",
+  NO_INGEST_DEFINITIONS: 'The project has no ingest definitions.',
+  NO_DATA_PRODUCTS: 'The project has no data products.',
+} as const;

package/src/__lib__/LegendCubeServiceLabels.ts

@@ -0,0 +1,41 @@
+/**
+ * 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 { MESSAGE_SERVICE_NOT_READABLE } from '@finos/legend-cube';
+
+// The text of service sources (PLAN §6.4), in progress: the source dialog's
+// Service tab and a service's panel
+
+export const CUBE_SERVICE_MESSAGE = {
+  /** Why a service source isn't valid yet: its first line is the node's error */
+  NOT_READABLE: `${MESSAGE_SERVICE_NOT_READABLE}\nPicking a service works; reading its columns and rows is still being built.`,
+  NO_CATALOG: "This Legend deployment doesn't list services",
+  CUBE_CHANGED:
+    'The cube changed while the service was being added; pick it again.',
+  NONE: 'No services are deployed.',
+  NO_MATCH: 'No service matches the search.',
+  IN_PROGRESS:
+    "Services are in progress: a service can be added to the canvas, but Cube can't read it yet.",
+} as const;
+
+/** How many of the matching services the tab shows, when it doesn't show them all */
+export const getShownServicesLabel = (
+  shown: number,
+  matching: number,
+): string | undefined =>
+  shown < matching
+    ? `Showing ${shown} of ${matching} services: search to narrow the list`
+    : undefined;