@metabase/rde 0.1.12 → 0.1.13

package/README.md

@@ -35,19 +35,22 @@ The wizard shows its checklist first (`✓` done, `○` to do, `–` not applica
 ○ Start Metabase
 ○ Create the admin user
 ○ Connect the Metabase CLI
+○ Enable transforms
 ○ Connect a sample database
 ○ Activate your license
-○ Connect your databases
 – Connect a git repository
+○ Connect your databases
 ○ Summary
 │
 ●  Running npm install -g @metabase/cli@alpha-release-65-integration-branch
 ```
 
-The steps up to the license run without a question, save one: `mb` is installed with the package manager that installed `rde`, the skill goes to the coding agents you pick from the ones found on the machine (at a terminal; without one, to every agent found), Metabase runs in Docker when Docker is there (the jar with your Java otherwise), on the first free port from 23000 up that no other container or instance claims, with an admin user whose password is generated and kept in `~/.rde`, `mb` is logged in under its `default` profile (the one question here comes when `default` already points at another Metabase), and a Postgres sample database comes up in a second container, connected to Metabase as a place transforms can write. Each of those choices is printed as it is made and can be overridden with a flag. The prompts that remain are the license token (Enter skips it), a connection string for your own database (Enter skips it), and, with a license that includes remote sync, where the git repository lives and which remote it uses.
+The steps up to the license run without a question, save one: `mb` is installed with the package manager that installed `rde`, the skill goes to the coding agents you pick from the ones found on the machine (at a terminal; without one, to every agent found), Metabase runs in Docker when Docker is there (the jar with your Java otherwise), on the first free port from 23000 up that no other container or instance claims, with an admin user whose password is generated and kept in `~/.rde`, `mb` is logged in under its `default` profile (the one question here comes when `default` already points at another Metabase), and a Postgres sample database comes up in a second container, connected to Metabase as a place transforms can write. Each of those choices is printed as it is made and can be overridden with a flag. The prompts that remain are the license token (Enter skips it), with a license that includes remote sync where the git repository lives and which remote it uses, and your own databases (Enter skips them).
 
 The databases step asks once. At a terminal, without `--yes` or `--skip-databases`, and while none of your own databases is connected, it lists what is connected (the sample database) and asks for a connection string: paste one and `rde` reads the engine from it (or asks which, when the string fits several, or shows the engine list when it fits none), then shows the connection for review, tests it, adds it, and offers another. Enter skips it, and the skip is remembered, so the next `rde init` does not ask again; `rde init --only databases` and `rde db add` still do. With `--yes` or without a terminal it asks nothing and the sample database stands in; `--database` connects yours ahead of time.
 
+It runs after the git step because content imported from a repository names its databases, and Metabase only finds them by name. Every database the content names that this instance lacks becomes a stub: a placeholder with that name and no connection, which keeps the content importable and which Metabase leaves out of its own database lists. When there are stubs, the step asks for them instead of the connection string: a checklist of their names, none picked, where you pick the few you work on (a repository can name dozens, most of them someone else's or out of reach from your machine). Each one picked asks for its connection string (Enter goes to the engine list, whose last choice leaves that one unconnected), then review, test, and connect: the stub becomes the real database under the same name and id, so the content on it works and its sync starts. Picking none skips the step like Enter does. The ones left over are named at the end of the step and in the summary, and `rde db add` and `rde db list` show them until they are connected. A database named ahead of time (`--database`, an answers file, `rde db add --url --name`) whose name is a stub's connects that stub too, never a second database of the same name.
+
 The git step reads `–` until a license with remote sync is active; it is checked again when its turn comes, so a run that activates a license connects the repository in the same pass.
 
 | Step | What it does |
@@ -59,10 +62,11 @@ The git step reads `–` until a license with remote sync is active; it is check
 | Start Metabase | Starts the container or the jar and waits for `/api/health`, showing Metabase's own progress |
 | Create the admin user | `admin@metabase.local` with a generated password that `rde credentials` shows, or your own with `--admin prompted`, see [Credentials](#credentials) |
 | Connect the Metabase CLI | Creates an API key named `rde` and logs `mb` in with it under the profile `default`, so plain `mb` uses the instance; when `default` already points at another Metabase it asks first, see [The `mb` profile](#the-mb-profile); a key Metabase rejects is replaced |
-| Connect a sample database | Runs Metabase's Postgres sample data (`metabase/qa-databases:postgres-sample-15`) in a container named `rde-sampledb-default` on the first free port from 25432 (or one Docker picks, when another program or a concurrent `rde init` takes that port first), connects it as `Sample Database`, and switches transforms on. It replaces the H2 sample database Metabase would otherwise bundle, which cannot be a transform target. Needs Docker, so a jar instance on a machine without Docker keeps the H2 one instead |
+| Enable transforms | Turns transforms on, unless someone already set them either way: turned off in the admin settings, they stay off on every later `rde init`, and the admin settings turn them back on |
+| Connect a sample database | Runs Metabase's Postgres sample data (`metabase/qa-databases:postgres-sample-15`) in a container named `rde-sampledb-default` on the first free port from 25432 (or one Docker picks, when another program or a concurrent `rde init` takes that port first), and connects it as `Sample Database`. It replaces the H2 sample database Metabase would otherwise bundle, which cannot be a transform target. Needs Docker, so a jar instance on a machine without Docker has no sample database |
 | Activate your license | Optional. Paste a token, or press Enter to skip; remote sync needs one with the `remote-sync` feature |
-| Connect your databases | At a terminal, until you connect one of your own or skip it: paste a connection string (Enter skips), review, test, add; repeat. `--database` names them ahead of time; with `--yes` or without a terminal nothing is asked. `rde db add` starts from the engine list, where the fields can also be filled one by one |
-| Connect a git repository | Only with a license. Initializes or reuses a repository and points Metabase's remote sync at it |
+| Connect a git repository | Only with a license. Initializes or reuses a repository and points Metabase's remote sync at it, with transforms included in the sync (the Transforms row under Collections to sync), and imports the content it already holds |
+| Connect your databases | At a terminal, until you connect one of your own or skip it: pick the databases the imported content uses from a checklist, or, with none, paste a connection string (Enter skips); review, test, add; repeat. `--database` names them ahead of time; with `--yes` or without a terminal nothing is asked. `rde db add` starts from the same checklist, then the engine list, where the fields can also be filled one by one |
 | Summary | URL, login email, the `mb` command for the instance, databases, repository, and the command that opens each detected agent |
 
 The second run on the same machine detects every step as done and prints the summary only:
@@ -76,10 +80,11 @@ The second run on the same machine detects every step as done and prints the sum
 ✓ Start Metabase
 ✓ Create the admin user
 ✓ Connect the Metabase CLI
+✓ Enable transforms
 ✓ Connect a sample database
 – Activate your license
-✓ Connect your databases
 – Connect a git repository
+✓ Connect your databases
 ○ Summary
 │
 ◇  Your environment ─────────────────────────────────────────────────────────────────╮
@@ -167,8 +172,8 @@ Docker is used whenever it is available: the image is self-contained, and the co
 | `rde credentials` | The Metabase URL, admin email, and password; `--json` for scripts and agents; `--api-key` for the API key alone |
 | `rde logs` | The container's log, or the jar's `metabase.log`; `-f` keeps streaming |
 | `rde open` | Opens the instance in the browser |
-| `rde db add` | The database wizard: pick the engine, paste a connection string or fill the fields, review, test, add. `rde db add --url <connection string> [--name <display name>]` asks nothing: it reads the engine from the string (`--engine` for one that fits several), tests it and adds it, which is how a script or a coding agent connects a database without a terminal; `--url -` reads the string from stdin |
-| `rde db list` | The connected databases; `--json` for scripts; a bare `rde db` does the same |
+| `rde db add` | The database wizard: pick the stubs to connect when the content uses databases not connected yet, otherwise (or after them) pick the engine, paste a connection string or fill the fields, review, test, add. `rde db add --url <connection string> [--name <display name>]` asks nothing: it reads the engine from the string (`--engine` for one that fits several), tests it and adds it, which is how a script or a coding agent connects a database without a terminal; `--url -` reads the string from stdin; a `--name` that is a stub's connects that stub |
+| `rde db list` | The connected databases and the stubs still waiting for a connection (`stub` in `--json`); `--json` for scripts; a bare `rde db` does the same |
 | `rde doctor` | One table of checks with a fix hint per failure; `--fix` re-runs the init steps behind them; `--json` for scripts and the rde skill (every row's `id`, `status`, `detail`, `hint`, and `fix`: the `rde` command that repairs it, or null when you have to act); exit 1 while anything fails |
 | `rde upgrade` | Moves the instance to a newer Metabase after backing up its data; see [Upgrading](#upgrading) |
 | `rde uninstall` | Removes the instance, its data, and the `mb` profile; see [Resetting](#resetting) |
@@ -191,12 +196,12 @@ mb git-sync status
 
 ## The git repository
 
-With a license that includes remote sync, the last step connects a git repository. You choose where Metabase pushes, then where the working directory lives (here, another directory, or an existing repository):
+With a license that includes remote sync, the step after the license connects a git repository. You choose where Metabase pushes, then where the working directory lives (here, another directory, or an existing repository):
 
 - **Local remote inside `~/.rde`** (default): a bare repository at `instances/default/data/content.git`, mounted into the container and reached as `file:///rde/content.git`. No account, no token. Your working directory gets it as `origin` (or as `rde-remote` when `origin` already points elsewhere).
 - **Hosted remote**: a GitHub, GitLab, or Bitbucket `https://` URL plus a token with read and write access. `rde` tests the connection through Metabase before saving anything, then clones the repository into the working directory (an existing repository gets the URL as `origin` instead); an empty hosted repository gets the first commit pushed to it. The token is handed to Metabase and, for the clone and that first push, to git in its environment; it never lands in the clone's config, the remote URL, or a credential helper, so a later `git pull` uses your own git credentials.
 
-A fresh repository gets a first commit with a `README.md` and a `.gitignore` that keeps out what a data app built in it must not push: `.env`, `.env.local`, `.env.*.local`, `node_modules/`, `.vite/`, the rde skill's `.scratch/`, and `.DS_Store` (a data app's built `dist/` stays tracked, since that bundle is what Metabase serves); a `.gitignore` already there keeps its lines and gets the missing ones, and a repository that already has commits is left as it is. A repository that already holds Metabase content is imported on the spot. Afterwards:
+A fresh repository gets a first commit with a `README.md` and a `.gitignore` that keeps out what a data app built in it must not push: `.env`, `.env.local`, `.env.*.local`, `node_modules/`, `.vite/`, the rde skill's `.scratch/`, and `.DS_Store` (a data app's built `dist/` stays tracked, since that bundle is what Metabase serves); a `.gitignore` already there keeps its lines and gets the missing ones, and a repository that already has commits is left as it is. A repository that already holds Metabase content is imported on the spot; each database it names that this instance lacks becomes a stub, which the databases step right after offers to connect. Afterwards:
 
 ```sh
 cd <your working directory>

package/dist/cli.mjs

@@ -240,10 +240,11 @@ const StepId = z.enum([
 	"start-metabase",
 	"admin-user",
 	"api-key",
+	"transforms",
 	"sample-database",
 	"license",
-	"databases",
 	"git-sync",
+	"databases",
 	"summary"
 ]);
 const GlobalConfig = z.object({
@@ -1037,8 +1038,12 @@ const Database = z.object({
 	id: z.int(),
 	name: z.string(),
 	engine: z.string(),
-	initial_sync_status: InitialSyncStatus
+	initial_sync_status: InitialSyncStatus,
+	is_stub: z.boolean().optional()
 }).loose();
+function isStub(database) {
+	return database.is_stub === true;
+}
 const DatabaseList = z.object({
 	data: z.array(Database),
 	total: z.int()
@@ -1072,6 +1077,17 @@ function databaseResource(http) {
 	async function list() {
 		return http.requestJson("GET", "/api/database", { schema: DatabaseList });
 	}
+	/** GET /api/database?include_stubs=true */
+	async function listWithStubs() {
+		return http.requestJson("GET", "/api/database?include_stubs=true", { schema: DatabaseList });
+	}
+	/** PUT /api/database/:id — on a stub, new connection details make it a real database */
+	async function connect(id, connection) {
+		return http.requestJson("PUT", `/api/database/${id}`, {
+			body: connection,
+			schema: Database
+		});
+	}
 	/** GET /api/database/:id */
 	async function get(id) {
 		return http.requestJson("GET", `/api/database/${id}`, { schema: Database });
@@ -1080,6 +1096,8 @@ function databaseResource(http) {
 		validate,
 		create,
 		list,
+		listWithStubs,
+		connect,
 		get
 	};
 }
@@ -1132,6 +1150,13 @@ function remoteSyncResource(http) {
 			schema: RemoteSyncSettingsResult
 		});
 	}
+	/** PUT /api/ee/remote-sync/settings with only `remote-sync-transforms`, which skips the repository check. */
+	async function syncTransforms() {
+		return http.requestJson("PUT", "/api/ee/remote-sync/settings", {
+			body: { "remote-sync-transforms": true },
+			schema: RemoteSyncSettingsResult
+		});
+	}
 	/** POST /api/ee/remote-sync/test-connection; an empty body tests the saved url and token. */
 	async function testConnection(connection = {}) {
 		return http.requestJson("POST", "/api/ee/remote-sync/test-connection", {
@@ -1145,6 +1170,7 @@ function remoteSyncResource(http) {
 	}
 	return {
 		updateSettings,
+		syncTransforms,
 		testConnection,
 		currentTask
 	};
@@ -1154,6 +1180,33 @@ function remoteSyncResource(http) {
 const Session = z.object({ id: z.string() }).loose();
 //#endregion
 //#region src/metabase/domain/session-properties.ts
+const SessionProperties = z.object({
+	"setup-token": z.string().nullable(),
+	"has-user-setup": z.boolean(),
+	version: z.object({ tag: z.string() }).loose(),
+	"token-features": z.record(z.string(), z.boolean())
+}).loose();
+//#endregion
+//#region src/metabase/resources/session.ts
+function sessionResource(http) {
+	/** GET /api/session/properties */
+	async function properties() {
+		return http.requestJson("GET", "/api/session/properties", { schema: SessionProperties });
+	}
+	/** POST /api/session */
+	async function create(credentials) {
+		return http.requestJson("POST", "/api/session", {
+			body: credentials,
+			schema: Session
+		});
+	}
+	return {
+		properties,
+		create
+	};
+}
+//#endregion
+//#region src/metabase/domain/engine.ts
 const EngineFieldOption = z.object({
 	name: z.string(),
 	value: z.unknown()
@@ -1179,36 +1232,16 @@ const Engine = z.object({
 	"superseded-by": z.string().nullable(),
 	"creatable?": z.boolean().optional()
 }).loose();
-const SessionProperties = z.object({
-	"setup-token": z.string().nullable(),
-	"has-user-setup": z.boolean(),
-	version: z.object({ tag: z.string() }).loose(),
-	"token-features": z.record(z.string(), z.boolean()),
-	engines: z.record(z.string(), Engine)
-}).loose();
+const Engines = z.record(z.string(), Engine);
 //#endregion
-//#region src/metabase/resources/session.ts
-function sessionResource(http) {
-	/** GET /api/session/properties */
-	async function properties() {
-		return http.requestJson("GET", "/api/session/properties", { schema: SessionProperties });
-	}
-	/** POST /api/session */
-	async function create(credentials) {
-		return http.requestJson("POST", "/api/session", {
-			body: credentials,
-			schema: Session
-		});
-	}
-	return {
-		properties,
-		create
-	};
-}
+//#region src/metabase/domain/setting.ts
+const BooleanSetting = z.boolean();
 //#endregion
 //#region src/metabase/resources/setting.ts
 const PREMIUM_EMBEDDING_TOKEN_SETTING = "premium-embedding-token";
+const ENGINES_SETTING = "engines";
 const TRANSFORMS_ENABLED_SETTING = "transforms-enabled";
+const TRANSFORMS_SETUP_COMPLETE_SETTING = "transforms-setup-complete";
 function settingResource(http) {
 	/** PUT /api/setting/premium-embedding-token */
 	async function setPremiumEmbeddingToken(value) {
@@ -1218,9 +1251,19 @@ function settingResource(http) {
 	async function enableTransforms() {
 		await http.requestNoContent("PUT", `/api/setting/${TRANSFORMS_ENABLED_SETTING}`, { body: { value: true } });
 	}
+	/** GET /api/setting/transforms-setup-complete */
+	async function transformsDecided() {
+		return http.requestJson("GET", `/api/setting/${TRANSFORMS_SETUP_COMPLETE_SETTING}`, { schema: BooleanSetting });
+	}
+	/** GET /api/setting/engines; admins only, which the API key's user is. */
+	async function engines() {
+		return http.requestJson("GET", `/api/setting/${ENGINES_SETTING}`, { schema: Engines });
+	}
 	return {
 		setPremiumEmbeddingToken,
-		enableTransforms
+		enableTransforms,
+		transformsDecided,
+		engines
 	};
 }
 //#endregion
@@ -2443,13 +2486,6 @@ const PLUGINS_DIR = "plugins";
 const METABASE_STOP_GRACE_MS = 3e4;
 const DB_DIR = "metabase.db";
 const DB_FILE = "metabase.db";
-const STAGING_STORE_ENV = {
-	MB_RUN_MODE: "e2e",
-	MB_STORE_USE_STAGING: "true"
-};
-const ALLOW_LOCAL_WAREHOUSES_ENV = { MB_WAREHOUSE_ALLOWED_NETWORKS: "allow-all" };
-const NO_H2_SAMPLE_ENV = { MB_LOAD_SAMPLE_CONTENT: "false" };
-const NO_AUDIT_DB_ENV = { MB_INSTALL_ANALYTICS_DATABASE: "false" };
 function instanceUrl(port) {
 	return `http://localhost:${port}`;
 }
@@ -2458,10 +2494,11 @@ function serverEnv(options) {
 		MB_DB_FILE: options.dbFile,
 		MB_PLUGINS_DIR: options.pluginsDir,
 		MB_SITE_URL: instanceUrl(options.port),
-		...STAGING_STORE_ENV,
-		...ALLOW_LOCAL_WAREHOUSES_ENV,
-		...NO_H2_SAMPLE_ENV,
-		...NO_AUDIT_DB_ENV
+		MB_RUN_MODE: "e2e",
+		MB_STORE_USE_STAGING: "true",
+		MB_WAREHOUSE_ALLOWED_NETWORKS: "allow-all",
+		MB_LOAD_SAMPLE_CONTENT: "false",
+		MB_INSTALL_ANALYTICS_DATABASE: "false"
 	};
 }
 function jettyEnv(port) {
@@ -3018,12 +3055,12 @@ async function portClaims(state, runtime) {
 }
 //#endregion
 //#region src/steps/admin-user.ts
-const STEP_ID$9 = "admin-user";
+const STEP_ID$10 = "admin-user";
 const ADMIN_USER_KEYS = {
-	email: `${STEP_ID$9}.email`,
-	password: `${STEP_ID$9}.password`,
-	firstName: `${STEP_ID$9}.first-name`,
-	lastName: `${STEP_ID$9}.last-name`
+	email: `${STEP_ID$10}.email`,
+	password: `${STEP_ID$10}.password`,
+	firstName: `${STEP_ID$10}.first-name`,
+	lastName: `${STEP_ID$10}.last-name`
 };
 const GENERATED_ADMIN_EMAIL = "admin@metabase.local";
 const GENERATED_PASSWORD_BYTES = 24;
@@ -3038,7 +3075,7 @@ function generatePassword(random) {
 		if (DIGIT.test(candidate)) return candidate;
 	}
 }
-function hostDeps$13(ctx) {
+function hostDeps$14(ctx) {
 	return {
 		client: (baseUrl, auth) => createMetabaseClient(baseUrl, auth, ctx.signal),
 		instanceRunning: () => isInstanceRunning(ctx.state, hostRuntimeDeps(ctx.state.name, ctx.signal)),
@@ -3176,9 +3213,9 @@ async function recordExistingAdmin(ctx, variant, client, url) {
 	ctx.ui.success(`Admin user ${email} recorded`);
 	return "completed";
 }
-function adminUserStep(options, deps = hostDeps$13) {
+function adminUserStep(options, deps = hostDeps$14) {
 	return {
-		id: STEP_ID$9,
+		id: STEP_ID$10,
 		title: "Create the admin user",
 		redoHint: "An instance keeps the admin it was set up with; `rde credentials` shows it.",
 		async detect(ctx) {
@@ -3559,14 +3596,14 @@ function mbTool(runner) {
 }
 //#endregion
 //#region src/steps/api-key.ts
-const STEP_ID$8 = "api-key";
+const STEP_ID$9 = "api-key";
 const API_KEY_KEYS = {
-	email: `${STEP_ID$8}.email`,
-	password: `${STEP_ID$8}.password`,
-	profile: `${STEP_ID$8}.profile`
+	email: `${STEP_ID$9}.email`,
+	password: `${STEP_ID$9}.password`,
+	profile: `${STEP_ID$9}.profile`
 };
 const ADMINISTRATORS_GROUP_NAME = "Administrators";
-function hostDeps$12(ctx) {
+function hostDeps$13(ctx) {
 	return {
 		client: (baseUrl, auth) => createMetabaseClient(baseUrl, auth, ctx.signal),
 		runner: processRunner(ctx.signal)
@@ -3685,9 +3722,9 @@ function usageNote(profile) {
 	if (profile === "default") return `${mbCommand(profile)} <command> uses this instance`;
 	return `${mbCommand(profile)} <command>\nMB_PROFILE=${profile} for agents and scripts`;
 }
-function apiKeyStep(deps = hostDeps$12) {
+function apiKeyStep(deps = hostDeps$13) {
 	return {
-		id: STEP_ID$8,
+		id: STEP_ID$9,
 		title: "Connect the Metabase CLI",
 		redoHint: "`rde status` shows the mb profile it uses.",
 		async detect(ctx) {
@@ -4646,20 +4683,29 @@ function syncWithHint(database) {
 function existingDatabaseLines(databases) {
 	return databases.map((db) => `${db.name} (${db.engine}, ${syncWithHint(db)})`);
 }
+function unconnectedStubsLine(stubs) {
+	return `Not connected yet, used by your content: ${stubs.map((stub) => stub.name).join(", ")}; \`rde db add\` connects one`;
+}
+function listingStatus(entry) {
+	if (entry.stub) return "not connected, your content uses it; `rde db add` connects it";
+	return entry.initialSyncStatus === null ? "missing on the server" : syncLabel(entry.initialSyncStatus);
+}
 function databaseListingLines(listing) {
 	if (listing.length === 0) return ["No databases connected yet; run `rde db add`"];
 	return listing.map((entry) => {
-		const sync = entry.initialSyncStatus === null ? "missing on the server" : syncLabel(entry.initialSyncStatus);
-		return `${entry.name}  ${entry.engine}  id ${entry.id}  ${sync}`;
+		const engine = entry.stub ? "?" : entry.engine;
+		return `${entry.name}  ${engine}  id ${entry.id}  ${listingStatus(entry)}`;
 	});
 }
 //#endregion
 //#region src/steps/databases/flow.ts
 const DATABASE_KEYS = {
 	connection: "databases.connection",
-	skip: "databases.skip"
+	skip: "databases.skip",
+	stubs: "databases.stubs"
 };
 const DATABASE_KEY_NAMES = {
+	connection: "connection",
 	detectedEngine: "detected-engine",
 	engine: "engine",
 	mode: "mode",
@@ -4703,11 +4749,13 @@ const RSA_KEY_UNAVAILABLE_ERROR = "RSA public key is not available";
 const KEY_RETRIEVAL_NOTE = "allowPublicKeyRetrieval=true is added: MySQL 8 needs it to log in to a local server without SSL; to leave it out, paste a connection string with allowPublicKeyRetrieval=false instead";
 const KEY_RETRIEVAL_HINT = "MySQL 8 without SSL needs allowPublicKeyRetrieval=true: go back and add ?allowPublicKeyRetrieval=true to the connection string, or turn on SSL";
 const CONNECTION_PLACEHOLDER = "leave empty to skip";
+const STUB_CONNECTION_PLACEHOLDER = "leave empty to pick the engine";
 const START_SCREEN = {
 	engine: "pick-engine",
 	"connection-string": "connection-string"
 };
 const FRESH$1 = {
+	target: null,
 	engine: null,
 	uri: null,
 	pasted: null,
@@ -4717,6 +4765,35 @@ const FRESH$1 = {
 	name: null,
 	fieldErrors: null
 };
+function targeting(stub) {
+	return {
+		...FRESH$1,
+		target: stub,
+		name: stub.name
+	};
+}
+function restart(model) {
+	return model.target === null ? FRESH$1 : targeting(model.target);
+}
+function nextStub(run, model) {
+	const stub = run.queue.shift();
+	if (stub !== void 0) return {
+		type: "next",
+		to: "connection-string",
+		model: targeting(stub)
+	};
+	return run.created.length > 0 ? {
+		type: "next",
+		to: "another",
+		model
+	} : {
+		type: "done",
+		model
+	};
+}
+function stubNamed(run, name) {
+	return run.stubs.find((stub) => stub.name === name) ?? null;
+}
 function ordinalOf(run) {
 	return run.created.length + 1;
 }
@@ -4786,20 +4863,60 @@ async function pickDetectedEngine(run, candidates) {
 	if (entry === void 0) throw new Error(`engine ${picked} was not offered`);
 	return entry;
 }
+function pickStubsScreen(run) {
+	return async (model) => {
+		const picked = await run.deps.prompts.multiselect({
+			key: DATABASE_KEYS.stubs,
+			message: "Your content uses these databases, not connected yet. Pick the ones to connect now (space picks, Enter goes on; the rest wait for `rde db add`)",
+			choices: run.stubs.map((stub) => ({
+				value: stub.id,
+				label: stub.name
+			})),
+			required: false
+		});
+		if (picked.length > 0) {
+			run.queue = run.stubs.filter((stub) => picked.includes(stub.id));
+			return nextStub(run, model);
+		}
+		if (run.deps.start === "connection-string" && run.created.length === 0) return {
+			type: "done",
+			model
+		};
+		return {
+			type: "next",
+			to: "pick-engine",
+			model: FRESH$1
+		};
+	};
+}
+function connectionQuestion(run, target) {
+	if (target === null) return {
+		key: DATABASE_KEYS.connection,
+		message: "Connection string of your database (Enter to skip; `rde db add` connects one later)",
+		placeholder: CONNECTION_PLACEHOLDER
+	};
+	return {
+		key: databaseKey(ordinalOf(run), "connection"),
+		message: `Connection string of ${target.name} (Enter to pick its engine instead)`,
+		placeholder: STUB_CONNECTION_PLACEHOLDER
+	};
+}
 function connectionStringScreen(run) {
 	return async (model) => {
 		let draft = model.uri;
 		for (;;) {
 			const uri = (await run.deps.prompts.text({
-				key: DATABASE_KEYS.connection,
-				message: "Connection string of your database (Enter to skip; `rde db add` connects one later)",
-				placeholder: CONNECTION_PLACEHOLDER,
+				...connectionQuestion(run, model.target),
 				...draft !== null && { initialValue: draft }
 			})).trim();
 			draft = uri;
-			if (uri.length === 0) return {
+			if (uri.length === 0) return model.target === null ? {
 				type: "done",
 				model
+			} : {
+				type: "next",
+				to: "pick-engine",
+				model: restart(model)
 			};
 			const candidates = detectEngine(uri).map((key) => run.deps.catalog.entry(key)).filter(isCreatableEntry);
 			const [first, ...others] = candidates;
@@ -4808,7 +4925,7 @@ function connectionStringScreen(run) {
 				return {
 					type: "next",
 					to: "pick-engine",
-					model: FRESH$1
+					model: restart(model)
 				};
 			}
 			const engine = others.length === 0 ? first : await pickDetectedEngine(run, candidates);
@@ -4822,7 +4939,7 @@ function connectionStringScreen(run) {
 				return {
 					type: "next",
 					to: "pick-engine",
-					model: FRESH$1
+					model: restart(model)
 				};
 			}
 			return toReview(run, model, {
@@ -4832,12 +4949,16 @@ function connectionStringScreen(run) {
 		}
 	};
 }
+function finishLabel(run, model) {
+	if (model.target !== null) return `Leave ${model.target.name} unconnected`;
+	return run.deps.existingCount + run.created.length > 0 ? "Finish" : "Skip for now";
+}
 function pickEngineScreen(run) {
 	return async (model) => {
 		const total = run.deps.existingCount + run.created.length;
 		const finishChoice = {
 			value: FINISH,
-			label: total > 0 ? "Finish" : "Skip for now"
+			label: finishLabel(run, model)
 		};
 		for (;;) {
 			const picked = await run.deps.prompts.select({
@@ -4846,6 +4967,7 @@ function pickEngineScreen(run) {
 				choices: [...run.deps.catalog.list().map(engineChoice), finishChoice],
 				...model.engine !== null && { initialValue: model.engine.key }
 			});
+			if (picked === "finish" && model.target !== null) return nextStub(run, model);
 			if (picked === "finish") {
 				if (total > 0 || await confirmSkip(run)) return {
 					type: "done",
@@ -4863,7 +4985,7 @@ function pickEngineScreen(run) {
 				type: "next",
 				to: "paste-uri",
 				model: model.engine?.key === entry.key ? model : {
-					...FRESH$1,
+					...restart(model),
 					engine: entry
 				}
 			};
@@ -4894,6 +5016,10 @@ async function chooseAfterParseError(run, engine, uri, error) {
 	if (entry === void 0) throw new Error(`engine ${picked} was not offered`);
 	return entry;
 }
+function reviewName(model, sameString) {
+	if (model.target !== null) return model.target.name;
+	return sameString ? model.name : null;
+}
 function toReview(run, model, connection) {
 	const mapped = mapDatabaseValues(connection.parsed);
 	const sameString = model.uri === connection.parsed.uri;
@@ -4901,13 +5027,14 @@ function toReview(run, model, connection) {
 		type: "next",
 		to: "review",
 		model: {
+			target: model.target,
 			engine: connection.engine,
 			uri: connection.parsed.uri,
 			pasted: mapped.details,
 			details: mapped.details,
 			failure: null,
 			suggestedName: defaultDisplayName(mapped, connection.parsed, connection.engine),
-			name: sameString ? model.name : null,
+			name: reviewName(model, sameString),
 			fieldErrors: null
 		}
 	};
@@ -5050,6 +5177,33 @@ async function fixReportedFields(run, fields, details, errors) {
 	}
 	return current;
 }
+function reviewQuestion(target, name) {
+	const edit = {
+		value: "edit",
+		label: "Edit a field"
+	};
+	if (target !== null) return {
+		message: `Connect ${name}?`,
+		choices: [{
+			value: "test",
+			label: "Test and connect"
+		}, edit]
+	};
+	return {
+		message: `Add ${name}?`,
+		choices: [
+			{
+				value: "test",
+				label: "Test and add"
+			},
+			edit,
+			{
+				value: "rename",
+				label: "Change the display name"
+			}
+		]
+	};
+}
 function reviewScreen(run) {
 	const review = reviewAttempt(run);
 	return (model) => model.failure === null ? review(model) : orFailure(model.failure, () => review({
@@ -5075,21 +5229,7 @@ function reviewAttempt(run) {
 			if (name === null) name = await promptName(run, current, chosen.engine);
 			const action = await run.deps.prompts.selectOrBack({
 				key: databaseKey(ordinalOf(run), "action"),
-				message: `Add ${name}?`,
-				choices: [
-					{
-						value: "test",
-						label: "Test and add"
-					},
-					{
-						value: "edit",
-						label: "Edit a field"
-					},
-					{
-						value: "rename",
-						label: "Change the display name"
-					}
-				]
+				...reviewQuestion(model.target, name)
 			});
 			if (action === BACK) return { type: "back" };
 			if (action === "edit") {
@@ -5168,26 +5308,44 @@ function testScreen(run) {
 function isRejectedDetails(error) {
 	return error instanceof MetabaseApiError && error.status === BAD_REQUEST_STATUS$1;
 }
+function commitFor(run, stub) {
+	if (stub === null) return {
+		verb: "add",
+		progress: "Adding",
+		past: "Added",
+		send: (request) => run.deps.database.create(request)
+	};
+	return {
+		verb: "connect",
+		progress: "Connecting",
+		past: "Connected",
+		send: ({ engine, details }) => run.deps.database.connect(stub.id, {
+			engine,
+			details
+		})
+	};
+}
 function createScreen(run) {
 	return async (model) => {
 		const chosen = requireEngine(run, model);
 		if (model.name === null) throw new Error("no display name before create");
-		const spinner = run.deps.ui.spinner(`Adding ${model.name}…`);
+		const commit = commitFor(run, model.target ?? stubNamed(run, model.name));
+		const spinner = run.deps.ui.spinner(`${commit.progress} ${model.name}…`);
 		let database;
 		try {
-			database = await run.deps.database.create({
+			database = await commit.send({
 				name: model.name,
 				engine: chosen.engine.key,
 				details: sentDetails(run, chosen, model.details).details
 			});
 		} catch (error) {
 			if (!isRejectedDetails(error)) {
-				spinner.fail(`Could not add ${model.name}`);
+				spinner.fail(`Could not ${commit.verb} ${model.name}`);
 				throw error;
 			}
 			spinner.fail(error.message);
 			keyRetrievalHint(run, chosen, error.message);
-			const failure = `Metabase could not add ${model.name}: ${error.message}`;
+			const failure = `Metabase could not ${commit.verb} ${model.name}: ${error.message}`;
 			return {
 				type: "next",
 				to: "review",
@@ -5199,14 +5357,15 @@ function createScreen(run) {
 			};
 		}
 		run.created.push(database);
-		spinner.stop(`Added ${database.name}. Initial sync is running in the background; \`rde status\` shows progress.`);
+		run.stubs = run.stubs.filter((candidate) => candidate.id !== database.id);
+		spinner.stop(`${commit.past} ${database.name}. Initial sync is running in the background; \`rde status\` shows progress.`);
 		run.added.push(addedDatabase(chosen, model, model.name));
 		await run.deps.onCreated(database);
-		return {
+		return model.target === null ? {
 			type: "next",
 			to: "another",
 			model
-		};
+		} : nextStub(run, model);
 	};
 }
 function anotherScreen(run) {
@@ -5227,18 +5386,24 @@ function anotherScreen(run) {
 		};
 		return {
 			type: "next",
-			to: "pick-engine",
+			to: offersStubs(run) ? "pick-stubs" : "pick-engine",
 			model: FRESH$1
 		};
 	};
 }
+function offersStubs(run) {
+	return run.deps.offerStubs && run.stubs.length > 0;
+}
 async function runDatabaseFlow(deps) {
 	const run = {
 		deps,
 		created: [],
-		added: []
+		added: [],
+		stubs: [...deps.stubs],
+		queue: []
 	};
 	await runFlow({
+		"pick-stubs": pickStubsScreen(run),
 		"connection-string": connectionStringScreen(run),
 		"pick-engine": pickEngineScreen(run),
 		"paste-uri": pasteUriScreen(run),
@@ -5246,10 +5411,11 @@ async function runDatabaseFlow(deps) {
 		test: testScreen(run),
 		create: createScreen(run),
 		another: anotherScreen(run)
-	}, START_SCREEN[deps.start], FRESH$1);
+	}, offersStubs(run) ? "pick-stubs" : START_SCREEN[deps.start], FRESH$1);
 	return {
 		created: run.created,
-		added: run.added
+		added: run.added,
+		stubsLeft: run.stubs
 	};
 }
 //#endregion
@@ -5305,8 +5471,9 @@ function gitTool(runner) {
 	}
 	async function isRepo(dir) {
 		if (!await directoryExists(dir)) return false;
-		const result = await runner.run(GIT, ["rev-parse", "--is-inside-work-tree"], { cwd: dir });
-		return result.exitCode === 0 && result.stdout.trim() === "true";
+		const result = await runner.run(GIT, ["rev-parse", "--show-toplevel"], { cwd: dir });
+		if (result.exitCode !== 0) return false;
+		return result.stdout.trim() === await promises.realpath(dir);
 	}
 	async function initBare(path, options) {
 		await git([
@@ -5419,13 +5586,13 @@ function gitTool(runner) {
 }
 //#endregion
 //#region src/steps/git-sync.ts
-const STEP_ID$7 = "git-sync";
+const STEP_ID$8 = "git-sync";
 const GIT_SYNC_KEYS = {
-	location: `${STEP_ID$7}.location`,
-	path: `${STEP_ID$7}.path`,
-	remote: `${STEP_ID$7}.remote`,
-	url: `${STEP_ID$7}.url`,
-	token: `${STEP_ID$7}.token`
+	location: `${STEP_ID$8}.location`,
+	path: `${STEP_ID$8}.path`,
+	remote: `${STEP_ID$8}.remote`,
+	url: `${STEP_ID$8}.url`,
+	token: `${STEP_ID$8}.token`
 };
 const BARE_REPO_NAME = "content.git";
 const DEFAULT_BRANCH = "main";
@@ -5455,7 +5622,11 @@ const TERMINAL_TASK_STATUSES = /* @__PURE__ */ new Set([
 	"timed-out",
 	"conflict"
 ]);
-function hostDeps$11(ctx) {
+const SYNC_MODE_SETTINGS = {
+	"remote-sync-type": "read-write",
+	"remote-sync-transforms": true
+};
+function hostDeps$12(ctx) {
 	return {
 		runner: processRunner(ctx.signal),
 		client: (baseUrl, auth) => createMetabaseClient(baseUrl, auth, ctx.signal),
@@ -5746,7 +5917,7 @@ async function configureLocalBare(run, runtime, workdir) {
 		},
 		settings: {
 			"remote-sync-url": bareUrlFor(runtime, barePath),
-			"remote-sync-type": "read-write",
+			...SYNC_MODE_SETTINGS,
 			"remote-sync-branch": prepared.branch
 		}
 	};
@@ -5789,7 +5960,7 @@ async function configureHosted(run, workdir, url) {
 		settings: {
 			"remote-sync-url": url,
 			"remote-sync-token": token,
-			"remote-sync-type": "read-write",
+			...SYNC_MODE_SETTINGS,
 			"remote-sync-branch": prepared.branch
 		}
 	};
@@ -5862,6 +6033,7 @@ async function importExistingContent(run, gitRemote) {
 	}
 	spinner.stop("Import finished");
 	reportImport(run, outcome);
+	await run.client.remoteSync.syncTransforms();
 }
 const SHELL_SAFE = /^[\w./-]+$/;
 function shellWord(value) {
@@ -5922,15 +6094,15 @@ async function runGitSync(ctx, deps) {
 	ctx.ui.note(usageLines$1(ctx.state, remote.gitRemote).join("\n"), "Working with the repository");
 	return "completed";
 }
-function gitSyncStep(deps = hostDeps$11) {
+function gitSyncStep(deps = hostDeps$12) {
 	return {
-		id: STEP_ID$7,
+		id: STEP_ID$8,
 		title: "Connect a git repository",
 		redoHint: "`rde init --only git-sync` with it points Metabase's remote sync at that repository instead.",
 		async detect(ctx) {
 			if (!hasRemoteSync(ctx.state.license)) return "not-applicable";
-			if (ctx.state.steps[STEP_ID$7]?.status === "skipped") return "not-applicable";
-			if (ctx.state.gitRemote === null || ctx.state.steps[STEP_ID$7]?.status !== "done") return "todo";
+			if (ctx.state.steps[STEP_ID$8]?.status === "skipped") return "not-applicable";
+			if (ctx.state.gitRemote === null || ctx.state.steps[STEP_ID$8]?.status !== "done") return "todo";
 			try {
 				return (await mbTool(deps(ctx).runner).gitSyncStatus(ctx.state.mbProfile)).branch === null ? "todo" : "done";
 			} catch (error) {
@@ -6071,12 +6243,12 @@ function skillsCli(runner) {
 }
 //#endregion
 //#region src/steps/agents-skills.ts
-const STEP_ID$6 = "agents-skills";
-const AGENTS_SKILLS_KEYS = { agents: `${STEP_ID$6}.agents` };
+const STEP_ID$7 = "agents-skills";
+const AGENTS_SKILLS_KEYS = { agents: `${STEP_ID$7}.agents` };
 const MECHANICS_NOTE = "The rde skill's mechanics come from `mb skills get <name>` at runtime, so nothing else needs installing.";
 const REQUIRED_SKILL_NAMES = [...DATA_APP_SKILL_NAMES, ...RDE_SOURCE_SKILL_NAMES];
 const DETECT_AGENTS = { kind: "detected" };
-function hostDeps$10(ctx) {
+function hostDeps$11(ctx) {
 	return {
 		runner: processRunner(ctx.signal),
 		probe: hostAgentProbe(),
@@ -6165,19 +6337,19 @@ async function selectAgents(ctx, all, options) {
 function skipLine(all, source) {
 	switch (source) {
 		case "override":
-		case "chosen": return `Skipping the skills; run \`rde init --only ${STEP_ID$6}\` to install it later`;
-		case "detected": return `No coding agent found (${displayNames(all)}); run \`rde init --only ${STEP_ID$6} --agents <name>\` once one is installed`;
+		case "chosen": return `Skipping the skills; run \`rde init --only ${STEP_ID$7}\` to install it later`;
+		case "detected": return `No coding agent found (${displayNames(all)}); run \`rde init --only ${STEP_ID$7} --agents <name>\` once one is installed`;
 	}
 }
-function agentsSkillsStep(options, deps = hostDeps$10) {
+function agentsSkillsStep(options, deps = hostDeps$11) {
 	return {
-		id: STEP_ID$6,
+		id: STEP_ID$7,
 		title: "Install the rde and data-app skills for your coding agents",
 		redoHint: "`rde init --only agents-skills` with it installs the skills for those agents.",
 		async detect(ctx) {
 			const resolved = deps(ctx);
 			const detected = detectedOnly(await detectAgents(resolved.probe));
-			if (detected.length === 0) return ctx.state.steps[STEP_ID$6]?.status === "skipped" ? "not-applicable" : "todo";
+			if (detected.length === 0) return ctx.state.steps[STEP_ID$7]?.status === "skipped" ? "not-applicable" : "todo";
 			return missingSkills(await skillsCli(resolved.runner).list(), detected).length === 0 ? "done" : "todo";
 		},
 		async run(ctx) {
@@ -6217,7 +6389,7 @@ function agentsSkillsStep(options, deps = hostDeps$10) {
 }
 //#endregion
 //#region src/steps/databases.ts
-const STEP_ID$5 = "databases";
+const STEP_ID$6 = "databases";
 const SAMPLE_STANDS_IN = { request: "sample-stands-in" };
 function hostDatabasesDeps(signal) {
 	return {
@@ -6226,7 +6398,7 @@ function hostDatabasesDeps(signal) {
 		now: () => /* @__PURE__ */ new Date()
 	};
 }
-function isNotServingYet$1(error) {
+function isNotServingYet$2(error) {
 	return error instanceof MetabaseUnreachableError || error instanceof MetabaseInitializingError;
 }
 function requireApiKey$2(state, apiKey) {
@@ -6255,14 +6427,15 @@ function authenticatedClient(state, apiKey, deps) {
 	});
 }
 async function listDatabases(state, apiKey, deps) {
-	const listed = await authenticatedClient(state, apiKey, deps).database.list();
+	const listed = await authenticatedClient(state, apiKey, deps).database.listWithStubs();
 	const records = new Map(state.databases.map((record) => [record.id, record]));
 	const onServer = listed.data.map((database) => ({
 		id: database.id,
 		name: database.name,
 		engine: database.engine,
 		initialSyncStatus: database.initial_sync_status,
-		createdAt: records.get(database.id)?.createdAt ?? null
+		createdAt: records.get(database.id)?.createdAt ?? null,
+		stub: isStub(database)
 	}));
 	const serverIds = new Set(listed.data.map((database) => database.id));
 	const missing = state.databases.filter((record) => !serverIds.has(record.id)).map((record) => ({
@@ -6270,24 +6443,27 @@ async function listDatabases(state, apiKey, deps) {
 		name: record.name,
 		engine: record.engine,
 		initialSyncStatus: null,
-		createdAt: record.createdAt
+		createdAt: record.createdAt,
+		stub: false
 	}));
 	return [...onServer, ...missing];
 }
-async function connectDatabases(ctx, deps, start) {
+async function connectDatabases(ctx, deps, opening) {
 	const configured = requireConfiguredRuntime(ctx.state);
 	const client = authenticatedClient(ctx.state, ctx.secrets.apiKey, deps);
-	const properties = await client.session.properties();
-	const existing = await client.database.list();
-	if (existing.data.length > 0) ctx.ui.note(existingDatabaseLines(existing.data).join("\n"), "Connected databases");
+	const engines = await client.setting.engines();
+	const listed = await client.database.listWithStubs();
+	const existing = listed.data.filter((database) => !isStub(database));
+	if (existing.length > 0) ctx.ui.note(existingDatabaseLines(existing).join("\n"), "Connected databases");
 	const result = await runDatabaseFlow({
-		start,
+		...opening,
+		stubs: listed.data.filter(isStub),
 		prompts: ctx.prompts,
 		ui: ctx.ui,
-		catalog: engineCatalog(properties.engines),
+		catalog: engineCatalog(engines),
 		hostAlias: hostAliasOf(configured.runtime),
 		database: client.database,
-		existingCount: existing.data.length,
+		existingCount: existing.length,
 		readTextFile: deps.readTextFile,
 		onCreated: async (database) => {
 			const record = toRecord$1(database, deps.now().toISOString());
@@ -6297,27 +6473,34 @@ async function connectDatabases(ctx, deps, start) {
 			});
 		}
 	});
+	if (result.stubsLeft.length > 0) ctx.ui.info(unconnectedStubsLine(result.stubsLeft));
 	return {
-		existing: existing.data.length,
+		existing: existing.length,
 		created: result.created.length,
 		added: result.added
 	};
 }
-async function addDatabases(ctx, deps) {
-	const connected = await connectDatabases(ctx, deps, "engine");
+async function addDatabases(ctx, deps, options) {
+	const connected = await connectDatabases(ctx, deps, {
+		start: "engine",
+		...options
+	});
 	return {
 		outcome: connected.existing + connected.created > 0 ? "completed" : "skipped",
 		result: { addedDatabases: connected.added }
 	};
 }
 async function askForOwnDatabase(ctx, deps) {
-	const connected = await connectDatabases(ctx, deps, "connection-string");
+	const connected = await connectDatabases(ctx, deps, {
+		start: "connection-string",
+		offerStubs: true
+	});
 	return {
 		outcome: connected.created > 0 ? "completed" : "skipped",
 		result: { addedDatabases: connected.added }
 	};
 }
-function hostDeps$9(ctx) {
+function hostDeps$10(ctx) {
 	return {
 		...hostDatabasesDeps(ctx.signal),
 		instanceRunning: () => isInstanceRunning(ctx.state, hostRuntimeDeps(ctx.state.name, ctx.signal))
@@ -6327,15 +6510,15 @@ function sampleDatabaseId(state) {
 	return state.sampleDatabase === null ? null : state.sampleDatabase.databaseId;
 }
 function skippedBefore(state) {
-	return state.steps[STEP_ID$5]?.status === "skipped";
+	return state.steps[STEP_ID$6]?.status === "skipped";
 }
 function ownDatabaseIds(state) {
 	const sampleId = sampleDatabaseId(state);
 	return new Set(state.databases.filter((record) => record.id !== sampleId).map((record) => record.id));
 }
-function databasesStep(options, deps = hostDeps$9) {
+function databasesStep(options, deps = hostDeps$10) {
 	return {
-		id: STEP_ID$5,
+		id: STEP_ID$6,
 		title: "Connect your databases",
 		redoHint: "Connect another with `rde db add --url <connection string>`.",
 		async detect(ctx) {
@@ -6358,14 +6541,14 @@ function databasesStep(options, deps = hostDeps$9) {
 			try {
 				return (await client.database.list()).data.some((database) => isOwn(database.id)) ? "done" : "todo";
 			} catch (error) {
-				if (isNotServingYet$1(error) || isRejectedCredential(error)) return "todo";
+				if (isNotServingYet$2(error) || isRejectedCredential(error)) return "todo";
 				throw error;
 			}
 		},
 		async run(ctx) {
 			switch (options.request) {
 				case "ask-once": return askForOwnDatabase(ctx, deps(ctx));
-				case "named": return addDatabases(ctx, deps(ctx));
+				case "named": return addDatabases(ctx, deps(ctx), { offerStubs: false });
 				case "sample-stands-in": return { outcome: "skipped" };
 			}
 		}
@@ -6373,7 +6556,7 @@ function databasesStep(options, deps = hostDeps$9) {
 }
 //#endregion
 //#region src/steps/install-mb.ts
-const STEP_ID$4 = "install-mb";
+const STEP_ID$5 = "install-mb";
 const MIN_MB_VERSION = "0.3.0";
 const MB_RANGE = `>=${MIN_MB_VERSION}`;
 function installedWith(scriptPath) {
@@ -6382,7 +6565,7 @@ function installedWith(scriptPath) {
 function rdeInstalledWith() {
 	return installedWith(process.argv[1]);
 }
-function hostDeps$8(ctx) {
+function hostDeps$9(ctx) {
 	return {
 		runner: processRunner(ctx.signal),
 		installedWith: rdeInstalledWith(),
@@ -6498,9 +6681,9 @@ async function stillWrong(install, after, deps) {
 		`${stillWrongAdvice(diagnosis)}.`
 	].join(" "));
 }
-function installMbStep(deps = hostDeps$8) {
+function installMbStep(deps = hostDeps$9) {
 	return {
-		id: STEP_ID$4,
+		id: STEP_ID$5,
 		title: "Install the Metabase CLI",
 		async detect(ctx) {
 			const found = await inspectMb(deps(ctx).runner);
@@ -6526,11 +6709,11 @@ function installMbStep(deps = hostDeps$8) {
 }
 //#endregion
 //#region src/steps/license.ts
-const STEP_ID$3 = "license";
-const LICENSE_KEYS = { token: `${STEP_ID$3}.token` };
+const STEP_ID$4 = "license";
+const LICENSE_KEYS = { token: `${STEP_ID$4}.token` };
 const TOKEN_PATTERN = /^[0-9a-f]{64}$/i;
 const NOT_FOUND_STATUS$2 = 404;
-function hostDeps$7(ctx) {
+function hostDeps$8(ctx) {
 	return {
 		client: (baseUrl, auth) => createMetabaseClient(baseUrl, auth, ctx.signal),
 		runner: processRunner(ctx.signal),
@@ -6553,13 +6736,13 @@ function activeLabel(status) {
 	const plan = status["plan-alias"];
 	return plan === void 0 ? "License active" : `License active (plan ${plan})`;
 }
-function licenseStep(deps = hostDeps$7) {
+function licenseStep(deps = hostDeps$8) {
 	return {
-		id: STEP_ID$3,
+		id: STEP_ID$4,
 		title: "Activate your license",
 		redoHint: "`rde init --from license` with it activates the license and runs the steps after it again.",
 		async detect(ctx) {
-			if (ctx.state.steps[STEP_ID$3]?.status === "skipped") return "not-applicable";
+			if (ctx.state.steps[STEP_ID$4]?.status === "skipped") return "not-applicable";
 			const configured = configuredRuntime(ctx.state);
 			if (configured === null || ctx.secrets.apiKey === null) return "todo";
 			const resolved = deps(ctx);
@@ -6650,7 +6833,7 @@ const PLATFORMS = {
 		javaHint: `Install Java 21 or newer with your distribution's package manager (openjdk-21-jre) or from https://adoptium.net`
 	}
 };
-function hostDeps$6(ctx) {
+function hostDeps$7(ctx) {
 	const runner = processRunner(ctx.signal);
 	return {
 		platform: process.platform,
@@ -6772,7 +6955,7 @@ function checkLine(check) {
 function checkLines(checks) {
 	return checks.map(checkLine);
 }
-function preflightStep(deps = hostDeps$6) {
+function preflightStep(deps = hostDeps$7) {
 	return {
 		id: "preflight",
 		title: "Check this machine",
@@ -6791,7 +6974,7 @@ function preflightStep(deps = hostDeps$6) {
 }
 //#endregion
 //#region src/steps/runtime.ts
-const STEP_ID$2 = "runtime";
+const STEP_ID$3 = "runtime";
 const MIN_PORT = 1;
 const MAX_PORT = 65535;
 const PORT_PATTERN = /^\d+$/;
@@ -6805,7 +6988,7 @@ const NO_RUNTIME_FLAGS = {
 	jar: null,
 	port: null
 };
-function hostDeps$5(ctx) {
+function hostDeps$6(ctx) {
 	return {
 		runtime: hostRuntimeDeps(ctx.state.name, ctx.signal),
 		releases: releaseLookup(ctx.signal)
@@ -6934,9 +7117,9 @@ async function persistedRuntime(ctx, options, deps) {
 	});
 	return chosen;
 }
-function runtimeStep(options, deps = hostDeps$5) {
+function runtimeStep(options, deps = hostDeps$6) {
 	return {
-		id: STEP_ID$2,
+		id: STEP_ID$3,
 		title: "Install Metabase",
 		redoHint: "Move it with `rde start --port`, or change its Metabase with `rde upgrade --to`.",
 		async detect(ctx) {
@@ -6962,11 +7145,11 @@ function runtimeStep(options, deps = hostDeps$5) {
 }
 //#endregion
 //#region src/steps/sample-database.ts
-const STEP_ID$1 = "sample-database";
+const STEP_ID$2 = "sample-database";
 const SAMPLE_DATABASE_DISPLAY_NAME = "Sample Database";
 const POSTGRES_ENGINE = "postgres";
 const NOT_FOUND_STATUS$1 = 404;
-function hostDeps$4(ctx) {
+function hostDeps$5(ctx) {
 	return {
 		runtime: hostRuntimeDeps(ctx.state.name, ctx.signal),
 		client: (baseUrl, auth) => createMetabaseClient(baseUrl, auth, ctx.signal),
@@ -6974,7 +7157,7 @@ function hostDeps$4(ctx) {
 		now: () => /* @__PURE__ */ new Date()
 	};
 }
-function isNotServingYet(error) {
+function isNotServingYet$1(error) {
 	return error instanceof MetabaseUnreachableError || error instanceof MetabaseInitializingError;
 }
 function isNotFound$2(error) {
@@ -7117,11 +7300,11 @@ async function connectDatabase(ctx, choice, configured, client, deps) {
 	return database;
 }
 function usageLines(record) {
-	return [`psql "${sampleDatabaseUrl(record.port)}"`, "Transforms are enabled; this database is where they can write."].join("\n");
+	return [`psql "${sampleDatabaseUrl(record.port)}"`, "Transforms can write to this database."].join("\n");
 }
-function sampleDatabaseStep(deps = hostDeps$4) {
+function sampleDatabaseStep(deps = hostDeps$5) {
 	return {
-		id: STEP_ID$1,
+		id: STEP_ID$2,
 		title: "Connect a sample database",
 		async detect(ctx) {
 			const resolved = deps(ctx);
@@ -7137,7 +7320,7 @@ function sampleDatabaseStep(deps = hostDeps$4) {
 			try {
 				return await recordedDatabase(record, client) === null ? "todo" : "done";
 			} catch (error) {
-				if (isNotServingYet(error) || isRejectedCredential(error)) return "todo";
+				if (isNotServingYet$1(error) || isRejectedCredential(error)) return "todo";
 				throw error;
 			}
 		},
@@ -7149,16 +7332,13 @@ function sampleDatabaseStep(deps = hostDeps$4) {
 			if (!docker.available) throw new ConfigError(`the sample database runs in Docker, which is not available: ${docker.reason}`);
 			const persisted = await persistedRecord(ctx, resolved);
 			const record = await installAndStart(ctx, sampleDatabaseContainer(persisted.record, resolved.runtime.docker, resolved.runtime.rdeHome), persisted.record, resolved);
-			const choice = {
+			await connectDatabase(ctx, {
 				...persisted,
 				record
-			};
-			const client = resolved.client(configured.url, {
+			}, configured, resolved.client(configured.url, {
 				kind: "api-key",
 				key: apiKey
-			});
-			await connectDatabase(ctx, choice, configured, client, resolved);
-			await client.setting.enableTransforms();
+			}), resolved);
 			ctx.ui.note(usageLines(record), "Sample database");
 			return { outcome: "completed" };
 		}
@@ -7169,7 +7349,7 @@ const DEFAULT_HEALTH_TIMING = { timeoutMs: 3e5 };
 //#region src/steps/start-metabase.ts
 const LOG_TAIL_ON_TIMEOUT = 30;
 const PERCENT = 100;
-function hostDeps$3(ctx) {
+function hostDeps$4(ctx) {
 	return {
 		runtime: hostRuntimeDeps(ctx.state.name, ctx.signal),
 		client: (baseUrl, auth) => createMetabaseClient(baseUrl, auth, ctx.signal),
@@ -7213,7 +7393,7 @@ async function startRuntime(ctx, runtime, deps) {
 		throw error;
 	}
 }
-function startMetabaseStep(deps = hostDeps$3) {
+function startMetabaseStep(deps = hostDeps$4) {
 	return {
 		id: "start-metabase",
 		title: "Start Metabase",
@@ -7273,9 +7453,9 @@ function startMetabaseStep(deps = hostDeps$3) {
 }
 //#endregion
 //#region src/steps/summary.ts
-const STEP_ID = "summary";
+const STEP_ID$1 = "summary";
 const GIT_SYNC_STEP_ID = "git-sync";
-function hostDeps$2(ctx) {
+function hostDeps$3(ctx) {
 	return {
 		client: (baseUrl, auth) => createMetabaseClient(baseUrl, auth, ctx.signal),
 		runner: processRunner(ctx.signal),
@@ -7299,14 +7479,21 @@ async function databaseLines$1(state, apiKey, deps) {
 		databases = (await deps.client(state.url, {
 			kind: "api-key",
 			key: apiKey
-		}).database.list()).data;
+		}).database.listWithStubs()).data;
 	} catch (error) {
 		if (isNotServing$1(error)) return ["Databases: Metabase is not running; `rde start`"];
 		if (isRejectedCredential(error)) return ["Databases: Metabase rejects the stored API key; `rde init --only api-key`"];
 		throw error;
 	}
-	if (databases.length === 0) return ["Databases: none connected yet; `rde db add`"];
-	return ["Databases:", ...existingDatabaseLines(databases).map((line) => `  ${line}`)];
+	const connected = databases.filter((database) => !isStub(database));
+	const stubs = databases.filter(isStub);
+	const stubLines = stubs.length === 0 ? [] : [unconnectedStubsLine(stubs)];
+	if (connected.length === 0) return ["Databases: none connected yet; `rde db add`", ...stubLines];
+	return [
+		"Databases:",
+		...existingDatabaseLines(connected).map((line) => `  ${line}`),
+		...stubLines
+	];
 }
 function remoteLine(remote) {
 	switch (remote.kind) {
@@ -7353,9 +7540,9 @@ async function summaryLines(state, apiKey, deps) {
 	lines.push("Lifecycle: rde status (--json for scripts), rde stop, rde start");
 	return lines;
 }
-function summaryStep(deps = hostDeps$2) {
+function summaryStep(deps = hostDeps$3) {
 	return {
-		id: STEP_ID,
+		id: STEP_ID$1,
 		title: "Summary",
 		async detect() {
 			return "todo";
@@ -7368,6 +7555,55 @@ function summaryStep(deps = hostDeps$2) {
 	};
 }
 //#endregion
+//#region src/steps/transforms.ts
+const STEP_ID = "transforms";
+function hostDeps$2(ctx) {
+	return {
+		client: (baseUrl, auth) => createMetabaseClient(baseUrl, auth, ctx.signal),
+		instanceRunning: () => isInstanceRunning(ctx.state, hostRuntimeDeps(ctx.state.name, ctx.signal))
+	};
+}
+function isNotServingYet(error) {
+	return error instanceof MetabaseUnreachableError || error instanceof MetabaseInitializingError;
+}
+function transformsStep(deps = hostDeps$2) {
+	return {
+		id: STEP_ID,
+		title: "Enable transforms",
+		async detect(ctx) {
+			const configured = configuredRuntime(ctx.state);
+			if (configured === null || ctx.secrets.apiKey === null) return "todo";
+			const resolved = deps(ctx);
+			if (!await resolved.instanceRunning()) return "todo";
+			const client = resolved.client(configured.url, {
+				kind: "api-key",
+				key: ctx.secrets.apiKey
+			});
+			try {
+				return await client.setting.transformsDecided() ? "done" : "todo";
+			} catch (error) {
+				if (isNotServingYet(error) || isRejectedCredential(error)) return "todo";
+				throw error;
+			}
+		},
+		async run(ctx) {
+			const configured = requireConfiguredRuntime(ctx.state);
+			if (ctx.secrets.apiKey === null) throw new ConfigError("no API key yet; the api-key step comes first");
+			const client = deps(ctx).client(configured.url, {
+				kind: "api-key",
+				key: ctx.secrets.apiKey
+			});
+			if (await client.setting.transformsDecided()) {
+				ctx.ui.info("Transforms are already set in Metabase; leaving them as they are");
+				return { outcome: "completed" };
+			}
+			await client.setting.enableTransforms();
+			ctx.ui.success("Transforms enabled");
+			return { outcome: "completed" };
+		}
+	};
+}
+//#endregion
 //#region src/steps/index.ts
 const DEFAULT_STEP_OPTIONS = {
 	runtime: NO_RUNTIME_FLAGS,
@@ -7383,6 +7619,7 @@ const STEP_BY_ID = {
 	"start-metabase": () => startMetabaseStep(),
 	"admin-user": (options) => adminUserStep(options.admin),
 	"api-key": () => apiKeyStep(),
+	transforms: () => transformsStep(),
 	"sample-database": () => sampleDatabaseStep(),
 	license: () => licenseStep(),
 	databases: (options) => databasesStep(options.databases),
@@ -8318,7 +8555,7 @@ const dbAdd = defineRdeCommand({
 		await addDatabases(await createWizardContext(name, {
 			signal: interruptSignal,
 			prompts
-		}), hostDatabasesDeps(interruptSignal));
+		}), hostDatabasesDeps(interruptSignal), { offerStubs: args.url === void 0 });
 	}
 });
 //#endregion
@@ -9360,7 +9597,8 @@ function applyDatabaseRecord(draft, record) {
 	const value = stringOf(record.answer);
 	const skippedConnection = record.key === DATABASE_KEYS.connection && value?.trim() === "";
 	const finished = parseDatabaseKey(record.key)?.name === "engine" && value === "finish";
-	if (skippedConnection || finished) draft.databasesFinished = true;
+	const pickedNoStub = record.key === DATABASE_KEYS.stubs && record.answer.kind === "multiselect" && record.answer.values.length === 0;
+	if (skippedConnection || finished || pickedNoStub) draft.databasesFinished = true;
 }
 function applyAdminRecord(draft, key, value) {
 	if (key === ADMIN_USER_KEYS.email && value !== null) admin(draft).email = value;
@@ -10737,7 +10975,7 @@ const upgradeCommand = defineRdeCommand({
 const main = defineCommand({
 	meta: {
 		name: "rde",
-		version: "0.1.12",
+		version: "0.1.13",
 		description: "Prepares a local machine for data-engineering work with Metabase and coding agents"
 	},
 	subCommands: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@metabase/rde",
-  "version": "0.1.12",
+  "version": "0.1.13",
   "description": "Prepares a local machine for data-engineering work with Metabase and coding agents",
   "license": "AGPL-3.0",
   "bin": {