better-supabase 0.8.0 → 0.10.0

package/dist/controller-D6NyNrlZ.js

@@ -0,0 +1,79 @@
+//#region src/blocks/controller.ts
+/** Builds a controller from its initial state, its actions and its work. */
+function defineController(initial, build) {
+	let snapshot = initial;
+	let run = 0;
+	let stop;
+	let disposed = false;
+	const listeners = /* @__PURE__ */ new Set();
+	const parts = build({
+		get: () => snapshot,
+		set: (patch) => {
+			const changes = typeof patch === "function" ? patch(snapshot) : patch;
+			const current = new Map(Object.entries(snapshot));
+			if (!Object.entries(changes).some(([key, value]) => !Object.is(current.get(key), value))) return;
+			snapshot = {
+				...snapshot,
+				...changes
+			};
+			for (const listener of [...listeners]) listener();
+		},
+		run: () => run
+	});
+	const halt = () => {
+		run += 1;
+		const cleanup = stop;
+		stop = void 0;
+		cleanup?.();
+	};
+	return {
+		subscribe: (listener) => {
+			if (disposed) return () => void 0;
+			listeners.add(listener);
+			if (listeners.size === 1) {
+				run += 1;
+				stop = parts.start?.();
+			}
+			return () => {
+				if (!listeners.delete(listener) || listeners.size > 0) return;
+				halt();
+			};
+		},
+		getSnapshot: () => snapshot,
+		actions: parts.actions,
+		dispose: () => {
+			if (disposed) return;
+			disposed = true;
+			listeners.clear();
+			halt();
+		}
+	};
+}
+/**
+* Runs `effect` for the signed-in user, and again after its cleanup when
+* another user signs in. Nothing runs while the session loads or is signed
+* out. Returns the function that stops following the session.
+*/
+function whileSignedIn(auth, effect) {
+	let user = null;
+	let cleanup;
+	const sync = () => {
+		const snapshot = auth.current();
+		const next = snapshot.status === "signed-in" ? snapshot.user.id : null;
+		if (next === user) return;
+		cleanup?.();
+		cleanup = void 0;
+		user = next;
+		if (next !== null) cleanup = effect(next);
+	};
+	const unsubscribe = auth.subscribe(sync);
+	sync();
+	return () => {
+		unsubscribe();
+		cleanup?.();
+		cleanup = void 0;
+		user = null;
+	};
+}
+//#endregion
+export { whileSignedIn as n, defineController as t };

package/dist/create/index.d.ts

@@ -0,0 +1,597 @@
+import { Q as ModuleAccessProvider } from "../index-MCXVzkXs.js";
+import { Cn as AppOnDeleteAction, Mn as AppTableVersions, bn as AppColumnFormat, hn as APP_ON_DELETE_ACTIONS, nt as Preset, vn as AppColumnAccess, xn as AppColumnType } from "../codegen-2m4SKVdi.js";
+import { c as DesignChange, p as CreateDesign } from "../index-8xwnaWHY.js";
+import { a as SupabaseLint, o as SupabaseOrganization, s as SupabaseProject } from "../management-D1gG89z2.js";
+import { t as PresetMigrationFile } from "../types-DGHfTW8_.js";
+//#region src/create/schema.d.ts
+/** One rendered SQL file, as `/create/migrations` returns it. */
+export interface SchemaSource {
+  readonly path: string;
+  readonly module: string;
+  readonly contents: string;
+}
+/** The table a foreign key points at. `columns` is empty when the SQL names none: the target's primary key. */
+export interface SchemaTarget {
+  readonly schema: string;
+  readonly table: string;
+  readonly columns: readonly string[];
+}
+export interface SchemaForeignKey {
+  readonly columns: readonly string[];
+  readonly target: SchemaTarget;
+  /** The `on delete` action, lower case: `cascade`, `set null`, `no action`. */
+  readonly onDelete: string;
+}
+export interface SchemaColumn {
+  readonly name: string;
+  readonly type: string;
+  readonly nullable: boolean;
+  /** The default expression as the SQL writes it, or `null` without one. */
+  readonly default: string | null;
+  readonly unique: boolean;
+  /** What the column is beyond its type (`email`, `select`), when it is more. */
+  readonly label?: string;
+}
+export interface SchemaTable {
+  /** `schema.name`, unquoted. */
+  readonly id: string;
+  readonly schema: string;
+  readonly name: string;
+  /** The module whose file creates the table. */
+  readonly module: string;
+  readonly primaryKey: readonly string[];
+  readonly foreignKeys: readonly SchemaForeignKey[];
+  readonly tenantColumn: string | null;
+  /** Every column, in table order. */
+  readonly columns: readonly SchemaColumn[];
+  /** The rollups and lookups of an app table, which its `<table>_view` adds. */
+  readonly computed?: readonly SchemaComputed[];
+}
+/** A column of an app table's view: a rollup or a lookup. */
+export interface SchemaComputed {
+  readonly name: string;
+  readonly kind: "rollup" | "lookup";
+  readonly summary: string;
+  readonly label: string;
+}
+/**
+ * A column that points at a table without a foreign key: the tenant or user
+ * column a block keeps plain so its rows outlive deletes, or a `regclass`
+ * that names any table (`to` is `null`).
+ */
+export interface SchemaSoftRef {
+  readonly from: string;
+  readonly column: string;
+  readonly to: string | null;
+  readonly kind: "tenant" | "user" | "any";
+}
+/** What `/create/schema` returns. */
+export interface SchemaData {
+  readonly tables: readonly SchemaTable[];
+  readonly softRefs: readonly SchemaSoftRef[];
+  /** Table id to the block manifest that installs it. */
+  readonly manifests: Readonly<Record<string, string>>;
+  /** The table ids `blocks.<module>.options.extraColumns` adds columns to. */
+  readonly extraColumns: readonly string[];
+  /** Table id to its module and logical table, the names an app table's reference uses. */
+  readonly blockTables: Readonly<Record<string, {
+    readonly block: string;
+    readonly table: string;
+  }>>;
+  /** The table tenant columns point at, or `null` without tenant foreign keys. */
+  readonly tenantTable: string | null;
+}
+/** The columns a diagram shows before a table is expanded: keys, tenant and soft references. */
+export declare function keyColumnsOf(table: SchemaTable, softColumns?: ReadonlySet<string>): readonly SchemaColumn[];
+export interface SchemaOptions {
+  /** The tenant column the config names (`organization_id` by default); `null` without tenants. */
+  readonly tenantColumn?: string | null;
+}
+/** The column the tenant blocks key rows by, from the preset's tenant name; `null` without tenants. */
+export declare function tenantColumnOf(preset: Preset): string | null;
+/**
+ * The tables in rendered module SQL: every `create table`, plus the columns
+ * and foreign keys later `alter table ... add` statements give them. A
+ * `create table` it can't read throws with the file and line, so a new SQL
+ * shape fails the tests instead of dropping a table from the diagram.
+ */
+export declare function parseSchema(files: readonly SchemaSource[], options?: SchemaOptions): readonly SchemaTable[];
+/**
+ * The statements that shape one table, as written: its `create table` and
+ * the `alter table` statements after it. Empty when no file creates it.
+ */
+export declare function tableStatements(files: readonly SchemaSource[], id: string): readonly string[];
+/** The foreign keys between tables, one per pair, with the targets outside the schema named by id. */
+export declare function schemaRelations(tables: readonly SchemaTable[]): readonly {
+  readonly from: string;
+  readonly to: string;
+}[];
+//#endregion
+//#region src/create/design-computed.d.ts
+/** The aggregates a rollup takes (`APP_ROLLUP_AGGREGATES`). */
+export declare const ROLLUP_AGGREGATES: readonly ["count", "sum", "min", "max", "avg"];
+export type RollupAggregate = (typeof ROLLUP_AGGREGATES)[number];
+/** `appTables.<table>.rollups.<name>`; the shape of `AppRollupConfig`. */
+export interface AppRollup {
+  readonly table: string;
+  readonly via: string;
+  readonly aggregate: RollupAggregate;
+  readonly column?: string;
+  readonly where?: {
+    readonly column: string;
+    readonly equals: string;
+  };
+}
+/** `appTables.<table>.lookups.<name>`; the shape of `AppLookupConfig`. */
+export interface AppLookup {
+  readonly via: string;
+  readonly column: string;
+}
+/** A rollup or lookup as a table node and the inspector list it. */
+export interface ComputedRow {
+  readonly name: string;
+  readonly kind: "rollup" | "lookup";
+  /** What it computes, such as `count of tasks where status = todo`. */
+  readonly summary: string;
+  /** The short form the node shows next to the name, such as `count`. */
+  readonly label: string;
+}
+type Tables = Readonly<Record<string, AppTable>>;
+export declare function isRollupAggregate(value: unknown): value is RollupAggregate;
+/** The columns of `table` a rollup or lookup can read, with their types. */
+export declare function readableColumns(table: AppTable): readonly (readonly [string, AppColumnType])[];
+/** The columns `aggregate` can read: numbers for sum and avg, ordered types for min and max, none for count. */
+export declare function rollupColumns(child: AppTable, aggregate: RollupAggregate): readonly string[];
+/** The select columns of `child` (text with options) a rollup can filter on. */
+export declare function filterColumns(child: AppTable): readonly (readonly [string, readonly string[]])[];
+/** Each app table column that references `parent`, as `{ table, via }`: what a rollup on `parent` can aggregate. */
+export declare function rollupSources(tables: Tables, parent: string): readonly {
+  readonly table: string;
+  readonly via: string;
+}[];
+/** Each column of `name` that references another app table, with that table: what a lookup can follow. */
+export declare function lookupSources(tables: Tables, name: string): readonly {
+  readonly via: string;
+  readonly target: string;
+}[];
+export type DraftRollup = { -readonly [K in keyof AppRollup]: AppRollup[K]; };
+/** `table` with a rollup or lookup set under `name`, replacing `previous` in its place. */
+export declare function tableWithComputed(table: AppTable, name: string, computed: {
+  readonly rollup: AppRollup;
+} | {
+  readonly lookup: AppLookup;
+}, previous: string): AppTable;
+/** `table` without the rollup or lookup `name`. */
+export declare function tableWithoutComputed(table: AppTable, name: string): AppTable;
+/**
+ * The tables with every rollup and lookup that no longer fits dropped: one
+ * whose table, link or column was deleted or retyped, or whose name a
+ * column now uses. `sql sync` would refuse them, and the design code would
+ * not encode.
+ */
+export declare function prunedComputed(tables: Tables): Tables;
+/** The rollups that aggregate `from`, pointed at `to`. */
+export declare function computedTableRenamed(tables: Tables, from: string, to: string): Tables;
+/** The rollup fitted to a new source or aggregate: a column the aggregate can read, and a filter the child still has. */
+export declare function fittedRollup(tables: Tables, rollup: AppRollup): AppRollup;
+/**
+ * Every rollup and lookup that reads `table.from`, reading `table.to`. The
+ * tables already have the column renamed, so a lookup finds its target
+ * through the renamed link.
+ */
+export declare function computedColumnRenamed(tables: Tables, table: string, from: string, to: string): Tables;
+/** The rollups and lookups of an app table, in the view's column order. */
+export declare function computedRows(table: AppTable): readonly ComputedRow[];
+//#endregion
+//#region src/create/design-subject.d.ts
+/** Makes the rows a subject (`appTables.<table>.subject`); the shape of `AppTableSubject`. */
+export interface AppSubject {
+  readonly type: string;
+  readonly title?: string;
+  readonly url?: string;
+  readonly search?: {
+    readonly title?: string;
+    readonly body?: readonly string[];
+  };
+  readonly permissions?: Readonly<Record<string, string>>;
+  readonly rank?: true | {
+    readonly group?: string;
+  };
+  readonly softDelete?: boolean;
+  readonly versions?: true | AppTableVersions;
+}
+/** Which writes emit an event and the columns its payload carries. */
+export interface AppEvents {
+  readonly on?: readonly ("created" | "updated" | "deleted")[];
+  readonly include?: readonly string[];
+}
+/** The columns `subject` adds: `rank` for manual order and `deleted_at` for trash. */
+export declare function subjectColumns(subject: AppSubject | undefined): SchemaColumn[];
+/** The subject with the columns it names renamed or dropped by `edit`. */
+export declare function subjectColumnsEdited(subject: AppSubject, edit: (columns: readonly string[]) => readonly string[]): AppSubject;
+/** Why `type` can't be the subject type of the app table `table`, or `undefined` when it can. */
+export declare function subjectTypeError(design: Design, table: string, type: string): string | undefined;
+/** App table events with `edit` applied to the payload columns, dropping an empty list. */
+export declare function eventsColumnsEdited(events: true | AppEvents, edit: (columns: readonly string[]) => readonly string[]): true | AppEvents;
+//#endregion
+//#region src/create/design.d.ts
+/** Another app table or `auth.users` (`{ table }`), or a block module's logical table (`{ block, table }`). */
+export interface AppReference {
+  readonly table: string;
+  readonly block?: string;
+  readonly onDelete?: AppOnDeleteAction;
+}
+export interface AppColumn {
+  readonly type: AppColumnType;
+  readonly nullable?: boolean;
+  readonly default?: string;
+  readonly unique?: boolean;
+  readonly references?: AppReference;
+  readonly format?: AppColumnFormat;
+  readonly options?: readonly string[];
+  readonly min?: number;
+  readonly max?: number;
+  readonly comment?: string;
+  readonly identity?: boolean;
+  /** Who reads and writes the column: everyone by default, `read`, or `server` (ADR 0051). */
+  readonly access?: AppColumnAccess;
+}
+export type AppScope = "inherit" | "user" | "none";
+export type AppTableId = "uuid" | "bigint";
+export interface AppTable {
+  readonly columns?: Readonly<Record<string, AppColumn>>;
+  readonly scope?: AppScope;
+  readonly timestamps?: boolean;
+  readonly id?: AppTableId;
+  readonly unique?: readonly (readonly string[])[];
+  readonly indexes?: readonly (readonly string[])[];
+  readonly comment?: string;
+  readonly subject?: AppSubject;
+  readonly rollups?: Readonly<Record<string, AppRollup>>;
+  readonly lookups?: Readonly<Record<string, AppLookup>>;
+  /** Outbox events on insert, update and delete; the shape of `AppTableEvents`. */
+  readonly events?: true | AppEvents;
+}
+/**
+ * What the canvas adds to a preset: app tables, extra columns on block
+ * tables (by module) and the positions of moved tables (by table id). It has
+ * the shape of `CreateDesign` from `better-supabase/preset`.
+ */
+export interface Design {
+  readonly appTables?: Readonly<Record<string, AppTable>>;
+  readonly extraColumns?: Readonly<Record<string, Readonly<Record<string, string>>>>;
+  readonly positions?: Readonly<Record<string, readonly [number, number]>>;
+}
+export declare const EMPTY_DESIGN: Design;
+/** The module name app tables carry in the diagram. */
+export declare const APP_MODULE = "app-tables";
+export declare function appTableId(name: string): string;
+export declare function isAppTable(table: Pick<SchemaTable, "module">): boolean;
+export declare function isEmptyDesign(design: Design): boolean;
+/** Why `name` can't name an app table or column, by the library's rules. */
+export declare function identifierError(name: string): string | undefined;
+/** Why a column can't be added to an app table, or `undefined` when it can. */
+export declare function columnError(table: AppTable, name: string, preset: Pick<Preset, "scope" | "tenantName" | "idType">): string | undefined;
+/**
+ * Why `value` can't be the default of `column` (its type, options and
+ * bounds), or `undefined` when it can or is empty.
+ */
+export declare function defaultError(column: Pick<AppColumn, "type" | "options" | "min" | "max" | "format">, value: string): string | undefined;
+/** A free app table name: `base`, then `base_2`, `base_3` and so on. */
+export declare function freeTableName(design: Design, taken: ReadonlySet<string>, base?: string): string;
+/** Adds an app table, placed at `position` when given. */
+export declare function addTable(design: Design, name: string, table?: AppTable, position?: readonly [number, number]): Design;
+/**
+ * Removes an app table, every app table column that references it (and
+ * those columns from key sets), and the rollups and lookups that read it.
+ */
+export declare function deleteTable(design: Design, name: string): Design;
+/** Renames an app table and the references to it. */
+export declare function renameTable(design: Design, from: string, to: string): Design;
+export type TablePatch = { readonly [K in "scope" | "timestamps" | "id" | "unique" | "indexes" | "comment" | "subject" | "events"]?: AppTable[K] | undefined; };
+/** Updates an app table's options; a key set to `undefined` is removed. */
+export declare function updateTable(design: Design, name: string, patch: TablePatch): Design;
+/**
+ * Sets an app table's id type and retypes the app table columns that
+ * reference it, since a key has the type of the id it points at.
+ */
+export declare function setTableId(design: Design, name: string, id: AppTableId): Design;
+/** Sets (adds or replaces) an app table column. */
+export declare function setColumn(design: Design, table: string, name: string, column: AppColumn): Design;
+/** Renames an app table column, keeping its place. */
+export declare function renameColumn(design: Design, table: string, from: string, to: string): Design;
+/** Replaces an app table with `edit` applied to it, such as `tableWithComputed`. */
+export declare function editTable(design: Design, table: string, edit: (current: AppTable) => AppTable): Design;
+export declare function deleteColumn(design: Design, table: string, name: string): Design;
+/** Sets an extra column on a block table (`blocks.<module>.options.extraColumns`). */
+export declare function setExtraColumn(design: Design, module: string, name: string, type: string): Design;
+export declare function deleteExtraColumn(design: Design, module: string, name: string): Design;
+/** A design with the name of the table an edit created. */
+export interface NamedDesign {
+  readonly design: Design;
+  readonly name: string;
+}
+/** Copies an app table under a free name, next to the original. */
+export declare function duplicateTable(design: Design, name: string, taken: ReadonlySet<string>): NamedDesign;
+/** Moves tables (table id to its new top-left corner). */
+export declare function moveTables(design: Design, moves: Readonly<Record<string, readonly [number, number]>>): Design;
+/**
+ * The app table column behind a foreign key from `tableId`, when the canvas
+ * added it, or `undefined` when a block or the preset owns the key.
+ */
+export declare function userConnection(design: Design, tableId: string, column: string | null): {
+  readonly table: string;
+  readonly column: string;
+} | undefined;
+/** Drops every saved position, so the automatic layout places every table again. */
+export declare function tidy(design: Design): Design;
+/** A naive English singular for a table name: `organizations` to `organization`. */
+export declare function singular(name: string): string;
+export interface Connection {
+  /** The app table the column goes on. */
+  readonly source: string;
+  /** The table id it references. */
+  readonly target: string;
+}
+export type ConnectResult = {
+  readonly ok: true;
+  readonly design: Design;
+  readonly column: string;
+} | {
+  readonly ok: false;
+  readonly error: string;
+};
+/**
+ * Adds a foreign key column from an app table to `target`. Only app tables
+ * get new columns. A self reference gets `parent_id`, and a second
+ * reference to the same table gets a role name (`owner_id`, `<target>_2_id`)
+ * the user can rename. A target without a single-column primary key, and
+ * the tenant table the scope column already references, are refused with a
+ * message.
+ */
+export declare function connect(design: Design, data: SchemaData, preset: Pick<Preset, "scope" | "tenantName" | "idType">, connection: Connection): ConnectResult;
+/**
+ * Adds a key to `targetId` on the app table `name` in the design, which can
+ * be a table the schema doesn't have yet: `<target>_id`, `parent_id` for a
+ * self reference, or a free role name when that column is taken.
+ */
+export declare function referenceFrom(design: Design, data: SchemaData, preset: Pick<Preset, "scope" | "tenantName" | "idType">, name: string, targetId: string): ConnectResult;
+export interface DesignIssue {
+  /** The app table or block module the issue is on. */
+  readonly table: string;
+  readonly message: string;
+}
+/**
+ * What would stop `sql sync` from writing the design: a table name a block
+ * already uses, a reference to a table the preset no longer installs, a
+ * set-null delete on a required column, a composite key on a column the
+ * table doesn't have, and extra columns for a block that is gone or no
+ * longer takes them.
+ */
+export declare function designIssues(design: Design, data: SchemaData, preset: Pick<Preset, "scope" | "tenantName" | "idType">): readonly DesignIssue[];
+/**
+ * The schema with the design applied: app tables added, extra columns
+ * appended to the block tables that accept them.
+ */
+export declare function withDesign(data: SchemaData, design: Design, preset: Pick<Preset, "scope" | "tenantName" | "idType">): SchemaData;
+//#endregion
+//#region src/create/column-keys.d.ts
+/**
+ * Whether a column signed-in users can't write is required with no default,
+ * which `appTables` refuses: nobody but the server could insert a row.
+ */
+export declare function lockedWithoutDefault(column: AppColumn): boolean;
+/** Whether `min` and `max` apply to a `type` column, as a value or a length. */
+export declare function takesBounds(type: AppColumnType): boolean;
+/**
+ * A column without the keys its type can't take: a format of another type,
+ * options outside text and text[], bounds that don't apply, an identity
+ * outside integer and bigint, and a default an identity or the type refuses.
+ */
+export declare function fitted(column: AppColumn): AppColumn;
+/** Why `option` can't join a select's `options`, or `undefined` when it can. */
+export declare function optionError(options: readonly string[], option: string): string | undefined;
+/** Why `value` can't be a bound of `column`, or `undefined` when it can (an empty value clears it). */
+export declare function boundError(column: AppColumn, side: "min" | "max", value: string): string | undefined;
+/** `column` with its bounds replaced; a bound left out is removed. */
+export declare function withBounds(column: AppColumn, bounds: {
+  readonly min?: number | undefined;
+  readonly max?: number | undefined;
+}): AppColumn;
+/** What the canvas shows for a column that is more than its type, such as an email or a select. */
+export declare function columnLabel(column: AppColumn): string | undefined;
+//#endregion
+//#region src/create/column-kinds.d.ts
+/** The groups of the column type picker, in the order it shows them. */
+export declare const KIND_GROUPS: readonly ["Text", "Number", "Date and time", "Choice", "Relation", "Other"];
+export type KindGroup = (typeof KIND_GROUPS)[number];
+/**
+ * A choice in the column type picker: a Postgres type with the format,
+ * options, identity or reference that make it, say, an email or a rating.
+ */
+export interface ColumnKind {
+  readonly id: string;
+  readonly label: string;
+  readonly group: KindGroup;
+  /** What the canvas shows next to the column name. */
+  readonly short: string;
+  /** The keys the kind sets; the rest of the column is kept where it fits. */
+  readonly column: AppColumn;
+  /** Set for kinds the picker shows but a drag from the table's handle makes. */
+  readonly drawn?: true;
+}
+export declare const COLUMN_KINDS: readonly ColumnKind[];
+export declare function kindById(id: string): ColumnKind | undefined;
+/** The picker choice a column reads as. */
+export declare function kindOf(column: AppColumn): ColumnKind;
+/**
+ * `column` as `kind`: the kind's keys, with the column's name-independent
+ * settings (required, unique, comment, a default and bounds that still fit)
+ * kept, and a select's options kept when it turns into the other select.
+ */
+export declare function withKind(column: AppColumn, kind: ColumnKind): AppColumn;
+/**
+ * Sets an app table column to `kind`. Currency keeps money as two columns:
+ * the column becomes `<name>_minor` (unless the name is taken) and a
+ * `<name>_currency` text column of 3 characters joins it. Returns the
+ * column's name after the change.
+ */
+export declare function setColumnKind(design: Design, table: string, name: string, kind: ColumnKind): NamedDesign;
+//#endregion
+//#region src/create/deploy.d.ts
+/** The name the deploy gives its migration in `supabase_migrations`. */
+export declare const MIGRATION_NAME = "better_supabase_blocks";
+/**
+ * Why this preset can't be deployed, or `undefined` when it can. With
+ * `access: "provider"` the preview renders a stand-in provider whose
+ * functions no real project has.
+ */
+export declare function deployBlocker(preset: Preset): string | undefined;
+/**
+ * The SQL of one migration for the rendered files: every schema file, then
+ * every data file, each in render order, which is the order `sql sync` and
+ * `sql data` apply them. pgTAP tests stay out.
+ */
+export declare function deployQuery(files: readonly PresetMigrationFile[]): string;
+/** A database password for a new project: 32 base64url characters. */
+export declare function generatePassword(): string;
+/** The project name the dialog suggests: the preset's name, or `my-app`. */
+export declare function suggestedProjectName(named: string | undefined): string;
+export declare function dashboardUrl(ref: string, page?: string): string;
+/** `GET /create/supabase/projects`. */
+export interface ProjectsResponse {
+  readonly organizations: readonly SupabaseOrganization[];
+  readonly projects: readonly SupabaseProject[];
+}
+/** `POST /create/supabase/projects`: the new project and its one-time password. */
+export interface CreatedProjectResponse {
+  readonly project: SupabaseProject;
+  readonly dbPassword: string;
+}
+/** `GET /create/supabase/projects/<ref>`. */
+export interface ProjectStatusResponse {
+  readonly project: SupabaseProject;
+  readonly ready: boolean;
+  /** Tables already in `public`, or `null` while the database is starting. */
+  readonly publicTables: number | null;
+}
+/** `POST /create/supabase/deploy`. */
+export interface DeployResponse {
+  readonly ref: string;
+  readonly migration: string;
+  readonly lints: readonly SupabaseLint[];
+}
+/** Every error body: `connect` means the Supabase session is missing or expired. */
+export interface ErrorResponse {
+  readonly error: "connect" | "confirm" | "blocked" | "invalid" | "supabase";
+  readonly message: string;
+}
+//#endregion
+//#region src/create/design-history.d.ts
+/** How many steps Undo can go back. */
+export declare const HISTORY_LIMIT = 50;
+export interface History<T> {
+  readonly past: readonly T[];
+  readonly present: T;
+  readonly future: readonly T[];
+  /** The value before the drag in progress, which `commitDrag` records as one step. */
+  readonly dragStart: T | null;
+}
+export type HistoryAction<T> = {
+  readonly type: "apply";
+  readonly value: T;
+} | {
+  readonly type: "drag";
+  readonly value: T;
+} | {
+  readonly type: "commitDrag";
+} | {
+  readonly type: "amend";
+  readonly value: T;
+} | {
+  readonly type: "undo";
+} | {
+  readonly type: "redo";
+} | {
+  readonly type: "reset";
+  readonly value: T;
+};
+export declare function initialHistory<T>(value: T): History<T>;
+/**
+ * An undo history. `drag` updates the value without a step while the
+ * pointer moves; `commitDrag` records the whole drag as one step. `amend`
+ * replaces the value in the current step, so a follow-up such as placing a
+ * dropped block stays part of the step that added it. `reset` replaces the
+ * value and clears the history, as loading a link does.
+ */
+export declare function undoHistory<T>(current: History<T>, action: HistoryAction<T>): History<T>;
+//#endregion
+//#region src/create/preview-provider.d.ts
+/**
+ * A stand-in for the app's authorization provider, so `/create` can render
+ * the SQL and the diagram for `access: "provider"`. Its templates call
+ * functions in a `provider` schema that no real project has: the preview
+ * says so next to the output.
+ */
+export declare function previewAccessProvider(preset: Preset): ModuleAccessProvider;
+/**
+ * The files `sql sync` writes for a config with only this preset and its
+ * `/create` design (app tables and extra columns). With
+ * `access: "provider"` the access functions come from
+ * `previewAccessProvider`.
+ */
+export declare function previewFiles(code: string, design?: CreateDesign): readonly PresetMigrationFile[];
+//#endregion
+//#region src/create/sample-rows.d.ts
+/** One sample row: column name to the text the grid shows, or `null`. */
+export type SampleRow = Readonly<Record<string, string | null>>;
+export interface SampleTable {
+  readonly columns: readonly string[];
+  readonly rows: readonly SampleRow[];
+}
+export declare const SAMPLE_ROW_COUNT = 8;
+/** Who reads the rows: a signed-in member, or server code with the service role. */
+export type SampleViewer = "member" | "server";
+/** The columns of `table` a `viewer` can't select: `access: "server"` ones for a member. */
+export declare function hiddenColumns(table: AppTable | undefined, viewer: SampleViewer): readonly string[];
+/**
+ * Deterministic sample rows for app table `name`, from its columns' types,
+ * formats, options, bounds and references. A reference shows the name of the
+ * row it points at, so rows of related tables line up. A `member` viewer
+ * doesn't get the columns `hiddenColumns` lists.
+ */
+export declare function sampleRows(design: Design, name: string, count?: number, viewer?: SampleViewer): SampleTable;
+//#endregion
+//#region src/create/schema-meta.d.ts
+/** The tables plus the soft references, manifests and extra-column tables the canvas draws. */
+export declare function schemaData(tables: readonly SchemaTable[], tenantName?: string): SchemaData;
+//#endregion
+//#region src/create/migration.d.ts
+/**
+ * Why no migration was written: `breaking` changes need the expand and
+ * contract steps in each change, and `unsupported` ones are outside what a
+ * generated migration covers.
+ */
+export type MigrationRefusal = "breaking" | "unsupported";
+export type MigrationPlan = {
+  readonly ok: true;
+  /** The SQL to apply; empty when nothing changed. */
+  readonly sql: string;
+  readonly changes: readonly DesignChange[];
+} | {
+  readonly ok: false;
+  readonly reason: MigrationRefusal;
+  /** The changes that caused the refusal, or every change when a file outside the app tables differs. */
+  readonly changes: readonly DesignChange[];
+};
+/**
+ * The migration that takes a project deployed from `base` to `next`, for
+ * added tables and added columns only. The rendered app-table SQL is
+ * idempotent (`create table if not exists`, `add column if not exists`,
+ * `drop policy if exists`), so the migration is the re-rendered file.
+ * Anything else, such as a rename, a retype, a changed default or a change
+ * outside `appTables`, is refused so a deploy never guesses.
+ */
+export declare function migrationBetween(code: string, base: CreateDesign, next: CreateDesign): MigrationPlan;
+//#endregion
+export { type AppColumnAccess, type AppColumnType, APP_ON_DELETE_ACTIONS as ON_DELETE_ACTIONS, type AppOnDeleteAction as OnDeleteAction, type PresetMigrationFile };