@finos/legend-cube-builder 0.0.2 → 0.0.4

package/src/stores/CubeEditorState.ts

@@ -15,19 +15,30 @@
  */
 
 import {
+  DataProductAccessPointSource,
+  IngestDatasetSource,
   buildSchemasAndValidity,
   createNodeRegistry,
   CubeDocument,
   diffSchemas,
+  Extend,
+  findLostSortOrders,
+  isTypingError,
+  type JsonObject,
+  MESSAGE_SORT_COLUMNS_CUT,
+  MESSAGE_SORT_COLUMNS_DROPPED,
+  MESSAGE_SORT_ORDER_LOST,
   type ModelContext,
   type NodeRegistry,
   type Query,
   QueryEmitter,
   type QueryNode,
+  type QueryRule,
   RelationalTableSource,
   rereadQueryFilterValues,
   type Schema,
   type SchemaInferenceResult,
+  type SourceDefinition,
 } from '@finos/legend-cube';
 import type { CommandRegistrar } from '@finos/legend-application';
 import type { GeneratorFn } from '@finos/legend-shared';
@@ -36,25 +47,57 @@ import {
   computed,
   flow,
   flowResult,
+  type IReactionDisposer,
   makeObservable,
   observable,
+  reaction,
 } from 'mobx';
 import { LEGEND_CUBE_COMMAND_KEY } from '../__lib__/LegendCubeCommand.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,
   type CubeModelOutline,
+  type NodeId,
 } 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 type { CubeHost } from './CubeHost.js';
+import { CubeExtendDraft } from './editors/CubeExtendDraft.js';
+import {
+  buildCubeExtendTypingLambdas,
+  createStaleCubeExtendTypingRule,
+  getCubeExtendTypingUpstream,
+  getCubeExtendUpstream,
+  isCubeExtendTypingCurrent,
+  isSameCubeExtendTyping,
+  readCubeExtendTyping,
+} from './CubeExtendTyping.js';
+import { type CubeHost, loadCubeModelOutline } from './CubeHost.js';
 import { CubeNodeEditorState } from './CubeNodeEditorState.js';
 import { CubeShowPureState } from './CubeShowPureState.js';
 import { CubeSourcePickerState } from './CubeSourcePickerState.js';
@@ -79,6 +122,18 @@ const isTypingText = (): boolean => {
   );
 };
 
+/** Focus is in the node editor, whose shortcuts give it back to the node (PLAN §11.8) */
+const isFocusInNodeEditor = (): boolean =>
+  document.activeElement?.closest(
+    `[data-testid="${LEGEND_CUBE_TEST_ID.NODE_EDITOR}"]`,
+  ) !== null && document.activeElement !== null;
+
+/** A source Cube types again to see drift: a table, or a data product's access point */
+type RecheckedSource =
+  | RelationalTableSource
+  | DataProductAccessPointSource
+  | IngestDatasetSource;
+
 /**
  * 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
@@ -89,9 +144,14 @@ export class CubeEditorState implements CommandRegistrar {
   readonly host: CubeHost;
   /** One registry for inference, emission and the saved spec */
   readonly registry: NodeRegistry;
+  /** The editor's own query rule: an Extend typed for another input than its own waits to be typed again (PLAN §11.7) */
+  private readonly staleExtendTyping: QueryRule;
   readonly execution: CubeExecutionState;
+  /** Where a lakehouse cube runs, a data product's or an ingest one's: its class and warehouse */
+  readonly dataProductRuntime: CubeDataProductRuntimeState;
   readonly sourcePicker: CubeSourcePickerState;
   readonly specTransfer: CubeSpecTransferState;
+  readonly examples: CubeExamplesState;
   readonly showPure: CubeShowPureState;
   readonly nodeEditor: CubeNodeEditorState;
 
@@ -114,6 +174,10 @@ export class CubeEditorState implements CommandRegistrar {
     new Map();
   /** Sources sent to the engine to be typed again, until it answers */
   private pendingSources: ReadonlySet<QueryNode> = new Set();
+  /** Extends sent to the engine to be typed, until it answers (PLAN §11.7) */
+  private typingExtends: ReadonlySet<QueryNode> = new Set();
+  /** Types the Extends that wait for it, whenever one does (PLAN §11.7 Q4) */
+  private readonly retyping: IReactionDisposer;
   /** The rows a run returns; kept per user, never in the cube */
   rowLimit: number;
   /** The palette shows icons only; kept per user, never in the cube */
@@ -129,8 +193,15 @@ export class CubeEditorState implements CommandRegistrar {
   private readonly importedOver = new WeakSet<CubeDocument>();
 
   constructor(host: CubeHost, document = new CubeDocument()) {
-    makeObservable<CubeEditorState, 'pendingSources' | 'modelOutlines'>(this, {
+    makeObservable<
+      CubeEditorState,
+      'pendingSources' | 'modelOutlines' | 'typingExtends'
+    >(this, {
       pendingSources: observable.ref,
+      typingExtends: observable.ref,
+      extendsToType: computed,
+      isTypingExtends: computed,
+      retypeExtends: flow,
       modelOutlines: observable.ref,
       modelOutline: computed,
       loadModelOutline: flow,
@@ -138,6 +209,7 @@ export class CubeEditorState implements CommandRegistrar {
       history: observable.ref,
       hostIssues: observable.ref,
       warnings: observable.ref,
+      derivedWarnings: computed,
       isResolvingSources: computed,
       rowLimit: observable,
       isPaletteCollapsed: observable,
@@ -145,6 +217,9 @@ export class CubeEditorState implements CommandRegistrar {
       analysis: computed,
       emitter: computed,
       canUndo: computed,
+      hasEditsToApply: computed,
+      executeEdited: action,
+      undoEdited: action,
       isDialogOpen: computed,
       applyDocument: action,
       undo: action,
@@ -155,6 +230,7 @@ export class CubeEditorState implements CommandRegistrar {
       select: action,
       connect: action,
       addNode: action,
+      addConfiguredNode: action,
       dropNode: action,
       removeNode: action,
       swapInputs: action,
@@ -166,6 +242,10 @@ export class CubeEditorState implements CommandRegistrar {
     });
     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,
@@ -178,18 +258,35 @@ export class CubeEditorState implements CommandRegistrar {
         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(): SchemaInferenceResult {
-    return buildSchemasAndValidity(
-      this.document.query,
-      this.registry.queryRules,
-    );
+    return buildSchemasAndValidity(this.document.query, [
+      ...this.registry.queryRules,
+      this.staleExtendTyping,
+    ]);
   }
 
   get emitter(): QueryEmitter {
@@ -208,6 +305,206 @@ export class CubeEditorState implements CommandRegistrar {
     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(): readonly Extend[] {
+    const { validity } = this.analysis;
+    return this.document.query.nodes.filter(
+      (node): node is Extend =>
+        node instanceof Extend &&
+        !this.typingExtends.has(node) &&
+        (validity.get(node.id) ?? []).some(isTypingError),
+    );
+  }
+
+  /** The cube shown has Extends the engine is typing */
+  get isTypingExtends(): boolean {
+    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: QueryNode): boolean {
+    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: readonly Extend[]): GeneratorFn<void> {
+    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 as JsonObject,
+      }));
+      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: ReadonlyMap<NodeId, Schema | CubeEngineError>;
+    try {
+      answers = (yield this.host.engine.typeLambdas(
+        context.model,
+        new Map(requests.flatMap(({ lambdas }) => [...lambdas])),
+      )) as ReadonlyMap<NodeId, Schema | CubeEngineError>;
+    } 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] as const),
+        ),
+      );
+    } finally {
+      this.typingExtends = new Set(
+        [...this.typingExtends].filter(
+          (node) => !sent.includes(node as Extend),
+        ),
+      );
+    }
+    // a typing that comes back the same leaves its node, and the query, alone
+    const warnings = new Map(this.warnings);
+    const replacements = new Map<QueryNode, QueryNode>(
+      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)] as const];
+      }),
+    );
+    this.warnings = warnings;
+    // an undo snapshot whose input differs keeps the typing it had
+    const emitters = new Map<Query, QueryEmitter>([[query, emitter]]);
+    this.replaceOutsideHistory(replacements, (snapshot, resolved) => {
+      const upstream = getCubeExtendTypingUpstream((resolved as Extend).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(): ReadonlyMap<string, readonly string[]> {
+    const { validity, schemas } = this.analysis;
+    const isValid = (nodeId: string): boolean =>
+      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: QueryNode): readonly string[] {
+    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
@@ -225,20 +522,59 @@ export class CubeEditorState implements CommandRegistrar {
   /** The outline of the cube's model, once an editor has loaded it */
   get modelOutline(): CubeModelOutline | undefined {
     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: ModelContext): CubeModelOutline | undefined {
+    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(): GeneratorFn<void> {
-    const model = this.document.context?.model;
+  getRunDatabaseType(
+    query: Query,
+    nodeId: string,
+    model: ModelContext,
+    runtime: string,
+  ): string | undefined {
+    const outline = this.getModelOutline(model);
+    if (!outline) {
+      return undefined;
+    }
+    const databases = new Set<string>();
+    const visit = (id: string): void => {
+      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: ModelContext | undefined = this.document.context?.model,
+  ): GeneratorFn<void> {
     if (model === undefined || this.modelOutlines.has(model)) {
       return;
     }
     try {
-      const outline = (yield this.host.modelCatalog.loadOutline(
+      const outline = (yield loadCubeModelOutline(
+        this.host,
         model,
       )) as CubeModelOutline;
       this.modelOutlines = new Map([...this.modelOutlines, [model, outline]]);
@@ -251,6 +587,7 @@ export class CubeEditorState implements CommandRegistrar {
   get isDialogOpen(): boolean {
     return (
       this.sourcePicker.isOpen ||
+      this.examples.isOpen ||
       this.specTransfer.mode !== undefined ||
       this.showPure.isOpen
     );
@@ -260,27 +597,93 @@ export class CubeEditorState implements CommandRegistrar {
    * 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(): void {
-    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(): boolean {
+    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(): void {
+    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(): void {
+    if (this.nodeEditor.finishApplied()) {
+      this.undo();
+    }
+  }
+
   deregisterCommands(): void {
     Object.values(LEGEND_CUBE_COMMAND_KEY).forEach((key) =>
       this.host.applicationStore.commandService.deregisterCommand(key),
@@ -320,11 +723,22 @@ export class CubeEditorState implements CommandRegistrar {
     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 is Extend => 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;
@@ -339,60 +753,118 @@ export class CubeEditorState implements CommandRegistrar {
    * 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?: readonly RelationalTableSource[],
+    only?: readonly RecheckedSource[],
+    fresh = false,
   ): GeneratorFn<void> {
     const { context, query } = this.document;
-    const sources = (only ?? query.nodes).filter(
+    if (!context) {
+      return;
+    }
+    const kept = (only ?? query.nodes).filter(
+      (node) => query.getNode(node.id) === node,
+    );
+    const tables = kept.filter(
       (node): node is RelationalTableSource =>
-        node instanceof RelationalTableSource &&
-        query.getNode(node.id) === node,
+        node instanceof RelationalTableSource,
     );
-    if (!context || !sources.length) {
+    // 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 is DataProductAccessPointSource =>
+            node instanceof DataProductAccessPointSource,
+        )
+      : [];
+    const dataSets = isCubeIngestModel(context.model)
+      ? kept.filter(
+          (node): node is IngestDatasetSource =>
+            node instanceof IngestDatasetSource,
+        )
+      : [];
+    const sources: readonly RecheckedSource[] = [
+      ...tables,
+      ...accessPoints,
+      ...dataSets,
+    ];
+    if (!sources.length) {
       return;
     }
     this.pendingSources = new Set([...this.pendingSources, ...sources]);
     let answers: ReadonlyMap<string, Schema | CubeEngineError>;
     try {
-      answers = (yield this.host.engine.resolveSchemas(
-        context.model,
-        new Map(
-          sources.map((source) => [
-            source.id,
-            [source.database, source.schema, source.table],
-          ]),
-        ),
-      )) as Map<string, Schema | CubeEngineError>;
-    } 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: unknown) => {
+                  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(),
+        ])) as ReadonlyMap<string, Schema | CubeEngineError>[];
+      answers = new Map([
+        ...(tableAnswers ?? []),
+        ...(accessPointAnswers ?? []),
+        ...(dataSetAnswers ?? []),
+      ]);
     } finally {
       this.pendingSources = new Set(
         [...this.pendingSources].filter(
-          (node) => !sources.includes(node as RelationalTableSource),
+          (node) => !sources.includes(node as RecheckedSource),
         ),
       );
     }
     const warnings = new Map(this.warnings);
     /** Each typed source, by the object that was sent, and what replaces it */
-    const replacements = new Map<
-      RelationalTableSource,
-      RelationalTableSource
-    >();
+    const replacements = new Map<RecheckedSource, RecheckedSource>();
     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',
+          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 =
@@ -401,7 +873,13 @@ export class CubeEditorState implements CommandRegistrar {
           : 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
@@ -423,13 +901,32 @@ export class CubeEditorState implements CommandRegistrar {
         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.
+   */
+  private replaceOutsideHistory(
+    replacements: ReadonlyMap<QueryNode, QueryNode>,
+    accepts?: (query: Query, resolved: QueryNode) => boolean,
+  ): void {
     if (!replacements.size) {
       return;
     }
@@ -441,7 +938,10 @@ export class CubeEditorState implements CommandRegistrar {
       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);
           }
         });
@@ -471,22 +971,30 @@ export class CubeEditorState implements CommandRegistrar {
   }
 
   /**
-   * 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: string): GeneratorFn<void> {
     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(): void {
@@ -516,9 +1024,16 @@ export class CubeEditorState implements CommandRegistrar {
     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
+   */
   private replaceDocument(next: CubeDocument): void {
-    if (next.query !== this.document.query) {
+    if (
+      next.query !== this.document.query ||
+      next.context !== this.document.context
+    ) {
       this.hostIssues = new Map();
       this.execution.clearError();
     }
@@ -547,10 +1062,27 @@ export class CubeEditorState implements CommandRegistrar {
     }
   }
 
+  /**
+   * 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(): readonly SourceDefinition[] {
+    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: string, afterId?: string): boolean {
     const definition = this.registry.get(type);
@@ -558,15 +1090,21 @@ export class CubeEditorState implements CommandRegistrar {
       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.
    */
@@ -576,7 +1114,7 @@ export class CubeEditorState implements CommandRegistrar {
       return;
     }
     if (definition.kind === 'source') {
-      this.sourcePicker.open();
+      this.sourcePicker.open(this.sourcePicker.tabForSourceType(type)?.key);
       return;
     }
     const { query } = this.document;
@@ -585,6 +1123,20 @@ export class CubeEditorState implements CommandRegistrar {
     );
   }
 
+  /**
+   * 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: QueryNode, afterId?: string): void {
+    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: string, targetId: string): boolean {
     const { query } = this.document;
@@ -696,6 +1248,7 @@ export class CubeEditorState implements CommandRegistrar {
 
   /** Stops any run; call when the page closes */
   dispose(): void {
+    this.retyping();
     this.execution.stop();
     this.nodeEditor.dispose();
   }