@finos/legend-cube-builder 0.0.3 → 0.0.5

package/docs/testing.md

@@ -19,11 +19,15 @@ run some files, e.g. `TEST_GROUP=core yarn workspace @finos/legend-cube-builder
 - `TEST__renderInCubeApplication(<CubeEditor host={host} />, host.applicationStore, LEGEND_CUBE_TEST_ID.EDITOR)`
   renders the page in a Legend application and waits for it.
 - A test of one part of the page makes the state itself, `new CubeEditorState(host, document)`, and renders the part
-  with it, e.g. `<CubeCanvas editorState={editorState} />` and `<CubeNodeEditorPanel editorState={editorState} />`
-  (as `CubeJoinEditor.test.tsx` does). `TEST__importDocument(editorState, document)` then imports a cube and waits
-  for its tables to be typed again, so nothing changes after the test. A `<CubeEditor>` test has no handle on the
-  state, so it imports through the Import dialog.
-- `TEST__findCanvasNode(id)`, `TEST__getCanvasNodes()` and `TEST__getCanvasNodeTooltip(node)` read the canvas.
+  with it, e.g. `<CubeCanvas editorState={editorState} />`, which floats the node editor from the canvas when a node
+  is clicked (as `CubeJoinEditor.test.tsx` does). `TEST__importDocument(editorState, document)` then imports a cube and waits
+  for its tables to be typed again, so nothing changes after the test. A `<CubeEditor>` test gets the page's state by
+  spying on `CubeEditorState.prototype.registerCommands`, which the page calls once, and reading the spy's
+  `mock.contexts[0]` (as `CubeCommands.test.tsx`'s `renderPage` does); it imports a cube through the Import dialog.
+- `TEST__findCanvasNode(id)`, `TEST__getCanvasNodes()` and `TEST__getCanvasNodeTooltip(node)` read the canvas; the
+  tooltip's text is the node's `aria-description`.
+- `TEST__openAddItems()` and `TEST__chooseAddItem(label)` use the header's Add Items, e.g. to open the source dialog on
+  a table tab (`'Relational Database Table'`); the empty canvas's link opens it with no tab chosen.
 - `src/__test-utils__/CubeNorthwindTestQueries.ts` has the Northwind tables' columns and ready-made queries, e.g.
   `sliceQuery()`.
 
@@ -35,6 +39,16 @@ What jsdom can't do:
 - **Print a failing comparison of two queries.** A query holds `BigInt`s, which Jest can't print, so a failing
   `toBe` between queries crashes the worker. Compare them as booleans: `expect(a === b).toBe(true)`.
 
+The floating node editor (PLAN §11.8):
+
+- **A press outside it** closes it on `pointerdown`, which jsdom 20 has no event class for: dispatch
+  `new MouseEvent('pointerdown', { bubbles: true, button: 0 })`, as `useCubeNodeEditorDismiss.test.tsx` does
+  (`fireEvent.pointerDown` sends no button).
+- **Its placement** can be tested once the canvas's rectangle and the window's size are stubbed, as
+  `CubeNodeEditorPopper.test.tsx` does; flipping and scrolling are checked in a browser.
+- **A tooltip test** lets MUI's 800 ms memory of an open tooltip lapse after each test, or a retry (`jest.retryTimes`,
+  set for every package) passes on the shorter `enterNextDelay`, as `CubeCanvas.test.tsx`'s tooltip tests do.
+
 Drag and drop goes through react-dnd's HTML5 backend: fire `dragStart`, `dragEnter`, `dragOver`, `drop` and
 `dragEnd` on the elements.
 
@@ -58,14 +72,27 @@ would serve it.
   keys returned, types and nullability, not SQL or Pure formatting, and never an engine answer that is a known
   defect.
 - **Rows come back in the database's order** unless a Sort reaches the node that runs, and H2's order changes between
-  queries, so compare counts and sets, never positions, without a Sort. Facts of the Cube Northwind data a test may
-  rely on: ORDERS has 830 orders, `ORDER_ID` running from 10248 to 11077 with no gap. Avoid comparing or sorting on its
-  32-bit `REAL` columns (`FREIGHT`, `UNIT_PRICE`, `DISCOUNT`), where exact equality silently matches nothing.
+  queries, so compare counts and sets, never positions, without a Sort. A Concat's rows come in no order either.
+  Facts of the Cube Northwind data a test may rely on: ORDERS has 830 orders, `ORDER_ID` running from 10248 to 11077
+  with no gap, in 21 ship countries; CUSTOMERS has 91 rows and SUPPLIERS 29; `CUBETEST.ALLTYPES` has 3 rows, ID 3
+  empty but for its key. Better still, check a result against its tables run alone, as the Concat tests do. Avoid
+  comparing or sorting on its 32-bit `REAL` columns (`FREIGHT`, `UNIT_PRICE`, `DISCOUNT`), where exact equality
+  silently matches nothing.
 - `src/__tests__/LegendCubeNorthwind.engine-roundtrip-test.ts` is the slice's automated acceptance (PLAN §11.2 Part
   A). It logs the engine's commit.
 - `src/__tests__/LegendCubeOperations.engine-roundtrip-test.ts` checks each operation: its lambda as the engine parses
   the printed Pure, its typing against Cube's inferred schema, and its rows. Its helpers are in
   `src/__test-utils__/CubeOperationsTestUtils.ts`; they take any `CubeEngine` and import no `V1_*` class.
+- `src/__tests__/CubeInferenceConformance.engine-roundtrip-test.ts` holds Cube's inference to the engine's (PLAN
+  §11.5): it types every node of every case in one batch and compares names, positions, precise types with their
+  parameters, and nullability exactly (`TEST__typingDifferences`). Where the engine misreports nullability (an outer
+  join's padded columns, the FULL merged key, a Difference's keys named apart, an Extend's columns after `toOne()`), a
+  case lists the columns in `widerNullable`, and Cube must say nullable
+  there. Every registered node type needs a case, or the coverage test fails, but a data product's access point
+  (`NOT_TYPED_BY_THE_ENGINE`: the open-source engine reads no data product; `CubeDataProduct.engine-roundtrip-test.ts`
+  types its stand-in). A case whose Concat converts types names the types it converts (`converted`), so a case that
+  silently stops converting fails. A case's every node must be valid. The saved-spec samples are typed the same way,
+  node by node, but one-way (`CubeSpecCorpus.engine-roundtrip-test.ts`).
 - **Sort descending in order tests.** H2 scans ORDERS in ascending `ORDER_ID` order, so a test that sorts ascending,
   or numbers rows by `ORDER_ID`, passes without the sort; the operations tests sort descending, with a control test
   pinning H2's own order.
@@ -73,11 +100,121 @@ would serve it.
   them on the fixture's H2, which takes both forms, so their rows can be compared with the native forms'.
   `src/__tests__/LegendCubeDialects.engine-roundtrip-test.ts` plans them, never running anything, on a test-only copy
   of the fixture model with a static connection per database type (`CUBE_ENGINE_TEST__generatePlanSql`), and checks
-  facts about the SQL: row numbers in the Sort's order, no `limit m,n`, no `top N distinct`. A check that should catch
+  facts about the SQL: row numbers in the Sort's order, no `limit m,n`, no `top N distinct`; for Group, its reduces,
+  HAVING and the GROUP BY target after two Renames (an engine issue, pinned); for Concat, one UNION ALL, each input's
+  Sort and Limit in its own subquery, and no SQL cast when it converts types. A check that should catch
   a missing workaround must fail without it: run it once with the workaround off before relying on it.
+- **Windows** (PLAN §11.6) are planned in `WINDOW_SHAPES` over `WINDOW_DATABASE_TYPES`, since Spanner, Presto and
+  Composite refuse any window (pinned): an OVER clause with no frame, `count(col)` and `count(1)` for the counts,
+  `rank()`, `dense_rank()` and `row_number()`, M5b's `ntile`, `percent_rank`, `cume_dist`, `lag`, `lead` and
+  `first_value`, Last's over the reversed sort (ClickHouse's own `lagInFrame` and `leadInFrame` over a whole-partition
+  frame, DuckDB's `first`), with the reversed sort putting empty values at the other end on every type, a Filter after a Partition as a `WITH n_…` and a `WHERE` outside the
+  window, never QUALIFY, and the capture's ORDER BY at the root. Run, they are checked three ways: the operations
+  tests ("Partition on the engine"), with values worked out on the fixture (rows tied on the sort share a running
+  value and a rank); `LegendCubeDirectConnectionOperations.engine-roundtrip-test.ts` on H2 and DuckDB, a second
+  database that runs them, windowed Distinct Count included; and `CubeWindowComposition.engine-roundtrip-test.ts`,
+  which runs pairs and triples of nodes with a Partition against a small JavaScript reference with SQL's null rules
+  and default frame (and M5b's functions, refusing a tie for the ones that depend on a row's place), checks every Partition is written in the array form, and shows (its negative control) that the
+  single form, unbound, gives wrong rows. The core's `PartitionEmitter.test.ts` pins the emitted text.
+  `CubeWindowIsolation.engine-roundtrip-test.ts` checks the lets themselves through the adapter, with a test-only
+  window: they run, type, show in Show Pure, and put an error inside a let on its window.
+- **Difference and Extend** (PLAN §11.7). The operations tests run a Difference against a reference computed from its
+  inputs' own rows, every numeric family included; the plan-only test pins its join (a native `full outer join` on
+  every type but H2, where the engine emulates it) and its `coalesce(…, 0) - coalesce(…, 0)`, never a cast, and an
+  Extend's columns written as their expressions; both run on H2 and DuckDB through the direct connection.
+  `CubeExpressions.engine-roundtrip-test.ts` covers Extend's engine calls: an expression parsed with its digits and
+  locations, typed as a chain after its input over the cube's model (its own enumerations and functions too), the
+  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.
 - `src/__tests__/CubeNorthwindRelationTypes.json` records the engine's relation type for every table of the bundled
   model. If the test comparing with it fails, the engine's typing changed: check the change, then record the file
   again by hand.
 
+### Direct connections
+
+- `TEST__createCubeHost()` also gives `connections`, a fake connection explorer
+  (`src/__test-utils__/FakeCubeConnectionExplorer.ts`) whose `listSchemas` answers `CUBE_DIRECT` and whose `listTables`
+  answers `FAKE_DIRECT_TABLES`, each a Jest mock.
+- On the engine, `V1_createEngineBackedCubeEngine()` also spies `buildDatabase` (schema exploration), and
+  `V1_createEngineBackedCubeConnectionExplorer()` gives a real explorer. `directH2Connection(schema)` and
+  `directDuckDBConnection(schema)` (`src/__test-utils__/CubeDirectConnectionFixtures.ts`) build small databases from
+  setup SQL.
+- **Setup SQL runs on every pooled connection**, so a setup must first drop what it creates. Each engine test file
+  still uses its own schema names, so files never depend on each other's data.
+- **Never assert an engine answer that is a known defect.** Schema exploration types H2's and DuckDB's `DECIMAL(10,2)`
+  as `Numeric(0,0)` and DuckDB's `VARCHAR(5)` as `Varchar(0)`; only the core's DuckDB sample
+  (`packages/legend-cube/src/spec/__tests__/fixtures/direct/`) holds those types, and no engine test reads it.
+
+### Data products and ingest data sets
+
+- **Fakes.** `TEST__createCubeHost()` also gives `dataProducts`, a fake data product catalog
+  (`src/__test-utils__/FakeCubeDataProductCatalog.ts`). An ingest catalog is opt-in: build one per test with
+  `createFakeCubeIngestCatalog()` (`src/__test-utils__/FakeCubeIngestCatalog.ts`) and pass its `catalog` as the host's
+  `ingestCatalog`; without it, Cube offers no Ingest tab.
+- **The open-source engine reads neither.** It has no data product or ingest definition to read, can't parse an ingest
+  definition, and can't type or run a `#I{...}#` accessor. So the engine tests stand each source in for with a Pure
+  function declaring the relation type the source would have, over an H2 table:
+  `src/__tests__/CubeDataProduct.engine-roundtrip-test.ts` for access points, and
+  `src/__tests__/CubeIngest.engine-roundtrip-test.ts` for ingest data sets. The ingest one swaps each accessor Cube
+  emits for its stand-in, then checks the nodes downstream (a Filter on `LAKE_OUT_ID`, a Join of two data sets, a
+  Group) against the engine's typing, and runs them.
+- **Testable locally:** reading a definition's data sets and types, the URN parser, the saved model, the source
+  dialog, the panels and the re-checks, all with fakes; downstream lambdas, on the stand-ins.
+- **Not testable locally:** the ingest servers' answers, the parse of a deployed definition's grammar, compiling and
+  running `#I{...}#`, the environment name and whether a warehouse is accepted. Those are checked in an internal
+  deployment (PLAN §11.2 Part B2).
+
 The engine tests in `src/__tests__/` import `V1_*` classes there, as an exception to the V1 rule: they need both the
 `v1/` adapter and `stores/`, which the import-hierarchy lint rule keeps apart.
+
+### Depot databases
+
+- **Fakes.** `createFakeCubeProjectCatalog()` (`src/__test-utils__/FakeCubeProjectCatalog.ts`) gives a catalog to pass
+  as the host's `projectCatalog`; without one, Cube offers no Project tab. Its `com.example:sales` holds the fake
+  engine's Northwind Database, so the fake engine types its tables.
+- **CI:** `src/__tests__/CubeDepotSamples.engine-roundtrip-test.ts` compiles the mock depot's committed sample
+  projects and types every table of their own Databases. The engine fetches a pointer's project from a depot, which CI
+  doesn't run, so no CI test sends a pointer.
+- **By hand (`cube-local`):** with the engine on :6300 and `yarn dev:mock-depot-server` on :6200,
+  `TEST_GROUP=cube-local yarn workspace @finos/legend-cube-builder test` runs the real catalog, the engine's pointer
+  fetch and the Project tab end to end (`src/__tests__/CubeDepot.cube-local-test.ts`). Its depot client sends its GETs
+  through axios, since the repo's Jest setup blocks `fetch`.
+- **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

@@ -16,11 +16,14 @@
 import type { CommandConfigData } from '@finos/legend-application';
 export declare enum LEGEND_CUBE_COMMAND_KEY {
     EXECUTE = "legend-cube.execute",
-    UNDO = "legend-cube.undo"
+    UNDO = "legend-cube.undo",
+    REDO = "legend-cube.redo",
+    VALIDATE_EXPRESSIONS = "legend-cube.validate-expressions"
 }
 /** Keys as `KeyboardEvent.code` names */
 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;CAC1B;AAED,yCAAyC;AACzC,eAAO,MAAM,0BAA0B,EAAE,iBAUxC,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,8 @@ 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 */
 export const LEGEND_CUBE_COMMAND_CONFIG = {
@@ -33,8 +35,18 @@ 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',
+    },
 };
 /** 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,uBAGX;AAHD,WAAY,uBAAuB;IACjC,0DAA+B,CAAA;IAC/B,oDAAyB,CAAA;AAC3B,CAAC,EAHW,uBAAuB,KAAvB,uBAAuB,QAGlC;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;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__/LegendCubeDataProductLabels.d.ts

@@ -0,0 +1,45 @@
+/**
+ * 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 { CubeDataProductEnvironmentType } from '../graph-manager/CubeDataProduct.js';
+import { CubeAccessPointGroupAccess } from '../graph-manager/CubeDataProductCatalog.js';
+/** The deployment classes' labels, as Data Cube shows them */
+export declare const CUBE_DATA_PRODUCT_ENVIRONMENT_LABELS: Readonly<Record<CubeDataProductEnvironmentType, string>>;
+/** Said of a project deployed from a SNAPSHOT version */
+export declare const CUBE_SNAPSHOT_VERSION_LABEL = "A SNAPSHOT version: its data and columns may change";
+export declare const CUBE_WAREHOUSE_APPLY_TITLE = "Use this warehouse for the cube's next runs; it's remembered for your next cubes";
+/** The warning on an access point that changed since the cube was saved; its new columns are used */
+export declare const getAccessPointDriftWarning: (diff: SchemaDiff) => string;
+/** The warning on an access point Cube couldn't re-check, which keeps its saved columns */
+export declare const getAccessPointRecheckWarning: (firstLine: string) => string;
+export declare const CUBE_DATA_PRODUCT_RECHECK_MESSAGE: {
+    readonly NO_ANSWER: "The data product catalog gave no columns for this access point";
+    readonly NO_CATALOG: "This Legend deployment doesn't serve data products";
+};
+/**
+ * Beside a run's error that says the cube's warehouse can't be used; it
+ * offers another only where the warehouse can be changed
+ */
+export declare const getCubeWarehouseErrorHint: (warehouse: string, canPickAnother: boolean) => string;
+/** A link to ask for access to an access point group in the marketplace */
+export declare const getCubeRequestAccessLabel: (accessPointGroup: string | undefined, dataProductName: string | undefined) => string;
+/**
+ * The viewer's access to a group, as the marketplace says it; a group with
+ * no access, or refused, offers to request it instead
+ */
+export declare const CUBE_ACCESS_POINT_GROUP_ACCESS_LABELS: Readonly<Partial<Record<CubeAccessPointGroupAccess, string>>>;
+export declare const CUBE_NO_ACCESS_LABEL = "No access";
+//# sourceMappingURL=LegendCubeDataProductLabels.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"LegendCubeDataProductLabels.d.ts","sourceRoot":"","sources":["../../src/__lib__/LegendCubeDataProductLabels.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,EAAE,8BAA8B,EAAE,MAAM,qCAAqC,CAAC;AACrF,OAAO,EAAE,0BAA0B,EAAE,MAAM,4CAA4C,CAAC;AAMxF,8DAA8D;AAC9D,eAAO,MAAM,oCAAoC,EAAE,QAAQ,CACzD,MAAM,CAAC,8BAA8B,EAAE,MAAM,CAAC,CAI/C,CAAC;AAEF,yDAAyD;AACzD,eAAO,MAAM,2BAA2B,wDACe,CAAC;AAExD,eAAO,MAAM,0BAA0B,qFAC6C,CAAC;AAErF,qGAAqG;AACrG,eAAO,MAAM,0BAA0B,GAAI,MAAM,UAAU,KAAG,MACsB,CAAC;AAErF,2FAA2F;AAC3F,eAAO,MAAM,4BAA4B,GAAI,WAAW,MAAM,KAAG,MACoB,CAAC;AAEtF,eAAO,MAAM,iCAAiC;;;CAGpC,CAAC;AAEX;;;GAGG;AACH,eAAO,MAAM,yBAAyB,GACpC,WAAW,MAAM,EACjB,gBAAgB,OAAO,KACtB,MAGqD,CAAC;AAEzD,2EAA2E;AAC3E,eAAO,MAAM,yBAAyB,GACpC,kBAAkB,MAAM,GAAG,SAAS,EACpC,iBAAiB,MAAM,GAAG,SAAS,KAClC,MAGmB,CAAC;AAEvB;;;GAGG;AACH,eAAO,MAAM,qCAAqC,EAAE,QAAQ,CAC1D,OAAO,CAAC,MAAM,CAAC,0BAA0B,EAAE,MAAM,CAAC,CAAC,CAUpD,CAAC;AAEF,eAAO,MAAM,oBAAoB,cAAc,CAAC"}

package/lib/__lib__/LegendCubeDataProductLabels.js

@@ -0,0 +1,60 @@
+/**
+ * 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 { CubeDataProductEnvironmentType } from '../graph-manager/CubeDataProduct.js';
+import { CubeAccessPointGroupAccess } from '../graph-manager/CubeDataProductCatalog.js';
+import { getSchemaChangeList } from './LegendCubeLabels.js';
+// The text of data product sources (PLAN §6.8): the source dialog's Data
+// product tab and a data product source's panel
+/** The deployment classes' labels, as Data Cube shows them */
+export const CUBE_DATA_PRODUCT_ENVIRONMENT_LABELS = {
+    [CubeDataProductEnvironmentType.PRODUCTION]: 'Production',
+    [CubeDataProductEnvironmentType.PRODUCTION_PARALLEL]: 'Production (parallel)',
+};
+/** Said of a project deployed from a SNAPSHOT version */
+export const CUBE_SNAPSHOT_VERSION_LABEL = 'A SNAPSHOT version: its data and columns may change';
+export const CUBE_WAREHOUSE_APPLY_TITLE = "Use this warehouse for the cube's next runs; it's remembered for your next cubes";
+/** The warning on an access point that changed since the cube was saved; its new columns are used */
+export const getAccessPointDriftWarning = (diff) => `This access point changed since the cube was saved: ${getSchemaChangeList(diff)}`;
+/** The warning on an access point Cube couldn't re-check, which keeps its saved columns */
+export const getAccessPointRecheckWarning = (firstLine) => `Could not re-check this access point, so it keeps its saved columns: ${firstLine}`;
+export const CUBE_DATA_PRODUCT_RECHECK_MESSAGE = {
+    NO_ANSWER: 'The data product catalog gave no columns for this access point',
+    NO_CATALOG: "This Legend deployment doesn't serve data products",
+};
+/**
+ * Beside a run's error that says the cube's warehouse can't be used; it
+ * offers another only where the warehouse can be changed
+ */
+export const getCubeWarehouseErrorHint = (warehouse, canPickAnother) => canPickAnother
+    ? `The run couldn't use the warehouse ${warehouse}. Pick another one in a source's panel.`
+    : `The run couldn't use the warehouse ${warehouse}.`;
+/** A link to ask for access to an access point group in the marketplace */
+export const getCubeRequestAccessLabel = (accessPointGroup, dataProductName) => accessPointGroup && dataProductName
+    ? `Request access to ${accessPointGroup} in ${dataProductName}`
+    : 'Request access';
+/**
+ * The viewer's access to a group, as the marketplace says it; a group with
+ * no access, or refused, offers to request it instead
+ */
+export const CUBE_ACCESS_POINT_GROUP_ACCESS_LABELS = {
+    [CubeAccessPointGroupAccess.ENTERPRISE]: 'Enterprise access',
+    [CubeAccessPointGroupAccess.APPROVED]: 'Entitled',
+    [CubeAccessPointGroupAccess.SUBMITTED_FOR_APPROVALS]: 'Submitted for approval',
+    [CubeAccessPointGroupAccess.PENDING_MANAGER_APPROVAL]: 'Pending manager approval',
+    [CubeAccessPointGroupAccess.PENDING_DATA_OWNER_APPROVAL]: 'Pending data owner approval',
+};
+export const CUBE_NO_ACCESS_LABEL = 'No access';
+//# sourceMappingURL=LegendCubeDataProductLabels.js.map

package/lib/__lib__/LegendCubeDataProductLabels.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"LegendCubeDataProductLabels.js","sourceRoot":"","sources":["../../src/__lib__/LegendCubeDataProductLabels.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAGH,OAAO,EAAE,8BAA8B,EAAE,MAAM,qCAAqC,CAAC;AACrF,OAAO,EAAE,0BAA0B,EAAE,MAAM,4CAA4C,CAAC;AACxF,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAE5D,yEAAyE;AACzE,gDAAgD;AAEhD,8DAA8D;AAC9D,MAAM,CAAC,MAAM,oCAAoC,GAE7C;IACF,CAAC,8BAA8B,CAAC,UAAU,CAAC,EAAE,YAAY;IACzD,CAAC,8BAA8B,CAAC,mBAAmB,CAAC,EAAE,uBAAuB;CAC9E,CAAC;AAEF,yDAAyD;AACzD,MAAM,CAAC,MAAM,2BAA2B,GACtC,qDAAqD,CAAC;AAExD,MAAM,CAAC,MAAM,0BAA0B,GACrC,kFAAkF,CAAC;AAErF,qGAAqG;AACrG,MAAM,CAAC,MAAM,0BAA0B,GAAG,CAAC,IAAgB,EAAU,EAAE,CACrE,uDAAuD,mBAAmB,CAAC,IAAI,CAAC,EAAE,CAAC;AAErF,2FAA2F;AAC3F,MAAM,CAAC,MAAM,4BAA4B,GAAG,CAAC,SAAiB,EAAU,EAAE,CACxE,wEAAwE,SAAS,EAAE,CAAC;AAEtF,MAAM,CAAC,MAAM,iCAAiC,GAAG;IAC/C,SAAS,EAAE,gEAAgE;IAC3E,UAAU,EAAE,oDAAoD;CACxD,CAAC;AAEX;;;GAGG;AACH,MAAM,CAAC,MAAM,yBAAyB,GAAG,CACvC,SAAiB,EACjB,cAAuB,EACf,EAAE,CACV,cAAc;IACZ,CAAC,CAAC,sCAAsC,SAAS,yCAAyC;IAC1F,CAAC,CAAC,sCAAsC,SAAS,GAAG,CAAC;AAEzD,2EAA2E;AAC3E,MAAM,CAAC,MAAM,yBAAyB,GAAG,CACvC,gBAAoC,EACpC,eAAmC,EAC3B,EAAE,CACV,gBAAgB,IAAI,eAAe;IACjC,CAAC,CAAC,qBAAqB,gBAAgB,OAAO,eAAe,EAAE;IAC/D,CAAC,CAAC,gBAAgB,CAAC;AAEvB;;;GAGG;AACH,MAAM,CAAC,MAAM,qCAAqC,GAE9C;IACF,CAAC,0BAA0B,CAAC,UAAU,CAAC,EAAE,mBAAmB;IAC5D,CAAC,0BAA0B,CAAC,QAAQ,CAAC,EAAE,UAAU;IACjD,CAAC,0BAA0B,CAAC,uBAAuB,CAAC,EAClD,wBAAwB;IAC1B,CAAC,0BAA0B,CAAC,wBAAwB,CAAC,EACnD,0BAA0B;IAC5B,CAAC,0BAA0B,CAAC,2BAA2B,CAAC,EACtD,6BAA6B;CAChC,CAAC;AAEF,MAAM,CAAC,MAAM,oBAAoB,GAAG,WAAW,CAAC"}

package/lib/__lib__/LegendCubeDirectConnectionLabels.d.ts

@@ -0,0 +1,56 @@
+/**
+ * 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 { CubeConnectionDatasourceKind, type CubeConnectionSummary } from '../graph-manager/CubeConnectionExplorer.js';
+/**
+ * The setup SQL the H2 form starts with (D5): a small sample database that
+ * first drops what it creates, since setup SQL runs on every connection
+ */
+export declare const CUBE_DIRECT_SAMPLE_SETUP_SQL: string;
+/** Pending labels: lower-case gerunds, shown as they are (spec §17.13) */
+export declare enum CUBE_DIRECT_PENDING_LABEL {
+    TESTING_CONNECTION = "testing connection",
+    LISTING_TABLES = "listing tables"
+}
+export declare const CUBE_DIRECT_MESSAGE: {
+    readonly H2_NEEDS_SETUP_SQL: "An H2 connection needs setup SQL: the engine creates the database from it";
+    readonly CUBE_CHANGED: "The cube changed while the table was loading; pick the table again.";
+    readonly NO_SCHEMA_FOUND: "The database has no schema Cube can read";
+    readonly NO_TABLE_SCHEMA: "The engine gave no schema for this table";
+};
+/** The text of loading a CSV into an in-memory DuckDB connection */
+export declare const CUBE_CSV_MESSAGE: {
+    readonly EMPTY: "The CSV is empty: its first row must name the columns";
+    readonly UNCLOSED_QUOTE: (line: number) => string;
+    readonly RAGGED_ROW: (row: number, values: number, columns: number) => string;
+    readonly TOO_MANY_ROWS: (rows: number, max: number) => string;
+    readonly TOO_LONG: (max: number) => string;
+    readonly ADDED: (table: string, rows: number, columns: number) => string;
+    readonly UNREADABLE_FILE: (name: string) => string;
+};
+export declare const CUBE_CSV_HELP_TEXT = "Paste a CSV, or choose a file, with a header row. Cube adds it to the setup SQL as a table of the csv schema, guessing each column's type from its values; edit the SQL to change them. Up to 10,000 rows: the cube saves them.";
+export declare const CUBE_DIRECT_HELP_TEXT: {
+    readonly SETUP_SQL: "The engine runs these statements on every connection, so they should first drop what they create. A statement ends with a line ending in ';'. A statement that returns rows, such as a select, fails.";
+    readonly DUCKDB_PATH: "A DuckDB file on the engine's host; leave it empty for an in-memory database.";
+    readonly FIXED_CONNECTION: "All of the cube's tables come from this connection: to use another one, remove every node from the cube first.";
+};
+export declare const CUBE_DIRECT_DATASOURCE_LABELS: Readonly<Record<CubeConnectionDatasourceKind, string>>;
+/** How many of a table's columns Cube leaves out, or nothing when it keeps them all */
+export declare const getHiddenColumnsLabel: (count: number) => string | undefined;
+/** What the page shows of a saved connection: never its setup SQL */
+export declare const getCubeConnectionSummaryLabel: (summary: CubeConnectionSummary) => string;
+/** A direct connection shown where Cube can't describe it, e.g. on a host without an explorer */
+export declare const CUBE_DIRECT_CONNECTION_FALLBACK_LABEL = "A direct database connection";
+//# sourceMappingURL=LegendCubeDirectConnectionLabels.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"LegendCubeDirectConnectionLabels.d.ts","sourceRoot":"","sources":["../../src/__lib__/LegendCubeDirectConnectionLabels.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EACL,4BAA4B,EAC5B,KAAK,qBAAqB,EAC3B,MAAM,4CAA4C,CAAC;AAIpD;;;GAGG;AACH,eAAO,MAAM,4BAA4B,QAO7B,CAAC;AAEb,0EAA0E;AAC1E,oBAAY,yBAAyB;IACnC,kBAAkB,uBAAuB;IACzC,cAAc,mBAAmB;CAClC;AAED,eAAO,MAAM,mBAAmB;;;;;CAOtB,CAAC;AAIX,oEAAoE;AACpE,eAAO,MAAM,gBAAgB;;oCAEJ,MAAM,KAAG,MAAM;+BAEpB,MAAM,UAAU,MAAM,WAAW,MAAM,KAAG,MAAM;mCAE5C,MAAM,OAAO,MAAM,KAAG,MAAM;6BAElC,MAAM,KAAG,MAAM;4BAEhB,MAAM,QAAQ,MAAM,WAAW,MAAM,KAAG,MAAM;qCAErC,MAAM,KAAG,MAAM;CAE/B,CAAC;AAEX,eAAO,MAAM,kBAAkB,oOACoM,CAAC;AAEpO,eAAO,MAAM,qBAAqB;;;;CAOxB,CAAC;AAEX,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAClD,MAAM,CAAC,4BAA4B,EAAE,MAAM,CAAC,CAO7C,CAAC;AAEF,uFAAuF;AACvF,eAAO,MAAM,qBAAqB,GAAI,OAAO,MAAM,KAAG,MAAM,GAAG,SAGF,CAAC;AAE9D,qEAAqE;AACrE,eAAO,MAAM,6BAA6B,GACxC,SAAS,qBAAqB,KAC7B,MAKW,CAAC;AAEf,iGAAiG;AACjG,eAAO,MAAM,qCAAqC,iCAClB,CAAC"}

package/lib/__lib__/LegendCubeDirectConnectionLabels.js

@@ -0,0 +1,76 @@
+/**
+ * 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 { CubeConnectionDatasourceKind, } from '../graph-manager/CubeConnectionExplorer.js';
+// The text of the source picker's database connection tab (PLAN §6.8)
+/**
+ * The setup SQL the H2 form starts with (D5): a small sample database that
+ * first drops what it creates, since setup SQL runs on every connection
+ */
+export const CUBE_DIRECT_SAMPLE_SETUP_SQL = [
+    'drop schema if exists CUBE_SAMPLE cascade;',
+    'create schema CUBE_SAMPLE;',
+    'create table CUBE_SAMPLE.CUSTOMERS (CUSTOMER_ID VARCHAR(5) PRIMARY KEY, COMPANY_NAME VARCHAR(40) NOT NULL, COUNTRY VARCHAR(15));',
+    "insert into CUBE_SAMPLE.CUSTOMERS values ('ALFKI', 'Alfreds Futterkiste', 'Germany'), ('ANATR', 'Ana Trujillo Emparedados', 'Mexico'), ('BONAP', 'Bon app''', 'France');",
+    'create table CUBE_SAMPLE.ORDERS (ORDER_ID INT PRIMARY KEY, CUSTOMER_ID VARCHAR(5) NOT NULL, ORDER_DATE DATE, AMOUNT DECIMAL(10,2));',
+    "insert into CUBE_SAMPLE.ORDERS values (10248, 'ALFKI', '1997-07-04', 32.38), (10249, 'ANATR', '1997-07-05', 11.61), (10250, 'BONAP', '1997-07-08', 65.83), (10251, 'ALFKI', '1997-07-08', 41.34);",
+].join('\n');
+/** Pending labels: lower-case gerunds, shown as they are (spec §17.13) */
+export var CUBE_DIRECT_PENDING_LABEL;
+(function (CUBE_DIRECT_PENDING_LABEL) {
+    CUBE_DIRECT_PENDING_LABEL["TESTING_CONNECTION"] = "testing connection";
+    CUBE_DIRECT_PENDING_LABEL["LISTING_TABLES"] = "listing tables";
+})(CUBE_DIRECT_PENDING_LABEL || (CUBE_DIRECT_PENDING_LABEL = {}));
+export const CUBE_DIRECT_MESSAGE = {
+    H2_NEEDS_SETUP_SQL: 'An H2 connection needs setup SQL: the engine creates the database from it',
+    CUBE_CHANGED: 'The cube changed while the table was loading; pick the table again.',
+    NO_SCHEMA_FOUND: 'The database has no schema Cube can read',
+    NO_TABLE_SCHEMA: 'The engine gave no schema for this table',
+};
+const formatCount = (value) => value.toLocaleString('en-US');
+/** The text of loading a CSV into an in-memory DuckDB connection */
+export const CUBE_CSV_MESSAGE = {
+    EMPTY: 'The CSV is empty: its first row must name the columns',
+    UNCLOSED_QUOTE: (line) => `The quoted value that starts on line ${line} is never closed`,
+    RAGGED_ROW: (row, values, columns) => `Row ${formatCount(row)} has ${formatCount(values)} ${values === 1 ? 'value' : 'values'}, but the header names ${formatCount(columns)} ${columns === 1 ? 'column' : 'columns'}`,
+    TOO_MANY_ROWS: (rows, max) => `The CSV has ${formatCount(rows)} rows; Cube loads at most ${formatCount(max)}, since the cube saves them and every run loads them again`,
+    TOO_LONG: (max) => `The CSV is too long: Cube loads at most ${formatCount(max)} characters`,
+    ADDED: (table, rows, columns) => `Added table ${table}: ${formatCount(rows)} ${rows === 1 ? 'row' : 'rows'}, ${formatCount(columns)} ${columns === 1 ? 'column' : 'columns'}. Test the connection to list it.`,
+    UNREADABLE_FILE: (name) => `Cube couldn't read the file ${name}`,
+};
+export const CUBE_CSV_HELP_TEXT = "Paste a CSV, or choose a file, with a header row. Cube adds it to the setup SQL as a table of the csv schema, guessing each column's type from its values; edit the SQL to change them. Up to 10,000 rows: the cube saves them.";
+export const CUBE_DIRECT_HELP_TEXT = {
+    SETUP_SQL: "The engine runs these statements on every connection, so they should first drop what they create. A statement ends with a line ending in ';'. A statement that returns rows, such as a select, fails.",
+    DUCKDB_PATH: "A DuckDB file on the engine's host; leave it empty for an in-memory database.",
+    FIXED_CONNECTION: "All of the cube's tables come from this connection: to use another one, remove every node from the cube first.",
+};
+export const CUBE_DIRECT_DATASOURCE_LABELS = {
+    [CubeConnectionDatasourceKind.LOCAL_H2]: "an H2 database in the engine's H2 server",
+    [CubeConnectionDatasourceKind.DUCKDB_IN_MEMORY]: 'an in-memory DuckDB database',
+    [CubeConnectionDatasourceKind.DUCKDB_FILE]: 'a DuckDB file',
+};
+/** How many of a table's columns Cube leaves out, or nothing when it keeps them all */
+export const getHiddenColumnsLabel = (count) => count === 0
+    ? undefined
+    : `${count} ${count === 1 ? 'column' : 'columns'} hidden`;
+/** What the page shows of a saved connection: never its setup SQL */
+export const getCubeConnectionSummaryLabel = (summary) => [
+    `${summary.databaseType}: ${CUBE_DIRECT_DATASOURCE_LABELS[summary.datasourceKind]}${summary.path ? ` (${summary.path})` : ''}`,
+    `${summary.setupSqlCount} setup ${summary.setupSqlCount === 1 ? 'statement' : 'statements'}`,
+    `authentication ${summary.authenticationKind}`,
+].join(', ');
+/** A direct connection shown where Cube can't describe it, e.g. on a host without an explorer */
+export const CUBE_DIRECT_CONNECTION_FALLBACK_LABEL = 'A direct database connection';
+//# sourceMappingURL=LegendCubeDirectConnectionLabels.js.map

package/lib/__lib__/LegendCubeDirectConnectionLabels.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"LegendCubeDirectConnectionLabels.js","sourceRoot":"","sources":["../../src/__lib__/LegendCubeDirectConnectionLabels.ts"],"names":[],"mappings":"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"}

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;AAoBH,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAmBhE,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;AAgCH,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CA+ChE,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"}