@svgrid/enterprise 3.1.0 → 3.1.2

package/dist/server/server-row-model.js

@@ -368,10 +368,53 @@ export function createServerRowModel(source, options) {
             }
         }
     }
-    // ---------------------------------------------------------- flatten
+    const leafRuns = new WeakMap();
+    function leafRun(store, rows) {
+        if (openDetails.size)
+            return null;
+        const prev = leafRuns.get(store);
+        if (prev && prev.rows === rows)
+            return prev;
+        const n = rows.length;
+        // Same length (a block landed, a row was patched): update the kept
+        // arrays in place. The flatten only ever copies out of them.
+        const inPlace = !!prev && prev.rows.length === n;
+        const display = inPlace ? prev.display : new Array(n);
+        const grid = inPlace ? prev.grid : new Array(n);
+        const old = prev?.rows;
+        const oldLength = old ? old.length : 0;
+        for (let i = 0; i < n; i += 1) {
+            const child = rows[i];
+            if (i < oldLength && old[i] === child) {
+                if (!inPlace) {
+                    display[i] = prev.display[i];
+                    grid[i] = prev.grid[i];
+                }
+                continue;
+            }
+            const ph = rowPlaceholderState(child);
+            if (ph) {
+                const d = ph === 'failed' ? FAILED_ROW : LOADING_ROW;
+                display[i] = d;
+                grid[i] = toGridRow(d);
+                continue;
+            }
+            if (child.kind !== 'leaf') {
+                // Written in place up to here, so the kept run is no longer whole.
+                leafRuns.delete(store);
+                return null;
+            }
+            const d = { kind: 'leaf', id: child.id, level: store.level, route: store.route, data: child.data };
+            display[i] = d;
+            grid[i] = toGridRow(d, child.data);
+        }
+        const run = { rows, display, grid };
+        leafRuns.set(store, run);
+        return run;
+    }
     function flatten() {
-        const display = [];
-        const grid = [];
+        let display = [];
+        let grid = [];
         segments = [];
         const pushRow = (d, data) => {
             display.push(d);
@@ -392,6 +435,28 @@ export function createServerRowModel(source, options) {
         };
         const walk = (store, from = 0, to = Number.POSITIVE_INFINITY) => {
             const rows = store.cache.rows();
+            const run = store.loadMore ? null : leafRun(store, rows);
+            if (run) {
+                // A level of leaves maps one to one: copy the range out of the run.
+                const end = Math.min(rows.length, to);
+                if (end > from) {
+                    segments.push({ store, displayStart: display.length, storeStart: from, length: end - from });
+                    const { display: d, grid: g } = run;
+                    if (display.length === 0) {
+                        // The common flat case: the whole list is this run. A slice is a
+                        // block copy; a push per row was the rest of the flatten's cost.
+                        display = d.slice(from, end);
+                        grid = g.slice(from, end);
+                    }
+                    else {
+                        for (let i = from; i < end; i += 1) {
+                            display.push(d[i]);
+                            grid.push(g[i]);
+                        }
+                    }
+                }
+                return;
+            }
             const end = Math.min(rows.length, to, store.loadMore ? loadedPrefix(rows) : Number.POSITIVE_INFINITY);
             let segStart = from;
             let dispStart = display.length;
@@ -606,6 +671,34 @@ export function createServerRowModel(source, options) {
             pagination: pagination(),
         };
     }
+    // `keepRowsWhileLoading`: after a sort, a filter or a regroup, the rows on
+    // screen stay until the new answer's first block lands or the time runs
+    // out. `holdUntil` is that deadline, 0 when nothing is held.
+    let holdUntil = 0;
+    let holdTimer = null;
+    let held = false;
+    function holdRows() {
+        const ms = options.keepRowsWhileLoading ?? 0;
+        if (ms > 0 && current.displayRows.length > 0)
+            holdUntil = Date.now() + ms;
+    }
+    /** Whether the rows on screen should stay a little longer. */
+    function holding() {
+        if (!holdUntil)
+            return false;
+        const root = stores.get(routeKey([]));
+        // A failed block ends the hold too: its Retry is the answer to show.
+        const rootAnswered = !!root && root.cache.getCacheState().some((b) => b.status !== 'loading');
+        let pending = false;
+        for (const s of stores.values())
+            if (s.refreshPending)
+                pending = true;
+        if (Date.now() >= holdUntil || rootError || (rootAnswered && !pending)) {
+            holdUntil = 0;
+            return false;
+        }
+        return true;
+    }
     function scheduleEmit() {
         if (disposed || emitScheduled)
             return;
@@ -614,7 +707,25 @@ export function createServerRowModel(source, options) {
             emitScheduled = false;
             if (disposed)
                 return;
+            if (holding()) {
+                held = true;
+                holdTimer ?? (holdTimer = setTimeout(() => {
+                    holdTimer = null;
+                    scheduleEmit();
+                }, Math.max(0, holdUntil - Date.now())));
+                return;
+            }
+            if (holdTimer) {
+                clearTimeout(holdTimer);
+                holdTimer = null;
+            }
             current = buildState();
+            // While rows were held the grid kept reporting positions in the old
+            // list, mapped through the old segments; map them through the new.
+            if (held) {
+                held = false;
+                applyViewport();
+            }
             options.onChange?.(current);
             for (const notify of subscribers)
                 notify();
@@ -749,6 +860,7 @@ export function createServerRowModel(source, options) {
     }
     function setSort(next) {
         sortModel = next;
+        holdRows();
         for (const store of storesAffectedBySort(next)) {
             if (options.clientSideSort && sortLocally(store))
                 continue;
@@ -759,6 +871,7 @@ export function createServerRowModel(source, options) {
     }
     function setFilter(next) {
         const previous = filterModel;
+        holdRows();
         filterModel = Array.isArray(next.columns)
             ? { global: next.global, columns: toServerFilterColumns(next) }
             : next;
@@ -1212,6 +1325,7 @@ export function createServerRowModel(source, options) {
                 expanded.clear();
                 seenGroups.clear();
             }
+            holdRows();
             rebuild();
         },
         toggleGroup(row) {
@@ -1439,6 +1553,9 @@ export function createServerRowModel(source, options) {
             if (asyncTimer)
                 clearTimeout(asyncTimer);
             asyncTimer = null;
+            if (holdTimer)
+                clearTimeout(holdTimer);
+            holdTimer = null;
             asyncQueue.length = 0;
             for (const s of stores.values())
                 s.cache.dispose();

package/dist/server/worker-data-source.d.ts

@@ -0,0 +1,62 @@
+/**
+ * A `ServerDataSource` whose rows live in a Web Worker.
+ *
+ * Sorting, filtering, grouping and aggregating a few hundred thousand rows
+ * takes long enough on the main thread that scrolling and typing stop while
+ * it runs. This moves that work into a worker and lets the grid treat the
+ * worker as a server: `createServerRowModel` (or the free
+ * `createServerDataSource`) asks for one block of rows at a time, the worker
+ * answers with just that block, and the full array never crosses back.
+ *
+ * Inside the worker the requests run through `createInMemoryDataSource`, the
+ * reference implementation of the datasource contract, so the answers are the
+ * ones every other backend is tested against.
+ *
+ * ```ts
+ * // grid.worker.ts
+ * import { serveWorkerDataSource } from '@svgrid/enterprise/worker'
+ * serveWorkerDataSource({ rows: () => fetch('/orders.json').then((r) => r.json()) })
+ *
+ * // App.svelte
+ * const worker = new Worker(new URL('./grid.worker.ts', import.meta.url), { type: 'module' })
+ * const ctl = createServerRowModel(createWorkerDataSource(worker), { groupBy: ['region'] })
+ * ```
+ *
+ * What it cannot do: run your functions. A worker receives data, not code,
+ * so a column's `valueGetter`, `comparator` or custom filter function never
+ * reaches it. Sorting and filtering go by field value, as with any server.
+ */
+import type { RowData } from '@svgrid/grid';
+import type { ServerDataSource } from '@svgrid/grid/server';
+import type { EntitySchema } from '../schema.js';
+import type { AggregateBucket, AggregateRequest } from '../sources/aggregate.js';
+/** What `createWorkerDataSource` needs from a `Worker`. A `MessagePort` fits too. */
+export type WorkerLike = {
+    postMessage(message: unknown): void;
+    addEventListener(type: string, listener: (event: MessageEvent) => void): void;
+    removeEventListener(type: string, listener: (event: MessageEvent) => void): void;
+    terminate?(): void;
+};
+export type WorkerDataSourceOptions<TData extends RowData> = {
+    /**
+     * Rows to copy into the worker. Copying is structured cloning on the main
+     * thread, so for a large dataset prefer loading it inside the worker
+     * (`serveWorkerDataSource({ rows })`) and leave this out.
+     */
+    rows?: ReadonlyArray<TData>;
+    /** Sent with `rows`. Default: the worker's own, or one read off the rows. */
+    schema?: EntitySchema<TData>;
+    /** The row id field, when the schema is inferred. */
+    idField?: string;
+};
+export type WorkerDataSource<TData extends RowData> = Required<Pick<ServerDataSource<TData>, 'getRows' | 'createRow' | 'updateRow' | 'deleteRow' | 'updateWhere'>> & {
+    /** Group and reduce in the worker, for `SvSchemaChart` and dashboards. */
+    getAggregate(request: AggregateRequest): Promise<AggregateBucket[]>;
+    /** Settles once the worker holds rows: with the row count, or the loader's error. */
+    readonly ready: Promise<number>;
+    /** Replace the worker's rows. Resolves with the new count. */
+    setRows(rows: ReadonlyArray<TData>, schema?: EntitySchema<TData>): Promise<number>;
+    /** Reject what is pending and terminate the worker. The row model's `dispose()` calls it. */
+    destroy(): void;
+};
+export declare function createWorkerDataSource<TData extends RowData>(worker: WorkerLike, options?: WorkerDataSourceOptions<TData>): WorkerDataSource<TData>;

package/dist/server/worker-data-source.js

@@ -0,0 +1,133 @@
+import { CHANNEL, fromWorkerError, isChannelMessage, } from '../worker/protocol.js';
+import { nudgeServerRowModel } from './enable.js';
+function abortReason(signal) {
+    return signal.reason ?? new DOMException('The request was aborted.', 'AbortError');
+}
+export function createWorkerDataSource(worker, options = {}) {
+    nudgeServerRowModel();
+    let nextId = 1;
+    let destroyed = false;
+    // Set once the worker cannot answer any more: it failed to start, its
+    // loader threw, or `destroy()` ran. Every later call rejects with it.
+    let failure = null;
+    const pending = new Map();
+    let resolveReady;
+    let rejectReady;
+    const ready = new Promise((resolve, reject) => {
+        resolveReady = resolve;
+        rejectReady = reject;
+    });
+    // A source nobody awaited `ready` on must not raise an unhandled rejection.
+    ready.catch(() => { });
+    function failAll(error) {
+        failure ?? (failure = error);
+        rejectReady(error);
+        for (const p of pending.values())
+            p.reject(error);
+        pending.clear();
+    }
+    function onMessage(event) {
+        const message = event.data;
+        if (!isChannelMessage(message))
+            return;
+        switch (message.kind) {
+            case 'ready':
+                resolveReady(message.rowCount);
+                break;
+            case 'failed':
+                failAll(fromWorkerError(message.error));
+                break;
+            case 'result': {
+                const p = pending.get(message.id);
+                if (!p)
+                    return; // cancelled, or answered after destroy
+                pending.delete(message.id);
+                if (message.ok)
+                    p.resolve(message.value);
+                else
+                    p.reject(fromWorkerError(message.error));
+                break;
+            }
+        }
+    }
+    // The worker script failed to load or threw at the top level. Without this
+    // every request would wait forever on a worker that is not there.
+    function onError(event) {
+        const message = event.message || 'The data source worker failed to start.';
+        failAll(new Error(message));
+    }
+    worker.addEventListener('message', onMessage);
+    worker.addEventListener('error', onError);
+    worker.start?.();
+    function send(message) {
+        worker.postMessage(message);
+    }
+    function request(message, signal) {
+        if (failure)
+            return Promise.reject(failure);
+        if (signal?.aborted)
+            return Promise.reject(abortReason(signal));
+        const id = nextId++;
+        return new Promise((resolve, reject) => {
+            const onAbort = () => {
+                if (!pending.delete(id))
+                    return;
+                send({ channel: CHANNEL, kind: 'cancel', id });
+                reject(abortReason(signal));
+            };
+            pending.set(id, {
+                resolve: (value) => {
+                    signal?.removeEventListener('abort', onAbort);
+                    resolve(value);
+                },
+                reject: (error) => {
+                    signal?.removeEventListener('abort', onAbort);
+                    reject(error);
+                },
+            });
+            signal?.addEventListener('abort', onAbort, { once: true });
+            send(message(id));
+        });
+    }
+    function call(method, args, signal) {
+        return request((id) => ({ channel: CHANNEL, kind: 'call', id, method, args }), signal);
+    }
+    function load(rows, schema) {
+        return request((id) => ({
+            channel: CHANNEL,
+            kind: 'load',
+            id,
+            rows,
+            ...(schema ? { schema: schema } : {}),
+            ...(options.idField ? { idField: options.idField } : {}),
+        }));
+    }
+    if (options.rows)
+        void load(options.rows, options.schema).catch(failAll);
+    return {
+        getRows(req) {
+            // The signal cannot be cloned, and `parentRow` / `context` are app
+            // objects the in-memory source never reads; sending them would only
+            // risk a DataCloneError.
+            const { signal, parentRow: _parentRow, context: _context, ...plain } = req;
+            return call('getRows', [plain], signal);
+        },
+        createRow: (input) => call('createRow', [input]),
+        updateRow: (id, patch) => call('updateRow', [id, patch]),
+        deleteRow: (id) => call('deleteRow', [id]),
+        updateWhere: (filterModel, patch, selection) => call('updateWhere', [filterModel, patch, selection]),
+        getAggregate: (req) => call('getAggregate', [req]),
+        ready,
+        setRows: (rows, schema) => load(rows, schema ?? options.schema),
+        destroy() {
+            if (destroyed)
+                return;
+            destroyed = true;
+            failure = new Error('createWorkerDataSource: the source was destroyed');
+            failAll(failure);
+            worker.removeEventListener('message', onMessage);
+            worker.removeEventListener('error', onError);
+            worker.terminate?.();
+        },
+    };
+}

package/dist/sheet/objects.d.ts

@@ -92,6 +92,53 @@ export declare function objectAt(objects: ReadonlyArray<SheetObject>, point: {
     width: number;
     height: number;
 } | null): SheetObject | null;
+/**
+ * The four panes Freeze Panes splits a sheet into: the frozen corner, the
+ * frozen rows (which scroll across), the frozen columns (which scroll
+ * down), and the body (which scrolls both ways).
+ */
+export type SheetPane = 'corner' | 'rows' | 'cols' | 'body';
+/**
+ * The pane an object belongs to: the one its anchor cell is in. Excel keeps
+ * an object with that pane, so one hung from a frozen cell is drawn over
+ * the frozen cells and stays put while the sheet scrolls under it.
+ */
+export declare function paneOf(anchor: {
+    row: number;
+    col: number;
+}, freeze: {
+    rows: number;
+    cols: number;
+}): SheetPane;
+/**
+ * How much of an object its pane cuts off, in pixels from each edge of its
+ * box. `box` and `edges` are in the same frame: `left` measured from the
+ * inline start, `top` from the top.
+ *
+ * `edges.start` and `edges.top` are where the scrolling cells begin (past
+ * the frozen columns, or the row numbers when none are frozen; under the
+ * frozen rows, or the header), and `edges.end` and `edges.bottom` where the
+ * sheet's window ends. An object is cut on the sides its pane scrolls from,
+ * so it slides under the frozen cells, and always at the window's far
+ * edges. A frozen pane never scrolls past its start, so nothing is cut
+ * there and the object is drawn whole over its frozen cells.
+ */
+export declare function paneClip(pane: SheetPane, box: {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+}, edges: {
+    start: number;
+    top: number;
+    end: number;
+    bottom: number;
+}): {
+    start: number;
+    top: number;
+    end: number;
+    bottom: number;
+};
 /**
  * The chart's spec, read from its range through `valueAt` (the computed
  * value) and `textAt` (what the cell shows, for the labels). A chart of a

package/dist/sheet/objects.js

@@ -49,6 +49,39 @@ export function objectAt(objects, point, boxOf) {
     }
     return null;
 }
+/**
+ * The pane an object belongs to: the one its anchor cell is in. Excel keeps
+ * an object with that pane, so one hung from a frozen cell is drawn over
+ * the frozen cells and stays put while the sheet scrolls under it.
+ */
+export function paneOf(anchor, freeze) {
+    const row = anchor.row < freeze.rows;
+    const col = anchor.col < freeze.cols;
+    return row && col ? 'corner' : row ? 'rows' : col ? 'cols' : 'body';
+}
+/**
+ * How much of an object its pane cuts off, in pixels from each edge of its
+ * box. `box` and `edges` are in the same frame: `left` measured from the
+ * inline start, `top` from the top.
+ *
+ * `edges.start` and `edges.top` are where the scrolling cells begin (past
+ * the frozen columns, or the row numbers when none are frozen; under the
+ * frozen rows, or the header), and `edges.end` and `edges.bottom` where the
+ * sheet's window ends. An object is cut on the sides its pane scrolls from,
+ * so it slides under the frozen cells, and always at the window's far
+ * edges. A frozen pane never scrolls past its start, so nothing is cut
+ * there and the object is drawn whole over its frozen cells.
+ */
+export function paneClip(pane, box, edges) {
+    const across = pane === 'rows' || pane === 'body';
+    const down = pane === 'cols' || pane === 'body';
+    return {
+        start: across ? Math.max(0, edges.start - box.left) : 0,
+        top: down ? Math.max(0, edges.top - box.top) : 0,
+        end: Math.max(0, box.left + box.width - edges.end),
+        bottom: Math.max(0, box.top + box.height - edges.bottom),
+    };
+}
 /** A cell's value as a number, or null when it is not one. */
 function numberOf(value) {
     if (typeof value === 'number')

package/dist/studio/cli.js

@@ -58,12 +58,66 @@ export async function runStudioAdd(options, io) {
     const verify = await verifyScaffold(files);
     return { schema, written, verify };
 }
+/** The stylesheets an `init`-generated layout imports, in cascade order. */
+const APP_STYLESHEETS = ['app.css', 'custom.css'];
+/**
+ * Fill the app-shell options the caller left out from the app already on disk,
+ * so `add --all` in a folder `init` generated keeps its stylesheets, title and
+ * theme. The shell layout from `init` carries no managed markers, so the merge
+ * write replaces it whole; anything it imported or named has to be carried
+ * over here or it is lost.
+ *
+ * Title: studio.config.json (shell brand, then title), else the `appTitle`
+ * constant of a layout an earlier `add --all` wrote.
+ */
+async function appShellDefaults(options, io) {
+    const stylesheets = options.stylesheets ?? [];
+    if (!options.stylesheets) {
+        for (const css of APP_STYLESHEETS) {
+            if ((await io.readFile(`src/${css}`)) != null)
+                stylesheets.push(css);
+        }
+    }
+    let title;
+    let theme;
+    const config = await io.readFile('studio.config.json');
+    if (config != null) {
+        try {
+            const parsed = JSON.parse(config);
+            theme = parsed.theme;
+            const brand = typeof theme?.shell?.brand === 'string' ? theme.shell.brand.trim() : '';
+            title = brand || (typeof parsed.title === 'string' ? parsed.title : undefined);
+        }
+        catch {
+            /* unreadable config: fall back to the layout below */
+        }
+    }
+    if (!title) {
+        const layout = await io.readFile('src/routes/+layout.svelte');
+        const m = layout?.match(/const appTitle = ("(?:[^"\\]|\\.)*")/);
+        if (m) {
+            try {
+                title = JSON.parse(m[1]);
+            }
+            catch {
+                /* not a JSON string literal: keep the default */
+            }
+        }
+    }
+    return {
+        ...options,
+        stylesheets,
+        ...(options.appTitle == null && title ? { appTitle: title } : {}),
+        ...(options.theme == null && typeof theme?.preset === 'string' ? { theme: theme.preset } : {}),
+        ...(options.dark == null && theme?.mode === 'dark' ? { dark: true } : {}),
+    };
+}
 /**
  * Scaffold a whole multi-entity app - every entity's screen plus a nav layout
  * and home page - and merge-write it. The `--all` path behind `svgrid-studio`.
  */
 export async function runStudioAddApp(schemas, options, io) {
-    const { files } = scaffoldApp(schemas, options);
+    const { files } = scaffoldApp(schemas, await appShellDefaults(options, io));
     const written = await writeAll(files, io);
     const verify = await verifyScaffold(files);
     return { written, verify };

package/dist/studio/emit-project.js

@@ -3,7 +3,7 @@ import { blockColumns, blockStyleCss, blockClassName, sanitizeClassName, compone
 import { uiComponentSpec, gridApiSettableProps, STANDARD_UI_EVENTS } from './ui-components.js';
 import { isDarkTheme, themeTokenCss } from './themes.js';
 import { hasFieldConditions } from '../edit-panel.js';
-import { SVGRID_VERSION } from '../version.js';
+import { SVGRID_VERSION, GRID_VERSION } from '../version.js';
 import { emitEntityModules, homeFile, layoutFile, lookupVar, namesFor, prepareEntities, relationDisplayFields, sqlDdlFiles } from './emit-schema.js';
 const has = (blocks, kind) => blocks.some((b) => b.config.kind === kind);
 /** Per-Tabs-block active-tab state var + a stable tab id. */
@@ -5231,8 +5231,13 @@ export function runtimeDeps(project, allSource) {
     // APIs of the SvGrid it was written by, so the app must install a runtime at
     // least that new. `latest` also made a scaffold non-reproducible - an app could
     // resolve a different runtime tomorrow, or break on an unrelated publish.
-    const svgrid = `^${SVGRID_VERSION}`;
-    const dependencies = { '@svgrid/grid': svgrid, '@svgrid/enterprise': svgrid };
+    // The two packages release on separate lines, so they need separate ranges.
+    // Using this package's version for BOTH asked for `@svgrid/grid@^3.1.1`,
+    // which does not exist, and `npm install` failed on every scaffolded app.
+    const dependencies = {
+        '@svgrid/grid': `^${GRID_VERSION}`,
+        '@svgrid/enterprise': `^${SVGRID_VERSION}`,
+    };
     if (allSource.includes("from '@supabase/supabase-js'"))
         dependencies['@supabase/supabase-js'] = '^2.45.0';
     if (allSource.includes("import pg from 'pg'"))

package/dist/studio/init-flow.d.ts

@@ -1,4 +1,4 @@
-import type { StudioIO } from './cli.js';
+import { type StudioIO } from './cli.js';
 import { type DbExecute, type SqlDialectName } from './introspect-db.js';
 import { type StudioProject } from './project.js';
 /** Terminal I/O, injected so the flow can be scripted in tests. */
@@ -30,6 +30,11 @@ export type InitFlags = {
     supabaseUrl?: string;
     /** Supabase anon key. */
     supabaseKey?: string;
+    /**
+     * A Drizzle (.ts) or Prisma (.prisma) schema file. Skips the source question
+     * and builds the app from its tables, served from memory with sample rows.
+     */
+    from?: string;
     /** Pick a starter dataset by id, skipping the source question. */
     dataset?: string;
     /** Theme preset id. */

package/dist/studio/init-flow.js

@@ -1,3 +1,4 @@
+import { resolveSchemas } from './cli.js';
 import { crudAppFromSchemas } from './screen-suites.js';
 import { starterDatasets, getStarterDataset } from './samples/datasets.js';
 import { introspectDatabase, listDatabaseTables, countTableRows } from './introspect-db.js';
@@ -92,7 +93,9 @@ function unwrapRows(body) {
     return [];
 }
 /** Step 1-2: where does the data come from, and what tables does it have? */
-async function gatherData(flags, prompts, db, fetchText) {
+async function gatherData(flags, prompts, db, fetchText, io) {
+    if (flags.from)
+        return gatherFromSchemaFile(flags, flags.from, prompts, io);
     let source = 'sample';
     if (flags.db)
         source = 'db';
@@ -126,6 +129,44 @@ async function gatherData(flags, prompts, db, fetchText) {
     prompts.say(`  Using ${dataset.name} (${entities.length} tables).`);
     return { schemas: entities, sources, seed, kind, title: dataset.name };
 }
+/**
+ * A schema file names the tables and columns but holds no rows and no
+ * connection, so the app runs on the in-memory source and the emitter seeds it
+ * with sample rows. `--db` + `--url` is the path to a live database.
+ */
+async function gatherFromSchemaFile(flags, from, prompts, io) {
+    const clash = flags.db ? '--db' : flags.supabaseUrl ? '--supabase-url' : flags.dataset ? '--dataset' : null;
+    if (clash)
+        throw new UserError(`--from and ${clash} both name the data source.`, 'Pass one of them.');
+    if ((await io.readFile(from)) == null) {
+        throw new UserError(`Schema file not found: ${from}`, 'Pass the path to a Drizzle schema (.ts) or a Prisma schema (.prisma).');
+    }
+    let all;
+    try {
+        all = await resolveSchemas(from, io);
+    }
+    catch (e) {
+        throw new UserError(`Could not read ${from}: ${e instanceof Error ? e.message : String(e)}`, 'Pass a Drizzle schema (.ts) or a Prisma schema (.prisma).');
+    }
+    if (all.length === 0) {
+        throw new UserError(`No tables or models found in ${from}.`, 'Drizzle tables are read from pgTable / mysqlTable / sqliteTable calls, Prisma models from `model X {` blocks.');
+    }
+    let picked = all.map((s) => s.name);
+    if (!flags.yes) {
+        prompts.say('');
+        prompts.say(`Found ${all.length} ${all.length === 1 ? 'table' : 'tables'} in ${from}:`);
+        all.forEach((s, i) => prompts.say(`  ${i + 1}. ${s.name}`));
+        picked = parseSelection(await prompts.ask('Which tables? (all, or a comma list of names/numbers)', 'all'), picked);
+    }
+    const schemas = all.filter((s) => picked.includes(s.name));
+    if (schemas.length === 0)
+        throw new UserError('No tables picked - nothing to build.');
+    const sources = {};
+    for (const s of schemas)
+        sources[s.name] = { kind: 'memory' };
+    prompts.say(`  Read ${schemas.length} ${schemas.length === 1 ? 'table' : 'tables'} from ${from} (in-memory data with sample rows).`);
+    return { schemas, sources, seed: {}, kind: 'memory' };
+}
 async function gatherFromDatabase(flags, prompts, db) {
     if (!db)
         throw new UserError('Connecting to a database is not available here.');
@@ -417,7 +458,7 @@ export async function runStudioInit(flags, prompts, db, io, fetchText = null) {
     // it rather than as Studio just changed it.
     const candidateDir = flags.out ?? '.';
     const markersBefore = await markersIn(candidateDir, io);
-    const data = await gatherData(flags, prompts, db, fetchText);
+    const data = await gatherData(flags, prompts, db, fetchText, io);
     const perEntity = await askScreens(data.schemas, flags, prompts);
     const theme = await askTheme(flags, prompts);
     const defaultTitle = flags.title ?? data.title ?? 'My app';

package/dist/studio/scaffold-app.d.ts

@@ -24,6 +24,12 @@ export type ScaffoldAppOptions = {
      */
     theme?: string;
     dark?: boolean;
+    /**
+     * Global stylesheets the layout imports, as paths relative to `src/` (for
+     * example `['app.css', 'custom.css']` in an app `init` generated). List only
+     * files that exist: importing a missing file fails the build.
+     */
+    stylesheets?: string[];
 };
 export declare function scaffoldApp(schemas: EntitySchema[], options?: ScaffoldAppOptions): {
     files: GeneratedFile[];