@sqlrooms/cells 0.29.0-rc.1 → 0.29.0-rc.3

package/dist/cellsSlice.js

@@ -1,147 +1,224 @@
-import { createId } from '@paralleldrive/cuid2';
 import { makePagedQuery } from '@sqlrooms/data-table';
 import { sanitizeQuery } from '@sqlrooms/duckdb';
 import { createSlice } from '@sqlrooms/room-store';
-import { generateUniqueName } from '@sqlrooms/utils';
+import { convertToValidColumnOrTableName, generateUniqueName, } from '@sqlrooms/utils';
 import { produce } from 'immer';
-import { buildGraphCacheFromEdges, buildDependencyGraph, buildDependencyGraphAsync, collectReachable, ensureGraphCache, removeCellFromCache, replaceCellDependenciesInCache, topologicalOrder, } from './dagUtils';
-import { findSheetIdForCell, getRequiredSqlSelectToJson, normalizeCellsConfigStructure, resolveDependencies, } from './helpers';
+import { buildDependencyGraph, buildDependencyGraphAsync, buildGraphCacheFromEdges, collectReachable, removeCellFromCache, replaceCellDependenciesInCache, topologicalOrder, } from './dagUtils';
+import { findArtifactIdForCell, getRequiredSqlSelectToJson, normalizeCellsConfigStructure, resolveDependencies, } from './helpers';
 import { dropResultRelation } from './resultRelationPolicy';
 import { isInputCell, isSqlCell } from './types';
-import { getSheetSchemaName, isDefined } from './utils';
+import { getArtifactSchemaName, getEffectiveResultName, isDefined, } from './utils';
+import { buildCrossFilterPredicate } from './vegaSelectionUtils';
 function createDefaultCellsConfig(config) {
-    const sheetId = createId();
     const defaultConfig = {
         data: {},
-        sheets: {
-            [sheetId]: {
-                id: sheetId,
-                type: 'notebook',
-                title: 'Sheet',
-                schemaName: getSheetSchemaName(sheetId),
-                cellIds: [],
-                edges: [],
-                graphCache: {
-                    dependencies: {},
-                    dependents: {},
-                    contentHashByCell: {},
-                },
-            },
-        },
-        sheetOrder: [sheetId],
-        currentSheetId: sheetId,
+        artifacts: {},
+        tableDepSchemas: ['main'],
     };
     if (!config) {
         return defaultConfig;
     }
-    const { sheets, sheetOrder, currentSheetId } = normalizeCellsConfigStructure(config, defaultConfig);
+    const { artifacts } = normalizeCellsConfigStructure(config);
     return {
         ...defaultConfig,
         ...config,
-        sheets,
-        sheetOrder,
-        currentSheetId,
+        artifacts,
     };
 }
 // --- Slice Implementation ---
 export function createCellsSlice(props) {
-    const { cellRegistry, supportedSheetTypes = ['notebook', 'canvas'] } = props;
+    const { cellRegistry } = props;
     const initialConfig = createDefaultCellsConfig(props?.config);
     // Keep result data outside Immer drafts, but scoped per slice instance.
     const cellResultCache = new Map();
     return createSlice((set, get, store) => {
-        const dropSqlResultRelation = async (resultName) => {
+        const dropRelationBestEffort = async (relationName) => {
             try {
                 const connector = await get().db.getConnector();
-                await dropResultRelation({ connector, relationName: resultName });
+                await dropResultRelation({ connector, relationName });
             }
             catch {
-                // Best-effort cleanup: relation might already be gone or connector
-                // might be unavailable during teardown.
+                // Best-effort cleanup
+            }
+        };
+        const dropRelationsForStatus = async (cellType, status) => {
+            if (!status)
+                return;
+            const registryItem = cellRegistry[cellType];
+            const names = registryItem?.getRelationsToDrop?.(status) ?? [];
+            for (const name of names) {
+                await dropRelationBestEffort(name);
             }
         };
+        // Mark cells stale when their dependent database tables change (schema-level).
+        store.subscribe((state, prevState) => {
+            if (state.db.tables === prevState.db.tables)
+                return;
+            const toName = (t) => `${t.table.schema ?? 'main'}.${t.table.table}`;
+            const oldNames = new Set(prevState.db.tables.map(toName));
+            const newNames = new Set(state.db.tables.map(toName));
+            const changed = new Set();
+            for (const n of oldNames) {
+                if (!newNames.has(n))
+                    changed.add(n);
+            }
+            for (const n of newNames) {
+                if (!oldNames.has(n))
+                    changed.add(n);
+            }
+            if (!changed.size)
+                return;
+            for (const artifact of Object.values(state.cells.config.artifacts)) {
+                const cache = artifact.graphCache;
+                if (!cache?.tableDependencies)
+                    continue;
+                for (const [cellId, tables] of Object.entries(cache.tableDependencies)) {
+                    if (tables.some((t) => changed.has(t))) {
+                        state.cells.invalidateCellStatus(cellId);
+                    }
+                }
+            }
+        });
         return {
             cells: {
                 cellRegistry,
-                supportedSheetTypes,
                 config: initialConfig,
                 status: {},
                 activeAbortControllers: {},
                 resultVersion: {},
                 pageVersion: {},
-                addCell: async (sheetId, cell, index) => {
+                async initialize() {
+                    for (const [cellId, cell] of Object.entries(get().cells.config.data)) {
+                        const registryItem = cellRegistry[cell.type];
+                        if (registryItem?.onInitialize) {
+                            registryItem.onInitialize({
+                                id: cellId,
+                                status: get().cells.status[cellId],
+                                get,
+                                set,
+                            });
+                        }
+                    }
+                },
+                setConfig(config) {
+                    set((state) => produce(state, (draft) => {
+                        draft.cells.config = config;
+                    }));
+                },
+                crossFilterSelections: {},
+                setCrossFilterSelection: (chartCellId, sqlId, selection) => {
+                    set((state) => produce(state, (draft) => {
+                        if (!draft.cells.crossFilterSelections[sqlId]) {
+                            draft.cells.crossFilterSelections[sqlId] = {};
+                        }
+                        draft.cells.crossFilterSelections[sqlId][chartCellId] = selection;
+                    }));
+                },
+                getCrossFilterPredicate: (chartCellId, sqlId) => {
+                    const group = get().cells.crossFilterSelections[sqlId];
+                    if (!group)
+                        return null;
+                    const siblingSelections = Object.entries(group)
+                        .filter(([id]) => id !== chartCellId)
+                        .map(([, sel]) => sel);
+                    return buildCrossFilterPredicate(siblingSelections);
+                },
+                clearCrossFilterGroup: (sqlId) => {
+                    set((state) => produce(state, (draft) => {
+                        delete draft.cells.crossFilterSelections[sqlId];
+                    }));
+                },
+                ensureArtifact: (artifactId, options) => {
+                    set((state) => produce(state, (draft) => {
+                        if (!draft.cells.config.artifacts[artifactId]) {
+                            draft.cells.config.artifacts[artifactId] = {
+                                id: artifactId,
+                                schemaName: options?.schemaName ?? getArtifactSchemaName(artifactId),
+                                cellIds: [],
+                                edges: [],
+                                graphCache: {
+                                    dependencies: {},
+                                    dependents: {},
+                                    contentHashByCell: {},
+                                    tableDependencies: {},
+                                },
+                            };
+                        }
+                        else if (options?.schemaName &&
+                            !draft.cells.config.artifacts[artifactId]?.schemaName) {
+                            draft.cells.config.artifacts[artifactId].schemaName =
+                                options.schemaName;
+                        }
+                    }));
+                },
+                addCell: async (artifactId, cell, index) => {
                     // Pre-compute dependencies outside produce() to support async
                     const sqlSelectToJson = getRequiredSqlSelectToJson(get());
-                    const targetSheet = get().cells.config.sheets[sheetId];
-                    const scopedCells = Object.fromEntries((targetSheet?.cellIds ?? [])
+                    const targetArtifact = get().cells.config.artifacts[artifactId];
+                    const scopedCells = Object.fromEntries((targetArtifact?.cellIds ?? [])
                         .map((id) => get().cells.config.data[id])
                         .filter(isDefined)
                         .map((candidate) => [candidate.id, candidate]));
                     scopedCells[cell.id] = cell;
-                    const deps = await resolveDependencies(cell, scopedCells, sheetId, cellRegistry, sqlSelectToJson);
+                    // Generate a unique result name for SQL cells if not set
+                    if (cell.type === 'sql' && !cell.data.resultName) {
+                        const existingNames = Object.values(scopedCells)
+                            .filter((c) => c.type === 'sql' && c.id !== cell.id)
+                            .map((c) => getEffectiveResultName(c.data, convertToValidColumnOrTableName));
+                        const baseName = getEffectiveResultName(cell.data, convertToValidColumnOrTableName);
+                        const uniqueName = generateUniqueName(baseName, existingNames);
+                        cell.data.resultName = uniqueName;
+                    }
+                    const deps = await resolveDependencies(cell, scopedCells, artifactId, cellRegistry, sqlSelectToJson);
                     set((state) => produce(state, (draft) => {
                         draft.cells.config.data[cell.id] = cell;
-                        if (cell.type === 'sql') {
-                            draft.cells.status[cell.id] = {
-                                type: 'sql',
-                                status: 'idle',
-                                referencedTables: [],
-                            };
-                        }
-                        else {
-                            draft.cells.status[cell.id] = { type: 'other' };
-                        }
-                        // Single-owner invariant: a cell can belong to one sheet only.
-                        for (const [existingSheetId, existingSheet] of Object.entries(draft.cells.config.sheets)) {
-                            if (existingSheetId === sheetId)
+                        const registryItem = cellRegistry[cell.type];
+                        draft.cells.status[cell.id] = registryItem?.createStatus?.(cell.id) ?? { type: 'other' };
+                        // Single-owner invariant: a cell can belong to one artifact only.
+                        for (const [existingArtifactId, existingArtifact,] of Object.entries(draft.cells.config.artifacts)) {
+                            if (existingArtifactId === artifactId)
                                 continue;
-                            existingSheet.cellIds = existingSheet.cellIds.filter((cid) => cid !== cell.id);
-                            existingSheet.edges = existingSheet.edges.filter((e) => e.source !== cell.id && e.target !== cell.id);
-                            removeCellFromCache(existingSheet, cell.id);
+                            existingArtifact.cellIds = existingArtifact.cellIds.filter((cid) => cid !== cell.id);
+                            existingArtifact.edges = existingArtifact.edges.filter((e) => e.source !== cell.id && e.target !== cell.id);
+                            removeCellFromCache(existingArtifact, cell.id);
                         }
-                        let sheet = draft.cells.config.sheets[sheetId];
-                        if (!sheet) {
-                            sheet = {
-                                id: sheetId,
-                                type: 'notebook',
-                                title: 'Sheet',
-                                schemaName: getSheetSchemaName(sheetId),
+                        let artifact = draft.cells.config.artifacts[artifactId];
+                        if (!artifact) {
+                            artifact = {
+                                id: artifactId,
+                                schemaName: getArtifactSchemaName(artifactId),
                                 cellIds: [],
                                 edges: [],
                                 graphCache: {
                                     dependencies: {},
                                     dependents: {},
                                     contentHashByCell: {},
+                                    tableDependencies: {},
                                 },
                             };
-                            draft.cells.config.sheets[sheetId] = sheet;
-                            if (!draft.cells.config.sheetOrder.includes(sheetId)) {
-                                draft.cells.config.sheetOrder.push(sheetId);
-                            }
-                            if (!draft.cells.config.currentSheetId) {
-                                draft.cells.config.currentSheetId = sheetId;
-                            }
+                            draft.cells.config.artifacts[artifactId] = artifact;
                         }
-                        const newIndex = index !== undefined ? index : sheet.cellIds.length;
-                        sheet.cellIds = sheet.cellIds.filter((cid) => cid !== cell.id);
-                        sheet.cellIds.splice(newIndex, 0, cell.id);
+                        const newIndex = index !== undefined ? index : artifact.cellIds.length;
+                        artifact.cellIds = artifact.cellIds.filter((cid) => cid !== cell.id);
+                        artifact.cellIds.splice(newIndex, 0, cell.id);
                         // Add edges from pre-computed dependencies
-                        sheet.edges = sheet.edges.filter((edge) => edge.target !== cell.id &&
+                        artifact.edges = artifact.edges.filter((edge) => edge.target !== cell.id &&
                             edge.id !== `${edge.source}-${cell.id}`);
-                        const localCellIds = new Set(sheet.cellIds);
-                        for (const depId of deps) {
+                        const localCellIds = new Set(artifact.cellIds);
+                        for (const depId of deps.cellIds) {
                             if (!localCellIds.has(depId) || depId === cell.id)
                                 continue;
-                            sheet.edges.push({
+                            artifact.edges.push({
                                 id: `${depId}-${cell.id}`,
                                 source: depId,
                                 target: cell.id,
                             });
                         }
-                        replaceCellDependenciesInCache(sheet, cell.id, deps.filter((depId) => localCellIds.has(depId)));
+                        replaceCellDependenciesInCache(artifact, cell.id, deps.cellIds.filter((depId) => localCellIds.has(depId)), deps.tableNames);
                     }));
                 },
                 removeCell: (id) => {
+                    const cell = get().cells.config.data[id];
                     const previousStatus = get().cells.status[id];
                     cellResultCache.delete(id);
                     set((state) => produce(state, (draft) => {
@@ -154,39 +231,46 @@ export function createCellsSlice(props) {
                             controller.abort();
                             delete draft.cells.activeAbortControllers[id];
                         }
-                        // Remove from all sheets
-                        for (const sheet of Object.values(draft.cells.config.sheets)) {
-                            sheet.cellIds = sheet.cellIds.filter((cid) => cid !== id);
-                            sheet.edges = sheet.edges.filter((e) => e.source !== id && e.target !== id);
-                            removeCellFromCache(sheet, id);
+                        // Remove from all artifacts
+                        for (const artifact of Object.values(draft.cells.config.artifacts)) {
+                            artifact.cellIds = artifact.cellIds.filter((cid) => cid !== id);
+                            artifact.edges = artifact.edges.filter((e) => e.source !== id && e.target !== id);
+                            removeCellFromCache(artifact, id);
                         }
                     }));
-                    if (previousStatus?.type === 'sql') {
-                        void dropSqlResultRelation(previousStatus.resultView);
+                    if (cell) {
+                        const registryItem = cellRegistry[cell.type];
+                        if (registryItem?.onRemove) {
+                            void registryItem.onRemove({
+                                id,
+                                status: previousStatus,
+                                get,
+                                set,
+                            });
+                        }
+                        else {
+                            void dropRelationsForStatus(cell.type, previousStatus);
+                        }
                     }
                 },
                 updateCell: async (id, updater, opts) => {
                     const cell = get().cells.config.data[id];
                     if (!cell)
                         return;
-                    const ownerSheetId = findSheetIdForCell(get(), id);
-                    const scopedCells = Object.fromEntries(((ownerSheetId &&
-                        get().cells.config.sheets[ownerSheetId]?.cellIds) ||
+                    const ownerArtifactId = findArtifactIdForCell(get(), id);
+                    const scopedCells = Object.fromEntries(((ownerArtifactId &&
+                        get().cells.config.artifacts[ownerArtifactId]?.cellIds) ||
                         [])
                         .map((cellId) => get().cells.config.data[cellId])
                         .filter(isDefined)
                         .map((candidate) => [candidate.id, candidate]));
                     const updatedCell = updater(cell);
                     scopedCells[id] = updatedCell;
-                    // Check if resultName changed for SQL cells with successful execution
-                    const resultNameChanged = isSqlCell(cell) &&
-                        isSqlCell(updatedCell) &&
-                        cell.data.resultName !== updatedCell.data.resultName;
+                    const registryItem = cellRegistry[cell.type];
                     const existingStatus = get().cells.status[id];
-                    const hasExistingView = resultNameChanged &&
-                        existingStatus?.type === 'sql' &&
-                        existingStatus.status === 'success' &&
-                        existingStatus.resultView;
+                    const oldResultRelation = existingStatus && registryItem?.getResultRelation
+                        ? registryItem.getResultRelation(existingStatus)
+                        : undefined;
                     const semanticInputChanged = isInputCell(cell) &&
                         isInputCell(updatedCell) &&
                         (cell.data.input.varName !== updatedCell.data.input.varName ||
@@ -194,12 +278,20 @@ export function createCellsSlice(props) {
                     const semanticSqlChanged = isSqlCell(cell) &&
                         isSqlCell(updatedCell) &&
                         cell.data.sql !== updatedCell.data.sql;
+                    const semanticChanged = registryItem?.hasSemanticChange?.(cell, updatedCell) ?? false;
                     // Apply cell data to the store immediately so that other
                     // actions (e.g. runCell triggered via Cmd+Enter) always see
                     // the latest value. Edge/dependency updates follow
                     // asynchronously below.
                     set((state) => produce(state, (draft) => {
                         draft.cells.config.data[id] = updatedCell;
+                        if (semanticChanged) {
+                            const status = draft.cells.status[id];
+                            if (status && registryItem?.invalidateStatus) {
+                                draft.cells.status[id] =
+                                    registryItem.invalidateStatus(status);
+                            }
+                        }
                     }));
                     // Avoid expensive dependency graph recomputation on each SQL keystroke.
                     // We recompute immediately for non-SQL edits, or when callers explicitly
@@ -208,13 +300,13 @@ export function createCellsSlice(props) {
                     if (shouldRecomputeDependencies) {
                         // Pre-compute dependencies outside produce() to support async
                         const sqlSelectToJson = getRequiredSqlSelectToJson(get());
-                        const newDeps = await resolveDependencies(updatedCell, scopedCells, ownerSheetId || '', cellRegistry, sqlSelectToJson);
+                        const newDeps = await resolveDependencies(updatedCell, scopedCells, ownerArtifactId || '', cellRegistry, sqlSelectToJson);
                         set((state) => produce(state, (draft) => {
-                            const ownerSheet = Object.values(draft.cells.config.sheets).find((sheet) => sheet.cellIds.includes(id));
+                            const ownerSheet = Object.values(draft.cells.config.artifacts).find((artifact) => artifact.cellIds.includes(id));
                             if (ownerSheet) {
                                 const localCellIds = new Set(ownerSheet.cellIds);
                                 ownerSheet.edges = ownerSheet.edges.filter((e) => e.target !== id);
-                                for (const depId of newDeps) {
+                                for (const depId of newDeps.cellIds) {
                                     if (!localCellIds.has(depId) || depId === id)
                                         continue;
                                     ownerSheet.edges.push({
@@ -223,65 +315,45 @@ export function createCellsSlice(props) {
                                         target: id,
                                     });
                                 }
-                                replaceCellDependenciesInCache(ownerSheet, id, newDeps.filter((depId) => localCellIds.has(depId)));
+                                replaceCellDependenciesInCache(ownerSheet, id, newDeps.cellIds.filter((depId) => localCellIds.has(depId)), newDeps.tableNames);
                             }
                         }));
                     }
-                    // If we have an existing view, rename it instead of invalidating
-                    if (hasExistingView && existingStatus?.resultView) {
-                        const registryItem = cellRegistry[cell.type];
-                        if (registryItem?.renameResult) {
-                            void registryItem.renameResult({
-                                id,
-                                oldResultView: existingStatus.resultView,
-                                get,
-                                set,
-                            });
-                        }
+                    // If the result relation changed name (e.g. SQL resultName changed), rename it
+                    const newStatus = get().cells.status[id];
+                    const newResultRelation = newStatus && registryItem?.getResultRelation
+                        ? registryItem.getResultRelation(newStatus)
+                        : undefined;
+                    const resultRelationChanged = oldResultRelation && newResultRelation !== oldResultRelation;
+                    if (resultRelationChanged && registryItem?.renameResult) {
+                        void registryItem.renameResult({
+                            id,
+                            oldResultView: oldResultRelation,
+                            get,
+                            set,
+                        });
                     }
                     // After update, trigger cascade only if explicitly requested
                     // or if semantic execution inputs changed.
-                    const shouldCascade = opts?.cascade || resultNameChanged || semanticInputChanged;
+                    const shouldCascade = opts?.cascade || resultRelationChanged || semanticInputChanged;
                     if (shouldCascade) {
-                        if (ownerSheetId) {
-                            void get().cells.runDownstreamCascade(ownerSheetId, id);
+                        if (ownerArtifactId) {
+                            void get().cells.runDownstreamCascade(ownerArtifactId, id);
                         }
                     }
                 },
-                addSheet: (title, type = 'notebook') => {
-                    const id = createId();
-                    set((state) => produce(state, (draft) => {
-                        const typeLabel = type.charAt(0).toUpperCase() + type.slice(1);
-                        const existingTitles = Object.values(draft.cells.config.sheets).map((s) => s.title);
-                        const defaultTitle = generateUniqueName(`${typeLabel} 1`, existingTitles, ' ');
-                        draft.cells.config.sheets[id] = {
-                            id,
-                            type,
-                            title: title || defaultTitle,
-                            schemaName: getSheetSchemaName(id),
-                            cellIds: [],
-                            edges: [],
-                            graphCache: {
-                                dependencies: {},
-                                dependents: {},
-                                contentHashByCell: {},
-                            },
-                        };
-                        draft.cells.config.sheetOrder.push(id);
-                        draft.cells.config.currentSheetId = id;
-                    }));
-                    return id;
-                },
-                removeSheet: (sheetId) => {
-                    const sheet = get().cells.config.sheets[sheetId];
-                    if (!sheet)
+                removeArtifact: (artifactId) => {
+                    const artifact = get().cells.config.artifacts[artifactId];
+                    if (!artifact)
                         return;
-                    const ownedCellIds = [...sheet.cellIds];
+                    const ownedCellIds = [...artifact.cellIds];
                     const relationNamesToDrop = ownedCellIds.flatMap((cellId) => {
+                        const cell = get().cells.config.data[cellId];
                         const status = get().cells.status[cellId];
-                        return status?.type === 'sql' && status.resultView
-                            ? [status.resultView]
-                            : [];
+                        if (!cell || !status)
+                            return [];
+                        const registryItem = cellRegistry[cell.type];
+                        return registryItem?.getRelationsToDrop?.(status) ?? [];
                     });
                     set((state) => produce(state, (draft) => {
                         for (const cellId of ownedCellIds) {
@@ -296,7 +368,7 @@ export function createCellsSlice(props) {
                             }
                             delete draft.cells.activeAbortControllers[cellId];
                         }
-                        for (const existingSheet of Object.values(draft.cells.config.sheets)) {
+                        for (const existingSheet of Object.values(draft.cells.config.artifacts)) {
                             existingSheet.cellIds = existingSheet.cellIds.filter((cid) => !ownedCellIds.includes(cid));
                             existingSheet.edges = existingSheet.edges.filter((e) => !ownedCellIds.includes(e.source) &&
                                 !ownedCellIds.includes(e.target));
@@ -304,124 +376,72 @@ export function createCellsSlice(props) {
                                 removeCellFromCache(existingSheet, cellId);
                             }
                         }
-                        delete draft.cells.config.sheets[sheetId];
-                        draft.cells.config.sheetOrder =
-                            draft.cells.config.sheetOrder.filter((id) => id !== sheetId);
-                        if (draft.cells.config.currentSheetId === sheetId) {
-                            draft.cells.config.currentSheetId =
-                                draft.cells.config.sheetOrder[0];
-                        }
+                        delete draft.cells.config.artifacts[artifactId];
                     }));
                     for (const relationName of relationNamesToDrop) {
-                        void dropSqlResultRelation(relationName);
+                        void dropRelationBestEffort(relationName);
                     }
                 },
-                closeSheet: (sheetId) => {
-                    set((state) => produce(state, (draft) => {
-                        draft.cells.config.sheetOrder =
-                            draft.cells.config.sheetOrder.filter((id) => id !== sheetId);
-                        if (draft.cells.config.currentSheetId === sheetId) {
-                            draft.cells.config.currentSheetId =
-                                draft.cells.config.sheetOrder[0];
-                        }
-                    }));
-                },
-                openSheet: (sheetId) => {
-                    set((state) => produce(state, (draft) => {
-                        if (!draft.cells.config.sheetOrder.includes(sheetId)) {
-                            draft.cells.config.sheetOrder.push(sheetId);
-                        }
-                        draft.cells.config.currentSheetId = sheetId;
-                    }));
-                },
-                setSheetOrder: (sheetOrder) => {
+                addEdge: (artifactId, edge) => {
                     set((state) => produce(state, (draft) => {
-                        draft.cells.config.sheetOrder = sheetOrder;
-                    }));
-                },
-                renameSheet: (sheetId, title) => {
-                    set((state) => produce(state, (draft) => {
-                        const sheet = draft.cells.config.sheets[sheetId];
-                        if (sheet) {
-                            // We could add validation here, but usually UI handles it.
-                            // For now, we'll just allow it as the primary logic is in view slices.
-                            sheet.title = title;
-                        }
-                    }));
-                },
-                setCurrentSheet: (sheetId) => {
-                    set((state) => produce(state, (draft) => {
-                        draft.cells.config.currentSheetId = sheetId;
-                    }));
-                },
-                addEdge: (sheetId, edge) => {
-                    set((state) => produce(state, (draft) => {
-                        let sheet = draft.cells.config.sheets[sheetId];
-                        if (!sheet) {
-                            sheet = {
-                                id: sheetId,
-                                type: 'notebook',
-                                title: 'Sheet',
-                                schemaName: getSheetSchemaName(sheetId),
+                        let artifact = draft.cells.config.artifacts[artifactId];
+                        if (!artifact) {
+                            artifact = {
+                                id: artifactId,
+                                schemaName: getArtifactSchemaName(artifactId),
                                 cellIds: [],
                                 edges: [],
                                 graphCache: {
                                     dependencies: {},
                                     dependents: {},
                                     contentHashByCell: {},
+                                    tableDependencies: {},
                                 },
                             };
-                            draft.cells.config.sheets[sheetId] = sheet;
-                            if (!draft.cells.config.sheetOrder.includes(sheetId)) {
-                                draft.cells.config.sheetOrder.push(sheetId);
-                            }
-                            if (!draft.cells.config.currentSheetId) {
-                                draft.cells.config.currentSheetId = sheetId;
-                            }
+                            draft.cells.config.artifacts[artifactId] = artifact;
                         }
-                        if (!sheet.cellIds.includes(edge.source) ||
-                            !sheet.cellIds.includes(edge.target)) {
+                        if (!artifact.cellIds.includes(edge.source) ||
+                            !artifact.cellIds.includes(edge.target)) {
                             return;
                         }
                         const id = `${edge.source}-${edge.target}`;
-                        if (!sheet.edges.find((e) => e.id === id)) {
-                            sheet.edges.push({ ...edge, id });
-                            ensureGraphCache(sheet);
-                            const deps = sheet.graphCache?.dependencies[edge.target] || [];
-                            replaceCellDependenciesInCache(sheet, edge.target, [
+                        if (!artifact.edges.find((e) => e.id === id)) {
+                            artifact.edges.push({ ...edge, id });
+                            const deps = artifact.graphCache?.dependencies[edge.target] || [];
+                            replaceCellDependenciesInCache(artifact, edge.target, [
                                 ...deps,
                                 edge.source,
                             ]);
                         }
                     }));
                 },
-                removeEdge: (sheetId, edgeId) => {
+                removeEdge: (artifactId, edgeId) => {
                     set((state) => produce(state, (draft) => {
-                        const sheet = draft.cells.config.sheets[sheetId];
-                        if (sheet) {
-                            sheet.edges = sheet.edges.filter((e) => e.id !== edgeId);
-                            delete sheet.graphCache;
+                        const artifact = draft.cells.config.artifacts[artifactId];
+                        if (artifact) {
+                            artifact.edges = artifact.edges.filter((e) => e.id !== edgeId);
+                            delete artifact.graphCache;
                         }
                     }));
                 },
-                updateEdgesFromSql: async (sheetId, cellId) => {
+                updateEdgesFromSql: async (artifactId, cellId) => {
                     const cell = get().cells.config.data[cellId];
-                    const sheet = get().cells.config.sheets[sheetId];
-                    if (!cell || !sheet)
+                    const artifact = get().cells.config.artifacts[artifactId];
+                    if (!cell || !artifact)
                         return;
                     // Pre-compute dependencies outside produce() to support async
                     const sqlSelectToJson = getRequiredSqlSelectToJson(get());
-                    const scopedCells = Object.fromEntries(sheet.cellIds
+                    const scopedCells = Object.fromEntries(artifact.cellIds
                         .map((id) => get().cells.config.data[id])
                         .filter(isDefined)
                         .map((candidate) => [candidate.id, candidate]));
-                    const deps = await resolveDependencies(cell, scopedCells, sheetId, cellRegistry, sqlSelectToJson);
+                    const deps = await resolveDependencies(cell, scopedCells, artifactId, cellRegistry, sqlSelectToJson);
                     set((state) => produce(state, (draft) => {
-                        const draftSheet = draft.cells.config.sheets[sheetId];
+                        const draftSheet = draft.cells.config.artifacts[artifactId];
                         if (draftSheet) {
                             draftSheet.edges = draftSheet.edges.filter((e) => e.target !== cellId);
                             const localCellIds = new Set(draftSheet.cellIds);
-                            for (const depId of deps) {
+                            for (const depId of deps.cellIds) {
                                 if (!localCellIds.has(depId) || depId === cellId)
                                     continue;
                                 draftSheet.edges.push({
@@ -430,7 +450,7 @@ export function createCellsSlice(props) {
                                     target: cellId,
                                 });
                             }
-                            replaceCellDependenciesInCache(draftSheet, cellId, deps.filter((depId) => localCellIds.has(depId)));
+                            replaceCellDependenciesInCache(draftSheet, cellId, deps.cellIds.filter((depId) => localCellIds.has(depId)), deps.tableNames);
                         }
                     }));
                 },
@@ -457,15 +477,14 @@ export function createCellsSlice(props) {
                     }
                 },
                 invalidateCellStatus: (id) => {
+                    const cell = get().cells.config.data[id];
+                    if (!cell)
+                        return;
+                    const registryItem = cellRegistry[cell.type];
                     set((state) => produce(state, (draft) => {
                         const status = draft.cells.status[id];
-                        if (status?.type === 'sql') {
-                            // Reset to idle, clearing the result so user knows to re-run
-                            draft.cells.status[id] = {
-                                type: 'sql',
-                                status: 'idle',
-                                referencedTables: status.referencedTables || [],
-                            };
+                        if (status && registryItem?.invalidateStatus) {
+                            draft.cells.status[id] = registryItem.invalidateStatus(status);
                         }
                     }));
                 },
@@ -496,25 +515,35 @@ export function createCellsSlice(props) {
                 },
                 fetchCellResultPage: async (id, pagination, sorting) => {
                     const state = get();
+                    const cell = state.cells.config.data[id];
+                    if (!cell)
+                        return;
+                    const registryItem = cellRegistry[cell.type];
                     const status = state.cells.status[id];
-                    if (status?.type !== 'sql' || !status.resultView)
+                    const resultRelation = status && registryItem?.getResultRelation
+                        ? registryItem.getResultRelation(status)
+                        : undefined;
+                    if (!resultRelation)
                         return;
                     const connector = await state.db.getConnector();
-                    const baseQuery = sanitizeQuery(`SELECT * FROM ${status.resultView}`);
+                    const baseQuery = sanitizeQuery(`SELECT * FROM ${resultRelation}`);
                     const pagedQuery = makePagedQuery(baseQuery, sorting ?? [], pagination);
                     const arrowTable = await connector.query(pagedQuery);
-                    const countResult = await connector.query(`SELECT COUNT(*)::int AS count FROM ${status.resultView}`);
+                    const countResult = await connector.query(`SELECT COUNT(*)::int AS count FROM ${resultRelation}`);
                     const totalRows = countResult.toArray()[0]?.count ?? 0;
                     get().cells.setCellResultPage(id, { arrowTable, totalRows });
                 },
                 // DAG methods (sync versions for UI usage)
-                getRootCells: (sheetId) => {
-                    const { dependencies } = buildDependencyGraph(sheetId, get());
+                getArtifactIdForCell: (cellId) => {
+                    return findArtifactIdForCell(get(), cellId);
+                },
+                getRootCells: (artifactId) => {
+                    const { dependencies } = buildDependencyGraph(artifactId, get());
                     const ids = Object.keys(dependencies);
                     return ids.filter((id) => (dependencies[id]?.length ?? 0) === 0);
                 },
-                getDownstream: (sheetId, sourceCellId) => {
-                    const { dependencies, dependents } = buildDependencyGraph(sheetId, get());
+                getDownstream: (artifactId, sourceCellId) => {
+                    const { dependencies, dependents } = buildDependencyGraph(artifactId, get());
                     const reachable = collectReachable(sourceCellId, dependents);
                     if (!reachable.size)
                         return [];
@@ -526,19 +555,19 @@ export function createCellsSlice(props) {
                     return topologicalOrder(rootsWithinScope, dependencies, dependents, reachable);
                 },
                 // Async cascade execution using AST-based dependency resolution
-                runAllCellsCascade: async (sheetId) => {
-                    const cached = buildDependencyGraph(sheetId, get());
+                runAllCellsCascade: async (artifactId) => {
+                    const cached = buildDependencyGraph(artifactId, get());
                     const hasCachedNodes = Object.keys(cached.dependencies).length > 0;
                     if (!hasCachedNodes) {
                         set((state) => produce(state, (draft) => {
-                            const sheet = draft.cells.config.sheets[sheetId];
-                            if (sheet) {
-                                sheet.graphCache = buildGraphCacheFromEdges(sheet);
+                            const artifact = draft.cells.config.artifacts[artifactId];
+                            if (artifact) {
+                                artifact.graphCache = buildGraphCacheFromEdges(artifact);
                             }
                         }));
                     }
                     const sqlSelectToJson = getRequiredSqlSelectToJson(get());
-                    const { dependencies, dependents } = await buildDependencyGraphAsync(sheetId, get(), sqlSelectToJson);
+                    const { dependencies, dependents } = await buildDependencyGraphAsync(artifactId, get(), sqlSelectToJson);
                     const roots = Object.keys(dependencies).filter((id) => (dependencies[id]?.length ?? 0) === 0);
                     const order = topologicalOrder(roots, dependencies, dependents);
                     for (const cellId of order) {
@@ -547,29 +576,35 @@ export function createCellsSlice(props) {
                         }
                         catch (error) {
                             const message = error instanceof Error ? error.message : String(error);
-                            set((state) => produce(state, (draft) => {
-                                const status = draft.cells.status[cellId];
-                                if (status?.type === 'sql') {
-                                    status.status = 'error';
-                                    status.lastError = message;
-                                }
-                            }));
+                            const failedCell = get().cells.config.data[cellId];
+                            const failedRegistryItem = failedCell
+                                ? cellRegistry[failedCell.type]
+                                : undefined;
+                            if (failedRegistryItem?.recordError) {
+                                set((state) => produce(state, (draft) => {
+                                    const status = draft.cells.status[cellId];
+                                    if (status) {
+                                        draft.cells.status[cellId] =
+                                            failedRegistryItem.recordError(status, message);
+                                    }
+                                }));
+                            }
                         }
                     }
                 },
-                runDownstreamCascade: async (sheetId, sourceCellId) => {
-                    const cached = buildDependencyGraph(sheetId, get());
+                runDownstreamCascade: async (artifactId, sourceCellId) => {
+                    const cached = buildDependencyGraph(artifactId, get());
                     const hasCachedNodes = Object.keys(cached.dependencies).length > 0;
                     if (!hasCachedNodes) {
                         set((state) => produce(state, (draft) => {
-                            const sheet = draft.cells.config.sheets[sheetId];
-                            if (sheet) {
-                                sheet.graphCache = buildGraphCacheFromEdges(sheet);
+                            const artifact = draft.cells.config.artifacts[artifactId];
+                            if (artifact) {
+                                artifact.graphCache = buildGraphCacheFromEdges(artifact);
                             }
                         }));
                     }
                     const sqlSelectToJson = getRequiredSqlSelectToJson(get());
-                    const { dependencies, dependents } = await buildDependencyGraphAsync(sheetId, get(), sqlSelectToJson);
+                    const { dependencies, dependents } = await buildDependencyGraphAsync(artifactId, get(), sqlSelectToJson);
                     const reachable = collectReachable(sourceCellId, dependents);
                     if (!reachable.size)
                         return;
@@ -585,13 +620,19 @@ export function createCellsSlice(props) {
                         }
                         catch (error) {
                             const message = error instanceof Error ? error.message : String(error);
-                            set((state) => produce(state, (draft) => {
-                                const status = draft.cells.status[cellId];
-                                if (status?.type === 'sql') {
-                                    status.status = 'error';
-                                    status.lastError = message;
-                                }
-                            }));
+                            const failedCell = get().cells.config.data[cellId];
+                            const failedRegistryItem = failedCell
+                                ? cellRegistry[failedCell.type]
+                                : undefined;
+                            if (failedRegistryItem?.recordError) {
+                                set((state) => produce(state, (draft) => {
+                                    const status = draft.cells.status[cellId];
+                                    if (status) {
+                                        draft.cells.status[cellId] =
+                                            failedRegistryItem.recordError(status, message);
+                                    }
+                                }));
+                            }
                         }
                     }
                 },