@svgrid/enterprise 2.5.2 → 2.6.0

package/dist/sources/schema-from-columns.js

@@ -0,0 +1,48 @@
+import { refineField } from './field-inference.js';
+/** Assemble an EntitySchema from discovered columns. */
+export function buildEntitySchema(table, columns) {
+    if (!columns.length)
+        throw new Error(`buildEntitySchema: "${table}" has no columns`);
+    // Primary key: first flagged pk, else a column literally named "id", else the
+    // first column (so update/delete always have a key to target).
+    const explicitPk = columns.find((c) => c.primaryKey)?.name;
+    const idField = explicitPk ?? columns.find((c) => /^id$/i.test(c.name))?.name ?? columns[0].name;
+    const fields = columns.map((c) => {
+        const isPk = c.name === idField;
+        // A foreign-key column (that isn't the PK) becomes a relation field, so the
+        // form renders a lookup and master-detail can be inferred.
+        if (c.references && !isPk) {
+            const rel = { field: c.name, type: 'relation' };
+            rel.relation = {
+                entity: c.references.table,
+                foreignKey: c.name,
+                labelField: c.references.labelField ?? 'name',
+            };
+            if (c.dbColumn)
+                rel.dbColumn = c.dbColumn;
+            if (c.required)
+                rel.required = true;
+            return rel;
+        }
+        const type = c.enumValues?.length ? 'enum' : (c.type ?? 'text');
+        const f = { field: c.name, type };
+        if (c.dbColumn)
+            f.dbColumn = c.dbColumn;
+        if (isPk) {
+            f.primaryKey = true;
+            f.readonly = true;
+        }
+        else if (c.required) {
+            f.required = true;
+        }
+        if (type === 'enum' && c.enumValues?.length) {
+            f.options = c.enumValues.map((v) => ({ value: v, label: v }));
+        }
+        // Infer a rich editor from the column name/type (phone / email / rating / ...).
+        return refineField(f);
+    });
+    return { name: table, label: table, idField, fields };
+}
+// Schema-level relation helpers live in ../schema (studio consumes them under
+// node16 resolution); re-exported here so introspection consumers get one entry.
+export { pickLabelField, linkRelationLabels } from '../schema.js';

package/dist/sources/supabase.d.ts

@@ -0,0 +1,33 @@
+/**
+ * createSupabaseDataSource - a browser-ready `ServerDataSource` over a Supabase
+ * table, using the `supabase-js` client (PostgREST). You bring the client (so
+ * there's no dependency here and Row-Level Security + auth apply per request);
+ * this maps the grid's sort / filter / page / CRUD onto the query builder.
+ *
+ *     import { createClient } from '@supabase/supabase-js'
+ *     const client = createClient(url, anonKey)
+ *     const source = createSupabaseDataSource({ client, table: 'customers', schema })
+ *
+ * Global search covers the schema's text + enum columns by default; override
+ * with `searchColumns`. The primary key comes from the schema (`idField`) and is
+ * stripped from inserts (it's database-generated).
+ */
+import type { RowData } from '@svgrid/grid';
+import { type EntitySchema } from '../schema';
+import type { WritableDataSource } from '../sveltekit/types';
+/** The slice of a `supabase-js` client this adapter needs. */
+export type SupabaseClientLike = {
+    from(table: string): any;
+};
+export type SupabaseDataSourceConfig<TData extends RowData> = {
+    client: SupabaseClientLike;
+    /** Table (or view) name. */
+    table: string;
+    schema: EntitySchema<TData>;
+    /**
+     * Columns the global search box matches (OR of ILIKEs). Defaults to the
+     * schema's text + enum fields.
+     */
+    searchColumns?: string[];
+};
+export declare function createSupabaseDataSource<TData extends RowData>(config: SupabaseDataSourceConfig<TData>): WritableDataSource<TData>;

package/dist/sources/supabase.js

@@ -0,0 +1,74 @@
+import { resolveIdField } from '../schema';
+import { nudgeEnterprise } from '../license';
+import { normalizeFilters } from './filters';
+const sanitize = (term) => term.replace(/[%,()]/g, '');
+export function createSupabaseDataSource(config) {
+    nudgeEnterprise('Studio'); // soft-gate; never blocks
+    const { client, table, schema } = config;
+    const idField = resolveIdField(schema);
+    const searchColumns = config.searchColumns ??
+        schema.fields.filter((f) => f.type === 'text' || f.type === 'enum').map((f) => String(f.field));
+    return {
+        async getRows(request) {
+            let q = client.from(table).select('*', { count: 'exact' });
+            const { predicates, search } = normalizeFilters(request.filterModel);
+            for (const p of predicates) {
+                switch (p.op) {
+                    case 'in':
+                        q = q.in(p.column, p.values);
+                        break;
+                    case 'contains':
+                        q = q.ilike(p.column, `%${p.value}%`);
+                        break;
+                    case 'startsWith':
+                        q = q.ilike(p.column, `${p.value}%`);
+                        break;
+                    case 'eq':
+                        q = q.eq(p.column, p.value);
+                        break;
+                    case 'gt':
+                        q = q.gt(p.column, p.value);
+                        break;
+                    case 'lt':
+                        q = q.lt(p.column, p.value);
+                        break;
+                    case 'between':
+                        q = q.gte(p.column, p.value).lte(p.column, p.valueTo);
+                        break;
+                    case 'isNull':
+                        q = q.is(p.column, null);
+                        break;
+                }
+            }
+            if (search && searchColumns.length) {
+                const term = sanitize(search);
+                q = q.or(searchColumns.map((c) => `${c}.ilike.%${term}%`).join(','));
+            }
+            for (const s of request.sortModel)
+                q = q.order(s.id, { ascending: !s.desc });
+            const { data, count, error } = await q.range(request.startRow, request.endRow - 1);
+            if (error)
+                throw new Error(error.message);
+            return { rows: (data ?? []), rowCount: count ?? 0 };
+        },
+        async createRow(input) {
+            const rest = { ...input };
+            delete rest[idField]; // primary key is database-generated
+            const { data, error } = await client.from(table).insert(rest).select().single();
+            if (error)
+                throw new Error(error.message);
+            return (data ?? input);
+        },
+        async updateRow(id, patch) {
+            const { data, error } = await client.from(table).update(patch).eq(idField, id).select().single();
+            if (error)
+                throw new Error(error.message);
+            return (data ?? { ...patch, [idField]: id });
+        },
+        async deleteRow(id) {
+            const { error } = await client.from(table).delete().eq(idField, id);
+            if (error)
+                throw new Error(error.message);
+        },
+    };
+}

package/dist/sources/with-entity-rules.d.ts

@@ -0,0 +1,25 @@
+/**
+ * withEntityRules - apply an `EntitySchema`'s computed fields and lifecycle
+ * hooks to any `ServerDataSource`, at the mutation boundary. It's a transparent
+ * wrapper: pass the result to `createServerDataSource` (or straight to the grid)
+ * and every read row gets its computed fields materialized, while writes run the
+ * schema's before/after hooks and cross-field validation.
+ *
+ *   const source = withEntityRules(createSqlDataSource(...), orderSchema)
+ *
+ * - `getRows`   -> each row through `applyComputed` (grid can sort/filter the
+ *                  computed value within the fetched page).
+ * - `createRow` -> `hooks.validate` + `hooks.beforeCreate` (may transform the
+ *                  payload or throw), then `applyComputed` on the returned row,
+ *                  then `hooks.afterCreate`.
+ * - `updateRow` -> the same with `beforeUpdate` / `afterUpdate`.
+ * - `deleteRow` -> `hooks.beforeDelete` (throw to veto) then `hooks.afterDelete`.
+ *
+ * Optional write methods stay optional, and any extra source capabilities
+ * (`getAggregate`, `rows()`) pass through untouched. Returning `applyComputed`
+ * rows from every method keeps the controller's optimistic reconciliation
+ * correct (a source must return the same row shape from all methods).
+ */
+import type { RowData, ServerDataSource } from '@svgrid/grid';
+import { type EntitySchema } from '../schema';
+export declare function withEntityRules<TData extends RowData, S extends ServerDataSource<TData>>(source: S, schema: EntitySchema<TData>): S;

package/dist/sources/with-entity-rules.js

@@ -0,0 +1,47 @@
+import { applyComputed, validateEntity } from '../schema';
+function firstError(errors) {
+    return Object.values(errors)[0] ?? 'Validation failed';
+}
+export function withEntityRules(source, schema) {
+    const hooks = schema.hooks ?? {};
+    const compute = (row) => applyComputed(schema, row);
+    const wrapped = {
+        async getRows(request) {
+            const res = await source.getRows(request);
+            return { ...res, rows: res.rows.map(compute) };
+        },
+    };
+    if (source.createRow) {
+        const create = source.createRow.bind(source);
+        wrapped.createRow = async (input) => {
+            const errors = await validateEntity(schema, input);
+            if (Object.keys(errors).length)
+                throw new Error(firstError(errors));
+            const payload = hooks.beforeCreate ? await hooks.beforeCreate(input) : input;
+            const row = compute(await create(payload));
+            await hooks.afterCreate?.(row);
+            return row;
+        };
+    }
+    if (source.updateRow) {
+        const update = source.updateRow.bind(source);
+        wrapped.updateRow = async (id, patch) => {
+            const errors = await validateEntity(schema, patch);
+            if (Object.keys(errors).length)
+                throw new Error(firstError(errors));
+            const payload = hooks.beforeUpdate ? await hooks.beforeUpdate(id, patch) : patch;
+            const row = compute(await update(id, payload));
+            await hooks.afterUpdate?.(row);
+            return row;
+        };
+    }
+    if (source.deleteRow) {
+        const del = source.deleteRow.bind(source);
+        wrapped.deleteRow = async (id) => {
+            await hooks.beforeDelete?.(id);
+            await del(id);
+            await hooks.afterDelete?.(id);
+        };
+    }
+    return { ...source, ...wrapped };
+}

package/dist/sources/with-relation-labels.d.ts

@@ -0,0 +1,26 @@
+/**
+ * withRelationLabels - decorate a source's rows with the human label of each
+ * foreign key, so the grid can show "Acme Inc" instead of the raw id `42`. It
+ * resolves labels through a `RelationLookup` (the same cached resolver the edit
+ * form's picker uses), so a value is fetched at most once and stays fresh.
+ *
+ *   const postsSource = withRelationLabels(rawPostsSource, [
+ *     { fk: 'authorId', lookup: authorLookup, as: 'author' },
+ *   ])
+ *
+ * Pair it with a schema where the FK field is `hidden: { grid: true }` and a
+ * read-only display column (`author`) shows the label. Because every method
+ * returns the decorated row shape, the controller's optimistic updates stay
+ * correct.
+ */
+import type { RowData, ServerDataSource } from '@svgrid/grid';
+import type { RelationLookup } from './relation-lookup';
+export type RelationLabelConfig = {
+    /** Local foreign-key field to resolve. */
+    fk: string;
+    /** Resolver for the related entity (see `createRelationLookup`). */
+    lookup: RelationLookup;
+    /** Field to write the resolved label onto. */
+    as: string;
+};
+export declare function withRelationLabels<TData extends RowData, S extends ServerDataSource<TData>>(source: S, relations: RelationLabelConfig[]): S;

package/dist/sources/with-relation-labels.js

@@ -0,0 +1,38 @@
+export function withRelationLabels(source, relations) {
+    if (relations.length === 0)
+        return source;
+    /** Decorate one row (used by create/update returns). */
+    const decorate = async (row) => {
+        const copy = { ...row };
+        await Promise.all(relations.map(async (r) => {
+            copy[r.as] = (await r.lookup.labelFor(row[r.fk])) ?? '';
+        }));
+        return copy;
+    };
+    const wrapped = {
+        async getRows(request) {
+            const res = await source.getRows(request);
+            // Batch: one lookup query per relation for the whole page (no N+1).
+            const maps = await Promise.all(relations.map((r) => r.lookup.labelsFor(res.rows.map((row) => row[r.fk]))));
+            const rows = res.rows.map((row) => {
+                const copy = { ...row };
+                relations.forEach((r, i) => {
+                    copy[r.as] = maps[i].get(String(row[r.fk])) ?? '';
+                });
+                return copy;
+            });
+            return { ...res, rows };
+        },
+    };
+    if (source.createRow) {
+        const fn = source.createRow.bind(source);
+        wrapped.createRow = async (input) => decorate(await fn(input));
+    }
+    if (source.updateRow) {
+        const fn = source.updateRow.bind(source);
+        wrapped.updateRow = async (id, patch) => decorate(await fn(id, patch));
+    }
+    if (source.deleteRow)
+        wrapped.deleteRow = source.deleteRow.bind(source);
+    return { ...source, ...wrapped };
+}

package/dist/staged-editing.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Staged editing - batch / draft mode for the grid.
+ *
+ * Without staged editing, every `onCellValueChange` writes immediately
+ * into the source data. Staged editing buffers writes into a draft
+ * shadow so the user can:
+ *
+ *   - Review every change before it lands
+ *   - Discard the whole batch
+ *   - Commit atomically (one server roundtrip; one undo step)
+ *
+ * Stays out of the headless engine - lives in `@svgrid/enterprise` as a small
+ * stateful wrapper your `onCellValueChange` handler delegates to.
+ *
+ * Usage:
+ * ```ts
+ * const stage = createStagedEditing<Order>()
+ *
+ * <SvGrid {data} {columns} features={features}
+ *   onCellValueChange={(e) => stage.record(e)}
+ * />
+ *
+ * stage.changes()  // → Change[]
+ * stage.commit(rows => /* push to server, set data = mutated rows *\/)
+ * stage.revert()   // → applies inverse writes back into the grid
+ * ```
+ */
+import type { RowData } from '@svgrid/grid';
+export type StagedChange<TData extends RowData> = {
+    /** Stable row id (the grid's row.id - or your getRowId result). */
+    rowId: string;
+    /** Source-array index at the time the change was recorded. */
+    rowIndex: number;
+    /** Field name on the row object. */
+    columnId: string;
+    /** Original value, BEFORE any staged edit. Stable across re-edits. */
+    original: unknown;
+    /** Most recent staged value. */
+    staged: unknown;
+    /** Timestamp the change was first staged (ms since epoch). */
+    recordedAt: number;
+    /** The whole row object as it was BEFORE the first edit. Useful for
+     *  optimistic locking / row-level commits. */
+    originalRow?: TData;
+};
+export type StagedEditingEvent = {
+    rowIndex: number;
+    columnId: string;
+    oldValue: unknown;
+    newValue: unknown;
+    row: unknown;
+};
+export type StagedEditingApi<TData extends RowData> = {
+    /** Feed a grid `onCellValueChange` event into the staging buffer. */
+    record(e: StagedEditingEvent): void;
+    /** Snapshot of every pending change, ordered by first edit. */
+    changes(): StagedChange<TData>[];
+    /** True when at least one cell is staged. */
+    isDirty(): boolean;
+    /** Count of distinct (row, column) pairs currently staged. */
+    size(): number;
+    /** Cells changed grouped by row id - one entry per touched row. */
+    changesByRow(): Array<{
+        rowId: string;
+        rowIndex: number;
+        cells: StagedChange<TData>[];
+    }>;
+    /**
+     * Hand every staged change to `commitFn`. When `commitFn` resolves
+     * truthy / void, the staging buffer is cleared. Throw / reject from
+     * `commitFn` to keep the buffer (so the user can retry).
+     */
+    commit(commitFn: (changes: StagedChange<TData>[]) => Promise<void> | void): Promise<void>;
+    /**
+     * Roll back every staged cell. Each call to `applyRevert` is passed
+     * (rowIndex, columnId, originalValue) - typically wired to
+     * `api.setCellValue(rowIndex, columnId, originalValue)`.
+     */
+    revert(applyRevert: (rowIndex: number, columnId: string, originalValue: unknown) => void): void;
+    /** Drop a single staged cell (without applying it). */
+    drop(rowId: string, columnId: string): void;
+    /** Wipe the buffer without applying anything. */
+    clear(): void;
+};
+export declare function createStagedEditing<TData extends RowData = RowData>(): StagedEditingApi<TData>;

package/dist/studio/bug-report.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Studio bug-report core (pure + node-safe, usable from the CLI and the
+ * designer). Two pieces:
+ *
+ *   - `sanitizeStudioProject` - strip credentials + seed DATA from a project so
+ *     a bug report never leaks a user's database or rows. It keeps the SCHEMA,
+ *     screens, and block structure (what actually reproduces a Studio bug) and
+ *     returns a plain-language list of what was removed, so the user sees it.
+ *   - `buildStudioBugReport` - assemble a markdown report + a prefilled GitHub
+ *     "new issue" URL. The URL carries a short summary (GitHub caps the prefill
+ *     ~8 KB); the full sanitized report goes in `markdown` for the caller to
+ *     copy to the clipboard / write to a file and paste in.
+ *
+ * The caller supplies `env` (version / node / os) so this stays free of any
+ * process or DOM access and is trivially testable.
+ */
+import type { StudioProject } from './project.js';
+export type SanitizeResult = {
+    project: StudioProject;
+    redactions: string[];
+};
+/**
+ * Return a copy of the project safe to attach to a bug report: credentials and
+ * seeded rows removed, schema + screens + blocks intact. Also returns a list of
+ * exactly what was stripped, for transparency.
+ */
+export declare function sanitizeStudioProject(project: StudioProject): SanitizeResult;
+export type StudioEnv = {
+    studioVersion?: string;
+    node?: string;
+    os?: string;
+};
+export type BugReportInput = {
+    /** The current project model (studio.config.json). Sanitized before use. */
+    project?: StudioProject;
+    /** The error that triggered the report (on a crash), if any. */
+    error?: Error | {
+        message: string;
+        stack?: string;
+    } | string;
+    /** What the user was doing (e.g. "generating the app", "editing the CRM board"). */
+    action?: string;
+    env?: StudioEnv;
+    /** `owner/repo` the issue targets (default the public SvGrid repo). */
+    repo?: string;
+};
+export type BugReport = {
+    title: string;
+    /** Full markdown report - copy to clipboard / write to a file and paste in. */
+    markdown: string;
+    /** Prefilled GitHub "new issue" URL. */
+    issueUrl: string;
+    redactions: string[];
+    /** True when the report was too big for the URL, so `markdown` must be pasted. */
+    truncated: boolean;
+};
+/**
+ * Build a shareable bug report from the current Studio state. The project is
+ * sanitized first; secrets never reach the markdown or the URL.
+ */
+export declare function buildStudioBugReport(input: BugReportInput): BugReport;

package/dist/studio/bug-report.js

@@ -0,0 +1,126 @@
+const REDACTED = '<redacted>';
+const DEFAULT_REPO = 'sv-grid/sv-grid';
+/** Keep the prefilled issue URL comfortably under browser / GitHub limits. */
+const MAX_URL = 7500;
+/** Param names that carry secrets (substring, case-insensitive). */
+const SECRET_NAME_RE = /(key|token|secret|auth|password|pass|bearer|credential)/i;
+/** Redact one entity's data source; push a human note for anything removed. */
+function sanitizeSource(entity, src, redactions) {
+    if (src.kind === 'memory') {
+        const { seed, ...rest } = src;
+        if (seed?.length)
+            redactions.push(`${entity}: ${seed.length} in-memory seed row(s) omitted`);
+        return rest;
+    }
+    if (src.kind === 'pglite') {
+        const { seed, ...rest } = src;
+        if (seed?.length)
+            redactions.push(`${entity}: ${seed.length} local-database seed row(s) omitted`);
+        return rest;
+    }
+    if (src.kind === 'supabase') {
+        const out = { ...src };
+        if (out.url) {
+            out.url = REDACTED;
+            redactions.push(`${entity}: Supabase URL redacted`);
+        }
+        if (out.key) {
+            out.key = REDACTED;
+            redactions.push(`${entity}: Supabase key redacted`);
+        }
+        return out;
+    }
+    if (src.kind === 'rest') {
+        const params = src.params.map((p) => {
+            // Header params and secret-named params carry auth; drop their values.
+            if (p.value && (p.location === 'header' || SECRET_NAME_RE.test(p.name))) {
+                redactions.push(`${entity}: REST ${p.location} param "${p.name}" value redacted`);
+                return { ...p, value: REDACTED };
+            }
+            return p;
+        });
+        let baseUrl = src.baseUrl;
+        if (/[?&](key|token|apikey|secret|auth|password)=/i.test(baseUrl)) {
+            baseUrl = baseUrl.replace(/([?&](?:key|token|apikey|secret|auth|password)=)[^&]*/gi, `$1${REDACTED}`);
+            redactions.push(`${entity}: credentials in REST baseUrl redacted`);
+        }
+        return { ...src, baseUrl, params };
+    }
+    // sql: the connection string lives in the host env, not the model - nothing to strip.
+    return src;
+}
+/**
+ * Return a copy of the project safe to attach to a bug report: credentials and
+ * seeded rows removed, schema + screens + blocks intact. Also returns a list of
+ * exactly what was stripped, for transparency.
+ */
+export function sanitizeStudioProject(project) {
+    const redactions = [];
+    if (!project.dataSources)
+        return { project, redactions };
+    const nextSources = {};
+    for (const [name, src] of Object.entries(project.dataSources)) {
+        nextSources[name] = sanitizeSource(name, src, redactions);
+    }
+    return { project: { ...project, dataSources: nextSources }, redactions };
+}
+function normalizeError(e) {
+    if (!e)
+        return undefined;
+    if (typeof e === 'string')
+        return { message: e };
+    return { message: e.message, stack: 'stack' in e ? e.stack : undefined };
+}
+function newIssueUrl(repo, title, body) {
+    const q = new URLSearchParams({ title, body, labels: 'studio,bug' });
+    return `https://github.com/${repo}/issues/new?${q.toString()}`;
+}
+function envLines(env) {
+    return [
+        `- Studio: ${env.studioVersion ?? 'unknown'}`,
+        `- Node: ${env.node ?? 'unknown'}`,
+        `- OS: ${env.os ?? 'unknown'}`,
+    ];
+}
+function renderSummary(env, err, action, redactions) {
+    const lines = ['### Environment', ...envLines(env), ''];
+    if (action)
+        lines.push('### What I was doing', action, '');
+    if (err)
+        lines.push('### Error', '```', err.message, '```', '');
+    lines.push(`_${redactions.length} item(s) redacted (credentials + seed data)._`);
+    return lines.join('\n');
+}
+/**
+ * Build a shareable bug report from the current Studio state. The project is
+ * sanitized first; secrets never reach the markdown or the URL.
+ */
+export function buildStudioBugReport(input) {
+    const env = input.env ?? {};
+    const err = normalizeError(input.error);
+    const { project, redactions } = input.project
+        ? sanitizeStudioProject(input.project)
+        : { project: undefined, redactions: [] };
+    const firstLine = (err?.message ?? 'Bug report').split('\n')[0].trim().slice(0, 100);
+    const title = `[Studio] ${firstLine}`;
+    const md = ['## SvGrid Studio bug report', '', '### Environment', ...envLines(env), ''];
+    if (input.action)
+        md.push('### What I was doing', input.action, '');
+    if (err)
+        md.push('### Error', '```', err.message, ...(err.stack ? ['', err.stack] : []), '```', '');
+    if (project)
+        md.push('### Project', `${project.entities?.length ?? 0} entities, ${project.screens?.length ?? 0} screens.`, '');
+    md.push('### Redactions', redactions.length ? redactions.map((r) => `- ${r}`).join('\n') : '- none', '');
+    if (project)
+        md.push('### Sanitized studio.config.json', '```json', JSON.stringify(project, null, 2), '```');
+    const markdown = md.join('\n');
+    const repo = input.repo ?? DEFAULT_REPO;
+    let issueUrl = newIssueUrl(repo, title, markdown);
+    let truncated = false;
+    if (issueUrl.length > MAX_URL) {
+        truncated = true;
+        const body = `${renderSummary(env, err, input.action, redactions)}\n\n> The full sanitized report was copied to your clipboard - paste it below.`;
+        issueUrl = newIssueUrl(repo, title, body);
+    }
+    return { title, markdown, issueUrl, redactions, truncated };
+}

package/dist/studio/cli.d.ts

@@ -0,0 +1,56 @@
+/**
+ * runStudioAdd - the one-command pipeline behind `@svgrid/studio add`: read a
+ * schema, introspect it, scaffold the files, merge-write them (preserving user
+ * edits outside managed regions), and verify the output compiles. This is the
+ * whole "CRUD screen in seconds" flow.
+ *
+ * Filesystem access is injected (`StudioIO`), so the orchestration is pure and
+ * unit-testable; the actual CLI bin supplies node:fs. No process/fs imports
+ * here, so it also runs in the browser (e.g. the designer's future
+ * write-to-project action).
+ */
+import type { EntitySchema } from '../schema.js';
+import { type ScaffoldOptions } from './scaffold.js';
+import { type ScaffoldAppOptions } from './scaffold-app.js';
+import { type VerifyResult } from './verify.js';
+export type StudioIO = {
+    /** Read a file; resolve to null when it doesn't exist. */
+    readFile: (path: string) => Promise<string | null>;
+    /** Write a file, creating parent directories as needed. */
+    writeFile: (path: string, contents: string) => Promise<void>;
+};
+export type AddOptions = ScaffoldOptions & {
+    /** Path to a Drizzle schema file to introspect. */
+    from?: string;
+    /** Which table in the Drizzle file to use (defaults to the first). */
+    table?: string;
+    /** Sample JSON rows to infer from, as an alternative to `from`. */
+    rows?: Array<Record<string, unknown>>;
+    /** Entity name (required with `rows`, ignored with `from`). */
+    name?: string;
+    /** A ready EntitySchema, bypassing introspection. */
+    schema?: EntitySchema;
+};
+export type AddResult = {
+    schema: EntitySchema;
+    /** Paths written, in order. */
+    written: string[];
+    verify: VerifyResult;
+};
+/** Resolve an EntitySchema from whichever input was provided. */
+export declare function resolveSchema(options: AddOptions, io: StudioIO): Promise<EntitySchema>;
+/**
+ * Resolve **every** entity from a Drizzle or Prisma schema file (the `--all
+ * --from` path), linked so foreign keys become working relation lookups.
+ */
+export declare function resolveSchemas(from: string, io: StudioIO): Promise<EntitySchema[]>;
+export declare function runStudioAdd(options: AddOptions, io: StudioIO): Promise<AddResult>;
+export type AddAppResult = {
+    written: string[];
+    verify: VerifyResult;
+};
+/**
+ * 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 declare function runStudioAddApp(schemas: EntitySchema[], options: ScaffoldAppOptions, io: StudioIO): Promise<AddAppResult>;