@sqlrooms/cells 0.29.0-rc.1

package/LICENSE.md

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright 2025 SQLRooms Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,32 @@
+# @sqlrooms/cells
+
+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
+- 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.
+
+## Stable public API
+
+Import from package root for stable APIs:
+
+- slice: `createCellsSlice`
+- hooks: `useCellsStore`
+- helpers: `findSheetIdForCell`, `getSheetsByType`
+- SQL helpers: `renderSqlWithInputs`, `findSqlDependencies`, `findSqlDependenciesFromAst`
+- UI: `SqlCellContent`, `SqlCellRunButton`, `TextCellContent`, `InputCellContent`, `VegaCellContent`, `SheetsTabBar`
+- types/schemas: exports from `types.ts`
+
+## Internal APIs
+
+Avoid importing internal implementation modules directly (for example `dagUtils`, `execution`, or component subpaths). These are not guaranteed to be semver-stable.

package/dist/cellsSlice.d.ts

@@ -0,0 +1,3 @@
+import type { CellsSliceOptions, CellsSliceState } from './types';
+export declare function createCellsSlice(props: CellsSliceOptions): import("zustand").StateCreator<CellsSliceState>;
+//# sourceMappingURL=cellsSlice.d.ts.map

package/dist/cellsSlice.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cellsSlice.d.ts","sourceRoot":"","sources":["../src/cellsSlice.ts"],"names":[],"mappings":"AAuBA,OAAO,KAAK,EAKV,iBAAiB,EACjB,eAAe,EAGhB,MAAM,SAAS,CAAC;AAgDjB,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,iBAAiB,mDA4uBxD"}

package/dist/cellsSlice.js

@@ -0,0 +1,602 @@
+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 { produce } from 'immer';
+import { buildGraphCacheFromEdges, buildDependencyGraph, buildDependencyGraphAsync, collectReachable, ensureGraphCache, removeCellFromCache, replaceCellDependenciesInCache, topologicalOrder, } from './dagUtils';
+import { findSheetIdForCell, getRequiredSqlSelectToJson, normalizeCellsConfigStructure, resolveDependencies, } from './helpers';
+import { dropResultRelation } from './resultRelationPolicy';
+import { isInputCell, isSqlCell } from './types';
+import { getSheetSchemaName, isDefined } from './utils';
+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,
+    };
+    if (!config) {
+        return defaultConfig;
+    }
+    const { sheets, sheetOrder, currentSheetId } = normalizeCellsConfigStructure(config, defaultConfig);
+    return {
+        ...defaultConfig,
+        ...config,
+        sheets,
+        sheetOrder,
+        currentSheetId,
+    };
+}
+// --- Slice Implementation ---
+export function createCellsSlice(props) {
+    const { cellRegistry, supportedSheetTypes = ['notebook', 'canvas'] } = 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) => {
+            try {
+                const connector = await get().db.getConnector();
+                await dropResultRelation({ connector, relationName: resultName });
+            }
+            catch {
+                // Best-effort cleanup: relation might already be gone or connector
+                // might be unavailable during teardown.
+            }
+        };
+        return {
+            cells: {
+                cellRegistry,
+                supportedSheetTypes,
+                config: initialConfig,
+                status: {},
+                activeAbortControllers: {},
+                resultVersion: {},
+                pageVersion: {},
+                addCell: async (sheetId, 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 ?? [])
+                        .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);
+                    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)
+                                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);
+                        }
+                        let sheet = draft.cells.config.sheets[sheetId];
+                        if (!sheet) {
+                            sheet = {
+                                id: sheetId,
+                                type: 'notebook',
+                                title: 'Sheet',
+                                schemaName: getSheetSchemaName(sheetId),
+                                cellIds: [],
+                                edges: [],
+                                graphCache: {
+                                    dependencies: {},
+                                    dependents: {},
+                                    contentHashByCell: {},
+                                },
+                            };
+                            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;
+                            }
+                        }
+                        const newIndex = index !== undefined ? index : sheet.cellIds.length;
+                        sheet.cellIds = sheet.cellIds.filter((cid) => cid !== cell.id);
+                        sheet.cellIds.splice(newIndex, 0, cell.id);
+                        // Add edges from pre-computed dependencies
+                        sheet.edges = sheet.edges.filter((edge) => edge.target !== cell.id &&
+                            edge.id !== `${edge.source}-${cell.id}`);
+                        const localCellIds = new Set(sheet.cellIds);
+                        for (const depId of deps) {
+                            if (!localCellIds.has(depId) || depId === cell.id)
+                                continue;
+                            sheet.edges.push({
+                                id: `${depId}-${cell.id}`,
+                                source: depId,
+                                target: cell.id,
+                            });
+                        }
+                        replaceCellDependenciesInCache(sheet, cell.id, deps.filter((depId) => localCellIds.has(depId)));
+                    }));
+                },
+                removeCell: (id) => {
+                    const previousStatus = get().cells.status[id];
+                    cellResultCache.delete(id);
+                    set((state) => produce(state, (draft) => {
+                        delete draft.cells.config.data[id];
+                        delete draft.cells.status[id];
+                        delete draft.cells.resultVersion[id];
+                        delete draft.cells.pageVersion[id];
+                        const controller = draft.cells.activeAbortControllers[id];
+                        if (controller) {
+                            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);
+                        }
+                    }));
+                    if (previousStatus?.type === 'sql') {
+                        void dropSqlResultRelation(previousStatus.resultView);
+                    }
+                },
+                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) ||
+                        [])
+                        .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 existingStatus = get().cells.status[id];
+                    const hasExistingView = resultNameChanged &&
+                        existingStatus?.type === 'sql' &&
+                        existingStatus.status === 'success' &&
+                        existingStatus.resultView;
+                    const semanticInputChanged = isInputCell(cell) &&
+                        isInputCell(updatedCell) &&
+                        (cell.data.input.varName !== updatedCell.data.input.varName ||
+                            cell.data.input.value !== updatedCell.data.input.value);
+                    const semanticSqlChanged = isSqlCell(cell) &&
+                        isSqlCell(updatedCell) &&
+                        cell.data.sql !== updatedCell.data.sql;
+                    // 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;
+                    }));
+                    // Avoid expensive dependency graph recomputation on each SQL keystroke.
+                    // We recompute immediately for non-SQL edits, or when callers explicitly
+                    // request cascading behavior.
+                    const shouldRecomputeDependencies = !semanticSqlChanged || opts?.cascade === true;
+                    if (shouldRecomputeDependencies) {
+                        // Pre-compute dependencies outside produce() to support async
+                        const sqlSelectToJson = getRequiredSqlSelectToJson(get());
+                        const newDeps = await resolveDependencies(updatedCell, scopedCells, ownerSheetId || '', cellRegistry, sqlSelectToJson);
+                        set((state) => produce(state, (draft) => {
+                            const ownerSheet = Object.values(draft.cells.config.sheets).find((sheet) => sheet.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) {
+                                    if (!localCellIds.has(depId) || depId === id)
+                                        continue;
+                                    ownerSheet.edges.push({
+                                        id: `${depId}-${id}`,
+                                        source: depId,
+                                        target: id,
+                                    });
+                                }
+                                replaceCellDependenciesInCache(ownerSheet, id, newDeps.filter((depId) => localCellIds.has(depId)));
+                            }
+                        }));
+                    }
+                    // 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,
+                            });
+                        }
+                    }
+                    // After update, trigger cascade only if explicitly requested
+                    // or if semantic execution inputs changed.
+                    const shouldCascade = opts?.cascade || resultNameChanged || semanticInputChanged;
+                    if (shouldCascade) {
+                        if (ownerSheetId) {
+                            void get().cells.runDownstreamCascade(ownerSheetId, 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)
+                        return;
+                    const ownedCellIds = [...sheet.cellIds];
+                    const relationNamesToDrop = ownedCellIds.flatMap((cellId) => {
+                        const status = get().cells.status[cellId];
+                        return status?.type === 'sql' && status.resultView
+                            ? [status.resultView]
+                            : [];
+                    });
+                    set((state) => produce(state, (draft) => {
+                        for (const cellId of ownedCellIds) {
+                            cellResultCache.delete(cellId);
+                            delete draft.cells.config.data[cellId];
+                            delete draft.cells.status[cellId];
+                            delete draft.cells.resultVersion[cellId];
+                            delete draft.cells.pageVersion[cellId];
+                            const controller = draft.cells.activeAbortControllers[cellId];
+                            if (controller) {
+                                controller.abort();
+                            }
+                            delete draft.cells.activeAbortControllers[cellId];
+                        }
+                        for (const existingSheet of Object.values(draft.cells.config.sheets)) {
+                            existingSheet.cellIds = existingSheet.cellIds.filter((cid) => !ownedCellIds.includes(cid));
+                            existingSheet.edges = existingSheet.edges.filter((e) => !ownedCellIds.includes(e.source) &&
+                                !ownedCellIds.includes(e.target));
+                            for (const cellId of ownedCellIds) {
+                                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];
+                        }
+                    }));
+                    for (const relationName of relationNamesToDrop) {
+                        void dropSqlResultRelation(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) => {
+                    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),
+                                cellIds: [],
+                                edges: [],
+                                graphCache: {
+                                    dependencies: {},
+                                    dependents: {},
+                                    contentHashByCell: {},
+                                },
+                            };
+                            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;
+                            }
+                        }
+                        if (!sheet.cellIds.includes(edge.source) ||
+                            !sheet.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, [
+                                ...deps,
+                                edge.source,
+                            ]);
+                        }
+                    }));
+                },
+                removeEdge: (sheetId, 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;
+                        }
+                    }));
+                },
+                updateEdgesFromSql: async (sheetId, cellId) => {
+                    const cell = get().cells.config.data[cellId];
+                    const sheet = get().cells.config.sheets[sheetId];
+                    if (!cell || !sheet)
+                        return;
+                    // Pre-compute dependencies outside produce() to support async
+                    const sqlSelectToJson = getRequiredSqlSelectToJson(get());
+                    const scopedCells = Object.fromEntries(sheet.cellIds
+                        .map((id) => get().cells.config.data[id])
+                        .filter(isDefined)
+                        .map((candidate) => [candidate.id, candidate]));
+                    const deps = await resolveDependencies(cell, scopedCells, sheetId, cellRegistry, sqlSelectToJson);
+                    set((state) => produce(state, (draft) => {
+                        const draftSheet = draft.cells.config.sheets[sheetId];
+                        if (draftSheet) {
+                            draftSheet.edges = draftSheet.edges.filter((e) => e.target !== cellId);
+                            const localCellIds = new Set(draftSheet.cellIds);
+                            for (const depId of deps) {
+                                if (!localCellIds.has(depId) || depId === cellId)
+                                    continue;
+                                draftSheet.edges.push({
+                                    id: `${depId}-${cellId}`,
+                                    source: depId,
+                                    target: cellId,
+                                });
+                            }
+                            replaceCellDependenciesInCache(draftSheet, cellId, deps.filter((depId) => localCellIds.has(depId)));
+                        }
+                    }));
+                },
+                runCell: async (id, opts) => {
+                    const state = get();
+                    const cell = state.cells.config.data[id];
+                    if (!cell)
+                        return;
+                    const registryItem = cellRegistry[cell.type];
+                    if (!registryItem)
+                        return;
+                    if (registryItem.runCell) {
+                        // Pass get/set to registry's runCell
+                        await registryItem.runCell({ id, opts, get, set });
+                        return;
+                    }
+                    // No default behavior - each cell type must define runCell if needed
+                },
+                cancelCell: (id) => {
+                    const state = get();
+                    const controller = state.cells.activeAbortControllers[id];
+                    if (controller) {
+                        controller.abort();
+                    }
+                },
+                invalidateCellStatus: (id) => {
+                    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 || [],
+                            };
+                        }
+                    }));
+                },
+                // Cell result cache actions
+                setCellResult: (id, data) => {
+                    cellResultCache.set(id, data);
+                    set((state) => produce(state, (draft) => {
+                        draft.cells.resultVersion[id] =
+                            (draft.cells.resultVersion[id] ?? 0) + 1;
+                    }));
+                },
+                setCellResultPage: (id, data) => {
+                    cellResultCache.set(id, data);
+                    set((state) => produce(state, (draft) => {
+                        draft.cells.pageVersion[id] =
+                            (draft.cells.pageVersion[id] ?? 0) + 1;
+                    }));
+                },
+                getCellResult: (id) => {
+                    return cellResultCache.get(id);
+                },
+                clearCellResult: (id) => {
+                    cellResultCache.delete(id);
+                    set((state) => produce(state, (draft) => {
+                        delete draft.cells.resultVersion[id];
+                        delete draft.cells.pageVersion[id];
+                    }));
+                },
+                fetchCellResultPage: async (id, pagination, sorting) => {
+                    const state = get();
+                    const status = state.cells.status[id];
+                    if (status?.type !== 'sql' || !status.resultView)
+                        return;
+                    const connector = await state.db.getConnector();
+                    const baseQuery = sanitizeQuery(`SELECT * FROM ${status.resultView}`);
+                    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 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());
+                    const ids = Object.keys(dependencies);
+                    return ids.filter((id) => (dependencies[id]?.length ?? 0) === 0);
+                },
+                getDownstream: (sheetId, sourceCellId) => {
+                    const { dependencies, dependents } = buildDependencyGraph(sheetId, get());
+                    const reachable = collectReachable(sourceCellId, dependents);
+                    if (!reachable.size)
+                        return [];
+                    reachable.delete(sourceCellId);
+                    const rootsWithinScope = Array.from(reachable).filter((id) => {
+                        const deps = dependencies[id] || [];
+                        return deps.filter((d) => reachable.has(d)).length === 0;
+                    });
+                    return topologicalOrder(rootsWithinScope, dependencies, dependents, reachable);
+                },
+                // Async cascade execution using AST-based dependency resolution
+                runAllCellsCascade: async (sheetId) => {
+                    const cached = buildDependencyGraph(sheetId, 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 sqlSelectToJson = getRequiredSqlSelectToJson(get());
+                    const { dependencies, dependents } = await buildDependencyGraphAsync(sheetId, 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) {
+                        try {
+                            await get().cells.runCell(cellId, { cascade: false });
+                        }
+                        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;
+                                }
+                            }));
+                        }
+                    }
+                },
+                runDownstreamCascade: async (sheetId, sourceCellId) => {
+                    const cached = buildDependencyGraph(sheetId, 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 sqlSelectToJson = getRequiredSqlSelectToJson(get());
+                    const { dependencies, dependents } = await buildDependencyGraphAsync(sheetId, get(), sqlSelectToJson);
+                    const reachable = collectReachable(sourceCellId, dependents);
+                    if (!reachable.size)
+                        return;
+                    reachable.delete(sourceCellId);
+                    const rootsWithinScope = Array.from(reachable).filter((id) => {
+                        const deps = dependencies[id] || [];
+                        return deps.filter((d) => reachable.has(d)).length === 0;
+                    });
+                    const order = topologicalOrder(rootsWithinScope, dependencies, dependents, reachable);
+                    for (const cellId of order) {
+                        try {
+                            await get().cells.runCell(cellId, { cascade: false });
+                        }
+                        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;
+                                }
+                            }));
+                        }
+                    }
+                },
+            },
+        };
+    });
+}
+//# sourceMappingURL=cellsSlice.js.map