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

package/README.md

@@ -5,16 +5,16 @@ Shared cells model and UI primitives used by notebook and canvas views.
 The package owns:
 
 - canonical cell records (`cells.config.data`)
-- sheet grouping and ordering (`cells.config.sheets`, `sheetOrder`, `currentSheetId`)
-- in-sheet dependency edges and cascade execution
+- artifact-scoped runtime containers (`cells.config.artifacts`)
+- in-artifact dependency edges and cascade execution
 - SQL/result execution helpers and status tracking
 
 ## Dependency and schema model
 
-- Dependencies and cascades are **sheet-local** by default.
-- Cross-sheet references are only supported via explicit fully qualified SQL names.
-- SQL execution resolves to a stable sheet schema namespace; it does not rely on global `USE schema`.
-- Unqualified result-name references are resolved to the current sheet namespace during execution.
+- Dependencies and cascades are **artifact-local** by default.
+- Cross-artifact references are only supported via explicit fully qualified SQL names.
+- SQL execution resolves to a stable artifact schema namespace; it does not rely on global `USE schema`.
+- Unqualified result-name references are resolved to the current artifact namespace during execution.
 
 ## Stable public API
 
@@ -22,9 +22,9 @@ Import from package root for stable APIs:
 
 - slice: `createCellsSlice`
 - hooks: `useCellsStore`
-- helpers: `findSheetIdForCell`, `getSheetsByType`
+- helpers: `findArtifactIdForCell`, `resolveArtifactSchemaName`
 - SQL helpers: `renderSqlWithInputs`, `findSqlDependencies`, `findSqlDependenciesFromAst`
-- UI: `SqlCellContent`, `SqlCellRunButton`, `TextCellContent`, `InputCellContent`, `VegaCellContent`, `SheetsTabBar`
+- UI: `SqlCellContent`, `SqlCellRunButton`, `TextCellContent`, `InputCellContent`, `VegaCellContent`, `CellSourceSelector`
 - types/schemas: exports from `types.ts`
 
 ## Internal APIs

package/dist/cellsSlice.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cellsSlice.d.ts","sourceRoot":"","sources":["../src/cellsSlice.ts"],"names":[],"mappings":"AA0BA,OAAO,KAAK,EAKV,iBAAiB,EACjB,eAAe,EAMhB,MAAM,SAAS,CAAC;AAoDjB,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,iBAAiB,mDA83BxD"}
+{"version":3,"file":"cellsSlice.d.ts","sourceRoot":"","sources":["../src/cellsSlice.ts"],"names":[],"mappings":"AAyBA,OAAO,KAAK,EAKV,iBAAiB,EACjB,eAAe,EAKhB,MAAM,SAAS,CAAC;AAiCjB,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,iBAAiB,mDA6zBxD"}

package/dist/cellsSlice.js

@@ -1,54 +1,33 @@
-import { createId } from '@paralleldrive/cuid2';
 import { makePagedQuery } from '@sqlrooms/data-table';
 import { sanitizeQuery } from '@sqlrooms/duckdb';
 import { createSlice } from '@sqlrooms/room-store';
 import { convertToValidColumnOrTableName, generateUniqueName, } from '@sqlrooms/utils';
 import { produce } from 'immer';
-import { buildDependencyGraph, buildDependencyGraphAsync, buildGraphCacheFromEdges, 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 { getEffectiveResultName, 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: {},
-                    tableDependencies: {},
-                },
-            },
-        },
-        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();
@@ -89,8 +68,8 @@ export function createCellsSlice(props) {
             }
             if (!changed.size)
                 return;
-            for (const sheet of Object.values(state.cells.config.sheets)) {
-                const cache = sheet.graphCache;
+            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)) {
@@ -103,7 +82,6 @@ export function createCellsSlice(props) {
         return {
             cells: {
                 cellRegistry,
-                supportedSheetTypes,
                 config: initialConfig,
                 status: {},
                 activeAbortControllers: {},
@@ -122,6 +100,11 @@ export function createCellsSlice(props) {
                         }
                     }
                 },
+                setConfig(config) {
+                    set((state) => produce(state, (draft) => {
+                        draft.cells.config = config;
+                    }));
+                },
                 crossFilterSelections: {},
                 setCrossFilterSelection: (chartCellId, sqlId, selection) => {
                     set((state) => produce(state, (draft) => {
@@ -145,11 +128,34 @@ export function createCellsSlice(props) {
                         delete draft.cells.crossFilterSelections[sqlId];
                     }));
                 },
-                addCell: async (sheetId, cell, index) => {
+                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]));
@@ -163,26 +169,24 @@ export function createCellsSlice(props) {
                         const uniqueName = generateUniqueName(baseName, existingNames);
                         cell.data.resultName = uniqueName;
                     }
-                    const deps = await resolveDependencies(cell, scopedCells, sheetId, cellRegistry, sqlSelectToJson);
+                    const deps = await resolveDependencies(cell, scopedCells, artifactId, cellRegistry, sqlSelectToJson);
                     set((state) => produce(state, (draft) => {
                         draft.cells.config.data[cell.id] = cell;
                         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 sheet only.
-                        for (const [existingSheetId, existingSheet] of Object.entries(draft.cells.config.sheets)) {
-                            if (existingSheetId === sheetId)
+                        // 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: {
@@ -192,31 +196,25 @@ export function createCellsSlice(props) {
                                     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);
+                        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.cellIds.filter((depId) => localCellIds.has(depId)), deps.tableNames);
+                        replaceCellDependenciesInCache(artifact, cell.id, deps.cellIds.filter((depId) => localCellIds.has(depId)), deps.tableNames);
                     }));
                 },
                 removeCell: (id) => {
@@ -233,11 +231,11 @@ 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 (cell) {
@@ -259,9 +257,9 @@ export function createCellsSlice(props) {
                     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)
@@ -302,9 +300,9 @@ 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);
@@ -339,41 +337,16 @@ export function createCellsSlice(props) {
                     // or if semantic execution inputs changed.
                     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: {},
-                                tableDependencies: {},
-                            },
-                        };
-                        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];
@@ -395,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));
@@ -403,65 +376,19 @@ 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 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) => {
+                addEdge: (artifactId, edge) => {
                     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) => {
-                    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: {
@@ -471,53 +398,46 @@ export function createCellsSlice(props) {
                                     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);
@@ -614,13 +534,16 @@ export function createCellsSlice(props) {
                     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 [];
@@ -632,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) {
@@ -669,19 +592,19 @@ export function createCellsSlice(props) {
                         }
                     }
                 },
-                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;