@finos/legend-cube-builder 0.0.3 → 0.0.5

package/lib/stores/CubeHost.d.ts

@@ -14,7 +14,14 @@
  * limitations under the License.
  */
 import type { GenericLegendApplicationStore } from '@finos/legend-application';
-import type { CubeEngine } from '../graph-manager/CubeEngine.js';
+import type { ModelContext } from '@finos/legend-cube';
+import type { CubeConnectionExplorer } from '../graph-manager/CubeConnectionExplorer.js';
+import type { CubeDataProductCatalog } from '../graph-manager/CubeDataProductCatalog.js';
+import type { CubeEngineClientSettings } from '../graph-manager/CubeEngineClientSettings.js';
+import type { CubeIngestCatalog } from '../graph-manager/CubeIngestCatalog.js';
+import { type CubeEngine, type CubeModelOutline } from '../graph-manager/CubeEngine.js';
+import type { CubeProjectCatalog } from '../graph-manager/CubeProjectCatalog.js';
+import type { CubeServiceCatalog } from '../graph-manager/CubeServiceCatalog.js';
 import type { LocalModelCatalog } from './LocalModelCatalog.js';
 /**
  * What the application hosting the Cube page gives it (PLAN §3.5, Settled
@@ -27,5 +34,71 @@ export interface CubeHost {
     readonly applicationStore: GenericLegendApplicationStore;
     readonly engine: CubeEngine;
     readonly modelCatalog: LocalModelCatalog;
+    /**
+     * Reads the databases behind direct connections (PLAN §6.8); without one,
+     * the source picker offers no database connection
+     */
+    readonly connectionExplorer?: CubeConnectionExplorer | undefined;
+    /**
+     * The deployed data products (PLAN §6.8); without one, the source dialog
+     * offers no data products
+     */
+    readonly dataProductCatalog?: CubeDataProductCatalog | undefined;
+    /**
+     * The deployed ingest definitions (PLAN §6.7); without one, the source
+     * dialog offers no ingest data sets
+     */
+    readonly ingestCatalog?: CubeIngestCatalog | undefined;
+    /**
+     * The published projects in the host's depot (PLAN §6.3); without one, the
+     * source dialog offers no projects
+     */
+    readonly projectCatalog?: CubeProjectCatalog | undefined;
+    /**
+     * The deployed services (PLAN §6.4), in progress; without one, the source
+     * dialog offers no services
+     */
+    readonly serviceCatalog?: CubeServiceCatalog | undefined;
+    /**
+     * The engine URL and request compression its engine clients share, which
+     * Dev Settings changes (PLAN §11.16); without them, Dev Settings can't
+     * change either
+     */
+    readonly engineClientSettings?: CubeEngineClientSettings | undefined;
+    /**
+     * Whether the page offers Cube's sample data: the source dialog's Sample
+     * Data tab and the Examples. Offered unless the host says no, as Studio
+     * does, where a cube reads only the project's ingest definitions
+     */
+    readonly offersSampleData?: boolean | undefined;
+    /**
+     * The one project whose own sources the page reads, e.g. the one Studio
+     * edits: the source dialog lists its ingest definitions and data products
+     * by name and path, with no class, deployment or search across the
+     * platform, and says which lakehouse runtime its runs use
+     */
+    readonly project?: CubeHostProject | undefined;
 }
+/** The lakehouse runtime a project's runs use, as the source dialog shows it */
+export interface CubeHostProjectRuntime {
+    /** e.g. `demo-dev, from demo::ingest::LakehouseRuntime` */
+    readonly label: string;
+    /** The warehouse a new cube starts on, when the runtime names one */
+    readonly warehouse?: string | undefined;
+}
+/** The one project a host's page reads the sources of (`CubeHost.project`) */
+export interface CubeHostProject {
+    /** Its lakehouse runtime; fails with a `CubeEngineError` saying why when it has none */
+    resolveRuntime(): Promise<CubeHostProjectRuntime>;
+}
+/** Whether the host's page reads one project's own sources, as Studio's does */
+export declare const isCubeProjectHost: (host: CubeHost) => boolean;
+/** Whether the host offers Cube's sample data and examples */
+export declare const isCubeSampleDataOffered: (host: CubeHost) => boolean;
+/**
+ * A model's databases and runtimes, wherever its kind keeps them: a
+ * project's in the host's depot (PLAN §6.3), any other through the model
+ * catalog's engine
+ */
+export declare const loadCubeModelOutline: (host: CubeHost, model: ModelContext) => Promise<CubeModelOutline>;
 //# sourceMappingURL=CubeHost.d.ts.map

package/lib/stores/CubeHost.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CubeHost.d.ts","sourceRoot":"","sources":["../../src/stores/CubeHost.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,2BAA2B,CAAC;AAC/E,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAC;AACjE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAEhE;;;;;;GAMG;AACH,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,gBAAgB,EAAE,6BAA6B,CAAC;IACzD,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAC;IAC5B,QAAQ,CAAC,YAAY,EAAE,iBAAiB,CAAC;CAC1C"}
+{"version":3,"file":"CubeHost.d.ts","sourceRoot":"","sources":["../../src/stores/CubeHost.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,2BAA2B,CAAC;AAC/E,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AACvD,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,4CAA4C,CAAC;AACzF,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,4CAA4C,CAAC;AACzF,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,8CAA8C,CAAC;AAC7F,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,uCAAuC,CAAC;AAC/E,OAAO,EAGL,KAAK,UAAU,EACf,KAAK,gBAAgB,EACtB,MAAM,gCAAgC,CAAC;AAMxC,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wCAAwC,CAAC;AACjF,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wCAAwC,CAAC;AACjF,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAEhE;;;;;;GAMG;AACH,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,gBAAgB,EAAE,6BAA6B,CAAC;IACzD,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAC;IAC5B,QAAQ,CAAC,YAAY,EAAE,iBAAiB,CAAC;IACzC;;;OAGG;IACH,QAAQ,CAAC,kBAAkB,CAAC,EAAE,sBAAsB,GAAG,SAAS,CAAC;IACjE;;;OAGG;IACH,QAAQ,CAAC,kBAAkB,CAAC,EAAE,sBAAsB,GAAG,SAAS,CAAC;IACjE;;;OAGG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,iBAAiB,GAAG,SAAS,CAAC;IACvD;;;OAGG;IACH,QAAQ,CAAC,cAAc,CAAC,EAAE,kBAAkB,GAAG,SAAS,CAAC;IACzD;;;OAGG;IACH,QAAQ,CAAC,cAAc,CAAC,EAAE,kBAAkB,GAAG,SAAS,CAAC;IACzD;;;;OAIG;IACH,QAAQ,CAAC,oBAAoB,CAAC,EAAE,wBAAwB,GAAG,SAAS,CAAC;IACrE;;;;OAIG;IACH,QAAQ,CAAC,gBAAgB,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IAChD;;;;;OAKG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,eAAe,GAAG,SAAS,CAAC;CAChD;AAED,gFAAgF;AAChF,MAAM,WAAW,sBAAsB;IACrC,2DAA2D;IAC3D,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,qEAAqE;IACrE,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CACzC;AAED,8EAA8E;AAC9E,MAAM,WAAW,eAAe;IAC9B,wFAAwF;IACxF,cAAc,IAAI,OAAO,CAAC,sBAAsB,CAAC,CAAC;CACnD;AAED,gFAAgF;AAChF,eAAO,MAAM,iBAAiB,GAAI,MAAM,QAAQ,KAAG,OACvB,CAAC;AAE7B,8DAA8D;AAC9D,eAAO,MAAM,uBAAuB,GAAI,MAAM,QAAQ,KAAG,OACxB,CAAC;AAMlC;;;;GAIG;AACH,eAAO,MAAM,oBAAoB,GAC/B,MAAM,QAAQ,EACd,OAAO,YAAY,KAClB,OAAO,CAAC,gBAAgB,CAqB1B,CAAC"}

package/lib/stores/CubeHost.js

@@ -13,5 +13,29 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-export {};
+import { CubeEngineError, CubeEngineErrorKind, } from '../graph-manager/CubeEngine.js';
+import { checkCubeProjectModel, getCubeProjectCoordinates, isCubeProjectModel, } from '../graph-manager/CubeProject.js';
+/** Whether the host's page reads one project's own sources, as Studio's does */
+export const isCubeProjectHost = (host) => host.project !== undefined;
+/** Whether the host offers Cube's sample data and examples */
+export const isCubeSampleDataOffered = (host) => host.offersSampleData !== false;
+/** Why the host can't list a project model's Databases */
+const NO_PROJECT_CATALOG = "This page can't read published projects: its host has no depot";
+/**
+ * A model's databases and runtimes, wherever its kind keeps them: a
+ * project's in the host's depot (PLAN §6.3), any other through the model
+ * catalog's engine
+ */
+export const loadCubeModelOutline = (host, model) => {
+    if (!isCubeProjectModel(model)) {
+        return host.modelCatalog.loadOutline(model);
+    }
+    const project = getCubeProjectCoordinates(model);
+    if (!project) {
+        return Promise.reject(new CubeEngineError(CubeEngineErrorKind.UNSUPPORTED_MODEL, checkCubeProjectModel(model).join('\n')));
+    }
+    return host.projectCatalog
+        ? host.projectCatalog.loadOutline(project)
+        : Promise.reject(new CubeEngineError(CubeEngineErrorKind.UNSUPPORTED_MODEL, NO_PROJECT_CATALOG));
+};
 //# sourceMappingURL=CubeHost.js.map

package/lib/stores/CubeHost.js.map

@@ -1 +1 @@
-{"version":3,"file":"CubeHost.js","sourceRoot":"","sources":["../../src/stores/CubeHost.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG"}
+{"version":3,"file":"CubeHost.js","sourceRoot":"","sources":["../../src/stores/CubeHost.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAQH,OAAO,EACL,eAAe,EACf,mBAAmB,GAGpB,MAAM,gCAAgC,CAAC;AACxC,OAAO,EACL,qBAAqB,EACrB,yBAAyB,EACzB,kBAAkB,GACnB,MAAM,iCAAiC,CAAC;AA4EzC,gFAAgF;AAChF,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAAC,IAAc,EAAW,EAAE,CAC3D,IAAI,CAAC,OAAO,KAAK,SAAS,CAAC;AAE7B,8DAA8D;AAC9D,MAAM,CAAC,MAAM,uBAAuB,GAAG,CAAC,IAAc,EAAW,EAAE,CACjE,IAAI,CAAC,gBAAgB,KAAK,KAAK,CAAC;AAElC,0DAA0D;AAC1D,MAAM,kBAAkB,GACtB,gEAAgE,CAAC;AAEnE;;;;GAIG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAClC,IAAc,EACd,KAAmB,EACQ,EAAE;IAC7B,IAAI,CAAC,kBAAkB,CAAC,KAAK,CAAC,EAAE,CAAC;QAC/B,OAAO,IAAI,CAAC,YAAY,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC;IAC9C,CAAC;IACD,MAAM,OAAO,GAAG,yBAAyB,CAAC,KAAK,CAAC,CAAC;IACjD,IAAI,CAAC,OAAO,EAAE,CAAC;QACb,OAAO,OAAO,CAAC,MAAM,CACnB,IAAI,eAAe,CACjB,mBAAmB,CAAC,iBAAiB,EACrC,qBAAqB,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CACxC,CACF,CAAC;IACJ,CAAC;IACD,OAAO,IAAI,CAAC,cAAc;QACxB,CAAC,CAAC,IAAI,CAAC,cAAc,CAAC,WAAW,CAAC,OAAO,CAAC;QAC1C,CAAC,CAAC,OAAO,CAAC,MAAM,CACZ,IAAI,eAAe,CACjB,mBAAmB,CAAC,iBAAiB,EACrC,kBAAkB,CACnB,CACF,CAAC;AACR,CAAC,CAAC"}

package/lib/stores/CubeIngestRecheck.d.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.
+ */
+import type { IngestDatasetSource, ModelContext, Schema } from '@finos/legend-cube';
+import { CubeEngineError, type NodeId } from '../graph-manager/CubeEngine.js';
+import type { CubeIngestCatalog } from '../graph-manager/CubeIngestCatalog.js';
+/**
+ * Reads an ingest cube's data sets again (PLAN §6.7): their columns as their
+ * deployed definitions declare them, through the catalog, with no engine
+ * call; `fresh` reads the definitions again rather than what this page visit
+ * read. One answer per source, failures included; never rejects.
+ */
+export declare const recheckCubeIngestSources: (catalog: CubeIngestCatalog | undefined, model: ModelContext, sources: readonly IngestDatasetSource[], fresh?: boolean) => Promise<Map<NodeId, Schema | CubeEngineError>>;
+//# sourceMappingURL=CubeIngestRecheck.d.ts.map

package/lib/stores/CubeIngestRecheck.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CubeIngestRecheck.d.ts","sourceRoot":"","sources":["../../src/stores/CubeIngestRecheck.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EACV,mBAAmB,EACnB,YAAY,EACZ,MAAM,EACP,MAAM,oBAAoB,CAAC;AAE5B,OAAO,EACL,eAAe,EAEf,KAAK,MAAM,EACZ,MAAM,gCAAgC,CAAC;AAKxC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,uCAAuC,CAAC;AAE/E;;;;;GAKG;AACH,eAAO,MAAM,wBAAwB,GACnC,SAAS,iBAAiB,GAAG,SAAS,EACtC,OAAO,YAAY,EACnB,SAAS,SAAS,mBAAmB,EAAE,EACvC,eAAa,KACZ,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,GAAG,eAAe,CAAC,CA+C/C,CAAC"}

package/lib/stores/CubeIngestRecheck.js

@@ -0,0 +1,53 @@
+/**
+ * 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 { CUBE_INGEST_RECHECK_MESSAGE } from '../__lib__/LegendCubeIngestLabels.js';
+import { CubeEngineError, CubeEngineErrorKind, } from '../graph-manager/CubeEngine.js';
+import { checkCubeIngestModel, getCubeIngestSettings, } from '../graph-manager/CubeIngest.js';
+/**
+ * Reads an ingest cube's data sets again (PLAN §6.7): their columns as their
+ * deployed definitions declare them, through the catalog, with no engine
+ * call; `fresh` reads the definitions again rather than what this page visit
+ * read. One answer per source, failures included; never rejects.
+ */
+export const recheckCubeIngestSources = async (catalog, model, sources, fresh = false) => {
+    const failAll = (kind, detail) => new Map(sources.map((source) => [
+        source.id,
+        new CubeEngineError(kind, detail, source.id),
+    ]));
+    if (!catalog) {
+        return failAll(CubeEngineErrorKind.UNSUPPORTED_MODEL, CUBE_INGEST_RECHECK_MESSAGE.NO_CATALOG);
+    }
+    const settings = getCubeIngestSettings(model);
+    if (!settings) {
+        return failAll(CubeEngineErrorKind.UNSUPPORTED_MODEL, checkCubeIngestModel(model).join('\n'));
+    }
+    try {
+        return await catalog.resolveSchemas(settings.environmentType, new Map(sources.map((source) => [
+            source.id,
+            {
+                ingestDefinitionUrn: source.ingestDefinitionUrn,
+                ingestDefinition: source.ingestDefinition,
+                dataSet: source.dataSet,
+            },
+        ])), { fresh });
+    }
+    catch (error) {
+        return error instanceof CubeEngineError
+            ? failAll(error.kind, error.detail)
+            : failAll(CubeEngineErrorKind.NETWORK, error instanceof Error ? error.message : String(error));
+    }
+};
+//# sourceMappingURL=CubeIngestRecheck.js.map

package/lib/stores/CubeIngestRecheck.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CubeIngestRecheck.js","sourceRoot":"","sources":["../../src/stores/CubeIngestRecheck.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAOH,OAAO,EAAE,2BAA2B,EAAE,MAAM,sCAAsC,CAAC;AACnF,OAAO,EACL,eAAe,EACf,mBAAmB,GAEpB,MAAM,gCAAgC,CAAC;AACxC,OAAO,EACL,oBAAoB,EACpB,qBAAqB,GACtB,MAAM,gCAAgC,CAAC;AAGxC;;;;;GAKG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAG,KAAK,EAC3C,OAAsC,EACtC,KAAmB,EACnB,OAAuC,EACvC,KAAK,GAAG,KAAK,EACmC,EAAE;IAClD,MAAM,OAAO,GAAG,CACd,IAAyB,EACzB,MAAc,EACyB,EAAE,CACzC,IAAI,GAAG,CACL,OAAO,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC;QACtB,MAAM,CAAC,EAAE;QACT,IAAI,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC;KAC7C,CAAC,CACH,CAAC;IACJ,IAAI,CAAC,OAAO,EAAE,CAAC;QACb,OAAO,OAAO,CACZ,mBAAmB,CAAC,iBAAiB,EACrC,2BAA2B,CAAC,UAAU,CACvC,CAAC;IACJ,CAAC;IACD,MAAM,QAAQ,GAAG,qBAAqB,CAAC,KAAK,CAAC,CAAC;IAC9C,IAAI,CAAC,QAAQ,EAAE,CAAC;QACd,OAAO,OAAO,CACZ,mBAAmB,CAAC,iBAAiB,EACrC,oBAAoB,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CACvC,CAAC;IACJ,CAAC;IACD,IAAI,CAAC;QACH,OAAO,MAAM,OAAO,CAAC,cAAc,CACjC,QAAQ,CAAC,eAAe,EACxB,IAAI,GAAG,CACL,OAAO,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC;YACtB,MAAM,CAAC,EAAE;YACT;gBACE,mBAAmB,EAAE,MAAM,CAAC,mBAAmB;gBAC/C,gBAAgB,EAAE,MAAM,CAAC,gBAAgB;gBACzC,OAAO,EAAE,MAAM,CAAC,OAAO;aACxB;SACF,CAAC,CACH,EACD,EAAE,KAAK,EAAE,CACV,CAAC;IACJ,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,OAAO,KAAK,YAAY,eAAe;YACrC,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,EAAE,KAAK,CAAC,MAAM,CAAC;YACnC,CAAC,CAAC,OAAO,CACL,mBAAmB,CAAC,OAAO,EAC3B,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CACvD,CAAC;IACR,CAAC;AACH,CAAC,CAAC"}

package/lib/stores/CubeLambdaImportState.d.ts

@@ -0,0 +1,118 @@
+/**
+ * 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 { CubeDocument, type IR } from '@finos/legend-cube';
+import { type GeneratorFn, type PlainObject } from '@finos/legend-shared';
+import type { CubeEditorState } from './CubeEditorState.js';
+/** A lambda a host opens the page on: its protocol JSON, and what to call it */
+export interface CubeInitialLambda {
+    readonly lambda: PlainObject;
+    /** What the page calls it, e.g. `materialized view TRADES_VIEW` */
+    readonly label: string;
+}
+/** Whether Cube writes the cube it read back as the lambda it read */
+export declare enum CubeLambdaFidelity {
+    /** The same Pure, so saving it changes nothing */
+    EXACT = "exact",
+    /** Pure that reads the same rows, written Cube's way */
+    REWRITTEN = "rewritten",
+    /**
+     * Not known: a step isn't valid, an expression couldn't be checked, or a
+     * step read with unknown columns is written another way
+     */
+    UNCHECKED = "unchecked"
+}
+export declare const CUBE_LAMBDA_IMPORT_MESSAGE: {
+    READING: (label: string) => string;
+    CANT_READ: (label: string) => string;
+    NOT_NEW: string;
+    REWRITTEN: (label: string) => string;
+    UNCHECKED: (label: string) => string;
+    GRID_LIMIT: string;
+    /** What the banner calls a lambda imported from the Import Pure dialog */
+    IMPORTED: string;
+    NOT_JSON: (reason: string) => string;
+};
+/** The source id the engine's grammar gives what Import Pure parses, so its errors name it */
+export declare const CUBE_IMPORT_PURE_SOURCE_ID = "cube:import-pure";
+export interface CubeLambdaImportError {
+    readonly message: string;
+    readonly detail?: string | undefined;
+}
+/** A lambda read into a cube: the cube, and what to compare it with once checked */
+export interface CubeLambdaReading {
+    readonly document: CubeDocument;
+    /** The lambda as read, which the cube is compared with */
+    readonly lambda: IR;
+    /** Whether it was a run's lambda, with `from()`, rather than a matview's relation */
+    readonly isRun: boolean;
+    /**
+     * The steps read without being checked, as the columns before them weren't
+     * known: read as Cube writes them, so the cube can't be vouched for unless
+     * it is written back the same
+     */
+    readonly unchecked: readonly string[];
+    readonly notes: readonly string[];
+}
+/**
+ * A lambda's protocol JSON read into a cube on the editor's host: its sources
+ * bound, its steps read, its expressions given their code. Throws a
+ * `CubeLambdaReadError`, or the engine's error, naming what can't be read.
+ */
+export declare const readCubeLambdaDocument: (editorState: CubeEditorState, json: unknown) => Promise<CubeLambdaReading>;
+/**
+ * Whether the cube, written again as the lambda was written (a matview's
+ * relation, or a run with no row limit), is the lambda it was read from.
+ * Written another way, it reads the same rows only when every step was
+ * checked as it was read: a step read with unknown columns, e.g. a select
+ * taken for the one a Join writes, may not.
+ */
+export declare const getCubeLambdaFidelity: (editorState: CubeEditorState, reading: Pick<CubeLambdaReading, "lambda" | "isRun" | "unchecked">) => CubeLambdaFidelity;
+/**
+ * Opens the page on a host's lambda (`CubeEditor`'s `initialLambda`): read
+ * into a cube, opened as the first one, with no undo step; a lambda that
+ * can't be read leaves the cube empty and says why. Once the cube's
+ * expressions are checked, whether Cube writes it back the same way.
+ */
+export declare class CubeLambdaImportState {
+    readonly editorState: CubeEditorState;
+    /** What the page calls the lambda it opened on */
+    label: string | undefined;
+    isReading: boolean;
+    error: CubeLambdaImportError | undefined;
+    /** Whether Cube writes the cube back as the lambda; none until checked */
+    fidelity: CubeLambdaFidelity | undefined;
+    notes: readonly string[];
+    /** Import Pure, from the Cube menu: the dialog, its text, why its last import failed */
+    isDialogOpen: boolean;
+    text: string;
+    isImporting: boolean;
+    dialogError: CubeLambdaImportError | undefined;
+    constructor(editorState: CubeEditorState);
+    open(initial: CubeInitialLambda): GeneratorFn<void>;
+    openDialog(): void;
+    closeDialog(): void;
+    setText(text: string): void;
+    /**
+     * Import Pure (PLAN §11.18): the dialog's text, Pure or the engine's JSON
+     * of a lambda, read into a cube that replaces this one, as one undo step;
+     * then, once checked, whether Cube writes it back the same. A lambda that
+     * can't be read leaves the cube as it was, and says why in the dialog.
+     */
+    importText(): GeneratorFn<void>;
+    /** Closes the banner */
+    dismiss(): void;
+}
+//# sourceMappingURL=CubeLambdaImportState.d.ts.map

package/lib/stores/CubeLambdaImportState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CubeLambdaImportState.d.ts","sourceRoot":"","sources":["../../src/stores/CubeLambdaImportState.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EACL,YAAY,EAaZ,KAAK,EAAE,EAGR,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAGL,KAAK,WAAW,EAChB,KAAK,WAAW,EACjB,MAAM,sBAAsB,CAAC;AAO9B,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAS5D,gFAAgF;AAChF,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC;IAC7B,mEAAmE;IACnE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AAED,sEAAsE;AACtE,oBAAY,kBAAkB;IAC5B,kDAAkD;IAClD,KAAK,UAAU;IACf,wDAAwD;IACxD,SAAS,cAAc;IACvB;;;OAGG;IACH,SAAS,cAAc;CACxB;AAED,eAAO,MAAM,0BAA0B;qBACpB,MAAM,KAAG,MAAM;uBACb,MAAM,KAAG,MAAM;;uBAEf,MAAM,KAAG,MAAM;uBAEf,MAAM,KAAG,MAAM;;IAIlC,0EAA0E;;uBAEvD,MAAM,KAAG,MAAM;CACnC,CAAC;AAEF,8FAA8F;AAC9F,eAAO,MAAM,0BAA0B,qBAAqB,CAAC;AAE7D,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CACtC;AAaD,oFAAoF;AACpF,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,QAAQ,EAAE,YAAY,CAAC;IAChC,0DAA0D;IAC1D,QAAQ,CAAC,MAAM,EAAE,EAAE,CAAC;IACpB,qFAAqF;IACrF,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB;;;;OAIG;IACH,QAAQ,CAAC,SAAS,EAAE,SAAS,MAAM,EAAE,CAAC;IACtC,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;CACnC;AA4ED;;;;GAIG;AACH,eAAO,MAAM,sBAAsB,GACjC,aAAa,eAAe,EAC5B,MAAM,OAAO,KACZ,OAAO,CAAC,iBAAiB,CA8B3B,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB,GAChC,aAAa,eAAe,EAC5B,SAAS,IAAI,CAAC,iBAAiB,EAAE,QAAQ,GAAG,OAAO,GAAG,WAAW,CAAC,KACjE,kBAqBF,CAAC;AAEF;;;;;GAKG;AACH,qBAAa,qBAAqB;IAChC,QAAQ,CAAC,WAAW,EAAE,eAAe,CAAC;IACtC,kDAAkD;IAClD,KAAK,EAAE,MAAM,GAAG,SAAS,CAAC;IAC1B,SAAS,UAAS;IAClB,KAAK,EAAE,qBAAqB,GAAG,SAAS,CAAC;IACzC,0EAA0E;IAC1E,QAAQ,EAAE,kBAAkB,GAAG,SAAS,CAAC;IACzC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAM;IAC9B,wFAAwF;IACxF,YAAY,UAAS;IACrB,IAAI,SAAM;IACV,WAAW,UAAS;IACpB,WAAW,EAAE,qBAAqB,GAAG,SAAS,CAAC;gBAEnC,WAAW,EAAE,eAAe;IAqBvC,IAAI,CAAC,OAAO,EAAE,iBAAiB,GAAG,WAAW,CAAC,IAAI,CAAC;IAiCpD,UAAU,IAAI,IAAI;IAKlB,WAAW,IAAI,IAAI;IAKnB,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAK3B;;;;;OAKG;IACF,UAAU,IAAI,WAAW,CAAC,IAAI,CAAC;IA2DhC,wBAAwB;IACxB,OAAO,IAAI,IAAI;CAKhB"}

package/lib/stores/CubeLambdaImportState.js

@@ -0,0 +1,302 @@
+/**
+ * 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 { CubeDocument, CubeLambdaReadError, ExpressionFilter, Extend, findCubeLambdaExtends, findCubeLambdaSources, isSameCubeIR, lambda, QueryEmitter, readCubeQuery, splitCubeLambda, Schema, } from '@finos/legend-cube';
+import { assertErrorThrown, parseLosslessJSON, } from '@finos/legend-shared';
+import { action, flow, makeObservable, observable, when } from 'mobx';
+import { CubeEngineError } from '../graph-manager/CubeEngine.js';
+import { CUBE_EXPRESSION_CODEC, readCubeLambdaJson, } from '../graph-manager/protocol/pure/CubeEngineBuilder.js';
+import { bindCubeLambdaSources } from './CubeLambdaSources.js';
+/** Whether Cube writes the cube it read back as the lambda it read */
+export var CubeLambdaFidelity;
+(function (CubeLambdaFidelity) {
+    /** The same Pure, so saving it changes nothing */
+    CubeLambdaFidelity["EXACT"] = "exact";
+    /** Pure that reads the same rows, written Cube's way */
+    CubeLambdaFidelity["REWRITTEN"] = "rewritten";
+    /**
+     * Not known: a step isn't valid, an expression couldn't be checked, or a
+     * step read with unknown columns is written another way
+     */
+    CubeLambdaFidelity["UNCHECKED"] = "unchecked";
+})(CubeLambdaFidelity || (CubeLambdaFidelity = {}));
+export const CUBE_LAMBDA_IMPORT_MESSAGE = {
+    READING: (label) => `Reading ${label}…`,
+    CANT_READ: (label) => `Cube can't read ${label}`,
+    NOT_NEW: 'Cube opens a lambda on a new cube only.',
+    REWRITTEN: (label) => `Cube writes ${label} another way, which reads the same rows: what Cube shows and saves is its own Pure.`,
+    UNCHECKED: (label) => `Cube couldn't check that its steps read the same rows as ${label}: review them.`,
+    GRID_LIMIT: "The limit beside from() is read as a Limit step: it may be the grid's row limit of the run the Pure was copied from.",
+    /** What the banner calls a lambda imported from the Import Pure dialog */
+    IMPORTED: 'the Pure imported',
+    NOT_JSON: (reason) => `Can't read the JSON: ${reason}`,
+};
+/** The source id the engine's grammar gives what Import Pure parses, so its errors name it */
+export const CUBE_IMPORT_PURE_SOURCE_ID = 'cube:import-pure';
+const toImportError = (error) => {
+    if (error instanceof CubeEngineError) {
+        return {
+            message: error.firstLine,
+            detail: error.detail !== error.firstLine ? error.detail : undefined,
+        };
+    }
+    assertErrorThrown(error);
+    return { message: error.message };
+};
+/** The engine's grammar of an expression's lambda, as the editor shows it */
+const codeOf = async (editorState, expression) => (await editorState.host.engine.renderPure(CUBE_EXPRESSION_CODEC.read(expression))).trim();
+/** Each Filter by Expression's and Extend column's code, the engine's grammar of its lambda */
+const withExpressionCode = async (editorState, query) => {
+    let next = query;
+    for (const node of query.nodes) {
+        if (node instanceof ExpressionFilter && node.lambda && !node.code) {
+            next = next.replace(node.withCondition(await codeOf(editorState, node.lambda), node.lambda));
+        }
+        else if (node instanceof Extend) {
+            const columns = [];
+            for (const column of node.columns) {
+                columns.push(column.lambda && !column.code
+                    ? { ...column, code: await codeOf(editorState, column.lambda) }
+                    : column);
+            }
+            next = next.replace(node.withColumns(columns));
+        }
+    }
+    return next;
+};
+/**
+ * The schema of each chain of extends of the lambda, typed by the engine in
+ * one call before the steps are read, so the steps after an Extend can be
+ * checked; none when the engine can't type them, as then the editor will
+ * say why
+ */
+const typeExtends = async (editorState, context, chains) => {
+    const schemas = new Map();
+    if (!chains.length) {
+        return schemas;
+    }
+    try {
+        const typed = await editorState.host.engine.typeLambdas(context.model, new Map(chains.map(({ typed: relation }, index) => [
+            `extend${index}`,
+            lambda([], [relation]),
+        ])));
+        chains.forEach(({ read }, index) => {
+            const schema = typed.get(`extend${index}`);
+            if (schema instanceof Schema) {
+                schemas.set(read, schema);
+            }
+        });
+    }
+    catch {
+        // typed again by the editor, which says why it can't
+    }
+    return schemas;
+};
+/**
+ * A lambda's protocol JSON read into a cube on the editor's host: its sources
+ * bound, its steps read, its expressions given their code. Throws a
+ * `CubeLambdaReadError`, or the engine's error, naming what can't be read.
+ */
+export const readCubeLambdaDocument = async (editorState, json) => {
+    const read = readCubeLambdaJson(json);
+    const parts = splitCubeLambda(read);
+    const binding = await bindCubeLambdaSources(editorState, findCubeLambdaSources(parts));
+    const { query, unchecked } = readCubeQuery(parts, {
+        bindSource: binding.bindSource,
+        expressions: CUBE_EXPRESSION_CODEC,
+        relationSchemas: await typeExtends(editorState, binding.context, findCubeLambdaExtends(parts)),
+        registry: editorState.registry,
+    });
+    return {
+        document: new CubeDocument({
+            context: {
+                ...binding.context,
+                ...(parts.runtime !== undefined ? { runtime: parts.runtime } : {}),
+            },
+            query: await withExpressionCode(editorState, query),
+        }),
+        lambda: read,
+        isRun: parts.runtime !== undefined,
+        unchecked,
+        notes: parts.limitBesideFrom ? [CUBE_LAMBDA_IMPORT_MESSAGE.GRID_LIMIT] : [],
+    };
+};
+/**
+ * Whether the cube, written again as the lambda was written (a matview's
+ * relation, or a run with no row limit), is the lambda it was read from.
+ * Written another way, it reads the same rows only when every step was
+ * checked as it was read: a step read with unknown columns, e.g. a select
+ * taken for the one a Join writes, may not.
+ */
+export const getCubeLambdaFidelity = (editorState, reading) => {
+    const { query, context } = editorState.document;
+    const selected = query.selected;
+    const emitter = new QueryEmitter(query, editorState.registry);
+    if (selected === undefined || !emitter.canEmit(selected)) {
+        return CubeLambdaFidelity.UNCHECKED;
+    }
+    const written = reading.isRun && context?.runtime !== undefined
+        ? emitter.emitExecutionLambda({ runtime: context.runtime })
+        : lambda([], [emitter.emitRelation(selected, { withRowOrder: true })]);
+    if (isSameCubeIR(written, reading.lambda, {
+        readExpression: CUBE_EXPRESSION_CODEC.read,
+    })) {
+        return CubeLambdaFidelity.EXACT;
+    }
+    return reading.unchecked.length
+        ? CubeLambdaFidelity.UNCHECKED
+        : CubeLambdaFidelity.REWRITTEN;
+};
+/**
+ * Opens the page on a host's lambda (`CubeEditor`'s `initialLambda`): read
+ * into a cube, opened as the first one, with no undo step; a lambda that
+ * can't be read leaves the cube empty and says why. Once the cube's
+ * expressions are checked, whether Cube writes it back the same way.
+ */
+export class CubeLambdaImportState {
+    editorState;
+    /** What the page calls the lambda it opened on */
+    label;
+    isReading = false;
+    error;
+    /** Whether Cube writes the cube back as the lambda; none until checked */
+    fidelity;
+    notes = [];
+    /** Import Pure, from the Cube menu: the dialog, its text, why its last import failed */
+    isDialogOpen = false;
+    text = '';
+    isImporting = false;
+    dialogError;
+    constructor(editorState) {
+        makeObservable(this, {
+            label: observable,
+            isReading: observable,
+            error: observable.ref,
+            fidelity: observable,
+            notes: observable.ref,
+            isDialogOpen: observable,
+            text: observable,
+            isImporting: observable,
+            dialogError: observable.ref,
+            open: flow,
+            dismiss: action,
+            openDialog: action,
+            closeDialog: action,
+            setText: action,
+            importText: flow,
+        });
+        this.editorState = editorState;
+    }
+    *open(initial) {
+        const { editorState } = this;
+        this.label = initial.label;
+        this.isReading = true;
+        this.error = undefined;
+        this.fidelity = undefined;
+        try {
+            const reading = (yield readCubeLambdaDocument(editorState, initial.lambda));
+            // the user may have started a cube while it was read
+            if (!editorState.isEmptyCube) {
+                throw new CubeLambdaReadError(CUBE_LAMBDA_IMPORT_MESSAGE.NOT_NEW);
+            }
+            editorState.openDocument(reading.document);
+            this.notes = reading.notes;
+            this.isReading = false;
+            // checked as the editor checks any expression: then compared
+            yield when(() => !editorState.isResolvingSources &&
+                !editorState.isCheckingExpressions &&
+                !editorState.nodesToCheck.length);
+            this.fidelity = getCubeLambdaFidelity(editorState, reading);
+        }
+        catch (error) {
+            this.error = toImportError(error);
+        }
+        finally {
+            this.isReading = false;
+        }
+    }
+    openDialog() {
+        this.isDialogOpen = true;
+        this.dialogError = undefined;
+    }
+    closeDialog() {
+        this.isDialogOpen = false;
+        this.isImporting = false;
+    }
+    setText(text) {
+        this.text = text;
+        this.dialogError = undefined;
+    }
+    /**
+     * Import Pure (PLAN §11.18): the dialog's text, Pure or the engine's JSON
+     * of a lambda, read into a cube that replaces this one, as one undo step;
+     * then, once checked, whether Cube writes it back the same. A lambda that
+     * can't be read leaves the cube as it was, and says why in the dialog.
+     */
+    *importText() {
+        const { editorState } = this;
+        const text = this.text.trim();
+        if (!text || this.isImporting) {
+            return;
+        }
+        this.isImporting = true;
+        this.dialogError = undefined;
+        try {
+            let json;
+            if (text.startsWith('{')) {
+                try {
+                    json = parseLosslessJSON(text);
+                }
+                catch (error) {
+                    assertErrorThrown(error);
+                    throw new CubeLambdaReadError(CUBE_LAMBDA_IMPORT_MESSAGE.NOT_JSON(error.message));
+                }
+            }
+            else {
+                json = (yield editorState.host.engine.parseExpression(text, CUBE_IMPORT_PURE_SOURCE_ID)).lambda;
+            }
+            const reading = (yield readCubeLambdaDocument(editorState, json));
+            if (!this.isDialogOpen) {
+                // closed while it was read
+                return;
+            }
+            editorState.importDocument(reading.document, false);
+            this.isDialogOpen = false;
+            this.text = '';
+            this.label = CUBE_LAMBDA_IMPORT_MESSAGE.IMPORTED;
+            this.error = undefined;
+            this.fidelity = undefined;
+            this.notes = reading.notes;
+            this.isImporting = false;
+            yield when(() => !editorState.isResolvingSources &&
+                !editorState.isCheckingExpressions &&
+                !editorState.nodesToCheck.length);
+            this.fidelity = getCubeLambdaFidelity(editorState, reading);
+        }
+        catch (error) {
+            this.dialogError = toImportError(error);
+        }
+        finally {
+            this.isImporting = false;
+        }
+    }
+    /** Closes the banner */
+    dismiss() {
+        this.error = undefined;
+        this.fidelity = undefined;
+        this.notes = [];
+    }
+}
+//# sourceMappingURL=CubeLambdaImportState.js.map