dineway 0.1.35 → 0.1.37

package/dist/cli/index.mjs

@@ -2,7 +2,7 @@
 import { t as __exportAll } from "../chunk-ClPoSABd.mjs";
 import { n as createDatabase } from "../connection-BCNICDWN.mjs";
 import { c as listTablesLike } from "../dialect-helpers-TkdbkFad.mjs";
-import { r as runMigrations, t as getMigrationStatus } from "../runner-lqEiJbO-.mjs";
+import { i as runMigrations, n as getMigrationStatus, t as getMigrationFingerprint } from "../runner-S3smkgdc.mjs";
 import { r as isI18nEnabled } from "../config-XW5tMrH8.mjs";
 import { n as slugify } from "../slugify-BzGxlOFx.mjs";
 import { t as ContentRepository } from "../content-DvpMad_N.mjs";
@@ -27,9 +27,9 @@ import { createHeaderAwareFetch, customHeadersInterceptor, isRedirectResponse, r
 import { o as convertDataForRead } from "../transport-B7kO-4ee.mjs";
 import { DinewayClient } from "../client/index.mjs";
 import { LocalStorage } from "../storage/local.mjs";
+import { createHash } from "node:crypto";
 import { imageSize } from "image-size";
 import { createGzipDecoder, unpackTar } from "modern-tar";
-import { createHash } from "node:crypto";
 import { createReadStream, createWriteStream, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { basename, dirname, extname, isAbsolute, join, relative, resolve } from "node:path";
 import { defineCommand, runCommand, runMain } from "citty";
@@ -190,7 +190,15 @@ function removeMarketplaceCredential(registryUrl) {
 //#region src/cli/project-env.ts
 const DEFAULT_DINEWAY_URL = "http://localhost:4321";
 const ENV_KEY_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
-const LINE_SPLIT_PATTERN = /\r?\n/;
+const LINE_SPLIT_PATTERN$1 = /\r?\n/;
+const DINEWAY_LOCAL_STATE_GITIGNORE_COMMENT = "# Dineway local state";
+const DINEWAY_LOCAL_STATE_GITIGNORE_ENTRIES = [
+	".dineway/deploy.json",
+	".dineway/forgeway.json",
+	".dineway/types.ts",
+	".dineway/schema.json",
+	".dineway/uploads/"
+];
 const NEWLINE_PATTERN = /\r?\n/g;
 function parseDotenvValue(value) {
 	const trimmed = value.trim();
@@ -199,7 +207,7 @@ function parseDotenvValue(value) {
 }
 function parseDotenv(text) {
 	const env = {};
-	for (const line of text.split(LINE_SPLIT_PATTERN)) {
+	for (const line of text.split(LINE_SPLIT_PATTERN$1)) {
 		const trimmed = line.trim();
 		if (!trimmed || trimmed.startsWith("#")) continue;
 		const normalized = trimmed.startsWith("export ") ? trimmed.slice(7).trim() : trimmed;
@@ -233,7 +241,7 @@ function formatEnvValue(value) {
 async function upsertProjectEnv(cwd, values) {
 	const envPath = join(cwd, ".env");
 	const existing = await readFile(envPath, "utf-8").catch(() => "");
-	const lines = existing ? existing.split(LINE_SPLIT_PATTERN) : [];
+	const lines = existing ? existing.split(LINE_SPLIT_PATTERN$1) : [];
 	const seen = /* @__PURE__ */ new Set();
 	const nextLines = lines.map((line) => {
 		const trimmed = line.trim();
@@ -255,9 +263,18 @@ async function upsertProjectEnv(cwd, values) {
 async function ensureProjectGitignoreEntry(cwd, entry) {
 	const gitignorePath = join(cwd, ".gitignore");
 	const existing = await readFile(gitignorePath, "utf-8").catch(() => "");
-	if (existing.split(LINE_SPLIT_PATTERN).map((line) => line.trim()).includes(entry)) return;
+	if (existing.split(LINE_SPLIT_PATTERN$1).map((line) => line.trim()).includes(entry)) return;
 	await writeFile(gitignorePath, `${existing}${existing && !existing.endsWith("\n") ? "\n" : ""}${entry}\n`, "utf-8");
 }
+async function ensureProjectGitignoreDinewayLocalState(cwd) {
+	const gitignorePath = join(cwd, ".gitignore");
+	const existing = await readFile(gitignorePath, "utf-8").catch(() => "");
+	const lines = new Set(existing.split(LINE_SPLIT_PATTERN$1).map((line) => line.trim()));
+	const missingEntries = DINEWAY_LOCAL_STATE_GITIGNORE_ENTRIES.filter((entry) => !lines.has(entry));
+	if (missingEntries.length === 0) return;
+	const block = [DINEWAY_LOCAL_STATE_GITIGNORE_COMMENT, ...missingEntries].join("\n");
+	await writeFile(gitignorePath, `${existing}${existing.trim() ? existing.endsWith("\n") ? "\n" : "\n\n" : ""}${block}\n`, "utf-8");
+}
 
 //#endregion
 //#region src/cli/client-factory.ts
@@ -1553,45 +1570,67 @@ const flyTarget = {
 
 //#endregion
 //#region src/cli/commands/deploy/utils/config.ts
+const DINEWAY_DIR_NAME = ".dineway";
+const DEPLOY_STATE_FILE_NAME = "deploy.json";
+function deployStatePath(cwd) {
+	return join(cwd, DINEWAY_DIR_NAME, DEPLOY_STATE_FILE_NAME);
+}
+function emptyDeployState() {
+	return { version: 1 };
+}
 async function readDeployPackageJson(cwd) {
 	const content = await readFile(join(cwd, "package.json"), "utf-8");
 	return JSON.parse(content);
 }
+async function readDeployState(cwd) {
+	try {
+		const content = await readFile(deployStatePath(cwd), "utf-8");
+		return {
+			...emptyDeployState(),
+			...JSON.parse(content),
+			version: 1
+		};
+	} catch (error) {
+		if (error && typeof error === "object" && error.code === "ENOENT") return emptyDeployState();
+		throw error;
+	}
+}
+async function writeDeployState(cwd, state) {
+	await mkdir(join(cwd, DINEWAY_DIR_NAME), { recursive: true });
+	await writeFile(deployStatePath(cwd), JSON.stringify({
+		...state,
+		version: 1
+	}, null, "	") + "\n", "utf-8");
+}
 async function readSavedDeployTarget(cwd) {
-	return (await readDeployPackageJson(cwd)).dineway?.deploy?.target;
+	return (await readDeployState(cwd)).target;
 }
 async function writeDeployTarget(cwd, target) {
-	const pkgPath = join(cwd, "package.json");
-	const pkg = await readDeployPackageJson(cwd);
-	pkg.dineway = {
-		...pkg.dineway,
-		deploy: {
-			...pkg.dineway?.deploy,
-			target
-		}
-	};
-	await writeFile(pkgPath, JSON.stringify(pkg, null, "	") + "\n", "utf-8");
+	await writeDeployState(cwd, {
+		...await readDeployState(cwd),
+		target
+	});
+}
+async function readForgewayDeployMetadata(cwd) {
+	return (await readDeployState(cwd)).targets?.forgeway ?? {};
 }
 async function writeForgewayDeployMetadata(cwd, metadata) {
-	const pkgPath = join(cwd, "package.json");
-	const pkg = await readDeployPackageJson(cwd);
-	pkg.dineway = {
-		...pkg.dineway,
-		deploy: {
-			...pkg.dineway?.deploy,
+	const state = await readDeployState(cwd);
+	await writeDeployState(cwd, {
+		...state,
+		targets: {
+			...state.targets,
 			forgeway: {
-				...pkg.dineway?.deploy?.forgeway,
+				...state.targets?.forgeway,
 				...metadata
 			}
 		}
-	};
-	await writeFile(pkgPath, JSON.stringify(pkg, null, "	") + "\n", "utf-8");
+	});
 }
 
 //#endregion
 //#region src/cli/commands/deploy/utils/forgeway-secrets.ts
 const DINEWAY_CONFIG_DIR_NAME = ".dineway";
-const DINEWAY_CONFIG_GITIGNORE = "*\n!.gitignore\n";
 const TRAILING_SLASH_PATTERN$1 = /\/$/;
 function getDinewayConfigDir(cwd = process.cwd()) {
 	return join(cwd, DINEWAY_CONFIG_DIR_NAME);
@@ -1608,19 +1647,10 @@ async function readStore(cwd = process.cwd()) {
 	}
 }
 async function writeStore(store, cwd = process.cwd()) {
-	const dir = getDinewayConfigDir(cwd);
-	await mkdir(dir, {
+	await mkdir(getDinewayConfigDir(cwd), {
 		recursive: true,
 		mode: 448
 	});
-	try {
-		await writeFile(join(dir, ".gitignore"), DINEWAY_CONFIG_GITIGNORE, {
-			encoding: "utf-8",
-			flag: "wx"
-		});
-	} catch (error) {
-		if (!error || typeof error !== "object" || error.code !== "EEXIST") throw error;
-	}
 	const file = getForgewaySecretPath(cwd);
 	await writeFile(file, JSON.stringify(store, null, "	") + "\n", {
 		encoding: "utf-8",
@@ -1665,6 +1695,7 @@ const DATABASE_ENV_VAR_NAMES = ["DINEWAY_DATABASE_URL", "DINEWAY_DATABASE_AUTH_T
 const POLL_INTERVAL_MS$1 = 5e3;
 const POLL_TIMEOUT_MS$1 = 3e5;
 const DIRECT_UPLOAD_CONCURRENCY = 8;
+const FILE_HASH_CONCURRENCY = 8;
 const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
 const PLACE_ID_PATTERN = /^[A-Za-z0-9_-]{10,}$/;
 const SLUG_SEPARATOR_PATTERN = /[^a-z0-9]+/g;
@@ -1675,6 +1706,10 @@ const LOCATION_PARTS_PATTERN = /[,;|/]+|\s+-\s+/u;
 const JWT_PATTERN = /[A-Za-z0-9_-]{32,}\.[A-Za-z0-9_-]{16,}\.[A-Za-z0-9_-]{16,}/g;
 const TOKEN_ASSIGNMENT_PATTERN = /(DINEWAY_DATABASE_AUTH_TOKEN|DATABASE_AUTH_TOKEN|AUTH_TOKEN)=\S+/gi;
 const TRAILING_SLASH_PATTERN = /\/$/;
+const LEADING_SLASHES_PATTERN = /^\/+/;
+const TRAILING_SLASHES_PATTERN = /\/+$/;
+const REGEXP_ESCAPE_PATTERN = /[|\\{}()[\]^$+?.]/g;
+const LINE_SPLIT_PATTERN = /\r?\n/;
 const BACKSLASH_PATTERN = /\\/g;
 const SHADOW_EMAIL_PATTERN = /^shadow_[a-f0-9]{16}@dineway\.ai$/i;
 const FOOD_TYPES = new Set([
@@ -1689,6 +1724,8 @@ const EXCLUDE_PATTERNS = [
 	"node_modules",
 	".git",
 	".next",
+	".astro",
+	".plan",
 	".env",
 	".env.local",
 	"dist",
@@ -1710,7 +1747,11 @@ const EXCLUDE_PATTERNS = [
 	".turbo",
 	".cache",
 	"skills",
-	"coverage"
+	"coverage",
+	"uploads",
+	"data.db",
+	"data.db-shm",
+	"data.db-wal"
 ];
 var ForgewayApiError = class extends Error {
 	constructor(message, status) {
@@ -1746,6 +1787,39 @@ function getEnv(name) {
 	const value = process.env[name];
 	return value && value.trim() ? value.trim() : void 0;
 }
+function isVerboseDeploy(options) {
+	return options?.verbose === true || getEnv("DINEWAY_DEPLOY_VERBOSE") === "1";
+}
+function formatDuration(ms) {
+	if (ms < 1e3) return `${ms}ms`;
+	return `${Math.round(ms / 100) / 10}s`;
+}
+function formatBytes$1(bytes) {
+	if (bytes < 1024) return `${bytes} B`;
+	const units = [
+		"KB",
+		"MB",
+		"GB"
+	];
+	let value = bytes / 1024;
+	for (let index = 0; index < units.length; index++) {
+		const unit = units[index];
+		if (value < 1024 || index === units.length - 1) return `${value.toFixed(value >= 10 ? 0 : 1)} ${unit}`;
+		value /= 1024;
+	}
+	return `${bytes} B`;
+}
+function deploymentFileSize(files) {
+	return files.reduce((total, file) => total + file.size, 0);
+}
+function formatSeedSummary(seed) {
+	if (!seed) return "no seed";
+	return [
+		`collections ${seed.collections.created}/${seed.collections.skipped}/${seed.collections.updated}`,
+		`content ${seed.content.created}/${seed.content.skipped}/${seed.content.updated}`,
+		`media ${seed.media.created}/${seed.media.skipped}`
+	].join(", ");
+}
 async function readJsonResponse(response) {
 	return await response.json().catch(() => null);
 }
@@ -1841,8 +1915,8 @@ async function promptRequired(question, initialValue, deps, errorMessage) {
 	if (!answer) throw new Error(errorMessage);
 	return answer;
 }
-function getSavedForgewayMetadata(pkg) {
-	return pkg.dineway?.deploy?.forgeway ?? {};
+async function readSavedForgewayMetadata(cwd) {
+	return await readForgewayDeployMetadata(cwd).catch(() => ({}));
 }
 async function resolveForgewayAccountEmail(options, grant, cwd, deps) {
 	const stored = await (deps.readCredentials ?? readForgewayCredentials)(cwd);
@@ -1920,8 +1994,7 @@ async function resolveFormalAccountCredentials(context, grant, email, deps) {
 	return credentials;
 }
 async function resolveShadowProjectContext(cwd, options, deps) {
-	const pkg = await readDeployPackageJson(cwd).catch(() => null);
-	const saved = pkg ? getSavedForgewayMetadata(pkg) : {};
+	const saved = await readSavedForgewayMetadata(cwd);
 	const platformApiUrl = normalizePlatformApiUrl(getEnv("DINEWAY_API_BASE_URL") ?? getEnv("FORGEWAY_API_URL") ?? (typeof saved.platformApiUrl === "string" ? saved.platformApiUrl : void 0));
 	const savedPlaceId = options.placeId ?? getEnv("DINEWAY_PLACE_ID") ?? (typeof saved.placeId === "string" ? saved.placeId : void 0);
 	let grant = await (deps.readShadowGrant ?? readForgewayShadowGrant)(platformApiUrl, savedPlaceId, cwd);
@@ -2010,8 +2083,12 @@ async function createShadowUser(platformApiUrl, placeId, deps) {
 function isRecord(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+function scalarText(value) {
+	if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") return String(value);
+	return "";
+}
 function uniqueStrings(values) {
-	return [...new Set(values.map((value) => String(value || "").trim()).filter(Boolean))];
+	return [...new Set(values.map((value) => scalarText(value).trim()).filter(Boolean))];
 }
 function displayText(value) {
 	if (typeof value === "string" || typeof value === "number") return String(value);
@@ -2020,10 +2097,10 @@ function displayText(value) {
 	return "";
 }
 function normalizeCompare(value) {
-	return String(value || "").toLowerCase().normalize("NFKD").replace(DIACRITICS_PATTERN, "").replace(NON_COMPARE_PATTERN, "");
+	return scalarText(value).toLowerCase().normalize("NFKD").replace(DIACRITICS_PATTERN, "").replace(NON_COMPARE_PATTERN, "");
 }
 function candidatePlaceId(candidate) {
-	return String(candidate.placeId || candidate.id || "").trim();
+	return (scalarText(candidate.placeId) || scalarText(candidate.id)).trim();
 }
 function candidateNameTexts(candidate) {
 	return uniqueStrings([
@@ -2140,7 +2217,7 @@ function scorePlaceCandidate(candidate, context) {
 		score += 10;
 		reasons.push("food_type");
 	}
-	const businessStatus = String(candidate.businessStatus ?? candidate.business_status ?? "").toUpperCase();
+	const businessStatus = (scalarText(candidate.businessStatus) || scalarText(candidate.business_status)).toUpperCase();
 	if (businessStatus === "OPERATIONAL") {
 		score += 4;
 		reasons.push("operational");
@@ -2391,8 +2468,7 @@ async function createDeploymentSite(context, input, deps) {
 	});
 }
 async function resolveDeploymentSite(cwd, context, options, seedPath, deps, preResolvedRestaurant) {
-	const pkg = await readDeployPackageJson(cwd).catch(() => null);
-	const saved = pkg ? getSavedForgewayMetadata(pkg) : {};
+	const saved = await readSavedForgewayMetadata(cwd);
 	const explicitSite = options.site;
 	const savedSite = typeof saved.siteId === "string" ? saved.siteId : saved.siteSlug;
 	const siteRef = context.placeId ? explicitSite : explicitSite ?? savedSite;
@@ -2422,20 +2498,50 @@ function redactDatabaseOutput(value, secrets) {
 	for (const secret of secrets) if (secret.length > 0) redacted = redacted.split(secret).join("[redacted]");
 	return redacted.replace(JWT_PATTERN, "[redacted-token]").replace(TOKEN_ASSIGNMENT_PATTERN, "$1=[redacted]");
 }
+async function hashFileSha256(filePath) {
+	const hash = createHash("sha256");
+	for await (const chunk of createReadStream(filePath)) hash.update(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+	return `sha256:${hash.digest("hex")}`;
+}
+async function buildDinewayInitializationFingerprint(seedPath) {
+	const migration = getMigrationFingerprint();
+	return {
+		version: 1,
+		migrationHash: migration.migrationHash,
+		migrationCount: migration.migrationCount,
+		seedHash: seedPath ? await hashFileSha256(seedPath) : null
+	};
+}
+function initializationFingerprintsMatch(left, right) {
+	return left?.version === right.version && left.migrationHash === right.migrationHash && left.migrationCount === right.migrationCount && left.seedHash === right.seedHash;
+}
+function localDatabaseInitializationMatches(metadata, siteId, databaseId, fingerprint) {
+	return metadata?.status === "succeeded" && metadata.siteId === siteId && metadata.databaseId === databaseId && initializationFingerprintsMatch(metadata.fingerprint, fingerprint);
+}
+async function readLocalDatabaseInitializationMetadata(cwd) {
+	return (await readSavedForgewayMetadata(cwd)).databaseInitialization;
+}
+async function writeLocalDatabaseInitializationMetadata(cwd, metadata) {
+	await writeForgewayDeployMetadata(cwd, { databaseInitialization: {
+		...metadata,
+		updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+	} });
+}
 async function runDinewayInitialization(options) {
 	const db = createDatabase({
 		url: options.credentials.databaseUrl,
 		authToken: options.credentials.authToken
 	});
 	try {
-		await runMigrations(db);
+		const migrations = await runMigrations(db);
+		let seedResult = null;
 		if (options.seedPath) {
 			const seed = JSON.parse(await readFile(options.seedPath, "utf-8"));
 			const validation = validateSeed(seed);
 			if (!validation.valid) throw new Error(`Seed validation failed: ${validation.errors.join("; ")}`);
 			const uploadsDir = resolve(options.cwd, "uploads");
 			await mkdir(uploadsDir, { recursive: true });
-			await applySeed(db, seed, {
+			seedResult = await applySeed(db, seed, {
 				includeContent: true,
 				onConflict: "skip",
 				storage: new LocalStorage({
@@ -2444,6 +2550,10 @@ async function runDinewayInitialization(options) {
 				})
 			});
 		}
+		return {
+			migrations,
+			seed: seedResult
+		};
 	} catch (error) {
 		const message = error instanceof Error ? error.message : String(error);
 		throw new Error(redactDatabaseOutput(message, [options.credentials.authToken, options.credentials.databaseUrl]), { cause: error });
@@ -2474,25 +2584,75 @@ async function recordSiteDatabaseInitialization(context, siteId, databaseId, sta
 	});
 }
 async function initializeSiteDatabaseBeforeDeploy(options) {
+	const fingerprint = await buildDinewayInitializationFingerprint(options.seedPath);
+	const bindStart = Date.now();
 	const databaseId = (await bindSiteDatabase(options.context, options.siteId, options.database, options.deps)).binding.database.id;
+	if (options.verbose) consola.info(`Database bound in ${formatDuration(Date.now() - bindStart)}`);
+	const localInitialization = await readLocalDatabaseInitializationMetadata(options.cwd);
+	if (!options.force && localDatabaseInitializationMatches(localInitialization, options.siteId, databaseId, fingerprint)) return {
+		status: "skipped",
+		databaseId,
+		fingerprint
+	};
+	const revealStart = Date.now();
 	const credentials = await revealDatabaseRuntimeCredentials(options.context, databaseId, options.deps);
+	if (options.verbose) consola.info(`Database credentials revealed in ${formatDuration(Date.now() - revealStart)}`);
 	try {
-		await (options.deps.runDinewayInitialization ?? runDinewayInitialization)({
+		const result = await (options.deps.runDinewayInitialization ?? runDinewayInitialization)({
 			cwd: options.cwd,
 			credentials,
 			seedPath: options.seedPath
 		});
 		await recordSiteDatabaseInitialization(options.context, options.siteId, credentials.databaseId || databaseId, "succeeded", void 0, options.deps);
+		await writeLocalDatabaseInitializationMetadata(options.cwd, {
+			siteId: options.siteId,
+			databaseId: credentials.databaseId || databaseId,
+			status: "succeeded",
+			fingerprint
+		});
+		return {
+			status: "initialized",
+			databaseId: credentials.databaseId || databaseId,
+			fingerprint,
+			result
+		};
 	} catch (error) {
 		const message = redactDatabaseOutput(error instanceof Error ? error.message : String(error), [credentials.authToken, credentials.databaseUrl]);
 		await recordSiteDatabaseInitialization(options.context, options.siteId, credentials.databaseId || databaseId, "failed", message, options.deps).catch(() => void 0);
+		await writeLocalDatabaseInitializationMetadata(options.cwd, {
+			siteId: options.siteId,
+			databaseId: credentials.databaseId || databaseId,
+			status: "failed",
+			fingerprint,
+			error: message.slice(0, 2e3)
+		}).catch(() => void 0);
 		throw new Error(message, { cause: error });
 	}
 }
-function shouldExclude(name) {
+function normalizeIgnorePattern(pattern) {
+	return pattern.trim().replace(BACKSLASH_PATTERN, "/").replace(LEADING_SLASHES_PATTERN, "").replace(TRAILING_SLASHES_PATTERN, "");
+}
+function wildcardPatternToRegExp(pattern) {
+	const source = pattern.split("**").map((part) => part.split("*").map((segment) => segment.replace(REGEXP_ESCAPE_PATTERN, "\\$&")).join("[^/]*")).join(".*");
+	return new RegExp(`^${source}$`);
+}
+function matchesIgnorePattern(path, rawPattern) {
+	const pattern = normalizeIgnorePattern(rawPattern);
+	if (!pattern || pattern.startsWith("#")) return false;
+	if (pattern.includes("*")) return wildcardPatternToRegExp(pattern).test(path);
+	if (!pattern.includes("/")) return path === pattern || path.startsWith(`${pattern}/`) || basename(path) === pattern;
+	return path === pattern || path.startsWith(`${pattern}/`);
+}
+async function readDeploymentIgnorePatterns(sourceDir) {
+	const ignorePath = join(sourceDir, ".dinewayignore");
+	if (!await fileExists$8(ignorePath)) return [];
+	return (await readFile(ignorePath, "utf-8")).split(LINE_SPLIT_PATTERN).map((line) => line.trim()).filter((line) => line && !line.startsWith("#"));
+}
+function shouldExclude(name, customPatterns = []) {
 	const normalized = name.replace(BACKSLASH_PATTERN, "/");
 	for (const pattern of EXCLUDE_PATTERNS) if (normalized === pattern || normalized.startsWith(`${pattern}/`) || normalized.endsWith(`/${pattern}`) || normalized.includes(`/${pattern}/`)) return true;
-	return normalized.endsWith(".log");
+	if (normalized.endsWith(".log")) return true;
+	return customPatterns.some((pattern) => matchesIgnorePattern(normalized, pattern));
 }
 function normalizeRelativePath(sourceDir, absolutePath) {
 	return relative(sourceDir, absolutePath).replace(BACKSLASH_PATTERN, "/");
@@ -2511,6 +2671,8 @@ async function hashFile(filePath) {
 	};
 }
 async function collectDeploymentFiles(sourceDir) {
+	const customIgnorePatterns = await readDeploymentIgnorePatterns(sourceDir);
+	const candidates = [];
 	const files = [];
 	async function walk(currentDir) {
 		const entries = await readdir(currentDir, { withFileTypes: true });
@@ -2518,22 +2680,29 @@ async function collectDeploymentFiles(sourceDir) {
 		for (const entry of entries) {
 			const absolutePath = join(currentDir, entry.name);
 			const normalizedPath = normalizeRelativePath(sourceDir, absolutePath);
-			if (!normalizedPath || shouldExclude(normalizedPath)) continue;
+			if (!normalizedPath || shouldExclude(normalizedPath, customIgnorePatterns)) continue;
 			if (entry.isDirectory()) {
 				await walk(absolutePath);
 				continue;
 			}
 			if (!entry.isFile()) continue;
-			const { sha, size } = await hashFile(absolutePath);
-			files.push({
+			candidates.push({
 				absolutePath,
-				path: normalizedPath,
-				sha,
-				size
+				path: normalizedPath
 			});
 		}
 	}
 	await walk(sourceDir);
+	await runWithConcurrency(candidates, FILE_HASH_CONCURRENCY, async ({ absolutePath, path }) => {
+		const { sha, size } = await hashFile(absolutePath);
+		files.push({
+			absolutePath,
+			path,
+			sha,
+			size
+		});
+	});
+	files.sort((a, b) => a.path.localeCompare(b.path));
 	return files;
 }
 async function runWithConcurrency(items, concurrency, worker) {
@@ -2571,16 +2740,23 @@ function getDeploymentError(metadata) {
 	if (!metadata || typeof metadata.error !== "object" || metadata.error === null) return null;
 	return metadata.error.errorMessage ?? null;
 }
-async function pollDeployment(context, deploymentId, deps) {
+async function pollDeployment(context, deploymentId, deps, verbose) {
 	const pollIntervalMs = deps.pollIntervalMs ?? POLL_INTERVAL_MS$1;
 	const pollTimeoutMs = deps.pollTimeoutMs ?? POLL_TIMEOUT_MS$1;
 	const startTime = Date.now();
 	let deployment = null;
+	let firstPoll = true;
+	let lastStatus = null;
 	while (Date.now() - startTime < pollTimeoutMs) {
-		if (pollIntervalMs > 0) await new Promise((done) => setTimeout(done, pollIntervalMs));
+		if (!firstPoll && pollIntervalMs > 0) await new Promise((done) => setTimeout(done, pollIntervalMs));
+		firstPoll = false;
 		await ossFetch(context, `/api/deployments/${encodeURIComponent(deploymentId)}/sync`, deps, { method: "POST" }).catch(() => void 0);
 		deployment = await ossFetch(context, `/api/deployments/${encodeURIComponent(deploymentId)}`, deps);
 		const status = deployment.status.toUpperCase();
+		if (verbose || status !== lastStatus) {
+			consola.info(`Deployment status: ${status} (${formatDuration(Date.now() - startTime)} elapsed)`);
+			lastStatus = status;
+		}
 		if (status === "READY") break;
 		if (status === "ERROR" || status === "CANCELED") throw new Error(getDeploymentError(deployment.metadata) ?? `Deployment failed with status: ${deployment.status}`);
 		if (pollIntervalMs === 0) break;
@@ -2594,8 +2770,13 @@ async function pollDeployment(context, deploymentId, deps) {
 }
 async function deploySiteProject(options) {
 	options.deps.onEvent?.("scan");
+	const scanStart = Date.now();
+	consola.start("Scanning deploy files");
 	const localFiles = await (options.deps.collectDeploymentFiles ?? collectDeploymentFiles)(options.sourceDir);
 	if (localFiles.length === 0) throw new Error("No deployable files found in the source directory.");
+	consola.success(`Scanned ${localFiles.length} files (${formatBytes$1(deploymentFileSize(localFiles))}) in ${formatDuration(Date.now() - scanStart)}`);
+	const createStart = Date.now();
+	consola.start("Creating Forgeway deployment");
 	const createResult = await ossFetch(options.context, `/api/deployments/sites/${encodeURIComponent(options.siteId)}/deploy`, options.deps, {
 		method: "POST",
 		body: JSON.stringify({
@@ -2607,15 +2788,25 @@ async function deploySiteProject(options) {
 			}))
 		})
 	});
+	if (options.verbose) consola.info(`Deployment manifest accepted in ${formatDuration(Date.now() - createStart)}`);
 	const localFileByPath = new Map(localFiles.map((file) => [file.path, file]));
-	await runWithConcurrency(createResult.files.filter((file) => !file.uploadedAt), DIRECT_UPLOAD_CONCURRENCY, async (manifestFile) => {
+	const pendingFiles = createResult.files.filter((file) => !file.uploadedAt);
+	const pendingSize = pendingFiles.reduce((total, file) => total + file.size, 0);
+	if (pendingFiles.length === 0) consola.success("No file uploads needed");
+	else consola.start(`Uploading ${pendingFiles.length} changed files (${formatBytes$1(pendingSize)})`);
+	let uploadedCount = 0;
+	await runWithConcurrency(pendingFiles, DIRECT_UPLOAD_CONCURRENCY, async (manifestFile) => {
 		const localFile = localFileByPath.get(manifestFile.path);
 		if (!localFile) throw new Error(`Forgeway returned an unknown file path: ${manifestFile.path}`);
 		if (localFile.sha !== manifestFile.sha || localFile.size !== manifestFile.size) throw new Error(`Forgeway file metadata mismatch for: ${manifestFile.path}`);
 		await uploadDirectDeploymentFile(options.context, createResult.id, manifestFile, localFile, options.deps);
+		uploadedCount += 1;
+		if (options.verbose || uploadedCount === pendingFiles.length || uploadedCount % 10 === 0) consola.info(`Uploaded ${uploadedCount}/${pendingFiles.length} files`);
 	});
+	consola.start("Starting Forgeway deployment");
 	await startDirectDeployment(options.context, createResult.id, options.startBody, options.deps);
-	const result = await pollDeployment(options.context, createResult.id, options.deps);
+	consola.start("Waiting for Forgeway deployment");
+	const result = await pollDeployment(options.context, createResult.id, options.deps, options.verbose);
 	return {
 		deploymentId: createResult.id,
 		...result,
@@ -2632,7 +2823,12 @@ async function persistForgewayCliEnv(cwd, params) {
 }
 function formatDinewayAdminBootstrapMessage(bootstrap) {
 	if (!bootstrap) return "";
-	if (bootstrap.status === "already_issued") return `Dineway admin bootstrap: ${bootstrap.message}`;
+	if (bootstrap.status === "already_issued") return [
+		"Dineway admin access is ready. Local CLI defaults were saved to .env.",
+		`Dineway admin email: ${bootstrap.adminEmail}`,
+		`Dineway admin bootstrap: ${bootstrap.message}`,
+		"CLI example: npx dineway whoami"
+	].join("\n");
 	return [
 		"Dineway admin access is ready. Local CLI defaults were saved to .env.",
 		`Dineway admin email: ${bootstrap.adminEmail}`,
@@ -2645,7 +2841,10 @@ async function deployForgeway(cwd, options, deps = {}) {
 	const sourceDir = resolve(cwd);
 	if (!(await stat(sourceDir).catch(() => null))?.isDirectory()) throw new Error(`"${sourceDir}" is not a valid directory.`);
 	if (EXCLUDE_PATTERNS.includes(basename(sourceDir))) throw new Error(`"${basename(sourceDir)}" is an excluded directory and cannot be deployed.`);
-	const seedPath = await resolveSeedPath$1(cwd, options.seed);
+	await ensureProjectGitignoreDinewayLocalState(cwd);
+	const verbose = isVerboseDeploy(options);
+	const seedPath = options.skipSeed ? null : await resolveSeedPath$1(cwd, options.seed);
+	if (options.skipSeed) consola.info("Skipping seed initialization by request");
 	const { context, restaurant } = await resolveProjectContext(cwd, options, deps);
 	await ensureRestaurantClaim(context, restaurant, deps);
 	const { site } = await resolveDeploymentSite(cwd, context, options, seedPath, deps, restaurant);
@@ -2654,15 +2853,22 @@ async function deployForgeway(cwd, options, deps = {}) {
 		consola.start("Initializing Forgeway managed database");
 		try {
 			deps.onEvent?.("initialize");
-			await initializeSiteDatabaseBeforeDeploy({
+			const initialization = await initializeSiteDatabaseBeforeDeploy({
 				context,
 				siteId: site.id,
 				database,
 				cwd,
 				seedPath,
+				force: options.forceDbInit === true,
+				verbose,
 				deps
 			});
-			consola.success("Database initialized");
+			if (initialization.status === "skipped") consola.success("Database already initialized for current schema and seed (local metadata)");
+			else {
+				const applied = initialization.result?.migrations.applied.length ?? 0;
+				const seedSummary = formatSeedSummary(initialization.result?.seed);
+				consola.success(`Database initialized: ${applied} migrations applied, ${seedSummary}`);
+			}
 		} catch (error) {
 			consola.error("Database initialization failed");
 			throw error;
@@ -2674,12 +2880,13 @@ async function deployForgeway(cwd, options, deps = {}) {
 		siteId: site.id,
 		sourceDir,
 		startBody: {},
-		deps
+		deps,
+		verbose
 	});
 	const url = deployment.liveUrl ?? `https://${site.domain}`;
 	await (deps.writeProjectEnv ?? persistForgewayCliEnv)(cwd, {
 		siteUrl: url,
-		token: deployment.dinewayAdminBootstrap?.status === "issued" ? deployment.dinewayAdminBootstrap.apiToken : void 0
+		token: deployment.dinewayAdminBootstrap?.apiToken
 	});
 	const bootstrapMessage = formatDinewayAdminBootstrapMessage(deployment.dinewayAdminBootstrap);
 	const statusMessage = deployment.isReady ? `Deploy complete: ${url}` : `Deploy started for ${site.domain}. Check Forgeway for build status.`;
@@ -3246,6 +3453,21 @@ const deployCommand = defineCommand({
 			type: "string",
 			description: "Seed file path for Forgeway Dineway initialization",
 			required: false
+		},
+		"skip-seed": {
+			type: "boolean",
+			description: "Skip applying seed data during Forgeway database initialization",
+			default: false
+		},
+		"force-db-init": {
+			type: "boolean",
+			description: "Force Forgeway database migrations and seed even when initialization fingerprints match",
+			default: false
+		},
+		verbose: {
+			type: "boolean",
+			description: "Show detailed Forgeway deploy progress and timing logs",
+			default: false
 		}
 	},
 	async run({ args }) {
@@ -3262,7 +3484,10 @@ const deployCommand = defineCommand({
 			restaurantName: args["restaurant-name"],
 			city: args.city,
 			database: args.database,
-			seed: args.seed
+			seed: args.seed,
+			skipSeed: args["skip-seed"],
+			forceDbInit: args["force-db-init"],
+			verbose: args.verbose
 		};
 		consola.start(`Preparing ${target.label} deploy`);
 		await ensureTargetCli(target, cwd, {
@@ -3290,8 +3515,13 @@ const deployCommand = defineCommand({
 			const build = options.dryRun ? null : await runBuild(cwd, options.env);
 			consola.info(options.dryRun ? "[dry-run] Would run build" : `Built with ${build?.display}`);
 		}
-		if (!options.dryRun) await writeDeployTarget(cwd, target.name);
-		else consola.info(`[dry-run] Would save dineway.deploy.target=${target.name}`);
+		if (!options.dryRun) {
+			await ensureProjectGitignoreDinewayLocalState(cwd);
+			await writeDeployTarget(cwd, target.name);
+		} else {
+			consola.info("[dry-run] Would ensure Dineway local state entries in .gitignore");
+			consola.info(`[dry-run] Would save .dineway/deploy.json target=${target.name}`);
+		}
 		const result = await target.deploy(cwd, options);
 		if (result.url) consola.success(result.url);
 		consola.success(result.message);