@finos/legend-cube-builder 0.0.2 → 0.0.4

package/lib/stores/CubeEditorState.js

@@ -13,12 +13,25 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { buildSchemasAndValidity, createNodeRegistry, CubeDocument, diffSchemas, QueryEmitter, RelationalTableSource, rereadQueryFilterValues, } from '@finos/legend-cube';
-import { action, computed, flow, flowResult, makeObservable, observable, } from 'mobx';
+import { DataProductAccessPointSource, IngestDatasetSource, buildSchemasAndValidity, createNodeRegistry, CubeDocument, diffSchemas, Extend, findLostSortOrders, isTypingError, MESSAGE_SORT_COLUMNS_CUT, MESSAGE_SORT_COLUMNS_DROPPED, MESSAGE_SORT_ORDER_LOST, QueryEmitter, RelationalTableSource, rereadQueryFilterValues, } from '@finos/legend-cube';
+import { action, computed, flow, flowResult, makeObservable, observable, reaction, } from 'mobx';
 import { LEGEND_CUBE_COMMAND_KEY } from '../__lib__/LegendCubeCommand.js';
-import { CUBE_EDITOR_CLOSED_REASON, DEFAULT_ROW_LIMIT, getSchemaDriftWarning, getSourceRecheckWarning, LEGEND_CUBE_USER_DATA_KEY, MAX_UNDO_STEPS, } from '../__lib__/LegendCubeLabels.js';
+import { LEGEND_CUBE_TEST_ID } from '../__lib__/LegendCubeTesting.js';
+import { CUBE_EDITOR_CLOSED_REASON, DEFAULT_ROW_LIMIT, getSchemaDriftWarning, getExtendRetypeWarning, getSourceRecheckWarning, LEGEND_CUBE_USER_DATA_KEY, MAX_UNDO_STEPS, } from '../__lib__/LegendCubeLabels.js';
+import { CUBE_DATA_PRODUCT_RECHECK_MESSAGE, getAccessPointDriftWarning, getAccessPointRecheckWarning, } from '../__lib__/LegendCubeDataProductLabels.js';
+import { CUBE_INGEST_RECHECK_MESSAGE, getDataSetDriftWarning, getDataSetRecheckWarning, } from '../__lib__/LegendCubeIngestLabels.js';
+import { isCubeDataProductModel } from '../graph-manager/CubeDataProduct.js';
+import { isCubeIngestModel } from '../graph-manager/CubeIngest.js';
 import { CubeEngineError, CubeEngineErrorKind, } from '../graph-manager/CubeEngine.js';
+import { getDatabaseType } from '../graph-manager/CubeModelOutlineHelper.js';
+import { recheckCubeDataProductSources } from './CubeDataProductRecheck.js';
+import { recheckCubeIngestSources } from './CubeIngestRecheck.js';
+import { CubeDataProductRuntimeState } from './CubeDataProductRuntimeState.js';
+import { CubeExamplesState } from './CubeExamplesState.js';
 import { CubeExecutionState } from './CubeExecutionState.js';
+import { CubeExtendDraft } from './editors/CubeExtendDraft.js';
+import { buildCubeExtendTypingLambdas, createStaleCubeExtendTypingRule, getCubeExtendTypingUpstream, getCubeExtendUpstream, isCubeExtendTypingCurrent, isSameCubeExtendTyping, readCubeExtendTyping, } from './CubeExtendTyping.js';
+import { loadCubeModelOutline } from './CubeHost.js';
 import { CubeNodeEditorState } from './CubeNodeEditorState.js';
 import { CubeShowPureState } from './CubeShowPureState.js';
 import { CubeSourcePickerState } from './CubeSourcePickerState.js';
@@ -31,6 +44,8 @@ const isTypingText = () => {
         element instanceof HTMLTextAreaElement ||
         (element instanceof HTMLElement && element.isContentEditable));
 };
+/** Focus is in the node editor, whose shortcuts give it back to the node (PLAN §11.8) */
+const isFocusInNodeEditor = () => document.activeElement?.closest(`[data-testid="${LEGEND_CUBE_TEST_ID.NODE_EDITOR}"]`) !== null && document.activeElement !== null;
 /**
  * The state of one Cube page (PLAN §7.8). The document is immutable: every
  * edit makes a new one through `applyDocument`, which keeps the previous one
@@ -41,9 +56,14 @@ export class CubeEditorState {
     host;
     /** One registry for inference, emission and the saved spec */
     registry;
+    /** The editor's own query rule: an Extend typed for another input than its own waits to be typed again (PLAN §11.7) */
+    staleExtendTyping;
     execution;
+    /** Where a lakehouse cube runs, a data product's or an ingest one's: its class and warehouse */
+    dataProductRuntime;
     sourcePicker;
     specTransfer;
+    examples;
     showPure;
     nodeEditor;
     document;
@@ -64,6 +84,10 @@ export class CubeEditorState {
     modelOutlines = new Map();
     /** Sources sent to the engine to be typed again, until it answers */
     pendingSources = new Set();
+    /** Extends sent to the engine to be typed, until it answers (PLAN §11.7) */
+    typingExtends = new Set();
+    /** Types the Extends that wait for it, whenever one does (PLAN §11.7 Q4) */
+    retyping;
     /** The rows a run returns; kept per user, never in the cube */
     rowLimit;
     /** The palette shows icons only; kept per user, never in the cube */
@@ -80,6 +104,10 @@ export class CubeEditorState {
     constructor(host, document = new CubeDocument()) {
         makeObservable(this, {
             pendingSources: observable.ref,
+            typingExtends: observable.ref,
+            extendsToType: computed,
+            isTypingExtends: computed,
+            retypeExtends: flow,
             modelOutlines: observable.ref,
             modelOutline: computed,
             loadModelOutline: flow,
@@ -87,6 +115,7 @@ export class CubeEditorState {
             history: observable.ref,
             hostIssues: observable.ref,
             warnings: observable.ref,
+            derivedWarnings: computed,
             isResolvingSources: computed,
             rowLimit: observable,
             isPaletteCollapsed: observable,
@@ -94,6 +123,9 @@ export class CubeEditorState {
             analysis: computed,
             emitter: computed,
             canUndo: computed,
+            hasEditsToApply: computed,
+            executeEdited: action,
+            undoEdited: action,
             isDialogOpen: computed,
             applyDocument: action,
             undo: action,
@@ -104,6 +136,7 @@ export class CubeEditorState {
             select: action,
             connect: action,
             addNode: action,
+            addConfiguredNode: action,
             dropNode: action,
             removeNode: action,
             swapInputs: action,
@@ -115,6 +148,7 @@ export class CubeEditorState {
         });
         this.host = host;
         this.registry = createNodeRegistry();
+        this.staleExtendTyping = createStaleCubeExtendTypingRule(this.registry, () => this.document.context?.model);
         this.document = document;
         const storedLimit = host.applicationStore.userDataService.getNumericValue(LEGEND_CUBE_USER_DATA_KEY.ROW_LIMIT);
         this.rowLimit = isValidRowLimit(storedLimit)
@@ -123,14 +157,28 @@ export class CubeEditorState {
         this.isPaletteCollapsed =
             host.applicationStore.userDataService.getBooleanValue(LEGEND_CUBE_USER_DATA_KEY.PALETTE_COLLAPSED) ?? false;
         this.execution = new CubeExecutionState(this);
+        this.dataProductRuntime = new CubeDataProductRuntimeState(this);
         this.sourcePicker = new CubeSourcePickerState(this);
         this.specTransfer = new CubeSpecTransferState(this);
+        this.examples = new CubeExamplesState(this);
         this.showPure = new CubeShowPureState(this);
         this.nodeEditor = new CubeNodeEditorState(this);
+        this.retyping = reaction(() => this.extendsToType, (waiting) => {
+            if (waiting.length) {
+                flowResult(this.retypeExtends(waiting)).catch(this.host.applicationStore.alertUnhandledError);
+            }
+        }, { fireImmediately: true });
     }
-    /** Each node's schema and errors, query-level rules included, as the emitter sees them */
+    /**
+     * Each node's schema and errors, query-level rules included, as the
+     * emitter sees them, and an Extend typed for another input than its own
+     * waiting (`ERR_TYPING`), which only the editor can tell
+     */
     get analysis() {
-        return buildSchemasAndValidity(this.document.query, this.registry.queryRules);
+        return buildSchemasAndValidity(this.document.query, [
+            ...this.registry.queryRules,
+            this.staleExtendTyping,
+        ]);
     }
     get emitter() {
         return new QueryEmitter(this.document.query, this.registry);
@@ -143,6 +191,152 @@ export class CubeEditorState {
     isPendingSource(node) {
         return this.pendingSources.has(node);
     }
+    /**
+     * The Extends of the cube shown that wait for the engine to type their
+     * columns, their input valid, and that aren't being typed (PLAN §11.7):
+     * new expressions, or an input that changed
+     */
+    get extendsToType() {
+        const { validity } = this.analysis;
+        return this.document.query.nodes.filter((node) => node instanceof Extend &&
+            !this.typingExtends.has(node) &&
+            (validity.get(node.id) ?? []).some(isTypingError));
+    }
+    /** The cube shown has Extends the engine is typing */
+    get isTypingExtends() {
+        return this.document.query.nodes.some((node) => this.typingExtends.has(node));
+    }
+    /** The node waits for the engine to type it, or is being typed: an Extend (PLAN §11.7) */
+    isTypingNode(node) {
+        return (this.typingExtends.has(node) ||
+            (this.analysis.validity.get(node.id) ?? []).some(isTypingError));
+    }
+    /**
+     * Types Extends' columns with the engine, in one call, outside the undo
+     * history (PLAN §11.7 Q4): each for the input it has now, its columns
+     * after its input's relation, as typing types any node. The typing goes in
+     * place of the very nodes sent, in the cube shown and the undo snapshots
+     * that give the engine the same input; one the user changed meanwhile is
+     * left to type again. Each typing records the input as the engine was given
+     * it (`upstream`). A typing the engine couldn't give names the column it
+     * failed on; when the engine can't be reached, a typing still current for
+     * the input is kept, with a warning, as a source's saved columns are.
+     */
+    *retypeExtends(nodes) {
+        const { context, query } = this.document;
+        if (!context) {
+            return;
+        }
+        const { schemas } = this.analysis;
+        const emitter = new QueryEmitter(query, this.registry);
+        const requests = nodes.flatMap((node) => {
+            const [inputId] = query.getInputIds(node.id);
+            const input = inputId === undefined ? undefined : schemas.get(inputId);
+            if (query.getNode(node.id) !== node ||
+                this.typingExtends.has(node) ||
+                !input ||
+                node.columns.some(({ lambda }) => lambda === undefined)) {
+                return [];
+            }
+            const columns = node.columns.map(({ name, lambda }) => ({
+                name,
+                lambda: lambda,
+            }));
+            return [
+                {
+                    node,
+                    input,
+                    columns,
+                    upstream: getCubeExtendUpstream(emitter, node.id, context.model),
+                    lambdas: buildCubeExtendTypingLambdas(query, node, columns, this.registry, false),
+                },
+            ];
+        });
+        if (!requests.length) {
+            return;
+        }
+        const sent = requests.map(({ node }) => node);
+        this.typingExtends = new Set([...this.typingExtends, ...sent]);
+        let answers;
+        try {
+            answers = (yield this.host.engine.typeLambdas(context.model, new Map(requests.flatMap(({ lambdas }) => [...lambdas]))));
+        }
+        catch (error) {
+            const failure = error instanceof CubeEngineError
+                ? error
+                : new CubeEngineError(CubeEngineErrorKind.NETWORK, error instanceof Error ? error.message : String(error));
+            answers = new Map(requests.flatMap(({ lambdas }) => [...lambdas.keys()].map((key) => [key, failure])));
+        }
+        finally {
+            this.typingExtends = new Set([...this.typingExtends].filter((node) => !sent.includes(node)));
+        }
+        // a typing that comes back the same leaves its node, and the query, alone
+        const warnings = new Map(this.warnings);
+        const replacements = new Map(requests.flatMap(({ node, input, columns, upstream }) => {
+            const { typing, error } = readCubeExtendTyping(answers, node, input, columns, upstream);
+            if (error?.kind === CubeEngineErrorKind.NETWORK &&
+                isCubeExtendTypingCurrent(node, input, upstream)) {
+                warnings.set(node.key, [getExtendRetypeWarning(error.firstLine)]);
+                return [];
+            }
+            warnings.delete(node.key);
+            return isSameCubeExtendTyping(typing, node.typing)
+                ? []
+                : [[node, node.withTyping(typing)]];
+        }));
+        this.warnings = warnings;
+        // an undo snapshot whose input differs keeps the typing it had
+        const emitters = new Map([[query, emitter]]);
+        this.replaceOutsideHistory(replacements, (snapshot, resolved) => {
+            const upstream = getCubeExtendTypingUpstream(resolved.typing);
+            if (upstream === undefined) {
+                return true;
+            }
+            let snapshotEmitter = emitters.get(snapshot);
+            if (!snapshotEmitter) {
+                snapshotEmitter = new QueryEmitter(snapshot, this.registry);
+                emitters.set(snapshot, snapshotEmitter);
+            }
+            return (getCubeExtendUpstream(snapshotEmitter, resolved.id, context.model) ===
+                upstream);
+        });
+    }
+    /**
+     * Warnings worked out from the query, by node id: a Sort whose order is
+     * lost before it is used (PLAN §11.4). Never stored and never errors, so
+     * Execute stays enabled; they go as soon as the query no longer loses it.
+     * A partial loss names each node that removes some of the Sort's columns,
+     * then the columns that came after a removed one. A loss waits until the
+     * Sort and every node it names have no errors, e.g. a Restrict just added,
+     * with no column yet: their own errors come first.
+     */
+    get derivedWarnings() {
+        const { validity, schemas } = this.analysis;
+        const isValid = (nodeId) => validity.get(nodeId)?.length === 0;
+        const { query } = this.document;
+        return new Map(Array.from(findLostSortOrders(query, undefined, schemas))
+            .filter(([sortId, loss]) => isValid(sortId) &&
+            isValid(loss.nodeId) &&
+            (loss.removals ?? []).every(({ nodeId }) => isValid(nodeId)))
+            .map(([sortId, loss]) => [
+            sortId,
+            loss.removals
+                ? [
+                    ...loss.removals.map(({ nodeId, columns }) => MESSAGE_SORT_COLUMNS_DROPPED(columns, nodeId)),
+                    ...(loss.cutColumns?.length
+                        ? [MESSAGE_SORT_COLUMNS_CUT(loss.cutColumns)]
+                        : []),
+                ]
+                : [MESSAGE_SORT_ORDER_LOST(loss.nodeId)],
+        ]));
+    }
+    /** A node's warnings: the stored ones (by key), then the derived ones (by id) */
+    getNodeWarnings(node) {
+        return [
+            ...(this.warnings.get(node.key) ?? []),
+            ...(this.derivedWarnings.get(node.id) ?? []),
+        ];
+    }
     /**
      * The node's errors, each once: its own and those of the query rules, then
      * the first line of the engine's error on it
@@ -159,19 +353,48 @@ export class CubeEditorState {
     /** The outline of the cube's model, once an editor has loaded it */
     get modelOutline() {
         const model = this.document.context?.model;
-        return model === undefined ? undefined : this.modelOutlines.get(model);
+        return model === undefined ? undefined : this.getModelOutline(model);
+    }
+    /** The outline of a model, once loaded */
+    getModelOutline(model) {
+        return this.modelOutlines.get(model);
     }
     /**
-     * Loads the outline of the cube's model, once per model. It only adds
-     * warnings, so a model that fails to load shows none.
+     * The database type a run of the query up to the node needs, with the
+     * model's runtime (PLAN §11.4), from the model's outline once it is loaded
+     * (`loadModelOutline`): the type of the runtime's connections to the
+     * databases the node reads. None without an outline, which writes every
+     * operation the native way.
      */
-    *loadModelOutline() {
-        const model = this.document.context?.model;
+    getRunDatabaseType(query, nodeId, model, runtime) {
+        const outline = this.getModelOutline(model);
+        if (!outline) {
+            return undefined;
+        }
+        const databases = new Set();
+        const visit = (id) => {
+            const node = query.getNode(id);
+            if (node instanceof RelationalTableSource) {
+                databases.add(node.database);
+            }
+            query
+                .getInputIds(id)
+                .forEach((inputId) => inputId !== undefined && visit(inputId));
+        };
+        visit(nodeId);
+        return getDatabaseType(outline, runtime, [...databases]);
+    }
+    /**
+     * Loads the outline of a model, the cube's by default, once per model. It
+     * only adds warnings and database types, so a model that fails to load
+     * shows none and runs every operation the native way.
+     */
+    *loadModelOutline(model = this.document.context?.model) {
         if (model === undefined || this.modelOutlines.has(model)) {
             return;
         }
         try {
-            const outline = (yield this.host.modelCatalog.loadOutline(model));
+            const outline = (yield loadCubeModelOutline(this.host, model));
             this.modelOutlines = new Map([...this.modelOutlines, [model, outline]]);
         }
         catch {
@@ -181,6 +404,7 @@ export class CubeEditorState {
     /** One of Cube's dialogs is open: the source picker, Import or Export, Show Pure */
     get isDialogOpen() {
         return (this.sourcePicker.isOpen ||
+            this.examples.isOpen ||
             this.specTransfer.mode !== undefined ||
             this.showPure.isOpen);
     }
@@ -188,25 +412,73 @@ export class CubeEditorState {
      * The page's keyboard shortcuts, while it is open (spec §17.12). Each does
      * nothing when its button can't be used, and nothing while a Cube dialog
      * is open, since a dialog doesn't stop the app's shortcuts (user's choice,
-     * 2026-10-07). Undo leaves Ctrl+Z to a text field that has the focus.
+     * 2026-10-07), or while something opened from the node editor holds it
+     * open. Like their buttons, they finish the node editor first (PLAN §11.8):
+     * F9 runs the edited query, and Ctrl+Z undoes what finishing applied. Undo
+     * leaves Ctrl+Z to a text field that has the focus.
      */
     registerCommands() {
-        const { commandService, alertUnhandledError } = this.host.applicationStore;
+        const { commandService } = this.host.applicationStore;
         commandService.registerCommand({
             key: LEGEND_CUBE_COMMAND_KEY.EXECUTE,
             trigger: () => !this.isDialogOpen &&
-                this.execution.canExecute &&
-                !this.execution.isRunning,
+                !this.nodeEditor.isHeld &&
+                !this.execution.isRunning &&
+                (this.execution.canExecute || this.hasEditsToApply),
+            action: () => this.nodeEditor.runFromKeyboard(() => this.executeEdited(), isFocusInNodeEditor()),
+        });
+        // F10 in the Extend editor (PLAN §11.7)
+        commandService.registerCommand({
+            key: LEGEND_CUBE_COMMAND_KEY.VALIDATE_EXPRESSIONS,
+            trigger: () => {
+                const { draft } = this.nodeEditor;
+                return (!this.isDialogOpen &&
+                    !this.readOnly &&
+                    draft instanceof CubeExtendDraft &&
+                    !draft.validating);
+            },
             action: () => {
-                flowResult(this.execution.execute()).catch(alertUnhandledError);
+                const { draft } = this.nodeEditor;
+                if (draft instanceof CubeExtendDraft) {
+                    flowResult(draft.validate()).catch(this.host.applicationStore.alertUnhandledError);
+                }
             },
         });
         commandService.registerCommand({
             key: LEGEND_CUBE_COMMAND_KEY.UNDO,
-            trigger: () => !this.isDialogOpen && this.canUndo && !isTypingText(),
-            action: () => this.undo(),
+            trigger: () => !this.isDialogOpen &&
+                !this.nodeEditor.isHeld &&
+                (this.canUndo || this.hasEditsToApply) &&
+                !isTypingText(),
+            action: () => this.nodeEditor.runFromKeyboard(() => this.undoEdited(), isFocusInNodeEditor()),
         });
     }
+    /** The node editor has edits that closing it would apply */
+    get hasEditsToApply() {
+        return this.nodeEditor.hasChanges && !this.readOnly;
+    }
+    /**
+     * Execute, as its button and F9 do (spec §17.5): finishes the node editor
+     * first, so the edits run, then runs the query if it can; runs nothing
+     * when the edits had to be dropped, since the run would not be what the
+     * user edited
+     */
+    executeEdited() {
+        if (!this.nodeEditor.finishApplied() || !this.execution.canExecute) {
+            return;
+        }
+        flowResult(this.execution.execute()).catch(this.host.applicationStore.alertUnhandledError);
+    }
+    /**
+     * Undo, as its button and Ctrl+Z do: finishes the node editor first, then
+     * undoes the last change, which drops the edits it just applied; when the
+     * edits had to be dropped instead, that was the undo
+     */
+    undoEdited() {
+        if (this.nodeEditor.finishApplied()) {
+            this.undo();
+        }
+    }
     deregisterCommands() {
         Object.values(LEGEND_CUBE_COMMAND_KEY).forEach((key) => this.host.applicationStore.commandService.deregisterCommand(key));
     }
@@ -239,10 +511,15 @@ export class CubeEditorState {
         this.document = next;
         this.readOnly = readOnly;
         flowResult(this.reresolveSources()).catch(this.host.applicationStore.alertUnhandledError);
+        // typed once on load too, as sources are checked again: the model may
+        // have changed the types of its functions (PLAN §11.7)
+        flowResult(this.retypeExtends(next.query.nodes.filter((node) => node instanceof Extend))).catch(this.host.applicationStore.alertUnhandledError);
     }
     /**
-     * Types the cube's tables again, in one engine call, outside the undo
-     * history (PLAN §10.3, Settled before M1.8):
+     * Types the cube's sources again, outside the undo history (PLAN §10.3,
+     * Settled before M1.8): its tables in one engine call, a data product
+     * cube's access points through the catalog, from the deployed artifact at
+     * the cube's version (PLAN §6.8). Warnings name the kind of source:
      * - a table whose columns are the saved ones is left as it is;
      * - a table that changed takes its new columns, with a warning listing the
      *   changes;
@@ -257,28 +534,62 @@ export class CubeEditorState {
      * left alone.
      *
      * `only` types just these sources of the cube shown, e.g. one Refresh. A
-     * table found unchanged loses any earlier warning.
+     * table found unchanged loses any earlier warning. `fresh` reads a data
+     * product's artifact again rather than what this page visit read.
      */
-    *reresolveSources(only) {
+    *reresolveSources(only, fresh = false) {
         const { context, query } = this.document;
-        const sources = (only ?? query.nodes).filter((node) => node instanceof RelationalTableSource &&
-            query.getNode(node.id) === node);
-        if (!context || !sources.length) {
+        if (!context) {
+            return;
+        }
+        const kept = (only ?? query.nodes).filter((node) => query.getNode(node.id) === node);
+        const tables = kept.filter((node) => node instanceof RelationalTableSource);
+        // an access point on a cube of tables is the no-mix rule's to flag
+        const accessPoints = isCubeDataProductModel(context.model)
+            ? kept.filter((node) => node instanceof DataProductAccessPointSource)
+            : [];
+        const dataSets = isCubeIngestModel(context.model)
+            ? kept.filter((node) => node instanceof IngestDatasetSource)
+            : [];
+        const sources = [
+            ...tables,
+            ...accessPoints,
+            ...dataSets,
+        ];
+        if (!sources.length) {
             return;
         }
         this.pendingSources = new Set([...this.pendingSources, ...sources]);
         let answers;
         try {
-            answers = (yield this.host.engine.resolveSchemas(context.model, new Map(sources.map((source) => [
-                source.id,
-                [source.database, source.schema, source.table],
-            ]))));
-        }
-        catch (error) {
-            const failure = error instanceof CubeEngineError
-                ? error
-                : new CubeEngineError(CubeEngineErrorKind.NETWORK, error instanceof Error ? error.message : String(error));
-            answers = new Map(sources.map((source) => [source.id, failure]));
+            const [tableAnswers, accessPointAnswers, dataSetAnswers] = (yield Promise.all([
+                tables.length
+                    ? this.host.engine
+                        .resolveSchemas(context.model, new Map(tables.map((source) => [
+                        source.id,
+                        [source.database, source.schema, source.table],
+                    ])))
+                        .catch((error) => {
+                        const failure = error instanceof CubeEngineError
+                            ? error
+                            : new CubeEngineError(CubeEngineErrorKind.NETWORK, error instanceof Error
+                                ? error.message
+                                : String(error));
+                        return new Map(tables.map((source) => [source.id, failure]));
+                    })
+                    : new Map(),
+                accessPoints.length
+                    ? recheckCubeDataProductSources(this.host.dataProductCatalog, context.model, accessPoints, fresh)
+                    : new Map(),
+                dataSets.length
+                    ? recheckCubeIngestSources(this.host.ingestCatalog, context.model, dataSets, fresh)
+                    : new Map(),
+            ]));
+            answers = new Map([
+                ...(tableAnswers ?? []),
+                ...(accessPointAnswers ?? []),
+                ...(dataSetAnswers ?? []),
+            ]);
         }
         finally {
             this.pendingSources = new Set([...this.pendingSources].filter((node) => !sources.includes(node)));
@@ -287,14 +598,26 @@ export class CubeEditorState {
         /** Each typed source, by the object that was sent, and what replaces it */
         const replacements = new Map();
         sources.forEach((source) => {
+            const isAccessPoint = source instanceof DataProductAccessPointSource;
+            const isDataSet = source instanceof IngestDatasetSource;
             const answer = answers.get(source.id) ??
-                new CubeEngineError(CubeEngineErrorKind.COMPILE, 'The engine gave no schema for this table', source.id);
+                new CubeEngineError(CubeEngineErrorKind.COMPILE, isAccessPoint
+                    ? CUBE_DATA_PRODUCT_RECHECK_MESSAGE.NO_ANSWER
+                    : isDataSet
+                        ? CUBE_INGEST_RECHECK_MESSAGE.NO_ANSWER
+                        : 'The engine gave no schema for this table', source.id);
             const saved = source.resolution.kind === 'resolved'
                 ? source.resolution.schema
                 : undefined;
             if (answer instanceof CubeEngineError) {
                 if (saved) {
-                    warnings.set(source.key, [getSourceRecheckWarning(answer.firstLine)]);
+                    warnings.set(source.key, [
+                        isAccessPoint
+                            ? getAccessPointRecheckWarning(answer.firstLine)
+                            : isDataSet
+                                ? getDataSetRecheckWarning(answer.firstLine)
+                                : getSourceRecheckWarning(answer.firstLine),
+                    ]);
                 }
                 else if (source.resolution.kind !== 'failed' ||
                     source.resolution.message !== answer.detail) {
@@ -312,13 +635,28 @@ export class CubeEditorState {
                 schema: answer,
             });
             if (saved) {
+                const diff = diffSchemas(saved, answer);
                 warnings.set(resolved.key, [
-                    getSchemaDriftWarning(diffSchemas(saved, answer)),
+                    isAccessPoint
+                        ? getAccessPointDriftWarning(diff)
+                        : isDataSet
+                            ? getDataSetDriftWarning(diff)
+                            : getSchemaDriftWarning(diff),
                 ]);
             }
             replacements.set(source, resolved);
         });
         this.warnings = warnings;
+        this.replaceOutsideHistory(replacements);
+    }
+    /**
+     * Puts nodes the engine checked in place of the very objects that were
+     * sent, outside the undo history: in the cube shown and in the undo
+     * snapshots taken meanwhile, so undoing an edit made meanwhile keeps them.
+     * A node the user changed meanwhile is a new object, and is left alone.
+     * Filter values saved as invalid text are read again against the columns.
+     */
+    replaceOutsideHistory(replacements, accepts) {
         if (!replacements.size) {
             return;
         }
@@ -330,7 +668,8 @@ export class CubeEditorState {
             if (checked === undefined) {
                 let replaced = document.query;
                 replacements.forEach((resolved, source) => {
-                    if (replaced.getNode(source.id) === source) {
+                    if (replaced.getNode(source.id) === source &&
+                        (accepts?.(document.query, resolved) ?? true)) {
                         replaced = replaced.replace(resolved);
                     }
                 });
@@ -359,21 +698,27 @@ export class CubeEditorState {
         }
     }
     /**
-     * Types a table again with the engine, from its Source panel (spec §17.6),
-     * as a re-check after an import does: no undo step, nothing changes when
-     * its columns are the same, and a warning lists any change.
+     * Types a source again, from its Source panel (spec §17.6), as a re-check
+     * after an import does: a table with the engine, an access point through
+     * the catalog. No undo step, nothing changes when its columns are the
+     * same, and a warning lists any change.
      */
     *refreshSource(nodeId) {
         const source = this.document.query.getNode(nodeId);
-        if (source instanceof RelationalTableSource) {
-            yield flowResult(this.reresolveSources([source]));
+        if (source instanceof RelationalTableSource ||
+            source instanceof DataProductAccessPointSource ||
+            source instanceof IngestDatasetSource) {
+            // a Refresh reads the deployed artifact or definition again
+            yield flowResult(this.reresolveSources([source], true));
         }
     }
     /**
      * Restores the document before the last edit; does nothing when there is
      * no history. A restored query is a new object (PLAN §4.3), so rows that
-     * ran before the edit show as stale. An edit that left the query alone,
-     * such as a rename, keeps it, with its rows and engine errors. Undoing an
+     * ran before the edit show as stale. An edit that left the query and the
+     * context alone, such as a rename, keeps them, with the rows and engine
+     * errors; undoing a warehouse edit brings back the context the rows ran
+     * with. Undoing an
      * import closes the node editor and the picker, as the import did.
      */
     undo() {
@@ -397,9 +742,14 @@ export class CubeEditorState {
         }
         this.history = [...this.history, this.document].slice(-MAX_UNDO_STEPS);
     }
-    /** Engine errors belong to the query they came from, so they are dropped when the query changes */
+    /**
+     * Engine errors belong to the query and the context they came from, so
+     * they are dropped when either changes, e.g. a data product cube's
+     * warehouse
+     */
     replaceDocument(next) {
-        if (next.query !== this.document.query) {
+        if (next.query !== this.document.query ||
+            next.context !== this.document.context) {
             this.hostIssues = new Map();
             this.execution.clearError();
         }
@@ -424,10 +774,23 @@ export class CubeEditorState {
             this.applyQuery(query.connect(sourceId, targetId, port));
         }
     }
+    /**
+     * The kinds of source the host serves: data products and ingest data sets
+     * only with their catalogs. The cube's kind may still disable one
+     * (`canAddNode`)
+     */
+    get offeredSources() {
+        return this.registry.sources.filter((definition) => (definition.type !== DataProductAccessPointSource.TYPE ||
+            this.sourcePicker.dataProductTab.isAvailable) &&
+            (definition.type !== IngestDatasetSource.TYPE ||
+                this.sourcePicker.ingestTab.isAvailable));
+    }
     /**
      * Whether a node of the type can be added: a transform, unconnected or
      * spliced in after `afterId`, when the query allows it; a source only
      * unconnected, through the source picker. Never while the cube is read-only.
+     * The low-level rule: the palette, drops and menus place nodes through
+     * `CubeAddPlacement` (PLAN §11.8).
      */
     canAddNode(type, afterId) {
         const definition = this.registry.get(type);
@@ -435,14 +798,18 @@ export class CubeEditorState {
             return false;
         }
         if (definition.kind === 'source') {
-            return afterId === undefined;
+            // through its tab, which the cube's kind may disable (PLAN §6.8)
+            const tab = this.sourcePicker.tabForSourceType(type);
+            return (afterId === undefined &&
+                tab !== undefined &&
+                this.sourcePicker.isTabEnabled(tab));
         }
         const { query } = this.document;
         return query.canAdd(definition.create(query.generateId(type)), afterId);
     }
     /**
-     * Adds a node of the type, as the palette and the context menu do (spec
-     * §17.4): a transform with its default settings, unconnected or spliced in
+     * Adds a node of the type (spec §17.4), the low-level add that
+     * `CubeAddPlacement` places for the palette, drops and menus: a transform with its default settings, unconnected or spliced in
      * after `afterId`; a source opens the source picker, which adds it once
      * the engine has typed it. Does nothing `canAddNode` refuses.
      */
@@ -452,12 +819,25 @@ export class CubeEditorState {
             return;
         }
         if (definition.kind === 'source') {
-            this.sourcePicker.open();
+            this.sourcePicker.open(this.sourcePicker.tabForSourceType(type)?.key);
             return;
         }
         const { query } = this.document;
         this.applyQuery(query.add(definition.create(query.generateId(type)), afterId));
     }
+    /**
+     * Adds a node made elsewhere, with its settings, as the grid's quick
+     * actions do (spec §12.4): spliced in after `afterId`, so it becomes the
+     * node that runs when that one did, as one undo step. Does nothing in a
+     * read-only cube, or when the query can't take it.
+     */
+    addConfiguredNode(node, afterId) {
+        const { query } = this.document;
+        if (this.readOnly || !query.canAdd(node, afterId)) {
+            return;
+        }
+        this.applyQuery(query.add(node, afterId));
+    }
     /** Whether dropping a node on another does anything: connect it, or else move it after it */
     canDropNode(nodeId, targetId) {
         const { query } = this.document;
@@ -544,6 +924,7 @@ export class CubeEditorState {
     }
     /** Stops any run; call when the page closes */
     dispose() {
+        this.retyping();
         this.execution.stop();
         this.nodeEditor.dispose();
     }