@moku-labs/worker 0.9.2 → 0.10.0

package/dist/{cli-imQGo0tc.cjs → cli-Dnb-P_pp.cjs}

@@ -1535,6 +1535,287 @@ const verifyAuth = async (ctx) => {
 	};
 };
 //#endregion
+//#region src/plugins/deploy/infra/render.ts
+/**
+* Derive a human-readable name from a resource descriptor: the Cloudflare resource `name` for the
+* provisioned kinds (kv/r2/d1/queue), or the exported `className` for a Durable Object (which has no
+* provisioned name). Used in both the provision events and the branded panels so the two agree.
+*
+* @param resource - The resource descriptor.
+* @returns A short name identifying the resource.
+* @example
+* ```ts
+* resourceName({ kind: "kv", name: "tracker-cache", binding: "CACHE" }); // "tracker-cache"
+* ```
+*/
+const resourceName = (resource) => resource.kind === "do" ? resource.className : resource.name;
+/**
+* Format a `kind name` cell, padding the kind so the names line up in a column.
+*
+* @param kind - The resource kind (kv / r2 / d1 / queue / do).
+* @param name - The resource name.
+* @returns The aligned `kind  name` cell.
+* @example
+* ```ts
+* cell("kv", "CACHE"); // "kv     CACHE"
+* ```
+*/
+const cell = (kind, name) => `${kind.padEnd(6)}${name}`;
+/**
+* Row tag for a Durable Object — it ships with the Worker (`wrangler deploy` creates the namespace),
+* so it is NEVER labelled `(exists)` (the planner never queried the account for it). Shared by the
+* plan and provision-result panels so the two always read the same.
+*/
+const SHIPS_WITH_WORKER = "(ships with worker)";
+/**
+* ANSI SGR matcher — built from `String.fromCharCode(27)` (the ESC byte) so no control character
+* appears in a regex literal (which both linters reject).
+*/
+const ANSI_SGR = new RegExp(String.raw`${String.fromCodePoint(27)}\[[0-9;]*m`, "gu");
+/**
+* Strip ANSI SGR escape sequences so a captured (colorized) error renders as plain, readable text.
+*
+* @param text - The (possibly colorized) text.
+* @returns The text with ANSI color codes removed.
+* @example
+* ```ts
+* stripAnsi(`${String.fromCharCode(27)}[31mX${String.fromCharCode(27)}[0m`); // "X"
+* ```
+*/
+const stripAnsi = (text) => text.replaceAll(ANSI_SGR, "");
+/**
+* Clean a captured (colorized, multi-line, wrapper-wrapped) provision error down to its meaningful
+* text: strip ANSI, drop the wrapper lines (the branded prefix, wrangler's log-file pointer), strip
+* each `✘ [ERROR]` marker, and join what's left. Returns the FULL message (the caller word-wraps it)
+* so the user reads the actual reason — never a truncated `…`.
+*
+* @param message - The captured error message.
+* @returns The full, plain failure reason.
+* @example
+* ```ts
+* cleanError("[moku-worker] wrangler exited…\n  ✘ [ERROR] The bucket name is invalid.");
+* // "The bucket name is invalid."
+* ```
+*/
+const cleanError = (message) => {
+	const cleaned = stripAnsi(message).split("\n").map((line) => line.trim()).filter((line) => line.length > 0).filter((line) => !/^\[moku-worker\]/u.test(line)).filter((line) => !/logs were written to/iu.test(line)).map((line) => line.replace(/^✘\s*/u, "").replace(/^\[error\]\s*/iu, "")).join(" ");
+	return cleaned.length > 0 ? cleaned : stripAnsi(message).trim();
+};
+/**
+* Word-wrap text to `width` columns (never splitting inside a word), so a long failure reason reads
+* as a tidy indented block instead of forcing the box wide or scrolling off the edge.
+*
+* @param text - The text to wrap.
+* @param width - The maximum column width per line.
+* @returns The wrapped lines.
+* @example
+* ```ts
+* wrapText("a long sentence to wrap", 10); // ["a long", "sentence", "to wrap"]
+* ```
+*/
+const wrapText = (text, width) => {
+	const lines = [];
+	let line = "";
+	for (const word of text.split(/\s+/u).filter(Boolean)) if (line.length === 0) line = word;
+	else if (line.length + 1 + word.length <= width) line += ` ${word}`;
+	else {
+		lines.push(line);
+		line = word;
+	}
+	if (line.length > 0) lines.push(line);
+	return lines;
+};
+/**
+* Render the infra preflight plan as a branded panel: a dim summary line (counts + account) then one
+* row per declared resource — a pink `+` for those to create, a dim `~ (exists)` for those already
+* present, and a dim `~ (ships with worker)` for Durable Objects (created by `wrangler deploy`, never
+* pre-provisioned). When nothing needs creating it still renders, so the user sees the full picture.
+*
+* @param ui - The branded console to render through.
+* @param plan - The infra plan (existing vs missing vs ships-with-Worker) from checkInfra()/planInfra().
+* @example
+* ```ts
+* renderPlan(ui, await planInfra(ctx, manifest));
+* ```
+*/
+const renderPlan = (ui, plan) => {
+	const { palette } = ui;
+	const counts = [`${String(plan.missing.length)} to create`, `${String(plan.exists.length)} exist`];
+	if (plan.ships.length > 0) counts.push(`${String(plan.ships.length)} with worker`);
+	const summary = palette.dim(`${counts.join(" · ")} · ${plan.account}`);
+	const createRows = plan.missing.map((resource) => `${palette.pink("+")} ${cell(resource.kind, resourceName(resource))}`);
+	const existsRows = plan.exists.map((ref) => `${palette.dim("~")} ${cell(ref.resource.kind, resourceName(ref.resource))} ${palette.dim("(exists)")}`);
+	const shipsRows = plan.ships.map((resource) => `${palette.dim("~")} ${cell(resource.kind, resourceName(resource))} ${palette.dim(SHIPS_WITH_WORKER)}`);
+	ui.heading("Infra plan");
+	ui.box([
+		summary,
+		"",
+		...createRows,
+		...existsRows,
+		...shipsRows
+	]);
+};
+/**
+* Render the provision result as a branded panel — a green `✓` per created resource, a dim `~` per
+* skipped, a dim `~ (ships with worker)` per Durable Object, a red `✗` per failure, then a summary
+* line (failed count red when non-zero) — followed, when anything failed, by a detail block printing
+* each failure's FULL reason (ANSI-stripped and word-wrapped) so it is actually readable instead of
+* truncated inside the box.
+*
+* @param ui - The branded console to render through.
+* @param result - The provision result from provisionInfra()/the deploy pipeline.
+* @example
+* ```ts
+* renderProvisionResult(ui, await provisionInfra(plan));
+* ```
+*/
+const renderProvisionResult = (ui, result) => {
+	const { palette } = ui;
+	const createdRows = result.created.map((ref) => `${palette.green("✓")} ${cell(ref.resource.kind, resourceName(ref.resource))}`);
+	const skippedRows = result.skipped.map((ref) => `${palette.dim("~")} ${cell(ref.resource.kind, resourceName(ref.resource))} ${palette.dim("(exists)")}`);
+	const bundledRows = result.bundled.map((resource) => `${palette.dim("~")} ${cell(resource.kind, resourceName(resource))} ${palette.dim(SHIPS_WITH_WORKER)}`);
+	const failedRows = result.failed.map((failure) => `${palette.red("✗")} ${cell(failure.resource.kind, resourceName(failure.resource))}`);
+	const failedCount = result.failed.length > 0 ? palette.red(`${String(result.failed.length)} failed`) : "0 failed";
+	const counts = [`${String(result.created.length)} created`, `${String(result.skipped.length)} exist`];
+	if (result.bundled.length > 0) counts.push(`${String(result.bundled.length)} with worker`);
+	const summary = `${counts.join(" · ")} · ${failedCount}`;
+	ui.heading("Provisioned");
+	ui.box([
+		...createdRows,
+		...skippedRows,
+		...bundledRows,
+		...failedRows,
+		"",
+		summary
+	]);
+	if (result.failed.length > 0) {
+		ui.line();
+		for (const failure of result.failed) {
+			ui.line(`  ${palette.red("✗")} ${cell(failure.resource.kind, resourceName(failure.resource))}`);
+			for (const wrapped of wrapText(cleanError(failure.error), ui.width - 4)) ui.line(palette.dim(`    ${wrapped}`));
+		}
+	}
+};
+/**
+* Format an elapsed duration compactly: sub-second as `820ms`, otherwise one-decimal seconds (`4.2s`),
+* and minutes once it crosses 60s (`1m04s`) so a long deploy stays readable.
+*
+* @param ms - The elapsed milliseconds.
+* @returns The compact duration string.
+* @example
+* ```ts
+* formatDuration(4234); // "4.2s"
+* ```
+*/
+const formatDuration = (ms) => {
+	if (ms < 1e3) return `${String(ms)}ms`;
+	const seconds = ms / 1e3;
+	if (seconds < 60) return `${seconds.toFixed(1)}s`;
+	const whole = Math.floor(seconds);
+	return `${String(Math.floor(whole / 60))}m${String(whole % 60).padStart(2, "0")}s`;
+};
+/**
+* Render the terminal deploy summary as a branded panel — the headline the user actually wants. The
+* live URL leads on its own line (pink, so it is the first thing the eye lands on), then a dim
+* key/value block: the target stage, the resource tally (with a red `failed` count when non-zero),
+* and the wall-clock time the whole deploy took. Replaces the prior single `deployed → url` line.
+*
+* @param ui - The branded console to render through.
+* @param summary - The deploy summary fields.
+* @param summary.url - The live deployed URL (the panel headline).
+* @param summary.stage - The target stage the worker deployed to.
+* @param summary.created - How many resources were created this run.
+* @param summary.exists - How many resources already existed (skipped).
+* @param summary.bundled - How many Durable Objects shipped with the Worker.
+* @param summary.failed - How many resources failed to provision.
+* @param summary.elapsedMs - The wall-clock deploy duration in milliseconds.
+* @example
+* ```ts
+* renderDeploySummary(ui, { url, stage: "production", created: 0, exists: 5, bundled: 1, failed: 0, elapsedMs: 4234 });
+* ```
+*/
+const renderDeploySummary = (ui, summary) => {
+	const { palette } = ui;
+	const parts = [`${String(summary.exists)} exist`, `${String(summary.created)} created`];
+	if (summary.bundled > 0) parts.push(`${String(summary.bundled)} with worker`);
+	const tally = parts.join(" · ");
+	const failedLabel = palette.red(`${String(summary.failed)} failed`);
+	const resources = summary.failed > 0 ? `${tally} · ${failedLabel}` : tally;
+	ui.heading("Deployed");
+	ui.box([
+		palette.pink(summary.url),
+		"",
+		`${palette.dim("stage".padEnd(10))}${summary.stage}`,
+		`${palette.dim("resources".padEnd(10))}${resources}`,
+		`${palette.dim("took".padEnd(10))}${formatDuration(summary.elapsedMs)}`
+	]);
+};
+/**
+* Render the D1 migration outcome as a branded panel — the readable replacement for wrangler's raw
+* `d1 migrations apply` TUI. One row per database: the `d1 <binding>` cell plus a pink `N applied`
+* count (or a dim `up to date` when nothing was pending), with each applied migration filename listed
+* beneath as a green `✓`. A dim scope footer (`remote` / `local`) names which database was touched.
+* The caller renders this only when at least one database actually ran migrations.
+*
+* @param ui - The branded console to render through.
+* @param outcomes - The per-database migration outcomes (one per d1 instance that declares migrations).
+* @param scope - Which database the migrations ran against: `remote` (Cloudflare) or `local` (dev).
+* @example
+* ```ts
+* renderMigrateSummary(ui, [{ binding: "DB", applied: ["0003_x.sql"], upToDate: false }], "remote");
+* ```
+*/
+const renderMigrateSummary = (ui, outcomes, scope) => {
+	const { palette } = ui;
+	const rows = [];
+	for (const outcome of outcomes) {
+		const count = outcome.applied.length;
+		const appliedLabel = palette.pink(count > 0 ? `${String(count)} applied` : "applied");
+		const status = outcome.upToDate ? palette.dim("up to date") : appliedLabel;
+		rows.push(`${cell("d1", outcome.binding)}  ${status}`);
+		for (const name of outcome.applied) rows.push(`  ${palette.green("✓")} ${palette.dim(name)}`);
+	}
+	ui.heading("Migrated");
+	ui.box([
+		...rows,
+		"",
+		palette.dim(scope)
+	]);
+};
+/**
+* Render the seed outcome as a branded panel — the readable replacement for wrangler's raw
+* `d1 execute` / `kv key delete` TUI. Leads with the loaded `file → binding` (pink file), an optional
+* dim stats line (rows written / statements, only the parts wrangler reported), then — when the seed
+* cleared cached KV keys — a `KV reset` block listing each `~ binding key` so the user sees exactly
+* what was dropped. A dim scope footer (`remote` / `local`) names which database was seeded.
+*
+* @param ui - The branded console to render through.
+* @param outcome - The seed outcome (file, target binding, best-effort counts, the KV keys reset).
+* @param scope - Which database the seed ran against: `remote` (Cloudflare) or `local` (dev).
+* @example
+* ```ts
+* renderSeedSummary(ui, { file: "db/seed.sql", binding: "DB", rowsWritten: 18, resetKv: [] }, "remote");
+* ```
+*/
+const renderSeedSummary = (ui, outcome, scope) => {
+	const { palette } = ui;
+	const lines = [`${palette.pink(outcome.file)} ${palette.dim("→")} ${outcome.binding}`];
+	const stats = [];
+	if (outcome.rowsWritten !== void 0) stats.push(`${String(outcome.rowsWritten)} rows written`);
+	if (outcome.statements !== void 0) stats.push(`${String(outcome.statements)} statements`);
+	if (stats.length > 0) lines.push(palette.dim(stats.join(" · ")));
+	if (outcome.resetKv.length > 0) {
+		lines.push("", palette.dim("KV reset"));
+		for (const entry of outcome.resetKv) lines.push(`${palette.dim("~")} ${entry.binding}  ${palette.dim(entry.key)}`);
+	}
+	ui.heading("Seeded");
+	ui.box([
+		...lines,
+		"",
+		palette.dim(scope)
+	]);
+};
+//#endregion
 //#region src/plugins/deploy/runner.ts
 /**
 * @file deploy plugin — wrangler subprocess wrapper (node:child_process).
@@ -1642,6 +1923,61 @@ const runWranglerInherit = (args) => {
 * Node-only; never imported by the runtime Worker bundle.
 */
 /**
+* Parse the best-effort row/statement counts from wrangler's `d1 execute` output so the branded seed
+* panel can report them — degrading gracefully (each field simply omitted) when wrangler's format
+* differs or the runner streamed instead of captured. Wrangler prints lines like "🚣 18 commands
+* executed" and a rows-written total; both are matched loosely (case-insensitive).
+*
+* @param output - The captured stdout from `wrangler d1 execute` (empty when the runner streamed).
+* @returns The parsed counts — each field present only when found.
+* @example
+* ```ts
+* parseSeedStats("🚣 18 commands executed (30 rows written)"); // { statements: 18, rowsWritten: 30 }
+* ```
+*/
+const parseSeedStats = (output) => {
+	const rows = /(\d{1,12}) rows? written/iu.exec(output);
+	const commands = /(\d{1,12}) commands? executed/iu.exec(output) ?? /executed (\d{1,12}) commands?/iu.exec(output);
+	const result = {};
+	if (commands?.[1] !== void 0) result.statements = Number(commands[1]);
+	if (rows?.[1] !== void 0) result.rowsWritten = Number(rows[1]);
+	return result;
+};
+/**
+* Parse which migrations wrangler applied from its captured `d1 migrations apply` output, so the
+* branded migrate panel can name them instead of dumping wrangler's raw migration TUI. `upToDate` is
+* true when wrangler reported nothing pending ("No migrations to apply"); otherwise every
+* `NNNN_name.sql` filename token in the output is collected in order (de-duplicated). Degrades
+* safely — an unrecognized format yields no names, and the panel falls back to a generic "applied".
+* Lives here (not in api.ts) so both the deploy path and the dev path parse it without a cycle.
+*
+* @param output - The captured stdout from `wrangler d1 migrations apply`.
+* @returns The applied migration filenames and whether the database was already up to date.
+* @example
+* ```ts
+* parseMigrationsApplied("Applied 0003_x.sql\n0004_y.sql"); // { applied: ["0003_x.sql", "0004_y.sql"], upToDate: false }
+* ```
+*/
+const parseMigrationsApplied = (output) => {
+	if (/no migrations to apply/iu.test(output)) return {
+		applied: [],
+		upToDate: true
+	};
+	const applied = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const match of output.matchAll(/\b\d{3,}_[A-Za-z0-9_-]+\.sql\b/gu)) {
+		const name = match[0];
+		if (!seen.has(name)) {
+			seen.add(name);
+			applied.push(name);
+		}
+	}
+	return {
+		applied,
+		upToDate: false
+	};
+};
+/**
 * Resolve the single configured d1 database (or the one bound to `binding` when several exist) from
 * the d1 plugin's manifest. The shared resolver behind `seed()`, the post-deploy seed, and the dev
 * seed; throws a branded error when the choice is ambiguous (none/several, no binding) or unknown.
@@ -1670,27 +2006,30 @@ const resolveD1 = (ctx, binding) => {
 * injectable dev path.
 *
 * @param ctx - The deploy plugin context.
-* @param run - The wrangler runner to execute each command through.
+* @param run - The wrangler runner to execute each command through (a CAPTURING runner lets the
+*   returned outcome report row/statement counts; a streaming one still works, just without them).
 * @param seed - The resolved seed config (SQL file, optional binding, KV keys to reset).
 * @param scope - The wrangler scope: `--remote` (deploy) or `--local` (dev).
-* @returns Resolves once the seed file has executed and every cached KV key is cleared.
+* @returns The seed outcome (file, target binding, best-effort counts, and the KV keys that were reset).
 * @throws {Error} When no d1 database is configured, or the seed's binding cannot be resolved.
 * @example
 * ```ts
-* await runConfiguredSeed(ctx, runWranglerInherit, ctx.config.seed, "--remote");
+* const outcome = await runConfiguredSeed(ctx, runWrangler, ctx.config.seed, "--remote");
 * ```
 */
 const runConfiguredSeed = async (ctx, run, seed, scope) => {
 	if (!ctx.has("d1")) throw new Error("[moku-worker] seed: no d1 database is configured.");
-	await run([
+	const database = resolveD1(ctx, seed.binding);
+	const executed = await run([
 		"d1",
 		"execute",
-		resolveD1(ctx, seed.binding).binding,
+		database.binding,
 		scope,
 		"--file",
 		seed.file
 	]);
-	for (const entry of seed.resetKv ?? []) await run([
+	const resetKv = seed.resetKv ?? [];
+	for (const entry of resetKv) await run([
 		"kv",
 		"key",
 		"delete",
@@ -1699,6 +2038,12 @@ const runConfiguredSeed = async (ctx, run, seed, scope) => {
 		entry.binding,
 		scope
 	]);
+	return {
+		file: seed.file,
+		binding: database.binding,
+		resetKv,
+		...parseSeedStats(typeof executed === "string" ? executed : "")
+	};
 };
 //#endregion
 //#region src/plugins/deploy/dev/build.ts
@@ -2044,7 +2389,8 @@ const seedLocal = async (ctx, deps) => {
 		phase: "seed",
 		detail: config.file
 	});
-	await runConfiguredSeed(ctx, deps.runWrangler, config, "--local");
+	const outcome = await runConfiguredSeed(ctx, deps.runWrangler, config, "--local");
+	renderSeedSummary((0, _moku_labs_common_cli.createBrandConsole)(), outcome, "local");
 };
 /**
 * Run a long-lived dev session: cold build → (local d1 migrate) → (local seed) → spawn `wrangler
@@ -2080,13 +2426,21 @@ const runDev = async (ctx, opts, deps) => {
 			phase: "migrate",
 			detail: "d1 (local)"
 		});
-		for (const binding of migrationBindings) await deps.runWrangler([
-			"d1",
-			"migrations",
-			"apply",
-			binding,
-			"--local"
-		]);
+		const outcomes = [];
+		for (const binding of migrationBindings) {
+			const output = await deps.runWrangler([
+				"d1",
+				"migrations",
+				"apply",
+				binding,
+				"--local"
+			]);
+			outcomes.push({
+				binding,
+				...parseMigrationsApplied(output)
+			});
+		}
+		renderMigrateSummary((0, _moku_labs_common_cli.createBrandConsole)(), outcomes, "local");
 	}
 	if (seed) await seedLocal(ctx, deps);
 	ctx.emit("dev:phase", {
@@ -2199,222 +2553,6 @@ const planInfra = async (ctx, manifest) => {
 	};
 };
 //#endregion
-//#region src/plugins/deploy/infra/render.ts
-/**
-* Derive a human-readable name from a resource descriptor: the Cloudflare resource `name` for the
-* provisioned kinds (kv/r2/d1/queue), or the exported `className` for a Durable Object (which has no
-* provisioned name). Used in both the provision events and the branded panels so the two agree.
-*
-* @param resource - The resource descriptor.
-* @returns A short name identifying the resource.
-* @example
-* ```ts
-* resourceName({ kind: "kv", name: "tracker-cache", binding: "CACHE" }); // "tracker-cache"
-* ```
-*/
-const resourceName = (resource) => resource.kind === "do" ? resource.className : resource.name;
-/**
-* Format a `kind name` cell, padding the kind so the names line up in a column.
-*
-* @param kind - The resource kind (kv / r2 / d1 / queue / do).
-* @param name - The resource name.
-* @returns The aligned `kind  name` cell.
-* @example
-* ```ts
-* cell("kv", "CACHE"); // "kv     CACHE"
-* ```
-*/
-const cell = (kind, name) => `${kind.padEnd(6)}${name}`;
-/**
-* Row tag for a Durable Object — it ships with the Worker (`wrangler deploy` creates the namespace),
-* so it is NEVER labelled `(exists)` (the planner never queried the account for it). Shared by the
-* plan and provision-result panels so the two always read the same.
-*/
-const SHIPS_WITH_WORKER = "(ships with worker)";
-/**
-* ANSI SGR matcher — built from `String.fromCharCode(27)` (the ESC byte) so no control character
-* appears in a regex literal (which both linters reject).
-*/
-const ANSI_SGR = new RegExp(String.raw`${String.fromCodePoint(27)}\[[0-9;]*m`, "gu");
-/**
-* Strip ANSI SGR escape sequences so a captured (colorized) error renders as plain, readable text.
-*
-* @param text - The (possibly colorized) text.
-* @returns The text with ANSI color codes removed.
-* @example
-* ```ts
-* stripAnsi(`${String.fromCharCode(27)}[31mX${String.fromCharCode(27)}[0m`); // "X"
-* ```
-*/
-const stripAnsi = (text) => text.replaceAll(ANSI_SGR, "");
-/**
-* Clean a captured (colorized, multi-line, wrapper-wrapped) provision error down to its meaningful
-* text: strip ANSI, drop the wrapper lines (the branded prefix, wrangler's log-file pointer), strip
-* each `✘ [ERROR]` marker, and join what's left. Returns the FULL message (the caller word-wraps it)
-* so the user reads the actual reason — never a truncated `…`.
-*
-* @param message - The captured error message.
-* @returns The full, plain failure reason.
-* @example
-* ```ts
-* cleanError("[moku-worker] wrangler exited…\n  ✘ [ERROR] The bucket name is invalid.");
-* // "The bucket name is invalid."
-* ```
-*/
-const cleanError = (message) => {
-	const cleaned = stripAnsi(message).split("\n").map((line) => line.trim()).filter((line) => line.length > 0).filter((line) => !/^\[moku-worker\]/u.test(line)).filter((line) => !/logs were written to/iu.test(line)).map((line) => line.replace(/^✘\s*/u, "").replace(/^\[error\]\s*/iu, "")).join(" ");
-	return cleaned.length > 0 ? cleaned : stripAnsi(message).trim();
-};
-/**
-* Word-wrap text to `width` columns (never splitting inside a word), so a long failure reason reads
-* as a tidy indented block instead of forcing the box wide or scrolling off the edge.
-*
-* @param text - The text to wrap.
-* @param width - The maximum column width per line.
-* @returns The wrapped lines.
-* @example
-* ```ts
-* wrapText("a long sentence to wrap", 10); // ["a long", "sentence", "to wrap"]
-* ```
-*/
-const wrapText = (text, width) => {
-	const lines = [];
-	let line = "";
-	for (const word of text.split(/\s+/u).filter(Boolean)) if (line.length === 0) line = word;
-	else if (line.length + 1 + word.length <= width) line += ` ${word}`;
-	else {
-		lines.push(line);
-		line = word;
-	}
-	if (line.length > 0) lines.push(line);
-	return lines;
-};
-/**
-* Render the infra preflight plan as a branded panel: a dim summary line (counts + account) then one
-* row per declared resource — a pink `+` for those to create, a dim `~ (exists)` for those already
-* present, and a dim `~ (ships with worker)` for Durable Objects (created by `wrangler deploy`, never
-* pre-provisioned). When nothing needs creating it still renders, so the user sees the full picture.
-*
-* @param ui - The branded console to render through.
-* @param plan - The infra plan (existing vs missing vs ships-with-Worker) from checkInfra()/planInfra().
-* @example
-* ```ts
-* renderPlan(ui, await planInfra(ctx, manifest));
-* ```
-*/
-const renderPlan = (ui, plan) => {
-	const { palette } = ui;
-	const counts = [`${String(plan.missing.length)} to create`, `${String(plan.exists.length)} exist`];
-	if (plan.ships.length > 0) counts.push(`${String(plan.ships.length)} with worker`);
-	const summary = palette.dim(`${counts.join(" · ")} · ${plan.account}`);
-	const createRows = plan.missing.map((resource) => `${palette.pink("+")} ${cell(resource.kind, resourceName(resource))}`);
-	const existsRows = plan.exists.map((ref) => `${palette.dim("~")} ${cell(ref.resource.kind, resourceName(ref.resource))} ${palette.dim("(exists)")}`);
-	const shipsRows = plan.ships.map((resource) => `${palette.dim("~")} ${cell(resource.kind, resourceName(resource))} ${palette.dim(SHIPS_WITH_WORKER)}`);
-	ui.heading("Infra plan");
-	ui.box([
-		summary,
-		"",
-		...createRows,
-		...existsRows,
-		...shipsRows
-	]);
-};
-/**
-* Render the provision result as a branded panel — a green `✓` per created resource, a dim `~` per
-* skipped, a dim `~ (ships with worker)` per Durable Object, a red `✗` per failure, then a summary
-* line (failed count red when non-zero) — followed, when anything failed, by a detail block printing
-* each failure's FULL reason (ANSI-stripped and word-wrapped) so it is actually readable instead of
-* truncated inside the box.
-*
-* @param ui - The branded console to render through.
-* @param result - The provision result from provisionInfra()/the deploy pipeline.
-* @example
-* ```ts
-* renderProvisionResult(ui, await provisionInfra(plan));
-* ```
-*/
-const renderProvisionResult = (ui, result) => {
-	const { palette } = ui;
-	const createdRows = result.created.map((ref) => `${palette.green("✓")} ${cell(ref.resource.kind, resourceName(ref.resource))}`);
-	const skippedRows = result.skipped.map((ref) => `${palette.dim("~")} ${cell(ref.resource.kind, resourceName(ref.resource))} ${palette.dim("(exists)")}`);
-	const bundledRows = result.bundled.map((resource) => `${palette.dim("~")} ${cell(resource.kind, resourceName(resource))} ${palette.dim(SHIPS_WITH_WORKER)}`);
-	const failedRows = result.failed.map((failure) => `${palette.red("✗")} ${cell(failure.resource.kind, resourceName(failure.resource))}`);
-	const failedCount = result.failed.length > 0 ? palette.red(`${String(result.failed.length)} failed`) : "0 failed";
-	const counts = [`${String(result.created.length)} created`, `${String(result.skipped.length)} exist`];
-	if (result.bundled.length > 0) counts.push(`${String(result.bundled.length)} with worker`);
-	const summary = `${counts.join(" · ")} · ${failedCount}`;
-	ui.heading("Provisioned");
-	ui.box([
-		...createdRows,
-		...skippedRows,
-		...bundledRows,
-		...failedRows,
-		"",
-		summary
-	]);
-	if (result.failed.length > 0) {
-		ui.line();
-		for (const failure of result.failed) {
-			ui.line(`  ${palette.red("✗")} ${cell(failure.resource.kind, resourceName(failure.resource))}`);
-			for (const wrapped of wrapText(cleanError(failure.error), ui.width - 4)) ui.line(palette.dim(`    ${wrapped}`));
-		}
-	}
-};
-/**
-* Format an elapsed duration compactly: sub-second as `820ms`, otherwise one-decimal seconds (`4.2s`),
-* and minutes once it crosses 60s (`1m04s`) so a long deploy stays readable.
-*
-* @param ms - The elapsed milliseconds.
-* @returns The compact duration string.
-* @example
-* ```ts
-* formatDuration(4234); // "4.2s"
-* ```
-*/
-const formatDuration = (ms) => {
-	if (ms < 1e3) return `${String(ms)}ms`;
-	const seconds = ms / 1e3;
-	if (seconds < 60) return `${seconds.toFixed(1)}s`;
-	const whole = Math.floor(seconds);
-	return `${String(Math.floor(whole / 60))}m${String(whole % 60).padStart(2, "0")}s`;
-};
-/**
-* Render the terminal deploy summary as a branded panel — the headline the user actually wants. The
-* live URL leads on its own line (pink, so it is the first thing the eye lands on), then a dim
-* key/value block: the target stage, the resource tally (with a red `failed` count when non-zero),
-* and the wall-clock time the whole deploy took. Replaces the prior single `deployed → url` line.
-*
-* @param ui - The branded console to render through.
-* @param summary - The deploy summary fields.
-* @param summary.url - The live deployed URL (the panel headline).
-* @param summary.stage - The target stage the worker deployed to.
-* @param summary.created - How many resources were created this run.
-* @param summary.exists - How many resources already existed (skipped).
-* @param summary.bundled - How many Durable Objects shipped with the Worker.
-* @param summary.failed - How many resources failed to provision.
-* @param summary.elapsedMs - The wall-clock deploy duration in milliseconds.
-* @example
-* ```ts
-* renderDeploySummary(ui, { url, stage: "production", created: 0, exists: 5, bundled: 1, failed: 0, elapsedMs: 4234 });
-* ```
-*/
-const renderDeploySummary = (ui, summary) => {
-	const { palette } = ui;
-	const parts = [`${String(summary.exists)} exist`, `${String(summary.created)} created`];
-	if (summary.bundled > 0) parts.push(`${String(summary.bundled)} with worker`);
-	const tally = parts.join(" · ");
-	const failedLabel = palette.red(`${String(summary.failed)} failed`);
-	const resources = summary.failed > 0 ? `${tally} · ${failedLabel}` : tally;
-	ui.heading("Deployed");
-	ui.box([
-		palette.pink(summary.url),
-		"",
-		`${palette.dim("stage".padEnd(10))}${summary.stage}`,
-		`${palette.dim("resources".padEnd(10))}${resources}`,
-		`${palette.dim("took".padEnd(10))}${formatDuration(summary.elapsedMs)}`
-	]);
-};
-//#endregion
 //#region src/plugins/deploy/naming.ts
 /**
 * @file deploy plugin — stage-aware resource naming.
@@ -3375,25 +3513,34 @@ const guidedDeployStep = async (ctx, manifest, stage, deps) => {
 * migrations dir — the generic, deploy-owned analogue of `wrangler d1 migrations apply <binding>
 * --remote`. The wrangler config was written earlier in the pipeline, so each binding resolves. The
 * caller runs this only AFTER a successful deploy, so a deploy that never happened never migrates a
-* remote DB. Streams wrangler's output; throws on the first non-zero exit (the caller folds it into
-* the report).
+* remote DB. CAPTURES wrangler's output (the raw TUI is hidden; {@link parseMigrationsApplied} turns
+* it into the branded panel's facts); throws on the first non-zero exit (the caller folds it into the
+* report, where the captured error is still surfaced).
 *
 * @param ctx - The deploy plugin context.
-* @returns Resolves once every configured database's remote migrations have been applied.
+* @returns The per-database migration outcomes (one per d1 instance that declares migrations).
 * @example
 * ```ts
-* await applyRemoteMigrations(ctx);
+* const outcomes = await applyRemoteMigrations(ctx);
 * ```
 */
 const applyRemoteMigrations = async (ctx) => {
-	if (!ctx.has("d1")) return;
-	for (const database of ctx.require(d1Plugin).deployManifest()) if (database.migrations !== void 0) await runWranglerInherit([
-		"d1",
-		"migrations",
-		"apply",
-		database.binding,
-		"--remote"
-	]);
+	if (!ctx.has("d1")) return [];
+	const outcomes = [];
+	for (const database of ctx.require(d1Plugin).deployManifest()) if (database.migrations !== void 0) {
+		const output = await runWrangler([
+			"d1",
+			"migrations",
+			"apply",
+			database.binding,
+			"--remote"
+		]);
+		outcomes.push({
+			binding: database.binding,
+			...parseMigrationsApplied(output)
+		});
+	}
+	return outcomes;
 };
 /**
 * Render a post-deploy step's failure as a branded line and capture its message into `errors` —
@@ -3437,9 +3584,13 @@ const runPostDeploy = async (ctx, want) => {
 	const errors = [];
 	let migration = "skipped";
 	if (want.migration) try {
-		await applyRemoteMigrations(ctx);
+		ctx.emit("deploy:phase", {
+			phase: "migrate",
+			detail: "remote D1"
+		});
+		const outcomes = await applyRemoteMigrations(ctx);
 		migration = "applied";
-		ui.check(true, "migrated", "remote D1");
+		if (outcomes.length > 0) renderMigrateSummary(ui, outcomes, "remote");
 	} catch (error) {
 		migration = "failed";
 		captureFailure(ui, errors, error);
@@ -3454,9 +3605,13 @@ const runPostDeploy = async (ctx, want) => {
 			seed = "failed";
 			captureFailure(ui, errors, /* @__PURE__ */ new Error("[moku-worker] deploy({ seed: true }) but no seed is configured — set pluginConfigs.deploy.seed."));
 		} else try {
-			await runConfiguredSeed(ctx, runWranglerInherit, config, "--remote");
+			ctx.emit("deploy:phase", {
+				phase: "seed",
+				detail: config.file
+			});
+			const outcome = await runConfiguredSeed(ctx, runWrangler, config, "--remote");
 			seed = "applied";
-			ui.check(true, "seeded", config.file);
+			renderSeedSummary(ui, outcome, "remote");
 		} catch (error) {
 			seed = "failed";
 			captureFailure(ui, errors, error);
@@ -3594,14 +3749,16 @@ const createDeployApi = (ctx) => ({
 	* Execute a SQL file against a configured D1 database via `wrangler d1 execute` — for seeding dev
 	* data. Local by default (applies that database's migrations first so the file's tables exist);
 	* `opts.remote` seeds Cloudflare (schema is applied by `deploy`). Generates the wrangler config up
-	* front so the binding resolves even on a first run. Streams wrangler's output.
+	* front so the binding resolves even on a first run. CAPTURES wrangler's output and renders a
+	* branded "Migrated" / "Seeded" summary (the raw migration/execute TUI is hidden) so the command
+	* reads the same as the rest of the deploy UX; a failure still surfaces the real wrangler error.
 	*
 	* @param sqlFile - Path to the SQL file to execute (e.g. "db/seed.sql").
 	* @param opts - Optional options.
 	* @param opts.stage - Stage for the generated config's resource names (defaults to the app stage).
 	* @param opts.binding - The d1 binding to target when more than one is configured (e.g. "DB").
 	* @param opts.remote - Seed the remote (Cloudflare) D1 instead of the local one.
-	* @returns Resolves once wrangler finishes executing the file.
+	* @returns Resolves once wrangler finishes executing the file and the summary is rendered.
 	* @example
 	* ```ts
 	* await api.seed("db/seed.sql");                   // local default d1 (migrate, then execute)
@@ -3614,14 +3771,22 @@ const createDeployApi = (ctx) => ({
 		await writeWranglerConfig(ctx.config.configFile, assembleManifest(ctx, stage), {}, wranglerExtra(ctx.config));
 		const target = resolveD1(ctx, opts?.binding);
 		const scope = opts?.remote === true ? "--remote" : "--local";
-		if (scope === "--local" && target.migrations !== void 0) await runWranglerInherit([
-			"d1",
-			"migrations",
-			"apply",
-			target.binding,
-			"--local"
-		]);
-		await runWranglerInherit([
+		const where = opts?.remote === true ? "remote" : "local";
+		const ui = (0, _moku_labs_common_cli.createBrandConsole)();
+		if (scope === "--local" && target.migrations !== void 0) {
+			const migrated = await runWrangler([
+				"d1",
+				"migrations",
+				"apply",
+				target.binding,
+				"--local"
+			]);
+			renderMigrateSummary(ui, [{
+				binding: target.binding,
+				...parseMigrationsApplied(migrated)
+			}], where);
+		}
+		const executed = await runWrangler([
 			"d1",
 			"execute",
 			target.binding,
@@ -3629,6 +3794,12 @@ const createDeployApi = (ctx) => ({
 			"--file",
 			sqlFile
 		]);
+		renderSeedSummary(ui, {
+			file: sqlFile,
+			binding: target.binding,
+			resetKv: [],
+			...parseSeedStats(executed)
+		}, where);
 	},
 	/**
 	* Scaffold a starting wrangler config (and CI files when ci is set).